source: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/TensorFlowConstantOptimizationEvaluator.cs @ 17475

#region License Information
/* HeuristicLab
 * Copyright (C) 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.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Parameters;
using HEAL.Attic;
using Tensorflow;
using static Tensorflow.Binding;
using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
  [StorableType("63944BF6-62E5-4BE4-974C-D30AD8770F99")]
  [Item("TensorFlowConstantOptimizationEvaluator", "")]
  public class TensorFlowConstantOptimizationEvaluator : SymbolicRegressionConstantOptimizationEvaluator {
    private const string MaximumIterationsName = "MaximumIterations";
    private const string LearningRateName = "LearningRate";

    #region Parameter Properties
    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[MaximumIterationsName]; }
    }
    public IFixedValueParameter<DoubleValue> LearningRateParameter {
      get { return (IFixedValueParameter<DoubleValue>)Parameters[LearningRateName]; }
    }
    #endregion

    #region Properties
    public int ConstantOptimizationIterations {
      get { return ConstantOptimizationIterationsParameter.Value.Value; }
    }
    public double LearningRate {
      get { return LearningRateParameter.Value.Value; }
    }
    #endregion

    public TensorFlowConstantOptimizationEvaluator()
      : base() {
      Parameters.Add(new FixedValueParameter<IntValue>(MaximumIterationsName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree(0 indicates other or default stopping criterion).", new IntValue(10)));
      Parameters.Add(new FixedValueParameter<DoubleValue>(LearningRateName, "", new DoubleValue(0.01)));
    }

    protected TensorFlowConstantOptimizationEvaluator(TensorFlowConstantOptimizationEvaluator original, Cloner cloner)
      : base(original, cloner) { }

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

    [StorableConstructor]
    protected TensorFlowConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }

    protected override ISymbolicExpressionTree OptimizeConstants(
      ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows,
      CancellationToken cancellationToken = default(CancellationToken), EvaluationsCounter counter = null) {
      return OptimizeTree(tree,
        problemData, rows,
        ApplyLinearScalingParameter.ActualValue.Value, UpdateVariableWeights,
        ConstantOptimizationIterations, LearningRate,
        cancellationToken, counter);
    }

    public static ISymbolicExpressionTree OptimizeTree(
      ISymbolicExpressionTree tree,
      IRegressionProblemData problemData, IEnumerable<int> rows,
      bool applyLinearScaling, bool updateVariableWeights, int maxIterations, double learningRate,
      CancellationToken cancellationToken = default(CancellationToken), EvaluationsCounter counter = null) {

      bool success = TreeToTensorConverter.TryConvert(tree, updateVariableWeights, applyLinearScaling,
        out Tensor prediction, out Dictionary<TreeToTensorConverter.DataForVariable, Tensor> variables/*, out double[] initialConstants*/);

      var target = tf.placeholder(tf.float64, name: problemData.TargetVariable);
      int samples = rows.Count();
      // mse
      var costs = tf.reduce_sum(tf.square(prediction - target)) / (2.0 * samples);
      var optimizer = tf.train.GradientDescentOptimizer((float)learningRate);

      // features as feed items
      var variablesFeed = new Hashtable();
      foreach (var kvp in variables) {
        var variableName = kvp.Key.variableName;
        var variable = kvp.Value;
        if (problemData.Dataset.VariableHasType<double>(variableName))
          variablesFeed.Add(variable, problemData.Dataset.GetDoubleValues(variableName, rows));
        if (problemData.Dataset.VariableHasType<string>(variableName))
          variablesFeed.Add(variable, problemData.Dataset.GetStringValues(variableName, rows));
        if (problemData.Dataset.VariableHasType<DoubleVector>(variableName))
          variablesFeed.Add(variable, problemData.Dataset.GetDoubleVectorValues(variableName, rows));
        throw new NotSupportedException($"Type of the variable is not supported: {variableName}");
      }
      variablesFeed.Add(target, problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows));


      using (var session = tf.Session()) {
        for (int i = 0; i < maxIterations; i++) {
          optimizer.minimize(costs);
          var result = session.run(optimizer, variablesFeed);
        }
      }
      optimizer.minimize(costs);

      if (!success)
        return (ISymbolicExpressionTree)tree.Clone();


      return null;
    }

    public static bool CanOptimizeConstants(ISymbolicExpressionTree tree) {
      return TreeToTensorConverter.IsCompatible(tree);
    }
  }
}