【笔记】sklearn中的SVM以及使用多项式特征以及核函数

sklearn中的SVM以及使用多项式特征以及核函数

sklearn中的SVM的使用

SVM的理论部分

需要注意的是，使用SVM算法，和KNN算法一样，都是需要做数据标准化的处理才可以，因为不同尺度的数据在其中的话，会严重影响SVM的最终结果

（在notebook中）

加载好需要的包，使用鸢尾花数据集，为了方便可视化，只取前两个特征，然后将其绘制出来

  import numpy as np
  import matplotlib.pyplot as plt
  from sklearn import datasets

  iris = datasets.load_iris()

  X = iris.data
  y = iris.target

  X = X[y<2,:2]
  y = y[y<2]

  plt.scatter(X[y==0,0],X[y==0,1],color='red')
  plt.scatter(X[y==1,0],X[y==1,1],color='blue')

图像如下

首先进行数据的标准化的操作，实例化并fit操作，然后对x进行transform操作，传入x_standard，这样就完成了标准化的操作

  from sklearn.preprocessing import StandardScaler

  standardScaler = StandardScaler()
  standardScaler.fit(X,y)
  X_standard = standardScaler.transform(X)

在标准化以后就可以调用SVM算法了，对于线性的SVM，可以直接使用LinearSVC类，然后实例化操作，在进行fit，设置C为10的九次方

  from sklearn.svm import LinearSVC

  svc = LinearSVC(C=1e9)
  svc.fit(X_standard,y)

使用先前的绘制函数并绘制图像

from matplotlib.colors import ListedColormap
def plot_decision_boundary(model, axis):

    x0,x1 = np.meshgrid(
        np.linspace(axis[0],axis[1],int((axis[1]-axis[0])*100)).reshape(-1,1),
        np.linspace(axis[2],axis[3],int((axis[3]-axis[2])*100)).reshape(-1,1)
    )
    X_new = np.c_[x0.ravel(),x1.ravel()]
    y_predict = model.predict(X_new)
    zz = y_predict.reshape(x0.shape)
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)

  plot_decision_boundary(svc,axis=[-3,3,-3,3])
  plt.scatter(X_standard[y==0,0],X_standard[y==0,1])
  plt.scatter(X_standard[y==1,0],X_standard[y==1,1])

图像如下（这就相当于是Hard margin SVM得到的结果）

设置C为0.01，并绘制图像

  svc2 = LinearSVC(C=0.01)
  svc2.fit(X_standard,y)

  plot_decision_boundary(svc2,axis=[-3,3,-3,3])
  plt.scatter(X_standard[y==0,0],X_standard[y==0,1])
  plt.scatter(X_standard[y==1,0],X_standard[y==1,1])

图像如下（将c缩小以后，有一个蓝色的点被错误分类了）

观察系数以及截距

结果如下

改造绘制函数，在新的函数中添加新的代码，在原先的基础上增加上一些绘制的代码，首先取出相应的系数w以及截距b，此时，模型直线应该是w0x0+w1x1+b=0的形式，不过可以改写成x1=-w0/w1*x0-b/w1的形式，那么每有一个x0，就能求出相应的x1，找到对应的点，将其串联起来就得到了需要的直线

对于绘制的点，在axis[0]，axis[1]之间取两百个点，这样就可以求出来上下的直线，将上直线设置为up_y，下设置为down_y，具体可以看这里（链接），由于担心可能超出设置的y的范围，那么就要设置一个过滤，要大于等于最小值，小于等于最大值，然后绘制出两条直线

from matplotlib.colors import ListedColormap
def plot_svc_decision_boundary(model, axis):

    x0,x1 = np.meshgrid(
        np.linspace(axis[0],axis[1],int((axis[1]-axis[0])*100)).reshape(-1,1),
        np.linspace(axis[2],axis[3],int((axis[3]-axis[2])*100)).reshape(-1,1)
    )
    X_new = np.c_[x0.ravel(),x1.ravel()]
    y_predict = model.predict(X_new)
    zz = y_predict.reshape(x0.shape)
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)

    w = model.coef_[0]
    b = model.intercept_[0]

    plot_x = np.linspace(axis[0],axis[1],200)
    up_y = -w[0]/w[1] * plot_x-b/w[1] + 1/w[1]
    down_y = -w[0]/w[1] * plot_x-b/w[1] - 1/w[1]

    up_index = (up_y >= axis[2])&(up_y <= axis[3])
    down_index = (down_y >= axis[2])&(down_y <= axis[3])

    plt.plot(plot_x[up_index],up_y[up_index],color="black")
  plt.plot(plot_x[down_index],down_y[down_index],color="black")

