4. Basic Train Loop

안녕하세요, MoonLight입니다.

​

이번 글에서는 PyTorch를 이용한 기본적인 Train Loop를 분석하고, 각 구성 요소가 하는 역할을 상세히 설명합니다.

​

이를 통해 신경망 모델을 학습하는 과정에서 필요한 핵심 개념들을 익힐 수 있습니다

​

이 Code의 기본적인 구조는 신경망을 이용한 Deep Learning Model을 학습시키기 위한 가장 기본적인 요소들을 모두 가지고 있다고 생각합니다.

​

각각의 요소들을 하나씩 살펴보면서 Deep Learning 신경망 학습을 하기 위해서 어떤 것들이 필요하고, PyTorch는 그것을 어떤 방식으로 지원하는지 알아보도록 하겠습니다.

​

​

​

​

​

 

 

 

1. 전체 Code

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader, random_split
import numpy as np

# Custom Dataset
class CustomDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets

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

    def __getitem__(self, index):
        x = self.data[index]
        y = self.targets[index]
        return x, y

# 데이터 생성
x_data = np.array([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]], dtype=np.float32)
y_data = np.array([[2], [4], [6], [8], [10], [12], [14], [16], [18], [20]], dtype=np.float32)

dataset = CustomDataset(x_data, y_data)

# Train/Validation Split
train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=2, shuffle=False)

# Check device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# 모델 정의
class LinearRegressionModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)

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

model = LinearRegressionModel(input_dim=1, output_dim=1).to(device)

# 손실 함수 및 옵티마이저
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.001)

# Learning Rate Scheduler
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.9)

# Early Stopping
class EarlyStopping:
    def __init__(self, patience=5, delta=0, save_path="best_model.pth"):
        self.patience = patience
        self.delta = delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
        self.save_path = save_path

    def __call__(self, val_loss, model):
        if self.best_loss is None:
            self.best_loss = val_loss
            self.save_checkpoint(val_loss, model)
        elif val_loss > self.best_loss - self.delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0
            self.save_checkpoint(val_loss, model)

    def save_checkpoint(self, val_loss, model):
        torch.save(model.state_dict(), self.save_path)
        print(f"Validation loss improved to {val_loss:.4f}. Model saved to {self.save_path}")

early_stopping = EarlyStopping(patience=10, delta=0.01, save_path="best_model.pth")

# Training Loop
nb_epochs = 100
for epoch in range(nb_epochs):
    model.train()
    train_loss = 0.0

    for x_batch, y_batch in train_loader:
        x_batch = torch.FloatTensor(x_batch).to(device)
        y_batch = torch.FloatTensor(y_batch).to(device)

        # Forward pass
        predictions = model(x_batch)
        loss = criterion(predictions, y_batch)

        # Backward pass and optimization
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.item() * x_batch.size(0)

    train_loss /= len(train_loader.dataset)

    # Validation Loop
    model.eval()
    val_loss = 0.0
    with torch.no_grad():
        for x_batch, y_batch in val_loader:
            x_batch = torch.FloatTensor(x_batch).to(device)
            y_batch = torch.FloatTensor(y_batch).to(device)

            predictions = model(x_batch)
            loss = criterion(predictions, y_batch)
            val_loss += loss.item() * x_batch.size(0)

    val_loss /= len(val_loader.dataset)

    # Learning Rate Step
    scheduler.step()

    print(f"Epoch {epoch+1}/{nb_epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, LR: {scheduler.get_last_lr()[0]:.6f}")

    # Early Stopping Check
    early_stopping(val_loss, model)
    if early_stopping.early_stop:
        print("Early stopping triggered.")
        break

# Load Best Model (Optional)
model.load_state_dict(torch.load("best_model.pth"))
model.to(device)
print("Best model loaded.")

