机器学习实战（四）：逻辑回归

最新推荐文章于 2024-09-23 10:39:18 发布
最新推荐文章于 2024-09-23 10:39:18 发布
阅读量1.6k 收藏 15
点赞数 1
分类专栏： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mys_mys/article/details/87196310
版权

一、概述

1、Logistic回归
假设现在有一些数据点，我们利用一条直线对这些点进行拟合(该线称为最佳拟合直线)，这个拟合过程就称作为回归
在这里插入图片描述
Logistic回归是分类方法，利用的是Sigmoid函数阈值在[0,1]这个特性。Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。
2、sigmoid函数
在这里插入图片描述
在这里插入图片描述
如果我们有合适的参数列向量θ([θ0,θ1,…θn]^T)，以及样本列向量x([x0,x1,…,xn])，那么我们对样本x分类就可以通过上述公式计算出一个概率，如果这个概率大于0.5，我们就可以说样本是正样本，否则样本是负样本。

举个例子，对于"垃圾邮件判别问题"，对于给定的邮件(样本)，我们定义非垃圾邮件为正类，垃圾邮件为负类。我们通过计算出的概率值即可判定邮件是否是垃圾邮件。
3、如何得到合适的参数向量θ?
根据sigmoid函数的特性：在这里插入图片描述
在已知样本x和参数θ的情况下，样本x属性正样本(y=1)和负样本(y=0)的条件概率
把上述两个概率公式合二为一：在这里插入图片描述
这个函数称为代价函数，给定一个样本，我们就可以通过这个代价函数求出，样本所属类别的概率，而这个概率越大越好，所以也就是求解这个代价函数的最大值。利用最大似然估计假定样本与样本之间相互独立，那么整个样本集生成的概率即为所有样本生成概率的乘积，再将公式对数化：在这里插入图片描述
m为样本的总数，y(i)表示第i个样本的类别，x(i)表示第i个样本，需要注意的是θ是多维向量，x(i)也是多维向量。
满足J(θ)的最大的θ值即是我们需要求解的模型
求最大值=>使用梯度上升算法
4、梯度上升算法
梯度上升迭代公式为：在这里插入图片描述
推导过程：在这里插入图片描述
4、Logistic回归的一般过程

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

二、实战案例

1、数据准备
在这里插入图片描述
编写代码查看数据分布情况：
在这里插入图片描述
假设Sigmoid函数的输入记为z，那么z=w0x0 + w1x1 + w2x2，即可将数据分割开。其中，x0为全是1的向量，x1为数据集的第一列数据，x2为数据集的第二列数据。另z=0，则0=w0 + w1x1 + w2x2。横坐标为x1，纵坐标为x2。这个方程未知的参数为w0，w1，w2，也就是我们需要求的回归系数(最优参数)。
2、训练算法
在这里插入图片描述
编写代码求解最优参数：w0 w1 w2
在这里插入图片描述
3、绘制决策边界
在这里插入图片描述
Logistic回归的目的是寻找一个非线性函数Sigmoid的最佳拟合参数，求解过程可以由最优化算法完成。
4、改进梯度上升算法
梯度上升算法在每次更新回归系数(最优参数)时，都需要遍历整个数据集，计算复杂度太高，**一次只用一个样本点去更新回归系数(最优参数)**有效减少计算量 随机梯度上升算法
改进之处：
1）调整alpha，alpha会随着迭代次数不断减小，但永远不会减小到0，为了保证在多次迭代之后新数据仍然具有一定的影响。在降低alpha的函数中，alpha每次减少1/(j+i)，其中j是迭代次数，i是样本点的下标。
2）更新回归系数(最优参数)，只使用一个样本点，并且选择的样本点是随机的，每次迭代不使用已经用过的样本点。有效地减少了计算量，并保证了回归效果。
在这里插入图片描述
代码汇总

from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
import numpy as np
import random


"""
函数说明：加载数据
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()
    # 转换成numpy的array数组
    dataArr = np.array(dataMat)
    # 数据个数
    n = np.shape(dataMat)[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()
    # 添加subplot
    ax = fig.add_subplot(111)
    # 绘制正样本
    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')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.show()


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


"""
函数说明：梯度上升算法
Parameters：
            dataMatIn - 数据集
            classLabels - 数据标签
Returns：
        weights.getA() - 求得的权重数组（最优参数）
