add get_test_params-method to some optuna sampler classes

Author: SimonBlanke

src/hyperactive/opt/optuna/_cmaes_sampler.py

@@ -125,9 +125,52 @@ def _get_sampler(self):
     @classmethod
     def get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the optimizer."""
+        from hyperactive.experiment.integrations import SklearnCvExperiment
+        from sklearn.datasets import make_regression
+        from sklearn.neural_network import MLPRegressor
+        
+        # Test case 1: Basic continuous parameters (from base)
         params = super().get_test_params(parameter_set)
         params[0].update({
             "sigma0": 0.5,
             "n_startup_trials": 1,
         })
+        
+        # Test case 2: Neural network with continuous parameters only
+        # (CMA-ES specific - only continuous parameters allowed)
+        X, y = make_regression(n_samples=50, n_features=5, noise=0.1, random_state=42)
+        mlp_exp = SklearnCvExperiment(
+            estimator=MLPRegressor(random_state=42, max_iter=100), 
+            X=X, y=y, cv=3
+        )
+        
+        continuous_param_space = {
+            "alpha": (1e-5, 1e-1),              # L2 regularization (continuous)
+            "learning_rate_init": (1e-4, 1e-1), # Learning rate (continuous)
+            "beta_1": (0.8, 0.99),              # Adam beta1 (continuous)
+            "beta_2": (0.9, 0.999),             # Adam beta2 (continuous)
+            # Note: No categorical parameters - CMA-ES doesn't support them
+        }
+        
+        params.append({
+            "param_space": continuous_param_space,
+            "n_trials": 8,  # Smaller for faster testing
+            "experiment": mlp_exp,
+            "sigma0": 0.3,          # Different sigma for diversity
+            "n_startup_trials": 2,  # More startup trials
+        })
+        
+        # Test case 3: High-dimensional continuous space (CMA-ES strength)
+        high_dim_continuous = {
+            f"x{i}": (-1.0, 1.0) for i in range(6)  # 6D continuous optimization
+        }
+        
+        params.append({
+            "param_space": high_dim_continuous,
+            "n_trials": 12,
+            "experiment": mlp_exp,
+            "sigma0": 0.7,          # Larger initial spread
+            "n_startup_trials": 3,
+        })
+        
         return params

src/hyperactive/opt/optuna/_grid_sampler.py

@@ -118,17 +118,47 @@ def get_test_params(cls, parameter_set="default"):
         from hyperactive.experiment.integrations import SklearnCvExperiment
         from sklearn.datasets import load_iris
         from sklearn.svm import SVC
+        from sklearn.neighbors import KNeighborsClassifier
 
         X, y = load_iris(return_X_y=True)
-        sklearn_exp = SklearnCvExperiment(estimator=SVC(), X=X, y=y)
-
-        param_space = {
+        
+        # Test case 1: Basic continuous parameters (converted to discrete)
+        svm_exp = SklearnCvExperiment(estimator=SVC(), X=X, y=y)
+        param_space_1 = {
             "C": [0.01, 0.1, 1, 10],
             "gamma": [0.0001, 0.01, 0.1, 1],
         }
-
-        return [{
-            "param_space": param_space,
-            "n_trials": 10,
-            "experiment": sklearn_exp,
-        }]
+        
+        # Test case 2: Mixed categorical and discrete parameters
+        knn_exp = SklearnCvExperiment(estimator=KNeighborsClassifier(), X=X, y=y)
+        param_space_2 = {
+            "n_neighbors": [1, 3, 5, 7],             # Discrete integers
+            "weights": ["uniform", "distance"],      # Categorical
+            "metric": ["euclidean", "manhattan"],    # Categorical  
+            "p": [1, 2],                             # Discrete for minkowski
+        }
+        
+        # Test case 3: Small exhaustive grid (tests complete enumeration)
+        param_space_3 = {
+            "C": [0.1, 1],                           # 2 values
+            "kernel": ["rbf", "linear"],             # 2 values  
+        }
+        # Total: 2 × 2 = 4 combinations, n_trials should cover all
+        
+        return [
+            {
+                "param_space": param_space_1,
+                "n_trials": 10,
+                "experiment": svm_exp,
+            },
+            {
+                "param_space": param_space_2, 
+                "n_trials": 15,
+                "experiment": knn_exp,
+            },
+            {
+                "param_space": param_space_3,
+                "n_trials": 4,  # Exact number for exhaustive search
+                "experiment": svm_exp,
+            }
+        ]

src/hyperactive/opt/optuna/_nsga_ii_sampler.py

@@ -115,10 +115,37 @@ def _get_sampler(self):
     @classmethod
     def get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the optimizer."""
+        from hyperactive.experiment.integrations import SklearnCvExperiment
+        from sklearn.datasets import load_iris
+        from sklearn.ensemble import RandomForestClassifier
+        
+        # Test case 1: Basic single-objective (inherits from base)
         params = super().get_test_params(parameter_set)
         params[0].update({
             "population_size": 20,
             "mutation_prob": 0.2,
             "crossover_prob": 0.8,
         })
