Add metadata to OpStandardScaler to allow for descaling

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

@@ -60,9 +60,19 @@ 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
+
+ // Since is a UnaryEstimator from RealNN to RealNN, exactly one value will be in std and mean
+ val stdVal = std.head
+ val meanVal = mean.head
+ val scalingArgs = LinearScalerArgs(1 / stdVal, - meanVal / stdVal)
+ 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] {
@@ -59,6 +61,8 @@ class OpScalarStandardScalerTest extends OpEstimatorSpec[RealNN, UnaryModel[Real
  1.150792911137501.toRealNN
  )
 
+ val descaleValues = Seq(10.0, 100.0, 1000.0)
+ val (descaleData, testD) = TestFeatureBuilder(descaleValues.map(_.toRealNN))
 
  val (inputData, testF) = TestFeatureBuilder(Seq(10, 100, 1000).map(_.toRealNN))
 
@@ -148,6 +152,39 @@ 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(testD)
+ val normedOutput = featureNormalizer.getOutput()
+ val metadata = featureNormalizer.fit(descaleData).getMetadata()
+
+ val expectedMean = descaleValues.sum / descaleValues.length
+ val expectedStd = math.sqrt(descaleValues.map(value => math.pow(expectedMean - value, 2)).sum
+ / (descaleValues.length - 1))
+ 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]
+ math.abs((meta.scalingArgs.asInstanceOf[LinearScalerArgs].slope - expectedSlope)
+ / expectedSlope) should be < 0.001
+ math.abs((meta.scalingArgs.asInstanceOf[LinearScalerArgs].intercept - expectedIntercept)
+ / 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(descaleData).train()
+ val transformed = wfModel.score()
+
+ val actual = transformed.collect().map(_.getAs[Double](1))
+ val expected : Seq[Double] = descaleValues
+ 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) }