#第30篇分享：乳腺癌预测及SVC的探索（python语言：sklearn支持向量机svm）（6）

#支持向量是个非常强大的算法，我们可以用它做分类和回归，而且通过使用不同的核函数，可以调节我们的模型达到非常优秀的效果，是个非常值得学习的算法：
初识一下：

'''
1.支持向量机能做什么：
线性二分类与多分类；非线性二分类与多分类；普通连续型变量的回归；概率型连续变量的回归；支持向量聚类；异常值检测；转导支持向量机；

2.应用领域：
他在手写识别数字和人脸识别中应用广泛；在文本和超文本分类中举足轻重，现在在医学上应用也比较广泛，蛋白质分类等；

3.原理是什么：
支持向量机的分类方法，是在分布中找出一个超平面作为一个决策边界，使模型在数据上的分类误差尽量小，尤其在未知数据集上的分类误差尽量小。
超平面：他的维度比所在的数据空间少一维，用来划分数据集。

决策边界：就是虚线超平面到我们超平面的距离，我们说这个决策边界越大越好；
w**T*xa+b=0 决策边界公式；w方向垂直我们的决策边界；
>0:1;<0:-1;就可以用来做二分类了；

推导：w**T*xa+b=k或者-k;两边同时除以k;w**T*xa+b=1或者-1；
这两条线过的点我们就称为支持向量；
w.(xp-xr)/||w||=2/||w||  所以：d = 2/||w||  求解d最大，那么就是w最小；
我们把上面的转化一下f(x) = ||w||**2/2 的最小值；min(||w||**2/2 )就是损失函数；

拉格朗日函数：L(w,b,a) = 1/2*||w||**2/2-Σai(yi(w.xi+b)-1) (ai>=0)

利用拉格朗日对偶函数：------
最终求解出f(xtest) = sign(w.xtest+b)=sign(Σaiyixi.xtest+b)
xtest:是任意测试样本；sign(h) h>0时返回1，h<0时返回-1；

'''
#

1.SVM：（可做分类预测及回归预测，选择不同的核函数即可）

①算法概念：
支持向量机SVM，其基本模型定义为特征空间上的间隔最大的线性分类器，其学习策略便是间隔最大化，二维不可分割就升维到三维寻找超平面，依次类推，最终可转化为一个凸二次规划问题的求解。

②.算法思路：初识SVM；
决策边界

这个算法致力于寻找将数据分开，那个最大的决策边界，如下图，中间的就是决策边界，决策边界进行平移，分别经过距离决策边界最近的点，这些点我们叫做支持向量；而这些点带入决策边界函数，值分别为-1，1；我们就可以得出：
决策函数：

上下超平面的距离：



拉格朗日乘数法对损失函数求解（转换为带约束条件的模式）：

求导之后得到：

引入拉格朗日对偶函数：


最终求解：sign(h)是h>0返回1，h<0返回-1：

软间隔;
（就是可以通过加入惩罚项，改变我们的超平面的距离，让我们希望被正确分配的点正确分配，但是，可以看出，这可能会导致另一个类的点分错误）：
上方线平移到蓝色线：蓝色线上方就是1，下方就是-1；可以看出有一部分红色被分错了。


③优缺点：
　优点：可以解决高维问题，即大型特征空间；能够处理非线性特征的相互作用；无需依赖整个数据；可以提高泛化能力；
缺点：当观测样本很多时，效率并不是很高； 对非线性问题没有通用解决方案，有时候很难找到一个合适的核函数； 对缺失数据敏感；对于核的选择也是有技巧的（libsvm中自带了四种核函数：线性核、多项式核、RBF以及sigmoid核）：
第一，如果样本数量小于特征数，那么就没必要选择非线性核，简单的使用线性核就可以了；
第二，如果样本数量大于特征数目，这时可以使用非线性核，将样本映射到更高维度，一般可以得到更好的结果；
第三，如果样本数目和特征数目相等，该情况可以使用非线性核，原理和第二种一样。
对于第一种情况，也可以先对数据进行降维，然后使用非线性核，这也是一种方法。

