source: branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveConstraintAnalyzer.cs @ 17794

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

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [Item("TestAnalyzer",
    "An operator that analyzes the training best symbolic regression solution for multi objective symbolic regression problems.")]
  [StorableType("D802BF87-6137-47D6-BC09-A905BBB3534D")]
  public class SymbolicRegressionMultiObjectiveConstraintAnalyzer :
    SymbolicDataAnalysisMultiObjectiveTrainingBestSolutionAnalyzer<ISymbolicRegressionSolution>,
    ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator {
    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
    private const string EstimationLimitsParameterName                    = "EstimationLimits";
    private const string ProblemDataParameterName                         = "ProblemData";

    private const string SolutionObjectivesName  = "Solution Objectives";
    private const string SolutionConstraintsName = "Solutions & Constraints";

    #region Constructors

    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>
      SymbolicDataAnalysisTreeInterpreterParameter =>
      (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>) Parameters
        [SymbolicDataAnalysisTreeInterpreterParameterName];

    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter =>
      (IValueLookupParameter<DoubleLimit>) Parameters[EstimationLimitsParameterName];

    public IValueLookupParameter<IRegressionProblemData> ProblemDataParameter =>
      (IValueLookupParameter<IRegressionProblemData>) Parameters[ProblemDataParameterName];

    public IResultParameter<DoubleMatrix> SolutionObjectivesParameter =>
      (IResultParameter<DoubleMatrix>) Parameters[SolutionObjectivesName];

    public IResultParameter<ItemList<ISymbolicRegressionSolution>> SolutionConstraintsParameter =>
      (IResultParameter<ItemList<ISymbolicRegressionSolution>>) Parameters[SolutionConstraintsName];

    public SymbolicRegressionMultiObjectiveConstraintAnalyzer() {
      Parameters.Add(new
                       LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName,
                         "The interpreter that should be used to calculate the output values of the symbolic data analysis tree."));
      Parameters.Add(new ValueLookupParameter<IRegressionProblemData>(ProblemDataParameterName,
                                                                      "The problem data on which the symbolic data analysis solution should be evaluated."));
      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName,
                                                           "The upper and lower limit that should be used as cut off value for the output values of symbolic data analysis trees."));
      Parameters.Add(new ResultParameter<DoubleMatrix>(SolutionObjectivesName,
                                                       "Shows the constraints violation for each solution"));
      SolutionObjectivesParameter.DefaultValue = new DoubleMatrix();
      Parameters.Add(new ResultParameter<ItemList<ISymbolicRegressionSolution>>(SolutionConstraintsName,
                                                                                "Holds the symbolic regression solutions"));
      SolutionConstraintsParameter.DefaultValue = new ItemList<ISymbolicRegressionSolution>();
    }

    [StorableConstructor]
    protected SymbolicRegressionMultiObjectiveConstraintAnalyzer(StorableConstructorFlag _) : base(_) { }

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

    #endregion

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

    public override IOperation Apply() {
      var results     = ResultCollection;
      var dataset     = ProblemDataParameter.ActualValue.Dataset;
      var trees       = SymbolicExpressionTreeParameter.ActualValue;
      var qualities   = QualitiesParameter.ActualValue;
      var constraints = ProblemDataParameter.ActualValue.IntervalConstraints.Constraints;

      if (!(qualities.First().Length < constraints.Count())) {
        //DoubleMatrix
        var dm = new DoubleMatrix(trees.Length, qualities[0].Length);
        for (var i = 0; i < qualities.Length; ++i) {
          for (var j = 0; j < qualities[i].Length; ++j) dm[i, j] = qualities[i][j];
        }

        dm.RowNames                             = GetRowNames(dm);
        dm.ColumnNames                          = GetColumnNames(constraints);
        SolutionObjectivesParameter.ActualValue = dm;
      }

      //SolutionsList
      var treeQualities = new[] {new {Tree = default(ISymbolicExpressionTree), Qualities = default(double[])}}.ToList();
      treeQualities.Clear();

      var q = qualities.Select(x => x.ToArray()).ToList();
      for (var i = 0; i < trees.Length; ++i) treeQualities.Add(new {Tree = trees[i], Qualities = q[i]});


      var count  = 0;
      var resSol = new ItemList<ISymbolicRegressionSolution>();
      foreach (var tq in treeQualities) {
        var model = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable,
                                                (ISymbolicExpressionTree) tq.Tree.Clone(),
                                                SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
                                                EstimationLimitsParameter.ActualValue.Lower,
                                                EstimationLimitsParameter.ActualValue.Upper);
        var sol =
          new SymbolicRegressionSolution(model, (IRegressionProblemData) ProblemDataParameter.ActualValue.Clone());
        //var sol = CreateSolution(tq.Tree, tq.Qualities);
        sol.Name = string.Join(", ", "Solution" + count, tq.Qualities[0], tq.Qualities.Skip(1).Count(x => x > 0));
        resSol.Add(sol);
        count++;
      }

      SolutionConstraintsParameter.ActualValue = resSol;
      return base.Apply();
    }

    protected override ISymbolicRegressionSolution CreateSolution(ISymbolicExpressionTree bestTree,
                                                                  double[] bestQuality) {
      var model = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable,
                                              (ISymbolicExpressionTree) bestTree.Clone(),
                                              SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
                                              EstimationLimitsParameter.ActualValue.Lower,
                                              EstimationLimitsParameter.ActualValue.Upper);
      if (ApplyLinearScalingParameter.ActualValue.Value) model.Scale(ProblemDataParameter.ActualValue);
      return new SymbolicRegressionSolution(model, (IRegressionProblemData) ProblemDataParameter.ActualValue.Clone());
    }

    private static IEnumerable<string> GetColumnNames(IEnumerable<IntervalConstraint> constraints) {
      yield return "NMSE";
      foreach (var constraint in constraints) {
        if(constraint.Enabled)
          yield return constraint.Expression;
      }
        
    }

    private static IEnumerable<string> GetRowNames(DoubleMatrix dm) {
      for (var i = 0; i < dm.Rows; ++i) yield return "Solution " + i;
    }
  }
}