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

#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.Diagnostics;
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 NumSharp;
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) {

      var vectorVariables = tree.IterateNodesBreadth()
        .OfType<VariableTreeNodeBase>()
        .Where(node => problemData.Dataset.VariableHasType<DoubleVector>(node.VariableName))
        .Select(node => node.VariableName);

      int? vectorLength = null;
      if (vectorVariables.Any()) {
        vectorLength = vectorVariables.Select(var => problemData.Dataset.GetDoubleVectorValues(var, rows)).First().First().Count;
      }
      int numRows = rows.Count();

      bool success = TreeToTensorConverter.TryConvert(tree,
        numRows, vectorLength,
        updateVariableWeights, applyLinearScaling,
        out Tensor prediction,
        out Dictionary<Tensor, string> parameters, out List<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).minimize(costs);

      // features as feed items
      var variablesFeed = new Hashtable();
      foreach (var kvp in parameters) {
        var variable = kvp.Key;
        var variableName = kvp.Value;
        if (problemData.Dataset.VariableHasType<double>(variableName)) {
          var data = problemData.Dataset.GetDoubleValues(variableName, rows).ToArray();
          if (vectorLength.HasValue) {
            var vectorData = new double[numRows][];
            for (int i = 0; i < numRows; i++)
              vectorData[i] = Enumerable.Repeat(data[i], vectorLength.Value).ToArray();
            variablesFeed.Add(variable, np.array(vectorData));
          } else
            variablesFeed.Add(variable, np.array(data, copy: false));
          //} else if (problemData.Dataset.VariableHasType<string>(variableName)) {
          //  variablesFeed.Add(variable, problemData.Dataset.GetStringValues(variableName, rows));
        } else if (problemData.Dataset.VariableHasType<DoubleVector>(variableName)) {
          var data = problemData.Dataset.GetDoubleVectorValues(variableName, rows).Select(x => x.ToArray()).ToArray();
          variablesFeed.Add(variable, np.array(data));
        } else
          throw new NotSupportedException($"Type of the variable is not supported: {variableName}");
      }
      var targetData = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows).ToArray();
      variablesFeed.Add(target, np.array(targetData, copy: false));


      using (var session = tf.Session()) {
        session.run(tf.global_variables_initializer());

        Trace.WriteLine("Weights:");
        foreach (var v in variables)
          Trace.WriteLine($"{v.name}: {session.run(v).ToString(true)}");

        for (int i = 0; i < maxIterations; i++) {

          //optimizer.minimize(costs);
          session.run(optimizer, variablesFeed);

          Trace.WriteLine("Weights:");
          foreach (var v in variables)
            Trace.WriteLine($"{v.name}: {session.run(v).ToString(true)}");
        }
      }

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


      return null;
    }

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