④.代码实例1：乳腺癌预测
数据位置：乳腺癌数据集

#coding=gb2312
import pandas as pd
'''
乳腺癌预测
'''
#1.读取数据：
data = pd.read_csv(r'./breast_cancer_data-master/data.csv')
#删除对预测无影响的id值：
data.drop('id',axis = 1,inplace=True)

#数据转换成数字格式，容易识别：
data['diagnosis'] = data['diagnosis'].map({
     'M':1,'B':0})

#对后面的数据处理，平均值，标准差，最大值，参数进行归类
featurs_mean = list(data.columns[1:11])
featurs_se = list(data.columns[12:21])
featurs_worst = list(data.columns[22:31])

#绘制良性还是恶性肿瘤的分布：
import seaborn as sns
import matplotlib.pyplot as plt
# sns.countplot(data['diagnosis'],label = 'Count')
# # plt.show()

'''
热力图对角线上的为单变量自身的相关系数是1。颜色越浅代表相关性越大。
radius_mean、perimeter_mean 和 area_mean 相关性非常大，compactness_mean、concavity_mean、concave_points_mean
这3个字段也是相关的，因此我们可以取其中的一个作为代表。
'''
corr = data[featurs_mean].corr()
plt.figure(figsize=(14,14))
sns.heatmap(corr,annot=True)     #annot = True 显示每个方格的数据
plt.show()

#2.对数据进行分割，测试0.25
from sklearn.model_selection import train_test_split
features_remain = ["radius_mean","compactness_mean", 'texture_mean', 'smoothness_mean',  'symmetry_mean', 'fractal_dimension_mean']
x_train, x_test, y_train, y_test = train_test_split(data[features_remain],data['diagnosis'],test_size = 0.25)  #抽取25%的数据作为测试集，其余作为训练集

#3.对数据进行标准化：
from sklearn.preprocessing import StandardScaler
# 进行标准化处理：
std = StandardScaler()
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)

from sklearn import svm
from sklearn import metrics
from sklearn.metrics import classification_report

model = svm.SVC()  # 创建SVM分类器
model.fit(x_train, y_train)  # 用训练集做训练
y_predict = model.predict(x_test)  # 用测试集做预测

print('准确率:', model.score(x_test,y_test))
#召回率：
print("召回率：",classification_report(y_test,y_predict,labels=[0,1],target_names=["a良性","b恶性"]))

结果：

代码实例2（支持向量机的探索：决策边界可视化）：

#1.线性SVM决策过程的可视化：
from sklearn.datasets import make_blobs
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np

#实例化数据集，并可视化：
'''
make_blobs函数是为聚类产生数据集
产生一个数据集和相应的标签
n_samples:表示数据样本点个数,默认值100
n_features:表示数据的维度，默认值是2
centers:产生数据的中心点，默认值3
cluster_std：数据集的标准差，浮点数或者浮点数序列，默认值1.0
center_box：中心确定之后的数据边界，默认值(-10.0, 10.0)
shuffle ：洗乱，默认值是True
random_state:官网解释是随机生成器的种子

'''
x,y = make_blobs(n_samples=50,centers=2,random_state=0,cluster_std=0.6)
plt.scatter(x[:,0],x[:,1],s=50,c=y,cmap="rainbow")
ax = plt.gca()  #获取当前的子图，如果不存在，则创建新的子图；

#绘制决策边界：contour[X,Y,Z,[levels],**kwargs] 绘制等高线的函数

#获取平面上的两条坐标轴的最大最小值：
xlim = ax.get_xlim()
ylim = ax.get_ylim()

#在最大值最小值之间形成30个规律的数据：
axisx = np.linspace(xlim[0],xlim[1],30)
axisy = np.linspace(ylim[0],ylim[1],30)

#生成一个二维数组：作为contour函数的X，Y
#使用meshgrid函数将两个一维向量转换为特征矩阵；
axisy,axisx = np.meshgrid(axisy,axisx)

