Changeset 8982 for trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs

Timestamp:

12/01/12 19:02:47 (12 years ago)

Author:

gkronber

Message:

#1902: removed class HyperParameter and changed implementations of covariance and mean functions to remove the parameter value caching and event handlers for parameter caching. Instead it is now possible to create the actual covariance and mean functions as Func from templates and specified parameter values. The instances of mean and covariance functions configured in the GUI are actually templates where the structure and fixed parameters can be specified.

File:

• trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunctions/CovarianceLinearArd.cs (modified) (7 diffs)

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

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -33 +34 @@
     Description = "Linear covariance function with automatic relevance determination for Gaussian processes.")]
   public sealed class CovarianceLinearArd : ParameterizedNamedItem, ICovarianceFunction {
-    [Storable]
-    private double[] inverseLength;
-    [Storable]
-    private readonly HyperParameter<DoubleArray> inverseLengthParameter;
     public IValueParameter<DoubleArray> InverseLengthParameter {
-      get { return inverseLengthParameter; }
+      get { return (IValueParameter<DoubleArray>)Parameters["InverseLength"]; }
     }
 
@@ -45 +42 @@
     private CovarianceLinearArd(CovarianceLinearArd original, Cloner cloner)
       : base(original, cloner) {
-      inverseLengthParameter = cloner.Clone(original.inverseLengthParameter);
-      if (original.inverseLength != null) {
-        this.inverseLength = new double[original.inverseLength.Length];
-        Array.Copy(original.inverseLength, inverseLength, inverseLength.Length);
-      }
-
-      RegisterEvents();
     }
     public CovarianceLinearArd()
@@ -58 +48 @@
       Description = ItemDescription;
 
-      inverseLengthParameter = new HyperParameter<DoubleArray>("InverseLength",
-                                                               "The inverse length parameter for ARD.");
-      Parameters.Add(inverseLengthParameter);
-      RegisterEvents();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEvents();
+      Parameters.Add(new OptionalValueParameter<DoubleArray>("InverseLength",
+                                                             "The inverse length parameter for ARD."));
     }
 
@@ -73 +56 @@
     }
 
-    // caching
-    private void RegisterEvents() {
-      Util.AttachArrayChangeHandler<DoubleArray, double>(inverseLengthParameter, () => { inverseLength = inverseLengthParameter.Value.ToArray(); });
-    }
-
-
     public int GetNumberOfParameters(int numberOfVariables) {
-      if (!inverseLengthParameter.Fixed)
+      if (InverseLengthParameter.Value == null)
         return numberOfVariables;
       else
@@ -86 +63 @@
     }
 
-    public void SetParameter(double[] hyp) {
-      if (!inverseLengthParameter.Fixed && hyp.Length > 0) {
-        inverseLengthParameter.SetValue(new DoubleArray(hyp.Select(e => 1.0 / Math.Exp(e)).ToArray()));
-      } else throw new ArgumentException("The length of the parameter vector does not match the number of free parameters for CovarianceLinearArd", "hyp");
+    public void SetParameter(double[] p) {
+      double[] inverseLength;
+      GetParameterValues(p, out inverseLength);
+      InverseLengthParameter.Value = new DoubleArray(inverseLength);
     }
 
-    public double GetCovariance(double[,] x, int i, int j, IEnumerable<int> columnIndices) {
-      return Util.ScalarProd(x, i, j, inverseLength, columnIndices);
+    private void GetParameterValues(double[] p, out double[] inverseLength) {
+      // gather parameter values
+      if (InverseLengthParameter.Value != null) {
+        inverseLength = InverseLengthParameter.Value.ToArray();
+      } else {
+        inverseLength = p.Select(e => 1.0 / Math.Exp(e)).ToArray();
+      }
     }
 
-    public IEnumerable<double> GetGradient(double[,] x, int i, int j, IEnumerable<int> columnIndices) {
+    public ParameterizedCovarianceFunction GetParameterizedCovarianceFunction(double[] p, IEnumerable<int> columnIndices) {
+      double[] inverseLength;
+      GetParameterValues(p, out inverseLength);
+      // create functions
+      var cov = new ParameterizedCovarianceFunction();
+      cov.Covariance = (x, i, j) => Util.ScalarProd(x, i, j, inverseLength, columnIndices);
+      cov.CrossCovariance = (x, xt, i, j) => Util.ScalarProd(x, i, xt, j, inverseLength, columnIndices);
+      cov.CovarianceGradient = (x, i, j) => GetGradient(x, i, j, inverseLength, columnIndices);
+      return cov;
+    }
+
+    private static IEnumerable<double> GetGradient(double[,] x, int i, int j, double[] inverseLength, IEnumerable<int> columnIndices) {
       if (columnIndices == null) columnIndices = Enumerable.Range(0, x.GetLength(1));
 
@@ -105 +98 @@
       }
     }
-
-    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j, IEnumerable<int> columnIndices) {
-      return Util.ScalarProd(x, i, xt, j, inverseLength, columnIndices);
-    }
   }
 }