Ver3.0 ๐ค ์์ฐ์ด ์์ฑ์ ์ํ GPT ๋ชจ๋ธ ๊ตฌํ ์์ ์ ๋ณต

๐ค ์์ฐ์ด ์์ฑ์ ์ํ GPT ๋ชจ๋ธ ๊ตฌํ ์์ ์ ๋ณต
์น๊ตฌ์ฒ๋ผ ์ฝ๊ฒ ๋ฐฐ์ฐ๋ GPT ๋ชจ๋ธ์ ๋ชจ๋ ๊ฒ ๐ฌโจ
๐ฏ GPT ๋ชจ๋ธ, ๋์ฒด ๋ญ๊ธธ๋?
์์ฆ AI๊ฐ ๊ธ์ ์ด๋ค๋ ์๊ธฐ ๋ง์ด ๋ค์ด๋ดค์ง? ๐ ChatGPT, GPT-4 ๊ฐ์ ์ด๋ฆ๋ค์ด ๋ด์ค์๋ ์์ฃผ ๋์ค๊ณ ๋ง์ด์ผ. ๊ทผ๋ฐ ์ด๋ฐ ๋ชจ๋ธ๋ค์ด ์ด๋ป๊ฒ ์๋ํ๋์ง, ์ง์ ๋ง๋ค ์ ์๋์ง ๊ถ๊ธํ์ง ์์?
GPT๋ Generative Pre-trained Transformer์ ์ฝ์์ผ. ํ์ด์ ์ค๋ช
ํ๋ฉด "๋ฏธ๋ฆฌ ํ์ต๋ ์์ฑํ ํธ๋์คํฌ๋จธ"๋ผ๋ ๋ป์ธ๋ฐ, ์ฝ๊ฒ ๋งํ๋ฉด ์์ฒญ๋ ์์ ํ
์คํธ๋ฅผ ์ฝ๊ณ ํ์ตํด์ ์ฌ๋์ฒ๋ผ ์์ฐ์ค๋ฌ์ด ๋ฌธ์ฅ์ ๋ง๋ค์ด๋ด๋ ์ธ๊ณต์ง๋ฅ ๋ชจ๋ธ์ด๋ผ๊ณ ๋ณด๋ฉด ๋ผ! ๐
์ด ๊ธ์์๋ GPT ๋ชจ๋ธ์ ์ง์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์น๊ตฌ์๊ฒ ์ค๋ช
ํ๋ฏ์ด ์ฐจ๊ทผ์ฐจ๊ทผ ์๋ ค์ค๊ฒ. ํ๋ก๊ทธ๋๋ฐ ๊ฒฝํ์ด ์๋ค๋ฉด ๋ ์ข๊ฒ ์ง๋ง, ์์ด๋ ๊ด์ฐฎ์. ์ต๋ํ ์ฝ๊ฒ ํ์ด์ ์ค๋ช
ํ ํ
๋๊น! ๐ช
๐ GPT ๋ชจ๋ธ์ ํต์ฌ ๊ฐ๋ ์ดํดํ๊ธฐ
1๏ธโฃ ํธ๋์คํฌ๋จธ ์ํคํ ์ฒ
GPT์ ํต์ฌ์ ๋ฐ๋ก ํธ๋์คํฌ๋จธ(Transformer)๋ผ๋ ๊ตฌ์กฐ์ผ. 2017๋
๊ตฌ๊ธ์ด ๋ฐํํ "Attention is All You Need"๋ผ๋ ๋
ผ๋ฌธ์์ ์ฒ์ ์๊ฐ๋๋๋ฐ, ์ด๊ฒ ์ ๋ง ํ๋ช
์ ์ด์์ด! ๐ฎ
๊ธฐ์กด์ RNN(์ํ ์ ๊ฒฝ๋ง)์ด๋ LSTM ๊ฐ์ ๋ชจ๋ธ๋ค์ ๋ฌธ์ฅ์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ์ด. ๋ง์น ์ฑ
์ ํ ๊ธ์์ฉ ์ฝ๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ผ. ๊ทผ๋ฐ ํธ๋์คํฌ๋จธ๋ ๋ฌธ์ฅ ์ ์ฒด๋ฅผ ํ ๋ฒ์ ๋ณด๋ฉด์ ๊ฐ ๋จ์ด ๊ฐ์ ๊ด๊ณ๋ฅผ ํ์
ํ ์ ์์ด. ํจ์ฌ ํจ์จ์ ์ด๊ณ ๋น ๋ฅด์ง! โก
ํธ๋์คํฌ๋จธ์ ๊ฐ์ฅ ์ค์ํ ํน์ง์ ๋ฐ๋ก "์ดํ
์
๋ฉ์ปค๋์ฆ(Attention Mechanism)"์ด์ผ. ์ด๊ฑด ๋ฌธ์ฅ์์ ์ด๋ค ๋จ์ด๊ฐ ๋ค๋ฅธ ๋จ์ด์ ์ผ๋ง๋ ๊ด๋ จ์ด ์๋์ง๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ์ด์ผ.
2๏ธโฃ ์ ํ ์ดํ ์ (Self-Attention)
์๋ฅผ ๋ค์ด๋ณผ๊ฒ. "๊ณ ์์ด๊ฐ ๋งคํธ ์์ ์์๋ค"๋ผ๋ ๋ฌธ์ฅ์ด ์๋ค๊ณ ํด๋ณด์. ๐ฑ
์ฌ๊ธฐ์ "์์๋ค"๋ผ๋ ๋จ์ด๋ฅผ ์ดํดํ๋ ค๋ฉด "๊ณ ์์ด๊ฐ"๋ผ๋ ์ฃผ์ด๋ฅผ ์์์ผ ํ๊ณ , "๋งคํธ ์์"๋ผ๋ ์ฅ์๋ ์์์ผ ํด. ์
ํ ์ดํ
์
์ ์ด๋ ๊ฒ ํ ๋ฌธ์ฅ ๋ด์์ ๊ฐ ๋จ์ด๊ฐ ๋ค๋ฅธ ๋ชจ๋ ๋จ์ด๋ค๊ณผ ์ด๋ค ๊ด๊ณ๋ฅผ ๋งบ๊ณ ์๋์ง๋ฅผ ๊ณ์ฐํด์ค.
์์์ผ๋ก ํํํ๋ฉด ์ด๋ ๊ฒ ๋ผ:
Attention(Q, K, V) = softmax(QK^T / โd_k)V
์ฌ๊ธฐ์:
โข Q (Query): ํ์ฌ ์ฃผ๋ชฉํ๊ณ ์๋ ๋จ์ด
โข K (Key): ๋น๊ต ๋์์ด ๋๋ ๋จ์ด๋ค
โข V (Value): ์ค์ ๋ก ๊ฐ์ ธ์ฌ ์ ๋ณด
โข d_k: ํค ๋ฒกํฐ์ ์ฐจ์
๋ณต์กํด ๋ณด์ด์ง? ๐
๊ทผ๋ฐ ๊ฐ๋
์ ๊ฐ๋จํด. "์ด ๋จ์ด๋ฅผ ์ดํดํ๋ ค๋ฉด ๋ฌธ์ฅ์ ๋ค๋ฅธ ์ด๋ค ๋จ์ด๋ค์ ์ง์คํด์ผ ํ ๊น?"๋ฅผ ๊ณ์ฐํ๋ ๊ฑฐ์ผ!
3๏ธโฃ ๋ฉํฐ ํค๋ ์ดํ ์ (Multi-Head Attention)
ํ๋์ ์ดํ
์
๋ง์ผ๋ก๋ ๋ถ์กฑํ ์ ์์ด. ๊ทธ๋์ GPT๋ ์ฌ๋ฌ ๊ฐ์ ์ดํ
์
์ ๋์์ ์ฌ์ฉํด. ์ด๊ฑธ ๋ฉํฐ ํค๋ ์ดํ
์
์ด๋ผ๊ณ ๋ถ๋ฌ! ๐ญ
๋ง์น ์ฌ๋ฌ ๋ช
์ ์ ๋ฌธ๊ฐ๊ฐ ๊ฐ์ ๋ฌธ์ฅ์ ๋ค๋ฅธ ๊ด์ ์์ ๋ถ์ํ๋ ๊ฒ๊ณผ ๋น์ทํด. ์ด๋ค ํค๋๋ ๋ฌธ๋ฒ์ ๊ด๊ณ์ ์ง์คํ๊ณ , ๋ค๋ฅธ ํค๋๋ ์๋ฏธ์ ๊ด๊ณ์ ์ง์คํ๋ ์์ด์ง. ์ด๋ ๊ฒ ํ๋ฉด ๋ฌธ์ฅ์ ๋ ํ๋ถํ๊ฒ ์ดํดํ ์ ์์ด! ๐
๐ ๏ธ GPT ๋ชจ๋ธ ๊ตฌํ ์ค๋นํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก GPT ๋ชจ๋ธ์ ๊ตฌํํด๋ณผ ๊ฑฐ์ผ! ๊ฑฑ์ ๋ง, ์ฐจ๊ทผ์ฐจ๊ทผ ๋ฐ๋ผ์ค๋ฉด ๋ผ. ๐
๋จผ์ ํ์ํ ๋๊ตฌ๋ค์ ์ค๋นํด์ผ ํด. ์๋ฆฌ๋ฅผ ํ๋ ค๋ฉด ์ฌ๋ฃ์ ๋๊ตฌ๊ฐ ํ์ํ๋ฏ์ด ๋ง์ด์ผ! ๐ณ
Python์ ์ฌ์ฉํ ๊ฑฐ๊ณ , ์ฃผ๋ก PyTorch๋ผ๋ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ๋ฅผ ์ธ ๊ฑฐ์ผ. TensorFlow๋ฅผ ์จ๋ ๋์ง๋ง, PyTorch๊ฐ ์ข ๋ ์ง๊ด์ ์ด๊ณ ์ฐ๊ตฌ์ฉ์ผ๋ก ๋ง์ด ์ฐ์ฌ์ ์ด๊ฑธ๋ก ์ค๋ช ํ ๊ฒ!
pip install torch torchvision torchaudio
pip install transformers
pip install numpy pandas
pip install tokenizers
pip install matplotlib seaborn
๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ญํ ์ ์ค๋ช
ํ๋ฉด:
โข torch: PyTorch ๋ฉ์ธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ์ ๊ฒฝ๋ง ๊ตฌ์ถ์ ํต์ฌ! ๐ฅ
โข transformers: Hugging Face์์ ๋ง๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ์ฌ์ ํ์ต๋ ๋ชจ๋ธ๋ค์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์์ด
โข numpy: ์์น ๊ณ์ฐ์ฉ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
โข tokenizers: ํ
์คํธ๋ฅผ ํ ํฐ์ผ๋ก ๋๋๋ ๋๊ตฌ
โข matplotlib: ํ์ต ๊ณผ์ ์ ์๊ฐํํ๋ ๋ฐ ์ ์ฉํด ๐
์ปดํจํฐ๋ ํ
์คํธ๋ฅผ ์ง์ ์ดํดํ ์ ์์ด. ๊ทธ๋์ ํ
์คํธ๋ฅผ ์ซ์๋ก ๋ณํํด์ผ ํ๋๋ฐ, ์ด ๊ณผ์ ์ ํ ํฐํ(Tokenization)๋ผ๊ณ ํด! ๐ข
์๋ฅผ ๋ค์ด "์๋
ํ์ธ์"๋ผ๋ ๋ฌธ์ฅ์ ํ ํฐํํ๋ฉด:
โข ๋จ์ด ๋จ์: ["์๋
ํ์ธ์"] โ [1234]
โข ์๋ธ์๋ ๋จ์: ["์๋
", "ํ์ธ์"] โ [567, 890]
โข ๋ฌธ์ ๋จ์: ["์", "๋
", "ํ", "์ธ", "์"] โ [10, 11, 12, 13, 14]
GPT๋ ์ฃผ๋ก BPE(Byte Pair Encoding)๋ผ๋ ์๋ธ์๋ ํ ํฐํ ๋ฐฉ์์ ์ฌ์ฉํด. ์ด ๋ฐฉ๋ฒ์ ์์ฃผ ๋์ค๋ ๋ฌธ์ ์กฐํฉ์ ํ๋์ ํ ํฐ์ผ๋ก ๋ง๋ค์ด์, ํจ์จ์ ์ผ๋ก ์ดํ๋ฅผ ๊ตฌ์ฑํ ์ ์์ด! ๐ฏ
๐๏ธ GPT ๋ชจ๋ธ ์ํคํ ์ฒ ๊ตฌํํ๊ธฐ
์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก GPT ๋ชจ๋ธ์ ๊ตฌ์กฐ๋ฅผ ์ฝ๋๋ก ๊ตฌํํด๋ณผ ๊ฑฐ์ผ! ์ฒ์๋ถํฐ ๋๊น์ง ์ฐจ๊ทผ์ฐจ๊ทผ ๋ง๋ค์ด๋ณด์. ๐
๐ง 1๋จ๊ณ: ์๋ฒ ๋ฉ ๋ ์ด์ด ๊ตฌํ
๋จผ์ ํ ํฐ์ ๋ฒกํฐ๋ก ๋ณํํ๋ ์๋ฒ ๋ฉ ๋ ์ด์ด๋ฅผ ๋ง๋ค์ด์ผ ํด. ์๋ฒ ๋ฉ์ ๊ฐ ํ ํฐ์ ๊ณ ์ฐจ์ ๊ณต๊ฐ์ ์ ์ผ๋ก ํํํ๋ ๊ฑฐ์ผ. ๋น์ทํ ์๋ฏธ๋ฅผ ๊ฐ์ง ๋จ์ด๋ค์ ๊ฐ๊น์ด ์์น์ ๋์ด๊ฒ ๋ผ! ๐
import torch
import torch.nn as nn
import math
class GPTEmbedding(nn.Module):
def __init__(self, vocab_size, d_model, max_len=512):
super(GPTEmbedding, self).__init__()
# ํ ํฐ ์๋ฒ ๋ฉ: ๊ฐ ํ ํฐ์ ๋ฒกํฐ๋ก ๋ณํ
self.token_embedding = nn.Embedding(vocab_size, d_model)
# ์์น ์๋ฒ ๋ฉ: ํ ํฐ์ ์์น ์ ๋ณด๋ฅผ ์ธ์ฝ๋ฉ
self.position_embedding = nn.Embedding(max_len, d_model)
self.d_model = d_model
def forward(self, x):
# x: (batch_size, seq_len)
seq_len = x.size(1)
# ์์น ์ธ๋ฑ์ค ์์ฑ
positions = torch.arange(0, seq_len).unsqueeze(0).to(x.device)
# ํ ํฐ ์๋ฒ ๋ฉ + ์์น ์๋ฒ ๋ฉ
token_emb = self.token_embedding(x) * math.sqrt(self.d_model)
pos_emb = self.position_embedding(positions)
return token_emb + pos_emb
์ฌ๊ธฐ์ ์ค์ํ ํฌ์ธํธ๋ ๋ ๊ฐ์ง์ผ:
โ ํ ํฐ ์๋ฒ ๋ฉ: ๊ฐ ๋จ์ด๋ฅผ ๋ฒกํฐ๋ก ๋ณํํด. ์๋ฅผ ๋ค์ด "๊ณ ์์ด"๋ผ๋ ๋จ์ด๊ฐ [0.2, -0.5, 0.8, ...] ๊ฐ์ ์ซ์ ๋ฆฌ์คํธ๋ก ํํ๋๋ ๊ฑฐ์ง. ๐ฑ
โก ์์น ์๋ฒ ๋ฉ: ๋ฌธ์ฅ์์ ๋จ์ด์ ์์น๋ ์ค์ํด! "๋๋ ๋๋ฅผ ์ข์ํด"์ "๋๋ฅผ ๋๋ ์ข์ํด"๋ ์๋ฏธ๊ฐ ๋น์ทํ์ง๋ง ๋์์ค๊ฐ ๋ค๋ฅด์์? ์์น ์ ๋ณด๋ฅผ ์ถ๊ฐํด์ ์ด๋ฐ ์ฐจ์ด๋ฅผ ๋ชจ๋ธ์ด ์ดํดํ ์ ์๊ฒ ํด์ค. ๐
๐ฏ 2๋จ๊ณ: ๋ฉํฐ ํค๋ ์ดํ ์ ๊ตฌํ
์ด์ GPT์ ํต์ฌ์ธ ๋ฉํฐ ํค๋ ์ดํ ์ ์ ๊ตฌํํด๋ณผ๊ฒ! ์ด ๋ถ๋ถ์ด ์ข ๋ณต์กํ ์ ์๋๋ฐ, ์ฒ์ฒํ ๋ฐ๋ผ์๋ด. ๐
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
# Query, Key, Value ๋ณํ์ ์ํ ์ ํ ๋ ์ด์ด
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
# ์ต์ข
์ถ๋ ฅ์ ์ํ ์ ํ ๋ ์ด์ด
self.W_o = nn.Linear(d_model, d_model)
def scaled_dot_product_attention(self, Q, K, V, mask=None):
# Q, K, V: (batch_size, num_heads, seq_len, d_k)
# ์ดํ
์
์ค์ฝ์ด ๊ณ์ฐ
attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# ๋ง์คํน ์ ์ฉ (๋ฏธ๋ ํ ํฐ์ ๋ณด์ง ๋ชปํ๊ฒ)
if mask is not None:
attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
# ์ํํธ๋งฅ์ค๋ก ํ๋ฅ ๋ถํฌ ์์ฑ
attn_probs = torch.softmax(attn_scores, dim=-1)
# Value์ ๊ณฑํด์ ์ต์ข
์ถ๋ ฅ
output = torch.matmul(attn_probs, V)
return output, attn_probs
def split_heads(self, x):
# (batch_size, seq_len, d_model) -> (batch_size, num_heads, seq_len, d_k)
batch_size, seq_len, d_model = x.size()
return x.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
def combine_heads(self, x):
# (batch_size, num_heads, seq_len, d_k) -> (batch_size, seq_len, d_model)
batch_size, num_heads, seq_len, d_k = x.size()
return x.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
def forward(self, Q, K, V, mask=None):
# ์ ํ ๋ณํ
Q = self.W_q(Q)
K = self.W_k(K)
V = self.W_v(V)
# ํค๋๋ก ๋ถํ
Q = self.split_heads(Q)
K = self.split_heads(K)
V = self.split_heads(V)
# ์ดํ
์
๊ณ์ฐ
attn_output, attn_probs = self.scaled_dot_product_attention(Q, K, V, mask)
# ํค๋ ๊ฒฐํฉ
output = self.combine_heads(attn_output)
# ์ต์ข
์ ํ ๋ณํ
output = self.W_o(output)
return output
์, ์ฝ๋๊ฐ ์ข ๊ธธ์ง? ๐
ํ๋์ฉ ๋ฏ์ด๋ณด์:
โ scaled_dot_product_attention: ์ด๊ฒ ์ดํ
์
์ ํต์ฌ์ด์ผ! Q(Query), K(Key), V(Value)๋ฅผ ๋ฐ์์ ์ดํ
์
์ค์ฝ์ด๋ฅผ ๊ณ์ฐํ๊ณ , ๊ทธ๊ฑธ ๋ฐํ์ผ๋ก ์ค์ํ ์ ๋ณด๋ฅผ ์ถ์ถํด. ๐ฏ
โก split_heads & combine_heads: ๋ฉํฐ ํค๋๋ฅผ ์ํด ๋ฒกํฐ๋ฅผ ์ฌ๋ฌ ๊ฐ๋ก ์ชผ๊ฐฐ๋ค๊ฐ ๋ค์ ํฉ์น๋ ํจ์์ผ. ๋ง์น ํผ์๋ฅผ ์กฐ๊ฐ๋ด์ ๋๋ ๋จน๋ค๊ฐ ๋ค์ ๋ชจ์ผ๋ ๊ฒ ๊ฐ์! ๐
โข mask: GPT๋ ์๊ธฐํ๊ท(autoregressive) ๋ชจ๋ธ์ด๋ผ์, ๋ฏธ๋์ ํ ํฐ์ ๋ณด๋ฉด ์ ๋ผ. ๋ง์คํฌ๋ฅผ ์ฌ์ฉํด์ ํ์ฌ ์์น ์ดํ์ ํ ํฐ๋ค์ ๊ฐ๋ ค์ค. ์ด๊ฒ ์์ผ๋ฉด ๋ชจ๋ธ์ด ์ปค๋ํ๋ ์
์ด ๋๊ฑฐ๋ ! ๐
๐งฑ 3๋จ๊ณ: ํผ๋ํฌ์๋ ๋คํธ์ํฌ
์ดํ ์ ๋ค์์๋ ํผ๋ํฌ์๋ ๋คํธ์ํฌ๊ฐ ์. ์ด๊ฑด ๋น๊ต์ ๊ฐ๋จํด! ๋ ๊ฐ์ ์ ํ ๋ ์ด์ด์ ํ์ฑํ ํจ์๋ก ๊ตฌ์ฑ๋ผ ์์ด. ๐
class FeedForward(nn.Module):
def __init__(self, d_model, d_ff, dropout=0.1):
super(FeedForward, self).__init__()
self.linear1 = nn.Linear(d_model, d_ff)
self.dropout = nn.Dropout(dropout)
self.linear2 = nn.Linear(d_ff, d_model)
def forward(self, x):
# x: (batch_size, seq_len, d_model)
# ์ฒซ ๋ฒ์งธ ์ ํ ๋ณํ + GELU ํ์ฑํ
x = torch.nn.functional.gelu(self.linear1(x))
x = self.dropout(x)
# ๋ ๋ฒ์งธ ์ ํ ๋ณํ
x = self.linear2(x)
return x
์ฌ๊ธฐ์ d_ff๋ ๋ณดํต d_model์ 4๋ฐฐ ์ ๋๋ก ์ค์ ํด. ์๋ฅผ ๋ค์ด d_model์ด 768์ด๋ฉด d_ff๋ 3072 ์ ๋๊ฐ ๋๋ ๊ฑฐ์ง! ์ด๋ ๊ฒ ์ฐจ์์ ๋๋ ธ๋ค๊ฐ ๋ค์ ์ค์ด๋ ๊ณผ์ ์์ ๋ชจ๋ธ์ด ๋ ๋ณต์กํ ํจํด์ ํ์ตํ ์ ์์ด. ๐ช
๊ทธ๋ฆฌ๊ณ GELU(Gaussian Error Linear Unit) ํ์ฑํ ํจ์๋ฅผ ์ฌ์ฉํ๋๋ฐ, ์ด๊ฒ ReLU๋ณด๋ค ์ฑ๋ฅ์ด ์ข ๋ ์ข๋ค๊ณ ์๋ ค์ ธ ์์ด. GPT-2๋ถํฐ ์ฌ์ฉ๋๊ธฐ ์์ํ์ง! โก
๐จ ํธ๋์คํฌ๋จธ ๋ธ๋ก ์กฐ๋ฆฝํ๊ธฐ
์ด์ ์ง๊ธ๊น์ง ๋ง๋ ์ปดํฌ๋ํธ๋ค์ ์กฐ๋ฆฝํด์ ํ๋์ ํธ๋์คํฌ๋จธ ๋ธ๋ก์ ๋ง๋ค์ด๋ณผ๊ฒ! ๋ ๊ณ ๋ธ๋ก ์กฐ๋ฆฝํ๋ ๊ฒ์ฒ๋ผ ์ฌ๋ฏธ์์ด! ๐งฉ
๐จ ํธ๋์คํฌ๋จธ ๋์ฝ๋ ๋ธ๋ก
class TransformerBlock(nn.Module):
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(TransformerBlock, self).__init__()
# ๋ฉํฐ ํค๋ ์ดํ
์
self.attention = MultiHeadAttention(d_model, num_heads)
# ํผ๋ํฌ์๋ ๋คํธ์ํฌ
self.feed_forward = FeedForward(d_model, d_ff, dropout)
# ๋ ์ด์ด ์ ๊ทํ
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
# ๋๋กญ์์
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
def forward(self, x, mask=None):
# x: (batch_size, seq_len, d_model)
# ๋ฉํฐ ํค๋ ์ดํ
์
+ ์์ฐจ ์ฐ๊ฒฐ + ์ ๊ทํ
attn_output = self.attention(x, x, x, mask)
x = self.norm1(x + self.dropout1(attn_output))
# ํผ๋ํฌ์๋ + ์์ฐจ ์ฐ๊ฒฐ + ์ ๊ทํ
ff_output = self.feed_forward(x)
x = self.norm2(x + self.dropout2(ff_output))
return x
์ฌ๊ธฐ์ ์ค์ํ ๊ฐ๋
์ด ๋ ๊ฐ์ง ๋์:
โ ์์ฐจ ์ฐ๊ฒฐ(Residual Connection): x + attn_output ์ด ๋ถ๋ถ ๋ดค์ด? ์๋ ์
๋ ฅ์ ์ถ๋ ฅ์ ๋ํด์ฃผ๋ ๊ฑฐ์ผ. ์ด๋ ๊ฒ ํ๋ฉด ๊ทธ๋๋์ธํธ๊ฐ ๋ ์ ํ๋ฅด๊ณ , ๊น์ ๋คํธ์ํฌ๋ ์์ ์ ์ผ๋ก ํ์ตํ ์ ์์ด! ๐
โก ๋ ์ด์ด ์ ๊ทํ(Layer Normalization): ๊ฐ ๋ ์ด์ด์ ์ถ๋ ฅ์ ์ ๊ทํํด์ ํ์ต์ ์์ ํ์์ผ. ๋ฐฐ์น ์ ๊ทํ์ ๋น์ทํ๋ฐ, ์ํ์ค ๋ฐ์ดํฐ์๋ ๋ ์ด์ด ์ ๊ทํ๊ฐ ๋ ์ ๋ง์! ๐
๐๏ธ ์์ ํ GPT ๋ชจ๋ธ
๋๋์ด! ๋ชจ๋ ๊ฑธ ํฉ์ณ์ ์์ ํ GPT ๋ชจ๋ธ์ ๋ง๋ค์ด๋ณด์! ๐
class GPTModel(nn.Module):
def __init__(self, vocab_size, d_model=768, num_heads=12,
num_layers=12, d_ff=3072, max_len=512, dropout=0.1):
super(GPTModel, self).__init__()
# ์๋ฒ ๋ฉ ๋ ์ด์ด
self.embedding = GPTEmbedding(vocab_size, d_model, max_len)
# ํธ๋์คํฌ๋จธ ๋ธ๋ก๋ค
self.transformer_blocks = nn.ModuleList([
TransformerBlock(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
# ์ต์ข
๋ ์ด์ด ์ ๊ทํ
self.ln_f = nn.LayerNorm(d_model)
# ์ถ๋ ฅ ๋ ์ด์ด (์ดํ ํ๋ฅ ๋ถํฌ ์์ฑ)
self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
# ๋๋กญ์์
self.dropout = nn.Dropout(dropout)
# ๊ฐ์ค์น ์ด๊ธฐํ
self.apply(self._init_weights)
def _init_weights(self, module):
if isinstance(module, nn.Linear):
torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
if module.bias is not None:
torch.nn.init.zeros_(module.bias)
elif isinstance(module, nn.Embedding):
torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
def forward(self, input_ids, attention_mask=None):
# input_ids: (batch_size, seq_len)
# ์๋ฒ ๋ฉ
x = self.embedding(input_ids)
x = self.dropout(x)
# ์ดํ
์
๋ง์คํฌ ์์ฑ (์๊ธฐํ๊ท๋ฅผ ์ํ ์ธ๊ณผ ๋ง์คํฌ)
if attention_mask is None:
seq_len = input_ids.size(1)
attention_mask = torch.tril(torch.ones(seq_len, seq_len)).unsqueeze(0).unsqueeze(0)
attention_mask = attention_mask.to(input_ids.device)
# ํธ๋์คํฌ๋จธ ๋ธ๋ก๋ค ํต๊ณผ
for transformer_block in self.transformer_blocks:
x = transformer_block(x, attention_mask)
# ์ต์ข
์ ๊ทํ
x = self.ln_f(x)
# ๋ก์ง ๊ณ์ฐ
logits = self.lm_head(x)
return logits
def generate(self, input_ids, max_length=50, temperature=1.0, top_k=50):
"""ํ
์คํธ ์์ฑ ํจ์"""
self.eval()
with torch.no_grad():
for _ in range(max_length):
# ํ์ฌ๊น์ง์ ์ํ์ค๋ก ์์ธก
logits = self.forward(input_ids)
# ๋ง์ง๋ง ํ ํฐ์ ๋ก์ง๋ง ์ฌ์ฉ
next_token_logits = logits[:, -1, :] / temperature
# Top-k ์ํ๋ง
if top_k > 0:
indices_to_remove = next_token_logits < torch.topk(next_token_logits, top_k)[0][..., -1, None]
next_token_logits[indices_to_remove] = -float('Inf')
# ํ๋ฅ ๋ถํฌ๋ก ๋ณํ
probs = torch.softmax(next_token_logits, dim=-1)
# ๋ค์ ํ ํฐ ์ํ๋ง
next_token = torch.multinomial(probs, num_samples=1)
# ์ํ์ค์ ์ถ๊ฐ
input_ids = torch.cat([input_ids, next_token], dim=1)
# ์ข
๋ฃ ํ ํฐ์ด๋ฉด ์ค๋จ
if next_token.item() == 0: # 0์ EOS ํ ํฐ์ผ๋ก ๊ฐ์
break
return input_ids
์! ๋๋์ด ์์ฑ์ด์ผ! ๐ ์ด ์ฝ๋๊ฐ ๋ฐ๋ก GPT์ ํต์ฌ์ด์ผ. ๋ช ๊ฐ์ง ์ค์ํ ํฌ์ธํธ๋ฅผ ์ง์ด๋ณผ๊ฒ:
โ ๋ชจ๋ธ ํฌ๊ธฐ ์ค์ : d_model=768, num_heads=12, num_layers=12๋ GPT-2 Small์ ์ค์ ์ด์ผ. ๋ ํฐ ๋ชจ๋ธ์ ๋ง๋ค๊ณ ์ถ์ผ๋ฉด ์ด ๊ฐ๋ค์ ๋๋ฆฌ๋ฉด ๋ผ! ๐
โก ์ธ๊ณผ ๋ง์คํฌ(Causal Mask): torch.tril๋ก ํ์ผ๊ฐ ํ๋ ฌ์ ๋ง๋ค์ด์, ๊ฐ ํ ํฐ์ด ์๊ธฐ ์ด์ ์ ํ ํฐ๋ค๋ง ๋ณผ ์ ์๊ฒ ํด. ์ด๊ฒ GPT๊ฐ ์์ฐจ์ ์ผ๋ก ํ
์คํธ๋ฅผ ์์ฑํ ์ ์๋ ๋น๊ฒฐ์ด์ผ! ๐
โข generate ํจ์: ์ค์ ๋ก ํ
์คํธ๋ฅผ ์์ฑํ๋ ํจ์์ผ. Top-k ์ํ๋ง์ ์ฌ์ฉํด์ ๋ค์ํ๋ฉด์๋ ๊ทธ๋ด๋ฏํ ํ
์คํธ๋ฅผ ๋ง๋ค์ด๋ด! ๐ฒ
๐ ๋ฐ์ดํฐ ์ค๋น์ ํ์ตํ๊ธฐ
๋ชจ๋ธ ๊ตฌ์กฐ๋ ์์ฑํ์ด! ์ด์ ์ค์ ๋ก ํ์ต์์ผ์ผ ํ๋๋ฐ, ๊ทธ๋ฌ๋ ค๋ฉด ๋ฐ์ดํฐ๊ฐ ํ์ํด. ์ด๋ป๊ฒ ์ค๋นํ๊ณ ํ์ต์ํค๋์ง ์์๋ณด์! ๐
๐ ๋ฐ์ดํฐ์ ์ค๋นํ๊ธฐ
GPT๋ฅผ ํ์ต์ํค๋ ค๋ฉด ์์ฒญ๋ ์์ ํ ์คํธ ๋ฐ์ดํฐ๊ฐ ํ์ํด. ์๋ GPT-3๋ 45TB์ ํ ์คํธ๋ก ํ์ตํ๋ค๊ณ ํ๋๊น! ๐ฑ ๋ฌผ๋ก ์ฐ๋ฆฌ๋ ์์ ๊ท๋ชจ๋ก ์์ํ ๊ฑฐ์ผ.
import torch
from torch.utils.data import Dataset, DataLoader
from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import Whitespace
class TextDataset(Dataset):
def __init__(self, texts, tokenizer, max_length=512):
self.texts = texts
self.tokenizer = tokenizer
self.max_length = max_length
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
# ํ ํฐํ
encoding = self.tokenizer.encode(text)
tokens = encoding.ids
# ํจ๋ฉ ๋๋ ์๋ฅด๊ธฐ
if len(tokens) > self.max_length:
tokens = tokens[:self.max_length]
else:
tokens = tokens + [0] * (self.max_length - len(tokens))
# ์
๋ ฅ๊ณผ ํ๊ฒ ์์ฑ (๋ค์ ํ ํฐ ์์ธก)
input_ids = torch.tensor(tokens[:-1])
target_ids = torch.tensor(tokens[1:])
return input_ids, target_ids
# ํ ํฌ๋์ด์ ํ์ต
def train_tokenizer(texts, vocab_size=10000):
tokenizer = Tokenizer(BPE(unk_token="[UNK]"))
trainer = BpeTrainer(vocab_size=vocab_size, special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]"])
tokenizer.pre_tokenizer = Whitespace()
# ํ
์คํธ๋ก ํ์ต
tokenizer.train_from_iterator(texts, trainer)
return tokenizer
# ์์ ์ฌ์ฉ
texts = [
"์๋
ํ์ธ์. GPT ๋ชจ๋ธ์ ํ์ตํ๊ณ ์์ต๋๋ค.",
"์์ฐ์ด ์ฒ๋ฆฌ๋ ์ ๋ง ํฅ๋ฏธ๋ก์ด ๋ถ์ผ์
๋๋ค.",
"๋ฅ๋ฌ๋์ผ๋ก ๋ง์ ๊ฒ์ ํ ์ ์์ด์!",
# ... ๋ ๋ง์ ํ
์คํธ
]
# ํ ํฌ๋์ด์ ํ์ต
tokenizer = train_tokenizer(texts, vocab_size=10000)
# ๋ฐ์ดํฐ์
์์ฑ
dataset = TextDataset(texts, tokenizer, max_length=128)
dataloader = DataLoader(dataset, batch_size=8, shuffle=True)
์ฌ๊ธฐ์ ์ค์ํ ๊ฑด ์
๋ ฅ๊ณผ ํ๊ฒ์ ํ ์นธ์ฉ ๋ฐ์ด์ ๋ง๋ ๋ค๋ ๊ฑฐ์ผ! ์๋ฅผ ๋ค์ด:
โข ์
๋ ฅ: "์๋
ํ์ธ์ GPT ๋ชจ๋ธ์"
โข ํ๊ฒ: "ํ์ธ์ GPT ๋ชจ๋ธ์ ํ์ตํ๊ณ "
์ด๋ ๊ฒ ํ๋ฉด ๋ชจ๋ธ์ด "์๋
"์ ๋ณด๊ณ "ํ์ธ์"๋ฅผ ์์ธกํ๊ณ , "์๋
ํ์ธ์"๋ฅผ ๋ณด๊ณ "GPT"๋ฅผ ์์ธกํ๋ ์์ผ๋ก ํ์ตํ๊ฒ ๋ผ! ๐ฏ
๐๏ธ ํ์ต ๋ฃจํ ๊ตฌํ
์ด์ ์ค์ ๋ก ๋ชจ๋ธ์ ํ์ต์ํค๋ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์! ๐ช
import torch.optim as optim
from torch.nn import CrossEntropyLoss
def train_gpt(model, dataloader, epochs=10, learning_rate=3e-4):
# ๋๋ฐ์ด์ค ์ค์
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
# ์ตํฐ๋ง์ด์ ์ ์์ค ํจ์
optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=0.01)
criterion = CrossEntropyLoss()
# ํ์ต๋ฅ ์ค์ผ์ค๋ฌ
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
model.train()
for epoch in range(epochs):
total_loss = 0
for batch_idx, (input_ids, target_ids) in enumerate(dataloader):
input_ids = input_ids.to(device)
target_ids = target_ids.to(device)
# Forward pass
logits = model(input_ids)
# ์์ค ๊ณ์ฐ
loss = criterion(logits.view(-1, logits.size(-1)), target_ids.view(-1))
# Backward pass
optimizer.zero_grad()
loss.backward()
# ๊ทธ๋๋์ธํธ ํด๋ฆฌํ (ํญ๋ฐ ๋ฐฉ์ง)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()
total_loss += loss.item()
if batch_idx % 100 == 0:
print(f'Epoch [{epoch+1}/{epochs}], Step [{batch_idx}/{len(dataloader)}], Loss: {loss.item():.4f}')
avg_loss = total_loss / len(dataloader)
print(f'Epoch [{epoch+1}/{epochs}] ์๋ฃ, Average Loss: {avg_loss:.4f}')
scheduler.step()
return model
# ๋ชจ๋ธ ์ด๊ธฐํ
vocab_size = 10000
model = GPTModel(vocab_size=vocab_size, d_model=512, num_heads=8, num_layers=6)
# ํ์ต ์์
trained_model = train_gpt(model, dataloader, epochs=10)
ํ์ต ์ฝ๋์์ ๋ช ๊ฐ์ง ์ค์ํ ํ
ํฌ๋์ ์ฌ์ฉํ์ด:
โ AdamW ์ตํฐ๋ง์ด์ : Adam์ ๊ฐ์ ๋ฒ์ ์ผ๋ก, weight decay๋ฅผ ๋ ํจ๊ณผ์ ์ผ๋ก ์ ์ฉํด. GPT ๊ฐ์ ํฐ ๋ชจ๋ธ์ ํนํ ์ข์! ๐
โก ๊ทธ๋๋์ธํธ ํด๋ฆฌํ: ๊ทธ๋๋์ธํธ๊ฐ ๋๋ฌด ์ปค์ง๋ฉด ํ์ต์ด ๋ถ์์ ํด์ง ์ ์์ด. ์ต๋ norm์ 1.0์ผ๋ก ์ ํํด์ ์์ ์ ์ธ ํ์ต์ ๋ณด์ฅํด! โ๏ธ
โข ์ฝ์ฌ์ธ ์ด๋๋ง ์ค์ผ์ค๋ฌ: ํ์ต๋ฅ ์ ์ ์ง์ ์ผ๋ก ์ค์ฌ์ ๋ ์ ๊ตํ ์ต์ ํ๋ฅผ ๊ฐ๋ฅํ๊ฒ ํด. ๋ง์น ๋ชฉ์ ์ง์ ๊ฐ๊น์์ง์๋ก ์๋๋ฅผ ์ค์ด๋ ๊ฒ๊ณผ ๋น์ทํด! ๐ข
๐จ ํ ์คํธ ์์ฑํ๊ธฐ
๋๋์ด ํ์ต๋ ๋ชจ๋ธ๋ก ํ ์คํธ๋ฅผ ์์ฑํด๋ณผ ์๊ฐ์ด์ผ! ์ด๊ฒ ์ ์ผ ์ฌ๋ฏธ์๋ ๋ถ๋ถ์ด์ง. ๐
๐ฒ ๋ค์ํ ์ํ๋ง ์ ๋ต
ํ ์คํธ๋ฅผ ์์ฑํ ๋ ์ด๋ค ํ ํฐ์ ์ ํํ ์ง ๊ฒฐ์ ํ๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ์ง ์์ด. ๊ฐ๊ฐ ์ฅ๋จ์ ์ด ์์ง!
def generate_text(model, tokenizer, prompt, max_length=100,
method='top_k', temperature=1.0, top_k=50, top_p=0.9):
"""
๋ค์ํ ์ํ๋ง ๋ฐฉ๋ฒ์ผ๋ก ํ
์คํธ ์์ฑ
Args:
method: 'greedy', 'top_k', 'top_p', 'beam_search'
temperature: ๋์์๋ก ๋ค์ํ ์ถ๋ ฅ, ๋ฎ์์๋ก ํ์ ์
top_k: ์์ k๊ฐ ํ ํฐ๋ง ๊ณ ๋ ค
top_p: ๋์ ํ๋ฅ ์ด p๊ฐ ๋ ๋๊น์ง์ ํ ํฐ๋ค๋ง ๊ณ ๋ ค
"""
model.eval()
device = next(model.parameters()).device
# ํ๋กฌํํธ ํ ํฐํ
encoding = tokenizer.encode(prompt)
input_ids = torch.tensor([encoding.ids]).to(device)
generated = input_ids
with torch.no_grad():
for _ in range(max_length):
# ์์ธก
logits = model(generated)
next_token_logits = logits[:, -1, :] / temperature
if method == 'greedy':
# ๊ฐ์ฅ ํ๋ฅ ์ด ๋์ ํ ํฐ ์ ํ
next_token = torch.argmax(next_token_logits, dim=-1, keepdim=True)
elif method == 'top_k':
# Top-k ์ํ๋ง
top_k_logits, top_k_indices = torch.topk(next_token_logits, top_k)
probs = torch.softmax(top_k_logits, dim=-1)
next_token_idx = torch.multinomial(probs, num_samples=1)
next_token = top_k_indices.gather(-1, next_token_idx)
elif method == 'top_p':
# Top-p (nucleus) ์ํ๋ง
sorted_logits, sorted_indices = torch.sort(next_token_logits, descending=True)
cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1)
# ๋์ ํ๋ฅ ์ด top_p๋ฅผ ๋๋ ํ ํฐ๋ค ์ ๊ฑฐ
sorted_indices_to_remove = cumulative_probs > top_p
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
next_token_logits[indices_to_remove] = -float('Inf')
probs = torch.softmax(next_token_logits, dim=-1)
next_token = torch.multinomial(probs, num_samples=1)
# ์์ฑ๋ ํ ํฐ ์ถ๊ฐ
generated = torch.cat([generated, next_token], dim=1)
# ์ข
๋ฃ ์กฐ๊ฑด
if next_token.item() == tokenizer.token_to_id("[SEP]"):
break
# ๋์ฝ๋ฉ
generated_text = tokenizer.decode(generated[0].tolist())
return generated_text
# ์ฌ์ฉ ์์
prompt = "์ธ๊ณต์ง๋ฅ์ ๋ฏธ๋๋"
generated = generate_text(trained_model, tokenizer, prompt,
method='top_p', temperature=0.8, top_p=0.9)
print(f"์์ฑ๋ ํ
์คํธ: {generated}")
๊ฐ ์ํ๋ง ๋ฐฉ๋ฒ์ ํน์ง์ ์ ๋ฆฌํด๋ณผ๊ฒ:
๐ฏ Greedy Decoding: ํญ์ ๊ฐ์ฅ ํ๋ฅ ์ด ๋์ ํ ํฐ์ ์ ํํด. ๋น ๋ฅด๊ณ ํ์ ์ ์ด์ง๋ง, ๋ฐ๋ณต์ ์ด๊ณ ์ง๋ฃจํ ํ
์คํธ๊ฐ ๋์ฌ ์ ์์ด.
๐ฒ Top-k Sampling: ์์ k๊ฐ ํ ํฐ ์ค์์ ๋๋คํ๊ฒ ์ ํํด. ๋ค์์ฑ๊ณผ ํ์ง์ ๊ท ํ์ด ์ข์! k=50 ์ ๋๊ฐ ์ผ๋ฐ์ ์ด์ผ.
๐ Top-p (Nucleus) Sampling: ๋์ ํ๋ฅ ์ด p๊ฐ ๋ ๋๊น์ง์ ํ ํฐ๋ค๋ง ๊ณ ๋ คํด. ๋ฌธ๋งฅ์ ๋ฐ๋ผ ํ๋ณด ๊ฐ์๊ฐ ๋์ ์ผ๋ก ๋ณํด์ ๋ ์์ฐ์ค๋ฌ์! p=0.9๊ฐ ๋ง์ด ์ฐ์ฌ.
๐ก๏ธ Temperature: ํ๋ฅ ๋ถํฌ๋ฅผ ์กฐ์ ํด. ๋์ผ๋ฉด ์ฐฝ์์ ์ด์ง๋ง ์ผ๊ด์ฑ์ด ๋จ์ด์ง๊ณ , ๋ฎ์ผ๋ฉด ์์ ํ์ง๋ง ์ง๋ฃจํ ์ ์์ด. 0.7~1.0์ด ์ ๋นํด!
๐ ๋น ์์น(Beam Search)
๋ ๊ณ ๊ธ ๊ธฐ๋ฒ์ธ ๋น ์์น๋ ์์๋ณด์! ์ด๊ฑด ์ฌ๋ฌ ๊ฐ๋ฅ์ฑ์ ๋์์ ํ์ํ๋ ๋ฐฉ๋ฒ์ด์ผ. ๐ฆ
def beam_search(model, tokenizer, prompt, beam_width=5, max_length=100):
"""
๋น ์์น๋ก ํ
์คํธ ์์ฑ
"""
model.eval()
device = next(model.parameters()).device
# ์ด๊ธฐ ์ํ์ค
encoding = tokenizer.encode(prompt)
initial_ids = torch.tensor([encoding.ids]).to(device)
# ๋น: (์ํ์ค, ๋์ ๋ก๊ทธ ํ๋ฅ )
beams = [(initial_ids, 0.0)]
with torch.no_grad():
for _ in range(max_length):
candidates = []
for seq, score in beams:
# ์์ธก
logits = model(seq)
next_token_logits = logits[:, -1, :]
log_probs = torch.log_softmax(next_token_logits, dim=-1)
# ์์ beam_width๊ฐ ํ ํฐ
top_log_probs, top_indices = torch.topk(log_probs, beam_width)
for i in range(beam_width):
next_token = top_indices[0, i].unsqueeze(0).unsqueeze(0)
next_seq = torch.cat([seq, next_token], dim=1)
next_score = score + top_log_probs[0, i].item()
candidates.append((next_seq, next_score))
# ์์ beam_width๊ฐ ํ๋ณด ์ ํ
beams = sorted(candidates, key=lambda x: x[1], reverse=True)[:beam_width]
# ๋ชจ๋ ๋น์ด ์ข
๋ฃ ํ ํฐ์ ๋๋ฌํ๋ฉด ์ค๋จ
if all(seq[0, -1].item() == tokenizer.token_to_id("[SEP]") for seq, _ in beams):
break
# ๊ฐ์ฅ ๋์ ์ ์์ ์ํ์ค ๋ฐํ
best_seq, best_score = beams[0]
generated_text = tokenizer.decode(best_seq[0].tolist())
return generated_text, best_score
๋น ์์น๋ ์ฌ๋ฌ ๊ฐ๋ฅ์ฑ์ ๋์์ ์ถ์ ํ๋ฉด์ ์ต์ ์ ์ํ์ค๋ฅผ ์ฐพ์. ๋ง์น ์ฒด์ค์์ ์ฌ๋ฌ ์๋ฅผ ๋ฏธ๋ฆฌ ๋ด๋ค๋ณด๋ ๊ฒ๊ณผ ๋น์ทํด! โ๏ธ
์ฅ์ ์ ๋ ์ผ๊ด์ฑ ์๊ณ ํ์ง ๋์ ํ
์คํธ๋ฅผ ์์ฑํ ์ ์๋ค๋ ๊ฑฐ์ผ. ๋จ์ ์ ๊ณ์ฐ๋์ด ๋ง๊ณ , ๋๋ก๋ ๋๋ฌด ์์ ํ ์ ํ๋ง ํด์ ์ฐฝ์์ฑ์ด ๋จ์ด์ง ์ ์์ด. ๋ฒ์ญ์ด๋ ์์ฝ ๊ฐ์ ์์
์๋ ์ข์ง๋ง, ์ฐฝ์์ ์ธ ๊ธ์ฐ๊ธฐ์๋ ์ํ๋ง์ด ๋ ๋์ ์ ์์ด! โ๏ธ
โก ์ต์ ํ์ ์ฑ๋ฅ ํฅ์
GPT ๋ชจ๋ธ์ ํฌ๊ณ ๋ฌด๊ฑฐ์์ ์ต์ ํ๊ฐ ์ ๋ง ์ค์ํด! ์ค์ ์์ ์ฌ์ฉํ๋ ค๋ฉด ์๋์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ ํด์ผ ํด. ๐
๐ฅ ํผํฉ ์ ๋ฐ๋ ํ์ต(Mixed Precision Training)
์ผ๋ฐ์ ์ผ๋ก ๋ฅ๋ฌ๋์ 32๋นํธ ๋ถ๋์์์ (FP32)์ ์ฌ์ฉํ๋๋ฐ, 16๋นํธ(FP16)๋ฅผ ์์ด ์ฐ๋ฉด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์ด๊ณ ์๋๋ฅผ 2๋ฐฐ ๋์ผ ์ ์์ด! ๐ฏ
from torch.cuda.amp import autocast, GradScaler
def train_with_mixed_precision(model, dataloader, epochs=10):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
optimizer = optim.AdamW(model.parameters(), lr=3e-4)
criterion = CrossEntropyLoss()
scaler = GradScaler() # ๊ทธ๋๋์ธํธ ์ค์ผ์ผ๋ฌ
for epoch in range(epochs):
for input_ids, target_ids in dataloader:
input_ids = input_ids.to(device)
target_ids = target_ids.to(device)
optimizer.zero_grad()
# ํผํฉ ์ ๋ฐ๋๋ก forward pass
with autocast():
logits = model(input_ids)
loss = criterion(logits.view(-1, logits.size(-1)), target_ids.view(-1))
# ์ค์ผ์ผ๋ backward pass
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
print(f'Epoch {epoch+1} ์๋ฃ')
return model
autocast()๋ฅผ ์ฌ์ฉํ๋ฉด PyTorch๊ฐ ์๋์ผ๋ก ์ด๋ค ์ฐ์ฐ์ FP16์ผ๋ก ํ ์ง ๊ฒฐ์ ํด์ค. ์ ํ๋๋ ๊ฑฐ์ ๊ทธ๋๋ก ์ ์งํ๋ฉด์ ์๋๋ ํจ์ฌ ๋นจ๋ผ์ ธ! โก
๐พ ๊ทธ๋๋์ธํธ ์ฒดํฌํฌ์ธํ (Gradient Checkpointing)
๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๋ ์ ์ฉํ ๊ธฐ๋ฒ์ด์ผ. ์ค๊ฐ ํ์ฑํ ๊ฐ์ ์ ์ฅํ์ง ์๊ณ , ํ์ํ ๋ ๋ค์ ๊ณ์ฐํ๋ ๊ฑฐ์ง. ์๋๋ ์กฐ๊ธ ๋๋ ค์ง์ง๋ง ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํฌ๊ฒ ์ ์ฝํ ์ ์์ด! ๐ช
from torch.utils.checkpoint import checkpoint
class TransformerBlockWithCheckpoint(nn.Module):
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super().__init__()
self.attention = MultiHeadAttention(d_model, num_heads)
self.feed_forward = FeedForward(d_model, d_ff, dropout)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
def forward(self, x, mask=None):
# ์ฒดํฌํฌ์ธํ
์ ์ฉ
def custom_forward(x):
attn_output = self.attention(x, x, x, mask)
x = self.norm1(x + self.dropout1(attn_output))
ff_output = self.feed_forward(x)
x = self.norm2(x + self.dropout2(ff_output))
return x
return checkpoint(custom_forward, x)
ํฐ ๋ชจ๋ธ์ ํ์ต์ํฌ ๋ "CUDA out of memory" ์๋ฌ๊ฐ ๋๋ฉด ์ด ๋ฐฉ๋ฒ์ ์จ๋ด! ํนํ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๊ณ ์ถ์ ๋ ์ ์ฉํด. ๐ฆ
๐ฏ ๋ชจ๋ธ ์์ํ(Quantization)
ํ์ต๋ ๋ชจ๋ธ์ ๋ฐฐํฌํ ๋๋ ์์ํ๋ฅผ ์ฌ์ฉํด์ ํฌ๊ธฐ๋ฅผ ์ค์ผ ์ ์์ด. 32๋นํธ ๊ฐ์ค์น๋ฅผ 8๋นํธ๋ 4๋นํธ๋ก ์ค์ด๋ ๊ฑฐ์ผ! ๐๏ธ
import torch.quantization as quantization
def quantize_model(model):
"""
๋ชจ๋ธ์ ๋์ ์์ํ
"""
# ๋์ ์์ํ (์ถ๋ก ์ ํ์ฑํ๋ฅผ ์์ํ)
quantized_model = quantization.quantize_dynamic(
model,
{nn.Linear}, # ์์ํํ ๋ ์ด์ด ํ์
dtype=torch.qint8 # 8๋นํธ ์ ์๋ก ๋ณํ
)
return quantized_model
# ์ฌ์ฉ ์์
quantized_model = quantize_model(trained_model)
# ๋ชจ๋ธ ํฌ๊ธฐ ๋น๊ต
original_size = sum(p.numel() * p.element_size() for p in trained_model.parameters())
quantized_size = sum(p.numel() * p.element_size() for p in quantized_model.parameters())
print(f"์๋ณธ ๋ชจ๋ธ ํฌ๊ธฐ: {original_size / 1024 / 1024:.2f} MB")
print(f"์์ํ ๋ชจ๋ธ ํฌ๊ธฐ: {quantized_size / 1024 / 1024:.2f} MB")
print(f"์์ถ๋ฅ : {original_size / quantized_size:.2f}x")
์์ํํ๋ฉด ๋ชจ๋ธ ํฌ๊ธฐ๊ฐ 1/4 ์ ๋๋ก ์ค์ด๋ค๊ณ ์ถ๋ก ์๋๋ ๋นจ๋ผ์ ธ! ์ ํ๋๋ ์ฝ๊ฐ ๋จ์ด์ง ์ ์์ง๋ง, ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ฌด์ํ ๋งํ ์์ค์ด์ผ. ๋ชจ๋ฐ์ผ์ด๋ ์ฃ์ง ๋๋ฐ์ด์ค์ ๋ฐฐํฌํ ๋ ํนํ ์ ์ฉํด! ๐ฑ
๐ฏ ํ์ธํ๋๊ณผ ์ ์ดํ์ต
์ฒ์๋ถํฐ GPT๋ฅผ ํ์ต์ํค๋ ๊ฑด ์ ๋ง ์ด๋ ค์. ๊ทธ๋์ ๋๋ถ๋ถ์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๊ฐ์ ธ์์ ํ์ธํ๋ํ๋ ๋ฐฉ๋ฒ์ ์จ! ์ด๊ฒ ํจ์ฌ ํ์ค์ ์ด๊ณ ํจ๊ณผ์ ์ด์ผ. ๐จ
๐ค Hugging Face Transformers ํ์ฉ
Hugging Face๋ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ๋ค์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๊ฒ ํด์ฃผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ. ์ ๋ง ํธ๋ฆฌํด! ๐
from transformers import GPT2LMHeadModel, GPT2Tokenizer, GPT2Config
from transformers import Trainer, TrainingArguments
# ์ฌ์ ํ์ต๋ GPT-2 ๋ชจ๋ธ ๋ก๋
model_name = "gpt2" # ๋๋ "gpt2-medium", "gpt2-large", "gpt2-xl"
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2LMHeadModel.from_pretrained(model_name)
# ํ๊ตญ์ด GPT๋ฅผ ์ํ๋ค๋ฉด
# model_name = "skt/kogpt2-base-v2"
# ํน์ ํ ํฐ ์ถ๊ฐ
tokenizer.pad_token = tokenizer.eos_token
# ๋ฐ์ดํฐ์
์ค๋น
class CustomDataset(torch.utils.data.Dataset):
def __init__(self, texts, tokenizer, max_length=512):
self.encodings = tokenizer(texts, truncation=True, padding=True,
max_length=max_length, return_tensors="pt")
def __len__(self):
return len(self.encodings.input_ids)
def __getitem__(self, idx):
return {
'input_ids': self.encodings.input_ids[idx],
'attention_mask': self.encodings.attention_mask[idx],
'labels': self.encodings.input_ids[idx]
}
# ํ์ต ๋ฐ์ดํฐ
train_texts = [
"๋น์ ์ ํ
์คํธ ๋ฐ์ดํฐ 1",
"๋น์ ์ ํ
์คํธ ๋ฐ์ดํฐ 2",
# ... ๋ ๋ง์ ๋ฐ์ดํฐ
]
train_dataset = CustomDataset(train_texts, tokenizer)
# ํ์ต ์ค์
training_args = TrainingArguments(
output_dir="./gpt2-finetuned",
num_train_epochs=3,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
warmup_steps=500,
weight_decay=0.01,
logging_dir='./logs',
logging_steps=100,
save_steps=1000,
save_total_limit=2,
fp16=True, # ํผํฉ ์ ๋ฐ๋ ํ์ต
)
# Trainer ์ด๊ธฐํ
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
)
# ํ์ธํ๋ ์์!
trainer.train()
# ๋ชจ๋ธ ์ ์ฅ
model.save_pretrained("./my-finetuned-gpt2")
tokenizer.save_pretrained("./my-finetuned-gpt2")
์ด๋ ๊ฒ ํ๋ฉด ๋ช ์๊ฐ ์์ ์์ ๋ง์ GPT ๋ชจ๋ธ์ ๋ง๋ค ์ ์์ด! ์ฒ์๋ถํฐ ํ์ตํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋น ๋ฅด๊ณ ํจ๊ณผ์ ์ด์ง. ๐
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ AI ์ ๋ฌธ๊ฐ์๊ฒ ๋์์ ๋ฐ์ผ๋ฉด ๋ ํจ์จ์ ์ผ๋ก ํ์ธํ๋ํ ์ ์์ด. ํนํ ๋๋ฉ์ธ ํนํ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ์ ๋ฌธ๊ฐ์ ์กฐ์ธ์ด ํฐ ๋์์ด ๋ผ! ๐ก
๐จ LoRA: ํจ์จ์ ์ธ ํ์ธํ๋
LoRA(Low-Rank Adaptation)๋ ์ต๊ทผ ์ธ๊ธฐ ์๋ ํ์ธํ๋ ๊ธฐ๋ฒ์ด์ผ. ๋ชจ๋ธ์ ์ผ๋ถ๋ง ํ์ต์์ผ์ ๋ฉ๋ชจ๋ฆฌ์ ์๊ฐ์ ํฌ๊ฒ ์ ์ฝํ ์ ์์ด! ๐ฏ
from peft import LoraConfig, get_peft_model, TaskType
# LoRA ์ค์
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=8, # ๋ญํฌ (๋ฎ์์๋ก ํ๋ผ๋ฏธํฐ ์ ์)
lora_alpha=32, # ์ค์ผ์ผ๋ง ํฉํฐ
lora_dropout=0.1,
target_modules=["c_attn", "c_proj"], # ์ดํ
์
๋ ์ด์ด์๋ง ์ ์ฉ
)
# ๋ชจ๋ธ์ LoRA ์ ์ฉ
model = GPT2LMHeadModel.from_pretrained("gpt2")
model = get_peft_model(model, lora_config)
# ํ์ต ๊ฐ๋ฅํ ํ๋ผ๋ฏธํฐ ํ์ธ
model.print_trainable_parameters()
# ์ถ๋ ฅ ์: trainable params: 294,912 || all params: 124,734,720 || trainable%: 0.24%
# ์ด์ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก ํ์ต
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
)
trainer.train()
LoRA๋ฅผ ์ฌ์ฉํ๋ฉด ์ ์ฒด ํ๋ผ๋ฏธํฐ์ 0.1~1%๋ง ํ์ต์์ผ๋ ์ข์ ์ฑ๋ฅ์ ๋ผ ์ ์์ด! ๋ฉ๋ชจ๋ฆฌ๋ ์ ๊ฒ ์ฐ๊ณ , ํ์ต๋ ๋น ๋ฅด๊ณ , ์ฌ๋ฌ ๊ฐ์ LoRA ์ด๋ํฐ๋ฅผ ๋ง๋ค์ด์ ๋ค์ํ ํ์คํฌ์ ์ฌ์ฉํ ์ ์์ด. ์ ๋ง ํ์ ์ ์ด์ง! ๐
๐ก๏ธ ์์ ์ฑ๊ณผ ์ค๋ฆฌ์ ๊ณ ๋ ค์ฌํญ
GPT ๊ฐ์ ๊ฐ๋ ฅํ ๋ชจ๋ธ์ ๋ง๋ค ๋๋ ์์ ์ฑ๊ณผ ์ค๋ฆฌ๋ ์ค์ํด. ์ฑ ์๊ฐ ์๊ฒ ๊ฐ๋ฐํ๊ณ ์ฌ์ฉํด์ผ ํด! ๐ค
โ ํธํฅ(Bias) ๋ฌธ์ : GPT๋ ํ์ต ๋ฐ์ดํฐ์ ํธํฅ์ ๊ทธ๋๋ก ํ์ตํด. ์ฑ๋ณ, ์ธ์ข
, ์ข
๊ต ๋ฑ์ ๋ํ ํธ๊ฒฌ์ด ํฌํจ๋ ์ ์์ด. ๋ฐ์ดํฐ๋ฅผ ์ ์คํ๊ฒ ์ ํํ๊ณ , ์ถ๋ ฅ์ ๋ชจ๋ํฐ๋งํด์ผ ํด! ๐
โก ์ ํด ์ฝํ
์ธ ์์ฑ: ๋ชจ๋ธ์ด ๋ถ์ ์ ํ๊ฑฐ๋ ์ ํดํ ๋ด์ฉ์ ์์ฑํ ์ ์์ด. ํํฐ๋ง ์์คํ
์ ๊ตฌ์ถํ๊ณ , ์์ ์ฅ์น๋ฅผ ๋ง๋ จํด์ผ ํด. ๐ก๏ธ
โข ์ ์๊ถ ๋ฌธ์ : ํ์ต ๋ฐ์ดํฐ์ ์ ์๊ถ์ ํ์ธํ๊ณ , ์์ฑ๋ ์ฝํ
์ธ ์ ์ฌ์ฉ ๋ฒ์๋ฅผ ๋ช
ํํ ํด์ผ ํด. ๋ฒ์ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๊ฑฐ๋ ! โ๏ธ
โฃ ์ค์ ๋ณด ํ์ฐ: GPT๋ ๊ทธ๋ด๋ฏํ์ง๋ง ํ๋ฆฐ ์ ๋ณด๋ฅผ ์์ฑํ ์ ์์ด. ํฉํธ ์ฒดํฌ๊ฐ ์ค์ํด! ํนํ ์๋ฃ, ๋ฒ๋ฅ ๊ฐ์ ๋ฏผ๊ฐํ ๋ถ์ผ์์๋ ๋์ฑ ์กฐ์ฌํด์ผ ํด. ๐
๐ ์์ ์ฅ์น ๊ตฌํํ๊ธฐ
class SafeGPT:
"""์์ ์ฅ์น๊ฐ ์๋ GPT ๋ํผ"""
def __init__(self, model, tokenizer, banned_words=None):
self.model = model
self.tokenizer = tokenizer
self.banned_words = banned_words or []
def contains_banned_content(self, text):
"""๊ธ์ง๋ ๋จ์ด๋ ํจํด ํ์ธ"""
text_lower = text.lower()
for word in self.banned_words:
if word.lower() in text_lower:
return True
return False
def generate_safe(self, prompt, max_length=100, **kwargs):
"""์์ ํ ํ
์คํธ ์์ฑ"""
# ํ๋กฌํํธ ๊ฒ์ฌ
if self.contains_banned_content(prompt):
return "์ฃ์กํฉ๋๋ค. ๋ถ์ ์ ํ ๋ด์ฉ์ด ํฌํจ๋์ด ์์ด ์์ฑํ ์ ์์ต๋๋ค."
# ํ
์คํธ ์์ฑ
generated = generate_text(self.model, self.tokenizer, prompt,
max_length=max_length, **kwargs)
# ์ถ๋ ฅ ๊ฒ์ฌ
if self.contains_banned_content(generated):
return "์ฃ์กํฉ๋๋ค. ์ ์ ํ ์๋ต์ ์์ฑํ ์ ์์ต๋๋ค."
# ์ ๋ขฐ๋ ์ ์ ์ถ๊ฐ
confidence = self.calculate_confidence(generated)
if confidence < 0.5:
generated += "\n\nโ ๏ธ ์ฃผ์: ์ด ์๋ต์ ์ ๋ขฐ๋๊ฐ ๋ฎ์ ์ ์์ต๋๋ค."
return generated
def calculate_confidence(self, text):
"""์์ฑ๋ ํ
์คํธ์ ์ ๋ขฐ๋ ๊ณ์ฐ"""
# ์ค์ ๋ก๋ ๋ ๋ณต์กํ ๋ก์ง์ด ํ์
# ์: ๋ชจ๋ธ์ ํ๋ฅ ๋ถํฌ, ์ผ๊ด์ฑ ์ฒดํฌ ๋ฑ
return 0.8 # ์์
# ์ฌ์ฉ ์์
banned_words = ["์์ค1", "์์ค2", "๋ถ์ ์ ํ๋จ์ด"]
safe_gpt = SafeGPT(model, tokenizer, banned_words)
response = safe_gpt.generate_safe("์๋
ํ์ธ์, GPT์
๋๋ค.")
์ด๋ฐ ์์ผ๋ก ์์ ์ฅ์น๋ฅผ ๊ตฌํํ๋ฉด ์ข ๋ ์ฑ ์๊ฐ ์๊ฒ AI๋ฅผ ์ฌ์ฉํ ์ ์์ด! ๋ฌผ๋ก ์๋ฒฝํ์ง ์์ง๋ง, ์ต์ํ์ ๋ณดํธ๋ง์ ๋์ง. ๐ก๏ธ
๐ ์ค์ ํ๋ก์ ํธ ์์ด๋์ด
์ด์ ๋ฐฐ์ด ๊ฑธ ํ์ฉํด์ ์ฌ๋ฏธ์๋ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณด์! ๋ช ๊ฐ์ง ์์ด๋์ด๋ฅผ ์๊ฐํ ๊ฒ. ๐ก
๐ 1. ๊ฐ์ธ ๋ง์ถคํ ๊ธ์ฐ๊ธฐ ๋์ฐ๋ฏธ
์์ ์ ๊ธ์ฐ๊ธฐ ์คํ์ผ์ ํ์ตํ GPT๋ฅผ ๋ง๋ค์ด๋ด! ์์ ์ด ์ด ๊ธ๋ค๋ก ํ์ธํ๋ํ๋ฉด, ๋น์ทํ ์คํ์ผ๋ก ๊ธ์ ์์ฑํด์ฃผ๋ AI ๋น์๊ฐ ๋ผ. ๋ธ๋ก๊ทธ ํฌ์คํธ, ์ด๋ฉ์ผ, ๋ณด๊ณ ์ ์์ฑ์ ๋์์ ๋ฐ์ ์ ์์ด! โ๏ธ
๊ตฌํ ํ:
โข ์์ ์ ๊ธ 100๊ฐ ์ด์ ์์ง
โข GPT-2๋ GPT-Neo๋ก ํ์ธํ๋
โข ์ฃผ์ ๋ณ๋ก ๋ค๋ฅธ ํ๋กฌํํธ ํ
ํ๋ฆฟ ์ค๋น
โข ์์ฑ๋ ๊ธ์ ์์ ํ๋ ์ธํฐํ์ด์ค ๊ตฌ์ถ
๐ฌ 2. ๋๋ฉ์ธ ํนํ ์ฑ๋ด
ํน์ ๋ถ์ผ์ ์ ๋ฌธ ์ง์์ ๊ฐ์ง ์ฑ๋ด์ ๋ง๋ค์ด๋ด! ์๋ฅผ ๋ค์ด ํ๋ก๊ทธ๋๋ฐ Q&A ๋ด, ์๋ฆฌ ๋ ์ํผ ์ถ์ฒ ๋ด, ์ฌํ ๊ฐ์ด๋ ๋ด ๋ฑ. ์ฌ๋ฅ๋ท์์ ์ด๋ฐ ์๋น์ค๋ฅผ ์ ๊ณตํ ์๋ ์์ด! ๐ค
๊ตฌํ ํ:
โข ํด๋น ๋๋ฉ์ธ์ ์ง๋ฌธ-๋ต๋ณ ๋ฐ์ดํฐ ์์ง
โข ๋ํ ํ์์ผ๋ก ๋ฐ์ดํฐ ๊ตฌ์กฐํ
โข ๋ฌธ๋งฅ์ ์ ์งํ๋ ๋ํ ๊ด๋ฆฌ ์์คํ
๊ตฌ์ถ
โข ์ฌ์ฉ์ ํผ๋๋ฐฑ์ผ๋ก ์ง์์ ๊ฐ์
๐จ 3. ์ฐฝ์์ ์ฝํ ์ธ ์์ฑ๊ธฐ
์, ์์ค, ๊ด๊ณ ์นดํผ, ๋
ธ๋ ๊ฐ์ฌ ๋ฑ์ ์์ฑํ๋ AI๋ฅผ ๋ง๋ค์ด๋ด! ์ฐฝ์์ฑ์ด ํ์ํ ๋ถ์ผ์์ ์๊ฐ์ ์ป๋ ๋๊ตฌ๋ก ํ์ฉํ ์ ์์ด. ๐ญ
๊ตฌํ ํ:
โข ์ฅ๋ฅด๋ณ๋ก ๋ค๋ฅธ ๋ชจ๋ธ ํ์ธํ๋
โข Temperature์ Top-p๋ฅผ ์กฐ์ ํด์ ์ฐฝ์์ฑ ์ ์ด
โข ์ฌ๋ฌ ๋ฒ์ ์ ์์ฑํด์ ์ ํํ ์ ์๊ฒ
โข ์ฌ์ฉ์๊ฐ ์คํ์ผ์ ์ง์ ํ ์ ์๋ ์ต์
์ ๊ณต
๐ 4. ์๋ ์์ฝ ๋ฐ ์ ๋ฆฌ ๋๊ตฌ
๊ธด ๋ฌธ์๋ ๊ธฐ์ฌ๋ฅผ ์ฝ๊ณ ํต์ฌ๋ง ์ถ์ถํ๋ ๋๊ตฌ๋ฅผ ๋ง๋ค์ด๋ด! ํ์ต์ด๋ ์
๋ฌด์ ์ ๋ง ์ ์ฉํด. ๐
๊ตฌํ ํ:
โข ์์ฝ ๋ฐ์ดํฐ์
์ผ๋ก ํ์ธํ๋ (์: CNN/DailyMail)
โข ์ถ์ถ์ ์์ฝ๊ณผ ์์ฑ์ ์์ฝ ๊ฒฐํฉ
โข ์์ฝ ๊ธธ์ด๋ฅผ ์กฐ์ ํ ์ ์๋ ์ต์
โข ์ค์ ํค์๋ ํ์ด๋ผ์ดํ
๊ธฐ๋ฅ ์ถ๊ฐ
๐ 5. ๋ค๊ตญ์ด ๋ฒ์ญ ๋ฐ ํ์งํ
GPT๋ฅผ ํ์ฉํ ๋ฒ์ญ ์์คํ
์ ๋ง๋ค์ด๋ด! ๋จ์ ๋ฒ์ญ์ ๋์ด์ ๋ฌธํ์ ๋งฅ๋ฝ๊น์ง ๊ณ ๋ คํ ํ์งํ๊ฐ ๊ฐ๋ฅํด. ๐บ๏ธ
๊ตฌํ ํ:
โข ๋ค๊ตญ์ด ๋ณ๋ ฌ ์ฝํผ์ค๋ก ํ์ต
โข ๋ฌธํ์ ๋์์ค๋ฅผ ๋ฐ์ํ๋ ํ๋กฌํํธ ์ค๊ณ
โข ์ญ๋ฒ์ญ์ผ๋ก ํ์ง ๊ฒ์ฆ
โข ์ ๋ฌธ ์ฉ์ด ์ฌ์ ํตํฉ
๐ ํ์ต ๋ฆฌ์์ค์ ์ปค๋ฎค๋ํฐ
GPT ๊ฐ๋ฐ์ ๊ณ์ ๊ณต๋ถํ๊ณ ์ถ๋ค๋ฉด ์ด๋ฐ ๋ฆฌ์์ค๋ค์ ํ์ฉํด๋ด! ํผ์์๋ ์ถฉ๋ถํ ๋ฐฐ์ธ ์ ์์ด. ๐
์จ๋ผ์ธ ๊ฐ์:
โข Stanford CS224N (Natural Language Processing with Deep Learning) ๐
โข Fast.ai์ Practical Deep Learning for Coders
โข Hugging Face์ NLP Course (๋ฌด๋ฃ!)
๋
ผ๋ฌธ:
โข "Attention is All You Need" (Transformer ์์กฐ ๋
ผ๋ฌธ) ๐
โข "Language Models are Few-Shot Learners" (GPT-3 ๋
ผ๋ฌธ)
โข "Training language models to follow instructions" (InstructGPT)
์ฑ
:
โข "Natural Language Processing with Transformers" by Lewis Tunstall
โข "Deep Learning" by Ian Goodfellow (๊ธฐ์ด ๋ค์ง๊ธฐ)
โข "Speech and Language Processing" by Jurafsky & Martin ๐
๋ธ๋ก๊ทธ์ ํํ ๋ฆฌ์ผ:
โข Jay Alammar์ The Illustrated Transformer (์๊ฐํ ์ต๊ณ !) ๐จ
โข Hugging Face Blog
โข OpenAI Blog
โข Towards Data Science์ NLP ๊ด๋ จ ๊ธ๋ค
์จ๋ผ์ธ ์ปค๋ฎค๋ํฐ:
โข Hugging Face Forums - ์ง๋ฌธํ๊ณ ๋ต๋ณ๋ฐ๊ธฐ ์ข์! ๐ฌ
โข Reddit์ r/MachineLearning, r/LanguageTechnology
โข Stack Overflow - ์ฝ๋ฉ ๋ฌธ์ ํด๊ฒฐ
โข GitHub - ์คํ์์ค ํ๋ก์ ํธ ์ฐธ์ฌ
ํ๊ตญ ์ปค๋ฎค๋ํฐ:
โข TensorFlow Korea
โข PyTorch Korea
โข AI Korea
โข ์ฌ๋ฅ๋ท์ AI/ํ๋ก๊ทธ๋๋ฐ ์นดํ
๊ณ ๋ฆฌ - ์ ๋ฌธ๊ฐ๋ค๊ณผ ์ํต! ๐ค
์ปจํผ๋ฐ์ค์ ๋ฐ์
:
โข NeurIPS, ICML, ACL ๊ฐ์ ๊ตญ์ ํํ
โข ํ๊ตญ์ ๋ณด๊ณผํํ, ํ๊ตญ์ธ๊ณต์ง๋ฅํํ
โข ๊ฐ์ข
AI ๋ฐ์
๊ณผ ์คํฐ๋ ๊ทธ๋ฃน
๐ฎ GPT์ ๋ฏธ๋์ ์ ๋ง
GPT ๊ธฐ์ ์ ๊ณ์ ๋ฐ์ ํ๊ณ ์์ด. ์์ผ๋ก ์ด๋ป๊ฒ ๋ ์ง ํ๋ฒ ์ดํด๋ณผ๊น? ๐
๐ ๋ฐ์ ๋ฐฉํฅ
โ ๋ฉํฐ๋ชจ๋ฌ ๋ชจ๋ธ: ํ
์คํธ๋ฟ๋ง ์๋๋ผ ์ด๋ฏธ์ง, ์ค๋์ค, ๋น๋์ค๊น์ง ์ดํดํ๊ณ ์์ฑํ๋ ๋ชจ๋ธ์ด ๋์ค๊ณ ์์ด. GPT-4V, DALL-E, Whisper ๊ฐ์ ๋ชจ๋ธ๋ค์ด ๊ทธ ์์ผ! ๐จ๐ต๐น
โก ๋ ํจ์จ์ ์ธ ๋ชจ๋ธ: ๊ฐ์ ์ฑ๋ฅ์ ๋ด๋ฉด์๋ ํฌ๊ธฐ๋ ์๊ณ ๋น ๋ฅธ ๋ชจ๋ธ๋ค์ด ๊ฐ๋ฐ๋๊ณ ์์ด. Mixture of Experts, Sparse Transformers ๊ฐ์ ๊ธฐ์ ๋ค์ด ์ฃผ๋ชฉ๋ฐ๊ณ ์์ง! โก
โข ๊ฐ์ธํ์ ๋ง์ถคํ: ๊ฐ ์ฌ์ฉ์์๊ฒ ๋ง์ถคํ๋ AI ๋น์๊ฐ ๊ฐ๋ฅํด์ง ๊ฑฐ์ผ. ๊ฐ์ธ์ ์ ํธ๋, ์คํ์ผ, ์ง์ ์์ค์ ๋ง์ถฐ ๋ํํ๋ AI! ๐ฏ
โฃ ์ถ๋ก ๋ฅ๋ ฅ ํฅ์: ๋จ์ํ ํจํด์ ํ์ตํ๋ ๊ฑธ ๋์ด์, ๋
ผ๋ฆฌ์ ์ถ๋ก ๊ณผ ๊ณํ ์๋ฆฝ์ด ๊ฐ๋ฅํ ๋ชจ๋ธ๋ก ๋ฐ์ ํ ๊ฑฐ์ผ. Chain-of-Thought, Tree of Thoughts ๊ฐ์ ๊ธฐ๋ฒ๋ค์ด ์ฐ๊ตฌ๋๊ณ ์์ด! ๐ง
โค ์ค๋ฆฌ์ ์์ ์ฑ: AI์ ํธํฅ์ ์ค์ด๊ณ , ์์ ํ๊ฒ ์ฌ์ฉํ ์ ์๋ ๋ฐฉ๋ฒ๋ค์ด ๊ณ์ ๊ฐ๋ฐ๋ ๊ฑฐ์ผ. Constitutional AI, RLHF ๊ฐ์ ๊ธฐ์ ๋ค์ด ๊ทธ ์์ง! ๐ก๏ธ
๐ผ ์ฐ์ ์ ์ฉ ๋ถ์ผ
GPT ๊ธฐ์ ์ ์ด๋ฏธ ๋ค์ํ ์ฐ์
์์ ํ์ฉ๋๊ณ ์์ด:
โข ๊ณ ๊ฐ ์๋น์ค: 24/7 ์ฑ๋ด, ์๋ ์๋ต ์์คํ
๐
โข ์ฝํ
์ธ ์ ์: ๊ธฐ์ฌ ์์ฑ, ๊ด๊ณ ์นดํผ, ์์
๋ฏธ๋์ด ํฌ์คํธ โ๏ธ
โข ๊ต์ก: ๊ฐ์ธ ๋ง์ถคํ ํํฐ, ์๋ ์ฑ์ , ํ์ต ์๋ฃ ์์ฑ ๐
โข ์๋ฃ: ์๋ฃ ๊ธฐ๋ก ์์ฝ, ์ง๋จ ๋ณด์กฐ, ํ์ ์๋ด ๐ฅ
โข ๋ฒ๋ฅ : ๊ณ์ฝ์ ๋ถ์, ํ๋ก ๊ฒ์, ๋ฒ๋ฅ ๋ฌธ์ ์์ฑ โ๏ธ
โข ๊ธ์ต: ๋ฆฌํฌํธ ์์ฑ, ๋ฆฌ์คํฌ ๋ถ์, ํฌ์ ์กฐ์ธ ๐ฐ
โข ์ํํธ์จ์ด ๊ฐ๋ฐ: ์ฝ๋ ์์ฑ, ๋ฒ๊ทธ ์์ , ๋ฌธ์ํ ๐ป
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ AI ๊ธฐ์ ์ ํ์ฉํ ์๋น์ค๋ค์ด ์ ์ ๋์ด๋ ๊ฑฐ์ผ! ๐
๐ฏ ๊ฐ๋ฐ์๋ก์์ ๊ธฐํ
GPT๋ฅผ ๋ค๋ฃฐ ์ค ์๋ ๊ฐ๋ฐ์๋ ์์ผ๋ก ์ ๋ง ๋ง์ ๊ธฐํ๋ฅผ ๊ฐ์ง ๊ฑฐ์ผ! ๐ช
โข AI ์์ง๋์ด, ML ์์ง๋์ด๋ก ์ทจ์
โข ํ๋ฆฌ๋์๋ก AI ํ๋ก์ ํธ ์์ฃผ
โข ์์ ๋ง์ AI ์๋น์ค๋ ์คํํธ์
์ฐฝ์
โข ๊ธฐ์กด ์ ํ์ AI ๊ธฐ๋ฅ ์ถ๊ฐ
โข AI ๊ต์ก ์ฝํ
์ธ ์ ์
ํนํ ๋๋ฉ์ธ ์ง์๊ณผ AI ๊ธฐ์ ์ ๊ฒฐํฉํ ์ ์๋ค๋ฉด ์ ๋ง ๊ฐ๋ ฅํด! ์๋ฅผ ๋ค์ด ์๋ฃ + AI, ๋ฒ๋ฅ + AI, ๊ธ์ต + AI ๊ฐ์ ์์ผ๋ก ๋ง์ด์ผ. ๐
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์! ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด. ๐ GPT ๋ชจ๋ธ์ ๊ธฐ์ด๋ถํฐ ์ค์ ๊ตฌํ, ์ต์ ํ, ์ค๋ฆฌ์ ๊ณ ๋ ค์ฌํญ๊น์ง ๋ค๋ค๋ดค์ด. ์ฒ์์ ์ด๋ ต๊ฒ ๋๊ปด์ก์ ์๋ ์์ง๋ง, ํ๋์ฉ ๋ฐ๋ผ์ค๋ค ๋ณด๋ฉด ์ถฉ๋ถํ ์ดํดํ ์ ์์ด!
ํต์ฌ์ ์ ๋ฆฌํ์๋ฉด:
๐ฏ GPT๋ ํธ๋์คํฌ๋จธ ๊ธฐ๋ฐ์ ์๊ธฐํ๊ท ์ธ์ด ๋ชจ๋ธ์ด์ผ. ์ดํ
์
๋ฉ์ปค๋์ฆ์ ํตํด ๋ฌธ๋งฅ์ ์ดํดํ๊ณ , ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ๋ฉด์ ์์ฐ์ค๋ฌ์ด ํ
์คํธ๋ฅผ ์์ฑํด.
๐ ๏ธ ์ง์ ๊ตฌํํ ์๋ ์์ง๋ง, ๋๋ถ๋ถ์ ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ํ์ธํ๋ํ๋ ๊ฒ ํ์ค์ ์ด์ผ. Hugging Face ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํ๋ฉด ํจ์ฌ ์ฌ์!
โก ์ต์ ํ๋ ํ์์ผ! ํผํฉ ์ ๋ฐ๋ ํ์ต, ๊ทธ๋๋์ธํธ ์ฒดํฌํฌ์ธํ
, ์์ํ ๊ฐ์ ๊ธฐ๋ฒ๋ค์ ์ฌ์ฉํด์ ํจ์จ์ ๋์ฌ์ผ ํด.
๐ก๏ธ ์์ ์ฑ๊ณผ ์ค๋ฆฌ๋ฅผ ํญ์ ๊ณ ๋ คํด์ผ ํด. ํธํฅ, ์ ํด ์ฝํ
์ธ , ์ค์ ๋ณด ๊ฐ์ ๋ฌธ์ ๋ค์ ์ธ์ํ๊ณ ๋๋นํด์ผ ํด.
๐ ๊ณ์ ๋ฐฐ์ฐ๊ณ ์คํํ๋ ๊ฒ ์ค์ํด! AI ๊ธฐ์ ์ ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๋๊น, ์ต์ ํธ๋ ๋๋ฅผ ๋ฐ๋ผ๊ฐ๊ณ ์ง์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ด.
GPT ๊ฐ๋ฐ์ ์ ๋ง ํฅ๋ฏธ์ง์งํ ๋ถ์ผ์ผ! ์ฐฝ์์ฑ๊ณผ ๊ธฐ์ ์ด ๋ง๋๋ ์ง์ ์ด๊ฑฐ๋ . ๋๋ ์ด์ ์์ ๋ง์ GPT ๋ชจ๋ธ์ ๋ง๋ค์ด์ ๋ฉ์ง ํ๋ก์ ํธ๋ฅผ ์์ํด๋ด. ๋งํ๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ์ปค๋ฎค๋ํฐ์ ์ง๋ฌธํ๊ณ , ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๐ค
ํ์ดํ
! ๋์ AI ์ฌ์ ์ ์์ํ ๊ฒ! ๐โจ
๐ ๋น์ ์ GPT ํ๋ก์ ํธ๋ฅผ ์์ํ์ธ์!
์ด ๊ธ์ด ๋์์ด ๋์๋ค๋ฉด, ์ง๊ธ ๋ฐ๋ก ์ฝ๋๋ฅผ ์ด๊ณ
์ฒซ ๋ฒ์งธ GPT ๋ชจ๋ธ์ ๋ง๋ค์ด๋ณด์ธ์!
The best time to start was yesterday.
The next best time is now! ๐ช
๐ ๋ ๋ง์ AI ์ง์์ด ํ์ํ์ ๊ฐ์?
์ฌ๋ฅ๋ท์์ AI ์ ๋ฌธ๊ฐ๋ค๊ณผ ํจ๊ป
๋น์ ์ ํ๋ก์ ํธ๋ฅผ ์ฑ๊ณต์์ผ๋ณด์ธ์! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.