private List <string> MutateIndividuals(List <string> ind)
{
List <string> newInd = new List <string>();
foreach (string individual in ind)
{
newInd.Add(mutator.Mutate(individual));
}
return(newInd);
}
//Chromosome (string): Solution
//Gene (bits): Part of solution
//Locus: Poisition of gene
//Alleles: Value of gene
//Phenotype: Decoded solution
//Genotype: Encoded solution
public static List <T> Evolve <T>(List <T> pPopulation, int pEvolvedPopulationSize, IMatingPoolSelector pPoolSelector, IBreedingPairSelector pPairSelector, ICrossoverOperator pOperator, IMutator pMutator) where T : GeneticEntity
{
List <T> pooledPop = new List <T>();
List <T> pairedPop = new List <T>();
List <T> crossedPop = new List <T>();
List <T> mutatedPop = new List <T>();
int stepCount = 1;
//Select Pool
pooledPop = pPoolSelector.SelectPool(pPopulation, pEvolvedPopulationSize);
OutputStep(pooledPop, stepCount, "pooling");
stepCount++;
//Select Pairs
pairedPop = pPairSelector.SelectPairs(pooledPop);
OutputStep(pairedPop, stepCount, "pairing");
stepCount++;
//Crossover
crossedPop = pOperator.Crossover(pairedPop);
OutputStep(crossedPop, stepCount, "crossing");
stepCount++;
//Mutate
mutatedPop = pMutator.Mutate(crossedPop);
OutputStep(pooledPop, stepCount, "mutating");
stepCount++;
return(mutatedPop);
}
internal IList <INeuralNetwork> GetMutatedNetworks(IEnumerable <INeuralNetwork> networksToTryToMutate, double mutateChance)
{
//try to mutate session that will live on 1 by 1
var mutatedTop = new List <INeuralNetwork>();
bool didMutate;
foreach (var topPerformer in networksToTryToMutate)
{
var net = _mutator.Mutate(topPerformer, mutateChance, out didMutate);
if (didMutate)
{
mutatedTop.Add(net);
}
}
return(mutatedTop);
}
private void MutateAndAddPoints(Person pers)
{
Person buf = new Person(pers.GetCode());
mMutOperator.Mutate(pers);
double dif = mMWrapper.FitnessFunction(buf) -
mMWrapper.FitnessFunction(pers);
if (!buf.IsEqual(pers))
{
for (int iter = 0; iter < mCrossRoulette.Length; iter++)
{
if (iter != mCurrentOperators[1])
{
mMutRoulette[iter] -= dif;
if (mMutRoulette[iter] < 0)
{
mMutRoulette[iter] = 0;
}
}
mMutRoulette[mCurrentOperators[1]] += dif;
if (mMutRoulette[mCurrentOperators[1]] < 0)
{
mMutRoulette[mCurrentOperators[1]] = 0;
}
}
}
}
public GeneticData GeneticAlgorithm(
ISelector selector,
IMutator mutator,
ICrosser crosser,
IEndCondition endCondition,
GeneticData startPopulation
)
{
const int selectedCount = 4;
GeneticData best = null;
var currentCombinations = new List <GeneticData> {
startPopulation
};
while (!endCondition.IsEnd(currentCombinations, envData))
{
var selected = selector.SelectBests(currentCombinations, selectedCount, envData);
var crossed = crosser.Cross(selected, envData);
currentCombinations = mutator.Mutate(crossed, envData);
best = selector.SelectBests(currentCombinations.Concat(new[] { best }).ToList(), 1, envData).First();
}
return(best);
}
public async Task <(MutantStatus, Mutant)> Run(ITestRunner testRunner, string tempDirectory, IEventListener eventListener)
{
var mutatedNode = mutator.Mutate(OriginalNode);
MutatedSyntaxRoot = originalSyntaxRoot.ReplaceNode(OriginalNode, mutatedNode);
var mutant = await Mutant.Create(OriginalClass, OriginalNode, MutatedSyntaxRoot);
var compilationResult = await CompileContainingProject(tempDirectory);
if (!compilationResult.Success)
{
// Not all mutations are valid in all circumstances, and therefore may not compile.
// E.g. "a + b" => "a - b" works when a and b are integers but not when they're strings.
eventListener.MutantSkipped(mutant, "mutation resulted in invalid code");
return(MutantStatus.Skipped, mutant);
}
CopyMutatedAssemblyIntoTempTestAssemblyDirectories(compilationResult.OutputFilePath, tempDirectory, config);
var copiedTempTestAssemblyFilePaths = TempTestAssemblyFilePaths(config, tempDirectory).ToArray();
var ranAnyTests = false;
for (var testAssemblyIndex = 0; testAssemblyIndex < config.TestAssemblyFilePaths.Length; ++testAssemblyIndex)
{
var originalTestAssemblyFilePath = config.TestAssemblyFilePaths[testAssemblyIndex];
var tempTestAssemblyFilePath = copiedTempTestAssemblyFilePaths[testAssemblyIndex];
string[] testsToRun = null;
if (coverageAnalysisResult != null)
{
testsToRun = coverageAnalysisResult.TestsThatCoverMember(memberName, originalTestAssemblyFilePath);
if (!testsToRun.Any())
{
continue;
}
}
var result = testsToRun != null?
testRunner.RunTests(new[] { tempTestAssemblyFilePath }, testsToRun) :
testRunner.RunAllTests(new[] { tempTestAssemblyFilePath });
ranAnyTests = true;
if (result.Status == TestRunStatus.SomeTestsFailed)
{
eventListener.MutantKilled(mutant, result.Error);
return(MutantStatus.Dead, mutant);
}
}
if (!ranAnyTests)
{
eventListener.MutantSkipped(mutant, "no covering tests");
return(MutantStatus.Skipped, mutant);
}
eventListener.MutantSurvived(mutant);
return(MutantStatus.Alive, mutant);
}
public void Procreate(List <int> child, ISelector selector, Random random)
{
crossover.Crossover(child, selector.Select(random).Chromosome, selector.Select(random).Chromosome, random);
//child.AddRange(selector.Select(random).Chromosome);
if (mutationRate == 1.0 || random.NextDouble() < mutationRate)
{
mutator.Mutate(child, random);
}
}
private List <Individual> CreateOffspring(List <Individual> individuals)
{
var offspring = new List <Individual>();
var offspringSize = _config.PopulationSize * _config.OffspringRatio;
while (offspring.Count < offspringSize)
{
var children = _crossOver.CreateChildren(_selector.Select(individuals), _selector.Select(individuals));
_mutator.Mutate(children.Item1, _config.MutationProbability);
_mutator.Mutate(children.Item2, _config.MutationProbability);
_evaluator.Evaluate(children.Item1);
_evaluator.Evaluate(children.Item2);
offspring.Add(children.Item1);
offspring.Add(children.Item2);
}
return(offspring);
}
public List <NeuralNetwork> NextPopulation(List <NeuralNetwork> currentPopulation)
{
List <List <double> > genotypes = converter.ToGenotypes(selector.Select(currentPopulation));
List <List <double> > afterCrossGenotypes = mixer.Cross(genotypes, currentPopulation.Count);
mutator.Mutate(afterCrossGenotypes);
return(converter.ToNetworks(afterCrossGenotypes, currentPopulation[0].Topology));
}
public Species[] Step(Species[] species)
{
Steps++;
UpdateBest(species);
var survived = _survivalSelection.Select(species).ToArray();
var newSpecies = _breeder.Breed(survived).ToArray();
_mutator.Mutate(newSpecies);
return(newSpecies);
}
public IEnumerable <T> ProduceOffspring(IEnumerable <T> parents)
{
var nextGen = parents
.Select(genome => genome.Clone() as T)
.ToArray();
foreach (var genome in nextGen)
{
_mutator.Mutate(genome);
}
return(nextGen);
}
public string Mutate(string input, int lowerBound, int upperBound)
{
var result = input;
for (var i = 0; i < _times; ++i)
{
if (_random.NextDouble() <= _chance)
{
result = _mutator.Mutate(result, lowerBound, upperBound);
}
}
return(result);
}
//public override void SynthesizeModel(Point[] trainingPoints)
//{
// var offspringPopulationSize = ExperimentParameters.OffspringPopulationSize;
// var numberOfGenerations = ExperimentParameters.NumberOfGenerations;
// BasePopulation = PopulationGenerator.GeneratePopulation(ExperimentParameters);
// for (var i = 0; i < offspringPopulationSize; i++)
// OffspringPopulation[i] = new Solution(ExperimentParameters);
// InitialPopulation = BasePopulation.DeepCopyByExpressionTree();
// for (var i = 0; i < numberOfGenerations; i++)
// {
// for (var j = 0; j < offspringPopulationSize; j++)
// {
// OffspringPopulation[j] = ParentsSelector.Select(BasePopulation)[0];
// OffspringPopulation[j] = StdDeviationsMutator.Mutate(OffspringPopulation[j]);
// OffspringPopulation[j] = RotationsMutator.Mutate(OffspringPopulation[j]);
// OffspringPopulation[j] = ObjectMutator.Mutate(OffspringPopulation[j]);
// OffspringPopulation[j].FitnessScore = Evaluator.Evaluate(OffspringPopulation[j]);
// }
// BasePopulation = SurvivorsSelector.Select(BasePopulation, OffspringPopulation);
// }
//}
protected override void Evolve(int offspringPopulationSize)
{
for (var j = 0; j < offspringPopulationSize; j++)
{
OffspringPopulation[j] = ParentsSelector.Select(BasePopulation)[0];
OffspringPopulation[j] = StdDeviationsMutator.Mutate(OffspringPopulation[j]);
OffspringPopulation[j] = RotationsMutator.Mutate(OffspringPopulation[j]);
OffspringPopulation[j] = ObjectMutator.Mutate(OffspringPopulation[j]);
OffspringPopulation[j].FitnessScore = Evaluator.Evaluate(OffspringPopulation[j]);
}
BasePopulation = SurvivorsSelector.Select(BasePopulation, OffspringPopulation);
}
private IEnumerable <Mutant> ApplyMutator(SyntaxNode syntaxNode, IMutator mutator)
{
var mutations = mutator.Mutate(syntaxNode);
foreach (var mutation in mutations)
{
yield return(new Mutant
{
Id = MutantCount++,
Mutation = mutation,
ResultStatus = MutantStatus.NotRun
});
}
}
/// <summary>
/// Mutates one single SyntaxNode using a mutator
/// </summary>
private IEnumerable <Mutant> ApplyMutator(SyntaxNode syntaxNode, IMutator mutator)
{
var mutations = mutator.Mutate(syntaxNode);
foreach (var mutation in mutations)
{
_logger.LogDebug("Mutant {0} created {1} -> {2} using {3}", _mutantCount, mutation.OriginalNode, mutation.ReplacementNode, mutator.GetType());
yield return(new Mutant()
{
Id = _mutantCount++,
Mutation = mutation,
ResultStatus = MutantStatus.NotRun
});
}
}
private IEnumerable <T> CreateChildren(T parentA, T parentB)
{
for (int i = 0; i < _childrenToCreate; i++)
{
var child = _genomeFactory.GetNewGenome();
foreach (var property in _genomeDescription.Properties)
{
property.Merge(parentA, parentB, child);
}
_mutator.Mutate(child);
yield return(child);
}
}
public string Mutate(string input, int lowerBound, int upperBound)
{
var result = input;
var times = GetTimes();
for (var i = 0; i < times; ++i)
{
if (_random.NextDouble() <= GetChance())
{
result = _mutator.Mutate(result, lowerBound, upperBound);
}
}
++_called;
return(result);
}
protected IEnumerable <TSolution> Improve(TProblem problem, TSolution bestSolution)
{
var mutation = mutator.Mutate(problem, bestSolution);
if (firstMutation == null)
{
firstMutation = mutation;
}
else if (stopOnRepeatedMutation && mutation.Equals(firstMutation))
{
ShouldContinue = false;
}
if (mutation.Score > bestSolution.Score)
{
bestSolution = mutation.GetResult();
firstMutation = null;
yield return(bestSolution);
}
}
public T[] FindSolution(T[] genes)
{
var individualSize = genes.Length;
var generationCount = 0;
var generation = populationCreator
.FirstGeneration(genes, populationSize)
.MakeIndividuals(fitnessFunction)
.OrderByDescending(individual => individual.Score)
.ToList();
var winner = generation.First();
var maxScore = 0;
var checkConvergence = new ConvergenceCriteria(winner.Score, this.solutionPrecision);
do
{
generationCount++;
maxScore = winner.Score;
var elite = generation.Take(eliteSize);
var offspring = mutator
.Mutate(crossOver.Cross(elite.Select(s => s.Value).ToList()), mutationProbability)
.MakeIndividuals(fitnessFunction).ToList();
generation = elite
.Union(offspring)
.Union(Rescued(generation.Except(elite).ToList(), populationSize - eliteSize - (offspring.Count)))
.OrderByDescending(individual => individual.Score)
.ToList();
winner = elite.First();
}while(!checkConvergence.IsConvergent(winner.Score) && generationCount < maxGenerations);
return(winner.Value);
}
