์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ ํŒŒ์ด์ฌ๊ณผ 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 ์†”๋ฃจ์…˜์„ ์ œ๊ณตํ•  ์ˆ˜ ์žˆ์–ด์š”!

๐Ÿค— Transformers ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ํ†ต์ผ๋œ API GPT ๋ชจ๋ธ ํ…์ŠคํŠธ ์ƒ์„ฑ BERT ๋ชจ๋ธ ํ…์ŠคํŠธ ์ดํ•ด T5 ๋ชจ๋ธ ๋ฒˆ์—ญ/์š”์•ฝ Hugging Face ์ƒํƒœ๊ณ„: ํ•˜๋‚˜์˜ ์ธํ„ฐํŽ˜์ด์Šค๋กœ ๋ชจ๋“  ๋ชจ๋ธ ์ ‘๊ทผ

๐Ÿ› ๏ธ ํ™˜๊ฒฝ ์„ค์ •: ์‹œ์ž‘์ด ๋ฐ˜์ด๋‹ค!

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ์š”? ๋จผ์ € ํ•„์š”ํ•œ ๋„๊ตฌ๋“ค์„ ์„ค์น˜ํ•ด์•ผ ํ•ด์š”. ๊ฑฑ์ • ๋งˆ์„ธ์š”, ์ƒ๊ฐ๋ณด๋‹ค ๊ฐ„๋‹จํ•ด์š”!

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 ์ด์ƒ์œผ๋กœ ์˜ฌ๋ฆฌ๋ฉด ๋งค์šฐ ์ฐฝ์˜์ ์ด์ง€๋งŒ ๋•Œ๋กœ๋Š” ์ด์ƒํ•œ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜์˜ฌ ์ˆ˜ ์žˆ์–ด์š”!

ํ…์ŠคํŠธ ์ƒ์„ฑ ํ”„๋กœ์„ธ์Šค ์ž…๋ ฅ ํ”„๋กฌํ”„ํŠธ "AI์˜ ๋ฏธ๋ž˜๋Š”" ํ† ํฌ๋‚˜์ด์ € ํ…์ŠคํŠธ โ†’ ์ˆซ์ž LLM ๋ชจ๋ธ ์ถ”๋ก  ๋ฐ ์˜ˆ์ธก ๋””์ฝ”๋”ฉ ์ˆซ์ž โ†’ ํ…์ŠคํŠธ ์ƒ์„ฑ ํŒŒ๋ผ๋ฏธํ„ฐ ์˜ํ–ฅ ๋‚ฎ์€ temperature ๋ณด์ˆ˜์  ์ผ๊ด€์„ฑ ๋†’์Œ ์ค‘๊ฐ„ temperature ๊ท ํ˜•์žกํžŒ ๊ถŒ์žฅ ์„ค์ • ๋†’์€ temperature ์ฐฝ์˜์  ์˜ˆ์ธก ๋ถˆ๊ฐ€ ์ ์ ˆํ•œ ํŒŒ๋ผ๋ฏธํ„ฐ ์กฐ์ •์ด ํ’ˆ์งˆ ์ข‹์€ ๊ฒฐ๊ณผ์˜ ํ•ต์‹ฌ!

๐Ÿ”ง ๋‹ค์–‘ํ•œ ๋ชจ๋ธ ํ™œ์šฉํ•˜๊ธฐ: ์ƒํ™ฉ๋ณ„ ์ตœ์  ์„ ํƒ

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์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ ์ ˆ์•ฝ ๊ฐ€๋Šฅ

