[Natural Language Processing Model] KOBERT와 Finetuning 실습

🌍 KOBERT 란?

 

 

KOBERT는 Korean Bidirectional Encoder Representations from Transformers의 약자로, SKT Brain에서 공개한 일종의 기계번역 모델이다.

KOBERT는 2018년 Google 에서 발표한 "BERT"의 한국어 버전 모델로서 텍스트 분류, 개체명 인식, 감정 분석, 기계 번역 등의 자연어 처리(Natural Language Processing) 작업에서 뛰어난 성능을 발휘할 수 있다.

 

---

 

🌍 KOBERT Finetuning 실습

1. 파이썬 메인 패키지 설치

# 통합 개발 환경을 위한 ipywidgets 패키지 설치
!pip install ipywidgets

# GitHub 저장소에서 최신 버전의 KOBERT를 불러와 설치
!pip install git+https://git@github.com/SKTBrain/KoBERT.git@master

 

 

2. 파이썬 기타 패키지 설치

import torch
from torch import nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import gluonnlp as nlp
import numpy as np
from tqdm.notebook import tqdm

torch

: 딥 러닝 프레임워크인 PyTorch 라이브러리를 가져온다  -->   신경망 모델 구축 & 학습에에 사용

 

nn

: PyTorch의 nn 모듈을 가져온다  --> .신경망 모델 정의에 사용

 

F

: PyTorch의 nn.functional 모듈을 가져온다  -->  활성화 함수 & 손실 함수 제공

 

optim

: PyTorch의 최적화 알고리즘을 제공하는 optim 모듈을 가져온다  -->  가중치 업데이트를 위한 최적화 알고리즘 구현

 

Dataset, DataLoader

: Dataset과 DataLoader 클래스를 가져온다  -->  PyTorch의 데이터 로딩 및 전처리

 

gluonnlp

: gluonnlp 패키지를 가져온다  -->  자연어 처리 작업을 위한 도구 제공

 

numpy

: NumPy 라이브러리를 가져온다  -->  다차원 배열 및 수학적 연산 지원

 

tqdm

: tqdm 패키지를 가져온다  -->  반복 작업의 진행 상황을 표시하는 프로그레스 바 제공

 

 

3. Tokenizer 와 이전에 설치한 KOBERT 모델 호출

from kobert import get_tokenizer
from kobert import get_pytorch_kobert_model

get_tokenizer

: KoBERT 패키지에서 get_tokenizer 함수를 가져온다  -->  KoBERT 모델에 대한 토크나이저(tokenizer)를 제공

 

• 토크나이저(tokenizer)

: 텍스트를 작은 단위로 분할하여 모델에 입력하는 전처리 과정( = 토큰화 )을 수행하는 프로그램

 

get_pytorch_kobert_model

: KoBERT 패키지에서 get_pytorch_kobert_model 함수를 가져온다  -->  PyTorch 형식으로 미리 훈련된 KoBERT 모델 호출

 

 

4. Transformers 라이브러리에서 AdamW & 코사인 스케줄링 기법 불러오기

from transformers import AdamW
from transformers.optimization import get_cosine_schedule_with_warmup

Adamw

: transformers 라이브러리에서 AdamW 임포트  -->  가중치 감쇠(weight decay), 학습률 스케줄링 등의 기능을 제공하는 딥러닝 모델 최적화 알고리즘

 

get_cosine_schedule_with_warmup

: transformers.optimization에서 코사인 스케줄링과 워밍업을 가져온다  -->  학습률을 조정하는 방법 중 하나인 코사인 스케줄링 제공

 

 

5. Pytorch 에서 디바이스 설정하기

## CPU
device = torch.device("cpu")

## GPU
device = torch.device("cuda:0")

디바이스를 CPU로 설정하는 경우

: torch.device("cpu")를 사용하여 현재 시스템에서 CPU를 사용하도록 지정  -->  GPU가 없는 환경에서 모델을 실행하거나, GPU를 사용하지 않고 CPU만을 사용하고자 할 때 사용

 

디바이스를 GPU로 설정하는 경우

: torch.device("cuda:0")를 사용하여 첫 번째 CUDA 디바이스(GPU)를 지정  -->  모델의 연산이 병렬화되어 더 빠른 속도로 작업 수행

 

 

6. BERT 모델과 Vocabulary 가져오기

bertmodel, vocab = get_pytorch_kobert_model(cachedir=".cache")

get_pytorch_kobert_model

: 지정된 캐시 디렉토리(".cache")에 있는 KoBERT 모델과 어휘집 가져오기  -->  get_pytorch_kobert_model 함수가 어휘집과 KoBERT를 PyTorch 모델로 반환

 

