sigmoid(x) = 1 / (1 + e^(-x))

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# Sigmoid 函数可视化
x_sig = torch.linspace(-10, 10, 100)
y_sig = torch.sigmoid(x_sig)

torch.manual_seed(42)

# 生成两类数据点
# 类别0：以 (2, 2) 为中心
class0_x = torch.randn(100, 2) + torch.tensor([2, 2])
class0_y = torch.zeros(100, 1)  # 标签 0

# 类别1：以 (-2, -2) 为中心
class1_x = torch.randn(100, 2) + torch.tensor([-2, -2])
class1_y = torch.ones(100, 1)   # 标签 1

# 合并数据
X = torch.cat([class0_x, class1_x], dim=0)  # shape: (200, 2)
y = torch.cat([class0_y, class1_y], dim=0)  # shape: (200, 1)

# 打乱数据
indices = torch.randperm(X.shape[0])
X = X[indices]
y = y[indices]

print(f"数据形状: X={X.shape}, y={y.shape}")
print(f"类别0样本数: {(y == 0).sum().item()}")
print(f"类别1样本数: {(y == 1).sum().item()}")

class LogisticRegression(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)  # 输入2维，输出1维

    def forward(self, x):
        # 线性变换后接 sigmoid
        return torch.sigmoid(self.linear(x))

model = LogisticRegression(input_dim=2)
print(f"模型结构:\n{model}")

# 损失函数：二元交叉熵
criterion = nn.BCELoss()

# 优化器
optimizer = optim.SGD(model.parameters(), lr=0.1)

print("损失函数: BCE Loss (二元交叉熵)")
print("公式: -[y*log(p) + (1-y)*log(1-p)]")

epochs = 1000
loss_history = []
accuracy_history = []

for epoch in range(epochs):
    # 五步法
    optimizer.zero_grad()

    y_pred = model(X)

    loss = criterion(y_pred, y)

    loss.backward()

    optimizer.step()

    # 计算准确率
    predictions = (y_pred >= 0.5).float()  # 概率>=0.5 预测为1，否则为0
    accuracy = (predictions == y).float().mean()

    loss_history.append(loss.item())
    accuracy_history.append(accuracy.item())

    if (epoch + 1) % 100 == 0:
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}, Accuracy: {accuracy.item()*100:.2f}%")

def plot_decision_boundary(model, X, y):
    """绘制决策边界"""
    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.linspace(x_min, x_max, 100),
                         np.linspace(y_min, y_max, 100))

    # 预测网格上每个点的类别
    grid = torch.tensor(np.c_[xx.ravel(), yy.ravel()], dtype=torch.float32)
    with torch.no_grad():
        probs = model(grid).reshape(xx.shape)

    # 绘制决策边界
    # 黑线为分界线（概率=0.5）
    contour = plt.contourf(xx, yy, probs.numpy(), levels=20, cmap='RdBu', alpha=0.7)
    plt.contour(xx, yy, probs.numpy(), levels=[0.5], colors='black', linewidths=2)

Sigmoid:    σ(x) = 1 / (1 + e^(-x))
BCE Loss:   -[y*log(p) + (1-y)*log(1-p)]

p >= 0.5 → 预测为正类(1)
p < 0.5  → 预测为负类(0)