机器学习——logistic回归知识准备

我得学习机器咋学习的

于 2022-12-11 18:09:52 发布

阅读量291

点赞数

文章标签：回归人工智能

本文链接：https://blog.csdn.net/blinnnnk/article/details/128258874

版权

logistic回归的一般过程

收集数据：采用任意方法收集数据
准备数据：由于需要距离计算，因此要求距离类型为数值型。另外，结构化数据格式则最佳。
分析数据：采用任意方法对数据进行分析。
训练算法:大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。
测试算法：一旦训练步骤完成，分类将会很快。
使用算法：首先，我们需要输入一些数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。

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

我们想要的函数应该是：能接受所有的输入然后预测出类别。ex.在两个类的情况下，上述函数输出0或1.类似这种性质的函数称为单位阶跃函数。但是，阶跃函数存在的问题是：该函数在跳跃点上从0瞬间跃到1，这个瞬间跳跃过程有时很难处理。因此，我们使用另一个具有类似性质的函数——Sigmoid函数，它在数学上更容易处理。Sigmoid函数的计算公式为： $\sigma \left ( z \right )= \frac{1}{1+e^{-z}}$

如下图所示，给出了Sigmoid函数在不同坐标尺度下的两条曲线图。当x=0时，函数值为0.5。随着x增大，对应的Sigmoid值将逼近于1；而随着x减小，对应的Sigmoid值将逼近于0.

当横坐标为-4到4，曲线比较平滑；如果横坐标刻度足够大，在x=0处Sigmoid函数看起来很像一个阶跃函数。

因此为了实现Logistic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有的结果值相加，这个总和代入Sigmoid函数中去，进而得到一个范围在0~1之间的一个数值。大于0.5的的数据分为1类，小于0.5的分为0类。所以Logistic回归也可以被看成是一种概率估计。

基于最优化方法的最佳回归系数确定

Sigmoid函数的输入记为z，由下面的公式得出：

若采用向量的写法：

表示将这两个数值对应元素相乘然后全部加起来即得到z值。

向量x：分类器的输入数据

向量w：我们要找的最佳参数（系数），从而使分类器尽可能地精确

为了寻找最佳参数，需要用到最优化理论地一些知识。下面是介绍梯度上升这一最优化方法，我们将学习到如何使用该方法求得数据集地最佳参数。

梯度上升法

梯度上升法的基本思想：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。

该公式的含义是：沿x的方向移动 $\frac{\partial f(x,y)}{\partial x}$ ,沿y的方向移动 $\frac{\partial f(x,y)}{\partial y}$ .

ps:梯度上升算法到达每个点后都会重新估计移动的方向。从 $p_{0}$ 开始，计算完该点的梯度，函数就根据梯度移动到下一点 $p_{1}$ .在 $p_{1}$ ，梯度再次被重新计算，并沿新的梯度方向移动到 $p_{2}$ .如此循环迭代，直到满足停止条件。迭代的过程中，梯度算子总是保证我们能选取到最佳的移动方向。

在上图中可以看到，梯度算子总是指向函数值增长最快的方向。这里说的是移动方向，而未提到移动量的大小。该量值称为步长，记作 $\alpha$ 。用向量表示的话，该梯度算法的迭代公式为：

梯度下降算法：

我们最经常听到的是梯度下降算法，与梯度上升算法一样，只需要将+换成-就可以了。

梯度上升算法用来求函数最大值，而梯度下降算法用来求函数的最小值。

导入一个数据集

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

Logistic 回归梯度上升优化算法

先加载数据

import matplotlib.pyplot as plt
import numpy as np

"""
Parameters:
    无
Returns:
    dataMat - 数据列表
    labelMat - 标签列表
"""
# 函数说明:加载数据
def loadDataSet():
    dataMat = []                                                        #创建数据列表
    labelMat = []                                                       #创建标签列表
    fr = open('testSet.txt')                                            #打开文件
    for line in fr.readlines():                                         #逐行读取
        lineArr = line.strip().split()                                  #去回车，放入列表
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])     #添加数据
        labelMat.append(int(lineArr[2]))                                #添加标签
    fr.close()                                                          #关闭文件
    return dataMat, labelMat                                            #返回