"""
def gradAscent(dataMatIn, classLabels):
    # 转换成numpy的mat
    dataMatrix = np.mat(dataMatIn)
    # 转换成numpy的mat,并进行转置
    labelMat = np.mat(classLabels).transpose()
    # 返回dataMatrix的大小。m为行数,n为列数。
    m, n = np.shape(dataMatrix)
    # 移动步长,也就是学习速率,控制更新的幅度。
    alpha = 0.001
    # 最大迭代次数
    maxCycles = 500
    weights = np.ones((n,1))
    for k in range(maxCycles):
        # 梯度上升矢量化公式
        # g(X)=h(theta) = theta * X
        h = sigmoid(dataMatrix * weights)
        error = labelMat - h
        # theta = theta + alpha * X^T(y - g(X))
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights.getA()


"""
函数说明：绘制数据集
Parameters：
            weights - 权重参数数组
"""
def plotBestFit(weights):
    # 加载数据集
    dataMat, labelMat = loadDataSet()
    # 转换成numpy的array数组
    dataArr = np.array(dataMat)
    # 数据个数
    n = np.shape(dataMat)[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()
    # 添加subplot
    ax = fig.add_subplot(111)
    # 绘制正样本
    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')
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()


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


"""
函数说明:绘制回归系数与迭代次数的关系
Parameters:
    weights_array1 - 回归系数数组1
    weights_array2 - 回归系数数组2
"""
def plotWeights(weights_array1, weights_array2):
    # 设置汉字格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
    # 将fig画布分隔成1行1列,不共享x轴和y轴,fig画布的大小为(13,8)
    # 当nrow=3,nclos=2时,代表fig画布被分为六个区域,axs[0][0]表示第一行第一列
    fig, axs = plt.subplots(nrows=3, ncols=2, sharex=False, sharey=False, figsize=(20, 10))
    x1 = np.arange(0, len(weights_array1), 1)
    # 绘制w0与迭代次数的关系
    axs[0][0].plot(x1, weights_array1[:, 0])
    axs0_title_text = axs[0][0].set_title(u'梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
    axs0_ylabel_text = axs[0][0].set_ylabel(u'W0', FontProperties=font)
    plt.setp(axs0_title_text, size=20, weight='bold', color='black')
    plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w1与迭代次数的关系
    axs[1][0].plot(x1, weights_array1[:, 1])
    axs1_ylabel_text = axs[1][0].set_ylabel(u'W1', FontProperties=font)
    plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w2与迭代次数的关系
    axs[2][0].plot(x1, weights_array1[:, 2])
    axs2_xlabel_text = axs[2][0].set_xlabel(u'迭代次数', FontProperties=font)
    axs2_ylabel_text = axs[2][0].set_ylabel(u'W2', FontProperties=font)
    plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
    plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')

    x2 = np.arange(0, len(weights_array2), 1)
    # 绘制w0与迭代次数的关系
    axs[0][1].plot(x2, weights_array2[:, 0])
    axs0_title_text = axs[0][1].set_title(u'改进的随机梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
    axs0_ylabel_text = axs[0][1].set_ylabel(u'W0', FontProperties=font)
    plt.setp(axs0_title_text, size=20, weight='bold', color='black')
    plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w1与迭代次数的关系
    axs[1][1].plot(x2, weights_array2[:, 1])
    axs1_ylabel_text = axs[1][1].set_ylabel(u'W1', FontProperties=font)
    plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w2与迭代次数的关系
    axs[2][1].plot(x2, weights_array2[:, 2])
    axs2_xlabel_text = axs[2][1].set_xlabel(u'迭代次数', FontProperties=font)
    axs2_ylabel_text = axs[2][1].set_ylabel(u'W1', FontProperties=font)
    plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
    plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')

    plt.show()


if __name__ == '__main__':
    # 1.绘制数据集
    # plotDataSet()

    # 2.求最优参数
    # dataMat, labelMat = loadDataSet()
    # print(gradAscent(dataMat, labelMat))

    # 3.绘制决策边界
    # dataMat, labelMat = loadDataSet()
    # weights = gradAscent(dataMat, labelMat)
    # plotBestFit(weights)

    # 4.改进：随机梯度下降法
    dataMat, labelMat = loadDataSet()
    weights = stocGradAscent1(np.array(dataMat), labelMat)
    plotBestFit(weights)

5、回归系数与迭代次数的关系
编写程序，绘制出回归系数和迭代次数的关系曲线：

代码

from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
import numpy as np
import random


"""
函数说明：加载数据
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


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


