Scrubbing online learners

docs/samples/Microsoft.ML.Samples/Dynamic/Trainers/BinaryClassification/AveragedPerceptronWithOptions.cs

@@ -25,7 +25,7 @@ public static void Example()
             {
                 LossFunction = new SmoothedHingeLoss.Options(),
                 LearningRate = 0.1f,
-                DoLazyUpdates = false,
+                LazyUpdates = false,
                 RecencyGain = 0.1f,
                 NumberOfIterations = 10
             };

src/Microsoft.ML.StandardLearners/Standard/Online/AveragedLinear.cs

@@ -58,15 +58,15 @@ public abstract class AveragedLinearOptions : OnlineLinearOptions
         /// Default is <see langword="true" />.
         /// </value>
         [Argument(ArgumentType.AtMostOnce, HelpText = "Instead of updating averaged weights on every example, only update when loss is nonzero", ShortName = "lazy")]
-        public bool DoLazyUpdates = true;
+        public bool LazyUpdates = true;
 
         /// <summary>
         /// The L2 weight for <a href='tmpurl_regularization'>regularization</a>.
         /// </summary>
-        [Argument(ArgumentType.AtMostOnce, HelpText = "L2 Regularization Weight", ShortName = "reg", SortOrder = 50)]
+        [Argument(ArgumentType.AtMostOnce, HelpText = "L2 Regularization Weight", ShortName = "reg,L2RegularizerWeight", SortOrder = 50)]
         [TGUI(Label = "L2 Regularization Weight")]
         [TlcModule.SweepableFloatParam("L2RegularizerWeight", 0.0f, 0.4f)]
-        public float L2RegularizerWeight = AveragedDefault.L2RegularizerWeight;
+        public float L2Regularization = AveragedDefault.L2Regularization;
 
         /// <summary>
         /// Extra weight given to more recent updates.
@@ -86,7 +86,7 @@ public abstract class AveragedLinearOptions : OnlineLinearOptions
         /// Default is <see langword="false" />.
         /// </value>
         [Argument(ArgumentType.AtMostOnce, HelpText = "Whether Recency Gain is multiplicative (vs. additive)", ShortName = "rgm")]
-        public bool RecencyGainMulti = false;
+        public bool RecencyGainMultiplicative = false;
 
         /// <summary>
         /// Determines whether to do averaging or not.
@@ -109,7 +109,7 @@ internal class AveragedDefault : OnlineLinearOptions.OnlineDefault
         {
             public const float LearningRate = 1;
             public const bool DecreaseLearningRate = false;
-            public const float L2RegularizerWeight = 0;
+            public const float L2Regularization = 0;
         }
 
         internal abstract IComponentFactory<IScalarOutputLoss> LossFunctionFactory { get; }
