허깅페이스 트렌스포머 활용강좌, BERT 앙상블 데이터세트 준비

딥러닝과 자연어 처리(NLP)가 발전하면서 다양한 모델들이 등장하였고, 그중 BERT(Bidirectional Encoder Representations from Transformers)는 오늘날 NLP에서 가장 영향력 있는 모델 중 하나로 자리 잡았습니다. 이번 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 BERT를 앙상블 모델로 구현하기 위해 데이터세트를 준비하는 방법에 대해 다루겠습니다.

1. 앙상블 학습의 개념

앙상블 학습이란 여러 개의 모델을 결합하여 성능을 개선하는 기법입니다. 여러 모델의 예측 결과를 조합함으로써 각각의 모델이 가지는 단점을 보완할 수 있습니다. 앙상블 학습은 일반적으로 두 가지 방식으로 이루어집니다:

  • 배깅(Bagging): 반복적인 샘플링을 통해 여러 모델을 훈련시키고, 각 모델의 예측 결과를 평균내거나 다수결 투표를 통해 최종 예측을 생성합니다.
  • 부스팅(Boosting): 이전 모델의 오차를 학습하는 방식으로 새로운 모델을 순차적으로 훈련시킵니다. 대표적인 방법으로는 XGBoost와 AdaBoost가 있습니다.

이번 강좌에서는 BERT 모델을 사용하여 다수의 모델을 조합해 앙상블 학습을 구현하는 데 중점을 두겠습니다.

2. 허깅페이스 트랜스포머 라이브러리 소개

허깅페이스의 트랜스포머 라이브러리는 다양한 사전 훈련된 언어 모델을 손쉽게 사용할 수 있도록 도와주는 파이썬 라이브러리입니다. BERT 모델뿐 아니라 GPT, T5 등의 다양한 모델들이 포함되어 있어 NLP 태스크를 수행하는 데 유용합니다. 이 라이브러리의 주요 기능은 다음과 같습니다:

  • 사전 훈련된 모델의 손쉬운 다운로드 및 활용
  • 모델과 tokenizer의 통합 사용
  • 간단한 API로 다양한 NLP 태스크(분류, 생성 등) 수행 가능

이제 BERT 모델을 활용하기 위해 필요한 데이터셋을 준비해보겠습니다.

3. 데이터셋 준비

우선, 앙상블 모델을 훈련하기 위해 사용할 데이터셋을 준비해야 합니다. BERT 모델을 학습하기 위해 일반적으로는 텍스트와 라벨이 필요한 데이터셋이 필요합니다. 예를 들어, 감정 분석 모델을 훈련한다고 가정할 때 다음과 같은 형식의 데이터가 필요합니다:


    | 텍스트               | 라벨 |
    |------------------|------|
    | "좋아요!"        | 1    |
    | "실망했어요"     | 0    |
    | "최고의 경험!"   | 1    |
    | "다시는 안 할래요" | 0    |
    

데이터를 준비한 후 CSV 파일로 저장해보겠습니다. 이 예시에서는 파이썬의 pandas 라이브러리를 활용하여 데이터를 CSV 형식으로 저장합니다.


    import pandas as pd

    # 예시 데이터 생성
    data = {
        'text': [
            '좋아요!', 
            '실망했어요', 
            '최고의 경험!', 
            '다시는 안 할래요'
        ],
        'label': [1, 0, 1, 0]
    }
    
    # 데이터프레임으로 변환
    df = pd.DataFrame(data)

    # CSV 파일로 저장
    df.to_csv('sentiment_data.csv', index=False, encoding='utf-8-sig')
    

4. 데이터셋 로딩 및 전처리

CSV 파일로 저장된 데이터셋을 로딩하고, BERT 모델에 맞게 전처리해야 합니다. 여기서는 허깅페이스의 ‘transformers’ 라이브러리에서 제공하는 tokenizer를 사용하여 데이터를 전처리합니다. 먼저 필요한 라이브러리를 설치하고 로딩하겠습니다.


    !pip install transformers
    !pip install torch
    

