public Brain(int numberOfPeers)
{
int inputNodeCount = 2; //there are 12 standard input nodes
StandardInputNeurons = new List <Neuron>();
//PeerInputNeurons = new List<PeerInputNeuronSet>();
for (int i = 0; i < 2; i++)
{
Neuron newNeuron = new Neuron();
newNeuron.AddConnection(TurnEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
newNeuron.AddConnection(MoveEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
StandardInputNeurons.Add(newNeuron);
}
// for(int i = 0; i < numberOfPeers; i++)
// {
// PeerInputNeuronSet newSet = new PeerInputNeuronSet();
// newSet.HeadingInputNeuron.AddConnection(TurnEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.HeadingInputNeuron.AddConnection(MoveEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.BearingInputNeuron.AddConnection(TurnEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.BearingInputNeuron.AddConnection(MoveEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.DistanceInputNeuron.AddConnection(TurnEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.DistanceInputNeuron.AddConnection(MoveEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.EnergyInputNeuron.AddConnection(TurnEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// newSet.EnergyInputNeuron.AddConnection(MoveEffortOutputNeuron, UnityEngine.Random.Range(-(float)inputNodeCount, (float)inputNodeCount));
// PeerInputNeurons.Add(newSet);
// }
}
public void GetNeuronValueTest()
{
Neuron childNeuron1 = new Neuron(0, 3);
Neuron childNeuron2 = new Neuron(1, 5);
Neuron parentNeuron = new Neuron(2);
Connection conn1 = new Connection(0, childNeuron1, -5);
Connection conn2 = new Connection(1, childNeuron2, 3);
parentNeuron.AddConnection(0, conn1);
parentNeuron.AddConnection(1, conn2);
Assert.IsTrue(Math.Abs(parentNeuron.GetValue() - 0.5) < .0000000001);
}
public void AddConnectionTest()
{
neuron.AddConnection(neuronFrom, 0.4f);
var expected = 0.4f;
var actual = neuron.Connections[0].Weight;
// checks if the weight has been updated.
Assert.AreEqual(expected, actual);
var expectedNeuron = neuronFrom;
var actualNeuron = neuron.Connections[0].NeuronFrom;
// checks if the neuron is stored.
Assert.AreEqual(expectedNeuron, actualNeuron);
}
protected void GenerateBiases()
{
Neuron outputBias = new Neuron(Neuron.Bias);
foreach (var node in Output)
{
outputBias.AddConnection(node);
}
if (this.HiddenLayer.Count == 0)
{
this.Input.Add(outputBias);
}
else
{
List <Neuron> biases = new List <Neuron>();
foreach (var nodeList in this.HiddenLayer)
{
Neuron bias = new Neuron(Neuron.Bias);
foreach (var node in nodeList)
{
bias.AddConnection(node);
}
biases.Add(bias);
}
this.Input.Add(biases[0]);
this.HiddenLayer[HiddenLayer.Count - 1].Add(outputBias);
for (int i = 0; i < this.HiddenLayer.Count - 1; i++)
{
this.HiddenLayer[i].Add(biases[i + 1]);
}
}
}
// We can connection two Neurons
public void Connect(Neuron a, Neuron b, float weight)
{
Connection c = new Connection(a, b, weight);
a.AddConnection(c);
//Also add the Connection here
connections.Add(c);
}
public void GenerateFromConnections(List <Connection> connList)
{
Clear();
foreach (var conn in connList)
{
Neuron sourceNeuron = FindNeuron(conn.Source.Index);
Neuron targetNeuron = FindNeuron(conn.Target.Index);
if (targetNeuron == null)
{
targetNeuron = conn.Target.Copy();
List <Neuron> sourceLayer = NeuronLayer(sourceNeuron);
if (IsInput(sourceLayer))
{
if (HiddenLayer.Count == 0)
{
List <Neuron> targetLayer = new List <Neuron>();
targetLayer.Add(targetNeuron);
HiddenLayer.Add(targetLayer);
}
else
{
List <Neuron> targetLayer = HiddenLayer[0];
targetLayer.Add(targetNeuron);
}
}
else
{
int hiddenPos = HiddenLayer.IndexOf(sourceLayer);
if (hiddenPos == HiddenLayer.Count - 1)
{
List <Neuron> targetLayer = new List <Neuron>();
targetLayer.Add(targetNeuron);
HiddenLayer.Add(targetLayer);
}
else
{
List <Neuron> targetLayer = HiddenLayer[hiddenPos + 1];
targetLayer.Add(targetNeuron);
}
}
sourceNeuron.AddConnection(targetNeuron, conn);
}
else
{
List <Neuron> sourceLayer = NeuronLayer(sourceNeuron);
List <Neuron> targetLayer = NeuronLayer(targetNeuron);
if (sourceLayer == targetLayer)
{
int hiddenPos = HiddenLayer.IndexOf(sourceLayer);
if (hiddenPos == HiddenLayer.Count - 1)
{
targetLayer = new List <Neuron>();
targetLayer.Add(targetNeuron);
HiddenLayer.Add(targetLayer);
}
else
{
targetLayer = HiddenLayer[hiddenPos + 1];
targetLayer.Add(targetNeuron);
}
}
else if (!IsInput(sourceNeuron) && !IsOutput(targetNeuron))
{
int sourceHiddenPos = HiddenLayer.IndexOf(sourceLayer);
int targetHiddenPos = HiddenLayer.IndexOf(targetLayer);
if (targetHiddenPos < sourceHiddenPos)
{
targetLayer.Remove(targetNeuron);
if (sourceHiddenPos == HiddenLayer.Count - 1)
{
List <Neuron> newLayer = new List <Neuron>();
newLayer.Add(targetNeuron);
HiddenLayer.Add(newLayer);
}
else
{
List <Neuron> newLayer = HiddenLayer[sourceHiddenPos + 1];
newLayer.Add(targetNeuron);
HiddenLayer.Add(newLayer);
}
if (targetLayer.Count == 0)
{
HiddenLayer.RemoveAt(targetHiddenPos);
}
}
}
sourceNeuron.AddConnection(targetNeuron, conn);
}
}
ResetInnovation();
ResetNodeIndex();
}
public void AddConnection(Neuron from, Neuron to)
{
from.AddConnection(to, Innovation);
Innovation++;
}
// We can connection two Neurons
void Connect(Neuron a, Neuron b, float weight)
{
Connection c = CreateConnection(a, b, weight);
a.AddConnection(c);
//b.AddConnection(c);
// Also add the Connection here
MyConnections.Add(c);
}
