딥러닝

에폭(Epoch)

전체 학습 데이터를 한 번 다 사용해서 학습하는 횟수

 

배치(Batch)

한 번 모델에 넣어서 학습시키는 데이터 묶음

 

풀배치

배치 크기 = 전체 데이터 수

 

미니 배치

배치 크기 작은거

 

온라인

배치 크기 = 1

 

다차원 배열

딥러닝에서 모든 데이터는 텐서 형태

 

텐서 차원

0차원 (Scalar): 숫자 하나 → 예: 7
1차원 (Vector): 배열 → 예: [1, 3, 5]
2차원 (Matrix): 행렬 → 예: 이미지의 한 채널
3차원 이상 (Tensor): 컬러 이미지(높이 × 너비 × 채널)

 

shape (형태)

• 텐서의 구조를 나타냄 (가로, 세로, 채널, 배치 크기 등)
• 예: (32, 3, 28, 28)
  → 32개의 이미지(batch 32)
  → 채널 3 (RGB)
  → 이미지 크기 28×28

dtype (데이터형)

• 텐서에 저장된 값의 자료형
• 주요 타입: float32, float64, int64 등
• 딥러닝에서는 주로 float32 사용
• 숫자형, 불리언, 복소수형만 지원

device (저장 위치)

• 텐서가 저장되어 있는 하드웨어 위치
• "cpu" : 일반 연산용 (기본값)
• "cuda" : GPU에서 연산 (빠름, 병렬 처리 가능)

함수 설명

torch.tensor([1, 2, 3])	리스트로부터 직접 텐서 생성
torch.arange(0, 10)	0부터 9까지 정수 텐서 생성 (range와 유사)
torch.zeros((3, 3))	3×3 크기의 0으로 채워진 텐서
torch.ones((2, 4))	2×4 크기의 1로 채워진 텐서
torch.rand((5, 2))	5×2 크기의 0~1 사이 랜덤값 텐서

 

인덱싱 / 슬라이싱
x[0]       # 첫 번째 원소  
x[:, 1]    # 두 번째 열 전체  
x[1:4]     # 1~3번째 원소

Reshaping
x.view(2, 3)        # 2×3 형태로 보기
x.reshape(-1, 4)    # 자동 계산으로 열 4개짜리로 변형

 

브로드캐스팅 (Broadcasting)

• 크기가 다른 텐서끼리도 자동으로 형태를 맞춰 연산할 수 있는 기능
• 작은 텐서를 큰 텐서의 크기에 맞게 자동 확장해 계산

a = torch.tensor([1, 2, 3])
b = 10
a + b  # → tensor([11, 12, 13])

 

텐서 연산 (Tensor Operations)

x + y
x - y
x * y
행렬 곱
x @ y
torch.matmul(x, y)

 

자동 미분이란?

• torch 텐서에 requires_grad=True를 설정하면
  해당 텐서와 관련된 모든 연산 과정을 자동으로 추적
• 이후 loss.backward()를 호출하면
  PyTorch가 자동으로 미분(gradient) 계산을 수행함

x = torch.tensor([2.0], requires_grad=True)
y = 3 * x**2 + 2 * x
y.backward()
print(x.grad)
# 미분 결과: dy/dx = 6x + 2 → x=2일 때 14

 

Dataset이란?

• 하나의 데이터를 어떻게 꺼내올지 정의하는 객체
• PyTorch에서 모델 학습 시, 데이터를 효율적으로 관리하기 위한 구조

커스텀 Dataset 클래스 만들 때 필수 메서드

__len__(self)

• 전체 샘플 개수를 반환
• 예: 이미지가 10,000장이면 len(dataset) → 10000

__getitem__(self, idx)

• 인덱스(idx)에 해당하는 데이터 1개 반환
• 보통 (X, y) 형태로 반환
• DataLoader에서 미니배치 단위로 꺼낼 때 이 메서드를 자동 호출함

for xb, yb in loader:
    print("batch X:", xb.shape, "batch y:", yb.shape)
    break
# batch X: torch.Size([16, 1]) batch y: torch.Size([16, 1])

 

DataLoader란?

• PyTorch에서 Dataset을 배치(batch) 단위로 나눠주는 도구
• 학습 시 데이터를 자동으로 묶어 (입력, 정답) 형태로 제공

---

주요 기능

• batch_size 만큼 데이터를 묶어서 반환
• shuffle=True이면 매 epoch마다 순서를 무작위로 섞음
• for xb, yb in loader: 형태로 반복문에서 사용 가능
• 학습 시 자동으로 입력(X), 정답(y) 형태로 묶어줌

loader = DataLoader(dataset, batch_size=32, shuffle=True)

for xb, yb in loader:
    pred = model(xb)               # 모델 예측
    loss = criterion(pred, yb)     # 손실 계산
    ...

batch_size	미니배치 크기 (기본값 1)
shuffle=True	매 epoch마다 데이터 순서 섞기
num_workers	병렬로 데이터 로딩 (윈도우는 0 추천)
drop_last=True	마지막 배치를 버림 (딥러닝에서 자주 사용)

 

drop_last=True를 사용하는 이유

