Ova and Pkpd as estimators

src/Microsoft.ML.Ensemble/OutputCombiners/MultiStacking.cs

@@ -57,7 +57,7 @@ public Arguments()
                     env => new Ova(env, new Ova.Arguments()
                     {
                         PredictorType = ComponentFactoryUtils.CreateFromFunction(
-                            e => new FastTreeBinaryClassificationTrainer(e, new FastTreeBinaryClassificationTrainer.Arguments()))
+                             e => new AveragedPerceptronTrainer(e, new AveragedPerceptronTrainer.Arguments()))
                     }));
             }
         }

src/Microsoft.ML.StandardLearners/Standard/MultiClass/MetaMulticlassTrainer.cs

@@ -2,56 +2,97 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Float = System.Single;
-
+using System;
+using System.Linq;
 using Microsoft.ML.Runtime.CommandLine;
 using Microsoft.ML.Runtime.Data;
 using Microsoft.ML.Runtime.Data.Conversion;
 using Microsoft.ML.Runtime.EntryPoints;
 using Microsoft.ML.Runtime.Internal.Calibration;
 using Microsoft.ML.Runtime.Internal.Internallearn;
 using Microsoft.ML.Runtime.Training;
+using Microsoft.ML.Core.Data;
 
 namespace Microsoft.ML.Runtime.Learners
 {
-    using TScalarTrainer = ITrainer<IPredictorProducing<Float>>;
+    using TScalarTrainer = ITrainerEstimator<IPredictionTransformer<IPredictorProducing<float>>, IPredictorProducing<float>>;
 
-    public abstract class MetaMulticlassTrainer<TPred, TArgs> : TrainerBase<TPred>
-        where TPred : IPredictor
-        where TArgs : MetaMulticlassTrainer<TPred, TArgs>.ArgumentsBase
+    public abstract class MetaMulticlassTrainer<TTransformer, TModel> : ITrainerEstimator<TTransformer, TModel>, ITrainer<TModel>
+        where TTransformer : IPredictionTransformer<TModel>
+        where TModel : IPredictor
     {
         public abstract class ArgumentsBase
         {
-            [Argument(ArgumentType.Multiple, HelpText = "Base predictor", ShortName = "p", SortOrder = 1, SignatureType = typeof(SignatureBinaryClassifierTrainer))]
+            [Argument(ArgumentType.Multiple, HelpText = "Base predictor", ShortName = "p", SortOrder = 4, SignatureType = typeof(SignatureBinaryClassifierTrainer))]
             [TGUI(Label = "Predictor Type", Description = "Type of underlying binary predictor")]
             public IComponentFactory<TScalarTrainer> PredictorType;
 
-            [Argument(ArgumentType.Multiple, HelpText = "Output calibrator", ShortName = "cali", NullName = "<None>", SignatureType = typeof(SignatureCalibrator))]
+            [Argument(ArgumentType.Multiple, HelpText = "Output calibrator", ShortName = "cali", SortOrder = 150, NullName = "<None>", SignatureType = typeof(SignatureCalibrator))]
             public IComponentFactory<ICalibratorTrainer> Calibrator = new PlattCalibratorTrainerFactory();
 
-            [Argument(ArgumentType.LastOccurenceWins, HelpText = "Number of instances to train the calibrator", ShortName = "numcali")]
+            [Argument(ArgumentType.LastOccurenceWins, HelpText = "Number of instances to train the calibrator", SortOrder = 150, ShortName = "numcali")]
             public int MaxCalibrationExamples = 1000000000;
 
-            [Argument(ArgumentType.Multiple, HelpText = "Whether to treat missing labels as having negative labels, instead of keeping them missing", ShortName = "missNeg")]
+            [Argument(ArgumentType.Multiple, HelpText = "Whether to treat missing labels as having negative labels, instead of keeping them missing", SortOrder = 150, ShortName = "missNeg")]
             public bool ImputeMissingLabelsAsNegative;
         }
 
-        protected readonly TArgs Args;
+        /// <summary>
+        /// The label column that the trainer expects. Can be <c>null</c>, which indicates that label
+        /// is not used for training.
+        /// </summary>
+        public readonly SchemaShape.Column LabelColumn;
+
+        protected readonly ArgumentsBase Args;
+        protected readonly IHost Host;
+        protected readonly ICalibratorTrainer Calibrator;
+
         private TScalarTrainer _trainer;
 
-        public sealed override PredictionKind PredictionKind => PredictionKind.MultiClassClassification;
-        public override TrainerInfo Info { get; }
+        public PredictionKind PredictionKind => PredictionKind.MultiClassClassification;
+
+        protected SchemaShape.Column[] OutputColumns { get; }
+
+        public TrainerInfo Info { get; }
+
+        public TScalarTrainer PredictorType;
 
-        internal MetaMulticlassTrainer(IHostEnvironment env, TArgs args, string name)
-            : base(env, name)
+        /// <summary>
+        /// Initializes the <see cref="MetaMulticlassTrainer{TTransformer, TModel}"/> from the Arguments class.
+        /// </summary>
+        /// <param name="env">The private instance of the <see cref="IHostEnvironment"/>.</param>
+        /// <param name="args">The legacy arguments <see cref="ArgumentsBase"/>class.</param>
+        /// <param name="name">The component name.</param>
+        /// <param name="labelColumn">The label column for the metalinear trainer and the binary trainer.</param>
+        /// <param name="singleEstimator">The binary estimator.</param>
+        /// <param name="calibrator">The calibrator.</param>
+        internal MetaMulticlassTrainer(IHostEnvironment env, ArgumentsBase args, string name, string labelColumn = null,
+            TScalarTrainer singleEstimator = null, ICalibratorTrainer calibrator = null)
         {
+            Host = Contracts.CheckRef(env, nameof(env)).Register(name);
             Host.CheckValue(args, nameof(args));
             Args = args;
+
+            if (labelColumn != null)
+                LabelColumn = new SchemaShape.Column(labelColumn, SchemaShape.Column.VectorKind.Scalar, NumberType.R4, false);
+
             // Create the first trainer so errors in the args surface early.
-            _trainer = CreateTrainer();
+            _trainer = singleEstimator ?? CreateTrainer();
+
+            Calibrator = calibrator ?? null;
+
+            if (args.Calibrator != null)
+                Calibrator = args.Calibrator.CreateComponent(Host);
+
             // Regarding caching, no matter what the internal predictor, we're performing many passes
             // simply by virtue of this being a meta-trainer, so we will still cache.
             Info = new TrainerInfo(normalization: _trainer.Info.NeedNormalization);
+
+            OutputColumns = new[]
+            {
+                new SchemaShape.Column(DefaultColumnNames.Score, SchemaShape.Column.VectorKind.Vector, NumberType.R4, false),
+                new SchemaShape.Column(DefaultColumnNames.PredictedLabel, SchemaShape.Column.VectorKind.Scalar, NumberType.U4, true)
+            };
         }
 
         private TScalarTrainer CreateTrainer()
@@ -61,29 +102,28 @@ private TScalarTrainer CreateTrainer()
                 new LinearSvm(Host, new LinearSvm.Arguments());
         }
 
-        protected IDataView MapLabelsCore<T>(ColumnType type, RefPredicate<T> equalsTarget, RoleMappedData data, string dstName)
+        protected IDataView MapLabelsCore<T>(ColumnType type, RefPredicate<T> equalsTarget, RoleMappedData data)
         {
             Host.AssertValue(type);
             Host.Assert(type.RawType == typeof(T));
             Host.AssertValue(equalsTarget);
             Host.AssertValue(data);
             Host.AssertValue(data.Schema.Label);
-            Host.AssertNonWhiteSpace(dstName);
 
             var lab = data.Schema.Label;
 
             RefPredicate<T> isMissing;
             if (!Args.ImputeMissingLabelsAsNegative && Conversions.Instance.TryGetIsNAPredicate(type, out isMissing))
             {
                 return LambdaColumnMapper.Create(Host, "Label mapper", data.Data,
-                    lab.Name, dstName, type, NumberType.Float,
-                    (ref T src, ref Float dst) =>
-                        dst = equalsTarget(ref src) ? 1 : (isMissing(ref src) ? Float.NaN : default(Float)));
+                    lab.Name, lab.Name, type, NumberType.Float,
+                    (ref T src, ref float dst) =>
+                        dst = equalsTarget(ref src) ? 1 : (isMissing(ref src) ? float.NaN : default(float)));
             }
             return LambdaColumnMapper.Create(Host, "Label mapper", data.Data,
-                lab.Name, dstName, type, NumberType.Float,
-                (ref T src, ref Float dst) =>
-                    dst = equalsTarget(ref src) ? 1 : default(Float));
+                lab.Name, lab.Name, type, NumberType.Float,
+                (ref T src, ref float dst) =>
+                    dst = equalsTarget(ref src) ? 1 : default(float));
         }
 
         protected TScalarTrainer GetTrainer()
