No abbreviations in TrainContext, use static readonly field where convenient.

Author: Tom Finley

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

@@ -37,21 +37,21 @@ public sealed class TrainContext
         /// <summary>
         /// Constructor, given a training set and optional other arguments.
         /// </summary>
-        /// <param name="train">Will set <see cref="TrainingSet"/> to this value. This must be specified</param>
-        /// <param name="valid">Will set <see cref="ValidationSet"/> to this value if specified</param>
-        /// <param name="initPredictor">Will set <see cref="InitialPredictor"/> to this value if specified</param>
-        public TrainContext(RoleMappedData train, RoleMappedData valid = null, IPredictor initPredictor = null)
+        /// <param name="trainingSet">Will set <see cref="TrainingSet"/> to this value. This must be specified</param>
+        /// <param name="validationSet">Will set <see cref="ValidationSet"/> to this value if specified</param>
+        /// <param name="initialPredictor">Will set <see cref="InitialPredictor"/> to this value if specified</param>
+        public TrainContext(RoleMappedData trainingSet, RoleMappedData validationSet = null, IPredictor initialPredictor = null)
         {
-            Contracts.CheckValue(train, nameof(train));
-            Contracts.CheckValueOrNull(valid);
-            Contracts.CheckValueOrNull(initPredictor);
+            Contracts.CheckValue(trainingSet, nameof(trainingSet));
+            Contracts.CheckValueOrNull(validationSet);
+            Contracts.CheckValueOrNull(initialPredictor);
 
             // REVIEW: Should there be code here to ensure that the role mappings between the two are compatible?
             // That is, all the role mappings are the same and the columns between them have identical types?
 
-            TrainingSet = train;
-            ValidationSet = valid;
-            InitialPredictor = initPredictor;
+            TrainingSet = trainingSet;
+            ValidationSet = validationSet;
+            InitialPredictor = initialPredictor;
         }
     }
 }

src/Microsoft.ML.LightGBM/LightGbmTrainerBase.cs

@@ -51,7 +51,7 @@ private sealed class CategoricalMetaData
         private protected int FeatureCount;
         private protected FastTree.Internal.Ensemble TrainedEnsemble;
 
-        private static TrainerInfo _info = new TrainerInfo(normalization: false, caching: false, supportValid: true);
+        private static readonly TrainerInfo _info = new TrainerInfo(normalization: false, caching: false, supportValid: true);
         public override TrainerInfo Info => _info;
 
         private protected LightGbmTrainerBase(IHostEnvironment env, LightGbmArguments args, string name)

src/Microsoft.ML.PCA/PcaTrainer.cs

@@ -75,7 +75,10 @@ public class Arguments : UnsupervisedLearnerInputBaseWithWeight
         private readonly int _seed;
 
         public override PredictionKind PredictionKind => PredictionKind.AnomalyDetection;
-        public override TrainerInfo Info { get; }
+
+        // The training performs two passes, only. Probably not worth caching.
+        private static readonly TrainerInfo _info = new TrainerInfo(caching: false);
+        public override TrainerInfo Info => _info;
 
         public RandomizedPcaTrainer(IHostEnvironment env, Arguments args)
             : base(env, LoadNameValue)
@@ -84,8 +87,6 @@ public RandomizedPcaTrainer(IHostEnvironment env, Arguments args)
             Host.CheckUserArg(args.Rank > 0, nameof(args.Rank), "Rank must be positive");
             Host.CheckUserArg(args.Oversampling >= 0, nameof(args.Oversampling), "Oversampling must be non-negative");
 
-            // Two passes, only. Probably not worth caching.
-            Info = new TrainerInfo(caching: false);
             _rank = args.Rank;
             _center = args.Center;
             _oversampling = args.Oversampling;

src/Microsoft.ML.StandardLearners/Standard/LinearClassificationTrainer.cs

