【机器学习实战】4 Logistic回归

最新推荐文章于 2024-08-05 17:04:33 发布

Aoife艺馨

最新推荐文章于 2024-08-05 17:04:33 发布

阅读量177

点赞数

文章标签：逻辑回归 python

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/sinat_34626178/article/details/127664743

版权

5 Logistic回归

本章内容：

Sigmoid函数和Logistic回归分类器

最优化理论初步

梯度下降最优化算法

数据中的缺失项处理

本章目的利用最优化算法，并利用它们训练出一个非线性函数用于分类

Logistic回归的一般过程：

收集数据：采用任意方法收集数据

准备数据：由于需要进行距离计算，因此要求数据类型为数值另外，结构化数据格式最佳

分析数据：采用任意方法对数据进行分析

训练算法：大部分时间用于训练，训练的目的是为了找到最佳的分类回归系数

测试算法：一旦训练步骤完成，分类将会很快

使用算法：首先，我们需要输入一些数据，并将其转换为成对应的结构化数值

接着基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定他们属于哪个类别，在这之后，我们就可以做一些其他分析操作

基本的梯度上升法和一个改进的随机梯度上升法，最有话算法将用于分类器的训练预计病马是否能被治愈

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

优点：计算代价不高，便于理解和实现。

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

适用数据类型：数值型和标称型数据

能接受所有的输入然后预测出类别

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

梯度上升法：

要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻

梯度上升算法意味着到达每个点都会重新估计移动的方向，迭代的过程中，梯度算子总是能保证我们能选取到最佳的移动方向

在这里插入图片描述

在这里插入图片描述

代码实现：

# coding:UTF-8
from numpy import *


def loadDataSet():
    """
    便利函数loadDataSet（）
    打开文本文件testSet.txt并逐行读取每行前两个值 分别是X1和X2 第三个值是数据对应的类别标签。
    为了方便计算 该函数将X0的值设置为1。0
    :return:dataMat:数据中第一列1。0 第二列 testSet 0 第三列 test 1
    labelMat：testSet 第2列
    """
    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):
    """
    数学函数 返回被映射的函数
    :param inX:
    :return:
    """

    return 1.0 / (1 + exp(-inX))


def gradAscent(dataMatIn, classLabels):
    """
    :param dataMatIn: 2维NumPy数组，每列分别代表每个不同的特征，每行代表每个训练样本，现在采用的是100个样本的简单数据集
    包含两个特征值X1 X2 X0 dataMathIn存放的100 * 3的矩阵
    alpha 是向目标移动的步长，maxCycles 是迭代次数 for循环迭代完成后，将返回训练好的回归系数
    dataMatrix * weights 事实上完成了300次的运算
    :param classLabels:
    :return:
    """
    dataMatrix = mat(dataMatIn)  # 转换成矩阵
    labelMat = mat(classLabels).transpose()  # 将１＊ｍ的ｌａｂｅｌ转换成ｍ＊１ 将一行变成1列
    m, n = shape(dataMatrix)  # 获取矩阵的行和列 100 * 3
    alpha = 0.001
    maxCycles = 500  # 迭代次数
    weights = ones((n, 1))  # weight是3行一列的单位1矩阵
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)
        error = (labelMat - h)
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights


def main():
    dataArr, labelMat = loadDataSet()
    print(gradAscent(dataArr, labelMat))


if __name__ == '__main__':
    main()

实现截图：

5.2.3 画出决策边界

画出数据集以及Logistic回归最佳拟合直线的函数

代码实现

