/// <summary>
/// Construct the parallel task.
/// </summary>
/// <param name="genome">The genome.</param>
/// <param name="theOwner">The owner.</param>
public ParallelScoreTask(IGenome genome, ParallelScore theOwner)
{
owner = theOwner;
this.genome = genome;
scoreFunction = theOwner.ScoreFunction;
adjusters = theOwner.Adjusters;
}
/// <summary>
/// Construct the parallel task.
/// </summary>
/// <param name="genome">The genome.</param>
/// <param name="theOwner">The owner.</param>
public ParallelScoreTask(IGenome genome, ParallelScore theOwner)
{
owner = theOwner;
this.genome = genome;
scoreFunction = theOwner.ScoreFunction;
adjusters = theOwner.Adjusters;
}
/// <summary>
/// Construct a neural genetic algorithm.
/// </summary>
/// <param name="network">The network to base this on.</param>
/// <param name="randomizer">The randomizer used to create this initial population.</param>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="populationSize">The population size.</param>
/// <param name="mutationPercent">The percent of offspring to mutate.</param>
/// <param name="percentToMate">The percent of the population allowed to mate.</param>
public NeuralGeneticAlgorithm(BasicNetwork network,
IRandomizer randomizer,
ICalculateScore calculateScore,
int populationSize, double mutationPercent,
double percentToMate)
{
this.Helper = new NeuralGeneticAlgorithmHelper();
this.Helper.CalculateScore = new GeneticScoreAdapter(calculateScore);
IPopulation population = new BasicPopulation(populationSize);
Helper.MutationPercent = mutationPercent;
Helper.MatingPopulation = (percentToMate * 2);
Helper.PercentToMate = (percentToMate);
Helper.Crossover = (new Splice(network.Structure.CalculateSize() / 3));
Helper.Mutate = (new MutatePerturb(4.0));
Helper.Population = (population);
for (int i = 0; i < population.PopulationSize; i++)
{
BasicNetwork chromosomeNetwork = (BasicNetwork)network
.Clone();
randomizer.Randomize(chromosomeNetwork);
NeuralGenome genome =
new NeuralGenome(this, chromosomeNetwork);
Helper.PerformScoreCalculation(genome);
Helper.Population.Add(genome);
}
population.Sort();
}
/// <summary>
/// Construct a neural genetic algorithm.
/// </summary>
///
/// <param name="network">The network to base this on.</param>
/// <param name="randomizer">The randomizer used to create this initial population.</param>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="populationSize">The population size.</param>
/// <param name="mutationPercent">The percent of offspring to mutate.</param>
/// <param name="percentToMate">The percent of the population allowed to mate.</param>
public NeuralGeneticAlgorithm(BasicNetwork network,
IRandomizer randomizer, ICalculateScore calculateScore,
int populationSize, double mutationPercent,
double percentToMate) : base(TrainingImplementationType.Iterative)
{
Genetic = new NeuralGeneticAlgorithmHelper
{
CalculateScore = new GeneticScoreAdapter(calculateScore)
};
IPopulation population = new BasicPopulation(populationSize);
Genetic.MutationPercent = mutationPercent;
Genetic.MatingPopulation = percentToMate * 2;
Genetic.PercentToMate = percentToMate;
Genetic.Crossover = new Splice(network.Structure.CalculateSize() / 3);
Genetic.Mutate = new MutatePerturb(4.0d);
Genetic.Population = population;
for (int i = 0; i < population.PopulationSize; i++)
{
var chromosomeNetwork = (BasicNetwork)(network
.Clone());
randomizer.Randomize(chromosomeNetwork);
var genome = new NeuralGenome(chromosomeNetwork)
{
GA = Genetic
};
Genetic.PerformCalculateScore(genome);
Genetic.Population.Add(genome);
}
population.Sort();
}
/// <summary>
/// Construct a neural genetic algorithm.
/// </summary>
///
/// <param name="network">The network to base this on.</param>
/// <param name="randomizer">The randomizer used to create this initial population.</param>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="populationSize">The population size.</param>
/// <param name="mutationPercent">The percent of offspring to mutate.</param>
/// <param name="percentToMate">The percent of the population allowed to mate.</param>
public NeuralGeneticAlgorithm(BasicNetwork network,
IRandomizer randomizer, ICalculateScore calculateScore,
int populationSize, double mutationPercent,
double percentToMate)
: base(TrainingImplementationType.Iterative)
{
Genetic = new NeuralGeneticAlgorithmHelper
{
CalculateScore = new GeneticScoreAdapter(calculateScore)
};
IPopulation population = new BasicPopulation(populationSize);
Genetic.MutationPercent = mutationPercent;
Genetic.MatingPopulation = percentToMate*2;
Genetic.PercentToMate = percentToMate;
Genetic.Crossover = new Splice(network.Structure.CalculateSize()/3);
Genetic.Mutate = new MutatePerturb(4.0d);
Genetic.Population = population;
for (int i = 0; i < population.PopulationSize; i++)
{
var chromosomeNetwork = (BasicNetwork) (network
.Clone());
randomizer.Randomize(chromosomeNetwork);
var genome = new NeuralGenome(chromosomeNetwork) {GA = Genetic};
Genetic.PerformCalculateScore(genome);
Genetic.Population.Add(genome);
}
population.Sort();
}
/// <summary>
/// Construct a NEAT or HyperNEAT trainer.
/// </summary>
/// <param name="calculateScore">The score function.</param>
/// <param name="inputCount">The input count.</param>
/// <param name="outputCount">The output count.</param>
/// <param name="populationSize">The population size.</param>
/// <returns></returns>
public static TrainEA ConstructNEATTrainer(
ICalculateScore calculateScore, int inputCount,
int outputCount, int populationSize)
{
var pop = new NEATPopulation(inputCount, outputCount,
populationSize);
pop.Reset();
return ConstructNEATTrainer(pop, calculateScore);
}
/// <summary>
/// Construct the parallel score calculation object.
/// </summary>
/// <param name="thePopulation">The population to score.</param>
/// <param name="theCODEC">The CODEC to use.</param>
/// <param name="theAdjusters">The score adjusters to use.</param>
/// <param name="theScoreFunction">The score function.</param>
/// <param name="theThreadCount">The requested thread count.</param>
public ParallelScore(IPopulation thePopulation, IGeneticCODEC theCODEC,
IList<IAdjustScore> theAdjusters, ICalculateScore theScoreFunction,
int theThreadCount)
{
_codec = theCODEC;
_population = thePopulation;
_scoreFunction = theScoreFunction;
_adjusters = theAdjusters;
ThreadCount = theThreadCount;
}
/// <summary>
/// Construct the parallel score calculation object.
/// </summary>
/// <param name="thePopulation">The population to score.</param>
/// <param name="theCODEC">The CODEC to use.</param>
/// <param name="theAdjusters">The score adjusters to use.</param>
/// <param name="theScoreFunction">The score function.</param>
/// <param name="theThreadCount">The requested thread count.</param>
public ParallelScore(IPopulation thePopulation, IGeneticCODEC theCODEC,
IList <IAdjustScore> theAdjusters, ICalculateScore theScoreFunction,
int theThreadCount)
{
_codec = theCODEC;
_population = thePopulation;
_scoreFunction = theScoreFunction;
_adjusters = theAdjusters;
ThreadCount = theThreadCount;
}
/// <summary>
/// Construct a NEAT or HyperNEAT trainer.
/// </summary>
/// <param name="calculateScore">The score function.</param>
/// <param name="inputCount">The input count.</param>
/// <param name="outputCount">The output count.</param>
/// <param name="populationSize">The population size.</param>
/// <returns></returns>
public static TrainEA ConstructNEATTrainer(
ICalculateScore calculateScore, int inputCount,
int outputCount, int populationSize)
{
var pop = new NEATPopulation(inputCount, outputCount,
populationSize);
pop.Reset();
return(ConstructNEATTrainer(pop, calculateScore));
}
public NeuralGeneticAlgorithm(BasicNetwork network, IRandomizer randomizer, ICalculateScore calculateScore, int populationSize, double mutationPercent, double percentToMate)
: base(TrainingImplementationType.Iterative)
{
NeuralGeneticAlgorithmHelper helper;
Label_012F:
helper = new NeuralGeneticAlgorithmHelper();
helper.CalculateScore = new GeneticScoreAdapter(calculateScore);
this.Genetic = helper;
IPopulation population = new BasicPopulation(populationSize);
this.Genetic.MutationPercent = mutationPercent;
this.Genetic.MatingPopulation = percentToMate * 2.0;
this.Genetic.PercentToMate = percentToMate;
this.Genetic.Crossover = new Splice(network.Structure.CalculateSize() / 3);
this.Genetic.Mutate = new MutatePerturb(4.0);
this.Genetic.Population = population;
int num = 0;
while (true)
{
NeuralGenome genome2;
if (num < population.PopulationSize)
{
BasicNetwork network2 = (BasicNetwork) network.Clone();
randomizer.Randomize(network2);
if ((((uint) percentToMate) + ((uint) populationSize)) >= 0)
{
genome2 = new NeuralGenome(network2) {
GA = this.Genetic
};
}
}
else
{
population.Sort();
if (((uint) populationSize) <= uint.MaxValue)
{
return;
}
goto Label_012F;
}
if ((((uint) num) + ((uint) populationSize)) >= 0)
{
NeuralGenome g = genome2;
this.Genetic.PerformCalculateScore(g);
if (((uint) populationSize) > uint.MaxValue)
{
goto Label_012F;
}
this.Genetic.Population.Add(g);
num++;
}
}
}
public NeuralSimulatedAnnealing(BasicNetwork network, ICalculateScore calculateScore, double startTemp, double stopTemp, int cycles)
: base(TrainingImplementationType.Iterative)
{
this._x87a7fc6a72741c2e = network;
this._x2308f8c4f898a271 = calculateScore;
NeuralSimulatedAnnealingHelper helper = new NeuralSimulatedAnnealingHelper(this) {
Temperature = startTemp,
StartTemperature = startTemp,
StopTemperature = stopTemp,
Cycles = cycles
};
this._xcad10f1a21e41441 = helper;
}
/// <summary>
/// Construct a neat trainer with a new population. The new population is
/// created from the specified parameters.
/// </summary>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="inputCount">The input neuron count.</param>
/// <param name="outputCount">The output neuron count.</param>
/// <param name="populationSize">The population size.</param>
public NEATTraining(ICalculateScore calculateScore,
int inputCount, int outputCount,
int populationSize)
{
this.inputCount = inputCount;
this.outputCount = outputCount;
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = new NEATPopulation(inputCount, outputCount,
populationSize);
Init();
}
/// <summary>
/// Construct a simulated annleaing trainer for a feedforward neural network.
/// </summary>
///
/// <param name="network">The neural network to be trained.</param>
/// <param name="calculateScore">Used to calculate the score for a neural network.</param>
/// <param name="startTemp">The starting temperature.</param>
/// <param name="stopTemp">The ending temperature.</param>
/// <param name="cycles">The number of cycles in a training iteration.</param>
public NeuralSimulatedAnnealing(IMLEncodable network,
ICalculateScore calculateScore, double startTemp,
double stopTemp, int cycles) : base(TrainingImplementationType.Iterative)
{
_network = network;
_calculateScore = calculateScore;
_anneal = new NeuralSimulatedAnnealingHelper(this)
{
Temperature = startTemp,
StartTemperature = startTemp,
StopTemperature = stopTemp,
Cycles = cycles
};
}
/// <summary>
/// Construct a simulated annleaing trainer for a feedforward neural network.
/// </summary>
///
/// <param name="network">The neural network to be trained.</param>
/// <param name="calculateScore">Used to calculate the score for a neural network.</param>
/// <param name="startTemp">The starting temperature.</param>
/// <param name="stopTemp">The ending temperature.</param>
/// <param name="cycles">The number of cycles in a training iteration.</param>
public NeuralSimulatedAnnealing(BasicNetwork network,
ICalculateScore calculateScore, double startTemp,
double stopTemp, int cycles) : base(TrainingImplementationType.Iterative)
{
_network = network;
_calculateScore = calculateScore;
_anneal = new NeuralSimulatedAnnealingHelper(this)
{
Temperature = startTemp,
StartTemperature = startTemp,
StopTemperature = stopTemp,
Cycles = cycles
};
}
/// <summary>
/// Construct a simulated annleaing trainer for a feedforward neural network.
/// </summary>
/// <param name="network">The neural network to be trained.</param>
/// <param name="calculateScore">Used to calculate the score for a neural network.</param>
/// <param name="startTemp">The starting temperature.</param>
/// <param name="stopTemp">The ending temperature.</param>
/// <param name="cycles">The number of cycles in a training iteration.</param>
public NeuralSimulatedAnnealing(BasicNetwork network,
ICalculateScore calculateScore,
double startTemp,
double stopTemp,
int cycles)
{
this.network = network;
this.calculateScore = calculateScore;
this.anneal = new NeuralSimulatedAnnealingHelper(this);
this.anneal.Temperature = startTemp;
this.anneal.StartTemperature = startTemp;
this.anneal.StopTemperature = stopTemp;
this.anneal.Cycles = cycles;
}
/// <summary>
/// Construct a method genetic algorithm.
/// </summary>
/// <param name="phenotypeFactory">The phenotype factory.</param>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="populationSize">The population size.</param>
public MLMethodGeneticAlgorithm(MLMethodGenomeFactory.CreateMethod phenotypeFactory,
ICalculateScore calculateScore, int populationSize)
: base(TrainingImplementationType.Iterative)
{
// create the population
IPopulation population = new BasicPopulation(populationSize, null);
population.GenomeFactory = new MLMethodGenomeFactory(phenotypeFactory,
population);
ISpecies defaultSpecies = population.CreateSpecies();
for (int i = 0; i < population.PopulationSize; i++)
{
IMLEncodable chromosomeNetwork = (IMLEncodable)phenotypeFactory();
MLMethodGenome genome = new MLMethodGenome(chromosomeNetwork);
defaultSpecies.Add(genome);
}
defaultSpecies.Leader = defaultSpecies.Members[0];
// create the trainer
this.genetic = new MLMethodGeneticAlgorithmHelper(population,
calculateScore);
this.genetic.CODEC = new MLEncodableCODEC();
IGenomeComparer comp = null;
if (calculateScore.ShouldMinimize)
{
comp = new MinimizeScoreComp();
}
else
{
comp = new MaximizeScoreComp();
}
this.genetic.BestComparer = comp;
this.genetic.SelectionComparer = comp;
// create the operators
int s = Math
.Max(defaultSpecies.Members[0].Size / 5, 1);
Genetic.Population = population;
this.genetic.AddOperation(0.9, new Splice(s));
this.genetic.AddOperation(0.1, new MutatePerturb(1.0));
}
/// <summary>
/// Add an objective.
/// </summary>
/// <param name="weight">The weight of this objective, 1.0 for full, 0.5 for half, etc.</param>
/// <param name="fitnessFunction">The fitness function.</param>
public void AddObjective(double weight, ICalculateScore fitnessFunction)
{
if (this.objectives.Count == 0)
{
this.min = fitnessFunction.ShouldMinimize;
}
else
{
if (fitnessFunction.ShouldMinimize != this.min)
{
throw new EncogError("Multi-objective mismatch, some objectives are min and some are max.");
}
}
this.objectives.Add(new FitnessObjective(weight, fitnessFunction));
}
/// <summary>
/// Add an objective.
/// </summary>
/// <param name="weight">The weight of this objective, 1.0 for full, 0.5 for half, etc.</param>
/// <param name="fitnessFunction">The fitness function.</param>
public void AddObjective(double weight, ICalculateScore fitnessFunction)
{
if (this.objectives.Count == 0)
{
this.min = fitnessFunction.ShouldMinimize;
}
else
{
if (fitnessFunction.ShouldMinimize != this.min)
{
throw new EncogError("Multi-objective mismatch, some objectives are min and some are max.");
}
}
this.objectives.Add(new FitnessObjective(weight, fitnessFunction));
}
/// <summary>
/// Construct an EA.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public BasicEA(IPopulation thePopulation,
ICalculateScore theScoreFunction)
{
RandomNumberFactory = EncogFramework.Instance.RandomFactory.FactorFactory();
EliteRate = 0.3;
MaxTries = 5;
MaxOperationErrors = 500;
CODEC = new GenomeAsPhenomeCODEC();
Population = thePopulation;
ScoreFunction = theScoreFunction;
Selection = new TournamentSelection(this, 4);
Rules = new BasicRuleHolder();
// set the score compare method
if (theScoreFunction.ShouldMinimize)
{
SelectionComparer = new MinimizeAdjustedScoreComp();
BestComparer = new MinimizeScoreComp();
}
else
{
SelectionComparer = new MaximizeAdjustedScoreComp();
BestComparer = new MaximizeScoreComp();
}
// set the iteration
foreach (ISpecies species in thePopulation.Species)
{
foreach (IGenome genome in species.Members)
{
IterationNumber = Math.Max(IterationNumber,
genome.BirthGeneration);
}
}
// Set a best genome, just so it is not null.
// We won't know the true best genome until the first iteration.
if (Population.Species.Count > 0 && Population.Species[0].Members.Count > 0)
{
BestGenome = Population.Species[0].Members[0];
}
}
/// <summary>
/// Construct an EA.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public BasicEA(IPopulation thePopulation,
ICalculateScore theScoreFunction)
{
RandomNumberFactory = EncogFramework.Instance.RandomFactory.FactorFactory();
EliteRate = 0.3;
MaxTries = 5;
MaxOperationErrors = 500;
CODEC = new GenomeAsPhenomeCODEC();
Population = thePopulation;
ScoreFunction = theScoreFunction;
Selection = new TournamentSelection(this, 4);
Rules = new BasicRuleHolder();
// set the score compare method
if (theScoreFunction.ShouldMinimize)
{
SelectionComparer = new MinimizeAdjustedScoreComp();
BestComparer = new MinimizeScoreComp();
}
else
{
SelectionComparer = new MaximizeAdjustedScoreComp();
BestComparer = new MaximizeScoreComp();
}
// set the iteration
foreach (ISpecies species in thePopulation.Species)
{
foreach (IGenome genome in species.Members)
{
IterationNumber = Math.Max(IterationNumber,
genome.BirthGeneration);
}
}
// Set a best genome, just so it is not null.
// We won't know the true best genome until the first iteration.
if (Population.Species.Count > 0 && Population.Species[0].Members.Count > 0)
{
BestGenome = Population.Species[0].Members[0];
}
}
/// <summary>
/// Construct neat training with an existing population.
/// </summary>
/// <param name="calculateScore">The score object to use.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore calculateScore,
IPopulation population)
{
if (population.Size() < 1)
{
throw new TrainingError("Population can not be empty.");
}
var genome = (NEATGenome)population.Genomes[0];
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = (population);
inputCount = genome.InputCount;
outputCount = genome.OutputCount;
Init();
}
/// <summary>
/// Construct a NEAT training class.
/// </summary>
/// <param name="score">How to score the networks.</param>
/// <param name="network">The network to base this on.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore score, BasicNetwork network,
IPopulation population)
{
ILayer inputLayer = network.GetLayer(BasicNetwork.TAG_INPUT);
ILayer outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
this.CalculateScore = new GeneticScoreAdapter(score);
this.Comparator = new GenomeComparator(CalculateScore);
this.inputCount = inputLayer.NeuronCount;
this.outputCount = outputLayer.NeuronCount;
this.Population = population;
foreach (IGenome obj in population.Genomes)
{
NEATGenome neat = (NEATGenome)obj;
neat.GA = this;
}
Init();
}
/// <summary>
/// Construct a neat trainer with a new population.
/// </summary>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="inputCount">The input neuron count.</param>
/// <param name="outputCount">The output neuron count.</param>
/// <param name="populationSize">The population size.</param>
public NEATTraining(ICalculateScore calculateScore,
int inputCount, int outputCount,
int populationSize)
{
this.inputCount = inputCount;
this.outputCount = outputCount;
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = new BasicPopulation(populationSize);
// create the initial population
for (int i = 0; i < populationSize; i++)
{
Population.Add(
new NEATGenome(this, Population.AssignGenomeID(),
inputCount, outputCount));
}
Init();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="network">an initialised Encog network.
/// The networks in the swarm will be created with
/// the same topology as this network.</param>
/// <param name="randomizer">any type of Encog network weight initialisation
/// object.</param>
/// <param name="calculateScore">any type of Encog network scoring/fitness object.</param>
/// <param name="populationSize">the swarm size.</param>
public NeuralPSO(BasicNetwork network,
IRandomizer randomizer, ICalculateScore calculateScore,
int populationSize)
: base(TrainingImplementationType.Iterative)
{
// initialisation of the member variables
m_populationSize = populationSize;
m_randomizer = randomizer;
m_calculateScore = calculateScore;
m_bestNetwork = network;
m_networks = new BasicNetwork[m_populationSize];
m_velocities = null;
m_bestVectors = new double[m_populationSize][];
m_bestErrors = new double[m_populationSize];
m_bestVectorIndex = -1;
// get a vector from the network.
m_bestVector = NetworkCODEC.NetworkToArray(m_bestNetwork);
m_va = new VectorAlgebra();
}
/// <summary>
/// Construct neat training with a predefined population.
/// </summary>
/// <param name="calculateScore">The score object to use.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore calculateScore,
IPopulation population)
{
if (population.Genomes.Count < 1)
{
throw new TrainingError("Population can not be empty.");
}
NEATGenome genome = (NEATGenome)population.Genomes[0];
this.CalculateScore = new GeneticScoreAdapter(calculateScore);
this.Population = population;
this.inputCount = genome.InputCount;
this.outputCount = genome.OutputCount;
foreach (IGenome obj in population.Genomes)
{
NEATGenome neat = (NEATGenome)obj;
neat.GA = this;
}
Init();
}
public NEATTraining(ICalculateScore calculateScore, IPopulation population)
{
NEATGenome genome;
this.xd9d3bb742c7a307b = 0.1;
this.x67e8029e782709f0 = 0.07;
this.xe6c7b0462e12d2ff = 0.04;
this.xd3f94467320a5684 = 0.05;
this.x8a503d42183ff26d = 0.26;
this.xa4a074c49c97739c = 0.7;
this.xf52a69d338e65c0f = 0.1;
this.x214332e2bd2e8ae1 = 100.0;
this.x7a6edccccc229234 = 0.5;
this.x68e0847485ce0c21 = 0.2;
this.xd7944ba63721a56b = 5;
this.xfca9d4aed1b3cd4b = 15;
this.xe44426390f1f3741 = 5;
this.x340c2bbd00cd3fa4 = 5;
this.xe5ff50155887c0e7 = 0.1;
goto Label_0102;
if (0 == 0)
{
goto Label_010B;
}
Label_0102:
if (population.Size() < 1)
{
throw new TrainingError("Population can not be empty.");
}
Label_010B:
genome = (NEATGenome) population.Genomes[0];
base.CalculateScore = new GeneticScoreAdapter(calculateScore);
base.Comparator = new GenomeComparator(base.CalculateScore);
base.Population = population;
this.x43f451310e815b76 = genome.InputCount;
this.x98cf41c6b0eaf6ab = genome.OutputCount;
this.xd586e0c16bdae7fc();
}
/// <summary>
/// Create a trainer for a score function.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public TrainEA(IPopulation thePopulation, ICalculateScore theScoreFunction)
: base(thePopulation, theScoreFunction)
{
}
/// <summary>
/// Construct a neat trainer with a new population. The new population is
/// created from the specified parameters.
/// </summary>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="inputCount">The input neuron count.</param>
/// <param name="outputCount">The output neuron count.</param>
/// <param name="populationSize">The population size.</param>
public NEATTraining(ICalculateScore calculateScore,
int inputCount, int outputCount,
int populationSize)
{
this.inputCount = inputCount;
this.outputCount = outputCount;
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = new NEATPopulation(inputCount, outputCount,
populationSize);
Init();
}
///<summary>
///</summary>
public ActiveFlow()
{
_AssessActivityDal = new AssessActivityDal();
_ICalculateScore = new CalculateScore();
}
/// <summary>
/// Construct a simulated annleaing trainer for a feedforward neural network.
/// </summary>
/// <param name="network">The neural network to be trained.</param>
/// <param name="calculateScore">Used to calculate the score for a neural network.</param>
/// <param name="startTemp">The starting temperature.</param>
/// <param name="stopTemp">The ending temperature.</param>
/// <param name="cycles">The number of cycles in a training iteration.</param>
public NeuralSimulatedAnnealing(BasicNetwork network,
ICalculateScore calculateScore,
double startTemp,
double stopTemp,
int cycles)
{
this.network = network;
this.calculateScore = calculateScore;
this.anneal = new NeuralSimulatedAnnealingHelper(this);
this.anneal.Temperature = startTemp;
this.anneal.StartTemperature = startTemp;
this.anneal.StopTemperature = stopTemp;
this.anneal.Cycles = cycles;
}
/// <summary>
/// Construct the fitness objective.
/// </summary>
/// <param name="weight">The weight.</param>
/// <param name="score">The score.</param>
public FitnessObjective(double weight, ICalculateScore score)
{
this.weight = weight;
this.score = score;
}
/// <summary>
/// Construct a method genetic algorithm.
/// </summary>
/// <param name="phenotypeFactory">The phenotype factory.</param>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="populationSize">The population size.</param>
public MLMethodGeneticAlgorithm(MLMethodGenomeFactory.CreateMethod phenotypeFactory,
ICalculateScore calculateScore, int populationSize)
: base(TrainingImplementationType.Iterative)
{
// create the population
IPopulation population = new BasicPopulation(populationSize, null);
population.GenomeFactory = new MLMethodGenomeFactory(phenotypeFactory,
population);
ISpecies defaultSpecies = population.CreateSpecies();
for (int i = 0; i < population.PopulationSize; i++)
{
IMLEncodable chromosomeNetwork = (IMLEncodable)phenotypeFactory();
MLMethodGenome genome = new MLMethodGenome(chromosomeNetwork);
defaultSpecies.Add(genome);
}
defaultSpecies.Leader = defaultSpecies.Members[0];
// create the trainer
this.genetic = new MLMethodGeneticAlgorithmHelper(population,
calculateScore);
this.genetic.CODEC = new MLEncodableCODEC();
IGenomeComparer comp = null;
if (calculateScore.ShouldMinimize)
{
comp = new MinimizeScoreComp();
}
else
{
comp = new MaximizeScoreComp();
}
this.genetic.BestComparer = comp;
this.genetic.SelectionComparer = comp;
// create the operators
int s = Math
.Max(defaultSpecies.Members[0].Size / 5, 1);
Genetic.Population = population;
this.genetic.AddOperation(0.9, new Splice(s));
this.genetic.AddOperation(0.1, new MutatePerturb(1.0));
}
/// <summary>
/// Construct a NEAT (or HyperNEAT trainer.
/// </summary>
/// <param name="population">The population.</param>
/// <param name="calculateScore">The score function.</param>
/// <returns>The NEAT EA trainer.</returns>
public static TrainEA ConstructNEATTrainer(NEATPopulation population,
ICalculateScore calculateScore)
{
var result = new TrainEA(population, calculateScore) {Speciation = new OriginalNEATSpeciation()};
result.Selection = new TruncationSelection(result, 0.3);
var weightMutation = new CompoundOperator();
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(1),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(2),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(3),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectProportion(0.02),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(1),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(2),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(3),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectProportion(0.02),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.03,
new NEATMutateWeights(new SelectFixed(1),
new MutateResetLinkWeight()));
weightMutation.Components.Add(
0.03,
new NEATMutateWeights(new SelectFixed(2),
new MutateResetLinkWeight()));
weightMutation.Components.Add(
0.03,
new NEATMutateWeights(new SelectFixed(3),
new MutateResetLinkWeight()));
weightMutation.Components.Add(
0.01,
new NEATMutateWeights(new SelectProportion(0.02),
new MutateResetLinkWeight()));
weightMutation.Components.FinalizeStructure();
result.ChampMutation = weightMutation;
result.AddOperation(0.5, new NEATCrossover());
result.AddOperation(0.494, weightMutation);
result.AddOperation(0.0005, new NEATMutateAddNode());
result.AddOperation(0.005, new NEATMutateAddLink());
result.AddOperation(0.0005, new NEATMutateRemoveLink());
result.Operators.FinalizeStructure();
if (population.IsHyperNEAT)
{
result.CODEC = new HyperNEATCODEC();
}
else
{
result.CODEC = new NEATCODEC();
}
return result;
}
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="network"></param>
/// <param name="randomizer"></param>
/// <param name="calculateScore"></param>
public ParticleSwarmOptimizationAlgorithm(BasicNetwork network,IRandomizer randomizer, ICalculateScore calculateScore)
: base(TrainingImplementationType.Iterative)
{
}
/// <summary>
/// Construct a genetic score adapter.
/// </summary>
/// <param name="calculateScore">The ICalculateScore object to use.</param>
public GeneticScoreAdapter(ICalculateScore calculateScore)
{
this.calculateScore = calculateScore;
}
/// <summary>
/// Create a trainer for a score function.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public TrainEA(IPopulation thePopulation, ICalculateScore theScoreFunction)
: base(thePopulation, theScoreFunction)
{
_strategies = new List <IStrategy>();
}
/// <summary>
/// Construct a neat trainer with a new population.
/// </summary>
/// <param name="calculateScore">The score calculation object.</param>
/// <param name="inputCount">The input neuron count.</param>
/// <param name="outputCount">The output neuron count.</param>
/// <param name="populationSize">The population size.</param>
public NEATTraining(ICalculateScore calculateScore,
int inputCount, int outputCount,
int populationSize)
{
this.inputCount = inputCount;
this.outputCount = outputCount;
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = new BasicPopulation(populationSize);
// create the initial population
for (int i = 0; i < populationSize; i++)
{
Population.Add(
new NEATGenome(this, Population.AssignGenomeID(),
inputCount, outputCount));
}
Init();
}
/// <summary>
/// Construct the adapter.
/// </summary>
///
/// <param name="calculateScore">The CalculateScore object to use.</param>
public GeneticScoreAdapter(ICalculateScore calculateScore)
{
_calculateScore = calculateScore;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="network">an initialised Encog network.
/// The networks in the swarm will be created with
/// the same topology as this network.</param>
/// <param name="randomizer">any type of Encog network weight initialisation
/// object.</param>
/// <param name="calculateScore">any type of Encog network scoring/fitness object.</param>
/// <param name="populationSize">the swarm size.</param>
public NeuralPSO(BasicNetwork network,
IRandomizer randomizer, ICalculateScore calculateScore,
int populationSize)
: base(TrainingImplementationType.Iterative)
{
// initialisation of the member variables
m_populationSize = populationSize;
m_randomizer = randomizer;
m_calculateScore = calculateScore;
m_bestNetwork = network;
m_networks = new BasicNetwork[m_populationSize];
m_velocities = null;
m_bestVectors = new double[m_populationSize][];
m_bestErrors = new double[m_populationSize];
m_bestVectorIndex = -1;
// get a vector from the network.
m_bestVector = NetworkCODEC.NetworkToArray(m_bestNetwork);
m_va = new VectorAlgebra();
}
/// <summary>
/// Construct neat training with an existing population.
/// </summary>
/// <param name="calculateScore">The score object to use.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore calculateScore,
IPopulation population)
{
if (population.Size() < 1)
{
throw new TrainingError("Population can not be empty.");
}
var genome = (NEATGenome) population.Genomes[0];
CalculateScore = new GeneticScoreAdapter(calculateScore);
Comparator = new GenomeComparator(CalculateScore);
Population = (population);
inputCount = genome.InputCount;
outputCount = genome.OutputCount;
Init();
}
/// <summary>
/// Construct a NEAT training class.
/// </summary>
/// <param name="score">How to score the networks.</param>
/// <param name="network">The network to base this on.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore score, BasicNetwork network,
IPopulation population)
{
ILayer inputLayer = network.GetLayer(BasicNetwork.TAG_INPUT);
ILayer outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
this.CalculateScore = new GeneticScoreAdapter(score);
this.Comparator = new GenomeComparator(CalculateScore);
this.inputCount = inputLayer.NeuronCount;
this.outputCount = outputLayer.NeuronCount;
this.Population = population;
foreach (IGenome obj in population.Genomes)
{
NEATGenome neat = (NEATGenome)obj;
neat.GA = this;
}
Init();
}
/// <summary>
/// Construct a NEAT (or HyperNEAT trainer.
/// </summary>
/// <param name="population">The population.</param>
/// <param name="calculateScore">The score function.</param>
/// <returns>The NEAT EA trainer.</returns>
public static TrainEA ConstructNEATTrainer(NEATPopulation population,
ICalculateScore calculateScore)
{
var result = new TrainEA(population, calculateScore)
{
Speciation = new OriginalNEATSpeciation()
};
result.Selection = new TruncationSelection(result, 0.3);
var weightMutation = new CompoundOperator();
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(1),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(2),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(3),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectProportion(0.02),
new MutatePerturbLinkWeight(0.02)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(1),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(2),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectFixed(3),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.1125,
new NEATMutateWeights(new SelectProportion(0.02),
new MutatePerturbLinkWeight(1)));
weightMutation.Components.Add(
0.03,
new NEATMutateWeights(new SelectFixed(1),
new MutateResetLinkWeight()));
weightMutation.Components.Add(
0.03,
new NEATMutateWeights(new SelectFixed(2),
new MutateResetLinkWeight()));
weightMutation.Components.Add(
0.03,
new NEATMutateWeights(new SelectFixed(3),
new MutateResetLinkWeight()));
weightMutation.Components.Add(
0.01,
new NEATMutateWeights(new SelectProportion(0.02),
new MutateResetLinkWeight()));
weightMutation.Components.FinalizeStructure();
result.ChampMutation = weightMutation;
result.AddOperation(0.5, new NEATCrossover());
result.AddOperation(0.494, weightMutation);
result.AddOperation(0.0005, new NEATMutateAddNode());
result.AddOperation(0.005, new NEATMutateAddLink());
result.AddOperation(0.0005, new NEATMutateRemoveLink());
result.Operators.FinalizeStructure();
if (population.IsHyperNEAT)
{
result.CODEC = new HyperNEATCODEC();
}
else
{
result.CODEC = new NEATCODEC();
}
return(result);
}
/// <summary>
/// Construct the fitness objective.
/// </summary>
/// <param name="weight">The weight.</param>
/// <param name="score">The score.</param>
public FitnessObjective(double weight, ICalculateScore score)
{
this.weight = weight;
this.score = score;
}
/// <summary>
/// Construct the helper.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public MLMethodGeneticAlgorithmHelper(IPopulation thePopulation,
ICalculateScore theScoreFunction)
: base(thePopulation, theScoreFunction)
{
}
public NEATTraining(ICalculateScore calculateScore, int inputCount, int outputCount, int populationSize)
{
this.xd9d3bb742c7a307b = 0.1;
this.x67e8029e782709f0 = 0.07;
this.xe6c7b0462e12d2ff = 0.04;
this.xd3f94467320a5684 = 0.05;
this.x8a503d42183ff26d = 0.26;
this.xa4a074c49c97739c = 0.7;
this.xf52a69d338e65c0f = 0.1;
this.x214332e2bd2e8ae1 = 100.0;
this.x7a6edccccc229234 = 0.5;
this.x68e0847485ce0c21 = 0.2;
this.xd7944ba63721a56b = 5;
this.xfca9d4aed1b3cd4b = 15;
this.xe44426390f1f3741 = 5;
this.x340c2bbd00cd3fa4 = 5;
this.xe5ff50155887c0e7 = 0.1;
this.x43f451310e815b76 = inputCount;
this.x98cf41c6b0eaf6ab = outputCount;
base.CalculateScore = new GeneticScoreAdapter(calculateScore);
base.Comparator = new GenomeComparator(base.CalculateScore);
if ((((uint) inputCount) & 0) == 0)
{
do
{
base.Population = new NEATPopulation(inputCount, outputCount, populationSize);
this.xd586e0c16bdae7fc();
}
while (((uint) inputCount) > uint.MaxValue);
}
}
/// <summary>
/// Create a trainer for a score function.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public TrainEA(IPopulation thePopulation, ICalculateScore theScoreFunction)
: base(thePopulation, theScoreFunction)
{
}
/// <summary>
/// Construct neat training with a predefined population.
/// </summary>
/// <param name="calculateScore">The score object to use.</param>
/// <param name="population">The population to use.</param>
public NEATTraining(ICalculateScore calculateScore,
IPopulation population)
{
if (population.Genomes.Count < 1)
{
throw new TrainingError("Population can not be empty.");
}
NEATGenome genome = (NEATGenome)population.Genomes[0];
this.CalculateScore = new GeneticScoreAdapter(calculateScore);
this.Population = population;
this.inputCount = genome.InputCount;
this.outputCount = genome.OutputCount;
foreach (IGenome obj in population.Genomes)
{
NEATGenome neat = (NEATGenome)obj;
neat.GA = this;
}
Init();
}
public GeneticScoreAdapter(ICalculateScore calculateScore)
{
this._x2308f8c4f898a271 = calculateScore;
}
/// <summary>
/// Construct the helper.
/// </summary>
/// <param name="thePopulation">The population.</param>
/// <param name="theScoreFunction">The score function.</param>
public MLMethodGeneticAlgorithmHelper(IPopulation thePopulation,
ICalculateScore theScoreFunction)
: base(thePopulation, theScoreFunction)
{
}
