허깅페이스 트렌스포머 활용강좌, Mobile BERT 라이브러리 설치 및 사전학습 모델 불러오기

딥러닝 분야에서 자연어 처리(NLP)는 매우 중요한 역할을 합니다. 특히 BERT(Bidirectional Encoder Representations from Transformers) 모델은 NLP 분야에서 널리 사용되고 있습니다.
이번 강좌에서는 허깅페이스(Hugging Face)의 트랜스포머 라이브러리를 사용하여 Mobile BERT 모델을 설치하고, 사전 학습된 모델을 불러오는 방법을 설명하겠습니다.
Mobile BERT는 경량화된 BERT 모델로, 모바일 기기에서도 효율적으로 사용할 수 있다는 장점이 있습니다.

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

허깅페이스 트랜스포머 라이브러리는 다양한 최신 NLP 모델을 손쉽게 사용할 수 있도록 도와주는 파이썬 라이브러리입니다.
이 라이브러리를 통해 BERT, GPT-2, T5 등 다양한 사전 학습 모델을 불러오고, 여러 NLP 태스크에 적용할 수 있습니다. 또한, 사용자 맞춤형 훈련을 위한 API를 제공합니다.

2. Mobile BERT 이해하기

Mobile BERT는 Google이 개발한 경량화된 BERT 모델입니다. 전통적인 BERT 모델은 대규모 데이터셋에서 사전 학습되어 강력한 성능을 보이지만,
그만큼 모델의 크기가 커서 모바일 기기나 임베디드 시스템에서 사용하는 데 제약이 있습니다.
이에 반해 Mobile BERT는 크기를 줄이고도 BERT의 성능을 최대한 유지하도록 설계되었습니다. 이러한 특성 덕분에 Mobile BERT는 여러 NLP 태스크에 활용되고 있습니다.

3. 환경 설정 및 라이브러리 설치

Mobile BERT를 사용하기 위해서는 먼저 허깅페이스 트랜스포머 라이브러리와 기타 필수 라이브러리를 설치해야 합니다.
다음 명령어를 통해 pip를 이용해 필요한 라이브러리를 설치할 수 있습니다:

pip install transformers torch

위 명령어로 설치가 완료되면, Python 환경에서 Mobile BERT를 사용할 준비가 완료됩니다.

참고: PyTorch를 설치하지 않았다면 설치해야 합니다. CUDA를 지원하는 GPU를 사용하는 경우,
공식 웹사이트에서 CUDA에 맞는 PyTorch 버전을 선택하여 설치하세요.

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

이제 Mobile BERT 모델을 불러와보겠습니다. 허깅페이스 트랜스포머 라이브러리에서는 미리 학습된 모델을 손쉽게 사용할 수 있도록
하기 위해 몇 가지 클래스를 제공합니다.

4.1 코드 예제

다음 코드를 통해 Mobile BERT를 불러옵니다:

from transformers import MobileBertTokenizer, MobileBertForSequenceClassification
import torch

# Mobile BERT 모델과 토크나이저 불러오기
model_name = "google/mobilebert-uncased"
tokenizer = MobileBertTokenizer.from_pretrained(model_name)
model = MobileBertForSequenceClassification.from_pretrained(model_name)

# 테스트할 문장
input_text = "허깅페이스 트랜스포머 매우 유용해요!"

# 입력 문장을 토크나이즈하고 텐서로 변환
inputs = tokenizer(input_text, return_tensors="pt")

# 모델에 입력하고 예측하기
with torch.no_grad():
    logits = model(**inputs).logits

predicted_class = torch.argmax(logits, dim=-1).item()
print(f"예측된 클래스: {predicted_class}")

4.2 코드 설명