new_var =  torch.FloatTensor([[4.0]]).to(device)
# 입력한 값 4에 대해서 예측값 y를 리턴받아서 pred_y에 저장
pred_y = model(new_var) # forward 연산
# y = 2x 이므로 입력이 4라면 y가 8에 가까운 값이 나와야 제대로 학습이 된 것
print("훈련 후 입력이 4일 때의 예측값 :", pred_y)

위의 Code는 Input Data(위의 Code에서 x_data)와 Target Data(위의 Code에서 y_data)와의 관계를 학습하는 Model을 Train 시킵니다.

​

 

위의 Code를 실행하면 아래와 유사한 결과는 출력될 것 입니다.

구체적인 값들은 실행할 때 마다 다르게 표시됩니다.

Using device: cuda
Epoch 1/100, Train Loss: 80.0494, Val Loss: 124.4230, LR: 0.001000
Validation loss improved to 124.4230. Model saved to best_model.pth
Epoch 2/100, Train Loss: 47.0147, Val Loss: 73.7780, LR: 0.001000
Validation loss improved to 73.7780. Model saved to best_model.pth
Epoch 3/100, Train Loss: 27.6969, Val Loss: 43.8782, LR: 0.001000
Validation loss improved to 43.8782. Model saved to best_model.pth
Epoch 4/100, Train Loss: 16.3471, Val Loss: 26.1432, LR: 0.001000
Validation loss improved to 26.1432. Model saved to best_model.pth
Epoch 5/100, Train Loss: 9.6966, Val Loss: 15.6065, LR: 0.001000
Validation loss improved to 15.6065. Model saved to best_model.pth
.
.
.
.
.
Epoch 25/100, Train Loss: 0.0370, Val Loss: 0.0340, LR: 0.000810
Epoch 26/100, Train Loss: 0.0366, Val Loss: 0.0323, LR: 0.000810
Validation loss improved to 0.0323. Model saved to best_model.pth
Epoch 27/100, Train Loss: 0.0368, Val Loss: 0.0312, LR: 0.000810
Epoch 28/100, Train Loss: 0.0362, Val Loss: 0.0301, LR: 0.000810
Epoch 29/100, Train Loss: 0.0360, Val Loss: 0.0292, LR: 0.000810
Epoch 30/100, Train Loss: 0.0359, Val Loss: 0.0285, LR: 0.000729
Epoch 31/100, Train Loss: 0.0357, Val Loss: 0.0277, LR: 0.000729
Epoch 32/100, Train Loss: 0.0362, Val Loss: 0.0274, LR: 0.000729
Epoch 33/100, Train Loss: 0.0361, Val Loss: 0.0269, LR: 0.000729
Epoch 34/100, Train Loss: 0.0355, Val Loss: 0.0263, LR: 0.000729
Epoch 35/100, Train Loss: 0.0356, Val Loss: 0.0262, LR: 0.000729
Epoch 36/100, Train Loss: 0.0356, Val Loss: 0.0259, LR: 0.000729
Early stopping triggered.

Best model loaded.
훈련 후 입력이 4일 때의 예측값 : tensor([[8.1321]], device='cuda:0', grad_fn=<AddmmBackward0>)

​

Train을 마친 Model에 Input으로 4를 넣으면 8.1321이라는 결과를 내놓는데, 어느 정도 훈련은 된 것 같네요.

​

​

​

​

 

 

2. 주요 과정

이번에는 Deep Learning 신경망 학습을 하기 위해서 반드시 필요한 여러 과정들이 있습니다.

​

Data를 준비하고 신경망을 구성하고 Loop를 돌면서 학습을 하고, Parameter를 Update하는 등의 여러 과정들이 위의 Code 중에 어디에 속하는지 간단하게 알아보도록 하겠습니다.

​

​

 

 

2.1. Dataset & DataLoader 준비

Deep Learning 학습을 하기 위해서는 반드시 학습 Data가 필요합니다.

그래서 가장 먼저 학습할 Data를 신경망에 입력할 수 있는 형태로 변환하는 과정이 반드시 필요합니다.

