ํ๊น ํ์ด์ค๋ Tensorflow Hub์ ์ ์ฌํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ๊ณณ์ด๋ค.
ํธ๋์คํฌ๋จธ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ๋ค์ํ ๋ชจ๋ธ๋ค์ด ์กด์ฌํ๋ฉฐ, ๊ฐ๊ฐ์ Task์ ๋ง๊ฒ ๋ฏธ์ธ์กฐ์ ์ ์งํํ ๋ชจ๋ธ๋ค ๋ํ ๊ตฌ์ถ๋์ด์๋ค. ๋ํ, ๋ฐ์ดํฐ๋ฅผ ๊ฐ ๋ชจ๋ธ์ ๋ง๊ฒ ์ ์ฒ๋ฆฌํ๊ธฐ ํธ๋ฆฌํ๋๋ก Tokenizer๋ ์ ๋ถ ๊ตฌํ๋์ด์๋ค.
๊ทธ ๋ฟ๋ง ์๋๋ผ, ํ์ต์ ์ํด ํ์ํ ๋ฐ์ดํฐ์ ๋ ์ ์ฅ๋์ด ์์ด, ์ฌ์ฉ์๋ ๊ทธ์ ๊ฐ์ ธ์จ ๋ค ์ฌ์ฉํ๊ธฐ๋ง ํ๋ฉด ๋๋ค.
์ฆ, ํ๊น ํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๊ธฐ์กด ํ์ต ์คํฌ๋ฆฝํธ์์ ๋ฐ๋ณต๋๋ ๋ชจ๋ ๋ถ๋ถ์ ์ผ์ผ์ด ๋ฐ๋ก ๊ตฌํํ์ง ์์๋ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๋ฐ์ดํฐ ๊ตฌ์ถ๋ถํฐ ์ ์ฒ๋ฆฌ, ๋ชจ๋ธ ํ์ต ๋ฐ ๊ฒฐ๊ณผ ๋์ถ๊น์ง ๋งค์ฐ ํธ๋ฆฌํ๊ณ ํจ์จ์ ์ผ๋ก ์ฝ๋ฉํ ์ ์๋ค๋ ์ฅ์ ์ด ์๋ค.
ํ๊น ํ์ด์ค๋ ๋ค์ํ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ๊ณผ ํ์ต ์คํฌ๋ฆฝํธ๋ฅผ ์ ๊ณตํ๋ ๋ชจ๋๋ก, pytorch์ tensorflow๋ก ๊ฐ๊ฐ ๊ตฌํ๋์ด ์๋ค. ๋จผ์ ํ์ํ ๋ชจ๋ธ์ ์์ ์ ์์ ์ ๋ง๊ฒ ๊ฐ์ ธ์ค๋ฉด ๋๋ค.
๊ฐ๋จํ๊ฒ Fill-Mask๋ฅผ ์ํด BERT ๋ชจ๋ธ์ ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด "bert-base-uncased" ์ฒ๋ผ ๊ฒ์์ ํ์ฌ ๋ค์ด๊ฐ์ ์ ๋ณด๋ฅผ ํ์ธํ๋ฉด ๋๋ค.
์ด ๋ชจ๋ธ์ ๋งค์ฐ ๊ฐ๋จํ๊ฒ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ๋ค.
#BERT ๋ชจ๋ธ๊ณผ ์ด๋ฅผ ์ํ BERT ๋ชจ๋ธ์ ๋ง๋ Tokenizer์ ๊ฐ์ ธ์จ๋ค.
from transformers import BertTokenizer, BertModel
#ํ ํฌ๋์ด์ ๋ ๋ฏธ๋ฆฌ ํ์ต๋ 'bert-base-uncased'์์ ๊ฐ์ ธ์จ๋ค.
#BertTokenizer๋์ AutoTokenizer์ ์ฌ์ฉํด๋ ๋๋ค.
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# ๋ชจ๋ธ์ ์ฌ์ ํ์ต๋ "bert-base-uncased"์ ๊ฐ์ ธ์์ ์ฌ์ฉํ๋ค.
# ์ด๋ํ AutoModel์ importํ์ฌ ์ฌ์ฉํ ์ ์๋ค.
model = BertModel.from_pretrained("bert-base-uncased")
#๋ฐ์ดํฐ๋ฅผ ์
๋ ฅํ๋ค
text = "Replace me by any text you'd like."
#ํ ํฌ๋์ด์ ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ธ์ ๋ฃ์ ์ ์๊ฒ ๋ง๋ค์ด์ค๋ค.
#'pt'๋ pytorch, 'tf'๋ tensorflow๋ฅผ ์๋ฏธํ๋ค.
encoded_input = tokenizer(text, return_tensors='pt')
#๋ง์ง๋ง์ผ๋ก ๋ชจ๋ธ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ผ๋ฉด ๋๋๋ค.
output = model(**encoded_input)
๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ค๋ ๊ฒ์ ์๋์ ๊ฐ๋ค.
from datasets import load_dataset
# ํ๊น
ํ์ด์ค์์ SNLI ๋ฐ์ดํฐ์
๊ฐ์ ธ์ค๊ธฐ
raw_datasets = load_dataset("snli")
๊ฐ๋จํ๊ฒ ๊ฐ์ ธ์์ ์ฌ์ฉ๋ง ํ๋ค๋ฉด ์์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ๊ฐ๋ฅํ๋ค.
ํ๊น ํ์ด์ค์์ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์ ๊ฐ์ ธ์์ ์์ ์ ์์ ์ ๋ง๊ฒ ๋ฏธ์ธ์กฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
์์๋ก Text Classification ํ๋ ๋ชจ๋ธ์ด๋ค.
#ํ์ต์ ์ฌ์ฉํ ์ตํฐ๋ง์ด์ ๋ฅผ ์ค์
from transformers import AdamW
optimizer = AdamW(model.parameters(), lr=2e-5)
#๋ฐ์ดํฐ์
์ ์ ์ฒ๋ฆฌ ์๋ฃํ๋ค๋ ๊ฐ์ ํ์, ํ์ต์ ์ํ ๊ธฐํ ์ค์ ์ ์งํํ๋ค.
num_epochs = 5
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
"linear",
optimizer=optimizer,
num_warmup_steps=0,
num_training_steps=num_training_steps,
)
#๊ฐ์ ธ์จ ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ํ์ต์ ์งํํ๋ค.
for batch in train_dataloader:
model.train()
optimizer.zero_grad()
batch = {k: v.to(device) for k, v in batch.items()}
outputs = model(**batch)
loss = outputs.loss
loss.backward()
optimizer.step()
lr_scheduler.step()
torch.save(model,model_save_path)
์ด์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ํ์ต์ ์งํํ๋๋ฐ,
ํ์ต์จ์ ์๊ฒ ์ค์ ํ์ฌ ์์ ์ ๋ฐ์ดํฐ์ ์ผ๋ก ๋ฏธ์ธ ์กฐ์ ์ํค๋ฉด ๋๋ค.
์ค๊ฐ์ ํ์ต๋๋ ๊ณผ์ ์ ํ์ธํ๊ณ ์ถ์ผ๋ฉด, ์๋์ ๊ฐ์ด ์ค์ ํ์ฌ ์ฑ๋ฅ์ ํ์ธํ ์ ์๋ค.
# ์ํฌํฌ๊ฐ ํ๋ ์งํ๋์์ ๋ ๋ง๋ค ๋์๊ฐ๋๋ก ์ค์ ํ๋ฉด ๋๋ค.
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for batch in eval_dataloader:
batch = {k: v.to(device) for k, v in batch.items()}
outputs = model(**batch)
logits = outputs.logits
predict = torch.argmax(logits, dim=-1)
metric.add_batch(predictions=predict, references=batch["labels"])
print(metric.compute())
ํน์ฌ๋ ๋ค๋ฅธ Task์ ์์ ์ ์ํด ๋ง๋ค์ด๋์ ๋ชจ๋ธ์ ์์ ์ Task์ ๋ง๊ฒ ๋ชจ๋ธ์ ์์ํ์ ์ถ๊ฐํ๊ฑฐ๋ ์์ ํ๊ณ ์ถ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ด ์๋ค.
#๋ชจ๋ธ์ ์ํ๊ณ ๋ชจ๋ธ์ ๋ฐฐ์น ์ ๋ฌ
from transformers import AutoModelForSequenceClassification
from transformers import AutoConfig
# model์ ์์ ํ ๊ฑฐ๋ผ๊ณ ์ค์
config_model = AutoConfig.from_pretrained(model_name)
# ๋ชจ๋ธ์ ๋ง์ง๋ง ๋ถ๋ถ์ Classification์ ์ํด 3๊ฐ์ ์์ํ์ผ๋ก ์ค์ ํจ
config_model.num_labels = 3
# ์์ ํ ๋ชจ๋ธ์ ์ฌ์ฉํ ๊ฑฐ๋ผ๊ณ ์ค์
model =AutoModelForSequenceClassification.from_config(config_model)
ํ์ฌ๊น์ง๋ Classification์ ์ํ ์์์ด๋ฉฐ, ํ๊ท๋ ๋ค๋ฅธ Task์ ์์ ์ ํ๊น ํ์ด์ค ํํ์ด์ง์ ์์ธํ ์ค๋ช ๋์ด์๋ค.
https://huggingface.co/
๋งค์ฐ ํธํ๊ณ ์ฐ๊ธฐ ์ฝ๋ค. ์์ฐ์ด ์ฒ๋ฆฌ ๊ณต๋ถํ๋ฉด์ ์ ์ฉํ๊ฒ ์ ์ฐ๊ณ ์๋ค.