@@ -186,7 +186,7 @@ public override void FinishIteration(IChannel ch)
                 // Finalize things
                 if (Averaged)
                 {
-                    if (_args.DoLazyUpdates && NumNoUpdates > 0)
+                    if (_args.LazyUpdates && NumNoUpdates > 0)
                     {
                         // Update the total weights to include the final loss=0 updates
                         VectorUtils.AddMult(in Weights, NumNoUpdates * WeightsScale, ref TotalWeights);
@@ -221,10 +221,10 @@ public override void ProcessDataInstance(IChannel ch, in VBuffer<float> feat, fl
                 // REVIEW: Should this be biasUpdate != 0?
                 // This loss does not incorporate L2 if present, but the chance of that addition to the loss
                 // exactly cancelling out loss is remote.
-                if (loss != 0 || _args.L2RegularizerWeight > 0)
+                if (loss != 0 || _args.L2Regularization > 0)
                 {
                     // If doing lazy weights, we need to update the totalWeights and totalBias before updating weights/bias
-                    if (_args.DoLazyUpdates && _args.Averaged && NumNoUpdates > 0 && TotalMultipliers * _args.AveragedTolerance <= PendingMultipliers)
+                    if (_args.LazyUpdates && _args.Averaged && NumNoUpdates > 0 && TotalMultipliers * _args.AveragedTolerance <= PendingMultipliers)
                     {
                         VectorUtils.AddMult(in Weights, NumNoUpdates * WeightsScale, ref TotalWeights);
                         TotalBias += Bias * NumNoUpdates * WeightsScale;
@@ -242,7 +242,7 @@ public override void ProcessDataInstance(IChannel ch, in VBuffer<float> feat, fl
 
                     // Perform the update to weights and bias.
                     VectorUtils.AddMult(in feat, biasUpdate / WeightsScale, ref Weights);
-                    WeightsScale *= 1 - 2 * _args.L2RegularizerWeight; // L2 regularization.
+                    WeightsScale *= 1 - 2 * _args.L2Regularization; // L2 regularization.
                     ScaleWeightsIfNeeded();
                     Bias += biasUpdate;
                     PendingMultipliers += Math.Abs(biasUpdate);
@@ -251,7 +251,7 @@ public override void ProcessDataInstance(IChannel ch, in VBuffer<float> feat, fl
                 // Add to averaged weights and increment the count.
                 if (Averaged)
                 {
-                    if (!_args.DoLazyUpdates)
+                    if (!_args.LazyUpdates)
                         IncrementAverageNonLazy();
                     else
                         NumNoUpdates++;
@@ -282,7 +282,7 @@ private void IncrementAverageNonLazy()
                 VectorUtils.AddMult(in Weights, Gain * WeightsScale, ref TotalWeights);
                 TotalBias += Gain * Bias;
                 NumWeightUpdates += Gain;
-                Gain = (_args.RecencyGainMulti ? Gain * _args.RecencyGain : Gain + _args.RecencyGain);
+                Gain = (_args.RecencyGainMultiplicative ? Gain * _args.RecencyGain : Gain + _args.RecencyGain);
 
                 // If gains got too big, rescale!
                 if (Gain > 1000)
@@ -303,11 +303,11 @@ private protected AveragedLinearTrainer(AveragedLinearOptions options, IHostEnvi
             Contracts.CheckUserArg(!options.ResetWeightsAfterXExamples.HasValue || options.ResetWeightsAfterXExamples > 0, nameof(options.ResetWeightsAfterXExamples), UserErrorPositive);
 
             // Weights are scaled down by 2 * L2 regularization on each update step, so 0.5 would scale all weights to 0, which is not sensible.
-            Contracts.CheckUserArg(0 <= options.L2RegularizerWeight && options.L2RegularizerWeight < 0.5, nameof(options.L2RegularizerWeight), "must be in range [0, 0.5)");
+            Contracts.CheckUserArg(0 <= options.L2Regularization && options.L2Regularization < 0.5, nameof(options.L2Regularization), "must be in range [0, 0.5)");
             Contracts.CheckUserArg(options.RecencyGain >= 0, nameof(options.RecencyGain), UserErrorNonNegative);
             Contracts.CheckUserArg(options.AveragedTolerance >= 0, nameof(options.AveragedTolerance), UserErrorNonNegative);
             // Verify user didn't specify parameters that conflict
-            Contracts.Check(!options.DoLazyUpdates || !options.RecencyGainMulti && options.RecencyGain == 0, "Cannot have both recency gain and lazy updates.");
+            Contracts.Check(!options.LazyUpdates || !options.RecencyGainMultiplicative && options.RecencyGain == 0, "Cannot have both recency gain and lazy updates.");
 
             AveragedLinearTrainerOptions = options;
         }

src/Microsoft.ML.StandardLearners/Standard/Online/AveragedPerceptron.cs

@@ -126,23 +126,23 @@ internal AveragedPerceptronTrainer(IHostEnvironment env, Options options)
         /// <param name="featureColumnName">The name of the feature column.</param>
         /// <param name="learningRate">The learning rate. </param>
         /// <param name="decreaseLearningRate">Whether to decrease learning rate as iterations progress.</param>
-        /// <param name="l2RegularizerWeight">L2 Regularization Weight.</param>
+        /// <param name="l2Regularization">Weight of L2 regularization term.</param>
         /// <param name="numIterations">The number of training iterations.</param>
         internal AveragedPerceptronTrainer(IHostEnvironment env,
             string labelColumnName = DefaultColumnNames.Label,
             string featureColumnName = DefaultColumnNames.Features,
             IClassificationLoss lossFunction = null,
             float learningRate = Options.AveragedDefault.LearningRate,
             bool decreaseLearningRate = Options.AveragedDefault.DecreaseLearningRate,
-            float l2RegularizerWeight = Options.AveragedDefault.L2RegularizerWeight,
+            float l2Regularization = Options.AveragedDefault.L2Regularization,
             int numIterations = Options.AveragedDefault.NumIterations)
             : this(env, new Options
             {
                 LabelColumnName = labelColumnName,
                 FeatureColumnName = featureColumnName,
                 LearningRate = learningRate,
                 DecreaseLearningRate = decreaseLearningRate,
-                L2RegularizerWeight = l2RegularizerWeight,
+                L2Regularization = l2Regularization,
                 NumberOfIterations = numIterations,
                 LossFunction = new TrivialFactory(lossFunction ?? new HingeLoss())
             })

src/Microsoft.ML.StandardLearners/Standard/Online/LinearSvm.cs

@@ -70,7 +70,7 @@ public sealed class Options : OnlineLinearOptions
             /// Column to use for example weight.
             /// </summary>
             [Argument(ArgumentType.AtMostOnce, HelpText = "Column to use for example weight", ShortName = "weight", SortOrder = 4, Visibility = ArgumentAttribute.VisibilityType.EntryPointsOnly)]
-            public string WeightColumn = null;
+            public string ExampleWeightColumnName = null;
         }
 
         private sealed class TrainState : TrainStateBase
@@ -232,19 +232,19 @@ public override LinearBinaryModelParameters CreatePredictor()
         /// <param name="env">The environment to use.</param>
         /// <param name="labelColumn">The name of the label column. </param>
         /// <param name="featureColumn">The name of the feature column.</param>
-        /// <param name="weightColumn">The optional name of the weight column.</param>
+        /// <param name="exampleWeightColumnName">The name of the example weight column (optional).</param>
         /// <param name="numIterations">The number of training iteraitons.</param>
         [BestFriend]
         internal LinearSvmTrainer(IHostEnvironment env,
             string labelColumn = DefaultColumnNames.Label,
             string featureColumn = DefaultColumnNames.Features,
-            string weightColumn = null,
+            string exampleWeightColumnName = null,
             int numIterations = Options.OnlineDefault.NumIterations)
             : this(env, new Options
             {
                 LabelColumnName = labelColumn,
                 FeatureColumnName = featureColumn,
-                WeightColumn = weightColumn,
+                ExampleWeightColumnName = exampleWeightColumnName,
                 NumberOfIterations = numIterations,
             })
         {

src/Microsoft.ML.StandardLearners/Standard/Online/OnlineGradientDescent.cs

@@ -95,22 +95,22 @@ public override LinearRegressionModelParameters CreatePredictor()
         /// <param name="featureColumn">Name of the feature column.</param>
         /// <param name="learningRate">The learning Rate.</param>
         /// <param name="decreaseLearningRate">Decrease learning rate as iterations progress.</param>
-        /// <param name="l2RegularizerWeight">L2 Regularization Weight.</param>
+        /// <param name="l2Regularization">Weight of L2 regularization term.</param>
         /// <param name="numIterations">Number of training iterations through the data.</param>
         /// <param name="lossFunction">The custom loss functions. Defaults to <see cref="SquaredLoss"/> if not provided.</param>
         internal OnlineGradientDescentTrainer(IHostEnvironment env,
             string labelColumn = DefaultColumnNames.Label,
             string featureColumn = DefaultColumnNames.Features,
             float learningRate = Options.OgdDefaultArgs.LearningRate,
             bool decreaseLearningRate = Options.OgdDefaultArgs.DecreaseLearningRate,
-            float l2RegularizerWeight = Options.OgdDefaultArgs.L2RegularizerWeight,
+            float l2Regularization = Options.OgdDefaultArgs.L2Regularization,
             int numIterations = Options.OgdDefaultArgs.NumIterations,
             IRegressionLoss lossFunction = null)
             : this(env, new Options
             {
                 LearningRate = learningRate,
                 DecreaseLearningRate = decreaseLearningRate,
-                L2RegularizerWeight = l2RegularizerWeight,
+                L2Regularization= l2Regularization,
                 NumberOfIterations = numIterations,
                 LabelColumnName = labelColumn,
                 FeatureColumnName = featureColumn,

src/Microsoft.ML.StandardLearners/StandardLearnersCatalog.cs

@@ -340,7 +340,7 @@ public static class StandardLearnersCatalog
         /// <see langword="true" /> to decrease the <paramref name="learningRate"/> as iterations progress; otherwise, <see langword="false" />.
         /// Default is <see langword="false" />.
         /// </param>
-        /// <param name="l2RegularizerWeight">The L2 weight for <a href='tmpurl_regularization'>regularization</a>.</param>
+        /// <param name="l2Regularization">The L2 weight for <a href='tmpurl_regularization'>regularization</a>.</param>
         /// <param name="numIterations">Number of passes through the training dataset.</param>
         /// <example>
         /// <format type="text/markdown">
@@ -356,13 +356,13 @@ public static class StandardLearnersCatalog
             IClassificationLoss lossFunction = null,
             float learningRate = AveragedLinearOptions.AveragedDefault.LearningRate,
             bool decreaseLearningRate = AveragedLinearOptions.AveragedDefault.DecreaseLearningRate,
-            float l2RegularizerWeight = AveragedLinearOptions.AveragedDefault.L2RegularizerWeight,
+            float l2Regularization = AveragedLinearOptions.AveragedDefault.L2Regularization,
             int numIterations = AveragedLinearOptions.AveragedDefault.NumIterations)
         {
             Contracts.CheckValue(catalog, nameof(catalog));
 
             var env = CatalogUtils.GetEnvironment(catalog);
-            return new AveragedPerceptronTrainer(env, labelColumnName, featureColumnName, lossFunction ?? new LogLoss(), learningRate, decreaseLearningRate, l2RegularizerWeight, numIterations);
+            return new AveragedPerceptronTrainer(env, labelColumnName, featureColumnName, lossFunction ?? new LogLoss(), learningRate, decreaseLearningRate, l2Regularization, numIterations);
         }
 
         /// <summary>
@@ -411,20 +411,20 @@ public IClassificationLoss CreateComponent(IHostEnvironment env)
         /// <param name="lossFunction">The custom loss. Defaults to <see cref="SquaredLoss"/> if not provided.</param>
         /// <param name="learningRate">The learning Rate.</param>
         /// <param name="decreaseLearningRate">Decrease learning rate as iterations progress.</param>
-        /// <param name="l2RegularizerWeight">L2 regularization weight.</param>
+        /// <param name="l2Regularization">The L2 weight for <a href='tmpurl_regularization'>regularization</a>.</param>
         /// <param name="numIterations">Number of training iterations through the data.</param>
         public static OnlineGradientDescentTrainer OnlineGradientDescent(this RegressionCatalog.RegressionTrainers catalog,
             string labelColumnName = DefaultColumnNames.Label,
             string featureColumnName = DefaultColumnNames.Features,
             IRegressionLoss lossFunction = null,
             float learningRate = OnlineGradientDescentTrainer.Options.OgdDefaultArgs.LearningRate,
             bool decreaseLearningRate = OnlineGradientDescentTrainer.Options.OgdDefaultArgs.DecreaseLearningRate,
-            float l2RegularizerWeight = AveragedLinearOptions.AveragedDefault.L2RegularizerWeight,
+            float l2Regularization = AveragedLinearOptions.AveragedDefault.L2Regularization,
             int numIterations = OnlineLinearOptions.OnlineDefault.NumIterations)
         {
             Contracts.CheckValue(catalog, nameof(catalog));
             var env = CatalogUtils.GetEnvironment(catalog);
-            return new OnlineGradientDescentTrainer(env, labelColumnName, featureColumnName, learningRate, decreaseLearningRate, l2RegularizerWeight,
+            return new OnlineGradientDescentTrainer(env, labelColumnName, featureColumnName, learningRate, decreaseLearningRate, l2Regularization,
                 numIterations, lossFunction);
         }