调用新的绘制函数并进行绘制svc图像

  plot_svc_decision_boundary(svc,axis=[-3,3,-3,3])
  plt.scatter(X_standard[y==0,0],X_standard[y==0,1])
  plt.scatter(X_standard[y==1,0],X_standard[y==1,1])

图像如下

绘制svc2的图像

  plot_svc_decision_boundary(svc2,axis=[-3,3,-3,3])
  plt.scatter(X_standard[y==0,0],X_standard[y==0,1])
  plt.scatter(X_standard[y==1,0],X_standard[y==1,1])

图像如下

以上就是线性问题的svm的使用，那么SVM不止可以解决线性问题，也可以解决非线性数据的问题

在svm中使用多项式特征以及核函数（使用svm来处理非线性数据的问题）

具体实现

（在notebook中）

自动生成非线性的数据make_moons来生成数据集，绘制图像看一下长什么样

  import numpy as np
  import matplotlib.pyplot as plt
  from sklearn import datasets

  X,y = datasets.make_moons()

  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

但是这个有点太规整了，所以添加一些噪音进去，设置noise为0.15，其实质上就是使数据的标准差增大，设置随机种子为666，然后再绘制图像看一下

  X,y = datasets.make_moons(noise=0.15,random_state=666)

  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

绘制函数

from matplotlib.colors import ListedColormap
def plot_decision_boundary(model, axis):

    x0,x1 = np.meshgrid(
        np.linspace(axis[0],axis[1],int((axis[1]-axis[0])*100)).reshape(-1,1),
        np.linspace(axis[2],axis[3],int((axis[3]-axis[2])*100)).reshape(-1,1)
    )
    X_new = np.c_[x0.ravel(),x1.ravel()]
    y_predict = model.predict(X_new)
    zz = y_predict.reshape(x0.shape)
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)

使用多项式特征的管道的详情原理

首先生成多项式的特征，然后数据标准化，最后调用LinearSVC的方法，设置C的默认值为1.0

  from sklearn.preprocessing import PolynomialFeatures
  from sklearn.preprocessing import StandardScaler
  from sklearn.svm import LinearSVC
  from sklearn.pipeline import Pipeline

  def PolynomialSVC(degree,C=1.0):
      return Pipeline([
          ("poly",PolynomialFeatures(degree=degree)),
          ("std_scaler",StandardScaler()),
          ("linearSVC",LinearSVC(C=C))
      ])

调用管道，再进行fit操作，然后将图像绘制出来

  poly_svc = PolynomialSVC(degree=3)
  poly_svc.fit(X,y)

  plot_decision_boundary(poly_svc,axis=[-1.5,2.5,-1.0,1.5])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下（可以看出来，边界变成了曲线，说明将结果转换成了一个高维的有多项式项特征的数据以后在使用linearSVM中）

其实SVM有一种特殊的方式，可以直接使用多项式特征，这种称为多项式和，想要使用这种方式，就要调用SVC这个类，先定义一个函数，在这种情况下，只需要两步，第一步对数据进行标准化，第二步实例化一个SVC对象，使用SVC函数，就需要传入一个参数kernel，其中传入一个字符串poly，这样就会自动对传入的数据进行多项式化，进行训练

  from sklearn.svm import SVC

  def PolynomialKernelSVC(degree,C=1.0):
      return Pipeline([
          ("std_scaler",StandardScaler()),
          ("kernelSVC",SVC(kernel="poly",degree=degree,C=C))
      ])

调用函数，并进行训练，然后绘制出图像

  poly_kernel_svc = PolynomialKernelSVC(degree=3)
  poly_kernel_svc.fit(X,y)

  plot_decision_boundary(poly_kernel_svc,axis=[-1.5,2.5,-1.0,1.5])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

以上就是SVM的两种多项式计算的方式