Merge branch 'PCAEstimator' of https://github.com/sfilipi/machinelearning-1 into PCAEstimator

Author: sfilipi

src/Microsoft.ML.Data/Scorers/BinaryClassifierScorer.cs

@@ -298,6 +298,6 @@ private static ColumnType GetPredColType(ColumnType scoreType, ISchemaBoundRowMa
         }
 
         private static bool OutputTypeMatches(ColumnType scoreType)
-        => scoreType == NumberType.Float;
+            => scoreType == NumberType.Float;
     }
 }

src/Microsoft.ML.Data/Scorers/PredictionTransformer.cs

@@ -20,6 +20,9 @@
 [assembly: LoadableClass(typeof(RankingPredictionTransformer<IPredictorProducing<float>>), typeof(RankingPredictionTransformer), null, typeof(SignatureLoadModel),
     "", RankingPredictionTransformer.LoaderSignature)]
 
+[assembly: LoadableClass(typeof(AnomalyPredictionTransformer<IPredictorProducing<float>>), typeof(AnomalyPredictionTransformer), null, typeof(SignatureLoadModel),
+    "", AnomalyPredictionTransformer.LoaderSignature)]
+
 namespace Microsoft.ML.Runtime.Data
 {
 
@@ -174,8 +177,6 @@ public SingleFeaturePredictionTransformerBase(IHost host, TModel model, ISchema
                 FeatureColumnType = trainSchema.GetColumnType(col);
 
             BindableMapper = ScoreUtils.GetSchemaBindableMapper(Host, model);
-
-            GetScorer();
         }
 
         internal SingleFeaturePredictionTransformerBase(IHost host, ModelLoadContext ctx)
@@ -221,13 +222,80 @@ protected virtual void SaveCore(ModelSaveContext ctx)
             ctx.SaveStringOrNull(FeatureColumn);
         }
 
-        protected virtual GenericScorer GetScorer()
+        protected virtual GenericScorer GetGenericScorer()
         {
             var schema = new RoleMappedSchema(TrainSchema, null, FeatureColumn);
             return new GenericScorer(Host, new GenericScorer.Arguments(), new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);
         }
     }
 
+    /// <summary>
+    /// Base class for the <see cref="ISingleFeaturePredictionTransformer{TModel}"/> working on anomaly detection tasks.
+    /// </summary>
+    /// <typeparam name="TModel">An implementation of the <see cref="IPredictorProducing{TResult}"/></typeparam>
+    public sealed class AnomalyPredictionTransformer<TModel> : SingleFeaturePredictionTransformerBase<TModel, BinaryClassifierScorer>
+        where TModel : class, IPredictorProducing<float>
+    {
+        public readonly string ThresholdColumn;
+        public readonly float Threshold;
+
+        public AnomalyPredictionTransformer(IHostEnvironment env, TModel model, ISchema inputSchema, string featureColumn,
+            float threshold = 0f, string thresholdColumn = DefaultColumnNames.Score)
+            : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(BinaryPredictionTransformer<TModel>)), model, inputSchema, featureColumn)
+        {
+            Host.CheckNonEmpty(thresholdColumn, nameof(thresholdColumn));
+            Threshold = threshold;
+            ThresholdColumn = thresholdColumn;
+
+            SetScorer();
+        }
+
+        public AnomalyPredictionTransformer(IHostEnvironment env, ModelLoadContext ctx)
+            : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(BinaryPredictionTransformer<TModel>)), ctx)
+        {
+            // *** Binary format ***
+            // <base info>
+            // float: scorer threshold
+            // id of string: scorer threshold column
+
+            Threshold = ctx.Reader.ReadSingle();
+            ThresholdColumn = ctx.LoadString();
+            SetScorer();
+        }
+
+        private void SetScorer()
+        {
+            var schema = new RoleMappedSchema(TrainSchema, null, FeatureColumn);
+            var args = new BinaryClassifierScorer.Arguments { Threshold = Threshold, ThresholdColumn = ThresholdColumn };
+            Scorer = new BinaryClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);
+        }
+
+        protected override void SaveCore(ModelSaveContext ctx)
+        {
+            Contracts.AssertValue(ctx);
+            ctx.SetVersionInfo(GetVersionInfo());
+
+            // *** Binary format ***
+            // <base info>
+            // float: scorer threshold
+            // id of string: scorer threshold column
+            base.SaveCore(ctx);
+
+            ctx.Writer.Write(Threshold);
+            ctx.SaveString(ThresholdColumn);
+        }
+
+        private static VersionInfo GetVersionInfo()
+        {
+            return new VersionInfo(
+                modelSignature: "ANOMPRED",
+                verWrittenCur: 0x00010001, // Initial
+                verReadableCur: 0x00010001,
+                verWeCanReadBack: 0x00010001,
+                loaderSignature: AnomalyPredictionTransformer.LoaderSignature);
+        }
+    }
+
     /// <summary>
     /// Base class for the <see cref="ISingleFeaturePredictionTransformer{TModel}"/> working on binary classification tasks.
     /// </summary>