​

앞서 Tensor 소개할 때 잠깐 언급했지만, 신경망 입력 형태는 어떠한 Data의 형태(이미지, 소리, Text 등)이든지 반드시 부동 소수점 형태로 변환이 되어야 합니다.

​

Dataset & DataLoader 준비 과정에서는 학습할 Data를 부동소수점 형태로 변환하고, Train Loop에서 쉽게 읽어갈 수 있도록 준비하는 과정이라고 생각하면 됩니다.

​

​

위의 Code에서는 아래 부분이 Data 준비 과정이라고 보시면 됩니다.

# Custom Dataset
class CustomDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets

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

    def __getitem__(self, index):
        x = self.data[index]
        y = self.targets[index]
        return x, y

# 데이터 생성
x_data = np.array([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]], dtype=np.float32)
y_data = np.array([[2], [4], [6], [8], [10], [12], [14], [16], [18], [20]], dtype=np.float32)

dataset = CustomDataset(x_data, y_data)

# Train/Validation Split
train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=2, shuffle=False)

 

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· Custom Dataset 클래스 정의 (`CustomDataset`)

· 데이터 생성 및 가공 (`x_data`, `y_data`)

· Dataset을 Train/Validation으로 분할 (`random_split`)

· DataLoader 생성 (`DataLoader` 설정: `batch_size`, `shuffle` 등)

​

​

Dataset과 Dataloader Class의 사용법에 대해서는 아래의 Post를 참고하시면 많은 도움이 되실 것입니다.

https://moonlight314.tistory.com/entry/5-Dataset-DataLoader

5. Dataset & DataLoader

 

​

​

​

 

2.2. 모델 구조 정의

다음으로 신경망 모델의 구조를 정의해야 합니다.

모델의 구조는 매우 다양합니다. 기본적인 구성을 가지고 있는 Dense Layer, CNN, RNN, LSTM Layer등이 있을 수 있고,

이를 다양하게 조합하고 많이 쌓아서(Deep) 신경망을 구성할 수도 있습니다.

 

제가 예로 든 신경망은 단순히 Linear Regression 문제를 푸는 모델이면 충분하기 때문에 하나의 Dense Layer만 가진 모델로 구성하였습니다.

# 모델 정의
class LinearRegressionModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)

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

model = LinearRegressionModel(input_dim=1, output_dim=1).to(device)

​

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· PyTorch `nn.Module`을 활용한 `LinearRegressionModel` 클래스 정의

· `forward()` 메서드에서 선형 변환 (`nn.Linear`)

· `to(device)`를 사용한 모델의 GPU/CPU 이동

​

모델 구조 정의 부분은 우리가 만들려는 모델의 기능에 따라서 매우 다양하고 복잡하게 만들어 질 수도 있습니다.

​

​

​

nn.Module을 상속받아 Model Class를 정의하는 방법에 대해서는 아래 Post에서 자세히 다루고 있습니다.

https://moonlight314.tistory.com/entry/6-%EC%8B%A0%EA%B2%BD%EB%A7%9D-%EA%B5%AC%EC%84%B1-Container-Class

6. 신경망 구성 - Container Class

 

​

​

​

 

 

3. Loss Function & Optimizer 설정

딥러닝 모델을 학습시키기 위해서는 Loss Function(손실 함수) 와 Optimizer가 필수적입니다.

이 둘은 모델이 점점 더 좋은 성능을 내도록 만드는 핵심 요소입니다.

​

먼저 Loss Function(손실 함수)는 모델의 예측값과 실제 정답값의 차이를 수치화하여 얼마나 잘못 예측했는지 를 측정하는 역할을 합니다. 손실 값이 작을수록 모델의 예측이 정확한 것입니다.

Optimizer는 손실 함수를 통해 "얼마나 틀렸는지" 를 계산한 후, 모델의 가중치를 업데이트하는 알고리즘입니다.

