파이토치 (PyTorch)

# 1. PyTorch 설치 (CUDA 12 지원)
$ pip install torch torchvision torchaudio

# 2. 텐서 생성 및 GPU 장치 할당
import torch

# GPU 사용 가능 여부 확인
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"연산 가속 디바이스: {device}")

# 2x3 무작위 텐서 생성 후 GPU로 전송
x = torch.randn(2, 3, device=device)
w = torch.randn(3, 2, device=device, requires_grad=True)  # 자동 미분 활성화

# 행렬 곱 연산 수행 (@ 연산자)
y = x @ w
print("행렬 곱 결과 shape:", y.shape)  # torch.Size([2, 2])

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

# 1. nn.Module 상속을 통한 커스텀 신경망 클래스 정의
class DeepClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_classes):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)      # 선형 변환 계층
        self.relu = nn.ReLU()                               # 비선형 활성화 함수
        self.dropout = nn.Dropout(p=0.2)                   # 과적합 방지 드롭아웃
        self.layer2 = nn.Linear(hidden_dim, num_classes)    # 최종 분류 출력 계층

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

# 2. 모델 인스턴스 생성 및 GPU 적재, PyTorch 2.0 초고속 컴파일
model = DeepClassifier(input_dim=784, hidden_dim=256, num_classes=10).to(device)
compiled_model = torch.compile(model)  # PyTorch 2.x JIT 커널 가속

# 3. 손실 함수와 최적화 옵티마이저 설정
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(compiled_model.parameters(), lr=0.001, weight_decay=0.01)

# 4. 정형화된 표준 파이토치 학습 루프
compiled_model.train()  # 학습 모드 활성화 (Dropout, BatchNorm 동작)
for epoch in range(5):
    # 가상 미니배치 데이터 (배치 크기 64)
    inputs = torch.randn(64, 784, device=device)
    targets = torch.randint(0, 10, (64,), device=device)

    # [필수 1] 이전 배치의 잔여 그래디언트 초기화
    optimizer.zero_grad()

    # [필수 2] 순방향 연산 (Forward Pass)
    outputs = compiled_model(inputs)

    # [필수 3] 오차 손실값 계산 (Loss Calculation)
    loss = criterion(outputs, targets)

    # [필수 4] 연쇄 법칙 기반 역전파 그래디언트 계산 (Autograd Backward)
    loss.backward()

    # [필수 5] 가중치 매개변수 업데이트 (Weight Step)
    optimizer.step()

    print(f"Epoch [{epoch+1}/5] - Loss: {loss.item():.4f}")