use the contravariance of ISingleFeaturePredictionTransformer instead of loading PredictionTransformer<object> from file

yaeldMS · yaeldMS · commit 297a677c1ac9 · 2019-03-07T15:08:00.000-08:00
diff --git a/src/Microsoft.ML.Data/Prediction/Calibrator.cs b/src/Microsoft.ML.Data/Prediction/Calibrator.cs
@@ -61,15 +61,15 @@
     "Calibrated Predictor Executor",
     ValueMapperCalibratedModelParameters<IPredictorProducing<float>, ICalibrator>.LoaderSignature, "BulkCaliPredExec")]
 
-[assembly: LoadableClass(typeof(FeatureWeightsCalibratedModelParameters<object, ICalibrator>), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(CalibratedModelParametersBase), typeof(FeatureWeightsCalibratedModelParameters<IPredictorProducing<float>, ICalibrator>), null, typeof(SignatureLoadModel),
     "Feature Weights Calibrated Predictor Executor",
     FeatureWeightsCalibratedModelParameters<IPredictorWithFeatureWeights<float>, ICalibrator>.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(ParameterMixingCalibratedModelParameters<object, ICalibrator>), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(CalibratedModelParametersBase), typeof(ParameterMixingCalibratedModelParameters<IPredictorProducing<float>, ICalibrator>), null, typeof(SignatureLoadModel),
     "Parameter Mixing Calibrated Predictor Executor",
     ParameterMixingCalibratedModelParameters<IPredictorWithFeatureWeights<float>, ICalibrator>.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(SchemaBindableCalibratedModelParameters<object, ICalibrator>), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(CalibratedModelParametersBase), typeof(SchemaBindableCalibratedModelParameters<IPredictorProducing<float>, ICalibrator>), null, typeof(SignatureLoadModel),
     "Schema Bindable Calibrated Predictor", SchemaBindableCalibratedModelParameters<IPredictorProducing<float>, ICalibrator>.LoaderSignature)]
 
 [assembly: LoadableClass(typeof(void), typeof(Calibrate), null, typeof(SignatureEntryPointModule), "Calibrate")]
@@ -490,7 +490,7 @@ private FeatureWeightsCalibratedModelParameters(IHostEnvironment env, ModelLoadC
             _featureWeights = (IPredictorWithFeatureWeights<float>)SubModel;
         }
 
