허깅페이스 트렌스포머 활용강좌, 화이자 COVID-19 위키피디아 텍스트 가져오기

화이자 COVID-19 위키피디아 텍스트 가져오기

이번 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 화이자(Pfizer)의 COVID-19 관련 정보를 위키피디아에서 가져오는 방법을 배워보겠습니다. 이 강좌는 자연어 처리(NLP)에 대한 기본 지식이 있는 분들을 대상으로 하며, Python과 함께 허깅페이스의 라이브러리를 친구처럼 편하게 사용할 수 있도록 여러분을 안내할 것입니다.

1. 환경 설정

먼저 필요한 라이브러리를 설치해야 합니다. 아래 코드를 입력하여 transformerswikipedia-api를 설치하세요.

!pip install transformers wikipedia-api

2. 라이브러리 임포트

필요한 라이브러리를 임포트합시다. transformers는 자연어 처리 모델을 쉽게 사용할 수 있도록 도와줍니다. wikipedia-api는 위키피디아 API에 간편하게 접근할 수 있도록 해줍니다.

import wikipediaapi
from transformers import pipeline

3. 위키피디아에서 정보 가져오기

이제 위키피디아에서 COVID-19와 화이자 관련 정보를 가져옵니다. wikipediaapi를 사용하여 정보를 가져오겠습니다.

wiki_wiki = wikipediaapi.Wikipedia('ko')
page = wiki_wiki.page("COVID-19_백신_화이자") 

if page.exists():
    print(page.text[0:1000])  # 첫 1000자 출력
else:
    print("페이지가 존재하지 않습니다.") 

코드 설명

위 코드는 위키피디아에서 “COVID-19 백신 화이자” 페이지를 가져옵니다. 페이지가 존재하는 경우에는 첫 1000자를 출력합니다. 이는 우리가 가져오려는 정보의 내용을 확인할 수 있도록 도와줍니다.

4. 텍스트 요약하기

가져온 데이터는 긴 문장이 많기 때문에 자연어 처리 모델을 통해 요약해 보겠습니다. 허깅페이스의 transformers 라이브러리에서 제공하는 요약 모델을 사용합니다.

summarizer = pipeline("summarization")

summary = summarizer(page.text, max_length=130, min_length=30, do_sample=False)

print("Summary:")
for s in summary:
    print(s['summary_text'])

코드 설명

이 코드는 허깅페이스의 “summarization” 파이프라인을 통해 텍스트 요약을 수행합니다. max_lengthmin_length를 설정해 요약의 길이를 조절할 수 있습니다.

5. 결론

이번 강좌에서는 허깅페이스의 트랜스포머와 위키피디아 API를 활용하여 화이자의 COVID-19 정보를 가져오고 요약하는 방법을 배웠습니다. 자연어 처리의 가능성을 엿보았기를 바랍니다. 이러한 기법들은 다양한 분야에서 응용될 수 있으며, 여러분의 프로젝트에 활용될 수 있는 유용한 도구입니다.

6. 다음 단계

더 나아가, 감정 분석, 질문 응답 시스템, 문서 분류 등의 다양한 자연어 처리 작업을 시도해 보세요! 허깅페이스의 모델 허브를 탐색하여 자신에게 맞는 모델을 찾고 활용하는 것을 추천합니다.

감사합니다!

허깅페이스 트렌스포머 활용강좌, 학습 및 검증 데이터세트 분리

최근 인공지능(AI) 및 머신러닝 분야에서 자연어 처리(NLP)의 중요성이 날로 증가하고 있습니다. 그 중심에는 허깅페이스(Hugging Face)의 트랜스포머 라이브러리가 있습니다. 이 라이브러리는 다양한 NLP 모델을 손쉽게 사용할 수 있도록 해주며, 특히 사전 훈련된(pre-trained) 모델을 통해 매우 쉽게 응용할 수 있는 장점을 가지고 있습니다. 본 강좌에서는 허깅페이스 트랜스포머 라이브러리를 사용하여 학습 및 검증 데이터셋을 분리하는 방법을 알려드리겠습니다.

1. 데이터셋 준비

첫 번째 단계는 사용할 데이터셋을 준비하는 것입니다. 일반적으로 NLP 문제를 해결하기 위해서는 레이블이 있는 데이터셋이 필요합니다. 이번 예제에서는 IMDb 영화 리뷰 데이터셋을 사용하여 긍정적인 리뷰와 부정적인 리뷰를 분류하는 모델을 학습할 것입니다. 이 데이터셋은 대중적으로 사용되며, 영화 리뷰의 텍스트와 그에 대한 레이블(긍정/부정)로 구성되어 있습니다.

