遗传算法在聚类优化中的应用

    import numpy as np
    from sklearn.datasets import make_blobs
    from sklearn.metrics import silhouette_score
    
    class GeneticClusteringOptimizer:
    def __init__(self, n_clusters, n_generations, population_size, crossover_rate, mutation_rate):
        self.n_clusters = n_clusters
        self.n_generations = n_generations
        self.population_size = population_size
        self.crossover_rate = crossover_rate
        self.mutation_rate = mutation_rate
    
    def initialize_population(self, X):
        population = []
        for _ in range(self.population_size):
            # 随机生成聚类中心坐标
            centers = np.random.uniform(X.min(axis=0), X.max(axis=0), size=(self.n_clusters, X.shape[1]))
            population.append(centers.flatten())
        return np.array(population)
    
    def evaluate_fitness(self, X, population):
        fitness = []
        for centers in population:
            centers = centers.reshape(-1, X.shape[1])
            labels = self.assign_clusters(X, centers)
            score = silhouette_score(X, labels)
            fitness.append(score)
        return np.array(fitness)
    
    def assign_clusters(self, X, centers):
        distances = np.linalg.norm(X[:, None, :] - centers[None, :, :], axis=-1)
        return np.argmin(distances, axis=1)
    
    def select_parents(self, population, fitness):
        parents = []
        for _ in range(2):
            # 使用轮盘赌选择法选择父代个体
            probabilities = fitness / fitness.sum()
            parent_idx = np.random.choice(len(population), p=probabilities)
            parents.append(population[parent_idx])
        return parents
    
    def crossover(self, parents):
        child1, child2 = parents.copy()
        # 在随机位置交叉
        crossover_point = np.random.randint(1, len(child1))
        child1[:crossover_point], child2[:crossover_point] = child2[:crossover_point], child1[:crossover_point]
        return child1, child2
    
    def mutate(self, individual):
        mutant = individual.copy()
        # 在随机位置进行变异
        mutation_points = np.random.rand(len(mutant)) < self.mutation_rate
        mutant[mutation_points] += np.random.normal(0, 1, sum(mutation_points))
        return mutant
    
    def optimize(self, X):
        population = self.initialize_population(X)
        for generation in range(self.n_generations):
            fitness = self.evaluate_fitness(X, population)
            new_population = []
            for _ in range(self.population_size // 2):
                parents = self.select_parents(population, fitness)
                child1, child2 = self.crossover(parents)
                new_population.append(self.mutate(child1))
                new_population.append(self.mutate(child2))
            population = np.array(new_population)
    
        # 选择最优的聚类中心
        fitness = self.evaluate_fitness(X, population)
        best_centers = population[np.argmax(fitness)].reshape(-1, X.shape[1])
        best_labels = self.assign_clusters(X, best_centers)
        return best_labels, best_centers
    
    # 示例用法
    X, y_true = make_blobs(n_samples=500, n_features=2, centers=4, random_state=42)
    optimizer = GeneticClusteringOptimizer(n_clusters=4, n_generations=100, population_size=50, crossover_rate=0.8, mutation_rate=0.1)
    best_labels, best_centers = optimizer.optimize(X)
    print("Silhouette Score:", silhouette_score(X, best_labels))
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读