/**
* Starts the genetic algorithm and stops after a specified number of
* iterations.
*/
public virtual Individual <A> geneticAlgorithm(ICollection <Individual <A> > initPopulation,
IFitnessFunction <A> fitnessFn, int maxIterations)
{
GoalTest <Individual <A> > goalTest = (state) => getIterations() >= maxIterations;
return(geneticAlgorithm(initPopulation, fitnessFn, goalTest, 0L));
}
/// <summary>
/// Constructor
/// </summary>
public Population(int size,
IIndividual ancestor,
IFitnessFunction fitnessFunction,
ISelection selectionMethod,
int numberIterations)
{
FitnessFunction = fitnessFunction;
Selection = Replacement = selectionMethod;
PopulationSize = size;
firstSelectionCount = size;
firstReplacementCount = ((int)(size / 2)) % 2 == 0 ? (int)(size / 2) : (int)(size / 2) + 1;
iterations = numberIterations;
// Agregar el ancestro a la poblacion
ancestor.Evaluate(fitnessFunction);
Individuals.Add(ancestor);
// Se agregan mas cromosomas a la poblacion
for (int i = 1; i < size; i++)
{
// Se crea un nuevo cromosoma al azar
IIndividual c = ancestor.CreateRandomIndividual();
// se calcula su aptitud
c.Evaluate(fitnessFunction);
// Se lo agrega a la poblacion
Individuals.Add(c);
}
}
public static IParticle Create(PsoParticleType type,
int locationDim,
int fitnessDim,
IFitnessFunction<double[], double[]> function,
double restartEpsilon = double.MaxValue,
int iterationsToRestart = int.MaxValue,
DimensionBound[] bounds = null,
double[] initVelocity = null
)
{
IParticle particle = null;
var rand = RandomGenerator.GetInstance();
switch (type)
{
case PsoParticleType.Standard:
case PsoParticleType.FullyInformed:
particle = new StandardParticle(restartEpsilon, iterationsToRestart);
break;
case PsoParticleType.ChargedParticle:
particle = new ChargedParticle();
break;
case PsoParticleType.DummyParticle:
particle = new DummyParticle();
break;
}
var x = bounds != null ? rand.RandomVector(locationDim, bounds) : rand.RandomVector(locationDim);
particle.Init(new ParticleState(x, function.Evaluate(x)),
initVelocity ?? rand.RandomVector(locationDim, MinInitialVelocity, MaxInitialVelocity), bounds);
return particle;
}
private void InitializeGeneticAlgorithm()
{
fitnessFunction = new FitnessFunction(inventory);
selectionOperator = new RouletteWheelSelection();
elitistSelection = new ElitistSelection();
crossoverOperator = new ContinuousUniformCrossover();
mutationOperator = new WeightsMutation();
initialPopulationProvider = new InitialPopulationProvider();
settings = new Settings
{
Inventory = inventory,
NumberOfCriterias = 3,
NumberOfElites = Convert.ToInt32(inputElites.Value),
PopulationSize = Convert.ToInt32(inputMaxPopulation.Value),
CrossoverRate = Convert.ToDouble(inputCrossoverRate.Value),
MutationRate = Convert.ToDouble(inputMutationRate.Value)
};
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
geneticAlgorithm = new GeneticAlgorithm(settings, initialPopulationProvider, fitnessFunction, selectionOperator, elitistSelection, crossoverOperator, mutationOperator);
generationsPlotData = new List <double>();
averageScorePlotData = new List <double>();
bestScorePlotData = new List <double>();
UpdatePlotData();
Plot();
buttonNextGeneration.Enabled = true;
buttonRun.Enabled = true;
buttonReset.Enabled = true;
}
public static IParticle Create(PsoParticleType type,
int locationDim,
int fitnessDim,
IFitnessFunction <double[], double[]> function,
double restartEpsilon = double.MaxValue,
int iterationsToRestart = int.MaxValue,
DimensionBound[] bounds = null,
double[] initVelocity = null
)
{
IParticle particle = null;
var rand = RandomGenerator.GetInstance();
switch (type)
{
case PsoParticleType.Standard:
case PsoParticleType.FullyInformed:
particle = new StandardParticle(restartEpsilon, iterationsToRestart);
break;
case PsoParticleType.ChargedParticle:
particle = new ChargedParticle();
break;
case PsoParticleType.DummyParticle:
particle = new DummyParticle();
break;
}
var x = bounds != null?rand.RandomVector(locationDim, bounds) : rand.RandomVector(locationDim);
particle.Init(new ParticleState(x, function.Evaluate(x)),
initVelocity ?? rand.RandomVector(locationDim, MinInitialVelocity, MaxInitialVelocity), bounds);
return(particle);
}
/// <summary>
/// Initializes a new instance of the <see cref="Optimizer"/> class.
/// </summary>
/// <param name="ancestor">The ancestor chromosome.</param>
/// <param name="populationSize">Size of the population.</param>
/// <param name="ff">The fitness function to use for chromosome fitness calculation.</param>
/// <param name="selection">The selection to be used to select the best chromosomes.</param>
public Optimizer(IChromosome ancestor, int populationSize, IFitnessFunction ff, Selection.SelectionBase selection)
{
if (ancestor == null)
{
throw new ArgumentNullException("ancestor");
}
if (ff == null)
{
throw new ArgumentNullException("ff");
}
if (selection == null)
{
throw new ArgumentNullException("selection");
}
_populationSize = populationSize;
FitnessFunction = ff;
Selection = selection;
_population = new List <IChromosome>();
ancestor.Evaluate(ff);
_population.Add(ancestor);
while (_population.Count < populationSize)
{
IChromosome newC = ancestor.Clone();
newC.Generate();
newC.Evaluate(ff);
_population.Add(newC);
}
MutationRate = 0.08f;
CrossoverRate = 0f;
}
/// <summary>
/// Initializes a new instance of the <see cref="Population"/> class.
/// </summary>
///
/// <param name="size">Initial size of population.</param>
/// <param name="ancestor">Ancestor chromosome to use for population creatioin.</param>
/// <param name="fitnessFunction">Fitness function to use for calculating
/// chromosome's fitness values.</param>
/// <param name="selectionMethod">Selection algorithm to use for selection
/// chromosome's to new generation.</param>
///
/// <remarks>Creates new population of specified size. The specified ancestor
/// becomes first member of the population and is used to create other members
/// with same parameters, which were used for ancestor's creation.</remarks>
///
/// <exception cref="ArgumentException">Too small population's size was specified. The
/// exception is thrown in the case if <paramref name="size"/> is smaller than 2.</exception>
///
public QueuePopulation(int size,
IChromosome ancestor,
IFitnessFunction fitnessFunction,
ISelectionMethod selectionMethod)
{
if (size < 2)
throw new ArgumentException("Too small population's size was specified.");
this.fitnessFunction = fitnessFunction;
this.selectionMethod = selectionMethod;
this.size = size;
// add ancestor to the population
ancestor.Evaluate(fitnessFunction);
population.Add(ancestor.Clone());
// add more chromosomes to the population
for (int i = 1; i < size; i++)
{
// create new chromosome
IChromosome c = ancestor.CreateNew();
// calculate it's fitness
c.Evaluate(fitnessFunction);
// add it to population
population.Add(c);
}
}
public void Launch()
{
if (generations != null)
{
generations.Reset();
}
if (setup == null)
{
setup = GetComponent <SetupScript>();
}
ui = GetComponent <UIManager>();
cars = setup.Setup();
carStates = new Dictionary <GameObject, CarState>();
carExecutors = new Dictionary <GameObject, GeneExecutor>();
generations = GetComponent <GenerationDB>();
fitness = (IFitnessFunction)System.Activator.CreateInstance(setup.FitnessFunctions.Where(type => type.Name.Equals(selectedFitnessFunction)).First());
terminator = (ITerminator)System.Activator.CreateInstance(setup.Terminators.Where(type => type.Name.Equals(selectedTerminator)).First());
mutator = (IMutator)System.Activator.CreateInstance(setup.Mutators.Where(type => type.Name.Equals(selectedMutator)).First());
foreach (string genetype in selectedGenes)
{
mutator.AssignGene(((IGene)System.Activator.CreateInstance(setup.GeneTypes.Where(type => type.Name.Equals(genetype)).First())).ID);
}
selector = (ISelector)System.Activator.CreateInstance(setup.Selectors.Where(type => type.Name.Equals(selectedSelector)).First());
recombiner = (IRecombiner)System.Activator.CreateInstance(setup.Recombiners.Where(type => type.Name.Equals(selectedRecombiner)).First());
init = (IInitializer)System.Activator.CreateInstance(setup.Initializers.Where(type => type.Name.Equals(selectedInitializer)).First());
foreach (string genetype in selectedGenes)
{
init.AssignGene(((IGene)System.Activator.CreateInstance(setup.GeneTypes.Where(type => type.Name.Equals(genetype)).First())).ID);
}
SetupCars();
simulation = StartCoroutine(FullSimulation());
}
public virtual void Transpose(IFitnessFunction <double[], double[]> function)
{
double[] newLocation;
var restart = _sinceLastImprovement == _iterationsToRestart;
if (restart)
{
newLocation = RandomGenerator.GetInstance().RandomVector(CurrentState.Location.Length, Bounds);
_sinceLastImprovement = 0;
}
else
{
newLocation = GetClampedLocation(CurrentState.Location.Select((x, i) => x + Velocity[i]).ToArray());
}
var newVal = function.Evaluate(newLocation);
var oldBest = PersonalBest;
CurrentState = new ParticleState(newLocation, newVal);
if (Optimization.IsBetter(newVal, PersonalBest.FitnessValue) < 0)
{
PersonalBest = CurrentState;
_sinceLastImprovement = 0;
}
else
{
_sinceLastImprovement++;
}
}
private string Ga(ISet <string> population, IFitnessFunction fitnessFn)
{
// new_population <- empty Set
ISet <string> newPopulation = new HashedSet <string>();
// for i = 1 to SIZE(population) do
for (int i = 0; i < population.Count; i++)
{
// x <- RANDOM-SELECTION(population, FITNESS-FN)
string x = this.RandomSelection(population, fitnessFn);
// y <- RANDOM-SELECTION(population, FITNESS-FN)
string y = this.RandomSelection(population, fitnessFn);
// child <- REPRODUCE(x, y)
string child = this.Reproduce(x, y);
// if (small random probability) then child <- MUTATE(child)
if (random.NextDouble() <= this.mutationProbability)
{
child = this.Mutate(child);
}
// add child to new_population
newPopulation.Add(child);
}
// population <- new_population
population.Clear();
population.UnionWith(newPopulation);
return(this.RetrieveBestIndividual(population, fitnessFn));
}
// public float probPermutation;
// public float probEncaptilation;
// public bool bEditing;
// public bool bDecimation;
/// public float probReproduction;
public GPParameters()
{
//initial value of GA
algorithmType = Algorithm.GP;
chromosomeKind = GAChromosome.Continue;
einitializationMethod = GPInitializationMethod.FullInitialization;
eselectionMethod = GPSelectionMethod.Rankselection;
GPFitness = null;//new RMSEFitness();
SelParam1 = 3;
SelParam2 = 0;
elitism = 1;
maxInitLevel = 5;
probCrossover = 0.99F;
probMutation = 0.10F;
probReproduction = 0.20F;
popSize = 1000;
broodSize = 1;
isProtectedOperationEnabled = true;
rConstFrom = -1;
rConstTo = 1;
rConstNum = 5;
bParalelGP = false;
}
public Population(int size, IFitnessFunction fitnessFunction, IReproduction reproductionFunction, INodeMutator mutator, ISelection selection)
{
this.populationSize = size;
this.fitnessFunction = fitnessFunction;
this.reproductionFunction = reproductionFunction;
this.mutator = mutator;
this.selector = selection;
this.fitnessFunction.Initialise();
// Create the initial population
for (int i = 0; i < size; i++)
{
try
{
NodeContext zeroContext = new NodeContext();
zeroContext.AvailableCollections = fitnessFunction.GetCollections();
zeroContext.AvailableInputs = fitnessFunction.GetInputs();
INode candidateNode = NodeFactory.GenerateNode(zeroContext);
// Make sure we have a decent candidate (i.e. not too large)
double fitness = this.fitnessFunction.CalculateFitness(candidateNode);
if (fitness == Double.MaxValue) continue;
this.population.Add(NodeFactory.GenerateNode(zeroContext));
}
catch (StackOverflowException)
{
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Population"/> class.
/// </summary>
///
/// <param name="size">Initial size of population.</param>
/// <param name="ancestor">Ancestor chromosome to use for population creatioin.</param>
/// <param name="fitnessFunction">Fitness function to use for calculating
/// chromosome's fitness values.</param>
/// <param name="selectionMethod">Selection algorithm to use for selection
/// chromosome's to new generation.</param>
///
/// <remarks>Creates new population of specified size. The specified ancestor
/// becomes first member of the population and is used to create other members
/// with same parameters, which were used for ancestor's creation.</remarks>
///
/// <exception cref="ArgumentException">Too small population's size was specified. The
/// exception is thrown in the case if <paramref name="size"/> is smaller than 2.</exception>
///
public Population(int size,
IChromosome ancestor,
IFitnessFunction fitnessFunction,
ISelectionMethod selectionMethod)
{
if (size < 2)
{
throw new ArgumentException("Too small population's size was specified.");
}
this.fitnessFunction = fitnessFunction;
this.selectionMethod = selectionMethod;
this.size = size;
// add ancestor to the population
ancestor.Evaluate(fitnessFunction);
population.Add(ancestor.Clone());
// add more chromosomes to the population
for (var i = 1; i < size; i++)
{
// create new chromosome
var c = ancestor.CreateNew();
// calculate it's fitness
c.Evaluate(fitnessFunction);
// add it to population
population.Add(c);
}
}
public IA(Game game, int players)
: base(game)
{
rndSeedGen = new Random();
rndControl = new Random();
rndMovControl = new Random();
this.comidas = null;
this.jugadores = null;
this.numWeights = HIDDEN_UNITS0 * (INPUT_UNITS + 1) + HIDDEN_UNITS1 * (HIDDEN_UNITS0 + 1) + OUTPUT_UNITS * (HIDDEN_UNITS1 + 1);
redes = new ActivationNetwork[players];
for (int i = 0; i < redes.Length; i++)
{
redes[i] = new ActivationNetwork(new SigmoidFunction(400), INPUT_UNITS, HIDDEN_UNITS0, HIDDEN_UNITS1, OUTPUT_UNITS);
}
inputVector = new double[INPUT_UNITS];
outputVector = new double[OUTPUT_UNITS];
doneEvents = new ManualResetEvent[players];
for (int i = 0; i < players; i++)
{
doneEvents[i] = new ManualResetEvent(false);
}
//Se puede jugar con los parametros de los rangos para modificar la evolucion de las redes
//Tambien se puede modificar el metodo de seleccion.
chromosomeGenerator = new UniformGenerator(new Range(-10f, 10f), rndSeedGen.Next(-100, 100));
mutationAdditionGenerator = new UniformGenerator(new Range(-8f, 8f), rndSeedGen.Next(-100, 100));
mutationMultiplierGenerator = new UniformGenerator(new Range(-8f, 8f), rndSeedGen.Next(-100, 100));
fitnessFunction = new GameFitnessFunction();
selectionMethod = new EliteSelection();
padre = new gameChromosome(chromosomeGenerator, mutationMultiplierGenerator, mutationAdditionGenerator, numWeights);
poblacion = new Population(WorldGame.JUGADORES, padre, fitnessFunction, selectionMethod);
}
public GeneticAlgorithmSettings(IFitnessFunction fitnessFunction, int problemSize)
{
GenotypeLength = problemSize;
Rng = new Random();
FittestSelectionAlgorithm = new BinaryTournamentWithAlpha(Rng);
FitnessFunction = fitnessFunction;
}
private void InitializeGeneticAlgorithm()
{
fitnessFunction = new FitnessFunction(cities);
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
elitistSelection = new ElitistSelection();
crossoverOperator = GetSelectedCrossoverOperator();
mutationOperator = GetSelectedMutationOperator();
initialPopulationProvider = new InitialPopulationProvider();
settings = new Settings
{
Cities = cities,
NumberOfElites = Convert.ToInt32(inputElites.Value),
PopulationSize = Convert.ToInt32(inputMaxPopulation.Value),
CrossoverRate = Convert.ToDouble(inputCrossoverRate.Value),
MutationRate = Convert.ToDouble(inputMutationRate.Value)
};
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
geneticAlgorithm = new GeneticAlgorithm(settings, initialPopulationProvider, fitnessFunction, selectionOperator, elitistSelection, crossoverOperator, mutationOperator);
generationsPlotData = new List <double>();
averageScorePlotData = new List <double>();
bestScorePlotData = new List <double>();
UpdatePlotData();
Plot();
DrawSolution(geneticAlgorithm.CurrentBestSolution, panelBestSolution, bestSolutionGraphics);
buttonNextGeneration.Enabled = true;
buttonRun.Enabled = true;
buttonReset.Enabled = true;
}
public Population(IFitnessFunction fitnessFunction, List <IGenome> population)
{
//Log.Create("../../Logs/");
this.selection = DefaultParameter.selection;
this.crossover = DefaultParameter.crossover;
this.mutation = DefaultParameter.mutation;
this.population = population;
}
public override void Transpose(IFitnessFunction <double[], double[]> function)
{
PullGpuState();
if (PersonalBest.FitnessValue == null || CurrentIsBetterThanBest())
{
PersonalBest = CurrentState;
}
}
public Population(IFitnessFunction fitnessFunction, List<IGenome> population)
{
//Log.Create("../../Logs/");
this.selection = DefaultParameter.selection;
this.crossover = DefaultParameter.crossover;
this.mutation = DefaultParameter.mutation;
this.population = population;
}
public GeneticDistributionFilter(GeneticDistributionFilterParams parameters)
{
GeneticAlgorithm = parameters.GeneticAlgorithm;
DistributionResolution = parameters.DistributionResolution;
GeneticDistributionFitness.DistributionResolution = parameters.DistributionResolution;
GetTrunkThreshold = parameters.GetTrunkThreshold;
_fitnessFunction = new GeneticDistributionFitness().Make();
}
/// <summary>
/// Creates PsoAlgorithm with specific parameters to solve given problem using precreated particles
/// </summary>
/// <param name="parameters">takes PsoParameters to check what stop conditions are defined.
/// PsoAlgorithm looks for TargetValue, Epsilon, TargetValueCondition, IterationsLimit, IterationsLimitCondition
/// </param>
/// <param name="fitnessFunction">function whose optimum is to be found</param>
/// <param name="particles"> particles traversing the search space </param>
/// <param name="logger"></param>
public PsoAlgorithm(PsoParameters parameters, IFitnessFunction <double[], double[]> fitnessFunction, IParticle[] particles, ILogger logger = null)
{
_parameters = parameters;
_fitnessFunction = fitnessFunction;
_particles = particles;
_iteration = 0;
_logger = logger;
_optimizer = PsoServiceLocator.Instance.GetService <IOptimization <double[]> >();
}
public WAPPopulation(int size, WAPChromosome ancestor, IFitnessFunction Func, ISelectionMethod sel)
: base(size, ancestor, Func, sel)
{
AddAlternativeRate = 0.01;
DropConditionRate = 0.6;
rand = new Random();
parallelism = false;
epoch = 0;
}
/// <summary>
/// Creates PsoAlgorithm with specific parameters to solve given problem using precreated particles
/// </summary>
/// <param name="parameters">takes PsoParameters to check what stop conditions are defined.
/// PsoAlgorithm looks for TargetValue, Epsilon, TargetValueCondition, IterationsLimit, IterationsLimitCondition
/// </param>
/// <param name="fitnessFunction">function whose optimum is to be found</param>
/// <param name="particles"> particles traversing the search space </param>
/// <param name="logger"></param>
public PsoAlgorithm(PsoParameters parameters, IFitnessFunction<double[], double[]> fitnessFunction, IParticle[] particles, ILogger logger = null)
{
_parameters = parameters;
_fitnessFunction = fitnessFunction;
_particles = particles;
_iteration = 0;
_logger = logger;
_optimizer = PsoServiceLocator.Instance.GetService<IOptimization<double[]>>();
}
private static void Print(IPopulation <MathProgram> pop, uint generation,
IFitnessFunction <MathProgram> fitnessFunction, double diff)
{
var elem = pop.BestProgram;
Console.WriteLine(
$"Gen {generation:000}, pop: {pop.Count:000}, diff: {diff:0.00}, " +
$"fitness: {fitnessFunction.Evaluate(elem):0.00} | {elem}");
}
public EliminationGeneticAlgorithm(IMutate <Chromosome> mutation, ISelection <Chromosome> selection, ICrossover <Chromosome> crossover,
IFitnessFunction <Chromosome> fitnessFunction, int iterationLimit, double fitnessTerminator, int populationSize, int chromosomeSize)
: base(mutation, selection, crossover, fitnessFunction, iterationLimit, fitnessTerminator, populationSize)
{
Population = new Population <Chromosome>(populationSize);
ChromosomeSize = chromosomeSize;
InitializePopulation();
}
/// <summary>
/// Constructor
/// </summary>
public Population(int size,
IIndividual ancestor,
IFitnessFunction fitnessFunction,
ISelection selectionMethod,
int iterations,
double mutationRate)
: this(size, ancestor, fitnessFunction, selectionMethod, iterations)
{
MutationRate = mutationRate;
}
/// <summary>
/// Constructor
/// </summary>
public Population(int size,
IIndividual ancestor,
IFitnessFunction fitnessFunction,
ISelection selectionMethod,
double randomSelectionPortion,
int iterations)
: this(size, ancestor, fitnessFunction, selectionMethod, iterations)
{
randomSelectionPortion = Math.Max(0, Math.Min(0.5, randomSelectionPortion));
}
static Population GetPopulation(int count, IFitnessFunction function)
{
var elements = new List <Element>();
for (int i = 0; i < count; i++)
{
elements.Add(new Element(GetRandomData(function)));
}
return(new Population(elements));
}
static SimpleGeneticAlgorithm GetAlgorithm(IFitnessFunction function, Options options)
{
return(new SimpleGeneticAlgorithm
(
new TournamentSelection(options.SelectionChance, options.PopulationSize, 5),
new PMXCrossover(options.CrossoverChance),
new UniformMutation(options.MutationChance, function.MinValue, function.MaxValue),
function
));
}
private int getFitnessSelectedIndex(IFitnessFunction gPFitness)
{
/*
* 0 = cmbFitnessFuncs.Items.Add("AE -Apsolute error (regression) ");
* 1 = cmbFitnessFuncs.Items.Add("RMSE -Root mean square error (regression) ");
* 2 = cmbFitnessFuncs.Items.Add("SE -Square error (regression) ");
* 3 = cmbFitnessFuncs.Items.Add("MSE -Mean square error (regression) ");
* 4 = cmbFitnessFuncs.Items.Add("MAE -Mean apsolute error (regression) ");
* 5 = cmbFitnessFuncs.Items.Add("RSE -Root square error (regression) ");
* 6 = cmbFitnessFuncs.Items.Add("RRSE -Relative root square error (regression) ");
* 7 = cmbFitnessFuncs.Items.Add("RAE -Root apsolute error (regression) ");
* 8 = cmbFitnessFuncs.Items.Add("ACC -Total accuracy (binary, multiclass) ");
*/
if (gPFitness is AEFitness)
{
return(0);
}
else if (gPFitness is RMSEFitness)
{
return(1);
}
else if (gPFitness is SEFitness)
{
return(2);
}
else if (gPFitness is MSEFitness)
{
return(3);
}
else if (gPFitness is MAEFitness)
{
return(4);
}
else if (gPFitness is RSEFitness)
{
return(5);
}
else if (gPFitness is RRSEFitness)
{
return(6);
}
else if (gPFitness is RAEFitness)
{
return(7);
}
else if (gPFitness is AccuracyFitness)
{
return(8);
}
else
{
return(0);
}
}
protected GeneticAlgorithm(IMutation <T> mutation, ISelection <T> selection, ICrossover <T> crossover,
IFitnessFunction <T> fitnessFunction, int iterationLimit, decimal fitnessTerminator, int populationSize)
{
Mutation = mutation;
Selection = selection;
Crossover = crossover;
FitnessFunction = fitnessFunction;
IterationLimit = iterationLimit;
FitnessTerminator = fitnessTerminator;
PopulationSize = populationSize;
}
protected GeneticAlgorithm(IMutation <T> mutation, ISelection <T> selection, List <ICrossover <T> > crossovers,
IFitnessFunction <T> fitnessFunction, int iterationLimit, double fitnessTerminator, int populationSize)
{
Mutation = mutation;
Selection = selection;
Crossovers = crossovers;
FitnessFunction = fitnessFunction;
IterationLimit = iterationLimit;
FitnessTerminator = fitnessTerminator;
PopulationSize = populationSize;
}
public GeneticEngine(IFitnessFunction fitnessFunction)
{
this._fitnessFunction = fitnessFunction;
this.GenomeLength = fitnessFunction.getAriaty();
this.GenerationCount = DEFAULT_GENERATION_COUNT;
this.IndividualCount = 100;
this.SelectionType = DEFAULT_SELECTION_TYPE;
this.CrossingType = DEFAULT_CROSSING_TYPE;
this.UseMutation = DEFAULT_USE_MUTATION;
this.MutationPercent = 0.1d;
}
protected GenericCudaAlgorithm(CudaParams parameters, StateProxy proxy)
{
Proxy = proxy;
ParticlesCount = parameters.ParticlesCount;
DimensionsCount = parameters.LocationDimensions;
Iterations = parameters.Iterations;
FitnessFunction = parameters.FitnessFunction;
SyncWithCpu = parameters.SyncWithCpu;
FunctionNumber = parameters.FunctionNumber;
InstanceNumber = parameters.InstanceNumber;
evalLogger = PsoServiceLocator.Instance.GetService <EvaluationsLogger>();
}
public List<IGenome> Generate(int size, IFitnessFunction fitnessFunction)
{
List<IGenome> population = new List<IGenome>();
for (int i = 0; i < size; i++)
{
population.Add(new BinaryGenome(DefaultParameter.genomeSize));
population[i].SetFitnessFunction(fitnessFunction);
}
return population;
}
public static void SaveToCache(string id, IFitnessFunction<double[], double[]> function)
{
if (functionCache.Count == cacheLimit)
{
functionCache.Clear();
}
functionCache.Add(id,function);
if (functionCache.Count > cacheLimit)
{
functionCache.Clear();
}
}
static IEnumerable <double> GetRandomData(IFitnessFunction function)
{
var data =
Enumerable
.Range(0, function.DataSize)
.Select(x => Utils.RandomDouble(function.MinValue, function.MaxValue))
.ToArray();
Utils.Shuffle(data);
return(data);
}
public static void SaveToCache(string id, IFitnessFunction <double[], double[]> function)
{
if (functionCache.Count == cacheLimit)
{
functionCache.Clear();
}
functionCache.Add(id, function);
if (functionCache.Count > cacheLimit)
{
functionCache.Clear();
}
}
protected GenericCudaAlgorithm(CudaParams parameters, StateProxy proxy)
{
Proxy = proxy;
ParticlesCount = parameters.ParticlesCount;
DimensionsCount = parameters.LocationDimensions;
Iterations = parameters.Iterations;
FitnessFunction = parameters.FitnessFunction;
SyncWithCpu = parameters.SyncWithCpu;
FunctionNumber = parameters.FunctionNumber;
InstanceNumber = parameters.InstanceNumber;
evalLogger = PsoServiceLocator.Instance.GetService<EvaluationsLogger>();
}
public List <IGenome> Generate(int size, IFitnessFunction fitnessFunction)
{
List <IGenome> population = new List <IGenome>();
for (int i = 0; i < size; i++)
{
population.Add(new BinaryGenome(DefaultParameter.genomeSize));
population[i].SetFitnessFunction(fitnessFunction);
}
return(population);
}
private void Benchmark()
{
fitnessFunction = new FitnessFunction(cities);
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
elitistSelection = new ElitistSelection();
initialPopulationProvider = new InitialPopulationProvider();
selectionOperator = new TournamentSelection(Convert.ToInt32(inputTournamentSize.Value));
var csv = "Crossover Operator,Mutation Operator,Avg. Best Score,Avg. Computation Time";
var result = RunBenchmark(new CycleCrossover(), new InsertMutation());
csv += $"\nCycle,Insert,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new InversionMutation());
csv += $"\nCycle,Inversion,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new ScrambleMutation());
csv += $"\nCycle,Scramble,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new SwapMutation());
csv += $"\nCycle,Swap,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new InsertMutation());
csv += $"\nOrder1,Insert,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new InversionMutation());
csv += $"\nOrder1,Inversion,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new ScrambleMutation());
csv += $"\nOrder1,Scramble,{result.Item1},{result.Item2}";
result = RunBenchmark(new OrderOneCrossover(), new SwapMutation());
csv += $"\nOrder1,Swap,{result.Item1},{result.Item2}";
result = RunBenchmark(new PMXCrossover(), new InsertMutation());
csv += $"\nPMX,Insert,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new InversionMutation());
csv += $"\nPMX,Inversion,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new ScrambleMutation());
csv += $"\nPMX,Scramble,{result.Item1},{result.Item2}";
result = RunBenchmark(new CycleCrossover(), new SwapMutation());
csv += $"\nPMX,Swap,{result.Item1},{result.Item2}";
File.WriteAllText("simulations.csv", csv);
}
public Population(IFitnessFunction fitnessFunction, int size)
{
// Log.Create("../../Logs/");
this.selection = DefaultParameter.selection;
this.crossover = DefaultParameter.crossover;
this.mutation = DefaultParameter.mutation;
this.generation = 1;
this.avarageFitness = 0;
this.fitnessFunction = fitnessFunction;
IInitialPopulationMethod initial = DefaultParameter.initialPopulation;
this.population = initial.Generate(DefaultParameter.genomeSize, fitnessFunction);
}
private static List <IParticle> CreateParticles(PsoParameters parameters, IFitnessFunction <double[], double[]> function)
{
var particles = new List <IParticle>();
foreach (var particle in parameters.Particles)
{
for (int i = 0; i < particle.Count; i++)
{
var p = ParticleFactory.Create(particle.ParticleType, parameters.FunctionParameters.Dimension, 1, function, parameters.Epsilon, parameters.ParticleIterationsToRestart, parameters.FunctionParameters.SearchSpace);
particles.Add(p);
}
}
return(particles);
}
public TwoIslandsPopulation(int size, IFitnessFunction fitnessFunction, IReproduction reproductionFunction, INodeMutator mutator, ISelection selection)
{
this.populationSize = size;
this.fitnessFunction = fitnessFunction;
this.reproductionFunction = reproductionFunction;
this.mutator = mutator;
this.selector = selection;
this.fitnessFunction.Initialise();
// The main population needs initializing
this.IntialisePopulation(this.mainPopulation);
this.IntialisePopulation(this.secondaryPopulation);
}
public GEngine(AbstractTrack[] tracks, int pCrossingover, int pMutation, IFitnessFunction fitnessFunction, IMutation mutation, ICrossingover crossingover, ISelection selection)
{
_countOfPerson = tracks.Length;
_tracks = new AbstractTrack[_countOfPerson];
_tracks = tracks;
_pCrossingover = pCrossingover;
_pMutation = pMutation;
_fitnessFunction = fitnessFunction;
_mutation = mutation;
_crossingover = crossingover;
_selection = selection;
_geneticsDataSet = new DB_GeneticsDataSet();
_launchId = Guid.NewGuid();
_launchTableAdapter = new DB_GeneticsDataSetTableAdapters.LaunchesTableAdapter();
_personsTableAdapter = new DB_GeneticsDataSetTableAdapters.PersonsTableAdapter();
}
public GeneticGenerator(IFitnessFunction fitnessFunction, MelodySequence base_seq = null)
{
this.fitnessFunction = fitnessFunction;
this.base_seq = base_seq;
this.MaxGenerations = 2000;
if (base_seq != null)
CreateUniques();
if (base_seq != null)
{
var mark = new MarkovChainGenerator(2);
mark.AddMelody(base_seq);
GPCustomTree.generator = mark;
}
}
public List<IGenome> Generate(int size, IFitnessFunction fitnessFunction)
{
List<IGenome> population = new List<IGenome>();
FlipGeneMutation flip = new FlipGeneMutation();
for (int i = 0; i < size; i+=2)
{
population.Add(new BinaryGenome(DefaultParameter.genomeSize));
population[i].SetFitnessFunction(fitnessFunction);
IGenome genome = (BinaryGenome)population[i].Clone();
flip.Mutate(genome);
population.Add(genome);
population[i+1].SetFitnessFunction(fitnessFunction);
}
return population;
}
public GeneticGenerator(IFitnessFunction fitnessFunction, PatchNames instrument = PatchNames.Acoustic_Grand, CompositionCategory cat=null)
{
this.fitnessFunction = fitnessFunction;
this.cat = cat;
this.MaxGenerations = 1000;
this.PrintProgress = true;
this.instrument = instrument;
if (cat != null)
{
// Markov generator
var mark = new MarkovChainGenerator(instrument, 2);
// Allowed notes
HashSet<Durations> durs = new HashSet<Durations>();
HashSet<int> fullPitches = new HashSet<int>();
foreach(var c in cat.Compositions)
{
if (c.Tracks.Count < 1)
continue;
var cloneMel = (c.Tracks[0].GetMainSequence() as MelodySequence).Clone() as MelodySequence;
cloneMel.StandardizeDuration();
mark.AddMelody(cloneMel);
foreach (var n in cloneMel.Notes)
{
durs.Add(NoteGene.GetClosestDuration(n.Duration));
fullPitches.Add(n.Pitch);
}
avgLength += cloneMel.Length;
}
avgLength /= cat.Compositions.Length;
GPCustomTree.generator = mark;
NoteGene.AllowedDurations = durs.ToArray();
NoteGene.AllowedFullPitches = fullPitches.ToArray();
}
}
public IA(Game game, int players)
: base(game)
{
rndSeedGen = new Random();
rndControl = new Random();
rndMovControl = new Random();
this.comidas = null;
this.jugadores = null;
this.numWeights = HIDDEN_UNITS0 * (INPUT_UNITS + 1) + HIDDEN_UNITS1 * (HIDDEN_UNITS0 + 1) + OUTPUT_UNITS * (HIDDEN_UNITS1 + 1);
redes = new ActivationNetwork[players];
for (int i = 0; i < redes.Length; i++)
{
redes[i] = new ActivationNetwork(new SigmoidFunction(400), INPUT_UNITS, HIDDEN_UNITS0, HIDDEN_UNITS1, OUTPUT_UNITS);
}
inputVector = new double[INPUT_UNITS];
outputVector = new double[OUTPUT_UNITS];
doneEvents = new ManualResetEvent[players];
for (int i = 0; i < players; i++) doneEvents[i] = new ManualResetEvent(false);
//Se puede jugar con los parametros de los rangos para modificar la evolucion de las redes
//Tambien se puede modificar el metodo de seleccion.
chromosomeGenerator = new UniformGenerator(new Range(-10f, 10f), rndSeedGen.Next(-100, 100));
mutationAdditionGenerator = new UniformGenerator(new Range(-8f, 8f), rndSeedGen.Next(-100, 100));
mutationMultiplierGenerator = new UniformGenerator(new Range(-8f, 8f), rndSeedGen.Next(-100, 100));
fitnessFunction = new GameFitnessFunction();
selectionMethod = new EliteSelection();
padre = new gameChromosome(chromosomeGenerator, mutationMultiplierGenerator, mutationAdditionGenerator, numWeights);
poblacion = new Population(WorldGame.JUGADORES, padre, fitnessFunction, selectionMethod);
}
/// <summary>
/// Builder a new genome from other Binary Genome
/// </summary>
/// <param name="binaryGenome">Binary Genome</param>
public BinaryGenome(BinaryGenome binaryGenome)
{
this.genes = binaryGenome.genes;
this.fitnessFunction = binaryGenome.fitnessFunction;
}
/// <summary>
/// Set Fitness Function in the Genome
/// </summary>
/// <param name="fitnessFunction">Class Implements in the Code of user</param>
public void SetFitnessFunction(IFitnessFunction fitnessFunction)
{
this.fitnessFunction = fitnessFunction;
}
public void setupFitnessFunction(string fitnessFunction)
{
foreach (Type t in this.GetType().Assembly.GetTypes())
{
if (t.GetInterface("IFitnessFunction", true) != null)
this.functionComboBox.Items.Add(t.Name);
}
fitFun = FitnessFunctionFactory.getFitnessFunction(fitnessFunction);
if (fitFun != null)
{
for (int j = 0; j < functionComboBox.Items.Count; j++)
if (functionComboBox.Items[j].ToString().Equals(fitFun.name))
{
functionComboBox.SelectedIndex = j;
break;
}
}
fillFitnessDescription();
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
fitFun = FitnessFunctionFactory.getFitnessFunction(this.functionComboBox.SelectedItem.ToString());
fillFitnessDescription();
}
private static List<IParticle> CreateParticles(PsoParameters parameters, IFitnessFunction<double[],double[]> function)
{
var particles = new List<IParticle>();
foreach (var particle in parameters.Particles)
{
for (int i = 0; i < particle.Count; i++)
{
var p = ParticleFactory.Create(particle.ParticleType, parameters.FunctionParameters.Dimension, 1, function, parameters.Epsilon, parameters.ParticleIterationsToRestart, parameters.FunctionParameters.SearchSpace);
particles.Add(p);
}
}
return particles;
}
public void Run(PsoParameters psoParameters, IParticle[] proxyParticleServices = null)
{
_function = FunctionFactory.GetFitnessFunction(psoParameters.FunctionParameters);
var useGpu = psoParameters.GpuParameters.UseGpu && GpuController.AnySupportedGpu();
CudaParticle cudaParticle = null;
if (useGpu)
cudaParticle = PrepareCudaAlgorithm(psoParameters);
var particles = PrepareParticles(psoParameters,proxyParticleServices,cudaParticle);
RunningParameters = psoParameters;
_algorithm = new PsoAlgorithm(psoParameters, _function, particles.ToArray());
_cudaReadyLock = new AutoResetEvent(false);
if (useGpu)
RunningCudaAlgorithm = Task<ParticleState>.Factory.StartNew(() =>
{
_cudaAlgorithm.Initialize();
_cudaReadyLock.Set();
var result = _cudaAlgorithm.Run(_cudaTokenSource.Token);
_function.Evaluate(result.Location);
_cudaAlgorithm.Dispose();
return result;
}, _cudaTokenSource.Token);
else
_cudaReadyLock.Set();
RunningAlgorithm = Task<ParticleState>.Factory.StartNew(delegate
{
_cudaReadyLock.WaitOne();
_cudaReadyLock.Dispose();
return StartAlgorithm(_tokenSource.Token);
}, _tokenSource.Token);
}
public override void Transpose(IFitnessFunction<double[], double[]> function)
{
}
public void setFitnessFunction(string fitnessFunctionName)
{
this.fitnessFunctionName = fitnessFunctionName;
fitnessFunction = FitnessFunctionFactory.getFitnessFunction(fitnessFunctionName);
fitnessFunction.reset();
}
public override void Transpose(IFitnessFunction<double[], double[]> function)
{
PullGpuState();
if (PersonalBest.FitnessValue == null || CurrentIsBetterThanBest())
PersonalBest = CurrentState;
}
/// <summary>
/// Evaluate chromosome with specified fitness function.
/// </summary>
///
/// <param name="function">Fitness function to use for evaluation of the chromosome.</param>
///
/// <remarks><para>Calculates chromosome's fitness using the specifed fitness function.</para></remarks>
///
public void Evaluate( IFitnessFunction function )
{
fitness = function.Evaluate( this );
}
public virtual void Transpose(IFitnessFunction<double[], double[]> function)
{
double[] newLocation;
var restart = _sinceLastImprovement == _iterationsToRestart;
if (restart)
{
newLocation = RandomGenerator.GetInstance().RandomVector(CurrentState.Location.Length, Bounds);
_sinceLastImprovement = 0;
}
else
{
newLocation = GetClampedLocation(CurrentState.Location.Select((x, i) => x + Velocity[i]).ToArray());
}
var newVal = function.Evaluate(newLocation);
var oldBest = PersonalBest;
CurrentState = new ParticleState(newLocation, newVal);
if (Optimization.IsBetter(newVal, PersonalBest.FitnessValue) < 0)
{
PersonalBest = CurrentState;
_sinceLastImprovement = 0;
}
else
{
_sinceLastImprovement++;
}
}