1.1 데이터셋 다운로드

python
from datasets import load_dataset

dataset = load_dataset("imdb")

위 코드를 사용하여 IMDb 데이터셋을 다운로드 할 수 있습니다. load_dataset 함수는 Hugging Face 데이터셋 라이브러리에서 사용할 수 있는 함수로, 다양한 공개 데이터셋을 손쉽게 다운로드할 수 있도록 해줍니다.

1.2 데이터셋 구조 확인

python
print(dataset)

다운로드한 데이터셋의 구조를 확인해 볼 수 있습니다. 데이터셋은 훈련(train), 테스트(test) 및 검증(validation)으로 나누어져 있습니다.

2. 데이터셋 분리

일반적으로 머신러닝에서는 모델을 훈련시키기 위해 데이터를 여러 부분으로 나누는 것이 중요합니다. 주로 훈련 데이터와 검증 데이터를 나누는데, 훈련 데이터는 모델을 학습하는 데 사용되고, 검증 데이터는 모델의 성능을 평가하는 데 사용됩니다. 이번에는 훈련 데이터에서 일부를 추출하여 검증 데이터로 사용할 것입니다.

2.1 훈련 데이터와 검증 데이터 분리

python
from sklearn.model_selection import train_test_split

train_data = dataset['train']
train_texts = train_data['text']
train_labels = train_data['label']

train_texts, val_texts, train_labels, val_labels = train_test_split(
    train_texts,
    train_labels,
    test_size=0.1,  # 10%를 검증 세트로 사용
    random_state=42
)

위 코드는 train_test_split 함수를 사용하여 훈련 데이터를 90%와 10%로 나누는 과정입니다. 여기서 test_size=0.1로 설정하였으므로, 원래 훈련 데이터의 10%를 검증 데이터로 선택합니다. random_state 인자는 분할의 일관성을 보장합니다.

2.2 분리된 데이터 확인

python
print("훈련 데이터 개수:", len(train_texts))
print("검증 데이터 개수:", len(val_texts))

이제 분리된 훈련 및 검증 데이터의 개수를 확인할 수 있습니다. 이 정보는 우리의 데이터가 적절하게 분리되었는지를 판단하는 데 도움이 됩니다.

3. 허깅페이스 트랜스포머 모델 준비

데이터셋을 분리한 후에는 이제 모델을 준비해야 합니다. 허깅페이스의 트랜스포머 라이브러리에서는 다양한 사전 학습된 모델을 제공하므로, 우리가 원하는 용도에 맞는 모델을 선택할 수 있습니다.

3.1 사전 훈련된 모델 선택

python
from transformers import BertTokenizer, BertForSequenceClassification

model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)

BertTokenizerBertForSequenceClassification를 사용하여 BERT 모델을 준비합니다. 이 모델은 텍스트 분류 작업에 적합하며, “bert-base-uncased”라는 사전 훈련된 버전을 사용하고 있습니다.

3.2 데이터 토큰화

python
train_encodings = tokenizer(train_texts, truncation=True, padding=True, return_tensors='pt')
val_encodings = tokenizer(val_texts, truncation=True, padding=True, return_tensors='pt')

tokenizer를 사용하여 훈련 및 검증 데이터를 토큰화합니다. truncation=True는 길이가 제한된 입력을 처리하며, padding=True는 모든 입력의 길이를 동일하게 맞춰줍니다.

4. 모델 학습

모델의 학습을 위해 PyTorch의 DataLoader를 사용하여 배치로 데이터를 조작할 수 있습니다. 또한, optimizer와 loss 함수를 설정하여 모델을 학습시킬 것입니다.

4.1 데이터 로더 준비

python
import torch
from torch.utils.data import DataLoader, Dataset

class IMDbDataset(Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

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

train_dataset = IMDbDataset(train_encodings, train_labels)
val_dataset = IMDbDataset(val_encodings, val_labels)

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)

새로운 데이터셋 클래스를 정의하여 Dataset 클래스에서 상속받고, DataLoader를 사용하여 배치 처리를 합니다. 배치 크기로 16을 사용하였습니다.

4.2 모델 학습 설정

python
from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)