이제 파이썬 코드로 데이터셋을 로딩하고 전처리할 수 있습니다.


    from transformers import BertTokenizer

    # 토크나이저 로드
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

    # 데이터셋 로딩
    df = pd.read_csv('sentiment_data.csv')

    # 텍스트 전처리
    encodings = tokenizer(df['text'].tolist(), truncation=True, padding=True, max_length=128)

    # 텍스트와 라벨 확인
    print(encodings['input_ids'])
    print(df['label'].tolist())
    

위 코드에서 ‘input_ids’는 각 단어가 BERT 모델에 입력되기 위해 매핑된 인덱스 값이며, 라벨은 예측하고자 하는 목표입니다. 모델을 훈련하기 위해 데이터셋의 형태로 변환해야 합니다.

5. 데이터 로더 생성

데이터를 모델에 전달하기 위해 PyTorch의 DataLoader를 사용하여 배치 단위로 데이터를 리턴하는 클래스를 만들어야 합니다.


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

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

        def __getitem__(self, idx):
            item = {key: torch.tensor(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)

    # 데이터셋 객체 만들기
    dataset = SentimentDataset(encodings, df['label'].tolist())

    # DataLoader 생성
    train_loader = DataLoader(dataset, batch_size=2, shuffle=True)
    

6. 모델 훈련

모델을 훈련시키기 위해 BERT 모델을 로드하고, 옵티마이저와 손실 함수를 설정합니다. 훈련 및 평가 과정에서 BERT 모델을 사용하게 됩니다.


    from transformers import BertForSequenceClassification, AdamW

    # 모델 로드
    model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

    # 옵티마이저 설정
    optimizer = AdamW(model.parameters(), lr=5e-5)

    # GPU 사용 시, 모델을 GPU로 이동
    if torch.cuda.is_available():
        model = model.cuda()

    # 모델 훈련
    model.train()
    for epoch in range(3):  # 에폭 수
        for batch in train_loader:
            optimizer.zero_grad()
            
            # GPU 사용 시, 배치를 GPU로 이동
            if torch.cuda.is_available():
                batch = {k: v.cuda() for k, v in batch.items()}

            outputs = model(**batch)
            loss = outputs.loss
            loss.backward()
            optimizer.step()
            print(f'Epoch {epoch}, Loss: {loss.item()}')
    

모델 훈련 시 출력된 손실 값은 모델이 얼마나 잘 학습하고 있는지를 나타내는 지표입니다. 손실 값이 낮아질수록 모델의 예측 성능이 좋아진다고 볼 수 있습니다.

7. 앙상블 모델 구축

여러 BERT 모델을 훈련시킨 후 앙상블하는 방법에는 여러 가지가 있습니다. 여기서는 간단한 방법으로 모델의 예측 결과를 평균내는 방식을 사용해보겠습니다.


    predictions = []

    # 앙상블할 모델 수 설정
    model_count = 3
    for i in range(model_count):
        model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
        # 모델 훈련은 생략(위에서 설명한 훈련 코드 사용)
        # ...
        
        # 테스트 데이터에 대한 예측
        model.eval()
        with torch.no_grad():
            outputs = model(**batch)
            logits = outputs.logits
            predictions.append(logits.softmax(dim=-1))

    # 예측 평균
    final_predictions = torch.mean(torch.stack(predictions), dim=0)
    predicted_labels = final_predictions.argmax(dim=-1).tolist()
    

8. 결과 검증

모델의 예측력을 평가하기 위해, 실제 라벨과의 비교를 통해 정확도를 계산할 수 있습니다. 다음은 정확도를 계산하고 출력하는 방법입니다.


    from sklearn.metrics import accuracy_score

    # 실제 라벨
    true_labels = df['label'].tolist()

    # 정확도 계산
    accuracy = accuracy_score(true_labels, predicted_labels)
    print(f'Accuracy: {accuracy * 100:.2f}%')
    

9. 최종 정리

이번 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 BERT 모델을 앙상블로 구성하는 방법에 대해 알아보았습니다. 데이터세트를 준비하고, 전처리 및 DataLoader 생성을 통해 BERT 모델을 훈련시켰습니다. 마지막으로 여러 모델의 예측 결과를 앙상블하여 최종 결과를 도출하였습니다.

딥러닝 모델의 성능 향상을 위해 앙상블 기법을 적용하는 것은 매우 효과적인 방법입니다. 이 강좌에서 배운 내용을 바탕으로 다양한 모델과 데이터셋에 실험해 보길 권장합니다.

10. 참고 자료

허깅페이스 트렌스포머 활용강좌, BERT 앙상블 클래스 정의

현대의 자연어 처리(NLP) 분야에서 딥러닝 모델은 중요한 역할을 하고 있습니다. 최근에는 허깅페이스의 트랜스포머 라이브러리를 통해, 다양한 모델들을 쉽게 사용할 수 있게 되었습니다. 본 강좌에서는 BERT(Bidirectional Encoder Representations from Transformers) 모델을 활용한 앙상블 클래스 정의에 대해 자세히 설명하고, 실습을 통해 구현해보겠습니다.

1. BERT 모델 소개

BERT는 Google에서 개발한 사전 훈련된 언어 모델로, Transformer 아키텍처를 기반으로 합니다. BERT의 주요 특징은 Bidirectional 기법을 사용하여 문맥을 양 방향에서 고려한다는 점입니다. 이는 텍스트의 의미를 보다 정교하게 파악할 수 있도록 돕습니다.

BERT는 다양한 다운스트림 태스크(예. 질문 답변, 감정 분석 등)에 Fine-tuning하여 사용될 수 있으며, Hugging Face의 Transformers 라이브러리를 통해 쉽게 접근할 수 있습니다.

2. 앙상블 학습(Ensemble Learning)

앙상블 학습은 여러 모델을 결합하여 보다 정확한 예측을 수행하는 기법입니다. 이를 통해 단일 모델에서 발생할 수 있는 오차를 줄이고, 모델이 제공하는 예측의 다양성을 확보할 수 있습니다.

일반적으로 앙상블의 방법에는 보팅, 배깅, 부스팅 등이 있으며, 각 방법마다 사용되는 알고리즘과 방법이 다릅니다. 여기서는 여러 BERT 모델을 결합하여 더욱 강력한 예측 모델을 만드는 방법을 다루겠습니다.

3. 환경 설정

앙상블 클래스를 구현하기 위해, 먼저 필요한 패키지를 설치해야 합니다. 다음과 같은 패키지를 준비해주세요:

pip install transformers torch numpy

4. BERT 앙상블 클래스 정의

이제 앙상블 학습을 위한 BERT 클래스의 기본 구조를 정의해 보겠습니다. 우리는 여러 개의 BERT 모델을 사용하고 이들의 출력을 결합하여 최종 결과를 도출할 것입니다. 이 과정에서 Hugging Face의 transformers 라이브러리를 사용하여 모델을 불러옵니다.

4.1 BERT 모델 불러오기

먼저 BERT 모델과 토크나이저를 불러오는 메서드를 정의합니다.


import torch
from transformers import BertTokenizer, BertForSequenceClassification

class BertEnsemble:
    def __init__(self, model_paths):
        self.models = []
        self.tokenizers = []
        
        for model_path in model_paths:
            tokenizer = BertTokenizer.from_pretrained(model_path)
            model = BertForSequenceClassification.from_pretrained(model_path)
            self.tokenizers.append(tokenizer)
            self.models.append(model)

    def predict(self, text):
        inputs = [tokenizer(text, return_tensors='pt') for tokenizer in self.tokenizers]
        outputs = [model(**input).logits for model, input in zip(self.models, inputs)]
        return outputs
    

4.2 예측 메서드 구현

각 모델의 예측값을 평균내어 최종 결과를 도출하는 메서드를 구현합니다.


    def ensemble_predict(self, text):
        outputs = self.predict(text)
        # 예측 결과 평균 계산
        summed_outputs = torch.mean(torch.stack(outputs), dim=0)
        return summed_outputs
    

5. 모델 학습 및 평가

앙상블 모델을 학습하고 평가하는 과정에 대해 설명하겠습니다. 데이터셋을 준비하고, 각 모델을 Fine-tune 한 뒤, 앙상블 모델의 성능을 평가합니다.


def fine_tune_model(model, train_dataloader, num_epochs=3):
    model.train()
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
    
    for epoch in range(num_epochs):
        for batch in train_dataloader:
            optimizer.zero_grad()
            outputs = model(batch['input_ids'], attention_mask=batch['attention_mask'], labels=batch['labels'])
            loss = outputs.loss
            loss.backward()
            optimizer.step()
            print(f'Epoch {epoch+1}, Loss: {loss.item()}')
    

6. 결론

이번 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 BERT 모델을 앙상블하는 방법에 대해 알아보았습니다. BERT의 효율성과 앙상블 학습의 조합을 통해 자연어 처리 태스크에서 더 향상된 성능을 기대할 수 있습니다. 실제 데이터셋에 맞춰 Fine-tuning을 수행하고, 이 과정을 통해 얻어진 인사이트를 바탕으로 나만의 모델을 구축해 보시기 바랍니다.

7. 참고 문헌

  • Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding.
  • Hugging Face. (n.d.). Transformers Documentation. Retrieved from Hugging Face Documentation

8. 추가 리소스

앙상블 학습에 대한 추가적인 예제와 자료를 얻기 위해, 다양한 온라인 커뮤니티나 학술 자료들을 참고하시길 추천드립니다. 특히 Kaggle 대회와 같은 실제 문제에 적용해보는 것도 좋은 학습 방법입니다.

허깅페이스 트렌스포머 활용강좌, BERT 사전학습 모델을 파이프라인에 불러오기

1. 서론

최근 인공지능 및 자연어 처리(NLP) 분야에서는 BERT(Bidirectional Encoder Representations from Transformers) 모델이 중요한 역할을 하고 있습니다. BERT는 구글에서 개발한 트랜스포머 기반의 사전학습 모델로, 다양한 NLP 과제에서 최첨단 성능을 보여주고 있습니다. 본 강좌에서는 파이썬과 허깅페이스(Hugging Face) Transformers 라이브러리를 사용해 BERT 모델을 쉽게 활용하는 방법에 대해 알아보겠습니다.

2. 허깅페이스 트랜스포머 라이브러리 설치

먼저, 허깅페이스 트랜스포머 라이브러리를 설치해야 합니다. 파이썬 패키지 관리자인 pip을 사용하여 설치할 수 있습니다.

pip install transformers

3. BERT 모델 이해하기

BERT는 입력 문장의 양 방향 문맥을 이해하여 더 나은 자연어 이해를 가능하게 합니다. 즉, 문장을 왼쪽에서 오른쪽으로, 또는 오른쪽에서 왼쪽으로 읽을 수 있어 문맥 정보를 더 풍부하게 고려할 수 있습니다.

4. BERT 사전학습 모델 불러오기

허깅페이스 라이브러리를 사용하여 BERT 모델을 불러오는 과정은 매우 간단합니다. 다음은 BERT 모델을 불러오기 위한 기본 코드입니다.


from transformers import BertTokenizer, BertForMaskedLM
import torch

# BERT 모델과 토크나이저 불러오기
model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForMaskedLM.from_pretrained(model_name)

# 예제 문장
text = "Hello, my name is [MASK]."
inputs = tokenizer(text, return_tensors="pt")

# 예측
with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits
    predicted_index = torch.argmax(predictions, dim=-1)
    predicted_token = tokenizer.decode(predicted_index[0, inputs['input_ids'].tolist().index(tokenizer.mask_token_id)])

print(f"예측된 단어: {predicted_token}")
    

4.1 코드 설명

위 코드는 다음과 같은 과정으로 이루어져 있습니다:

  • BertTokenizer: 주어진 텍스트를 BERT 모델에서 사용할 수 있는 텐서 형태로 변환합니다.
  • BertForMaskedLM: BERT 모델을 불러옵니다. 이 모델은 언어 모델링, 특히 마스킹된 언어 모델링에 적합합니다.
  • inputs: 입력 문장을 인코딩하여 텐서 형태로 변환합니다.
  • outputs: 모델에 입력을 전달하여 예측 logits을 생성합니다.
  • predicted_index: 가장 높은 확률을 가진 토큰의 인덱스를 추출합니다.
  • 최종 예측 단어: 인덱스를 사용하여 실제 단어로 변환합니다.

5. BERT를 활용한 텍스트 분류

BERT 모델은 텍스트 분류 작업에도 쉽게 적용할 수 있습니다. 아래의 코드는 BERT를 활용하여 주어진 텍스트의 감성을 분석하는 간단한 예제를 보여줍니다.


from transformers import BertTokenizer, BertForSequenceClassification

# 감정 분류 모델 불러오기
model_name = 'nlptown/bert-base-multilingual-uncased-sentiment'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)

