허깅페이스 트렌스포머 활용강좌, 데이터세트 클래스 생성

이번 강좌에서는 허깅페이스(Hugging Face)트랜스포머(Transformers) 라이브러리를 활용하여 데이터세트 클래스를 생성하는 방법에 대해 다룰 것입니다. 허깅페이스 트랜스포머는 자연어 처리(NLP) 작업을 위한 필수 도구 중 하나로, 다양한 사전 훈련된 모델과 데이터셋을 제공합니다. 이러한 모델을 효과적으로 활용하기 위해서는 사용자 정의 데이터세트를 생성하는 것이 중요합니다.

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

허깅페이스 트랜스포머 라이브러리는 머신러닝의 자연어 처리 분야에서 가장 많이 사용되는 라이브러리 중 하나로, BERT, GPT-2, T5와 같은 최신 모델을 포함하고 있습니다. 이 라이브러리는 모델의 훈련, 미세 조정(fine-tuning), 예측 등을 간편하게 구현할 수 있도록 도와줍니다.

2. 데이터셋 클래스란?

데이터셋 클래스는 모델 훈련 및 평가에 사용될 데이터의 구조를 정의하는 클래스입니다. 데이터셋 클래스를 사용하면 사용자 정의 데이터를 쉽게 로드하고 전처리할 수 있습니다. 허깅페이스 트랜스포머에서는 datasets 라이브러리를 통해 데이터를 쉽게 다룰 수 있는 기능을 제공합니다.

3. 데이터셋 클래스 생성 방법

이번 섹션에서는 Python을 사용하여 데이터셋 클래스를 생성하는 방법을 다루겠습니다. 구체적으로는 torch.utils.data.Dataset 클래스를 상속받아 사용자 정의 데이터셋 클래스를 만들고 이를 허깅페이스 트랜스포머와 통합하는 방법을 설명하겠습니다.

3.1 준비하기

먼저, 필요한 라이브러리를 설치하고 임포트합니다. 아래의 코드를 사용하여 transformersdatasets 라이브러리를 설치합니다.

!pip install transformers datasets torch

3.2 사용자 정의 데이터셋 클래스 만들기

여기에서 데이터셋 클래스를 생성하는 방법을 보여드리겠습니다.

import torch
from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=512):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_length = max_length

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

    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]

        # 토큰화 및 인덱스 변환
        encoding = self.tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=self.max_length,
            return_token_type_ids=False,
            padding='max_length',
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt'
        )

        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

위의 클래스는 텍스트와 라벨을 입력으로 받아서 해당 텍스트를 토큰화 하고 라벨을 텐서로 반환하는 데이터셋입니다. torch.utils.data.Dataset 클래스를 상속받아 __len____getitem__ 메소드를 구현하였습니다.

3.3 데이터셋 사용하기

이제 사용자 정의 데이터셋을 어떻게 사용할 수 있는지 살펴봅시다. 데이터를 준비하고 데이터로더를 생성하는 예는 다음과 같습니다.

from transformers import AutoTokenizer

# 토크나이저 준비
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

# 데이터 준비
texts = ["Hello, how are you?", "I am fine, thank you."]
labels = [0, 1] # 예시 라벨

# 데이터셋 인스턴스 생성
dataset = MyDataset(texts, labels, tokenizer)

# 데이터 로더 생성
from torch.utils.data import DataLoader

dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

for batch in dataloader:
    print(batch)

위 코드는 작은 데이터셋을 만든 후에 데이터로더를 생성하여 배치 단위로 데이터를 반환하는 예입니다. 데이터 로더는 훈련 중 데이터 샘플을 무작위로 선택하여 배치 단위로 반환할 수 있게 해줍니다.

4. 데이터셋 클래스 확장

이제 사용자 정의 데이터셋 클래스를 확장하여 여러 기능을 추가하는 방법을 보여드리겠습니다. 예를 들어, 데이터 전처리 과정 추가, 여러 형식의 입력을 처리하기 등 다양한 기능을 포함할 수 있습니다.

4.1 데이터 전처리

데이터 전처리는 모델의 성능을 높이는 중요한 단계입니다. 필요한 경우, __init__ 메소드에 전처리 기능을 구현할 수 있습니다.

def preprocess(self, text):
        # 여기에 전처리 로직을 추가하세요
        return text.lower().strip()

이 메소드를 __getitem__에서 호출하여 데이터를 반환하기 전에 전처리를 수행할 수 있습니다.

4.2 여러 형식의 입력 처리

