source: branches/3133_ProblemModifiers/HeuristicLab.Problems.Modifiers/Modifier/InModelSingularEvaluationRemovalStrategy.cs

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2018 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 HEAL.Attic;
using HeuristicLab.Algorithms.DataAnalysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Problems.Modifiers {
  [StorableType("888EE1F9-F142-40F4-B5DC-D541184F8A9D")]
  [Item("InModelSingularEvaluationRemovalStrategy", "A modifier attached to a problem")]
  public class InModelSingularEvaluationRemovalStrategy : ModelBasedEvaluationRemoverProblemModifier {

    public const string SurvivalProbabilityParameterName = "SurvivalProbability";
    public const string ModelBuilderParameterName = "ModelBuilder";
    public const string InModelComparisonParameterName = "InModelComparison";
    public IFixedValueParameter<PercentValue> SurvivalProbabilityParameter => (IFixedValueParameter<PercentValue>)Parameters[SurvivalProbabilityParameterName];
    public IValueParameter<IAlgorithm> ModelBuilderParameter => (IValueParameter<IAlgorithm>)Parameters[ModelBuilderParameterName];
    public IFixedValueParameter<BoolValue> InModelComparisonParameter => (IFixedValueParameter<BoolValue>)Parameters[InModelComparisonParameterName];
    public double SurvivalProbability => SurvivalProbabilityParameter.Value.Value;
    public IAlgorithm ModelBuilder => ModelBuilderParameter.Value;
    public bool InModelComparison => InModelComparisonParameter.Value.Value;

    [StorableConstructor]
    protected InModelSingularEvaluationRemovalStrategy(StorableConstructorFlag _) : base(_) { }
    protected InModelSingularEvaluationRemovalStrategy(InModelSingularEvaluationRemovalStrategy original, Cloner cloner) : base(original, cloner) { }

    public InModelSingularEvaluationRemovalStrategy() : base() {
      Parameters.Add(new FixedValueParameter<PercentValue>(
        SurvivalProbabilityParameterName,
        "Probability of survival despite bad prediction values",
        new PercentValue(0.05)));
      Parameters.Add(new ValueParameter<IAlgorithm>(ModelBuilderParameterName, "The model builder", new LinearRegression()));
      Parameters.Add(new FixedValueParameter<BoolValue>(InModelComparisonParameterName, "Whether the actual qualities (false) or the predicted qualities (values) will be used to determine removal. This is relevant if the model has a strong offset to the actual values", new BoolValue(false)));
    }

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

    protected override IRegressionSolution BuildRunningModel(RegressionProblemData pd, IRandom random, int objectiveNumber) {
      if (pd.TrainingPartition.Size <= 0) return null;
      try {
        ModelBuilder.Problem = new RegressionProblem() { ProblemData = pd };
        if (ModelBuilder.Parameters.ContainsKey("Seed") && (ModelBuilder.Parameters["Seed"] is IValueParameter<IntValue> seedparam)) {
          seedparam.Value.Value = random.Next();
          if (ModelBuilder.Parameters.ContainsKey("SetSeedRandomly") && (ModelBuilder.Parameters["SetSeedRandomly"] is IValueParameter<BoolValue> setseedparam)) {
            setseedparam.Value.Value = false;
          }
        }
        ModelBuilder.Start();
        var res = ModelBuilder.Results.Select(x => x.Value).OfType<IRegressionSolution>().Single();
        ModelBuilder.Prepare();
        ModelBuilder.Runs.Clear();
        return res;
      } catch (Exception) {
        return null;
      }
    }


    protected override bool RemoveEvaluation(Individual individual, bool[] maximization, IRandom random) {
      if (random.NextDouble() < SurvivalProbability) return false;
      if (solutions == null || solutions.Count != maximization.Length || solutions.Any(s => s == null)) return false;
      var q = solutions.Select(x => x.Model.GetEstimatedValues(ToDataset(ExtractInputs(individual)), new[] { 0 }).Single()).ToArray();
      return lastPopulation.Any(x => DominationCalculator<double[]>.Dominates(InModelComparison ? x.Item3 : x.Item2, q, maximization, false) == DominationResult.Dominates);
    }

  }
}