public void LoadGenome(Genome genome)
{
this.genome = genome;
for (var i = 0; i < genome.NumInputNeurons; i++)
{
InputNeurons.Add(new Neuron("input" + i));
}
var weightIndex = 0;
var previousLayer = new List <Neuron>();
for (var layerId = 0; layerId < genome.NumHiddenLayers; layerId++)
{
var hiddenLayer = new List <Neuron>();
previousLayer = GetPreviousLayer(layerId);
SetupLayer(hiddenLayer, genome.NumNeuronsPerHiddenLayer, previousLayer, "hl" + layerId + "n", ref weightIndex, genome);
hiddenLayers.Add(hiddenLayer);
}
previousLayer = hiddenLayers[hiddenLayers.Count - 1];
SetupLayer(OutputNeurons, genome.NumOutputNeurons, previousLayer, "output", ref weightIndex, genome);
}
public void SetInputs(IEnumerable <double> values)
{
for (int i = 0; i < InputNeurons.Count; i++)
{
InputNeurons.ElementAt(i).Value = values.ElementAt(i);
}
}
public void AddInputNeuronAndMesh(InputNeuron neuron)
{
InputNeurons.Add(neuron);
foreach (WorkingNeuron wn in FirstHiddenLayer)
{
wn.AddNeuronConnection(new Connection(neuron, 0));
}
}
public Genome(Genome target, List <Gene> otherGenes = null)
{
SpeciesId = target.SpeciesId;
Fitness = target.Fitness;
CreateNetwork(target.InputCount, target.OutputCount, otherGenes ?? target.Genes);
Assert.AreEqual(InputNeurons.Count(), target.InputCount);
Assert.AreEqual(OutputNeurons.Count(), target.OutputCount);
}
/// <summary>
/// Saves the neural network as a .ann file.
/// </summary>
/// <param name="name">The .ann file name.</param>
/// <returns>The .ann file.</returns>
public AnnFile Save(string name)
{
var map = ComputeNodeIdMap();
return(new AnnFile
{
Name = name,
Activation = Activation,
InputNeurons = InputNeurons.Select(neuron => (uint)map[neuron.ID]).ToList(),
OutputNeurons = OutputNeurons.Select(neuron => (uint)map[neuron.ID]).ToList(),
AdjacencyMatrix = AdjacencyMatrix
});
}
public Genome(int inputCount, int outputCount, float geneWeightRandomVal = 0)
{
if (inputCount < 1 || outputCount < 1)
{
throw new System.ArgumentException("Invalid initialization", "inputCount or outputCount");
}
SpeciesId = null;
Fitness = 0;
InitStartingNeurons(inputCount, outputCount);
InitStartingGenes(geneWeightRandomVal);
Assert.AreEqual(InputNeurons.Count(), inputCount);
Assert.AreEqual(OutputNeurons.Count(), outputCount);
Assert.AreEqual(Neurons.Count, inputCount + outputCount + 1);
Assert.AreEqual(Genes.Count, inputCount * outputCount);
}
/// <summary>
/// Create a network from the given genes without any prerequesties.
/// </summary>
/// <param name="targetGenes"></param>
private void CreateNetwork(int inputCount, int outputCount, IEnumerable <Gene> targetGenes)
{
Neurons = new List <Neuron>();
Genes = new List <Gene>(targetGenes.Count());
AddStartingNeurons(inputCount, outputCount);
foreach (var gene in targetGenes)
{
Genes.Add(ForceConnection(gene));
}
InputNeurons = Neurons.Where(x => x.Type == ENeuronType.Input);
OutputNeurons = Neurons.Where(x => x.Type == ENeuronType.Output);
Debug.Assert(Genes.Count == targetGenes.Count());
Debug.Assert(InputNeurons.Count() == inputCount);
Debug.Assert(OutputNeurons.Count() == outputCount);
}
public void RemoveInputNeuron(InputNeuron neuron)
{
InputNeurons.Remove(neuron);
foreach (WorkingNeuron wn in neurons[1])
{
List <Connection> connectionsToRemove = new List <Connection>();
foreach (Connection c in wn.GetConnections())
{
if (c.entryNeuron == neuron)
{
connectionsToRemove.Add(c);
}
}
foreach (Connection c in connectionsToRemove)
{
wn.GetConnections().Remove(c);
}
}
}
/// <summary>
/// Initialize the network with the starting genes.
/// All inputs, but the bias, will be connected to output neurons.
/// </summary>
private void InitStartingGenes(float geneWeightRandomVal)
{
Genes = new List <Gene>(InputCount * OutputCount);
var inputNeurons = InputNeurons.ToArray();
var outputNeurons = OutputNeurons.ToArray();
for (int i = 0; i < InputCount; i++)
{
for (int j = 0; j < OutputCount; j++)
{
Gene newGene = new Gene(
inputNeurons[i],
outputNeurons[j],
Random.Range(-geneWeightRandomVal, geneWeightRandomVal)
);
Genes.Add(newGene);
inputNeurons[i].OutGenes.Add(newGene);
outputNeurons[j].InGenes.Add(newGene);
}
}
}
private void Initialize(int inputs, int outputs)
{
var random = new Random();
for (int i = 0; i < inputs; i++)
{
InputNeurons.Add(new Neuron());
}
for (int i = 0; i < outputs; i++)
{
var dentrites = new List <Synapse>();
foreach (var input in InputNeurons)
{
dentrites.Add(new Synapse()
{
Neuron = input, Weight = (random.NextDouble() - 0.5) * 0.01
});
}
OutputNeurons.Add(new Neuron()
{
Dendrites = dentrites
});
}
}
public double[] GetInputValues(int cycle)
{
return(InputNeurons.Select(x => x.Values[cycle] / Divisor).ToArray());
}
public void AddInputNeuron(InputNeuron neuron)
{
InputNeurons.Add(neuron);
}
