2.1 API : LogisticRegression

LogisticRegression

from sklearn.linear_model import LogisticRegression

LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True,
 intercept_scaling=1, class_weight=None, random_state=None, solver='lbfgs', 
 max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)

 - Parameters(参数)
 	penalty：
	惩罚项，str类型，可选参数为l1和l2，默认为l2。用于指定惩罚项中使用的规范。newton-cg、
	sag和lbfgs求解算法只支持L2规范。L1规范假设的是模型的参数满足拉普拉斯分布，L2假设的模
	型参数满足高斯分布，所谓的范式就是加上对参数的约束，使得模型更不会过拟合(overfit)

	dual : bool, default=False
	对偶或原始方法，bool类型，默认为False。对偶方法只用在求解线性多核(liblinear)的L2惩罚
	项上。当样本数量>样本特征的时候，dual通常设置为False。

	tol : float, default=1e-4
	停止求解的标准，float类型，默认为1e-4。就是求解到多少的时候，停止，认为已经求出最优解

	C : float, default=1.0
	正则化参数(λ的倒数)，float类型，默认为1.0。必须是正浮点型数。
	C越大，惩罚越小，易过拟合，泛化能力越差；C越小，惩罚越大，不易过拟合，泛化能力越好

	fit_intercept：bool, default=True
	指定是否将常量（也称为偏差或截距）添加到决策函数

	intercept_scaling : float, default=1
	仅在正则化项为”liblinear”，且fit_intercept设置为True时有用。float类型，默认为1

	class_weight : dict or ‘balanced’, default=None
	用于标示分类模型中各种类型的权重，可以是一个字典或者’balanced’字符串，默认为不输入，
	也就是不考虑权重，即为None。如果选择输入的话，可以选择balanced让类库自己计算类型权重，
	或者自己输入各个类型的权重。
	
	random_state : int, RandomState instance, default=None
	随机数种子，int类型，可选参数，默认为无，仅在solver == ‘sag’, ‘saga’ or ‘liblinear’ 时有用

	solver : {‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’, ‘saga’}, default=’lbfgs’
	优化算法选择参数，只有五个可选参数，即newton-cg,lbfgs,liblinear,sag,saga。默认为liblinear。
	对于小数据集，“liblinear”是一个很好的选择，而“sag”和“saga”对于大数据集来说更快。
	solver参数决定了我们对逻辑回归损失函数的优化方法，有四种算法可以选择，分别是：
	1.liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。
	2.lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
	3.newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
	4.sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。
	5.saga：线性收敛的随机优化算法的的变种

	max_iter : int, default=100
	算法收敛最大迭代次数，int类型，默认为100。仅在正则化优化算法为newton-cg, sag和lbfgs才
	有用，算法收敛的最大迭代次数。

	multi_class : {‘auto’, ‘ovr’, ‘multinomial’}, default=’auto’
	分类方式选择参数，str类型，可选参数为ovr和multinomial，即ovr与MvM，默认为ovr
	如果是二元逻辑回归，ovr和multinomial并没有任何区别，区别主要在多元逻辑回归上。
	如果选择了ovr，则4种损失函数的优化方法liblinear，newton-cg,lbfgs和sag都可以选择。
	但是如果选择了multinomial,则只能选择newton-cg, lbfgs和sag了。

	verbose : int, default=0
	日志冗长度，int类型。默认为0。就是不输出训练过程，1的时候偶尔输出结果，大于1，
	对于每个子模型都输出。

	warm_start : bool, default=False
	bool类型。默认为False。如果为True，则下一次训练重新使用上一次的调用作为初始化。
	
	n_jobs : int, default=None
	并行数。int类型，默认为1。1的时候，用CPU的一个内核运行程序，2的时候，用CPU的2个内核运行程序。
	为-1的时候，用所有CPU的内核运行程序。
	
	l1_ratio : float, default=None
	Elastic-Net混合参数，
	其中0 <= l1_ratio <=1。仅当惩罚=“ elasticnet”时使用。
	设置l1_ratio = 0等效于使用惩罚=“ l2”，而设置l1_ratio = 1等效于使用惩罚=“ l1”

 - Attributes(属性)
	classes_ : ndarray of shape (n_classes, )
	分类器已知的类别标签列表

	coef_ : ndarray of shape (1, n_features) or (n_classes, n_features)
	估计系数

	intercept_ : ndarray of shape (1,) or (n_classes,)
	截距
	如果fit_intercept设置为False，则截距设置为零。

	n_iter_ : ndarray of shape (n_classes,) or (1, )
	所有类的实际迭代数
	对于liblinear求解器，仅给出所有类的最大迭代次数pe (n_classes,) or (1, )
	

 - Methods(方法)
	decision_function(X)
	预测样本的置信度分数

	densify()
	将系数矩阵转换为密集数组格式

	fit(X, y[, sample_weight])
	根据给定的训练数据拟合模型

	get_params([deep])
	获取这个估计器的参数

	predict(X)
	预测X中的样本的类别标签

	predict_log_proba(X)
	预测概率估计的对数

	predict_proba(X)
	概率的估计

	score(X, y[, sample_weight])
	返回给定测试数据和标签的平均精度

	set_params(**params)
	设置这个估计器的参数

	sparsify()
	将系数矩阵转换为稀疏格式

