source: branches/3076_IA_evaluators_analyzers/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionConstraintAnalyzer.cs @ 17733

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

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [StorableType("4318C6BD-E0A1-45FE-AC30-96E7F73B51FB")]
  public class SymbolicRegressionConstraintAnalyzer : SymbolicDataAnalysisAnalyzer, ISymbolicExpressionTreeAnalyzer {
    private const string ConstraintViolationsResultName   = "Constraint Violations";
    private const string ProblemDataParameterName         = "ProblemData";
    private const string ConstraintViolationParameterName = "ConstraintViolations";
    private const string PenalityMultiplierParameterName = "ConstraintsPenalityMultiplier";

    #region parameter properties

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

    public IResultParameter<DataTable> ConstraintViolationParameter =>
      (IResultParameter<DataTable>) Parameters[ConstraintViolationParameterName];

    public ILookupParameter<DoubleValue> PenalityMultiplierParameter =>
      (ILookupParameter<DoubleValue>)Parameters[PenalityMultiplierParameterName];

    #endregion

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

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

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

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

    public SymbolicRegressionConstraintAnalyzer() {
      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName,
        "The problem data of the symbolic data analysis problem."));
      Parameters.Add(new ResultParameter<DataTable>(ConstraintViolationParameterName,
        "Shows the number of constraint violations!"));
      Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));

      ConstraintViolationParameter.DefaultValue = new DataTable(ConstraintViolationParameterName) {
        VisualProperties = 
          {
            XAxisTitle = "Generations",
            YAxisTitle = "Constraint Violations"
          }
      };
    }

    public override void InitializeState()
    {
      Iterations = 0;
      base.InitializeState();
    }

    public override void ClearState()
    {
      Iterations = 0;
      base.ClearState();
    }


    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey(PenalityMultiplierParameterName))
        Parameters.Add(new LookupParameter<DoubleValue>(PenalityMultiplierParameterName,
        "Lookup parameter for the penality multiplier.", "PenalityMultiplier"));
    }

    public override IOperation Apply()
    {
      Iterations++;

      PenalityMultiplierParameter.ActualValue = new DoubleValue(QuadraticDiscreteDoubleValueModifier.Calculate(0, 0.05, 1.0, Iterations, 0, 2000));
      //GeneralizedExponentialDiscreteDoubleValueModifier

      var problemData = RegressionProblemDataParameter.ActualValue;
      var trees       = SymbolicExpressionTreeParameter.ActualValue;

      var results        = ResultCollectionParameter.ActualValue;
      var constraints    = problemData.IntervalConstraints.EnabledConstraints;
      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
      var newDataTable   = ConstraintViolationParameter.ActualValue;

      if (newDataTable.Rows.Count == 0)
        foreach (var constraint in constraints)
          newDataTable.Rows.Add(new DataRow(constraint.Expression));

      var interpreter = new IntervalInterpreter();
      foreach (var constraint in constraints) {
        var violations = trees.Select(tree => ConstraintSatisfied(constraint, interpreter, variableRanges, tree, out double error))
                              .Count(satisfied => !satisfied);
        newDataTable.Rows[constraint.Expression].Values.Add(violations);
      }

      return base.Apply();
    }

    public static bool ConstraintSatisfied(IntervalConstraint constraint,
                                           IntervalInterpreter intervalInterpreter,
                                           IReadOnlyDictionary<string, Interval> variableRanges,
                                           ISymbolicExpressionTree solution,
                                           out double error) {
      if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable))
        throw new
          ArgumentException($"The given variable {constraint.Variable} in the constraint does not exists in the model.",
                            nameof(IntervalConstraintsParser));

      Interval resultInterval;

      // create new variable ranges for defined regions
      IDictionary<string, Interval> regionRanges = new Dictionary<string, Interval>();
      foreach (var kvp in variableRanges)
      {
        if (kvp.Key != constraint.Target && constraint.Regions.TryGetValue(kvp.Key, out Interval val))
        {
          regionRanges.Add(kvp.Key, val);
        }
        else
        {
          regionRanges.Add(kvp);
        }
      }

      // calculate result interval
      if (!constraint.IsDerivative) {
        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(solution, new ReadOnlyDictionary<string, Interval>(regionRanges));
      }
      else {
        var tree = solution;
        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
          if (!IntervalInterpreter.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree))
            throw new ArgumentException("Cube, Root, Power Symbols are not supported.");
          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
        }

        resultInterval = intervalInterpreter.GetSymbolicExpressionTreeInterval(tree, new ReadOnlyDictionary<string, Interval>(regionRanges));
      }

      error = 0.0;
      bool satisfied = true;
      if(!constraint.Interval.Contains(resultInterval.LowerBound))
      {
        satisfied = false;
        error += Math.Abs(resultInterval.LowerBound - constraint.Interval.LowerBound);
      }

      if (!constraint.Interval.Contains(resultInterval.UpperBound))
      {
        satisfied = false;
        error += Math.Abs(resultInterval.UpperBound - constraint.Interval.UpperBound);
      }

      error *= constraint.Weight;

      //var satisfied = constraint.Interval.Contains(resultInterval);
      return satisfied;
    }

    public static bool ConstraintsSatisfied(IEnumerable<IntervalConstraint> constraints,
                                            IReadOnlyDictionary<string, Interval> variableRanges,
                                            ISymbolicExpressionTree solution,
                                            out double error) {
      var intervalInterpreter = new IntervalInterpreter();
      error = 0.0;
      var satisfied = true;
      foreach (var constraint in constraints) {
        if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable))
          throw new
            ArgumentException($"The given variable {constraint.Variable} in the constraint does not exists in the model.",
                              nameof(IntervalConstraintsParser));

        satisfied = ConstraintSatisfied(constraint, intervalInterpreter, variableRanges, solution, out double e) && satisfied;
        error += e;
        //if (!satisfied) return false;
      }

      return satisfied;
    }
  }
}