model.train()
for epoch in range(3):  # 총 3 에폭
    total_loss = 0
    for batch in train_loader:
        optimizer.zero_grad()
        outputs = model(**batch)
        loss = outputs.loss
        total_loss += loss.item()
        loss.backward()
        optimizer.step()
    print(f"Epoch: {epoch + 1}, Loss: {total_loss / len(train_loader)}")

AdamW 최적화 알고리즘을 사용하여 모델을 학습합니다. 매 에폭마다 총 손실을 계산하고 출력합니다. 이번 예제에서는 3회 훈련하였습니다.

5. 모델 평가

모델이 훈련된 후에는 검증 데이터에 대한 성능을 평가해야 합니다. 이를 통해 모델이 얼마나 잘 일반화되는지를 확인할 수 있습니다.

5.1 모델 평가 함수 정의

python
from sklearn.metrics import accuracy_score

def evaluate_model(model, val_loader):
    model.eval()
    all_labels = []
    all_preds = []

    with torch.no_grad():
        for batch in val_loader:
            outputs = model(**batch)
            preds = outputs.logits.argmax(dim=-1)
            all_labels.extend(batch['labels'].tolist())
            all_preds.extend(preds.tolist())

    accuracy = accuracy_score(all_labels, all_preds)
    return accuracy

accuracy = evaluate_model(model, val_loader)
print("검증 정확도:", accuracy)

evaluate_model 함수를 정의하여 모델의 성능을 평가합니다. 검증 데이터에 대한 정확도를 출력하여 모델의 성능을 파악합니다.

6. 결론

이번 강좌에서는 Hugging Face의 트랜스포머 라이브러리를 활용하여 IMDb 영화 리뷰 데이터셋을 다루는 방법을 배웠습니다. 데이터셋을 분리하고, 모델을 학습시키고, 성능을 평가하는 과정까지 전반적으로 살펴보았습니다. 이러한 과정을 통해 NLP 분야의 기초적인 이해를 할 수 있었기를 바랍니다. 이러한 기술은 다양한 언어 모델에 적용할 수 있으며, 이를 통해 더 나은 결과를 얻을 수 있습니다.

허깅페이스 트렌스포머 활용강좌, 학습 모델 이전에 BART 토크나이징

최근 인공지능과 자연어 처리(NLP) 분야는 눈부신 발전을 이루었습니다. 특히, 트랜스포머(Transformers) 아키텍처는
다양한 NLP 작업에서 혁신적인 결과를 가져왔습니다. 이번 글에서는 허깅페이스(Hugging Face) 라이브러리의
BART(Bidirectional and Auto-Regressive Transformers) 모델을 중심으로,
데이터 전처리에서 중요한 역할을 하는 토크나이징(Tokenization) 과정에 대해 자세히 알아보도록 하겠습니다.
BART는 단순한 비지도 학습과 다수의 감독 학습 작업에서 GPT와 BERT의 장점을 결합한 모델로서, 텍스트 요약, 번역,
질문 생성 등의 다양한 과제에 활용됩니다.

1. BART 모델 이해하기

BART는 인코더-디코더 구조를 갖춘 모델로, 주로 덮어쓰기 복원(auto-regressive)과 입력을 리커버하는
(denoising) 방식 모두를 통해 훈련됩니다. 이러한 구조 덕분에 BART는 텍스트의 다양한 변화를 잘 처리할 수 있으며,
텍스트 생성, 요약, 번역 등 다양한 NLP 작업에서 높은 성능을 발휘합니다.
BART의 주요 특징을 요약하자면 다음과 같습니다.

  • 인코더와 디코더가 모두 존재하여 다양한 작업에 유연하게 사용 가능
  • 이전 문맥을 기반으로 단어를 생성하는 다이나믹한 능력
  • 넉넉한 사전 훈련 데이터에 기반하여 다양한 텍스트 특징을 학습

2. 토크나이징의 필요성

자연어 처리 모델을 훈련시키기 위한 첫 번째 단계는 데이터를 적절한 형식으로 변환하는 것입니다.
토크나이저(tokenizer)는 텍스트를 더 작은 단위, 즉 토큰(token)으로 나누어 모델이 이해할 수 있도록 돕습니다.
이를 통해 모델은 문장과 단어 간의 관계를 더 잘 이해할 수 있게 됩니다. BART에서도 토크나이징은
필수적으로 필요한 과정이며, 텍스트 데이터를 준비하는데 중요한 역할을 합니다.

