支持向量机&&聚类

2018-08-22 本文已影响66人仙灵儿

支持向量机SVM（Support Vector Machine）

一、支持向量机的原理

Support Vector Machine。支持向量机，其含义是通过支持向量运算的分类器。其中“机”的意思是机器，可以理解为分类器。那么什么是支持向量呢？在求解的过程中，会发现只根据部分数据就可以确定分类器，这些数据称为支持向量。见下图，在一个二维环境中，其中点R，S，G点和其它靠近中间黑线的点可以看作为支持向量，它们可以决定分类器，也就是黑线的具体参数。

from sklearn.datasets import load_iris
iris = load_iris()
data = iris.data[:,:2]
target = iris.target
plt.scatter(data[:,0],data[:,1],c=target)

训练模型

l = SVC(kernel='linear')
r = SVC(kernel='rbf')  # 二次曲线
p = SVC(kernel='poly')  # 高次曲线
l.fit(data,target)
r.fit(data,target)
p.fit(data,target)

x = np.linspace(data[:,0].min(),data[:,0].max(),200)
y = np.linspace(data[:,1].min(),data[:,1].max(),200)

xx,yy =np.meshgrid(x,y)

X_test = np.c_[xx.flatten(),yy.flatten()]
plt.scatter(X_test[:,0],X_test[:,1])

y1_ = l.predict(X_test)  # 用linear内核做预测
y2_ = r.predict(X_test)  # 用rbf内核做预测
y3_ = p.predict(X_test)  # 用poly内核做预测

plt.scatter(X_test[:,0],X_test[:,1],c=y1_)

plt.scatter(X_test[:,0],X_test[:,1],c=y2_)

plt.scatter(X_test[:,0],X_test[:,1],c=y3_)

3、使用SVM多种核函数进行回归

导包

# SVC 是 分类的 SVR是回归的
from sklearn.svm import SVR  # 回归

x = np.linspace(-np.pi,np.pi,40)
y = np.sin(x)
plt.scatter(x,y)

noise = np.random.random(10) - 0.5  # [-0.5, 0.5)
noise
y.shape
y[::4]+=noise
plt.scatter(x,y)

# 这里是回归模型 用的是 SVR
# 获取模型
l = SVR(kernel='linear')
r = SVR(kernel='rbf')
p = SVR(kernel='poly')
# 训练模型
l.fit(x.reshape(-1,1),y)
r.fit(x.reshape(-1,1),y)
p.fit(x.reshape(-1,1),y)
# 生成一些测试的X_test
X_test = np.linspace(-np.pi,np.pi,15).reshape(-1,1)
X_test
# 预测 X_teset
y1_ = l.predict(X_test)
y2_ = r.predict(X_test)
y3_ = p.predict(X_test)

plt.figure(figsize=(12,6))
plt.scatter(x,y,c='k',label='real')
plt.plot(X_test,y1_,c='r',label='linear')  # linear内核
plt.plot(X_test,y2_,c='g',label='rbf')   # 二次曲线
plt.plot(X_test,y3_,c='b',label='poly')   # 高次曲线
plt.legend()

K均值算法（K-means）聚类

【关键词】K个种子，均值

一、K-means算法原理

聚类的概念：一种无监督的学习，事先不知道类别，自动将相似的对象归到同一个簇中。

K-Means算法是一种聚类分析（cluster analysis）的算法，其主要是来计算数据聚集的算法，主要通过不断地取离种子点最近均值的算法。

K-Means算法主要解决的问题如下图所示。我们可以看到，在图的左边有一些点，我们用肉眼可以看出来有四个点群，但是我们怎么通过计算机程序找出这几个点群来呢？于是就出现了我们的K-Means算法

[图片上传失败...(image-d9584e-1534869443139)]

这个算法其实很简单，如下图所示：

[图片上传失败...(image-71f7d7-1534869443139)]

从上图中，我们可以看到，A，B，C，D，E是五个在图中点。而灰色的点是我们的种子点，也就是我们用来找点群的点。有两个种子点，所以K=2。

然后，K-Means的算法如下：

随机在图中取K（这里K=2）个种子点。
然后对图中的所有点求到这K个种子点的距离，假如点Pi离种子点Si最近，那么Pi属于Si点群。（上图中，我们可以看到A，B属于上面的种子点，C，D，E属于下面中部的种子点）
接下来，我们要移动种子点到属于他的“点群”的中心。（见图上的第三步）
然后重复第2）和第3）步，直到，种子点没有移动（我们可以看到图中的第四步上面的种子点聚合了A，B，C，下面的种子点聚合了D，E）。

这个算法很简单，重点说一下“求点群中心的算法”：欧氏距离（Euclidean Distance）：差的平方和的平方根

[图片上传失败...(image-9ffb3e-1534869443137)]

K-Means主要最重大的缺陷——都和初始值有关：

K是事先给定的，这个K值的选定是非常难以估计的。很多时候，事先并不知道给定的数据集应该分成多少个类别才最合适。（ISODATA算法通过类的自动合并和分裂，得到较为合理的类型数目K）

K-Means算法需要用初始随机种子点来搞，这个随机种子点太重要，不同的随机种子点会有得到完全不同的结果。（K-Means++算法可以用来解决这个问题，其可以有效地选择初始点）

总结：K-Means算法步骤：