​

이 둘이 모델을 좀 더 좋은 성능으로 학습시키는 과정은 먼저 모델이 데이터를 입력받아 예측값을 계산합니다.

손실함수는 이 예측값과 실제값의 차이를 정해진 방식에 따라서 계산하고, 계산한 차이(Loss)를 Backpropagation 시킵니다.

Optimizer는 차이를 줄일 수 있도록 Weight & Bias를 조정하는 과정을 계속해서 반복하는 것입니다.

# 손실 함수 및 옵티마이저
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.001)
.
.
.
        # Forward pass
        predictions = model(x_batch)
        loss = criterion(predictions, y_batch)

        # Backward pass and optimization
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

​

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· 손실 함수 선택 (`nn.MSELoss`)

· 옵티마이저 설정 (`optim.SGD`, 학습률 `lr` 설정)

· Input을 Model을 통과시켜서 예측값을 계산

· 미리 설정한 Loss Function으로 오차를 계산

· 오차를 Backpropagation 시킨다.

· Weight & Bias를 Update합니다.

​

​

Loss Function(손실함수)대해서는 아래 Post에서 자세히 다루고 있습니다.

https://moonlight314.tistory.com/entry/7-Loss-Function-%EC%86%90%EC%8B%A4-%ED%95%A8%EC%88%98

7. Loss Function( 손실 함수 )

 

 

​

​

Optimizer에 대해서는 아래 Post에서 자세히 다루고 있으니 도움이 되실 것입니다.

https://moonlight314.tistory.com/entry/8-Optimizers

8. Optimizers

 

​

​

​

​

​

​

 

4. 학습 루프 (Train Loop)

딥러닝 모델이 데이터를 학습하는 과정은 단순히 한 번의 계산으로 끝나지 않습니다.

학습 데이터를 여러 번 반복해서 학습하면서 점점 더 좋은 성능을 내도록 개선해야 합니다.

이 학습 과정을 반복하는 핵심 구조가 바로 Train Loop 입니다.

# Training Loop
nb_epochs = 100
for epoch in range(nb_epochs):
    model.train()
    train_loss = 0.0

    for x_batch, y_batch in train_loader:
        x_batch = torch.FloatTensor(x_batch).to(device)
        y_batch = torch.FloatTensor(y_batch).to(device)

        # Forward pass
        predictions = model(x_batch)
        loss = criterion(predictions, y_batch)

        # Backward pass and optimization
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.item() * x_batch.size(0)

    train_loss /= len(train_loader.dataset)

​

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· 모델을 `train()` 모드로 설정

· DataLoader를 순회하며 미니배치 학습 수행

· 순전파 (Forward) 연산 수행 (`model(x_batch)`)

· 손실 함수 계산 (`criterion(predictions, y_batch)`)

· 역전파 (Backward) 및 가중치 갱신 (`loss.backward()`, `optimizer.step()`)

· 학습 손실값 계산

· 이 과정을 Epoch 만큼 반복

​

​

※ Train / Eval. 모드의 차이

구분	train() 모드	eval() 모드
Dropout	활성화 (일부 뉴런 비활성)	비활성화 (모든 뉴런 활성)
Batch Normalization	미니배치 통계 사용	학습된 전체 통계 사용
목적	학습(Training)	평가(Validation/Test)

​

​

​

​

 

 

5. 검증 루프 (Validation Loop)

딥러닝 모델이 학습을 잘하고 있는지 확인하려면, 단순히 학습 데이터(Training Data)만 보는 것이 아니라 새로운 데이터(Validation Data) 에서도 잘 동작하는지 평가해야 합니다.

​

이를 위해 Validation Loop(검증 루프) 를 사용합니다.

​

