Internalization.

Author: codemzs

src/Microsoft.ML.StandardLearners/FactorizationMachine/FieldAwareFactorizationMachineModelParameters.cs

@@ -290,12 +290,12 @@ public sealed class FieldAwareFactorizationMachinePredictionTransformer : Predic
         /// <summary>
         /// The name of the feature column used by the prediction transformer.
         /// </summary>
-        internal IReadOnlyList<string> FeatureColumns { get; }
+        private IReadOnlyList<string> FeatureColumns { get; }
 
         /// <summary>
         /// The type of the feature columns.
         /// </summary>
-        internal IReadOnlyList<DataViewType> FeatureColumnTypes { get; }
+        private IReadOnlyList<DataViewType> FeatureColumnTypes { get; }
 
         private readonly string _thresholdColumn;
         private readonly float _threshold;

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

@@ -51,7 +51,8 @@ public abstract class LinearModelParameters : ModelParametersBase<float>,
         ISingleCanSavePfa,
         ISingleCanSaveOnnx
     {
-        protected readonly VBuffer<float> Weight;
+        [BestFriend]
+        private protected readonly VBuffer<float> Weight;
 
         // _weightsDense is not persisted and is used for performance when the input instance is sparse.
         private VBuffer<float> _weightsDense;
@@ -250,7 +251,7 @@ bool ISingleCanSaveOnnx.SaveAsOnnx(OnnxContext ctx, string[] outputs, string fea
         }
 
         // Generate the score from the given values, assuming they have already been normalized.
-        protected virtual float Score(in VBuffer<float> src)
+        private protected virtual float Score(in VBuffer<float> src)
         {
             if (src.IsDense)
             {
@@ -711,7 +712,7 @@ private protected override void SaveCore(ModelSaveContext ctx)
             ctx.SetVersionInfo(GetVersionInfo());
         }
 
-        protected override float Score(in VBuffer<float> src)
+        private protected override float Score(in VBuffer<float> src)
         {
             return MathUtils.ExpSlow(base.Score(in src));
         }

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

@@ -105,28 +105,28 @@ internal static class Defaults
 
         private const string RegisterName = nameof(LbfgsTrainerBase<TArgs, TTransformer, TModel>);
 
-        protected int NumFeatures;
-        protected VBuffer<float> CurrentWeights;
-        protected long NumGoodRows;
-        protected Double WeightSum;
-        protected bool ShowTrainingStats;
+        private protected int NumFeatures;
+        private protected VBuffer<float> CurrentWeights;
+        private protected long NumGoodRows;
+        private protected Double WeightSum;
+        private protected bool ShowTrainingStats;
 
         private TModel _srcPredictor;
 
-        protected readonly TArgs Args;
-        protected readonly float L2Weight;
-        protected readonly float L1Weight;
-        protected readonly float OptTol;
-        protected readonly int MemorySize;
-        protected readonly int MaxIterations;
-        protected readonly float SgdInitializationTolerance;
-        protected readonly bool Quiet;
-        protected readonly float InitWtsDiameter;
-        protected readonly bool UseThreads;
-        protected readonly int? NumThreads;
-        protected readonly bool DenseOptimizer;
-        protected readonly long MaxNormalizationExamples;
-        protected readonly bool EnforceNonNegativity;
+        private protected readonly TArgs Args;
+        private protected readonly float L2Weight;
+        private protected readonly float L1Weight;
+        private protected readonly float OptTol;
+        private protected readonly int MemorySize;
+        private protected readonly int MaxIterations;
+        private protected readonly float SgdInitializationTolerance;
+        private protected readonly bool Quiet;
+        private protected readonly float InitWtsDiameter;
+        private protected readonly bool UseThreads;
+        private protected readonly int? NumThreads;
+        private protected readonly bool DenseOptimizer;
+        private protected readonly long MaxNormalizationExamples;
+        private protected readonly bool EnforceNonNegativity;
 
         // The training data, when NOT using multiple threads.
         private RoleMappedData _data;
@@ -256,9 +256,9 @@ private static TArgs ArgsInit(string featureColumn, SchemaShape.Column labelColu
             return args;
         }
 
-        protected virtual int ClassCount => 1;
-        protected int BiasCount => ClassCount;
-        protected int WeightCount => ClassCount * NumFeatures;
+        private protected virtual int ClassCount => 1;
+        private protected int BiasCount => ClassCount;
+        private protected int WeightCount => ClassCount * NumFeatures;
         private protected virtual Optimizer InitializeOptimizer(IChannel ch, FloatLabelCursor.Factory cursorFactory,
             out VBuffer<float> init, out ITerminationCriterion terminationCriterion)
         {
@@ -364,15 +364,15 @@ private protected virtual VBuffer<float> InitializeWeightsSgd(IChannel ch, Float
             return result;
         }
 
-        protected abstract VBuffer<float> InitializeWeightsFromPredictor(TModel srcPredictor);
+        private protected abstract VBuffer<float> InitializeWeightsFromPredictor(TModel srcPredictor);
 
         private protected abstract void CheckLabel(RoleMappedData data);
 
-        protected virtual void PreTrainingProcessInstance(float label, in VBuffer<float> feat, float weight)
+        private protected virtual void PreTrainingProcessInstance(float label, in VBuffer<float> feat, float weight)
         {
         }
 
-        protected abstract TModel CreatePredictor();
+        private protected abstract TModel CreatePredictor();
 
         /// <summary>
         /// The basic training calls the optimizer
@@ -570,24 +570,24 @@ private protected virtual void TrainCore(IChannel ch, RoleMappedData data)
 
         // Ensure that the bias portion of vec is represented in vec.
         // REVIEW: Is this really necessary?
-        protected void EnsureBiases(ref VBuffer<float> vec)
+        private protected void EnsureBiases(ref VBuffer<float> vec)
         {
             // REVIEW: Consider promoting this "densify first n entries" to a general purpose utility,
             // if we ever encounter other situations where this becomes useful.
             Contracts.Assert(vec.Length == BiasCount + WeightCount);
             VBufferUtils.DensifyFirst(ref vec, BiasCount);
         }
 
-        protected abstract float AccumulateOneGradient(in VBuffer<float> feat, float label, float weight,
+        private protected abstract float AccumulateOneGradient(in VBuffer<float> feat, float label, float weight,
             in VBuffer<float> xDense, ref VBuffer<float> grad, ref float[] scratch);
 
         private protected abstract void ComputeTrainingStatistics(IChannel ch, FloatLabelCursor.Factory cursorFactory, float loss, int numParams);
 
-        protected abstract void ProcessPriorDistribution(float label, float weight);
+        private protected abstract void ProcessPriorDistribution(float label, float weight);
         /// <summary>
         /// The gradient being used by the optimizer
         /// </summary>
-        protected virtual float DifferentiableFunction(in VBuffer<float> x, ref VBuffer<float> gradient,
+        private protected virtual float DifferentiableFunction(in VBuffer<float> x, ref VBuffer<float> gradient,
             IProgressChannelProvider progress)
         {
             Contracts.Assert((_numChunks == 0) != (_data == null));
@@ -647,7 +647,7 @@ protected virtual float DifferentiableFunction(in VBuffer<float> x, ref VBuffer<
         /// REVIEW: consider getting rid of multithread-targeted members
         /// Using TPL, the distinction between Multithreaded and Sequential implementations is unnecessary
         /// </remarks>
-        protected virtual float DifferentiableFunctionMultithreaded(in VBuffer<float> xDense, ref VBuffer<float> gradient, IProgressChannel pch)
+        private protected virtual float DifferentiableFunctionMultithreaded(in VBuffer<float> xDense, ref VBuffer<float> gradient, IProgressChannel pch)
         {
             Contracts.Assert(_data == null);
             Contracts.Assert(_cursorFactory == null);
@@ -679,7 +679,7 @@ protected virtual float DifferentiableFunctionMultithreaded(in VBuffer<float> xD
             return loss;
         }
 
-        protected float DifferentiableFunctionComputeChunk(int ichk, in VBuffer<float> xDense, ref VBuffer<float> grad, IProgressChannel pch)
+        private protected float DifferentiableFunctionComputeChunk(int ichk, in VBuffer<float> xDense, ref VBuffer<float> grad, IProgressChannel pch)
         {
             Contracts.Assert(0 <= ichk && ichk < _numChunks);
             Contracts.AssertValueOrNull(pch);
@@ -733,7 +733,7 @@ private protected float DifferentiableFunctionStream(FloatLabelCursor.Factory cu
             return (float)loss;
         }
 
-        protected VBuffer<float> InitializeWeights(IEnumerable<float> weights, IEnumerable<float> biases)
+        private protected VBuffer<float> InitializeWeights(IEnumerable<float> weights, IEnumerable<float> biases)
         {
             Contracts.AssertValue(biases);
             Contracts.AssertValue(weights);

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

@@ -134,7 +134,7 @@ protected override BinaryPredictionTransformer<CalibratedModelParametersBase<Lin
         public BinaryPredictionTransformer<CalibratedModelParametersBase<LinearBinaryModelParameters, PlattCalibrator>> Fit(IDataView trainData, IPredictor initialPredictor)
             => TrainTransformer(trainData, initPredictor: initialPredictor);
 
-        protected override float AccumulateOneGradient(in VBuffer<float> feat, float label, float weight,
+        private protected override float AccumulateOneGradient(in VBuffer<float> feat, float label, float weight,
             in VBuffer<float> x, ref VBuffer<float> grad, ref float[] scratch)
         {
             float bias = 0;
@@ -364,7 +364,7 @@ private protected override void ComputeTrainingStatistics(IChannel ch, FloatLabe
             }
         }
 
-        protected override void ProcessPriorDistribution(float label, float weight)
+        private protected override void ProcessPriorDistribution(float label, float weight)
         {
             if (label > 0)
                 _posWeight += weight;
@@ -384,7 +384,7 @@ private protected override Optimizer InitializeOptimizer(IChannel ch, FloatLabel
             return opt;
         }
 
-        protected override VBuffer<float> InitializeWeightsFromPredictor(CalibratedModelParametersBase<LinearBinaryModelParameters, PlattCalibrator> srcPredictor)
+        private protected override VBuffer<float> InitializeWeightsFromPredictor(CalibratedModelParametersBase<LinearBinaryModelParameters, PlattCalibrator> srcPredictor)
         {
             Contracts.AssertValue(srcPredictor);
 
@@ -393,7 +393,7 @@ protected override VBuffer<float> InitializeWeightsFromPredictor(CalibratedModel
             return InitializeWeights(pred.Weights, new[] { pred.Bias });
         }
 
-        protected override CalibratedModelParametersBase<LinearBinaryModelParameters, PlattCalibrator> CreatePredictor()
+        private protected override CalibratedModelParametersBase<LinearBinaryModelParameters, PlattCalibrator> CreatePredictor()
         {
             // Logistic regression is naturally calibrated to
             // output probabilities when transformed using

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

@@ -67,7 +67,7 @@ public sealed class Options : OptionsBase
 
         private LinearModelStatistics _stats;
 
-        protected override int ClassCount => _numClasses;
+        private protected override int ClassCount => _numClasses;
 
         /// <summary>
         /// Initializes a new instance of <see cref="MulticlassLogisticRegression"/>
@@ -184,7 +184,7 @@ private protected override Optimizer InitializeOptimizer(IChannel ch, FloatLabel
             return opt;
         }
 
-        protected override float AccumulateOneGradient(in VBuffer<float> feat, float label, float weight,
+        private protected override float AccumulateOneGradient(in VBuffer<float> feat, float label, float weight,
             in VBuffer<float> x, ref VBuffer<float> grad, ref float[] scores)
         {
             if (Utils.Size(scores) < _numClasses)
@@ -220,7 +220,7 @@ protected override float AccumulateOneGradient(in VBuffer<float> feat, float lab
             return weight * datumLoss;
         }
 
-        protected override VBuffer<float> InitializeWeightsFromPredictor(MulticlassLogisticRegressionModelParameters srcPredictor)
+        private protected override VBuffer<float> InitializeWeightsFromPredictor(MulticlassLogisticRegressionModelParameters srcPredictor)
         {
             Contracts.AssertValue(srcPredictor);
             Contracts.Assert(srcPredictor.InputType.GetVectorSize() > 0);
@@ -232,7 +232,7 @@ protected override VBuffer<float> InitializeWeightsFromPredictor(MulticlassLogis
             return InitializeWeights(srcPredictor.DenseWeightsEnumerable(), srcPredictor.GetBiases());
         }
 
-        protected override MulticlassLogisticRegressionModelParameters CreatePredictor()
+        private protected override MulticlassLogisticRegressionModelParameters CreatePredictor()
         {
             if (_numClasses < 1)
                 throw Contracts.Except("Cannot create a multiclass predictor with {0} classes", _numClasses);
@@ -301,7 +301,7 @@ private protected override void ComputeTrainingStatistics(IChannel ch, FloatLabe
             _stats = new LinearModelStatistics(Host, NumGoodRows, numParams, deviance, nullDeviance);
         }
 
-        protected override void ProcessPriorDistribution(float label, float weight)
+        private protected override void ProcessPriorDistribution(float label, float weight)
         {
             int iLabel = (int)label;
             Contracts.Assert(0 <= iLabel && iLabel < _numClasses);

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

@@ -51,7 +51,7 @@ public CoefficientStatistics(string name, float estimate, float stdError, float
     /// </summary>
     public sealed class LinearModelStatistics : ICanSaveModel
     {
-        public const string LoaderSignature = "LinearModelStats";
+        internal const string LoaderSignature = "LinearModelStats";
 
         private static VersionInfo GetVersionInfo()
         {

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

@@ -118,8 +118,8 @@ public abstract class AveragedLinearTrainer<TTransformer, TModel> : OnlineLinear
         where TTransformer : ISingleFeaturePredictionTransformer<TModel>
         where TModel : class
     {
-        protected readonly AveragedLinearOptions AveragedLinearTrainerOptions;
-        protected IScalarOutputLoss LossFunction;
+        private protected readonly AveragedLinearOptions AveragedLinearTrainerOptions;
+        private protected IScalarOutputLoss LossFunction;
 
         private protected abstract class AveragedTrainStateBase : TrainStateBase
         {
@@ -295,7 +295,7 @@ private void IncrementAverageNonLazy()
             }
         }
 
-        protected AveragedLinearTrainer(AveragedLinearOptions options, IHostEnvironment env, string name, SchemaShape.Column label)
+        private protected AveragedLinearTrainer(AveragedLinearOptions options, IHostEnvironment env, string name, SchemaShape.Column label)
             : base(options, env, name, label)
         {
             Contracts.CheckUserArg(options.LearningRate > 0, nameof(options.LearningRate), UserErrorPositive);

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

@@ -163,7 +163,7 @@ public TrivialFactory(IClassificationLoss loss)
 
         public override PredictionKind PredictionKind => PredictionKind.BinaryClassification;
 
-        protected override bool NeedCalibration => true;
+        private protected override bool NeedCalibration => true;
 
         protected override SchemaShape.Column[] GetOutputColumnsCore(SchemaShape inputSchema)
         {

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

@@ -223,7 +223,7 @@ public override LinearBinaryModelParameters CreatePredictor()
             }
         }
 
-        protected override bool NeedCalibration => true;
+        private protected override bool NeedCalibration => true;
 
         /// <summary>
         /// Initializes a new instance of <see cref="LinearSvmTrainer"/>.

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

@@ -70,8 +70,8 @@ public abstract class OnlineLinearTrainer<TTransformer, TModel> : TrainerEstimat
         where TTransformer : ISingleFeaturePredictionTransformer<TModel>
         where TModel : class
     {
-        protected readonly OnlineLinearOptions OnlineLinearTrainerOptions;
-        protected readonly string Name;
+        private protected readonly OnlineLinearOptions OnlineLinearTrainerOptions;
+        private protected readonly string Name;
 
         /// <summary>
         /// An object to hold the mutable updatable state for the online linear trainers. Specific algorithms should subclass
@@ -246,12 +246,12 @@ public virtual float Margin(in VBuffer<float> feat)
         private const float _maxWeightScale = 1 << 10; // Exponent ranges 127 to -128, tolerate 10 being cut off that.
         private const float _minWeightScale = 1 / _maxWeightScale;
 
-        protected const string UserErrorPositive = "must be positive";
-        protected const string UserErrorNonNegative = "must be non-negative";
+        private protected const string UserErrorPositive = "must be positive";
+        private protected const string UserErrorNonNegative = "must be non-negative";
 
         public override TrainerInfo Info { get; }
 
-        protected virtual bool NeedCalibration => false;
+        private protected virtual bool NeedCalibration => false;
 
         private protected OnlineLinearTrainer(OnlineLinearOptions options, IHostEnvironment env, string name, SchemaShape.Column label)
             : base(Contracts.CheckRef(env, nameof(env)).Register(name), TrainerUtils.MakeR4VecFeature(options.FeatureColumn), label, TrainerUtils.MakeR4ScalarWeightColumn(options.InitialWeights))