+        
+        # Test case 2: Multi-objective with mixed parameter types
+        X, y = load_iris(return_X_y=True)
+        rf_exp = SklearnCvExperiment(estimator=RandomForestClassifier(random_state=42), X=X, y=y)
+        
+        mixed_param_space = {
+            "n_estimators": (10, 50),           # Continuous integer
+            "max_depth": [3, 5, 7, None],       # Mixed discrete/None
+            "criterion": ["gini", "entropy"],   # Categorical
+            "min_samples_split": (2, 10),       # Continuous integer
+            "bootstrap": [True, False],         # Boolean categorical
+        }
+        
+        params.append({
+            "param_space": mixed_param_space,
+            "n_trials": 15,  # Smaller for faster testing
+            "experiment": rf_exp,
+            "population_size": 8,   # Smaller population for testing
+            "mutation_prob": 0.1,
+            "crossover_prob": 0.9,
+        })
+        
         return params

src/hyperactive/opt/optuna/_qmc_sampler.py

@@ -110,9 +110,47 @@ def _get_sampler(self):
     @classmethod
     def get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the optimizer."""
+        from hyperactive.experiment.integrations import SklearnCvExperiment
+        from sklearn.datasets import load_iris
+        from sklearn.linear_model import LogisticRegression
+        
+        # Test case 1: Halton sequence without scrambling
         params = super().get_test_params(parameter_set)
         params[0].update({
             "qmc_type": "halton",
             "scramble": False,
         })
+        
+        # Test case 2: Sobol sequence with scrambling
+        X, y = load_iris(return_X_y=True)
+        lr_exp = SklearnCvExperiment(estimator=LogisticRegression(random_state=42, max_iter=1000), X=X, y=y)
+        
+        mixed_param_space = {
+            "C": (0.01, 100),                        # Continuous
+            "penalty": ["l1", "l2", "elasticnet"],   # Categorical
+            "l1_ratio": (0.0, 1.0),                  # Continuous ratio
+            "solver": ["liblinear", "saga"],         # Categorical
+        }
+        
+        params.append({
+            "param_space": mixed_param_space,
+            "n_trials": 16,  # Power of 2 for better QMC properties
+            "experiment": lr_exp,
+            "qmc_type": "sobol",  # Different sequence type
+            "scramble": True,     # With scrambling for randomization
+        })
+        
+        # Test case 3: Higher dimensional space (tests QMC scaling)
+        high_dim_space = {
+            f"param_{i}": (0.0, 1.0) for i in range(8)  # 8-dimensional continuous space
+        }
+        
+        params.append({
+            "param_space": high_dim_space,
+            "n_trials": 32,  # Power of 2, good for QMC
+            "experiment": lr_exp,
+            "qmc_type": "sobol",
+            "scramble": False,
+        })
+        
         return params

src/hyperactive/opt/optuna/_tpe_sampler.py

@@ -117,9 +117,61 @@ def _get_sampler(self):
     @classmethod
     def get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the optimizer."""
+        from hyperactive.experiment.integrations import SklearnCvExperiment
+        from sklearn.datasets import load_wine
+        from sklearn.ensemble import RandomForestClassifier
+        from sklearn.svm import SVC
+        
+        # Test case 1: Basic TPE with standard parameters
         params = super().get_test_params(parameter_set)
         params[0].update({
             "n_startup_trials": 5,
             "n_ei_candidates": 12,
         })
+        
+        # Test case 2: Mixed parameter types with warm start
+        X, y = load_wine(return_X_y=True)
+        rf_exp = SklearnCvExperiment(estimator=RandomForestClassifier(random_state=42), X=X, y=y)
+        
+        mixed_param_space = {
+            "n_estimators": (10, 100),              # Continuous integer
+            "max_depth": [3, 5, 7, 10, None],       # Mixed discrete/None
+            "criterion": ["gini", "entropy"],       # Categorical
+            "min_samples_split": (2, 20),           # Continuous integer
+            "bootstrap": [True, False],             # Boolean
+        }
+        
+        # Warm start with known good configuration
+        warm_start_points = [
+            {"n_estimators": 50, "max_depth": 5, "criterion": "gini", 
+             "min_samples_split": 2, "bootstrap": True}
+        ]
+        
+        params.append({
+            "param_space": mixed_param_space,
+            "n_trials": 20,
+            "experiment": rf_exp,
+            "n_startup_trials": 3,     # Fewer random trials before TPE
+            "n_ei_candidates": 24,     # More EI candidates for better optimization
+            "initialize": {"warm_start": warm_start_points},
+        })
+        
+        # Test case 3: High-dimensional continuous space (TPE strength)
+        svm_exp = SklearnCvExperiment(estimator=SVC(), X=X, y=y)
+        high_dim_space = {
+            "C": (0.01, 100),
+            "gamma": (1e-6, 1e2),
+            "coef0": (0.0, 10.0),
+            "degree": (2, 5),
+            "tol": (1e-5, 1e-2),
+        }
+        
+        params.append({
+            "param_space": high_dim_space,
+            "n_trials": 25,
+            "experiment": svm_exp,
+            "n_startup_trials": 8,     # More startup for exploration
+            "n_ei_candidates": 32,     # More candidates for complex space
+        })
+        
         return params