【笔记】逻辑回归中使用多项式（sklearn）

在逻辑回归中使用多项式特征以及在sklearn中使用逻辑回归并添加多项式

在逻辑回归中使用多项式特征

在上面提到的直线划分中，很明显有个问题，当样本并没有很好地遵循直线划分（非线性分布）的时候，其预测的结果是不太准的，所以可以引用多项式项，从线性回归转换成多项式回归，同理，为逻辑回归添加多项式项，基于这基础，就可以对逻辑回归进行一个比较好的分类，可以使用将degree设置成各种大小来构建任意大小的决策边界

具体实现

（在notebook中）

熟悉的加载包环节，然后设置一个随机数，种子为666，生成X和y，x为两百个样本，每个样本为两个特征，是第一个特征的平方和第二个特征的平方相加小于1.5，小于1.5为1，大于为0，然后绘制图像

  import numpy as np
  import matplotlib.pyplot as plt

  np.random.seed(666)
  X = np.random.normal(0,1,size=(200,2))
  y = np.array(X[:,0]**2 + X[:,1]**2 < 1.5,dtype='int')

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

图像如下

使用逻辑回归，使用封装好的方法，进行实例化，然后fit操作

  from LogisticRegression import LogisticRegression

  log_reg = LogisticRegression()
  log_reg.fit(X,y)

可以得到准确度

  log_reg.score(X,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(log_reg,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

添加多项式项，详细参照这里的思想

简要概述：做一个为逻辑回归添加多项式项的管道

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

  def PolynomialLogisticRegression(degree):
      return Pipeline([
          ('poly',PolynomialFeatures(degree=degree)),
          ('std_scaler',StandardScaler()),
          ('log_reg',LogisticRegression())
      ])

进行实例化，最后fit操作

  poly_log_reg = PolynomialLogisticRegression(degree=2)
  poly_log_reg.fit(X,y)

结果如下

其准确率为

绘制图像：

  plot_decision_boundary(poly_log_reg,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

设置degree为20，再试验一下

  poly_log_reg2 = PolynomialLogisticRegression(degree=20)
  poly_log_reg2.fit(X,y)

结果如下

绘制图像：

  plot_decision_boundary(poly_log_reg2,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

出现这种决策边界很奇怪的情况，估计就是degree太大了，导致了形状不太规则，显然发生了过拟合的形象，模型越复杂越容易产生过拟合的情况，此时就要解决过拟合的情况，使用模型正则化就可以很好的解决

在逻辑回归中使用正则化同时使用sklearn中的逻辑回归

为逻辑回归添加正则项

关于正则项，可以
点击这里

这里可以使用新的计算方式

这种方式的好处是，如果c越大，在优化损失函数的时候就可以更好更快的将前项减到最小，这种就是在sklearn中的使用的方式

具体实现

（在notebook中）

与上面不同的是，生成的测试用例不同，对第一个特征平方，第二个特征为正常，同样的使相加的和小于1.5，添加一些噪音，挑二十个点，将其强制变为分类结果为1

  np.random.seed(666)
  X = np.random.normal(0,1,size=(200,2))
  y = np.array(X[:,0]**2 + X[:,1] < 1.5,dtype='int')
  for _ in range(20):
      y[np.random.randint(200)] = 1

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

图像如下

使用sklearn来进行逻辑回归

首先还是分割数据集，要想使用sklearn中的逻辑回归，调用LogisticRegression即可，实例化以后在进行fit，传入训练集

  from sklearn.model_selection import train_test_split

  X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=666)

  from sklearn.linear_model import LogisticRegression

  log_reg = LogisticRegression()
  log_reg.fit(X_train,y_train)

然后看一下在训练数据集上的模拟的准确度

  log_reg.score(X_train,y_train)

结果如下

再看一下在测试数据集上的结果

  log_reg.score(X_test,y_test)

结果如下

绘制函数：

  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(log_reg,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

和上面一样，使用管道来组合一个多项式逻辑回归方法

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

  def PolynomialLogisticRegression(degree):
      return Pipeline([
          ('poly',PolynomialFeatures(degree=degree)),
          ('std_scaler',StandardScaler()),
          ('log_reg',LogisticRegression())
      ])

然后进行实例化，设置degree为2，并进行fit操作

  poly_log_reg = PolynomialLogisticRegression(degree=2)
  poly_log_reg.fit(X_train,y_train)

然后看一下在训练数据集上的模拟的准确度

  poly_log_reg.score(X_train,y_train)

结果如下

再看一下在测试数据集上的结果

  poly_log_reg.score(X_test,y_test)

结果如下

绘制决策边界

  plot_decision_boundary(poly_log_reg,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

设置degree为20

  poly_log_reg2 = PolynomialLogisticRegression(degree=20)
  poly_log_reg2.fit(X_train,y_train)

训练数据集准确度结果如下

测试数据集准确度结果如下（此时可以看出来一些过拟合的现象）

绘制出决策边界

  plot_decision_boundary(poly_log_reg2,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

设置一个新的管道，传入一个新的C的参数，然后调用操作，设置c为0.1，degree为20

  def PolynomialLogisticRegression(degree,C):
      return Pipeline([
          ('poly',PolynomialFeatures(degree=degree)),
          ('std_scaler',StandardScaler()),
          ('log_reg',LogisticRegression(C=C))
      ])

  poly_log_reg3 = PolynomialLogisticRegression(degree=20,C=0.1)
  poly_log_reg3.fit(X_train,y_train)

训练数据集准确度结果如下

测试数据集准确度结果如下

绘制决策边界

  plot_decision_boundary(poly_log_reg3,axis=[-4,4,-4,4])
  plt.scatter(X[y==0,0],X[y==0,1])
  plt.scatter(X[y==1,0],X[y==1,1])

图像如下

多设置一个参数penalty，设置以后进行操作

  def PolynomialLogisticRegression(degree,C,penalty='l1'):
      return Pipeline([
          ('poly',PolynomialFeatures(degree=degree)),
          ('std_scaler',StandardScaler()),
          ('log_reg',LogisticRegression(C=C,penalty=penalty))
      ])

  poly_log_reg4 = PolynomialLogisticRegression(degree=20,C=0.1,penalty='l1')
  poly_log_reg4.fit(X_train,y_train)

此时报错

这里表示Solver仅能使用L2正则项，意思是只能使用L2正则项？（疑惑）

那怎么使用L1正则项来添加呢？
乂，我也不清楚…
等大佬解答