• 배치 크기를 항상 일정하게 유지하기 위해
• 대부분의 모델이나 레이어는
  batch_size가 항상 일정하다고 가정하고 작성됨
• 예를 들어,
  전체 데이터가 100개이고 batch_size=32라면
  마지막 배치는 4개만 남음 → (100 % 32 = 4)
  → 이런 불완전한 배치는 학습 중 shape mismatch 오류를 일으킬 수 있음
• 특히 RNN 계열이나 배치 연산 의1ㅌ존적인 모델에서는
  마지막 미니배치를 제거하는 것이 안전함

'''
SV 파일을 읽어 feature와 target을 PyTorch 텐서로 변환하고,
Dataset과 DataLoader를 이용해 학습용 미니배치 단위로 데이터를 공급하는 구조를 구현'''

from torch.utils.data import Dataset, DataLoader
import torch
import pandas as pd


class CSVDataset(Dataset):
    def __init__(self, csv_file):
        super().__init__()
        df = pd.read_csv(csv_file)
        self.x = torch.tensor(df[["close", "volume"]].values, dtype=torch.int64)
        self.y = torch.tensor(df["close"].values, dtype=torch.int64)

    def __len__(self):
        return len(self.y)

    def __getitem__(self, idx):
        return self.x[idx], self.y[idx]


dataset = CSVDataset(
    "/Users/choimanseon/Documents/multicampus/ML/example/deep_learning/stock_daily.csv"
)
loader = DataLoader(dataset, batch_size=32, shuffle=True)

for xb, yb in loader:
    print("batch X: ", xb.shape, "batch y: ", yb.shape)
    print("xb:\n", xb)
    print("yb:\n", yb)

 

순전파 (Forward propagation)

모델이 입력값을 받아 예측값을 만드는 과정

1. 입력값(Input)
   • 학습에 사용되는 데이터 (예: 이미지, 숫자, 문장 등)
2. 가중치(Weight)
   • 모델 내부의 학습 가능한 파라미터
   • 처음엔 랜덤하게 설정됨
3. 예측값(Prediction)
   • 입력값이 모델(가중치 포함)을 통과해 나온 결과
   • 예: “이 사진은 고양이다” 확률 0.8

👉 이 과정을 순전파(Forward) 라고 해.
입력 → 가중치 계산 → 예측값 생성까지가 순전파야.

---

손실함수 (Loss Function)

• 예측값과 실제 정답(라벨)을 비교해 오차(얼마나 틀렸는지) 를 계산.
• 예:
  • 예측이 0.8, 정답이 1.0 → 오차 0.2
  • 예측이 0.1, 정답이 1.0 → 오차 0.9
• 손실값이 작을수록 모델이 더 잘 맞춘다는 뜻.

---

역전파 (Backward propagation)

• 손실함수를 통해 생긴 오차를 가중치에 되돌려 보내는 과정

1. 손실함수 → 오차 계산
   • 모델의 예측이 얼마나 틀렸는지 수치화
2. 최적화함수(Optimizer)
   • 오차를 기준으로 가중치를 얼마나, 어떤 방향으로 바꿔야 하는지 계산
   • 대표 예: SGD, Adam 등
3. 가중치 업데이트
   • 가중치를 조금씩 조정해서 다음 예측이 더 정확하게 되게 함

👉 이 과정을 역전파(Backward) 라고 부름.
손실 → 오차 계산 → 가중치 조정

 

from torch.utils.data import Dataset, DataLoader, TensorDataset
import torch
import torch.nn as nn

x = torch.linspace(0, 1, steps=100).unsqueeze(1)
y = 3 * x + 1 + 0.1 * torch.randn_like(x)

x_train, x_test = x[:80], x[80:]
y_train, y_test = y[:80], y[80:]

train_dataset = TensorDataset(x_train, y_train)
test_dataset = TensorDataset(x_test, y_test)

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=16, shuffle=True)


class MLPRegressor(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(1, 16), nn.ReLU(), nn.Linear(16, 16), nn.ReLU(), nn.Linear(16, 1)
        )

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


model = MLPRegressor()

criterion = nn.MSELoss()

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

num_epochs = 200

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for xb, yb in train_loader:
        optimizer.zero_grad()  # ① 이전 단계의 gradient 초기화
        pred = model(xb)  # ② 입력 xb를 통해 모델의 예측값 계산
        loss = criterion(pred, yb)  # ③ 예측값(pred)과 실제값(yb) 간 손실 계산
        loss.backward()  # ④ 손실을 기준으로 각 파라미터의 gradient 계산 (역전파)
        optimizer.step()  # ⑤ 계산된 gradient를 이용해 파라미터 업데이트
        running_loss += loss.item() * xb.size(0)

    epoch_loss = running_loss / len(train_dataset)
    if (epoch + 1) % 20 == 0:
        print(f"[Epoch {epoch+1}/{num_epochs}] Train MSE: {epoch_loss:.4f}")

    model.eval()
    with torch.no_grad():
        total_loss = 0.0
        for xb, yb in test_loader:
            pred = model(xb)
            loss = criterion(pred, yb)
            total_loss += loss.item() * xb.size(0)

        test_loss = total_loss / len(test_dataset)
        print(f"\n[Test MSE] : {test_loss:.4f}")