source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Analyzers/ReferenceQualityAnalyzer.cs @ 6421

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

namespace HeuristicLab.Problems.MetaOptimization {
  /// <summary>
  /// TODO
  /// </summary>
  [Item("ReferenceQualityAnalyzer", "")]
  [StorableClass]
  public sealed class ReferenceQualityAnalyzer : SingleSuccessorOperator, IAnalyzer {

    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]; }
    }

    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);
    }

    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);
        }
      }
    }
  }
}