텐서 — AI의 레고 블록

import torch

# === 텐서: NumPy 배열 + GPU + 자동 미분 ===

# 1. 텐서 생성
x = torch.tensor([1.0, 2.0, 3.0])
print(f"텐서: {x}")
print(f"크기: {x.shape}")
print(f"타입: {x.dtype}")

# 2. 행렬 연산 (NumPy와 거의 동일)
A = torch.randn(3, 4)   # 3×4 랜덤 행렬
B = torch.randn(4, 2)   # 4×2 랜덤 행렬
C = A @ B                # 3×2 결과
print(f"\n행렬 곱셈: {A.shape} × {B.shape} = {C.shape}")

# 3. 자동 미분 — PyTorch의 핵심!
w = torch.tensor(0.0, requires_grad=True)  # "기울기 추적"
target = torch.tensor(3.0)

loss = (w - target) ** 2
print(f"\nw = {w.item():.4f}, 손실 = {loss.item():.4f}")

# 역전파 — 한 줄로 기울기 계산!
loss.backward()
print(f"기울기 (∂L/∂w) = {w.grad.item():.4f}")
print(f"수동 계산: 2 × ({w.item():.4f} - 3) = {2 * (w.item() - 3):.4f}  (일치!)")

# === 순수 파이썬 텐서 + 자동 미분 ===

class Tensor:
    """미니 텐서: 값 + 기울기 추적"""
    def __init__(self, data, requires_grad=False):
        self.data = data  # 실제 값
        self.grad = 0.0   # 기울기
        self.requires_grad = requires_grad

    def __mul__(self, other):
        result = Tensor(self.data * other.data)
        # 역전파 시 기울기 전파 기록
        result._backward = lambda g: (
            setattr(self, 'grad', self.grad + other.data * g),
            setattr(other, 'grad', other.grad + self.data * g),
        )
        result.requires_grad = True
        return result

    def backward(self, grad=1.0):
        if hasattr(self, '_backward'):
            self._backward(grad)

# 1. 텐서 생성 (w는 학습할 가중치)
x = Tensor(3.0)
w = Tensor(2.0, requires_grad=True)

# 2. 순전파: y = x * w
y = x * w
print(f"x = {x.data}, w = {w.data}")
print(f"y = x * w = {y.data}")

# 3. 역전파: dy/dw = x, dy/dx = w
y.backward(1.0)
print(f"\n자동 미분 결과:")
print(f"  dL/dw = {w.grad}  (= x의 값)")
print(f"  dL/dx = {x.grad}  (= w의 값)")

# 4. 경사하강법 시뮬레이션
lr = 0.1
w_new = w.data - lr * w.grad
print(f"\n경사하강법 (lr={lr}):")
print(f"  w: {w.data} → {w_new}")