코드의 각 요소를 살펴보면 다음과 같습니다:

  • from transformers import MobileBertTokenizer, MobileBertForSequenceClassification:
    Mobile BERT 모델과 토크나이저를 불러옵니다.
  • model_name = "google/mobilebert-uncased": 사용할 사전 학습 모델의 이름을 설정합니다.
  • tokenizer = MobileBertTokenizer.from_pretrained(model_name): 모델에 대한 토크나이저를 초기화합니다.
  • model = MobileBertForSequenceClassification.from_pretrained(model_name): 모델을 초기화합니다.
    이 때 해당 모델은 문장 분류 작업에 적합합니다.
  • inputs = tokenizer(input_text, return_tensors="pt"): 입력된 문장을 토크나이즈하고 PyTorch 텐서로 변환합니다.
  • with torch.no_grad():: 텐서의 변화도 추적하지 않도록 설정하여 메모리 효율성을 높입니다.
  • logits = model(**inputs).logits: 모델을 통해 예측한 결과를 가져옵니다.
  • predicted_class = torch.argmax(logits, dim=-1).item(): 예측된 클래스 중 가장 높은 확률을 가진 클래스를 선택합니다.

5. Mobile BERT를 활용한 실제 예제

Mobile BERT 모델을 활용하여 문장 분류 작업을 수행하는 예제를 살펴보겠습니다.
접근 방식은 주어진 문장을 긍정적이거나 부정적인지 분류하는 것입니다.

5.1 데이터셋 준비

우선 신뢰성 있는 데이터를 준비해야 합니다. 예를 들어, 영화 리뷰 데이터셋은 긍정적/부정적 리뷰로 나뉘어 있습니다.
이를 사용하여 모델을 학습시킬 수 있습니다. 데이터를 로드하고 전처리를 수행하는 코드를 작성해보겠습니다.

import pandas as pd

# 샘플 데이터로드 (긍정 리뷰 5개, 부정 리뷰 5개)
data = {
    "text": [
        "나는 이 영화를 정말 좋아한다.", 
        "최고의 영화다!", 
        "정말 감동적이었다.", 
        "완벽한 명작이다.", 
        "이 영화는 내 마음을 울렸다.",
        "이것은 시간 낭비이다.", 
        "나쁘고 지루하다.", 
        "정말 실망스러웠다.", 
        "절대 보지 마라.", 
        "이 영화는 최악이다."
    ],
    "label": [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
}

df = pd.DataFrame(data)
print(df.head())

5.2 모델 학습

이제 데이터를 모델에 학습시키기 위한 과정입니다. 간단한 훈련 루프를 작성하여 모델을 학습시킬 수 있습니다.
그러나 여기서는 훈련 과정에 대한 보다 깊은 내용을 다루지 않고, 주어진 데이터로 간단한 전이 학습을 진행해보겠습니다.

from torch.utils.data import DataLoader, Dataset

class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer

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

    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]
        encoding = self.tokenizer(text, return_tensors='pt', padding='max_length', truncation=True, max_length=128)
        return {'input_ids': encoding['input_ids'].flatten(), 'attention_mask': encoding['attention_mask'].flatten(), 'label': torch.tensor(label, dtype=torch.long)}

dataset = CustomDataset(df['text'].values, df['label'].values, tokenizer)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

# 단순 훈련 루프
for epoch in range(3):
    for batch in dataloader:
        model.train()
        outputs = model(input_ids=batch['input_ids'], attention_mask=batch['attention_mask'], labels=batch['label'])
        loss = outputs.loss
        loss.backward()
        # Optimizer Step 등은 생략
        print(f"Epoch {epoch + 1}, Loss: {loss.item()}")

5.3 예측 및 평가

모델이 학습된 후, 새로운 문장에 대해 예측을 수행할 수 있습니다. 다음 예제를 통해 이를 확인해보겠습니다:

test_text = "이 영화는 아주 좋습니다."
test_inputs = tokenizer(test_text, return_tensors="pt")

with torch.no_grad():
    test_logits = model(**test_inputs).logits

test_predicted_class = torch.argmax(test_logits, dim=-1).item()
print(f"테스트 문장 '{test_text}'에 대한 예측 클래스: {test_predicted_class}")

6. 마무리

이번 강좌에서는 허깅페이스 트랜스포머 라이브러리를 사용하여 Mobile BERT 모델을 설치하고, 사전 학습된 모델을 불러와
문장 분류 작업을 수행하는 방법에 대해 살펴보았습니다. Mobile BERT는 가벼운 모델이기 때문에 모바일 환경이나 리소스가 제한된 환경에서도 유용하게 활용될 수 있습니다.
다양한 NLP 태스크에 대한 적용 가능성을 더 연구해보는 것을 권장합니다.