3. 허깅페이스 라이브러리 설치

토크나이징 과정을 시작하기 전에, 허깅페이스의 트랜스포머 라이브러리를 설치해야 합니다.
아래의 명령어로 쉽게 설치할 수 있습니다.

pip install transformers

4. BART 토크나이저 사용하기

이제 BART 모델의 토크나이저를 사용하여 텍스트를 토크나이징하여 보겠습니다.
여기에서는 BART의 사전 훈련된 모델을 불러오고, 간단한 예제로 텍스트를 토크나이징하여
토큰과 그 토큰의 인덱스를 출력해 보겠습니다.

4.1. 파이썬 코드 예제


from transformers import BartTokenizer

# BART 토크나이저 불러오기
tokenizer = BartTokenizer.from_pretrained('facebook/bart-base')

# 테스트 텍스트
text = "딥러닝은 인공지능의 한 분야입니다."

# 토크나이징
tokens = tokenizer.tokenize(text)
print("토큰화 결과:", tokens)

# 토큰의 인덱스 확인
token_ids = tokenizer.convert_tokens_to_ids(tokens)
print("토큰 ID:", token_ids)
    

위의 코드를 실행하면 아래와 같은 결과를 얻을 수 있습니다:


토큰화 결과: ['▁딥', '러', '닝', '은', '▁인', '공지', '능', '의', '▁한', '▁분야', '입니다', '.']
토큰 ID: [31050, 17381, 2804, 1839, 1507, 7138, 5390, 1839, 2269, 2252, 2872, 2]
    

5. 디코딩 과정

토크나이징 후, 모델에 데이터를 입력하기 전에 디코딩 과정을 통해 토큰의 원래 문장을 복원할 수 있습니다.
다음의 코드는 인덱스를 원래 문장으로 디코딩하는 방법을 보여 줍니다.


# 토큰 ID를 원래 문장으로 디코딩
decoded_text = tokenizer.decode(token_ids)
print("디코딩 결과:", decoded_text)
    

이를 통해 우리는 원래의 문장을 복구할 수 있습니다.
이 과정을 통해 모델이 이해할 수 있는 입력을 어떻게 준비하고,
다시 원래의 형태로 복원할 수 있는지를 보여주었습니다.

6. BART를 활용한 텍스트 요약

토크나이징 후 다음 단계로는 BART 모델을 사용하여 입력된 텍스트를 요약하는 과정입니다.
사용자는 입력 텍스트를 모델에 주고 요약된 결과를 얻을 수 있습니다.
다음은 BART를 활용한 텍스트 요약의 간단한 예제입니다.


from transformers import BartForConditionalGeneration

# BART 모델 불러오기
model = BartForConditionalGeneration.from_pretrained('facebook/bart-base')

# 입력할 텍스트
input_text = "인공지능은 기계가 인간의 지능을 모방하여 수행하는 작업을 의미합니다. 이러한 기술은 최근 몇 년 동안 비약적인 발전을 이루었습니다."

# 텍스트를 토크나이즈 후 인덱스로 변환
input_ids = tokenizer.encode(input_text, return_tensors='pt')

# 요약 생성
summary_ids = model.generate(input_ids, max_length=50, num_beams=5, early_stopping=True)

# 요약 결과 디코딩
summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
print("요약 결과:", summary)
    

위의 코드를 실행하면 입력 텍스트의 요약을 생성하게 됩니다.
BART 모델은 입력된 문장을 이해하고, 그것을 간결한 형식으로 변환하는 능력을 가지고 있습니다.

7. 마치며

이번 글에서는 허깅페이스의 BART 모델을 활용한 텍스트 토크나이징 과정과
간단한 요약 예제를 다루었습니다. BART를 비롯한 트랜스포머 모델들은
자연어 처리의 다양한 과제를 효과적으로 수행할 수 있는 뛰어난 성능을 보이고 있습니다.
데이터 전처리 과정에서 토크나이징의 중요성을 인식하고, 이를 통해 모델의 학습 효율성을 높일 수 있습니다.
다음 글에서는 BART의 활용 사례 및 추가적인 응용 방법에 대해 다루어 보겠습니다.

감사합니다!

허깅페이스 트렌스포머 활용강좌, 학습 데이터세트를 활용한 BERT 앙상블 학습 및 예측

