Changeset 8366 for trunk/sources/HeuristicLab.Algorithms.DataAnalysis

Timestamp:

07/31/12 11:19:24 (12 years ago)

Author:

gkronber

Message:

#1902 added linear mean and covariance function

Location:

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4

Files:

• GaussianProcess/CovarianceLinear.cs (added)
• GaussianProcess/CovarianceSum.cs (modified) (1 diff)
• GaussianProcess/GaussianProcessModel.cs (modified) (3 diffs)
• GaussianProcess/IMeanFunction.cs (modified) (1 diff)
• GaussianProcess/MeanConst.cs (modified) (1 diff)
• GaussianProcess/MeanLinear.cs (added)
• GaussianProcess/MeanZero.cs (modified) (1 diff)
• GaussianProcess/Util.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (1 diff)

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSum.cs

@@ -1 @@
-using System.Collections.Generic;
+using System;
 using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.GaussianProcess {
-  public class CovarianceSum : ICovarianceFunction {
-    private IList<ICovarianceFunction> covariances;
+  [StorableClass]
+  [Item(Name = "CovarianceSum",
+    Description = "Sum covariance function for Gaussian processes.")]
+  public class CovarianceSum : Item, ICovarianceFunction {
+    [Storable]
+    private ItemList<ICovarianceFunction> terms;
 
-    public int NumberOfParameters {
-      get { return covariances.Sum(c => c.NumberOfParameters); }
+    [Storable]
+    private int numberOfVariables;
+    public ItemList<ICovarianceFunction> Terms {
+      get { return terms; }
     }
 
-    public CovarianceSum(IEnumerable<ICovarianceFunction> covariances) {
-      this.covariances = covariances.ToList();
+    [StorableConstructor]
+    protected CovarianceSum(bool deserializing)
+      : base(deserializing) {
     }
 
-    public void SetMatrix(double[,] x) {
-      foreach (var covariance in covariances) {
-        covariance.SetMatrix(x, x);
+    protected CovarianceSum(CovarianceSum original, Cloner cloner)
+      : base(original, cloner) {
+      this.terms = cloner.Clone(terms);
+    }
+
+    public CovarianceSum()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovarianceSum(this, cloner);
+    }
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      this.numberOfVariables = numberOfVariables;
+      return terms.Select(t => t.GetNumberOfParameters(numberOfVariables)).Sum();
+    }
+
+    public void SetParameter(double[] hyp, double[,] x) {
+      int offset = 0;
+      foreach (var t in terms) {
+        t.SetParameter(hyp.Skip(offset).Take(t.GetNumberOfParameters(numberOfVariables)), x);
+        offset += numberOfVariables;
       }
     }
 
-    public void SetMatrix(double[,] x, double[,] xt) {
-      foreach (var covariance in covariances) {
-        covariance.SetMatrix(x, xt);
-      }
-    }
 
-    public void SetHyperparamter(double[] hyp) {
-      int i = 0;
-      foreach (var covariance in covariances) {
-        int n = covariance.NumberOfParameters;
-        covariance.SetHyperparamter(hyp.Skip(i).Take(n).ToArray());
-        i += n;
-      }
+    public void SetParameter(double[] hyp, double[,] x, double[,] xt) {
+      this.l = Math.Exp(hyp[0]);
+      this.sf2 = Math.Exp(2 * hyp[1]);
+
+      this.symmetric = false;
+      this.x = x;
+      this.xt = xt;
+      sd = null;
     }
 
     public double GetCovariance(int i, int j) {
-      return covariances.Select(c => c.GetCovariance(i, j)).Sum();
+      if (sd == null) CalculateSquaredDistances();
+      return sf2 * Math.Exp(-sd[i, j] / 2.0);
     }
 
 
     public double[] GetDiagonalCovariances() {
-      return covariances
-        .Select(c => c.GetDiagonalCovariances())
-        .Aggregate((s, d) => s.Zip(d, (a, b) => a + b).ToArray())
-        .ToArray();
+      if (x != xt) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      var sd = new double[rows];
+      for (int i = 0; i < rows; i++) {
+        sd[i] = Util.SqrDist(Util.GetRow(x, i).Select(e => e / l), Util.GetRow(xt, i).Select(e => e / l));
+      }
+      return sd.Select(d => sf2 * Math.Exp(-d / 2.0)).ToArray();
     }
 
-    public double[] GetDerivatives(int i, int j) {
-      return covariances
-        .Select(c => c.GetDerivatives(i, j))
-        .Aggregate(Enumerable.Empty<double>(), (h0, h1) => h0.Concat(h1))
-        .ToArray();
+
+    public double[] GetGradient(int i, int j) {
+      var res = new double[2];
+      res[0] = sf2 * Math.Exp(-sd[i, j] / 2.0) * sd[i, j];
+      res[1] = 2.0 * sf2 * Math.Exp(-sd[i, j] / 2.0);
+      return res;
+    }
+
+    private void CalculateSquaredDistances() {
+      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      int cols = xt.GetLength(0);
+      sd = new double[rows, cols];
+      if (symmetric) {
+        for (int i = 0; i < rows; i++) {
+          for (int j = i; j < rows; j++) {
+            sd[i, j] = Util.SqrDist(Util.GetRow(x, i).Select(e => e / l), Util.GetRow(xt, j).Select(e => e / l));
+            sd[j, i] = sd[i, j];
+          }
+        }
+      } else {
+        for (int i = 0; i < rows; i++) {
+          for (int j = 0; j < cols; j++) {
+            sd[i, j] = Util.SqrDist(Util.GetRow(x, i).Select(e => e / l), Util.GetRow(xt, j).Select(e => e / l));
+          }
+        }
+      }
     }
   }

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs

@@ -138 +138 @@
 
       // calculate means and covariances
-      double[] m = meanFunction.GetMean();
+      double[] m = meanFunction.GetMean(x);
       for (int i = 0; i < n; i++) {
 
@@ -188 +188 @@
       double[] meanGradients = new double[meanFunction.GetNumberOfParameters(nAllowedVariables)];
       for (int i = 0; i < meanGradients.Length; i++) {
-        var meanGrad = meanFunction.GetGradients(i);
+        var meanGrad = meanFunction.GetGradients(i, x);
         meanGradients[i] = -Util.ScalarProd(meanGrad, alpha);
       }
 
       double[] covGradients = new double[covarianceFunction.GetNumberOfParameters(nAllowedVariables)];
-      for (int i = 0; i < n; i++) {
-        for (int j = 0; j < n; j++) {
-          var covDeriv = covarianceFunction.GetGradient(i, j);
-          for (int k = 0; k < covGradients.Length; k++) {
-            covGradients[k] += q[i, j] * covDeriv[k];
+      if (covGradients.Length > 0) {
+        for (int i = 0; i < n; i++) {
+          for (int j = 0; j < n; j++) {
+            var covDeriv = covarianceFunction.GetGradient(i, j);
+            for (int k = 0; k < covGradients.Length; k++) {
+              covGradients[k] += q[i, j] * covDeriv[k];
+            }
           }
         }
-      }
-      covGradients = covGradients.Select(g => g / 2.0).ToArray();
+        covGradients = covGradients.Select(g => g / 2.0).ToArray();
+      }
 
       return new double[] { noiseGradient }
@@ -246 +248 @@
       covarianceFunction.SetParameter(covHyp, x, newX);
       meanFunction.SetParameter(meanHyp, newX);
-      var ms = meanFunction.GetMean();
+      var ms = meanFunction.GetMean(newX);
       for (int i = 0; i < newN; i++) {
 

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/IMeanFunction.cs

@@ -6 +6 @@
     int GetNumberOfParameters(int numberOfVariables);
     void SetParameter(double[] hyp, double[,] x);
-    double[] GetMean();
-    double[] GetGradients(int k);
+    double[] GetMean(double[,] x);
+    double[] GetGradients(int k, double[,] x);
   }
 }

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanConst.cs

@@ -34 +34 @@
     }
 
-    public double[] GetMean() {
+    public double[] GetMean(double[,] x) {
       return Enumerable.Repeat(c, n).ToArray();
     }
 
-    public double[] GetGradients(int k) {
+    public double[] GetGradients(int k, double[,] x) {
       if (k > 0) throw new ArgumentException();
       return Enumerable.Repeat(1.0, n).ToArray();

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanZero.cs

@@ -29 +29 @@
     }
 
-    public double[] GetMean() {
+    public double[] GetMean(double[,] x) {
       return Enumerable.Repeat(0.0, n).ToArray();
     }
 
-    public double[] GetGradients(int k) {
+    public double[] GetGradients(int k, double[,] x) {
       if (k > 0) throw new ArgumentException();
       return Enumerable.Repeat(0.0, n).ToArray();

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/Util.cs

@@ -24 +24 @@
       return Enumerable.Range(0, cols).Select(c => x[r, c]);
     }
+    public static IEnumerable<double> GetCol(double[,] x, int c) {
+      int rows = x.GetLength(0);
+      return Enumerable.Range(0, rows).Select(r => x[r, c]);
+    }
   }
 }

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj

@@ -122 +122 @@
     </Compile>
     <Compile Include="FixedDataAnalysisAlgorithm.cs" />
+    <Compile Include="GaussianProcess\CovarianceLinear.cs" />
+    <Compile Include="GaussianProcess\MeanLinear.cs" />
     <Compile Include="GaussianProcess\Util.cs" />
     <Compile Include="GaussianProcess\MeanZero.cs" />