Transformers documentation

이미지 캡셔닝

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

이미지 캡셔닝

이미지 캡셔닝은 주어진 이미지에 대한 캡션을 예측하는 작업입니다. 일반적인 실생활 응용 분야에는 시각 장애인의 다양한 상황 내 이동을 돕는 것이 포함됩니다. 따라서 이미지 캡셔닝은 이미지를 설명함으로써 사용자의 콘텐츠 접근성을 향상시키는 데 기여합니다.

이 가이드에서는 다음 내용을 보여 드립니다:

  • 이미지 캡셔닝 모델을 fine-tune합니다.
  • 파인튜닝된 모델을 추론에 사용합니다.

시작하기 전에 필요한 라이브러리가 모두 설치되어 있는지 확인하세요:

pip install transformers datasets evaluate -q
pip install jiwer -q

모델을 업로드하여 커뮤니티와 공유할 수 있도록 Hugging Face 계정에 로그인하는 것을 권장합니다. 프롬프트가 표시되면 토큰을 입력하여 로그인하세요:

from huggingface_hub import notebook_login

notebook_login()

Pokémon BLIP 캡션 데이터셋을 로드합니다

🤗 Dataset 라이브러리를 사용하여 {image-caption} 쌍으로 구성된 데이터셋을 로드합니다. PyTorch에서 자체 이미지 캡셔닝 데이터셋을 만들려면 이 노트북을 참고하세요.

from datasets import load_dataset

ds = load_dataset("lambdalabs/pokemon-blip-captions")
ds
DatasetDict({
    train: Dataset({
        features: ['image', 'text'],
        num_rows: 833
    })
})

데이터셋에는 image와 text라는 두 가지 기능이 있습니다.

많은 이미지 캡셔닝 데이터셋에는 이미지당 여러 개의 캡션이 포함되어 있습니다. 이러한 경우, 학습 중에는 사용 가능한 캡션에서 무작위로 하나를 샘플링하는 것이 일반적인 전략입니다.

train_test_split 메서드를 사용하여 데이터셋의 train split을 train set과 test set으로 분리합니다:

ds = ds["train"].train_test_split(test_size=0.1)
train_ds = ds["train"]
test_ds = ds["test"]

학습 세트에서 몇 가지 샘플을 시각화해 보겠습니다.

from textwrap import wrap
import matplotlib.pyplot as plt
import numpy as np


def plot_images(images, captions):
    plt.figure(figsize=(20, 20))
    for i in range(len(images)):
        ax = plt.subplot(1, len(images), i + 1)
        caption = captions[i]
        caption = "\n".join(wrap(caption, 12))
        plt.title(caption)
        plt.imshow(images[i])
        plt.axis("off")


sample_images_to_visualize = [np.array(train_ds[i]["image"]) for i in range(5)]
sample_captions = [train_ds[i]["text"] for i in range(5)]
plot_images(sample_images_to_visualize, sample_captions)
Sample training images

데이터셋 전처리

데이터셋에는 두 가지 모달리티(이미지와 텍스트)가 있으므로, 전처리 파이프라인은 이미지와 캡션을 전처리합니다.

이를 위해, 파인튜닝하려는 모델에 해당하는 프로세서 클래스를 로드합니다.

from transformers import AutoProcessor

checkpoint = "microsoft/git-base"
processor = AutoProcessor.from_pretrained(checkpoint)

processor는 내부적으로 이미지를 전처리(리사이징 및 픽셀 스케일링 포함)하고 캡션을 토큰화합니다.

def transforms(example_batch):
    images = [x for x in example_batch["image"]]
    captions = [x for x in example_batch["text"]]
    inputs = processor(images=images, text=captions, padding="max_length")
    inputs.update({"labels": inputs["input_ids"]})
    return inputs


train_ds.set_transform(transforms)
test_ds.set_transform(transforms)

데이터셋이 준비되면 이제 fine-tuning을 위해 모델을 설정할 수 있습니다.

베이스 모델 로드

“microsoft/git-base”를 AutoModelForCausalLM 객체로 로드합니다.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(checkpoint)

평가

이미지 캡셔닝 모델은 일반적으로 Rouge Score 또는 Word Error Rate로 평가됩니다. 이 가이드에서는 Word Error Rate(WER)를 사용합니다.

이를 위해 🤗 Evaluate 라이브러리를 사용합니다. WER의 잠재적 한계 및 기타 주의사항에 대해서는 이 가이드를 참고하세요.

from evaluate import load
import torch

wer = load("wer")


def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predicted = logits.argmax(-1)
    decoded_labels = processor.batch_decode(labels, skip_special_tokens=True)
    decoded_predictions = processor.batch_decode(predicted, skip_special_tokens=True)
    wer_score = wer.compute(predictions=decoded_predictions, references=decoded_labels)
    return {"wer_score": wer_score}

학습

이제 모델을 fine-tuning할 준비가 되었습니다. 이를 위해 🤗 Trainer를 사용합니다.

먼저 TrainingArguments를 사용하여 학습 인수를 정의합니다.

from transformers import TrainingArguments, Trainer

model_name = checkpoint.split("/")[1]

training_args = TrainingArguments(
    output_dir=f"{model_name}-pokemon",
    learning_rate=5e-5,
    num_train_epochs=50,
    fp16=True,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=32,
    gradient_accumulation_steps=2,
    save_total_limit=3,
    eval_strategy="steps",
    eval_steps=50,
    save_strategy="steps",
    save_steps=50,
    logging_steps=50,
    remove_unused_columns=False,
    push_to_hub=True,
    label_names=["labels"],
    load_best_model_at_end=True,
)

그런 다음 데이터셋과 모델과 함께 🤗 Trainer에 전달합니다.

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
    eval_dataset=test_ds,
    compute_metrics=compute_metrics,
)

학습을 시작하려면 Trainer 객체에 train()을 호출하기만 하면 됩니다.

trainer.train()

학습이 진행됨에 따라 학습 손실이 매끄럽게 감소하는 것을 확인할 수 있습니다.

학습이 완료되면 push_to_hub() 메서드를 사용하여 모델을 Hub에 공유하여 누구나 모델을 사용할 수 있도록 하세요:

trainer.push_to_hub()

추론

test_ds에서 샘플 이미지를 가져와 모델을 테스트합니다.

from PIL import Image
import requests

url = "https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"
image = Image.open(requests.get(url, stream=True).raw)
image
Test image

모델을 위해 이미지를 준비합니다.

from accelerate import Accelerator

device = Accelerator().device
inputs = processor(images=image, return_tensors="pt").to(device)
pixel_values = inputs.pixel_values

generate를 호출하고 예측을 디코딩합니다.

generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_caption)
a drawing of a pink and blue pokemon

fine-tuned model이 꽤 좋은 캡션을 생성한 것 같습니다!

Update on GitHub