转载请注明作者和出处：http://blog.csdn.net/john_bh/
运行平台： Windows
Python版本： Python3.6
IDE： Sublime text3

一从疝气病症状预测病马的死亡率
二使用Sklearn构建Logistic回归分类器
- 1 LogisticRegression
- 2 使用Logistic回归进行分类
三总结

一、从疝气病症状预测病马的死亡率

1.1 实战背景

使用Logistic回归的估计马疝病的死亡率：

收集数据：给定数据文件。
准备数据：用python解析文本文件，并填充缺失值。
分析数据：可视化并观察数据。
训练算法：使用优化算法，找到最佳系数。
测试算法：为了量化回归的效果，需要观察错误率，根据错误率决定是否退到训练阶段，通过改变迭代的次数和步长等参数来得到更好的回归系数。
使用算法：首先，我们需要输入一些数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数，就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。

1.2 准备数据：处理数据中的缺失值

数据中的缺失值是一个非常棘手的问题，很多文献都致力于解决这个问题。那么，数据缺失究竟带来了什么问题？假设有100个样本和20个特征，这些数据都是机器收集回来的。若机器上的某个传感器损坏导致一个特征无效时该怎么办？它们是否还可用？答案是肯定的。因为有时候数据相当昂贵，扔掉和重新获取都是不可取的，所以必须采用一些方法来解决这个问题。下面给出了一些可选的做法：

使用可用特征的均值来填补缺失值；
使用特殊值来填补缺失值，如-1；
忽略有缺失值的样本；
使用相似样本的均值添补缺失值；
使用另外的机器学习算法预测缺失值。

现在我们要对数据进行预处理，使其可以顺利地使用分类算法，在预处理数据阶段需要做两件事：
第一，所有的缺失值必须用一个实数值来替换，因为使用的NumPy数据类型不允许包含缺失值。这里选择实数0来替换所有缺失值，恰好能适用于Logistic回归，因此这样做的直觉在于，我们需要的是一个在更新时不会影响系数的值。

weights = weights + alpha * error * dataMatrix[randIndex]

如果说dataMatrix的某特征对应值是0，那么该特征的系数将不做更新，即：

weights = weights

另外，由于sigmoid(0)=0.5，即它对结果的预测不惧任何倾向性，因此不会对误差造成任何影响。基于上述原因，将缺失值用0代替既可以保留现有数据，也不需要对优化算法进行修改；此外该数据集中的特征取值一般不为0，因此在某种意义上他也满足“特殊值”这个要求。

第二，如果在测试数据集中发现了一条数据的类别标记已经缺失，那么简单的做法就是将该条数据丢弃。因为类别标签和特征不同，很难确定采用某个合适的值来替换。采用Logistic回归进行分类时，这种做法是合理的，而如果采用knn的方法就可能不太可行。

原始的数据集经过处理，保存为两个文件：horseColicTest.txt和horseColicTraining.txt。已经处理好的“干净”可用的数据集下载地址：
https://#
https://#

现在我们有一个“干净”可用的数据集，和一个不错的优化算法，下面将把这些部分融合在一起，训练出来一个分类器，利用该分类器来预测病马的生死问题。

1.3 预测算法：使用Logistic回归进行分类

使用Logistic回归方法进行分类并不需要做很多工作，所需做的只是把测试集上每个特征向量乘以最优化方法得来的回归系数，再将乘积结果求和，最后输入到Sigmoid函数中即可。如果对应的Sigmoid值大于0.5就预测类别标签为1，否则为0。
新建一个文件：LR_Horse.py:

# -*- coding:UTF-8 -*-
import numpy as np
import random

"""
函数说明:sigmoid函数
Parameters:
    inX - 数据
Returns:
    返回sigmoid函数
"""
def sigmoid(inX):
    return 1.0/(1+np.exp(-inX))

"""
函数说明:梯度上升算法
Parameters:
    dataMatIn - 数据集
    classLabels - 数据标签
Returns:
    weights.getA() - 求得的权重数组(最优参数)
"""
def gradAscent(dataMatIn,classLables):
    dataMatrix=np.mat(dataMatIn)    #转换成numpy的mat
    lableMat=np.mat(classLables).transpose()   #转换成numpy的mat,并进行转置
    m,n=np.shape(dataMatrix)    #返回dataMatrix的行数和列数：m为行数,n为列数。
    alpha=0.01    #移动步长,或者叫做学习速率,控制更新的幅度。
    maxCycles=500    #最大迭代次数
    weights=np.ones((n,1))    #参数θ默认为1
    for k in range(maxCycles):
        h=sigmoid(dataMatrix * weights)     #梯度上升矢量化公式,通过sigmoid函数得到h_θ(x)
        error = (lableMat - h)    #计算真实值和与测试值的差值，按照差值方向调整回归系数
        weights = weights + alpha * dataMatrix.transpose() * error    #参数迭代生成新的参数θ
    return weights.getA()      #返回参数向量

