허깅페이스 트렌스포머 활용강좌, Trainer 클래스 사전학습

딥러닝은 현재 다양한 분야에서 활용되며, 그 중 자연어 처리(NLP)는 특히 빠르게 발전하고 있는 분야입니다. 허깅페이스(Hugging Face)는 이러한 딥러닝 모델을 쉽게 다룰 수 있도록 다양한 라이브러리를 제공하는 플랫폼으로 유명합니다. 본 강좌에서는 허깅페이스의 Transformers 라이브러리를 활용하여 사전학습(pre-training) 및 Trainer 클래스를 사용하는 방법에 대해 자세히 설명하고, 실습할 수 있는 파이썬 코드 예제를 제공합니다.

1. 허깅페이스 Transformers 소개

허깅페이스 Transformers는 변환기(Transformer) 아키텍처를 기반으로 한 다양한 자연어 처리 모델을 쉽게 사용할 수 있도록 해주는 라이브러리입니다. 이 라이브러리는 BERT, GPT-2, RoBERTa, T5 등과 같은 다양한 사전학습 모델을 제공합니다. 이를 통해 우리는 복잡한 모델 구현 없이도 간편하게 자연어 처리 작업을 수행할 수 있습니다.

2. Trainer 클래스 개요

Trainer 클래스는 허깅페이스 Transformers 라이브러리에서 제공하는 고수준 API로, 모델 훈련과 평가를 간편하게 수행할 수 있도록 돕는 클래스입니다. Trainer 클래스를 사용하면 사용자 정의 훈련 루프를 작성하지 않고도 원하는 모델을 학습할 수 있습니다. Trainer 클래스를 사용할 때는 데이터셋, 모델, 훈련 인자(training arguments), 그리고 평가 인자를 지정해야 합니다.

2.1. 필요한 라이브러리 설치

먼저 라이브러리를 설치해야 합니다. 아래의 명령어를 실행하여 Transformers와 함께 필요한 라이브러리를 설치할 수 있습니다.

!pip install transformers datasets

2.2. Trainer 클래스 사용 준비

Trainer 클래스를 사용하기 위해 필요한 준비 작업은 다음과 같습니다:

  • 모델 로딩: 허깅페이스의 모델 허브에서 원하는 모델을 로딩합니다.
  • 토크나이저 설정: 입력 데이터를 벡터로 변환하기 위해 토크나이저를 설정합니다.
  • 데이터셋 준비: 훈련 및 평가에 사용할 데이터셋을 준비합니다.
  • 훈련 인자 설정: 훈련 과정에서 사용할 다양한 인자들을 설정합니다.

3. 데이터셋 준비하기

여기서는 IMDb 영화 리뷰 데이터셋을 사용하여 긍정 및 부정 리뷰를 분류하는 모델을 학습할 것입니다. 이를 위해 Hugging Face의 datasets 라이브러리를 활용하여 IMDb 데이터셋을 다운로드하겠습니다.

from datasets import load_dataset

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

4. 모델과 토크나이저 설정하기

우리는 BERT 모델을 사용할 것이며, Hugging Face에서 제공하는 ‘bert-base-uncased’ 모델을 로드하겠습니다. 동시에 해당 모델에 맞는 토크나이저도 설정해야 합니다.

from transformers import BertTokenizer, BertForSequenceClassification

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

5. 데이터셋 전처리

데이터셋을 모델에 맞게 전처리해야 합니다. 텍스트 데이터를 토큰화하고, 필요하면 패딩을 추가하여 고정된 길이로 맞추겠습니다.

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

train_tokenized = train_dataset.map(preprocess_function, batched=True)
test_tokenized = test_dataset.map(preprocess_function, batched=True)

6. Trainer 클래스 설정

이제 Trainer 클래스를 설정하기 위해 훈련 인자를 정의해야 합니다. 훈련 인자는 훈련 과정의 하이퍼파라미터를 정의합니다.

from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_tokenized,
    eval_dataset=test_tokenized,
)

7. 모델 훈련

모델 훈련을 시작합니다. 아래 코드로 훈련을 수행할 수 있습니다.

trainer.train()

8. 모델 평가

훈련 후 모델의 성능을 평가할 수 있습니다. 평가 메트릭을 확인하여 모델이 얼마나 잘 작동하는지 알아보겠습니다.

