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

Timestamp:

09/04/12 09:50:52 (12 years ago)

Author:

gkronber

Message:

#1902 implemented LinearARD and MaternIso covariance functions.

Location:

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4

Files:

• GaussianProcess/CovarianceLinear.cs (modified) (2 diffs)
• GaussianProcess/CovarianceLinearArd.cs (modified) (3 diffs)
• GaussianProcess/CovarianceMaternIso.cs (added)
• GaussianProcess/ICovarianceFunction.cs (modified) (1 diff)
• GaussianProcess/Util.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (1 diff)

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

@@ -51 +51 @@
 
     public double GetCovariance(double[,] x, int i, int j) {
-      return Util.ScalarProd(Util.GetRow(x, i), Util.GetRow(x, j));
+      return Util.ScalarProd(x, i, j);
     }
 
@@ -59 +59 @@
 
     public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
-      return Util.ScalarProd(Util.GetRow(x, i), Util.GetRow(xt, j));
+      return Util.ScalarProd(x, i, xt, j);
     }
   }

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

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -32 +33 @@
   public class CovarianceLinearArd : Item, ICovarianceFunction {
     [Storable]
-    private double[,] x;
-    [Storable]
-    private double[,] xt;
-
-    [Storable]
-    private double[] l;
-    public double[] Length {
+    private double[] inverseLength;
+    public double[] InverseLength {
       get {
-        double[] res = new double[l.Length];
-        Array.Copy(l, res, res.Length);
+        if (inverseLength == null) return null;
+        double[] res = new double[inverseLength.Length];
+        Array.Copy(inverseLength, res, res.Length);
         return res;
       }
     }
 
-    private double[,] k;
-    private bool symmetric;
-
-
     public int GetNumberOfParameters(int numberOfVariables) {
       return numberOfVariables;
     }
+
     [StorableConstructor]
     protected CovarianceLinearArd(bool deserializing) : base(deserializing) { }
     protected CovarianceLinearArd(CovarianceLinearArd original, Cloner cloner)
       : base(original, cloner) {
-      if (original.x != null) {
-        this.x = new double[original.x.GetLength(0), original.x.GetLength(1)];
-        Array.Copy(original.x, this.x, x.Length);
-
-        this.xt = new double[original.xt.GetLength(0), original.xt.GetLength(1)];
-        Array.Copy(original.xt, this.xt, xt.Length);
-
-        this.k = new double[original.k.GetLength(0), original.k.GetLength(1)];
-        Array.Copy(original.k, this.k, k.Length);
-        this.l = new double[original.l.GetLength(0)];
-        Array.Copy(original.l, this.l, l.Length);
-      }
-      this.symmetric = original.symmetric;
+      this.inverseLength = original.InverseLength;  // array is copied in the getter
     }
     public CovarianceLinearArd()
@@ -80 +62 @@
 
     public void SetParameter(double[] hyp) {
-      l = hyp.Select(Math.Exp).ToArray();
+      inverseLength = hyp.Select(e => 1.0 / Math.Exp(e)).ToArray();
     }
 
-    public void SetData(double[,] x) {
-      SetData(x, x);
-      this.symmetric = true;
+    public double GetCovariance(double[,] x, int i, int j) {
+      return Util.ScalarProd(x, i, j, inverseLength);
     }
 
-    public void SetData(double[,] x, double[,] xt) {
-      this.x = x;
-      this.xt = xt;
-      this.symmetric = false;
-
-      k = null;
+    public IEnumerable<double> GetGradient(double[,] x, int i, int j) {
+      for (int k = 0; k < inverseLength.Length; k++) {
+        yield return -2.0 * x[i, k] * x[j, k] * inverseLength[k] * inverseLength[k];
+      }
     }
 
-    public double GetCovariance(int i, int j) {
-      if (k == null) CalculateInnerProduct();
-      return k[i, j];
-    }
-
-    public double GetGradient(int i, int j, int k) {
-
-    }
-
-
-    private void CalculateInnerProduct() {
-      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
-      int rows = x.GetLength(0);
-      int cols = xt.GetLength(0);
-      k = new double[rows, cols];
-      if (symmetric) {
-        for (int i = 0; i < rows; i++) {
-          for (int j = i; j < cols; j++) {
-
-            k[i, j] = Util.ScalarProd(Util.GetRow(x, i).Select((e, k) => e / l[k]),
-                                      Util.GetRow(x, j).Select((e, k) => e / l[k]));
-            k[j, i] = k[i, j];
-          }
-        }
-      } else {
-        for (int i = 0; i < rows; i++) {
-          for (int j = 0; j < cols; j++) {
-            k[i, j] = Util.ScalarProd(Util.GetRow(x, i).Select((e, k) => e / l[k]),
-                                      Util.GetRow(xt, j).Select((e, k) => e / l[k]));
-          }
-        }
-      }
+    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
+      return Util.ScalarProd(x, i, xt, j, inverseLength);
     }
   }

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

@@ -30 +30 @@
     IEnumerable<double> GetGradient(double[,] x, int i, int j);
     double GetCrossCovariance(double[,] x, double[,] xt, int i, int j);
-    //void SetData(double[,] x);
-    //void SetData(double[,] x, double[,] xt);
-
-    //double GetCovariance(int i, int j);
-    //double GetGradient(int i, int j, int k);
   }
 }

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

@@ -29 +29 @@
     }
 
+    public static double SqrDist(IEnumerable<double> x, IEnumerable<double> y) {
+      return x.Zip(y, (a, b) => (a - b) * (a - b)).Sum();
+    }
+
     public static double SqrDist(double x, double y) {
       double d = x - y;
       return d * d;
-    }
-
-    public static double SqrDist(IEnumerable<double> x, IEnumerable<double> y) {
-      return x.Zip(y, (a, b) => (a - b) * (a - b)).Sum();
     }
 
@@ -50 +50 @@
       return scale * scale * ss;
     }
+
     public static double SqrDist(double[,] x, int i, int j, double[] scale) {
       return SqrDist(x, i, x, j, scale);
@@ -62 +63 @@
       return ss;
     }
+    public static double ScalarProd(double[,] x, int i, int j, double scale = 1.0) {
+      return ScalarProd(x, i, x, j, scale);
+    }
+
+    public static double ScalarProd(double[,] x, int i, double[,] xt, int j, double scale = 1.0) {
+      double sum = 0.0;
+      for (int k = 0; k < x.GetLength(1); k++) {
+        sum += x[i, k] * xt[j, k];
+      }
+      return scale * scale * sum;
+    }
+    public static double ScalarProd(double[,] x, int i, int j, double[] scale) {
+      return ScalarProd(x, i, x, j, scale);
+    }
+
+    public static double ScalarProd(double[,] x, int i, double[,] xt, int j, double[] scale) {
+      double sum = 0.0;
+      for (int k = 0; k < x.GetLength(1); k++) {
+        sum += x[i, k] * scale[k] * xt[j, k] * scale[k];
+      }
+      return sum;
+    }
 
     public static IEnumerable<double> GetRow(double[,] x, int r) {

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

@@ -120 +120 @@
     </Compile>
     <Compile Include="FixedDataAnalysisAlgorithm.cs" />
+    <Compile Include="GaussianProcess\CovarianceMaternIso.cs" />
+    <Compile Include="GaussianProcess\CovarianceLinearArd.cs" />
     <Compile Include="GaussianProcess\CovarianceRQiso.cs" />
     <Compile Include="GaussianProcess\CovarianceNoise.cs" />