source: branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeFragmentLengthsAnalyzer.cs @ 9082

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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.Collections.Generic;
using System.Linq;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
// type definitions for convenience
using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;

namespace HeuristicLab.EvolutionaryTracking {
  /// <summary>
  /// An operator that gathers information on tree fragments that get passed from one generation to the next via genetic operators
  /// (Tracking of genetic variance and heredity)
  /// </summary>
  [Item("SymbolicExpressionTreeFragmentLengthAnalyzer", "An operator that provides statistics about fragment lengths")]
  [StorableClass]
  public sealed class SymbolicExpressionTreeFragmentLengthAnalyzer : SymbolicExpressionTreeFragmentsAnalyzer {
    private const string FragmentLengthsParameterName = "Fragment Lengths";
    // impact values calculator
    public ILookupParameter<DataTable> FragmentLengthsParameter { get { return (ILookupParameter<DataTable>)Parameters[FragmentLengthsParameterName]; } }
    public DataTable FragmentLengths {
      get { return FragmentLengthsParameter.ActualValue; }
      set { FragmentLengthsParameter.ActualValue = value; }
    }

    [StorableConstructor]
    private SymbolicExpressionTreeFragmentLengthAnalyzer(bool deserializing) : base(deserializing) { }
    private SymbolicExpressionTreeFragmentLengthAnalyzer(SymbolicExpressionTreeFragmentLengthAnalyzer original, Cloner cloner) : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicExpressionTreeFragmentLengthAnalyzer(this, cloner);
    }
    public SymbolicExpressionTreeFragmentLengthAnalyzer()
      : base() {
      #region Add parameters
      Parameters.Add(new LookupParameter<DataTable>(FragmentLengthsParameterName));
      #endregion

      UpdateCounterParameter.Hidden = true;
      UpdateIntervalParameter.Hidden = true;


    }
    #region After deserialization code

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    #endregion
    #region IStatefulItem members
    public override void InitializeState() {
      base.InitializeState();
      UpdateCounter.Value = 0;
    }

    public override void ClearState() {
      base.ClearState();
      UpdateCounter.Value = 0;
    }
    #endregion

    public override IOperation Apply() {
      UpdateCounter.Value++;
      if (UpdateCounter.Value == UpdateInterval.Value) {
        UpdateCounter.Value = 0; // reset counter
        if (Generations.Value > 1) {
          SecondaryTraceMap = SecondaryTraceMap ?? new TraceMapType();
          SecondaryFragmentMap = SecondaryFragmentMap ?? new CloneMapType();
          SecondaryCloneMap = SecondaryCloneMap ?? new CloneMapType();

          InitializeParameters();
          InitializeRows();

          var parents = SecondaryTraceMap.Values.SelectMany(list => list.Cast<ISymbolicExpressionTree>()).ToList(); // parents of individuals at generation N-1
          var offspring = SecondaryTraceMap.Keys.Cast<ISymbolicExpressionTree>().ToList(); // individuals at generation N-1
          var fragments = SecondaryFragmentMap.Values.Cast<IFragment>().ToList();


          // a hash of the offspring trees that got selected for reproduction at generation N
          var selected = new HashSet<ISymbolicExpressionTree>(GlobalTraceMap.Values.SelectMany(list => list.Cast<ISymbolicExpressionTree>()));

          var selectedOffspringFragments = SecondaryFragmentMap.Where(m => selected.Contains((ISymbolicExpressionTree)m.Key)).Select(m => m.Key).ToList();

          var selectedOffspring = offspring.Where(selected.Contains).ToList();
          var selectedOffspringParents = selectedOffspring.SelectMany(x => SecondaryTraceMap[x].Cast<ISymbolicExpressionTree>()).ToList();

          var rows = FragmentLengths.Rows;

          double avgParentsLength = parents.Count > 0 ? parents.Average(p => p.Length) : 0;
          double avgGoodParentsLength = selectedOffspringParents.Count > 0 ? selectedOffspringParents.Average(p => p.Length) : 0;
          rows["Parent lengths (all)"].Values.Add(avgParentsLength);
          rows["Parent lengths (good)"].Values.Add(avgGoodParentsLength);
          double avgOffspringLength = offspring.Count > 0 ? offspring.Average(o => o.Length) : 0;
          double avgGoodOffspringLength = selectedOffspring.Count > 0 ? selectedOffspring.Average(o => o.Length) : 0;
          rows["Offspring lengths (good)"].Values.Add(avgOffspringLength);
          rows["Offspring lengths (all)"].Values.Add(avgGoodOffspringLength);
          double avgFragmentLength = fragments.Count > 0 ? fragments.Average(f => f.Length) : 0;
          double avgGoodFragmentLength = selectedOffspringFragments.Count > 0 ? fragments.Average(f => f.Length) : 0;
          rows["Fragment lengths (good)"].Values.Add(avgGoodFragmentLength);
          rows["Fragment lengths (all)"].Values.Add(avgFragmentLength);
        }
      }

      return base.Apply();
    }

    protected override void InitializeParameters() {
      var results = ResultsParameter.ActualValue;
      if (!results.ContainsKey("Fragment Lengths")) {
        FragmentLengths = FragmentLengths ?? new DataTable("Fragment Lengths") { VisualProperties = { YAxisTitle = "Fragment length" } };
        results.Add(new Result("Fragment Lengths", FragmentLengths));
      }
      base.InitializeParameters();
    }

    private void InitializeRows() {
      string[] rowNames =
        {
          "Parent lengths (good)", "Parent lengths (all)",
          "Offspring lengths (good)", "Offspring lengths (all)",
          "Fragment lengths (good)", "Fragment lengths (all)"
        };
      foreach (var rowName in rowNames.Where(rowName => !FragmentLengths.Rows.ContainsKey(rowName))) {
        FragmentLengths.Rows.Add(new DataRow(rowName) { VisualProperties = { StartIndexZero = true } });
      }
    }
  } //SymbolicExpressionTreeFragmentLengthAnalyzer
}