딥러닝 분야에서 자연어 처리(Natural Language Processing, NLP)의 발전에는
다양한 혁신적 모델이 기여하고 있습니다. 그 중 하나가 바로 BERT(Bidirectional Encoder Representations from Transformers)입니다.
BERT는 문맥을 이해하는 데 매우 강력하며, 텍스트 분류, 질의응답, 감정 분석 등 다양한 NLP 과제에서
최첨단 성능을 보이고 있습니다. 이번 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 이용해
BERT 모델을 앙상블 학습하는 방법과 이를 통한 예측 과정에 대해 살펴보겠습니다.

1. BERT 모델 이해하기

BERT는 Transformer 아키텍처를 기반으로 한 사전 학습된 언어 모델로,
일반적인 방향성을 가지고 있지 않고 양 방향으로 텍스트를 인코딩하여 문맥을 잘 파악합니다.
BERT 모델은 두 가지 주요 과제, 즉 마스크 언어 모델(Masked Language Model)과 다음 문장 예측(Next Sentence Prediction)으로 사전 학습됩니다.

1.1 마스크 언어 모델

마스크 언어 모델에서는 입력 문장에서 일부 단어를 마스킹하고,
모델이 마스크된 단어를 예측하도록 학습합니다.
이를 통해 문맥에 따른 단어의 의미를 파악할 수 있습니다.

1.2 다음 문장 예측

이 과제에서는 두 문장을 입력받아 두 문장이 연속적인 문장인지 아닌지를 판별합니다.
이를 통해 문장 간의 관계를 이해할 수 있게 됩니다.

2. 허깅페이스 트랜스포머 소개

허깅페이스의 트랜스포머 라이브러리는 전 세계 다양한 NLP 모델을 손쉽게 사용할 수 있는 프레임워크입니다.
이 라이브러리는 모델 로드와 데이터 처리, 학습, 예측을 위한 다양한 유틸리티를 제공합니다.
특히 BERT 및 다른 Transformer 기반 모델들을 쉽게 사용할 수 있는 인터페이스를 갖추고 있습니다.

3. 데이터 준비

이번 예제에서는 IMDB 영화 리뷰 데이터셋을 사용하여 영화 리뷰의 긍정/부정을 예측하는 모델을 구축하겠습니다.
데이터셋은 공개된 데이터셋을 활용할 것입니다.
먼저 데이터셋을 다운로드하고 전처리하는 과정을 살펴봅시다.

3.1 데이터셋 다운로드 및 전처리

import pandas as pd
from sklearn.model_selection import train_test_split

# IMDB 데이터셋 다운로드
url = "https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz"
!wget {url} -O aclImdb_v1.tar.gz
!tar -xvf aclImdb_v1.tar.gz

# 데이터셋 로드
train_data = pd.read_csv("aclImdb/train.csv")
test_data = pd.read_csv("aclImdb/test.csv")

# 학습 데이터와 테스트 데이터로 분리
X_train, X_test, y_train, y_test = train_test_split(train_data['review'], train_data['label'], 
                                                    test_size=0.2, random_state=42)
    

4. BERT 모델 로드 및 학습

이제 BERT 모델을 로드하고 학습할 준비가 되었습니다.
허깅페이스 트랜스포머 라이브러리를 통해 BERT 모델을 쉽게 사용할 수 있습니다.
먼저 모델과 토크나이저를 로드한 후, 데이터셋을 BERT 입력 형식으로 변환하겠습니다.

4.1 모델 및 토크나이저 로드

from transformers import BertTokenizer, BertForSequenceClassification
import torch

# BERT 모델과 토크나이저 로드
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
    

4.2 데이터셋 토큰화

# 데이터셋을 BERT 입력 형식으로 변환
def tokenize_data(texts):
    return tokenizer(texts.tolist(), padding=True, truncation=True, return_tensors='pt')

train_encodings = tokenize_data(X_train)
test_encodings = tokenize_data(X_test)
    

5. 모델 앙상블 학습

모델 앙상블은 여러 개의 모델을 결합하여 더 나은 성능을 달성하는 방법입니다.
BERT를 기반으로 여러 개의 모델을 학습시키고 이들의 예측 결과를 결합하여 최종 결과를 도출합니다.
다음은 모델 앙상블을 구현하는 코드입니다.

5.1 학습 및 예측 함수 정의

