source: branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSingleObjectiveMetaModelAnalyzer.cs @ 17776

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HEAL.Attic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [StorableType("4B69A82A-265B-46DA-9055-B6E0EB6C3EC8")]
  public class SymbolicRegressionSingleObjectiveMetaModelAnalyzer 
    : SymbolicRegressionMetaModelAnalyzer<SymbolicRegressionSingleObjectiveProblem>, ISymbolicExpressionTreeAnalyzer {

    #region constants
    private const string BestMetaModelParameterName = "Best Meta Model";
    #endregion

    #region parameter properties
    public IResultParameter<ISymbolicRegressionSolution> BestMetaModelParameter =>
      (IResultParameter<ISymbolicRegressionSolution>)Parameters[BestMetaModelParameterName];
    #endregion

    #region constructors and cloning
    [StorableConstructor]
    protected SymbolicRegressionSingleObjectiveMetaModelAnalyzer(StorableConstructorFlag _) : base(_) { }

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

    public SymbolicRegressionSingleObjectiveMetaModelAnalyzer() {
      Parameters.Add(new ResultParameter<ISymbolicRegressionSolution>(BestMetaModelParameterName,
        "The best meta model found."));
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey(BestMetaModelParameterName))
        Parameters.Add(new ResultParameter<ISymbolicRegressionSolution>(BestMetaModelParameterName,
          "The best meta model found."));
    }

    public override IDeepCloneable Clone(Cloner cloner) => new SymbolicRegressionSingleObjectiveMetaModelAnalyzer(this, cloner);
    #endregion

    protected override void PerformApply(
      SymbolicRegressionSingleObjectiveProblem baseProblem, 
      IEnumerable<SymbolicRegressionSingleObjectiveProblem> problems, 
      string targetVariable) {
      // init
      var solutions = this.SymbolicExpressionTree.ToArray();
      var evaluator = baseProblem.Evaluator;
      var bestQuality = baseProblem.Maximization.Value ? double.MinValue : double.MaxValue;
      SymbolicRegressionSolution bestMetaModel = null;

      // iterate solutions
      foreach (var solution in solutions) {
        double qualityAvg = CalculateAverageQuality(solution, evaluator, problems);

        // check if this solution is the best
        bool isBest = baseProblem.Maximization.Value ? (bestQuality < qualityAvg) : (bestQuality > qualityAvg);
        if (isBest) {
          bestQuality = qualityAvg;
          bestMetaModel = BuildSolution(solution, targetVariable, baseProblem);
        }
      }
      BestMetaModelParameter.ActualValue = bestMetaModel;
    }

    private SymbolicRegressionSolution BuildSolution(
      ISymbolicExpressionTree solution, 
      string targetVariable,
      SymbolicRegressionSingleObjectiveProblem baseProblem) {
      var model = new SymbolicRegressionModel(
            targetVariable,
            (ISymbolicExpressionTree)solution.Clone(),
            new SymbolicDataAnalysisExpressionTreeInterpreter());
      return new SymbolicRegressionSolution(model, baseProblem.ProblemData);
    }

    private double CalculateAverageQuality(
      ISymbolicExpressionTree solution,
      ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData> evaluator, 
      IEnumerable<SymbolicRegressionSingleObjectiveProblem> problems) {
      double qualitySum = 0.0;
      // iterate problems
      foreach (var problem in problems) {
        IDataset dataset = problem.ProblemData.Dataset;
        IEnumerable<int> rows = Enumerable.Range(0, dataset.Rows);
        // evalute problem with the evaluator of the base problem
        qualitySum += evaluator.Evaluate(ExecutionContext, solution, problem.ProblemData, rows);
      }
      // calculate the average quality
      return qualitySum / problems.Count();
    }
  }
}