机器学习--逻辑回归

最新推荐文章于 2024-05-29 16:42:20 发布

m0_74238225

最新推荐文章于 2024-05-29 16:42:20 发布

阅读量716

点赞数 30

文章标签：机器学习逻辑回归人工智能

本文链接：https://blog.csdn.net/m0_74238225/article/details/139272580

版权

1.收集数据：根据问题需求，采用适当的方法收集数据。

2.准备数据：

3.分析数据：使用统计方法或可视化工具对数据进行分析，了解数据的分布和特征之间的关系。

在机器学习的世界里，逻辑回归（Logistic Regression）是一种非常经典且实用的分类算法。尽管它的名字中包含了“回归”二字，但实际上它主要用于解决分类问题，尤其是二分类问题。接下来，我们将深入解析逻辑回归的原理、二分类与逻辑回归的区别、sigmoid函数、算法原理、求解参数以及梯度下降算法。

一、逻辑回归的原理

逻辑回归的原理是基于线性回归，但是通过引入一个sigmoid函数将线性回归的连续值映射到0和1之间，从而实现对二分类问题的处理。在逻辑回归中，我们假设输出变量y服从伯努利分布，即y只取0和1两个值，并且给定x的条件下，y取1的概率是p，取0的概率是1-p。

二、二分类与逻辑回归的区别

二分类问题是机器学习中的一个重要问题，它要求将数据集划分为两个类别。而逻辑回归是一种用于解决二分类问题的算法。因此，二分类是一个问题类型，而逻辑回归是解决这个问题的一种具体方法。

三、Sigmoid函数

Sigmoid函数是逻辑回归的核心，它将线性回归的连续值映射到0和1之间，从而实现了对二分类问题的处理。Sigmoid函数的数学表达式为：

其中，z是线性回归的预测值。通过Sigmoid函数，我们可以将z转换为概率值p，从而判断样本属于哪个类别。

函数图像：

四、算法原理

逻辑回归的算法原理可以概括为以下几个步骤：

构建线性回归模型，计算预测值z。
使用Sigmoid函数将预测值z转换为概率值p。
根据概率值p判断样本属于哪个类别（通常设定一个阈值，如0.5，大于阈值的判为正类，小于阈值的判为负类）。

五、求解参数

在逻辑回归中，我们需要求解的参数是线性回归的系数（权重）和截距。为了求解这些参数，我们通常采用极大似然估计法。具体来说，就是构造一个似然函数，然后通过最大化似然函数来求解参数。在逻辑回归中，似然函数通常取为对数似然函数，因为对数似然函数更容易求解。

六、梯度上升算法

逻辑回归的梯度上升算法与梯度下降算法在本质上是相似的，但方向相反。梯度下降算法用于最小化损失函数，而梯度上升算法则用于最大化某个函数，如最大似然函数。在逻辑回归的上下文中，我们虽然经常使用梯度下降来最小化损失函数（如交叉熵损失），但为了理解梯度上升的概念，我们可以假设我们要最大化一个与逻辑回归相关的函数，如对数似然函数。

以下是逻辑回归梯度上升算法的基本步骤和解释：

1.定义损失函数（或目标函数）：

在逻辑回归中，我们通常使用对数似然函数作为目标函数，因为它度量了模型参数与训练数据的匹配程度。对数似然函数越大，模型参数越合理。

2.计算梯度：

梯度是函数在某一点上变化最快的方向。在逻辑回归中，我们需要计算对数似然函数关于模型参数（即权重向量和偏置项）的梯度。这可以通过求导来实现。

3.选择初始参数：

在开始梯度上升之前，我们需要为模型参数选择一个初始值。这些初始值可以是随机的，也可以是预先设定的。

4.执行梯度上升：

在梯度上升算法中，我们沿着梯度的方向更新模型参数，以使得对数似然函数值增加。具体地，我们将当前参数值加上梯度的某个比例（即学习率）来得到新的参数值。这个过程不断重复，直到满足某个停止条件（如达到最大迭代次数或梯度值变得非常小）。

5.返回优化后的参数：

当梯度上升算法停止时，我们返回优化后的模型参数。这些参数使得对数似然函数值尽可能大，从而得到了一个较好的逻辑回归模型。

6.代码实现：

# 梯度上升算法
def gradAscent(X, y, alpha=0.01, max_iters=1000):
    m, n = X.shape
    # 添加偏置项（x0 = 1）到X
    X_b = np.hstack((np.ones((m, 1)), X))
    # 初始化权重
    weights = np.zeros((n + 1, 1))
 
    for i in range(max_iters):
        h = sigmoid(np.dot(X_b, weights))
        error = y - h
        gradient = np.dot(X_b.T, error) / m
        weights += alpha * gradient
 
    return weights

