Logistic回归_-0.397822 8.058397 -1 0.824839 13.730343 -1 1.5072-CSDN博客

本文链接：https://blog.csdn.net/zxc024000/article/details/53608256

前言

生活中有许多最优化问题，如到达两地的最短时间、发动机油耗最小产生最率最大。本章将使用最优化算法训练一个非线性函数用于分类。这里所说的非线性函数（分类器），就是logistic回归分类器。

假设有一些数据点，用一条直线对这些数据点进行拟合（该线称为最佳拟合直线），这个拟合过程就称为回归。利用logistic回归来分类的主要思想为：根据现有数据对分类边界建立回归公式，通过该回归公式进行分类。

回归一词来源于最佳拟合，表示找到最佳拟合参数集。训练分类器时，采用最优化算法，寻找最佳拟合参数。

(1)收集数据：任意方法。

(2)准备数据：数值型数据，结构化数据格式。

(3)分析数据：任意方法。

(4)训练算法：找到最佳的分类回归参数。

(5)测试算法：使用测试数据，测试算法准确度。

(6)使用算法：输入数据，转化格式，使用训练好的回归参数进行回归计算，判定属于的类别。

基于logistic回归的和Sigmoid函数的分类

优点：计算代价不高。

缺点：容易欠拟合，分类精度可能不高。

Sigmod函数：

$f(x)=\frac{1}{1+e^{-x}}$
当x值为0时，sigmod函数值为0.5.随着x值的增大，对应的sigmod值逼近1。随着x的减少，对应的sigmod值逼近0。

为了实现分类任务，在将每一个特征乘以一个回归系数，然后把所有值相加，将这个值作为sigmod函数的输入，从而得到一个范围在0~1之间的数值。如果大于0.5，属于分类1，反之属于分类0.

现在，我们要解决的任务就是：最佳回归系数？

基于最优化方法的最佳回归系数缺点

$z = w_0x_0+w_1x_1+w_2x_2+...+w_nx_n$
采用向量改写上述公式：

$z = w^Tx$
其中z为sigmod函数的输入，x是分类器的输入数据，w是最佳参数（系数）。为了寻找最佳参数，需要用到最优化。

梯度上升法

梯度上升法是一种最优化算法，其基本思想是：为了找到某个函数的最大值，沿着该函数的梯度方向寻找。函数f(x,y)的梯度由下式表示：

$\nabla{f(x,y)}=[\frac{ {\frac{ \vartheta f(x,y) }{ \vartheta x }} } { {\frac{ \vartheta f(x,y) }{ \vartheta y }} }]$
这个梯度意味着，找找到函数最大的值，需要沿x的方向移动
$\frac{ \vartheta f(x,y) }{ \vartheta x }$
沿y的方向移动

$\frac{ \vartheta f(x,y) }{ \vartheta y }$
其中f(x,y)必须是可微。移动方向有了，需要移动多少？移动量的大小称为步长，记做
$\alpha$
梯度算法的迭代公式如下：

$w:=w+\alpha{\nabla{f(w)}}$
该过程迭代执行，直到满足某个停止条件。

梯度下降，只是把上式中的+改为-号，它寻找函数关于参数w的最小值：
$w:=w-\alpha{\nabla{f(w)}}$

上面两式，梯度上升用来求函数的最大值，梯度下降用来求函数的最小值。对于梯度下降公式的理解：用来训练的数据是准备好的，不变的。但是非线性函数f的系数是可以改变的，通过改变系数w，求得函数f的最小值。

训练算法：使用梯度下降找到最佳参数

伪代码

初始化每个回归系数(1)
重复R次：
    计算整个数据集的梯度
    使用alpha(步长)x梯度更新回归稀疏
    返回回归系数

具体实现
logistic回归梯度下降算法

#加载数据
def loadDataSet():
    dataMat = []; labelMat = []
    fr = open('testSet.txt')
    for line in fr.readlines():
        #分割文本  strip去掉前后空白 split分割
        lineArr = line.strip().split()
        #[x0 x1 x2]=[1 xxx xxx] 1为x0
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        #标签        
        labelMat.append(int(lineArr[2]))
    return dataMat,labelMat

