[카테고리:] 허깅페이스 활용

자연어 처리(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. 참고자료

• Hugging Face Transformers 문서
• PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization
• PyTorch 공식 문서

딥러닝은 현재 다양한 분야에서 활용되며, 그 중 자연어 처리(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 클래스를 이용한 모델 사전학습에 대해 알아보았습니다. 허깅페이스는 다양한 사전학습된 모델을 제공하여, 자연어 처리에서의 여러 작업을 쉽게 수행할 수 있도록 돕고 있습니다. 이번 예제를 통해 손쉽게 모델을 훈련하고 평가하는 방법을 익혔기를 바랍니다. 앞으로도 허깅페이스와 딥러닝의 다양한 가능성을 탐색해 나가시길 바랍니다.

감사합니다!

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

1. Mobile BERT란?

Mobile BERT는 구글이 BERT의 경량 버전으로 출시한 모델입니다. BERT 모델은 두 가지 주요 구성 요소인 Encoder와 Decoder를 기반으로 하며, 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. 참고 자료

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

• Hugging Face Transformers Documentation
• MobileBERT: Model Compression and Acceleration for Natural Language Processing

최근 자연어 처리(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의 세계는 매우 넓고, 다양한 응용 가능성을 지니고 있습니다. 지속적으로 학습하고 연구하여 더욱 효과적인 모델을 개발해 나가시기 바랍니다.

딥러닝 분야에서 자연어 처리(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를 사용할 준비가 완료됩니다.

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 태스크에 대한 적용 가능성을 더 연구해보는 것을 권장합니다.

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