在无监督学习中，我们首先就会接触到kmeans算法，因为既简单，又实用，而且速度也很快。所以今天在这里写一个非常简单的kmeans算法，以帮助我们更快的领悟算法的思想，以及它的变种。一下是其实现步骤
1.确定聚类数，数据分为多少类。
2.随机初始化每一类的中心点。
3.计算每一个样本点到每一类中心点的距离，并分配给距离它最小的那个中心点。
4.更新中心点，新的中心点为属于它所有点的平均值。
5.重复3,4操作，即可完成。
数据不是太漂亮，实现的效果也不是特别好，代码写的很简单，还有优化的空间。
from sklearn.datasets import load_iris import numpy as np import matplotlib.pyplot as plt a,b = load_iris(return_X_y=True) x = a[:,:2] #便于绘图 center_1 = np.array([5,3.5]) #初始化中心点 center_2 = np.array([6,2]) center_3 = np.array([7,3]) for k in range(200): center_list1 = [] center_list2 = [] center_list3 = [] for i in x: a = ((i[0] - center_1[0])*(i[1]-center_1[1]))**2 b = ((i[0] - center_2[0])*(i[1]-center_2[1]))**2 c = ((i[0] - center_3[0])*(i[1]-center_3[1]))**2 if a<b and a<c : center_list1.append(i) elif b<c: center_list2.append(i) elif c<b : center_list3.append(i) new_1_x = 0 new_1_y = 0 for a in center_list1: new_1_x +=a[0] new_1_y +=a[1] center_1[0] = new_1_x / (len(center_list1)) center_1[1] = new_1_y / (len(center_list1)) new_1_x = 0 new_1_y = 0 for a in center_list2: new_1_x += a[0] new_1_y += a[1] print(len(center_list3)) center_2[0] = new_1_x / (len(center_list2)) center_2[1] = new_1_y / (len(center_list2)) new_1_x = 0 new_1_y = 0 for a in center_list3: new_1_x += a[0] new_1_y += a[1] center_3[0] = new_1_x / (len(center_list3)) center_3[1] = new_1_y / (len(center_list3)) plt.scatter([x[0] for x in center_list1],[x[1] for x in center_list1],c='red') plt.scatter([x[0] for x in center_list2],[x[1] for x in center_list2],c='green') plt.scatter([x[0] for x in center_list3],[x[1] for x in center_list3],c='blue') plt.scatter(center_1[0],center_1[1],c='black') plt.scatter(center_2[0],center_2[1],c = 'black') plt.scatter(center_3[0],center_3[1],c='black') plt.show()
下面的这个代码是一个优化的版本，参考于https://www.cnblogs.com/zxzhu/p/7994612.html，
该博客主写的方法也太简单的，便于阅读,很适合学习。
1 2 3 4 5 6 from sklearn.datasets import make_blobs 7 import numpy as np 8 import matplotlib.pyplot as plt 9 10 11 def Distance(x): 12 def Dis(y): 13 return np.sqrt(sum((x-y)**2)) #欧式距离 14 return Dis 15 16 def init_k_means(k): 17 k_means = {} 18 for i in range(k): 19 k_means[i] = [] 20 return k_means 21 22 def cal_seed(k_mean): #重新计算种子点 23 k_mean = np.array(k_mean) 24 new_seed = np.mean(k_mean,axis=0) #各维度均值 25 return new_seed 26 27 def K_means(data,seed_k,k_means): 28 for i in data: 29 f = Distance(i) 30 dis = list(map(f,seed_k)) #某一点距所有中心点的距离 31 index = dis.index(min(dis)) 32 k_means[index].append(i) 33 34 new_seed = [] #新的样本中心点 35 for i in range(len(seed_k)): 36 new_seed.append(cal_seed(k_means[i])) 37 new_seed = np.array(new_seed) 38 return k_means,new_seed 39 40 def run_K_means(data,k): 41 seed_k = data[np.random.randint(len(data),size=k)] #随机产生样本中心点 42 k_means = init_k_means(k) #初始化每一类 43 result = K_means(data,seed_k,k_means) 44 count = 0 45 while not (result[1] == seed_k).all(): #种子点改变，继续聚类 46 count+=1 47 seed_k = result[1] 48 k_means = init_k_means(k=7) 49 result = K_means(data,seed_k,k_means) 50 print('Done') 51 #print(result[1]) 52 print(count) 53 plt.figure(figsize=(8,8)) 54 Color = 'rbgyckm' 55 for i in range(k): 56 mydata = np.array(result[0][i]) 57 plt.scatter(mydata[:,0],mydata[:,1],color = Color[i]) 58 return result[0] 59 x,y = make_blobs(n_features=3,n_samples=1000,random_state=21) 60 61 run_K_means(data,k=3)
程序中那个闭包的操作需要我们多去捋一捋。
在聚类中使用的较多的一种聚类是基于密度的DBSCAN算法，该算法不需要指定类别数，但是要指定半径大小以及该范围内包含点的最小数目。
DBSCAN算法描述:输入:
输入: 包含n个对象的数据库，半径e，最少数目MinPts;
输出:所有生成的簇，达到密度要求。
(1)Repeat
(2)从数据库中抽出一个未处理的点；
(3)IF抽出的点是核心点 THEN 找出所有从该点密度可达的对象，形成一个簇；
(4)ELSE 抽出的点是边缘点(非核心对象)，跳出本次循环，寻找下一个点；
(5)UNTIL 所有的点都被处理。
DBSCAN对用户定义的参数很敏感，细微的不同都可能导致差别很大的结果，而参数的选择无规律可循，只能靠经验确定。
1.与K-means方法相比，DBSCAN不需要事先知道要形成的簇类的数量。
2.与K-means方法相比，DBSCAN可以发现任意形状的簇类。
3.同时，DBSCAN能够识别出噪声点。
4.DBSCAN对于数据库中样本的顺序不敏感，即Pattern的输入顺序对结果的影响不大。但是，对于处于簇类之间边界样本，可能会根据哪个簇类优先被探测到而>其归属有所摆动。
具体的实现如下，过程很简单，细读后，复现应该是没有问题的，我也是从
https://www.cnblogs.com/tiaozistudy/p/dbscan_algorithm.html，里面学来的，代码基本一样，他里面有跟详细的介绍。
import math import numpy as np from sklearn.datasets import make_circles import random import matplotlib.pyplot as plt class visited: ''' 记录那些点是被标记了的，那些点是没有被标记的，以及没有被标记点的个数 ， 记录的是每个点在data里面的位置，也就是index ''' def __init__(self,count=0): self.visitedlist = list() self.unvisitedlist = [i for i in range(count] self.unvisitednum = count def visvit(self,opints): self.visitedlist.append(opints) self.unvisitedlist.remove(opints) self.unvisitednum -= 1 #计算距离 def dist(x , y): return math.sqrt(np.power(x-y,2).sum()) def DBSCAN(data,eps,minpts): count = data.shape[0] visit = visited(count) k = -1 #表示类别 C = [-1 for i in range(count] while (visit.unvisitednum > 0 ): p = random.choice(visit.unvisitedlist) visit.visvit(p) N = [i for i in visit.unvisitedlist if dist(data[i],data[p]) <= eps] if len(N) >= minpts: k += 1 C[p] = k for p1 in N: visit.visvit(p1) M = [i for i in visit.unvisitedlist if dist(data[i],data[p]) <= eps] if len(M) >=minpts: for i in M: if i not in N: N.append(i) C[p1] = k else: C[p] = -1 return C x ,y = make_circles(n_samples=2000,factor=0.6,noise=0.05,random_state=1) a = DBSCAN(x,0.1,10) plt.figure(figsize=(12,9)) plt.scatter(x[:,0],x[:,1],c = a) plt.show()
上面讲述了两种常用的聚类方法，里面的DBSCAN还可以用KD树来优化，这里就不讲述了，（我也不会)。聚类方法也还挺简单的，没有那些复杂的数学公式推导，相信你们也和我一样，看到公式就头疼。聚类的算法重点还是其思想，理解了它的思想，那么你也就成功了65%。
公众号：FPGA之旅