#匹配一下：xy就是已经形成的网格，ravel是降维函数，vstack能够将多个结构一致的一维数组按行堆叠起来；
xy = np.vstack([axisx.ravel(),axisy.ravel()]).T
# print(xy.T)
# plt.scatter(xy[:,0],xy[:,1],s=1,cmap="rainbow")

#开始建模：通过fit计算出对应的决策边界：
#decision_function返回每个输出样本点到决策边界的距离：
#然后将数据距离转换为axisx的结构，由于contour函数要求Z的结构要与X，Y保持一致；
clf = SVC(kernel="linear").fit(x,y)
Z = clf.decision_function(xy).reshape(axisx.shape)
# print(Z)
#画决策边界和平行于决策边界的超平面：
ax.contour(axisx,axisy,Z
           ,colors="k"
           ,levels=[-1,0,1]
           ,alpha=0.5
           ,linestyles=["--","-","--"]
           )

# #扩展一下：改变levels:新增可视化；
# plt.scatter(x[10,0],x[10,1],c="black",s=50,cmap="rainbow")
# ax = plt.gca()
# print(clf.decision_function(x[10].reshape(1,2)))
# ax.contour(axisx,axisy,Z
#            ,colors="k"
#            ,levels=[-3.33917354]
#            ,alpha=0.5
#            ,linestyles=["--"]
#            )

# plt.xticks([])
# plt.yticks([])
plt.show()

代码实例3（支持向量机的探索：绘图封装成函数）：

#2.将绘图过程包装成函数：
from sklearn.datasets import make_blobs
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np

def plot_svc_decision_function(model,ax=None):
    if ax is None:
        ax = plt.gca()

    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

    axisx = np.linspace(xlim[0],xlim[1],30)
    axisy = np.linspace(ylim[0],ylim[1],30)

    axisy,axisx = np.meshgrid(axisy,axisx)
    xy = np.vstack([axisx.ravel(),axisy.ravel()]).T

    Z = model.decision_function(xy).reshape(axisx.shape)

    ax.contour(axisx,axisy,Z
               ,colors="k"
               ,levels=[-1,0,1]
               ,alpha=0.5
               ,linestyles=["--","-","--"]
               )
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)

    plt.show()

#绘制决策边界：
#实例化数据集，并可视化：
x,y = make_blobs(n_samples=50,centers=2,random_state=0,cluster_std=0.6)

clf = SVC(kernel="linear").fit(x,y)
plt.scatter(x[:,0],x[:,1],s=50,c=y,cmap="rainbow")

plot_svc_decision_function(clf)

#探索一下建立好的模型：

#predict:根据决策边界，对x中的样本进行分类：返回结构为n_samples
print(clf.predict(x))

#score:返回给定测试集数据和标签的平均准确度：
print(clf.score(x,y))

#support_vectors_:返回支持向量：
print(clf.support_vectors_)

#n_support__:返回每个类中支持向量个数
print(clf.n_support_)

代码实例4（支持向量机的探索：环形数据：非线性可分，引入核函数概念）：

# 3.数据非线性可分：环形数据
from sklearn.datasets import make_circles
import matplotlib.pyplot as plt
from sklearn.svm import SVC
import numpy as np
x,y = make_circles(100,factor=0.1,noise=0.1)
# plt.figure(figsize=(12,8))
plt.scatter(x[:,0],x[:,1],c=y,s=50,cmap="rainbow")
# print(y)
plt.show()

#绘制决策边界函数：
def plot_svc_decision_function(model,ax=None):
    if ax is None:
        ax = plt.gca()

    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

    axisx = np.linspace(xlim[0],xlim[1],30)
    axisy = np.linspace(ylim[0],ylim[1],30)

    axisy,axisx = np.meshgrid(axisy,axisx)
    xy = np.vstack([axisx.ravel(),axisy.ravel()]).T

    Z = model.decision_function(xy).reshape(axisx.shape)

    ax.contour(axisx,axisy,Z
               ,colors="k"
               ,levels=[-1,0,1]
               ,alpha=0.5
               ,linestyles=["--","-","--"]
               )
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)

    plt.show()