@@ -367,11 +435,13 @@ public sealed class RegressionPredictionTransformer<TModel> : SingleFeaturePredi
         public RegressionPredictionTransformer(IHostEnvironment env, TModel model, ISchema inputSchema, string featureColumn)
             : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(RegressionPredictionTransformer<TModel>)), model, inputSchema, featureColumn)
         {
+            Scorer = GetGenericScorer();
         }
 
         internal RegressionPredictionTransformer(IHostEnvironment env, ModelLoadContext ctx)
             : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(RegressionPredictionTransformer<TModel>)), ctx)
         {
+            Scorer = GetGenericScorer();
         }
 
         protected override void SaveCore(ModelSaveContext ctx)
@@ -387,7 +457,7 @@ protected override void SaveCore(ModelSaveContext ctx)
         private static VersionInfo GetVersionInfo()
         {
             return new VersionInfo(
-                modelSignature: "MC  PRED",
+                modelSignature: "REG PRED",
                 verWrittenCur: 0x00010001, // Initial
                 verReadableCur: 0x00010001,
                 verWeCanReadBack: 0x00010001,
@@ -396,17 +466,23 @@ private static VersionInfo GetVersionInfo()
         }
     }
 
+    /// <summary>
+    /// Base class for the <see cref="ISingleFeaturePredictionTransformer{TModel}"/> working on ranking tasks.
+    /// </summary>
+    /// <typeparam name="TModel">An implementation of the <see cref="IPredictorProducing{TResult}"/></typeparam>
     public sealed class RankingPredictionTransformer<TModel> : SingleFeaturePredictionTransformerBase<TModel, GenericScorer>
     where TModel : class, IPredictorProducing<float>
     {
         public RankingPredictionTransformer(IHostEnvironment env, TModel model, ISchema inputSchema, string featureColumn)
             : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(RankingPredictionTransformer<TModel>)), model, inputSchema, featureColumn)
         {
+            Scorer = GetGenericScorer();
         }
 
         internal RankingPredictionTransformer(IHostEnvironment env, ModelLoadContext ctx)
             : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(RankingPredictionTransformer<TModel>)), ctx)
         {
+            Scorer = GetGenericScorer();
         }
 
         protected override void SaveCore(ModelSaveContext ctx)
@@ -422,7 +498,7 @@ protected override void SaveCore(ModelSaveContext ctx)
         private static VersionInfo GetVersionInfo()
         {
             return new VersionInfo(
-                modelSignature: "MC  RANK",
+                modelSignature: "RANK PRED",
                 verWrittenCur: 0x00010001, // Initial
                 verReadableCur: 0x00010001,
                 verWeCanReadBack: 0x00010001,
@@ -462,4 +538,12 @@ internal static class RankingPredictionTransformer
         public static RankingPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)
             => new RankingPredictionTransformer<IPredictorProducing<float>>(env, ctx);
     }
+
+    internal static class AnomalyPredictionTransformer
+    {
+        public const string LoaderSignature = "AnomalyPredXfer";
+
+        public static AnomalyPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)
+            => new AnomalyPredictionTransformer<IPredictorProducing<float>>(env, ctx);
+    }
 }

src/Microsoft.ML.PCA/PcaTrainer.cs

@@ -42,7 +42,7 @@ namespace Microsoft.ML.Runtime.PCA
     /// <remarks>
     /// This PCA can be made into Kernel PCA by using Random Fourier Features transform
     /// </remarks>
-    public sealed class RandomizedPcaTrainer : TrainerEstimatorBase<BinaryPredictionTransformer<PcaPredictor>, PcaPredictor>
+    public sealed class RandomizedPcaTrainer : TrainerEstimatorBase<AnomalyPredictionTransformer<PcaPredictor>, PcaPredictor>
     {
         public const string LoadNameValue = "pcaAnomaly";
         internal const string UserNameValue = "PCA Anomaly Detector";
@@ -335,8 +335,8 @@ protected override SchemaShape.Column[] GetOutputColumnsCore(SchemaShape inputSc
             };
         }
 
-        protected override BinaryPredictionTransformer<PcaPredictor> MakeTransformer(PcaPredictor model, ISchema trainSchema)
-            => new BinaryPredictionTransformer<PcaPredictor>(Host, model, trainSchema, _featureColumn);
+        protected override AnomalyPredictionTransformer<PcaPredictor> MakeTransformer(PcaPredictor model, ISchema trainSchema)
+            => new AnomalyPredictionTransformer<PcaPredictor>(Host, model, trainSchema, _featureColumn);
 
         [TlcModule.EntryPoint(Name = "Trainers.PcaAnomalyDetector",
             Desc = "Train an PCA Anomaly model.",