/// <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); }