#绘制决策边界：
clf = SVC(kernel="linear").fit(x,y)
plt.scatter(x[:,0],x[:,1],c=y,s=50,cmap="rainbow")
plot_svc_decision_function(clf)

print(clf.score(x,y))

#4.数据非线性可分：环形数据,很明显分的效果并不明显，所以这时候
#我们需要引入核函数的概念，也就是提升数据的维度，在三维空间我们就会
#得到一个超平面，将数据顺利分隔开；

#这里面就要介绍一下kernel可选参数：线性核：linear;多项式核：poly;双曲正切核：sigmoid;高斯径向基：rbf;
#除了linear，其他核函数均可以处理非线性数据；
#多项式d=1就是处理线性问题，当d是更高次项的时候就是在处理非线性问题；

代码实例5（支持向量机的探索：探索核函数在不同数据集上的表现）：

# 5.探索核函数在不同数据集上的表现：

#a.导入需要的模块：
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from matplotlib.colors import ListedColormap
from sklearn.svm import SVC
from sklearn.datasets import make_circles,make_moons,make_blobs,make_classification

#b.创建数据集，构建核函数：
n_samples = 100
datasets = [
    make_moons(n_samples=n_samples,noise=0.2,random_state=0)
    ,make_circles(n_samples=n_samples,noise=0.2,factor=0.5,random_state=1)
    ,make_blobs(n_samples=n_samples,centers=2,random_state=5)
    ,make_classification(n_samples=n_samples,n_features=2,n_informative=2,n_redundant=0,random_state=7)
]
# print(datasets)
kernels = ["linear","rbf","poly","sigmoid"]

#c.查看一下数据集：
# for x,y in datasets:
#     plt.figure(figsize=(5,4))
#     plt.scatter(x[:,0],x[:,1],c=y,s=50,cmap="rainbow")
#     plt.show()


#d.构建子图：
nrows = len(datasets)
ncols = len(kernels)+1
fig,axes = plt.subplots(nrows,ncols,figsize=(20,16))
# plt.show()

#放入数据：
for ds_cnt,(x,y) in enumerate(datasets):

    #第一列放入原始数据：
    ax = axes[ds_cnt,0]
    if ds_cnt == 0:
        ax.set_title("Input data")
    ax.scatter(x[:,0],x[:,1],c=y,s=5,zorder=10,cmap=plt.cm.Paired,edgecolors="k")
    ax.set_xticks([])
    ax.set_yticks([])
    # plt.show()

    #第二层循环：不同核函数循环：填充分类结果
    for est_idx,kernel in enumerate(kernels):
        #定义子图位置：
        ax = axes[ds_cnt,est_idx+1]
        print(kernel)
        #建模
        clf = SVC(kernel=kernel,gamma=2).fit(x,y)
        score = clf.score(x,y)

        #绘制图像本身分布散点图：
        ax.scatter(x[:, 0], x[:, 1], c=y,s=5, zorder=10, cmap=plt.cm.Paired, edgecolors="k")
        #绘制支持向量：
        ax.scatter(clf.support_vectors_[:,0],clf.support_vectors_[:,1],s=50,
                   facecolors="none",zorder=10,edgecolors="k")

        #绘制决策边界：
        x_min,x_max = x[:,0].min()-0.5,x[:,0].max()+0.5
        y_min,y_max = x[:,1].min()-0.5,x[:,1].max()+0.5

        #np.mgrid 合并了我们之前用的：np.linspace,np.meshgrid的用法；
        #如果步长是复数，其整数部分就是起始值和结束值之间创建的点的数量；
        xx,yy = np.mgrid[x_min:x_max:200j,y_min:y_max:200j]
        # print(xx)

        #np.c_,类似于np.vstack的功能：
        Z = clf.decision_function(np.c_[xx.ravel(),yy.ravel()]).reshape(xx.shape)
        #填充等高线不同区域的颜色：
        ax.pcolormesh(xx,yy,Z>0, shading='auto',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(kernel)

        #为每张图添加分类的分数：
        ax.text(0.95,0.06,("%.2f"%score).lstrip("0")
                ,size=15
                ,bbox=dict(boxstyle="round",alpha=0.8,facecolor="white")#为分数添加一个白色的格子作为底色。
                ,transform=ax.transAxes  #确定文字对应的坐标轴，就是ax子图的坐标轴本身。
                ,horizontalalignment="right" #位与坐标轴什么方向；
                )
    # plt.tight_layout()
plt.show()

代码实例6（支持向量机的探索：探索核函数：C的作用）：

#6.探索核函数的优势和缺陷：data.describe【0.01-0.99】  可以查看量纲的问题，rbf核需要进行无量纲化标准化；
#线性核，尤其是多项式核函数在高次项计算非常缓慢；
#rbf和多项式核函数都不擅长处理量纲不统一的数据集；

#degree:整数，默认3可不填，多项式核函数的次数；
#gamma:浮点数，可不填，仅在kernel的选项是rbf,poly,sigmoid时候有效；
#coef0:浮点数，可不填，核函数中常数项，只在kernel为poly和sigmoid时候有效；

#硬间隔与软间隔：重要参数C
#C是松弛系数的惩罚系数，C设定值大，SVC会选择边际小的；

#调整线性核函数：
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from matplotlib import pyplot as plt
import numpy as np
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
data = load_breast_cancer()
x,y = data.data,data.target

#标准化后准确度直线上升：
x = StandardScaler().fit_transform(x)
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.25,random_state=0)


