用麻雀搜索算法优化k-means聚类算法完整代码

当然，我可以帮您提供使用麻雀搜索算法优化k-means聚类算法的代码。下面是一个示例的完整代码：

import numpy as np

class KMeans:
    def __init__(self, n_clusters, max_iter=100):
        self.n_clusters = n_clusters
        self.max_iter = max_iter

    def fit(self, X):
        self.centroids = X[np.random.choice(range(len(X)), self.n_clusters, replace=False)]
        
        for _ in range(self.max_iter):
            clusters = self.assign_clusters(X)
            new_centroids = self.update_centroids(X, clusters)
            
            if np.allclose(self.centroids, new_centroids):
                break
                
            self.centroids = new_centroids

    def assign_clusters(self, X):
        clusters = []
        
        for x in X:
            distances = np.linalg.norm(x - self.centroids, axis=1)
            cluster = np.argmin(distances)
            clusters.append(cluster)
        
        return np.array(clusters)

    def update_centroids(self, X, clusters):
        new_centroids = []
        
        for i in range(self.n_clusters):
            cluster_points = X[clusters == i]
            centroid = np.mean(cluster_points, axis=0)
            new_centroids.append(centroid)
        
        return np.array(new_centroids)


class SparrowSearch:
    def __init__(self, n_clusters, n_sparrows, max_iter=100, w=0.9, c1=2.0, c2=2.0):
        self.n_clusters = n_clusters
        self.n_sparrows = n_sparrows
        self.max_iter = max_iter
        self.w = w
        self.c1 = c1
        self.c2 = c2

    def fit(self, X):
        self.sparrows = X[np.random.choice(range(len(X)), self.n_sparrows, replace=False)]
        self.best_centroids = None
        self.best_cost = np.inf
        
        for _ in range(self.max_iter):
            self.update_centroids(X)
            self.update_positions()
            
            cost = self.calculate_cost(X)
            if cost < self.best_cost:
                self.best_centroids = self.centroids
                self.best_cost = cost

    def update_centroids(self, X):
        kmeans = KMeans(self.n_clusters)
        kmeans.fit(self.sparrows)
        self.centroids = kmeans.centroids

    def update_positions(self):
        velocities = np.zeros_like(self.sparrows)
        
        for i in range(self.n_sparrows):
            r1 = np.random.random(self.sparrows.shape[1])
            r2 = np.random.random(self.sparrows.shape[1])
            
            velocities[i] = (self.w * velocities[i] +
                             self.c1 * r1 * (self.centroids[i] - self.sparrows[i]) +
                             self.c2 * r2 * (self.best_centroids[i] - self.sparrows[i]))
            
            self.sparrows[i] += velocities[i]

    def calculate_cost(self, X):
        distances = np.linalg.norm(X[:, None] - self.centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        cost = 0
        for i in range(self.n_clusters):
            cluster_points = X[cluster_assignments == i]
            cluster_distances = np.linalg.norm(cluster_points - self.centroids[i], axis=1)
            cost += np.sum(cluster_distances)
        
        return cost


# 示例使用鸢尾花数据集
from sklearn.datasets import load_iris

data = load_iris().data

kmeans = KMeans(3)
kmeans.fit(data)

sparrow_search = SparrowSearch(3, 10)
sparrow_search.fit(data)

print("K-means centroids:")
print(kmeans.centroids)
print("SparrowSearch centroids:")
print(sparrow_search.best_centroids)

这个代码示例中包含了两个类：`KMeans`和`SparrowSearch`。`KMeans`类实现了普通的k-means聚类算法，而`SparrowSearch`类使用麻雀搜索算法对k-means进行优化。

注意：这只是一个简单的示例代码，实际使用时可能需要根据具体问题进行适当的调整和改进。