"""
函数说明:改进的随机梯度上升算法
Parameters:
    dataMatrix - 数据集
    classLabels - 数据标签
    numIter - 迭代次数
Returns:
    weights - 求得的权重数组(最优参数)
"""
def stocGradAscent1(dataMatrix,classLables,numIter=150):
    m,n=np.shape(dataMatrix)    #返回dataMatrix的行数和列数：m为行数,n为列数。
    weights=np.ones(n)    #初始化参数 
    for j in range(numIter):
        dataIndex=list(range(m))
        for i in range(m):
            alpha = 4 / (1.0 + j + i) + 0.01    #降低alpha的大小，每次减小1/(j+i)
            randIndex = int(random.uniform(0,len(dataIndex)))    #随机选取样本
            h=sigmoid(np.sum(dataMatrix[randIndex] * weights))     # #选择随机选取的一个样本，计算h
            error = (classLables[randIndex] - h)    #计算误差
            weights = weights + alpha * error * dataMatrix[randIndex]      #更新回归系数
            del(dataIndex[randIndex])    #删除已经使用的样本
    return weights    #返回参数向量

"""
函数说明:分类函数
Parameters:
    inX - 特征向量
    weights - 回归系数
Returns:
    分类结果
"""
def classifyVector(inX,weights):
    prob=sigmoid(sum(inX * weights))
    if prob > 0.5: return 1.0
    else: return 0.0

"""
函数说明:使用Python写的Logistic分类器做预测
Parameters:
    无
Returns:
    无
"""
def colicTest():
    trainingSet = []      #创建数据列表
    trainingLabels = []     #创建标签列表
    frTrain = open('horseColicTraining.txt')   #打开训练数据文件   
    for line in frTrain.readlines():    #逐行读取
        currLine = line.strip().split('\t')
        lineArr=[]
        for i in range(len(currLine)-1):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[-1]))
    trainWeights = stocGradAscent1(np.array(trainingSet), trainingLabels, 500)   #使用改进的随机梯度上升训练
    #trainWeights = gradAscent(np.array(trainingSet), trainingLabels)  # 使用梯度上升训练
    errorCount = 0; numTestVec = 0.0

    frTest = open('horseColicTest.txt')   #打开测试数据文件 
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr =[]
        for i in range(len(currLine)-1):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(np.array(lineArr), trainWeights))!= int(currLine[-1]):
            errorCount += 1
        #if int(classifyVector(np.array(lineArr), trainWeights[:,0]))!= int(currLine[-1]):
            #errorCount += 1
    errorRate = (float(errorCount)/numTestVec) * 100      #错误率计算
    print("测试集错误率为: %.2f%%" % errorRate)

if __name__ == '__main__':
    colicTest()

运行结果如下如所示：

可以看出，错误率还是蛮高的。首先，因为数据集本身有30%的数据缺失，这个是不能避免的。另一个主要原因是，我们使用的是改进的随机梯度上升算法，因为数据集本身就很小，就几百的数据量。用改进的随机梯度上升算法显然不合适。再试一下梯度上升算法，看一下运行效果：

这里写图片描述

可以看到错误率较低。很显然，使用随机梯度上升算法，反而得不偿失了。所以可以得到如下结论： 当数据集较小时，我们使用梯度上升算法；当数据集较大时，我们使用改进的随机梯度上升算法。对应的，在Sklearn中，我们就可以根据数据情况选择优化算法，比如数据较小的时候，我们使用liblinear，数据较大时，我们使用sag和saga。

二、使用Sklearn构建Logistic回归分类器

官方英文文档：
http://scikit-learn.org/dev/modules/classes.html#module-sklearn.linear_model

2.1 LogisticRegression

看下LogisticRegression这个函数，可以发现竟然有14个参数：

参数说明如下：

