source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Evaluators/AlgorithmEvaluator.cs @ 6024

using System;
using System.Diagnostics;
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.Symbolic.Regression;

namespace HeuristicLab.Problems.MetaOptimization {
  [Item("AlgorithmEvaluator", "")]
  [StorableClass]
  public class AlgorithmEvaluator : SingleSuccessorOperator {

    #region Parameter properties
    public ILookupParameter<IRandom> RandomParameter {
      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
    }
    public ILookupParameter<IAlgorithm> AlgorithmParameter {
      get { return (LookupParameter<IAlgorithm>)Parameters["Algorithm"]; }
    }
    public ILookupParameter<IntValue> ProblemIndexParameter {
      get { return (LookupParameter<IntValue>)Parameters["ProblemIndex"]; }
    }
    public ILookupParameter<IntValue> RepetitionIndexParameter {
      get { return (LookupParameter<IntValue>)Parameters["RepetitionIndex"]; }
    }
    public ILookupParameter<ParameterConfigurationTree> ParameterConfigurationParameter {
      get { return (ILookupParameter<ParameterConfigurationTree>)Parameters["ParameterConfigurationTree"]; }
    }
    public IValueParameter<IItemList<IRun>> RunsParameter {
      get { return (IValueParameter<IItemList<IRun>>)Parameters["Runs"]; }
    }
    #endregion

    [StorableConstructor]
    protected AlgorithmEvaluator(bool deserializing) : base(deserializing) { }
    public AlgorithmEvaluator()
      : base() {
      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used to initialize the new random permutation."));
      Parameters.Add(new LookupParameter<IAlgorithm>("Algorithm", ""));
      Parameters.Add(new LookupParameter<IntValue>("ProblemIndex", ""));
      Parameters.Add(new LookupParameter<IntValue>("RepetitionIndex", ""));
      Parameters.Add(new LookupParameter<ParameterConfigurationTree>("ParameterConfigurationTree", ""));
      Parameters.Add(new ValueParameter<IItemList<IRun>>("Runs", ""));
    }
    protected AlgorithmEvaluator(AlgorithmEvaluator original, Cloner cloner) : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new AlgorithmEvaluator(this, cloner);
    }

    public override IOperation Apply() {
      IAlgorithm algorithm = AlgorithmParameter.ActualValue;

      #region Debug Code for SymbolicRegressionGrammar
      var srp = (SymbolicRegressionSingleObjectiveProblem)algorithm.Problem;
      //Console.WriteLine("Evaluating Grammar: " + PrintGrammar(srp.SymbolicExpressionTreeGrammar));
      #endregion

      var sw = new Stopwatch();
      sw.Start();
      //// prepare and clear is needed, if the algorithm has been started and stopped before (this happens when meta level algorithm is paused)
      //algorithm.Prepare(); // <--- SHOULD NOT HAPPEN!
      //algorithm.Runs.Clear();

      algorithm.StartSync(CancellationToken);
      sw.Stop();
      Console.WriteLine("{0},{1}: {2} (Grammar: {3})", ProblemIndexParameter.ActualValue.Value, RepetitionIndexParameter.ActualValue.Value, sw.Elapsed, PrintGrammar(srp.SymbolicExpressionTreeGrammar));

      RunsParameter.Value = new ItemList<IRun>(algorithm.Runs);

      return base.Apply();
    }

    /// <summary>
    /// This method should repair an invalid parameterConfiguration.
    /// The strategy is to just randomize parameter settings. It's not guaranteed to be a vaild setting
    /// </summary>
    private void Repair(ParameterConfigurationTree parameterConfiguration, IRandom random) {
      parameterConfiguration.Randomize(random);
    }

    // for debug purposes, remove later
    private static string PrintGrammar(ISymbolicExpressionGrammar grammar) {
      return string.Join(string.Empty, grammar.Symbols.Select(x => x.InitialFrequency).ToArray());
      //foreach (var symbol in grammar.Symbols) {
      //  Console.WriteLine("{0} ({1})", symbol.ToString(), symbol.InitialFrequency);
      //}
    }
  }
}