AI 학습 원리 Training의 핵심을 한 문장으로 요약하면 이렇습니다. “틀릴 때마다 조금씩 고쳐나가는 반복” 입니다. 사람이 자전거를 배울 때 넘어지고, 균형을 잡고, 페달 감각을 익히듯 AI도 오답을 측정하고, 오차를 줄이는 방향으로 내부 파라미터를 수없이 조정합니다. 이 글에서는 AI가 데이터를 받아 학습을 완료하기까지의 전 과정을 손실함수·경사하강법·역전파·과적합까지 그림·수식·파이썬 코드와 함께 완전히 풀어봅니다.
목차
- AI 학습이란 무엇인가 – 파라미터와 목표의 정의
- 손실함수(Loss Function) – 오답을 숫자로 측정하는 방법
- 경사하강법(Gradient Descent) – 오차를 줄이는 방향 탐색
- 역전파(Backpropagation) – 신경망 전체에 오차를 전달하는 원리
- 학습의 실전 흐름 – 에포크·배치·학습률·과적합 관리
- AI Training 전체 과정 요약과 현대 학습 기법의 발전
1. AI 학습이란 무엇인가 – 파라미터와 목표의 정의
AI가 ‘학습한다’는 말은 정확히 무엇을 의미할까요? 컴퓨터 과학적으로 정의하면 다음과 같습니다.
“주어진 데이터에 대해 손실(오차)을 최소화하는 파라미터(가중치)를 찾는 최적화 과정”
파라미터(Parameter)란 무엇인가
신경망의 각 연결선에는 가중치(Weight) 와 편향(Bias) 이라는 숫자가 붙어 있습니다. 이 숫자들이 바로 AI가 학습하면서 조정하는 파라미터입니다.
[단일 뉴런의 계산 과정]
입력값들 가중치 편향
x₁ ──×── w₁ ──┐
x₂ ──×── w₂ ──┼──→ (합산: Σxᵢwᵢ + b) ──→ 활성화 함수 ──→ 출력
x₃ ──×── w₃ ──┘ ↑
b (bias)
수식: output = f(w₁x₁ + w₂x₂ + w₃x₃ + b)
f = 활성화 함수 (ReLU, Sigmoid 등)
GPT-4 같은 대형 모델은 이 가중치의 수가 수천억 개에 달합니다. AI 학습이란 결국 이 수천억 개의 숫자를 최적값으로 조율하는 과정입니다.
학습의 목표 – 일반화(Generalization)
중요한 점은 AI의 목표가 단순히 학습 데이터를 암기하는 것이 아니라는 것입니다. 한 번도 본 적 없는 새 데이터에도 잘 작동하는 능력, 즉 일반화(Generalization)가 진짜 목표입니다.
[AI 학습의 올바른 목표]
나쁜 학습: 훈련 데이터 100% 정답 → 새 데이터 실패 (과적합)
좋은 학습: 훈련 데이터 95% 정답 → 새 데이터 93% 정답 (일반화)
비유: 시험 문제를 통째로 외운 학생(과적합) vs
개념을 이해해 응용하는 학생(일반화)
지도학습 기준 학습 데이터의 구성
전체 데이터셋
├── 훈련 데이터 (Training Set) : 70~80% → 모델 학습에 사용
├── 검증 데이터 (Validation Set) : 10~15% → 학습 중 성능 점검
└── 테스트 데이터 (Test Set) : 10~15% → 최종 성능 평가
2. 손실함수(Loss Function) – 오답을 숫자로 측정하는 방법
AI가 학습하려면 먼저 “지금 얼마나 틀렸는가” 를 측정할 수 있어야 합니다. 이 역할을 하는 것이 손실함수(Loss Function) 입니다. 손실함수는 모델의 예측값과 실제 정답 사이의 차이를 하나의 숫자(손실값, Loss)로 변환합니다.
손실함수의 핵심 역할
[손실함수의 위치]
입력 데이터 ──→ [모델] ──→ 예측값(ŷ)
↓
실제 정답(y) ──→ [손실함수] ──→ 손실값(L)
↓
이 숫자를 최소화하는 것이 학습 목표
손실값이 0에 가까울수록 모델이 정답에 가깝고, 클수록 많이 틀렸다는 의미입니다.
대표적인 손실함수 3가지
① 평균 제곱 오차 (MSE – Mean Squared Error) 회귀 문제(연속적인 숫자 예측)에 주로 사용합니다. 예측값과 정답의 차이를 제곱해 평균 냅니다. 제곱을 하는 이유는 방향(양수/음수)을 없애고, 큰 오차에 더 큰 패널티를 주기 위함입니다.
python
import numpy as np
def mse_loss(y_true, y_pred):
"""
y_true: 실제 정답값 배열
y_pred: 모델 예측값 배열
"""
return np.mean((y_true - y_pred) ** 2)
# 예시
y_true = np.array([3.0, 5.0, 2.5, 7.0])
y_pred = np.array([2.8, 5.2, 2.0, 6.5])
loss = mse_loss(y_true, y_pred)
print(f"MSE 손실값: {loss:.4f}") # MSE 손실값: 0.1325
# 수식: L = (1/n) × Σ(yᵢ - ŷᵢ)²
② 크로스 엔트로피 손실 (Cross-Entropy Loss) 분류 문제(고양이/개 구분, 감성 분석 등)에 사용합니다. 모델이 정답 클래스에 낮은 확률을 예측할수록 손실값이 급격히 커지는 특성을 가집니다.
python
def binary_cross_entropy(y_true, y_pred):
"""
이진 분류용 크로스 엔트로피
y_true: 0 또는 1
y_pred: 0~1 사이의 확률값
"""
epsilon = 1e-15 # log(0) 방지를 위한 아주 작은 값
y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
return -np.mean(
y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)
)
# 예시: 스팸 메일 분류
y_true = np.array([1, 0, 1, 1]) # 실제: 스팸/정상/스팸/스팸
y_pred = np.array([0.9, 0.1, 0.8, 0.3]) # 예측 확률
loss = binary_cross_entropy(y_true, y_pred)
print(f"Cross-Entropy 손실값: {loss:.4f}") # 0.3 부분이 손실 키움
③ 손실함수 선택 기준 요약
| 문제 유형 | 출력 형태 | 권장 손실함수 |
|---|---|---|
| 회귀 (연속값 예측) | 실수 | MSE, MAE, Huber Loss |
| 이진 분류 | 0 또는 1 | Binary Cross-Entropy |
| 다중 분류 | 클래스 중 하나 | Categorical Cross-Entropy |
| 생성 모델 (GAN) | 이미지·텍스트 | 적대적 손실 + 재건 손실 |
3. 경사하강법(Gradient Descent) – 오차를 줄이는 방향 탐색
손실값을 구했다면 이제 그 손실을 어떻게 줄일 것인가가 문제입니다. 이 최적화 알고리즘이 경사하강법(Gradient Descent) 입니다. AI Training 전체에서 가장 핵심적인 수학 개념입니다.
산에서 내려오는 비유
경사하강법을 가장 직관적으로 이해하는 방법은 산 비유입니다.
[경사하강법 시각화]
손실값(L)
│
│ ╲ ╱
│ ╲ ╱╲ ╱
│ ╲ ╱ ╲ ╱
│ ╲ ╱ ╲ ╱
│ ╲___╱ ╲____╱
│ ↑
│ 전역 최솟값 (Global Minimum)
│ ← 우리가 도달하고 싶은 지점
└────────────────────────────→ 가중치(W)
규칙:
현재 위치에서 기울기(Gradient)를 계산
기울기의 반대 방향으로 한 걸음 이동
손실값이 최소가 되는 지점에 도달할 때까지 반복
산 정상(높은 손실값)에서 출발해 가장 경사가 급한 방향으로 내려가다 보면 결국 골짜기(최솟값)에 도달하게 됩니다.
경사하강법 수식과 코드
python
# 경사하강법 핵심 수식:
# W_new = W_old - η × ∂L/∂W
# η (에타): 학습률 (Learning Rate)
# ∂L/∂W: 손실함수의 가중치에 대한 편미분 (기울기, Gradient)
import numpy as np
def gradient_descent_demo():
"""단순 2차 함수 L(w) = w² 에서 최솟값 탐색 시뮬레이션"""
w = 10.0 # 가중치 초기값 (산 정상 출발)
lr = 0.1 # 학습률 (한 걸음의 크기)
epochs = 30 # 반복 횟수
print(f"{'Step':>5} | {'W (가중치)':>12} | {'Loss (w²)':>12} | {'Gradient':>10}")
print("-" * 50)
for step in range(epochs):
loss = w ** 2 # 손실함수: L = w²
gradient = 2 * w # 손실의 기울기: dL/dw = 2w
w = w - lr * gradient # 가중치 업데이트
if step % 5 == 0:
print(f"{step:>5} | {w:>12.4f} | {loss:>12.4f} | {gradient:>10.4f}")
gradient_descent_demo()
# 출력 예시:
# Step | W (가중치) | Loss (w²) | Gradient
# --------------------------------------------------
# 0 | 8.0000 | 100.0000 | 20.0000
# 5 | 2.0972 | 26.2144 | 5.2429
# 10 | 0.5505 | 4.3998 | 1.1010
# 15 | 0.1444 | 0.3031 | 0.2888
# 20 | 0.0379 | 0.0209 | 0.0758
# 25 | 0.0100 | 0.0014 | 0.0199
# → w가 점점 0(최솟값)에 수렴
경사하강법의 세 가지 변형
학습 데이터 전체를 한 번에 처리하는 방식(BGD)은 메모리와 속도 문제가 있어, 현실에서는 아래 세 가지 방식을 상황에 맞게 씁니다.
| 방식 | 설명 | 장점 | 단점 |
|---|---|---|---|
| BGD (Batch GD) | 전체 데이터로 한 번 업데이트 | 안정적 수렴 | 메모리 과다, 속도 느림 |
| SGD (Stochastic GD) | 데이터 1개마다 업데이트 | 빠름, 지역 최솟값 탈출 가능 | 불안정, 노이즈 큼 |
| Mini-Batch GD | 소규모 묶음(32~512개)마다 업데이트 | 속도·안정성 균형 | 현업 표준 |
학습률(Learning Rate)의 중요성
학습률이 너무 크면:
W ──→ W' ──→ W'' ──→ (최솟값을 건너뜀 → 발산)
↑ ↑
골짜기 왼쪽 골짜기 오른쪽 (왔다갔다 반복)
학습률이 너무 작으면:
W → W'→ W''→ ... (극히 조금씩만 이동 → 학습이 너무 느림)
최적의 학습률:
적당한 보폭으로 빠르고 안정적으로 최솟값에 수렴
실전 팁: Adam, AdaGrad 등 학습률을 자동 조정하는
적응형 옵티마이저(Adaptive Optimizer)를 사용
4. 역전파(Backpropagation) – 신경망 전체에 오차를 전달하는 원리
경사하강법이 “어느 방향으로 이동할지”를 알려준다면, 역전파(Backpropagation) 는 “신경망 내 수천억 개의 가중치 각각에 대한 기울기를 효율적으로 계산”하는 알고리즘입니다. 1986년 럼멜하트(Rumelhart)가 정리한 이 알고리즘은 현대 딥러닝의 근간입니다.
순전파(Forward Pass)와 역전파(Backward Pass)
AI의 한 학습 스텝은 항상 두 단계로 구성됩니다.
[학습 1 스텝 = 순전파 + 역전파]
──────────── 순전파 (Forward Pass) ────────────→
입력(X) ──→ Layer1 ──→ Layer2 ──→ Layer3 ──→ 예측값(ŷ)
↓
손실 계산: L = Loss(ŷ, y)
↓
←─────────── 역전파 (Backward Pass) ───────────
입력(X) ←── Layer1 ←── Layer2 ←── Layer3 ←── 손실(L)
↑ ↑ ↑
가중치 가중치 가중치
업데이트 업데이트 업데이트
(∂L/∂W₁) (∂L/∂W₂) (∂L/∂W₃)
순전파: 입력 데이터가 앞으로 흘러가며 예측값을 만들어냄 역전파: 손실값이 뒤로 흘러가며 각 층의 가중치가 얼마나 손실에 기여했는지 계산
연쇄 법칙(Chain Rule) – 역전파의 수학적 핵심
역전파가 가능한 이유는 미적분학의 연쇄 법칙(Chain Rule) 덕분입니다.
[연쇄 법칙 직관적 이해]
L(손실) ← f₃(W₃) ← f₂(W₂) ← f₁(W₁) ← X(입력)
W₁에 대한 손실의 기울기:
∂L/∂W₁ = ∂L/∂f₃ × ∂f₃/∂f₂ × ∂f₂/∂f₁ × ∂f₁/∂W₁
→ 각 층의 기울기를 뒤에서 앞으로 곱해나가면 된다!
→ 이미 계산된 기울기를 재사용하므로 매우 효율적
역전파 동작 원리 – 간단한 예시 코드
python
import numpy as np
class SimpleNeuralNet:
"""2층 신경망 순전파·역전파 직접 구현 (NumPy Only)"""
def __init__(self, input_size, hidden_size, output_size, lr=0.01):
# 가중치 초기화 (Xavier 초기화)
self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(1/input_size)
self.b1 = np.zeros((1, hidden_size))
self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(1/hidden_size)
self.b2 = np.zeros((1, output_size))
self.lr = lr
def relu(self, z):
return np.maximum(0, z)
def relu_derivative(self, z):
return (z > 0).astype(float) # z > 0이면 1, 아니면 0
def sigmoid(self, z):
return 1 / (1 + np.exp(-z))
def forward(self, X):
"""순전파: 입력 → 예측값"""
self.X = X
self.z1 = X @ self.W1 + self.b1 # 1층 선형 변환
self.a1 = self.relu(self.z1) # 1층 활성화 (ReLU)
self.z2 = self.a1 @ self.W2 + self.b2 # 2층 선형 변환
self.a2 = self.sigmoid(self.z2) # 출력층 활성화 (Sigmoid)
return self.a2
def backward(self, y_true):
"""역전파: 손실 → 가중치 기울기 계산 → 업데이트"""
n = y_true.shape[0]
# ── 출력층 역전파 ──────────────────────────
# 크로스 엔트로피 + 시그모이드 미분 결합
dL_da2 = self.a2 - y_true # 손실의 출력에 대한 기울기
dL_dW2 = self.a1.T @ dL_da2 / n # W2 기울기
dL_db2 = np.mean(dL_da2, axis=0, keepdims=True)
# ── 은닉층 역전파 (연쇄 법칙 적용) ─────────
dL_da1 = dL_da2 @ self.W2.T # 역방향으로 기울기 전달
dL_dz1 = dL_da1 * self.relu_derivative(self.z1) # ReLU 미분
dL_dW1 = self.X.T @ dL_dz1 / n # W1 기울기
dL_db1 = np.mean(dL_dz1, axis=0, keepdims=True)
# ── 가중치 업데이트 (경사하강법 적용) ───────
self.W2 -= self.lr * dL_dW2
self.b2 -= self.lr * dL_db2
self.W1 -= self.lr * dL_dW1
self.b1 -= self.lr * dL_db1
# ── 학습 실행 예시 ──────────────────────────────
np.random.seed(42)
X = np.random.randn(100, 4) # 100개 샘플, 4개 특징
y = (X[:, 0] + X[:, 1] > 0).astype(float).reshape(-1, 1) # 이진 레이블
model = SimpleNeuralNet(input_size=4, hidden_size=8, output_size=1, lr=0.05)
for epoch in range(200):
pred = model.forward(X)
model.backward(y)
if epoch % 50 == 0:
loss = -np.mean(y * np.log(pred + 1e-15) + (1-y) * np.log(1-pred + 1e-15))
print(f"Epoch {epoch:>4} | Loss: {loss:.4f}")
# 출력:
# Epoch 0 | Loss: 0.7134
# Epoch 50 | Loss: 0.5421
# Epoch 100 | Loss: 0.3892
# Epoch 150 | Loss: 0.2741 ← 손실이 꾸준히 감소
5. 학습의 실전 흐름 – 에포크·배치·학습률·과적합 관리
이론을 넘어 실제 AI 모델을 훈련할 때 반드시 이해해야 하는 실전 개념들을 정리합니다.
에포크(Epoch)와 배치(Batch)
[에포크와 배치의 관계]
전체 훈련 데이터: 10,000개 샘플
배치 크기(Batch Size): 100개
→ 1 에포크 = 100번의 가중치 업데이트 (10,000 ÷ 100)
Epoch 1:
Batch 1 (샘플 1~100) → 순전파 → 역전파 → 업데이트 #1
Batch 2 (샘플 101~200) → 순전파 → 역전파 → 업데이트 #2
...
Batch 100(샘플 9901~10000)→ 순전파 → 역전파 → 업데이트 #100
Epoch 2: (데이터 셔플 후 다시 반복)
...
Epoch N: (손실이 충분히 줄어들 때까지 반복)
과적합(Overfitting)과 방지 기법
과적합은 모델이 훈련 데이터를 ‘외워버려’ 새 데이터에 일반화하지 못하는 현상입니다. AI Training에서 가장 흔히 만나는 문제입니다.
[과적합 진단 – 손실 곡선 패턴]
손실값
│
│ 훈련 손실 ─────────────────────────────────→ 계속 감소
│
│ 검증 손실 ───────╮
│ ╰──────────────────────→ 어느 순간부터 증가
│ ↑
│ 과적합 시작 지점 (Early Stopping 적용 구간)
└───────────────────────────────────────────→ Epoch
과적합 방지 4가지 핵심 기법
python
import torch
import torch.nn as nn
class RegularizedNet(nn.Module):
def __init__(self):
super().__init__()
self.network = nn.Sequential(
nn.Linear(128, 256),
nn.ReLU(),
# 기법 1: 드롭아웃 (Dropout)
# 학습 중 무작위로 뉴런 20%를 0으로 꺼서 특정 경로 의존 방지
nn.Dropout(p=0.2),
nn.Linear(256, 256),
# 기법 2: 배치 정규화 (Batch Normalization)
# 각 층의 출력을 정규화해 학습 안정성·속도 향상
nn.BatchNorm1d(256),
nn.ReLU(),
nn.Dropout(p=0.3),
nn.Linear(256, 10)
)
def forward(self, x):
return self.network(x)
model = RegularizedNet()
# 기법 3: L2 정규화 (Weight Decay)
# 가중치가 너무 커지면 패널티를 부여해 단순한 모델 유도
optimizer = torch.optim.Adam(
model.parameters(),
lr=0.001,
weight_decay=1e-4 # L2 정규화 계수
)
# 기법 4: 조기 종료 (Early Stopping)
# 검증 손실이 개선되지 않으면 학습을 조기에 멈춤
best_val_loss = float('inf')
patience = 10 # 10 에포크 동안 개선 없으면 중단
no_improve = 0
for epoch in range(1000):
# ... 학습 코드 ...
val_loss = 0.35 # 예시값 (실제로는 검증 데이터로 계산)
if val_loss < best_val_loss:
best_val_loss = val_loss
no_improve = 0
# torch.save(model.state_dict(), 'best_model.pt') # 최적 모델 저장
else:
no_improve += 1
if no_improve >= patience:
print(f"Early Stopping at Epoch {epoch}")
break
현대 옵티마이저 – Adam이 표준이 된 이유
[옵티마이저 발전 계보]
SGD (1951)
↓ 문제: 학습률 고정 → 수렴 불안정
AdaGrad (2011)
↓ 해결: 파라미터별 학습률 조정
↓ 문제: 학습률이 계속 감소해 학습 멈춤
RMSProp (2012)
↓ 해결: 최근 기울기에 더 높은 가중치
Adam (2014) ← 현업 표준
↓ = RMSProp + 모멘텀(관성) 결합
↓ 대부분의 상황에서 빠르고 안정적
AdamW (2019) ← Transformer 시대 표준
= Adam + 가중치 감쇠 분리 (더 정확한 정규화)
6. AI Training 전체 과정 요약과 현대 학습 기법의 발전
지금까지 배운 내용을 하나의 흐름으로 통합하겠습니다.
AI Training 전체 파이프라인
[AI Training 전체 흐름도]
① 데이터 준비
원본 데이터 → 전처리(정규화, 증강) → Train/Val/Test 분할
② 모델 설계
신경망 구조 결정 (층 수, 뉴런 수, 활성화 함수)
③ 학습 루프 (Epoch 반복)
┌─────────────────────────────────────────┐
│ 배치 데이터 로드 │
│ ↓ │
│ 순전파 (Forward Pass) │
│ 예측값 계산 │
│ ↓ │
│ 손실 계산 (Loss Function) │
│ 예측값 vs 정답 오차 수치화 │
│ ↓ │
│ 역전파 (Backward Pass) │
│ 각 가중치의 기울기 계산 │
│ ↓ │
│ 옵티마이저 업데이트 (Adam 등) │
│ W = W - lr × gradient │
└─────────────────────────────────────────┘
↓ (모든 배치 처리 = 1 Epoch 완료)
검증 데이터로 성능 측정
↓
과적합 체크 → 조기 종료 판단
↓
최적 모델 저장
④ 테스트 & 배포
한 번도 본 적 없는 테스트 데이터로 최종 성능 평가
현대 AI 학습의 패러다임 변화
전통적인 학습 방식에서 현대 대규모 모델로의 전환은 세 가지 키워드로 요약됩니다.
① 사전 훈련 + 미세 조정 (Pre-training + Fine-tuning) GPT·BERT처럼 수천억 개의 텍스트로 일반 지식을 먼저 학습(사전 훈련)한 뒤, 특정 작업에 맞게 소량의 데이터로 추가 학습(미세 조정)하는 방식입니다. 처음부터 다시 학습하는 비용을 획기적으로 줄였습니다.
② 전이 학습 (Transfer Learning) 이미 학습된 모델의 가중치를 새 문제에 재사용합니다. 사람이 수영을 배우면 수상 스포츠 전반에 응용할 수 있듯, AI도 이미지 인식 모델의 저수준 특징 추출 능력을 의료 영상 진단에 전용할 수 있습니다.
③ RLHF (인간 피드백 강화학습) ChatGPT가 사용한 방식으로, 인간 평가자가 모델의 출력에 점수를 매기고 그 피드백으로 강화학습을 수행합니다. 단순히 정답을 맞히는 것을 넘어 “인간이 선호하는 방식으로 대답” 하도록 학습시키는 기술입니다.
[RLHF 간략 흐름]
사전 훈련 모델 (GPT)
↓
지도 미세 조정 (SFT)
↓
보상 모델 학습 (인간 선호도 데이터 학습)
↓
PPO 강화학습 (보상 모델 점수 최대화)
↓
ChatGPT / Claude 등 대화형 AI 완성
결론
AI 학습 원리 Training의 본질은 오차를 측정하고(손실함수), 오차를 줄이는 방향을 찾고(경사하강법), 신경망 전체에 그 방향을 전파해(역전파) 가중치를 조금씩 조정하는 반복 과정입니다. 이 단순한 원리가 수천억 번 반복되면서 언어를 이해하고, 이미지를 인식하고, 바둑 세계 챔피언을 이기는 AI가 만들어집니다. 이 원리를 이해했다면, 다음 단계로 PyTorch나 TensorFlow로 직접 모델을 구현해보는 것을 강력히 권합니다.
답글 남기기
댓글을 달기 위해서는 로그인해야합니다.