source: branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGAEvaluator.cs @ 9077

#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.SymbolicExpressionTreeEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Random;

namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
  [StorableClass]
  public sealed class SymbolicDataAnalysisIslandGAEvaluator<T> : SingleSuccessorOperator, IStochasticOperator, ISymbolicDataAnalysisIslandGAEvaluator
    where T : class,IDataAnalysisProblemData {
    private const string RandomParameterName = "Random";
    private const string ProblemDataParameterName = "ProblemData";
    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
    private const string EvaluatorParameterName = "ProblemEvaluator";
    private const string QualityParameterName = "Quality";
    private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
    private const string FixedSamplesPartitionParameterName = "FixedSamplesPartition";
    private const string FixedSamplesParameterName = "FixedSamples";
    private const string FixedSamplesFitnessWeightParameterName = "FixedSamplesFitnessWeight";
    private const string RandomSamplesParameterName = "RandomSamples";
    private const string RandomSamplesFitnessWeightParameterName = "RandomSamplesFitnessWeight";

    #region parameter properties
    public ILookupParameter<IRandom> RandomParameter {
      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
    }
    public ILookupParameter<T> ProblemDataParameter {
      get { return (ILookupParameter<T>)Parameters[ProblemDataParameterName]; }
    }
    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
    }
    public ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>> EvaluatorParameter {
      get { return (ILookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>)Parameters[EvaluatorParameterName]; }
    }
    public ILookupParameter<DoubleValue> QualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
    }
    public IValueLookupParameter<IntRange> FitnessCalculationPartitionParameter {
      get { return (IValueLookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
    }
    public ILookupParameter<IntRange> FixedSamplesPartitionParameter {
      get { return (ILookupParameter<IntRange>)Parameters[FixedSamplesPartitionParameterName]; }
    }
    public ILookupParameter<IntValue> FixedSamplesParameter {
      get { return (ILookupParameter<IntValue>)Parameters[FixedSamplesParameterName]; }
    }
    public IFixedValueParameter<DoubleValue> FixedSamplesFitnessWeightParameter {
      get { return (IFixedValueParameter<DoubleValue>)Parameters[FixedSamplesFitnessWeightParameterName]; }
    }
    public ILookupParameter<IntValue> RandomSamplesParameter {
      get { return (ILookupParameter<IntValue>)Parameters[RandomSamplesParameterName]; }
    }
    public IFixedValueParameter<DoubleValue> RandomSamplesFitnessWeightParameter {
      get { return (IFixedValueParameter<DoubleValue>)Parameters[RandomSamplesFitnessWeightParameterName]; }
    }
    #endregion

    #region properties
    public double FixedSamplesFitnessWeight {
      get { return FixedSamplesFitnessWeightParameter.Value.Value; }
      set { FixedSamplesFitnessWeightParameter.Value.Value = value; }
    }
    public double RandomSamplesFitnessWeight {
      get { return RandomSamplesFitnessWeightParameter.Value.Value; }
      set { RandomSamplesFitnessWeightParameter.Value.Value = value; }
    }
    #endregion

    [StorableConstructor]
    private SymbolicDataAnalysisIslandGAEvaluator(bool deserializing) : base(deserializing) { }
    private SymbolicDataAnalysisIslandGAEvaluator(SymbolicDataAnalysisIslandGAEvaluator<T> original, Cloner cloner)
      : base(original, cloner) {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicDataAnalysisIslandGAEvaluator<T>(this, cloner);
    }

    public SymbolicDataAnalysisIslandGAEvaluator()
      : base() {
      Parameters.Add(new LookupParameter<IRandom>(RandomParameterName, "The random generator to use."));
      Parameters.Add(new LookupParameter<T>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic data analysis solution encoded as a symbolic expression tree."));
      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisSingleObjectiveEvaluator<T>>(EvaluatorParameterName, "The evaluator provided by the symbolic data analysis  problem."));
      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The quality which is calculated by the encapsulated evaluator."));
      Parameters.Add(new ValueLookupParameter<IntRange>(FitnessCalculationPartitionParameterName, "The data partition used to calculate the fitness"));
      Parameters.Add(new LookupParameter<IntRange>(FixedSamplesPartitionParameterName, "The data partition which is used to calculate the fitness on the fixed samples."));
      Parameters.Add(new LookupParameter<IntValue>(FixedSamplesParameterName, "The number of fixed samples used for fitness calculation in each island."));
      Parameters.Add(new FixedValueParameter<DoubleValue>(FixedSamplesFitnessWeightParameterName, "The weight of the fitness obtained on the fixed samples.", new DoubleValue(1)));
      Parameters.Add(new LookupParameter<IntValue>(RandomSamplesParameterName, "The number of random samples used for fitness calculation in each island."));
      Parameters.Add(new FixedValueParameter<DoubleValue>(RandomSamplesFitnessWeightParameterName, "The weight of the fitness obtained on the random samples.", new DoubleValue(1)));

      EvaluatorParameter.Hidden = true;
    }

    public override IOperation Apply() {
      var evaluator = EvaluatorParameter.ActualValue;
      //calculate fitness on fixed samples
      if (QualityParameter.ActualValue == null) {
        var operation = ExecutionContext.CreateOperation(evaluator, ExecutionContext.Scope);
        return new OperationCollection() { operation, ExecutionContext.CreateOperation(this) };
      }
      //calculate fitness on random samples;
      var samplesStart = FitnessCalculationPartitionParameter.ActualValue.Start;
      var samplesEnd = FitnessCalculationPartitionParameter.ActualValue.End;
      var fixedSamplesStart = FixedSamplesPartitionParameter.ActualValue.Start;
      var fixedSamplesEnd = FixedSamplesPartitionParameter.ActualValue.End;
      var randomSamples = RandomSamplesParameter.ActualValue.Value;
      var maxRandomSamples = samplesEnd - samplesStart - fixedSamplesEnd + fixedSamplesStart;

      var rows = Enumerable.Range(samplesStart, samplesEnd - samplesStart).Where(r => r < fixedSamplesStart || r >= fixedSamplesEnd);
      rows = rows.SampleRandomWithoutRepetition(RandomParameter.ActualValue, randomSamples, maxRandomSamples);

      var fixedSamplesFitness = QualityParameter.ActualValue.Value;
      var tree = SymbolicExpressionTreeParameter.ActualValue;
      var problemData = ProblemDataParameter.ActualValue;

      var executionContext = new ExecutionContext(ExecutionContext, evaluator, ExecutionContext.Scope);
      var randomSamplesFitness = evaluator.Evaluate(executionContext, tree, problemData, rows);
      QualityParameter.ActualValue.Value = fixedSamplesFitness * FixedSamplesFitnessWeight + randomSamplesFitness * RandomSamplesFitnessWeight;
      return base.Apply();
    }
  }
}