Transformers documentation
Görsel soru yanıtlama
Görsel soru yanıtlama
Görsel Soru Cevaplama (VQA), bir görsel temelinde açık uçlu soruları yanıtlama görevidir. Bu görevi destekleyen modellere verilen girdi genellikle bir görsel ile bir sorunun birleşimidir ve çıktı, doğal dilde ifade edilen bir cevaptır.
VQA için bazı dikkat çekici kullanım senaryosu örnekleri şunlardır:
- Görme engelli bireyler için erişilebilirlik uygulamaları.
- Eğitim: derslerde veya ders kitaplarında sunulan görsel materyaller hakkında sorular sorma. VQA, interaktif müze sergilerinde veya tarihi mekanlarda da kullanılabilir.
- Müşteri hizmetleri ve e-ticaret: VQA, kullanıcıların ürünler hakkında soru sormasına olanak tanıyarak kullanıcı deneyimini iyileştirebilir.
- Görsel geri getirme: VQA modelleri, belirli özelliklere sahip görselleri geri getirmek için kullanılabilir. Örneğin, kullanıcı bir görsel kümesinden köpek içeren tüm görselleri bulmak için “Bir köpek var mı?” diye sorabilir.
Bu kılavuzda şunları öğreneceksiniz:
Graphcore/vqaveri setinde sınıflandırma VQA modeli, özellikle ViLT, ince ayar yapın.- İnce ayarladığınız ViLT'yi çıkarım için kullanın.
- BLIP-2 gibi üretken bir modelle sıfır atışlı VQA çıkarımı çalıştırın.
ViLT'yi ince ayar
ViLT modeli, metin gömlemlerini Vision Transformer (ViT) içine entegre ederek Vision-and-Language Pre-training (VLP) için minimal bir tasarıma sahip olmasını sağlar. Bu model, çeşitli aşağı akış görevlerinde kullanılabilir. VQA görevi için, [CLS] token'ının son gizli durumunun üzerine yerleştirilen ve rastgele başlatılan bir sınıflandırıcı başlığı (doğrusal katman) eklenir. Bu nedenle Görsel Soru Cevaplama bir sınıflandırma problemi olarak ele alınır.
BLIP, BLIP-2 ve InstructBLIP gibi daha yeni modeller, VQA’yı üretken bir görev olarak ele alır. Bu kılavuzun ilerleyen bölümlerinde, bunların sıfır atışlı (zero-shot) VQA çıkarımı için nasıl kullanılacağını gösteriyoruz.
Başlamadan önce, gerekli tüm kütüphanelerin yüklü olduğundan emin olun.
pip install -q transformers datasets
Modelinizi toplulukla paylaşmanızı öneririz. 🤗 Hub'a yüklemek için Hugging Face hesabınıza giriş yapın. İstenildiğinde giriş yapmak için token'ınızı girin:
>>> from huggingface_hub import notebook_login
>>> notebook_login()Model kontrol noktasını küresel bir değişken olarak tanımlayalım.
>>> model_checkpoint = "dandelin/vilt-b32-mlm"Verileri yükleyin
İllüstrasyon amaçlı olarak bu kılavuzda, etiketlenmiş görsel soru-cevap Graphcore/vqa veri setinin çok küçük bir örneğini kullanıyoruz.
Tam veri setini 🤗 Hub üzerinde bulabilirsiniz.
Graphcore/vqa veri setinin bir alternatifi olarak, aynı verileri resmi VQA veri seti sayfasından manuel olarak indirebilirsiniz. Özel verilerinizle öğreticiyi takip etmeyi tercih ediyorsanız, 🤗 Datasets dokümantasyonundaki Görsel veri seti oluşturma rehberine göz atın.
Doğrulama bölüntüsünden ilk 200 örneği yükleyip veri setinin özelliklerini inceleyelim:
>>> from datasets import load_dataset
>>> dataset = load_dataset("Graphcore/vqa", split="validation[:200]")
>>> dataset
Dataset({
features: ['question', 'question_type', 'question_id', 'image_id', 'answer_type', 'label'],
num_rows: 200
})Veri setinin özelliklerini anlamak için bir örneğe bakalım:
>>> dataset[0]
{'question': 'Where is he looking?',
'question_type': 'none of the above',
'question_id': 262148000,
'image_id': '/root/.cache/huggingface/datasets/downloads/extracted/ca733e0e000fb2d7a09fbcc94dbfe7b5a30750681d0e965f8e0a23b1c2f98c75/val2014/COCO_val2014_000000262148.jpg',
'answer_type': 'other',
'label': {'ids': ['at table', 'down', 'skateboard', 'table'],
'weights': [0.30000001192092896,
1.0,
0.30000001192092896,
0.30000001192092896]}}Görevle ilgili özellikler şunları içerir:
question: görüntüden yanıtlanması gereken soruimage_id: sorunun atıfta bulunduğu görselin yolulabel: etiketler
Gerekli olmadıkları için diğer özellikleri kaldırabiliriz:
>>> dataset = dataset.remove_columns(['question_type', 'question_id', 'answer_type'])Gördüğünüz gibi, label özelliği, farklı insan etiketleyiciler tarafından toplanan aynı soruya (burada ids olarak adlandırılır) verilen birkaç cevabı içerir.
Bunun nedeni, bir sorunun cevabının öznel olabilmesidir. Bu durumda soru “where is he looking?” şeklindedir. Bazı kişiler bunu “down” olarak etiketlerken, diğerleri “at table”, bir diğeri ise “skateboard” olarak etiketlemiştir vb.
Görseli inceleyin ve hangi cevabı vereceğinizi düşünün:
>>> from PIL import Image
>>> image = Image.open(dataset[0]['image_id'])
>>> image
Soruların ve cevapların belirsizliği nedeniyle, bu tür veri setleri çok etiketli sınıflandırma problemi olarak ele alınır (birden fazla cevabın geçerli olma olasılığı vardır). Ayrıca, yalnızca tek-sıcak (one-hot) kodlanmış bir vektör oluşturmak yerine, belirli bir cevabın etiketlemelerde kaç kez göründüğüne dayalı yumuşak bir kodlama oluşturulur.
Örneğin, yukarıdaki örnekte “down” cevabı diğer cevaplardan çok daha sık seçildiği için 1.0 puanı (veri setinde weight olarak adlandırılır) alır ve kalan cevapların puanları < 1.0’dur.
Daha sonra modeli uygun bir sınıflandırma başlığıyla örneklemek için, etiket adını bir tam sayıya ve tam sayıyı etiket adına eşleyen iki sözlük oluşturalım:
>>> import itertools
>>> labels = [item['ids'] for item in dataset['label']]
>>> flattened_labels = list(itertools.chain(*labels))
>>> unique_labels = list(set(flattened_labels))
>>> label2id = {label: idx for idx, label in enumerate(unique_labels)}
>>> id2label = {idx: label for label, idx in label2id.items()}Eşlemeler hazır olduğuna göre, artık metin yanıtlarını kimlikleriyle değiştirebilir ve daha uygun bir sonraki ön işleme için veri setini düzleştirebiliriz.
>>> def replace_ids(inputs):
... inputs["label"]["ids"] = [label2id[x] for x in inputs["label"]["ids"]]
... return inputs
>>> dataset = dataset.map(replace_ids)
>>> flat_dataset = dataset.flatten()
>>> flat_dataset.features
{'question': Value(dtype='string', id=None),
'image_id': Value(dtype='string', id=None),
'label.ids': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None),
'label.weights': Sequence(feature=Value(dtype='float64', id=None), length=-1, id=None)}Veri ön işleme
Bir sonraki adım, görüntü ve metin verilerini model için hazırlamak üzere bir ViLT işlemcisini yüklemektir. ViltProcessor, bir BERT belirteçleyicisini ve ViLT görüntü işleyicisini kullanışlı bir tek işlemci içinde birleştirir:
>>> from transformers import ViltProcessor
>>> processor = ViltProcessor.from_pretrained(model_checkpoint)Verileri ön işlemek için görüntüleri ve soruları ViltProcessor ile kodlamamız gerekir. İşleyici, metni belirteçlere ayırmak ve metin verisi için input_ids, attention_mask ve token_type_ids oluşturmak üzere BertTokenizerFast kullanır.
Görüntüler için ise işleyici, görüntüyü yeniden boyutlandırmak ve normalize etmek için ViltImageProcessor kullanır ve pixel_values ile pixel_mask oluşturur.
Tüm bu ön işleme adımları arka planda gerçekleştirilir; biz yalnızca processor nesnesini çağırmamız yeterlidir. Bununla birlikte, hedef etiketleri hazırlamamız hâlâ gerekmektedir. Bu gösterimde her öğe, olası bir cevaba (etikete) karşılık gelir. Doğru cevaplar için öğe, ilgili puanını (ağırlığını) barındırırken, kalan öğeler sıfıra ayarlanır.
Aşağıdaki fonksiyon, processor’u görsellere ve sorulara uygular ve etiketleri yukarıda belirtildiği gibi biçimlendirir:
>>> import torch
>>> def preprocess_data(examples):
... image_paths = examples['image_id']
... images = [Image.open(image_path) for image_path in image_paths]
... texts = examples['question']
... encoding = processor(images, texts, padding="max_length", truncation=True, return_tensors="pt")
... for k, v in encoding.items():
... encoding[k] = v.squeeze()
... targets = []
... for labels, scores in zip(examples['label.ids'], examples['label.weights']):
... target = torch.zeros(len(id2label))
... for label, score in zip(labels, scores):
... target[label] = score
... targets.append(target)
... encoding["labels"] = targets
... return encodingTüm veri setine ön işleme fonksiyonunu uygulamak için 🤗 Datasets map fonksiyonunu kullanın. map işlemini hızlandırmak için batched=True ayarını yaparak veri setinin birden çok öğesini aynı anda işleyebilirsiniz. Bu aşamada, ihtiyaç duymadığınız sütunları kaldırmakta serbestsiniz.
>>> processed_dataset = flat_dataset.map(preprocess_data, batched=True, remove_columns=['question','question_type', 'question_id', 'image_id', 'answer_type', 'label.ids', 'label.weights'])
>>> processed_dataset
Dataset({
features: ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values', 'pixel_mask', 'labels'],
num_rows: 200
})Son adım olarak, DefaultDataCollator kullanarak örneklerden oluşan bir parti oluşturun:
>>> from transformers import DefaultDataCollator
>>> data_collator = DefaultDataCollator()Modeli eğitin
Artık modelinizi eğitmeye hazırsınız! ViLT'yi ViltForQuestionAnswering ile yükleyin. Etiket sayısını ve etiket eşlemelerini belirtin:
>>> from transformers import ViltForQuestionAnswering
>>> model = ViltForQuestionAnswering.from_pretrained(model_checkpoint, num_labels=len(id2label), id2label=id2label, label2id=label2id)Bu noktada yalnızca üç adım kaldı:
- Eğitim hiperparametrelerinizi TrainingArguments içinde tanımlayın:
>>> from transformers import TrainingArguments
>>> repo_id = "MariaK/vilt_finetuned_200"
>>> training_args = TrainingArguments(
... output_dir=repo_id,
... per_device_train_batch_size=4,
... num_train_epochs=20,
... save_steps=200,
... logging_steps=50,
... learning_rate=5e-5,
... save_total_limit=2,
... remove_unused_columns=False,
... push_to_hub=True,
... )- Eğitim argümanlarını, model, veri seti, işlemci ve veri toplayıcıyla birlikte Trainer'a iletin.
>>> from transformers import Trainer
>>> trainer = Trainer(
... model=model,
... args=training_args,
... data_collator=data_collator,
... train_dataset=processed_dataset,
... processing_class=processor,
... )- Modelinizi ince ayar yapmak için train() çağrın.
>>> trainer.train()Eğitim tamamlandıktan sonra, nihai modelinizi 🤗 Hub'da paylaşmak için push_to_hub() yöntemini kullanın:
>>> trainer.push_to_hub()Çıkarım
Artık bir ViLT modelini ince ayarladınız ve 🤗 Hub'a yüklediniz; bu modeli çıkarım (inference) için kullanabilirsiniz.
- Bir görüntü ve bir soru alın ve bunları, modelinizden gelen processor kullanarak modele hazırlayın.
- Sonucu veya ön işleme adımını modele iletin.
- Logitlerden en olası cevabın kimliğini alın ve gerçek cevabı
id2labeliçinde bulun.
>>> processor = ViltProcessor.from_pretrained("MariaK/vilt_finetuned_200")
>>> image = Image.open(example['image_id'])
>>> question = example['question']
>>> # prepare inputs
>>> inputs = processor(image, question, return_tensors="pt")
>>> model = ViltForQuestionAnswering.from_pretrained("MariaK/vilt_finetuned_200")
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: downSıfır atışlı VQA
Önceki model, VQA'yı bir sınıflandırma görevi olarak ele alıyordu. BLIP, BLIP-2 ve InstructBLIP gibi bazı son modeller, VQA'yı üretken bir görev olarak ele alıyor. BLIP-2'yi bir örnek olarak ele alalım. Bu model, önceden eğitilmiş herhangi bir görme kodlayıcı ve LLM kombinasyonunun kullanılabildiği yeni bir görsel-dil ön eğitimi paradigmi tanıttı (daha fazla bilgi için BLIP-2 blog yazısına göz atın). Bu sayede, görsel soru yanıtlama dahil olmak üzere çeşitli görsel-dil görevlerinde en iyi sonuçlara ulaşmak mümkün hale geliyor.
Bu modeli VQA için nasıl kullanabileceğinizi gösterelim. Önce modeli yükleyelim. Burada, eğitim sırasında Trainer bu işi otomatik olarak yaptığı için yapmamız gerekmediği halde, modelin mevcut bir GPU’ya gönderilmesini açıkça belirtiyoruz:
>>> from transformers import AutoProcessor, Blip2ForConditionalGeneration
from accelerate import Accelerator
>>> import torch
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2ForConditionalGeneration.from_pretrained("Salesforce/blip2-opt-2.7b", dtype=torch.float16)
>>> device = Accelerator().device
>>> model.to(device)Model, girdi olarak görüntü ve metin alır; bu nedenle VQA veri setindeki ilk örnekteki tam olarak aynı görüntü/soru çiftini kullanalım:
>>> example = dataset[0]
>>> image = Image.open(example['image_id'])
>>> question = example['question']BLIP-2'yi görsel soru yanıtlama görevi için kullanmak için metinsel istemin belirli bir biçimi izlemesi gerekir: Question: {} Answer:.
>>> prompt = f"Question: {question} Answer:"Şimdi görüntüyü/istemi modelin işlemcisiyle ön işlemeye, işlenmiş girdiyi modelden geçirmeye ve çıktıyı çözmeye ihtiyacımız var:
>>> inputs = processor(image, text=prompt, return_tensors="pt").to(device, torch.float16)
>>> generated_ids = model.generate(**inputs, max_new_tokens=10)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
"He is looking at the crowd"Gördüğünüz gibi model kalabalığı ve yüzün yönünü (aşağı bakış) tanımladı; ancak kalabalığın kaykaycının arkasında olduğu gerçeğini gözden kaçırmış gibi görünüyor. Yine de, insan etiketli veri setleri edinmenin mümkün olmadığı durumlarda bu yaklaşım, faydalı sonuçları hızla üretebilir.
Update on GitHub