앞서 Dataset을 준비할 때, Validation Data를 따로 준비한 것도 모두 Validation Loop에서 학습이 제대로 잘 이루어지고 있는지 확인하기 위해서 입니다.

    # Validation Loop
    model.eval()
    val_loss = 0.0
    with torch.no_grad():
        for x_batch, y_batch in val_loader:
            x_batch = torch.FloatTensor(x_batch).to(device)
            y_batch = torch.FloatTensor(y_batch).to(device)

            predictions = model(x_batch)
            loss = criterion(predictions, y_batch)
            val_loss += loss.item() * x_batch.size(0)

    val_loss /= len(val_loader.dataset)

​

​

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· 모델을 `eval()` 모드로 설정

· `torch.no_grad()` 블록 사용 (Gradient 계산 비활성화)

· Validation 데이터셋을 통한 손실값 평가

​

​

​

​

​

 

 

6. 학습률 스케줄링 (Learning Rate Scheduler)

딥러닝 모델이 학습할 때, 학습률(Learning Rate) 은 모델의 가중치를 얼마나 빠르게 조정할지를 결정하는 중요한 요소입니다. 너무 크면 최적의 해를 찾기 어렵고, 너무 작으면 학습이 너무 느려질 수 있습니다.

​

이를 해결하기 위해 Learning Rate Scheduling(학습률 스케줄링) 을 사용합니다.

즉, 학습이 진행됨에 따라 적절한 시점에 학습률을 조절 하여 더 효율적인 학습을 돕는 방법입니다.

​

일반적으로 Learning Rate 값은 큰 값에서 점점 작은 값으로 줄여가는데, 이렇게 값을 조정하는 이유는 큰 학습률로 빠르게 좋은 위치로 이동한 후에 점점 작은 값으로 정교하게 최적화시키는 과정을 거치고, 최종적으로는 최적점 근처에서 진동을 줄이고 안정적으로 수렴하도록 하기 위함입니다.

# Learning Rate Scheduler
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.9)
.
.
.
    # Learning Rate Step
    scheduler.step()

​

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· 학습률 스케줄러 (`optim.lr_scheduler.StepLR`)를 초기화하고 생성합니다.

· Train Loop에서 `scheduler.step()`을 사용하여 일정 Epoch마다 학습률 감소시킵니다.

​

​

Learning Rate Scheduling에 대해서는 아래 Post에서 자세히 다루고 있으니 도움이 되실 것입니다.

https://moonlight314.tistory.com/entry/9-Learning-Rate-Schedulers

9. Learning Rate Schedulers

 

​

​

​

​

​

7. Early Stopping 기법

딥러닝 Train Loop는 한 번 학습을 시작하면 폭주 기관차처럼 정해진 Epoch만큼 멈추지 않고 계속해서 학습을 합니다.

학습을 많이 하면 무조건 모델 성능이 좋아진다고 장담할 수 없습니다.

오히려 딥러닝 모델을 학습할 때, 너무 많이 학습하면 오히려 성능이 나빠질 수도 있는데, 이를 과적합(Overfitting) 이라고 합니다.

​

Early Stopping(조기 종료) 은 모델이 더 이상 성능이 좋아지지 않을 때 학습을 멈추는 기법입니다.

즉, 최적의 성능을 보이는 시점에서 학습을 자동으로 종료하여 과적합을 방지하는 것입니다.

# Early Stopping
class EarlyStopping:
    def __init__(self, patience=5, delta=0, save_path="best_model.pth"):
        self.patience = patience
        self.delta = delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
        self.save_path = save_path

    def __call__(self, val_loss, model):
        if self.best_loss is None:
            self.best_loss = val_loss
            self.save_checkpoint(val_loss, model)
        elif val_loss > self.best_loss - self.delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0
            self.save_checkpoint(val_loss, model)

    def save_checkpoint(self, val_loss, model):
        torch.save(model.state_dict(), self.save_path)
        print(f"Validation loss improved to {val_loss:.4f}. Model saved to {self.save_path}")

