source: branches/HeuristicLab.MetaOptimization (trunk integration)/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs @ 8746

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.ParameterConfigurationEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.MetaOptimization {
  /// <summary>
  /// TODO
  /// </summary>
  [Item("ReferenceQualityAnalyzer", "TODO")]
  [StorableClass]
  public sealed class ReferenceQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {
    public bool EnabledByDefault {
      get { return true; }
    }

    public ValueLookupParameter<ResultCollection> ResultsParameter {
      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
    }
    public ScopeTreeLookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
      get { return (ScopeTreeLookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
    }
    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
    }
    public LookupParameter<DoubleArray> ReferenceQualityAveragesParameter {
      get { return (LookupParameter<DoubleArray>)Parameters["ReferenceQualityAverages"]; }
    }
    public LookupParameter<DoubleArray> ReferenceQualityDeviationsParameter {
      get { return (LookupParameter<DoubleArray>)Parameters["ReferenceQualityDeviations"]; }
    }
    public LookupParameter<DoubleArray> ReferenceEvaluatedSolutionAveragesParameter {
      get { return (LookupParameter<DoubleArray>)Parameters["ReferenceEvaluatedSolutionAverages"]; }
    }
    public LookupParameter<ConstrainedItemList<IProblem>> ProblemsParameter {
      get { return (LookupParameter<ConstrainedItemList<IProblem>>)Parameters[MetaOptimizationProblem.ProblemsParameterName]; }
    }
    public LookupParameter<BoolValue> MaximizationParameter {
      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
    }
    public LookupParameter<DoubleValue> QualityWeightParameter {
      get { return (LookupParameter<DoubleValue>)Parameters[MetaOptimizationProblem.QualityWeightParameterName]; }
    }
    public LookupParameter<DoubleValue> StandardDeviationWeightParameter {
      get { return (LookupParameter<DoubleValue>)Parameters[MetaOptimizationProblem.StandardDeviationWeightParameterName]; }
    }
    public LookupParameter<DoubleValue> EvaluatedSolutionsWeightParameter {
      get { return (LookupParameter<DoubleValue>)Parameters[MetaOptimizationProblem.EvaluatedSolutionsWeightParameterName]; }
    }

    #region Constructors and Cloning
    public ReferenceQualityAnalyzer()
      : base() {
      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", ""));
      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", ""));
      Parameters.Add(new ScopeTreeLookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
      Parameters.Add(new LookupParameter<DoubleArray>("ReferenceQualityAverages", ""));
      Parameters.Add(new LookupParameter<DoubleArray>("ReferenceQualityDeviations", ""));
      Parameters.Add(new LookupParameter<DoubleArray>("ReferenceEvaluatedSolutionAverages", ""));
      Parameters.Add(new LookupParameter<ConstrainedItemList<IProblem>>(MetaOptimizationProblem.ProblemsParameterName));
      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized."));
      Parameters.Add(new LookupParameter<DoubleValue>(MetaOptimizationProblem.QualityWeightParameterName));
      Parameters.Add(new LookupParameter<DoubleValue>(MetaOptimizationProblem.StandardDeviationWeightParameterName));
      Parameters.Add(new LookupParameter<DoubleValue>(MetaOptimizationProblem.EvaluatedSolutionsWeightParameterName));
    }

    [StorableConstructor]
    private ReferenceQualityAnalyzer(bool deserializing) : base(deserializing) { }
    private ReferenceQualityAnalyzer(ReferenceQualityAnalyzer original, Cloner cloner) : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ReferenceQualityAnalyzer(this, cloner);
    }
    #endregion

    public override IOperation Apply() {
      ResultCollection results = ResultsParameter.ActualValue;
      ItemArray<ParameterConfigurationTree> solutions = ParameterConfigurationParameter.ActualValue;
      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
      bool maximization = MaximizationParameter.ActualValue.Value;
      double qualityWeight = QualityWeightParameter.ActualValue.Value;
      double standardDeviationWeight = StandardDeviationWeightParameter.ActualValue.Value;
      double evaluatedSolutionsWeight = EvaluatedSolutionsWeightParameter.ActualValue.Value;

      if (ReferenceQualityAveragesParameter.ActualValue == null) {
        // this is generation zero. calculate the reference values and apply them on population. in future generations `AlgorithmRunsAnalyzer` will do the nomalization
        DoubleArray referenceQualityAverages = CalculateReferenceQualityAverages(solutions, maximization);
        DoubleArray referenceQualityDeviations = CalculateReferenceQualityDeviations(solutions, maximization);
        DoubleArray referenceEvaluatedSolutionAverages = CalculateReferenceEvaluatedSolutionAverages(solutions, maximization);

        ReferenceQualityAveragesParameter.ActualValue = referenceQualityAverages;
        ReferenceQualityDeviationsParameter.ActualValue = referenceQualityDeviations;
        ReferenceEvaluatedSolutionAveragesParameter.ActualValue = referenceEvaluatedSolutionAverages;

        NormalizePopulation(solutions, qualities, referenceQualityAverages, referenceQualityDeviations, referenceEvaluatedSolutionAverages, qualityWeight, standardDeviationWeight, evaluatedSolutionsWeight, maximization);

        results.Add(new Result("ReferenceQualities", referenceQualityAverages));
        results.Add(new Result("ReferenceQualityDeviations", referenceQualityDeviations));
        results.Add(new Result("ReferenceEvaluatedSolutionAverages", referenceEvaluatedSolutionAverages));
      }

      return base.Apply();
    }

    private DoubleArray CalculateReferenceQualityAverages(ItemArray<ParameterConfigurationTree> solutions, bool maximization) {
      DoubleArray references = new DoubleArray(ProblemsParameter.ActualValue.Count);
      for (int pi = 0; pi < ProblemsParameter.ActualValue.Count; pi++) {
        if (maximization)
          references[pi] = solutions.Where(x => x.AverageQualities != null).Select(x => x.AverageQualities[pi]).Max();
        else
          references[pi] = solutions.Where(x => x.AverageQualities != null).Select(x => x.AverageQualities[pi]).Min();
      }
      return references;
    }

    private DoubleArray CalculateReferenceQualityDeviations(ItemArray<ParameterConfigurationTree> solutions, bool maximization) {
      DoubleArray references = new DoubleArray(ProblemsParameter.ActualValue.Count);
      for (int pi = 0; pi < ProblemsParameter.ActualValue.Count; pi++) {
        if (maximization)
          references[pi] = solutions.Where(x => x.QualityStandardDeviations != null).Select(x => x.QualityStandardDeviations[pi]).Max();
        else
          references[pi] = solutions.Where(x => x.QualityStandardDeviations != null).Select(x => x.QualityStandardDeviations[pi]).Min();
      }
      return references;
    }

    private DoubleArray CalculateReferenceEvaluatedSolutionAverages(ItemArray<ParameterConfigurationTree> solutions, bool maximization) {
      DoubleArray references = new DoubleArray(ProblemsParameter.ActualValue.Count);
      for (int pi = 0; pi < ProblemsParameter.ActualValue.Count; pi++) {
        if (maximization)
          references[pi] = solutions.Where(x => x.AverageEvaluatedSolutions != null).Select(x => x.AverageEvaluatedSolutions[pi]).Max();
        else
          references[pi] = solutions.Where(x => x.AverageEvaluatedSolutions != null).Select(x => x.AverageEvaluatedSolutions[pi]).Min();
      }
      return references;
    }

    private void NormalizePopulation(ItemArray<ParameterConfigurationTree> solutions, ItemArray<DoubleValue> qualities,
          DoubleArray referenceQualityAverages,
          DoubleArray referenceQualityDeviations,
          DoubleArray referenceEvaluatedSolutionAverages,
          double qualityAveragesWeight,
          double qualityDeviationsWeight,
          double evaluatedSolutionsWeight,
          bool maximization) {
      for (int i = 0; i < solutions.Length; i++) {
        if (solutions[i].AverageQualities == null || solutions[i].QualityStandardDeviations == null || solutions[i].AverageEvaluatedSolutions == null) {
          // this parameterConfigurationTree has not been evaluated correctly (due to a faulty configuration, which led to an exception)
          // since we are in generation zero, there is no WorstQuality available for a penalty value
          double penaltyValue = maximization ? double.MinValue : double.MaxValue;
          qualities[i].Value = penaltyValue;
        } else {
          qualities[i].Value = MetaOptimizationUtil.Normalize(solutions[i],
            referenceQualityAverages.ToArray(),
            referenceQualityDeviations.ToArray(),
            referenceEvaluatedSolutionAverages.ToArray(),
            qualityAveragesWeight,
            qualityDeviationsWeight,
            evaluatedSolutionsWeight,
            maximization);
        }
      }
    }
  }
}