trainer.evaluate()

9. 모델 예측

이제 훈련된 모델을 사용하여 새로운 데이터에 대한 예측을 수행할 수 있습니다.

def predict(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
    with torch.no_grad():
        outputs = model(**inputs)
    predictions = torch.argmax(outputs.logits, dim=-1)
    return predictions

sample_texts = ["I love this movie!", "This is the worst film ever."]
predictions = predict(sample_texts)
print(predictions)

10. 마무리

본 강좌에서는 허깅페이스의 Transformers 라이브러리를 활용하여 Trainer 클래스를 이용한 모델 사전학습에 대해 알아보았습니다. 허깅페이스는 다양한 사전학습된 모델을 제공하여, 자연어 처리에서의 여러 작업을 쉽게 수행할 수 있도록 돕고 있습니다. 이번 예제를 통해 손쉽게 모델을 훈련하고 평가하는 방법을 익혔기를 바랍니다. 앞으로도 허깅페이스와 딥러닝의 다양한 가능성을 탐색해 나가시길 바랍니다.

감사합니다!

허깅페이스 트렌스포머 활용강좌, PEGASUS 자동 요약

자연어 처리(NLP) 분야에서 자동 요약은 매우 중요한 작업 중 하나입니다. 사람의 개입 없이 긴 텍스트를 요약하여 정보의 핵심을 전달하는 것은 많은 실제 응용 프로그램에서 필수적입니다. 본 강좌에서는 허깅페이스(Hugging Face)에서 제공하는 PEGASUS 모델을 활용하여 자동 요약 작업을 수행하는 방법에 대해 설명합니다.

1. PEGASUS란?

PEGASUS는 Google에서 개발한 자동 요약을 위한 딥러닝 모델입니다. 이 모델은 Transformer 아키텍처를 기반으로 하고 있으며, 다양한 텍스트 요약 작업에서 높은 성능을 보여주고 있습니다. PEGASUS는 특히 중요한 문장을 선택하고 생성하는 능력이 뛰어나며, 이러한 특성 덕분에 긴 문장을 효과적으로 요약할 수 있습니다.

1.1. PEGASUS의 기본 원리

PEGASUS는 입력 문서에서 핵심 정보를 효과적으로 요약하는 능력을 갖추고 있습니다. 모델은 주어진 문서에서 중요한 부분을 선택하고, 이를 바탕으로 짧은 요약문을 생성합니다. 일반적으로 PEGASUS 모델은 다음의 두 가지 단계로 요약을 수행합니다:

  • 텍스트 인코딩: 입력된 긴 텍스트를 인코딩하여 의미를 추출합니다.
  • 요약 생성: 인코딩된 정보를 바탕으로 짧은 요약문을 생성합니다.

2. 환경 설정

본 강좌에서는 Python과 Hugging Face의 Transformers 라이브러리를 사용할 것입니다. 아래의 단계를 따라 환경을 설정해 주세요:

2.1. 필수 라이브러리 설치

pip install transformers torch

위의 명령어를 통해 Hugging Face의 Transformers 라이브러리와 PyTorch를 설치할 수 있습니다. PyTorch는 딥러닝 모델을 학습하고 추론하는데 사용되는 기본 라이브러리입니다.

3. PEGASUS 모델 로딩

이제 PEGASUS 모델을 로드하고 사용할 준비가 되었습니다. 아래의 코드를 사용하여 모델과 토크나이저를 로드합니다:

from transformers import PegasusForConditionalGeneration, PegasusTokenizer

# PEGASUS 모델과 토크나이저 로드
model_name = "google/pegasus-large"
tokenizer = PegasusTokenizer.from_pretrained(model_name)
model = PegasusForConditionalGeneration.from_pretrained(model_name)

3.1. 문서 요약 함수 정의하기

이제 요약할 문서를 입력받아 요약을 생성하는 함수를 정의해보겠습니다.

def summarize_text(text):
    # 입력 텍스트를 토큰화
    inputs = tokenizer(text, truncation=True, padding="longest", return_tensors="pt")
    
    # 요약 생성
    summary_ids = model.generate(inputs["input_ids"], num_beams=4, min_length=30, max_length=200, early_stopping=True)
    
    # 요약 텍스트 변환
    summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
    return summary

4. 요약 예제

이제 위에서 정의한 summarize_text 함수를 사용하여 실제 문서의 요약을 생성해 보겠습니다.

# 예제 텍스트
document = """
2023년 2월 27일, OpenAI는 새로운 인공지능 언어 모델 GPT-4를 발표했습니다. 이 모델은 이전 모델 대비 월등한 성능을 보여주며, 다양한 언어 처리 작업을 수행할 수 있습니다.
GPT-4는 대규모 데이터셋으로 학습되었으며, 자연어 생성, 번역, 질문 및 답변 등 여러 분야에서 활용될 수 있습니다.
또한, GPT-4는 사용자의 요구에 맞춘 맞춤형 응답을 생성할 수 있어 기업과 연구자들에게 많은 관심을 받고 있습니다.
"""

# 요약 생성
summary = summarize_text(document)
print("원본 문서:")
print(document)
print("\n생성된 요약:")
print(summary)

5. 결과 분석

생성된 요약 결과를 분석해 보겠습니다. 요약의 품질은 원본 문서에서 핵심 정보가 얼마나 잘 반영되었는지에 따라 다릅니다. PEGASUS 모델은 긴 텍스트에 대해 강력한 요약 능력을 발휘하지만, 특정한 설정이나 수치적인 한계가 존재할 수 있습니다. 따라서, 결과를 검토하고 필요에 따라 파라미터를 조정하는 것이 중요합니다.

6. 파라미터 튜닝

모델의 요약 품질을 개선하기 위해서는 다양한 하이퍼파라미터를 조정할 수 있습니다. 주요 파라미터로는 num_beams, min_length, max_length가 있습니다. 이들 파라미터의 의미는 다음과 같습니다:

  • num_beams: 빔 서치에서 사용되는 빔의 수 입니다. 값이 클수록 더 많은 후보 요약을 고려하지만, 계산 비용이 증가합니다.
  • min_length: 생성될 요약의 최소 길이입니다. 이 값은 생성된 요약의 의미를 보장하는 데 중요합니다.
  • max_length: 생성될 요약의 최대 길이입니다. 이 값은 요약이 지나치게 길어지지 않도록 조정합니다.

7. 결론

본 강좌에서는 허깅페이스의 PEGASUS 모델을 활용하여 자동 요약을 수행하는 방법을 배웠습니다. PEGASUS는 자연어 처리 분야에서 매우 유용한 도구로서, 방대한 양의 정보를 효과적으로 전달하기 위해 활용될 수 있습니다. 향후 더 발전된 요약 모델이나 방법론도 연구될 것으로 예상되니 지속적인 관심과 학습이 필요합니다.

8. 참고자료

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

최근 자연어 처리(NLP) 분야에서의 혁신은 딥러닝 모델의 발전 덕분에 이루어졌습니다. 특히, 허깅페이스(Hugging Face)에서 개발한 트렌스포머(Transformers) 라이브러리는 이러한 발전의 상징으로 자리잡았습니다. 본 강좌에서는 PEGASUS 모델을 이용하여 텍스트 요약 태스크를 수행하기 위해 필요한 라이브러리 설정 및 사전학습 모델 불러오는 방법에 대해 자세히 다루겠습니다.

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

허깅페이스 트렌스포머 라이브러리는 다양한 NLP 태스크에 사용할 수 있는 사전학습된 모델을 제공하는 파이썬 라이브러리입니다. 이 라이브러리는 특히 트랜스포머 아키텍처를 기반으로 다양한 모델(BERT, GPT-2, RoBERTa, T5 등)을 제공합니다. PEGASUS는 이러한 트랜스포머 아키텍처를 기반으로 하는 모델 중 하나로, 주로 텍스트 요약을 위한 사전학습 모델입니다.

2. PEGASUS 모델 소개

PEGASUS(Pre-trained Text-to-Text Transfer Transformer)는 구글에서 개발한 모델로, 자연어 문서에서 중요한 정보를 추출하여 요약하는 데 최적화되어 있습니다. PEGASUS 모델의 핵심 아이디어는 입력 문서에서 문장들을 임의로 선택하여 마스킹하고, 마스킹된 문장을 예측하는 방식으로 사전학습을 수행하는 것입니다. 이 과정에서 모델은 글의 전반적인 맥락을 이해하고 중요한 정보를 식별하게 됩니다.

2.1. PEGASUS 모델의 장점

  • 우수한 텍스트 요약 성능
  • 사전학습된 모델을 활용하여 적은 데이터로도 학습 가능
  • 다양한 언어와 도메인에서 사용 가능

3. 환경 설정

PEGASUS 모델을 이용하기 위해서는 먼저 필요한 라이브러리를 설치해야 합니다. 이 과정에서는 주로 transformers, torch 라이브러리 설치가 필요합니다. 아래는 설치 방법입니다.

pip install transformers torch

3.1. 필요한 라이브러리 임포트

설치가 완료되었다면, 다음과 같이 필요한 라이브러리를 임포트합니다.

import torch
from transformers import PegasusForConditionalGeneration, PegasusTokenizer

4. PEGASUS 모델 불러오기

이제 PEGASUS 모델과 토크나이저를 불러올 차례입니다. PEGASUS 모델은 허깅페이스의 모델 허브에서 쉽게 불러올 수 있습니다.

model_name = "google/pegasus-xsum"

# 토크나이저 및 모델 불러오기
tokenizer = PegasusTokenizer.from_pretrained(model_name)
model = PegasusForConditionalGeneration.from_pretrained(model_name)

4.1 요약할 텍스트 준비

모델을 사용하기 위해서는 요약할 텍스트를 준비해야 합니다. 아래 코드에서는 샘플 텍스트를 정의합니다.

sample_text = "자연어 처리는 컴퓨터와 인간의 언어 사이의 상호 작용을 다루는 컴퓨터 과학의 한 분야입니다. 자연어 처리는 인간의 언어를 이해하고 처리하는 방법을 연구합니다."

4.2 텍스트 토큰화 및 요약

토크나이저를 사용하여 텍스트를 토큰화 한 후, 배치 크기를 설정하고 요약을 수행합니다.

# 텍스트 인코딩
inputs = tokenizer(sample_text, return_tensors="pt", max_length=512, truncation=True)

# 요약 생성
summary_ids = model.generate(inputs["input_ids"], num_beams=4, max_length=50, early_stopping=True)

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

5. 요약 결과 분석

위 코드에서 생성한 요약 결과를 확인해보겠습니다. 생성된 요약 문장은 본래 문서에서 가장 중요한 정보를 간결하게 전달해야 합니다. 이 과정에서 발생할 수 있는 문제로는 잘못된 문장 형성이나 누락된 정보가 있습니다. 이러한 문제를 해결하기 위해서는 학습 데이터의 양과 질이 매우 중요합니다.

6. 결론

본 강좌를 통해 PEGASUS 모델을 활용하여 텍스트 요약을 수행하는 방법에 대해 알아보았습니다. PEGASUS 모델은 사전학습된 강력한 자연어 처리 모델로, 효과적인 요약 도구로 자리잡고 있습니다. 더불어 허깅페이스 트렌스포머 라이브러리를 통해 쉽게 모델을 불러와 사용할 수 있음을 확인했습니다.

향후 이 강좌에서는 PEGASUS 모델을 Fine-tuning하여 특정 도메인에 맞게 조정하는 방법과, 다양한 하이퍼파라미터를 조정하여 성능을 개선하는 방법에 대해 다루어 보도록 하겠습니다. NLP의 세계는 매우 넓고, 다양한 응용 가능성을 지니고 있습니다. 지속적으로 학습하고 연구하여 더욱 효과적인 모델을 개발해 나가시기 바랍니다.

© 2023 블로그 작성자

허깅페이스 트렌스포머 활용강좌, Mobile BERT 추론 시 마지막 은닉층

최근 몇 년간 자연어 처리(NLP) 분야에서 깊은 학습 기반의 모델들이 인기를 끌며 많은 발전을 거듭해왔습니다. 그중에서도 허깅페이스(Hugging Face)의 트랜스포머 모델들은 사용의 용이함과 성능 덕분에 인기를 끌고 있습니다. 특히 Mobile BERT는 경량화된 BERT 모델로서, 모바일 환경에서도 효과적으로 사용할 수 있도록 설계되었습니다. 이번 강좌에서는 Mobile BERT 모델을 활용하여 마지막 은닉층의 출력을 추출하는 방법을 소개하겠습니다.

1. Mobile BERT란?

Mobile BERT는 구글이 BERT의 경량 버전으로 출시한 모델입니다. BERT 모델은 두 가지 주요 구성 요소인 EncoderDecoder를 기반으로 하며, Mobile BERT는 이 중 Encoder를 경량화하여 다양한 모바일 기기에서도 사용할 수 있도록 최적화되었습니다. Mobile BERT는 4배 더 적은 파라미터를 가지고 있으며, 연산 효율을 높이기 위해 다양한 기법을 적용하였습니다.

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

허깅페이스의 트랜스포머 모델을 사용하기 위해 먼저 필요한 라이브러리를 설치해야 합니다. 아래의 명령어를 사용하여 라이브러리를 설치할 수 있습니다.

pip install transformers torch

3. Mobile BERT 모델 불러오기

모델 설치가 완료되면 Mobile BERT 모델을 불러올 수 있습니다. 다음은 기본적인 코드입니다.

from transformers import MobileBertTokenizer, MobileBertModel

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

4. 입력 데이터 전처리

Mobile BERT 모델에 입력할 데이터는 텍스트 형태로 제공되어야 하며, 토크나이저를 통해 적절한 형식으로 변환해야 합니다. 다음은 입력 문장을 전처리하는 방법입니다.

# 입력 문장 정의
input_text = "허깅페이스의 트랜스포머를 활용해보세요!"

# 문장 토큰화 및 인덱스 변환
inputs = tokenizer(input_text, return_tensors='pt')

5. 모델을 통한 추론

전처리가 완료된 데이터는 Mobile BERT 모델에 입력되어 마지막 은닉층 출력값을 가져올 수 있습니다. 모델의 forward 메서드를 이용하여 출력값을 계산할 수 있습니다.

with torch.no_grad():
    outputs = model(**inputs)

# 마지막 은닉층의 출력값은 outputs[0]에 저장됩니다.
last_hidden_states = outputs.last_hidden_state
print(last_hidden_states.shape)  # (배치크기, 시퀀스 길이, 은닉층 크기)

6. 결과 해석

마지막 은닉층의 출력값은 3차원 텐서로 반환됩니다. 텐서의 첫 번째 차원은 배치 크기, 두 번째 차원은 시퀀스 길이(문장의 단어 수), 세 번째 차원은 은닉층의 차원입니다. 예를 들어, 배치 크기가 1, 시퀀스 길이가 10, 은닉층 차원이 768인 경우, 출력값의 형태는 (1, 10, 768)입니다.

7. 응용 예시: 임베딩 벡터 추출

마지막 은닉층의 출력값은 각 단어의 임베딩 벡터로 활용될 수 있습니다. 이러한 벡터들을 사용하여 여러가지 자연어 처리 태스크에 활용할 수 있습니다.

# 첫 번째 단어의 임베딩 벡터 추출
word_embedding = last_hidden_states[0, 0, :]  # (768,)
print(word_embedding.shape)

8. 정리

이번 포스트에서는 허깅페이스의 트랜스포머 라이브러리를 사용하여 Mobile BERT 모델을 활용하는 방법을 알아보았습니다. 모델을 통해 입력 데이터 전처리, 추론 과정 및 마지막 은닉층의 시퀀스 출력을 얻는 방법을 소개하였습니다. 이러한 방법은 다양한 자연어 처리 응용에 활용될 수 있으며, 실제로 많은 연구 및 산업 분야에서 사용되고 있습니다.

9. 참고 자료

자세한 내용은 다음의 링크에서 확인하실 수 있습니다:

허깅페이스 트렌스포머 활용강좌, Mobile BERT 빈칸 채우기 퀴즈

이번 강좌에서는 허깅페이스(Hugging Face)트랜스포머(Transformers) 라이브러리를 활용하여 Mobile BERT 모델을 사용한 빈칸 채우기 퀴즈를 만들어보겠습니다. Mobile BERT는 BERT 모델을 경량화하여 모바일 환경에서도 효과적으로 사용할 수 있는 모델로, 텍스트 임베딩, 질의 응답, 텍스트 분류 등 다양한 NLP 작업에 활용됩니다.

1. 준비사항

이 강좌를 진행하기 위해 필요한 환경과 라이브러리는 다음과 같습니다:

  • Python 3.6 이상
  • Transformers 라이브러리
  • torch 라이브러리
  • pandas (선택 사항, 데이터프레임을 사용하기 위해)

2. 환경 설정

!pip install transformers torch pandas

3. Mobile BERT 모델 소개

Mobile BERT는 Google에서 개발한 BERT(Base Bidirectional Encoder Representations from Transformers)를 기반으로 한 경량화된 변형 모델입니다. Mobile BERT는 BERT와 동일한 아키텍처를 활용하지만, 모델 크기를 줄이고 수행 속도를 높이기 위해 몇 가지 기술적인 조정을 거쳤습니다. 이는 모바일 및 엣지 디바이스에서도 자연어 처리 작업을 지원할 수 있도록 설계되었습니다.

4. 데이터 준비

이번 예제에서는 빈칸 채우기 문제를 구성하기 위해 텍스트 샘플을 준비합니다. 샘플 텍스트에는 특정 단어가 빈칸으로 표시되며, 우리의 목표는 해당 위치에 가장 적합한 단어를 찾는 것입니다.

sample_text = "나는 [MASK]를 사랑합니다. 기계 학습은 [MASK]의 일종입니다."

5. Mobile BERT 모델 로드

허깅페이스의 트랜스포머 라이브러리를 사용하여 Mobile BERT 모델을 로드합니다. 모델과 토크나이저를 가져오기 위해 아래 코드를 사용합니다:


from transformers import MobileBertTokenizer, MobileBertForMaskedLM
import torch

# Mobile BERT 토크나이저와 모델 로드
tokenizer = MobileBertTokenizer.from_pretrained('google/mobilebert-uncased')
model = MobileBertForMaskedLM.from_pretrained('google/mobilebert-uncased')

6. 빈칸 채우기 함수 구현

이제 빈칸 채우기를 수행하는 함수를 구현합니다. 이 함수는 텍스트를 입력으로 받아, [MASK]를 포함하는 문장을 토크나이즈하고, 모델을 통해 예측한 결과를 반환합니다.


def fill_mask(text):
    # 텍스트 토크나이즈
    input_ids = tokenizer.encode(text, return_tensors='pt')
    
    # 모델 예측
    with torch.no_grad():
        outputs = model(input_ids)
    
    # 예측된 토큰 ID 얻기
    predictions = outputs.logits.argmax(dim=-1)
    
    # 예측된 단어들로부터 텍스트 복원
    filled_text = tokenizer.decode(predictions[0])
    return filled_text

7. 빈칸 채우기 호출

이제 구현한 함수를 사용하여 빈칸 채우기를 해보겠습니다. 다음은 빈칸이 있는 문장을 입력으로 사용한 코드입니다.


# 빈칸 있는 샘플 텍스트
sample_text = "나는 [MASK]를 사랑합니다. 기계 학습은 [MASK]의 일종입니다."

# 빈칸 채우기 함수 호출
filled_text = fill_mask(sample_text)
print(filled_text)

8. 결과 해석

모델이 예측한 결과를 해석합니다. Mobile BERT는 사전 훈련된 모델로, 자연어의 문맥을 이해하고 적절한 단어를 선택하는 데 뛰어난 성능을 보입니다. 이 예제를 통해 모델이 어떻게 빈칸을 채우는지 이해할 수 있습니다.

9. 실습: 여러 문장에 대한 빈칸 채우기

여러 개의 문장에 대해 빈칸 채우기를 실습해보겠습니다. 여러 샘플을 리스트에 넣고, 반복문을 통해 결과를 확인해보세요.


# 빈칸 있는 여러 문장 샘플
samples = [
    "나는 [MASK]를 사랑합니다.",
    "기계 학습은 [MASK]의 일종입니다.",
    "[MASK]는 매우 중요한 개념입니다."
]

# 각 샘플에 대해 빈칸 채우기
for sample in samples:
    filled = fill_mask(sample)
    print(f"원래 문장: {sample} -> 채워진 문장: {filled}")

10. 결론

이번 강좌에서는 Mobile BERT를 활용하여 NLP 빈칸 채우기 문제를 해결해보았습니다. 허깅페이스의 트랜스포머 라이브러리를 사용하면 복잡한 자연어 처리 작업을 손쉽게 수행할 수 있습니다. Mobile BERT는 모바일 환경에서도 효율적으로 작동하기 때문에, 경량화된 머신러닝 애플리케이션에 매우 적합합니다.

11. 참고 문헌