source: branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSplittingAnalyzer.cs @ 18063

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using HEAL.Attic;
using HeuristicLab.Analysis;
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 {
    [StorableType("7CAE2D30-EDEC-44B6-B772-A2E63E64288F")]
    public class SymbolicRegressionSplittingAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer {
      private const string ProblemDataParameterName = "ProblemData";
      private const string BetterWithSplittingParameterName = "Tighter bounds after splitting";
      private const string NoSplitAcceptedParameterName = "Accepted without splitting";
      private const string NoSplitDiscardedParameterName = "Dicarded without splitting";
      private const string SplitAcceptedParameterName = "Accepted with splitting";
      private const string SplitDiscardedParameterName = "Discarded with splitting";


      #region parameter properties

      public ILookupParameter<IRegressionProblemData> RegressionProblemDataParameter =>
        (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName];

      public IResultParameter<IntValue> BetterWithSplittingParameter =>
        (IResultParameter<IntValue>) Parameters[BetterWithSplittingParameterName];

      public IResultParameter<IntValue> NoSplitAcceptedParameter =>
        (IResultParameter<IntValue>) Parameters[NoSplitAcceptedParameterName];

      public IResultParameter<IntValue> NoSplitDiscardedParameter =>
        (IResultParameter<IntValue>)Parameters[NoSplitDiscardedParameterName];

      public IResultParameter<IntValue> SplitAcceptedParameter =>
        (IResultParameter<IntValue>)Parameters[SplitAcceptedParameterName];

        public IResultParameter<IntValue> SplitDiscardedParameter =>
          (IResultParameter<IntValue>)Parameters[SplitDiscardedParameterName];



      #endregion
      public override bool EnabledByDefault => false;
      public static int Iterations { get; set; } = 0;

      public static int BetterWithSplitting { get; set; } = 0;

      public static int AccpetedWithoutSplitting { get; set; } = 0;
      public static int DiscardedWithoutSplitting { get; set; } = 0;
      public static int AccptedWithSplitting { get; set; } = 0;
      public static int DiscardedWithSplitting { get; set; } = 0;

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

      private SymbolicRegressionSplittingAnalyzer(SymbolicRegressionSplittingAnalyzer original, Cloner cloner) : base(original, cloner) { }

      public SymbolicRegressionSplittingAnalyzer() {
        Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName,
          "The problem data of the symbolic data analysis problem."));

        if (!Parameters.ContainsKey(BetterWithSplittingParameterName)) {
          Parameters.Add(new ResultParameter<IntValue>(BetterWithSplittingParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);

        if (!Parameters.ContainsKey(NoSplitAcceptedParameterName)) {
          Parameters.Add(new ResultParameter<IntValue>(NoSplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        NoSplitAcceptedParameter.DefaultValue = new IntValue(BetterWithSplitting);

        if (!Parameters.ContainsKey(NoSplitDiscardedParameterName)) {
          Parameters.Add(new ResultParameter<IntValue>(NoSplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);

        if (!Parameters.ContainsKey(SplitAcceptedParameterName)) {
          Parameters.Add(new ResultParameter<IntValue>(SplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);

        if (!Parameters.ContainsKey(SplitDiscardedParameterName)) {
          Parameters.Add(new ResultParameter<IntValue>(SplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);
        }



      [StorableHook(HookType.AfterDeserialization)]
      private void AfterDeserialization() {
        if (!Parameters.ContainsKey(BetterWithSplittingParameterName)) {
          Parameters.Add(new ResultParameter<IntValue>(BetterWithSplittingParameterName, "Shows the number constraints which gets accepted after splitting"));
        }

        BetterWithSplittingParameter.DefaultValue = new IntValue(BetterWithSplitting);

        if (!Parameters.ContainsKey(NoSplitAcceptedParameterName))
        {
          Parameters.Add(new ResultParameter<IntValue>(NoSplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        NoSplitAcceptedParameter.DefaultValue = new IntValue(AccpetedWithoutSplitting);

        if (!Parameters.ContainsKey(NoSplitDiscardedParameterName))
        {
          Parameters.Add(new ResultParameter<IntValue>(NoSplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        NoSplitDiscardedParameter.DefaultValue = new IntValue(DiscardedWithoutSplitting);

        if (!Parameters.ContainsKey(SplitAcceptedParameterName))
        {
          Parameters.Add(new ResultParameter<IntValue>(SplitAcceptedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        SplitAcceptedParameter.DefaultValue = new IntValue(AccptedWithSplitting);

        if (!Parameters.ContainsKey(SplitDiscardedParameterName))
        {
          Parameters.Add(new ResultParameter<IntValue>(SplitDiscardedParameterName, "Shows the number constraints which gets accepted after splitting"));
        }
        SplitDiscardedParameter.DefaultValue = new IntValue(DiscardedWithSplitting);
        }

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

      public override void InitializeState() {
        Iterations = 0;
        BetterWithSplitting = 0;
        AccptedWithSplitting = 0;
        AccpetedWithoutSplitting = 0;
        DiscardedWithSplitting = 0;
        DiscardedWithoutSplitting = 0;
        base.InitializeState();
      }

      public override void ClearState() {
        Iterations = 0;
        BetterWithSplitting = 0;
        AccptedWithSplitting = 0;
        AccpetedWithoutSplitting = 0;
        DiscardedWithSplitting = 0;
        DiscardedWithoutSplitting = 0;
        base.ClearState();
      }

      public override IOperation Apply() {
        var problemData = RegressionProblemDataParameter.ActualValue;
        var trees = SymbolicExpressionTreeParameter.ActualValue;
        var constraints = problemData.IntervalConstraints.EnabledConstraints;
        var intervalCollection = problemData.VariableRanges;
        var estimator = new IABoundsEstimator();
        var splittingEstimator = new IABoundsEstimator {UseIntervalSplitting = true, SplittingIterations = 12};

        foreach (var solution in trees) {
          var noSplitting = IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution);
          var splitting = IntervalUtil.IntervalConstraintsViolation(constraints, splittingEstimator, intervalCollection, solution);

          if (noSplitting.Any(x => x != 0)) DiscardedWithoutSplitting++;
          if (noSplitting.All(x => x == 0)) AccpetedWithoutSplitting++;

          if (splitting.Any(x => x != 0))
            DiscardedWithSplitting++;
          else {
            AccptedWithSplitting++;
          }

          for (var i = 0; i < noSplitting.Count(); ++i) {
            if (splitting.ToArray()[i] < noSplitting.ToArray()[i]) {
              BetterWithSplitting++;
            }
            /*if (splitting.ToArray()[i] < noSplitting.ToArray()[i]) {
              BetterWithSplitting++;
            } else if (splitting.ToArray()[i] > noSplitting.ToArray()[i] && !splitting.ToArray()[i].IsAlmost(noSplitting.ToArray()[i])) {
              WorseWithSplitting++;
              noSplitting = IntervalUtil.IntervalConstraintsViolation(constraints, estimator, intervalCollection, solution);
              splitting = IntervalUtil.IntervalConstraintsViolation(constraints, splittingEstimator, intervalCollection, solution);
            }*/
          }
        }

        BetterWithSplittingParameter.ActualValue.Value = BetterWithSplitting;
        NoSplitAcceptedParameter.ActualValue.Value = AccpetedWithoutSplitting;
        NoSplitDiscardedParameter.ActualValue.Value = DiscardedWithoutSplitting;
        SplitAcceptedParameter.ActualValue.Value = AccptedWithSplitting;
        SplitDiscardedParameter.ActualValue.Value = DiscardedWithSplitting;
        return base.Apply();
      }
    }
}