bertmodel, vocab

: 코드 실행 후 bertmodel 변수에는 로드된 KoBERT 모델이, vocab 변수에는 로드된 어휘집이 저장  -->  저장된 모델과 어휘집을 사용하여 텍스트 분류, 개체명 인식, 문장 생성 등 다양한 자연어 처리 작업 수행

 

cachedir=".cache"

: 캐시 디렉토리를 설정하여 모델과 어휘집을 캐시  -->  이후 동일한 모델과 어휘집을 다시 로드할 때 다운로드 시간과 리소스 절약 가능

 

 

7. 데이터셋 다운로드하기

!wget -O .cache/ratings_train.txt http://skt-lsl-nlp-model.s3.amazonaws.com/KoBERT/datasets/nsmc/ratings_train.txt
!wget -O .cache/ratings_test.txt http://skt-lsl-nlp-model.s3.amazonaws.com/KoBERT/datasets/nsmc/ratings_test.txt

학습을 위한 훈련용 데이터셋 다운로드

: ratings_train.txt 파일을 다운로드하여 .cache 디렉토리에 저장  -->  KoBERT 모델 학습을 위한 훈련 데이터셋( 네이버 영화 리뷰 데이터셋 ) 저장

 

성능 평가를 위한 테스트용 데이터셋 다운로드

: ratings_test.txt 파일을 다운로드하여 .cache 디렉토리에 저장  -->  학습된 모델의 예측 결과와 실제 평가 점수를 비교하여 KoBERT 모델의 성능 평가

 

 

8. 텍스트 분류 작업에 필요한 데이터셋 구성

dataset_train = nlp.data.TSVDataset(".cache/ratings_train.txt", field_indices=[1,2], num_discard_samples=1)
dataset_test = nlp.data.TSVDataset(".cache/ratings_test.txt", field_indices=[1,2], num_discard_samples=1)

훈련 데이터셋 구성

: nlp.data.TSVDataset을 사용하여 훈련 데이터셋 구성

 

.cache/ratings_train.txt	앞서 다운로드한 네이버 영화 리뷰 훈련 데이터셋의 경로
field_indices=[1,2]	데이터셋에서 사용할 필드 인덱스를 지정하는 것으로, 1번 인덱스와 2번 인덱스에 해당하는 필드 사용
num_discard_samples=1	데이터셋에서 버릴 샘플 수를 지정. 위의 경우, 첫 번째 줄에 있는 헤더를 버리고 데이터 사용

 

테스트 데이터셋 구성

: nlp.data.TSVDataset을 사용하여 테스트 데이터셋 구성  -->  필드 인덱스와 num_discard_samples는 훈련 데이터셋과 동일하게 설정

 

.cache/ratings_test.txt

다운로드한 네이버 영화 리뷰 테스트 데이터셋의 경로

 

 

9. BERT 모델에 사용할 토크나이저 설정

tokenizer = get_tokenizer()
tok = nlp.data.BERTSPTokenizer(tokenizer, vocab, lower=False)

get_tokenizer() 함수

: KoBERT 모델과 호환되는 BERT 토크나이저를 가져오는 함수  -->  BERT 토크나이저는 입력 텍스트를 토큰으로 분할하는 역할 수행

 

nlp.data.BERTSPTokenizer를 사용하여 BERT 토크나이저 설정

: 토크나이저는 tokenizer와 vocab을 입력으로 받음  -->  tokenizer는 앞서 가져온 BERT 토크나이저를, vocab은 BERT 모델에서 사용하는 어휘집(Vocabulary)을 전달

 

lower=False

: 소문자 변환을 사용하지 않음을 의미  -->  대소문자를 유지하며 토큰화 수행

 

 

10. BERT 모델에 사용될 데이터셋 생성을 위한 BERTDataset 클래스 정의

class BERTDataset(Dataset):
    def __init__(self, dataset, sent_idx, label_idx, bert_tokenizer, max_len,
                 pad, pair):
        transform = nlp.data.BERTSentenceTransform(
            bert_tokenizer, max_seq_length=max_len, pad=pad, pair=pair)

        self.sentences = [transform([i[sent_idx]]) for i in dataset]
        self.labels = [np.int32(i[label_idx]) for i in dataset]

    def __getitem__(self, i):
        return (self.sentences[i] + (self.labels[i], ))

    def __len__(self):
        return (len(self.labels))

BERTDataset 클래스

: torch.utils.data.Dataset을 상속받아 데이터셋을 구성  -->  주어진 데이터셋을 BERT 모델에 적합한 형식으로 변환하는 역할 수행

 

