public Population BreedPopulation(ref Population sourcePopulation, int currentGeneration) {
#region Pre-Crossover, Figuring out how many agents to breed etc.
int LifetimeGeneration = currentGeneration + sourcePopulation.trainingGenerations;
int totalNumWeightMutations = 0;
//float totalWeightChangeValue = 0f;
// go through species list and adjust fitness
List<SpeciesBreedingPool> childSpeciesPoolsList = new List<SpeciesBreedingPool>(); // will hold agents in an internal list to facilitate crossover
for (int s = 0; s < sourcePopulation.speciesBreedingPoolList.Count; s++) {
SpeciesBreedingPool newChildSpeciesPool = new SpeciesBreedingPool(sourcePopulation.speciesBreedingPoolList[s].templateGenome, sourcePopulation.speciesBreedingPoolList[s].speciesID); // create Breeding Pools
// copies the existing breeding pools but leaves their agentLists empty for future children
childSpeciesPoolsList.Add(newChildSpeciesPool); // Add to list of pools
}
sourcePopulation.RankAgentArray(); // based on modified species fitness score, so compensated for species sizes
Agent[] newAgentArray = new Agent[sourcePopulation.masterAgentArray.Length];
// Calculate total fitness score:
float totalScore = 0f;
if (survivalByRaffle) {
for (int a = 0; a < sourcePopulation.populationMaxSize; a++) { // iterate through all agents
totalScore += sourcePopulation.masterAgentArray[a].fitnessScoreSpecies;
}
}
// Figure out How many Agents survive
int numSurvivors = Mathf.RoundToInt(survivalRate * (float)sourcePopulation.populationMaxSize);
//Depending on method, one at a time, select an Agent to survive until the max Number is reached
int newChildIndex = 0;
// For ( num Agents ) {
for (int i = 0; i < numSurvivors; i++) {
// If survival is by fitness score ranking:
if (survivalByRank) {
// Pop should already be ranked, so just traverse from top (best) to bottom (worst)
newAgentArray[newChildIndex] = sourcePopulation.masterAgentArray[newChildIndex];
SpeciesBreedingPool survivingAgentBreedingPool = sourcePopulation.GetBreedingPoolByID(childSpeciesPoolsList, newAgentArray[newChildIndex].speciesID);
survivingAgentBreedingPool.AddNewAgent(newAgentArray[newChildIndex]);
//SortNewAgentIntoSpecies(newAgentArray[newChildIndex], childSpeciesList); // sorts this surviving agent into next generation's species'
newChildIndex++;
}
// if survival is completely random, as a control:
if (survivalStochastic) {
int randomAgent = UnityEngine.Random.Range(0, numSurvivors - 1);
// Set next newChild slot to a randomly-chosen agent within the survivor faction -- change to full random?
newAgentArray[newChildIndex] = sourcePopulation.masterAgentArray[randomAgent];
SpeciesBreedingPool survivingAgentBreedingPool = sourcePopulation.GetBreedingPoolByID(childSpeciesPoolsList, newAgentArray[newChildIndex].speciesID);
survivingAgentBreedingPool.AddNewAgent(newAgentArray[newChildIndex]);
//SortNewAgentIntoSpecies(newAgentArray[newChildIndex], childSpeciesList); // sorts this surviving agent into next generation's species'
newChildIndex++;
}
// if survival is based on a fitness lottery:
if (survivalByRaffle) { // Try when Fitness is normalized from 0-1
float randomSlicePosition = UnityEngine.Random.Range(0f, totalScore);
float accumulatedFitness = 0f;
for (int a = 0; a < sourcePopulation.populationMaxSize; a++) { // iterate through all agents
accumulatedFitness += sourcePopulation.masterAgentArray[a].fitnessScoreSpecies;
// if accum fitness is on slicePosition, copy this Agent
//Debug.Log("NumSurvivors: " + numSurvivors.ToString() + ", Surviving Agent " + a.ToString() + ": AccumFitness: " + accumulatedFitness.ToString() + ", RafflePos: " + randomSlicePosition.ToString() + ", TotalScore: " + totalScore.ToString() + ", newChildIndex: " + newChildIndex.ToString());
if (accumulatedFitness >= randomSlicePosition) {
newAgentArray[newChildIndex] = sourcePopulation.masterAgentArray[a]; // add to next gen's list of agents
SpeciesBreedingPool survivingAgentBreedingPool = sourcePopulation.GetBreedingPoolByID(childSpeciesPoolsList, newAgentArray[newChildIndex].speciesID);
survivingAgentBreedingPool.AddNewAgent(newAgentArray[newChildIndex]);
//SortNewAgentIntoSpecies(newAgentArray[newChildIndex], childSpeciesList); // sorts this surviving agent into next generation's species'
newChildIndex++;
break;
}
}
}
}
// Figure out how many new agents must be created to fill up the new population:
int numNewChildAgents = sourcePopulation.populationMaxSize - numSurvivors;
int numEligibleBreederAgents = Mathf.RoundToInt(breedingRate * (float)sourcePopulation.populationMaxSize);
int currentRankIndex = 0;
// Once the agents are ranked, trim the BreedingPools of agents that didn't make the cut for mating:
if(useSpeciation) {
for (int s = 0; s < sourcePopulation.speciesBreedingPoolList.Count; s++) {
int index = 0;
int failsafe = 0;
int numAgents = sourcePopulation.speciesBreedingPoolList[s].agentList.Count;
while (index < numAgents) {
if (index < sourcePopulation.speciesBreedingPoolList[s].agentList.Count) {
if (sourcePopulation.speciesBreedingPoolList[s].agentList[index].fitnessRank >= numEligibleBreederAgents) {
sourcePopulation.speciesBreedingPoolList[s].agentList.RemoveAt(index);
}
else {
index++;
}
}
else {
break;
}
failsafe++;
if (failsafe > 500) {
Debug.Log("INFINITE LOOP! hit failsafe 500 iters -- Trimming BreedingPools!");
break;
}
}
//Debug.Log("BreedPopulation -- TRIMSpeciesPool# " + s.ToString() + ", id: " + sourcePopulation.speciesBreedingPoolList[s].speciesID.ToString() + ", Count: " + sourcePopulation.speciesBreedingPoolList[s].agentList.Count.ToString());
//
}
}
float totalScoreBreeders = 0f;
if (breedingByRaffle) { // calculate total fitness scores to determine lottery weights
for (int a = 0; a < numEligibleBreederAgents; a++) { // iterate through all agents
totalScoreBreeders += sourcePopulation.masterAgentArray[a].fitnessScoreSpecies;
}
}
#endregion
// Iterate over numAgentsToCreate :
int newChildrenCreated = 0;
while (newChildrenCreated < numNewChildAgents) {
// Find how many parents random number btw min/max:
int numParentAgents = 2; // UnityEngine.Random.Range(minNumParents, maxNumParents);
int numChildAgents = 1; // defaults to one child, but:
if (numNewChildAgents - newChildrenCreated >= 2) { // room for two more!
numChildAgents = 2;
}
Agent[] parentAgentsArray = new Agent[numParentAgents]; // assume 2 for now? yes, so far....
List<GeneNodeNEAT>[] parentNodeListArray = new List<GeneNodeNEAT>[numParentAgents];
List<GeneLinkNEAT>[] parentLinkListArray = new List<GeneLinkNEAT>[numParentAgents];
Agent firstParentAgent = SelectAgentFromPopForBreeding(sourcePopulation, numEligibleBreederAgents, ref currentRankIndex);
parentAgentsArray[0] = firstParentAgent;
List<GeneNodeNEAT> firstParentNodeList = firstParentAgent.brainGenome.nodeNEATList;
List<GeneLinkNEAT> firstParentLinkList = firstParentAgent.brainGenome.linkNEATList;
//List<GeneNodeNEAT> firstParentNodeList = new List<GeneNodeNEAT>();
//List<GeneLinkNEAT> firstParentLinkList = new List<GeneLinkNEAT>();
//firstParentNodeList = firstParentAgent.brainGenome.nodeNEATList;
//firstParentLinkList = firstParentAgent.brainGenome.linkNEATList;
parentNodeListArray[0] = firstParentNodeList;
parentLinkListArray[0] = firstParentLinkList;
Agent secondParentAgent;
SpeciesBreedingPool parentAgentBreedingPool = sourcePopulation.GetBreedingPoolByID(sourcePopulation.speciesBreedingPoolList, firstParentAgent.speciesID);
if (useSpeciation) {
//parentAgentBreedingPool
float randBreedOutsideSpecies = UnityEngine.Random.Range(0f, 1f);
if (randBreedOutsideSpecies < interspeciesBreedingRate) { // Attempts to Found a new species
// allowed to breed outside its own species:
secondParentAgent = SelectAgentFromPopForBreeding(sourcePopulation, numEligibleBreederAgents, ref currentRankIndex);
}
else {
// Selects mate only from within its own species:
secondParentAgent = SelectAgentFromPoolForBreeding(parentAgentBreedingPool);
}
}
else {
secondParentAgent = SelectAgentFromPopForBreeding(sourcePopulation, numEligibleBreederAgents, ref currentRankIndex);
}
parentAgentsArray[1] = secondParentAgent;
List<GeneNodeNEAT> secondParentNodeList = secondParentAgent.brainGenome.nodeNEATList;
List<GeneLinkNEAT> secondParentLinkList = secondParentAgent.brainGenome.linkNEATList;
//List<GeneNodeNEAT> secondParentNodeList = new List<GeneNodeNEAT>();
//List<GeneLinkNEAT> secondParentLinkList = new List<GeneLinkNEAT>();
//secondParentNodeList = secondParentAgent.brainGenome.nodeNEATList;
//secondParentLinkList = secondParentAgent.brainGenome.linkNEATList;
parentNodeListArray[1] = secondParentNodeList;
parentLinkListArray[1] = secondParentLinkList;
// Iterate over ChildArray.Length : // how many newAgents created
for (int c = 0; c < numChildAgents; c++) { // for number of child Agents in floatArray[][]:
Agent newChildAgent = new Agent();
List<GeneNodeNEAT> childNodeList = new List<GeneNodeNEAT>();
List<GeneLinkNEAT> childLinkList = new List<GeneLinkNEAT>();
GenomeNEAT childBrainGenome = new GenomeNEAT();
childBrainGenome.nodeNEATList = childNodeList;
childBrainGenome.linkNEATList = childLinkList;
int numEnabledLinkGenes = 0;
if (useCrossover) {
int nextLinkInnoA = 0;
int nextLinkInnoB = 0;
//int nextBodyNodeInno = 0;
//int nextBodyAddonInno = 0;
int failsafeMax = 500;
int failsafe = 0;
int parentListIndexA = 0;
int parentListIndexB = 0;
//int parentBodyNodeIndex = 0;
bool parentDoneA = false;
bool parentDoneB = false;
bool endReached = false;
int moreFitParent = 0; // which parent is more Fit
if (parentAgentsArray[0].fitnessScoreSpecies < parentAgentsArray[1].fitnessScoreSpecies) {
moreFitParent = 1;
}
else if (parentAgentsArray[0].fitnessScoreSpecies == parentAgentsArray[1].fitnessScoreSpecies) {
moreFitParent = Mathf.RoundToInt(UnityEngine.Random.Range(0f, 1f));
}
// MATCH UP Links between both agents, if they have a gene with matching Inno#, then mixing can occur
while (!endReached) {
failsafe++;
if(failsafe > failsafeMax) {
Debug.Log("failsafe reached!");
break;
}
// inno# of next links:
if(parentLinkListArray[0].Count > parentListIndexA) {
nextLinkInnoA = parentLinkListArray[0][parentListIndexA].innov;
}
else {
parentDoneA = true;
}
if (parentLinkListArray[1].Count > parentListIndexB) {
nextLinkInnoB = parentLinkListArray[1][parentListIndexB].innov;
}
else {
parentDoneB = true;
}
int innoDelta = nextLinkInnoA - nextLinkInnoB; // 0=match, neg= Aextra, pos= Bextra
if (parentDoneA && !parentDoneB) {
innoDelta = 1;
}
if (parentDoneB && !parentDoneA) {
innoDelta = -1;
}
if (parentDoneA && parentDoneB) { // reached end of both parent's linkLists
endReached = true;
break;
}
if (innoDelta < 0) { // Parent A has an earlier link mutation
//Debug.Log("newChildIndex: " + newChildIndex.ToString() + ", IndexA: " + parentListIndexA.ToString() + ", IndexB: " + parentListIndexB.ToString() + ", innoDelta < 0 (" + innoDelta.ToString() + ") -- moreFitP: " + moreFitParent.ToString() + ", nextLinkInnoA: " + nextLinkInnoA.ToString() + ", nextLinkInnoB: " + nextLinkInnoB.ToString());
if (moreFitParent == 0) { // Parent A is more fit:
GeneLinkNEAT newChildLink = new GeneLinkNEAT(parentLinkListArray[0][parentListIndexA].fromNodeID, parentLinkListArray[0][parentListIndexA].toNodeID, parentLinkListArray[0][parentListIndexA].weight, parentLinkListArray[0][parentListIndexA].enabled, parentLinkListArray[0][parentListIndexA].innov, parentLinkListArray[0][parentListIndexA].birthGen);
childLinkList.Add(newChildLink);
if (parentLinkListArray[0][parentListIndexA].enabled)
numEnabledLinkGenes++;
}
else {
if(CheckForMutation(crossoverRandomLinkChance)) { // was less fit parent, but still passed on a gene!:
GeneLinkNEAT newChildLink = new GeneLinkNEAT(parentLinkListArray[0][parentListIndexA].fromNodeID, parentLinkListArray[0][parentListIndexA].toNodeID, parentLinkListArray[0][parentListIndexA].weight, parentLinkListArray[0][parentListIndexA].enabled, parentLinkListArray[0][parentListIndexA].innov, parentLinkListArray[0][parentListIndexA].birthGen);
childLinkList.Add(newChildLink);
}
}
parentListIndexA++;
}
if (innoDelta > 0) { // Parent B has an earlier link mutation
//Debug.Log("newChildIndex: " + newChildIndex.ToString() + ", IndexA: " + parentListIndexA.ToString() + ", IndexB: " + parentListIndexB.ToString() + ", innoDelta > 0 (" + innoDelta.ToString() + ") -- moreFitP: " + moreFitParent.ToString() + ", nextLinkInnoA: " + nextLinkInnoA.ToString() + ", nextLinkInnoB: " + nextLinkInnoB.ToString());
if (moreFitParent == 1) { // Parent B is more fit:
GeneLinkNEAT newChildLink = new GeneLinkNEAT(parentLinkListArray[1][parentListIndexB].fromNodeID, parentLinkListArray[1][parentListIndexB].toNodeID, parentLinkListArray[1][parentListIndexB].weight, parentLinkListArray[1][parentListIndexB].enabled, parentLinkListArray[1][parentListIndexB].innov, parentLinkListArray[1][parentListIndexB].birthGen);
childLinkList.Add(newChildLink);
if (parentLinkListArray[1][parentListIndexB].enabled)
numEnabledLinkGenes++;
}
else {
if (CheckForMutation(crossoverRandomLinkChance)) { // was less fit parent, but still passed on a gene!:
GeneLinkNEAT newChildLink = new GeneLinkNEAT(parentLinkListArray[1][parentListIndexB].fromNodeID, parentLinkListArray[1][parentListIndexB].toNodeID, parentLinkListArray[1][parentListIndexB].weight, parentLinkListArray[1][parentListIndexB].enabled, parentLinkListArray[1][parentListIndexB].innov, parentLinkListArray[1][parentListIndexB].birthGen);
childLinkList.Add(newChildLink);
}
}
parentListIndexB++;
}
if (innoDelta == 0) { // Match!
float randParentIndex = UnityEngine.Random.Range(0f, 1f);
float newWeightValue;
if (randParentIndex < 0.5) {
// ParentA wins:
newWeightValue = parentLinkListArray[0][parentListIndexA].weight;
}
else { // ParentB wins:
newWeightValue = parentLinkListArray[1][parentListIndexB].weight;
}
//Debug.Log("newChildIndex: " + newChildIndex.ToString() + ", IndexA: " + parentListIndexA.ToString() + ", IndexB: " + parentListIndexB.ToString() + ", innoDelta == 0 (" + innoDelta.ToString() + ") -- moreFitP: " + moreFitParent.ToString() + ", nextLinkInnoA: " + nextLinkInnoA.ToString() + ", nextLinkInnoB: " + nextLinkInnoB.ToString() + ", randParent: " + randParentIndex.ToString() + ", weight: " + newWeightValue.ToString());
GeneLinkNEAT newChildLink = new GeneLinkNEAT(parentLinkListArray[0][parentListIndexA].fromNodeID, parentLinkListArray[0][parentListIndexA].toNodeID, newWeightValue, parentLinkListArray[0][parentListIndexA].enabled, parentLinkListArray[0][parentListIndexA].innov, parentLinkListArray[0][parentListIndexA].birthGen);
childLinkList.Add(newChildLink);
if (parentLinkListArray[0][parentListIndexA].enabled)
numEnabledLinkGenes++;
parentListIndexA++;
parentListIndexB++;
}
}
// once childLinkList is built -- use nodes of the moreFit parent:
for (int i = 0; i < parentNodeListArray[moreFitParent].Count; i++) {
// iterate through all nodes in the parent List and copy them into fresh new geneNodes:
GeneNodeNEAT clonedNode = new GeneNodeNEAT(parentNodeListArray[moreFitParent][i].id, parentNodeListArray[moreFitParent][i].nodeType, parentNodeListArray[moreFitParent][i].activationFunction, parentNodeListArray[moreFitParent][i].sourceAddonInno, parentNodeListArray[moreFitParent][i].sourceAddonRecursionNum, false, parentNodeListArray[moreFitParent][i].sourceAddonChannelNum);
childNodeList.Add(clonedNode);
}
if (useMutation) {
// BODY MUTATION:
//PerformBodyMutation(ref childBodyGenome, ref childBrainGenome);
// NEED TO ADJUST BRAINS IF MUTATION CHANGES #NODES!!!!
// BRAIN MUTATION:
if (numEnabledLinkGenes < 1)
numEnabledLinkGenes = 1;
for (int k = 0; k < childLinkList.Count; k++) {
float mutateChance = mutationBlastModifier * masterMutationRate / (1f + (float)numEnabledLinkGenes * 0.15f);
if (LifetimeGeneration - childLinkList[k].birthGen < newLinkBonusDuration) {
float t = 1 - ((LifetimeGeneration - childLinkList[k].birthGen) / (float)newLinkBonusDuration);
// t=0 means age of gene is same as bonusDuration, t=1 means it is brand new
mutateChance = Mathf.Lerp(mutateChance, mutateChance * newLinkMutateBonus, t);
}
if (CheckForMutation(mutateChance)) { // Weight Mutation!
//Debug.Log("Weight Mutation Link[" + k.ToString() + "] weight: " + childLinkList[k].weight.ToString() + ", mutate: " + MutateFloat(childLinkList[k].weight).ToString());
childLinkList[k].weight = MutateFloat(childLinkList[k].weight);
totalNumWeightMutations++;
}
}
if (CheckForMutation(mutationBlastModifier * mutationRemoveLinkChance)) {
//Debug.Log("Remove Link Mutation Agent[" + newChildIndex.ToString() + "]");
childBrainGenome.RemoveRandomLink();
}
if (CheckForMutation(mutationBlastModifier * mutationAddNodeChance)) { // Adds a new node
//Debug.Log("Add Node Mutation Agent[" + newChildIndex.ToString() + "]");
childBrainGenome.AddNewRandomNode(LifetimeGeneration, GetNextAddonInnov());
}
if (CheckForMutation(mutationBlastModifier * mutationRemoveNodeChance)) { // Adds a new node
//Debug.Log("Add Node Mutation Agent[" + newChildIndex.ToString() + "]");
childBrainGenome.RemoveRandomNode();
}
if (CheckForMutation(mutationBlastModifier * mutationAddLinkChance)) { // Adds new connection
//Debug.Log("Add Link Mutation Agent[" + newChildIndex.ToString() + "]");
if (CheckForMutation(existingNetworkBias)) {
childBrainGenome.AddNewExtraLink(existingFromNodeBias, LifetimeGeneration);
}
else {
childBrainGenome.AddNewRandomLink(LifetimeGeneration);
}
}
if (CheckForMutation(mutationBlastModifier * mutationActivationFunctionChance)) {
TransferFunctions.TransferFunction newFunction;
int randIndex = Mathf.RoundToInt(UnityEngine.Random.Range(0f, childNodeList.Count - 1));
int randomTF = (int)UnityEngine.Random.Range(0f, 12f);
switch (randomTF) {
case 0:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
case 1:
newFunction = TransferFunctions.TransferFunction.Linear;
break;
case 2:
newFunction = TransferFunctions.TransferFunction.Gaussian;
break;
case 3:
newFunction = TransferFunctions.TransferFunction.Abs;
break;
case 4:
newFunction = TransferFunctions.TransferFunction.Cos;
break;
case 5:
newFunction = TransferFunctions.TransferFunction.Sin;
break;
case 6:
newFunction = TransferFunctions.TransferFunction.Tan;
break;
case 7:
newFunction = TransferFunctions.TransferFunction.Square;
break;
case 8:
newFunction = TransferFunctions.TransferFunction.Threshold01;
break;
case 9:
newFunction = TransferFunctions.TransferFunction.ThresholdNegPos;
break;
case 10:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
case 11:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
case 12:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
default:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
}
if (childNodeList[randIndex].nodeType != GeneNodeNEAT.GeneNodeType.Out) { // keep outputs -1 to 1 range
Debug.Log("ActivationFunction Mutation Node[" + randIndex.ToString() + "] prev: " + childNodeList[randIndex].activationFunction.ToString() + ", new: " + newFunction.ToString());
childNodeList[randIndex].activationFunction = newFunction;
}
}
}
else {
Debug.Log("Mutation Disabled!");
}
// THE BODY ==========!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!======================================================================================
CritterGenome childBodyGenome = new CritterGenome(); // create new body genome for Child
// This creates the ROOT NODE!!!!
// Clone Nodes & Addons from more fit parent to create new child body genome
// crossover is on, so check for matching Nodes and Add-ons (based on Inno#'s) to determine when to mix Settings/Attributes:
// Iterate over the nodes of the more fit parent:
for (int i = 0; i < parentAgentsArray[moreFitParent].bodyGenome.CritterNodeList.Count; i++) {
int currentNodeInno = parentAgentsArray[moreFitParent].bodyGenome.CritterNodeList[i].innov;
if (i == 0) { // if this is the ROOT NODE:
childBodyGenome.CritterNodeList[0].CopySettingsFromNode(parentAgentsArray[moreFitParent].bodyGenome.CritterNodeList[0]);
// The root node was already created during the Constructor method of the CritterGenome,
// ... so instead of creating a new one, just copy the settings
}
else { // NOT the root node, proceed normally:
// Create new cloned node defaulted to the settings of the source( more-fit parent's) Node:
CritterNode clonedCritterNode = parentAgentsArray[moreFitParent].bodyGenome.CritterNodeList[i].CloneThisCritterNode();
// Check other parent for same node:
for (int j = 0; j < parentAgentsArray[1 - moreFitParent].bodyGenome.CritterNodeList.Count; j++) {
if (parentAgentsArray[1 - moreFitParent].bodyGenome.CritterNodeList[j].innov == currentNodeInno) {
// CROSSOVER NODE SETTINGS HERE!!! ---- If random dice roll > 0.5, use less fit parent's settings, otherwise leave as default
BodyCrossover(ref clonedCritterNode, parentAgentsArray[1 - moreFitParent].bodyGenome.CritterNodeList[j]);
}
}
childBodyGenome.CritterNodeList.Add(clonedCritterNode);
}
}
// ADD-ONS!!!!!!!!!!!!!!!!!!!!!!
BreedCritterAddons(ref childBodyGenome, ref parentAgentsArray[moreFitParent].bodyGenome, ref parentAgentsArray[1 - moreFitParent].bodyGenome);
newChildAgent.bodyGenome = childBodyGenome; // ?????
if (useMutation) {
// BODY MUTATION:
PerformBodyMutation(ref childBodyGenome, ref childBrainGenome);
}
}
else { // no crossover:
//===============================================================================================
for (int i = 0; i < parentNodeListArray[0].Count; i++) {
// iterate through all nodes in the parent List and copy them into fresh new geneNodes:
GeneNodeNEAT clonedNode = new GeneNodeNEAT(parentNodeListArray[0][i].id, parentNodeListArray[0][i].nodeType, parentNodeListArray[0][i].activationFunction, parentNodeListArray[0][i].sourceAddonInno, parentNodeListArray[0][i].sourceAddonRecursionNum, false, parentNodeListArray[0][i].sourceAddonChannelNum);
childNodeList.Add(clonedNode);
}
for (int j = 0; j < parentLinkListArray[0].Count; j++) {
//same thing with connections
GeneLinkNEAT clonedLink = new GeneLinkNEAT(parentLinkListArray[0][j].fromNodeID, parentLinkListArray[0][j].toNodeID, parentLinkListArray[0][j].weight, parentLinkListArray[0][j].enabled, parentLinkListArray[0][j].innov, parentLinkListArray[0][j].birthGen);
childLinkList.Add(clonedLink);
if (parentLinkListArray[0][j].enabled)
numEnabledLinkGenes++;
}
// MUTATION:
if (useMutation) {
// BODY MUTATION:
//childBrainGenome.nodeNEATList = childNodeList
//PerformBodyMutation(ref childBodyGenome, ref childBrainGenome);
// BRAIN MUTATION:
if (numEnabledLinkGenes < 1)
numEnabledLinkGenes = 1;
for (int k = 0; k < childLinkList.Count; k++) {
float mutateChance = mutationBlastModifier * masterMutationRate / (1f + (float)numEnabledLinkGenes * 0.15f);
if (LifetimeGeneration - childLinkList[k].birthGen < newLinkBonusDuration) {
float t = 1 - ((LifetimeGeneration - childLinkList[k].birthGen) / (float)newLinkBonusDuration);
// t=0 means age of gene is same as bonusDuration, t=1 means it is brand new
mutateChance = Mathf.Lerp(mutateChance, mutateChance * newLinkMutateBonus, t);
}
if (CheckForMutation(mutateChance)) { // Weight Mutation!
//Debug.Log("Weight Mutation Link[" + k.ToString() + "] weight: " + childLinkList[k].weight.ToString() + ", mutate: " + MutateFloat(childLinkList[k].weight).ToString());
childLinkList[k].weight = MutateFloat(childLinkList[k].weight);
totalNumWeightMutations++;
}
}
if (CheckForMutation(mutationBlastModifier * mutationRemoveLinkChance)) {
//Debug.Log("Remove Link Mutation Agent[" + newChildIndex.ToString() + "]");
childBrainGenome.RemoveRandomLink();
}
if (CheckForMutation(mutationBlastModifier * mutationAddNodeChance)) { // Adds a new node
//Debug.Log("Add Node Mutation Agent[" + newChildIndex.ToString() + "]");
childBrainGenome.AddNewRandomNode(LifetimeGeneration, GetNextAddonInnov());
}
if (CheckForMutation(mutationBlastModifier * mutationAddLinkChance)) { // Adds new connection
//Debug.Log("Add Link Mutation Agent[" + newChildIndex.ToString() + "]");
if(CheckForMutation(existingNetworkBias)) {
childBrainGenome.AddNewExtraLink(existingFromNodeBias, LifetimeGeneration);
}
else {
childBrainGenome.AddNewRandomLink(LifetimeGeneration);
}
}
if (CheckForMutation(mutationBlastModifier * mutationActivationFunctionChance)) {
TransferFunctions.TransferFunction newFunction;
int randIndex = Mathf.RoundToInt(UnityEngine.Random.Range(0f, childNodeList.Count - 1));
int randomTF = (int)UnityEngine.Random.Range(0f, 12f);
switch (randomTF) {
case 0:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
case 1:
newFunction = TransferFunctions.TransferFunction.Linear;
break;
case 2:
newFunction = TransferFunctions.TransferFunction.Gaussian;
break;
case 3:
newFunction = TransferFunctions.TransferFunction.Abs;
break;
case 4:
newFunction = TransferFunctions.TransferFunction.Cos;
break;
case 5:
newFunction = TransferFunctions.TransferFunction.Sin;
break;
case 6:
newFunction = TransferFunctions.TransferFunction.Tan;
break;
case 7:
newFunction = TransferFunctions.TransferFunction.Square;
break;
case 8:
newFunction = TransferFunctions.TransferFunction.Threshold01;
break;
case 9:
newFunction = TransferFunctions.TransferFunction.ThresholdNegPos;
break;
case 10:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
case 11:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
case 12:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
default:
newFunction = TransferFunctions.TransferFunction.RationalSigmoid;
break;
}
if (childNodeList[randIndex].nodeType != GeneNodeNEAT.GeneNodeType.Out) { // keep outputs -1 to 1 range
Debug.Log("ActivationFunction Mutation Node[" + randIndex.ToString() + "] prev: " + childNodeList[randIndex].activationFunction.ToString() + ", new: " + newFunction.ToString());
childNodeList[randIndex].activationFunction = newFunction;
}
}
//for (int t = 0; t < childNodeList.Count; t++) {
//}
}
else {
Debug.Log("Mutation Disabled!");
}
// THE BODY!!!!! ++++++++++++++++++++++================+++++++++++++++++++===============+++++++++++++++++++===================+++++++++++++++++==============
CritterGenome childBodyGenome = new CritterGenome(); // create new body genome for Child
// Iterate over the nodes of the more fit parent:
for (int i = 0; i < parentAgentsArray[0].bodyGenome.CritterNodeList.Count; i++) {
int currentNodeInno = parentAgentsArray[0].bodyGenome.CritterNodeList[i].innov;
if (i == 0) { // if this is the ROOT NODE:
childBodyGenome.CritterNodeList[0].CopySettingsFromNode(parentAgentsArray[0].bodyGenome.CritterNodeList[0]);
// The root node was already created during the Constructor method of the CritterGenome,
// ... so instead of creating a new one, just copy the settings
}
else { // NOT the root node, proceed normally:
// Create new cloned node defaulted to the settings of the source( more-fit parent's) Node:
CritterNode clonedCritterNode = parentAgentsArray[0].bodyGenome.CritterNodeList[i].CloneThisCritterNode();
childBodyGenome.CritterNodeList.Add(clonedCritterNode);
}
}
// ADD-ONS!!!!!!!!!!!!!!!!!!!!!!
BreedCritterAddons(ref childBodyGenome, ref parentAgentsArray[0].bodyGenome, ref parentAgentsArray[0].bodyGenome);
newChildAgent.bodyGenome = childBodyGenome;
if (useMutation) {
// BODY MUTATION:
PerformBodyMutation(ref childBodyGenome, ref childBrainGenome);
}
}
newChildAgent.brainGenome = childBrainGenome;
//newChildAgent.brainGenome.nodeNEATList = childNodeList;
//newChildAgent.brainGenome.linkNEATList = childLinkList;
BrainNEAT childBrain = new BrainNEAT(newChildAgent.brainGenome);
childBrain.BuildBrainNetwork();
newChildAgent.brain = childBrain;
//Debug.Log("NEW CHILD numNodes: " + newChildAgent.brainGenome.nodeNEATList.Count.ToString() + ", #Neurons: " + newChildAgent.brain.neuronList.Count.ToString());
//newChildAgent.bodyGenome.PreBuildCritter(0.8f);
// Species:
if (useSpeciation) {
float randAdoption = UnityEngine.Random.Range(0f, 1f);
if (randAdoption < adoptionRate) { // Attempts to Found a new species
bool speciesGenomeMatch = false;
for (int s = 0; s < childSpeciesPoolsList.Count; s++) {
float geneticDistance = GenomeNEAT.MeasureGeneticDistance(newChildAgent.brainGenome, childSpeciesPoolsList[s].templateGenome, neuronWeight, linkWeight, weightWeight, normalizeExcess, normalizeDisjoint, normalizeLinkWeight);
if (geneticDistance < speciesSimilarityThreshold) {
speciesGenomeMatch = true;
//agent.speciesID = speciesBreedingPoolList[s].speciesID; // this is done inside the AddNewAgent method below v v v
childSpeciesPoolsList[s].AddNewAgent(newChildAgent);
//Debug.Log(" NEW CHILD (" + newChildIndex.ToString() + ") SortAgentIntoBreedingPool dist: " + geneticDistance.ToString() + ", speciesIDs: " + newChildAgent.speciesID.ToString() + ", " + childSpeciesPoolsList[s].speciesID.ToString() + ", speciesCount: " + childSpeciesPoolsList[s].agentList.Count.ToString());
break;
}
}
if (!speciesGenomeMatch) {
SpeciesBreedingPool newSpeciesBreedingPool = new SpeciesBreedingPool(newChildAgent.brainGenome, sourcePopulation.GetNextSpeciesID()); // creates new speciesPool modeled on this agent's genome
newSpeciesBreedingPool.AddNewAgent(newChildAgent); // add this agent to breeding pool
childSpeciesPoolsList.Add(newSpeciesBreedingPool); // add new speciesPool to the population's list of all active species
//Debug.Log(" NEW CHILD (" + newChildIndex.ToString() + ") SortAgentIntoBreedingPool NO MATCH!!! -- creating new BreedingPool " + newSpeciesBreedingPool.speciesID.ToString() + ", newChildAgentSpeciesID: " + newChildAgent.speciesID.ToString());
}
}
else { // joins parent species automatically:
SpeciesBreedingPool newSpeciesBreedingPool = sourcePopulation.GetBreedingPoolByID(childSpeciesPoolsList, parentAgentBreedingPool.speciesID);
newSpeciesBreedingPool.AddNewAgent(newChildAgent); // add this agent to breeding pool
//Debug.Log(" NEW CHILD (" + newChildIndex.ToString() + ") NO ADOPTION SortAgentIntoBreedingPool speciesIDs: " + newChildAgent.speciesID.ToString() + ", " + newSpeciesBreedingPool.speciesID.ToString() + ", speciesCount: " + newSpeciesBreedingPool.agentList.Count.ToString());
}
}
else { // joins parent species automatically:
SpeciesBreedingPool newSpeciesBreedingPool = sourcePopulation.GetBreedingPoolByID(childSpeciesPoolsList, parentAgentBreedingPool.speciesID);
newSpeciesBreedingPool.AddNewAgent(newChildAgent); // add this agent to breeding pool
}
newChildAgent.parentFitnessScoreA = sourcePopulation.masterAgentArray[newChildIndex].fitnessScore;
newAgentArray[newChildIndex] = newChildAgent;
newChildIndex++; // new child created!
newChildrenCreated++;
}
}
/*Debug.Log("Finished Crossover! childSpeciesPoolsList:");
for (int i = 0; i < sourcePopulation.speciesBreedingPoolList.Count; i++) {
string poolString = " Child Species ID: " + sourcePopulation.speciesBreedingPoolList[i].speciesID.ToString();
for (int j = 0; j < sourcePopulation.speciesBreedingPoolList[i].agentList.Count; j++) {
poolString += ", member# " + j.ToString() + ", species: " + sourcePopulation.speciesBreedingPoolList[i].agentList[j].speciesID.ToString() + ", fitRank: " + sourcePopulation.speciesBreedingPoolList[i].agentList[j].fitnessRank.ToString();
}
Debug.Log(poolString);
}*/
// Clear out extinct species:
int listIndex = 0;
for (int s = 0; s < childSpeciesPoolsList.Count; s++) {
if (listIndex >= childSpeciesPoolsList.Count) {
Debug.Log("end childSpeciesPoolsList " + childSpeciesPoolsList.Count.ToString() + ", index= " + listIndex.ToString());
break;
}
else {
if (childSpeciesPoolsList[listIndex].agentList.Count == 0) { // if empty:
//Debug.Log("Species " + childSpeciesPoolsList[listIndex].speciesID.ToString() + " WENT EXTINCT!!! --- childSpeciesPoolsList[" + listIndex.ToString() + "] old Count: " + childSpeciesPoolsList.Count.ToString() + ", s: " + s.ToString());
childSpeciesPoolsList.RemoveAt(listIndex);
//s--; // see if this works
}
else {
listIndex++;
}
}
}
Debug.Log("Finished Crossover! totalNumWeightMutations: " + totalNumWeightMutations.ToString() + ", mutationBlastModifier: " + mutationBlastModifier.ToString() + ", bodyMutationBlastModifier: " + bodyMutationBlastModifier.ToString() + ", LifetimeGeneration: " + LifetimeGeneration.ToString() + ", currentGeneration: " + currentGeneration.ToString() + ", sourcePopulation.trainingGenerations: " + sourcePopulation.trainingGenerations.ToString());
sourcePopulation.masterAgentArray = newAgentArray;
sourcePopulation.speciesBreedingPoolList = childSpeciesPoolsList;
/*Debug.Log("Finished Crossover! sourcePopulation.speciesBreedingPoolList:");
for (int i = 0; i < sourcePopulation.speciesBreedingPoolList.Count; i++) {
string poolString = "New Species ID: " + sourcePopulation.speciesBreedingPoolList[i].speciesID.ToString();
for (int j = 0; j < sourcePopulation.speciesBreedingPoolList[i].agentList.Count; j++) {
poolString += ", member# " + j.ToString() + ", species: " + sourcePopulation.speciesBreedingPoolList[i].agentList[j].speciesID.ToString() + ", fitRank: " + sourcePopulation.speciesBreedingPoolList[i].agentList[j].fitnessRank.ToString();
}
Debug.Log(poolString);
}*/
return sourcePopulation;
}
public Population BreedPopulation(ref Population sourcePopulation)
{
for(int m = 0; m < sourcePopulation.masterAgentArray.Length; m++) {
//sourcePopulation.masterAgentArray[m].brain.genome.PrintBiases("sourcePop " + sourcePopulation.masterAgentArray[m].fitnessScore.ToString() + ", " + m.ToString() + ", ");
//newPop.masterAgentArray[m].brain.genome.PrintBiases("newPop " + m.ToString() + ", ");
}
// rank sourcePop by fitness score // maybe do this as a method of Population class?
sourcePopulation.RankAgentArray();
Population newPopulation = new Population();
newPopulation = sourcePopulation.CopyPopulationSettings();
// Calculate total fitness score:
float totalScore = 0f;
if(survivalByRaffle) {
for(int a = 0; a < sourcePopulation.populationMaxSize; a++) { // iterate through all agents
totalScore += sourcePopulation.masterAgentArray[a].fitnessScore;
}
}
// Create the Population that will hold the next Generation agentArray:
Population newPop = sourcePopulation.CopyPopulationSettings();
// Figure out How many Agents survive
int numSurvivors = Mathf.RoundToInt(survivalRate * (float)newPop.populationMaxSize);
//Depending on method, one at a time, select an Agent to survive until the max Number is reached
int newChildIndex = 0;
// For ( num Agents ) {
for(int i = 0; i < numSurvivors; i++) {
// If survival is by fitness score ranking:
if(survivalByRank) {
// Pop should already be ranked, so just traverse from top (best) to bottom (worst)
newPopulation.masterAgentArray[newChildIndex] = sourcePopulation.masterAgentArray[newChildIndex];
newChildIndex++;
}
// if survival is completely random, as a control:
if(survivalStochastic) {
int randomAgent = UnityEngine.Random.Range (0, numSurvivors-1);
// Set next newChild slot to a completely randomly-chosen agent
newPopulation.masterAgentArray[newChildIndex] = sourcePopulation.masterAgentArray[randomAgent];
newChildIndex++;
}
// if survival is based on a fitness lottery:
if(survivalByRaffle) { // Try when Fitness is normalized from 0-1
float randomSlicePosition = UnityEngine.Random.Range(0f, totalScore);
float accumulatedFitness = 0f;
for(int a = 0; a < sourcePopulation.populationMaxSize; a++) { // iterate through all agents
accumulatedFitness += sourcePopulation.masterAgentArray[a].fitnessScore;
// if accum fitness is on slicePosition, copy this Agent
Debug.Log ("NumSurvivors: " + numSurvivors.ToString() + ", Surviving Agent " + a.ToString() + ": AccumFitness: " + accumulatedFitness.ToString() + ", RafflePos: " + randomSlicePosition.ToString() + ", TotalScore: " + totalScore.ToString() + ", newChildIndex: " + newChildIndex.ToString());
if(accumulatedFitness >= randomSlicePosition) {
newPopulation.masterAgentArray[newChildIndex] = sourcePopulation.masterAgentArray[a];
newChildIndex++;
}
}
}
// set newPop Agent to lucky sourcePop index
////////// Agent survivingAgent = sourcePopulation.Select
// Fill up newPop agentArray with the surviving Agents
// Keep track of Index, as that will be needed for new agents
}
// Figure out how many new agents must be created to fill up the new population:
int numNewChildAgents = newPopulation.populationMaxSize - numSurvivors;
int numEligibleBreederAgents = Mathf.RoundToInt(breedingRate * (float)newPop.populationMaxSize);
int currentRankIndex = 0;
float totalScoreBreeders = 0f;
if(breedingByRaffle) {
for(int a = 0; a < numEligibleBreederAgents; a++) { // iterate through all agents
totalScoreBreeders += sourcePopulation.masterAgentArray[a].fitnessScore;
}
}
//float[][] parentAgentChromosomes = new float[][];
// Iterate over numAgentsToCreate :
// Change to While loop?
int newChildrenCreated = 0;
while(newChildrenCreated < numNewChildAgents) {
// Find how many parents random number btw min/max
int numParentAgents = UnityEngine.Random.Range (minNumParents, maxNumParents);
int numChildAgents = 1;
if(numNewChildAgents - newChildrenCreated >= 2) { // room for two more!
numChildAgents = 2;
//Debug.Log ("numNewChildAgents: " + numNewChildAgents.ToString() + " - newChildrenCreated: " + newChildrenCreated.ToString() + " = numChildAgents: " + numChildAgents.ToString());
}
float[][] parentAgentBiases = new float[numParentAgents][];
float[][] parentAgentWeights = new float[numParentAgents][];
for(int p = 0; p < numParentAgents; p++) {
// Iterate over numberOfParents :
// Depending on method, select suitable agents' genome.Arrays until the numberOfPArents is reached, collect them in an array of arrays
// If breeding is by fitness score ranking:
if(breedingByRank) {
// Pop should already be ranked, so just traverse from top (best) to bottom (worst) to select parentAgents
if(currentRankIndex >= numEligibleBreederAgents) { // if current rank index is greater than the num of eligible breeders, then restart the index to 0;
currentRankIndex = 0;
}
//parentAgentChromosomes[p] = new float[sourcePopulation.masterAgentArray[currentRankIndex].genome.genomeBiases.Length];
parentAgentBiases[p] = sourcePopulation.masterAgentArray[currentRankIndex].genome.genomeBiases;
parentAgentWeights[p] = sourcePopulation.masterAgentArray[currentRankIndex].genome.genomeWeights;
currentRankIndex++;
}
// if survival is completely random, as a control:
if(breedingStochastic) {
int randomAgent = UnityEngine.Random.Range (0, numEligibleBreederAgents-1); // check if minus 1 is needed
// Set next newChild slot to a completely randomly-chosen agent
parentAgentBiases[p] = sourcePopulation.masterAgentArray[randomAgent].genome.genomeBiases;
parentAgentWeights[p] = sourcePopulation.masterAgentArray[randomAgent].genome.genomeWeights;
}
// if survival is based on a fitness lottery:
if(breedingByRaffle) {
float randomSlicePosition = UnityEngine.Random.Range(0f, totalScoreBreeders);
float accumulatedFitness = 0f;
for(int a = 0; a < numEligibleBreederAgents; a++) { // iterate through all agents
accumulatedFitness += sourcePopulation.masterAgentArray[a].fitnessScore;
// if accum fitness is on slicePosition, copy this Agent
Debug.Log ("Breeding Agent " + a.ToString() + ": AccumFitness: " + accumulatedFitness.ToString() + ", RafflePos: " + randomSlicePosition.ToString() + ", totalScoreBreeders: " + totalScoreBreeders.ToString() + ", numEligibleBreederAgents: " + numEligibleBreederAgents.ToString());
if(accumulatedFitness >= randomSlicePosition) {
parentAgentBiases[p] = sourcePopulation.masterAgentArray[a].genome.genomeBiases;
parentAgentWeights[p] = sourcePopulation.masterAgentArray[a].genome.genomeWeights;
}
}
}
}
// Combine the genes in the parentArrays and return the specified number of children genomes
// Pass that array of parentAgent genome.Arrays into the float-based MixFloatChromosomes() function,
float[][] childAgentBiases = MixFloatChromosomes(parentAgentBiases, numChildAgents);
float[][] childAgentWeights = MixFloatChromosomes(parentAgentWeights, numChildAgents);
// It can return an Array of Arrays (of new childAgent genome.Arrays)
// Iterate over ChildArray.Length : // how many newAgents created
for(int c = 0; c < numChildAgents; c++) { // for number of child Agents in floatArray[][]:
for(int b = 0; b < sourcePopulation.masterAgentArray[0].genome.genomeBiases.Length; b++) {
//Debug.Log ("ChildNumber: " + c.ToString() + ", BiasIndex: " + b.ToString() + ", biasValue: " + childAgentBiases[c][b].ToString () + ", newChildIndex: " + newChildIndex.ToString() + ", numNewChildren: " + numNewChildAgents.ToString() + ", numChildAgents: " + numChildAgents.ToString() + ", newChildrenCreated: " + newChildrenCreated.ToString());
newPopulation.masterAgentArray[newChildIndex].genome.genomeBiases[b] = childAgentBiases[c][b];
// weights and functions and more!
}
for(int w = 0; w < sourcePopulation.masterAgentArray[0].genome.genomeWeights.Length; w++) {
//Debug.Log ("ChildNumber: " + c.ToString() + ", BiasIndex: " + b.ToString() + ", biasValue: " + childAgentBiases[c][b].ToString () + ", newChildIndex: " + newChildIndex.ToString() + ", numNewChildren: " + numNewChildAgents.ToString() + ", numChildAgents: " + numChildAgents.ToString() + ", newChildrenCreated: " + newChildrenCreated.ToString());
newPopulation.masterAgentArray[newChildIndex].genome.genomeWeights[w] = childAgentWeights[c][w];
// weights and functions and more!
}
newPopulation.masterAgentArray[newChildIndex].brain.SetBrainFromGenome(newPopulation.masterAgentArray[newChildIndex].genome);
newChildIndex++; // new child created!
newChildrenCreated++;
}
}
//newPop.isFunctional = true;
return newPopulation;
}