遗传算法优化随机森林的全部代码

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from deap import base, creator, tools, algorithms

# Define the fitness function
def eval_rf(individual):
    # Convert the individual to a list of feature indices
    features = [i for i, selected in enumerate(individual) if selected]

    if len(features) == 0:
        return -1,  # Penalize individuals with no selected features

    # Select the corresponding features from the dataset
    X_train_selected = X_train[:, features]

    # Train a random forest classifier
    clf = RandomForestClassifier(n_estimators=100)
    clf.fit(X_train_selected, y_train)

    # Evaluate the accuracy on the test set
    X_test_selected = X_test[:, features]
    accuracy = clf.score(X_test_selected, y_test)

    return accuracy,  # The fitness function must return a tuple

# Create the toolbox
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
toolbox = base.Toolbox()

# Register the necessary functions
toolbox.register("attr_bool", np.random.choice, [False, True])
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=len(X_train[0]))
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", eval_rf)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
toolbox.register("select", tools.selTournament, tournsize=4)

# Define the main algorithm
def main():
    population_size = 100
    num_generations = 50

    # Initialize the population
    population = toolbox.population(n=population_size)

    # Evaluate the fitness of the initial population
    fitness = list(map(toolbox.evaluate, population))
    for ind, fit in zip(population, fitness):
        ind.fitness.values = fit

    for generation in range(num_generations):
        print(f"Generation {generation + 1}/{num_generations}")

        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Clone the selected individuals
        offspring = list(map(toolbox.clone, offspring))

        # Apply crossover and mutation on the offspring
        for child1, child2 in zip(offspring[::2], offspring[1::2]):
            if np.random.rand() < 0.5:
                tools.cxTwoPoint(child1, child2)

            tools.mutFlipBit(child1, indpb=0.05)
            tools.mutFlipBit(child2, indpb=0.05)

            del child1.fitness.values
            del child2.fitness.values

        # Evaluate the individuals with invalid fitness
        invalid_individuals = [ind for ind in offspring if not ind.fitness.valid]
        fitness = list(map(toolbox.evaluate, invalid_individuals))
        for ind, fit in zip(invalid_individuals, fitness):
            ind.fitness.values = fit

        # Replace the population with the offspring
        population[:] = offspring

        # Gather all the fitness values in the population
        fits = [ind.fitness.values[0] for ind in population]

        # Print the statistics
        print(f"  Max fitness: {max(fits):.4f}")
        print(f"  Average fitness: {np.mean(fits):.4f}")

    # Select the best individual
    best_individual = tools.selBest(population, k=1)[0]

    # Print the best individual's fitness
    best_fitness = best_individual.fitness.values[0]
    print(f"\nBest individual's fitness: {best_fitness:.4f}")

    # Convert the best individual to a list of feature indices
    best_features = [i for i, selected in enumerate(best_individual) if selected]

    print(f"\nBest features: {best_features}")

if __name__ == "__main__":
    main()