데이터셋이 다양한 입력 형식을 처리해야 할 경우 조건문을 사용하여 다르게 처리할 수 있습니다. 입력 텍스트의 형식에 따라 조건을 추가하면 됩니다.

if isinstance(text, list):
    text = " ".join(text)  # 리스트 텍스트 합치기

5. 결론

이번 강좌에서는 허깅페이스 트랜스포머의 데이터셋 클래스를 생성하고 사용하는 방법을 알아보았습니다. 사용자 정의 데이터셋은 모델 훈련 및 평가에 있어 매우 중요한 요소입니다. 이를 통해 우리는 다양한 형식의 데이터를 효율적으로 처리하고, 원하는 방식으로 모델을 훈련할 수 있습니다.

앞으로 더 많은 자연어 처리 문제를 해결하기 위해 허깅페이스를 활용해 보세요. 그리고 자신만의 데이터셋 클래스를 만들어 보며 실력을 쌓아보시기 바랍니다. 감사합니다!

허깅페이스 트렌스포머 활용강좌, 데이터세트 준비

딥러닝과 자연어 처리(NLP)의 세계는 빠르게 발전하고 있으며, 그 가운데 허깅페이스의 트랜스포머 라이브러리는 많은 연구자와 개발자들에게 필수적인 도구로 자리잡고 있습니다. 이 글에서는 허깅페이스의 트랜스포머 라이브러리를 활용하여 데이터셋을 준비하는 방법을 자세히 설명하겠습니다. 데이터셋 준비는 모델 훈련의 첫 걸음이며, 고품질의 데이터가 좋은 결과를 가져오는 데 필수적입니다.

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

허깅페이스 트랜스포머 라이브러리는 자연어 처리 모델을 쉽게 사용할 수 있도록 만들어진 오픈소스 라이브러리입니다. 이 라이브러리는 다양한 사전 훈련된 모델들과 데이터셋을 제공하여 연구자들이 새로운 모델을 설계하고 실험할 수 있는 기반을 제공합니다. 저렴한 비용으로 가장 최신의 NLP 모델을 사용할 수 있다는 점에서 매우 큰 장점을 가지고 있습니다.

2. 데이터셋 준비의 중요성

모델의 성능은 대개 데이터셋의 품질에 의존합니다. 잘 구성된 데이터셋은 모델 훈련의 진행을 원활하게 하고, 데이터의 다양성과 양은 모델이 일반화하는 데 큰 영향을 미칩니다. 따라서 데이터셋 준비 단계에서 다음과 같은 사항을 고려해야 합니다:

  • 데이터의 품질: 중복된 데이터와 노이즈가 적은 데이터를 사용하는 것이 중요합니다.
  • 데이터의 다양성: 다양한 상황과 케이스를 포함해야 모델이 실제 환경에서 잘 작동할 수 있습니다.
  • 데이터의 크기: 데이터 양이 많을수록 모델 훈련의 일반화 능력이 높아집니다.

3. 데이터셋 다운로드 및 준비

허깅페이스는 다양한 공개 데이터셋을 제공합니다. 이러한 데이터셋을 사용하면 모델 학습에 필요한 데이터를 쉽게 확보할 수 있습니다. 이제 데이터셋을 로드하고 전처리하는 방법을 살펴보겠습니다.

3.1. Hugging Face Datasets 라이브러리 설치

먼저, 허깅페이스의 Datasets 라이브러리를 설치해야 합니다:

pip install datasets

3.2. 데이터셋 불러오기

이제 Python에서 Hugging Face의 데이터셋을 불러오는 법을 알아보겠습니다. 예를 들어, IMDB 영화 리뷰 데이터셋을 사용할 것입니다.

from datasets import load_dataset

# IMDB 데이터셋 불러오기
dataset = load_dataset("imdb")

print(dataset)

위의 코드를 실행하면 학습 세트와 테스트 세트로 나뉜 데이터셋이 불러와집니다. 다음은 데이터셋의 구조를 점검하는 방법입니다:

# 데이터셋의 첫 번째 항목 출력
print(dataset['train'][0])

3.3. 데이터셋 전처리

데이터셋을 불러온 후에는 모델 학습에 적합한 형태로 전처리해야 합니다. 전처리 과정은 주로 데이터 정제, 토큰화, 패딩 등을 포함합니다.

IMDB 데이터셋의 경우, 각 리뷰는 텍스트 데이터로 되어 있으며, 긍정 또는 부정 레이블이 존재합니다. 이 데이터를 모델에 입력하기 위해 텍스트를 토큰화하고 순서에 맞게 정렬해야 합니다.