# 예제 문장
sentence = "I love using Hugging Face Transformers!"
inputs = tokenizer(sentence, return_tensors="pt")

# 예측
with torch.no_grad():
    outputs = model(**inputs)
    logits = outputs.logits
    predicted_class = torch.argmax(logits, dim=-1)

print(f"예측된 감정 클래스: {predicted_class.item()}")
    

5.1 텍스트 분류 코드 설명

위의 코드는 감정 분류를 수행하며, 다음과 같은 과정을 따릅니다:

  • nlptown/bert-base-multilingual-uncased-sentiment 모델을 불러와 다국적 감정 분류 작업을 수행합니다.
  • 입력된 문장을 토크나이저를 사용하여 텐서 형태로 변환합니다.
  • 모델에 입력을 주어 logits을 계산합니다.
  • logits에서 가장 높은 값의 클래스를 선택하여 예측된 감정 클래스를 출력합니다.

6. 요약

BERT 모델을 통해 자연어 처리 분야에서 다양한 작업을 수행할 수 있음을 알 수 있습니다. 허깅페이스 라이브러리를 사용하면 이러한 모델을 쉽게 활용할 수 있으며, 실험을 통해 그 성능을 더욱 개선할 수 있습니다. 차후에는 파인튜닝(fine-tuning)이나 다른 작업으로의 확장도 고려해볼 수 있습니다.