def train_and_evaluate(model, train_encodings, labels):
    # 모델 훈련 및 평가 로직
    inputs = {'input_ids': train_encodings['input_ids'],
              'attention_mask': train_encodings['attention_mask'],
              'labels': torch.tensor(labels.tolist())}
    
    optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
    model.train()
    
    for epoch in range(3):  # 여러 에폭 동안 학습
        outputs = model(**inputs)
        loss = outputs[0]
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
        print(f'Epoch: {epoch}, Loss: {loss.item()}')

def predict(model, test_encodings):
    model.eval()
    with torch.no_grad():
        outputs = model(**test_encodings)
        logits = outputs[0]
    return logits.argmax(dim=1)
    

5.2 모델 앙상블 실행

# 앙상블할 모델 목록
models = [BertForSequenceClassification.from_pretrained('bert-base-uncased') for _ in range(5)]
predictions = []

for model in models:
    train_and_evaluate(model, train_encodings, y_train)
    preds = predict(model, test_encodings)
    predictions.append(preds)

# 예측 결과 앙상블
final_preds = torch.stack(predictions).mean(dim=0).round().long()
    

6. 결과 분석 및 평가

최종 예측 결과를 바탕으로 모델의 성능을 평가하겠습니다.
정확도를 계산하고 confusion matrix를 시각화하여 모델의 예측 성능을 분석해봅시다.

6.1 성능 평가

from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay

# 성능 평가
accuracy = accuracy_score(y_test, final_preds)
print(f'Accuracy: {accuracy * 100:.2f}%')

# Confusion matrix 출력
cm = confusion_matrix(y_test, final_preds)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
    

7. 결론

이번 강좌에서는 허깅페이스 트랜스포머 라이브러리를 활용하여 BERT 모델을 앙상블 학습하는 방법을 살펴보았습니다.
BERT는 강력한 성능을 가진 모델이며, 앙상블 기법을 통해 모델의 예측 성능을 더욱 향상시킬 수 있음을 확인할 수 있었습니다.
다양한 NLP 태스크에 BERT를 활용하여 다음 단계로 나아가보시기 바랍니다.

참고 자료

허깅페이스 트렌스포머 활용강좌, 학습 데이터세트 이외의 BERT 앙상블 학습 및 예측

이번 글에서는 허깅페이스 트랜스포머 라이브러리가 제공하는 BERT 모델을 활용하여 앙상블 학습을 수행하고, 이를 통해 예측 성능을 개선하는 방법에 대해 다루어보겠습니다. 앙상블 학습은 여러 모델의 예측 결과를 결합하여 더 좋은 성능을 얻고자 하는 기법입니다. 본 강좌에서는 BERT 모델을 다양하게 조합하여 앙상블화를 구현하는 과정을 상세히 설명하겠습니다.

1. 앙상블 학습의 기초

앙상블 학습은 여러 개의 모델을 조합하여 최종 예측 결과를 만드는 방법입니다. 이 방식은 각각의 모델이 가지는 강점을 살려, 전체 모델의 성능을 향상시킬 수 있습니다. 일반적으로 활용되는 앙상블 방법으로는 다음과 같은 기법들이 있습니다:

  • 배깅(Bagging): 여러 모델을 독립적으로 학습시켜, 최종 예측 결과를 평균하여 성능을 향상시킵니다.
  • 부스팅(Boosting): 이전 모델이 잘못 예측한 데이터에 대한 가중치를 높여서 다음 모델을 학습시킵니다.
  • 스태킹(Stacking): 다양한 모델의 예측값을 새로운 특징으로 사용하여 최종 예측을 위한 메타 모델을 학습합니다.

2. BERT 모델 소개

BERT(Bidirectional Encoder Representations from Transformers)는 Transformer 기반의 사전 훈련된 언어 모델로, 다양한 자연어 처리(NLP) 작업에 탁월한 성능을 보여주고 있습니다. BERT의 특징 중 두 가지는:

  • 양방향성: BERT는 문맥을 양 방향에서 학습하여 단어의 의미를 보다 정확하게 이해할 수 있습니다.
  • 사전 훈련: 방대한 데이터로 사전 훈련이 되어 있어, 별도의 미세 조정(fine-tuning)만으로도 다양한 과제가 가능합니다.

3. 데이터 준비

앙상블 학습을 위해 준비할 데이터셋은 간단한 자연어 처리 문제를 다루는 것이 좋습니다. 예를 들어, 영화 리뷰 데이터를 사용하여 긍정/부정 감성을 분류하는 작업을 해보겠습니다.

먼저, 허깅페이스 라이브러리와 필요한 패키지를 설치합니다:

