Changeset 8612 for trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanLinear.cs

Timestamp:

09/10/12 13:28:55 (12 years ago)

Author:

gkronber

Message:

#1902 implemented all mean and covariance functions with parameters as ParameterizedNamedItems

File:

• trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanLinear.cs (modified) (3 diffs)

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

@@ -19 +19 @@
  */
 #endregion
+
 using System;
 using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -28 +30 @@
   [StorableClass]
   [Item(Name = "MeanLinear", Description = "Linear mean function for Gaussian processes.")]
-  public class MeanLinear : Item, IMeanFunction {
+  public sealed class MeanLinear : ParameterizedNamedItem, IMeanFunction {
     [Storable]
-    private double[] alpha;
-    public double[] Weights {
-      get {
-        if (alpha == null) return new double[0];
-        var copy = new double[alpha.Length];
-        Array.Copy(alpha, copy, copy.Length);
-        return copy;
+    private double[] weights;
+    [Storable]
+    private readonly HyperParameter<DoubleArray> weightsParameter;
+    public IValueParameter<DoubleArray> WeightsParameter { get { return weightsParameter; } }
+
+    [StorableConstructor]
+    private MeanLinear(bool deserializing) : base(deserializing) { }
+    private MeanLinear(MeanLinear original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.weights != null) {
+        this.weights = new double[original.weights.Length];
+        Array.Copy(original.weights, weights, original.weights.Length);
       }
-    }
-    public int GetNumberOfParameters(int numberOfVariables) {
-      return numberOfVariables;
-    }
-    [StorableConstructor]
-    protected MeanLinear(bool deserializing) : base(deserializing) { }
-    protected MeanLinear(MeanLinear original, Cloner cloner)
-      : base(original, cloner) {
-      if (original.alpha != null) {
-        this.alpha = new double[original.alpha.Length];
-        Array.Copy(original.alpha, alpha, original.alpha.Length);
-      }
+      weightsParameter = cloner.Clone(original.weightsParameter);
+      RegisterEvents();
     }
     public MeanLinear()
       : base() {
+      this.weightsParameter = new HyperParameter<DoubleArray>("Weights", "The weights parameter for the linear mean function.");
+      Parameters.Add(weightsParameter);
+      RegisterEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MeanLinear(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    private void RegisterEvents() {
+      Util.AttachArrayChangeHandler<DoubleArray, double>(weightsParameter, () => {
+        weights = weightsParameter.Value.ToArray();
+      });
+    }
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return weightsParameter.Fixed ? 0 : numberOfVariables;
     }
 
     public void SetParameter(double[] hyp) {
-      this.alpha = new double[hyp.Length];
-      Array.Copy(hyp, alpha, hyp.Length);
-    }
-    public void SetData(double[,] x) {
-      // nothing to do
+      if (!weightsParameter.Fixed) {
+        weightsParameter.SetValue(new DoubleArray(hyp));
+      } else if (hyp.Length != 0) throw new ArgumentException("The length of the parameter vector does not match the number of free parameters for the linear mean function.", "hyp");
     }
 
     public double[] GetMean(double[,] x) {
       // sanity check
-      if (alpha.Length != x.GetLength(1)) throw new ArgumentException("The number of hyperparameters must match the number of variables for the linear mean function.");
+      if (weights.Length != x.GetLength(1)) throw new ArgumentException("The number of hyperparameters must match the number of variables for the linear mean function.");
       int cols = x.GetLength(1);
       int n = x.GetLength(0);
       return (from i in Enumerable.Range(0, n)
-              let rowVector = from j in Enumerable.Range(0, cols)
-                              select x[i, j]
-              select Util.ScalarProd(alpha, rowVector))
+              let rowVector = Enumerable.Range(0, cols).Select(j => x[i, j])
+              select Util.ScalarProd(weights, rowVector))
         .ToArray();
     }
@@ -79 +95 @@
       int n = x.GetLength(0);
       if (k > cols) throw new ArgumentException();
-      return (from r in Enumerable.Range(0, n)
-              select x[r, k]).ToArray();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MeanLinear(this, cloner);
+      return (Enumerable.Range(0, n).Select(r => x[r, k])).ToArray();
     }
   }