7. 참고 문헌

  • Devlin, J. et al. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding.
  • Hugging Face Transformers Documentation. 링크

허깅페이스 트렌스포머 활용강좌, BERT 벡터 차원, 단어 토크나이징 및 디코딩

딥러닝에 있어 자연어 처리는 매우 중요한 분야이며, 허깅페이스의 트랜스포머 라이브러리는 이러한 작업을 보다 용이하게 수행할 수 있도록 도와줍니다. 이 글에서는 BERT(Bidirectional Encoder Representations from Transformers) 모델을 중심으로, 벡터 차원, 단어 토크나이징 및 디코딩에 대해 자세히 알아보겠습니다.

BERT 모델 개요

BERT는 Google에서 개발한 사전 훈련된 언어 모델로, 주어진 텍스트의 문맥을 이해하는 데 탁월한 성능을 보입니다. BERT는 두 가지 주요 작업, 즉 언어 모델링(Language Modeling)다음 문장 예측(Next Sentence Prediction)을 통해 훈련됩니다. 이러한 훈련 덕분에 BERT는 다양한 자연어 처리 작업에 매우 효과적으로 활용될 수 있습니다.

BERT 벡터 차원

BERT의 입력 벡터는 텍스트의 각 토큰(token)을 고유한 벡터 표현으로 변환합니다. 이러한 벡터는 주로 768 차원으로 구성되어 있으며, 이는 BERT의 기본 모델인 BERT-Base에 해당합니다. 모델의 크기에 따라 벡터 차원이 달라질 수 있습니다. BERT-Large는 1024 차원의 벡터를 사용합니다. 각 차원은 특정한 의미를 가지며, 단어 간의 문맥적 관계를 표현합니다.

