Improvements to WarpedGP class

Author: mandar2812

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/models/gp/AbstractGPRegressionModel.scala

@@ -28,6 +28,7 @@ import io.github.mandar2812.dynaml.algebra.PartitionedMatrixSolvers._
 import io.github.mandar2812.dynaml.kernels.{DiracKernel, LocalScalarKernel, SVMKernel}
 import io.github.mandar2812.dynaml.models.{ContinuousProcess, SecondOrderProcess}
 import io.github.mandar2812.dynaml.optimization.GloballyOptWithGrad
+import io.github.mandar2812.dynaml.pipes.DataPipe
 import io.github.mandar2812.dynaml.probability.MultGaussianPRV
 import org.apache.log4j.Logger
 
@@ -391,4 +392,18 @@ object AbstractGPRegressionModel {
     else if(order > 0 && ex == 0) new GPNarModel(order, cov, noise, data).asInstanceOf[M]
     else new GPNarXModel(order, ex, cov, noise, data).asInstanceOf[M]
   }
+
+  def apply[T, I](
+    cov: LocalScalarKernel[I],
+    noise: LocalScalarKernel[I])(
+    trainingdata: T, num: Int)(
+    implicit transform: DataPipe[T, Seq[(I, Double)]], ct: ClassTag[I]) =
+    new AbstractGPRegressionModel[T, I](cov, noise, trainingdata, num) {
+      /**
+        * Convert from the underlying data structure to
+        * Seq[(I, Y)] where I is the index set of the GP
+        * and Y is the value/label type.
+        **/
+      override def dataAsSeq(data: T) = transform(data)
+    }
 }

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/models/gp/WarpedGP.scala

@@ -5,7 +5,7 @@ import io.github.mandar2812.dynaml.algebra.{PartitionedMatrix, PartitionedVector
 import io.github.mandar2812.dynaml.analysis.{DifferentiableMap, PartitionedVectorField, PushforwardMap}
 import io.github.mandar2812.dynaml.models.{ContinuousProcess, SecondOrderProcess}
 import io.github.mandar2812.dynaml.optimization.GloballyOptWithGrad
-import io.github.mandar2812.dynaml.pipes.DataPipe
+import io.github.mandar2812.dynaml.pipes.{DataPipe, Encoder}
 import io.github.mandar2812.dynaml.probability.{E, MeasurableDistrRV}
 import io.github.mandar2812.dynaml.utils
 
@@ -15,8 +15,10 @@ import scala.reflect.ClassTag
   * Created by mandar on 02/01/2017.
   */
 abstract class WarpedGP[T, I](p: AbstractGPRegressionModel[T, I])(
-  wFuncT: PushforwardMap[Double, Double, Double])(
-  implicit ev: ClassTag[I], pf: PartitionedVectorField)
+  warpingFunc: PushforwardMap[Double, Double, Double])(
+  implicit ev: ClassTag[I],
+  pf: PartitionedVectorField,
+  transform: Encoder[T, Seq[(I, Double)]])
   extends ContinuousProcess[
     T, I, Double,
     MeasurableDistrRV[PartitionedVector, PartitionedVector, PartitionedMatrix]]
