transformers 라이브러리 - Hugging Face Transformer

transformers는 자연어처리를 위해 필수적인 라이브러리 입니다.

 

Transormer 모델을 쉽게 구현할 수 있도록 도와주는 도구로, 주요 기능과 예시코드를 소개합니다.

 

 

---

Transformer 모델

Transformer 모델은 2017년 "Attention Is All You Need" 논문에서 처음 소개된 아키텍처입니다.

 

발표 이후에 대규모 자연어처리 모델의 메인 스트림으로 자리잡게 되었습니다.

 

Transformer 모델은 문맥을 효과적으로 파악하면서도 대규모 데이터와 병렬 처리를 가능하도록 만들었습니다.

 

 

---

transformers 라이브러리 기능

Hugging Face에서 개발한 파이썬 라이브러리로 Transformer 모델을 쉽게 구현할 수 있도록 도와줍니다.

 

1. 다양한 Pre-trained 모델 제공

GPT, BERT, RoBERTa, T5, DistilBERT, 등 다양한 사전 훈련된 트랜스포머 모델을 불러오고 사용할 수 있습니다.

사용 가능한 사전학습 모델은 아래 링크에서 확인할 수 있습니다.

Models - Hugging Face

 

2. 토크나이저

입력 텍스트를 토큰으로 분할하고 모델이 이해할 수 있는 형식으로 변환하기 위한 토크나이저를 제공합니다.

 

3. 모델 파인 튜닝

사전 훈련된 모델을 다양한 NLP 작업에 맞게 파인 튜닝하고 훈련할 수 있습니다.

 

4. PyTorch 및 TensorFlow 지원

PyTorch와 TensorFlow 두 가지 주요 딥러닝 프레임워크를 모두 지원합니다.

 

 

---

transformers 예시 코드

PyTorch, Tensorflow 프레임워크를 모두 제공하여 더 필요한 프레임워크를 선택하여 사용할 수 있습니다.

 

1.PyTorch 사용

# 필요한 라이브러리 설치
!pip install transformers torch

import torch
from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments
from sklearn.model_selection import train_test_split
from torch.utils.data import DataLoader, Dataset

# IMDB 데이터셋 로드
from transformers import pipeline
classifier = pipeline('sentiment-analysis')

# IMDB 데이터 로드
data = classifier("This movie is great!")

# 사전 훈련된 BERT 모델 및 토크나이저 로드
model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)

# 데이터 전처리
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length):
        self.encodings = tokenizer(texts, truncation=True, padding=True, max_length=max_length, return_tensors='pt')
        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)

# 훈련 및 검증 데이터 나누기
texts = ["This is a positive review.", "This is a negative review."]
labels = [1, 0]

train_texts, val_texts, train_labels, val_labels = train_test_split(texts, labels, test_size=0.2)

# 데이터셋 및 데이터로더 설정
max_length = 128
train_dataset = CustomDataset(train_texts, train_labels, tokenizer, max_length)
val_dataset = CustomDataset(val_texts, val_labels, tokenizer, max_length)

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

# 훈련 설정
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    evaluation_strategy="steps",
    eval_steps=500,
    save_steps=1000,
    save_total_limit=2,
    load_best_model_at_end=True,
    evaluation_strategy="steps",
    save_steps=500,
)

# 훈련 시작
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
)

trainer.train()

# 훈련된 모델로 추론 수행
test_texts = ["This movie is terrible.", "I loved this film."]
test_dataset = CustomDataset(test_texts, [0, 1], tokenizer, max_length)
test_loader = DataLoader(test_dataset, batch_size=8)
predictions = trainer.predict(test_dataset=test_loader)
print(predictions.predictions)

 

 

2. tensorflow 사용

# 필요한 라이브러리 설치
!pip install transformers tensorflow

import tensorflow as tf
from transformers import BertTokenizer, TFBertForSequenceClassification
from transformers import pipeline
from sklearn.model_selection import train_test_split

# IMDB 데이터셋 로드
classifier = pipeline('sentiment-analysis')
data = classifier("This movie is great!")

# IMDB 데이터 로드
data = classifier("This movie is great!")

# 사전 훈련된 BERT 모델 및 토크나이저 로드
model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = TFBertForSequenceClassification.from_pretrained(model_name)

# 데이터 전처리
texts = ["This is a positive review.", "This is a negative review."]
labels = [1, 0]

# 훈련 및 검증 데이터 나누기
train_texts, val_texts, train_labels, val_labels = train_test_split(texts, labels, test_size=0.2)

# 데이터 토크나이징 및 인코딩
train_encodings = tokenizer(train_texts, truncation=True, padding=True, return_tensors='tf')
val_encodings = tokenizer(val_texts, truncation=True, padding=True, return_tensors='tf')

train_dataset = tf.data.Dataset.from_tensor_slices((
    dict(train_encodings),
    train_labels
))

val_dataset = tf.data.Dataset.from_tensor_slices((
    dict(val_encodings),
    val_labels
))

# 모델 훈련 설정
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-5)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
metric = tf.keras.metrics.SparseCategoricalAccuracy('accuracy')

model.compile(optimizer=optimizer, loss=loss, metrics=[metric])

# 모델 훈련
model.fit(train_dataset.shuffle(1000).batch(8), validation_data=val_dataset.batch(8), epochs=3)

# 모델 평가
test_texts = ["This movie is terrible.", "I loved this film."]
test_labels = [0, 1]

test_encodings = tokenizer(test_texts, truncation=True, padding=True, return_tensors='tf')
test_dataset = tf.data.Dataset.from_tensor_slices((
    dict(test_encodings),
    test_labels
))

results = model.evaluate(test_dataset.batch(8))
print("Test accuracy:", results[1])