파이썬 예제 코드: BERT 벡터 차원 확인하기

python
from transformers import BertTokenizer, BertModel
import torch

# BERT 토크나이저 및 모델 불러오기
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

# 입력 텍스트
text = "Hello, this is a test sentence."

# 텍스트를 토크나이즈하고 텐서로 변환
inputs = tokenizer(text, return_tensors='pt')

# BERT 모델에 입력하여 벡터 차원 얻기
with torch.no_grad():
    outputs = model(**inputs)

# 마지막 은닉 상태
last_hidden_state = outputs.last_hidden_state

# 벡터 차원 확인
print("벡터 차원:", last_hidden_state.shape)

위의 코드는 BERT 모델과 토크나이저를 이용하여 입력된 문장의 벡터 차원을 확인하는 예제입니다. `last_hidden_state`의 shape을 통해 각 토큰의 벡터 차원이 768임을 확인할 수 있습니다.

단어 토크나이징

단어 토크나이징은 문장을 유의미한 단위로 분할하는 과정으로, BERT 모델에 입력하기 전에 필수적으로 수행해야 합니다. 허깅페이스의 트랜스포머 라이브러리는 다양한 토크나이저를 제공하며, BERT에 적합한 토크나이저도 포함되어 있습니다.

토크나이징 예제

