输入层 → 隐藏层1 → 隐藏层2 → ... → 输出层
           ↓ReLU      ↓ReLU         ↓(无/softmax)

XOR 真值表：
  输入 (0,0) → 输出 0
  输入 (0,1) → 输出 1
  输入 (1,0) → 输出 1
  输入 (1,1) → 输出 0

import torch
import torch.nn as nn
import torch.optim as optim

# XOR 数据
X_xor = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
y_xor = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# 线性模型（无法解决 XOR）
class LinearXOR(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(2, 1)

    def forward(self, x):
        return torch.sigmoid(self.linear(x))

linear_model = LinearXOR()
criterion = nn.BCELoss()
optimizer = optim.SGD(linear_model.parameters(), lr=0.1)

for epoch in range(1000):
    optimizer.zero_grad()
    y_pred = linear_model(X_xor)
    loss = criterion(y_pred, y_xor)
    loss.backward()
    optimizer.step()

# 线性模型准确率最高只有 75%（无法完美解决）

class MLP(nn.Module):
    """
    多层神经网络

    结构：
        输入 (2)
          ↓
        隐藏层1 (8个神经元) + ReLU
          ↓
        隐藏层2 (8个神经元) + ReLU
          ↓
        输出层 (1个神经元) + Sigmoid
    """

    def __init__(self, input_dim=2, hidden_dim=8, output_dim=1):
        super().__init__()

        # 第一层：输入 -> 隐藏层1
        self.fc1 = nn.Linear(input_dim, hidden_dim)

        # 第二层：隐藏层1 -> 隐藏层2
        self.fc2 = nn.Linear(hidden_dim, hidden_dim)

        # 输出层：隐藏层2 -> 输出
        self.fc3 = nn.Linear(hidden_dim, output_dim)

        # 激活函数
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # 第一隐藏层
        x = self.fc1(x)
        x = self.relu(x)

        # 第二隐藏层
        x = self.fc2(x)
        x = self.relu(x)

        # 输出层
        x = self.fc3(x)
        x = self.sigmoid(x)

        return x

# 创建 MLP 模型
mlp = MLP(input_dim=2, hidden_dim=8, output_dim=1)

# 训练 MLP
criterion = nn.BCELoss()
optimizer = optim.Adam(mlp.parameters(), lr=0.01)

epochs = 2000
for epoch in range(epochs):
    optimizer.zero_grad()
    y_pred = mlp(X_xor)
    loss = criterion(y_pred, y_xor)
    loss.backward()
    optimizer.step()

# MLP 可以完美解决 XOR 问题（准确率 100%）

import numpy as np

def generate_spiral_data(n_samples=300):
    """生成两类螺旋数据"""
    np.random.seed(42)

    # 第一类：向内螺旋
    theta1 = np.linspace(0, 4*np.pi, n_samples//2)
    r1 = theta1 + np.random.randn(n_samples//2) * 0.2
    x1 = r1 * np.cos(theta1)
    y1 = r1 * np.sin(theta1)

    # 第二类：向外螺旋
    theta2 = np.linspace(0, 4*np.pi, n_samples//2)
    r2 = theta2 + np.random.randn(n_samples//2) * 0.2
    x2 = -r2 * np.cos(theta2)
    y2 = -r2 * np.sin(theta2)

    # 合并数据
    X = np.vstack([np.column_stack([x1, y1]), np.column_stack([x2, y2])])
    y = np.hstack([np.zeros(n_samples//2), np.ones(n_samples//2)])

    return torch.tensor(X, dtype=torch.float32), torch.tensor(y, dtype=torch.float32).unsqueeze(1)

X_spiral, y_spiral = generate_spiral_data(300)

class DeepMLP(nn.Module):
    """更深的网络用于解决复杂分类问题"""
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(2, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, 64)
        self.fc4 = nn.Linear(64, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        x = self.sigmoid(self.fc4(x))
        return x

deep_mlp = DeepMLP()
criterion = nn.BCELoss()
optimizer = optim.Adam(deep_mlp.parameters(), lr=0.01)

epochs = 1000
for epoch in range(epochs):
    optimizer.zero_grad()
    y_pred = deep_mlp(X_spiral)
    loss = criterion(y_pred, y_spiral)
    loss.backward()
    optimizer.step()