# score = []
# C_range = np.linspace(0.01,30,50)
# # print(C_range)
#
# for i in C_range:
#     clf = SVC(kernel="linear",C=i,cache_size=5000).fit(x_train,y_train)
#     score.append(clf.score(x_test,y_test))
# print(max(score),C_range[score.index(max(score))])
# plt.plot(C_range,score)
# plt.show()

#看一下rbf效果：
score = []
C_range = np.linspace(0.01,30,50)
# print(C_range)

for i in C_range:
    clf = SVC(kernel="rbf",C=i,gamma="auto",cache_size=5000).fit(x_train,y_train)
    score.append(clf.score(x_test,y_test))
print(max(score),C_range[score.index(max(score))])
plt.plot(C_range,score)
plt.show()

分数和C的探索：可视化查找最优值


代码实例7（支持向量机的探索：探索核函数：评估指标ROC曲线：横坐标假正率，纵坐标召回率）：

#7.SVC的评估指标：样本不均衡问题：class_weight,不能单纯的追求少数类的捕捉，有可能会误伤多数类，造成准确率下降；

#引入混淆矩阵的概念：样本不平衡的问题很有用：准确率，精确度，召回率，假正率；

#绘制ROC曲线增加理解：假正率横轴，召回率纵轴（真正率，查全率）

#概率与阈值：自建数据集
# #调整线性核函数：
from matplotlib import pyplot as plt
import numpy as np
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs
class_1_ = 7
class_2_ = 4
centers_ = [[0.0,0.0],[1,1]]
clusters_std = [0.5,1]
x_,y_ = make_blobs(n_samples=[class_1_,class_2_]
                   ,centers=centers_
                   ,cluster_std=clusters_std
                   ,random_state=0
                   ,shuffle=False)
plt.scatter(x_[:,0],x_[:,1],c=y_,cmap="rainbow",s=30)

plt.show()

from sklearn.linear_model import LogisticRegression as LogiR
clf_lo = LogiR().fit(x_,y_)

prob = clf_lo.predict_proba(x_)

#将样本和概率放到DataFrame中
import pandas as pd
prob = pd.DataFrame(prob)
prob.columns = ["0","1"]
# print(prob)

#手动调节阈值改变模型效果：
for i in range(prob.shape[0]):
    if prob.loc[i,"1"] > 0.4:
        prob.loc[i,"pred"] = 1
    else:
        prob.loc[i,"pred"] = 0

