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

딥러닝과 자연어 처리(NLP)는 현대의 인공지능 기술에서 중요한 역할을 하고 있습니다. 그 중에서도 BERT(Bidirectional Encoder Representations from Transformers)는 구글이 개발한 강력한 언어 모델로, 많은 NLP 작업에서 뛰어난 성능을 보여주고 있습니다. 이번 강좌에서는 허깅페이스의 트렌스포머 라이브러리를 활용하여 BERT 모델을 파인튜닝하고, 텍스트 분류 작업을 수행하는 방법에 대해 자세히 알아보겠습니다.

1. 허깅페이스와 BERT 소개

허깅페이스(Hugging Face)는 자연어 처리 모델을 쉽게 사용할 수 있도록 다양한 모델과 툴을 제공하는 라이브러리입니다. 특히, BERT와 같은 트렌스포머 기반의 모델을 간편하게 사용할 수 있도록 해줍니다. BERT 모델은 문맥의 양쪽 정보를 동시에 고려하여 더 깊이 있는 이해를 가능하게 합니다. 이는 전통적인 RNN이나 LSTM 기반 모델들보다 더 우수한 성능을 발휘할 수 있는 이유입니다.

2. BERT 모델의 기본 구조

BERT는 인코더 – 디코더 구조의 트렌스포머 모델로, 주로 인코더 부분이 사용됩니다. BERT의 주요 특징은 다음과 같습니다:

  • 양방향 Attention: BERT는 양방향 문맥을 학습할 수 있어 특정 단어의 의미를 더 풍부하게 이해합니다.
  • Masked Language Model: 학습 중 일부 단어를 마스킹하고, 모델은 마스킹된 단어를 예측하도록 훈련됩니다.
  • Next Sentence Prediction: 두 문장이 주어졌을 때, 두 문장이 실제로 연속적인 문장인지 여부를 예측합니다.

3. Hugging Face Transformers 설치

먼저, 허깅페이스의 트렌스포머 라이브러리를 설치해야 합니다. 이를 위해서는 다음과 같은 명령어를 사용하여 설치할 수 있습니다:

pip install transformers

4. 데이터셋 준비하기

딥러닝 모델을 훈련시키기 위해서는 적절한 데이터셋이 필요합니다. 본 강좌에서는 간단한 텍스트 분류 작업을 위해 IMDB 영화 리뷰 데이터셋을 사용하겠습니다. 이 데이터셋은 긍정적인 리뷰와 부정적인 리뷰로 구성되어 있습니다.


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}
!tar -xvf aclImdb_v1.tar.gz

# 긍정 및 부정 리뷰 로드
pos_reviews = pd.read_csv('aclImdb/train/pos/*.txt', delimiter="\n", header=None)
neg_reviews = pd.read_csv('aclImdb/train/neg/*.txt', delimiter="\n", header=None)

# 데이터 준비
positive = [(1, review) for review in pos_reviews[0]]
negative = [(0, review) for review in neg_reviews[0]]

data = positive + negative
df = pd.DataFrame(data, columns=['label', 'review'])
df['label'] = df['label'].map({0: 'negative', 1: 'positive'})

# 훈련 데이터와 테스트 데이터로 분리
train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)
    

5. 데이터 전처리

BERT 모델을 사용하기 위해서는 데이터를 적절한 형식으로 전처리해야 합니다. 허깅페이스의 트렌스포머 라이브러리에서 제공하는 BERT 토크나이저를 사용하겠습니다.


from transformers import BertTokenizer

# BertTokenizer 로드
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# 데이터 토큰화
def tokenize_data(data):
    return tokenizer(data['review'].tolist(), padding=True, truncation=True, return_tensors='pt')

train_encodings = tokenize_data(train_df)
test_encodings = tokenize_data(test_df)
    

6. 데이터셋 생성

토큰화된 데이터를 Dataset 클래스를 사용해 PyTorch Dataset으로 변환합니다.


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'] = self.labels[idx]
        return item

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

train_dataset = IMDbDataset(train_encodings, train_df['label'].tolist())
test_dataset = IMDbDataset(test_encodings, test_df['label'].tolist())
    

7. 모델 설정 및 파인튜닝

이제 BERT 모델을 로드하고, 분류 작업을 위해 파인튜닝을 진행하겠습니다.


from transformers import BertForSequenceClassification, Trainer, TrainingArguments

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

