Add metadata to OpStandardScaler to allow for descaling

core/src/main/scala/com/salesforce/op/stages/impl/feature/OpScalarStandardScaler.scala

@@ -60,9 +60,17 @@ class OpScalarStandardScaler
     val internalScaler = new MLLibStandardScaler(withMean = estimator.getWithMean, withStd = estimator.getWithStd)
     val scalerModel = internalScaler.fit(vecData)
 
+    val std = scalerModel.std.toArray
+    val mean = scalerModel.mean.toArray
+    val stdMean = std.sum / std.length
+    val meanMean = mean.sum / mean.length
+    val scalingArgs = LinearScalerArgs(1 / stdMean, meanMean / stdMean)
+    val meta = ScalerMetadata(ScalingType.Linear, scalingArgs).toMetadata()
+    setMetadata(meta)
+
     new OpScalarStandardScalerModel(
-      std = scalerModel.std.toArray,
-      mean = scalerModel.mean.toArray,
+      std = std,
+      mean = mean,
       withStd = scalerModel.withStd,
       withMean = scalerModel.withMean,
       operationName = operationName,

core/src/test/scala/com/salesforce/op/stages/impl/feature/OpScalarStandardScalerTest.scala

@@ -44,6 +44,8 @@ import org.junit.runner.RunWith
 import org.scalatest.FlatSpec
 import org.scalatest.junit.JUnitRunner
 
+import scala.util.{Failure, Success}
+
 
 @RunWith(classOf[JUnitRunner])
 class OpScalarStandardScalerTest extends OpEstimatorSpec[RealNN, UnaryModel[RealNN, RealNN], OpScalarStandardScaler] {
@@ -148,6 +150,35 @@ class OpScalarStandardScalerTest extends OpEstimatorSpec[RealNN, UnaryModel[Real
     assert(sumSqDist <= 0.000001, "===> the sum of squared distances between actual and expected should be zero.")
   }
 
+  it should "descale and work in standardized workflow" in {
+    val featureNormalizer = new OpScalarStandardScaler().setInput(testF)
+    val normedOutput = featureNormalizer.getOutput()
+    val metadata = featureNormalizer.fit(inputData).getMetadata()
+    val expectedStd = 90.0 * math.sqrt(37.0)
+    val expectedMean = 370.0
+    val expectedSlope = 1 / expectedStd
+    val expectedIntercept = expectedMean / expectedStd
+    ScalerMetadata(metadata) match {
+      case Failure(err) => fail(err)
+      case Success(meta) =>
+        meta shouldBe a[ScalerMetadata]
+        meta.scalingType shouldBe ScalingType.Linear
+        meta.scalingArgs shouldBe a[LinearScalerArgs]
+        meta.scalingArgs.asInstanceOf[LinearScalerArgs].slope - expectedSlope should be < 0.001
+        meta.scalingArgs.asInstanceOf[LinearScalerArgs].intercept - expectedIntercept should be < 0.001
+    }
+
+    val descaledResponse = new DescalerTransformer[RealNN, RealNN, RealNN]()
+      .setInput(normedOutput, normedOutput).getOutput()
+    val workflow = new OpWorkflow().setResultFeatures(descaledResponse)
+    val wfModel = workflow.setInputDataset(inputData).train()
+    val transformed = wfModel.score()
+
+    val actual = transformed.collect().map(_.getAs[Double](1))
+    val expected = Array(-730.0, -640.0, 260.0)
+    all(actual.zip(expected).map(x => math.abs(x._2 - x._1))) should be < 0.0001
+  }
+
   private def validateDataframeDoubleColumn(normalizedFeatureDF: DataFrame, scaledFeatureName: String,
     targetColumnName: String): Double = {
     val sqDistUdf = udf { (leftCol: Double, rightCol: Double) => Math.pow(leftCol - rightCol, 2) }