이 강좌가 도움이 되었다면, 주변에 공유해주세요! 추가적인 자료나 질문이 있으시면 언제든지 댓글로 남겨주세요.

허깅페이스 트렌스포머 활용강좌, Mobile BERT vs BERT Tokenizer

서론

딥러닝과 자연어 처리(NLP) 분야에서 최근 몇 년 간 가장 주목받는 기술 중 하나는 BERT(Bidirectional Encoder Representations from Transformers) 입니다. BERT는 문맥을 이해하는 데 탁월한 성능을 보여주며, 이는 다양한 NLP 작업에 활용되고 있습니다. 그러나 BERT는 크기가 크고 연산 비용이 많이 들어, 모바일 환경에서는 사용이 어렵습니다. 이러한 문제를 해결하기 위해 Mobile BERT가 등장하였습니다. 이번 강좌에서는 허깅페이스의 Transformers 라이브러리를 활용하여 BERT와 Mobile BERT의 특징을 비교하고, 두 모델의 Tokenizer를 사용해보겠습니다.

1. BERT 모델 소개

BERT는 2018년 구글에서 발표한 언어 표현 모델로, 사전 훈련된 언어 표현을 학습하여 다양한 NLP 작업을 수행할 수 있게 돕습니다. BERT는 Transformer’s encoder 구조를 기반으로 하며, Bidirectional 방식으로 문맥을 이해할 수 있습니다. 일반적인 NLP 작업으로는 감정 분석, 질문 답변 시스템, 문장 유사도 계산 등이 있습니다.

1.1 BERT의 특징

  • Bidirectional Attention: 문맥을 양 방향으로 이해합니다.
  • Masked Language Modeling: 입력 문장에서 일부 단어를 마스크하고, 이를 예측하는 방식으로 학습합니다.
  • Next Sentence Prediction: 두 문장이 연속적인 관계에 있는지를 예측합니다.

2. Mobile BERT 모델 소개

Mobile BERT는 BERT의 경량화 버전으로, 모바일 기기에서 효율적으로 사용할 수 있도록 설계되었습니다. Mobile BERT는 BERT의 파라미터 수를 대폭 줄였으나, 성능은 유지합니다. 이를 통해 모바일 기기에서도 자연어 처리 작업을 원활하게 수행할 수 있습니다.

2.1 Mobile BERT의 특징

  • 작은 모델 크기: Mobile BERT는 BERT보다 훨씬 작은 모델입니다.
  • 높은 처리 속도: 경량화된 구조 덕분에 모바일 환경에서도 빠르게 동작합니다.
  • 효율적인 메모리 사용: 적은 자원으로도 높은 성능을 발휘할 수 있도록 최적화되었습니다.

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

허깅페이스(Transformers)는 다양한 사전 훈련된 NLP 모델을 쉽게 사용할 수 있도록 도와주는 Python 라이브러리입니다. 이 라이브러리는 BERT, Mobile BERT, GPT-2 등 다양한 모델을 제공합니다. 또한, 모델의 Tokenizer도 함께 제공하여 텍스트를 손쉽게 전처리할 수 있도록 돕습니다.

3.1 설치 방법

pip install transformers torch

4. Mobile BERT vs BERT Tokenizer 사용 예제

이제 BERT와 Mobile BERT의 Tokenizer 사용법에 대해 살펴보겠습니다. 아래의 코드는 두 모델의 Tokenizer를 설치하고, 입력 텍스트에 대해 각각 토크나이징을 수행하는 예제입니다.

from transformers import BertTokenizer, MobileBertTokenizer

# BERT Tokenizer 초기화
bert_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")

# Mobile BERT Tokenizer 초기화
mobile_bert_tokenizer = MobileBertTokenizer.from_pretrained("google/mobilebert-uncased")

# 입력 텍스트
text = "딥러닝은 매우 흥미로운 분야입니다."

# BERT Tokenization
bert_tokens = bert_tokenizer.tokenize(text)
print("BERT Tokens:", bert_tokens)

# Mobile BERT Tokenization
mobile_bert_tokens = mobile_bert_tokenizer.tokenize(text)
print("Mobile BERT Tokens:", mobile_bert_tokens)

4.1 코드 설명

