从上面的描述可以看出，newton-cg、lbfgs和sag这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear通吃L1正则化和L2正则化。
同时，sag每次仅仅使用了部分样本进行梯度迭代，所以当样本量少的时候不要选择它，而如果样本量非常大，比如大于10万，sag是第一选择。但是sag不能用于L1正则化，所以当你有大量的样本，又需要L1正则化的话就要自己做取舍了。要么通过对样本采样来降低样本量，要么回到L2正则化。
但是liblinear也有自己的弱点！我们知道，逻辑回归有二元逻辑回归和多元逻辑回归。对于多元逻辑回归常见的有one-vs-rest(OvR)和many-vs-many(MvM)两种。而MvM一般比OvR分类相对准确一些。而liblinear只支持OvR，不支持MvM，这样如果我们需要相对精确的多元逻辑回归时，就不能选择liblinear了。也意味着如果我们需要相对精确的多元逻辑回归不能使用L1正则化了。

第3章线性逻辑回归代码示例

线性回归是指模型是用“直线”拟合，用直线回归、然后分类。

适合于数据的分布界限是：直线可以分割的。

3.1 步骤1：生成、构建训练数据集

# 导入库
import numpy as np
import matplotlib.pyplot as plt

# 创建自动生成的数据集
np.random.seed(0)

# 生成二维随机向量点(X1,X2)
X = np.random.normal(0, 1, size=(200, 2))
X1 = X[:,0]
X2 = X[:,1]
print(X.shape)
print(X1.shape)
print(X2.shape)

# 生成样本二分类的标签：
# 2X+X2  > 1的点标签为1
# 2X+X2 =< 1的点标签为0
# 边界：直线边界 X1^2 + X2
Y = np.array((X1**2 + X2) > 1, dtype='int')
print(Y.shape)
print(Y)

# 随机抽取 20个样本，强制其分类为 1，
# 相当于更改数据，添加噪音
for _ in range(10):
    Y[np.random.randint(200)] = 1

    
# 所有标签y=0的点
plt.scatter(X[Y==0, 0], X[Y==0, 1])

# 所有标签y=1的点
plt.scatter(X[Y==1, 0], X[Y==1, 1])

plt.show()

(200, 2)
(200,)
(200,)
(200,)
[1 1 1 0 0 1 0 0 1 0 1 0 1 0 1 0 0 0 1 0 0 1 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0
 0 0 0 1 0 1 1 1 1 1 0 1 0 1 1 1 0 1 1 1 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 1 1
 1 1 0 0 0 0 1 0 1 0 1 1 0 1 0 0 0 0 0 1 1 1 0 0 1 1 0 1 0 0 0 1 0 0 0 1 0
 0 1 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 1 0 0 0 1 0 0 1 1 1 0 1 1 0 1 1
 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 1 0 1 0 0 1 0 0 0
 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1]

3.2 步骤2：构建模型并训练模型

# 构建模型并训练模型
from sklearn.model_selection import train_test_split

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, random_state=0)

from sklearn.linear_model import LogisticRegression

#log_reg = LogisticRegression()
log_reg = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
                               intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
                               penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
                               verbose=0, warm_start=False)
log_reg.fit(X_train, Y_train)
score_train = log_reg.score(X_train, Y_train)
score_test = log_reg.score(X_test, Y_test)
print("训练集分数",score_train)
print("测试集分数：",score_test)

训练集分数 0.7933333333333333
测试集分数： 0.8

备注：从上图可以看出，用直线去拟合抛物线分布的向量点，准确率并不高。

下一篇文章看如何优化，使用多项式来进行预测。

3.3 步骤3：可视化模型预测的分类边界

# 可视化训练结果

#可视化决策边界：通过两种预测分类的颜色不同来展示决策的边界
# 背景数据：为二维网格数据点：meshgrid
# 所有用模型预测为1的点，标注红色
# 所有用模型预测为0的点，标注为蓝色
def plot_decision_boundary(model, axis):
    # 生成二维度的网格数据
    x1, x2 = 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)
    )
    print("x1.shape", x1.shape)
    print("x2.shape", x2.shape)
    
    # 组合X1,X2, 得到(X1,X2)向量点
    X = np.c_[x1.ravel(), x2.ravel()]
    print("X.shape", X.shape)
    
    # 模型预测分类
    y_predict = model.predict(X)
    print("y_predict.shape=", y_predict.shape)
    
    # 把一维预测值转换成网格上的点的分类类型
    y = y_predict.reshape(x1.shape)
    print("y.shape=", y.shape)
    print(y)
    
    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A','#FFF59D','#90CAF9'])
    
    # 彩色打印网格点，网格点的颜色由y的类型确定
    # y的类型，由模型对网格点的预测得到
    plt.contourf(x1, x2, y, linewidth=5, cmap=custom_cmap)

plot_decision_boundary(log_reg, axis=[-3, 3, -3, 3])

# 可视化源样本点
plt.scatter(X[Y==0,0], X[Y==0,1])
plt.scatter(X[Y==1,0], X[Y==1,1])

plt.show()

x1.shape (600, 600)
x2.shape (600, 600)
X.shape (360000, 2)
y_predict.shape= (360000,)
y.shape= (600, 600)
[[0 0 0 ... 0 0 0]
 [0 0 0 ... 0 0 0]
 [0 0 0 ... 0 0 0]
 ...
 [1 1 1 ... 1 1 1]
 [1 1 1 ... 1 1 1]
 [1 1 1 ... 1 1 1]]