public void SpawnRandomPipeButton()
{
if (!automaticPipes.isOn)
{
SpawnPipe((int)transform.position.x + 10,
RandomnessHandler.RandomIntMinMax(1, Settings.Instance.height - 3));
}
}
public void RandomizeWeightsAndBiases()
{
bias = RandomnessHandler.RandomMinMax(-5, 5);
foreach (var node in CorrectWeights.Keys)
{
weights[node] = RandomnessHandler.RandomMinMax(-5, 5);
}
}
public Evaluator(int populationSize, Counter nodeInnovation,
Counter connectionInnovation, Func <Genome, float> fitnessFunction, Genome startingGenome = null)
{
this.populationSize = populationSize;
if (startingGenome == null)
{
this.nodeInnovation = nodeInnovation;
this.connectionInnovation = connectionInnovation;
var inputGenes = new Dictionary <int, NodeGene>();
var outputGenes = new Dictionary <int, NodeGene>();
for (var i = 0; i < Settings.Instance.inputs; i++)
{
var newNodeInnovation = nodeInnovation.GetInnovation();
inputGenes.Add(newNodeInnovation, new NodeGene(NodeGene.TypeE.Input, newNodeInnovation, 0, i));
}
for (var i = 0; i < Settings.Instance.outputs; i++)
{
var newNodeInnovation = nodeInnovation.GetInnovation();
outputGenes.Add(newNodeInnovation, new NodeGene(NodeGene.TypeE.Output, newNodeInnovation, 1, i));
}
var connectionGenes = new Dictionary <int, ConnectionGene>();
if (Settings.Instance.autoGenerateConnections)
{
foreach (var inputGene in inputGenes)
{
foreach (var outputGene in outputGenes)
{
var newConnectionInnovation = connectionInnovation.GetInnovation();
connectionGenes.Add(newConnectionInnovation,
new ConnectionGene(inputGenes.FirstOrDefault(x => x.Value == inputGene.Value).Key,
outputGenes.FirstOrDefault(x => x.Value == outputGene.Value).Key,
RandomnessHandler.RandomZeroToOne() * 4 - 2, true,
newConnectionInnovation));
}
}
}
var nodeGenes = new Dictionary <int, NodeGene>(inputGenes);
outputGenes.ToList().ForEach(x => nodeGenes.Add(x.Key, x.Value));
startingGenome = new Genome(nodeGenes, connectionGenes, nodeInnovation, connectionInnovation);
}
else
{
this.nodeInnovation = startingGenome.NodeCounter;
this.connectionInnovation = startingGenome.ConnectionsCounter;
}
for (var i = 0; i < populationSize; i++)
{
Genomes.Add(new GenomeWrapper(new Genome(startingGenome)));
}
this.fitnessFunction = fitnessFunction;
}
private void InitializeNetwork(int inputs, IReadOnlyList <int> hiddenLayers, int outputs, bool initializeParams)
{
values = new float[1 + hiddenLayers.Count + 1][];
desiredValues = new float[1 + hiddenLayers.Count + 1][];
biases = new float[1 + hiddenLayers.Count + 1][];
biasesSmudge = new float[1 + hiddenLayers.Count + 1][];
weights = new float[1 + hiddenLayers.Count][][];
weightsSmudge = new float[1 + hiddenLayers.Count][][];
values[0] = new float[inputs];
desiredValues[0] = new float[inputs];
biases[0] = new float[inputs];
biasesSmudge[0] = new float[inputs];
for (var i = 0; i < hiddenLayers.Count; i++)
{
values[i + 1] = new float[hiddenLayers[i]];
desiredValues[i + 1] = new float[hiddenLayers[i]];
biases[i + 1] = new float[hiddenLayers[i]];
biasesSmudge[i + 1] = new float[hiddenLayers[i]];
weights[i] = new float[values[i + 1].Length][];
weightsSmudge[i] = new float[values[i + 1].Length][];
for (var j = 0; j < weights[i].Length; j++)
{
weights[i][j] = new float[values[i].Length];
weightsSmudge[i][j] = new float[values[i].Length];
if (!initializeParams)
{
continue;
}
for (var k = 0; k < weights[i][j].Length; k++)
{
weights[i][j][k] = RandomnessHandler.RandomZeroToOne();
}
}
}
values[hiddenLayers.Count + 1] = new float[outputs];
desiredValues[hiddenLayers.Count + 1] = new float[outputs];
biases[hiddenLayers.Count + 1] = new float[outputs];
biasesSmudge[hiddenLayers.Count + 1] = new float[outputs];
weights[hiddenLayers.Count] = new float[outputs][];
weightsSmudge[hiddenLayers.Count] = new float[outputs][];
for (var j = 0; j < weights[hiddenLayers.Count].Length; j++)
{
weights[hiddenLayers.Count][j] = new float[values[hiddenLayers.Count].Length];
weightsSmudge[hiddenLayers.Count][j] = new float[values[hiddenLayers.Count].Length];
if (!initializeParams)
{
continue;
}
for (var k = 0; k < weights[hiddenLayers.Count][j].Length; k++)
{
weights[hiddenLayers.Count][j][k] = RandomnessHandler.RandomZeroToOne();
}
}
}
public Node(Node[] nodes, bool isInput = false)
{
weights = new Dictionary <Node, float>();
TrainingWeightsSmudge = new Dictionary <Node, float>();
foreach (var node in nodes)
{
weights.Add(node, RandomnessHandler.RandomZeroToOne() * Mathf.Sqrt(2f / nodes.Length));
TrainingWeightsSmudge.Add(node, 0);
}
bias = 0;
this.isInput = isInput;
}
private GenomeWrapper GetRandomGenomeInSpecies(Species selectedSpecies)
{
var totalFitness = selectedSpecies.Members.Sum(g => g.Fitness);
var speciesIndex = RandomnessHandler.RandomZeroToOne() * totalFitness;
var currentFitness = 0f;
foreach (var g in selectedSpecies.Members)
{
currentFitness += g.Fitness;
if (currentFitness >= speciesIndex)
{
return(g);
}
}
return(null);
}
private Species GetRandomSpecies()
{
var totalFitness = species.Sum(s => s.LastCalculatedFitness.Fitness);
var speciesIndex = RandomnessHandler.RandomZeroToOne() * totalFitness;
var currentFitness = 0f;
foreach (var s in species)
{
currentFitness += s.LastCalculatedFitness.Fitness;
if (currentFitness >= speciesIndex)
{
return(s);
}
}
return(null);
}
private void Update()
{
completeMovement += Time.deltaTime * Settings.Instance.gameSpeed;
if (automaticPipes.isOn && delay > Settings.Instance.pipeDistance - 0.5f)
{
SpawnPipe(spawnedPipes * Settings.Instance.pipeDistance - (int)completeMovement,
RandomnessHandler.RandomIntMinMax(1, Settings.Instance.height - 3));
delay = 0;
}
delay += Time.deltaTime * Settings.Instance.gameSpeed;
pipeHeight.maxValue = Settings.Instance.height - 4;
if (automaticPipes.isOn)
{
return;
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
SpawnPipe((int)transform.position.x + 10, 1);
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
SpawnPipe((int)transform.position.x + 10, 2);
}
if (Input.GetKeyDown(KeyCode.Alpha3))
{
SpawnPipe((int)transform.position.x + 10, 3);
}
if (Input.GetKeyDown(KeyCode.Alpha4))
{
SpawnPipe((int)transform.position.x + 10, 4);
}
if (Input.GetKeyDown(KeyCode.Alpha5))
{
SpawnPipe((int)transform.position.x + 10, 5);
}
if (Input.GetKeyDown(KeyCode.Alpha6))
{
SpawnPipe((int)transform.position.x + 10, 6);
}
}
public void Reset()
{
spawnedPipes = 0;
foreach (var pipeToDestroy in GameObject.FindGameObjectsWithTag("Pipe"))
{
Destroy(pipeToDestroy);
}
pipes.Clear();
delay = 0;
if (!automaticPipes.isOn)
{
return;
}
completeMovement = 0;
for (var i = 0; i < 5; i++)
{
SpawnPipe(spawnedPipes * Settings.Instance.pipeDistance - (int)completeMovement,
RandomnessHandler.RandomIntMinMax(1, Settings.Instance.height - 3));
}
}
public void Evaluate()
{
species.Clear();
HighestScore = float.MinValue;
FittestGenome = null;
foreach (var g in Genomes)
{
var foundSpecies = false;
foreach (var s in species.Where(
s => Genome.CalculateCompatibilityDistance(g.Genome, s.Mascot.Genome, C1, C2, C3) < DT))
{
s.Members.Add(g);
g.Species = s;
foundSpecies = true;
break;
}
if (!foundSpecies)
{
var newSpecies = new Species(g);
species.Add(newSpecies);
g.Species = newSpecies;
}
var score = EvaluateGenome(g.Genome);
g.Fitness = g.Fitness * 0.5f + score;
if (!(HighestScore <= score))
{
continue;
}
HighestScore = score;
if (FittestGenome != null)
{
FittestGenome.Best = false;
}
FittestGenome = g;
g.Best = true;
}
species.RemoveAll(s => s.Members.Count == 0);
if (species.Count > populationSize / 5)
{
var orderedSpecies = species.OrderBy(s => s.CalculateSpeciesFitness().Fitness).ToArray();
var speciesIndex = 0;
while (species.Count > populationSize / 5)
{
species.Remove(orderedSpecies[speciesIndex]);
speciesIndex++;
}
}
Genomes.Clear();
foreach (var speciesFitness in species.Select(s => s.CalculateSpeciesFitness())
.Where(f => !f.BestMember.Best))
{
Genomes.Add(new GenomeWrapper(new Genome(speciesFitness.BestMember.Genome)));
}
Genomes.Add(new GenomeWrapper(new Genome(FittestGenome.Genome))
{
Best = true
});
while (Genomes.Count < populationSize)
{
var s = GetRandomSpecies();
var p1 = GetRandomGenomeInSpecies(s);
var p2 = GetRandomGenomeInSpecies(s);
var mostFitParent = p1.Fitness > p2.Fitness ? p1 : p2;
var leastFitParent = p1.Fitness > p2.Fitness ? p2 : p1;
var child = Genome.Crossover(mostFitParent.Genome, leastFitParent.Genome);
if (RandomnessHandler.RandomZeroToOne() < WeightMutationRate)
{
child.WeightMutation();
}
if (RandomnessHandler.RandomZeroToOne() < AddConnectionRate)
{
child.AddConnectionMutation(connectionInnovation, ConnectionMutationMaxAttempts);
}
if (RandomnessHandler.RandomZeroToOne() < ToggleConnectionRate)
{
child.ToggleConnectionMutation();
}
if (RandomnessHandler.RandomZeroToOne() < AddNodeRate)
{
child.AddNodeMutation(nodeInnovation, connectionInnovation);
}
Genomes.Add(new GenomeWrapper(child)
{
Fitness = leastFitParent.Fitness
});
}
}
