source: branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/BestSolutionAnalyzer.cs @ 16053

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2018 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;
using System.Diagnostics;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;

namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration {
  [Item("Best Solution Analyzer", "Returns the characteristics of the best solution so far.")]
  [StorableClass]
  public class BestSolutionAnalyzer : Item, IGrammarEnumerationAnalyzer {
    public static readonly string BestTrainingQualityResultName = "Best R² (Training)";
    public static readonly string BestTestQualityResultName = "Best R² (Test)";
    public static readonly string BestTrainingModelResultName = "Best model (Training)";
    public static readonly string BestTrainingSolutionResultName = "Best solution (Training)";
    public static readonly string BestComplexityResultName = "Best solution complexity";
    public static readonly string BestSolutions = "Best solutions";

    private static readonly ISymbolicDataAnalysisExpressionTreeInterpreter expressionTreeLinearInterpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();

    public BestSolutionAnalyzer() { }

    [StorableConstructor]
    protected BestSolutionAnalyzer(bool deserializing) : base(deserializing) { }

    protected BestSolutionAnalyzer(BestSolutionAnalyzer original, Cloner cloner) : base(original, cloner) {
    }

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

    public void Deregister(GrammarEnumerationAlgorithm algorithm) {
      algorithm.DistinctSentenceGenerated -= AlgorithmDistinctSentenceGenerated;
    }

    public void Register(GrammarEnumerationAlgorithm algorithm) {
      algorithm.DistinctSentenceGenerated += AlgorithmDistinctSentenceGenerated;
    }

    private void AlgorithmDistinctSentenceGenerated(object sender, PhraseAddedEventArgs args) {
      var algorithm = (GrammarEnumerationAlgorithm)sender;
      var sentence = args.NewPhrase;

      var results = algorithm.Results;
      var grammar = algorithm.Grammar;
      var problemData = algorithm.Problem.ProblemData;

      SymbolicExpressionTree tree = algorithm.Grammar.ParseSymbolicExpressionTree(sentence);
      Debug.Assert(SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree));

      double r2 = algorithm.Evaluator.Evaluate(problemData, tree);
      double bestR2 = results.ContainsKey(BestTrainingQualityResultName) ? GetValue<double>(results[BestTrainingQualityResultName].Value) : 0.0;
      if (r2 < bestR2)
        return;

      var bestComplexity = results.ContainsKey(BestComplexityResultName) ? GetValue<int>(results[BestComplexityResultName].Value) : int.MaxValue;
      var complexity = sentence.Complexity;

      if (algorithm.BestTrainingSentence == null || r2 > bestR2 || (r2.IsAlmost(bestR2) && complexity < bestComplexity)) {
        algorithm.BestTrainingSentence = sentence;

        var model = new SymbolicRegressionModel(problemData.TargetVariable, tree, expressionTreeLinearInterpreter);
        model.Scale(problemData);
        var bestSolution = model.CreateRegressionSolution(problemData);

        results.AddOrUpdateResult(BestTrainingQualityResultName, new DoubleValue(bestSolution.TrainingRSquared));
        results.AddOrUpdateResult(BestTestQualityResultName, new DoubleValue(bestSolution.TestRSquared));
        results.AddOrUpdateResult(BestTrainingModelResultName, bestSolution.Model);
        results.AddOrUpdateResult(BestTrainingSolutionResultName, bestSolution);
        results.AddOrUpdateResult(BestComplexityResultName, new IntValue(complexity));

        // record best sentence quality & length
        DataTable dt;
        if (!results.ContainsKey(BestSolutions)) {
          var names = new[] { "Quality", "Length", "Complexity", "Timestamp" };
          dt = new DataTable();
          foreach (var name in names) {
            dt.Rows.Add(new DataRow(name) { VisualProperties = { StartIndexZero = true } });
          }
          results.AddOrUpdateResult(BestSolutions, dt);
        }
        dt = (DataTable)results[BestSolutions].Value;
        dt.Rows["Quality"].Values.Add(r2);
        dt.Rows["Length"].Values.Add((double)sentence.Count);
        dt.Rows["Complexity"].Values.Add(complexity);
        dt.Rows["Timestamp"].Values.Add(algorithm.ExecutionTime.TotalMilliseconds / 1000d);
      }

      // stop the algorithm if the best quality was already achieved
      if (r2.IsAlmost(1d)) {
        algorithm.Stop();
      }
    }

    private T GetValue<T>(IItem value) where T : struct {
      var v = value as ValueTypeValue<T>;
      if (v == null)
        throw new ArgumentException(string.Format("Item is not of type {0}", typeof(ValueTypeValue<T>)));
      return v.Value;
    }
  }
}