-        private static FeatureWeightsCalibratedModelParameters<TSubModel, TCalibrator> Create(IHostEnvironment env, ModelLoadContext ctx)
+        private static CalibratedModelParametersBase Create(IHostEnvironment env, ModelLoadContext ctx)
         {
             Contracts.CheckValue(env, nameof(env));
             env.CheckValue(ctx, nameof(ctx));
@@ -557,7 +557,7 @@ private ParameterMixingCalibratedModelParameters(IHostEnvironment env, ModelLoad
             _featureWeights = SubModel as IPredictorWithFeatureWeights<float>;
         }
 
-        private static ParameterMixingCalibratedModelParameters<TSubModel, TCalibrator> Create(IHostEnvironment env, ModelLoadContext ctx)
+        private static CalibratedModelParametersBase Create(IHostEnvironment env, ModelLoadContext ctx)
         {
             Contracts.CheckValue(env, nameof(env));
             env.CheckValue(ctx, nameof(ctx));
@@ -729,7 +729,7 @@ private SchemaBindableCalibratedModelParameters(IHostEnvironment env, ModelLoadC
             _featureContribution = SubModel as IFeatureContributionMapper;
         }
 
-        private static SchemaBindableCalibratedModelParameters<TSubModel, TCalibrator> Create(IHostEnvironment env, ModelLoadContext ctx)
+        private static CalibratedModelParametersBase Create(IHostEnvironment env, ModelLoadContext ctx)
         {
             Contracts.CheckValue(ctx, nameof(ctx));
             ctx.CheckAtModel(GetVersionInfo());
diff --git a/src/Microsoft.ML.Data/Prediction/IPredictionTransformer.cs b/src/Microsoft.ML.Data/Prediction/IPredictionTransformer.cs
@@ -14,6 +14,7 @@ namespace Microsoft.ML
     /// </summary>
     /// <typeparam name="TModel">The <see cref="IPredictor"/> or <see cref="ICalibrator"/> used for the data transformation.</typeparam>
     public interface IPredictionTransformer<out TModel> : ITransformer
+        where TModel : class
     {
         TModel Model { get; }
     }
@@ -25,6 +26,7 @@ public interface IPredictionTransformer<out TModel> : ITransformer
     /// </summary>
     /// <typeparam name="TModel">The <see cref="IPredictor"/> or <see cref="ICalibrator"/> used for the data transformation.</typeparam>
     public interface ISingleFeaturePredictionTransformer<out TModel> : IPredictionTransformer<TModel>
+        where TModel : class
     {
         /// <summary>The name of the feature column.</summary>
         string FeatureColumn { get; }
diff --git a/src/Microsoft.ML.Data/Scorers/PredictionTransformer.cs b/src/Microsoft.ML.Data/Scorers/PredictionTransformer.cs
@@ -8,22 +8,22 @@
 using Microsoft.ML.Data;
 using Microsoft.ML.Data.IO;
 
-[assembly: LoadableClass(typeof(BinaryPredictionTransformer<object>), typeof(BinaryPredictionTransformer), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(BinaryPredictionTransformer<IPredictorProducing<float>>), typeof(BinaryPredictionTransformer), null, typeof(SignatureLoadModel),
     "", BinaryPredictionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(MulticlassPredictionTransformer<object>), typeof(MulticlassPredictionTransformer), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(MulticlassPredictionTransformer<IPredictorProducing<VBuffer<float>>>), typeof(MulticlassPredictionTransformer), null, typeof(SignatureLoadModel),
     "", MulticlassPredictionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(RegressionPredictionTransformer<object>), typeof(RegressionPredictionTransformer), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(RegressionPredictionTransformer<IPredictorProducing<float>>), typeof(RegressionPredictionTransformer), null, typeof(SignatureLoadModel),
     "", RegressionPredictionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(RankingPredictionTransformer<object>), typeof(RankingPredictionTransformer), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(RankingPredictionTransformer<IPredictorProducing<float>>), typeof(RankingPredictionTransformer), null, typeof(SignatureLoadModel),
     "", RankingPredictionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(AnomalyPredictionTransformer<object>), typeof(AnomalyPredictionTransformer), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(AnomalyPredictionTransformer<IPredictorProducing<float>>), typeof(AnomalyPredictionTransformer), null, typeof(SignatureLoadModel),
     "", AnomalyPredictionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(ClusteringPredictionTransformer<object>), typeof(ClusteringPredictionTransformer), null, typeof(SignatureLoadModel),
+[assembly: LoadableClass(typeof(ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>>), typeof(ClusteringPredictionTransformer), null, typeof(SignatureLoadModel),
     "", ClusteringPredictionTransformer.LoaderSignature)]
 
 namespace Microsoft.ML.Data
@@ -51,7 +51,8 @@ public abstract class PredictionTransformerBase<TModel> : IPredictionTransformer
         private protected readonly IHost Host;
         [BestFriend]
         private protected ISchemaBindableMapper BindableMapper;
-        protected DataViewSchema TrainSchema;
+        [BestFriend]
+        private protected DataViewSchema TrainSchema;
 
         /// <summary>
         /// Whether a call to <see cref="ITransformer.GetRowToRowMapper(DataViewSchema)"/> should succeed, on an
@@ -141,7 +142,8 @@ IRowToRowMapper ITransformer.GetRowToRowMapper(DataViewSchema inputSchema)
 
         private protected abstract void SaveModel(ModelSaveContext ctx);
 
-        protected void SaveModelCore(ModelSaveContext ctx)
+        [BestFriend]
+        private protected void SaveModelCore(ModelSaveContext ctx)
         {
             // *** Binary format ***
             // <base info>
@@ -233,14 +235,14 @@ public sealed override DataViewSchema GetOutputSchema(DataViewSchema inputSchema
             return Transform(new EmptyDataView(Host, inputSchema)).Schema;
         }
 
-        private protected override void SaveModel(ModelSaveContext ctx)
+        private protected sealed override void SaveModel(ModelSaveContext ctx)
         {
             Host.CheckValue(ctx, nameof(ctx));
             ctx.CheckAtModel();
             SaveCore(ctx);
         }
 
-        protected virtual void SaveCore(ModelSaveContext ctx)
+        private protected virtual void SaveCore(ModelSaveContext ctx)
         {
             SaveModelCore(ctx);
             ctx.SaveStringOrNull(FeatureColumn);
@@ -295,7 +297,7 @@ private void SetScorer()
             Scorer = new BinaryClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);
         }
 
-        protected override void SaveCore(ModelSaveContext ctx)
+        private protected override void SaveCore(ModelSaveContext ctx)
         {
             Contracts.AssertValue(ctx);
             ctx.SetVersionInfo(GetVersionInfo());
@@ -364,7 +366,7 @@ private void SetScorer()
             Scorer = new BinaryClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);
         }
 
-        protected override void SaveCore(ModelSaveContext ctx)
+        private protected override void SaveCore(ModelSaveContext ctx)
         {
             Contracts.AssertValue(ctx);
             ctx.SetVersionInfo(GetVersionInfo());
@@ -428,7 +430,7 @@ private void SetScorer()
             Scorer = new MultiClassClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);
         }
 
-        protected override void SaveCore(ModelSaveContext ctx)
+        private protected override void SaveCore(ModelSaveContext ctx)
         {
             Contracts.AssertValue(ctx);
             ctx.SetVersionInfo(GetVersionInfo());
@@ -473,7 +475,7 @@ internal RegressionPredictionTransformer(IHostEnvironment env, ModelLoadContext
             Scorer = GetGenericScorer();
         }
 
-        protected override void SaveCore(ModelSaveContext ctx)
+        private protected override void SaveCore(ModelSaveContext ctx)
         {
             Contracts.AssertValue(ctx);
             ctx.SetVersionInfo(GetVersionInfo());
@@ -515,7 +517,7 @@ internal RankingPredictionTransformer(IHostEnvironment env, ModelLoadContext ctx
             Scorer = GetGenericScorer();
         }
 
-        protected override void SaveCore(ModelSaveContext ctx)
+        private protected override void SaveCore(ModelSaveContext ctx)
         {
             Contracts.AssertValue(ctx);
             ctx.SetVersionInfo(GetVersionInfo());
@@ -567,7 +569,7 @@ internal ClusteringPredictionTransformer(IHostEnvironment env, ModelLoadContext
             Scorer = new ClusteringScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);
         }
 
-        protected override void SaveCore(ModelSaveContext ctx)
+        private protected override void SaveCore(ModelSaveContext ctx)
         {
             Contracts.AssertValue(ctx);
             ctx.SetVersionInfo(GetVersionInfo());
@@ -594,47 +596,47 @@ internal static class BinaryPredictionTransformer
     {
         public const string LoaderSignature = "BinaryPredXfer";
 
-        public static BinaryPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)
-            => new BinaryPredictionTransformer<object>(env, ctx);
+        public static BinaryPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)
+            => new BinaryPredictionTransformer<IPredictorProducing<float>>(env, ctx);
     }
 
     internal static class MulticlassPredictionTransformer
     {
         public const string LoaderSignature = "MulticlassPredXfer";
 
-        public static MulticlassPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)
-            => new MulticlassPredictionTransformer<object>(env, ctx);
+        public static MulticlassPredictionTransformer<IPredictorProducing<VBuffer<float>>> Create(IHostEnvironment env, ModelLoadContext ctx)
+            => new MulticlassPredictionTransformer<IPredictorProducing<VBuffer<float>>>(env, ctx);
     }
 
     internal static class RegressionPredictionTransformer
     {
         public const string LoaderSignature = "RegressionPredXfer";
 
-        public static RegressionPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)
-            => new RegressionPredictionTransformer<object>(env, ctx);
+        public static RegressionPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)
+            => new RegressionPredictionTransformer<IPredictorProducing<float>>(env, ctx);
     }
 
     internal static class RankingPredictionTransformer
     {
         public const string LoaderSignature = "RankingPredXfer";
 
-        public static RankingPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)
-            => new RankingPredictionTransformer<object>(env, ctx);
+        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<object> Create(IHostEnvironment env, ModelLoadContext ctx)
-            => new AnomalyPredictionTransformer<object>(env, ctx);
+        public static AnomalyPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)
+            => new AnomalyPredictionTransformer<IPredictorProducing<float>>(env, ctx);
     }
 
     internal static class ClusteringPredictionTransformer
     {
         public const string LoaderSignature = "ClusteringPredXfer";
 
-        public static ClusteringPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)
-            => new ClusteringPredictionTransformer<object>(env, ctx);
+        public static ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>> Create(IHostEnvironment env, ModelLoadContext ctx)
+            => new ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>>(env, ctx);
     }
 }
