nsga_ii_sampler_example.main()

Complexity

Conditions

3

Size

Total Lines	127
Code Lines	32

Duplication

Lines	127
Ratio	100 %

Importance

Changes

0

"""
def main():

This code seems to be duplicated in your project.

    # === NSGAIISampler Example ===
    # Multi-objective Optimization with NSGA-II

    nsga_ii_theory()

    # Load dataset
    X, y = load_digits(return_X_y=True)
    print(f"Dataset: Handwritten digits ({X.shape[0]} samples, {X.shape[1]} features)")

    # Create multi-objective experiment
    experiment = MultiObjectiveExperiment(X, y)

    # Multi-objective Problem:
    #   Objective 1: Maximize classification accuracy
    #   Objective 2: Minimize model complexity
    #   → Trade-off between performance and simplicity

    # Define search space
    param_space = {
        "n_estimators": (10, 200),  # Number of trees
        "max_depth": (1, 20),  # Tree depth (complexity)
        "min_samples_split": (2, 20),  # Minimum samples to split
        "min_samples_leaf": (1, 10),  # Minimum samples per leaf
        "max_features": ["sqrt", "log2", None],  # Feature sampling
    }

    # Search Space:
    # for param, space in param_space.items():
    #   print(f"  {param}: {space}")

    # Configure NSGAIISampler
    optimizer = NSGAIISampler(
        param_space=param_space,
        n_trials=50,  # Population evolves over multiple generations
        random_state=42,
        experiment=experiment,
        population_size=20,  # Population size for genetic algorithm
        mutation_prob=0.1,  # Mutation probability
        crossover_prob=0.9,  # Crossover probability
    )

    # NSGAIISampler Configuration:
    # n_trials: configured above
    # population_size: for genetic algorithm
    # mutation_prob: mutation probability
    # crossover_prob: crossover probability
    # Selection: Non-dominated sorting + crowding distance

    # Note: This example demonstrates the interface.
    # In practice, NSGA-II returns multiple Pareto-optimal solutions.
    # For single-objective problems, consider TPE or GP samplers instead.

    # Run optimization
    # Running NSGA-II multi-objective optimization...

    try:
        best_params = optimizer.solve()

        # Results
        print("\n=== Results ===")
        print(f"Best parameters: {best_params}")
        print(f"Best score: {optimizer.best_score_:.4f}")
        print()

        # NSGA-II typically returns multiple solutions along Pareto front:
        #  High accuracy, high complexity models
        #  Medium accuracy, medium complexity models
        #  Lower accuracy, low complexity models
        #  User selects based on preferences/constraints

    except Exception as e:
        print(f"Multi-objective optimization example: {e}")
        print("Note: This demonstrates the interface for multi-objective problems.")
        return None, None

    # NSGA-II Evolution Process:
    #
    # Generation 1: Random initialization
    #  Diverse population across parameter space
    #  Wide range of accuracy/complexity trade-offs

    # Generations 2-N: Evolutionary improvement
    #  Non-dominated sorting identifies best fronts
    #  Crowding distance maintains solution diversity
    #  Crossover combines good solutions
    #  Mutation explores new parameter regions

    # Final Population: Pareto front approximation
    #  Multiple non-dominated solutions
    #  Represents optimal trade-offs
    #  User chooses based on domain requirements

    # Key Advantages:
    #  Handles multiple conflicting objectives naturally
    #  Finds diverse set of optimal trade-offs
    #  No need to specify objective weights a priori
    #  Provides insight into objective relationships
    #  Robust to objective scaling differences

    # Best Use Cases:
    #  True multi-objective problems (accuracy vs speed, cost vs quality)
    #  When trade-offs between objectives are important
    #  Robustness analysis with multiple criteria
    #  When single objective formulation is unclear

    # Limitations:
    #  More complex than single-objective methods
    #  Requires more evaluations (population-based)
    #  May be overkill for single-objective problems
    #  Final solution selection still required

    # When to Use NSGA-II vs Single-objective Methods:
    # Use NSGA-II when:
    #    Multiple objectives genuinely conflict
    #    Trade-off analysis is valuable
    #    Objective weights are unknown
    #
    # Use TPE/GP when:
    #    Single clear objective
    #    Computational budget is limited
    #    Faster convergence needed

    if "best_params" in locals():
        return best_params, optimizer.best_score_
    else:
        return None, None