OneVersusAllModelParameters Strongly Typed

src/Microsoft.ML.Core/Prediction/IPredictor.cs

@@ -12,8 +12,7 @@ namespace Microsoft.ML
     /// <see cref="ITrainer"/> and <see cref="IPredictor"/> it is still useful, but for things based on
     /// the <see cref="IEstimator{TTransformer}"/> idiom, it is inappropriate.
     /// </summary>
-    [BestFriend]
-    internal enum PredictionKind
+    public enum PredictionKind
     {
         Unknown = 0,
         Custom = 1,

src/Microsoft.ML.Data/Prediction/Calibrator.cs

@@ -528,15 +528,15 @@ internal sealed class ParameterMixingCalibratedModelParameters<TSubModel, TCalib
         where TSubModel : class
         where TCalibrator : class, ICalibrator
     {
-        private readonly IPredictorWithFeatureWeights<float> _featureWeights;
+        private readonly TSubModel _featureWeights;
 
         internal ParameterMixingCalibratedModelParameters(IHostEnvironment env, TSubModel predictor, TCalibrator calibrator)
             : base(env, RegistrationName, predictor, calibrator)
         {
             Host.Check(predictor is IParameterMixer<float>, "Predictor does not implement " + nameof(IParameterMixer<float>));
             Host.Check(calibrator is IParameterMixer, "Calibrator does not implement " + nameof(IParameterMixer));
             Host.Assert(predictor is IPredictorWithFeatureWeights<float>);
-            _featureWeights = predictor as IPredictorWithFeatureWeights<float>;
+            _featureWeights = predictor;
         }
 
         internal const string LoaderSignature = "PMixCaliPredExec";
@@ -558,7 +558,7 @@ private ParameterMixingCalibratedModelParameters(IHostEnvironment env, ModelLoad
         {
             Host.Check(SubModel is IParameterMixer<float>, "Predictor does not implement " + nameof(IParameterMixer));
             Host.Check(SubModel is IPredictorWithFeatureWeights<float>, "Predictor does not implement " + nameof(IPredictorWithFeatureWeights<float>));
-            _featureWeights = SubModel as IPredictorWithFeatureWeights<float>;
+            _featureWeights = SubModel;
         }
 
         private static CalibratedModelParametersBase Create(IHostEnvironment env, ModelLoadContext ctx)
@@ -579,7 +579,7 @@ void ICanSaveModel.Save(ModelSaveContext ctx)
 
         public void GetFeatureWeights(ref VBuffer<float> weights)
         {
-            _featureWeights.GetFeatureWeights(ref weights);
+           ((IPredictorWithFeatureWeights<float>)_featureWeights).GetFeatureWeights(ref weights);
         }
 
         IParameterMixer<float> IParameterMixer<float>.CombineParameters(IList<IParameterMixer<float>> models)
@@ -879,6 +879,15 @@ public static IPredictor GetCalibratedPredictor(IHostEnvironment env, IChannel c
             return CreateCalibratedPredictor(env, (IPredictorProducing<float>)predictor, trainedCalibrator);
         }
 
+        public static CalibratedModelParametersBase<TSubPredictor, TCalibrator> GetCalibratedPredictor<TSubPredictor, TCalibrator>(IHostEnvironment env, IChannel ch, ICalibratorTrainer caliTrainer,
+            TSubPredictor predictor, RoleMappedData data, int maxRows = _maxCalibrationExamples)
+            where TSubPredictor : class
+            where TCalibrator : class, ICalibrator
+        {
+            var trainedCalibrator = TrainCalibrator(env, ch, caliTrainer, (IPredictor)predictor, data, maxRows) as TCalibrator;
+            return (CalibratedModelParametersBase<TSubPredictor, TCalibrator>)CreateCalibratedPredictor(env, predictor, trainedCalibrator);
+        }
+
         public static ICalibrator TrainCalibrator(IHostEnvironment env, IChannel ch, ICalibratorTrainer caliTrainer, IDataView scored, string labelColumn, string scoreColumn, string weightColumn = null, int maxRows = _maxCalibrationExamples)
         {
             Contracts.CheckValue(env, nameof(env));
@@ -963,12 +972,12 @@ public static ICalibrator TrainCalibrator(IHostEnvironment env, IChannel ch, ICa
         }
 
         public static IPredictorProducing<float> CreateCalibratedPredictor<TSubPredictor, TCalibrator>(IHostEnvironment env, TSubPredictor predictor, TCalibrator cali)
-        where TSubPredictor : class, IPredictorProducing<float>
+        where TSubPredictor : class
         where TCalibrator : class, ICalibrator
         {
             Contracts.Assert(predictor != null);
             if (cali == null)
-                return predictor;
+                return (IPredictorProducing<float>)predictor;
 
             for (; ; )
             {
@@ -980,7 +989,7 @@ public static IPredictorProducing<float> CreateCalibratedPredictor<TSubPredictor
 
             var predWithFeatureScores = predictor as IPredictorWithFeatureWeights<float>;
             if (predWithFeatureScores != null && predictor is IParameterMixer<float> && cali is IParameterMixer)
-                return new ParameterMixingCalibratedModelParameters<IPredictorWithFeatureWeights<float>, TCalibrator>(env, predWithFeatureScores, cali);
+                return new ParameterMixingCalibratedModelParameters<TSubPredictor, TCalibrator>(env, predictor, cali);
 
             if (predictor is IValueMapper)
                 return new ValueMapperCalibratedModelParameters<TSubPredictor, TCalibrator>(env, predictor, cali);

src/Microsoft.ML.EntryPoints/ModelOperations.cs

@@ -155,7 +155,7 @@ public static PredictorModelOutput CombineOvaModels(IHostEnvironment env, Combin
                 return new PredictorModelOutput
                 {
                     PredictorModel = new PredictorModelImpl(env, data, input.TrainingData,
-                    OneVersusAllModelParameters.Create(host, input.UseProbabilities,
+                    OneVersusAllModelParametersBuilder.Create(host, input.UseProbabilities,
                             input.ModelArray.Select(p => p.Predictor as IPredictorProducing<float>).ToArray()))
                 };
             }

src/Microsoft.ML.LightGbm/LightGbmMulticlassTrainer.cs

@@ -198,9 +198,9 @@ private protected override OneVersusAllModelParameters CreatePredictor()
             }
             string obj = (string)GetGbmParameters()["objective"];
             if (obj == "multiclass")
-                return OneVersusAllModelParameters.Create(Host, OneVersusAllModelParameters.OutputFormula.Softmax, predictors);
+                return OneVersusAllModelParametersBuilder.Create(Host, OneVersusAllModelParameters.OutputFormula.Softmax, predictors);
             else
-                return OneVersusAllModelParameters.Create(Host, predictors);
+                return OneVersusAllModelParametersBuilder.Create(Host, predictors);
         }
 
         private protected override void CheckDataValid(IChannel ch, RoleMappedData data)