허깅페이스 트렌스포머 활용강좌, BERT 앙상블 파인튜닝

최근 몇 년간, 딥러닝 분야에서 자연어 처리(NLP)는 급격한 발전을 이루었으며, 그 중 가장 큰 선두주자 중 하나는 바로 BERT입니다. BERT(Bidirectional Encoder Representations from Transformers)는 구글에서 발표한 모델로, 문맥을 양 방향으로 이해할 수 있는 능력을 가지고 있습니다. 이 강좌에서는BERT 모델에 대해 자세히 알아보고, 여러 BERT 모델들을 앙상블하여 성능을 향상시키는 방법과 함께 허깅페이스(Hugging Face) 트랜스포머 라이브러리를 활용하여 파인튜닝하는 과정을 설명하겠습니다.

1. BERT란?

BERT는 ‘Bidirectional Encoder Representations from Transformers’의 약자로, 문맥을 이해하는 데 매우 강력한 능력을 지닌 사전 학습된 모델입니다. 전통적인 NLP 모델들은 일반적으로 한 방향으로만 문맥을 이해했지만, BERT는 Transformer 아키텍처를 기반으로 양 방향에서 문맥 정보를 동시에 수집할 수 있습니다. 이를 통해 단어의 의미를 문맥에 맞게 뽑아내는 데에 가능성을 제공합니다.

1.1. BERT의 특징

  • 양방향성: BERT는 입력 텍스트의 양쪽 문맥을 동시에 고려합니다.
  • 사전 학습(pre-trained): 대규모 코퍼스를 사용하여 사전 학습 완료 후, 특정 작업에 맞게 파인튜닝할 수 있습니다.
  • 층 구조: 다수의 Transformer 레이어로 구성되어 있어 복잡한 문맥을 효과적으로 처리합니다.

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

허깅페이스는 BERT를 비롯한 다양한 사전 학습된 NLP 모델들을 쉽게 사용할 수 있게 해주는 라이브러리입니다. 이 라이브러리를 사용하면, 복잡한 구현 없이도 다양한 NLP 태스크를 수행할 수 있습니다. Hugging Face Transformers 라이브러리는 단순한 인터페이스와 함께 직관적인 API를 제공하여 학습 및 파인튜닝을 쉽게 할 수 있도록 돕습니다.

2.1. 설치하는 방법

!pip install transformers

3. BERT 앙상블 기법

앙상블 기법이란 여러 개의 모델을 결합하여 더 나은 성능을 얻는 방법입니다. BERT 모델을 앙상블하는 이유는 모델 간의 다양성이 있어 오버피팅을 방지하고, 일반화 성능을 향상시킬 수 있기 때문입니다. 앙상블 기법을 활용하면 BERT 모델의 강점을 보다 효과적으로 극대화할 수 있습니다.

3.1. 앙상블 방법론

전략은 다양하지만, 가장 일반적으로 사용되는 방법 중 두 가지는 하드 보팅소프트 보팅입니다.

  • 하드 보팅: 각 모델이 예측한 클래스 라벨 중 가장 많이 선택된 라벨을 결과로 채택합니다.
  • 소프트 보팅: 각 모델이 예측한 클래스 확률의 평균을 내어, 가장 높은 확률의 클래스를 결과로 채택합니다.

4. BERT 파인튜닝

이제 BERT 모델을 파인튜닝하는 방법에 대해 알아보겠습니다. 다음 단계에 따라 BERT 모델을 설정하고, 앙상블하는 방법을 진행하겠습니다.

4.1. 데이터셋 준비

먼저, 사용할 데이터셋을 준비합니다. 아래의 예제에서는 IMDB 영화 리뷰 데이터를 사용할 것입니다. 이 데이터는 긍정/부정 리뷰로 구분됩니다.

4.1.1. 데이터셋 로딩


import pandas as pd
from sklearn.model_selection import train_test_split

# IMDB 데이터셋 로드
data = pd.read_csv('imdb_reviews.csv')
train_data, test_data = train_test_split(data, test_size=0.2)
        

4.2. BERT 모델 로딩

이제 허깅페이스 트랜스포머 라이브러리를 사용하여 BERT 모델을 로드하겠습니다.


from transformers import BertTokenizer, BertForSequenceClassification

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

4.3. 데이터 전처리

BERT 모델에 입력하기 위해 데이터를 전처리해야 합니다. 텍스트를 토크나이즈하고, 입력 IDs와 어텐션 마스크를 생성합니다.


def preprocess_data(data):
    inputs = tokenizer(data['text'].tolist(), padding=True, truncation=True, return_tensors="pt", max_length=512)
    labels = torch.tensor(data['label'].tolist())
    return inputs, labels

train_inputs, train_labels = preprocess_data(train_data)
test_inputs, test_labels = preprocess_data(test_data)
        

4.4. 모델 학습

모델을 학습하기 위해 PyTorch의 DataLoader를 사용하고, Adam 옵티마이저를 설정합니다.


from torch.utils.data import DataLoader, TensorDataset
from transformers import AdamW

train_dataset = TensorDataset(train_inputs['input_ids'], train_inputs['attention_mask'], train_labels)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
optimizer = AdamW(model.parameters(), lr=1e-5)

# 모델 학습
model.train()
for epoch in range(3):
    for batch in train_loader:
        optimizer.zero_grad()
        input_ids, attention_mask, labels = batch
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        print(f'Epoch: {epoch}, Loss: {loss.item()}')
        

4.5. 평가 및 앙상블

학습한 모델을 평가하고, 다른 BERT 모델도 동일한 방식으로 학습하여 앙상블을 진행합니다. 각 모델의 예측 결과를 수집하고, 하드 or 소프트 보팅을 통해 최종 예측을 합니다.


# 모델 평가 및 앙상블
def evaluate_and_ensemble(models, dataloader):
    ensemble_preds = []
    for model in models:
        model.eval()
        preds = []
        for batch in dataloader:
            input_ids, attention_mask = batch
            with torch.no_grad():
                outputs = model(input_ids, attention_mask=attention_mask)
            preds.append(torch.argmax(outputs.logits, dim=1))
        ensemble_preds.append(torch.cat(preds, dim=0))
    
    # 하드 보팅
    final_preds = torch.mode(torch.stack(ensemble_preds), dim=0)[0]
    return final_preds

final_predictions = evaluate_and_ensemble([model], test_loader)
        

5. 결론

이번 강좌에서는 허깅페이스 트랜스포머 라이브러리를 활용하여 BERT 모델을 앙상블하여 성능을 높이는 방법에 대해 알아보았습니다. BERT의 강력한 언어 이해 능력을 바탕으로, 적절한 데이터 전처리와 앙상블 기법을 통해 NLP 태스크에서 높은 성능을 달성할 수 있음을 보여주었습니다. 향후 이 기법을 통해 다양한 자연어 처리 문제를 해결해 나갈 수 있기를 기대합니다.

6. 참고 자료

허깅페이스 트렌스포머 활용강좌, 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 분류 파인튜닝

딥러닝의 발전과 함께 자연어 처리(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를 활용하길 바랍니다.

참고 자료