๋ชจ๋ธ ์ตœ์ ํ™” ์ „๋žต ๋น„๊ต ์ผ๋ฐ˜ ๋ชจ๋ธ 16GB ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰ ์ •ํ™•๋„: 100% ์†๋„: ๋ณดํ†ต ๊ตฌํ˜„: ์‰ฌ์›€ ๊ธฐ๋ณธ ์„ค์ • ์–‘์žํ™” ๋ชจ๋ธ 4GB ๋ฉ”๋ชจ๋ฆฌ 75% ์ ˆ๊ฐ ์ •ํ™•๋„: 98% ์†๋„: ๋น ๋ฆ„ ๊ตฌํ˜„: ๋ณดํ†ต ๊ถŒ์žฅ ๋ฐฉ์‹ LoRA ํŠœ๋‹ 2GB ํ•™์Šต ํŒŒ๋ผ๋ฏธํ„ฐ 0.2% ์ •ํ™•๋„: 99% ์†๋„: ๋งค์šฐ๋น ๋ฆ„ ๊ตฌํ˜„: ์–ด๋ ค์›€ ํŒŒ์ธํŠœ๋‹์šฉ

๐ŸŽจ ์‹ค์ „ ํ”„๋กœ์ ํŠธ: ๋‚˜๋งŒ์˜ 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
ํ”„๋กœ๋•์…˜ ๋ฐฐํฌ ์•„ํ‚คํ…์ฒ˜ ํด๋ผ์ด์–ธํŠธ ์›น/๋ชจ๋ฐ”์ผ ์•ฑ HTTPS ๋กœ๋“œ๋ฐธ๋Ÿฐ์„œ Nginx/ALB API ์„œ๋ฒ„ 1 FastAPI API ์„œ๋ฒ„ 2 FastAPI API ์„œ๋ฒ„ 3 FastAPI LLM ๋ชจ๋ธ ์„œ๋ฒ„ GPU ์ธ์Šคํ„ด์Šค (์–‘์žํ™” ๋ชจ๋ธ) Redis ์บ์‹œ ์‘๋‹ต ์บ์‹ฑ PostgreSQL ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ๋ชจ๋‹ˆํ„ฐ๋ง Prometheus ํ™•์žฅ ๊ฐ€๋Šฅํ•˜๊ณ  ์•ˆ์ •์ ์ธ ์„œ๋น„์Šค ๊ตฌ์กฐ

๐ŸŽ“ ๊ณ ๊ธ‰ ํ™œ์šฉ: ํŒŒ์ธํŠœ๋‹๊ณผ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•

์‚ฌ์ „ํ•™์Šต๋œ ๋ชจ๋ธ์„ ๊ทธ๋Œ€๋กœ ์“ฐ๋Š” ๊ฒƒ๋„ ์ข‹์ง€๋งŒ, ํŠน์ • ๋„๋ฉ”์ธ์ด๋‚˜ ์Šคํƒ€์ผ์— ๋งž๊ฒŒ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•ํ•˜๋ฉด ํ›จ์”ฌ ๋” ์ข‹์€ ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์–ด์š”!

๋ฐ์ดํ„ฐ์…‹ ์ค€๋น„ํ•˜๊ธฐ
ํŒŒ์ธํŠœ๋‹์„ ์œ„ํ•ด์„œ๋Š” ๋จผ์ € ํ•™์Šต ๋ฐ์ดํ„ฐ๋ฅผ ์ค€๋น„ํ•ด์•ผ ํ•ด์š”:

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 ์—ฌ์ •์— ์ด ๊ธ€์ด ์ข‹์€ ์ถœ๋ฐœ์ ์ด ๋˜์—ˆ๊ธฐ๋ฅผ ๋ฐ”๋ผ์š”. ํ–‰์šด์„ ๋นŒ์–ด์š”! ๐Ÿ€

Happy Coding! ๐Ÿš€ ํŒŒ์ด์ฌ๊ณผ Transformers๋กœ ๋งŒ๋“œ๋Š” ์—ฌ๋Ÿฌ๋ถ„๋งŒ์˜ AI ์„ธ์ƒ ๐Ÿค– ๐Ÿ’ก ๐ŸŽฏ ๐ŸŒŸ ๊ณ„์† ๋ฐฐ์šฐ๊ณ , ์‹คํ—˜ํ•˜๊ณ , ์„ฑ์žฅํ•˜์„ธ์š”!
๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.