dynaml-core: Added spearman correlation to RegressionMetrics

Signed-off-by: mandar2812 <[email protected]>

Author: mandar2812

build.sbt

@@ -90,30 +90,17 @@ lazy val DynaML = (project in file(".")).enablePlugins(JavaAppPackaging, BuildIn
     buildInfoKeys := Seq[BuildInfoKey](name, version, scalaVersion, sbtVersion),
     buildInfoPackage := "io.github.mandar2812.dynaml.repl",
     buildInfoUsePackageAsPath := true,
-    mappings in Universal ++= Seq({
-      // we are using the reference.conf as default application.conf
-      // the user can override settings here
-      val init = (resourceDirectory in Compile).value / "DynaMLInit.scala"
-      init -> "conf/DynaMLInit.scala"
-    }, {
-      val banner = (resourceDirectory in Compile).value / "dynamlBanner.txt"
-      banner -> "conf/banner.txt"
-    }, {
-      val zeppelin_env = (resourceDirectory in Compile).value / "zeppelin-site.xml"
-      zeppelin_env -> "conf/zeppelin-site.xml"
-    }, {
-      val zeppelin_shiro = (resourceDirectory in Compile).value / "shiro.ini.template"
-      zeppelin_shiro -> "conf/shiro.ini"
-    }, {
-      val zeppelinConf = (resourceDirectory in Compile).value / "interpreter-setting.json"
-      zeppelinConf -> "lib/interpreter-setting.json"
-    }, {
-      val common = (resourceDirectory in Compile).value / "common.sh"
-      common -> "bin/common.sh"
-    }, {
-      val intp = (resourceDirectory in Compile).value / "interpreter.sh"
-      intp -> "bin/interpreter.sh"
-    }),
+    mappings in Universal ++= Seq(
+      {
+        //Initialization script for the DynaML REPL
+        val init = (resourceDirectory in Compile).value / "DynaMLInit.scala"
+        init -> "conf/DynaMLInit.scala"
+      },
+      {
+        val banner = (resourceDirectory in Compile).value / "dynamlBanner.txt"
+        banner -> "conf/banner.txt"
+      }
+    ),
     javaOptions in Universal ++= Seq(
       // -J params will be added as jvm parameters
       "-J-Xmx2048m",

dynaml-core/src/main/scala-2.11/io/github/mandar2812/dynaml/evaluation/RegressionMetrics.scala

@@ -34,9 +34,7 @@ import io.github.mandar2812.dynaml.algebra.square
 
 class RegressionMetrics(
     override protected val scoresAndLabels: List[(Double, Double)],
-    val len: Int)
-  extends Metrics[Double] {
-  private val logger = Logger.getLogger(this.getClass)
+    val len: Int) extends Metrics[Double] {
 
   val length: Int = len
 
@@ -54,6 +52,8 @@ class RegressionMetrics(
 
   val corr: Double = RegressionMetrics.computeCorr(scoresAndLabels, length)
 
+  val sp_corr: Double = RegressionMetrics.computeSpearmanCorr(scoresAndLabels, length)
+
   val predictionEfficiency = scoresAndLabels.map((p) =>
     math.pow(p._1 - p._2, 2)/length).sum
 
@@ -85,14 +85,17 @@ class RegressionMetrics(
     scala.Predef.print("Corr. Coefficient = ")
     pprint.pprintln(corr)
 
+    scala.Predef.print("Spearman Corr. Coefficient = ")
+    pprint.pprintln(sp_corr)
+
     scala.Predef.print("Model Yield = ")
     pprint.pprintln(modelYield)
 
     scala.Predef.print("Std Dev of Residuals = ")
     pprint.pprintln(sigma)
   }
 
-  override def kpi() = DenseVector(mae, rmse, Rsq, corr)
+  override def kpi() = DenseVector(mae, rmse, Rsq, corr, sp_corr)
 
   override def generatePlots(): Unit = {
     println("Generating Plot of Residuals")
@@ -130,7 +133,7 @@ object RegressionMetrics {
     val mean: Double = scoresAndLabels.map{coup => coup._2}.sum/size
     var SSres = 0.0
     var SStot = 0.0
-    scoresAndLabels.foreach((couple) => {
+    scoresAndLabels.foreach(couple => {
       SSres += math.pow(couple._2 - couple._1, 2)
       SStot += math.pow(couple._2 - mean, 2)
     })
@@ -144,7 +147,7 @@ object RegressionMetrics {
     var SSLabel = 0.0
     var SSPred = 0.0
     var SSLabelPred = 0.0
-    scoresAndLabels.foreach((couple) => {
+    scoresAndLabels.foreach(couple => {
       SSLabel += math.pow(couple._2 - meanLabel, 2)
       SSPred += math.pow(couple._1 - meanScore, 2)
       SSLabelPred += (couple._1 - meanScore)*(couple._2 - meanLabel)
@@ -153,16 +156,39 @@ object RegressionMetrics {
     SSLabelPred/(math.sqrt(SSPred)*math.sqrt(SSLabel))
   }
 
+  def computeSpearmanCorr(scoresAndLabels: Iterable[(Double, Double)], size: Int): Double = {
+
+    val (predictions, targets) = scoresAndLabels.toSeq.unzip
+
+    val addOneToIndex = (p: (Double, Int)) => (p._1, p._2 + 1)
+
+    def sort_with_ranks(seq: Seq[Double]) =
+      seq.sorted
+        .zipWithIndex
+        .map(addOneToIndex)
+        .groupBy(_._1)
+        .map(coll => (coll._1, coll._2.map(_._2)))
+        .mapValues(values => values.sum.toDouble/values.length)
+
+    val preds_rank_map   = sort_with_ranks(predictions)
+    val targets_rank_map = sort_with_ranks(targets)
+
+    val ranks_preds      = predictions.map(preds_rank_map(_))
+    val ranks_targets    = targets.map(targets_rank_map(_))
+
+    computeCorr(ranks_preds.zip(ranks_targets), size)
+  }
+
   def computeYield(scoresAndLabels: Iterable[(Double, Double)], size: Int): Double =
     (scoresAndLabels.map(_._1).max - scoresAndLabels.map(_._1).min)/
       (scoresAndLabels.map(_._2).max - scoresAndLabels.map(_._2).min)
 
 }
 
-class MultiRegressionMetrics(override protected val scoresAndLabels: List[(DenseVector[Double], DenseVector[Double])],
-                             val len: Int)
-  extends Metrics[DenseVector[Double]] {
-  private val logger = Logger.getLogger(this.getClass)
+class MultiRegressionMetrics(
+  override protected val scoresAndLabels: List[(DenseVector[Double], DenseVector[Double])],
+  val len: Int) extends Metrics[DenseVector[Double]] {
+
 
   val num_outputs: Int = scoresAndLabels.head._2.length
 

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

@@ -35,12 +35,13 @@ import io.github.mandar2812.dynaml.pipes.DataPipe
   * f(x) ~ GP(0, cov(X,X))
   * e|f(x) ~ N(0, noise(X,X))
   */
-class GPNarXModel(order: Int,
-                  ex: Int,
-                  cov: LocalScalarKernel[DenseVector[Double]],
-                  nL: LocalScalarKernel[DenseVector[Double]],
-                  trainingdata: Seq[(DenseVector[Double], Double)],
-                  meanFunc: DataPipe[DenseVector[Double], Double] = DataPipe(_ => 0.0)) extends
+class GPNarXModel(
+  order: Int,
+  ex: Int,
+  cov: LocalScalarKernel[DenseVector[Double]],
+  nL: LocalScalarKernel[DenseVector[Double]],
+  trainingdata: Seq[(DenseVector[Double], Double)],
+  meanFunc: DataPipe[DenseVector[Double], Double] = DataPipe(_ => 0.0)) extends
 GPRegression(cov, nL, trainingdata, meanFunc) {
 
   val modelOrder = order

dynaml-examples/src/main/scala-2.11/io/github/mandar2812/dynaml/examples/AbottPowerPlant.scala

@@ -23,9 +23,9 @@ import com.quantifind.charts.Highcharts._
 import io.github.mandar2812.dynaml.DynaMLPipe._
 import io.github.mandar2812.dynaml.evaluation.{MultiRegressionMetrics, RegressionMetrics}
 import io.github.mandar2812.dynaml.kernels.LocalScalarKernel
-import io.github.mandar2812.dynaml.models.gp.GPNarXModel
+import io.github.mandar2812.dynaml.models.gp.{AbstractGPRegressionModel, GPNarXModel, GPRegression}
 import io.github.mandar2812.dynaml.models.stp.MVStudentsTModel
-import io.github.mandar2812.dynaml.optimization.{GradBasedGlobalOptimizer, GridSearch, ProbGPCommMachine}
+import io.github.mandar2812.dynaml.optimization.{GlobalOptimizer, GradBasedGlobalOptimizer, GridSearch, ProbGPCommMachine}
 import io.github.mandar2812.dynaml.pipes.{DataPipe, StreamDataPipe}
 import io.github.mandar2812.dynaml.utils.GaussianScaler
 
@@ -39,6 +39,7 @@ object AbottPowerPlant {
   type Features = DenseVector[Double]
   type Kernel = LocalScalarKernel[Features]
   type Scales = (GaussianScaler, GaussianScaler)
+  type GPModel = AbstractGPRegressionModel[Seq[(DenseVector[Double], Double)], DenseVector[Double]]
 
   type Data = Stream[(Features, Features)]
 
@@ -172,20 +173,18 @@ object AbottPowerPlant {
     //create RegressionMetrics instance and produce plots
 
     val modelTrainTest =
-      (trainTest: ((Stream[(Features, Double)],
-        Stream[(Features, Double)]),
-        (Features, Features))) => {
+      (trainTest: ((Stream[(Features, Double)], Stream[(Features, Double)]), (Features, Features))) => {
 
         val model = new GPNarXModel(deltaT, 4, kernel,
           noise, trainTest._1._1)
 
-        val gs = opt("globalOpt") match {
-          case "GS" => new GridSearch[model.type](model)
+        val gs: GlobalOptimizer[GPModel] = opt("globalOpt") match {
+          case "GS" => new GridSearch[GPModel](model)
             .setGridSize(opt("grid").toInt)
             .setStepSize(opt("step").toDouble)
             .setLogScale(false)
 
-          case "ML" => new GradBasedGlobalOptimizer[model.type](model)
+          case "ML" => new GradBasedGlobalOptimizer(model)
 
           case "GPC" => new ProbGPCommMachine(model)
             .setPolicy(opt("policy"))
@@ -198,7 +197,7 @@ object AbottPowerPlant {
 
         val startConf = kernel.effective_state ++ noise.effective_state
 
-        val (optModel, _) = gs.optimize(startConf, opt)
+        val (optModel, _): (GPModel, Map[String, Double]) = gs.optimize(startConf, opt)
 
         val res = optModel.test(trainTest._1._2)
 
@@ -209,13 +208,16 @@ object AbottPowerPlant {
             l._4*trainTest._2._2(-1) + trainTest._2._1(-1))})
 
         val scoresAndLabelsPipe =
-          DataPipe(
-            (res: Seq[(Features, Double, Double, Double, Double)]) =>
-              res.map(i => (i._3, i._2, i._4, i._5)).toList) > deNormalize
+          DataPipe[
+            Seq[(Features, Double, Double, Double, Double)],
+            List[(Double, Double, Double, Double)]](
+            _.map(i => (i._3, i._2, i._4, i._5)).toList) >
+            deNormalize
 
         val scoresAndLabels = scoresAndLabelsPipe.run(res.toList)
 
-        val metrics = new RegressionMetrics(scoresAndLabels.map(i => (i._1, i._2)),
+        val metrics = new RegressionMetrics(
+          scoresAndLabels.map(i => (i._1, i._2)),
           scoresAndLabels.length)
 
         val (name, name1) =