# 函数说明:绘制数据集
def plotDataSet():
    dataMat, labelMat = loadDataSet()                                   #加载数据集
    dataArr = np.array(dataMat)                                         #转换成numpy的array数组
    n = np.shape(dataMat)[0]                                            #数据个数
    xcord1 = []; ycord1 = []                                            #正样本
    xcord2 = []; ycord2 = []                                            #负样本
    for i in range(n):                                                  #根据数据集标签进行分类
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])    #1为正样本
        else:
            xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])    #0为负样本
    fig = plt.figure()
    ax = fig.add_subplot(111)                                           #添加subplot
    ax.scatter(xcord1, ycord1, s = 20, c = 'red', marker = 's',alpha=.5)#绘制正样本
    ax.scatter(xcord2, ycord2, s = 20, c = 'green',alpha=.5)            #绘制负样本
    plt.title('DataSet')                                                #绘制title
    plt.xlabel('x'); plt.ylabel('y')                                    #绘制label
    plt.show()                                                          #显示


if __name__ == '__main__':
    plotDataSet()

显示数据集分布：

2. 梯度上升算法：


import numpy as np

def loadDataset():#功能为打开文本文件testSet.txt并逐行读取
    # 每行前两个值分别是X1和X2,第三个值是数据对应的类别标签，为了方便计算，设X0=1.0
    dataMat=[]
    labelMat=[]
    fr =open('testSet.txt')
    for line in fr.readlines():
        lineArr=line.strip().split()
        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+np.exp(-inX))


def gradAscent(dataMatIn,classLabels):
    # dataMatIn每列代表不同的特征，每行则代表每个训练样本，我们采用的是100个样本的简单数据集；dataMatIn理放的是100*3的矩阵；第二个参数是类别标签
    dataMatrix=np.mat(dataMatIn)
    labelMat=np.mat(classLabels).transpose()#transpose是啥意思
    m,n=np.shape(dataMatrix)
    alpha=0.001#向目标移动的步长
    maxCycles=500#迭代的次数
    weights=np.ones((n,1))
    for k in range (maxCycles):
        h=Sigmoid(dataMatrix*weights)
        error=(labelMat-h)
        weights=weights+alpha*dataMatrix.transpose()*error
    return weights
    #for循环迭代完成后，返回训练好的回归系数
#梯度上升算法

if __name__=='__main__':
    dataMat,labelMat=loadDataSet()
    print(gradAscent(dataMat,labelMat))

运算结果：（返回回归系数）

分析数据：画出决策边界：

#分析数据/；画出决策边界
def plotBestFit(weights):
    dataMat, labelMat = loadDataSet()                                   #加载数据集
    dataArr = np.array(dataMat)                                         #转换成numpy的array数组
    n = np.shape(dataMat)[0]                                            #数据个数
    xcord1 = []; ycord1 = []                                            #正样本
    xcord2 = []; ycord2 = []                                            #负样本
    for i in range(n):                                                  #根据数据集标签进行分类
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])    #1为正样本
        else:
            xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])    #0为负样本
    fig = plt.figure()
    ax = fig.add_subplot(111)                                           #添加subplot
    ax.scatter(xcord1, ycord1, s = 20, c = 'red', marker = 's',alpha=.5)#绘制正样本
    ax.scatter(xcord2, ycord2, s = 20, c = 'green',alpha=.5)            #绘制负样本
    x = np.arange(-3.0, 3.0, 0.1)
    y = (-weights[0] - weights[1] * x) / weights[2]
    ax.plot(x, y)
    plt.title('BestFit')                                                #绘制title
    plt.xlabel('X1'); plt.ylabel('X2')                                  #绘制label
    plt.show()       


    
if __name__=='__main__':
    dataMat,labelMat=loadDataSet()
    print(gradAscent(dataMat,labelMat))
    weights=gradAscent(dataMat,labelMat)
    plotBestFit(weights)

