/// <summary>
/// Chooses a new trainer from the solution population to add to the trainer
/// population.
/// </summary>
/// <remarks>
/// Chooses a new trainer from the solution population to add to the trainer
/// population. The solution individual is chosen with the highest variance
/// of the predictions from the current predictor population.
/// </remarks>
protected internal virtual PushGPIndividual ChooseNewTrainer()
{
List <float> individualVariances = new List <float>();
for (int i = 0; i < _solutionGA.GetPopulationSize(); i++)
{
PushGPIndividual individual = (PushGPIndividual)_solutionGA.GetIndividualFromPopulation(i);
List <float> predictions = new List <float>();
for (int j = 0; j < _populations[_currentPopulation].Length; j++)
{
PredictionGAIndividual predictor = (PredictionGAIndividual)_populations[_currentPopulation][j];
predictions.Add(predictor.PredictSolutionFitness(individual));
}
individualVariances.Add(Variance(predictions));
}
// Find individual with the highest variance
int highestVarianceIndividual = 0;
float highestVariance = individualVariances[0];
for (int i_1 = 0; i_1 < _solutionGA.GetPopulationSize(); i_1++)
{
if (highestVariance < individualVariances[i_1])
{
highestVarianceIndividual = i_1;
highestVariance = individualVariances[i_1];
}
}
return((PushGPIndividual)_solutionGA.GetIndividualFromPopulation(highestVarianceIndividual));
}
/// <summary>
/// NOTE: This is entirely copied from PushGP, except EvaluateIndividual
/// was changed to PredictIndividual, as noted below (twice).
/// </summary>
protected internal override PushGPIndividual Autosimplify(PushGPIndividual inIndividual, int steps)
{
PushGPIndividual simplest = (PushGPIndividual)inIndividual.Clone();
PushGPIndividual trial = (PushGPIndividual)inIndividual.Clone();
PredictIndividual(simplest, true);
// Changed from EvaluateIndividual
float bestError = simplest.GetFitness();
bool madeSimpler = false;
for (int i = 0; i < steps; i++)
{
madeSimpler = false;
float method = Rng.Next(100);
if (trial._program.ProgramSize() <= 0)
{
break;
}
if (method < _simplifyFlattenPercent)
{
// Flatten random thing
int pointIndex = Rng.Next(trial._program.ProgramSize());
object point = trial._program.Subtree(pointIndex);
if (point is Program)
{
trial._program.Flatten(pointIndex);
madeSimpler = true;
}
}
else
{
// Remove small number of random things
int numberToRemove = Rng.Next(3) + 1;
for (int j = 0; j < numberToRemove; j++)
{
int trialSize = trial._program.ProgramSize();
if (trialSize > 0)
{
int pointIndex = Rng.Next(trialSize);
trial._program.ReplaceSubtree(pointIndex, new Program());
trial._program.Flatten(pointIndex);
madeSimpler = true;
}
}
}
if (madeSimpler)
{
PredictIndividual(trial, true);
// Changed from EvaluateIndividual
if (trial.GetFitness() <= bestError)
{
simplest = (PushGPIndividual)trial.Clone();
bestError = trial.GetFitness();
}
}
trial = (PushGPIndividual)simplest.Clone();
}
return(simplest);
}
/// <summary>
/// Determines the predictor's fitness on a trainer, where the trainer is the
/// inInput, and the trainer's actual fitness is inOutput.
/// </summary>
/// <remarks>
/// Determines the predictor's fitness on a trainer, where the trainer is the
/// inInput, and the trainer's actual fitness is inOutput. The fitness of
/// the predictor is the absolute error between the prediction and the
/// trainer's actual fitness.
/// </remarks>
/// <returns>Predictor's fitness (i.e. error) for the given trainer.</returns>
/// <exception cref="System.Exception"></exception>
public override float EvaluateTestCase(GAIndividual inIndividual, object inInput, object inOutput)
{
PushGPIndividual trainer = (PushGPIndividual)inInput;
float trainerFitness = (float)inOutput;
float predictedTrainerFitness = ((PredictionGAIndividual)inIndividual).PredictSolutionFitness(trainer);
return(Math.Abs(predictedTrainerFitness - trainerFitness));
}
public override float PredictSolutionFitness(PushGPIndividual pgpIndividual)
{
List <float> errors = new List <float>();
for (int n = 0; n < _sampleSize; n++)
{
GATestCase test = _solutionGA._testCases[_sampleIndices[n]];
float e = _solutionGA.EvaluateTestCase(pgpIndividual, test._input, test._output);
errors.Add(e);
}
return(AbsoluteAverageOfErrors(errors));
}
protected internal override void BeginGeneration()
{
if (_generationCount % _generationsBetweenTrainers == _generationsBetweenTrainers - 1)
{
// Time to add a new trainer
PushGPIndividual newTrainer = (PushGPIndividual)ChooseNewTrainer().Clone();
EvaluateSolutionIndividual(newTrainer);
_trainerPopulation.Remove(0);
_trainerPopulation.Add(newTrainer);
EvaluateTrainerFitnesses();
}
}
/// <summary>
/// This must be private, since there must be a _solutionGA set before this
/// method is invoked.
/// </summary>
/// <remarks>
/// This must be private, since there must be a _solutionGA set before this
/// method is invoked. Use SetGAandTrainers() instead.
/// </remarks>
private void InitTrainerPopulation()
{
_trainerPopulation = new List <PushGPIndividual>();
PushGPIndividual individual = new PushGPIndividual();
for (int i = 0; i < _trainerPopulationSize; i++)
{
_trainerPopulation.Add((PushGPIndividual)individual.Clone());
_solutionGA.InitIndividual(_trainerPopulation[i]);
}
EvaluateTrainerFitnesses();
}
/// <summary>
/// Calculates and sets the exact fitness from any individual of the
/// _solutionGA population.
/// </summary>
/// <remarks>
/// Calculates and sets the exact fitness from any individual of the
/// _solutionGA population. This includes trainers.
/// </remarks>
/// <param name="inIndividual"/>
protected internal virtual void EvaluateSolutionIndividual(PushGPIndividual inIndividual)
{
_solutionGA.EvaluateIndividual(inIndividual);
}
/// <summary>Predicts the fitness of the input PushGPIndividual</summary> /// <param name="individual">to predict the fitness of</param> /// <returns>predicted fitness</returns> public abstract float PredictSolutionFitness(PushGPIndividual pgpIndividual);
public override float PredictSolutionFitness(PushGPIndividual pgpIndividual)
{
//TODO implement _program being run to predict fitness
return(-2999);
}