@@ -25,6 +27,41 @@ abstract class WarpedGP[T, I](p: AbstractGPRegressionModel[T, I])(
     MeasurableDistrRV[PartitionedVector, PartitionedVector, PartitionedMatrix]]
   with GloballyOptWithGrad {
 
+  /**
+    * The training data
+    **/
+  override protected val g: T = p.data
+
+  private val dataProcessPipe = transform >
+    DataPipe((s: Seq[(I, Double)]) => s.map(pattern => (pattern._1, warpingFunc.i(pattern._2)))) >
+    transform.i
+
+  val underlyingProcess =
+    AbstractGPRegressionModel[T, I](
+      p.covariance, p.noiseModel)(
+      dataProcessPipe(p.data), p.npoints)(transform, ev)
+
+
+  /**
+    * Mean Function: Takes a member of the index set (input)
+    * and returns the corresponding mean of the distribution
+    * corresponding to input.
+    **/
+  override val mean = p.mean
+  /**
+    * Underlying covariance function of the
+    * Gaussian Processes.
+    **/
+  override val covariance = p.covariance
+  /**
+    * Stores the names of the hyper-parameters
+    **/
+  override protected var hyper_parameters: List[String] = underlyingProcess._hyper_parameters
+  /**
+    * A Map which stores the current state of
+    * the system.
+    **/
+  override protected var current_state: Map[String, Double] = underlyingProcess._current_state
 
   //Define the default determinant implementation
   implicit val detImpl = DataPipe(
@@ -33,11 +70,11 @@ abstract class WarpedGP[T, I](p: AbstractGPRegressionModel[T, I])(
   //Define the push forward map for the multivariate case
   val wFuncPredDistr: PushforwardMap[PartitionedVector, PartitionedVector, PartitionedMatrix] =
     PushforwardMap(
-      DataPipe((v: PartitionedVector) => v.map(c => (c._1, c._2.map(wFuncT.run)))),
+      DataPipe((v: PartitionedVector) => v.map(c => (c._1, c._2.map(warpingFunc.run)))),
       DifferentiableMap(
-        (v: PartitionedVector) => v.map(c => (c._1, c._2.map(wFuncT.i.run))),
+        (v: PartitionedVector) => v.map(c => (c._1, c._2.map(warpingFunc.i.run))),
         (v: PartitionedVector) => new PartitionedMatrix(
-          v._data.map(l => ((l._1, l._1), diag(l._2.map(wFuncT.i.J)))) ++
+          v._data.map(l => ((l._1, l._1), diag(l._2.map(warpingFunc.i.J)))) ++
             utils.combine(Seq((0 until v.rowBlocks.toInt).toList, (0 until v.rowBlocks.toInt).toList))
               .map(c =>
                 (c.head.toLong, c.last.toLong))
@@ -52,28 +89,10 @@ abstract class WarpedGP[T, I](p: AbstractGPRegressionModel[T, I])(
     * 2) Y- : The lower error bar estimate (mean - sigma*stdDeviation)
     * 3) Y+ : The upper error bar. (mean + sigma*stdDeviation)
     **/
-  override def predictionWithErrorBars[U <: Seq[I]](testData: U, sigma: Int) = ???
-
-  /**
-    * Mean Function: Takes a member of the index set (input)
-    * and returns the corresponding mean of the distribution
-    * corresponding to input.
-    **/
-  override val mean = p.mean
-  /**
-    * Underlying covariance function of the
-    * Gaussian Processes.
-    **/
-  override val covariance = p.covariance
-  /**
-    * Stores the names of the hyper-parameters
-    **/
-  override protected var hyper_parameters: List[String] = p._hyper_parameters
-  /**
-    * A Map which stores the current state of
-    * the system.
-    **/
-  override protected var current_state: Map[String, Double] = p._current_state
+  override def predictionWithErrorBars[U <: Seq[I]](testData: U, sigma: Int) =
+    underlyingProcess
+      .predictionWithErrorBars(testData, sigma)
+      .map(d => (d._1, warpingFunc(d._2), warpingFunc(d._3), warpingFunc(d._4)))
 
   /**
     * Calculates the energy of the configuration,
@@ -86,33 +105,37 @@ abstract class WarpedGP[T, I](p: AbstractGPRegressionModel[T, I])(
     * @param options Optional parameters about configuration
     * @return Configuration Energy E(h)
     **/
-  override def energy(h: Map[String, Double], options: Map[String, String]) = p.energy(h, options)
+  override def energy(h: Map[String, Double], options: Map[String, String]) = {
+    val trainingLabels = PartitionedVector(
+      dataAsSeq(g).toStream.map(_._2),
+      underlyingProcess.npoints.toLong, underlyingProcess._blockSize
+    )
+
+    detImpl(wFuncPredDistr.i.J(trainingLabels))*underlyingProcess.energy(h, options)
+  }
+
 
   /** Calculates posterior predictive distribution for
     * a particular set of test data points.
     *
     * @param test A Sequence or Sequence like data structure
     *             storing the values of the input patters.
     **/
-  override def predictiveDistribution[U <: Seq[I]](test: U) = wFuncPredDistr -> p.predictiveDistribution(test)
+  override def predictiveDistribution[U <: Seq[I]](test: U) =
+    wFuncPredDistr -> underlyingProcess.predictiveDistribution(test)
 
   /**
     * Convert from the underlying data structure to
     * Seq[(I, Y)] where I is the index set of the GP
     * and Y is the value/label type.
     **/
-  override def dataAsSeq(data: T) = p.dataAsSeq(data)
-
-  /**
-    * The training data
-    **/
-  override protected val g: T = p.data
+  override def dataAsSeq(data: T) = transform(data)
 
   /**
     * Predict the value of the
     * target variable given a
     * point.
     *
     **/
-  override def predict(point: I) = wFuncT(p.predictionWithErrorBars(Seq(point), 1).head._2)
+  override def predict(point: I) = warpingFunc(underlyingProcess.predictionWithErrorBars(Seq(point), 1).head._2)
 }