PyTorch 实现逻辑回归（二分类，Mini-Batch 梯度下降版）

import torch

# 超参数
n_item, n_feature = 1000, 2 #定义数据规模：1000 个样本，每个样本有 2 个特征（例如 x1、x2）
learning_rate = 0.01  #学习率，指每次更新参数时的步长
epochs = 100  #训练轮数，指整个数据集会被遍历优化100次
batch_size = 32   #每次训练使用的样本数量为 32，这是小批量梯度下降

# 数据
torch.manual_seed(123)  #设置随机种子为 123，确保每次运行结果可复现
data_x = torch.randn(size=(n_item, n_feature)).float() #生成 1000 行、2 列的随机数据（服从标准正态分布 N(0,1)）
data_y = torch.where(data_x[:, 0]*0.5 - data_x[:, 1]*1.5 > 0, 1., 0.).float().view(-1, 1)#构造标签 y，即“真实答案”

# 模型参数
w = torch.randn(size=(n_feature, 1), requires_grad=True)
b = torch.zeros(size=(1, 1), requires_grad=True)
#初始化模型参数 w（2×1）和 b（1×1），并设置为可训练（需要梯度）

# 训练
for epoch in range(epochs):
    for i in range(0, n_item, batch_size):
        x_batch = data_x[i:i+batch_size]
        y_batch = data_y[i:i+batch_size]
        #训练循环

        # forward
        z = x_batch @ w + b   # [batch,1]
        y_hat = torch.sigmoid(z)
        #前向传播计算，即代入后映射成概率

        # loss
        loss = -(y_batch*torch.log(y_hat) + (1-y_batch)*torch.log(1-y_hat)).mean()
        #代入损失函数计算loss

        # backward
        loss.backward()
        #反向传播，自动计算梯度

        # update
        with torch.no_grad():
            w -= learning_rate * w.grad
            b -= learning_rate * b.grad
            w.grad.zero_()
            b.grad.zero_()
            #参数更新，一步步梯度下降

    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
    #打印 Loss