@@ -95,9 +135,14 @@ protected TScalarTrainer GetTrainer()
             return train;
         }
 
-        protected abstract TPred TrainCore(IChannel ch, RoleMappedData data, int count);
+        protected abstract TModel TrainCore(IChannel ch, RoleMappedData data, int count);
 
-        public override TPred Train(TrainContext context)
+        /// <summary>
+        /// The legacy train method.
+        /// </summary>
+        /// <param name="context">The trainig context for this learner.</param>
+        /// <returns>The trained model.</returns>
+        public TModel Train(TrainContext context)
         {
             Host.CheckValue(context, nameof(context));
             var data = context.TrainingSet;
@@ -116,5 +161,41 @@ public override TPred Train(TrainContext context)
                 return pred;
             }
         }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="inputSchema"></param>
+        /// <returns></returns>
+        public SchemaShape GetOutputSchema(SchemaShape inputSchema)
+        {
+            Host.CheckValue(inputSchema, nameof(inputSchema));
+
+            // Special treatment for label column: we allow different types of labels, so the trainers
+            // may define their own requirements on the label column.
+            if (LabelColumn != null)
+            {
+                if (!inputSchema.TryFindColumn(LabelColumn.Name, out var labelCol))
+                    throw Host.Except($"Label column '{LabelColumn.Name}' is not found");
+
+                if (!labelCol.IsKey || labelCol.ItemType != NumberType.R4 || labelCol.ItemType != NumberType.R8)
+                    throw Host.ExceptSchemaMismatch(nameof(labelCol), DefaultColumnNames.PredictedLabel, labelCol.Name, "R8, R4 or a Key", labelCol.GetTypeString());
+            }
+
+            var outColumns = inputSchema.Columns.ToDictionary(x => x.Name);
+            foreach (var col in OutputColumns)
+                outColumns[col.Name] = col;
+
+            return new SchemaShape(outColumns.Values);
+        }
+
+        IPredictor ITrainer.Train(TrainContext context) => Train(context);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public abstract TTransformer Fit(IDataView input);
     }
-}
+}