위의 예제에서, transformers 라이브러리에서 제공하는 BertTokenizerMobileBertTokenizer를 통해 두 개의 Tokenizer를 초기화하였습니다. 입력 텍스트를 tokenize 메소드를 사용해 토크나이즈한 뒤, 결과를 출력합니다. BERT와 Mobile BERT의 토큰화 결과를 비교할 수 있습니다.

5. 비교 분석

BERT와 Mobile BERT의 Tokenizer를 사용한 결과, 두 모델의 토큰화 결과를 비교하고, 각 모델의 특성을 분석해보겠습니다. 사용한 입력 문장은 “딥러닝은 매우 흥미로운 분야입니다.” 입니다.

# BERT Tokenization 결과
BERT Tokens: ['deep', '##learning', '은', '매우', '흥미로운', '분야', '입니다', '.']

# Mobile BERT Tokenization 결과
Mobile BERT Tokens: ['딥러닝', '은', '매우', '흥미로운', '분야', '입니다', '.']

5.1 분석

BERT Tokenizer는 한 단어를 여러 개의 서브워드로 분할하는 반면, Mobile BERT Tokenizer는 입력된 문장을 단어 단위로 잘게 쪼개지 않고 유지합니다. 이는 Mobile BERT가 모바일 환경에서 보다 효율적으로 작동할 수 있도록 최적화 되어 있기 때문입니다.

6. 고급 활용

Tokenization과 모델 로딩 외에도, 허깅페이스 라이브러리를 통해 BERT 및 Mobile BERT 모델을 활용한 다양한 고급 작업들을 진행할 수 있습니다. 예를 들어, 감정 분석 모델을 구축하거나, 특정 태스크에 대한 Fine-tuning을 수행할 수 있습니다.

6.1 모델 파인튜닝

모델 파인튜닝은 특정 데이터셋에 대해 사전 훈련된 모델을 재훈련하는 과정입니다. 아래의 코드는 BERT 모델을 파인튜닝하기 위한 기본적인 방법을 보여줍니다.

from transformers import BertForSequenceClassification, Trainer, TrainingArguments
import torch
from torch.utils.data import Dataset, DataLoader

# 예시 데이터셋 클래스
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer

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

    def __getitem__(self, idx):
        input_encoding = self.tokenizer(self.texts[idx], truncation=True, padding='max_length', max_length=512, return_tensors='pt')
        item = {key: val[0] for key, val in input_encoding.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

# 모델 초기화
model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)

# 데이터셋 및 DataLoader 생성
train_texts = ["이 영화는 좋았어요.", "이 영화는 별로였어요."]
train_labels = [1, 0]  # 감정 레이블 1: 긍정, 0: 부정
train_dataset = CustomDataset(train_texts, train_labels, bert_tokenizer)
train_loader = DataLoader(train_dataset, batch_size=2)

# TrainingArguments 설정
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=2,
    logging_dir='./logs',
)

# Trainer 객체 생성
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
)

# 모델 훈련
trainer.train()

6.2 코드 설명

코드에서는 CustomDataset 클래스를 정의하여 입력 데이터를 다루며, BERT 모델을 로드한 후 Trainer 객체를 통해 훈련을 시작합니다. 이 방법을 통해 BERT 모델을 특정 태스크에 맞게 조정할 수 있습니다.

7. 결론

이번 강좌에서는 허깅페이스의 Transformers 라이브러리를 사용하여 BERT와 Mobile BERT의 Tokenizer를 비교하고, 이를 기반으로 모델 훈련의 기본 과정을 살펴보았습니다. BERT는 성능이 뛰어나지만 고사양의 하드웨어를 요구하는 반면, Mobile BERT는 경량화된 모델로써 모바일 환경에서도 자연어 처리를 가능하게 합니다. 앞으로 더 다양한 실습과 연구를 통해 딥러닝과 자연어 처리 분야에서 성과를 이뤄나가기를 기대합니다.

참고 문헌

  • Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2018). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding.
  • Sun, C., Qiu, X., Xu, Y., & Huang, X. (2019). MobileBERT: Transformer-based Model for Resource-bound Devices.

허깅페이스 트렌스포머 활용강좌, M2M100 한국어 텍스트 토크나이징