diff --git a/src/Microsoft.ML.Transforms/PermutationFeatureImportance.cs b/src/Microsoft.ML.Transforms/PermutationFeatureImportance.cs
@@ -15,7 +15,9 @@
 
 namespace Microsoft.ML.Transforms
 {
-    internal static class PermutationFeatureImportance<TModel, TMetric, TResult> where TResult : MetricsStatisticsBase<TMetric>, new()
+    internal static class PermutationFeatureImportance<TModel, TMetric, TResult>
+        where TResult : MetricsStatisticsBase<TMetric>, new()
+        where TModel : class
     {
         public static ImmutableArray<TResult>
             GetImportanceMetricsMatrix(
diff --git a/src/Microsoft.ML.Transforms/PermutationFeatureImportanceExtensions.cs b/src/Microsoft.ML.Transforms/PermutationFeatureImportanceExtensions.cs
@@ -63,7 +63,7 @@ public static ImmutableArray<RegressionMetricsStatistics>
                 string features = DefaultColumnNames.Features,
                 bool useFeatureWeightFilter = false,
                 int? topExamples = null,
-                int permutationCount = 1)
+                int permutationCount = 1) where TModel : class
         {
             return PermutationFeatureImportance<TModel, RegressionMetrics, RegressionMetricsStatistics>.GetImportanceMetricsMatrix(
                             catalog.GetEnvironment(),
@@ -140,7 +140,7 @@ public static ImmutableArray<BinaryClassificationMetricsStatistics>
                 string features = DefaultColumnNames.Features,
                 bool useFeatureWeightFilter = false,
                 int? topExamples = null,
-                int permutationCount = 1)
+                int permutationCount = 1) where TModel : class
         {
             return PermutationFeatureImportance<TModel, BinaryClassificationMetrics, BinaryClassificationMetricsStatistics>.GetImportanceMetricsMatrix(
                             catalog.GetEnvironment(),
@@ -214,7 +214,7 @@ public static ImmutableArray<MultiClassClassifierMetricsStatistics>
                 string features = DefaultColumnNames.Features,
                 bool useFeatureWeightFilter = false,
                 int? topExamples = null,
-                int permutationCount = 1)
+                int permutationCount = 1) where TModel : class
         {
             return PermutationFeatureImportance<TModel, MultiClassClassifierMetrics, MultiClassClassifierMetricsStatistics>.GetImportanceMetricsMatrix(
                             catalog.GetEnvironment(),
@@ -295,7 +295,7 @@ public static ImmutableArray<RankingMetricsStatistics>
                 string features = DefaultColumnNames.Features,
                 bool useFeatureWeightFilter = false,
                 int? topExamples = null,
-                int permutationCount = 1)
+                int permutationCount = 1) where TModel : class
         {
             return PermutationFeatureImportance<TModel, RankingMetrics, RankingMetricsStatistics>.GetImportanceMetricsMatrix(
                             catalog.GetEnvironment(),
diff --git a/test/Microsoft.ML.Tests/Scenarios/Api/Estimators/DeserializationTests.cs b/test/Microsoft.ML.Tests/Scenarios/Api/Estimators/DeserializationTests.cs
@@ -48,7 +48,7 @@ public void LoadModelAndExtractPredictor()
                 loadedModel = ml.Model.Load(fs);
 
             var gam = (((loadedModel as TransformerChain<ITransformer>).LastTransformer
-                as BinaryPredictionTransformer<object>).Model
+                as ISingleFeaturePredictionTransformer<object>).Model
                 as CalibratedModelParametersBase).SubModel
                 as BinaryClassificationGamModelParameters;
             Assert.NotNull(gam);
@@ -92,9 +92,12 @@ public void SaveAndLoadModelWithLoader()
             data.Schema["Features"].GetSlotNames(ref slotNames);
             var ageIndex = FindIndex(slotNames.GetValues(), "age");
             var transformer = (loadedModel as CompositeDataLoader<IMultiStreamSource, ITransformer>).Transformer.LastTransformer;
-            var gamModel = ((transformer as BinaryPredictionTransformer<object>).Model
-                as CalibratedModelParametersBase).SubModel
-                as BinaryClassificationGamModelParameters;
+            var singleFeaturePredictionTransformer = transformer as ISingleFeaturePredictionTransformer<object>;
+            Assert.NotNull(singleFeaturePredictionTransformer);
+            var calibratedModelParameters = singleFeaturePredictionTransformer.Model as CalibratedModelParametersBase;
+            Assert.NotNull(calibratedModelParameters);
+            var gamModel = calibratedModelParameters.SubModel as BinaryClassificationGamModelParameters;
+            Assert.NotNull(gamModel);
             var ageBinUpperBounds = gamModel.GetBinUpperBounds(ageIndex);
             var ageBinEffects = gamModel.GetBinEffects(ageIndex);
         }

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ namespace Microsoft.ML`
`14`	`14`	`/// </summary>`
`15`	`15`	`/// <typeparam name="TModel">The <see cref="IPredictor"/> or <see cref="ICalibrator"/> used for the data transformation.</typeparam>`
`16`	`16`	`public interface IPredictionTransformer<out TModel> : ITransformer`
	`17`	`+ where TModel : class`
`17`	`18`	`{`
`18`	`19`	`TModel Model { get; }`
`19`	`20`	`}`
`@@ -25,6 +26,7 @@ public interface IPredictionTransformer<out TModel> : ITransformer`
`25`	`26`	`/// </summary>`
`26`	`27`	`/// <typeparam name="TModel">The <see cref="IPredictor"/> or <see cref="ICalibrator"/> used for the data transformation.</typeparam>`
`27`	`28`	`public interface ISingleFeaturePredictionTransformer<out TModel> : IPredictionTransformer<TModel>`
	`29`	`+ where TModel : class`
`28`	`30`	`{`
`29`	`31`	`/// <summary>The name of the feature column.</summary>`
`30`	`32`	`string FeatureColumn { get; }`
Original file line number	Diff line number	Diff line change
`@@ -8,22 +8,22 @@`
`8`	`8`	`using Microsoft.ML.Data;`
`9`	`9`	`using Microsoft.ML.Data.IO;`
`10`	`10`
`11`		`-[assembly: LoadableClass(typeof(BinaryPredictionTransformer<object>), typeof(BinaryPredictionTransformer), null, typeof(SignatureLoadModel),`
	`11`	`+[assembly: LoadableClass(typeof(BinaryPredictionTransformer<IPredictorProducing<float>>), typeof(BinaryPredictionTransformer), null, typeof(SignatureLoadModel),`
`12`	`12`	`"", BinaryPredictionTransformer.LoaderSignature)]`
`13`	`13`
`14`		`-[assembly: LoadableClass(typeof(MulticlassPredictionTransformer<object>), typeof(MulticlassPredictionTransformer), null, typeof(SignatureLoadModel),`
	`14`	`+[assembly: LoadableClass(typeof(MulticlassPredictionTransformer<IPredictorProducing<VBuffer<float>>>), typeof(MulticlassPredictionTransformer), null, typeof(SignatureLoadModel),`
`15`	`15`	`"", MulticlassPredictionTransformer.LoaderSignature)]`
`16`	`16`
`17`		`-[assembly: LoadableClass(typeof(RegressionPredictionTransformer<object>), typeof(RegressionPredictionTransformer), null, typeof(SignatureLoadModel),`
	`17`	`+[assembly: LoadableClass(typeof(RegressionPredictionTransformer<IPredictorProducing<float>>), typeof(RegressionPredictionTransformer), null, typeof(SignatureLoadModel),`
`18`	`18`	`"", RegressionPredictionTransformer.LoaderSignature)]`
`19`	`19`
`20`		`-[assembly: LoadableClass(typeof(RankingPredictionTransformer<object>), typeof(RankingPredictionTransformer), null, typeof(SignatureLoadModel),`
	`20`	`+[assembly: LoadableClass(typeof(RankingPredictionTransformer<IPredictorProducing<float>>), typeof(RankingPredictionTransformer), null, typeof(SignatureLoadModel),`
`21`	`21`	`"", RankingPredictionTransformer.LoaderSignature)]`
`22`	`22`
`23`		`-[assembly: LoadableClass(typeof(AnomalyPredictionTransformer<object>), typeof(AnomalyPredictionTransformer), null, typeof(SignatureLoadModel),`
	`23`	`+[assembly: LoadableClass(typeof(AnomalyPredictionTransformer<IPredictorProducing<float>>), typeof(AnomalyPredictionTransformer), null, typeof(SignatureLoadModel),`
`24`	`24`	`"", AnomalyPredictionTransformer.LoaderSignature)]`
`25`	`25`
`26`		`-[assembly: LoadableClass(typeof(ClusteringPredictionTransformer<object>), typeof(ClusteringPredictionTransformer), null, typeof(SignatureLoadModel),`
	`26`	`+[assembly: LoadableClass(typeof(ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>>), typeof(ClusteringPredictionTransformer), null, typeof(SignatureLoadModel),`
`27`	`27`	`"", ClusteringPredictionTransformer.LoaderSignature)]`
`28`	`28`
`29`	`29`	`namespace Microsoft.ML.Data`
`@@ -51,7 +51,8 @@ public abstract class PredictionTransformerBase<TModel> : IPredictionTransformer`
`51`	`51`	`private protected readonly IHost Host;`
`52`	`52`	`[BestFriend]`
`53`	`53`	`private protected ISchemaBindableMapper BindableMapper;`
`54`		`- protected DataViewSchema TrainSchema;`
	`54`	`+ [BestFriend]`
	`55`	`+ private protected DataViewSchema TrainSchema;`
`55`	`56`
`56`	`57`	`/// <summary>`
`57`	`58`	`/// Whether a call to <see cref="ITransformer.GetRowToRowMapper(DataViewSchema)"/> should succeed, on an`
`@@ -141,7 +142,8 @@ IRowToRowMapper ITransformer.GetRowToRowMapper(DataViewSchema inputSchema)`
`141`	`142`
`142`	`143`	`private protected abstract void SaveModel(ModelSaveContext ctx);`
`143`	`144`
`144`		`- protected void SaveModelCore(ModelSaveContext ctx)`
	`145`	`+ [BestFriend]`
	`146`	`+ private protected void SaveModelCore(ModelSaveContext ctx)`
`145`	`147`	`{`
`146`	`148`	`// * Binary format *`
`147`	`149`	`// <base info>`
`@@ -233,14 +235,14 @@ public sealed override DataViewSchema GetOutputSchema(DataViewSchema inputSchema`
`233`	`235`	`return Transform(new EmptyDataView(Host, inputSchema)).Schema;`
`234`	`236`	`}`
`235`	`237`
`236`		`- private protected override void SaveModel(ModelSaveContext ctx)`
	`238`	`+ private protected sealed override void SaveModel(ModelSaveContext ctx)`
`237`	`239`	`{`
`238`	`240`	`Host.CheckValue(ctx, nameof(ctx));`
`239`	`241`	`ctx.CheckAtModel();`
`240`	`242`	`SaveCore(ctx);`
`241`	`243`	`}`
`242`	`244`
`243`		`- protected virtual void SaveCore(ModelSaveContext ctx)`
	`245`	`+ private protected virtual void SaveCore(ModelSaveContext ctx)`
`244`	`246`	`{`
`245`	`247`	`SaveModelCore(ctx);`
`246`	`248`	`ctx.SaveStringOrNull(FeatureColumn);`
`@@ -295,7 +297,7 @@ private void SetScorer()`
`295`	`297`	`Scorer = new BinaryClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);`
`296`	`298`	`}`
`297`	`299`
`298`		`- protected override void SaveCore(ModelSaveContext ctx)`
	`300`	`+ private protected override void SaveCore(ModelSaveContext ctx)`
`299`	`301`	`{`
`300`	`302`	`Contracts.AssertValue(ctx);`
`301`	`303`	`ctx.SetVersionInfo(GetVersionInfo());`
`@@ -364,7 +366,7 @@ private void SetScorer()`
`364`	`366`	`Scorer = new BinaryClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);`
`365`	`367`	`}`
`366`	`368`
`367`		`- protected override void SaveCore(ModelSaveContext ctx)`
	`369`	`+ private protected override void SaveCore(ModelSaveContext ctx)`
`368`	`370`	`{`
`369`	`371`	`Contracts.AssertValue(ctx);`
`370`	`372`	`ctx.SetVersionInfo(GetVersionInfo());`
`@@ -428,7 +430,7 @@ private void SetScorer()`
`428`	`430`	`Scorer = new MultiClassClassifierScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);`
`429`	`431`	`}`
`430`	`432`
`431`		`- protected override void SaveCore(ModelSaveContext ctx)`
	`433`	`+ private protected override void SaveCore(ModelSaveContext ctx)`
`432`	`434`	`{`
`433`	`435`	`Contracts.AssertValue(ctx);`
`434`	`436`	`ctx.SetVersionInfo(GetVersionInfo());`
`@@ -473,7 +475,7 @@ internal RegressionPredictionTransformer(IHostEnvironment env, ModelLoadContext`
`473`	`475`	`Scorer = GetGenericScorer();`
`474`	`476`	`}`
`475`	`477`
`476`		`- protected override void SaveCore(ModelSaveContext ctx)`
	`478`	`+ private protected override void SaveCore(ModelSaveContext ctx)`
`477`	`479`	`{`
`478`	`480`	`Contracts.AssertValue(ctx);`
`479`	`481`	`ctx.SetVersionInfo(GetVersionInfo());`
`@@ -515,7 +517,7 @@ internal RankingPredictionTransformer(IHostEnvironment env, ModelLoadContext ctx`
`515`	`517`	`Scorer = GetGenericScorer();`
`516`	`518`	`}`
`517`	`519`
`518`		`- protected override void SaveCore(ModelSaveContext ctx)`
	`520`	`+ private protected override void SaveCore(ModelSaveContext ctx)`
`519`	`521`	`{`
`520`	`522`	`Contracts.AssertValue(ctx);`
`521`	`523`	`ctx.SetVersionInfo(GetVersionInfo());`
`@@ -567,7 +569,7 @@ internal ClusteringPredictionTransformer(IHostEnvironment env, ModelLoadContext`
`567`	`569`	`Scorer = new ClusteringScorer(Host, args, new EmptyDataView(Host, TrainSchema), BindableMapper.Bind(Host, schema), schema);`
`568`	`570`	`}`
`569`	`571`
`570`		`- protected override void SaveCore(ModelSaveContext ctx)`
	`572`	`+ private protected override void SaveCore(ModelSaveContext ctx)`
`571`	`573`	`{`
`572`	`574`	`Contracts.AssertValue(ctx);`
`573`	`575`	`ctx.SetVersionInfo(GetVersionInfo());`
`@@ -594,47 +596,47 @@ internal static class BinaryPredictionTransformer`
`594`	`596`	`{`
`595`	`597`	`public const string LoaderSignature = "BinaryPredXfer";`
`596`	`598`
`597`		`- public static BinaryPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)`
`598`		`- => new BinaryPredictionTransformer<object>(env, ctx);`
	`599`	`+ public static BinaryPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)`
	`600`	`+ => new BinaryPredictionTransformer<IPredictorProducing<float>>(env, ctx);`
`599`	`601`	`}`
`600`	`602`
`601`	`603`	`internal static class MulticlassPredictionTransformer`
`602`	`604`	`{`
`603`	`605`	`public const string LoaderSignature = "MulticlassPredXfer";`
`604`	`606`
`605`		`- public static MulticlassPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)`
`606`		`- => new MulticlassPredictionTransformer<object>(env, ctx);`
	`607`	`+ public static MulticlassPredictionTransformer<IPredictorProducing<VBuffer<float>>> Create(IHostEnvironment env, ModelLoadContext ctx)`
	`608`	`+ => new MulticlassPredictionTransformer<IPredictorProducing<VBuffer<float>>>(env, ctx);`
`607`	`609`	`}`
`608`	`610`
`609`	`611`	`internal static class RegressionPredictionTransformer`
`610`	`612`	`{`
`611`	`613`	`public const string LoaderSignature = "RegressionPredXfer";`
`612`	`614`
`613`		`- public static RegressionPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)`
`614`		`- => new RegressionPredictionTransformer<object>(env, ctx);`
	`615`	`+ public static RegressionPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)`
	`616`	`+ => new RegressionPredictionTransformer<IPredictorProducing<float>>(env, ctx);`
`615`	`617`	`}`
`616`	`618`
`617`	`619`	`internal static class RankingPredictionTransformer`
`618`	`620`	`{`
`619`	`621`	`public const string LoaderSignature = "RankingPredXfer";`
`620`	`622`
`621`		`- public static RankingPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)`
`622`		`- => new RankingPredictionTransformer<object>(env, ctx);`
	`623`	`+ public static RankingPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)`
	`624`	`+ => new RankingPredictionTransformer<IPredictorProducing<float>>(env, ctx);`
`623`	`625`	`}`
`624`	`626`
`625`	`627`	`internal static class AnomalyPredictionTransformer`
`626`	`628`	`{`
`627`	`629`	`public const string LoaderSignature = "AnomalyPredXfer";`
`628`	`630`
`629`		`- public static AnomalyPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)`
`630`		`- => new AnomalyPredictionTransformer<object>(env, ctx);`
	`631`	`+ public static AnomalyPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment env, ModelLoadContext ctx)`
	`632`	`+ => new AnomalyPredictionTransformer<IPredictorProducing<float>>(env, ctx);`
`631`	`633`	`}`
`632`	`634`
`633`	`635`	`internal static class ClusteringPredictionTransformer`
`634`	`636`	`{`
`635`	`637`	`public const string LoaderSignature = "ClusteringPredXfer";`
`636`	`638`
`637`		`- public static ClusteringPredictionTransformer<object> Create(IHostEnvironment env, ModelLoadContext ctx)`
`638`		`- => new ClusteringPredictionTransformer<object>(env, ctx);`
	`639`	`+ public static ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>> Create(IHostEnvironment env, ModelLoadContext ctx)`
	`640`	`+ => new ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>>(env, ctx);`
`639`	`641`	`}`
`640`	`642`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,9 @@`
`15`	`15`
`16`	`16`	`namespace Microsoft.ML.Transforms`
`17`	`17`	`{`
`18`		`- internal static class PermutationFeatureImportance<TModel, TMetric, TResult> where TResult : MetricsStatisticsBase<TMetric>, new()`
	`18`	`+ internal static class PermutationFeatureImportance<TModel, TMetric, TResult>`
	`19`	`+ where TResult : MetricsStatisticsBase<TMetric>, new()`
	`20`	`+ where TModel : class`
`19`	`21`	`{`
`20`	`22`	`public static ImmutableArray<TResult>`
`21`	`23`	`GetImportanceMetricsMatrix(`