【机器学习】逻辑回归

逻辑回归 是一种用于二分类问题的统计学习方法，尽管名字带有"回归"，但它实际用于解决分类问题。与线性回归不同，逻辑回归预测的是数据点属于某个类别的概率。本教程将详细介绍逻辑回归的核心概念，包括模型的推导、损失函数、梯度下降优化、决策边界的可视化等。全程将使用numpy实现逻辑回归，最后我们会使用sklearn实现并验证结果。

逻辑回归模型简介

逻辑回归模型的核心思想是使用 Sigmoid 函数 将线性回归的输出值映射到 (0,1) 区间，从而得到属于某类别的概率。

假设我们的模型公式为：

y = w T ⋅ X + b y = w^T \cdot X + b y=wT⋅X+b

通过Sigmoid函数，将线性模型的输出映射到概率：

p ( y = 1 ∣ X ) = σ ( w T ⋅ X + b ) = 1 1 + e − ( w T ⋅ X + b ) p(y=1|X) = \sigma(w^T \cdot X + b) = \frac{1}{1 + e^{-(w^T \cdot X + b)}} p(y=1∣X)=σ(wT⋅X+b)=1+e−(wT⋅X+b)1

其中：

• ( p(y=1|X) ) 表示样本属于类别1的概率，
• ( w ) 是权重向量，
• ( b ) 是偏置项，
• ( X ) 是输入特征向量。

当预测概率大于0.5时，我们通常将样本分类为类别1，否则归类为类别0。

损失函数：交叉熵损失

逻辑回归的目标是最小化交叉熵损失（Log-Loss），交叉熵损失能够衡量预测概率和实际类别之间的差异。定义如下：

L ( y , y ^ ) = − 1 n ∑ i = 1 n [ y i log ⁡ ( y i ^ ) + ( 1 − y i ) log ⁡ ( 1 − y i ^ ) ] L(y, \hat{y}) = -\frac{1}{n} \sum_{i=1}^n \left[ y_i \log(\hat{y_i}) + (1 - y_i) \log(1 - \hat{y_i}) \right] L(y,y^)=−n1i=1∑n[yilog(yi^)+(1−yi)log(1−yi^)]

其中：

• ( y_i ) 是第 ( i ) 个样本的真实标签（0或1），
• ( \hat{y_i} ) 是第 ( i ) 个样本的预测概率。

梯度下降优化

逻辑回归模型的权重和偏置项可以通过梯度下降进行优化。我们先求损失函数对 ( w ) 和 ( b ) 的偏导数：

• 对 ( w ) 的偏导数为：

∂ L ∂ w = 1 n ∑ i = 1 n ( y i − y i ^ ) X i \frac{\partial L}{\partial w} = \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y_i}) X_i ∂w∂L=n1i=1∑n(yi−yi^)Xi

• 对 ( b ) 的偏导数为：

∂ L ∂ b = 1 n ∑ i = 1 n ( y i − y i ^ ) \frac{\partial L}{\partial b} = \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y_i}) ∂b∂L=n1i=1∑n(yi−yi^)

通过这两个梯度更新 ( w ) 和 ( b )：

w = w + α ⋅ ∂ L ∂ w b = b + α ⋅ ∂ L ∂ b w = w + \alpha \cdot \frac{\partial L}{\partial w}\\ b = b + \alpha \cdot \frac{\partial L}{\partial b} w=w+α⋅∂w∂Lb=b+α⋅∂b∂L

其中 ( \alpha ) 是学习率。

代码实现逻辑回归模型

我们使用 numpy 从头实现逻辑回归模型。

数据准备

我们首先生成一个用于二分类的示例数据集：

import numpy as np
import matplotlib.pyplot as plt

# 生成二分类数据
np.random.seed(42)
num_samples = 100
X_class0 = np.random.randn(num_samples, 2) + np.array([-2, -2])
X_class1 = np.random.randn(num_samples, 2) + np.array([2, 2])
X = np.vstack((X_class0, X_class1))
y = np.hstack((np.zeros(num_samples), np.ones(num_samples)))

# 可视化数据
plt.scatter(X[:num_samples, 0], X[:num_samples, 1], color="blue", label="Class 0")
plt.scatter(X[num_samples:, 0], X[num_samples:, 1], color="red", label="Class 1")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.title("Binary Classification Dataset")
plt.show()

定义 Sigmoid 函数

Sigmoid 函数将线性回归的输出转换为概率：

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

定义损失函数

实现交叉熵损失函数：

def compute_loss(y_true, y_pred):
    n = len(y_true)
    loss = -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    return loss

梯度计算

我们使用 compute_gradients 函数计算梯度：

def compute_gradients(X, y, y_pred):
    n = len(y)
    dw = (1 / n) * X.T.dot(y_pred - y)
    db = (1 / n) * np.sum(y_pred - y)
    return dw, db

梯度下降训练模型

def gradient_descent(X, y, learning_rate, iterations):
    n_features = X.shape[1]
    w = np.random.randn(n_features)
    b = np.random.randn(1)
    
    for i in range(iterations):
        # 计算预测值
        linear_model = X.dot(w) + b
        y_pred = sigmoid(linear_model)
        
        # 计算损失
        loss = compute_loss(y, y_pred)
        if i % 100 == 0:
            print(f"Iteration {i}, Loss: {loss}")
        
        # 计算梯度并更新参数
        dw, db = compute_gradients(X, y, y_pred)
        w -= learning_rate * dw
        b -= learning_rate * db
        
    return w, b

模型训练与可视化

设置超参数并训练模型：

# 超参数设置
learning_rate = 0.1
iterations = 1000

# 训练模型
w_trained, b_trained = gradient_descent(X, y, learning_rate, iterations)

# 决策边界可视化
x_boundary = np.linspace(-4, 4, 100)
y_boundary = -(w_trained[0] * x_boundary + b_trained) / w_trained[1]

plt.scatter(X[:num_samples, 0], X[:num_samples, 1], color="blue", label="Class 0")
plt.scatter(X[num_samples:, 0], X[num_samples:, 1], color="red", label="Class 1")
plt.plot(x_boundary, y_boundary, color="green", label="Decision Boundary")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.title("Logistic Regression Decision Boundary")
plt.show()

使用 sklearn 实现逻辑回归

我们使用 sklearn 中的 LogisticRegression 来验证逻辑回归模型。

from sklearn.linear_model import LogisticRegression

# 训练模型
log_reg = LogisticRegression()
log_reg.fit(X, y)

# 可视化决策边界
x_boundary = np.linspace(-4, 4, 100)
y_boundary = -(log_reg.coef_[0][0] * x_boundary + log_reg.intercept_) / log_reg.coef_[0][1]

plt.scatter(X[:num_samples, 0], X[:num_samples, 1], color="blue", label="Class 0")
plt.scatter(X[num_samples:, 0], X[num_samples:, 1], color="red", label="Class 1")
plt.plot(x_boundary, y_boundary, color="green", label="Decision Boundary")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.title("Logistic Regression Decision Boundary with Sklearn")
plt.show()

总结

在本教程中，我们详细推导了逻辑回归模型的核心原理，包括Sigmoid函数、交叉熵损失和梯度下降优化。通过numpy实现，我们掌握了模型的各个步骤，最后使用sklearn验证了结果并可视化了决策边界。这篇教程希望能够帮助你深入理解逻辑回归的原理和实现。