from transformers import AutoTokenizer

# BERT용 토크나이저 로드
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

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

# 전처리 적용
tokenized_datasets = dataset['train'].map(preprocess_function, batched=True)

위의 코드에서는 BERT 모델에 맞춰 토큰화를 진행하였습니다. truncation=True 인자는 입력 데이터가 토큰의 최대 길이를 초과할 경우 잘리도록 하는 역할을 합니다. 이 과정을 통해 각 리뷰는 모델이 이해할 수 있는 형태로 변환됩니다.

3.4. 데이터셋 검토

전처리 과정을 마친 후, 데이터셋을 검토해보겠습니다. 어떤 형식으로 변환되었는지 확인해볼 수 있습니다:

# 변환된 데이터셋 첫 번째 항목 출력
print(tokenized_datasets[0])

4. 데이터셋 분할 및 저장

본격적인 모델 훈련에 들어가기 전에 데이터를 훈련 세트와 검증 세트로 나누는 것이 필요합니다. 이를 통해 모델의 일반화 성능을 평가할 수 있는 기준을 설정할 수 있습니다.

train_test_split = dataset['train'].train_test_split(test_size=0.2)
train_dataset = train_test_split['train']
test_dataset = train_test_split['test']

# 데이터셋 저장
train_dataset.save_to_disk("train_dataset")
test_dataset.save_to_disk("test_dataset")

위 코드에서는 전체 훈련 데이터의 20%를 검증 세트로 할당하고, 훈련 및 검증 세트를 각각 저장하는 방법을 보여주고 있습니다.

5. 데이터셋의 예시

이제 만든 데이터셋을 활용하여 훈련을 진행할 준비가 되었습니다. 앞서 준비한 IMDB 데이터셋의 일부 예시는 다음과 같습니다:

이 영화는 훌륭하다. 긍정
이 영화는 정말 끔찍하다. 부정

이러한 예시들을 통해 모델은 긍정적인 리뷰와 부정적인 리뷰를 구분하는 법을 학습하게 됩니다. 그리고 전처리 과정에서 토큰화가 완료된 상태이므로, 바로 모델 훈련에 사용할 수 있습니다.

6. 결론

이번 글에서는 허깅페이스 트랜스포머 라이브러리를 사용하여 데이터셋을 준비하는 전반적인 과정을 살펴보았습니다. 데이터 준비는 딥러닝 모델 훈련의 기초가 되는 단계로, 품질 높은 데이터셋을 구성하는 것의 중요성을 알 수 있었습니다. 앞으로의 포스트에서는 준비된 데이터셋을 가지고 실제 모델을 훈련시키는 과정을 다룰 예정입니다.

딥러닝과 NLP 분야의 발전에 발맞춰, 허깅페이스는 여러분의 데이터셋 준비 과정을 더욱 수월하게 만들어 줄 것입니다. 지속적으로 학습하고 실험하는 과정을 통해 여러분만의 모델을 개발해보시길 바랍니다.

참고문헌

허깅페이스 트렌스포머 활용강좌, 다중 클래스 분류용 BERT 사전학습 모델 불러오기

다중 클래스 분류용 BERT 사전학습 모델 불러오기

BERT(Bidirectional Encoder Representations from Transformers)는 구글에서 제안한 자연어 처리 모델로, 문맥 이해를 위해 양방향 Transformer 구조를 활용합니다. BERT는 사전 학습(pre-training) 및 미세 조정(fine-tuning) 단계를 통해 다양한 자연어 처리 태스크에 적용될 수 있습니다. 이번 강좌에서는 허깅페이스(Hugging Face) 트랜스포머 라이브러리를 사용하여 사전학습된 BERT 모델을 불러와 다중 클래스 분류 문제를 해결하는 방법을 소개하겠습니다.

1. 환경 설정

본 강좌에서는 다음의 라이브러리가 필요합니다:

  • transformers
  • torch (PyTorch)
  • numpy
  • pandas

다음 명령어를 통해 필요한 라이브러리를 설치할 수 있습니다:

!pip install transformers torch numpy pandas

2. 데이터 준비

우선, 다중 클래스 분류 문제를 위한 데이터셋을 준비해야 합니다. 예시로, 간단한 텍스트와 라벨을 가진 데이터프레임을 만들어 보겠습니다.

import pandas as pd

