支持向量机.docx
《支持向量机.docx》由会员分享，可在线阅读，更多相关《支持向量机.docx（16页珍藏版）》请在冰豆网上搜索。
支持向量机
支持向量机（SVM）
%matplotlibinline
importnumpyasnp
importmatplotlib.pyplotasplt
fromscipyimportstats
#useseabornplottingdefaults
importseabornassns;sns.set（）
#随机来点数据
fromsklearn.datasets.samples_generatorimportmake_blobs
X,y=make_blobs（n_samples=50,centers=2,
random_state=0,cluster_std=0.60）
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
随便的画几条分割线，哪个好来这？
xfit=np.linspace（-1,3.5）
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
plt.plot（[0.6],[2.1],'x',color='red',markeredgewidth=2,markersize=10）
form,bin[（1,0.65）,（0.5,1.6）,（-0.2,2.9）]:
plt.plot（xfit,m*xfit+b,'-k'）
plt.xlim（-1,3.5）;
SupportVectorMachines:
最小化 雷区
xfit=np.linspace（-1,3.5）
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
form,b,din[（1,0.65,0.33）,（0.5,1.6,0.55）,（-0.2,2.9,0.2）]:
yfit=m*xfit+b
plt.plot（xfit,yfit,'-k'）
plt.fill_between（xfit,yfit-d,yfit+d,edgecolor='none',
color='#AAAAAA',alpha=0.4）
plt.xlim（-1,3.5）;
训练一个基本的SVM
fromsklearn.svmimportSVC#"Supportvectorclassifier"
model=SVC（kernel='linear'）
model.fit（X,y）
#绘图函数
defplot_svc_decision_function（model,ax=None,plot_support=True）:
"""Plotthedecisionfunctionfora2DSVC"""
ifaxisNone:
ax=plt.gca（）
xlim=ax.get_xlim（）
ylim=ax.get_ylim（）
#creategridtoevaluatemodel
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）
#plotdecisionboundaryandmargins
ax.contour（X,Y,P,colors='k',
levels=[-1,0,1],alpha=0.5,
linestyles=['--','-','--']）
#plotsupportvectors
ifplot_support:
ax.scatter（model.support_vectors_[:
0],
model.support_vectors_[:
1],
s=300,linewidth=1,facecolors='none'）;
ax.set_xlim（xlim）
ax.set_ylim（ylim）
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
plot_svc_decision_function（model）;
model.support_vectors_
defplot_svm（N=10,ax=None）:
X,y=make_blobs（n_samples=200,centers=2,
random_state=0,cluster_std=0.60）
X=X[:
N]
y=y[:
N]
model=SVC（kernel='linear',C=1E10）
model.fit（X,y）
ax=axorplt.gca（）
ax.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
ax.set_xlim（-1,4）
ax.set_ylim（-1,6）
plot_svc_decision_function（model,ax）
fig,ax=plt.subplots（1,2,figsize=（16,6））
fig.subplots_adjust（left=0.0625,right=0.95,wspace=0.1）
foraxi,Ninzip（ax,[60,120]）:
plot_svm（N,axi）
axi.set_title（'N={0}'.format（N））
引入核函数的SVM
∙首先我们先用线性的核来看一下在下面这样比较难的数据集上还能分了吗？
fromsklearn.datasets.samples_generatorimportmake_circles
X,y=make_circles（100,factor=.1,noise=.1）
clf=SVC（kernel='linear'）.fit（X,y）
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
plot_svc_decision_function（clf,plot_support=False）;
#加入了新的维度r
frommpl_toolkitsimportmplot3d
r=np.exp（-（X**2）.sum
（1））
defplot_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='autumn'）
ax.view_init（elev=elev,azim=azim）
ax.set_xlabel（'x'）
ax.set_ylabel（'y'）
ax.set_zlabel（'r'）
plot_3D（elev=45,azim=45,X=X,y=y）
#加入径向基函数
clf=SVC（kernel='rbf',C=1E6）
clf.fit（X,y）
#这回牛逼了！
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
plot_svc_decision_function（clf）
plt.scatter（clf.support_vectors_[:
0],clf.support_vectors_[:
1],
s=300,lw=1,facecolors='none'）;
使用这种核支持向量机，我们学习一个合适的非线性决策边界。
这种核变换策略在机器学习中经常被使用！
调节SVM参数:
SoftMargin问题
调节C参数
∙当C趋近于无穷大时：
意味着分类严格不能有错误
∙当C趋近于很小的时：
意味着可以有更大的错误容忍
X,y=make_blobs（n_samples=100,centers=2,
random_state=0,cluster_std=0.8）
plt.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）;
X,y=make_blobs（n_samples=100,centers=2,
random_state=0,cluster_std=0.8）
fig,ax=plt.subplots（1,2,figsize=（16,6））
fig.subplots_adjust（left=0.0625,right=0.95,wspace=0.1）
foraxi,Cinzip（ax,[10.0,0.1]）:
model=SVC（kernel='linear',C=C）.fit（X,y）
axi.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
plot_svc_decision_function（model,axi）
axi.scatter（model.support_vectors_[:
0],
model.support_vectors_[:
1],
s=300,lw=1,facecolors='none'）;
axi.set_title（'C={0:
.1f}'.format（C）,size=14）
X,y=make_blobs（n_samples=100,centers=2,
random_state=0,cluster_std=1.1）
fig,ax=plt.subplots（1,2,figsize=（16,6））
fig.subplots_adjust（left=0.0625,right=0.95,wspace=0.1）
foraxi,gammainzip（ax,[10.0,0.1]）:
model=SVC（kernel='rbf',gamma=gamma）.fit（X,y）
axi.scatter（X[:
0],X[:
1],c=y,s=50,cmap='autumn'）
plot_svc_decision_function（model,axi）
axi.scatter（model.support_vectors_[:
0],
model.support_vectors_[:
1],
s=300,lw=1,facecolors='none'）;
axi.set_title（'gamma={0:
.1f}'.format（gamma）,size=14）
Example:
FaceRecognition
Asanexampleofsupportvectormachinesinaction,let'stakealookatthefacialrecognitionproblem.WewillusetheLabeledFacesintheWilddataset,whichconsistsofseveralthousandcollatedphotosofvariouspublicfigures.AfetcherforthedatasetisbuiltintoScikit-Learn:
fromsklearn.datasetsimportfetch_lfw_people
faces=fetch_lfw_people（min_faces_per_person=60）
print（faces.target_names）
print（faces.images.shape）
fig,ax=plt.subplots（3,5）
fori,axiinenumerate（ax.flat）:
axi.imshow（faces.images[i],cmap='bone'）
axi.set（xticks=[],yticks=[],
xlabel=faces.target_names[faces.target[i]]）
∙每个图的大小是[62×47]
∙在这里我们就把每一个像素点当成了一个特征，但是这样特征太多了，用PCA降维一下吧！
fromsklearn.svmimportSVC
#fromsklearn.decompositionimportRandomizedPCA
fromsklearn.decompositionimportPCA
fromsklearn.pipelineimportmake_pipeline
pca=PCA（n_components=150,whiten=True,random_state=42）
svc=SVC（kernel='rbf',class_weight='balanced'）
model=make_pipeline（pca,svc）
fromsklearn.model_selectionimporttrain_test_split
Xtrain,Xtest,ytrain,ytest=train_test_split（faces.data,faces.target,
random_state=40）
使用gridsearchcross-validation来选择我们的参数
fromsklearn.model_selectionimportGridSearchCV
param_grid={'svc__C':
[1,5,10],
'svc__gamma':
[0.0001,0.0005,0.001]}
grid=GridSearchCV（model,param_grid）
%timegrid.fit（Xtrain,ytrain）
print（grid.best_params_）
model=grid.best_estimator_
yfit=model.predict（Xtest）
yfit.shape
fig,ax=plt.subplots（4,6）
fori,axiinenumerate（ax.flat）:
axi.imshow（Xtest[i].reshape（62,47）,cmap='bone'）
axi.set（xticks=[],yticks=[]）
axi.set_ylabel（faces.target_names[yfit[i]].split（）[-1],
color='black'ifyfit[i]==ytest[i]else'red'）
fig.suptitle（'PredictedNames;IncorrectLabelsinRed',size=14）;
fromsklearn.metricsimportclassification_report
print（classification_report（ytest,yfit,
target_names=faces.target_names））
∙精度（precision）=正确预测的个数（TP）/被预测正确的个数（TP+FP）
∙召回率（recall）=正确预测的个数（TP）/预测个数（TP+FN）
∙F1=2精度召回率/（精度+召回率）
fromsklearn.metricsimportconfusion_matrix
mat=confusion_matrix（ytest,yfit）
sns.heatmap（mat.T,square=True,annot=True,fmt='d',cbar=False,
xticklabels=faces.target_names,
yticklabels=faces.target_names）
plt.xlabel（'truelabel'）
plt.ylabel（'predictedlabel'）;
升级会员 