__init__ 메서드

: 초기화 작업을 수행하는 메서드  -->  주어진 데이터셋, 문장 인덱스(sent_idx), 라벨 인덱스(label_idx), BERT 토크나이저(bert_tokenizer), 최대 길이(max_len), 패딩(pad), 페어(pair) 등을 인자로 받음

 

nlp.data.BERTSentenceTransform

: 데이터셋의 문장을 BERT 입력 형식으로 변환  -->  변환된 문장들은 self.sentences에, 라벨은 정수 형태로 변환되여 self.labels에 저장

 

__getitem__ 메서드

: 인덱스 i에 해당하는 데이터를 반환하는 메서드  -->  BERT 입력 문장과 해당 라벨을 튜플 형태로 반환

 

__len__ 메서드

: 데이터셋의 길이를 반환하는 메서드  -->  데이터셋의 길이는 라벨의 개수와 동일

 

 

11. BERT 모델 학습에 사용되는 파라미터 설정

## Setting parameters
max_len = 64
batch_size = 64
warmup_ratio = 0.1
num_epochs = 5
max_grad_norm = 1
log_interval = 200
learning_rate =  5e-5

 

파라미터	설명
max_len	입력 문장의 최대 길이 설정
batch_size	학습 1회당 사용되는 데이터 샘플 개수 설정
warmup_ratio	학습 초기 learning rate 증가 비율 설정
num_epochs	전체 데이터셋에 대해 학습 반복 횟수 설정
max_grad_norm	그래디언트(gradient)의 최대 노름(norm)을 제한
log_interval	학습 중 로그를 출력하는 간격 조정
learning_rate	학습 속도를 조절

 

 

12. 구성한 데이터셋을 BERTDataset 클래스의 객체로 변환

data_train = BERTDataset(dataset_train, 0, 1, tok, max_len, True, False)
data_test = BERTDataset(dataset_test, 0, 1, tok, max_len, True, False)

훈련 데이터셋 변환

: BERTDataset 클래스의 객체를 생성하여 훈련 데이터셋을 변환  -->  변환된 문장과 라벨은 data_train에 저장

 

테스트 데이터셋 변환

: BERTDataset 클래스의 객체를 생성하여 테스트 데이터셋 변환  -->  변환된 문장과 라벨은 data_test에 저장

 

인자	의미
dataset_train	훈련에 사용할 데이터셋
dataset_test	테스트에 사용할 데이터셋
0	문장 인덱스
1	라벨 인덱스
tok	토크나이저 객체
max_len	최대 문장 길이
True	패딩 사용 여부
False	페어(Pair) 사용 여부

 

 

13. 데이터셋을 미니배치 형태로 로딩

train_dataloader = torch.utils.data.DataLoader(data_train, batch_size=batch_size, num_workers=5)
test_dataloader = torch.utils.data.DataLoader(data_test, batch_size=batch_size, num_workers=5)

훈련 데이터셋 로딩

: torch.utils.data.DataLoader를 사용하여 훈련 데이터셋을 로딩하는 데이터로더(train_dataloader) 생성

 

테스트 데이터셋 로딩

: torch.utils.data.DataLoader를 사용하여 테스트 데이터셋을 로딩하는 데이터로더(test_dataloader) 생성

 

인자	설명
batch_size	한 번에 로딩할 미니 배치 크기 지정
num_workers	데이터 로딩에 사용할 프로세스 수 지정
data_train	훈련 데이터셋
data_test	테스트 데이터셋

 

 

14. BERT 모델 기반 분류기인 BERTClassifier 클래스 정의

class BERTClassifier(nn.Module):
    def __init__(self,
                 bert,
                 hidden_size = 768,
                 num_classes=2,
                 dr_rate=None,
                 params=None):
        super(BERTClassifier, self).__init__()
        self.bert = bert
        self.dr_rate = dr_rate
                 
        self.classifier = nn.Linear(hidden_size , num_classes)
        if dr_rate:
            self.dropout = nn.Dropout(p=dr_rate)
    
    def gen_attention_mask(self, token_ids, valid_length):
        attention_mask = torch.zeros_like(token_ids)
        for i, v in enumerate(valid_length):
            attention_mask[i][:v] = 1
        return attention_mask.float()

    def forward(self, token_ids, valid_length, segment_ids):
        attention_mask = self.gen_attention_mask(token_ids, valid_length)
        
        _, pooler = self.bert(input_ids = token_ids, token_type_ids = segment_ids.long(), attention_mask = attention_mask.float().to(token_ids.device))
        if self.dr_rate:
            out = self.dropout(pooler)
        else:
            out = pooler
        return self.classifier(out)

