利用Python如何实现K-means聚类算法

import numpy as np
import matplotlib.pyplot as plt
import random
from sklearn.datasets import make_blobs
np.random.seed(123)
from sklearn.cluster import KMeans
class Kmeans:
 def __init__(self,data,k):
  self.data=data
  self.k = k
 def cluster_data_Bysklearn(self):
  kmeans_model = KMeans(self.k,random_state=1)
  labels = kmeans_model.fit(self.data).labels_
  print(labels)
  return labels
 
 def kmeans(self):
  # 获取4个随机数
  rarray = np.random.random(size=self.k)
  # 乘以数据集大小——>数据集中随机的4个点
  rarray = np.floor(rarray * len(self.data))
  # 转为int
  rarray = rarray.astype(int)
  print('数据集中随机索引', rarray)
  # 随机取数据集中的4个点作为初始中心点
  center = data[rarray]
  # 测试比较偏、比较集中的点，效果依然完美，测试需要删除以上代码
  # center = np.array([[4.6,-2.5],[4.4,-1.7],[4.3,-0.7],[4.8,-1.1]])
  # 1行80列的0数组，标记每个样本所属的类(k[i])
  cls = np.zeros([len(self.data)], np.int)
  print('初始center=\n', center)
  run = True
  time = 0
  n = len(self.data)
  while run:
time = time + 1
for i in range(n):
 # 求差
 tmp = data[i] - center
 # 求平方
 tmp = np.square(tmp)
 # axis=1表示按行求和
 tmp = np.sum(tmp, axis=1)
 # 取最小（最近）的给该点“染色”（标记每个样本所属的类(k[i])）
 cls[i] = np.argmin(tmp)
# 如果没有修改各分类中心点，就结束循环
run = False
# 计算更新每个类的中心点
for i in range(self.k):
 # 找到属于该类的所有样本
 club = data[cls == i]
 # axis=0表示按列求平均值，计算出新的中心点
 newcenter = np.mean(club, axis=0)
 # 如果新旧center的差距很小，看做他们相等，否则更新之。run置true，再来一次循环
 ss = np.abs(center[i] - newcenter)
 if np.sum(ss, axis=0) > 1e-4:
  center[i] = newcenter
  run = True
print('new center=\n', center)
  print('程序结束，迭代次数：', time)
  # 按类打印图表，因为每打印一次，颜色都不一样，所以可区分出来
  # for i in range(self.k):
  #  club = data[cls == i]
  #  self.showtable(club)
  # 打印最后的中心点
  self.showtable(center)
  #打印聚类标签
  print(cls)
 
 def showtable(self,data):
  x = data.T[0]
  y = data.T[1]
  plt.scatter(x, y)
  plt.show()
 
if __name__ == '__main__':
 data = np.random.rand(10,2)
 K = 4
 model = Kmeans(data,K)
 
 model.kmeans()
 model.cluster_data_Bysklearn()

import numpy as np
import matplotlib.pyplot as plt
import random
from sklearn.datasets import make_blobs
 
 
%matplotlib inline

X, y = make_blobs(centers=6, n_samples=1000)
print(f'Shape of dataset: {X.shape}')
 
fig = plt.figure(figsize=(8,6))
plt.scatter(X[:,0], X[:,1], c=y)
plt.title("Dataset with 6 clusters")
plt.xlabel("First feature")
plt.ylabel("Second feature")
plt.show()

class KMeans():
 def __init__(self, n_clusters=6):
  self.k = n_clusters
 
 def fit(self, data):
  """
  Fits the k-means model to the given dataset
  """
  n_samples, _ = data.shape
  # initialize cluster centers
  self.centers = np.array(random.sample(list(data), self.k))
  self.initial_centers = np.copy(self.centers)
 
  # We will keep track of whether the assignment of data points
  # to the clusters has changed. If it stops changing, we are 
  # done fitting the model
  old_assigns = None
  n_iters = 0
 
  while True:
new_assigns = [self.classify(datapoint) for datapoint in data]
 
if new_assigns == old_assigns:
 print(f"Training finished after {n_iters} iterations!")
 return
 
old_assigns = new_assigns
n_iters += 1
 
# recalculate centers
for id_ in range(self.k):
 points_idx = np.where(np.array(new_assigns) == id_)
 datapoints = data[points_idx]
 self.centers[id_] = datapoints.mean(axis=0)
 
 def l2_distance(self, datapoint):
  dists = np.sqrt(np.sum((self.centers - datapoint)**2, axis=1))
  return dists
 
 def classify(self, datapoint):
  """
  Given a datapoint, compute the cluster closest to the
  datapoint. Return the cluster ID of that cluster.
  """
  dists = self.l2_distance(datapoint)
  return np.argmin(dists)
 
 def plot_clusters(self, data):
  plt.figure(figsize=(12,10))
  plt.title("Initial centers in black, final centers in red")
  plt.scatter(data[:, 0], data[:, 1], marker='.', c='y')
  plt.scatter(self.centers[:, 0], self.centers[:,1], c='r')
  plt.scatter(self.initial_centers[:, 0], self.initial_centers[:,1], c='k')
  plt.show()

X = np.random.randn(10,100)
kmeans = KMeans(n_clusters=6)
kmeans.fit(X)
for data in X:
 print(kmeans.classify(data))