data = {
    'text': [
        '나는 자연어 처리가 좋아요.',
        'PyTorch와 TensorFlow가 인기 있어요.',
        '딥러닝은 머신러닝의 한 분야입니다.',
        '대화형 AI는 많은 관심을 받고 있어요.',
        '텍스트 분류는 중요한 작업입니다.'
    ],
    'label': [0, 1, 1, 2, 0]
}

df = pd.DataFrame(data)

3. 데이터 전처리

BERT 모델의 입력 형식에 맞게 데이터를 전처리합니다. BERT Tokenizer를 사용하여 텍스트를 토큰화하고, 입력 아이디와 어텐션 마스크를 생성합니다.

from transformers import BertTokenizer

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

# 토큰화 및 입력 아이디, 어텐션 마스크 생성
def encode_data(text):
    return tokenizer(text, padding='max_length', truncation=True, max_length=128, return_tensors='pt')

encoded_texts = [encode_data(text)['input_ids'] for text in df['text']]
attention_masks = [encode_data(text)['attention_mask'] for text in df['text']]

4. 데이터셋 분할

데이터를 학습용과 검증용으로 분할합니다. 여기서는 데이터의 80%를 학습 데이터로, 20%를 검증 데이터로 사용합니다.

from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(
    df['text'],
    df['label'],
    test_size=0.2,
    random_state=42
)

5. 데이터 로더 생성

PyTorch의 DataLoader를 사용하여 배치 처리를 위한 데이터 로더를 생성합니다.

import torch
from torch.utils.data import Dataset, DataLoader

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

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

    def __getitem__(self, idx):
        text = encode_data(self.texts[idx])
        return {
            'input_ids': text['input_ids'].squeeze(),
            'attention_mask': text['attention_mask'].squeeze(),
            'labels': torch.tensor(self.labels[idx])
        }

train_dataset = TextDataset(X_train.tolist(), y_train.tolist())
val_dataset = TextDataset(X_val.tolist(), y_val.tolist())

train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=2, shuffle=False)

6. 모델 불러오기

허깅페이스의 Transformers 라이브러리에서 사전 학습된 BERT 모델을 불러옵니다. 여기에 분류기를 추가하여 다중 클래스 분류 문제를 해결합니다.

from transformers import BertForSequenceClassification

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

7. 모델 학습

모델을 학습하기 위해 오차 함수와 최적화 알고리즘을 설정하고, 단순한 학습 루프를 작성해 봅니다.

from transformers import AdamW
from tqdm import tqdm

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

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

# 모델 학습
model.train()
for epoch in range(3):  # 에포크 수
    for batch in tqdm(train_loader):
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['labels'].to(device)

        optimizer.zero_grad()
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

    print(f'Epoch {epoch+1} Loss: {loss.item()}')

8. 검증 및 성능 평가

검증 데이터를 사용하여 모델의 성능을 평가합니다. 여기서는 정확도를 측정합니다.

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for batch in val_loader:
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['labels'].to(device)

        outputs = model(input_ids, attention_mask=attention_mask)
        _, predicted = torch.max(outputs.logits, dim=1)

        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = correct / total
print(f'Accuracy: {accuracy:.2f}') 

9. 결론

이번 강좌에서는 허깅페이스 트랜스포머 라이브러리를 이용하여 사전 학습된 BERT 모델을 다중 클래스 분류 문제에 활용하는 방법을 배웠습니다. BERT는 강력한 성능을 보이므로, 분석하고자 하는 많은 자연어 처리 문제에 적용할 수 있습니다. 실제 프로젝트에 사용하는 과정에서 여러 실험과 튜닝을 통해 최적의 결과를 얻을 수 있도록 해야 합니다. 트렌스포머 모델들은 빠르게 발전하고 있으므로, 지속적인 학습이 필요합니다.

더 궁금한 점이 있다면 언제든지 질문해 주세요!

허깅페이스 트렌스포머 활용강좌, 구글 코랩 환경 설정

딥러닝과 자연어 처리(NLP)의 발전에 따라 효율적이고 강력한 변환 모델들이 등장하였습니다. 그 중 하나가 허깅페이스(Hugging Face)의 트랜스포머(transformers) 라이브러리입니다. 이 강좌에서는 구글 코랩 환경에서 허깅페이스의 트랜스포머 라이브러리를 사용하는 방법과 기본적인 예제, 그리고 실제 코드 활용 방법에 대해 설명하겠습니다.

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