BERTClassifier 클래스

: nn.Module을 상속받아 모델 정의  -->  주어진 BERT 모델을 기반으로 입력 문장을 분류하는 역할 수행

 

__init__ 메서드

: 초기화 작업을 수행하는 메서드  -->  주어진 인자들을 기반으로 모델 구조 설정

 

인자	설명
bert	BERT 모델 객체
hidden_size	BERT 모델의 은닉 상태 크기 지정
num_classes	분류할 클래스 개수 지정
dr_rate	드롭아웃(dropout) 비율 지정
params	추가적인 파라미터 설정

 

gen_attention_mask 메서드

: 어텐션 마스크(attention mask)를 생성하는 메서드  -->  어텐션 마스크는 입력 문장의 패딩 부분을 제외하고 실제 입력에 대한 어텐션을 수행하기 위해 사용되며, 위 메서드는 입력 토큰의 길이(`valid_length`)에 따라 어텐션 마스크를 생성함

 

forward 메서드

: 모델의 순전파 연산을 수행하는 메서드  -->  입력으로 주어진 토큰(`token_ids`), 유효 길이(`valid_length`), 세그먼트 토큰(`segment_ids`)을 활용하여 BERT 모델을 통과시킴

 

 

15. BERTClassifier 클래스의 객체 생성

model = BERTClassifier(bertmodel,  dr_rate=0.5).to(device)

 

요소	설명
bertmodel	BERT 모델 객체
dr_rate	드롭아웃 (dropout) 비율 설정
to(device)	모델을 지정한 장치로 이동

 

 

16. 옵티마이저와 스케줄러 설정

# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
    {'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},
    {'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]

no_decay

: 가중치 감쇠(weight decay)를 적용하지 않을 파라미터들의 이름을 나타내는 리스트

 

optimizer_grouped_parameters

: 옵티마이저가 갱신해야 할 파라미터들과 해당 파라미터들에 대한 가중치 감쇠 값을 설정하는 리스트  -->  리스트 내의 각 딕셔너리는 하나의 파라미터 그룹을 나타냄

 

요소	설명
params	갱신해야 할 파라미터를 나타내는 리스트 지정
weight_decay	파라미터들에 대한 가중치 감쇠값 설정

 

 

17. AdamW 옵티마이저 객체 생성

optimizer = AdamW(optimizer_grouped_parameters, lr=learning_rate)
loss_fn = nn.CrossEntropyLoss()

loss_fn 함수

: 크로스 엔트로피 손실 함수(CrossEntropyLoss)로, 모델의 예측값과 실제값 사이의 차이를 통해 손실 계산  -->  주로 다중 클래스 분류 문제에서 사용되며, 모델의 출력과 정답 클래스 간의 차이를 최소화하여 모델 학습에 기여함

 

optimizer_grouped_parameters

: optimizer_grouped_parameters를 사용하여 AdamW 옵티마이저 객체 생성

 

lr=learning_rate

옵티마이저가 파라미터들을 업데이트할 때 사용할 학습률(learning rate) 지정

 

 

18. 학습에 필요한 총 스텝 수와 웜업 스텝 수 계산

t_total = len(train_dataloader) * num_epochs
warmup_step = int(t_total * warmup_ratio)

t_total

: 전체 학습 데이터의 배치 수(`len(train_dataloader)`)와 학습할 에포크 수(`num_epochs`)를 곱하여 계산  -->  총 몇 번의 스텝( = 모델이 한 번의 순전파와 역전파를 완료하는 단위 )을 수행할 것인지를 나타냄

 

warmup_step

: 총 스텝 수(`t_total`)에 웜업 비율(`warmup_ratio`)을 곱하여 계산  -->  학습 초기에 학습률을 점진적으로 증가시키는 웜업 단계를 나타내며, 웜업 단계는 초기에는 학습률을 작게 설정하고 점차적으로 증가시켜 안정화된 학습을 도움

 

 

19. 코사인 함수를 통해 스케줄러(scheduler) 생성

scheduler = get_cosine_schedule_with_warmup(optimizer, num_warmup_steps=warmup_step, num_training_steps=t_total)

get_cosine_schedule_with_warmup 함수

: 주어진 옵티마이저(optimizer)에 대해 코사인 함수를 기반으로 학습률을 조정하는 스케줄러 생성

 

num_training_steps

: 총 스텝 수를 나타내며, 앞서 계산한 't_total' 값을 사용하여 설정  -->  전체 학습 데이터에 대해 몇 번의 스텝을 수행할 것인지를 의미

 

num_warmup_steps

: 웜업 스텝 수를 나타내며, 앞서 계산한 'warmup_step' 값을 사용하여 설정  -->  학습 초기에 학습률을 점진적으로 증가시키는 웜업 단계의 스텝 수를 의미

 

 

20. 정확도 계산 함수 calc_accuracy  구현

def calc_accuracy(X,Y):
    max_vals, max_indices = torch.max(X, 1)
    train_acc = (max_indices == Y).sum().data.cpu().numpy()/max_indices.size()[0]
    return train_acc

torch.max(X, 1)

: `X` 텐서의 각 행에서 최대값과 그에 해당하는 인덱스 반환

 

max_vals	최댓값 저장
max_indices	최댓값에 해당하는 인덱스 저장

 

(max_indices == Y).sum()

: 예측값과 실제값이 일치하는 횟수 계산  -->  sum() 은 True인 요소의 개수 반환

 

.data.cpu().numpy()

: 계산 결과를 CPU 상에서 넘파이 배열로 변환

 

 

21. 주어진 에포크 수만큼 학습 진행 후 학습 데이터와 테스트 데이터에 대한 정확도 계산

for e in range(num_epochs):
    train_acc = 0.0
    test_acc = 0.0
    model.train()
    for batch_id, (token_ids, valid_length, segment_ids, label) in tqdm(enumerate(train_dataloader), total=len(train_dataloader)):
        optimizer.zero_grad()
        token_ids = token_ids.long().to(device)
        segment_ids = segment_ids.long().to(device)
        valid_length= valid_length
        label = label.long().to(device)
        out = model(token_ids, valid_length, segment_ids)
        loss = loss_fn(out, label)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)
        optimizer.step()
        scheduler.step()  # Update learning rate schedule
        train_acc += calc_accuracy(out, label)
        if batch_id % log_interval == 0:
            print("epoch {} batch id {} loss {} train acc {}".format(e+1, batch_id+1, loss.data.cpu().numpy(), train_acc / (batch_id+1)))
    print("epoch {} train acc {}".format(e+1, train_acc / (batch_id+1)))
    model.eval()
    for batch_id, (token_ids, valid_length, segment_ids, label) in tqdm(enumerate(test_dataloader), total=len(test_dataloader)):
        token_ids = token_ids.long().to(device)
        segment_ids = segment_ids.long().to(device)
        valid_length= valid_length
        label = label.long().to(device)
        out = model(token_ids, valid_length, segment_ids)
        test_acc += calc_accuracy(out, label)
    print("epoch {} test acc {}".format(e+1, test_acc / (batch_id+1)))

train_acc

: 학습 데이터에 대한 정확도가 누적되는 변수

 

test_acc

: 테스트 데이터에 대한 정확도가 누적되는 변수

 

model.train()

: 모델을 학습 모드로 설정  -->  모델 내부의 드롭아웃(dropout)이나 배치 정규화(batch normalization)와 같은 학습 동작 활성화

 

학습 데이터 순회 반복문

: for batch_id, (token_ids, valid_length, segment_ids, label) in tqdm(enumerate(train_dataloader), total=len(train_dataloader)):  -->  학습 데이터를 배치 단위로 순회하는 반복문으로, 각 배치에 대해 다음의 작업 수행

 

1. optimizer.zero_grad()를 통해 옵티마이저의 기울기 초기화
2. 데이터를 GPU로 이동시킴
3. 모델을 통해 예측값 계산
4. 손실 함수를 통해 손실 계산
5. 역전파를 수행하여 기울기 계산
6. torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm) 을 통해 기울기 클리핑 수행
7. 옵티마이저를 통한 파라미터 업데이트
8. 스케줄러를 통한 학습률 스케줄 업데이트
9. train_acc += calc_accuracy(out, label) 을 통해 정확도 계산 및 계산값 누적
10. if batch_id % log_interval == 0: 을 통해 일정 간격으로 현재 에포크 및 배치 ID, 손실과 훈련 정확도 출력

 

model.eval()

: 모델을 평가 모드로 설정  -->  드롭아웃이나 배치 정규화와 같은 학습 동작을 비활성화하고, 모델의 예측 결과를 안정적으로 평가하기 위해 사용

 

테스트 데이터 순회 반복문

: for batch_id, (token_ids, valid_length, segment_ids, label) in tqdm(enumerate(test_dataloader), total=len(test_dataloader)):  -->  테스트 데이터를 배치 단위로 순회하는 반복문으로, 각 배치에 대해 다음의 작업 수행

1. 데이터를 GPU로 이동시킴
2. 모델을 통한 예측값 계산
3. test_acc += calc_accuracy(out, label) 을 통해 정확도 계산 및 계산값 누적