def sigmoid(inX):
    #激活函数
    return 1.0/(1+exp(-inX))

#梯度下降法
def gradAscent(dataMatIn, classLabels):
    #转换为mat类型
    dataMatrix = mat(dataMatIn)             
    labelMat = mat(classLabels).transpose() 
    #m行，n列
    m,n = shape(dataMatrix)
    #步长
    alpha = 0.001
    #最大迭代次数
    maxCycles = 500
    #回归系数(列向量）
    weights = ones((n,1))
    for k in range(maxCycles):
        #计算整个数据集乘以回归系数后，经过sigmod函数计算的值(列向量)
        h = sigmoid(dataMatrix*weights)
        #计算整个数据集预测分类的误差(列向量)
        error = (h-labelMat) 
        #梯度下降w=w-步长*梯度（也就是找到h的最小值，最小值减去一个值，从而让error最小）
        weights = weights -alpha * dataMatrix.transpose()* error 
        #梯度上升（也就是找到h的最大值，减去最大的值，从而让error最小）
        #error=（labelMat-h）
        #weights = weights +alpha * dataMatrix.transpose()* error
    return weights

这里是计算真实类别和预测类别的差值，按照差值的方向调整回归系数。

画出决策边界

考虑sigmod(x)，当函数sigmod的输入即（w0x0+xw1+yw2）为0时，是两个类别的决策边界。下面代码画出分割线，便于理解。

def plotBestFit(wei):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr = array(dataMat)
    #行数，样本数
    n = shape(dataArr)[0] 
    xcord1 = []; ycord1 = []
    xcord2 = []; ycord2 = []
    for i in range(n):
        #类别1
        if int(labelMat[i])== 1:
            xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
        #类别0
        else:
            xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
    #创建画布
    fig = plt.figure()
    ax = fig.add_subplot(111)
    #两类数据点样式
    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    ax.scatter(xcord2, ycord2, s=30, c='green')
    x = arange(-3.0, 3.0, 0.1)
    #sigmod(x)中的 x等于0时是两类的分界线 x0w0+xw1+yw2=0
    y = (-weights[0]-weights[1]*x)/weights[2]
    #转置
    y=y.transpose()
    ax.plot(x, y)
    plt.xlabel('X1'); plt.ylabel('X2');
    plt.show()

训练方法：随机梯度下降

之前的梯度下降方法，每次更新回归系数时需要遍历整个数据集，如果处理大量（千万、亿）条数据时，每个数据点包含上百个特征时，该方法的计算复杂度太高。一种改进方法：一次仅用一个样本点来更新回归系数，该方法称为随机梯度下降法。

采用这种方法可以在新的样本点到来时对分类器进行增量式更新，因此随机梯度下降法是一个在线学习算法。与在线学习相对应的，一次处理所有数据称为批处理

随机梯度下降算法伪码

初始化回归系数
对数据集中每一个样本
    计算该样本的梯度
    alpha*gradient更新回归系数
返回回归系数

随机梯度下降法

def stocGradAscent0(dataMatrix, classLabels):
    dataMatrix=array(dataMatrix)
    #行（样本数），列（特征数）
    m,n = shape(dataMatrix)
    #步长
    alpha = 0.01
    weights = ones(n)   #initialize to all ones
    #每一个样本
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))
        error =  h-classLabels[i]
        #梯度下降（求最小h，使得error最小）
        weights = weights - alpha * error * dataMatrix[i]
    return weights

上述代码相当于在整个数据集上运行一次，我们可以改进该算法，使得在整个数据集上迭代150次，另外固定的步长可能导致回归系数收敛时来回波动（这个问题可以理解为，回归系数因为步长过大，在收敛值左右跳动），因此需要随着训练次数的增长，适当减少步长。

改进的随机梯度下降算法

