source: branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Operators/DynamicDepthLimitComparator.cs @ 8119

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Linq;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Common;

namespace HeuristicLab.Problems.DataAnalysis.Operators {
  [Item("DynamicDepthLimitComparator", "As implemented by Ciprian.")]
  [StorableClass]
  public class DynamicDepthLimitComparator : SingleSuccessorOperator, ISubScopesQualityComparator {
    public IValueLookupParameter<BoolValue> MaximizationParameter {
      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
    }
    public ILookupParameter<BoolValue> ResultParameter {
      get { return (ILookupParameter<BoolValue>)Parameters["Result"]; }
    }
    public ILookupParameter<DoubleValue> LeftSideParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["LeftSide"]; }
    }
    public ILookupParameter<ItemArray<DoubleValue>> RightSideParameter {
      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["RightSide"]; }
    }
    public ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
      get { return (ILookupParameter<SymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
    }
    public IValueLookupParameter<IntValue> DynamicDepthLimitParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["DynamicDepthLimit"]; }
    }
    public IValueLookupParameter<IntValue> InitialDepthLimitParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["InitialDepthLimit"]; }
    }
    public IValueParameter<DoubleValue> CLowerParameter {
      get { return (IValueParameter<DoubleValue>)Parameters["cLower"]; }
    }
    public IValueParameter<DoubleValue> CRaiseParameter {
      get { return (IValueParameter<DoubleValue>)Parameters["cRaise"]; }
    }
    public ILookupParameter<DoubleValue> BestQualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["BestQuality"]; }
    }

    [StorableConstructor]
    protected DynamicDepthLimitComparator(bool deserializing) : base(deserializing) { }
    protected DynamicDepthLimitComparator(DynamicDepthLimitComparator original, Cloner cloner)
      : base(original, cloner) {
    }

    public DynamicDepthLimitComparator()
      : base() {
      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, false otherwise"));
      Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison: True means Quality is better, False means it is worse than parents."));
      Parameters.Add(new LookupParameter<DoubleValue>("LeftSide", "The quality of the child."));
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("RightSide", "The qualities of the parents."));
      Parameters.Add(new ValueLookupParameter<IntValue>("DynamicDepthLimit", "The current depth limit."));
      Parameters.Add(new ValueLookupParameter<IntValue>("InitialDepthLimit"));
      Parameters.Add(new LookupParameter<SymbolicExpressionTree>("SymbolicExpressionTree", "The newly created child."));
      Parameters.Add(new LookupParameter<DoubleValue>("BestQuality"));
      Parameters.Add(new ValueParameter<DoubleValue>("cLower", "", new DoubleValue(0.03)));
      Parameters.Add(new ValueParameter<DoubleValue>("cRaise", "", new DoubleValue(0.015)));
    }

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

    public override IOperation Apply() {
      if (ResultParameter.ActualValue == null || ResultParameter.ActualValue.Value) {
        ResultParameter.ActualValue = new BoolValue(true);
        double leftQuality = LeftSideParameter.ActualValue.Value;
        bool maximization = MaximizationParameter.ActualValue.Value;

        SymbolicExpressionTree tree = SymbolicExpressionTreeParameter.ActualValue;
        int ddl = DynamicDepthLimitParameter.ActualValue.Value;
        double cRaise = CRaiseParameter.Value.Value;
        double cLower = CLowerParameter.Value.Value;
        double bestQuality = BestQualityParameter.ActualValue.Value;
        double relativeQuality = maximization ? leftQuality / bestQuality - 1 : bestQuality / leftQuality - 1;
        if (tree.Height <= ddl) {
          // height is smaller than ddl => check improvement and reduce ddl 
          if (relativeQuality >= (ddl - tree.Height) * cLower) {
            ddl = Math.Max(tree.Height, InitialDepthLimitParameter.ActualValue.Value);
          }
        } else {
          // height is larger than dll => check improvement and increase ddl
          if (relativeQuality >= (tree.Height - ddl) * cRaise) {
            ddl = tree.Height;
          } else {
            // height is larger but no improvement => reject
            ResultParameter.ActualValue.Value = false;
          }
        }

        // update best quality
        if (relativeQuality > 0 && ResultParameter.ActualValue.Value)
          BestQualityParameter.ActualValue.Value = leftQuality;

        DynamicDepthLimitParameter.ActualValue.Value = ddl;
      }
      return base.Apply();
    }
  }
}