# 훈련 인자 설정
training_args = TrainingArguments(
    output_dir='./results',
    evaluation_strategy='epoch',
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    num_train_epochs=3,
    weight_decay=0.01,
)

# 트레이너 객체 생성
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset,
)
    
# 모델 훈련
trainer.train()
    

8. 평가 및 예측

모델 훈련 후, 테스트 데이터셋을 이용하여 모델 성능을 평가하고 예측해 보겠습니다.


# 모델 평가
trainer.evaluate()

# 예측
predictions = trainer.predict(test_dataset)
predicted_labels = predictions.predictions.argmax(-1)
    

9. 결과 해석

모델이 예측한 라벨을 원본 라벨과 비교하여 정확도를 계산하고, 수정할 부분이 있는지 분석합니다. Confusion Matrix를 통해서 더욱 자세한 결과를 시각화할 수도 있습니다.


from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

confusion_mtx = confusion_matrix(test_df['label'].tolist(), predicted_labels)
plt.figure(figsize=(10,7))
sns.heatmap(confusion_mtx, annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()
    

10. 결론

이번 강좌에서는 허깅페이스 트렌스포머 라이브러리를 활용하여 BERT 모델을 파인튜닝하고 텍스트 분류 작업을 수행하는 방법을 살펴보았습니다. BERT와 같은 사전 훈련된 모델을 사용하는 것은 시간과 자원을 절약할 뿐만 아니라 성능도 크게 향상시킬 수 있습니다. 앞으로도 다양한 NLP 작업에서 BERT와 같은 모델을 활용하여 더 나은 성능을 달성할 수 있기를 바랍니다.

참고사항

  • 허깅페이스 트렌스포머 공식 문서: 링크
  • BERT 원 논문: 링크

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

본 강좌에서는 딥러닝 및 자연어 처리 분야에서 널리 사용되는 BERT 모델을 활용하여 파인튜닝 없이 분류 작업을 수행하는 방법에 대해 알아보겠습니다. BERT(Bidirectional Encoder Representations from Transformers)는 문맥을 이해하는 데 있어 혁신적인 모델로, 구글에 의해 개발되었습니다. 본 강좌는 허깅페이스(Hugging Face) 라이브러리를 활용하여 BERT 모델을 간편하게 사용할 수 있는 방법에 중점을 둡니다.

1. 허깅페이스 트랜스포머란?

허깅페이스 트랜스포머 라이브러리는 다양한 사전 학습된 NLP 모델을 제공하는 파이썬 라이브러리입니다. 이 라이브러리를 사용하면 BERT, GPT-2, T5 등 여러 자연어 처리 모델을 손쉽게 사용할 수 있습니다. 또한 전이 학습을 통해 특정 작업에 맞게 모델을 조정할 수도 있습니다.

2. BERT의 기본 개념

BERT는 Bidirectional Encoder Representations from Transformers의 약자로, 양방향의 문맥 정보를 활용할 수 있는 특징이 있습니다. 전통적인 RNN이나 LSTM과 달리, BERT는 Transformer 구조를 기반으로 하여, 입력 데이터의 모든 단어를 동시에 고려하여 문맥을 이해합니다.

3. 파인튜닝 없이 BERT 분류하기

일반적으로 BERT 모델은 특정 작업에 맞게 파인튜닝하는 것이 일반적입니다. 하지만 우리는 파인튜닝 없이도 BERT 모델을 활용하여 텍스트 분류 작업을 수행할 수 있습니다. 다음은 파인튜닝 없이 BERT 모델을 사용하는 방법에 대한 단계별 설명입니다.

3.1 라이브러리 설치

먼저 필요한 라이브러리를 설치해야 합니다. 아래 명령어를 사용하여 허깅페이스의 트랜스포머와 토크나이저 라이브러리를 설치합니다.

!pip install transformers torch

3.2 데이터 준비

다음으로 사용할 데이터를 준비합니다. 예를 들어, 긍정적 문장과 부정적 문장을 구분하는 데이터셋을 사용할 수 있습니다. 아래는 간단한 예시입니다.

data = [
        {"text": "이 영화는 정말 재미있었어요.", "label": "positive"},
        {"text": "최악의 영화입니다.", "label": "negative"},
        {"text": "정말 훌륭한 연기였습니다.", "label": "positive"},
        {"text": "이건 시간 낭비입니다.", "label": "negative"},
    ]

3.3 BERT 모델과 토크나이저 불러오기

허깅페이스 라이브러리를 사용하여 사전 학습된 BERT 모델과 토크나이저를 불러올 수 있습니다. 아래의 코드를 사용하여 불러옵니다.

from transformers import BertTokenizer, BertModel
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

3.4 텍스트 데이터 전처리

이제 데이터에서 텍스트를 토큰화하고 입력 텐서를 만들기 위한 전처리를 수행해야 합니다. BERT 모델의 입력 형식에 맞게 데이터를 변환합니다.

inputs = tokenizer([d['text'] for d in data], padding=True, truncation=True, return_tensors="pt")
labels = [d['label'] for d in data]

3.5 모델 출력 추출

BERT 모델을 통해 각 텍스트의 출력 벡터를 생성할 수 있습니다. 이 벡터는 다음 단계에서 분류 작업에 사용됩니다.

with torch.no_grad():
    outputs = model(**inputs)
    embeddings = outputs.last_hidden_state[:, 0, :].numpy()  # CLS 토큰 사용

3.6 텍스트 분류기 구현

이제 모델의 출력인 임베딩을 사용하여 간단한 분류기를 구축할 수 있습니다. 예를 들어, 로지스틱 회귀를 사용할 수 있습니다.

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 임베딩과 레이블을 벡터화
X = embeddings
y = [1 if label == "positive" else 0 for label in labels]

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 로지스틱 회귀 모델 학습
classifier = LogisticRegression()
classifier.fit(X_train, y_train)

# 예측
y_pred = classifier.predict(X_test)

# 정확도 평가
accuracy = accuracy_score(y_test, y_pred)
print(f"모델 정확도: {accuracy:.2f}")  # 모델의 정확도를 출력합니다.

4. 결론

본 강좌에서는 허깅페이스 트랜스포머 라이브러리를 활용하여 파인튜닝 없이 BERT 모델을 사용하는 방법에 대해 배웠습니다. BERT의 사전 학습된 임베딩을 활용하여 간단한 분류 작업을 수행할 수 있음을 확인하였고, 이를 통해 자연어 처리의 기초를 다질 수 있었습니다. 자연어 처리가 필요한 다양한 응용 분야에서 BERT 모델이 유용하게 사용될 수 있음을 알 수 있습니다.

5. 참고자료

허깅페이스 트렌스포머 활용강좌, 파인튜닝 BERT 모델 학습 과정 시각화

딥러닝의 발전과 함께 자연어 처리(NLP) 분야에서도 많은 혁신이 이루어지고 있습니다. 특히, BERT(Bidirectional Encoder Representations from Transformers) 모델은 그 성능과 효율성 덕분에 많은 인기를 끌게 되었습니다. 이번 글에서는 허깅페이스(Hugging Face) 라이브러리를 통해 BERT 모델을 파인튜닝하고 그 과정과 결과를 시각화하는 방법을 상세히 다루어 보겠습니다.

1. BERT 모델 개요

BERT는 Google에서 개발한 사전 학습된 텍스트 표현 모델로, Bidirectional Attention Mechanism을 사용하여 단어의 문맥을 양방향에서 이해합니다. BERT는 두 가지 주요 작업, 즉 마스킹된 언어 모델링(Masked Language Modeling)과 다음 문장 예측(Next Sentence Prediction)을 통해 사전 학습됩니다. 이런 과정을 통해 BERT는 자연어 이해 및 생성 작업에 매우 높은 성능을 보이게 됩니다.

2. 환경 설정

BERT 모델을 파인튜닝하기 위해서는 먼저 필요한 패키지를 설치해야 합니다. 아래의 코드를 통해 Hugging Face의 Transformers과 기타 필요한 라이브러리를 설치합니다.

!pip install transformers torch datasets matplotlib seaborn

3. 데이터셋 준비

이번 예제에서는 IMDB 영화 리뷰 데이터셋을 사용하여 영화 리뷰가 긍정적인지 부정적인지를 분류하는 이진 분류 문제를 다룰 것입니다. Hugging Face의 datasets 라이브러리를 사용하여 손쉽게 데이터를 불러올 수 있습니다.

from datasets import load_dataset

dataset = load_dataset('imdb')
train_dataset = dataset['train']
test_dataset = dataset['test']

4. 데이터 전처리

BERT 모델에 입력하기 위해서는 텍스트 토큰화가 필요합니다. Hugging Face의 Tokenizer를 사용해 데이터를 준비합니다. BERT는 최대 입력 길이가 512로 제한되므로 이 점을 유의해야 합니다.

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

def tokenize_function(examples):
    return tokenizer(examples['text'], padding='max_length', truncation=True)

tokenized_train = train_dataset.map(tokenize_function, batched=True)
tokenized_test = test_dataset.map(tokenize_function, batched=True)

5. 데이터 로더 설정

데이터를 로딩하고 배치로 나누는 과정입니다. 파이토치의 DataLoader를 사용하여 훈련 및 검증에 필요한 배치를 구성합니다.

import torch

train_loader = torch.utils.data.DataLoader(tokenized_train, batch_size=16, shuffle=True)
test_loader = torch.utils.data.DataLoader(tokenized_test, batch_size=16)

6. 모델 설정

이제 BERT 모델을 설정하고 이를 파인튜닝할 준비를 합니다. Hugging Face에서는 간단하게 BERT 모델을 불러올 수 있습니다.

from transformers import BertForSequenceClassification

model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

7. 학습 준비

파인튜닝을 위한 손실 함수와 최적화 알고리즘을 설정합니다. BERT는 기본적으로 CrossEntropyLoss를 사용하여 분류 문제를 해결합니다.

from transformers import AdamW

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

8. 모델 학습

이제 모델 학습을 진행합니다. 각 에포크에서 훈련 데이터와 검증 데이터를 통해 모델을 학습시키고 성능을 평가합니다. 에포크 수, 손실 값, 정확도 등을 기록하여 모니터링합니다.

from tqdm import tqdm

model.train()
for epoch in range(3):
    for batch in tqdm(train_loader):
        optimizer.zero_grad()
        input_ids = batch['input_ids'].to(model.device)
        attention_mask = batch['attention_mask'].to(model.device)
        labels = batch['label'].to(model.device)

        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        print(f"Epoch {epoch}, Loss: {loss.item()}")

9. 성능 평가

학습이 완료된 후, 테스트 데이터를 통해 모델의 성능을 평가합니다. 정확도, 정밀도, 재현율 등의 메트릭을 사용하여 모델을 평가합니다.

from sklearn.metrics import accuracy_score

model.eval()
predictions, true_labels = [], []
with torch.no_grad():
    for batch in test_loader:
        input_ids = batch['input_ids'].to(model.device)
        attention_mask = batch['attention_mask'].to(model.device)
        
        outputs = model(input_ids, attention_mask=attention_mask)
        preds = torch.argmax(outputs.logits, dim=-1)
        
        predictions.extend(preds.cpu().numpy())
        true_labels.extend(batch['label'].numpy())

accuracy = accuracy_score(true_labels, predictions)
print(f'Accuracy: {accuracy}') 

10. 학습 과정 시각화

모델의 학습 과정과 성능을 시각화하는 것은 모델을 이해하고 튜닝하는 데에 매우 중요합니다. 토치비전(TorchVision)과 매트플롯립(Matplotlib)을 사용하여 학습 손실을 그래프로 시각화합니다.

import matplotlib.pyplot as plt

def plot_loss(losses):
    plt.plot(losses, label='Training Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.title('Training Loss Over Epochs')
    plt.legend()
    plt.show()

losses = [...]  # 각 에포크의 손실을 기록
plot_loss(losses)

결론

이번 글에서는 허깅페이스 라이브러리를 활용하여 BERT 모델을 파인튜닝하는 전 과정을 살펴보았습니다. 데이터셋 준비, 모델 설정, 학습 과정, 성능 평가 그리고 시각화까지 다양한 과정을 통해 BERT 모델의 파인튜닝을 효과적으로 진행할 수 있음을 보여주었습니다.

딥러닝 모델의 성공적인 구현에는 적절한 데이터 전처리, 하이퍼파라미터 튜닝, 그리고 결과 분석이 필수적입니다. BERT와 같은 사전 훈련된 모델을 통해 자연어 처리 문제를 효율적으로 해결할 수 있음을 잊지 마세요.

허깅페이스 트렌스포머 활용강좌, 파이토치 사전학습

딥러닝의 발전과 함께 자연어 처리(NLP) 분야에서도 큰 혁신이 일어나고 있습니다. 그 중에서도 허깅페이스(Hugging Face)에서 제공하는 트렌스포머(Transformers) 라이브러리는 사전학습(pre-trained)된 언어 모델들을 손쉽게 활용할 수 있도록 도와줍니다. 본 글에서는 허깅페이스 트렌스포머의 기본 개념과 사용 방법에 대해 소개하고, 파이토치(PyTorch) 기반의 사전학습된 모델을 활용하는 방법에 대해 자세히 설명하겠습니다.

1. 허깅페이스 트렌스포머 라이브러리란?

허깅페이스 트렌스포머 라이브러리는 다양한 자연어 처리 태스크를 위한 사전학습된 모델들을 포함하고 있습니다. 이러한 모델들은 예를 들어 번역, 텍스트 분류, 요약, 질문 응답 등과 같은 다양한 NLP 작업을 수행할 수 있도록 훈련되어 있습니다. 트렌스포머 아키텍처는 셀프 어텐션(self-attention) 메커니즘을 통해 입력 시퀀스의 각 단어의 중요도를 계산하여 문맥을 이해하는 데 탁월한 성능을 보여줍니다.

1.1 설치하기

허깅페이스 트렌스포머 라이브러리를 설치하기 위해서는 먼저 파이썬 환경을 설정해야 합니다. 아래의 명령어를 통해 설치할 수 있습니다.

pip install transformers torch

2. 사전학습 모델 이해하기

사전학습된 모델은 대규모 데이터셋으로 훈련되어 특정 태스크에 대한 성능을 높이기 위해 미세조정(fine-tuning)할 수 있습니다. 예를 들어 BERT, GPT-2, RoBERTa 등과 같은 모델들이 있습니다. 이러한 모델들은 기본적인 언어 이해를 위해 설계되었으며, 다양한 데이터셋에 대해 사전학습을 거쳤습니다.

2.1 BERT 모델

BERT(Bidirectional Encoder Representations from Transformers) 모델은 양 방향성 시퀀스 인코더로, 문맥을 반영하여 단어의 의미를 파악합니다. 수많은 자연어 처리 태스크에서 뛰어난 성능을 보이는 이 모델은 문장 내 단어들을 둘러싼 문맥을 동시에 이해할 수 있는 능력을 가지고 있습니다.

2.2 GPT-2 모델

GPT-2(Generative Pre-trained Transformer 2)는 주로 텍스트 생성 작업에 사용되는 모델로, 순차적인 데이터 처리를 통해 문맥을 이해하고 생성하는 데 강점을 보입니다. 이 모델은 특정 주제나 스타일의 문서를 생성하는 데 널리 활용됩니다.

3. 파이토치(PyTorch)와 함께 사용하는 방법

파이토치는 딥러닝 모델을 구성하고 학습하는 데 매우 유용한 프레임워크입니다. 허깅페이스의 트렌스포머 라이브러리는 파이토치와 함께 사용할 수 있도록 설계되어 있어, 모델을 쉽게 로드하고 활용할 수 있습니다.

3.1 텍스트 분류 예제

이번 섹션에서는 BERT 모델을 사용하여 간단한 텍스트 분류 작업을 수행하는 예제를 보여드리겠습니다. Text Classification을 위해 IMDB 영화 리뷰 데이터셋을 사용할 예정입니다.

3.1.1 데이터셋 준비

먼저 IMDB 데이터셋을 다운로드하고 사전처리합니다. 이를 위해 pandas 라이브러리를 사용할 것입니다.

import pandas as pd

# IMDB 영화 리뷰 데이터 다운로드
url = "https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz"
imdb_data = pd.read_csv(url)

# 데이터 전처리
df = pd.DataFrame(imdb_data)
df['label'] = df['label'].map({'pos': 1, 'neg': 0})
df.head()

3.1.2 데이터셋 로드와 분리

데이터셋을 로드한 후 학습 데이터와 검증 데이터를 분리합니다.

from sklearn.model_selection import train_test_split

# train/test split
train_data, test_data = train_test_split(df, test_size=0.2, random_state=42)

# 분리된 데이터 확인
print(f'훈련 데이터 크기: {len(train_data)}, 테스트 데이터 크기: {len(test_data)}')

3.1.3 허깅페이스 데이터셋 설정

이제 Hugging Face의 Dataset 클래스를 사용하여 데이터를 불러오겠습니다.

from transformers import Dataset

# Hugging Face Dataset 형식으로 변환
train_dataset = Dataset.from_pandas(train_data)
test_dataset = Dataset.from_pandas(test_data)

3.1.4 모델 로드하기

사전학습된 BERT 모델을 불러옵니다. 이러한 모델들은 AutoModelForSequenceClassification 클래스를 통해 호출할 수 있습니다.

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 사전학습된 BERT 모델과 토크나이저 로드
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

3.1.5 데이터 전처리

텍스트 데이터를 BERT 모델이 처리할 수 있는 입력 형식으로 변환합니다.

def preprocess_function(examples):
    return tokenizer(examples['text'], truncation=True, padding='max_length', max_length=512)

tokenized_train_data = train_dataset.map(preprocess_function, batched=True)
tokenized_test_data = test_dataset.map(preprocess_function, batched=True)

3.1.6 모델 학습하기

모델을 학습시키기 위해 Trainer 클래스를 사용합니다.

from transformers import Trainer, TrainingArguments

# 훈련 인자 설정
training_args = TrainingArguments(
    output_dir='./results',
    evaluation_strategy='epoch',
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train_data,
    eval_dataset=tokenized_test_data
)

# 모델 훈련
trainer.train()

3.1.7 모델 평가하기

훈련된 모델의 성능을 평가합니다.

4. 결론

허깅페이스 트렌스포머 라이브러리를 활용하면, 사전학습된 모델을 손쉽게 다룰 수 있습니다. BERT와 같은 모델은 텍스트 분류 외에도 다양한 자연어 처리 작업에 활용될 수 있으며, 연구 및 산업에서 중요한 역할을 하고 있습니다. 본 블로그에서는 모델의 설치부터 학습, 평가까지의 과정을 함께 살펴보았습니다. 실무에 적용할 수 있는 유용한 지식을 습득하셨기를 바랍니다.

5. 참고자료

허깅페이스 트렌스포머 활용강좌, 토크나이징 및 인코딩

딥러닝과 자연어 처리는 최근 몇 년 동안 급격히 발전했으며, 이 과정에서 허깅페이스(Hugging Face) 트랜스포머 라이브러리는 인기 있는 도구 중 하나가 되었습니다. 이 강좌에서는 허깅페이스 트랜스포머 라이브러리를 사용하여 토크나이징(Tokenizing)과 인코딩(Encoding)의 개념을 심도 있게 설명하고, 이를 파이썬 코드로 구현하는 방법을 알아보겠습니다.

1. 트랜스포머 모델이란?

트랜스포머 모델은 Attention 메커니즘을 기반으로 한 딥러닝 모델로, 언어 처리 작업에서 높은 성능을 보입니다. 2017년 “Attention is All You Need”라는 논문에서 처음 소개되었습니다. 이 모델은 입력 시퀀스의 모든 단어를 한 번에 고려하여 컨텍스트 정보를 효과적으로 포착합니다.

2. 허깅페이스와 그 기초

허깅페이스는 많은 사전 훈련된 트랜스포머 모델들을 무료로 제공하는 플랫폼입니다. 이를 통해 연구자와 개발자는 다양한 NLP 작업(예: 질문 답변, 텍스트 생성, 감정 분석)을 간편하게 수행할 수 있습니다. 허깅페이스의 transformers 라이브러리를 사용하면 복잡한 NLP 작업을 쉽게 처리할 수 있습니다.

3. 토크나이징(Tokenizing)

토크나이징은 텍스트를 개별적인 단위(토큰)로 나누는 과정입니다. 예를 들어, 문장을 단어로 나누거나, 단어를 서브워드(subword)로 나누는 것입니다. 이 과정은 모델이 이해할 수 있는 형태로 데이터를 변환하는 데 필수적입니다.

3.1 왜 토크나이징이 중요한가?

트랜스포머 모델은 입력 텍스트를 고정된 길이의 토큰 시퀀스로 변환해야 합니다. 잘 구현된 토크나이저는 입력 데이터를 더 잘 처리하고 모델의 성능을 향상시킬 수 있습니다.

3.2 허깅페이스의 토크나이저 사용하기

허깅페이스 트랜스포머 라이브러리에는 여러 종류의 토크나이저가 포함되어 있습니다. 이들은 각 모델에 최적화되어 있으며, 예를 들어 BERT, GPT-2, T5 모델에 사용될 토크나이저가 다릅니다.

예제: BERT 모델의 토크나이징

from transformers import BertTokenizer

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

# 텍스트 입력
text = "허깅페이스 트랜스포머를 활용한 NLP 강좌에 오신 것을 환영합니다!"

# 텍스트 토크나이징
tokens = tokenizer.tokenize(text)
print(tokens)

위 코드를 실행하면 입력된 텍스트가 각 토큰으로 분리된 결과를 확인할 수 있습니다. 그러나 이 또한 모델에 맞는 형태로 변환하는 과정이 필요합니다.

4. 인코딩(Encoding)

토크나이징 후, 우리는 토큰을 모델에 입력할 수 있는 숫자 형태로 변환해야 합니다. 이 과정을 인코딩이라고 하며, 일반적으로 각 단어의 인덱스를 사용하여 토큰을 숫자로 변환합니다.

예제: BERT 모델의 인코딩

# 텍스트 인코딩
encoded_input = tokenizer.encode(text, return_tensors='pt')
print(encoded_input)

여기서 return_tensors='pt'는 PyTorch 텐서를 반환하라는 의미입니다. 이는 딥러닝 모델에 직접 입력할 수 있는 형형태입니다.

5. 통합 예제: 텍스트 분류를 위한 데이터 전처리

이제까지 배운 토크나이징과 인코딩 과정을 하나의 예제로 통합해 보겠습니다. 여기서는 간단한 텍스트 분류 모델을 위해 데이터를 전처리하는 과정을 살펴보겠습니다.

5.1 데이터 준비

우선 간단한 텍스트 분류를 위한 데이터를 준비해야 합니다. 텍스트와 해당 레이블을 포함한 리스트를 생성하겠습니다.

texts = [
    "나는 허깅페이스가 너무 좋다.",
    "딥러닝은 어렵지만 흥미롭다.",
    "AI 기술은 우리의 삶을 변화시키고 있다.",
    "트랜스포머 모델은 정말 강력하다.",
    "이것은 고양이에 대한 텍스트이다."
]
labels = [1, 1, 1, 1, 0]  # 1: 긍정, 0: 부정

5.2 데이터 토크나이징 및 인코딩

다음으로 데이터를 토크나이징하고 인코딩하는 코드를 작성하겠습니다. 이를 위해 루프를 사용하여 각 텍스트에 대해 토크나이징 및 인코딩을 수행합니다.

# 모든 데이터를 처리하기 위한 빈 리스트 초기화
encoded_texts = []

# 각 텍스트에 대해 토크나이징 및 인코딩 수행
for text in texts:
    encoded_text = tokenizer.encode(text, return_tensors='pt')
    encoded_texts.append(encoded_text)

print(encoded_texts)

5.3 모델에 입력하기

이제 인코딩된 텍스트를 모델에 입력하여 예측 작업을 수행할 수 있습니다. 예를 들어 텍스트 분류 모델은 다음과 같이 사용할 수 있습니다.

from transformers import BertForSequenceClassification
import torch

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

# 모델을 평가 모드로 전환
model.eval()

# 각 인코딩된 텍스트에 대해 예측 수행
for encoded_text in encoded_texts:
    with torch.no_grad():
        outputs = model(encoded_text)
        predictions = torch.argmax(outputs.logits, dim=-1)
        print(f"예측 레이블: {predictions.item()}")

위 코드에서 우리는 각각의 인코딩된 텍스트에 대해 예측을 수행하여 해당 텍스트의 레이블을 예측합니다. 이러한 방식으로 우리는 딥러닝 모델을 사용하여 새로운 텍스트의 카테고리를 분류할 수 있습니다.

6. 결론

이 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 사용하여 토크나이징과 인코딩의 중요성에 대해 배웠습니다. 또한, 이를 통해 간단한 텍스트 분류 모델을 구현해 보았습니다. 허깅페이스는 다양한 사전 훈련된 모델과 함께 강력한 API를 제공하여 NLP 작업을 쉽게 수행할 수 있게 해줍니다. 앞으로도 딥러닝 및 자연어 처리 분야에 대한 학습을 계속 이어가길 바랍니다!

7. 참고자료