#改进的梯度下降算法
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    dataMatrix=array(dataMatrix)
    #行、列
    m,n = shape(dataMatrix)
    #初始化回归系数
    weights = ones(n)   #initialize to all ones
    #在整个数据集上迭代numIter次
    for j in range(numIter):
        dataIndex = range(m)
        for i in range(m):
            #调整alpha值
            alpha = 4/(1.0+j+i)+0.0001
            #随机选取样本点
            randIndex = int(random.uniform(0,len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error =  h-classLabels[randIndex]
            #梯度下降
            weights = weights -alpha * error * dataMatrix[randIndex]
            #删除该样本点索引
            del(dataIndex[randIndex])
    return weights

总结

Logistic回归的目标就是寻找非线性函数Sigmod的最佳拟合参数，这个求解过程可以用最优化算法完成。梯度下降（上升）法较为常用，随机梯度下降算法比梯度下降算法占用的资源更少，且是一个在线算法，可以在新数据到来时进行更新，而不需要读取整个数据集进行批处理运算。

testSet.txt(训练数据)

-0.017612	14.053064	0
-1.395634	4.662541	1
-0.752157	6.538620	0
-1.322371	7.152853	0
0.423363	11.054677	0
0.406704	7.067335	1
0.667394	12.741452	0
-2.460150	6.866805	1
0.569411	9.548755	0
-0.026632	10.427743	0
0.850433	6.920334	1
1.347183	13.175500	0
1.176813	3.167020	1
-1.781871	9.097953	0
-0.566606	5.749003	1
0.931635	1.589505	1
-0.024205	6.151823	1
-0.036453	2.690988	1
-0.196949	0.444165	1
1.014459	5.754399	1
1.985298	3.230619	1
-1.693453	-0.557540	1
-0.576525	11.778922	0
-0.346811	-1.678730	1
-2.124484	2.672471	1
1.217916	9.597015	0
-0.733928	9.098687	0
-3.642001	-1.618087	1
0.315985	3.523953	1
1.416614	9.619232	0
-0.386323	3.989286	1
0.556921	8.294984	1
1.224863	11.587360	0
-1.347803	-2.406051	1
1.196604	4.951851	1
0.275221	9.543647	0
0.470575	9.332488	0
-1.889567	9.542662	0
-1.527893	12.150579	0
-1.185247	11.309318	0
-0.445678	3.297303	1
1.042222	6.105155	1
-0.618787	10.320986	0
1.152083	0.548467	1
0.828534	2.676045	1
-1.237728	10.549033	0
-0.683565	-2.166125	1
0.229456	5.921938	1
-0.959885	11.555336	0
0.492911	10.993324	0
0.184992	8.721488	0
-0.355715	10.325976	0
-0.397822	8.058397	0
0.824839	13.730343	0
1.507278	5.027866	1
0.099671	6.835839	1
-0.344008	10.717485	0
1.785928	7.718645	1
-0.918801	11.560217	0
-0.364009	4.747300	1
-0.841722	4.119083	1
0.490426	1.960539	1
-0.007194	9.075792	0
0.356107	12.447863	0
0.342578	12.281162	0
-0.810823	-1.466018	1
2.530777	6.476801	1
1.296683	11.607559	0
0.475487	12.040035	0
-0.783277	11.009725	0
0.074798	11.023650	0
-1.337472	0.468339	1
-0.102781	13.763651	0
-0.147324	2.874846	1
0.518389	9.887035	0
1.015399	7.571882	0
-1.658086	-0.027255	1
1.319944	2.171228	1
2.056216	5.019981	1
-0.851633	4.375691	1
-1.510047	6.061992	0
-1.076637	-3.181888	1
1.821096	10.283990	0
3.010150	8.401766	1
-1.099458	1.688274	1
-0.834872	-1.733869	1
-0.846637	3.849075	1
1.400102	12.628781	0
1.752842	5.468166	1
0.078557	0.059736	1
0.089392	-0.715300	1
1.825662	12.693808	0
0.197445	9.744638	0
0.126117	0.922311	1
-0.679797	1.220530	1
0.677983	2.556666	1
0.761349	10.693862	0
-2.168791	0.143632	1
1.388610	9.341997	0
0.317029	14.739025	0