prob["y_true"] = y_
prob = prob.sort_values(by="1",ascending=False)
print(prob)

#手动计算准确率及召回率：
from sklearn.metrics import confusion_matrix as CM , precision_score as P,recall_score as R

C = CM(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])
P1 = P(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])
R1 = R(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])

# print(C,P1,R1)

# #实例化SVC的时候，可以probability=True ；就可以用概率接口了predict_proba
# clf_proba = SVC(kernel="linear",C=1.0,probability=True).fit(x_,y_)
#
# print(clf_proba.predict_proba(x_))
# print(clf_proba.decision_function(x_))

#绘制ROC曲线：

cm = CM(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])

#假正率FRR
a = cm[1,0]/cm[1,:].sum()
#召回率recall
b = cm[0,0]/cm[0,:].sum()
#
# print(a,b)
clf_proba = SVC(kernel="linear",C=1.0,probability=True).fit(x_,y_)
#绘图：
recall = []
FPR = []

probrange = np.linspace(clf_proba.predict_proba(x_)[:,1].min(),clf_proba.predict_proba(x_)[:,1].max(),11)

from sklearn.metrics import confusion_matrix as CM,recall_score as R
from matplotlib import pyplot as plt

for i in probrange:
    y_predict = []
    for j in range(x_.shape[0]):
        if clf_proba.predict_proba(x_)[j,1]>i:
            y_predict.append(1)
        else:
            y_predict.append(0)
    cm = CM(y_,y_predict,labels=[1,0])
    # 假正率FRR
    a = cm[1, 0] / cm[1, :].sum()
    # 召回率recall
    b = cm[0, 0] / cm[0, :].sum()
    recall.append(b)
    FPR.append(a)

recall.sort()
FPR.sort()

plt.plot(FPR,recall,c="red")
plt.plot(probrange+0.05,probrange+0.05,c="black",linestyle="--")
plt.show()

代码实例8（支持向量机的探索：探索核函数：ROC曲线下方面机：最大值是1，越大代表越好）：

# 8.sklearn中的roc面积：

# 1.线性SVM决策过程的可视化：
from sklearn.datasets import make_classification
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np
from sklearn.svm import  SVC

#实例化数据集，并可视化：
x,y = make_classification(n_samples=100,n_features=2,n_informative=2,n_redundant=0,random_state=7)
plt.scatter(x[:,0],x[:,1],s=50,c=y,cmap="rainbow")
plt.show()

clf_proba = SVC(kernel="linear",C=1.0,probability=True).fit(x,y)
from sklearn.metrics import roc_curve

#thresholds 返回的是距离值的阈值
FPR,recall,thresholds = roc_curve(y,clf_proba.decision_function(x),pos_label=1)

# print(FPR,recall,thresholds)

#AUC返回的是ROC曲线的面积
from sklearn.metrics import roc_auc_score as AUC
# area = AUC(y,clf_proba.decision_function(x))
area = AUC(y,clf_proba.decision_function(x))

plt.figure()

#找一下最优点：Recall和FPR差距最大的点：约登指数(后加入的代码)
maxindex = (recall-FPR).tolist().index(max(recall-FPR))
plt.scatter(FPR[maxindex],recall[maxindex],c="black",s=30)
print("最优点位的坐标：",FPR[maxindex],recall[maxindex],"\n","AUC面积",area)


plt.plot(FPR,recall,color="red",label="ROC curve(area=%0.2f)"%area)
plt.plot([0,1],[0,1],color="black",linestyle="--")
plt.xlim([-0.05,1.05])
plt.ylim([-0.05,1.05])
plt.xlabel("False Positive Rate")
plt.ylabel("Recall")
plt.title("Receiver operating characteristic example")
plt.legend(loc="lower right")
plt.show()

以上就是对SVM支持向量机的一个简单介绍，希望能对看到的人有点帮助，随着不断深入学习，也会来修正和修改一下，力求易懂且正确。

持续更新，，，