python
# 입력 텍스트
text = "I love studying machine learning."

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

위의 예제는 “I love studying machine learning.” 이라는 문장을 토크나이징하여 각 단어를 토큰으로 변환하는 방법을 보여줍니다. BERT 토크나이저는 일반적인 단어 구분뿐만 아니라, 서브워드(subword) 단위로도 처리하여 오타나 새로운 단어에 대해 유연하게 대응할 수 있습니다.

디코딩

디코딩 과정은 토크나이징의 반대 과정으로, 토큰화된 결과를 다시 원래의 문장으로 변환하는 작업입니다. 이를 통해 모델의 출력을 사람이 이해할 수 있는 형태로 변환할 수 있습니다.

디코딩 예제

python
# 토큰을 ID로 변환
token_ids = tokenizer.convert_tokens_to_ids(tokens)

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

위의 예제는 주어진 토큰을 ID로 변환한 후, 이를 디코딩하여 원래의 문장으로 되돌리는 과정을 보여줍니다. 디코딩 함수는 주어진 ID로부터 인간이 이해할 수 있는 언어로 변환하는 데 사용됩니다.

결론

본 강좌에서는 허깅페이스의 BERT를 활용한 기본적인 벡터 차원 이해, 단어 토크나이징 및 디코딩 기법에 대해 알아보았습니다. BERT는 다양한 자연어 처리 작업에 매우 유용하게 적용될 수 있으며, 허깅페이스 라이브러리를 통해 손쉽게 사용할 수 있습니다. 앞으로도 더욱 심화된 주제를 다루며, 여러분의 딥러닝 실력을 한층 더 발전시킬 수 있기를 바랍니다.

허깅페이스 트렌스포머 활용강좌, BERT 분류 파인튜닝

딥러닝의 발전과 함께 자연어 처리(NLP) 분야에서도 많은 혁신이 이루어졌습니다. 특히, 허깅페이스(Hugging Face)의 트랜스포머(Transformers) 라이브러리는 여러 강력한 사전 훈련(pre-trained) 모델을 제공하며, 연구자나 개발자가 손쉽게 자연어 처리 모델을 활용할 수 있게 해주고 있습니다. 이 강좌에서는 BERT(Bidirectional Encoder Representations from Transformers) 모델을 사용하여 텍스트 분류 작업을 수행하는 방법을 자세하게 설명하겠습니다.

