source: branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/ModelClustersFrequencyAnalyzer.cs @ 17002

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2019 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 HEAL.Attic;
using HeuristicLab.Algorithms.EvolvmentModelsOfModels;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using System;
using System.Collections.Generic;
using System.Linq;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  /// <summary>
  /// Calculates the accumulated frequencies of variable-symbols over all trees in the population.
  /// </summary>
  [Item("SymbolicDataAnalysisModelClustersFrequencyAnalyzer", "Calculates the accumulated frequencies of Model Clusters over all trees in the population.")]
  [StorableType("4755115D-1B73-4577-BA2A-A762AE4C3B2F")]
  public sealed class ModelClustersFrequencyAnalyzer : SymbolicDataAnalysisAnalyzer {
    private const string ModelClustersFrequencyParameterName = "ModelClustersFrequency";
    private const string AggregateModelClustersParameterName = "AggregateModelClusters";

    #region parameter properties
    private const string MapParameterName = "Map";
    public ILookupParameter<DataTable> ModelClustersFrequencyParameter {
      get { return (ILookupParameter<DataTable>)Parameters[ModelClustersFrequencyParameterName]; }
    }
    public IValueLookupParameter<BoolValue> AggregateModelClustersParameter {
      get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateModelClustersParameterName]; }
    }
    public ILookupParameter<EMMMapBase<ISymbolicExpressionTree>> MapParameter {
      get { return (ILookupParameter<EMMMapBase<ISymbolicExpressionTree>>)Parameters[MapParameterName]; }
    }

    #endregion
    #region properties
    public BoolValue AggregateModelClusters {
      get { return AggregateModelClustersParameter.ActualValue; }
      set { AggregateModelClustersParameter.Value = value; }
    }
    public DataTable ModelClustersFrequency {
      get { return ModelClustersFrequencyParameter.ActualValue; }
      set { ModelClustersFrequencyParameter.ActualValue = value; }
    }
    #endregion
    [StorableConstructor]
    private ModelClustersFrequencyAnalyzer(StorableConstructorFlag _) : base(_) { }
    private ModelClustersFrequencyAnalyzer(ModelClustersFrequencyAnalyzer original, Cloner cloner)
      : base(original, cloner) {
    }
    public ModelClustersFrequencyAnalyzer()
      : base() {
      Parameters.Add(new LookupParameter<DataTable>(ModelClustersFrequencyParameterName, "The relative Model Clusters reference frequencies aggregated over all trees in the population."));
      Parameters.Add(new ValueLookupParameter<BoolValue>(AggregateModelClustersParameterName, "Switch that determines whether all references to factor Model Clusters should be aggregated regardless of the value. Turn off to analyze all factor variable references with different values separately.", new BoolValue(true)));
      Parameters.Add(new LookupParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName));
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      // BackwardsCompatibility3.3
      #region Backwards compatible code, remove with 3.4
      if (!Parameters.ContainsKey(AggregateModelClustersParameterName)) {
        Parameters.Add(new ValueLookupParameter<BoolValue>(AggregateModelClustersParameterName, "Switch that determines whether all references to factor Model Clusters should be aggregated regardless of the value. Turn off to analyze all factor Model Clusters references with different values separately.", new BoolValue(true)));
      }
      #endregion
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new ModelClustersFrequencyAnalyzer(this, cloner);
    }

    public override IOperation Apply() {
      ItemArray<ISymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
      ResultCollection results = ResultCollection;
      DataTable datatable;
      if (ModelClustersFrequencyParameter.ActualValue == null) {
        datatable = new DataTable("ModelClusters frequencies", "Relative frequency of ModelClusters references aggregated over the whole population.");
        datatable.VisualProperties.XAxisTitle = "Generation";
        datatable.VisualProperties.YAxisTitle = "Relative ModelClusters Frequency";
        ModelClustersFrequencyParameter.ActualValue = datatable;
        results.Add(new Result("ModelClusters frequencies", "Relative frequency of ModelClusters references aggregated over the whole population.", datatable));
      }

      datatable = ModelClustersFrequencyParameter.ActualValue;
      // all rows must have the same number of values so we can just take the first
      int numberOfValues = datatable.Rows.Select(r => r.Values.Count).DefaultIfEmpty().First();

      foreach (var pair in CalculateModelClustersFrequency(expressions, MapParameter.ActualValue)) {
        if (!datatable.Rows.ContainsKey(pair.Key)) {
          // initialize a new row for the variable and pad with zeros
          DataRow row = new DataRow(pair.Key, "", Enumerable.Repeat(0.0, numberOfValues));
          row.VisualProperties.StartIndexZero = true;
          datatable.Rows.Add(row);
        }
        datatable.Rows[pair.Key].Values.Add(Math.Round(pair.Value, 3));
      }

      // add a zero for each data row that was not modified in the previous loop 
      foreach (var row in datatable.Rows.Where(r => r.Values.Count != numberOfValues + 1))
        row.Values.Add(0.0);

      return base.Apply();
    }

    public static IEnumerable<KeyValuePair<string, double>> CalculateModelClustersFrequency(IEnumerable<ISymbolicExpressionTree> trees, EMMMapBase<ISymbolicExpressionTree> map) {
      var modelClustersFrequency = trees
          .SelectMany(t => GetModelClustersReferences(t, map))
          .GroupBy(pair => pair.Key, pair => pair.Value)
          .ToDictionary(g => g.Key, g => g.Sum());

      double totalNumberOfSymbols = modelClustersFrequency.Values.Sum();

      foreach (var pair in modelClustersFrequency.OrderBy(p => p.Key, new NaturalStringComparer()))
        yield return new KeyValuePair<string, double>(pair.Key, pair.Value / totalNumberOfSymbols);
    }

    private static IEnumerable<KeyValuePair<string, double>> GetModelClustersReferences(ISymbolicExpressionTree tree, EMMMapBase<ISymbolicExpressionTree> map) {
      Dictionary<string, double> references = new Dictionary<string, double>();
      if (map is EMMIslandMap island) {
        foreach (var treeNode in tree.IterateNodesPrefix().OfType<TreeModelTreeNode>()) {
          string referenceId = "no";

          referenceId = "Cluster " + island.ClusterNumber[treeNode.TreeNumber];
          if (references.ContainsKey(referenceId)) {
            int a = (int)references[referenceId];
            a++;
            references[referenceId] = a;
          } else {
            references[referenceId] = 1;
          }
        }
      } else {
        if (map is EMMSucsessMap sMap) {
          for (int i = 0; i < map.ModelSet.Count; i++) {
            string referenceId = "Tree Probability" + i;
            references[referenceId] = sMap.Probabilities[i];
          }
        } else {
          string referenceId = "no";
          references[referenceId] = 0;
        }
      }
      return references;
    }
  }
}