penalty：惩罚项，str类型，可选参数为l1和l2，默认为l2。用于指定惩罚项中使用的规范。newton-cg、sag和lbfgs求解算法只支持L2规范。L1G规范假设的是模型的参数满足拉普拉斯分布，L2假设的模型参数满足高斯分布，所谓的范式就是加上对参数的约束，使得模型更不会过拟合(overfit)，但是如果要说是不是加了约束就会好，这个没有人能回答，只能说，加约束的情况下，理论上应该可以获得泛化能力更强的结果。
dual：对偶或原始方法，bool类型，默认为False。对偶方法只用在求解线性多核(liblinear)的L2惩罚项上。当样本数量>样本特征的时候，dual通常设置为False。
tol：停止求解的标准，float类型，默认为1e-4。就是求解到多少的时候，停止，认为已经求出最优解。
c：正则化系数λ的倒数，float类型，默认为1.0。必须是正浮点型数。像SVM一样，越小的数值表示越强的正则化。
fit_intercept：是否存在截距或偏差，bool类型，默认为True。
intercept_scaling：仅在正则化项为”liblinear”，且fit_intercept设置为True时有用。float类型，默认为1。
class_weight：用于标示分类模型中各种类型的权重，可以是一个字典或者balanced字符串，默认为不输入，也就是不考虑权重，即为None。如果选择输入的话，可以选择balanced让类库自己计算类型权重，或者自己输入各个类型的权重。举个例子，比如对于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，让类库自动提高非法用户样本的权重。提高了某种分类的权重，相比不考虑权重，会有更多的样本分类划分到高权重的类别，从而可以解决上面两类问题。
random_state：随机数种子，int类型，可选参数，默认为无，仅在正则化优化算法为sag,liblinear时有用。
solver：优化算法选择参数，只有五个可选参数，即newton-cg,lbfgs,liblinear,sag,saga。默认为liblinear。solver参数决定了我们对逻辑回归损失函数的优化方法，有四种算法可以选择，分别是：
- liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。
- lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
- newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
- sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。
- saga：线性收敛的随机优化算法的的变重。
$\space \space \space\space\space\space\space\space\space$ 总结：
- liblinear适用于小数据集，而sag和saga适用于大数据集因为速度更快。
- 对于多分类问题，只有newton-cg,sag,saga和lbfgs能够处理多项损失，而liblinear受限于一对剩余(OvR)。啥意思，就是用liblinear的时候，如果是多分类问题，得先把一种类别作为一个类别，剩余的所有类别作为另外一个类别。一次类推，遍历所有类别，进行分类。
- newton-cg,sag和lbfgs这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear和saga通吃L1正则化和L2正则化。
- 同时，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正则化了。
max_iter：算法收敛最大迭代次数，int类型，默认为10。仅在正则化优化算法为newton-cg,
sag和lbfgs才有用，算法收敛的最大迭代次数。
multi_class：分类方式选择参数，str类型，可选参数为ovr和multinomial，默认为ovr。ovr即前面提到的one-vs-rest(OvR)，而multinomial即前面提到的many-vs-many(MvM)。如果是二元逻辑回归，ovr和multinomial并没有任何区别，区别主要在多元逻辑回归上。

OvR和MvM有什么不同？
OvR的思想很简单，无论你是多少元逻辑回归，我们都可以看做二元逻辑回归。具体做法是，对于第K类的分类决策，我们把所有第K类的样本作为正例，除了第K类样本以外的所有样本都作为负例，然后在上面做二元逻辑回归，得到第K类的分类模型。其他类的分类模型获得以此类推。
而MvM则相对复杂，这里举MvM的特例one-vs-one(OvO)作讲解。如果模型有T类，我们每次在所有的T类样本里面选择两类样本出来，不妨记为T1类和T2类，把所有的输出为T1和T2的样本放在一起，把T1作为正例，T2作为负例，进行二元逻辑回归，得到模型参数。我们一共需要T(T-1)/2次分类。
可以看出OvR相对简单，但分类效果相对略差（这里指大多数样本分布情况，某些样本分布下OvR可能更好）。而MvM分类相对精确，但是分类速度没有OvR快。如果选择了ovr，则4种损失函数的优化方法liblinear，newton-cg,lbfgs和sag都可以选择。但是如果选择了multinomial,则只能选择newton-cg,lbfgs和sag了。
verbose：日志冗长度，int类型。默认为0。就是不输出训练过程，1的时候偶尔输出结果，大于1，对于每个子模型都输出。
warm_start：热启动参数，bool类型。默认为False。如果为True，则下一次训练是以追加树的形式进行（重新使用上一次的调用作为初始化）。
n_jobs：并行数。int类型，默认为1。1的时候，用CPU的一个内核运行程序，2的时候，用CPU的2个内核运行程序。为-1的时候，用所有CPU的内核运行程序。

2.2 使用Logistic回归进行分类

# -*- coding:UTF-8 -*-
import numpy as np
from sklearn.linear_model import LogisticRegression

def colicSklearn():
    #使用np读取数据
    trainFiled=np.loadtxt('horseColicTraining.txt',delimiter="  ")
    trainSet = trainFiled[:,:-1]
    trainLables=trainFiled[:,-1:]

    testFiled = np.loadtxt('horseColicTest.txt', delimiter="    ")
    testSet = testFiled[:, :-1]
    testLables = testFiled[:, -1:]
    classifier=LogisticRegression(solver='liblinear',max_iter=10).fit(trainSet,trainLables)
    test_accurcy=classifier.score(testSet,testLables) *100

    print('正确率：%f%%'%test_accurcy)
if __name__ == '__main__':
    colicSklearn()

运行结果如下图所示：
这里写图片描述

可以更改solver参数，比如设置为sag，使用随机平均梯度下降算法，看看效果，这里不再展示了。

三、总结

Logistic 回归的目的是寻找一个非线性的函数Sigmoid最佳拟合参数，求解过程可以由最优化算法来实现。在最优化算法中，最常用的是梯度上升算法，而梯度上升算法又可以简化为随机梯度上升算法。

随机梯度上升算法与梯度上升算法的效果相当，但是占用更少的计算资源；此外随机梯度上升是一个在线算法，他可以在新数据到来时就程程参数的更新，而不需要重新读取整个数据集来进行批处理计算。

Logistic回归的优缺点
优点：实现简单，易于理解和实现；计算代价不高，速度很快，存储资源低。
缺点：容易欠拟合，分类精度可能不高。

《机器学习实战》学习笔记（四）之Logistic（下）Logistic回归实战之预测病马死亡率及使用Sklearn构建Logistic回归分类器