class_weight详解：
举个例子，比如对于0,1的二元模型，我们可以定义class_weight={0:0.9,1:0.1}，这样类型0的权重为90%，而类型1的权重为10%。如果class_weight选择balanced，那么类库会根据训练样本量来计算权重。某种类型样本量越多，则权重越低，样本量越少，则权重越高。当class_weight为balanced时，类权重计算方法如下：n_samples / (n_classes * np.bincount(y))。n_samples为样本数，n_classes为类别数量，np.bincount(y)会输出每个类的样本数，例如y=[1,0,0,1,1],则np.bincount(y)=[2,3]。

那么class_weight有什么作用呢？

在分类模型中，我们经常会遇到两类问题

• 第一种是误分类的代价很高。比如对合法用户和非法用户进行分类，将非法用户分类为合法用户的代价很高，我们宁愿将合法用户分类为非法用户，这时可以人工再甄别，但是却不愿将非法用户分类为合法用户。这时，我们可以适当提高非法用户的权重。
• 第二种是样本是高度失衡的，比如我们有合法用户和非法用户的二元样本数据10000条，里面合法用户有9995条，非法用户只有5条，如果我们不考虑权重，则我们可以将所有的测试集都预测为合法用户，这样预测准确率理论上有99.95%，但是却没有任何意义。这时，我们可以选择balanced，让类库自动提高非法用户样本的权重。提高了某种分类的权重，相比不考虑权重，会有更多的样本分类划分到高权重的类别，从而可以解决上面两类问题。

solver详解

1. liblinear适用于小数据集，而sag和saga适用于大数据集因为速度更快。

2. 对于多分类问题，只有newton-cg,sag,saga和lbfgs能够处理多项损失，而liblinear受限于一对剩余(OvR)。啥意思，就是用liblinear的时候，如果是多分类问题，得先把一种类别作为一个类别，剩余的所有类别作为另外一个类别。一次类推，遍历所有类别，进行分类。

3. newton-cg,sag和lbfgs这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear和saga通吃L1正则化和L2正则化。

4. sag每次仅仅使用了部分样本进行梯度迭代，所以当样本量少的时候不要选择它，而如果样本量非常大，比如大于10万，sag是第一选择。但是sag不能用于L1正则化，所以当你有大量的样本，又需要L1正则化的话就要自己做取舍了。要么通过对样本采样来降低样本量，要么回到L2正则化。

从上面的描述，大家可能觉得，既然newton-cg, lbfgs和sag这么多限制，如果不是大样本，我们选择liblinear不就行了嘛！错，因为liblinear也有自己的弱点！我们知道，逻辑回归有二元逻辑回归和多元逻辑回归。对于多元逻辑回归常见的有one-vs-rest(OvR)和many-vs-many(MvM)两种。而MvM一般比OvR分类相对准确一些。郁闷的是liblinear只支持OvR，不支持MvM，这样如果我们需要相对精确的多元逻辑回归时，就不能选择liblinear了。也意味着如果我们需要相对精确的多元逻辑回归不能使用L1正则化了。

案例

>>> from sklearn.datasets import load_iris
>>> from sklearn.linear_model import LogisticRegression
>>> X, y = load_iris(return_X_y=True)
>>> clf = LogisticRegression(random_state=0).fit(X, y)
>>> clf.predict(X[:2, :])
array([0, 0])
>>> clf.predict_proba(X[:2, :])
array([[9.8...e-01, 1.8...e-02, 1.4...e-08],
       [9.7...e-01, 2.8...e-02, ...e-08]])
>>> clf.score(X, y)
0.97...

import numpy as np
import pandas as pd
import matplotlib as mpl
import warnings
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score


# 加载数据
def loaddata():
    data = pd.read_csv('data/data1.txt', header=None, delimiter=',')
    data = data.values
    n = data.shape[1] - 1
    X = data[:, :n]
    y = data[:, n]
    return X, y


# 画决策边界图
def plotDescionSBoundary(X, y, theta):
    mpl.rcParams['font.sans-serif'] = ['simHei']
    mpl.rcParams['axes.unicode_minus'] = False
    fig = plt.figure()
    fig.subplots()
    cm_dark = mpl.colors.ListedColormap(['g', 'r'])
    # 根据y自动选择颜色
    plt.scatter(X[:, 0], X[:, 1], c=np.array(y).squeeze(), cmap=cm_dark, s=30)

    x1 = np.arange(min(X[:, 0]), max(X[:, 0]), 0.1)
    x2 = -(theta[0] + theta[1] * x1) / theta[2]
    plt.plot(x1, x2)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.title('决策边界图')
    plt.show()


if __name__ == '__main__':
    # 消除警告
    warnings.filterwarnings(action='ignore')
    # 设置精度
    np.set_printoptions(suppress=True)
    # 加载数据
    X, y = loaddata()

    # 逻辑回归模型
    lgr = LogisticRegression(C=50, max_iter=2500)
    # 训练
    lgr.fit(X, y)
    print('theta_0 =', lgr.intercept_)
    print('theta =', lgr.coef_)
    # 预测
    y_pred = lgr.predict(X)
    print('准确率 =', accuracy_score(y_pred, y))
    theta = np.append(lgr.intercept_, lgr.coef_)
    # 画决策边界图
    plotDescionSBoundary(X, y, theta)