source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs @ 10888

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.EvolutionTracking {
  [StorableClass]
  [Item("GenealogyAnalyzer", "An analyzer which performs the necessary instrumentation to record the evolution of a genetic algorithm.")]
  public class GenealogyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer
  where T : class,IItem {
    private const string GenerationsParameterName = "Generations";
    private const string ResultsParameterName = "Results";
    private const string PopulationGraphParameterName = "PopulationGraph";
    public const string QualityParameterName = "Quality";
    public const string PopulationParameterName = "SymbolicExpressionTree";

    private const string CrossoverParameterName = "Crossover";
    private const string ManipulatorParameterName = "Mutator";
    private const string SolutionCreatorParameterName = "SolutionCreator";

    private const string BeforeCrossoverOperatorParameterName = "BeforeCrossoverOperator";
    private const string AfterCrossoverOperatorParameterName = "AfterCrossoverOperator";

    private const string BeforeManipulatorOperatorParameterName = "BeforeManipulatorOperator";
    private const string AfterManipulatorOperatorParameterName = "AfterManipulatorOperator";

    private const string EnableCrossoverTrackingParameterName = "EnableCrossoverTracking";
    private const string EnableManipulatorTrackingParameterName = "EnableManipulatorTracking";
    private const string EnableSolutionCreatorTrackingParameterName = "EnableSolutionCreatorTracking"; // should always be enabled. maybe superfluous

    #region parameter properties
    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
    }
    public IScopeTreeLookupParameter<T> PopulationParameter {
      get { return (IScopeTreeLookupParameter<T>)Parameters[PopulationParameterName]; }
    }
    public IValueParameter<ICrossoverOperator<T>> BeforeCrossoverOperatorParameter {
      get { return (IValueParameter<ICrossoverOperator<T>>)Parameters[BeforeCrossoverOperatorParameterName]; }
    }
    public IValueParameter<ICrossoverOperator<T>> AfterCrossoverOperatorParameter {
      get { return (IValueParameter<ICrossoverOperator<T>>)Parameters[AfterCrossoverOperatorParameterName]; }
    }
    public IValueParameter<IManipulatorOperator<T>> BeforeManipulatorOperatorParameter {
      get { return (IValueParameter<IManipulatorOperator<T>>)Parameters[BeforeManipulatorOperatorParameterName]; }
    }
    public IValueParameter<IManipulatorOperator<T>> AfterManipulatorOperatorParameter {
      get { return (IValueParameter<IManipulatorOperator<T>>)Parameters[AfterManipulatorOperatorParameterName]; }
    }
    public ILookupParameter<ResultCollection> ResultsParameter {
      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
    }
    public ILookupParameter<IntValue> GenerationsParameter {
      get { return (ILookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
    }
    public IValueParameter<BoolValue> EnableCrossoverTrackingParameter {
      get { return (IValueParameter<BoolValue>)Parameters[EnableCrossoverTrackingParameterName]; }
    }
    public IValueParameter<BoolValue> EnableManipulatorTrackingParameter {
      get { return (IValueParameter<BoolValue>)Parameters[EnableManipulatorTrackingParameterName]; }
    }
    public IValueParameter<BoolValue> EnableSolutionCreatorTrackingParameter {
      get { return (IValueParameter<BoolValue>)Parameters[EnableSolutionCreatorTrackingParameterName]; }
    }
    public ILookupParameter<ICrossover> CrossoverParameter {
      get { return (ILookupParameter<ICrossover>)Parameters[CrossoverParameterName]; }
    }
    public ILookupParameter<IManipulator> ManipulatorParameter {
      get { return (ILookupParameter<IManipulator>)Parameters[ManipulatorParameterName]; }
    }

    public ILookupParameter<ISolutionCreator> SolutionCreatorParameter {
      get { return (ILookupParameter<ISolutionCreator>)Parameters[SolutionCreatorParameterName]; }
    }
    #endregion

    #region properties
    public ICrossover Crossover {
      get { return CrossoverParameter.ActualValue; }
    }
    public IManipulator Manipulator {
      get { return ManipulatorParameter.ActualValue; }
    }
    public ICrossoverOperator<T> BeforeCrossoverOperator {
      get { return BeforeCrossoverOperatorParameter.Value; }
    }
    public ICrossoverOperator<T> AfterCrossoverOperator {
      get { return AfterCrossoverOperatorParameter.Value; }
    }
    public IManipulatorOperator<T> BeforeManipulatorOperator {
      get { return BeforeManipulatorOperatorParameter.Value; }
    }
    public IManipulatorOperator<T> AfterManipulatorOperator {
      get { return AfterManipulatorOperatorParameter.Value; }
    }
    public ISolutionCreator SolutionCreator {
      get { return SolutionCreatorParameter.ActualValue; }
    }
    public BoolValue EnableCrossoverTracking {
      get { return EnableCrossoverTrackingParameter.Value; }
    }
    public BoolValue EnableManipulatorTracking {
      get { return EnableManipulatorTrackingParameter.Value; }
    }
    public BoolValue EnableSolutionCreatorTracking {
      get { return EnableSolutionCreatorTrackingParameter.Value; }
    }
    public ResultCollection Results {
      get { return ResultsParameter.ActualValue; }
    }
    public IntValue Generations {
      get { return GenerationsParameter.ActualValue; }
    }
    public IGenealogyGraph<T> GenealogyGraph {
      get {
        IResult result;
        if (!Results.ContainsKey(PopulationGraphParameterName)) {
          result = new Result(PopulationGraphParameterName, new GenealogyGraph<T>());
          Results.Add(result);
        } else {
          result = Results[PopulationGraphParameterName];
        }
        var graph = (IGenealogyGraph<T>)result.Value;
        return graph;
      }
    }
    #endregion

    public GenealogyAnalyzer() {
      // the instrumented operators
      Parameters.Add(new LookupParameter<ICrossover>(CrossoverParameterName, "The crossover operator."));
      Parameters.Add(new LookupParameter<IManipulator>(ManipulatorParameterName, "The manipulator operator."));
      Parameters.Add(new LookupParameter<ISolutionCreator>(SolutionCreatorParameterName, "The solution creator operator."));
      // the analyzer parameters
      Parameters.Add(new ValueParameter<BoolValue>(EnableCrossoverTrackingParameterName, new BoolValue(true)));
      Parameters.Add(new ValueParameter<BoolValue>(EnableManipulatorTrackingParameterName, new BoolValue(true)));
      Parameters.Add(new ValueParameter<BoolValue>(EnableSolutionCreatorTrackingParameterName, new BoolValue(true)));
      // parameters required by the analyzer to do its work
      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName));
      Parameters.Add(new ScopeTreeLookupParameter<T>(PopulationParameterName, "The population of individuals."));
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The individual qualities."));
      Parameters.Add(new ValueParameter<ICrossoverOperator<T>>(BeforeCrossoverOperatorParameterName));
      Parameters.Add(new ValueParameter<ICrossoverOperator<T>>(AfterCrossoverOperatorParameterName));
      Parameters.Add(new ValueParameter<IManipulatorOperator<T>>(BeforeManipulatorOperatorParameterName));
      Parameters.Add(new ValueParameter<IManipulatorOperator<T>>(AfterManipulatorOperatorParameterName));
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new GenealogyAnalyzer<T>(this, cloner);
    }
    protected GenealogyAnalyzer(GenealogyAnalyzer<T> original, Cloner cloner)
      : base(original, cloner) {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      // the instrumented operators
      if (!Parameters.ContainsKey(CrossoverParameterName))
        Parameters.Add(new LookupParameter<ICrossover>(CrossoverParameterName, "The crossover operator."));
      if (!Parameters.ContainsKey(ManipulatorParameterName))
        Parameters.Add(new LookupParameter<IManipulator>(ManipulatorParameterName, "The manipulator operator."));
      if (!Parameters.ContainsKey(SolutionCreatorParameterName))
        Parameters.Add(new LookupParameter<ISolutionCreator>(SolutionCreatorParameterName, "The solution creator operator."));
      // the analyzer parameters
      if (!Parameters.ContainsKey(EnableCrossoverTrackingParameterName))
        Parameters.Add(new ValueParameter<BoolValue>(EnableCrossoverTrackingParameterName, new BoolValue(true)));
      if (!Parameters.ContainsKey(EnableManipulatorTrackingParameterName))
        Parameters.Add(new ValueParameter<BoolValue>(EnableManipulatorTrackingParameterName, new BoolValue(true)));
      if (!Parameters.ContainsKey(EnableSolutionCreatorTrackingParameterName))
        Parameters.Add(new ValueParameter<BoolValue>(EnableSolutionCreatorTrackingParameterName, new BoolValue(true)));
      // parameters required by the analyzer to do its work
      if (!Parameters.ContainsKey(GenerationsParameterName))
        Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
      if (!Parameters.ContainsKey(ResultsParameterName))
        Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName));
      if (!Parameters.ContainsKey(PopulationParameterName)) {
        Parameters.Add(new ScopeTreeLookupParameter<T>(PopulationParameterName, "The population of individuals."));
      }
      if (!Parameters.ContainsKey(QualityParameterName)) {
        Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The individual qualities."));
      }
    }

    public bool EnabledByDefault {
      get { return false; }
    }

    private void ConfigureTrackingOperators() {
      // at the beginning we add the before/after operators to the instrumented operators
      if (Crossover != null) {
        var instrumentedCrossover = (InstrumentedOperator)Crossover;
        instrumentedCrossover.AfterExecutionOperators.Clear();
        instrumentedCrossover.BeforeExecutionOperators.Clear();

        if (EnableCrossoverTracking.Value) {
          if (BeforeCrossoverOperator != null) {
            instrumentedCrossover.BeforeExecutionOperators.Add(BeforeCrossoverOperator);
          }
          if (AfterCrossoverOperator != null) {
            instrumentedCrossover.AfterExecutionOperators.Add(AfterCrossoverOperator);
          }
        }
      }

      if (Manipulator != null) {
        var instrumentedManipulator = (InstrumentedOperator)Manipulator;
        instrumentedManipulator.AfterExecutionOperators.Clear();
        instrumentedManipulator.BeforeExecutionOperators.Clear();

        if (EnableManipulatorTracking.Value) {
          if (BeforeManipulatorOperator != null) {
            instrumentedManipulator.BeforeExecutionOperators.Add(BeforeManipulatorOperator);
          }
          if (AfterManipulatorOperator != null) {
            instrumentedManipulator.AfterExecutionOperators.Add(AfterManipulatorOperator);
          }
        }
      }
    }

    public override IOperation Apply() {
      var population = PopulationParameter.ActualValue.ToList();
      var qualities = QualityParameter.ActualValue.ToList();

      if (Generations.Value == 0) {
        ConfigureTrackingOperators();

        for (int i = 0; i < population.Count; ++i) {
          var individual = population[i];
          var vertex = new GenealogyGraphNode<T> { Content = individual, Rank = Generations.Value };
          GenealogyGraph.AddVertex(vertex);
          // save the vertex id in the individual scope (so that we can identify graph indices)
          ExecutionContext.Scope.SubScopes[i].Variables.Add(new Variable("Id", new StringValue(vertex.Id)));
        }
      } else {
        var elite = population.FirstOrDefault(x => GenealogyGraph.Contains(x));
        if (elite != null) {
          var prevVertex = (IGenealogyGraphNode<T>)GenealogyGraph[elite];
          prevVertex.IsElite = true; // mark elites in the graph retroactively

          var clone = (T)elite.Clone();

          var vertex = new GenealogyGraphNode<T> {
            Content = prevVertex.Content,
            Rank = Generations.Value,
            Quality = prevVertex.Quality,
            IsElite = false
          };

          GenealogyGraph.SetContent(prevVertex, clone);
          // swap id
          var id = prevVertex.Id;
          GenealogyGraph.SetId(prevVertex, vertex.Id);

          // add new vertex to the graph
          vertex.Id = id;
          GenealogyGraph.AddVertex(vertex);

          GenealogyGraph.AddArc(prevVertex, vertex); // connect current elite with previous elite

          if (prevVertex.InArcs.Any()) {
            vertex.InArcs.Last().Data = prevVertex.InArcs.Last().Data; // save the fragment in case there is one
          }
        }
      }
      // update qualities
      for (int i = 0; i < population.Count; ++i) {
        var vertex = (IGenealogyGraphNode)GenealogyGraph[population[i]];
        vertex.Quality = qualities[i].Value;
      }

      return base.Apply();
    }
  }
}