【机器学习】机器学习的基本分类-监督学习-逻辑回归（Logistic Regression）

逻辑回归是一种分类算法，尽管名字中包含"回归"，但其主要用于解决二分类和多分类问题。它通过学习一个逻辑函数，预测输入属于某个类别的概率。

1. 逻辑回归的基本概念

目标

逻辑回归的目标是找到一个函数 h(x)，输出一个概率值 P(y=1|x)，表示输入样本 x 属于正类的概率。

逻辑函数（Sigmoid 函数）

逻辑回归使用 Sigmoid 函数将线性回归的结果映射到 (0, 1) 之间：

其中：

z 是线性模型的结果。
h(x) 是预测为正类的概率。

【机器学习】机器学习的基本分类-监督学习-逻辑回归-Sigmoid 函数-CSDN博客

2. 逻辑回归的损失函数

为了优化模型参数 w 和 b，逻辑回归最小化 对数似然损失函数：

其中：

m 是样本数量。
是第 i 个样本的真实标签。

逻辑回归通过梯度下降或其他优化算法最小化该损失函数。

【机器学习】机器学习的基本分类-监督学习-逻辑回归-对数似然损失函数（Log-Likelihood Loss Function）-CSDN博客

3. 逻辑回归的假设

数据集中的样本是独立的。
输入特征和目标变量之间是线性可分的（通过特征变换，可以扩展到非线性问题）。

4. Python 实现

4.1 数据生成

我们以二分类任务为例：

python 复制代码

from sklearn.datasets import make_classification
import matplotlib.pyplot as plt

# 生成二分类数据
# 参数说明：
# n_samples=100: 生成100个样本
# n_features=4: 每个样本有4个特征
# n_classes=2: 分为2个类别
# n_informative=2: 有2个特征是信息特征，对分类有帮助
# n_redundant=1: 有1个特征是冗余特征，对分类无直接帮助
# n_repeated=0: 没有重复的特征
# random_state=0: 设置随机种子，保证结果可重复
X, y = make_classification(n_samples=100, n_features=4, n_classes=2, n_informative=2, n_redundant=1, n_repeated=0,
                           random_state=0)

# 可视化生成的数据
# 这里只绘制了前两个特征，因为高维数据无法直接可视化
# c=y: 根据类别y上色
# cmap='viridis': 使用'viridis'颜色地图
# edgecolor='k': 设置点的边缘颜色为黑色
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', edgecolor='k')
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.title("Generated Data")
plt.show()

4.2 使用 Scikit-learn 实现

python 复制代码

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 生成二分类数据
# 参数说明：n_samples=100表示生成100个样本，n_features=4表示数据有4个特征，n_classes=2表示二分类问题，
# n_informative=2表示其中2个特征是有信息的，n_redundant=1表示1个特征是冗余的，n_repeated=0表示没有重复的特征，
# random_state=0表示随机种子，保证结果可重复
X, y = make_classification(n_samples=100, n_features=4, n_classes=2, n_informative=2, n_redundant=1, n_repeated=0,
                           random_state=0)

# 数据集划分
# 将数据集划分为训练集和测试集，test_size=0.2表示测试集占20%，random_state=42保证划分结果可重复
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 逻辑回归模型
# 初始化逻辑回归模型
model = LogisticRegression()
# 使用训练集数据拟合模型
model.fit(X_train, y_train)

# 模型预测
# 使用拟合好的模型对测试集进行预测
y_pred = model.predict(X_test)

# 评估模型
# 输出模型的准确率
print("Accuracy:", accuracy_score(y_test, y_pred))
# 输出模型的混淆矩阵
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
# 输出模型的分类报告，包括精确度、召回率、F1值等指标
print("Classification Report:\n", classification_report(y_test, y_pred))

输出结果

bash 复制代码

Accuracy: 0.9
Confusion Matrix:
 [[9 2]
 [0 9]]
Classification Report:
               precision    recall  f1-score   support

           0       1.00      0.82      0.90        11
           1       0.82      1.00      0.90         9

    accuracy                           0.90        20
   macro avg       0.91      0.91      0.90        20
weighted avg       0.92      0.90      0.90        20

4.3 自定义实现

使用 NumPy 手动实现逻辑回归的梯度下降：

python 复制代码

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成二分类数据
# 参数说明：n_samples=100表示生成100个样本，n_features=4表示数据有4个特征，n_classes=2表示二分类问题，
# n_informative=2表示其中2个特征是有信息的，n_redundant=1表示1个特征是冗余的，n_repeated=0表示没有重复的特征，
# random_state=0表示随机种子，保证结果可重复
X, y = make_classification(n_samples=100, n_features=4, n_classes=2, n_informative=2, n_redundant=1, n_repeated=0,
                           random_state=0)

# 数据集划分
# 将数据集划分为训练集和测试集，test_size=0.2表示测试集占20%，random_state=42保证划分结果可重复
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Sigmoid 函数
# 用于将预测值映射到0到1之间，作为概率解释
def sigmoid(z):
    return 1 / (1 + np.exp(-z))


# 损失函数
# 计算模型预测值与真实值之间的交叉熵损失
def compute_loss(y, y_pred):
    return -np.mean(y * np.log(y_pred) + (1 - y) * np.log(1 - y_pred))


# 梯度下降实现逻辑回归
# 参数说明：X为特征数据，y为目标标签，learning_rate为学习率，n_iterations为迭代次数
# 返回值说明：weights为权重参数，bias为偏置参数
def logistic_regression(X, y, learning_rate=0.01, n_iterations=1000):
    m, n = X.shape
    weights = np.zeros(n)
    bias = 0

    for _ in range(n_iterations):
        # 计算预测值
        z = np.dot(X, weights) + bias
        y_pred = sigmoid(z)

        # 计算梯度
        dw = (1 / m) * np.dot(X.T, (y_pred - y))
        db = (1 / m) * np.sum(y_pred - y)

        # 更新参数
        weights -= learning_rate * dw
        bias -= learning_rate * db

    return weights, bias


# 使用模型
# 训练逻辑回归模型，得到权重参数和偏置参数
weights, bias = logistic_regression(X_train, y_train)
# 对测试集进行预测
z = np.dot(X_test, weights) + bias
y_pred = (sigmoid(z) >= 0.5).astype(int)

# 输出准确率
print("Accuracy:", accuracy_score(y_test, y_pred))