source: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToTensorConverter.cs @ 17489

#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

#define EXPLICIT_SHAPE

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using NumSharp;
using Tensorflow;
using static Tensorflow.Binding;
using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  public class TreeToTensorConverter {

    #region helper class
    public class DataForVariable {
      public readonly string variableName;
      public readonly string variableValue; // for factor vars

      public DataForVariable(string varName, string varValue) {
        this.variableName = varName;
        this.variableValue = varValue;
      }

      public override bool Equals(object obj) {
        var other = obj as DataForVariable;
        if (other == null) return false;
        return other.variableName.Equals(this.variableName) &&
               other.variableValue.Equals(this.variableValue);
      }

      public override int GetHashCode() {
        return variableName.GetHashCode() ^ variableValue.GetHashCode();
      }
    }
    #endregion

    public static bool TryConvert(ISymbolicExpressionTree tree, int numRows, Dictionary<string, int> variableLengths,
      bool makeVariableWeightsVariable, bool addLinearScalingTerms,
      out Tensor graph, out Dictionary<Tensor, string> parameters, out List<Tensor> variables
/*, out double[] initialConstants*/) {

      try {
        var converter = new TreeToTensorConverter(numRows, variableLengths, makeVariableWeightsVariable, addLinearScalingTerms);
        graph = converter.ConvertNode(tree.Root.GetSubtree(0));

        //var parametersEntries = converter.parameters.ToList(); // guarantee same order for keys and values
        parameters = converter.parameters; // parametersEntries.Select(kvp => kvp.Value).ToList();
        variables = converter.variables;
        //initialConstants = converter.initialConstants.ToArray();
        return true;
      } catch (NotSupportedException) {
        graph = null;
        parameters = null;
        variables = null;
        //initialConstants = null;
        return false;
      }
    }

    private readonly int numRows;
    private readonly Dictionary<string, int> variableLengths;
    private readonly bool makeVariableWeightsVariable;
    private readonly bool addLinearScalingTerms;

    //private readonly List<double> initialConstants = new List<double>();
    private readonly Dictionary<Tensor, string> parameters = new Dictionary<Tensor, string>();
    private readonly List<Tensor> variables = new List<Tensor>();

    private TreeToTensorConverter(int numRows, Dictionary<string, int> variableLengths, bool makeVariableWeightsVariable, bool addLinearScalingTerms) {
      this.numRows = numRows;
      this.variableLengths = variableLengths;
      this.makeVariableWeightsVariable = makeVariableWeightsVariable;
      this.addLinearScalingTerms = addLinearScalingTerms;
    }



    private Tensor ConvertNode(ISymbolicExpressionTreeNode node) {
      if (node.Symbol is Constant) {
        var value = ((ConstantTreeNode)node).Value;
        //initialConstants.Add(value);
#if EXPLICIT_SHAPE
        //var var = (RefVariable)tf.VariableV1(value, name: $"c_{variables.Count}", dtype: tf.float64, shape: new[] { 1, 1 });
        var value_arr = np.array(value).reshape(1, 1);
        var var = tf.Variable(value_arr, name: $"c_{variables.Count}", dtype: tf.float64);
#endif
        //var var = tf.Variable(value, name: $"c_{variables.Count}", dtype: tf.float64/*, shape: new[] { 1, 1 }*/);
        variables.Add(var);
        return var;
      }

      if (node.Symbol is Variable/* || node.Symbol is BinaryFactorVariable*/) {
        var varNode = node as VariableTreeNodeBase;
        //var factorVarNode = node as BinaryFactorVariableTreeNode;
        // factor variable values are only 0 or 1 and set in x accordingly
        //var varValue = factorVarNode != null ? factorVarNode.VariableValue : string.Empty;
        //var par = FindOrCreateParameter(parameters, varNode.VariableName, varValue);
#if EXPLICIT_SHAPE
        var par = tf.placeholder(tf.float64, new TensorShape(numRows, variableLengths[varNode.VariableName]), name: varNode.VariableName);
#endif
        parameters.Add(par, varNode.VariableName);

        if (makeVariableWeightsVariable) {
          //initialConstants.Add(varNode.Weight);
#if EXPLICIT_SHAPE
          //var w = (RefVariable)tf.VariableV1(varNode.Weight, name: $"w_{varNode.VariableName}_{variables.Count}", dtype: tf.float64, shape: new[] { 1, 1 });
          var w_arr = np.array(varNode.Weight).reshape(1, 1);
          var w = tf.Variable(w_arr, name: $"w_{varNode.VariableName}", dtype: tf.float64);
#endif
          //var w = tf.Variable(varNode.Weight, name: $"w_{varNode.VariableName}_{variables.Count}", dtype: tf.float64/*, shape: new[] { 1, 1 }*/);
          variables.Add(w);
          return w * par;
        } else {
          return varNode.Weight * par;
        }
      }

      //if (node.Symbol is FactorVariable) {
      //  var factorVarNode = node as FactorVariableTreeNode;
      //  var products = new List<Tensor>();
      //  foreach (var variableValue in factorVarNode.Symbol.GetVariableValues(factorVarNode.VariableName)) {
      //    //var par = FindOrCreateParameter(parameters, factorVarNode.VariableName, variableValue);
      //    var par = tf.placeholder(tf.float64, new TensorShape(numRows, 1), name: factorVarNode.VariableName);
      //    parameters.Add(par, factorVarNode.VariableName);

      //    var value = factorVarNode.GetValue(variableValue);
      //    //initialConstants.Add(value);
      //    var wVar = (RefVariable)tf.VariableV1(value, name: $"f_{factorVarNode.VariableName}_{variables.Count}", dtype: tf.float64, shape: new[] { 1, 1 });
      //    //var wVar = tf.Variable(value, name: $"f_{factorVarNode.VariableName}_{variables.Count}"/*, shape: new[] { 1, 1 }*/);
      //    variables.Add(wVar);

      //    products.add(wVar * par);
      //  }

      //  return products.Aggregate((a, b) => a + b);
      //}

      if (node.Symbol is Addition) {
        var terms = new List<Tensor>();
        foreach (var subTree in node.Subtrees) {
          terms.Add(ConvertNode(subTree));
        }

        return terms.Aggregate((a, b) => a + b);
      }

      if (node.Symbol is Subtraction) {
        var terms = new List<Tensor>();
        for (int i = 0; i < node.SubtreeCount; i++) {
          var t = ConvertNode(node.GetSubtree(i));
          if (i > 0) t = -t;
          terms.Add(t);
        }

        if (terms.Count == 1) return -terms[0];
        else return terms.Aggregate((a, b) => a + b);
      }

      if (node.Symbol is Multiplication) {
        var terms = new List<Tensor>();
        foreach (var subTree in node.Subtrees) {
          terms.Add(ConvertNode(subTree));
        }

        if (terms.Count == 1) return terms[0];
        else return terms.Aggregate((a, b) => a * b);
      }

      if (node.Symbol is Division) {
        var terms = new List<Tensor>();
        foreach (var subTree in node.Subtrees) {
          terms.Add(ConvertNode(subTree));
        }

        if (terms.Count == 1) return 1.0 / terms[0];
        else return terms.Aggregate((a, b) => a * (1.0 / b));
      }

      if (node.Symbol is Absolute) {
        var x1 = ConvertNode(node.GetSubtree(0));
        return tf.abs(x1);
      }

      if (node.Symbol is AnalyticQuotient) {
        var x1 = ConvertNode(node.GetSubtree(0));
        var x2 = ConvertNode(node.GetSubtree(1));
        return x1 / tf.pow(1 + x2 * x2, 0.5);
      }

      if (node.Symbol is Logarithm) {
        return math_ops.log(
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is Exponential) {
        return math_ops.pow(
          Math.E,
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is Square) {
        return tf.square(
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is SquareRoot) {
        return math_ops.sqrt(
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is Cube) {
        return math_ops.pow(
          ConvertNode(node.GetSubtree(0)), 3.0);
      }

      if (node.Symbol is CubeRoot) {
        return math_ops.pow(
          ConvertNode(node.GetSubtree(0)), 1.0 / 3.0);
        // TODO
        // f: x < 0 ? -Math.Pow(-x, 1.0 / 3) : Math.Pow(x, 1.0 / 3),
        // g:  { var cbrt_x = x < 0 ? -Math.Pow(-x, 1.0 / 3) : Math.Pow(x, 1.0 / 3); return 1.0 / (3 * cbrt_x * cbrt_x); }
      }

      if (node.Symbol is Sine) {
        return tf.sin(
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is Cosine) {
        return tf.cos(
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is Tangent) {
        return tf.tan(
          ConvertNode(node.GetSubtree(0)));
      }

      if (node.Symbol is Mean) {
        return tf.reduce_mean(
          ConvertNode(node.GetSubtree(0)),
          axis: new[] { 1 },
          keepdims: true);
      }

      //if (node.Symbol is StandardDeviation) {
      //  return tf.reduce_std(
      //    ConvertNode(node.GetSubtree(0)),
      //    axis: new [] { 1 }
      // );
      //}

      if (node.Symbol is Sum) {
        return tf.reduce_sum(
          ConvertNode(node.GetSubtree(0)),
          axis: new[] { 1 },
          keepdims: true);
      }

      if (node.Symbol is StartSymbol) {
        if (addLinearScalingTerms) {
          // scaling variables α, β are given at the beginning of the parameter vector
#if EXPLICIT_SHAPE
          //var alpha = (RefVariable)tf.VariableV1(1.0, name: $"alpha_{1.0}", dtype: tf.float64, shape: new[] { 1, 1 });
          //var beta = (RefVariable)tf.VariableV1(0.0, name: $"beta_{0.0}", dtype: tf.float64, shape: new[] { 1, 1 });

          var alpha_arr = np.array(1.0).reshape(1, 1);
          var alpha = tf.Variable(alpha_arr, name: $"alpha", dtype: tf.float64);
          var beta_arr = np.array(1.0).reshape(1, 1);
          var beta = tf.Variable(beta_arr, name: $"beta", dtype: tf.float64);
#endif
          //var alpha = tf.Variable(1.0, name: $"alpha_{1.0}", dtype: tf.float64/*, shape: new[] { 1, 1 }*/);
          //var beta = tf.Variable(0.0, name: $"beta_{0.0}", dtype: tf.float64/*, shape: new[] { 1, 1 }*/);
          variables.Add(alpha);
          variables.Add(beta);
          var t = ConvertNode(node.GetSubtree(0));
          return t * alpha + beta;
        } else return ConvertNode(node.GetSubtree(0));
      }

      throw new NotSupportedException($"Node symbol {node.Symbol} is not supported.");
    }

    public static bool IsCompatible(ISymbolicExpressionTree tree) {
      var containsUnknownSymbol = (
        from n in tree.Root.GetSubtree(0).IterateNodesPrefix()
        where
          !(n.Symbol is Variable) &&
          //!(n.Symbol is BinaryFactorVariable) &&
          //!(n.Symbol is FactorVariable) &&
          !(n.Symbol is Constant) &&
          !(n.Symbol is Addition) &&
          !(n.Symbol is Subtraction) &&
          !(n.Symbol is Multiplication) &&
          !(n.Symbol is Division) &&
          !(n.Symbol is Logarithm) &&
          !(n.Symbol is Exponential) &&
          !(n.Symbol is SquareRoot) &&
          !(n.Symbol is Square) &&
          !(n.Symbol is Sine) &&
          !(n.Symbol is Cosine) &&
          !(n.Symbol is Tangent) &&
          !(n.Symbol is HyperbolicTangent) &&
          !(n.Symbol is Erf) &&
          !(n.Symbol is Norm) &&
          !(n.Symbol is StartSymbol) &&
          !(n.Symbol is Absolute) &&
          !(n.Symbol is AnalyticQuotient) &&
          !(n.Symbol is Cube) &&
          !(n.Symbol is CubeRoot) &&
          !(n.Symbol is Mean) &&
          //!(n.Symbol is StandardDeviation) &&
          !(n.Symbol is Sum)
        select n).Any();
      return !containsUnknownSymbol;
    }
  }
}