"""
函数说明：梯度上升算法
Parameters：
            dataMatIn - 数据集
            classLabels - 数据标签
Returns：
        weights.getA() - 求得的权重数组（最优参数）
"""
def gradAscent(dataMatIn, classLabels):
    # 转换成numpy的mat
    dataMatrix = np.mat(dataMatIn)
    # 转换成numpy的mat,并进行转置
    labelMat = np.mat(classLabels).transpose()
    # 返回dataMatrix的大小。m为行数,n为列数。
    m, n = np.shape(dataMatrix)
    # 移动步长,也就是学习速率,控制更新的幅度。
    alpha = 0.01
    # 最大迭代次数
    maxCycles = 500
    weights = np.ones((n, 1))
    weights_array = np.array([])
    for k in range(maxCycles):
        # 梯度上升矢量化公式
        h = sigmoid(dataMatrix * weights)
        error = labelMat - h
        # theta = theta + alpha*X^T(y - g(X))
        weights = weights + alpha * dataMatrix.transpose() * error
        weights_array = np.append(weights_array,weights)
    weights_array = weights_array.reshape(maxCycles,n)
    return weights.getA(),weights_array


"""
函数说明：随机梯度上升算法
"""
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    # 返回dataMatrix的大小。m为行数,n为列数。
    m, n = np.shape(dataMatrix)
    # 参数初始化
    weights = np.ones(n)
    # 存储每次更新的回归系数
    weights_array = np.array([])
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            # 降低alpha的大小，每次减小1/(j+i)。
            alpha = 4/(1.0+j+i)+0.01
            # 随机选取样本
            randIndex = int(random.uniform(0, len(dataIndex)))
            # 选择随机选取的一个样本，计算h
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            # 计算误差
            error = classLabels[randIndex] - h
            # 更新回归系数
            weights = weights + alpha * error * dataMatrix[randIndex]
            # 添加回归系数到数组中
            weights_array = np.append(weights_array, weights, axis=0)
            # 删除已经使用的样本
            del(dataIndex[randIndex])
    # 改变维度
    weights_array = weights_array.reshape(numIter*m, n)
    return weights, weights_array


