Replace SubComponent with IComponentFactory in ML.Ensemble

eerhardt · eerhardt · commit 84119d35a9e3 · 2018-08-15T17:31:29.000-05:00
Working towards #585
diff --git a/src/Microsoft.ML.Ensemble/Selector/SubModelSelector/BaseSubModelSelector.cs b/src/Microsoft.ML.Ensemble/Selector/SubModelSelector/BaseSubModelSelector.cs
@@ -54,16 +54,16 @@ public virtual IList<FeatureSubsetModel<IPredictorProducing<TOutput>>> Prune(ILi
             return models;
         }
 
-        private SubComponent<IEvaluator, SignatureEvaluator> GetEvaluatorSubComponent()
+        private IEvaluator GetEvaluator(IHostEnvironment env)
         {
             switch (PredictionKind)
             {
                 case PredictionKind.BinaryClassification:
-                    return new SubComponent<IEvaluator, SignatureEvaluator>(BinaryClassifierEvaluator.LoadName);
+                    return new BinaryClassifierEvaluator(env, new BinaryClassifierEvaluator.Arguments());
                 case PredictionKind.Regression:
-                    return new SubComponent<IEvaluator, SignatureEvaluator>(RegressionEvaluator.LoadName);
+                    return new RegressionEvaluator(env, new RegressionEvaluator.Arguments());
                 case PredictionKind.MultiClassClassification:
-                    return new SubComponent<IEvaluator, SignatureEvaluator>(MultiClassClassifierEvaluator.LoadName);
+                    return new MultiClassClassifierEvaluator(env, new MultiClassClassifierEvaluator.Arguments());
                 default:
                     throw Host.Except("Unrecognized prediction kind '{0}'", PredictionKind);
             }
@@ -83,10 +83,9 @@ public virtual void CalculateMetrics(FeatureSubsetModel<IPredictorProducing<TOut
                 IDataScorerTransform scorePipe = ScoreUtils.GetScorer(model.Predictor, testData, Host, testData.Schema);
                 // REVIEW: Should we somehow allow the user to customize the evaluator?
                 // By what mechanism should we allow that?
-                var evalComp = GetEvaluatorSubComponent();
                 RoleMappedData scoredTestData = new RoleMappedData(scorePipe,
                     GetColumnRoles(testData.Schema, scorePipe.Schema));
-                IEvaluator evaluator = evalComp.CreateInstance(Host);
+                IEvaluator evaluator = GetEvaluator(Host);
                 // REVIEW: with the new evaluators, metrics of individual models are no longer
                 // printed to the Console. Consider adding an option on the combiner to print them.
                 // REVIEW: Consider adding an option to the combiner to save a data view
diff --git a/src/Microsoft.ML.Ensemble/Trainer/Binary/EnsembleTrainer.cs b/src/Microsoft.ML.Ensemble/Trainer/Binary/EnsembleTrainer.cs
@@ -13,6 +13,8 @@
 using Microsoft.ML.Runtime.Ensemble.Selector;
 using Microsoft.ML.Ensemble.EntryPoints;
 using Microsoft.ML.Runtime.Internal.Internallearn;
+using Microsoft.ML.Runtime.EntryPoints;
+using Microsoft.ML.Runtime.Learners;
 
 [assembly: LoadableClass(EnsembleTrainer.Summary, typeof(EnsembleTrainer), typeof(EnsembleTrainer.Arguments),
     new[] { typeof(SignatureBinaryClassifierTrainer), typeof(SignatureTrainer) },
@@ -26,7 +28,7 @@ namespace Microsoft.ML.Runtime.Ensemble
     /// A generic ensemble trainer for binary classification.
     /// </summary>
     public sealed class EnsembleTrainer : EnsembleTrainerBase<Single, TScalarPredictor,
-        IBinarySubModelSelector, IBinaryOutputCombiner, SignatureBinaryClassifierTrainer>,
+        IBinarySubModelSelector, IBinaryOutputCombiner>,
         IModelCombiner<TScalarPredictor, TScalarPredictor>
     {
         public const string LoadNameValue = "WeightedEnsemble";
@@ -44,9 +46,22 @@ public sealed class Arguments : ArgumentsBase
             [TGUI(Label = "Output combiner", Description = "Output combiner type")]
             public ISupportBinaryOutputCombinerFactory OutputCombiner = new MedianFactory();
 
+            [Argument(ArgumentType.Multiple, HelpText = "Base predictor type", ShortName = "bp,basePredictorTypes", SortOrder = 1, Visibility = ArgumentAttribute.VisibilityType.CmdLineOnly, SignatureType = typeof(SignatureBinaryClassifierTrainer))]
+            public IComponentFactory<ITrainer<TScalarPredictor>>[] BasePredictors;
+
+            public override IComponentFactory<ITrainer<TScalarPredictor>>[] BasePredictorFactories
+            {
+                get { return BasePredictors; }
+                set { BasePredictors = value; }
+            }
+
             public Arguments()
             {
-                BasePredictors = new[] { new SubComponent<ITrainer<TScalarPredictor>, SignatureBinaryClassifierTrainer>("LinearSVM") };
+                BasePredictors = new[]
+                {
+                    new SimpleComponentFactory<ITrainer<TScalarPredictor>>(
+                        env => new LinearSvm(env, new LinearSvm.Arguments()))
+                };
             }
         }
 
diff --git a/src/Microsoft.ML.Ensemble/Trainer/EnsembleTrainerBase.cs b/src/Microsoft.ML.Ensemble/Trainer/EnsembleTrainerBase.cs
@@ -20,7 +20,7 @@ namespace Microsoft.ML.Runtime.Ensemble
 {
     using Stopwatch = System.Diagnostics.Stopwatch;
 
-    public abstract class EnsembleTrainerBase<TOutput, TPredictor, TSelector, TCombiner, TSig> : TrainerBase<TPredictor>
+    public abstract class EnsembleTrainerBase<TOutput, TPredictor, TSelector, TCombiner> : TrainerBase<TPredictor>
          where TPredictor : class, IPredictorProducing<TOutput>
          where TSelector : class, ISubModelSelector<TOutput>
          where TCombiner : class, IOutputCombiner<TOutput>
@@ -53,8 +53,7 @@ public abstract class ArgumentsBase : LearnerInputBaseWithLabel
             [TGUI(Label = "Show Sub-Model Metrics")]
             public bool ShowMetrics;
 
-            [Argument(ArgumentType.Multiple, HelpText = "Base predictor type", ShortName = "bp,basePredictorTypes", SortOrder = 1, Visibility = ArgumentAttribute.VisibilityType.CmdLineOnly)]
-            public SubComponent<ITrainer<IPredictorProducing<TOutput>>, TSig>[] BasePredictors;
+            public abstract IComponentFactory<ITrainer<IPredictorProducing<TOutput>>>[] BasePredictorFactories { get; set; }
         }
 
         private const int DefaultNumModels = 50;
@@ -78,21 +77,22 @@ private protected EnsembleTrainerBase(ArgumentsBase args, IHostEnvironment env,
 
             using (var ch = Host.Start("Init"))
             {
-                ch.CheckUserArg(Utils.Size(Args.BasePredictors) > 0, nameof(Args.BasePredictors), "This should have at-least one value");
+                var predictorFactories = Args.BasePredictorFactories;
+                ch.CheckUserArg(Utils.Size(predictorFactories) > 0, nameof(Args.BasePredictorFactories), "This should have at-least one value");
 
                 NumModels = Args.NumModels ??
-                    (Args.BasePredictors.Length == 1 ? DefaultNumModels : Args.BasePredictors.Length);
+                    (predictorFactories.Length == 1 ? DefaultNumModels : predictorFactories.Length);
 
                 ch.CheckUserArg(NumModels > 0, nameof(Args.NumModels), "Must be positive, or null to indicate numModels is the number of base predictors");
 
-                if (Utils.Size(Args.BasePredictors) > NumModels)
+                if (Utils.Size(predictorFactories) > NumModels)
                     ch.Warning("The base predictor count is greater than models count. Some of the base predictors will be ignored.");
 
                 _subsetSelector = Args.SamplingType.CreateComponent(Host);
 
                 Trainers = new ITrainer<IPredictorProducing<TOutput>>[NumModels];
                 for (int i = 0; i < Trainers.Length; i++)
-                    Trainers[i] = Args.BasePredictors[i % Args.BasePredictors.Length].CreateInstance(Host);
+                    Trainers[i] = predictorFactories[i % predictorFactories.Length].CreateComponent(Host);
                 // We infer normalization and calibration preferences from the trainers. However, even if the internal trainers
                 // don't need caching we are performing multiple passes over the data, so it is probably appropriate to always cache.
                 Info = new TrainerInfo(
diff --git a/src/Microsoft.ML.Ensemble/Trainer/Multiclass/MulticlassDataPartitionEnsembleTrainer.cs b/src/Microsoft.ML.Ensemble/Trainer/Multiclass/MulticlassDataPartitionEnsembleTrainer.cs
@@ -12,7 +12,9 @@
 using Microsoft.ML.Runtime.Ensemble;
 using Microsoft.ML.Runtime.Ensemble.OutputCombiners;
 using Microsoft.ML.Runtime.Ensemble.Selector;
+using Microsoft.ML.Runtime.EntryPoints;
 using Microsoft.ML.Runtime.Internal.Internallearn;
+using Microsoft.ML.Runtime.Learners;
 
 [assembly: LoadableClass(MulticlassDataPartitionEnsembleTrainer.Summary, typeof(MulticlassDataPartitionEnsembleTrainer),
     typeof(MulticlassDataPartitionEnsembleTrainer.Arguments),
@@ -28,7 +30,7 @@ namespace Microsoft.ML.Runtime.Ensemble
     /// </summary>
     public sealed class MulticlassDataPartitionEnsembleTrainer :
         EnsembleTrainerBase<VBuffer<Single>, EnsembleMultiClassPredictor,
-        IMulticlassSubModelSelector, IMultiClassOutputCombiner, SignatureMultiClassClassifierTrainer>,
+        IMulticlassSubModelSelector, IMultiClassOutputCombiner>,
         IModelCombiner<TVectorPredictor, TVectorPredictor>
     {
         public const string LoadNameValue = "WeightedEnsembleMulticlass";
@@ -45,9 +47,22 @@ public sealed class Arguments : ArgumentsBase
             [TGUI(Label = "Output combiner", Description = "Output combiner type")]
             public ISupportMulticlassOutputCombinerFactory OutputCombiner = new MultiMedian.Arguments();
 
+            [Argument(ArgumentType.Multiple, HelpText = "Base predictor type", ShortName = "bp,basePredictorTypes", SortOrder = 1, Visibility = ArgumentAttribute.VisibilityType.CmdLineOnly, SignatureType = typeof(SignatureMultiClassClassifierTrainer))]
+            public IComponentFactory<ITrainer<TVectorPredictor>>[] BasePredictors;
+
+            public override IComponentFactory<ITrainer<TVectorPredictor>>[] BasePredictorFactories
+            {
+                get { return BasePredictors; }
+                set { BasePredictors = value; }
+            }
+
             public Arguments()
             {
-                BasePredictors = new[] { new SubComponent<ITrainer<TVectorPredictor>, SignatureMultiClassClassifierTrainer>("MultiClassLogisticRegression") };
+                BasePredictors = new[]
+                {
+                    new SimpleComponentFactory<ITrainer<TVectorPredictor>>(
+                        env => new MulticlassLogisticRegression(env, new MulticlassLogisticRegression.Arguments()))
+                };
             }
         }
 
diff --git a/src/Microsoft.ML.Ensemble/Trainer/Regression/RegressionEnsembleTrainer.cs b/src/Microsoft.ML.Ensemble/Trainer/Regression/RegressionEnsembleTrainer.cs
@@ -12,7 +12,9 @@
 using Microsoft.ML.Runtime.Ensemble;
 using Microsoft.ML.Runtime.Ensemble.OutputCombiners;
 using Microsoft.ML.Runtime.Ensemble.Selector;
+using Microsoft.ML.Runtime.EntryPoints;
 using Microsoft.ML.Runtime.Internal.Internallearn;
+using Microsoft.ML.Runtime.Learners;
 
 [assembly: LoadableClass(typeof(RegressionEnsembleTrainer), typeof(RegressionEnsembleTrainer.Arguments),
     new[] { typeof(SignatureRegressorTrainer), typeof(SignatureTrainer) },
@@ -23,7 +25,7 @@ namespace Microsoft.ML.Runtime.Ensemble
 {
     using TScalarPredictor = IPredictorProducing<Single>;
     public sealed class RegressionEnsembleTrainer : EnsembleTrainerBase<Single, TScalarPredictor,
-       IRegressionSubModelSelector, IRegressionOutputCombiner, SignatureRegressorTrainer>,
+       IRegressionSubModelSelector, IRegressionOutputCombiner>,
        IModelCombiner<TScalarPredictor, TScalarPredictor>
     {
         public const string LoadNameValue = "EnsembleRegression";
@@ -39,9 +41,22 @@ public sealed class Arguments : ArgumentsBase
             [TGUI(Label = "Output combiner", Description = "Output combiner type")]
             public ISupportRegressionOutputCombinerFactory OutputCombiner = new MedianFactory();
 
+            [Argument(ArgumentType.Multiple, HelpText = "Base predictor type", ShortName = "bp,basePredictorTypes", SortOrder = 1, Visibility = ArgumentAttribute.VisibilityType.CmdLineOnly, SignatureType = typeof(SignatureRegressorTrainer))]
+            public IComponentFactory<ITrainer<TScalarPredictor>>[] BasePredictors;
+
+            public override IComponentFactory<ITrainer<TScalarPredictor>>[] BasePredictorFactories
+            {
+                get { return BasePredictors; }
+                set { BasePredictors = value; }
+            }
+
             public Arguments()
             {
-                BasePredictors = new[] { new SubComponent<ITrainer<TScalarPredictor>, SignatureRegressorTrainer>("OnlineGradientDescent") };
+                BasePredictors = new[]
+                {
+                    new SimpleComponentFactory<ITrainer<TScalarPredictor>>(
+                        env => new OnlineGradientDescentTrainer(env, new OnlineGradientDescentTrainer.Arguments()))
+                };
             }
         }
 
