๐ LLM์ ํ์ฉํ ์ค์ AI ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐ ์ฑ ์คํฐ๋ ์ ๋ฆฌ ์๋ฃ
(์ ์๊ถ ๋ฌธ์ ์ ์ ๊ธํ๊ฒ ์ต๋๋ค~!)
โถ๏ธ ์ค์ต์ฝ๋ (๊นํ ๊ณต๊ฐ์ฝ๋ ํ์ฉ)
โถ๏ธ ๊นํ์ฝ๋
1. ํ๊น ํ์ด์ค ํธ๋์คํฌ๋จธ๋
โฏ Transformer ๋ผ์ด๋ธ๋ฌ๋ฆฌ
• ๊ณตํต๋ ์ธํฐํ์ด์ค๋ก ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์ ํ์ฉํ ์ ์๋๋ก ์ง์ํ์ฌ ๋ฅ๋ฌ๋ ๋ถ์ผ์ ํต์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค ํ๋ (์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ)
• ๋ชจ๋ธ๊ณผ ํ ํฌ๋์ด์ → transformer ๋ผ์ด๋ธ๋ฌ๋ฆฌ : AutoTokenizer, AutoModel
• ๋ฐ์ดํฐ์ → datasets ๋ผ์ด๋ธ๋ฌ๋ฆฌ
from transformers import AutoTokenizer, AutoModel
text = "What is Huggingface Transformers?"
# BERT ๋ชจ๋ธ ํ์ฉ
bert_model = AutoModel.from_pretrained("bert-base-uncased")
bert_tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
encoded_input = bert_tokenizer(text, return_tensors='pt')
bert_output = bert_model(**encoded_input)
# GPT-2 ๋ชจ๋ธ ํ์ฉ
gpt_model = AutoModel.from_pretrained('gpt2')
gpt_tokenizer = AutoTokenizer.from_pretrained('gpt2')
encoded_input = gpt_tokenizer(text, return_tensors='pt')
gpt_output = gpt_model(**encoded_input)
• output ์ ์๋ฒ ๋ฉ๋ ์ซ์ ๋ฒกํฐ ๊ฒฐ๊ณผ
2. ํ๊น
ํ์ด์ค ํ๋ธ ํ์ํ๊ธฐ
โฏ ํ๊น ํ์ด์ค ํ๋ธ
Hugging Face – The AI community building the future.
huggingface.co
• ๋ค์ํ ์ฌ์ ํ์ต ๋ชจ๋ธ๊ณผ ๋ฐ์ดํฐ์ ์ ํ์ํ๊ณ ์ฝ๊ฒ ๋ถ๋ฌ์ ์ฌ์ฉํ ์ ์๋๋ก ์ ๊ณตํ๋ ์จ๋ผ์ธ ํ๋ซํผ
• Space : ์์ ์ ๋ชจ๋ธ ๋ฐ๋ชจ๋ฅผ ์ ๊ณตํ๊ณ ๋ค๋ฅธ ์ฌ๋์ ๋ชจ๋ธ์ ์ฌ์ฉํด๋ณผ ์ ์๋ ๊ธฐ๋ฅ
โฏ ๋ชจ๋ธํ๋ธ
• ์ด๋ค ์์ ์ ์ฌ์ฉํ๋์ง, ์ด๋ค ์ธ์ด๋ก ํ์ต๋ ๋ชจ๋ธ์ธ์ง ๋ค์ํ ๊ธฐ์ค์ผ๋ก ๋ชจ๋ธ์ ๋ถ๋ฅ. NLP, CV, Audio, Multimodal ๋ฑ ๋ค์ํ ์์ ๋ถ์ผ์ ๋ชจ๋ธ์ ์ ๊ณตํ๋ค.
• ๋ชจ๋ธ์ ์ด๋ฆ ๋ฐ ์์ฝ ์ ๋ณด, ๋ชจ๋ธ ์ค๋ช ์นด๋, ๋ชจ๋ธ ํธ๋ ๋, ๋ชจ๋ธ ์ถ๋ก ํ ์คํธ ๋ฑ์ ํ์ธํด๋ณผ ์ ์๋ค.
โฏ ๋ฐ์ดํฐ์ ํ๋ธ
• ๋ฐ์ดํฐ์ ํฌ๊ธฐ, ์ ํ ๋ฑ์ด ์ถ๊ฐ๋์ด์๋ค.
• KLUE : ํ๊ตญ์ด ์ธ์ด ์ดํด ํ๊ฐ์ ์ฝ์๋ก ํ ์คํธ ๋ถ๋ฅ, ๊ธฐ๊ณ ๋ ํด, ๋ฌธ์ฅ ์ ์ฌ๋ ํ๋จ ๋ฑ ๋ค์ํ ์์ ์์ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ๊ธฐ ์ํด ๊ฐ๋ฐ๋ ๋ฒค์น๋งํฌ ๋ฐ์ดํฐ์ ์ด๋ค. MRC๋ฐ์ดํฐ, YNAT ๋ฐ์ดํฐ ๋ฑ 8๊ฐ ๋ฐ์ดํฐ๊ฐ ํฌํจ๋์ด ์๋ค. ํ์ต์ฉ/๊ฒ์ฆ์ฉ/ํ ์คํธ์ฉ ๋ฐ์ดํฐ์ ์ผ๋ก ๊ตฌ๋ถ๋์ด ์๋ค.
โฏ ์คํ์ด์ค
• ๋ชจ๋ธ ๋ฐ๋ชจ๋ฅผ ๊ฐํธํ๊ฒ ๊ณต๊ฐํ ์ ์๋ ๊ธฐ๋ฅ์ด๋ค. ์คํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณ๋์ ๋ณต์กํ ์นํ์ด์ง ๊ฐ๋ฐ ์์ด ๋ชจ๋ธ ๋ฐ๋ชจ๋ฅผ ๋ฐ๋ก ๊ณต์ ํ ์ ์๋ค.
• ๊ฐ์ฒด์ธ์ ๋ชจ๋ธ Yolo v9 ํ๋ฉด์ผ๋ก, ์ผ์ชฝ์ ๋ชจ๋ธ ์ถ๋ก ์ ์ฌ์ฉํ ์ด๋ฏธ์ง๋ฅผ ์ ๋ก๋ํ ์ ์๋ ์์ญ๊ณผ ์ฌ์ฉํ ๋ชจ๋ธ์ ์ข ๋ฅ, ์ถ๋ก ์ ์ฌ์ฉํ ๋ชจ๋ธ ์ค์ ์ ์ ํํ ์ ์๋ ์์ญ์ด ์๋ค.
โฏ LLM ๋ฆฌ๋๋ณด๋
• ์์ด ๋ฐ์ดํฐ ๋ฆฌ๋๋ณด๋
Open LLM Leaderboard - a Hugging Face Space by open-llm-leaderboard
huggingface.co
• ํ๊ตญ์ด๋ฐ์ดํฐ ๋ฆฌ๋๋ณด๋
Open Ko-LLM Leaderboard - a Hugging Face Space by upstage
huggingface.co
• ํ์ ๋ํ๋ ๋ฒค์น๋งํฌ ํญ๋ชฉ ๋ฆฌ์คํธ : ko-GPQA, Average ๋ฑ
• ๋ชจ๋ธ ํ์ต ๋ฐฉ์ : pretrained, fine-tuned ๋ฑ
• ๋ชจ๋ธ ํฌ๊ธฐ, ํ๋ผ๋ฏธํฐ ๋ฐ์ดํฐ ํ์ ๋ฑ
3. ํ๊น
ํ์ด์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ๋ฒ ์ตํ๊ธฐ
โฏ ๋ฐ๋์ ํค๋
• ํ๊น ํ์ด์ค๋ ๋ชจ๋ธ์ Body์ Head๋ก ๊ตฌ๋ถํ๋ค. ๊ฐ์ Body๋ฅผ ์ฌ์ฉํ๋ฉด์, ๋ค๋ฅธ ์์ ์ ์ฌ์ฉํ ์ ์๋๋ก ๋ง๋ค๊ธฐ ์ํด์์ด๋ค.
• ๊ฐ๋ น ๊ฐ์ BERT body๋ฅผ ์ฌ์ฉํ์ง๋ง, ํ ์คํธ ๋ถ๋ฅ ํค๋, ํ ํฐ ๋ถ๋ฅ ํค๋ ๋ฑ ์์ ์ข ๋ฅ์ ๋ฐ๋ผ ์๋ก ๋ค๋ฅธ ํค๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
• ๋ชจ๋ธ ๋ถ๋ฌ์ค๊ธฐ
from transformers import AutoModel
model_id = 'klue/roberta-base'
model = AutoModel.from_pretrained(model_id)
• ๋ถ๋ฅ ํค๋๊ฐ ํฌํจ๋ ๋ชจ๋ธ ๋ถ๋ฌ์ค๊ธฐ
from transformers import AutoModelForSequenceClassification
model_id = 'SamLowe/roberta-base-go_emotions'
classification_model = AutoModelForSequenceClassification.from_pretrained(model_id)
• ๋ถ๋ฅ ํค๋๊ฐ ๋๋ค์ผ๋ก ์ด๊ธฐํ๋ ๋ชจ๋ธ ๋ถ๋ฌ์ค๊ธฐ
from transformers import AutoModelForSequenceClassification
model_id = 'klue/roberta-base'
classification_model = AutoModelForSequenceClassification.from_pretrained(model_id)
โฏ ํ ํฌ๋์ด์ ํ์ฉํ๊ธฐ
• ํ ์คํธ๋ฅผ ํ ํฐ ๋จ์๋ก ๋๋๊ณ ๊ฐ ํ ํฐ์ ๋์ํ๋ ํ ํฐ ์์ด๋๋ก ๋ณํ, ํ์ํ ๊ฒฝ์ฐ ํน์ ํ ํฐ์ ์ถ๊ฐ
• ํ ํฌ๋์ด์ ๋ ํ์ต ๋ฐ์ดํฐ๋ฅผ ํตํด ์ดํ ์ฌ์ ์ ๊ตฌ์ถํ๋ฏ๋ก ๋ชจ๋ธ๊ณผ ํจ๊ป ์ ์ฅํ๋ ๊ฒ์ด ์ผ๋ฐ์
• ๋ชจ๋ธ๊ณผ ํ ํฌ๋์ด์ ๋ฅผ ๋ถ๋ฌ์ค๋ ๊ฒฝ์ฐ ๋์ผํ ๋ชจ๋ธ ์์ด๋๋ฅผ ์ค์
from transformers import AutoTokenizer
model_id = 'klue/roberta-base'
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenized = tokenizer("ํ ํฌ๋์ด์ ๋ ํ
์คํธ๋ฅผ ํ ํฐ ๋จ์๋ก ๋๋๋ค")
print(tokenized)
# {'input_ids': [0, 9157, 7461, 2190, 2259, 8509, 2138, 1793, 2855, 5385, 2200, 20950, 2],
# 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
# 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
print(tokenizer.convert_ids_to_tokens(tokenized['input_ids']))
# ['[CLS]', 'ํ ํฌ', '##๋์ด', '##์ ', '##๋', 'ํ
์คํธ', '##๋ฅผ', 'ํ ', '##ํฐ', '๋จ์', '##๋ก', '๋๋๋ค', '[SEP]']
print(tokenizer.decode(tokenized['input_ids']))
# [CLS] ํ ํฌ๋์ด์ ๋ ํ
์คํธ๋ฅผ ํ ํฐ ๋จ์๋ก ๋๋๋ค [SEP]
print(tokenizer.decode(tokenized['input_ids'], skip_special_tokens=True))
# ํ ํฌ๋์ด์ ๋ ํ
์คํธ๋ฅผ ํ ํฐ ๋จ์๋ก ๋๋๋ค
โฏ ๋ฐ์ดํฐ์ ํ์ฉํ๊ธฐ
from datasets import load_dataset
klue_mrc_dataset = load_dataset('klue', 'mrc')
4. ๋ชจ๋ธ ํ์ตํ๊ธฐ
โฏ ์ฐํฉ๋ด์ค ๋ฐ์ดํฐ ์ค์ต
• ํ๊ตญ์ด ๊ธฐ์ฌ ์ ๋ชฉ์ ๋ฐํ์ผ๋ก ๊ธฐ์ฌ์ ์นดํ ๊ณ ๋ฆฌ๋ฅผ ๋ถ๋ฅํ๋ ํ ์คํธ ๋ถ๋ฅ ๋ชจ๋ธ
• ํธ๋ ์ด๋ API๋ฅผ ์ฌ์ฉํด ํ์ต
1) ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
from datasets import load_dataset
klue_tc_train = load_dataset('klue', 'ynat', split='train')
klue_tc_eval = load_dataset('klue', 'ynat', split='validation')
klue_tc_train
klue_tc_train.features['label'].names
# ['IT๊ณผํ', '๊ฒฝ์ ', '์ฌํ', '์ํ๋ฌธํ', '์ธ๊ณ', '์คํฌ์ธ ', '์ ์น']
2) ๋ฐ์ดํฐ ์ค๋น
train_dataset = klue_tc_train.train_test_split(test_size=10000, shuffle=True, seed=42)['test']
dataset = klue_tc_eval.train_test_split(test_size=1000, shuffle=True, seed=42)
test_dataset = dataset['test']
valid_dataset = dataset['train'].train_test_split(test_size=1000, shuffle=True, seed=42)['test']
3) Trainer๋ฅผ ์ฌ์ฉํ ํ์ต
import torch
import numpy as np
from transformers import (
Trainer,
TrainingArguments,
AutoModelForSequenceClassification,
AutoTokenizer
)
# 1) ์ค๋น
def tokenize_function(examples):
return tokenizer(examples["title"], padding="max_length", truncation=True)
model_id = "klue/roberta-base"
model = AutoModelForSequenceClassification.from_pretrained(model_id, num_labels=len(train_dataset.features['label'].names))
tokenizer = AutoTokenizer.from_pretrained(model_id)
train_dataset = train_dataset.map(tokenize_function, batched=True)
valid_dataset = valid_dataset.map(tokenize_function, batched=True)
test_dataset = test_dataset.map(tokenize_function, batched=True)
# 2) ํ์ต ํ๋ผ๋ฏธํฐ์ ํ๊ฐํจ์ ์ ์
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=1,
per_device_train_batch_size=8,
per_device_eval_batch_size=8,
evaluation_strategy="epoch",
learning_rate=5e-5,
push_to_hub=False
)
def compute_metrics(eval_pred):
logits, labels = eval_pred
predictions = np.argmax(logits, axis=-1)
return {"accuracy": (predictions == labels).mean()}
# 3) ํ์ต ์งํ
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=valid_dataset,
tokenizer=tokenizer,
compute_metrics=compute_metrics,
)
trainer.train()
trainer.evaluate(test_dataset) # ์ ํ๋ 0.84
• Trainer API๋ฅผ ์ฌ์ฉํ์ง ์๋๋ค๋ฉด torch๋ก ๊ตฌํ ํด์ผ ํจ (๋ชจ๋ธ ๊ตฌํ ์ฝ๋ ๋์๊ณผ์ ์ ๋ํ ์ดํด๋๊ฐ ๋์์ง๊ธด ํจ)
5. ๋ชจ๋ธ ์ถ๋ก ํ๊ธฐ
โฏ ํ์ดํ๋ผ์ธ์ ํ์ฉํ ์ถ๋ก
• ๋ชจ๋ธ์ ํ์ฉํ๊ธฐ ์ฝ๋๋ก ์ถ์ํํ ํ์ดํ๋ผ์ธ์ ํ์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ์ง์ ๋ชจ๋ธ๊ณผ ํ ํฌ๋์ด์ ๋ฅผ ๋ถ๋ฌ์ ํ์ฉํ๋ ๋ฐฉ๋ฒ ์กด์ฌ
• ํ์ดํ๋ผ์ธ ํ์ฉ ์ถ๋ก
from transformers import pipeline
model_id = "๋ณธ์ธ์ ์์ด๋ ์
๋ ฅ/roberta-base-klue-ynat-classification"
model_pipeline = pipeline("text-classification", model=model_id)
model_pipeline(dataset["title"][:5])
• Custom pipeline ์ ์ํด์ ๊ตฌํํ ์๋ ์๊ธด ํจ (class , def ํ์ฉ)
'1๏ธโฃ AIโขDS > ๐ LLM' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฑ ์คํฐ๋] 2. ํธ๋์คํฌ๋จธ ์ํคํ ์ฒ ์ดํด๋ณด๊ธฐ (0) | 2024.12.11 |
---|---|
[์ฑ ์คํฐ๋] 13.LLM ์ด์ํ๊ธฐ (0) | 2024.12.03 |
[์ฑ ์คํฐ๋] 1. LLM ๊ธฐ์ด : sLLM, RAG (0) | 2024.12.01 |
๋๊ธ