从数据中选择k个对象作为初始聚类中心;
计算每个聚类对象到聚类中心的距离来划分；
再次计算每个聚类中心
计算标准测度函数，直到达到最大迭代次数，则停止，否则，继续操作。
确定最优的聚类中心

K-Means算法应用

看到这里，你会说，K-Means算法看来很简单，而且好像就是在玩坐标点，没什么真实用处。而且，这个算法缺陷很多，还不如人工呢。是的，前面的例子只是玩二维坐标点，的确没什么意思。但是你想一下下面的几个问题：

1）如果不是二维的，是多维的，如5维的，那么，就只能用计算机来计算了。

2）二维坐标点的X，Y 坐标，其实是一种向量，是一种数学抽象。现实世界中很多属性是可以抽象成向量的，比如，我们的年龄，我们的喜好，我们的商品，等等，能抽象成向量的目的就是可以让计算机知道某两个属性间的距离。如：我们认为，18岁的人离24岁的人的距离要比离12岁的距离要近，鞋子这个商品离衣服这个商品的距离要比电脑要近，等等。

二、实战

重要参数：

n_clusters：聚类的个数

重要属性：

cluster_centers_ : [n_clusters, n_features]的数组，表示聚类中心点的坐标
labels_ : 每个样本点的标签

实战，三问中国足球几多愁？

导包，3D图像需导包：

from mpl_toolkits.mplot3d import Axes3D

读取数据

AsiaFootball.csv

列名修改为："国家","2006世界杯","2010世界杯","2007亚洲杯"

from mpl_toolkits.mplot3d import Axes3D
df = pd.read_csv('./AsiaFootball.csv',header=None)
df.columns = ["国家","2006世界杯","2010世界杯","2007亚洲杯"]
df

data = df.iloc[:,1:]  # 所有行都要 从1开始 到最后 （如果是取到最后 冒号后面的可以省略）
data

kmeans = KMeans(n_clusters=3)
kmeans.fit(data)
kmeans.predict(data)
y_ = kmeans.fit_predict(data)  # 训练完之后 直接用训练 数据来预测 相当于 kmeans.fit()+kmeans.predict()

# y_==0
df[y_==0]
df[y_==1]
df[y_==2]['国家']

for循环打印输出分组后的球队，每一组球队打印一行

for i in range(3):
    # print(i)
    s = df[y_==i]['国家']
    for country in s:
        print(country)
    print('\n')

绘制三维立体图形

ax = plt.subplot(projection = '3d')
ax.scatter3D()

from mpl_toolkits.mplot3d import Axes3D
centers = kmeans.cluster_centers_
centers

plt.figure(figsize=(12,8))
ax = plt.subplot(projection='3d')
# 
x = df['2006世界杯']
y = df['2010世界杯']
z = df['2007亚洲杯']
ax.scatter3D(x,y,z,c=y_,s=100,alpha=1)
ax.set_xlabel('2006世界杯')
ax.set_ylabel('2010世界杯')
ax.set_zlabel('2007亚洲杯')
ax.scatter3D(centers[:,0],centers[:,1],centers[:,2],c='r')

### 2、聚类实践与常见错误[](http://localhost:8888/notebooks/00/12/02_kmeans.ipynb#2%E3%80%81%E8%81%9A%E7%B1%BB%E5%AE%9E%E8%B7%B5%E4%B8%8E%E5%B8%B8%E8%A7%81%E9%94%99%E8%AF%AF)

导包，使用make_blobs创建样本点
X_train,y_train = make_blobs(n_samples=1500, n_features=2, centers=3)
plt.scatter(X_train[:,0],X_train[:,1],c=y_train)

第一种错误，k值不合适，make_blobs默认中心点三个

kmeans = KMeans(n_clusters=4)
y_ = kmeans.fit_predict(X_train)
plt.scatter(X_train[:,0],X_train[:,1],c=y_)

第二种错误:标准差cluster_std不相同

X_train,y_train = make_blobs(n_samples=500, n_features=2, centers=3, cluster_std=[0.5,2,10])  # 对3堆数据 分别设置 标准差
plt.scatter(X_train[:,0],X_train[:,1],c=y_train)

kmeans = KMeans(n_clusters=3)
y_ = kmeans.fit_predict(X_train)
plt.scatter(X_train[:,0],X_train[:,1],c=y_)

第三种错误,数据有偏差
trans = [[0.6,-0.6],[-0.4,0.8]]
X2 = np.dot(X,trans)

plt.scatter(X_train[:,0],X_train[:,1],c=y_train)

trans = [
    [0.6,-0.6],
    [-0.4,0.8]
]
X_train2 = np.dot(X_train,trans)
plt.scatter(X_train2[:,0],X_train2[:,1],c=y_train)

kmeans = KMeans(n_clusters=3)
y_ = kmeans.fit_predict(X_train2)
plt.scatter(X_train2[:,0],X_train2[:,1],c=y_)

第四个错误：样本数量不同

X,y = make_blobs(n_samples=1500, n_features=2, centers=3)

X1 = X[y==0]  # X1中的这些点 目标值都是0
X2 = X[y==1][:100]
X3 = X[y==2][:10]

X = np.concatenate((X1,X2,X3))
X

y_train = [0]*500+[1]*100+[2]*10
plt.scatter(X[:,0],X[:,1],c=y_train)

kmeans = KMeans(n_clusters=3)
y_ = kmeans.fit_predict(X)
plt.scatter(X[:,0],X[:,1],c=y_)