[NLP] 한국어 모델 fine-tuning

BERT 다국어모델에 한국어 감성분석을 fine-tuning하는 방법을 소개합니다.

 

1. kor_hate 데이터셋 불러오기

이 예제에서는 Hugging Face의 "kor_hate" 데이터를 사용합니다. train과 test 데이터셋으로 나누어져 있고, train셋에는 7,896개, test셋에는 471개의 댓글이 있습니다.

from datasets import load_dataset
dataset = load_dataset('kor_hate')
dataset

# 출력 ------
# DatasetDict({
#     train: Dataset({
#         features: ['comments', 'contain_gender_bias', 'bias', 'hate'],
#         num_rows: 7896
#     })
#     test: Dataset({
#         features: ['comments', 'contain_gender_bias', 'bias', 'hate'],
#         num_rows: 471
#     })
# })

 

데이터셋의 라벨을 확인해보면, "comments"는 댓글이 담겨있고 "contain_gender_bias"는 댓글에 성별에 관한 내용의 여부를 나타냅니다. "hate" 피처에는 혐오 표현이 있는지 3가지 레이블로 나누어져 있습니다. 

dataset['train'].features
# {'comments': Value(dtype='string', id=None),
#  'contain_gender_bias': ClassLabel(names=['False', 'True'], id=None),
#  'bias': ClassLabel(names=['none', 'gender', 'others'], id=None),
#  'hate': ClassLabel(names=['hate', 'offensive', 'none'], id=None)}

 

이번 예시에서는 contain_gender_bias를 사용해서 성별에 관한 표현이 있는지에 대해 fine-tuning 시켜보겠습니다. 필요한 데이터만 남깁니다.

dataset = dataset.select_columns(['comments', 'contain_gender_bias'])
dataset = dataset.rename_column("contain_gender_bias" , "labels" )

 

 

2. 토크나이징

BERT 다국어 모델로 comments 피처를 토크나이징 시키고, 모델 인풋에 필요한 컬럼만 남겨줍니다.

from transformers import AutoTokenizer
checkpoint = "bert-base-multilingual-cased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

tokenized_datasets = dataset.map(lambda example: tokenizer(example['comments']))
tokenized_datasets = tokenized_datasets.select_columns(['labels', 'input_ids', 'token_type_ids', 'attention_mask'])

 

동적 패딩을 위해 DataCollator를 설정합니다.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

 

데이터로더를 사용해줍니다.

from torch.utils.data import DataLoader
train_dataloader = DataLoader(tokenized_datasets['train'], shuffle=True, batch_size=8, collate_fn=data_collator)
eval_dataloader = DataLoader(tokenized_datasets['test'], shuffle=True, batch_size=8, collate_fn=data_collator)

 

데이터로더가 잘 불러오는지 확인해주려면 아래 코드를 실행해보면 됩니다.

for batch in train_dataloader:
    break
{k: v.shape for k, v in batch.items()}

# --- 출력
# {'input_ids': torch.Size([8, 54]),
#  'attention_mask': torch.Size([8, 54]),
#  'token_type_ids': torch.Size([8, 54]),
#  'labels': torch.Size([8])}

 

 

3. 모델 불러오기

from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

 

 

GPU를 사용할 수 있도록 설정합니다. 결과가 type='cuda'로 출력된다면 GPU를 사용합니다.

import torch
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)

print(device)
# device(type='cuda')

 

 

 

4. Optimizer와 Scheduler 설정하기

AdamW 옵티마이저와 스케줄러를 설정합니다.

# optimizer 설정
from transformers import AdamW
optimizer = AdamW(model.parameters(), lr=5e-5)

# scheduler 설정
from transformers import get_scheduler
num_epochs = 3
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,
)
print(num_training_steps)
# 2961

 

 

5. fine-tuning 시키기

두가지 코드를 소개하겠습니다. 

먼저 첫번째는 전형적인 파이토치 훈련 루프의 기본 구조를 코드로 구현해서 훈련합니다.

from tqdm.auto import tqdm
progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch  in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

 

transformers의 Trainer 클래스를 사용하면 훈련과 평가 프로세스를 추상화하고 간단하게 처리할 수 있습니다. 직접 훈련 루프를 작성할 필요가 없습니다.

from transformers import TrainingArguments, Trainer

# 훈련 설정 (TrainingArguments)
training_args = TrainingArguments("text-classification-bert-base")

# Trainer 생성
trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    train_dataset=train_dataloader.dataset,
    eval_dataset=eval_dataloader.dataset,
    optimizers=(optimizer, lr_scheduler),
)

 

 

6. 모델 평가하기

# 평가 메트릭 설정
import evaluate
metric = evaluate.load("accuracy")

# 모델 평가
model.eval()
for batch in eval_dataloader:
    batch = {k : v.to(device) for k, v in batch.items()}
    with torch.no_grad():
        outputs = model(**batch)

    logits = outputs.logits
    predictions = torch.argmax(logits, dim=-1)
    metric.add_batch(predictions=predictions, references=batch['labels'])
metric.compute()

 

Trainer를 사용해서 더 간단하게 평가할수도 있습니다.

import numpy as np
metric = evaluate.load("accuracy")

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

# Trainer 객체 생성
trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
    train_dataset=train_dataloader.dataset,
    eval_dataset=eval_dataloader.dataset,
)

# 모델 훈련
trainer.train()

# 평가 결과에서 정확도 추출
eval_results = trainer.evaluate()
accuracy = eval_results["eval_accuracy"]