허깅페이스 트랜스포머 라이브러리는 다양한 최첨단 자연어 처리(NLP) 모델을 제공하는 오픈 소스 라이브러리입니다. BERT, GPT-2, RoBERTa, T5 등과 같은 모델을 쉽게 사용할 수 있으며, 이러한 모델들은 사전 훈련(pre-trained)되어 있어, 적은 데이터로도 높은 성능을 낼 수 있습니다. 이 라이브러리는 PyTorch와 TensorFlow 두 가지의 딥러닝 프레임워크를 지원합니다.

2. 구글 코랩 개요

구글 코랩(Google Colaboratory)은 클라우드 기반의 Jupyter 노트북 서비스입니다. 무료 GPU 리소스를 제공하여 사용자가 딥러닝 모델을 훈련하고 실행하기에 매우 유용한 환경을 제공합니다. 이 과정을 통해 구글 코랩을 활용하여 허깅페이스 트랜스포머 라이브러리를 사용하는 방법을 배워보겠습니다.

3. 구글 코랩 환경 설정하기

3.1 구글 코랩 접속하기

구글 코랩에 접속하려면 웹 브라우저에서 Google Colab을 방문하십시오. 구글 계정으로 로그인하면 새로운 노트북을 만들 수 있는 화면이 나타납니다.

3.2 새로운 노트북 만들기

오른쪽 상단의 ‘새 노트북(New Notebook)’ 버튼을 클릭하여 새로운 Jupyter 노트북을 생성합니다. 노트북의 이름을 설정하여 작업을 구분해줍니다.

3.3 런타임 유형 설정하기

구글 코랩에서는 GPU를 사용하여 모델을 훈련할 수 있습니다. 이를 위해 상단 메뉴에서 런타임(> Runtime) -> 런타임 유형 변경(> Change runtime type)을 선택합니다. ‘하드웨어 가속기(Hardware accelerator)’에서 ‘GPU’를 선택한 후 저장(Save) 버튼을 클릭합니다.

4. 허깅페이스 트랜스포머 라이브러리 설치하기

이제 코랩 환경에서 허깅페이스 트랜스포머 라이브러리를 설치해야 합니다. 아래의 코드를 입력하고 실행하여 라이브러리를 설치합니다.

!pip install transformers

5. 기본적인 활용 예시

설치가 완료되면 허깅페이스의 트랜스포머 라이브러리를 활용하여 텍스트 분류 작업을 수행해보겠습니다.

5.1 라이브러리 임포트 및 모델 초기화

import torch
from transformers import BertTokenizer, BertForSequenceClassification

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

5.2 입력문장 토크나이징 및 예측 수행

모델에 입력할 문장을 정의하고 이를 토크나이징하여 예측을 수행합니다.

# 입력 문장 정의
input_sentence = "I love programming with Python!"

# 문장을 토크나이징
inputs = tokenizer(input_sentence, return_tensors="pt")

# 모델 예측
with torch.no_grad():
    logits = model(**inputs).logits

# 예측 결과 출력
predicted_class = torch.argmax(logits, dim=1)
print(f"Predicted class: {predicted_class.item()}")

6. 결론

이번 강좌에서는 구글 코랩에서 허깅페이스 트랜스포머 라이브러리를 활용하는 방법에 대해 알아보았습니다. 환경 설정부터 기본적인 텍스트 분류 예제까지 모든 과정을 수행해보았으며, 이를 통해 NLP 모델을 쉽게 사용할 수 있는 방법을 배웠습니다. 허깅페이스의 트랜스포머 라이브러리는 다른 많은 기능도 제공하므로, 이를 바탕으로 다양한 프로젝트를 진행할 수 있을 것입니다.

7. 참고 자료

허깅페이스 트렌스포머 활용강좌, 감성 분석

이번 글에서는 자연어 처리(NLP)에서 자주 사용되는 허깅페이스 트랜스포머(Hugging Face Transformers) 라이브러리를 활용하여 감성 분석을 수행하는 방법에 대해 알아보겠습니다. 감성 분석은 텍스트 데이터를 통해 감정이나 감성을 추출하는 기술로, 다양한 분야에서 유용하게 사용됩니다.

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

허깅페이스 트랜스포머 라이브러리는 다양한 사전 학습된 자연어 처리 모델을 쉽게 사용할 수 있게 해주는 파이썬 라이브러리입니다. BERT, GPT-2, T5 등 여러 종류의 모델을 지원하며, 특히 Fine-tuning이 용이하여 다양한 작업에 맞게 모델을 조정할 수 있습니다.

2. 감성 분석의 개요