def plotBestFit(wei):
    """
    使用Matplotlib画出来的 设置了sigmoid函数为0
    sigmoid函数为0
    :param wei:
    :return:
    """
    weights = wei.getA()
    dataMat, labelMat = loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[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])
        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)
    y = (-weights[0] - weights[1] * x) / weights[2]
    ax.plot(x, y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()


def main():
    matplotlib.use('TkAgg')
    dataArr, labelMat = loadDataSet()
    weights = gradAscent(dataArr, labelMat)
    print(weights.dtype)
    plotBestFit(weights)

实现截图：

在这里插入图片描述

这个分类结果相当不错梯度上升算法在500次迭代得到的回归最佳拟合路线

5.3 随机梯度上升

梯度上升算法在每次更新回归系数都需要便利整个数据集，该方法处理100个数据集尚可，但如果数据集太大的话计算复杂度就太高了，一种改进的方法是一次金庸一个样本点来回归更新系数，随机梯度上升算法，由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。一次处理所有数据可以称作为“批处理”

随机梯度上升算法与梯度上升算大在代码上很相似，但是也有一些区别，h 和 error都是向量前者全是数值第二前者没有矩阵的转换过程，所有的都是NumPy数组

def stocGradAscent0(dataMatrix, classLabels):
    """
    随机梯度上升算法
    :param dataMatrix:
    :param classLabels:
    :return:
    """
    m, n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)  # 3
    for i in range(m):  # 100
        h = sigmoid(sum(dataMatrix[i] * weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights

def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m, n = shape(dataMatrix)
    weights = ones(n)
    for j in range(numIter):
        dataIndex = range(m)
        for i in range(m):
            alpha = 4 / (1.0 + j + i) + 0.01
            randIndex = int(random.uniform(0, len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex] * weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            numpy.delete(dataMatrix, randIndex, 0)
            # del (dataMatrix[randIndex])
        return weights

实现截图：

实现代码

def main():
    matplotlib.use('TkAgg')
    dataArr, labelMat = loadDataSet()
    # weights = gradAscent(dataArr, labelMat)
    # print('weights:', weights)
    # plotBestFit(weights)
    # weights = stocGradAscent0(array(dataArr), labelMat)
    # plotBestFit(mat(weights).transpose())
    weights = stocGradAscent1(array(dataArr), labelMat, 500)
    print(mat(weights).transpose())
    plotBestFit(mat(weights).transpose())

实现截图：

使用随机梯度上升算大来解决病马的生死预测问题

5.3 从疝气病症预测病马的死亡率

# coding:UTF-8
import matplotlib
import numpy
from numpy import *
import matplotlib.pyplot as plt


def loadDataSet():
    """
    便利函数loadDataSet（）
    打开文本文件testSet.txt并逐行读取每行前两个值 分别是X1和X2 第三个值是数据对应的类别标签。
    为了方便计算 该函数将X0的值设置为1。0
    :return:dataMat:数据中第一列1。0 第二列 testSet 0 第三列 test 1
    labelMat：testSet 第2列
    """
    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):
    """
    数学函数 返回被映射的函数
    :param inX:
    :return:
    """

    return 1.0 / (1 + exp(-inX))


def gradAscent(dataMatIn, classLabels):
    """
    :param dataMatIn: 2维NumPy数组，每列分别代表每个不同的特征，每行代表每个训练样本，现在采用的是100个样本的简单数据集
    包含两个特征值X1 X2 X0 dataMathIn存放的100 * 3的矩阵
    alpha 是向目标移动的步长，maxCycles 是迭代次数 for循环迭代完成后，将返回训练好的回归系数
    dataMatrix * weights 事实上完成了300次的运算
    :param classLabels:
    :return:
    """
    dataMatrix = mat(dataMatIn)  # 转换成矩阵
    labelMat = mat(classLabels).transpose()  # 将１＊ｍ的ｌａｂｅｌ转换成ｍ＊１ 将一行变成1列
    m, n = shape(dataMatrix)  # 获取矩阵的行和列 100 * 3
    alpha = 0.001
    maxCycles = 500  # 迭代次数
    weights = ones((n, 1))  # weight是3行一列的单位1矩阵
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)
        error = (labelMat - h)
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights


def plotBestFit(wei):
    """
    使用Matplotlib画出来的 设置了sigmoid函数为0
    sigmoid函数为0
    该算法例子简单且数据集很小，但是这个方法却需要大量的计算（300次）
    :param wei:
    :return:
    """
    weights = wei.getA()
    dataMat, labelMat = loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[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])
        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)  # 从-3。0到3。0 以0。1的方式增加
    y = (-weights[0] - weights[1] * x) / weights[2]
    ax.plot(x, y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()


def stocGradAscent0(dataMatrix, classLabels):
    """
    随机梯度上升算法
    :param dataMatrix:
    :param classLabels:
    :return:
    """
    m, n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)  # 3
    for i in range(m):  # 100
        h = sigmoid(sum(dataMatrix[i] * weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights


def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m, n = shape(dataMatrix)
    weights = ones(n)
    for j in range(numIter):
        dataIndex = range(m)
        for i in range(m):
            alpha = 4 / (1.0 + j + i) + 0.01
            randIndex = int(random.uniform(0, len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex] * weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            numpy.delete(dataMatrix, randIndex, 0)
            # del (dataMatrix[randIndex])
        return weights


def classifyVector(inX, weights):
    prob = sigmoid(sum(inX * weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0


def colicTest():
    """
    打开测试机和训练集 并对数据进行数据进行格式化处理的函数，该函数首先导入训练集，同前面一样数据的最后一列仍然是类别标签，数据最初有三个类别标签
    分别代表马的三种情况：存活 已经死亡 安利死 为了方便 死亡和安利死合并成未能存活，数据导入之后
    便可以使用stocGragAscent1来计算回归系数向量。
    :return:
    """
    frTrain = open(r'horseColicTraining.txt', encoding='ISO-8859-1')
    frTest = open(r'horseColicTest.txt', encoding='ISO-8859-1')
    trainingSet = [];
    trainingLabels = []
    for line in frTrain.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500)
    errorCount = 0;
    numTestVec = 0.0
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):
            errorCount += 1
    errorRate = (float(errorCount) / numTestVec)
    print("这次结果的测试错误率是 ： %f" % errorRate)
    return errorRate


def multiTest():
    numTests = 10;
    errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    print("在第 %d 迭代之后平均错误率是： %f" % (numTests, errorSum / float(numTests)))


def main():
    matplotlib.use('TkAgg')
    dataArr, labelMat = loadDataSet()
    # weights = gradAscent(dataArr, labelMat)
    # print('weights:', weights)
    # plotBestFit(weights)
    # weights = stocGradAscent0(array(dataArr), labelMat)
    # plotBestFit(mat(weights).transpose())
    # weights = stocGradAscent1(array(dataArr), labelMat, 500)
    # print(mat(weights).transpose())
    # plotBestFit(mat(weights).transpose())
    multiTest()


if __name__ == '__main__':
    main()

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

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

实现截图：

逻辑回归的定义：

逻辑回归主要解决二分类问题，用来表示某件事情发生的可能性

逻辑回归的优点：

实现简单，广泛的应用于工业问题上

计算量小，速度很快，存储资源低

便利的观测样本概率分数

对逻辑回归而言，多重共线性并不是问题，它可以结合L2正则化来解决该问题

计算代价不高，易于理解和实现

缺点：

当特征空间很大时，逻辑回归性能不是很好

容易欠拟合，一般准确度不太高

不能很好的处理大量多类特征或变量

只能处理两分类 softmax可以用于多分类且必须线性可分

对于非线性特征，需要进行转换

要求特征：

线性回归只能用于回归问题，逻辑回归虽然名字叫回归，但是更多用于分类问题，逻辑回归要求离散的变量

线性回归要求自变量和因变量之间的关系，逻辑回归则无法表达变量之间的关系

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【机器学习实战】4 Logistic回归

【小胡冲冲冲】逻辑回归主要解决二分类问题，用来表示某件事情发生的可能性。
复制链接

扫一扫

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。