딥러닝의 급속한 발전과 함께 자연어 처리(NLP) 분야는 놀라운 변화의 중간에 있습니다. 특히, 최근에는 다양한 사전 훈련된 모델을 제공하는 허깅페이스(Hugging Face) 라이브러리가 주목받고 있습니다. 오늘은 그중에서도 M2M100 모델을 사용하여 한국어 텍스트를 토크나이징하는 방법을 소개하겠습니다.

1. M2M100 모델 소개

M2M100은 Facebook AI에서 개발한 모델로, 다국어 번역을 위한 사전 훈련된 변압기(Transformer) 모델입니다. 이 모델은 100개 이상의 언어를 지원하며, 다양한 언어 간의 번역을 위해 설계되었습니다. M2M100은 특히 문장 수준에서의 번역 성능이 뛰어나며, 한국어와 같은 저분량 언어에서도 유용하게 활용할 수 있습니다.

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

모델을 사용하기 위해서는 먼저 허깅페이스 트랜스포머 라이브러리를 설치해야 합니다. 이는 pip를 통해 간단하게 설치할 수 있습니다.

pip install transformers

3. 토크나이저(Tokenization)란?

토크나이징은 입력 문장을 개별 단위(토큰)로 나누는 과정입니다. 자연어 처리 모델은 텍스트를 직접 처리할 수 없기 때문에, 텍스트를 숫자로 변환하여 모델에 입력할 수 있어야 합니다. 이러한 작업을 수행하는 것이 바로 ‘토크나이징’입니다.

4. M2M100의 토크나이저 사용하기

이제 M2M100 모델을 사용하여 한국어 텍스트를 토크나이징하는 방법을 살펴보겠습니다. 아래의 코드를 실행하여 토크나이저를 로드하고, 예시 한국어 문장을 토크나이징해 보겠습니다.

from transformers import M2M100Tokenizer

# M2M100 토크나이저 로드
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")

# 한국어 텍스트 입력
text = "안녕하세요! 딥러닝을 배우고 있습니다."

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

# 토큰화 결과 출력
print("토크나이징 결과:", tokens)

4.1 코드 설명

위 코드는 M2M100Tokenizer 클래스를 사용하여 M2M100 모델을 위한 토크나이저를 로드하고 있습니다. 다음으로, 한국어 문장을 입력하여 tokenizer.tokenize() 메서드를 호출함으로써 해당 문장을 토큰화합니다.

5. 토크나이징 출력 결과 해석

토크나이징의 출력 결과는 모델이 이해할 수 있도록 변환된 토큰 리스트입니다. 예를 들어, 한국어 문장 “안녕하세요! 딥러닝을 배우고 있습니다.”의 경우, 토크나이징 후에도 각 단어의 의미를 잘 보존하면서 모델에 입력할 수 있는 형식으로 변환됩니다.

5.1 예시 출력

예상된 출력:
토크나이징 결과: ['안녕', '##하', '##세', '##요', '!', '딥', '##러', '##닝', '을', '배', '##우', '고', '있', '##습', '##니', '##다', '.']

출력된 결과를 보면, 입력된 문장이 여러 개의 토큰으로 나누어졌음을 확인할 수 있습니다. ‘안녕하세요’는 두 개의 토큰으로 나누어졌으며, 각각의 형태소에 해당하는 ‘안녕’, ‘하세’로 구분되었습니다.

6. 추가 옵션: 토크나이저의 다양한 기능

토크나이저는 단순한 토크나이징뿐만 아니라, 특별한 기호나 위치 정보를 처리하는 기능도 제공합니다. 몇 가지 추가 기능을 살펴보겠습니다.

6.1 패딩(Padding)

모델에 입력할 텍스트의 길이를 동일하게 맞추기 위해 패딩을 추가할 수 있습니다. 아래의 코드를 참고하십시오.

# 여러 개의 문장 준비
texts = ["안녕하세요! 딥러닝을 배우고 있습니다.", "이번 강좌는 허깅페이스를 활용합니다."]

# 문장을 토크나이징하고 패딩
encoded_inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")

print("패딩된 입력:", encoded_inputs)

6.2 디코딩(Decoding)

