딥러닝 기초 핵심 개념 1

Loss Function

Loss Function은 모델의 예측값과 실제 값이 얼마나 유사한지를 판단하는 함수입니다. 작을수록 두 값이 유사합니다. 회귀와 분류에 따라 다양한 Loss Function이 사용됩니다.

 

회귀- 

평균절대오차(Mean Absolute Error): 두 값의 차이의 절대값의 전체 합의 평균 

$MAE = \frac{1}{N}\sum |y - \hat{y}|$

 

평균제곱오차(Mean Squared Error): 두 값의 차이의 제곱의 전체 합의 평균 

$MSE = \frac{1}{N}\sum_{i=1}^{N} (|y_{i} - \hat{y}_{i}|)^{2}$

RMSE: MSE의 제곱근(Root) 
$RMSE = \sqrt{\frac{1}{N}\sum_{i=1}^{N} (|y_{i} - \hat{y}_{i}|)^{2}}$

 

분류- 

Binary Cross Entropy(BCE), 

$Loss = -\frac{1}{N}\sum_{i=0}^{N}y_{i}\log(\hat{y_{i}})+(1 - y_{i})\log(1 - \hat{y_{i}})$

 

Categorical Cross Entropy(CCE)

$Loss = -\frac{1}{N}\sum_{i=0}^{N}\sum_{j=0}^{J}y_{j}\log(\hat{y_{j}})+(1 - y_{j})\log(1 - \hat{y_{j}})$

 

회귀 모델 - 평균제곱오차(Mean Squared Error, MSE)

import numpy as np

# 예측값과 실제값
predictions = np.array([2, 4, 6, 8])
targets = np.array([1, 3, 5, 7])

# 평균제곱오차 계산
def mean_squared_error(predictions, targets):
    return np.mean((predictions - targets) ** 2)

# Loss 계산
loss = mean_squared_error(predictions, targets)
print("Mean Squared Error Loss:", loss)

 

>>> Mean Squared Error Loss: 1.0

 

$\frac{((2 - 1)^{2} + (4 - 3)^{2} + (6 - 5)^{2} + (8 - 7)^{2}}{4} = 1$

 

 

Batch Size

 

Batch Size는 한 번의 학습에 사용되는 데이터의 수를 의미합니다. CPU나 GPU의 메모리에 맞추어 설정하며, 적절한 값을 선택하는 것이 중요합니다.

Epoch in Machine Learning

 MNIST 데이터셋을 사용하여 모델을 학습할 때 Batch Size를 설정하는 예시 코드입니다.

import torch
from torchvision import datasets, transforms

# 데이터셋 다운로드
train_data = datasets.MNIST(root='data', train=True, download=True, transform=transforms.ToTensor())

# DataLoader 설정
batch_size = 64
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True)

# 데이터 로드 및 학습
for batch_idx, (data, target) in enumerate(train_loader):
    # data와 target을 사용하여 모델을 학습
    pass

 

 

Feedforward Neural Network

 

Feedforward Neural Network는 데이터가 한 방향으로만 전달되는 구조로, 퍼셉트론의 기본 연산으로 실행됩니다.

Feedforward Neural Network

아래는 간단한 Feedforward Neural Network 입니다.

import torch
import torch.nn as nn

# 간단한 Feedforward Neural Network 정의
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 1)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x
        
# 모델 생성
model = SimpleNN()

# 입력 데이터 정의
input_data = torch.randn(32, 10)

# 모델에 입력 데이터 전달하여 출력값 계산
output = model(input_data)

 

 

Backpropagation

 

Backpropagation은 오차를 역으로 전파하여 가중치를 업데이트하는 알고리즘입니다. 이를 통해 모델이 학습을 진행하며 가중치를 조정합니다.

V.Lavrenko

 

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

# 모델 정의
model = nn.Linear(10, 1)

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

# 학습 반복
for epoch in range(num_epochs):
    for batch_idx, (data, target) in enumerate(train_loader):
        # Forward pass
        outputs = model(data)
        loss = criterion(outputs, target)
        
        # Backward pass 및 가중치 업데이트
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()