1. BERT란 무엇인가?

BERT는 Google에서 발표한 자연어 처리 모델로, ‘양방향'(Bidirectional)이라는 특징이 있습니다. 이는 텍스트의 컨텍스트를 이해하는 데 매우 강력한 기능을 제공합니다. BERT는 텍스트 데이터를 처리할 때, 단어의 위치에 관계없이 문맥을 이해하기 때문에 전통적인 단어 임베딩 기법보다 우수한 성능을 보입니다.

2. 허깅페이스 Transformers 라이브러리 소개

허깅페이스의 Transformers 라이브러리는 BERT를 포함한 다양한 트랜스포머 모델을 손쉽게 사용할 수 있는 파이썬 라이브러리입니다. 현재 NLP 분야에서 널리 사용되고 있으며, 사전 훈련된 모델을 불러와서 파인튜닝(fine-tuning)하여 특정 작업에 맞게 효율적으로 사용할 수 있습니다.

2.1 설치하기

허깅페이스 Transformers 라이브러리를 설치하기 위해 아래의 pip 명령어를 사용합니다:

pip install transformers

3. BERT로 텍스트 분류하기

이번 강좌에서는 IMDB 영화 리뷰 데이터셋을 사용하여 영화 리뷰가 긍정적인지 부정적인지를 분류하는 모델을 구현합니다. 데이터셋은 다음과 같은 형태로 되어 있습니다:

  • 텍스트: 영화 리뷰
  • 레이블: 긍정(1) 또는 부정(0)

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"
# 데이터를 로드하고 전처리
# 여기에 데이터 로딩 및 전처리 코드가 옵니다. (간단한 예시입니다)
data = pd.read_csv("imdb_reviews.csv")
data['label'] = data['sentiment'].apply(lambda x: 1 if x == 'positive' else 0)

train_texts, val_texts, train_labels, val_labels = train_test_split(data['review'], data['label'], test_size=0.2)
    

3.2 BERT Tokenization

텍스트 데이터를 BERT 모델에 맞게 변환하기 위해 토크나이저(tokenizer)를 사용합니다. 토크나이저는 텍스트를 분할하여 모델 입력 형식으로 변환하는 역할을 합니다.


from transformers import BertTokenizer

# BERT 토크나이저 초기화
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# BERT 입력 형태로 변환하는 함수
def encode(texts):
    return tokenizer(texts.tolist(), padding=True, truncation=True, return_tensors='pt')

train_encodings = encode(train_texts)
val_encodings = encode(val_texts)
    

3.3 데이터셋 만들기

토크나이저가 변환한 인코딩을 파이토치 텐서로 변환하여 데이터셋을 만듭니다.


import torch

class IMDbDataset(torch.utils.data.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.values)
val_dataset = IMDbDataset(val_encodings, val_labels.values)
    

4. BERT 모델 정의하기

이제 Hugging Face의 Transforms 라이브러리에서 제공하는 BERT 모델을 불러와서 분류 작업을 위한 파인튜닝을 진행합니다.


from transformers import BertForSequenceClassification

# BERT 모델 불러오기
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
    

5. 모델 훈련하기

모델을 훈련하기 위해 Trainer API를 사용할 수 있습니다. 이 API는 훈련 루프를 자동으로 처리하므로 매우 편리합니다.


from transformers import Trainer, TrainingArguments

# 훈련 환경 설정
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
)

# 훈련 시작
trainer.train()
    

6. 모델 평가하기

훈련된 모델을 평가하여 성능을 확인합니다.


trainer.evaluate()
    

결론

본 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 BERT 모델을 사용한 텍스트 분류 작업을 수행하는 방법을 배웠습니다. BERT는 다양한 자연어 처리 작업에서 우수한 성능을 발휘하며, 사전 훈련된 모델을 활용하면 적은 데이터만으로도 좋은 결과를 낼 수 있습니다. 앞으로 여러분이 다양한 NLP 프로젝트에서 BERT를 활용하길 바랍니다.

참고 자료