import numpy as np def kmeans(data, k, max_iterations=100): # 随机初始化k个聚类中心 centers = data[np.random.choice(range(len(data)), k, replace=False)] for _ in range(max_iterations): # 分配每个数据点到最近的聚类中心 labels = np.argmin(np.linalg.norm(data[:, np.newaxis] - centers, axis=-1), axis=-1) # 更新聚类中心为每个簇的平均值 new_centers = np.array([data[labels == i].mean(axis=0) for i in range(k)]) # 如果聚类中心没有发生变化,则收敛并退出循环 if np.all(centers == new_centers): break centers = new_centers return labels, centers # 示例用法 data = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]]) k = 2 labels, centers = kmeans(data, k) print("聚类标签:", labels) print("聚类中心:", centers)
时间: 2023-07-15 18:13:23 浏览: 145
这是一个简单的 K-Means 聚类算法的 Python 实现。K-Means 算法是一种无监督学习算法,它可以对数据进行聚类,将相似的数据点分到同一个簇中。
这个实现中,输入参数包括数据集 data、聚类数 k 和最大迭代次数 max_iterations。算法首先随机初始化 k 个聚类中心 centers,然后进行迭代。在每次迭代中,算法根据当前聚类中心分配每个数据点到最近的聚类中心,得到每个数据点的聚类标签 labels。然后算法更新聚类中心为每个簇的平均值,得到新的聚类中心 new_centers。如果新的聚类中心与旧的聚类中心完全相同,则算法已经收敛并退出循环,否则使用新的聚类中心继续下一轮迭代。最后,算法返回每个数据点的聚类标签和最终的聚类中心。
在示例用法中,我们使用一个 2 维数据集 data,包括 6 个数据点。我们将聚类数设为 2,然后调用 kmeans 函数进行聚类。最后,我们输出每个数据点的聚类标签和最终的聚类中心。
需要注意的是,K-Means 算法对于初始聚类中心的选择非常敏感,不同的初始聚类中心可能会导致不同的聚类结果。因此,实际使用时需要多次运行算法并选择最优的结果。
相关问题
import random import numpy as np import matplotlib.pyplot as plt 生成随机坐标点 def generate_points(num_points): points = [] for i in range(num_points): x = random.uniform(-10, 10) y = random.uniform(-10, 10) points.append([x, y]) return points 计算欧几里得距离 def euclidean_distance(point1, point2): return np.sqrt(np.sum(np.square(np.array(point1) - np.array(point2)))) K-means算法实现 def kmeans(points, k, num_iterations=100): num_points = len(points) # 随机选择k个点作为初始聚类中心 centroids = random.sample(points, k) # 初始化聚类标签和距离 labels = np.zeros(num_points) distances = np.zeros((num_points, k)) for i in range(num_iterations): # 计算每个点到每个聚类中心的距离 for j in range(num_points): for l in range(k): distances[j][l] = euclidean_distance(points[j], centroids[l]) # 根据距离将点分配到最近的聚类中心 for j in range(num_points): labels[j] = np.argmin(distances[j]) # 更新聚类中心 for l in range(k): centroids[l] = np.mean([points[j] for j in range(num_points) if labels[j] == l], axis=0) return labels, centroids 生成坐标点 points = generate_points(100) 对点进行K-means聚类 k_values = [2, 3, 4] for k in k_values: labels, centroids = kmeans(points, k) # 绘制聚类结果 colors = [‘r’, ‘g’, ‘b’, ‘y’, ‘c’, ‘m’] for i in range(k): plt.scatter([points[j][0] for j in range(len(points)) if labels[j] == i], [points[j][1] for j in range(len(points)) if labels[j] == i], color=colors[i]) plt.scatter([centroid[0] for centroid in centroids], [centroid[1] for centroid in centroids], marker=‘x’, color=‘k’, s=100) plt.title(‘K-means clustering with k={}’.format(k)) plt.show()import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import load_iris 载入数据集 iris = load_iris() X = iris.data y = iris.target K-means聚类 kmeans = KMeans(n_clusters=3, random_state=0).fit(X) 可视化结果 plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_) plt.xlabel(‘Sepal length’) plt.ylabel(‘Sepal width’) plt.title(‘K-means clustering on iris dataset’) plt.show()对这个算法的结果用SSE,轮廓系数,方差比率准则,DBI几个指标分析
首先,我们需要定义这些指标:
1. SSE (Sum of Squared Errors):误差平方和,表示每个点到其所属簇中心的距离的平方和,用于评估聚类效果的好坏。
2. 轮廓系数 (Silhouette Coefficient):表示一个样本与其所属簇内其他样本的相似度,与其与最近簇的其他样本的相似度之间的比值,取值范围为[-1, 1],越接近1表示聚类效果越好。
3. 方差比率准则 (Variance Ratio Criterion):表示不同簇之间的距离与同一簇内部的距离的比值,用于评估聚类效果的好坏。
4. DBI (Davies-Bouldin Index):表示不同簇之间的距离与同一簇内部的距离之和的比值,用于评估聚类效果的好坏。
接下来,我们分别用这些指标来评估上面两段代码实现的K-means算法的聚类效果。
对于第一段代码,我们可以在K-means算法的函数中添加计算SSE的代码,并在函数返回值中返回SSE的值。同时,我们可以使用sklearn库中的metrics模块来计算轮廓系数。方差比率准则的计算与SSE类似,只需要将距离平方和改为距离的平方和,即可得到方差比率准则的值。DBI的计算可以使用sklearn库中的metrics模块中的davies_bouldin_score函数来实现。
代码如下所示:
```
import random import numpy as np import matplotlib.pyplot as plt from sklearn.metrics import silhouette_score from sklearn.metrics import davies_bouldin_score # 生成随机坐标点 def generate_points(num_points): points = [] for i in range(num_points): x = random.uniform(-10, 10) y = random.uniform(-10, 10) points.append([x, y]) return points # 计算欧几里得距离 def euclidean_distance(point1, point2): return np.sqrt(np.sum(np.square(np.array(point1) - np.array(point2)))) # K-means算法实现 def kmeans(points, k, num_iterations=100): num_points = len(points) # 随机选择k个点作为初始聚类中心 centroids = random.sample(points, k) # 初始化聚类标签和距离 labels = np.zeros(num_points) distances = np.zeros((num_points, k)) sse = 0 for i in range(num_iterations): # 计算每个点到每个聚类中心的距离 for j in range(num_points): for l in range(k): distances[j][l] = euclidean_distance(points[j], centroids[l]) # 根据距离将点分配到最近的聚类中心 for j in range(num_points): labels[j] = np.argmin(distances[j]) # 更新聚类中心 for l in range(k): centroids[l] = np.mean([points[j] for j in range(num_points) if labels[j] == l], axis=0) # 计算SSE sse = np.sum(np.square(distances[np.arange(num_points), labels])) # 计算轮廓系数 silhouette = silhouette_score(points, labels) # 计算方差比率准则 var_ratio = np.sum(np.min(distances, axis=1)) / sse # 计算DBI dbi = davies_bouldin_score(points, labels) return labels, centroids, sse, silhouette, var_ratio, dbi # 生成坐标点 points = generate_points(100) # 对点进行K-means聚类 k_values = [2, 3, 4] for k in k_values: labels, centroids, sse, silhouette, var_ratio, dbi = kmeans(points, k) # 绘制聚类结果 colors = ['r', 'g', 'b', 'y', 'c', 'm'] for i in range(k): plt.scatter([points[j][0] for j in range(len(points)) if labels[j] == i], [points[j][1] for j in range(len(points)) if labels[j] == i], color=colors[i]) plt.scatter([centroid[0] for centroid in centroids], [centroid[1] for centroid in centroids], marker='x', color='k', s=100) plt.title('K-means clustering with k={}'.format(k)) plt.show() print('SSE: {:.2f}'.format(sse)) print('Silhouette: {:.2f}'.format(silhouette)) print('Variance Ratio Criterion: {:.2f}'.format(var_ratio)) print('DBI: {:.2f}'.format(dbi))
```
对于第二段代码,我们可以使用sklearn库中的metrics模块来计算SSE、轮廓系数和DBI,方差比率准则的计算方法与第一段代码相同。
代码如下所示:
```
import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.datasets import load_iris from sklearn.metrics import silhouette_score from sklearn.metrics import davies_bouldin_score # 载入数据集 iris = load_iris() X = iris.data y = iris.target # K-means聚类 kmeans = KMeans(n_clusters=3, random_state=0).fit(X) # 计算SSE sse = np.sum(np.square(X - kmeans.cluster_centers_[kmeans.labels_])) # 计算轮廓系数 silhouette = silhouette_score(X, kmeans.labels_) # 计算方差比率准则 var_ratio = kmeans.inertia_ / sse # 计算DBI dbi = davies_bouldin_score(X, kmeans.labels_) # 可视化结果 plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_) plt.xlabel('Sepal length') plt.ylabel('Sepal width') plt.title('K-means clustering on iris dataset') plt.show() print('SSE: {:.2f}'.format(sse)) print('Silhouette: {:.2f}'.format(silhouette)) print('Variance Ratio Criterion: {:.2f}'.format(var_ratio)) print('DBI: {:.2f}'.format(dbi))
```
通过这些指标的计算,我们可以得到K-means算法的聚类效果的好坏。一般来说,SSE和轮廓系数越小,方差比率准则越大,DBI越小,则聚类效果越好。
kmeans代码实现聚类python,并输出对应的聚类中心
下面是一个用 Python 实现 K-Means 聚类的代码示例:
```python
import numpy as np
def kmeans(X, k, max_iterations=100):
# 随机选择 k 个初始聚类中心
centers = X[np.random.choice(X.shape[0], k, replace=False), :]
for i in range(max_iterations):
# 计算每个样本到每个聚类中心的距离
distances = np.array([np.linalg.norm(X - center, axis=1) for center in centers])
# 找到每个样本最近的聚类中心
nearest_centers = np.argmin(distances, axis=0)
# 更新每个聚类中心为该聚类内样本的平均位置
for center_idx in range(k):
centers[center_idx] = np.mean(X[nearest_centers == center_idx, :], axis=0)
# 输出聚类中心
return centers
```
在调用该代码时,需要传入样本数据 `X`,聚类数量 `k` 和最大迭代次数 `max_iterations`。最终,代码会返回 `k` 个聚类中心。
阅读全文