代码解释：
函数定义：
gradAscent(X, y, alpha=0.01, max_iters=1000)：定义了一个名为gradAscent的函数，它接受四个参数：特征矩阵X、目标向量y、学习率alpha（默认为0.01）和最大迭代次数max_iters（默认为1000）。
获取数据形状：
m, n = X.shape：获取特征矩阵X的行数（样本数）和列数（特征数）。
添加偏置项：
X_b = np.hstack((np.ones((m, 1)), X))：在X的左侧添加一列全为1的向量，作为偏置项（即x0=1）。现在X_b是一个m×(n+1)的矩阵。
初始化权重：
weights = np.zeros((n + 1, 1))：初始化权重向量weights为一个(n+1)×1的零矩阵，因为我们现在有n个特征和一个偏置项。
梯度上升迭代：
对于max_iters次迭代，执行以下操作：
计算假设函数（在这里假设为逻辑函数）的输出h：h = sigmoid(np.dot(X_b, weights))。这里sigmoid函数没有给出，但通常是一个将线性组合映射到0和1之间的函数。
计算误差error：error = y - h。误差是真实标签y和模型预测h之间的差。
计算梯度gradient：gradient = np.dot(X_b.T, error) / m。梯度是误差与特征矩阵的转置的乘积的平均值。
更新权重weights：weights += alpha * gradient。根据学习率alpha和计算出的梯度来更新权重。
返回权重：
函数返回经过梯度上升迭代更新后的权重向量weights。
注意：虽然这个函数的名字是gradAscent（梯度上升），但在逻辑回归中，我们通常是在最小化损失函数（即负对数似然），所以实际上是沿着负梯度方向移动，这通常被称为梯度下降。但在这个特定的实现中，因为权重是沿着梯度方向增加的（即weights += alpha * gradient），所以名称gradAscent是合适的，只是从逻辑回归的角度来看，这实际上是在执行梯度下降。

七、完整算法实现：

import numpy as np
import matplotlib.pyplot as plt
 
# Sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))
 
# 梯度上升算法（已在问题中给出，这里再次列出以保持完整性）
def gradAscent(X, y, alpha=0.01, max_iters=1000):
    m, n = X.shape
    X_b = np.hstack((np.ones((m, 1)), X))
    weights = np.zeros((n + 1, 1))
    for i in range(max_iters):
        h = sigmoid(np.dot(X_b, weights))
        error = y - h
        gradient = np.dot(X_b.T, error) / m
        weights += alpha * gradient
    return weights
 
# 生成数据
np.random.seed(42)  # 设置随机种子以确保结果可复现
X = np.random.randn(100, 2)  # 生成100个二维数据点
y = (X[:, 0] + X[:, 1] > 0).astype(int)  # 根据x1 + x2 > 0的条件生成标签
y = y.reshape(-1, 1)  # 转换为列向量
 
# 训练模型
weights = gradAscent(X, y, alpha=0.01, max_iters=10000)
 
# 绘制决策边界
def plot_decision_boundary(X, y, weights):
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01))
    # 添加偏置项1到网格数据
    Z = sigmoid(np.dot(np.c_[np.ones((xx.ravel().shape[0], 1)), xx.ravel(), yy.ravel()], weights))
    Z = Z.reshape(xx.shape)
 
    # 阈值化Z以得到0或1的决策边界
    Z = Z.round().astype(int)
 
    # 绘制决策边界和散点图
    plt.contourf(xx, yy, Z, alpha=0.5)
    plt.scatter(X[y.ravel() == 0, 0], X[y.ravel() == 0, 1], color='red', marker='^', label='Class 0')
    plt.scatter(X[y.ravel() == 1, 0], X[y.ravel() == 1, 1], color='blue', marker='o', label='Class 1')
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.legend()
    plt.show()
# 调用绘图函数
plot_decision_boundary(X, y, weights)

代码分析：
导入必要的库:
numpy（通常缩写为np）: 用于数值计算，尤其是处理大型多维数组和矩阵。
matplotlib.pyplot（通常缩写为plt）: 用于绘制图形和可视化。
定义Sigmoid函数:
Sigmoid函数通常用于逻辑回归，因为它可以将任何实数映射到0和1之间，从而可以解释为一个概率。在此代码中，sigmoid函数接受一个数值z作为输入，并返回其Sigmoid值。
定义梯度上升算法:
梯度上升算法是一种优化算法，用于找到函数的最大值。在逻辑回归中，我们使用梯度上升（或更常见的梯度下降，但方向相反）来找到使模型预测最准确的权重。
在此函数中，X是特征矩阵，y是标签向量，alpha是学习率，max_iters是最大迭代次数。
函数首先添加偏置项到X，然后初始化权重为0。
在每次迭代中，它计算预测值h，然后计算误差error，接着计算梯度，并用梯度更新权重。
迭代完成后，返回找到的权重。
生成数据:
使用numpy的随机函数生成100个二维数据点。
根据x1 + x2 > 0的条件为每个数据点生成一个标签（0或1）。
将标签从行向量转换为列向量，以便与特征矩阵的形状匹配。
训练模型:
调用gradAscent函数来训练模型，找到最佳权重。
绘制决策边界:
定义一个函数plot_decision_boundary来绘制决策边界和数据点。
首先，找到特征的最小和最大值，然后创建一个网格，用于评估模型在整个特征空间上的预测。
对于网格中的每个点，添加偏置项1，并计算其Sigmoid值（即预测的概率）。
使用Z.round().astype(int)将概率阈值化为0或1，以创建一个决策边界。
使用plt.contourf绘制决策边界。
使用plt.scatter绘制数据点，其中红色表示类0，蓝色表示类1。
添加标签、图例，并显示图形。
调用绘图函数:
最后，调用plot_decision_boundary函数来可视化决策边界和数据点。
整个过程从数据生成开始，通过训练逻辑回归模型找到最佳权重，最后使用这些权重绘制决策边界，从而展示模型如何对数据进行分类。