!pip install transformers datasets torch scikit-learn

데이터셋 로드

다음으로 Hugging Face의 datasets 라이브러리를 사용하여 데이터셋을 로드하겠습니다:

from datasets import load_dataset

dataset = load_dataset('imdb')
train_data = dataset['train']
test_data = dataset['test']

4. 모델 설정

이번 예제에서는 BERT 모델을 기반으로 하는 두 개의 변형 모델을 만듭니다. 이를 통해 앙상블 효과를 얻을 수 있을 것입니다. 먼저, BERT 모델을 불러오는 함수를 작성하겠습니다:

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments

# BERT 모델 및 토크나이저 불러오기
def load_model_and_tokenizer(model_name='bert-base-uncased'):
    tokenizer = BertTokenizer.from_pretrained(model_name)
    model = BertForSequenceClassification.from_pretrained(model_name)
    return tokenizer, model

5. 데이터 전처리

모델의 입력으로 사용하기 위해 텍스트 데이터를 전처리하는 과정을 설명하겠습니다:

def preprocess_data(dataset, tokenizer, max_len=128):
    inputs = tokenizer(dataset['text'], padding=True, truncation=True, max_length=max_len, return_tensors='pt')
    inputs['labels'] = torch.tensor(dataset['label'])
    return inputs

train_inputs = preprocess_data(train_data, tokenizer)
test_inputs = preprocess_data(test_data, tokenizer)

6. 모델 학습

이제 모델을 학습할 시간입니다. 앞서 불러온 모델과 전처리한 데이터를 사용하여 훈련합니다:

def train_model(model, train_inputs):
    training_args = TrainingArguments(
        output_dir='./results',
        num_train_epochs=3,
        per_device_train_batch_size=16,
        per_device_eval_batch_size=64,
        evaluation_strategy='epoch',
        logging_dir='./logs',
    )
    
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_inputs,
    )
    trainer.train()

# 모델 학습
model1 = load_model_and_tokenizer()[1]
train_model(model1, train_inputs)

7. 앙상블 모델 학습

이제 두 번째 모델을 추가하여 앙상블을 수행합니다. BERT 구조는 동일하지만, 다른 초기화 또는 하이퍼파라미터를 사용할 수 있습니다:

model2 = load_model_and_tokenizer(model_name='bert-large-uncased')[1]
train_model(model2, train_inputs)

8. 앙상블 예측

모델 예측 결과를 앙상블하여 최종 결과를 생성합니다. 두 모델의 예측 결과를 평균 내어 최종 예측을 구합니다:

import numpy as np

def ensemble_predict(models, inputs):
    preds = []
    for model in models:
        model.eval()
        with torch.no_grad():
            outputs = model(**inputs)
            preds.append(outputs.logits)
    
    ensemble_preds = np.mean(preds, axis=0)
    return ensemble_preds

models = [model1, model2]
predictions = ensemble_predict(models, test_inputs)

9. 성능 평가

이제 앙상블 모델의 성능을 평가합니다. 정확도 또는 F1 점수와 같은 지표를 사용할 수 있습니다:

from sklearn.metrics import accuracy_score, f1_score

# 정답 레이블을 가져옵니다
labels = test_data['label']

# 앙상블 예측 결과와 레이블을 기반으로 지표 계산
predicted_labels = np.argmax(predictions, axis=1)

accuracy = accuracy_score(labels, predicted_labels)
f1 = f1_score(labels, predicted_labels)

print(f'Accuracy: {accuracy:.4f}, F1 Score: {f1:.4f}')

10. 결론 및 미래 작업

이번 강좌를 통해 BERT 모델을 활용한 앙상블 학습 방법에 대해 배워 보았습니다. 여러 모델의 예측을 결합함으로써 성능을 개선하는 방법을 익혔습니다. 향후 작업으로는 다음과 같은 것들이 있습니다:

  • 더 많은 모델을 사용한 앙상블
  • 전처리 개선 및 데이터 증강
  • Hyperparameter tuning을 통한 성능 최적화

딥러닝 분야에서 앙상블 학습은 계속해서 유망한 방법으로 자리잡고 있으며, 다양한 모델을 혼합함으로써 더 높은 정확도를 달성할 수 있습니다. 앞서 언급한 것처럼, 여러 BERT 모델을 활용하여 성능을 끌어올리는 다양한 실험을 시도할 수 있습니다.

참고 문헌