Cleaned up more default parameters and removed unused options since interface implementation will take care of them

ooples · ooples · commit 5988019d61b7 · 2024-12-15T10:49:53.000-05:00
diff --git a/src/Interfaces/IOptimizationAlgorithm.cs b/src/Interfaces/IOptimizationAlgorithm.cs
@@ -10,13 +10,12 @@ public OptimizationResult<T> Optimize(
         Matrix<T> XTest,
         Vector<T> yTest,
         PredictionModelOptions modelOptions,
-        OptimizationAlgorithmOptions optimizationOptions,
         IRegression<T> regressionMethod,
         IRegularization<T> regularization,
         INormalizer<T> normalizer,
         NormalizationInfo<T> normInfo,
         IFitnessCalculator<T> fitnessCalculator,
         IFitDetector<T> fitDetector);
 
-    bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory, OptimizationAlgorithmOptions options, IFitnessCalculator<T> fitnessCalculator);
+    bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory, IFitnessCalculator<T> fitnessCalculator);
 }
diff --git a/src/Interfaces/IPredictionModelBuilder.cs b/src/Interfaces/IPredictionModelBuilder.cs
@@ -2,15 +2,15 @@
 
 public interface IPredictionModelBuilder<T>
 {
-    IPredictionModelBuilder<T> WithFeatureSelector(IFeatureSelector<T> selector);
-    IPredictionModelBuilder<T> WithNormalizer(INormalizer<T> normalizer);
-    IPredictionModelBuilder<T> WithRegularization(IRegularization<T> regularization, RegularizationOptions? regularizationOptions = null);
-    IPredictionModelBuilder<T> WithFitnessCalculator(IFitnessCalculator<T> calculator, FitnessCalculatorOptions? _fitnessCalculatorOptions = null);
-    IPredictionModelBuilder<T> WithFitDetector(IFitDetector<T> detector);
-    IPredictionModelBuilder<T> WithRegression(IRegression<T> regression, RegressionOptions<T>? regressionOptions = null);
-    IPredictionModelBuilder<T> WithOptimizer(IOptimizationAlgorithm<T> optimizationAlgorithm, OptimizationAlgorithmOptions? optimizationOptions = null);
-    IPredictionModelBuilder<T> WithDataPreprocessor(IDataPreprocessor<T> dataPreprocessor);
-    IPredictionModelBuilder<T> WithOutlierRemoval(IOutlierRemoval<T> outlierRemoval);
+    IPredictionModelBuilder<T> ConfigureFeatureSelector(IFeatureSelector<T> selector);
+    IPredictionModelBuilder<T> ConfigureNormalizer(INormalizer<T> normalizer);
+    IPredictionModelBuilder<T> ConfigureRegularization(IRegularization<T> regularization);
+    IPredictionModelBuilder<T> ConfigureFitnessCalculator(IFitnessCalculator<T> calculator);
+    IPredictionModelBuilder<T> ConfigureFitDetector(IFitDetector<T> detector);
+    IPredictionModelBuilder<T> ConfigureRegression(IRegression<T> regression);
+    IPredictionModelBuilder<T> ConfigureOptimizer(IOptimizationAlgorithm<T> optimizationAlgorithm);
+    IPredictionModelBuilder<T> ConfigureDataPreprocessor(IDataPreprocessor<T> dataPreprocessor);
+    IPredictionModelBuilder<T> ConfigureOutlierRemoval(IOutlierRemoval<T> outlierRemoval);
     PredictionModelResult<T> Build(Matrix<T> x, Vector<T> y);
     Vector<T> Predict(Matrix<T> newData, PredictionModelResult<T> model);
     void SaveModel(PredictionModelResult<T> model, string filePath);
diff --git a/src/LinearAlgebra/PredictionModelBuilder.cs b/src/LinearAlgebra/PredictionModelBuilder.cs
@@ -10,10 +10,6 @@ namespace AiDotNet.LinearAlgebra;
 public class PredictionModelBuilder<T> : IPredictionModelBuilder<T>
 {
     private readonly PredictionModelOptions _options;
-    private OptimizationAlgorithmOptions? _optimizationOptions;
-    private RegularizationOptions? _regularizationOptions;
-    private RegressionOptions<T>? _regressionOptions;
-    private FitnessCalculatorOptions? _fitnessCalculatorOptions;
     private IFeatureSelector<T>? _featureSelector;
     private INormalizer<T>? _normalizer;
     private IRegularization<T>? _regularization;
@@ -29,59 +25,55 @@ public PredictionModelBuilder(PredictionModelOptions? options = null)
         _options = options ?? new PredictionModelOptions();
     }
 
-    public IPredictionModelBuilder<T> WithFeatureSelector(IFeatureSelector<T> selector)
+    public IPredictionModelBuilder<T> ConfigureFeatureSelector(IFeatureSelector<T> selector)
     {
         _featureSelector = selector;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithNormalizer(INormalizer<T> normalizer)
+    public IPredictionModelBuilder<T> ConfigureNormalizer(INormalizer<T> normalizer)
     {
         _normalizer = normalizer;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithRegularization(IRegularization<T> regularization, RegularizationOptions? regularizationOptions = null)
+    public IPredictionModelBuilder<T> ConfigureRegularization(IRegularization<T> regularization)
     {
         _regularization = regularization;
-        _regularizationOptions = regularizationOptions;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithFitnessCalculator(IFitnessCalculator<T> calculator, FitnessCalculatorOptions? fitnessCalculatorOptions = null)
+    public IPredictionModelBuilder<T> ConfigureFitnessCalculator(IFitnessCalculator<T> calculator)
     {
         _fitnessCalculator = calculator;
-        _fitnessCalculatorOptions = fitnessCalculatorOptions;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithFitDetector(IFitDetector<T> detector)
+    public IPredictionModelBuilder<T> ConfigureFitDetector(IFitDetector<T> detector)
     {
         _fitDetector = detector;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithRegression(IRegression<T> regression, RegressionOptions<T>? regressionOptions = null)
+    public IPredictionModelBuilder<T> ConfigureRegression(IRegression<T> regression)
     {
         _regression = regression;
-        _regressionOptions = regressionOptions;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithOptimizer(IOptimizationAlgorithm<T> optimizationAlgorithm, OptimizationAlgorithmOptions? optimizationOptions = null)
+    public IPredictionModelBuilder<T> ConfigureOptimizer(IOptimizationAlgorithm<T> optimizationAlgorithm)
     {
         _optimizer = optimizationAlgorithm;
-        _optimizationOptions = optimizationOptions;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithDataPreprocessor(IDataPreprocessor<T> dataPreprocessor)
+    public IPredictionModelBuilder<T> ConfigureDataPreprocessor(IDataPreprocessor<T> dataPreprocessor)
     {
         _dataPreprocessor = dataPreprocessor;
         return this;
     }
 
-    public IPredictionModelBuilder<T> WithOutlierRemoval(IOutlierRemoval<T> outlierRemoval)
+    public IPredictionModelBuilder<T> ConfigureOutlierRemoval(IOutlierRemoval<T> outlierRemoval)
     {
         _outlierRemoval = outlierRemoval;
         return this;
@@ -102,7 +94,6 @@ public PredictionModelResult<T> Build(Matrix<T> x, Vector<T> y)
         // Use defaults for these interfaces if they aren't set
         var normalizer = _normalizer ?? new NoNormalizer<T>();
         var optimizer = _optimizer ?? new NormalOptimizer<T>();
-        var optimizerOptions = _optimizationOptions ?? new OptimizationAlgorithmOptions();
         var featureSelector = _featureSelector ?? new NoFeatureSelector<T>();
         var fitDetector = _fitDetector ?? new DefaultFitDetector<T>();
         var fitnessCalculator = _fitnessCalculator ?? new RSquaredFitnessCalculator<T>();
@@ -117,7 +108,7 @@ public PredictionModelResult<T> Build(Matrix<T> x, Vector<T> y)
         var (XTrain, yTrain, XVal, yVal, XTest, yTest) = dataPreprocessor.SplitData(preprocessedX, preprocessedY);
 
         // Optimize the model
-        var optimizationResult = optimizer.Optimize(XTrain, yTrain, XVal, yVal, XTest, yTest, _options, optimizerOptions, _regression, regularization, normalizer, 
+        var optimizationResult = optimizer.Optimize(XTrain, yTrain, XVal, yVal, XTest, yTest, _options, _regression, regularization, normalizer, 
             normInfo, fitnessCalculator, fitDetector);
 
         return new PredictionModelResult<T>
diff --git a/src/Optimizers/NormalOptimizer.cs b/src/Optimizers/NormalOptimizer.cs
@@ -4,10 +4,12 @@ public class NormalOptimizer<T> : IOptimizationAlgorithm<T>
 {
     private readonly Random _random = new();
     private readonly INumericOperations<T> _numOps;
+    private readonly OptimizationAlgorithmOptions _optimizationOptions;
 
-    public NormalOptimizer(INumericOperations<T>? numericOperations = null)
+    public NormalOptimizer(OptimizationAlgorithmOptions? optimizationOptions = null)
     {
-        _numOps = numericOperations ?? MathHelper.GetNumericOperations<T>();
+        _numOps = MathHelper.GetNumericOperations<T>();
+        _optimizationOptions = optimizationOptions ?? new OptimizationAlgorithmOptions();
     }
 
     public OptimizationResult<T> Optimize(
@@ -18,7 +20,6 @@ public OptimizationResult<T> Optimize(
         Matrix<T> XTest,
         Vector<T> yTest,
         PredictionModelOptions modelOptions,
-        OptimizationAlgorithmOptions optimizationOptions,
         IRegression<T> regressionMethod,
         IRegularization<T> regularization,
         INormalizer<T> normalizer,
@@ -28,7 +29,7 @@ public OptimizationResult<T> Optimize(
     {
         var bestSolution = new Vector<T>(XTrain.Columns, _numOps);
         var bestIntercept = _numOps.Zero;
-        T bestFitness = optimizationOptions.MaximizeFitness ? _numOps.MinValue : _numOps.MaxValue;
+        T bestFitness = _optimizationOptions.MaximizeFitness ? _numOps.MinValue : _numOps.MaxValue;
         var fitnessHistory = new List<T>();
         var iterationHistory = new List<OptimizationIterationInfo<T>>();
         var bestSelectedFeatures = new List<Vector<T>>();
@@ -52,7 +53,7 @@ public OptimizationResult<T> Optimize(
         PredictionStats<T>? bestValidationPredictionStats = null;
         PredictionStats<T>? bestTestPredictionStats = null;
 
-        for (int iteration = 0; iteration < optimizationOptions.MaxIterations; iteration++)
+        for (int iteration = 0; iteration < _optimizationOptions.MaxIterations; iteration++)
         {
             // Randomly select features
             var selectedFeatures = RandomlySelectFeatures(XTrain.Columns, modelOptions.MinimumFeatures, modelOptions.MaximumFeatures);
@@ -87,9 +88,9 @@ public OptimizationResult<T> Optimize(
             var testActualBasicStats = new BasicStats<T>(yTest);
             var testPredictedBasicStats = new BasicStats<T>(testPredictions);
 
-            var trainingPredictionStats = new PredictionStats<T>(yTrain, trainingPredictions, featureCount, _numOps.FromDouble(optimizationOptions.ConfidenceLevel), _numOps);
-            var validationPredictionStats = new PredictionStats<T>(yVal, validationPredictions, featureCount, _numOps.FromDouble(optimizationOptions.ConfidenceLevel), _numOps);
-            var testPredictionStats = new PredictionStats<T>(yTest, testPredictions, featureCount, _numOps.FromDouble(optimizationOptions.ConfidenceLevel), _numOps);
+            var trainingPredictionStats = new PredictionStats<T>(yTrain, trainingPredictions, featureCount, _numOps.FromDouble(_optimizationOptions.ConfidenceLevel), _numOps);
+            var validationPredictionStats = new PredictionStats<T>(yVal, validationPredictions, featureCount, _numOps.FromDouble(_optimizationOptions.ConfidenceLevel), _numOps);
+            var testPredictionStats = new PredictionStats<T>(yTest, testPredictions, featureCount, _numOps.FromDouble(_optimizationOptions.ConfidenceLevel), _numOps);
 
             // Detect fit type
             var fitDetectionResult = fitDetector.DetectFit(
@@ -141,7 +142,7 @@ public OptimizationResult<T> Optimize(
             });
 
             // Check for early stopping
-            if (optimizationOptions.UseEarlyStopping && ShouldEarlyStop(iterationHistory, optimizationOptions, fitnessCalculator))
+            if (_optimizationOptions.UseEarlyStopping && ShouldEarlyStop(iterationHistory, fitnessCalculator))
             {
                 break;
             }
@@ -194,14 +195,14 @@ public OptimizationResult<T> Optimize(
         };
     }
 
-    public bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory, OptimizationAlgorithmOptions options, IFitnessCalculator<T> fitnessCalculator)
+    public bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory, IFitnessCalculator<T> fitnessCalculator)
     {
-        if (iterationHistory.Count < options.EarlyStoppingPatience)
+        if (iterationHistory.Count < _optimizationOptions.EarlyStoppingPatience)
         {
             return false;
         }
 
-        var recentIterations = iterationHistory.Skip(Math.Max(0, iterationHistory.Count - options.EarlyStoppingPatience)).ToList();
+        var recentIterations = iterationHistory.Skip(Math.Max(0, iterationHistory.Count - _optimizationOptions.EarlyStoppingPatience)).ToList();
 
         // Find the best fitness score
         T bestFitness = iterationHistory[0].Fitness;
@@ -238,7 +239,7 @@ public bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory,
             }
         }
 
-        return noImprovement || consecutiveBadFits >= options.BadFitPatience;
+        return noImprovement || consecutiveBadFits >= _optimizationOptions.BadFitPatience;
     }
 
     private List<int> RandomlySelectFeatures(int totalFeatures, int minFeatures, int maxFeatures)

Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,6 @@ namespace AiDotNet.LinearAlgebra;`
`10`	`10`	`public class PredictionModelBuilder<T> : IPredictionModelBuilder<T>`
`11`	`11`	`{`
`12`	`12`	`private readonly PredictionModelOptions _options;`
`13`		`- private OptimizationAlgorithmOptions? _optimizationOptions;`
`14`		`- private RegularizationOptions? _regularizationOptions;`
`15`		`- private RegressionOptions<T>? _regressionOptions;`
`16`		`- private FitnessCalculatorOptions? _fitnessCalculatorOptions;`
`17`	`13`	`private IFeatureSelector<T>? _featureSelector;`
`18`	`14`	`private INormalizer<T>? _normalizer;`
`19`	`15`	`private IRegularization<T>? _regularization;`
`@@ -29,59 +25,55 @@ public PredictionModelBuilder(PredictionModelOptions? options = null)`
`29`	`25`	`_options = options ?? new PredictionModelOptions();`
`30`	`26`	`}`
`31`	`27`
`32`		`- public IPredictionModelBuilder<T> WithFeatureSelector(IFeatureSelector<T> selector)`
	`28`	`+ public IPredictionModelBuilder<T> ConfigureFeatureSelector(IFeatureSelector<T> selector)`
`33`	`29`	`{`
`34`	`30`	`_featureSelector = selector;`
`35`	`31`	`return this;`
`36`	`32`	`}`
`37`	`33`
`38`		`- public IPredictionModelBuilder<T> WithNormalizer(INormalizer<T> normalizer)`
	`34`	`+ public IPredictionModelBuilder<T> ConfigureNormalizer(INormalizer<T> normalizer)`
`39`	`35`	`{`
`40`	`36`	`_normalizer = normalizer;`
`41`	`37`	`return this;`
`42`	`38`	`}`
`43`	`39`
`44`		`- public IPredictionModelBuilder<T> WithRegularization(IRegularization<T> regularization, RegularizationOptions? regularizationOptions = null)`
	`40`	`+ public IPredictionModelBuilder<T> ConfigureRegularization(IRegularization<T> regularization)`
`45`	`41`	`{`
`46`	`42`	`_regularization = regularization;`
`47`		`- _regularizationOptions = regularizationOptions;`
`48`	`43`	`return this;`
`49`	`44`	`}`
`50`	`45`
`51`		`- public IPredictionModelBuilder<T> WithFitnessCalculator(IFitnessCalculator<T> calculator, FitnessCalculatorOptions? fitnessCalculatorOptions = null)`
	`46`	`+ public IPredictionModelBuilder<T> ConfigureFitnessCalculator(IFitnessCalculator<T> calculator)`
`52`	`47`	`{`
`53`	`48`	`_fitnessCalculator = calculator;`
`54`		`- _fitnessCalculatorOptions = fitnessCalculatorOptions;`
`55`	`49`	`return this;`
`56`	`50`	`}`
`57`	`51`
`58`		`- public IPredictionModelBuilder<T> WithFitDetector(IFitDetector<T> detector)`
	`52`	`+ public IPredictionModelBuilder<T> ConfigureFitDetector(IFitDetector<T> detector)`
`59`	`53`	`{`
`60`	`54`	`_fitDetector = detector;`
`61`	`55`	`return this;`
`62`	`56`	`}`
`63`	`57`
`64`		`- public IPredictionModelBuilder<T> WithRegression(IRegression<T> regression, RegressionOptions<T>? regressionOptions = null)`
	`58`	`+ public IPredictionModelBuilder<T> ConfigureRegression(IRegression<T> regression)`
`65`	`59`	`{`
`66`	`60`	`_regression = regression;`
`67`		`- _regressionOptions = regressionOptions;`
`68`	`61`	`return this;`
`69`	`62`	`}`
`70`	`63`
`71`		`- public IPredictionModelBuilder<T> WithOptimizer(IOptimizationAlgorithm<T> optimizationAlgorithm, OptimizationAlgorithmOptions? optimizationOptions = null)`
	`64`	`+ public IPredictionModelBuilder<T> ConfigureOptimizer(IOptimizationAlgorithm<T> optimizationAlgorithm)`
`72`	`65`	`{`
`73`	`66`	`_optimizer = optimizationAlgorithm;`
`74`		`- _optimizationOptions = optimizationOptions;`
`75`	`67`	`return this;`
`76`	`68`	`}`
`77`	`69`
`78`		`- public IPredictionModelBuilder<T> WithDataPreprocessor(IDataPreprocessor<T> dataPreprocessor)`
	`70`	`+ public IPredictionModelBuilder<T> ConfigureDataPreprocessor(IDataPreprocessor<T> dataPreprocessor)`
`79`	`71`	`{`
`80`	`72`	`_dataPreprocessor = dataPreprocessor;`
`81`	`73`	`return this;`
`82`	`74`	`}`
`83`	`75`
`84`		`- public IPredictionModelBuilder<T> WithOutlierRemoval(IOutlierRemoval<T> outlierRemoval)`
	`76`	`+ public IPredictionModelBuilder<T> ConfigureOutlierRemoval(IOutlierRemoval<T> outlierRemoval)`
`85`	`77`	`{`
`86`	`78`	`_outlierRemoval = outlierRemoval;`
`87`	`79`	`return this;`
`@@ -102,7 +94,6 @@ public PredictionModelResult<T> Build(Matrix<T> x, Vector<T> y)`
`102`	`94`	`// Use defaults for these interfaces if they aren't set`
`103`	`95`	`var normalizer = _normalizer ?? new NoNormalizer<T>();`
`104`	`96`	`var optimizer = _optimizer ?? new NormalOptimizer<T>();`
`105`		`- var optimizerOptions = _optimizationOptions ?? new OptimizationAlgorithmOptions();`
`106`	`97`	`var featureSelector = _featureSelector ?? new NoFeatureSelector<T>();`
`107`	`98`	`var fitDetector = _fitDetector ?? new DefaultFitDetector<T>();`
`108`	`99`	`var fitnessCalculator = _fitnessCalculator ?? new RSquaredFitnessCalculator<T>();`
`@@ -117,7 +108,7 @@ public PredictionModelResult<T> Build(Matrix<T> x, Vector<T> y)`
`117`	`108`	`var (XTrain, yTrain, XVal, yVal, XTest, yTest) = dataPreprocessor.SplitData(preprocessedX, preprocessedY);`
`118`	`109`
`119`	`110`	`// Optimize the model`
`120`		`- var optimizationResult = optimizer.Optimize(XTrain, yTrain, XVal, yVal, XTest, yTest, _options, optimizerOptions, _regression, regularization, normalizer,`
	`111`	`+ var optimizationResult = optimizer.Optimize(XTrain, yTrain, XVal, yVal, XTest, yTest, _options, _regression, regularization, normalizer,`
`121`	`112`	`normInfo, fitnessCalculator, fitDetector);`
`122`	`113`
`123`	`114`	`return new PredictionModelResult<T>`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,12 @@ public class NormalOptimizer<T> : IOptimizationAlgorithm<T>`
`4`	`4`	`{`
`5`	`5`	`private readonly Random _random = new();`
`6`	`6`	`private readonly INumericOperations<T> _numOps;`
	`7`	`+ private readonly OptimizationAlgorithmOptions _optimizationOptions;`
`7`	`8`
`8`		`- public NormalOptimizer(INumericOperations<T>? numericOperations = null)`
	`9`	`+ public NormalOptimizer(OptimizationAlgorithmOptions? optimizationOptions = null)`
`9`	`10`	`{`
`10`		`- _numOps = numericOperations ?? MathHelper.GetNumericOperations<T>();`
	`11`	`+ _numOps = MathHelper.GetNumericOperations<T>();`
	`12`	`+ _optimizationOptions = optimizationOptions ?? new OptimizationAlgorithmOptions();`
`11`	`13`	`}`
`12`	`14`
`13`	`15`	`public OptimizationResult<T> Optimize(`
`@@ -18,7 +20,6 @@ public OptimizationResult<T> Optimize(`
`18`	`20`	`Matrix<T> XTest,`
`19`	`21`	`Vector<T> yTest,`
`20`	`22`	`PredictionModelOptions modelOptions,`
`21`		`- OptimizationAlgorithmOptions optimizationOptions,`
`22`	`23`	`IRegression<T> regressionMethod,`
`23`	`24`	`IRegularization<T> regularization,`
`24`	`25`	`INormalizer<T> normalizer,`
`@@ -28,7 +29,7 @@ public OptimizationResult<T> Optimize(`
`28`	`29`	`{`
`29`	`30`	`var bestSolution = new Vector<T>(XTrain.Columns, _numOps);`
`30`	`31`	`var bestIntercept = _numOps.Zero;`
`31`		`- T bestFitness = optimizationOptions.MaximizeFitness ? _numOps.MinValue : _numOps.MaxValue;`
	`32`	`+ T bestFitness = _optimizationOptions.MaximizeFitness ? _numOps.MinValue : _numOps.MaxValue;`
`32`	`33`	`var fitnessHistory = new List<T>();`
`33`	`34`	`var iterationHistory = new List<OptimizationIterationInfo<T>>();`
`34`	`35`	`var bestSelectedFeatures = new List<Vector<T>>();`
`@@ -52,7 +53,7 @@ public OptimizationResult<T> Optimize(`
`52`	`53`	`PredictionStats<T>? bestValidationPredictionStats = null;`
`53`	`54`	`PredictionStats<T>? bestTestPredictionStats = null;`
`54`	`55`
`55`		`- for (int iteration = 0; iteration < optimizationOptions.MaxIterations; iteration++)`
	`56`	`+ for (int iteration = 0; iteration < _optimizationOptions.MaxIterations; iteration++)`
`56`	`57`	`{`
`57`	`58`	`// Randomly select features`
`58`	`59`	`var selectedFeatures = RandomlySelectFeatures(XTrain.Columns, modelOptions.MinimumFeatures, modelOptions.MaximumFeatures);`
`@@ -87,9 +88,9 @@ public OptimizationResult<T> Optimize(`
`87`	`88`	`var testActualBasicStats = new BasicStats<T>(yTest);`
`88`	`89`	`var testPredictedBasicStats = new BasicStats<T>(testPredictions);`
`89`	`90`
`90`		`- var trainingPredictionStats = new PredictionStats<T>(yTrain, trainingPredictions, featureCount, _numOps.FromDouble(optimizationOptions.ConfidenceLevel), _numOps);`
`91`		`- var validationPredictionStats = new PredictionStats<T>(yVal, validationPredictions, featureCount, _numOps.FromDouble(optimizationOptions.ConfidenceLevel), _numOps);`
`92`		`- var testPredictionStats = new PredictionStats<T>(yTest, testPredictions, featureCount, _numOps.FromDouble(optimizationOptions.ConfidenceLevel), _numOps);`
	`91`	`+ var trainingPredictionStats = new PredictionStats<T>(yTrain, trainingPredictions, featureCount, _numOps.FromDouble(_optimizationOptions.ConfidenceLevel), _numOps);`
	`92`	`+ var validationPredictionStats = new PredictionStats<T>(yVal, validationPredictions, featureCount, _numOps.FromDouble(_optimizationOptions.ConfidenceLevel), _numOps);`
	`93`	`+ var testPredictionStats = new PredictionStats<T>(yTest, testPredictions, featureCount, _numOps.FromDouble(_optimizationOptions.ConfidenceLevel), _numOps);`
`93`	`94`
`94`	`95`	`// Detect fit type`
`95`	`96`	`var fitDetectionResult = fitDetector.DetectFit(`
`@@ -141,7 +142,7 @@ public OptimizationResult<T> Optimize(`
`141`	`142`	`});`
`142`	`143`
`143`	`144`	`// Check for early stopping`
`144`		`- if (optimizationOptions.UseEarlyStopping && ShouldEarlyStop(iterationHistory, optimizationOptions, fitnessCalculator))`
	`145`	`+ if (_optimizationOptions.UseEarlyStopping && ShouldEarlyStop(iterationHistory, fitnessCalculator))`
`145`	`146`	`{`
`146`	`147`	`break;`
`147`	`148`	`}`
`@@ -194,14 +195,14 @@ public OptimizationResult<T> Optimize(`
`194`	`195`	`};`
`195`	`196`	`}`
`196`	`197`
`197`		`- public bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory, OptimizationAlgorithmOptions options, IFitnessCalculator<T> fitnessCalculator)`
	`198`	`+ public bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory, IFitnessCalculator<T> fitnessCalculator)`
`198`	`199`	`{`
`199`		`- if (iterationHistory.Count < options.EarlyStoppingPatience)`
	`200`	`+ if (iterationHistory.Count < _optimizationOptions.EarlyStoppingPatience)`
`200`	`201`	`{`
`201`	`202`	`return false;`
`202`	`203`	`}`
`203`	`204`
`204`		`- var recentIterations = iterationHistory.Skip(Math.Max(0, iterationHistory.Count - options.EarlyStoppingPatience)).ToList();`
	`205`	`+ var recentIterations = iterationHistory.Skip(Math.Max(0, iterationHistory.Count - _optimizationOptions.EarlyStoppingPatience)).ToList();`
`205`	`206`
`206`	`207`	`// Find the best fitness score`
`207`	`208`	`T bestFitness = iterationHistory[0].Fitness;`
`@@ -238,7 +239,7 @@ public bool ShouldEarlyStop(List<OptimizationIterationInfo<T>> iterationHistory,`
`238`	`239`	`}`
`239`	`240`	`}`
`240`	`241`
`241`		`- return noImprovement \|\| consecutiveBadFits >= options.BadFitPatience;`
	`242`	`+ return noImprovement \|\| consecutiveBadFits >= _optimizationOptions.BadFitPatience;`
`242`	`243`	`}`
`243`	`244`
`244`	`245`	`private List<int> RandomlySelectFeatures(int totalFeatures, int minFeatures, int maxFeatures)`