토크나이징된 결과를 다시 원래의 텍스트로 변환하는 기능도 있습니다. 이를 통해 모델의 출력을 쉽게 확인할 수 있습니다.

# 토크나이징된 텍스트 디코딩
input_ids = encoded_inputs['input_ids'][0]
decoded_text = tokenizer.decode(input_ids)

print("디코딩된 텍스트:", decoded_text)

7. 마무리

본 강좌에서는 Hugging Face의 M2M100 모델을 활용하여 한국어 텍스트를 효과적으로 토크나이징하는 방법을 소개했습니다. M2M100 모델은 다양한 언어 간의 번역 성능이 뛰어나며, 한국어와 같은 저분량의 언어에서도 우수한 성능을 보입니다. 이를 통해 자연어 처리 애플리케이션에서 효율적으로 모델을 활용할 수 있을 것입니다.

8. 참고 자료

딥러닝과 자연어 처리 분야의 발전에 함께하시길 바랍니다. 감사합니다!

허깅페이스 트렌스포머 활용강좌, M2M100 한국어 영어 자동 번역

본 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 M2M100 모델을 사용해 한국어와 영어 간의 자동 번역 작업을 수행하는 방법에 대해 자세히 설명합니다. M2M100은 다국어 번역을 지원하는 모델로, 100개 이상의 언어 간의 상호 번역을 지원합니다. 이 글에서는 M2M100의 개요, 설치 방법, 데이터 준비, 모델 로드 및 예측을 수행하는 과정을 단계별로 설명합니다.

1. M2M100 모델 개요

M2M100 (Multilingual to Multilingual) 모델은 Facebook AI Research에서 개발한 다국어 기계 번역 모델로, 100개 이상의 언어로 서로 번역할 수 있는 기능을 제공합니다. M2M100의 가장 큰 장점은 다음과 같습니다:

  • 다국어 지원: 영어, 한국어, 중국어, 프랑스어 등 다양한 언어 간의 번역 가능
  • 다양한 언어 쌍: 사전 훈련된 네트워크를 통해 상호 번역을 지원
  • 사용 용이성: 허깅페이스의 트랜스포머 라이브러리를 통해 쉽게 구현 및 사용 가능

2. 환경 설정 및 설치

M2M100 모델을 사용하기 위해 필요한 라이브러리와 패키지를 설치하는 방법입니다. 다음 단계를 따라 환경을 설정합니다.

pip install transformers torch

위 명령어를 통해 허깅페이스의 트랜스포머 라이브러리와 PyTorch를 설치합니다. 여기서는 PyTorch를 기본으로 사용하겠습니다. 설치가 완료되면 다음 코드로 M2M100 모델을 사용할 준비가 완료되었습니다.

3. M2M100 모델 로드

M2M100 모델을 로드하기 위해 다음과 같은 코드 snippets를 작성합니다.


from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer

# 모델과 토크나이저 로드
model_name = "facebook/m2m100_418M"
tokenizer = M2M100Tokenizer.from_pretrained(model_name)
model = M2M100ForConditionalGeneration.from_pretrained(model_name)
    

위 코드는 필요한 모델과 토크나이저를 허깅페이스의 허브에서 로드합니다.

4. 데이터 준비

번역할 문장을 준비합니다. 예를 들어, 영어 문장을 한국어로 번역하거나 한국어 문장을 영어로 번역하는 경우를 고려할 수 있습니다. 아래 코드는 번역할 문장을 준비하는 예시입니다.


# 번역할 문장
text_to_translate = "딥러닝은 인공지능의 한 분야로, 컴퓨터가 데이터를 통해 학습하도록 하는 기술입니다."
    

이제 이 문장을 M2M100 모델을 통해 번역해보겠습니다.

5. 번역 수행

모델아에게 입력된 문장을 기반으로 번역을 수행합니다. 모델의 입력을 준비한 후, 토큰화를 수행하고 모델을 통해 예측을 진행하는 과정입니다.


# 토큰화
tokenized_input = tokenizer(text_to_translate, return_tensors="pt", padding=True)

# 번역 수행
with torch.no_grad():
    generated_ids = model.generate(
        tokenized_input['input_ids'], 
        forced_bos_token_id=tokenizer.get_lang_id('ko') # 한국어로 번역
    )

