#线性SVM可视化
from sklearn.datasets import make_blobs
from sklearn.svm import SVC
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
X,y=make_blobs(n_samples=50,centers=2,random_state=0,cluster_std=0.6)
y
'''Contour是我们专门用来绘制等高线的函数。等高线，本质上是在二维图像上表现三维图像的一种形式，其中两维
X和Y是两条坐标轴上的取值，而Z表示高度。Contour就是将由X和Y构成平面上的所有点中，高度一致的点连接成
线段的函数，在同一条等高线上的点一定具有相同的Z值。我们可以利用这个性质来绘制我们的决策边界'''
'''matplotlib.axes.Axes.contour([X, Y,] Z, [levels], **kwargs)'''
plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap="rainbow")
ax=plt.gca()#获取当前的子图，如果没有就创建
#将上述过程包装成函数：
def plot_svc_decision_function(model,ax=None):
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
x = np.linspace(xlim[0],xlim[1],30)
y = np.linspace(ylim[0],ylim[1],30)
Y,X = np.meshgrid(y,x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)
ax.contour(X, Y, P,colors="k",levels=[-1,0,1],alpha=0.5,linestyles=["--","-","--"])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
#则整个绘图过程可以写作：
clf = SVC(kernel = "linear").fit(X,y)
plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap="rainbow")
plot_svc_decision_function(clf)
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_circles
X,y = make_circles(100, factor=0.1, noise=.1)
plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap="rainbow")
def plot_svc_decision_function(model,ax=None):
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
x = np.linspace(xlim[0],xlim[1],30)
y = np.linspace(ylim[0],ylim[1],30)
Y,X = np.meshgrid(y,x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)
ax.contour(X, Y, P,colors="k",levels=[-1,0,1],alpha=0.5,linestyles=["--","-","--"])
ax.set_xlim(xlim)
ax.set_ylim(ylim)
clf = SVC(kernel = "linear").fit(X,y)
plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap="rainbow")
plot_svc_decision_function(clf)
r = np.exp(-(X**2).sum(1))
rlim = np.linspace(min(r),max(r),100)
from mpl_toolkits import mplot3d
def plot_3D(elev=30,azim=30,X=X,y=y):
ax = plt.subplot(projection="3d")
ax.scatter3D(X[:,0],X[:,1],r,c=y,s=50,cmap='rainbow')
ax.view_init(elev=elev,azim=azim)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_zlabel("r")
plt.show()
from ipywidgets import interact,fixed
interact(plot_3D,elev=[0,30],azip=(-180,180),X=fixed(X),y=fixed(y))
plt.show()
#r=np.exp(-(y**2).sum(1))#求解X所有的平方
#r=range(100)
#rlim=np.linspace(min(r),max(r),100)
#plot_3D()
#为什么要采用这样的r，因为这样的r才会让模型线性可分，所以后面把数据升高维度的方法就是找到这样的r
#针对环形数据，就是采用这样的r才能解决
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_blobs,make_circles,make_moons,make_classification
n_samples=100
datasets=[make_blobs(n_samples=n_samples,centers=2,random_state=5),#簇型数据
make_circles(n_samples=n_samples,noise=0.2,factor=0.5,random_state=1),
make_moons(n_samples=n_samples,noise=0.2,random_state=3),
make_classification(n_samples=n_samples,n_features=2,n_informative=2,n_redundant=0,random_state=4)]
#分类数据，虽然分为2类，但是要指明2个特征，且都带有信息量
for X,y in datasets:
plt.figure(figsize=(5,4))
plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap="rainbow")
fig,axes=plt.subplots(4,5,figsize=(20,16))
kernals=["linear","poly","rbf","sigmoid"]
for ds_cnt ,(X,y) in enumerate(datasets):
ax=axes[ds_cnt,0]#取出第0列
if ds_cnt==0:
ax.set_title("input data")
ax.scatter(X[:,0],X[:,1],c=y,zorder=10#层级，位于图片的最上层
,cmap=plt.cm.Paired,edgecolors="k")
ax.set_xticks(())
ax.set_yticks(())
for est_dx,kernal in enumerate(kernals):
#定义子图的位置
ax=axes[ds_cnt,est_dx+1]
#建模
clf=SVC(kernel=kernal,gamma=2).fit(X,y)
score=clf.score(X,y)#这里没有分训练集和测试集，出来之后不一定是1
#绘制图像本身的散点图
ax.scatter(X[:,0],X[:,1],c=y,zorder=10#层级，位于图片的最上层
,cmap=plt.cm.Paired,edgecolors="k")
#绘制支持向量
ax.scatter(clf.support_vectors_[:,0],clf.support_vectors_[:,1],s=50,zorder=10
,facecolors="none"#表示没有颜色，透明，且比原来的散点大一些，相当于是圈出来了
,edgecolors="k")
#绘制决策边界
xmin,xmax=X[:,0].min()-0.5,X[:,0].max()+0.5
ymin,ymax=X[:,1].min()-0.5,X[:,1].max()+0.5
#np.mgrid,合并了我们之前使用的np.linespace np.meshgrid
#一次性使用最大值和最小值绘制网络
#表示为【起始值：结束值：步长】
#步长如果是复数，也就是后面加个J，则整数部分是创建的点的数量，且结束值包含在内
XX,yy=np.mgrid[xmin:xmax:200j,ymin:ymax:200j]
#np.c_类似于np.vstack的功能
Z=clf.decision_function(np.c_[XX.ravel(),yy.ravel()]).reshape(XX.shape)
#填充等高线不同区域的颜色，Z》0的填充一种颜色，其余的填充一种颜色
ax.pcolormesh(XX,yy,Z>0,cmap=plt.cm.Paired)
#绘制等高线
ax.contour(XX,yy,Z,
colors=["k","k","k"]
,linestyles=["--","-","--"],
levels=[-1,0,1])
#设定坐标轴为不显示
ax.set_xticks(())
ax.set_yticks(())
#将标题放在第一行的顶上
if ds_cnt==0:
ax.set_title(kernal)
#为每张图添加分类的分数
ax.text(0.95,0.06,('%.2f'%score).lstrip('0')#表示不显示0
,size=15
,bbox=dict(boxstyle="round",alpha=0.8,facecolor='white')#为分数添加一个白色的格子为底色
,transform=ax.transAxes#确定文字所对应的坐标轴就是AX的坐标轴
,horizontalalignment="right"#位于坐标轴的什么方向
)
plt.tight_layout()
plt.show()
from sklearn.datasets import load_breast_cancer
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from time import time
import datetime
data=load_breast_cancer()
X=data.data
y=data.target
from sklearn.preprocessing import StandardScaler
X=StandardScaler().fit_transform(X)
Xtrain,Xtest,ytrain,ytest=train_test_split(X,y,test_size=0.3,random_state=0)
for kernel in ["linear","poly","rbf","sigmoid"]:
time0=time()
clf=SVC(kernel=kernel,gamma="auto",degree=1).fit(Xtrain,ytrain)
#degree=1
#多项式核函数的次数，默认3，
#cache_size=5000#单位是MB使用多大的内存，默认200
print("the accuracy under kernel %s is %f"%(kernel,clf.score(Xtest,ytest)))
print(datetime.datetime.fromtimestamp(time()-time0).strftime("%M:%S:%f"))#分秒微秒
the accuracy under kernel linear is 0.959064
00:00:002991
the accuracy under kernel poly is 0.970760
00:00:002992
the accuracy under kernel rbf is 0.976608
00:00:005984
the accuracy under kernel sigmoid is 0.941520
00:00:003988
#对于高斯径向基中的gamma画学习曲线
score=[]
gas=np.logspace(-10,1,50)
for i in gas:
clf=SVC(kernel="rbf",gamma=i).fit(Xtrain,ytrain)
score.append(clf.score(Xtest,ytest))
print(max(score),gas[score.index(max(score))])
plt.plot(gas,score)
plt.show()
#使用网格搜索
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import GridSearchCV
time0=time()
gamma_range=np.logspace(-10,1,50)
coef0_range=np.linspace(0,5,10)
param_grid=dict(gamma=gamma_range,coef0=coef0_range)
param_grid
cv=StratifiedShuffleSplit(n_splits=5,test_size=0.3,random_state=0)#分5分，其中测试集占30%
clf=SVC(kernel="poly",degree=1)
grid=GridSearchCV(clf,param_grid=param_grid,cv=cv)
grid.fit(X,y)
score=[]
c_range=np.linspace(0.01,1,50)
for i in c_range:
clf=SVC(kernel="rbf",gamma=0.020235896477251554,C=i).fit(Xtrain,ytrain)
score.append(clf.score(Xtest,ytest))
print(max(score),c_range[score.index(max(score))])
plt.plot(c_range,score)
plt.show()
from sklearn.datasets import make_blobs
class1=500
class2=50
centers=[[0.0,0.0],[2.0,2.0]]
std=[1.5,0.5]
X,y=make_blobs(n_samples=[class1,class2]
,centers=centers
,cluster_std=std,random_state=0,shuffle=False)
clf=SVC(kernel="linear").fit(X,y)
wclf=SVC(kernel="linear",class_weight={1:10}).fit(X,y)#告诉算法我们少数类和多数类的真实比例
#做样本均衡之后准确性下降了
#画出两个图的决策边界
plt.figure(figsize=(6,5))
plt.scatter(X[:,0],X[:,1],c=y,cmap="rainbow")
ax=plt.gca()
#绘制决策边界的第一步：要现有网格
xlim=ax.get_xlim()
ylim=ax.get_ylim()
xx=np.linspace(xlim[0],xlim[1],30)
yy=np.linspace(ylim[0],ylim[1],30)
#axisy,axisx=np.meshgrid(axisy,axisx)
#我们将使用这里形成的二维数组作为我们contour函数中的X和Y
#使用meshgrid函数将两个一维向量转换为特征矩阵
#核心是将两个特征向量广播，以便获取y.shape * x.shape这么多个坐标点的横坐标和纵坐标
YY,XX=np.meshgrid(yy,xx)
xy=np.vstack([XX.ravel(),YY.ravel()]).T
Z_clf=clf.decision_function(xy).reshape(XX.shape)
a=ax.contour(XX,YY,Z_clf,colors="black",levels=[0],linestyles="-")
Z_wclf=wclf.decision_function(xy).reshape(XX.shape)
b=ax.contour(XX,YY,Z_wclf,colors="red",levels=[0],linestyles="--")
#第三步：画图例
plt.legend([a.collections[0], b.collections[0]], ["non weighted", "weighted"],
loc="upper right")
plt.show()
扫一扫
529
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
