source: branches/HeuristicLab.Problems.GaussianProcessTuning/HeuristicLab.Problems.GaussianProcessTuning/Interpreter.cs @ 9387

using System;
using System.Linq;
using System.Text;
using System.Threading;
using HeuristicLab.Algorithms.DataAnalysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Problems.GaussianProcessTuning {
  [StorableClass]
  [Item("Interpreter", "An interpreter for Gaussian process configurations represented as trees.")]
  public class Interpreter : Item {
    [StorableConstructor]
    protected Interpreter(bool deserializing) : base(deserializing) { }
    protected Interpreter(Interpreter original, Cloner cloner)
      : base(original, cloner) {
    }
    public Interpreter()
      : base() { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new Interpreter(this, cloner);
    }

    public void EvaluateGaussianProcessConfiguration(ISymbolicExpressionTree tree, IRegressionProblemData problemData, out double negLogLikelihood, out IGaussianProcessSolution solution) {
      var meanFunction = GetMeanFunction(tree);
      var covFunction = GetCovFunction(tree);

      var gprAlg = new GaussianProcessRegression();
      gprAlg.Problem.ProblemDataParameter.Value = problemData;
      gprAlg.CovarianceFunction = covFunction;
      gprAlg.MeanFunction = meanFunction;
      gprAlg.GaussianProcessModelCreatorParameter.Value =
        gprAlg.GaussianProcessModelCreatorParameter.ValidValues.First(
          v => v is GaussianProcessRegressionModelCreator);
      gprAlg.MinimizationIterations = 50;

      var signal = new AutoResetEvent(false);
      double result = double.MaxValue;
      IGaussianProcessSolution regSolution = null;
      gprAlg.Stopped += (sender, args) => {
        result = ((DoubleValue)gprAlg.Results["NegativeLogLikelihood"].Value).Value;
        if (gprAlg.Results.ContainsKey("Solution"))
          regSolution = (IGaussianProcessSolution)gprAlg.Results["Solution"].Value;
        signal.Set();
      };
      Exception ex = null;
      gprAlg.ExceptionOccurred += (sender, args) => {
        result = double.MaxValue;
        regSolution = null;
        ex = args.Value;
        signal.Set();
      };

      gprAlg.Prepare();
      gprAlg.Start();

      signal.WaitOne();
      if (ex != null) throw ex;

      gprAlg.Prepare();
      gprAlg.Problem = null;
      solution = regSolution;
      negLogLikelihood = result;
    }

    private IMeanFunction GetMeanFunction(ISymbolicExpressionTree tree) {
      return GetMeanFunction(tree.Root.GetSubtree(0).GetSubtree(0).GetSubtree(0));
    }

    private ICovarianceFunction GetCovFunction(ISymbolicExpressionTree tree) {
      return GetCovFunction(tree.Root.GetSubtree(0).GetSubtree(0).GetSubtree(1));
    }

    private ICovarianceFunction GetCovFunction(ISymbolicExpressionTreeNode node) {
      if (node.Symbol is CovConst) {
        return new CovarianceConst();
      } else if (node.Symbol is CovScale) {
        var cov = new CovarianceScale();
        cov.CovarianceFunctionParameter.Value = GetCovFunction(node.GetSubtree(0));
        return cov;
      } else if (node.Symbol is CovMask) {
        var maskNode = node as CovMaskTreeNode;
        var covSymbol = node.Symbol as CovMask;
        var cov = new CovarianceMask();
        cov.SelectedDimensionsParameter.Value = new IntArray((from i in Enumerable.Range(0, covSymbol.Dimension)
                                                              where maskNode.Mask[i]
                                                              select i).ToArray());
        cov.CovarianceFunctionParameter.Value = GetCovFunction(node.GetSubtree(0));
        return cov;
      } else if (node.Symbol is CovLin) {
        return new CovarianceLinear();
      } else if (node.Symbol is CovLinArd) {
        return new CovarianceLinearArd();
      } else if (node.Symbol is CovMatern) {
        var covSymbol = node.Symbol as CovMatern;
        var cov = new CovarianceMaternIso();
        cov.DParameter.Value = cov.DParameter.ValidValues.Single(x => x.Value == covSymbol.D);
        return cov;
      } else if (node.Symbol is CovSeArd) {
        return new CovarianceSquaredExponentialArd();
      } else if (node.Symbol is CovSeIso) {
        return new CovarianceSquaredExponentialIso();
      } else if (node.Symbol is CovRQIso) {
        return new CovarianceRationalQuadraticIso();
      } else if (node.Symbol is CovRQArd) {
        return new CovarianceRationalQuadraticArd();
      } else if (node.Symbol is CovNn) {
        return new CovarianceNeuralNetwork();
      } else if (node.Symbol is CovPeriodic) {
        return new CovariancePeriodic();
      } else if (node.Symbol is CovNoise) {
        return new CovarianceNoise();
      } else if (node.Symbol is CovSum) {
        var covSum = new Algorithms.DataAnalysis.CovarianceSum();
        covSum.Terms.Add(GetCovFunction(node.GetSubtree(0)));
        foreach (var subTree in node.Subtrees.Skip(1)) {
          covSum.Terms.Add(GetCovFunction(subTree));
        }
        return covSum;
      } else if (node.Symbol is CovProd) {
        var covProd = new Algorithms.DataAnalysis.CovarianceProduct();
        covProd.Factors.Add(GetCovFunction(node.GetSubtree(0)));
        foreach (var subTree in node.Subtrees.Skip(1)) {
          covProd.Factors.Add(GetCovFunction(subTree));
        }
        return covProd;
      } else {
        throw new ArgumentException("unknown symbol " + node.Symbol);
      }
    }


    private IMeanFunction GetMeanFunction(ISymbolicExpressionTreeNode node) {
      if (node.Symbol is MeanConst) {
        return new Algorithms.DataAnalysis.MeanConst();
      } else if (node.Symbol is MeanLinear) {
        return new Algorithms.DataAnalysis.MeanLinear();
      } else if (node.Symbol is MeanProd) {
        var meanProd = new Algorithms.DataAnalysis.MeanProduct();
        meanProd.Factors.Add(GetMeanFunction(node.GetSubtree(0)));
        foreach (var subTree in node.Subtrees.Skip(1)) {
          meanProd.Factors.Add(GetMeanFunction(subTree));
        }
        return meanProd;
      } else if (node.Symbol is MeanSum) {
        var meanSum = new Algorithms.DataAnalysis.MeanSum();
        meanSum.Terms.Add(GetMeanFunction(node.GetSubtree(0)));
        foreach (var subTree in node.Subtrees.Skip(1)) {
          meanSum.Terms.Add(GetMeanFunction(subTree));
        }
        return meanSum;
      } else if (node.Symbol is MeanZero) {
        return new Algorithms.DataAnalysis.MeanZero();
      } else {
        throw new ArgumentException("Unknown mean function" + node.Symbol);
      }
    }

    //private bool[] CalculateMask(ISymbolicExpressionTreeNode node) {
    //  var maskNode = node as MeanMaskTreeNode;
    //  if (maskNode != null) {
    //    bool[] newMask = CombineMasksProd(maskNode.Mask, CalculateMask(node.GetSubtree(0)));
    //    return newMask;
    //  } else if (node.Symbol is MeanProd) {
    //    bool[] newMask = CalculateMask(node.GetSubtree(0));
    //    foreach (var subTree in node.Subtrees.Skip(1)) {
    //      newMask = CombineMasksProd(newMask, CalculateMask(subTree));
    //    }
    //    return newMask;
    //  } else if (node.Symbol is MeanSum) {
    //    bool[] newMask = CalculateMask(node.GetSubtree(0));
    //    foreach (var subTree in node.Subtrees.Skip(1)) {
    //      newMask = CombineMasksSum(newMask, CalculateMask(subTree));
    //    }
    //    return newMask;
    //  } else if (node.SubtreeCount == 1) {
    //    return CalculateMask(node.GetSubtree(0));
    //  } else if (node is SymbolicExpressionTreeTerminalNode) {
    //    return null;
    //  } else {
    //    throw new NotImplementedException();
    //  }
    //}

    //private bool[] CombineMasksProd(bool[] m, bool[] n) {
    //  if (m == null) return n;
    //  if (n == null) return m;
    //  if (m.Length != n.Length) throw new ArgumentException();
    //  bool[] res = new bool[m.Length];
    //  for (int i = 0; i < res.Length; i++)
    //    res[i] = m[i] | n[i];
    //  return res;
    //}


    //private bool[] CombineMasksSum(bool[] m, bool[] n) {
    //  if (m == null) return n;
    //  if (n == null) return m;
    //  if (m.Length != n.Length) throw new ArgumentException();
    //  bool[] res = new bool[m.Length];
    //  for (int i = 0; i < res.Length; i++)
    //    res[i] = m[i] & n[i];
    //  return res;
    //}

  }
}