# 디코딩
translated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
print(f"번역 결과: {translated_text}")
    

위 코드를 실행하면 다음과 같은 결과를 확인할 수 있습니다.

6. 번역 결과 확인

번역 결과는 모델이 생성한 한국어 문장입니다. M2M100 모델의 성능은 번역할 문장에 따라 다소 차이가 있을 수 있지만, 전반적으로 높은 품질의 번역을 제공하는 편입니다.

7. 여러 문장 번역하기

M2M100 모델을 사용하여 여러 문장을 동시에 번역하는 것은 매우 간편합니다. 다음과 같이 여러 개의 문장을 준비한 다음 반복문을 통해 번역하면 됩니다.


# 여러 문장 번역
sentences_to_translate = [
    "AI는 21세기 최고의 기술 중 하나로 자리잡고 있습니다.",
    "트랜스포머 아키텍처는 자연어 처리의 혁신을 가져왔습니다."
]

for sentence in sentences_to_translate:
    input_ids = tokenizer(sentence, return_tensors="pt", padding=True)['input_ids']
    with torch.no_grad():
        output_ids = model.generate(input_ids, forced_bos_token_id=tokenizer.get_lang_id('ko'))
    translated_sentence = tokenizer.decode(output_ids[0], skip_special_tokens=True)
    print(f"{sentence} -> {translated_sentence}")
    

이러한 방식으로 여러 문장을 손쉽게 번역할 수 있습니다.

8. 성능 평가

자동 번역의 성능을 평가하는 방법에는 BleU score, METEOR score 등이 있습니다. 이러한 평가 방법을 사용하여 모델의 번역 품질을 정량적으로 평가할 수 있습니다. 현재까지는 자연어 처리 분야에서의 일반적인 평가 방법에 대해 논의해 보겠습니다.

9. 마무리

본 강좌에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 M2M100 모델을 통한 자동 번역을 수행하는 방법에 대해 다뤘습니다. 딥러닝 모델을 효율적으로 활용하여 다양한 자연어 처리 응용 프로그램을 구축할 수 있습니다. 앞으로도 다양한 딥러닝 모델과 기술을 통해 더욱 발전할 수 있기를 기대합니다.

참고 자료

허깅페이스 트렌스포머 활용강좌, M2M100 중국어 영어 자동 변역

최근 인공지능의 발달로 자연어 처리 분야에서도 많은 발전이 이루어지고 있습니다. 그중에서도
허깅페이스(Hugging Face)트랜스포머(Transformers) 라이브러리는
다양한 언어 모델을 손쉽게 사용할 수 있도록 돕는 도구로 자리 잡았습니다. 본 강좌에서는 허깅페이스를
활용하여 M2M100 모델을 사용해 중국어와 영어 간의 자동 번역을 구현하는 방법에 대해
자세히 설명하고자 합니다.

1. M2M100 모델 소개

M2M100은 다국어 번역을 위한 모델로, 여러 언어 간의 직접 변환을 지원합니다. 이 모델은 ‘다양한
언어’를 포함하여 다국어를 다루는 능력이 뛰어납니다. M2M100은 100개 이상의 언어를 지원하며,
기존의 번역 시스템과 달리 중간 언어를 거치지 않고 직접 번역을 수행할 수 있는 장점이 있습니다.

2. 설치 및 설정

M2M100 모델을 사용하기 위해 우선 허깅페이스 트랜스포머 라이브러리와 관련 종속성을
설치해야 합니다. 아래와 같이 pip 명령어를 사용하여 설치할 수 있습니다.

pip install transformers torch

3. 모델 로드 및 번역 함수 구현

모델을 사용하기 위해서는 먼저 M2M100 모델을 로드해야 합니다. 다음 코드는 모델과 토크나이저를
로드하고, 번역을 수행하는 간단한 함수를 구현한 예제입니다.


from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer

# 모델과 토크나이저 로드
model_name = "facebook/m2m100_418M"
tokenizer = M2M100Tokenizer.from_pretrained(model_name)
model = M2M100ForConditionalGeneration.from_pretrained(model_name)