감성 분석은 주로 아래와 같은 작업을 포함합니다:

  • 문서의 전반적인 감정 상태(긍정, 부정, 중립)
  • 제품 리뷰의 세부 감정
  • 소셜 미디어 포스트의 감정 추적

감성 분석은 머신러닝, 딥러닝의 기법을 통해 구현할 수 있으며, 학습 데이터의 품질과 양이 결과에 큰 영향을 미칩니다.

3. 환경 설정

이 강좌를 진행하기 위해 필요한 라이브러리를 설치하겠습니다. 아래의 명령어를 사용하여 허깅페이스 트랜스포머와 토큰화 라이브러리인 transformerstorch를 설치하세요.

pip install transformers torch

4. 데이터셋 준비하기

감성 분석을 위한 데이터셋으로는 유명한 IMDb 영화 리뷰 데이터셋을 사용할 것입니다. 이 데이터셋은 영화에 대한 긍정적 또는 부정적인 리뷰를 포함하고 있습니다.

from sklearn.datasets import fetch_openml

data = fetch_openml('IMDb', version=1)
texts, labels = data['data'], data['target']

5. 데이터 전처리

데이터를 모델에 입력할 수 있도록 전처리하겠습니다. 텍스트를 정제하고, 레이블을 숫자로 변환하는 과정이 필요합니다.

import pandas as pd

df = pd.DataFrame({'text': texts, 'label': labels})
df['label'] = df['label'].apply(lambda x: 1 if x == 'pos' else 0)
texts = df['text'].tolist()
labels = df['label'].tolist()

6. 모델 불러오기

감성 분석을 위한 사전 학습된 BERT 모델을 불러오겠습니다. 또한, 텍스트를 토큰화하고 모델에 입력할 수 있는 형식으로 변환합니다.

from transformers import AutoTokenizer, AutoModelForSequenceClassification

model_name = 'nlptown/bert-base-multilingual-uncased-sentiment'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

7. 텍스트 토큰화

모델에 입력할 수 있도록 텍스트를 토큰화합니다. 각 리뷰를 모델에 입력하기 위해서 적절한 형태로 변환하는 과정입니다.

encodings = tokenizer(texts, truncation=True, padding=True, max_length=128, return_tensors="pt")

8. 모델 학습

모델을 학습시키기 위해서는 주어진 데이터로 Fine-tuning을 수행해야 합니다. 이제 PyTorch의 데이터 로더를 사용하여 데이터셋을 구성하겠습니다.

import torch
from torch.utils.data import DataLoader, Dataset

class SentimentDataset(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)

dataset = SentimentDataset(encodings, labels)
train_loader = DataLoader(dataset, batch_size=16, shuffle=True)

9. 모델 훈련

모델을 훈련하기 위해 손실 함수와 옵티마이저를 정의하고, 에포크에 걸쳐 훈련을 진행합니다.

from transformers import AdamW

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

model.train()
for epoch in range(3):
    for batch in train_loader:
        optimizer.zero_grad()
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        print(f'Epoch: {epoch}, Loss: {loss.item()}')

10. 모델 평가

모델을 평가하여 성능을 확인해보겠습니다. 검증 데이터셋을 사용하여 정확도와 손실을 측정합니다.

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for batch in train_loader:
        outputs = model(**batch)
        predictions = outputs.logits.argmax(dim=-1)
        correct += (predictions == batch['labels']).sum().item()
        total += batch['labels'].size(0)

accuracy = correct / total
print(f'Accuracy: {accuracy}')

11. 예측하기

모델이 학습이 완료되면 새로운 데이터에 대한 예측을 진행할 수 있습니다. 아래는 실제 예측을 하는 예제 코드입니다.

def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True, max_length=128)
    with torch.no_grad():
        outputs = model(**inputs)
    prediction = outputs.logits.argmax(dim=-1)
    return '긍정' if prediction.item() == 1 else '부정'

test_text = "이 영화는 정말 재미있었습니다!"
print(f'예측: {predict_sentiment(test_text)}')

12. 결론

이 글에서는 허깅페이스 트랜스포머 라이브러리를 활용하여 감성 분석을 수행하는 전 과정을 살펴보았습니다. 모델을 Fine-tuning하고 실제 데이터를 예측하는 과정을 통해 딥러닝 모델의 활용 가능성을 확인할 수 있었습니다. 앞으로도 다양한 자연어 처리 작업에 허깅페이스 트랜스포머를 응용할 수 있을 것입니다.

13. 참고 문헌