Ver3.0 ๐ ํ์ด์ฌ๊ณผ Hugging Face Transformers๋ก ๋๊ท๋ชจ ์ธ์ด๋ชจ๋ธ(LLM) ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ํธ์ถํ๊ธฐ

๐ ํ์ด์ฌ๊ณผ Hugging Face Transformers๋ก ๋๊ท๋ชจ ์ธ์ด๋ชจ๋ธ(LLM) ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ํธ์ถํ๊ธฐ
์น๊ตฌ์ฒ๋ผ ํธํ๊ฒ ๋ฐฐ์ฐ๋ AI ๋ชจ๋ธ ํ์ฉ ์๋ฒฝ ๊ฐ์ด๋
๐ ์๋
! ์์ฆ ChatGPT๋ Claude ๊ฐ์ AI ์๋น์ค๋ค ๋ง์ด ์จ๋ณด์
จ์ฃ ? ๊ทธ๋ฐ๋ฐ ์ด๋ฐ ๊ฐ๋ ฅํ ์ธ์ด๋ชจ๋ธ์ ๋ด ํ์ด์ฌ ์ฝ๋์์ ์ง์ ๋ถ๋ฌ์ ์ธ ์ ์๋ค๋ฉด ์ด๋จ๊น์? ์ค๋์ Hugging Face Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํด์ ๋๊ท๋ชจ ์ธ์ด๋ชจ๋ธ(LLM)์ ๋ด ์ปดํจํฐ๋ ์๋ฒ์์ ์ง์ ํธ์ถํ๊ณ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ์น๊ตฌ์ฒ๋ผ ํธํ๊ฒ ์๋ ค๋๋ฆด๊ฒ์!
๐ก ์ด ๊ธ์ ๋ค ์ฝ๊ณ ๋๋ฉด ์ฌ๋ฌ๋ถ๋ GPT ์คํ์ผ์ ๋ชจ๋ธ์ ์ง์ ๋ค๋ฃฐ ์ ์๊ฒ ๋ ๊ฑฐ์์. ํ๋ก๊ทธ๋๋ฐ ์ด๋ณด์๋ ๋ฐ๋ผํ ์ ์๋๋ก ์ต๋ํ ์ฝ๊ฒ ์ค๋ช
ํ ํ
๋ ๊ฑฑ์ ๋ง์ธ์!
๐ฏ Hugging Face์ Transformers๊ฐ ๋ญ๊ธธ๋?
๋จผ์ ๊ธฐ๋ณธ๋ถํฐ ์์๋ณผ๊น์? Hugging Face๋ AI ๋ชจ๋ธ์ ๊ณต์ ํ๊ณ ํ์ฉํ ์ ์๋ ํ๋ซํผ์ด์์. ๋ง์น GitHub์ด ์ฝ๋๋ฅผ ๊ณต์ ํ๋ ๊ณณ์ด๋ผ๋ฉด, Hugging Face๋ AI ๋ชจ๋ธ์ ๊ณต์ ํ๋ ๊ณณ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ์.
๐ค Hugging Face์ ๋ง์ค์ฝํธ๋ ๊ท์ฌ์ด ์ด๋ชจ์ง์ธ๋ฐ, ์ด๊ฒ ๋ฐ๋ก ํ์ฌ ์ด๋ฆ์ ์ ๋์์. "ํฌ์นํ๋ ์ผ๊ตด"์ด๋ผ๋ ๋ป์ผ๋ก, AI๋ฅผ ๋ ์น๊ทผํ๊ณ ์ ๊ทผํ๊ธฐ ์ฝ๊ฒ ๋ง๋ค๊ฒ ๋ค๋ ์ฒ ํ์ ๋ด๊ณ ์์ฃ .
Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํต์ฌ ํน์ง:
โจ ํต์ผ๋ ์ธํฐํ์ด์ค: ์์ฒ ๊ฐ์ ๋ค์ํ ๋ชจ๋ธ์ ๋์ผํ ๋ฐฉ์์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ
๐ ํ๋ ์์ํฌ ํธํ์ฑ: PyTorch, TensorFlow, JAX ๋ชจ๋ ์ง์
๐ฆ ์ฌ์ ํ์ต ๋ชจ๋ธ: ์ด๋ฏธ ํ์ต๋ ๋ชจ๋ธ์ ๋ฐ๋ก ๋ค์ด๋ก๋ํด์ ์ฌ์ฉ
โก ๋น ๋ฅธ ์ถ๋ก : ์ต์ ํ๋ ์ฝ๋๋ก ์ค์๊ฐ ์๋ต ๊ฐ๋ฅ
๐ ๋ค๊ตญ์ด ์ง์: ํ๊ตญ์ด๋ฅผ ํฌํจํ 100๊ฐ ์ด์์ ์ธ์ด ๋ชจ๋ธ ์ ๊ณต
์ฌ๋ฅ๋ท(https://www.jaenung.net)์์ AI ๊ด๋ จ ์ฌ๋ฅ์ ๊ฑฐ๋ํ์๋ ๋ถ๋ค๋ ๋ง์๋ฐ, Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ์ฉํ๋ฉด ๊ณ ๊ฐ์๊ฒ ๋ ์ ๋ฌธ์ ์ธ AI ์๋ฃจ์ ์ ์ ๊ณตํ ์ ์์ด์!
๐ ๏ธ ํ๊ฒฝ ์ค์ : ์์์ด ๋ฐ์ด๋ค!
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํด๋ณผ๊น์? ๋จผ์ ํ์ํ ๋๊ตฌ๋ค์ ์ค์นํด์ผ ํด์. ๊ฑฑ์ ๋ง์ธ์, ์๊ฐ๋ณด๋ค ๊ฐ๋จํด์!
1๋จ๊ณ: Python ๋ฒ์ ํ์ธ
Python 3.7 ์ด์์ด ํ์ํด์. ํฐ๋ฏธ๋์ด๋ ๋ช
๋ น ํ๋กฌํํธ์์ ํ์ธํด๋ณด์ธ์:
python --version
# ๋๋
python3 --version
๐ก ํ: Python 3.8 ์ด์์ ๊ถ์ฅํด์. ์ต์ ๋ฒ์ ์ผ์๋ก ์ฑ๋ฅ๊ณผ ํธํ์ฑ์ด ์ข๊ฑฐ๋ ์!
2๋จ๊ณ: ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
์ด์ ํ์ํ ํจํค์ง๋ค์ ์ค์นํ ์ฐจ๋ก์์. ๋ช
๋ น์ด ํ๋๋ฉด ๋๋์:
pip install transformers torch accelerate
๊ฐ ํจํค์ง๊ฐ ํ๋ ์ผ์ ๊ฐ๋จํ ์ค๋ช ํ๋ฉด:
| ํจํค์ง๋ช | ์ญํ | ํ์๋ |
|---|---|---|
| transformers | Hugging Face์ ํต์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ๋ชจ๋ธ ๋ก๋ฉ๊ณผ ์ถ๋ก ๋ด๋น | ํ์ โญโญโญ |
| torch | PyTorch ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ, ๋ชจ๋ธ ์คํ ์์ง | ํ์ โญโญโญ |
| accelerate | ๋๊ท๋ชจ ๋ชจ๋ธ์ ํจ์จ์ ์ผ๋ก ๋ก๋ฉํ๊ณ ์คํ | ๊ถ์ฅ โญโญ |
| sentencepiece | ์ผ๋ถ ๋ชจ๋ธ์ ํ ํฌ๋์ด์ ์ ํ์ | ์ ํ โญ |
โ ๏ธ ์ฃผ์์ฌํญ: GPU๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด CUDA๊ฐ ์ค์น๋ PyTorch ๋ฒ์ ์ด ํ์ํด์. GPU๊ฐ ์๋ค๋ฉด CPU ๋ฒ์ ์ผ๋ก๋ ์ถฉ๋ถํ ํ ์คํธํ ์ ์์ด์. ๋ค๋ง ์๋๋ ์ข ๋๋ฆด ์ ์์ด์.
3๋จ๊ณ: GPU ์ฌ์ฉ ๊ฐ๋ฅ ์ฌ๋ถ ํ์ธ
์ค์น๊ฐ ๋๋ฌ๋ค๋ฉด GPU๋ฅผ ์ฌ์ฉํ ์ ์๋์ง ํ์ธํด๋ด์:
import torch
print(f"CUDA ์ฌ์ฉ ๊ฐ๋ฅ: {torch.cuda.is_available()}")
if torch.cuda.is_available():
print(f"GPU ์ด๋ฆ: {torch.cuda.get_device_name(0)}")
print(f"GPU ๋ฉ๋ชจ๋ฆฌ: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด GPU ์ฌ์ฉ ๊ฐ๋ฅ ์ฌ๋ถ์ ์ฌ์์ ์ ์ ์์ด์. GPU๊ฐ ์์ด๋ ๊ด์ฐฎ์์! CPU๋ก๋ ์ถฉ๋ถํ ํ์ตํ ์ ์๋ต๋๋ค.
๐ฌ ์ฒซ ๋ฒ์งธ LLM ํธ์ถ: Hello, AI World!
์, ์ด์ ์ง์ง ์ฌ๋ฏธ์๋ ๋ถ๋ถ์ด์์! ์ฒซ ๋ฒ์งธ ์ธ์ด๋ชจ๋ธ์ ๋ถ๋ฌ์์ ์ค์ ๋ก ํ
์คํธ๋ฅผ ์์ฑํด๋ณผ๊ฒ์.
๊ฐ์ฅ ๊ฐ๋จํ ์์ : GPT-2๋ก ํ
์คํธ ์์ฑํ๊ธฐ
Step 1: ํ์ํ ๋ชจ๋ ์ํฌํธ
from transformers import pipeline
# ํ
์คํธ ์์ฑ ํ์ดํ๋ผ์ธ ์์ฑ
generator = pipeline('text-generation', model='gpt2')
๐ ๋๋์ฃ ? ๋จ ๋ ์ค๋ก GPT-2 ๋ชจ๋ธ์ ๋ถ๋ฌ์์ด์! pipeline์ Hugging Face์ ๋ง๋ฒ ๊ฐ์ ํจ์์์. ๋ณต์กํ ์ค์ ์์ด ๋ฐ๋ก ๋ชจ๋ธ์ ์ฌ์ฉํ ์ ์๊ฒ ํด์ฃผ๊ฑฐ๋ ์.
Step 2: ํ ์คํธ ์์ฑํด๋ณด๊ธฐ
# ํ๋กฌํํธ ์
๋ ฅ
prompt = "์ธ๊ณต์ง๋ฅ์ ๋ฏธ๋๋"
# ํ
์คํธ ์์ฑ
result = generator(prompt, max_length=50, num_return_sequences=1)
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
print(result[0]['generated_text'])
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด AI๊ฐ ์ฌ๋ฌ๋ถ์ ํ๋กฌํํธ๋ฅผ ์ด์ด์ ๋ฌธ์ฅ์ ์์ฑํด์ค์!
ํ๋ผ๋ฏธํฐ ์ค๋ช
:
๐ max_length: ์์ฑํ ์ต๋ ํ ํฐ ์ (๋จ์ด ๊ฐ์์ ๋น์ทํ๊ฒ ์๊ฐํ๋ฉด ๋ผ์)
๐ข num_return_sequences: ์์ฑํ ๊ฒฐ๊ณผ์ ๊ฐ์
๐ก๏ธ temperature: ์ฐฝ์์ฑ ์กฐ์ (๋์์๋ก ๋ค์ํ๊ณ ์์ธก ๋ถ๊ฐ๋ฅ)
๐ฏ top_k: ์์ k๊ฐ ๋จ์ด ์ค์์๋ง ์ ํ
๐ top_p: ๋์ ํ๋ฅ ์ด p๊ฐ ๋ ๋๊น์ง์ ๋จ์ด๋ค ์ค์์ ์ ํ
๋ ์ธ๋ฐํ ์ ์ด: ํ๋ผ๋ฏธํฐ ์กฐ์ ํ๊ธฐ
์ด์ ์ข ๋ ๊ณ ๊ธ ๊ธฐ๋ฅ์ ์จ๋ณผ๊น์? ์์ฑ ํ์ง์ ๋์ด๋ ์ฌ๋ฌ ํ๋ผ๋ฏธํฐ๋ค์ ์กฐ์ ํด๋ด์:
result = generator(
"์ธ๊ณต์ง๋ฅ์ ๋ฏธ๋๋",
max_length=100,
num_return_sequences=3,
temperature=0.8,
top_k=50,
top_p=0.95,
do_sample=True
)
# ์ฌ๋ฌ ๊ฒฐ๊ณผ ์ถ๋ ฅ
for i, output in enumerate(result):
print(f"\n=== ๊ฒฐ๊ณผ {i+1} ===")
print(output['generated_text'])
๐ก ํ๋ก ํ: temperature๋ฅผ 0.7~0.9 ์ฌ์ด๋ก ์ค์ ํ๋ฉด ์ฐฝ์์ ์ด๋ฉด์๋ ์ผ๊ด์ฑ ์๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด์. 1.0 ์ด์์ผ๋ก ์ฌ๋ฆฌ๋ฉด ๋งค์ฐ ์ฐฝ์์ ์ด์ง๋ง ๋๋ก๋ ์ด์ํ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ์ ์์ด์!
๐ง ๋ค์ํ ๋ชจ๋ธ ํ์ฉํ๊ธฐ: ์ํฉ๋ณ ์ต์ ์ ํ
Hugging Face์๋ ์๋ง ๊ฐ์ ๋ชจ๋ธ์ด ์์ด์. ์ํฉ์ ๋ง๋ ๋ชจ๋ธ์ ์ ํํ๋ ๊ฒ์ด ์ค์ํ์ฃ . ๋ํ์ ์ธ ๋ชจ๋ธ๋ค์ ์ดํด๋ณผ๊ฒ์!
ํ๊ตญ์ด ํนํ ๋ชจ๋ธ: KoGPT ์๋ฆฌ์ฆ
ํ๊ตญ์ด๋ก ์์
ํ๋ค๋ฉด ํ๊ตญ์ด์ ํนํ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒ ํจ์ฌ ์ข์์:
from transformers import AutoTokenizer, AutoModelForCausalLM
# KoGPT ๋ชจ๋ธ ๋ก๋
model_name = "skt/kogpt2-base-v2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# ํ
์คํธ ์์ฑ
prompt = "์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ ๋ฐ์ ์ผ๋ก"
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs, max_length=100, do_sample=True, temperature=0.8)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)
ํ๊ตญ์ด ๋ชจ๋ธ ์ถ์ฒ ๋ฆฌ์คํธ:
๐ฐ๐ท skt/kogpt2-base-v2: SKT์์ ๋ง๋ ๊ฒฝ๋ ํ๊ตญ์ด GPT
๐ฐ๐ท kakaobrain/kogpt: ์นด์นด์ค๋ธ๋ ์ธ์ ๋๊ท๋ชจ ํ๊ตญ์ด ๋ชจ๋ธ
๐ฐ๐ท beomi/KoAlpaca-Polyglot-12.8B: ๋ช
๋ น์ด ํ๋๋ ํ๊ตญ์ด ๋ชจ๋ธ
๐ฐ๐ท nlpai-lab/kullm-polyglot-12.8b-v2: ๊ณ ์ฑ๋ฅ ํ๊ตญ์ด LLM
๋ํํ AI: ChatGPT ์คํ์ผ ๋ชจ๋ธ
๋ํ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ์ฑ๋ด์ ๋ง๋ค๊ณ ์ถ๋ค๋ฉด ๋ํ์ ํนํ๋ ๋ชจ๋ธ์ ์ฌ์ฉํด์ผ ํด์:
from transformers import AutoModelForCausalLM, AutoTokenizer
# ๋ํํ ๋ชจ๋ธ ๋ก๋
model_name = "microsoft/DialoGPT-medium"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# ๋ํ ์์
chat_history_ids = None
for step in range(5): # 5ํด ๋ํ
# ์ฌ์ฉ์ ์
๋ ฅ
user_input = input("You: ")
# ์
๋ ฅ ์ธ์ฝ๋ฉ
new_input_ids = tokenizer.encode(user_input + tokenizer.eos_token, return_tensors='pt')
# ์ด์ ๋ํ ์ด์ด๋ถ์ด๊ธฐ
bot_input_ids = torch.cat([chat_history_ids, new_input_ids], dim=-1) if chat_history_ids is not None else new_input_ids
# ์๋ต ์์ฑ
chat_history_ids = model.generate(
bot_input_ids,
max_length=1000,
pad_token_id=tokenizer.eos_token_id,
temperature=0.7,
top_p=0.9
)
# ์๋ต ๋์ฝ๋ฉ
response = tokenizer.decode(chat_history_ids[:, bot_input_ids.shape[-1]:][0], skip_special_tokens=True)
print(f"Bot: {response}")
๐ก ๋ํ ํ์ง ํฅ์ ํ: ๋ํ ํ์คํ ๋ฆฌ๋ฅผ ๊ณ์ ๋์ ํ๋ฉด ๋งฅ๋ฝ์ ์ดํดํ๋ ๋ํ๊ฐ ๊ฐ๋ฅํด์. ํ์ง๋ง ๋๋ฌด ๊ธธ์ด์ง๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์์ผ๋ ์ ์ ํ ์๋ผ์ฃผ๋ ๊ฒ๋ ์ค์ํด์!
ํน์ ๋ชฉ์ ๋ชจ๋ธ๋ค
| ์์ ์ ํ | ์ถ์ฒ ๋ชจ๋ธ | ์ฉ๋ |
|---|---|---|
| ํ ์คํธ ์์ฝ | facebook/bart-large-cnn | ๊ธด ๋ฌธ์๋ฅผ ์งง๊ฒ ์์ฝ |
| ๋ฒ์ญ | Helsinki-NLP/opus-mt-* | ๋ค๊ตญ์ด ๋ฒ์ญ (100+ ์ธ์ด์) |
| ์ง๋ฌธ ๋ต๋ณ | deepset/roberta-base-squad2 | ๋ฌธ์์์ ๋ต๋ณ ์ถ์ถ |
| ๊ฐ์ ๋ถ์ | cardiffnlp/twitter-roberta-base-sentiment | ๊ธ์ /๋ถ์ /์ค๋ฆฝ ํ๋จ |
| ์ฝ๋ ์์ฑ | Salesforce/codegen-350M-mono | ์์ฐ์ด๋ก ์ฝ๋ ์์ฑ |
โ๏ธ ๊ณ ๊ธ ๊ธฐ๋ฒ: ๋ชจ๋ธ ์ปค์คํฐ๋ง์ด์ง๊ณผ ์ต์ ํ
์ด์ ์ข ๋ ์ ๋ฌธ์ ์ธ ๋ด์ฉ์ผ๋ก ๋ค์ด๊ฐ๋ณผ๊ฒ์. ์ค๋ฌด์์ LLM์ ํ์ฉํ ๋ ํ์ํ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค์ด์์.
1. ๋ชจ๋ธ ์์ํ(Quantization): ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ ๋ง๋ฒ
๋๊ท๋ชจ ๋ชจ๋ธ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฒญ๋๊ฒ ๋ง์ด ๋จน์ด์. ์์ํ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ธ ํฌ๊ธฐ๋ฅผ 1/4๋ก ์ค์ผ ์ ์์ด์!
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
# 8๋นํธ ์์ํ ์ค์
quantization_config = BitsAndBytesConfig(
load_in_8bit=True,
llm_int8_threshold=6.0
)
# ์์ํ๋ ๋ชจ๋ธ ๋ก๋
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-7b-hf",
quantization_config=quantization_config,
device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
์์ํ์ ์ฅ๋จ์ :
โ
์ฅ์ :
โข ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ 75% ๊ฐ์
โข ์ถ๋ก ์๋ ํฅ์ ๊ฐ๋ฅ
โข ๋ ํฐ ๋ชจ๋ธ์ ์ํ GPU์์ ์คํ ๊ฐ๋ฅ
โ ๏ธ ๋จ์ :
โข ์ฝ๊ฐ์ ์ ํ๋ ์์ค (๋ณดํต 1-2%)
โข ์ด๊ธฐ ๋ก๋ฉ ์๊ฐ ์ฆ๊ฐ
โข ์ผ๋ถ ์ฐ์ฐ์์ ์๋ ์ ํ ๊ฐ๋ฅ
2. LoRA: ํจ์จ์ ์ธ ํ์ธํ๋
์ ์ฒด ๋ชจ๋ธ์ ์ฌํ์ตํ๋ ๋์ ์์ ์ด๋ํฐ๋ง ํ์ตํ๋ ๋ฐฉ๋ฒ์ด์์. ๋ฉ๋ชจ๋ฆฌ๋ ์ ๊ฒ ์ฐ๊ณ ์๋๋ ๋นจ๋ผ์:
from peft import LoraConfig, get_peft_model, TaskType
# LoRA ์ค์
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=8, # LoRA ๋ญํฌ
lora_alpha=32,
lora_dropout=0.1,
target_modules=["q_proj", "v_proj"] # ์ ์ฉํ ๋ ์ด์ด
)
# ๊ธฐ๋ณธ ๋ชจ๋ธ์ LoRA ์ ์ฉ
model = AutoModelForCausalLM.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%
๐ก LoRA ํ๋ผ๋ฏธํฐ ๊ฐ์ด๋:
โข r (๋ญํฌ): 4-16 ์ฌ์ด ๊ถ์ฅ. ๋์์๋ก ํํ๋ ฅ ์ฆ๊ฐํ์ง๋ง ๋ฉ๋ชจ๋ฆฌ๋ ์ฆ๊ฐ
โข lora_alpha: ๋ณดํต r์ 2-4๋ฐฐ๋ก ์ค์
โข lora_dropout: 0.05-0.1 ์ฌ์ด๊ฐ ์ ๋น
3. ๋ฐฐ์น ์ฒ๋ฆฌ: ์ฌ๋ฌ ์
๋ ฅ ๋์ ์ฒ๋ฆฌ
ํ ๋ฒ์ ์ฌ๋ฌ ํ
์คํธ๋ฅผ ์ฒ๋ฆฌํ๋ฉด ํจ์จ์ด ํจ์ฌ ์ข์์ ธ์:
from transformers import pipeline
# ํ์ดํ๋ผ์ธ ์์ฑ
generator = pipeline('text-generation', model='gpt2', device=0) # GPU ์ฌ์ฉ
# ์ฌ๋ฌ ํ๋กฌํํธ ์ค๋น
prompts = [
"์ธ๊ณต์ง๋ฅ์ ๋ฏธ๋๋",
"๊ธฐํ ๋ณํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ฉด",
"์ฐ์ฃผ ํ์ฌ์ ๋ค์ ๋ชฉํ๋"
]
# ๋ฐฐ์น ์ฒ๋ฆฌ
results = generator(prompts, max_length=50, batch_size=3)
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
for i, result in enumerate(results):
print(f"\nํ๋กฌํํธ {i+1}: {prompts[i]}")
print(f"์์ฑ ๊ฒฐ๊ณผ: {result[0]['generated_text']}")
4. ์คํธ๋ฆฌ๋ฐ ์์ฑ: ์ค์๊ฐ ์ถ๋ ฅ
ChatGPT์ฒ๋ผ ํ
์คํธ๊ฐ ์ค์๊ฐ์ผ๋ก ์์ฑ๋๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๊ฒ ํ๋ ค๋ฉด:
from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
from threading import Thread
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# ์คํธ๋ฆฌ๋จธ ์ค์
streamer = TextIteratorStreamer(tokenizer, skip_special_tokens=True)
# ์
๋ ฅ ์ค๋น
prompt = "์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ ๋ฐ์ ์ผ๋ก"
inputs = tokenizer(prompt, return_tensors="pt")
# ๋ณ๋ ์ค๋ ๋์์ ์์ฑ ์์
generation_kwargs = dict(inputs, streamer=streamer, max_length=100)
thread = Thread(target=model.generate, kwargs=generation_kwargs)
thread.start()
# ์ค์๊ฐ์ผ๋ก ์ถ๋ ฅ
print(prompt, end="")
for new_text in streamer:
print(new_text, end="", flush=True)
thread.join()
โ ๏ธ ์ฑ๋ฅ ์ต์ ํ ์ฃผ์์ฌํญ:
โข GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ๋ฉด device_map="auto"๋ฅผ ์ฌ์ฉํด ์๋์ผ๋ก CPU/GPU ๋ถ์ฐ
โข ๋ฐฐ์น ํฌ๊ธฐ๋ GPU ๋ฉ๋ชจ๋ฆฌ์ ๋ง์ถฐ ์กฐ์ (OOM ์๋ฌ ์ฃผ์)
โข ๊ธด ์ํ์ค๋ gradient_checkpointing์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ ๊ฐ๋ฅ
๐จ ์ค์ ํ๋ก์ ํธ: ๋๋ง์ AI ์ฑ๋ด ๋ง๋ค๊ธฐ
์ด์ ๋ฐฐ์ด ๋ด์ฉ์ ์ข
ํฉํด์ ์ค์ ๋ก ๋์ํ๋ ์ฑ๋ด์ ๋ง๋ค์ด๋ณผ๊ฒ์! ์ฌ๋ฅ๋ท์์ AI ์ฑ๋ด ๊ฐ๋ฐ ์ฌ๋ฅ์ ๊ณต์ ํ๊ณ ์ถ์ ๋ถ๋ค์๊ฒ ํนํ ์ ์ฉํ ๊ฑฐ์์.
ํ๋ก์ ํธ ๊ตฌ์กฐ ์ค๊ณ
chatbot_project/
โ
โโโ models/ # ๋ชจ๋ธ ์ ์ฅ ํด๋
โโโ config.py # ์ค์ ํ์ผ
โโโ chatbot.py # ์ฑ๋ด ํต์ฌ ๋ก์ง
โโโ utils.py # ์ ํธ๋ฆฌํฐ ํจ์
โโโ main.py # ์คํ ํ์ผ
Step 1: ์ค์ ํ์ผ ์์ฑ (config.py)
class ChatbotConfig:
# ๋ชจ๋ธ ์ค์
MODEL_NAME = "microsoft/DialoGPT-medium"
MAX_LENGTH = 1000
TEMPERATURE = 0.7
TOP_P = 0.9
TOP_K = 50
# ๋ํ ์ค์
MAX_HISTORY = 5 # ์ต๊ทผ 5ํด๊น์ง๋ง ๊ธฐ์ต
# ์์คํ
์ค์
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
# ์๋ต ํํฐ๋ง
MIN_LENGTH = 10
MAX_RESPONSE_LENGTH = 200
Step 2: ์ฑ๋ด ํด๋์ค ๊ตฌํ (chatbot.py)
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from config import ChatbotConfig
class AIChatbot:
def __init__(self):
self.config = ChatbotConfig()
self.tokenizer = AutoTokenizer.from_pretrained(self.config.MODEL_NAME)
self.model = AutoModelForCausalLM.from_pretrained(self.config.MODEL_NAME)
self.model.to(self.config.DEVICE)
self.chat_history = []
def generate_response(self, user_input):
"""์ฌ์ฉ์ ์
๋ ฅ์ ๋ํ ์๋ต ์์ฑ"""
# ์
๋ ฅ ์ธ์ฝ๋ฉ
new_input_ids = self.tokenizer.encode(
user_input + self.tokenizer.eos_token,
return_tensors='pt'
).to(self.config.DEVICE)
# ๋ํ ํ์คํ ๋ฆฌ ๊ด๋ฆฌ
if len(self.chat_history) > 0:
bot_input_ids = torch.cat([self.chat_history[-1], new_input_ids], dim=-1)
else:
bot_input_ids = new_input_ids
# ํ์คํ ๋ฆฌ ๊ธธ์ด ์ ํ
if bot_input_ids.shape[-1] > self.config.MAX_LENGTH:
bot_input_ids = bot_input_ids[:, -self.config.MAX_LENGTH:]
# ์๋ต ์์ฑ
with torch.no_grad():
chat_history_ids = self.model.generate(
bot_input_ids,
max_length=bot_input_ids.shape[-1] + self.config.MAX_RESPONSE_LENGTH,
pad_token_id=self.tokenizer.eos_token_id,
temperature=self.config.TEMPERATURE,
top_p=self.config.TOP_P,
top_k=self.config.TOP_K,
do_sample=True
)
# ์๋ต ๋์ฝ๋ฉ
response = self.tokenizer.decode(
chat_history_ids[:, bot_input_ids.shape[-1]:][0],
skip_special_tokens=True
)
# ํ์คํ ๋ฆฌ ์
๋ฐ์ดํธ
self.chat_history.append(chat_history_ids)
if len(self.chat_history) > self.config.MAX_HISTORY:
self.chat_history.pop(0)
return response
def reset_conversation(self):
"""๋ํ ํ์คํ ๋ฆฌ ์ด๊ธฐํ"""
self.chat_history = []
print("๋ํ๊ฐ ์ด๊ธฐํ๋์์ต๋๋ค.")
Step 3: ์ ํธ๋ฆฌํฐ ํจ์ (utils.py)
import re
from datetime import datetime
def clean_response(text):
"""์๋ต ํ
์คํธ ์ ์ """
# ํน์๋ฌธ์ ์ ๊ฑฐ
text = re.sub(r'[^\w\s๊ฐ-ํฃ.,!?]', '', text)
# ์ฐ์๋ ๊ณต๋ฐฑ ์ ๊ฑฐ
text = re.sub(r'\s+', ' ', text)
return text.strip()
def save_conversation(conversation_log, filename=None):
"""๋ํ ๋ด์ฉ ์ ์ฅ"""
if filename is None:
filename = f"conversation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
with open(filename, 'w', encoding='utf-8') as f:
for turn in conversation_log:
f.write(f"User: {turn['user']}\n")
f.write(f"Bot: {turn['bot']}\n")
f.write("-" * 50 + "\n")
print(f"๋ํ๊ฐ {filename}์ ์ ์ฅ๋์์ต๋๋ค.")
def load_custom_responses(filepath):
"""์ปค์คํ
์๋ต ํจํด ๋ก๋"""
custom_responses = {}
try:
with open(filepath, 'r', encoding='utf-8') as f:
for line in f:
if '|' in line:
pattern, response = line.strip().split('|')
custom_responses[pattern.lower()] = response
except FileNotFoundError:
print("์ปค์คํ
์๋ต ํ์ผ์ ์ฐพ์ ์ ์์ต๋๋ค.")
return custom_responses
Step 4: ๋ฉ์ธ ์คํ ํ์ผ (main.py)
from chatbot import AIChatbot
from utils import clean_response, save_conversation
import sys
def main():
print("=" * 60)
print("๐ค AI ์ฑ๋ด์ ์์ํฉ๋๋ค!")
print("=" * 60)
print("๋ช
๋ น์ด:")
print(" - 'quit' ๋๋ 'exit': ์ข
๋ฃ")
print(" - 'reset': ๋ํ ์ด๊ธฐํ")
print(" - 'save': ๋ํ ๋ด์ฉ ์ ์ฅ")
print("=" * 60)
# ์ฑ๋ด ์ด๊ธฐํ
chatbot = AIChatbot()
conversation_log = []
while True:
try:
# ์ฌ์ฉ์ ์
๋ ฅ
user_input = input("\n๋น์ : ").strip()
# ์ข
๋ฃ ๋ช
๋ น
if user_input.lower() in ['quit', 'exit', '์ข
๋ฃ']:
print("\n์ฑ๋ด์ ์ข
๋ฃํฉ๋๋ค. ์๋
ํ ๊ฐ์ธ์! ๐")
break
# ์ด๊ธฐํ ๋ช
๋ น
if user_input.lower() in ['reset', '์ด๊ธฐํ']:
chatbot.reset_conversation()
conversation_log = []
continue
# ์ ์ฅ ๋ช
๋ น
if user_input.lower() in ['save', '์ ์ฅ']:
if conversation_log:
save_conversation(conversation_log)
else:
print("์ ์ฅํ ๋ํ๊ฐ ์์ต๋๋ค.")
continue
# ๋น ์
๋ ฅ ์ฒ๋ฆฌ
if not user_input:
print("๋ฉ์์ง๋ฅผ ์
๋ ฅํด์ฃผ์ธ์.")
continue
# ์๋ต ์์ฑ
print("์ฑ๋ด: ", end="", flush=True)
response = chatbot.generate_response(user_input)
response = clean_response(response)
print(response)
# ๋ํ ๋ก๊ทธ ์ ์ฅ
conversation_log.append({
'user': user_input,
'bot': response
})
except KeyboardInterrupt:
print("\n\nํ๋ก๊ทธ๋จ์ด ์ค๋จ๋์์ต๋๋ค.")
sys.exit(0)
except Exception as e:
print(f"\n์ค๋ฅ๊ฐ ๋ฐ์ํ์ต๋๋ค: {str(e)}")
print("๊ณ์ ์งํํ๋ ค๋ฉด ์๋ฌด ํค๋ ๋๋ฅด์ธ์...")
if __name__ == "__main__":
main()
์ฑ๋ด ๊ฐ์ ์์ด๋์ด:
๐ฏ ๊ฐ์ ๋ถ์ ์ถ๊ฐ: ์ฌ์ฉ์ ๊ฐ์ ์ ๋ฐ๋ผ ์๋ต ํค ์กฐ์
๐ง ์ฅ๊ธฐ ๊ธฐ์ต: ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ํ ์ ์ฅํ๊ณ ์ฐธ์กฐ
๐ ์น ์ธํฐํ์ด์ค: Flask๋ FastAPI๋ก ์น ์๋น์คํ
๐ ์์ฑ ์ง์: TTS/STT ํตํฉ์ผ๋ก ์์ฑ ๋ํ ๊ฐ๋ฅ
๐ ๋ถ์ ๋์๋ณด๋: ๋ํ ํต๊ณ ๋ฐ ์ฌ์ฉ์ ํจํด ๋ถ์
๐ ๋ฌธ์ ํด๊ฒฐ ๊ฐ์ด๋: ์์ฃผ ๋ง๋๋ ์๋ฌ๋ค
LLM์ ๋ค๋ฃจ๋ค ๋ณด๋ฉด ์ฌ๋ฌ ๊ฐ์ง ๋ฌธ์ ๋ฅผ ๋ง๋๊ฒ ๋ผ์. ๊ฐ์ฅ ํํ ์๋ฌ๋ค๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ดค์ด์!
1. CUDA Out of Memory (OOM) ์๋ฌ
์๋ฌ ๋ฉ์์ง: RuntimeError: CUDA out of memory. Tried to allocate X.XX GiB
ํด๊ฒฐ ๋ฐฉ๋ฒ:
# ๋ฐฉ๋ฒ 1: ๋ฐฐ์น ํฌ๊ธฐ ์ค์ด๊ธฐ
outputs = model.generate(inputs, batch_size=1) # ๊ธฐ๋ณธ๊ฐ๋ณด๋ค ์๊ฒ
# ๋ฐฉ๋ฒ 2: ๊ทธ๋๋์ธํธ ์ฒดํฌํฌ์ธํ
model.gradient_checkpointing_enable()
# ๋ฐฉ๋ฒ 3: ์์ํ ์ฌ์ฉ
from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=quantization_config
)
# ๋ฐฉ๋ฒ 4: ์บ์ ์ ๋ฆฌ
import torch
torch.cuda.empty_cache()
# ๋ฐฉ๋ฒ 5: ๋ ์์ ๋ชจ๋ธ ์ฌ์ฉ
# ์: gpt2-large ๋์ gpt2-medium ์ฌ์ฉ
2. ํ ํฌ๋์ด์ ๊ฒฝ๊ณ ๋ฉ์์ง
๊ฒฝ๊ณ ๋ฉ์์ง: Token indices sequence length is longer than the specified maximum sequence length
ํด๊ฒฐ ๋ฐฉ๋ฒ:
# ์
๋ ฅ ๊ธธ์ด ์ ํ
inputs = tokenizer(
text,
max_length=512,
truncation=True, # ์๋ ์๋ผ๋ด๊ธฐ
padding=True,
return_tensors="pt"
)
# ๋๋ ์๋์ผ๋ก ํ
์คํธ ๋ถํ
def split_text(text, max_length=500):
words = text.split()
chunks = []
current_chunk = []
for word in words:
current_chunk.append(word)
if len(' '.join(current_chunk)) > max_length:
chunks.append(' '.join(current_chunk[:-1]))
current_chunk = [word]
if current_chunk:
chunks.append(' '.join(current_chunk))
return chunks
3. ๋๋ฆฐ ์ถ๋ก ์๋
์ฑ๋ฅ ๊ฐ์ ๋ฐฉ๋ฒ:
# 1. GPU ์ฌ์ฉ ํ์ธ
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)
# 2. Half precision ์ฌ์ฉ (GPU ์ ์ฉ)
model.half() # FP16์ผ๋ก ๋ณํ
# 3. torch.compile ์ฌ์ฉ (PyTorch 2.0+)
import torch
model = torch.compile(model)
# 4. ๋ฐฐ์น ์ฒ๋ฆฌ
inputs = tokenizer(texts, padding=True, return_tensors="pt")
outputs = model.generate(**inputs)
# 5. KV ์บ์ ํ์ฉ
outputs = model.generate(
inputs,
use_cache=True, # ๊ธฐ๋ณธ๊ฐ์ด์ง๋ง ๋ช
์์ ์ผ๋ก
past_key_values=past_kv # ์ด์ ๊ณ์ฐ ์ฌ์ฌ์ฉ
)
4. ์ด์ํ ์ถ๋ ฅ ๊ฒฐ๊ณผ
| ์ฆ์ | ์์ธ | ํด๊ฒฐ์ฑ |
|---|---|---|
| ๋ฐ๋ณต๋๋ ํ ์คํธ | temperature๊ฐ ๋๋ฌด ๋ฎ์ | temperature๋ฅผ 0.7-0.9๋ก ์ฆ๊ฐ |
| ๋ฌด์๋ฏธํ ์ถ๋ ฅ | temperature๊ฐ ๋๋ฌด ๋์ | temperature๋ฅผ 0.5-0.7๋ก ๊ฐ์ |
| ์งง์ ์๋ต | max_length๊ฐ ์์ | max_length ์ฆ๊ฐ ๋๋ min_length ์ค์ |
| ๋งฅ๋ฝ ๋ฌด์ | ํ๋กฌํํธ ํ์ ๋ฌธ์ | ๋ช ํํ ์ง์๋ฌธ๊ณผ ์์ ์ถ๊ฐ |
5. ๋ชจ๋ธ ๋ค์ด๋ก๋ ์คํจ
# ๋ฐฉ๋ฒ 1: ์บ์ ๋๋ ํ ๋ฆฌ ์ง์
from transformers import AutoModel
model = AutoModel.from_pretrained(
"model_name",
cache_dir="./my_cache" # ์ํ๋ ๊ฒฝ๋ก
)
# ๋ฐฉ๋ฒ 2: ์คํ๋ผ์ธ ๋ชจ๋ (๋ฏธ๋ฆฌ ๋ค์ด๋ก๋ํ ๊ฒฝ์ฐ)
from transformers import AutoModel
model = AutoModel.from_pretrained(
"./local_model_path",
local_files_only=True
)
# ๋ฐฉ๋ฒ 3: ํ๋ก์ ์ค์
import os
os.environ['HTTP_PROXY'] = 'http://proxy.example.com:8080'
os.environ['HTTPS_PROXY'] = 'http://proxy.example.com:8080'
# ๋ฐฉ๋ฒ 4: ์ฌ์๋ ๋ก์ง
from transformers import AutoModel
import time
def download_model_with_retry(model_name, max_retries=3):
for i in range(max_retries):
try:
model = AutoModel.from_pretrained(model_name)
return model
except Exception as e:
print(f"๋ค์ด๋ก๋ ์คํจ (์๋ {i+1}/{max_retries}): {e}")
if i < max_retries - 1:
time.sleep(5)
else:
raise
๋๋ฒ๊น
ํ:
๐ ๋ก๊น
ํ์ฑํ: transformers.logging.set_verbosity_info()
๐ ๋ฉ๋ชจ๋ฆฌ ๋ชจ๋ํฐ๋ง: torch.cuda.memory_summary()
โฑ๏ธ ์๊ฐ ์ธก์ : time.time()์ผ๋ก ๋ณ๋ชฉ ์ง์ ์ฐพ๊ธฐ
๐งช ์์ ๋ฐ์ดํฐ๋ก ํ
์คํธ: ์ ์ฒด ์คํ ์ ์ํ๋ก ๊ฒ์ฆ
๐ ํ๋ก๋์ ๋ฐฐํฌ: ์ค์ ์๋น์ค ๋ง๋ค๊ธฐ
์ด์ ๊ฐ๋ฐํ ๋ชจ๋ธ์ ์ค์ ์๋น์ค๋ก ๋ฐฐํฌํ๋ ๋ฐฉ๋ฒ์ ์์๋ณผ๊ฒ์. ์ฌ๋ฅ๋ท์์ AI ์๋น์ค๋ฅผ ์ ๊ณตํ๋ ค๋ ๋ถ๋ค์๊ฒ ๊ผญ ํ์ํ ๋ด์ฉ์ด์์!
FastAPI๋ก REST API ๋ง๋ค๊ธฐ
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import pipeline
import torch
import uvicorn
# FastAPI ์ฑ ์์ฑ
app = FastAPI(title="LLM API Service")
# ๋ชจ๋ธ ๋ก๋ (์ฑ ์์ ์ ํ ๋ฒ๋ง)
@app.on_event("startup")
async def load_model():
global generator
device = 0 if torch.cuda.is_available() else -1
generator = pipeline(
'text-generation',
model='gpt2',
device=device
)
print("๋ชจ๋ธ ๋ก๋ ์๋ฃ!")
# ์์ฒญ ๋ชจ๋ธ ์ ์
class GenerateRequest(BaseModel):
prompt: str
max_length: int = 100
temperature: float = 0.7
num_return_sequences: int = 1
# ์๋ต ๋ชจ๋ธ ์ ์
class GenerateResponse(BaseModel):
generated_texts: list[str]
model_name: str
parameters: dict
# ํ
์คํธ ์์ฑ ์๋ํฌ์ธํธ
@app.post("/generate", response_model=GenerateResponse)
async def generate_text(request: GenerateRequest):
try:
# ์
๋ ฅ ๊ฒ์ฆ
if not request.prompt:
raise HTTPException(status_code=400, detail="ํ๋กฌํํธ๊ฐ ๋น์ด์์ต๋๋ค.")
if request.max_length > 500:
raise HTTPException(status_code=400, detail="max_length๋ 500 ์ดํ์ฌ์ผ ํฉ๋๋ค.")
# ํ
์คํธ ์์ฑ
results = generator(
request.prompt,
max_length=request.max_length,
temperature=request.temperature,
num_return_sequences=request.num_return_sequences,
do_sample=True
)
# ๊ฒฐ๊ณผ ์ถ์ถ
generated_texts = [r['generated_text'] for r in results]
return GenerateResponse(
generated_texts=generated_texts,
model_name="gpt2",
parameters={
"max_length": request.max_length,
"temperature": request.temperature,
"num_sequences": request.num_return_sequences
}
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"์์ฑ ์ค ์ค๋ฅ ๋ฐ์: {str(e)}")
# ํฌ์ค ์ฒดํฌ ์๋ํฌ์ธํธ
@app.get("/health")
async def health_check():
return {
"status": "healthy",
"model_loaded": 'generator' in globals(),
"cuda_available": torch.cuda.is_available()
}
# ์๋ฒ ์คํ
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)
Docker๋ก ์ปจํ ์ด๋ํํ๊ธฐ
# Dockerfile
FROM python:3.9-slim
WORKDIR /app
# ์์คํ
์์กด์ฑ ์ค์น
RUN apt-get update && apt-get install -y \
build-essential \
&& rm -rf /var/lib/apt/lists/*
# Python ํจํค์ง ์ค์น
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# ์ ํ๋ฆฌ์ผ์ด์
์ฝ๋ ๋ณต์ฌ
COPY . .
# ๋ชจ๋ธ ์บ์ ๋๋ ํ ๋ฆฌ ์์ฑ
RUN mkdir -p /app/model_cache
ENV TRANSFORMERS_CACHE=/app/model_cache
# ํฌํธ ๋
ธ์ถ
EXPOSE 8000
# ์๋ฒ ์คํ
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
# requirements.txt
fastapi==0.104.1
uvicorn[standard]==0.24.0
transformers==4.35.0
torch==2.1.0
pydantic==2.5.0
accelerate==0.24.0
# docker-compose.yml
version: '3.8'
services:
llm-api:
build: .
ports:
- "8000:8000"
volumes:
- ./model_cache:/app/model_cache
environment:
- CUDA_VISIBLE_DEVICES=0
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 1
capabilities: [gpu]
์ฑ๋ฅ ๋ชจ๋ํฐ๋ง ์ถ๊ฐ
from prometheus_client import Counter, Histogram, generate_latest
from fastapi import Response
import time
# ๋ฉํธ๋ฆญ ์ ์
request_count = Counter('llm_requests_total', 'Total requests')
request_duration = Histogram('llm_request_duration_seconds', 'Request duration')
generation_tokens = Histogram('llm_generated_tokens', 'Generated tokens count')
@app.post("/generate")
async def generate_text(request: GenerateRequest):
start_time = time.time()
request_count.inc()
try:
results = generator(...)
# ํ ํฐ ์ ๊ธฐ๋ก
for result in results:
token_count = len(result['generated_text'].split())
generation_tokens.observe(token_count)
return GenerateResponse(...)
finally:
# ์์ฒญ ์๊ฐ ๊ธฐ๋ก
duration = time.time() - start_time
request_duration.observe(duration)
# ๋ฉํธ๋ฆญ ์๋ํฌ์ธํธ
@app.get("/metrics")
async def metrics():
return Response(generate_latest(), media_type="text/plain")
๐ก ๋ฐฐํฌ ์ฒดํฌ๋ฆฌ์คํธ:
โ
ํ๊ฒฝ ๋ณ์๋ก ๋ฏผ๊ฐํ ์ ๋ณด ๊ด๋ฆฌ
โ
๋ก๊น
์์คํ
๊ตฌ์ถ (ELK, CloudWatch ๋ฑ)
โ
์๋ฌ ์ถ์ ๋๊ตฌ ์ฐ๋ (Sentry ๋ฑ)
โ
API ๋ฌธ์ ์๋ ์์ฑ (FastAPI Swagger)
โ
๋ ์ดํธ ๋ฆฌ๋ฏธํ
๊ตฌํ
โ
HTTPS ์ ์ฉ
โ
๋ฐฑ์
๋ฐ ๋ณต๊ตฌ ๊ณํ ์๋ฆฝ
๋ถํ ํ ์คํธ
# locust๋ฅผ ์ฌ์ฉํ ๋ถํ ํ
์คํธ
from locust import HttpUser, task, between
class LLMUser(HttpUser):
wait_time = between(1, 3)
@task
def generate_text(self):
self.client.post("/generate", json={
"prompt": "์ธ๊ณต์ง๋ฅ์ ๋ฏธ๋๋",
"max_length": 50,
"temperature": 0.7
})
@task(2) # 2๋ฐฐ ๋ ์์ฃผ ์คํ
def health_check(self):
self.client.get("/health")
# ์คํ: locust -f load_test.py --host=http://localhost:8000
๐ ๊ณ ๊ธ ํ์ฉ: ํ์ธํ๋๊ณผ ์ปค์คํฐ๋ง์ด์ง
์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๊ทธ๋๋ก ์ฐ๋ ๊ฒ๋ ์ข์ง๋ง, ํน์ ๋๋ฉ์ธ์ด๋ ์คํ์ผ์ ๋ง๊ฒ ์ปค์คํฐ๋ง์ด์งํ๋ฉด ํจ์ฌ ๋ ์ข์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด์!
๋ฐ์ดํฐ์
์ค๋นํ๊ธฐ
ํ์ธํ๋์ ์ํด์๋ ๋จผ์ ํ์ต ๋ฐ์ดํฐ๋ฅผ ์ค๋นํด์ผ ํด์:
from datasets import Dataset
import pandas as pd
# ๋ฐ์ดํฐ ์ค๋น (์: ๊ณ ๊ฐ ์๋ด ๋ฐ์ดํฐ)
data = {
'prompt': [
"์ ํ ๋ฐฐ์ก์ ์ผ๋ง๋ ๊ฑธ๋ฆฌ๋์?",
"ํ๋ถ ์ ์ฑ
์ด ์ด๋ป๊ฒ ๋๋์?",
"ํ์๊ฐ์
์ ์ด๋ป๊ฒ ํ๋์?"
],
'response': [
"์ผ๋ฐ์ ์ผ๋ก ์ฃผ๋ฌธ ํ 2-3์ผ ๋ด์ ๋ฐฐ์ก๋ฉ๋๋ค. ์ง์ญ์ ๋ฐ๋ผ ์ฐจ์ด๊ฐ ์์ ์ ์์ต๋๋ค.",
"๊ตฌ๋งค ํ 7์ผ ์ด๋ด ๋ฏธ๊ฐ๋ด ์ํ์ ํํด ์ ์ก ํ๋ถ์ด ๊ฐ๋ฅํฉ๋๋ค.",
"ํํ์ด์ง ์ฐ์ธก ์๋จ์ 'ํ์๊ฐ์
' ๋ฒํผ์ ํด๋ฆญํ์ฌ ์งํํ์ค ์ ์์ต๋๋ค."
]
}
df = pd.DataFrame(data)
# ํ๋กฌํํธ ํ์ ์ง์
def format_prompt(row):
return f"์ง๋ฌธ: {row['prompt']}\n๋ต๋ณ: {row['response']}"
df['text'] = df.apply(format_prompt, axis=1)
# Dataset ๊ฐ์ฒด๋ก ๋ณํ
dataset = Dataset.from_pandas(df[['text']])
print(dataset)
LoRA๋ฅผ ์ฌ์ฉํ ํจ์จ์ ํ์ธํ๋
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
Trainer,
DataCollatorForLanguageModeling
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import torch
# ๋ชจ๋ธ๊ณผ ํ ํฌ๋์ด์ ๋ก๋
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
model = AutoModelForCausalLM.from_pretrained(
model_name,
load_in_8bit=True, # ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ
device_map="auto"
)
# ์์ํ ํ์ต ์ค๋น
model = prepare_model_for_kbit_training(model)
# LoRA ์ค์
lora_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["c_attn"], # GPT-2์ ์ดํ
์
๋ ์ด์ด
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM"
)
# LoRA ์ ์ฉ
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ
def tokenize_function(examples):
return tokenizer(
examples['text'],
truncation=True,
max_length=512,
padding='max_length'
)
tokenized_dataset = dataset.map(
tokenize_function,
batched=True,
remove_columns=dataset.column_names
)
# ๋ฐ์ดํฐ ์ฝ๋ ์ดํฐ
data_collator = DataCollatorForLanguageModeling(
tokenizer=tokenizer,
mlm=False # Causal LM์ด๋ฏ๋ก False
)
# ํ์ต ์ค์
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=4,
learning_rate=2e-4,
fp16=True, # Mixed precision
logging_steps=10,
save_steps=100,
save_total_limit=2,
warmup_steps=100,
report_to="none"
)
# ํธ๋ ์ด๋ ์์ฑ
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset,
data_collator=data_collator
)
# ํ์ต ์์
print("ํ์ต์ ์์ํฉ๋๋ค...")
trainer.train()
# ๋ชจ๋ธ ์ ์ฅ
model.save_pretrained("./fine_tuned_model")
tokenizer.save_pretrained("./fine_tuned_model")
print("๋ชจ๋ธ ์ ์ฅ ์๋ฃ!")
ํ์ธํ๋ ํ์ดํผํ๋ผ๋ฏธํฐ ๊ฐ์ด๋:
๐ Learning Rate: 1e-5 ~ 5e-4 (์์ ๋ชจ๋ธ์ ๋๊ฒ, ํฐ ๋ชจ๋ธ์ ๋ฎ๊ฒ)
๐ Epochs: 3-5 ์ํญ (๊ณผ์ ํฉ ์ฃผ์)
๐ฆ Batch Size: GPU ๋ฉ๋ชจ๋ฆฌ์ ๋ง์ถฐ ์กฐ์ (๋ณดํต 4-16)
๐ก๏ธ Warmup Steps: ์ ์ฒด ์คํ
์ 5-10%
โ๏ธ Weight Decay: 0.01-0.1 (์ ๊ทํ)
ํ์ธํ๋๋ ๋ชจ๋ธ ์ฌ์ฉํ๊ธฐ
from peft import PeftModel, PeftConfig
# ํ์ธํ๋๋ ๋ชจ๋ธ ๋ก๋
config = PeftConfig.from_pretrained("./fine_tuned_model")
base_model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
model = PeftModel.from_pretrained(base_model, "./fine_tuned_model")
tokenizer = AutoTokenizer.from_pretrained("./fine_tuned_model")
# ์ถ๋ก
def generate_response(prompt):
inputs = tokenizer(f"์ง๋ฌธ: {prompt}\n๋ต๋ณ:", return_tensors="pt")
with torch.no_grad():
outputs = model.generate(
**inputs,
max_length=200,
temperature=0.7,
top_p=0.9,
do_sample=True
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
# "๋ต๋ณ:" ์ดํ ํ
์คํธ๋ง ์ถ์ถ
answer = response.split("๋ต๋ณ:")[-1].strip()
return answer
# ํ
์คํธ
test_prompts = [
"๋ฐฐ์ก ์ถ์ ์ ์ด๋ป๊ฒ ํ๋์?",
"๊ฒฐ์ ๋ฐฉ๋ฒ์๋ ์ด๋ค ๊ฒ๋ค์ด ์๋์?"
]
for prompt in test_prompts:
print(f"\n์ง๋ฌธ: {prompt}")
print(f"๋ต๋ณ: {generate_response(prompt)}")
ํ๋กฌํํธ ์์ง๋์ด๋ง: ๋ ๋์ ๊ฒฐ๊ณผ ์ป๊ธฐ
ํ์ธํ๋ ์์ด๋ ํ๋กฌํํธ๋ง ์ ์์ฑํ๋ฉด ๋๋ผ์ด ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด์:
# Few-shot ํ๋กฌํํธ ์์
few_shot_prompt = """๋ค์์ ๊ณ ๊ฐ ์๋ด ๋ํ์
๋๋ค.
์ง๋ฌธ: ๋ฐฐ์ก๋น๋ ์ผ๋ง์ธ๊ฐ์?
๋ต๋ณ: 3๋ง์ ์ด์ ๊ตฌ๋งค ์ ๋ฌด๋ฃ๋ฐฐ์ก์ด๋ฉฐ, ๊ทธ ์ดํ๋ 3,000์์
๋๋ค.
์ง๋ฌธ: ๊ตํ์ ๊ฐ๋ฅํ๊ฐ์?
๋ต๋ณ: ๋ค, ์๋ น ํ 7์ผ ์ด๋ด ์ํ ํ์๊ฐ ์์ ๊ฒฝ์ฐ ๋ฌด๋ฃ ๊ตํ์ด ๊ฐ๋ฅํฉ๋๋ค.
์ง๋ฌธ: {user_question}
๋ต๋ณ:"""
# ์ฌ์ฉ ์์
user_question = "ํฌ์ธํธ๋ ์ด๋ป๊ฒ ์ ๋ฆฝ๋๋์?"
prompt = few_shot_prompt.format(user_question=user_question)
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs, max_length=200)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
๐ก ํ๋กฌํํธ ์์ฑ ํ:
โข ๋ช
ํํ๊ณ ๊ตฌ์ฒด์ ์ธ ์ง์๋ฌธ ์ฌ์ฉ
โข ์ํ๋ ์ถ๋ ฅ ํ์ ์์ ์ ๊ณต
โข ์ญํ ์ค์ (์: "๋น์ ์ ์ ๋ฌธ ์๋ด์์
๋๋ค")
โข ์ ์ฝ์ฌํญ ๋ช
์ (์: "100์ ์ด๋ด๋ก ๋ต๋ณ")
โข Few-shot ์์๋ก ํจํด ํ์ต
๐ ๋ณด์๊ณผ ์ค๋ฆฌ์ ๊ณ ๋ ค์ฌํญ
LLM์ ์ค์ ์๋น์ค์ ์ ์ฉํ ๋๋ ๋ณด์๊ณผ ์ค๋ฆฌ์ ์ธก๋ฉด๋ ๋ฐ๋์ ๊ณ ๋ คํด์ผ ํด์.
1. ์
๋ ฅ ๊ฒ์ฆ ๋ฐ ํํฐ๋ง
import re
from typing import Optional
class InputValidator:
def __init__(self):
# ๊ธ์ง์ด ๋ชฉ๋ก
self.forbidden_words = [
"์์ค1", "์์ค2", "๋น์์ด1" # ์ค์ ๋ก๋ ๋ ํฌ๊ด์ ์ธ ๋ฆฌ์คํธ ํ์
]
# ์์ฌ์ค๋ฌ์ด ํจํด
self.suspicious_patterns = [
r'<script.*?>.*?</script>', # XSS ๊ณต๊ฒฉ
r'DROP\s+TABLE', # SQL Injection
r'\.\./', # Path traversal
]
def validate_input(self, text: str) -> tuple[bool, Optional[str]]:
"""์
๋ ฅ ํ
์คํธ ๊ฒ์ฆ"""
# ๊ธธ์ด ์ฒดํฌ
if len(text) > 1000:
return False, "์
๋ ฅ์ด ๋๋ฌด ๊น๋๋ค (์ต๋ 1000์)"
# ๊ธ์ง์ด ์ฒดํฌ
text_lower = text.lower()
for word in self.forbidden_words:
if word in text_lower:
return False, "๋ถ์ ์ ํ ๋จ์ด๊ฐ ํฌํจ๋์ด ์์ต๋๋ค"
# ์์ฌ์ค๋ฌ์ด ํจํด ์ฒดํฌ
for pattern in self.suspicious_patterns:
if re.search(pattern, text, re.IGNORECASE):
return False, "์์ฌ์ค๋ฌ์ด ํจํด์ด ๊ฐ์ง๋์์ต๋๋ค"
return True, None
def sanitize_input(self, text: str) -> str:
"""์
๋ ฅ ํ
์คํธ ์ ์ """
# HTML ํ๊ทธ ์ ๊ฑฐ
text = re.sub(r'<[^>]+>', '', text)
# ํน์๋ฌธ์ ์ ํ
text = re.sub(r'[^\w\s๊ฐ-ํฃ.,!?]', '', text)
# ์ฐ์๋ ๊ณต๋ฐฑ ์ ๊ฑฐ
text = re.sub(r'\s+', ' ', text)
return text.strip()
# ์ฌ์ฉ ์์
validator = InputValidator()
def safe_generate(user_input: str):
# ๊ฒ์ฆ
is_valid, error_msg = validator.validate_input(user_input)
if not is_valid:
return {"error": error_msg}
# ์ ์
clean_input = validator.sanitize_input(user_input)
# ์์ฑ
result = generator(clean_input, max_length=100)
return result
2. ์ถ๋ ฅ ํํฐ๋ง
class OutputFilter:
def __init__(self):
self.toxic_classifier = pipeline(
"text-classification",
model="unitary/toxic-bert"
)
def is_safe_output(self, text: str, threshold: float = 0.7) -> bool:
"""์์ฑ๋ ํ
์คํธ์ ์์ ์ฑ ๊ฒ์ฌ"""
result = self.toxic_classifier(text)[0]
if result['label'] == 'toxic' and result['score'] > threshold:
return False
return True
def filter_personal_info(self, text: str) -> str:
"""๊ฐ์ธ์ ๋ณด ๋ง์คํน"""
# ์ด๋ฉ์ผ ๋ง์คํน
text = re.sub(
r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
'[์ด๋ฉ์ผ]',
text
)
# ์ ํ๋ฒํธ ๋ง์คํน
text = re.sub(
r'\b\d{2,3}-\d{3,4}-\d{4}\b',
'[์ ํ๋ฒํธ]',
text
)
# ์ฃผ๋ฏผ๋ฑ๋ก๋ฒํธ ๋ง์คํน
text = re.sub(
r'\b\d{6}-\d{7}\b',
'[์ฃผ๋ฏผ๋ฑ๋ก๋ฒํธ]',
text
)
return text
# ์ฌ์ฉ ์์
output_filter = OutputFilter()
def safe_response(generated_text: str) -> dict:
# ์ ํด์ฑ ๊ฒ์ฌ
if not output_filter.is_safe_output(generated_text):
return {
"success": False,
"message": "๋ถ์ ์ ํ ๋ด์ฉ์ด ์์ฑ๋์์ต๋๋ค"
}
# ๊ฐ์ธ์ ๋ณด ํํฐ๋ง
filtered_text = output_filter.filter_personal_info(generated_text)
return {
"success": True,
"text": filtered_text
}
3. ์ฌ์ฉ๋ ์ ํ (Rate Limiting)
from collections import defaultdict
from datetime import datetime, timedelta
import time
class RateLimiter:
def __init__(self, max_requests: int = 100, time_window: int = 3600):
"""
max_requests: ์๊ฐ ์๋์ฐ ๋ด ์ต๋ ์์ฒญ ์
time_window: ์๊ฐ ์๋์ฐ (์ด)
"""
self.max_requests = max_requests
self.time_window = time_window
self.requests = defaultdict(list)
def is_allowed(self, user_id: str) -> tuple[bool, Optional[str]]:
"""์์ฒญ ํ์ฉ ์ฌ๋ถ ํ์ธ"""
now = datetime.now()
cutoff_time = now - timedelta(seconds=self.time_window)
# ์ค๋๋ ์์ฒญ ์ ๊ฑฐ
self.requests[user_id] = [
req_time for req_time in self.requests[user_id]
if req_time > cutoff_time
]
# ์์ฒญ ์ ํ์ธ
if len(self.requests[user_id]) >= self.max_requests:
retry_after = (self.requests[user_id][0] + timedelta(seconds=self.time_window) - now).seconds
return False, f"{retry_after}์ด ํ์ ๋ค์ ์๋ํด์ฃผ์ธ์"
# ์์ฒญ ๊ธฐ๋ก
self.requests[user_id].append(now)
return True, None
# FastAPI์์ ์ฌ์ฉ
rate_limiter = RateLimiter(max_requests=50, time_window=3600)
@app.post("/generate")
async def generate_text(request: GenerateRequest, user_id: str = Header(...)):
# Rate limiting ์ฒดํฌ
allowed, message = rate_limiter.is_allowed(user_id)
if not allowed:
raise HTTPException(status_code=429, detail=message)
# ์ ์ ์ฒ๋ฆฌ
result = generator(request.prompt)
return result
โ ๏ธ ์ค๋ฆฌ์ ๊ณ ๋ ค์ฌํญ:
โข ํธํฅ์ฑ: ๋ชจ๋ธ์ด ํน์ ์ง๋จ์ ๋ํ ํธ๊ฒฌ์ ๊ฐ์ง ์ ์์
โข ์ ์๊ถ: ์์ฑ๋ ์ฝํ
์ธ ์ ์ ์๊ถ ๋ฌธ์
โข ํฌ๋ช
์ฑ: ์ฌ์ฉ์์๊ฒ AI ์์ฑ ์ฝํ
์ธ ์์ ๋ช
์
โข ์ฑ
์: ์์ฑ๋ ์ฝํ
์ธ ์ ๋ํ ์ฑ
์ ์์ฌ ๋ช
ํํ
โข ํ๋ผ์ด๋ฒ์: ํ์ต ๋ฐ์ดํฐ์ ๊ฐ์ธ์ ๋ณด ๋ณดํธ
4. ๋ก๊น ๋ฐ ๊ฐ์ฌ
import logging
import json
from datetime import datetime
# ๋ก๊ฑฐ ์ค์
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('llm_service.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
class AuditLogger:
@staticmethod
def log_request(user_id: str, prompt: str, metadata: dict = None):
"""์์ฒญ ๋ก๊น
"""
log_data = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"prompt_length": len(prompt),
"prompt_preview": prompt[:50] + "..." if len(prompt) > 50 else prompt,
"metadata": metadata or {}
}
logger.info(f"REQUEST: {json.dumps(log_data, ensure_ascii=False)}")
@staticmethod
def log_response(user_id: str, response: str, generation_time: float):
"""์๋ต ๋ก๊น
"""
log_data = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"response_length": len(response),
"generation_time": generation_time,
"response_preview": response[:50] + "..." if len(response) > 50 else response
}
logger.info(f"RESPONSE: {json.dumps(log_data, ensure_ascii=False)}")
@staticmethod
def log_error(user_id: str, error: str, context: dict = None):
"""์๋ฌ ๋ก๊น
"""
log_data = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"error": str(error),
"context": context or {}
}
logger.error(f"ERROR: {json.dumps(log_data, ensure_ascii=False)}")
# ์ฌ์ฉ ์์
audit_logger = AuditLogger()
@app.post("/generate")
async def generate_text(request: GenerateRequest, user_id: str = Header(...)):
start_time = time.time()
try:
# ์์ฒญ ๋ก๊น
audit_logger.log_request(
user_id=user_id,
prompt=request.prompt,
metadata={"max_length": request.max_length}
)
# ์์ฑ
result = generator(request.prompt)
# ์๋ต ๋ก๊น
generation_time = time.time() - start_time
audit_logger.log_response(
user_id=user_id,
response=result[0]['generated_text'],
generation_time=generation_time
)
return result
except Exception as e:
# ์๋ฌ ๋ก๊น
audit_logger.log_error(
user_id=user_id,
error=str(e),
context={"prompt_length": len(request.prompt)}
)
raise
๐ ์ถ๊ฐ ํ์ต ๋ฆฌ์์ค์ ์ปค๋ฎค๋ํฐ
LLM ๊ฐ๋ฐ์ ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๋ ๋ถ์ผ์์. ๊ณ์ ํ์ตํ๊ณ ์ต์ ์ ๋ณด๋ฅผ ์ป๋ ๊ฒ์ด ์ค์ํ์ฃ !
๊ณต์ ๋ฌธ์ ๋ฐ ํํ ๋ฆฌ์ผ
| ๋ฆฌ์์ค | ์ค๋ช | ๋์ด๋ |
|---|---|---|
| Hugging Face Documentation | ๊ณต์ ๋ฌธ์, ๊ฐ์ฅ ์ ํํ๊ณ ์ต์ ์ ๋ณด | ์ด๊ธ~๊ณ ๊ธ |
| Hugging Face Course | ๋ฌด๋ฃ ์จ๋ผ์ธ ๊ฐ์ข, ์ฒด๊ณ์ ์ธ ํ์ต | ์ด๊ธ~์ค๊ธ |
| PyTorch Tutorials | ๋ฅ๋ฌ๋ ๊ธฐ์ด๋ถํฐ ๊ณ ๊ธ๊น์ง | ์ด๊ธ~๊ณ ๊ธ |
| Papers with Code | ์ต์ ๋ ผ๋ฌธ๊ณผ ๊ตฌํ ์ฝ๋ | ์ค๊ธ~๊ณ ๊ธ |
์ ์ฉํ GitHub ์ ์ฅ์
# ์ถ์ฒ ์ ์ฅ์ ๋ชฉ๋ก
repositories = [
"huggingface/transformers", # ํต์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
"huggingface/peft", # ํจ์จ์ ํ์ธํ๋
"tloen/alpaca-lora", # LoRA ํ์ธํ๋ ์์
"oobabooga/text-generation-webui", # ์น UI
"imartinez/privateGPT", # ๋ก์ปฌ GPT
"langchain-ai/langchain", # LLM ์ ํ๋ฆฌ์ผ์ด์
ํ๋ ์์ํฌ
]
์ปค๋ฎค๋ํฐ ๋ฐ ํฌ๋ผ
ํ๋ฐํ ์ปค๋ฎค๋ํฐ:
๐ฌ Hugging Face Forums: ๊ณต์ ํฌ๋ผ, ์ ๋ฌธ๊ฐ๋ค์ ๋ต๋ณ
๐ฌ Reddit r/MachineLearning: ์ต์ ํธ๋ ๋์ ๋
ผ์
๐ฌ Discord ์๋ฒ: ์ค์๊ฐ ์ง์์๋ต
๐ฌ Stack Overflow: ๊ธฐ์ ์ ๋ฌธ์ ํด๊ฒฐ
๐ฌ ํ๊ตญ AI ์ปค๋ฎค๋ํฐ: ๋ค์ด๋ฒ ์นดํ, ์คํ์นดํก๋ฐฉ ๋ฑ
์ค์ ํ๋ก์ ํธ ์์ด๋์ด
๋ฐฐ์ด ๋ด์ฉ์ ํ์ฉํด ๋ค์๊ณผ ๊ฐ์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณด์ธ์:
1. ๊ฐ์ธ ๋น์ ์ฑ๋ด
์ผ์ ๊ด๋ฆฌ, ๋ฉ๋ชจ ์์ฑ, ์ ๋ณด ๊ฒ์ ๋ฑ์ ๋์์ฃผ๋ AI ๋น์
2. ์ฝํ
์ธ ์์ฑ ๋๊ตฌ
๋ธ๋ก๊ทธ ๊ธ, ์์
๋ฏธ๋์ด ํฌ์คํธ, ์ด๋ฉ์ผ ์ด์ ์๋ ์์ฑ
3. ์ฝ๋ ๋ฆฌ๋ทฐ ์ด์์คํดํธ
์ฝ๋๋ฅผ ๋ถ์ํ๊ณ ๊ฐ์ ์ ์์ ํด์ฃผ๋ ๋๊ตฌ
4. ๊ต์ก์ฉ ํํฐ
ํ์๋ค์ ์ง๋ฌธ์ ๋ตํ๊ณ ์ค๋ช
ํด์ฃผ๋ AI ํํฐ
5. ๊ฐ์ ๋ถ์ ์ฑ๋ด
์ฌ์ฉ์์ ๊ฐ์ ์ ํ์
ํ๊ณ ๊ณต๊ฐํ๋ ๋ํ ์์คํ
์ต์ ํธ๋ ๋ ๋ฐ๋ผ๊ฐ๊ธฐ
# ์ ์ฉํ ๋ด์ค๋ ํฐ ๋ฐ ๋ธ๋ก๊ทธ
resources = {
"The Batch": "Andrew Ng์ AI ๋ด์ค๋ ํฐ",
"Import AI": "์ฃผ๊ฐ AI ๋ด์ค ์์ฝ",
"Hugging Face Blog": "์ต์ ๋ชจ๋ธ๊ณผ ๊ธฐ์ ์๊ฐ",
"OpenAI Blog": "GPT ์๋ฆฌ์ฆ ์
๋ฐ์ดํธ",
"Google AI Blog": "๊ตฌ๊ธ์ AI ์ฐ๊ตฌ ์์"
}
# ํ๋ก์ฐํ ๋งํ ์ฐ๊ตฌ์/๊ฐ๋ฐ์
influencers = [
"Andrej Karpathy",
"Jeremy Howard",
"Sebastian Ruder",
"Yann LeCun",
"Hugging Face ํ"
]
๐ก ํ์ต ํ:
โข ๋งค์ผ 30๋ถ์ฉ ๊ณต์ ๋ฌธ์ ์ฝ๊ธฐ
โข ์ฃผ 1ํ ์๋ก์ด ๋ชจ๋ธ ํ
์คํธํด๋ณด๊ธฐ
โข ์์ ํ๋ก์ ํธ๋ถํฐ ์์ํด์ ์ ์ง์ ์ผ๋ก ํ์ฅ
โข ์ปค๋ฎค๋ํฐ์ ์ง๋ฌธํ๊ณ ๋ต๋ณํ๋ฉฐ ํ์ต
โข ์ต์ ๋
ผ๋ฌธ์ ๊ตฌํ ์ฝ๋ ๋ถ์ํ๊ธฐ
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์! ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด์. ํ์ด์ฌ๊ณผ Hugging Face Transformers๋ฅผ ์ฌ์ฉํด์ LLM์ ํธ์ถํ๊ณ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ฒ์๋ถํฐ ๋๊น์ง ์ดํด๋ดค์ด์.
์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๋ด์ฉ์ ์ ๋ฆฌํด๋ณผ๊น์?
โ
Hugging Face์ Transformers์ ๊ธฐ๋ณธ ๊ฐ๋
โ
ํ๊ฒฝ ์ค์ ๊ณผ ๋ชจ๋ธ ๋ก๋ฉ ๋ฐฉ๋ฒ
โ
๋ค์ํ ๋ชจ๋ธ ํ์ฉ (GPT, BERT, T5 ๋ฑ)
โ
๊ณ ๊ธ ์ต์ ํ ๊ธฐ๋ฒ (์์ํ, LoRA)
โ
์ค์ ์ฑ๋ด ํ๋ก์ ํธ ๊ตฌํ
โ
๋ฌธ์ ํด๊ฒฐ ๋ฐ ๋๋ฒ๊น
โ
ํ๋ก๋์
๋ฐฐํฌ ์ ๋ต
โ
ํ์ธํ๋๊ณผ ์ปค์คํฐ๋ง์ด์ง
โ
๋ณด์๊ณผ ์ค๋ฆฌ์ ๊ณ ๋ ค์ฌํญ
ํต์ฌ ํฌ์ธํธ ์์ฝ:
๐ฏ ์์์ ๊ฐ๋จํ๊ฒ: pipeline ํจ์๋ก ๋ช ์ค์ด๋ฉด ์ถฉ๋ถ
โก ์ต์ ํ๊ฐ ์ค์: ์์ํ์ LoRA๋ก ํจ์จ์ฑ ๊ทน๋ํ
๐ง ์ํฉ์ ๋ง๋ ์ ํ: ์์
์ ์ ํฉํ ๋ชจ๋ธ ์ ํ์ด ํต์ฌ
๐ก๏ธ ์์ ์ด ์ฐ์ : ์
์ถ๋ ฅ ํํฐ๋ง๊ณผ rate limiting ํ์
๐ ์ง์์ ํ์ต: AI ๋ถ์ผ๋ ๋น ๋ฅด๊ฒ ๋ฐ์ , ๊ณ์ ๊ณต๋ถํด์ผ
LLM ๊ธฐ์ ์ ์ ๋ง ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๊ณ ์์ด์. ์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ด ๋ด์ผ์ด๋ฉด ๊ตฌ์์ด ๋ ์๋ ์์ฃ . ํ์ง๋ง ๊ธฐ๋ณธ ์๋ฆฌ์ ์ ๊ทผ ๋ฐฉ๋ฒ์ ์ดํดํ๋ค๋ฉด, ์๋ก์ด ๊ธฐ์ ์ด ๋์๋ ๋น ๋ฅด๊ฒ ์ ์ํ ์ ์์ ๊ฑฐ์์!
์ฌ๋ฅ๋ท(https://www.jaenung.net)์์ AI ๊ฐ๋ฐ ์ฌ๋ฅ์ ๊ณต์ ํ๊ณ ์ถ์ ๋ถ๋ค์ด๋ผ๋ฉด, ์ด ๊ธ์์ ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ๊ณ ๊ฐ์๊ฒ ์ ๋ฌธ์ ์ธ ์๋น์ค๋ฅผ ์ ๊ณตํ ์ ์์ ๊ฑฐ์์. ์ฑ๋ด ๊ฐ๋ฐ, ์ฝํ
์ธ ์์ฑ ์๋ํ, ๋ฐ์ดํฐ ๋ถ์ ๋ฑ ๋ค์ํ ๋ถ์ผ์ ํ์ฉํ ์ ์๋ต๋๋ค!
๐ ์ด์ ์ฌ๋ฌ๋ถ ์ฐจ๋ก์์! ์ง์ ์ฝ๋๋ฅผ ์์ฑํ๊ณ , ์คํํ๊ณ , ์คํจํ๊ณ , ๋ฐฐ์ฐ์ธ์. ๊ทธ๊ฒ ๊ฐ์ฅ ๋น ๋ฅธ ํ์ต ๋ฐฉ๋ฒ์ด์์. ๋งํ๋ ๋ถ๋ถ์ด ์๋ค๋ฉด ์ปค๋ฎค๋ํฐ์ ์ง๋ฌธํ๊ณ , ๊ณต์ ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์ธ์. ์ฌ๋ฌ๋ถ์ ์ด๋ฏธ ์ถฉ๋ถํ ์ค๋น๋์์ด์!
๐ช ํ์ดํ
! ์ฌ๋ฌ๋ถ์ AI ํ๋ก์ ํธ๊ฐ ์ฑ๊ณตํ๊ธธ ์์ํฉ๋๋ค!
๐ค ๊ถ๊ธํ ์ ์ด๋ ํผ๋๋ฐฑ์ด ์๋ค๋ฉด ์ธ์ ๋ ์ปค๋ฎค๋ํฐ์ ๊ณต์ ํด์ฃผ์ธ์. ํจ๊ป ๋ฐฐ์ฐ๊ณ ์ฑ์ฅํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ฆ๊ฑฐ์ด ์ผ์ด๋๊น์!
๐ ๋ค์ ๋จ๊ณ ์ถ์ฒ:
1. ์ด ๊ธ์ ์ฝ๋๋ฅผ ์ง์ ์คํํด๋ณด๊ธฐ
2. ๊ฐ๋จํ ์ฑ๋ด ํ๋ก์ ํธ ๋ง๋ค์ด๋ณด๊ธฐ
3. ์์ ๋ง์ ๋ฐ์ดํฐ๋ก ํ์ธํ๋ ์๋
4. ์ปค๋ฎค๋ํฐ์ ํ๋ก์ ํธ ๊ณต์ ํ๊ธฐ
5. ์ค์ ์๋น์ค๋ก ๋ฐฐํฌํด๋ณด๊ธฐ
์ฌ๋ฌ๋ถ์ AI ์ฌ์ ์ ์ด ๊ธ์ด ์ข์ ์ถ๋ฐ์ ์ด ๋์๊ธฐ๋ฅผ ๋ฐ๋ผ์. ํ์ด์ ๋น์ด์! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.