Changeset 8582

Timestamp:

09/05/12 17:04:30 (12 years ago)

Author:

gkronber

Message:

#1902 implemented a few covariance functions as parameterized named items. Implemented rudimentary view for Gaussian process models.

Location:

trunk/sources

Files:

• HeuristicLab.Algorithms.DataAnalysis.Views/3.4/GaussianProcessModelView.Designer.cs (modified) (4 diffs)
• HeuristicLab.Algorithms.DataAnalysis.Views/3.4/GaussianProcessModelView.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceConst.cs (modified) (4 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceFunction.cs (added)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceLinear.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceLinearArd.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceMaternIso.cs (modified) (7 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovariancePeriodic.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/HyperParameter.cs (added)
• HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessModel.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/GaussianProcessModelView.Designer.cs

@@ -19 +19 @@
  */
 #endregion
+
+using HeuristicLab.Optimization.Views;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.Views {
@@ -45 +47 @@
     /// </summary>
     private void InitializeComponent() {
+      this.resultCollectionView = new ResultCollectionView();
       this.SuspendLayout();
+      // 
+      // resultCollectionView
+      // 
+      this.resultCollectionView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.resultCollectionView.Location = new System.Drawing.Point(0, 0);
+      this.resultCollectionView.Name = "resultCollectionView";
+      this.resultCollectionView.Size = new System.Drawing.Size(253, 251);
+      this.resultCollectionView.TabIndex = 0;
       // 
       // GaussianProcessModelView
@@ -51 +62 @@
       this.AllowDrop = true;
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.resultCollectionView);
       this.Name = "GaussianProcessModelView";
       this.Size = new System.Drawing.Size(253, 251);
@@ -59 +71 @@
     #endregion
 
-
+    private ResultCollectionView resultCollectionView;
 
   }

trunk/sources/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/GaussianProcessModelView.cs

@@ -21 +21 @@
 
 using System.Windows.Forms;
+using HeuristicLab.Data;
 using HeuristicLab.MainForm;
 using HeuristicLab.MainForm.WindowsForms;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.Views {
@@ -31 +33 @@
     public new IGaussianProcessModel Content {
       get { return (IGaussianProcessModel)base.Content; }
-      set { base.Content = value; }
+      set {
+        base.Content = value;
+      }
     }
 
@@ -43 +47 @@
       if (Content == null) {
         // clear
+        resultCollectionView.Content = null;
       } else {
-        // update
+        resultCollectionView.Content = CreateResultCollection(Content);
       }
+    }
+
+    private ResultCollection CreateResultCollection(IGaussianProcessModel gaussianProcessModel) {
+      var res = new ResultCollection();
+      res.Add(new Result("Mean Function", gaussianProcessModel.MeanFunction));
+      res.Add(new Result("Covariance Function", gaussianProcessModel.CovarianceFunction));
+      res.Add(new Result("Noise sigma", new DoubleValue(gaussianProcessModel.SigmaNoise)));
+      return res;
     }
   }

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

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -30 +31 @@
   [Item(Name = "CovarianceConst",
     Description = "Constant covariance function for Gaussian processes.")]
-  public class CovarianceConst : Item, ICovarianceFunction {
+  public class CovarianceConst : CovarianceFunction {
+
+    public IValueParameter<DoubleValue> ScaleParameter {
+      get { return scaleParameter; }
+    }
+
     [Storable]
-    private double sf2;
-    public double Scale { get { return sf2; } }
+    private readonly HyperParameter<DoubleValue> scaleParameter;
+
+    [Storable]
+    private double scale;
 
     [StorableConstructor]
@@ -42 +50 @@
     protected CovarianceConst(CovarianceConst original, Cloner cloner)
       : base(original, cloner) {
-      this.sf2 = original.sf2;
+      this.scaleParameter = cloner.Clone(original.scaleParameter);
+      this.scale = original.scale;
+
+      RegisterEvents();
     }
 
     public CovarianceConst()
       : base() {
+      scaleParameter = new HyperParameter<DoubleValue>("Scale", "The scale of the constant covariance function.");
+      Parameters.Add(scaleParameter);
+      RegisterEvents();
     }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    // caching
+    private void RegisterEvents() {
+      AttachValueChangeHandler<DoubleValue, double>(scaleParameter, () => { scale = scaleParameter.Value.Value; });
+    }
+
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -53 +78 @@
     }
 
-    public int GetNumberOfParameters(int numberOfVariables) {
-      return 1;
+    public override int GetNumberOfParameters(int numberOfVariables) {
+      return scaleParameter.Fixed ? 0 : 1;
     }
 
-    public void SetParameter(double[] hyp) {
-      if (hyp.Length != 1) throw new ArgumentException("CovarianceConst has only one hyperparameter", "k");
-      this.sf2 = Math.Exp(2 * hyp[0]);
+    public override void SetParameter(double[] hyp) {
+      if (!scaleParameter.Fixed && hyp.Length == 1) {
+        scaleParameter.SetValue(new DoubleValue(Math.Exp(2 * hyp[0])));
+      } else {
+        throw new ArgumentException("The length of the parameter vector does not match the number of free parameters for CovarianceConst", "hyp");
+      }
     }
 
-
-    public double GetCovariance(double[,] x, int i, int j) {
-      return sf2;
+    public override double GetCovariance(double[,] x, int i, int j) {
+      return scale;
     }
 
-    public IEnumerable<double> GetGradient(double[,] x, int i, int j) {
-      yield return 2 * sf2;
+    public override IEnumerable<double> GetGradient(double[,] x, int i, int j) {
+      yield return 2.0 * scale;
     }
 
-    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
-      return sf2;
+    public override double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
+      return scale;
     }
   }

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

@@ -29 +29 @@
   [StorableClass]
   [Item(Name = "CovarianceLinear", Description = "Linear covariance function for Gaussian processes.")]
-  public class CovarianceLinear : Item, ICovarianceFunction {
-    public int GetNumberOfParameters(int numberOfVariables) {
+  public class CovarianceLinear : CovarianceFunction {
+    public override int GetNumberOfParameters(int numberOfVariables) {
       return 0;
     }
@@ -46 +46 @@
     }
 
-    public void SetParameter(double[] hyp) {
+    public override void SetParameter(double[] hyp) {
       if (hyp.Length > 0) throw new ArgumentException("No hyperparameters are allowed for the linear covariance function.");
     }
 
-    public double GetCovariance(double[,] x, int i, int j) {
+    public override double GetCovariance(double[,] x, int i, int j) {
       return Util.ScalarProd(x, i, j);
     }
 
-    public IEnumerable<double> GetGradient(double[,] x, int i, int j) {
+    public override IEnumerable<double> GetGradient(double[,] x, int i, int j) {
       yield break;
     }
 
-    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
+    public override double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
       return Util.ScalarProd(x, i, xt, j);
     }

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

@@ -25 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -31 +32 @@
   [Item(Name = "CovarianceLinearArd",
     Description = "Linear covariance function with automatic relevance determination for Gaussian processes.")]
-  public class CovarianceLinearArd : Item, ICovarianceFunction {
+  public class CovarianceLinearArd : CovarianceFunction {
+    public IValueParameter<DoubleArray> InverseLengthParameter {
+      get { return inverseLengthParameter; }
+    }
+
+    [Storable]
+    private HyperParameter<DoubleArray> inverseLengthParameter;
+
     [Storable]
     private double[] inverseLength;
-    public double[] InverseLength {
-      get {
-        if (inverseLength == null) return null;
-        double[] res = new double[inverseLength.Length];
-        Array.Copy(inverseLength, res, res.Length);
-        return res;
-      }
-    }
-
-    public int GetNumberOfParameters(int numberOfVariables) {
-      return numberOfVariables;
-    }
 
     [StorableConstructor]
@@ -51 +47 @@
     protected CovarianceLinearArd(CovarianceLinearArd original, Cloner cloner)
       : base(original, cloner) {
-      this.inverseLength = original.InverseLength;  // array is copied in the getter
+      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()
       : base() {
+      inverseLengthParameter = new HyperParameter<DoubleArray>("InverseLength",
+                                                               "The inverse length parameter for ARD.");
+      Parameters.Add(inverseLengthParameter);
+      RegisterEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
     }
 
@@ -61 +72 @@
     }
 
-    public void SetParameter(double[] hyp) {
-      inverseLength = hyp.Select(e => 1.0 / Math.Exp(e)).ToArray();
+    // caching
+    private void RegisterEvents() {
+      AttachArrayChangeHandler<DoubleArray, double>(inverseLengthParameter, () => { inverseLength = inverseLengthParameter.Value.ToArray(); });
     }
 
-    public double GetCovariance(double[,] x, int i, int j) {
+
+    public override int GetNumberOfParameters(int numberOfVariables) {
+      if (!inverseLengthParameter.Fixed)
+        return numberOfVariables;
+      else
+        return 0;
+    }
+
+    public override 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 override double GetCovariance(double[,] x, int i, int j) {
       return Util.ScalarProd(x, i, j, inverseLength);
     }
 
-    public IEnumerable<double> GetGradient(double[,] x, int i, int j) {
+    public override 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];
@@ -75 +101 @@
     }
 
-    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
+    public override 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/CovarianceMaternIso.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -30 +33 @@
   [Item(Name = "CovarianceMaternIso",
     Description = "Matern covariance function for Gaussian processes.")]
-  public class CovarianceMaternIso : Item, ICovarianceFunction {
+  public class CovarianceMaternIso : CovarianceFunction {
+    public IValueParameter<DoubleValue> ScaleParameter {
+      get { return scaleParameter; }
+    }
+    public IValueParameter<DoubleValue> InverseLengthParameter {
+      get { return inverseLengthParameter; }
+    }
+    public IConstrainedValueParameter<IntValue> DParameter {
+      get { return dParameter; }
+    }
+
+    [Storable]
+    private readonly HyperParameter<DoubleValue> inverseLengthParameter;
+    [Storable]
+    private readonly HyperParameter<DoubleValue> scaleParameter;
+    [Storable]
+    private readonly ConstrainedValueParameter<IntValue> dParameter;
+
+    [Storable]
+    private double inverseLength;
     [Storable]
     private double sf2;
-    public double Scale { get { return sf2; } }
-    [Storable]
-    private double inverseLength;
-    public double InverseLength { get { return inverseLength; } }
     [Storable]
     private int d;
-    public int D {
-      get { return d; }
-      set {
-        if (value == 1 || value == 3 || value == 5) d = value;
-        else throw new ArgumentException("D can only take the values 1, 3, or 5");
-      }
-    }
 
     [StorableConstructor]
@@ -54 +65 @@
     protected CovarianceMaternIso(CovarianceMaternIso original, Cloner cloner)
       : base(original, cloner) {
+      this.scaleParameter = cloner.Clone(original.scaleParameter);
       this.sf2 = original.sf2;
+      this.inverseLengthParameter = cloner.Clone(original.inverseLengthParameter);
       this.inverseLength = original.inverseLength;
+      this.dParameter = cloner.Clone(original.dParameter);
       this.d = original.d;
+      RegisterEvents();
     }
 
     public CovarianceMaternIso()
       : base() {
-      d = 1;
+      inverseLengthParameter = new HyperParameter<DoubleValue>("InverseLength", "The inverse length parameter of the isometric Matern covariance function.");
+      scaleParameter = new HyperParameter<DoubleValue>("Scale", "The scale parameter of the isometric Matern covariance function.");
+      var validDValues = new ItemSet<IntValue>();
+      validDValues.Add((IntValue)new IntValue(1).AsReadOnly());
+      validDValues.Add((IntValue)new IntValue(3).AsReadOnly());
+      validDValues.Add((IntValue)new IntValue(5).AsReadOnly());
+      dParameter = new ConstrainedValueParameter<IntValue>("D", "The d parameter (allowed values: 1, 3, or 5) of the isometric Matern covariance function.", validDValues, validDValues.First());
+
+      Parameters.Add(inverseLengthParameter);
+      Parameters.Add(scaleParameter);
+      Parameters.Add(dParameter);
+
+      RegisterEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
     }
 
@@ -68 +100 @@
     }
 
-    public int GetNumberOfParameters(int numberOfVariables) {
-      return 2;
+    // caching
+    private void RegisterEvents() {
+      AttachValueChangeHandler<DoubleValue, double>(inverseLengthParameter, () => { inverseLength = inverseLengthParameter.Value.Value; });
+      AttachValueChangeHandler<DoubleValue, double>(scaleParameter, () => { sf2 = scaleParameter.Value.Value; });
+      AttachValueChangeHandler<IntValue, int>(dParameter, () => { d = dParameter.Value.Value; });
     }
 
-    public void SetParameter(double[] hyp) {
-      if (hyp.Length != 2) throw new ArgumentException("CovarianceMaternIso has two hyperparameters", "hyp");
-      this.inverseLength = 1.0 / Math.Exp(hyp[0]);
-      this.sf2 = Math.Exp(2 * hyp[1]);
+    public override int GetNumberOfParameters(int numberOfVariables) {
+      return
+        (inverseLengthParameter.Fixed ? 0 : 1) +
+        (scaleParameter.Fixed ? 0 : 1);
+    }
+
+    public override void SetParameter(double[] hyp) {
+      int i = 0;
+      if (!inverseLengthParameter.Fixed) {
+        inverseLengthParameter.SetValue(new DoubleValue(1.0 / Math.Exp(hyp[i])));
+        i++;
+      }
+      if (!scaleParameter.Fixed) {
+        scaleParameter.SetValue(new DoubleValue(Math.Exp(2 * hyp[i])));
+        i++;
+      }
+      if (hyp.Length != i) throw new ArgumentException("The length of the parameter vector does not match the number of free parameters for CovarianceMaternIso", "hyp");
     }
 
@@ -101 +149 @@
     }
 
-    public double GetCovariance(double[,] x, int i, int j) {
+    public override double GetCovariance(double[,] x, int i, int j) {
       double dist = i == j
                    ? 0.0
@@ -108 +156 @@
     }
 
-    public IEnumerable<double> GetGradient(double[,] x, int i, int j) {
+    public override IEnumerable<double> GetGradient(double[,] x, int i, int j) {
       double dist = i == j
                    ? 0.0
@@ -117 +165 @@
     }
 
-    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
+    public override double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
       double dist = Math.Sqrt(Util.SqrDist(x, i, xt, j, Math.Sqrt(d) * inverseLength));
       return sf2 * m(dist);

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

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -29 +31 @@
   [StorableClass]
   [Item(Name = "CovariancePeriodic", Description = "Periodic covariance function for Gaussian processes.")]
-  public class CovariancePeriodic : Item, ICovarianceFunction {
+  public class CovariancePeriodic : CovarianceFunction {
+    public IValueParameter<DoubleValue> ScaleParameter {
+      get { return scaleParameter; }
+    }
+    public IValueParameter<DoubleValue> InverseLengthParameter {
+      get { return inverseLengthParameter; }
+    }
+    public IValueParameter<DoubleValue> PeriodParameter {
+      get { return periodParameter; }
+    }
+
     [Storable]
-    private double sf2;
-    public double Scale { get { return sf2; } }
+    private HyperParameter<DoubleValue> scaleParameter;
+    [Storable]
+    private HyperParameter<DoubleValue> inverseLengthParameter;
+    [Storable]
+    private HyperParameter<DoubleValue> periodParameter;
+
+    [Storable]
+    private double scale;
     [Storable]
     private double inverseLength;
-    public double InverseLength { get { return inverseLength; } }
     [Storable]
-    private double p;
-    public double Period { get { return p; } }
+    private double period;
 
-    public int GetNumberOfParameters(int numberOfVariables) {
-      return 3;
-    }
+
     [StorableConstructor]
     protected CovariancePeriodic(bool deserializing) : base(deserializing) { }
     protected CovariancePeriodic(CovariancePeriodic original, Cloner cloner)
       : base(original, cloner) {
-      sf2 = original.sf2;
-      inverseLength = original.inverseLength;
-      p = original.p;
+      this.scaleParameter = cloner.Clone(original.scaleParameter);
+      this.inverseLengthParameter = cloner.Clone(original.inverseLengthParameter);
+      this.periodParameter = cloner.Clone(original.periodParameter);
+      this.scale = original.scale;
+      this.inverseLength = original.inverseLength;
+      this.period = original.period;
+
+      RegisterEvents();
     }
+
     public CovariancePeriodic()
       : base() {
+      scaleParameter = new HyperParameter<DoubleValue>("Scale", "The scale of the periodic covariance function.");
+      inverseLengthParameter = new HyperParameter<DoubleValue>("InverseLength", "The inverse length parameter for the periodic covariance function.");
+      periodParameter = new HyperParameter<DoubleValue>("Period", "The period parameter for the periodic covariance function.");
+      Parameters.Add(scaleParameter);
+      Parameters.Add(inverseLengthParameter);
+      Parameters.Add(periodParameter);
+
+      RegisterEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
     }
 
@@ -59 +92 @@
     }
 
-    public void SetParameter(double[] hyp) {
-      if (hyp.Length != 3) throw new ArgumentException();
-      this.inverseLength = 1.0 / Math.Exp(hyp[0]);
-      this.p = Math.Exp(hyp[1]);
-      this.sf2 = Math.Exp(2 * hyp[2]);
+    // caching
+    private void RegisterEvents() {
+      AttachValueChangeHandler<DoubleValue, double>(scaleParameter, () => { scale = scaleParameter.Value.Value; });
+      AttachValueChangeHandler<DoubleValue, double>(inverseLengthParameter, () => { inverseLength = inverseLengthParameter.Value.Value; });
+      AttachValueChangeHandler<DoubleValue, double>(periodParameter, () => { period = periodParameter.Value.Value; });
     }
 
-    public double GetCovariance(double[,] x, int i, int j) {
+    public override int GetNumberOfParameters(int numberOfVariables) {
+      return
+        (new[] { scaleParameter, inverseLengthParameter, periodParameter }).Count(p => !p.Fixed);
+    }
+
+    public override void SetParameter(double[] hyp) {
+      int i = 0;
+      if (!inverseLengthParameter.Fixed) {
+        inverseLengthParameter.SetValue(new DoubleValue(1.0 / Math.Exp(hyp[i])));
+        i++;
+      }
+      if (!periodParameter.Fixed) {
+        periodParameter.SetValue(new DoubleValue(Math.Exp(hyp[i])));
+        i++;
+      }
+      if (!scaleParameter.Fixed) {
+        scaleParameter.SetValue(new DoubleValue(Math.Exp(2 * hyp[i])));
+        i++;
+      }
+      if (hyp.Length != i) throw new ArgumentException("The length of the parameter vector does not match the number of free parameters for CovariancePeriod", "hyp");
+    }
+
+    public override double GetCovariance(double[,] x, int i, int j) {
       double k = i == j ? 0.0 : GetDistance(x, x, i, j);
-      k = Math.PI * k / p;
+      k = Math.PI * k / period;
       k = Math.Sin(k) * inverseLength;
       k = k * k;
 
-      return sf2 * Math.Exp(-2.0 * k);
+      return scale * Math.Exp(-2.0 * k);
     }
 
-    public IEnumerable<double> GetGradient(double[,] x, int i, int j) {
-      double v = i == j ? 0.0 : Math.PI * GetDistance(x, x, i, j) / p;
+    public override IEnumerable<double> GetGradient(double[,] x, int i, int j) {
+      double v = i == j ? 0.0 : Math.PI * GetDistance(x, x, i, j) / period;
       double gradient = Math.Sin(v) * inverseLength;
       gradient *= gradient;
-      yield return 4.0 * sf2 * Math.Exp(-2.0 * gradient) * gradient;
+      yield return 4.0 * scale * Math.Exp(-2.0 * gradient) * gradient;
       double r = Math.Sin(v) * inverseLength;
-      yield return 4.0 * sf2 * inverseLength * Math.Exp(-2 * r * r) * r * Math.Cos(v) * v;
-      yield return 2.0 * sf2 * Math.Exp(-2 * gradient);
+      yield return 4.0 * scale * inverseLength * Math.Exp(-2 * r * r) * r * Math.Cos(v) * v;
+      yield return 2.0 * scale * Math.Exp(-2 * gradient);
     }
 
-    public double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
+    public override double GetCrossCovariance(double[,] x, double[,] xt, int i, int j) {
       double k = GetDistance(x, xt, i, j);
-      k = Math.PI * k / p;
+      k = Math.PI * k / period;
       k = Math.Sin(k) * inverseLength;
       k = k * k;
 
-      return sf2 * Math.Exp(-2.0 * k);
+      return scale * Math.Exp(-2.0 * k);
     }
 

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

@@ -76 +76 @@
     [Storable]
     private double sqrSigmaNoise;
+    public double SigmaNoise {
+      get { return Math.Sqrt(sqrSigmaNoise); }
+    }
 
     [Storable]

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

@@ -120 +120 @@
     </Compile>
     <Compile Include="FixedDataAnalysisAlgorithm.cs" />
+    <Compile Include="GaussianProcess\HyperParameter.cs" />
+    <Compile Include="GaussianProcess\CovarianceFunction.cs" />
     <Compile Include="GaussianProcess\CovarianceRQArd.cs" />
     <Compile Include="GaussianProcess\CovarianceMaternIso.cs" />

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessModel.cs

@@ -29 +29 @@
   public interface IGaussianProcessModel : IRegressionModel {
     double NegativeLogLikelihood { get; }
+    double SigmaNoise { get; }
     IMeanFunction MeanFunction { get; }
     ICovarianceFunction CovarianceFunction { get; }