Multilayer Perceptron

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, in_dim=784, hidden=[128, 64], out_dim=10):
        super().__init__()
        dims = [in_dim, *hidden, out_dim]
        layers = []
        for i in range(len(dims) - 1):
            layers.append(nn.Linear(dims[i], dims[i + 1]))
            if i < len(dims) - 2:   # không đặt ReLU sau lớp đầu ra
                layers.append(nn.ReLU())
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

# Khởi tạo & đếm tham số
model = MLP(784, [128, 64], 10)
n_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Tham số: {n_params:,}")   # ~109k

# Forward pass thử
x = torch.randn(32, 784)        # batch 32, ảnh flatten
logits = model(x)               # (32, 10)
print(logits.shape)

import torch
import torch.nn as nn

# Dữ liệu XOR
X = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
y = torch.tensor([[0.], [1.], [1.], [0.]])

# MLP nhỏ nhất: 2 đầu vào -> 2 nơ-ron ẩn (tanh) -> 1 đầu ra (sigmoid)
model = nn.Sequential(
    nn.Linear(2, 2),
    nn.Tanh(),
    nn.Linear(2, 1),
    nn.Sigmoid(),
)

loss_fn = nn.BCELoss()
opt = torch.optim.Adam(model.parameters(), lr=0.1)

for epoch in range(2000):
    pred = model(X)
    loss = loss_fn(pred, y)
    opt.zero_grad()
    loss.backward()
    opt.step()

    if epoch % 200 == 0:
        acc = ((pred > 0.5).float() == y).float().mean().item()
        print(f"epoch {epoch:4d}  loss={loss.item():.4f}  acc={acc:.2f}")

# Kết quả cuối
print("Dự đoán:", model(X).squeeze().detach().tolist())
# ~ [0.02, 0.98, 0.98, 0.02]  ← XOR đã học được!