"""
函数说明:绘制回归系数与迭代次数的关系
Parameters:
    weights_array1 - 回归系数数组1
    weights_array2 - 回归系数数组2
"""
def plotWeights(weights_array1, weights_array2):
    # 设置汉字格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
    # 将fig画布分隔成1行1列,不共享x轴和y轴,fig画布的大小为(13,8)
    # 当nrow=3,nclos=2时,代表fig画布被分为六个区域,axs[0][0]表示第一行第一列
    fig, axs = plt.subplots(nrows=3, ncols=2, sharex=False, sharey=False, figsize=(20, 10))
    x1 = np.arange(0, len(weights_array1), 1)
    # 绘制w0与迭代次数的关系
    axs[0][0].plot(x1, weights_array1[:, 0])
    axs0_title_text = axs[0][0].set_title(u'梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
    axs0_ylabel_text = axs[0][0].set_ylabel(u'W0', FontProperties=font)
    plt.setp(axs0_title_text, size=20, weight='bold', color='black')
    plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w1与迭代次数的关系
    axs[1][0].plot(x1, weights_array1[:, 1])
    axs1_ylabel_text = axs[1][0].set_ylabel(u'W1', FontProperties=font)
    plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w2与迭代次数的关系
    axs[2][0].plot(x1, weights_array1[:, 2])
    axs2_xlabel_text = axs[2][0].set_xlabel(u'迭代次数', FontProperties=font)
    axs2_ylabel_text = axs[2][0].set_ylabel(u'W2', FontProperties=font)
    plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
    plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')

    x2 = np.arange(0, len(weights_array2), 1)
    # 绘制w0与迭代次数的关系
    axs[0][1].plot(x2, weights_array2[:, 0])
    axs0_title_text = axs[0][1].set_title(u'改进的随机梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
    axs0_ylabel_text = axs[0][1].set_ylabel(u'W0', FontProperties=font)
    plt.setp(axs0_title_text, size=20, weight='bold', color='black')
    plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w1与迭代次数的关系
    axs[1][1].plot(x2, weights_array2[:, 1])
    axs1_ylabel_text = axs[1][1].set_ylabel(u'W1', FontProperties=font)
    plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
    # 绘制w2与迭代次数的关系
    axs[2][1].plot(x2, weights_array2[:, 2])
    axs2_xlabel_text = axs[2][1].set_xlabel(u'迭代次数', FontProperties=font)
    axs2_ylabel_text = axs[2][1].set_ylabel(u'W1', FontProperties=font)
    plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
    plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')

    plt.show()


if __name__ == '__main__':
    # 5.回归系数与迭代次数的关系
    dataMat, labelMat = loadDataSet()
    weights1, weights_array1 = stocGradAscent1(np.array(dataMat), labelMat, numIter=150)

    weights2, weights_array2 = gradAscent(dataMat, labelMat)
    plotWeights(weights_array1, weights_array2)

在这里插入图片描述
分析：

随机梯度上升算法，随机选取样本点，所以每次的运行结果是不同的。但是大体趋势是一样的。改进的随机梯度上升算法收敛效果更好。一共有100个样本点，改进的随机梯度上升算法迭代次数为150。而上图显示15000次迭代次数的原因是，使用一次样本就更新一下回归系数。因此，迭代150次，相当于更新回归系数150*100=15000次。迭代150次，更新1.5万次回归参数。从上图左侧的改进随机梯度上升算法回归效果中可以看出，其实在更新2000次回归系数的时候，已经收敛了。**相当于遍历整个数据集20次的时候，回归系数已收敛。**训练已完成。

梯度上升算法每次更新回归系数都要遍历整个数据集。从图中可以看出，当迭代次数为300多次的时候，回归系数才收敛。

qmys
关注
专栏目录
3、逻辑回归代码案例及数据.zip
05-21
这个资源是逻辑回归案例中对应的数据和代码，原文可以看我的博客内容介绍，建议结合原文查看： 逻辑回归虽然叫回归，但它解决的是分类问题，之所以叫回归是有一些历史原因，不过怎么叫没关系。在分类问题中，逻辑回归算法是一种用的比较广泛的机器学习算法。
机器学习：Logistic回归
qq_51667621的博客
11-21 1346
目录一、基于Logistic回归和Sigmoid函数的分类1.1 Logistic回归的一般过程1.2 Sigmoid函数二、基于优化方法的最佳回归系数确定2.1 梯度上升算法2.2 梯度下降算法2.3 使用梯度上升找到最佳参数2.4 分析数据画出决策边界三、训练算法：随机梯度上升算法3.1 随机梯度上升算法3.2 随机梯度上升算法改进四、从疝气病症预测病马的死亡率4.1 准备数据：处理数据中的缺失值4.2 测试算法：用Logistic回归进行分类4.3 小结 一、基于Logistic回归和Sigmoid函
【逻辑回归+实战】
最新发布
qq_43094272的博客
09-23 911
原文：https://blog.csdn.net/didiaopao/article/details/126483343。
机器学习第五章笔记——logistic回归(逻辑回归)
jgq1466693的博客
10-03 1126
这个章节中将首次接触到最优化算法，假设目前存在一些数据点，用一条之间对这些点进行拟合，这个拟合过程就被称为回归。利用Logistic回归进行分类的主要思想就是：根据现有数据对分类边界线建立回归公式，以此进行分类。回归一词源于最佳拟合，即要找到最佳拟合参数集。训练分类器时的做法其实就是在寻找最佳拟合参数，使用的就是最优化算法。二值型输出分类器的数学原理。Logistic回归的一般过程1、收集数据：采用任意方法收集数据2、准备数据：由于需要计算距离，所以就要求数据类型为数值型，结构化数据格式则最佳。
机器学习——Logistic回归
hshagahhva的博客
11-21 1007
一：Logistic回归简介 Logistic回归是统计学习中的经典分类方法，属于对数线性模型，所以也被称为对数几率回归。该模型是一种分类算法，Logistic回归是一种线性分类器，针对的是线性可分问题。我们要了解Logistic回归进行分类的主要思想是：根据现有的数据对分类边界线建立回归方程，然后以此进行分类。这里回归一词源于最佳拟合参数，表示要找到最佳拟合参数集。 Logistic回归的优点在于计算代价不高，易于理解和实现。缺点是容易发生欠拟合现象，分类的精度不高。适...
基于Logistic回归和Sigmoid函数的分类【机器学习】
shentanyue的博客
07-24 1万+
（一）认识Logistic回归（LR）分类器 首先，Logistic回归虽然名字里带“回归”，但是它实际上是一种分类方法，主要用于两分类问题，利用Logistic函数（或称为Sigmoid函数），自变量取值范围为(-INF, INF)，自变量的取值范围为(0,1)，函数形式为： 由于sigmoid函数的定义域是(-INF, +INF),而值域为(0, 1)。因此最基本的LR分类器适合于对两...
机器学习实战：基于逻辑回归模型的信用卡欺诈检测
12-22
在不需要做额外特征提取工作的情况下，本项目意在通过逻辑回归模型的调优，得到较为准确可靠的反欺诈检测方法，分析过程中使用到了Python Pandas, Numpy, Matplotlib, Seaborn以及机器学习库Scikit-Learn等。...
机器学习案例实战：Python实现逻辑回归与梯度下降策略.zip
04-28
在本压缩包中，我们聚焦于机器学习领域，特别是通过Python语言实现逻辑回归与梯度下降策略。逻辑回归是预测性建模技术，常用于分类问题，尤其适用于二分类问题。它通过构建一个连续的线性函数来逼近离散的目标变量，...
【机器学习】逻辑回归（实战）
酱懵静的博客
01-28 2262
决策边界的绘制步骤如下: ① 构建坐标数据，合理的范围当中，根据实际训练时输入数据来决定（可参考 iris.DESCR） ② 整合坐标点，得到所有测试输入数据坐标点 ③ 预测，得到所有点的概率值 ④ 绘制等高线，完成决策边界
激活函数之logistic sigmoid函数介绍及C++实现
热门推荐
网络资源是无限的
06-28 1万+
激活函数之logistic sigmoid函数介绍及C++实现
【机器学习】Logistic回归
weixin_54365065的博客
12-08 623
机器学习 ——Logisitic回归
机器学习：（5）Logistic回归
qq_45802659的博客
11-18 2512
Logistic回归一、Logistic回归与梯度上升算法1. Logistic回归1.1. 基于Logistic回归和Sigmoid函数的分类1.2. 基于最优化方法的最佳回归系数确定2. 梯度上升算法三级目录 一、Logistic回归与梯度上升算法 1. Logistic回归 logistic回归又称logistic回归分析，是一种广义的线性回归分析模型，常用于数据挖掘，疾病自动诊断，经济预测等领域。例如，探讨引发疾病的危险因素，并根据危险因素预测疾病发生的概率等。 logistic回归的因变量可以
关于logistic、logit、log-odds、sigmoid、softmax、cross entropy
weixin_45783996的博客
03-27 7119
定义 sigmoid 函数：形状像S的函数。 logistic 函数：一种典型的sigmoid 函数，函数如下： logit函数：logistic 函数的反函数，也有logistic unit的意思，类似于probit相对于标准正态分布的分布函数（也是S型的呢）的反函数，即probability unit，就是通过概率找到随机变量的值： 也叫log-odds函数，因为p/(1-p)在统计学中叫做odds，几率、可能性、胜率的意思。 logistic模型（logit模型）：是一种回归模型，回归模型就是指对
机器学习-基于Logistic回归和Sigmoid函数的分类
spritezhong的博客
05-11 5034
Logistic回归 1.先给出Sigmoid函数 由这个函数生成的曲线称为Sigmoid曲线 对于二元分类，符合伯努利分布（the Bernoulli distribution, 又称两点分布，0-1分布），因为二元分类的输出一定是0或1，典型的伯努利实验。所以： 由最大似然函数可知 两边同时取对数： 因为求似然函数的最大值，所以采用梯度上
logistic sigmoid函数是什么，有什么应用场景？
weixin_40551464的博客
01-29 971
尽管 sigmoid 函数在早期的神经网络模型中非常流行，但它有一些缺点，如梯度消失问题，即在极端输入值下梯度接近于零，这会导致神经网络在训练过程中学习速度减慢。因此，无论输入值 x 是多么极端（正无穷或负无穷），Sigmoid 函数的输出始终限制在 0 和 1 之间。由于其输出在 0 和 1 之间，sigmoid 函数被用来估计概率，特别是在需要将模型输出解释为概率的场景中。在神经网络中，尤其是早期的神经网络，sigmoid 函数经常被用作激活函数，用于添加网络的非线性特性。
案例实战：Python实现逻辑回归(Logistic Regression)与梯度下降策略
bigcindy的博客
06-09 8058
0. 案例背景 我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学系的管理员，你想根据两次考试的结果来决定每个申请人的录取机会。你有以前的申请人的历史数据，你可以用它作为逻辑回归的训练集。对于每一个培训例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。 1. 导入pythony库 #导入机器学习三大件：Numpy, Pandas, Matplotlib import numpy as np import pandas
机器学习实战：逻辑回归及其Python实现
"本文介绍了机器学习中的两种重要方法——回归和分类，特别关注了逻辑回归分析在Python中的应用。文中详细阐述了分类与回归的区别与联系，以及常用的分类和回归算法。此外，还深入探讨了逻辑回归的基本原理和作用。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值