PyTorch Neural Network
Multi-Layer Perceptron (MLP)

import torch
import torch.nn as nn

class MyMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(2, 4)
        self.layer2 = nn.Linear(4, 1)
        self.relu   = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.relu(self.layer1(x))
        x = self.sigmoid(self.layer2(x))
        return x

model = MyMLP()
print(model)
print(sum(p.numel() for p in model.parameters()))

# วิธีสั้น: nn.Sequential
model = nn.Sequential(
    nn.Linear(2, 4),
    nn.ReLU(),
    nn.Linear(4, 1),
    nn.Sigmoid()
)

print(model)
# Sequential(
#   (0): Linear(2, 4)
#   (1): ReLU()
#   (2): Linear(4, 1)
#   (3): Sigmoid()
# )

# ใช้เหมือนกัน
output = model(x)

import torch
import torch.nn as nn

# Data
X = torch.tensor([[0,0],[0,1],[1,0],[1,1]],
                 dtype=torch.float32)
y = torch.tensor([[0],[1],[1],[0]],
                 dtype=torch.float32)

# Model
model = nn.Sequential(
    nn.Linear(2, 8),   # hidden layer ขนาด 8
    nn.ReLU(),
    nn.Linear(8, 1),
    nn.Sigmoid()
)

# Loss + Optimizer
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(
    model.parameters(), lr=0.01)

# Training loop
for epoch in range(1000):
    y_hat = model(X)
    loss = criterion(y_hat, y)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 200 == 0:
        print(f"Epoch {epoch+1}: loss={loss.item():.4f}")

# Test
with torch.no_grad():
    pred = model(X)
    print((pred > 0.5).float())

# 1. Forward pass
y_hat = model(X)

# 2. Compute loss
loss = criterion(y_hat, y)

# 3. Zero gradients
optimizer.zero_grad()

# 4. Backward pass
loss.backward()

# 5. Update weights
optimizer.step()

# SGD: พื้นฐาน, ช้าแต่เสถียร
optimizer = torch.optim.SGD(
    model.parameters(), lr=0.01)

# Adam: ปรับ lr อัตโนมัติ, นิยมใช้
optimizer = torch.optim.Adam(
    model.parameters(), lr=0.001)

# AdamW: Adam + weight decay
optimizer = torch.optim.AdamW(
    model.parameters(), lr=0.001,
    weight_decay=0.01)

# ดู learning rate ปัจจุบัน
for param_group in optimizer.param_groups:
    print(param_group['lr'])

uv add django

uv run django-admin startproject wk10 .
uv run manage.py startapp dashboard

# wk10/urls.py
from django.urls import path, include
urlpatterns = [
    path('', include('dashboard.urls')),
]

# dashboard/views.py
import json, torch, torch.nn as nn
from django.http import StreamingHttpResponse

def train(request):
    def event_stream():
        X = torch.tensor([[0,0],[0,1],
                          [1,0],[1,1]], dtype=torch.float32)
        y = torch.tensor([[0],[1],[1],[0]],
                         dtype=torch.float32)
        model = nn.Sequential(
            nn.Linear(2, 8), nn.ReLU(),
            nn.Linear(8, 1), nn.Sigmoid())
        criterion = nn.BCELoss()
        optimizer = torch.optim.Adam(model.parameters(), lr=0.05)
        for epoch in range(201):
            loss = criterion(model(X), y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            with torch.no_grad():
                pred = model(X).squeeze().tolist()
            yield f"data: {json.dumps({'epoch': epoch, 'loss': loss.item(), 'pred': pred})}\n\n"
    return StreamingHttpResponse(event_stream(), content_type='text/event-stream')

# ฝึกสอน: ต้องการ gradient
for epoch in range(1000):
    y_hat = model(X)           # forward
    loss = criterion(y_hat, y)
    optimizer.zero_grad()
    loss.backward()            # คำนวณ gradient
    optimizer.step()           # อัปเดต

# ประเมิน: ไม่ต้องการ gradient
with torch.no_grad():         # ปิด gradient
    y_hat = model(X)
    accuracy = (y_hat > 0.5).float().eq(y).mean()
    print(f"Accuracy: {accuracy:.4f}")

# model.eval() / model.train()
model.eval()                  # ประเมิน mode
y_hat = model(X)

model.train()                 # ฝึก mode
y_hat = model(X)

# บันทึก weights (แนะนำ)
torch.save(model.state_dict(),
           'model_weights.pth')

# โหลด weights
model = MyMLP()               # สร้าง model ก่อน
model.load_state_dict(
    torch.load('model_weights.pth'))
model.eval()

# บันทึก model ทั้งหมด
torch.save(model, 'model_full.pth')

# โหลด model ทั้งหมด
model = torch.load('model_full.pth')