source: branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Analysis/RSquaredEvaluator.cs @ 15982

using System;
using System.Diagnostics;
using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;

namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration {
  [Item("RSquaredEvaluator", "")]
  [StorableClass]
  public class RSquaredEvaluator : 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";

    private static readonly ISymbolicDataAnalysisExpressionTreeInterpreter expressionTreeLinearInterpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();

    public bool OptimizeConstants { get; set; }

    public RSquaredEvaluator() { }

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

    protected RSquaredEvaluator(RSquaredEvaluator original, Cloner cloner) : base(original, cloner) {
      this.OptimizeConstants = original.OptimizeConstants;
    }

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

    public void Register(GrammarEnumerationAlgorithm algorithm) {
      algorithm.Started += OnStarted;
      algorithm.Stopped += OnStopped;
      algorithm.DistinctSentenceGenerated += AlgorithmOnDistinctSentenceGenerated;
    }

    public void Deregister(GrammarEnumerationAlgorithm algorithm) {
      algorithm.Started -= OnStarted;
      algorithm.Stopped -= OnStopped;
      algorithm.DistinctSentenceGenerated -= AlgorithmOnDistinctSentenceGenerated;
    }

    private void AlgorithmOnDistinctSentenceGenerated(object sender, PhraseAddedEventArgs phraseAddedEventArgs) {
      GrammarEnumerationAlgorithm algorithm = (GrammarEnumerationAlgorithm)sender;
      EvaluateSentence(algorithm, phraseAddedEventArgs.NewPhrase);
    }

    private void OnStarted(object sender, EventArgs eventArgs) {
      GrammarEnumerationAlgorithm algorithm = (GrammarEnumerationAlgorithm)sender;

      algorithm.BestTrainingSentence = null;
    }

    private void OnStopped(object sender, EventArgs eventArgs) { }

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

    private void EvaluateSentence(GrammarEnumerationAlgorithm algorithm, SymbolString symbolString) {
      var results = algorithm.Results;
      var grammar = algorithm.Grammar;
      var problemData = algorithm.Problem.ProblemData;

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

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

      var bestComplexity = int.MaxValue;
      if (results.ContainsKey(BestComplexityResultName)) {
        bestComplexity = GetValue<int>(results[BestComplexityResultName].Value);
      } else if (algorithm.BestTrainingSentence != null) {
        bestComplexity = grammar.GetComplexity(algorithm.BestTrainingSentence);
        results.AddOrUpdateResult(BestComplexityResultName, new IntValue(bestComplexity));
      }
      var complexity = grammar.GetComplexity(symbolString);

      if (r2 > bestR2 || (r2.IsAlmost(bestR2) && complexity < bestComplexity)) {
        results.AddOrUpdateResult(BestTrainingQualityResultName, new DoubleValue(r2));
        results.AddOrUpdateResult(BestComplexityResultName, new IntValue(complexity));
        algorithm.BestTrainingSentence = symbolString;
      }
    }

    public static double Evaluate(IRegressionProblemData problemData, SymbolicExpressionTree tree, bool optimizeConstants = true) {
      double r2;

      // TODO: Initialize constant values randomly
      // TODO: Restarts
      if (optimizeConstants) {
        r2 = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(expressionTreeLinearInterpreter,
          tree,
          problemData,
          problemData.TrainingIndices,
          applyLinearScaling: false,
          maxIterations: 10,
          updateVariableWeights: false,
          updateConstantsInTree: true);

        foreach (var symbolicExpressionTreeNode in tree.IterateNodesPostfix()) {
          ConstantTreeNode constTreeNode = symbolicExpressionTreeNode as ConstantTreeNode;
          if (constTreeNode != null && constTreeNode.Value.IsAlmost(0.0)) {
            constTreeNode.Value = 0.0;
          }
        }
      } else {
        r2 = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(expressionTreeLinearInterpreter,
          tree,
          double.MinValue,
          double.MaxValue,
          problemData,
          problemData.TrainingIndices,
          applyLinearScaling: true);
      }
      return double.IsNaN(r2) ? 0.0 : r2;
    }
  }
}