def translate(text, source_language, target_language):
    tokenizer.src_lang = source_language
    encoded_input = tokenizer(text, return_tensors="pt")
    generated_tokens = model.generate(**encoded_input, forced_bos_token_id=tokenizer.get_lang_id(target_language))
    return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]

3.1 번역 함수 설명

위 코드는 다음과 같이 작동합니다:

  1. tokenizer.src_lang: 소스 언어를 설정합니다.
  2. tokenizer(): 입력 텍스트를 토크나이즈합니다.
  3. model.generate(): 토크나이즈된 입력을 바탕으로 번역을 수행합니다.
  4. tokenizer.batch_decode(): 생성된 토큰을 디코드하여 번역된 텍스트를 반환합니다.

4. 번역 예제

이제 번역 기능을 테스트해 보겠습니다. 아래 예제는 중국어 문장을 영어로 번역하는 기능을
보여줍니다.


# 번역할 문장
text = "你好,世界!"  # Hello, World!
source_lang = "zh"  # 중국어
target_lang = "en"  # 영어

# 번역 수행
translated_text = translate(text, source_lang, target_lang)
print(f"번역 결과: {translated_text}")

4.1 결과 해석

위의 코드를 실행하면 “Hello, World!”라는 영어 문장이 출력됩니다. M2M100 모델은
상대적으로 복잡한 문장 구조를 가진 언어 간의 번역도 잘 수행할 수 있습니다.

5. 여러 언어 번역 예제

M2M100 모델의 강력한 기능 중 하나는 다수의 언어를 지원한다는 점입니다. 아래 예제에서는
한국어, 프랑스어, 스페인어 등 여러 언어 간 번역을 수행해 보겠습니다.


# 다국어 번역 테스트
samples = [
    {"text": "여러 언어를 지원하는 모델입니다.", "source": "ko", "target": "en"},  # 한국어 to 영어
    {"text": "Bonjour le monde!", "source": "fr", "target": "ko"},  # 프랑스어 to 한국어
    {"text": "¡Hola Mundo!", "source": "es", "target": "ja"},  # 스페인어 to 일본어
]

for sample in samples:
    translated = translate(sample["text"], sample["source"], sample["target"])
    print(f"{sample['text']} ({sample['source']}) -> {translated} ({sample['target']})")

5.1 다국어 번역 결과

위 코드를 실행하면 여러 언어 간의 번역이 출력될 것입니다. 중요한 점은 M2M100 모델이
중간 언어를 거치지 않고도 다양한 언어를 직접 번역할 수 있다는 것입니다.

6. 성능 평가

번역의 품질을 평가하기 위해 BLEU(Bilingual Evaluation Understudy) 점수를 사용할 수 있습니다.
BLEU 점수는 생성된 번역과 참조 번역 간의 유사성을 정량적으로 평가하는 지표입니다.
다음은 BLEU 점수를 계산하는 과정입니다.


from nltk.translate.bleu_score import sentence_bleu

# 참조 번역과 시스템 번역
reference = ["Hello", "World"]
candidate = translated_text.split()

# BLEU 점수 계산
bleu_score = sentence_bleu([reference], candidate)
print(f"BLEU 점수: {bleu_score:.4f}")

6.1 성능 평가 해석

BLEU 점수가 0에 가까울수록 번역이 좋지 않고, 1에 가까울수록 번역의 품질이 좋음을 의미합니다.
여러 언어 간의 번역 성능을 평가하기 위해 다양한 예제와 참조 번역을 사용하여 성능을
분석할 수 있습니다.

7. 결론

허깅페이스의 M2M100 모델은 다국어 번역 분야에서 혁신적인 발전을 이룩한 모델입니다.
본 강좌에서는 M2M100 모델을 활용해 중국어와 영어 간의 자동 번역을 위한 기초적인
예제를 살펴보았습니다. 이 모델은 직접적인 언어 변환이 가능하여, 중간 언어 없이
다양한 언어 간의 번역이 가능합니다.

앞으로 더 많은 언어와 복잡한 문장을 실험해 보면서 이 모델의 성능을 더욱 개선하고
활용할 수 있는 방법들을 찾아보시기 바랍니다. 허깅페이스의 트랜스포머 라이브러리는
다양한 NLP 태스크에 활용 가능하므로, 다양한 프로젝트에 응용해 보세요.