@@ -49,7 +49,8 @@ public abstract class LinearTrainerBase<TPredictor> : TrainerBase<TPredictor>
     {
         protected bool NeedShuffle;
 
-        public override TrainerInfo Info { get; }
+        private static readonly TrainerInfo _info = new TrainerInfo();
+        public override TrainerInfo Info => _info;
 
         /// <summary>
         /// Whether data is to be shuffled every epoch.
@@ -59,7 +60,6 @@ public abstract class LinearTrainerBase<TPredictor> : TrainerBase<TPredictor>
         private protected LinearTrainerBase(IHostEnvironment env, string name)
             : base(env, name)
         {
-            Info = new TrainerInfo();
         }
 
         public override TPredictor Train(TrainContext context)

src/Microsoft.ML.StandardLearners/Standard/LogisticRegression/LbfgsPredictorBase.cs

@@ -132,7 +132,10 @@ public abstract class ArgumentsBase : LearnerInputBaseWithWeight
         private VBuffer<Float>[] _localGradients;
         private Float[] _localLosses;
 
-        public override TrainerInfo Info { get; }
+        // REVIEW: It's pointless to request caching when we're going to load everything into
+        // memory, that is, when using multiple threads. So should caching not be requested?
+        private static readonly TrainerInfo _info = new TrainerInfo(caching: true, supportIncrementalTrain: true);
+        public override TrainerInfo Info => _info;
 
         internal LbfgsTrainerBase(ArgumentsBase args, IHostEnvironment env, string name, bool showTrainingStats = false)
             : base(env, name)
@@ -160,9 +163,6 @@ internal LbfgsTrainerBase(ArgumentsBase args, IHostEnvironment env, string name,
             DenseOptimizer = args.DenseOptimizer;
             ShowTrainingStats = showTrainingStats;
             EnforceNonNegativity = args.EnforceNonNegativity;
-            // REVIEW: It's pointless to request caching when we're going to load everything into
-            // memory, that is, when using multiple threads. So should caching not be requested?
-            Info = new TrainerInfo(caching: true, supportIncrementalTrain: true);
 
             if (EnforceNonNegativity && ShowTrainingStats)
             {

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

@@ -45,13 +45,13 @@ public sealed class Arguments : LearnerInputBaseWithLabel
 
         public override PredictionKind PredictionKind => PredictionKind.MultiClassClassification;
 
-        public override TrainerInfo Info { get; }
+        private static readonly TrainerInfo _info = new TrainerInfo(normalization: false, caching: false);
+        public override TrainerInfo Info => _info;
 
         public MultiClassNaiveBayesTrainer(IHostEnvironment env, Arguments args)
             : base(env, LoadName)
         {
             Host.CheckValue(args, nameof(args));
-            Info = new TrainerInfo(normalization: false, caching: false);
         }
 
         public override MultiClassNaiveBayesPredictor Train(TrainContext context)

src/Microsoft.ML.StandardLearners/Standard/OlsLinearRegression.cs

@@ -61,7 +61,10 @@ It assumes that the conditional mean of the dependent variable follows a linear
         private readonly bool _perParameterSignificance;
 
         public override PredictionKind PredictionKind => PredictionKind.Regression;
-        public override TrainerInfo Info { get; }
+
+        // The training performs two passes, only. Probably not worth caching.
+        private static readonly TrainerInfo _info = new TrainerInfo(caching: false);
+        public override TrainerInfo Info => _info;
 
         public OlsLinearRegressionTrainer(IHostEnvironment env, Arguments args)
             : base(env, LoadNameValue)
@@ -70,8 +73,6 @@ public OlsLinearRegressionTrainer(IHostEnvironment env, Arguments args)
             Host.CheckUserArg(args.L2Weight >= 0, nameof(args.L2Weight), "L2 regularization term cannot be negative");
             _l2Weight = args.L2Weight;
             _perParameterSignificance = args.PerParameterSignificance;
-            // Two passes, only. Probably not worth caching.
-            Info = new TrainerInfo(caching: false);
         }
 
         /// <summary>

src/Microsoft.ML.StandardLearners/Standard/Simple/SimpleTrainers.cs

@@ -55,13 +55,14 @@ public class Arguments
         }
 
         public override PredictionKind PredictionKind => PredictionKind.BinaryClassification;
-        public override TrainerInfo Info { get; }
+
+        private static readonly TrainerInfo _info = new TrainerInfo(normalization: false, caching: false);
+        public override TrainerInfo Info => _info;
 
         public RandomTrainer(IHostEnvironment env, Arguments args)
             : base(env, LoadNameValue)
         {
             Host.CheckValue(args, nameof(args));
-            Info = new TrainerInfo(normalization: false, caching: false);
         }
 
         public override RandomPredictor Train(TrainContext context)
@@ -205,13 +206,14 @@ public sealed class Arguments
         }
 
         public override PredictionKind PredictionKind => PredictionKind.BinaryClassification;
-        public override TrainerInfo Info { get; }
+
+        private static readonly TrainerInfo _info = new TrainerInfo(normalization: false, caching: false);
+        public override TrainerInfo Info => _info;
 
         public PriorTrainer(IHostEnvironment env, Arguments args)
             : base(env, LoadNameValue)
         {
             Host.CheckValue(args, nameof(args));
-            Info = new TrainerInfo(normalization: false, caching: false);
         }
 
         public override PriorPredictor Train(TrainContext context)