void GeneticAlgorithm::mutate(Genotype& genotype) { // Generate a dummy genotype with which to test mutations with. Genotype dummyGenotype = genotype; do { // Whilst the mutated genome are acceptable to the user... // Generate a dummy genotype with which to test mutations with. dummyGenotype = genotype; // Apply mutations to each gene in the dummy genome. for (int gene = 0; gene < dummyGenotype.myGenes.size(); gene++) { // Generate prototype mutations until one fits into [0, 1]. double newValue = 0; do { newValue = dummyGenotype.getGene(gene) + myRand.randNorm(0.0, myMutationVariance); } while ((newValue < 0) || (newValue > 1)); // Apply the mutation. dummyGenotype.setGene(gene, newValue); } } while(myGenomeChecker.checkGenomeIsValid(dummyGenotype) == false); // The genome is valid, so overwrite the original genotype. genotype = dummyGenotype; }
void GeneticAlgorithm::mutate ( ) { int transfer; int first; double x; vector<int>::iterator geneIterator; for (int i = 0; i < population.size(); i++ ) { transfer = 0; Genotype g; g.setGene(*population[i].getGene()); for (geneIterator = g.getGene()->begin(); geneIterator != g.getGene()->end(); ++geneIterator) { x = rand ( ) % 1000 / 1000.0; if ( x < PMUTATION ) { ++transfer; if ( transfer % 2 == 1 ) first = distance(g.getGene()->begin(),geneIterator); else { if(g.getGene()->at(first) < *geneIterator) { ++g.getGene()->at(first); --*geneIterator; } else if(g.getGene()->at(first) > *geneIterator) { --g.getGene()->at(first); ++*geneIterator; } else { ++g.getGene()->at(first); ++*geneIterator; } } } } verifyAndPush(g); } return; }
void TanCTRNNetwork::reconstructNetwork(Genotype& genotype) { // Initialise the parameters according to the genotype. int gene = 0; /* Reconstruct the weights between the neurons. * Note these GENE NUMBERS are expected to be at the begining of the genome by * writeWeightsToGenome. */ for (int dest = 0; dest < myNoNeurons; dest++) { for (int source = 0; source < myNoNeurons; source++) { // Note inputs now have incoming weights. Is this good? myWeights[dest * myNoNeurons + source] = genotype.myGenes.at(gene) * myMaxWeight * 2 - myMaxWeight; gene++; } } // If requested, on first construction remap the inital weights to an alternative // bounds. if((genotype.myHasEverBeenConstructed == false) && (abs(myInitialWeightModifier - myMaxWeight) > 0.000001)) { for (int dest = 0; dest < myNoNeurons; dest++) { for (int source = 0; source < myNoNeurons; source++) { myWeights[dest * myNoNeurons + source] = myWeights[dest * myNoNeurons + source] * (myInitialWeightModifier / myMaxWeight); } } // And write these weights back into the genenome. writeWeightsToGenotype(genotype); } // If requested, impose a feedforward structure. if(myNetworkIsFeedforward) { for (int dest = 0; dest < myNoNeurons; dest++) { for (int source = 0; source < myNoNeurons; source++) { int destLayer, sourceLayer; if(dest < myNoInputs) { destLayer = 0; } else if(dest < myNoInputs + myFFLayer1Size) { destLayer = 1; } else if(dest < myNoInputs + myFFLayer1Size + myFFLayer2Size) { destLayer = 2; } else { destLayer = 3; } if(source < myNoInputs) { sourceLayer = 0; } else if(source < myNoInputs + myFFLayer1Size) { sourceLayer = 1; } else if(source < myNoInputs + myFFLayer1Size + myFFLayer2Size) { sourceLayer = 2; } else { sourceLayer = 3; } if(sourceLayer != (destLayer - 1)) { myWeights[dest * myNoNeurons + source] = 0.0; } } } } // Sensor weights. mySensorWeight = genotype.myGenes.at(gene) * myMaxWeight * 2 - myMaxWeight; gene++; // Output weights and biases (if required). if(myUseOutputWeightsAndBiases) { for(int o = 0; o < myNoOutputs; o++) { myOutputWeights[o] = genotype.myGenes.at(gene) * myMaxWeight * 2 - myMaxWeight; gene++; myOutputBiases[o] = genotype.myGenes.at(gene) * myMaxWeight * 2 - myMaxWeight; gene++; } } /* If the population should be seeded with centre-crossing networks, and the network has never been constructed * before, ALTER THE GENES so the bias genes are centre crossing. */ for (int i = 0; i < myNoNeurons; i++) { if (mySeedWithCentreCrossing && genotype.myHasEverBeenConstructed == false) { genotype.setGene(gene, 0.5); // XXX IS THIS RIGHT FOR CENTRE CROSSING IN TANH??? } myBiases[i] = genotype.myGenes.at(gene) * myMaxWeight * 2 - myMaxWeight; gene++; // Set time constants, scaled exponentially to [exp(0) exp(5)] myTimeConstants[i] = exp(genotype.myGenes.at(gene) * 5); gene++; // If requested, actually set the time constants to 1. if(mySetTausToOne) { myTimeConstants[i] = 1.0; } // If requested, actually set the biases to 0. if(mySetBiasesToZero) { myBiases[i] = 0.0; } } // Record in the genotype that it has been reconstructed. genotype.myHasEverBeenConstructed = true; }