结果：

在上面分析Sigmoid函数中，z是Sigmoid函数的输入，就可以将数据分隔开。x1是全为1的向量，x1是数据集第一列数据，x2是数据集的第二列数据。z=0是两个分类（0和1）的分界处，所以，设定横坐标为x1，纵坐标为x2，这个方程的位置参数是w0,w1,w2,，也就是我们求的回归系数（最优参数），已经求解出的就是回归系数[w0,w1,w2],通过系数就可以确定不同数据之间的分割线，画出决策边界

3.训练算法：随机梯度上升算法

梯度上升算法需要每次都遍历一次数据集，当数据集小的时候可以，但是当数据集很大的时候，机如果是数十亿、数百万的时候，那么该计算方法的计算复杂度就太高了。改进算法：一次仅用一个样本点来更新回归系数，该方法称为随机梯度上升算法。

随机梯度上升算法可以写成如下的伪代码：

所有回归系数初始化为1

对数据集中每个样本

计算该样本的梯度

使用alpha × gradient更新回归系数值

返回回归系数值

代码：

'''
Parameters:
    dataMatrix - 数据数组
    classLabels - 数据标签
    numIter - 迭代次数
Returns:
    weights - 求得的回归系数数组(最优参数)
'''
# 函数说明:改进的随机梯度上升算法
def stocGradAscent1(dataMatrix, classLabels, 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(sum(dataMatrix[randIndex]*weights))          #选择随机选取的一个样本，计算h
            error = classLabels[randIndex] - h                       #计算误差
            weights = weights + alpha * error * dataMatrix[randIndex]#更新回归系数
            del(dataIndex[randIndex])                                #删除已经使用的样本
    return weights

记得要在前面添加import random

运行结果：

改进算法还增加了一个迭代次数作为第三个参数。如果该参数没有给定，算法自动默认迭代150次

4.比较两次算法

判断优化算法的优劣的可靠算法是看它是否收敛，参数是否达到稳定值，观察三个回归系数的变化情况：

由于改进的随机梯度上升算法，随机选取样本点，所以每次的运行结果是不同的。但是大体趋势是一样的。改进的随机梯度上升算法收敛效果更好。为什么这么说呢？

让我们分析一下。一共有100个样本点，改进的随机梯度上升算法迭代次数为150。而上图显示15000次迭代次数的原因是，使用一次样本就更新一下回归系数。因此，迭代150次，相当于更新回归系数150*100=15000次。简而言之，迭代150次，更新1.5万次回归参数。从上图左侧的改进随机梯度上升算法回归效果中可以看出，其实在更新2000次回归系数的时候，已经收敛了。相当于遍历整个数据集20次的时候，回归系数已收敛。训练已完成。

再让我们看看上图右侧的梯度上升算法回归效果，梯度上升算法每次更新回归系数都要遍历整个数据集。从图中可以看出，当迭代次数为300多次的时候，回归系数才收敛。凑个整，就当它在遍历整个数据集300次的时候已经收敛好了。

没有对比就没有伤害，改进的随机梯度上升算法，在遍历数据集的第20次开始收敛。而梯度上升算法，在遍历数据集的第300次才开始收敛。想像一下，大量数据的情况下，谁效果更好呢？不言而喻，但是程序的时间我们也做了对比，没有免费的午餐。

我得学习机器咋学习的

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习——logistic回归知识准备

z=0是两个分类（0和1）的分界处，所以，设定横坐标为x1，纵坐标为x2，这个方程的位置参数是w0,w1,w2,，也就是我们求的回归系数（最优参数），已经求解出的就是回归系数[w0,w1,w2],通过系数就可以确定不同数据之间的分割线，画出决策边界。梯度上升算法需要每次都遍历一次数据集，当数据集小的时候可以，但是当数据集很大的时候，机如果是数十亿、数百万的时候，那么该计算方法的计算复杂度就太高了。由于改进的随机梯度上升算法，随机选取样本点，所以每次的运行结果是不同的。改进的随机梯度上升算法收敛效果更好。
复制链接

扫一扫