early_stopping = EarlyStopping(patience=10, delta=0.01, save_path="best_model.pth")
.
.
.
    # Early Stopping Check
    early_stopping(val_loss, model)
    if early_stopping.early_stop:
        print("Early stopping triggered.")
        break

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· `EarlyStopping` 클래스 정의 및 객체 생성

· Validation 손실을 기준으로 학습 중단 여부 결정 (`patience`, `delta` 활용)

· `torch.save()`로 최적 모델 저장

​

​

Early Stopping 기법에 대해서는 아래 Post에서 자세히 다루고 있으니 도움이 되실 것입니다.

https://moonlight314.tistory.com/entry/10-Early-Stopping

10. Early Stopping

 

​

​

​

​

​

 

8. 최고 성능의 모델 저장 및 불러오기

Train이 진행되면서 Validiation Dataset에서 가장 좋은 성능을 보이는 Model을 저장해 놓아야 합니다.

그래야만 나중에 Train 결과 모델을 사용할 수 있기 때문이니 이는 너무나 당연한 일입니다.

​

보통 Model을 저장하는 Code는 Early Stop Class 내부에 선언해 둡니다.

    def save_checkpoint(self, val_loss, model):
        torch.save(model.state_dict(), self.save_path)
        print(f"Validation loss improved to {val_loss:.4f}. Model saved to {self.save_path}")
.
.
.
# Load Best Model (Optional)
model.load_state_dict(torch.load("best_model.pth"))
model.to(device)
print("Best model loaded.")

​

위 Code가 하는 일을 간단하게 정리하면 아래와 같습니다.

· `EarlyStopping`을 활용하여 최적의 모델을 `best_model.pth`로 저장

· 학습 종료 후 `torch.load("best_model.pth")`를 이용하여 성능이 가장 좋은 모델을 불러옴

· 모델을 `to(device)`로 이동하여 실험 가능하도록 설정

​

​

​

이번 Post에서는 PyTorch Model Train Loop의 기본적인 요소에 대해서 알아보았습니다.

​

다음 Post에서는 각 요소들을 하나씩 살펴보는 자료를 준비해 보도록 하겠습니다.

​

감사합니다.

​

---

 

더욱 다양한 PyTorch 강의를 보시려면 아래 강의 목록을 읽어보시면 도움이 됩니다.

1. PyTorch 소개

https://moonlight314.tistory.com/entry/1-PyTorch-%EC%86%8C%EA%B0%9C

1. PyTorch 소개

---

2. PyTorch의 주요 Module 소개

https://moonlight314.tistory.com/entry/2-PyTorch%EC%9D%98-%EC%A3%BC%EC%9A%94-Module-%EC%86%8C%EA%B0%9C

2. PyTorch의 주요 Module 소개

---

3. Tensor

https://moonlight314.tistory.com/entry/3-Tensor

3. Tensor

---

4. Basic Train Loop

https://moonlight314.tistory.com/entry/4-Basic-Train-Loop

4. Basic Train Loop

---

5. Dataset & DataLoader

https://moonlight314.tistory.com/entry/5-Dataset-DataLoader

5. Dataset & DataLoader

---

6. 신경망 구성 - Container Class

https://moonlight314.tistory.com/entry/6-%EC%8B%A0%EA%B2%BD%EB%A7%9D-%EA%B5%AC%EC%84%B1-Container-Class

6. 신경망 구성 - Container Class

---

7. Loss Function( 손실 함수 )

https://moonlight314.tistory.com/entry/7-Loss-Function-%EC%86%90%EC%8B%A4-%ED%95%A8%EC%88%98

7. Loss Function( 손실 함수 )

---

8. Optimizers

https://moonlight314.tistory.com/entry/8-Optimizers

8. Optimizers

---

9. Learning Rate Schedulers

https://moonlight314.tistory.com/entry/9-Learning-Rate-Schedulers

9. Learning Rate Schedulers

---

10. Early Stopping

https://moonlight314.tistory.com/entry/10-Early-Stopping

10. Early Stopping