Generowanie danych wyjściowych PaliGemma za pomocą Keras

Wyświetl na ai.google.dev Uruchom w Google Colab Otwórz w Vertex AI Wyświetl źródło na GitHubie

Modele PaliGemma mają możliwości multimodalne, co pozwala generować dane wyjściowe przy użyciu danych wejściowych w formie tekstu i obrazów. Możesz używać danych obrazów z tymi modelami, aby dostarczać dodatkowy kontekst do swoich żądań, lub używać modelu do analizowania zawartości obrazów. W tym samouczku pokazujemy, jak używać modelu PaliGemma z Keras do analizowania obrazów i odpowiadania na pytania dotyczące tych obrazów.

Co zawiera ten notatnik

Ten notatnik używa modelu PaliGemma z Keras i pokazuje, jak:

  • Instalowanie biblioteki Keras i wymaganych zależności
  • Pobierz PaliGemmaCausalLM, wstępnie wytrenowaną odmianę modelu PaliGemma do przyczynowego modelowania języka wizualnego, i użyj jej do utworzenia modelu.
  • Sprawdź, czy model potrafi wywnioskować informacje o dostarczonych obrazach.

Zanim zaczniesz

Zanim zaczniesz korzystać z tego notatnika, musisz znać kod w języku Python i wiedzieć, jak trenuje się duże modele językowe (LLM). Nie musisz znać Keras, ale podstawowa wiedza na temat tej biblioteki będzie przydatna podczas czytania przykładowego kodu.

Konfiguracja

W sekcjach poniżej znajdziesz informacje o krokach wstępnych, które należy wykonać, aby notatnik mógł korzystać z modelu PaliGemma. Obejmują one uzyskanie dostępu do modelu, klucza interfejsu API i skonfigurowanie środowiska wykonawczego notatnika.

Uzyskiwanie dostępu do PaliGemma

Zanim po raz pierwszy użyjesz modelu PaliGemma, musisz poprosić o dostęp do niego na platformie Kaggle, wykonując te czynności:

  1. Zaloguj się na Kaggle lub utwórz nowe konto, jeśli jeszcze go nie masz.
  2. Otwórz kartę modelu PaliGemma i kliknij Poproś o dostęp.
  3. Wypełnij formularz zgody i zaakceptuj warunki.

Konfigurowanie klucza interfejsu API

Aby korzystać z PaliGemma, musisz podać nazwę użytkownika Kaggle i klucz interfejsu API Kaggle.

Aby wygenerować klucz interfejsu API Kaggle, otwórz stronę Ustawienia w Kaggle i kliknij Utwórz nowy token. Spowoduje to pobranie pliku kaggle.json zawierającego dane logowania do interfejsu API.

Następnie w Colab w panelu po lewej stronie kliknij Obiekty tajne (🔑) i dodaj nazwę użytkownika Kaggle oraz klucz interfejsu API Kaggle. Zapisz nazwę użytkownika pod nazwą KAGGLE_USERNAME, a klucz interfejsu API pod nazwą KAGGLE_KEY.

Wybierz środowisko wykonawcze

Aby ukończyć ten samouczek, musisz mieć środowisko wykonawcze Colab z zasobami wystarczającymi do uruchomienia modelu PaliGemma. W takim przypadku możesz użyć procesora graficznego T4:

  1. W prawym górnym rogu okna Colab kliknij menu ▾ (Dodatkowe opcje połączenia).
  2. Wybierz Zmień typ środowiska wykonawczego.
  3. W sekcji Akcelerator sprzętowy wybierz GPU T4.

Ustawianie zmiennych środowiskowych

Ustaw zmienne środowiskowe dla KAGGLE_USERNAME, KAGGLE_KEY i KERAS_BACKEND.

import os
from google.colab import userdata

# Set up environmental variables
os.environ["KAGGLE_USERNAME"] = userdata.get('KAGGLE_USERNAME')
os.environ["KAGGLE_KEY"] = userdata.get('KAGGLE_KEY')
os.environ["KERAS_BACKEND"] = "jax"

Instalowanie Keras

Uruchom komórkę poniżej, aby zainstalować Keras.

pip install -U -q keras-nlp keras-hub kagglehub

Importowanie zależności i konfigurowanie Keras

Zainstaluj zależności potrzebne do tego notatnika i skonfiguruj backend Keras. Ustawisz też Keras na używanie bfloat16, aby platforma korzystała z mniejszej ilości pamięci.

import keras
import keras_hub
import numpy as np
import PIL
import requests
import io
import matplotlib
import re
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from PIL import Image

keras.config.set_floatx("bfloat16")

Wczytywanie modelu

Po skonfigurowaniu wszystkiego możesz pobrać wstępnie wytrenowany model i utworzyć kilka metod pomocniczych, które pomogą mu generować odpowiedzi. W tym kroku pobierzesz model z Keras Hub za pomocą PaliGemmaCausalLM. Ta klasa pomaga zarządzać strukturą przyczynowego wizualnego modelu językowego PaliGemma i ją uruchamiać. Przyczynowy wizualny model językowy przewiduje następny token na podstawie poprzednich tokenów. Keras Hub udostępnia implementacje wielu popularnych architektur modeli.

Utwórz model za pomocą metody from_preset i wydrukuj jego podsumowanie. Ten proces zajmie około minuty.

paligemma = keras_hub.models.PaliGemmaCausalLM.from_preset("kaggle://keras/paligemma2/keras/pali_gemma2_mix_3b_224")
paligemma.summary()

Tworzenie metod narzędziowych

Aby ułatwić generowanie odpowiedzi z modelu, utwórz 2 metody narzędziowe:

  • crop_and_resize: metoda pomocnicza dla read_img. Ta metoda przycina i zmienia rozmiar obrazu do podanego rozmiaru, dzięki czemu ostateczny obraz jest przeskalowany bez zniekształcania proporcji.
  • read_img: metoda pomocnicza dla read_img_from_url. Ta metoda otwiera obraz, zmienia jego rozmiar, aby pasował do ograniczeń modelu, i umieszcza go w tablicy, którą model może zinterpretować.
  • read_img_from_url: Pobiera obraz za pomocą prawidłowego adresu URL. Ta metoda jest potrzebna do przekazania obrazu do modelu.

Symbolu read_img_from_url użyjesz w następnym kroku tego notatnika.

def crop_and_resize(image, target_size):
    width, height = image.size
    source_size = min(image.size)
    left = width // 2 - source_size // 2
    top = height // 2 - source_size // 2
    right, bottom = left + source_size, top + source_size
    return image.resize(target_size, box=(left, top, right, bottom))

def read_image(url, target_size):
    contents = io.BytesIO(requests.get(url).content)
    image = PIL.Image.open(contents)
    image = crop_and_resize(image, target_size)
    image = np.array(image)
    # Remove alpha channel if necessary.
    if image.shape[2] == 4:
        image = image[:, :, :3]
    return image

def parse_bbox_and_labels(detokenized_output: str):
  matches = re.finditer(
      '<loc(?P<y0>\d\d\d\d)><loc(?P<x0>\d\d\d\d)><loc(?P<y1>\d\d\d\d)><loc(?P<x1>\d\d\d\d)>'
      ' (?P<label>.+?)( ;|$)',
      detokenized_output,
  )
  labels, boxes = [], []
  fmt = lambda x: float(x) / 1024.0
  for m in matches:
    d = m.groupdict()
    boxes.append([fmt(d['y0']), fmt(d['x0']), fmt(d['y1']), fmt(d['x1'])])
    labels.append(d['label'])
  return np.array(boxes), np.array(labels)

def display_boxes(image, boxes, labels, target_image_size):
  h, l = target_size
  fig, ax = plt.subplots()
  ax.imshow(image)
  for i in range(boxes.shape[0]):
      y, x, y2, x2 = (boxes[i]*h)
      width = x2 - x
      height = y2 - y
      # Create a Rectangle patch
      rect = patches.Rectangle((x, y),
                               width,
                               height,
                               linewidth=1,
                               edgecolor='r',
                               facecolor='none')
      # Add label
      plt.text(x, y, labels[i], color='red', fontsize=12)
      # Add the patch to the Axes
      ax.add_patch(rect)

  plt.show()

def display_segment_output(image, bounding_box, segment_mask, target_image_size):
    # Initialize a full mask with the target size
    full_mask = np.zeros(target_image_size, dtype=np.uint8)
    target_width, target_height = target_image_size

    for bbox, mask in zip(bounding_box, segment_mask):
        y1, x1, y2, x2 = bbox
        x1 = int(x1 * target_width)
        y1 = int(y1 * target_height)
        x2 = int(x2 * target_width)
        y2 = int(y2 * target_height)

        # Ensure mask is 2D before converting to Image
        if mask.ndim == 3:
            mask = mask.squeeze(axis=-1)
        mask = Image.fromarray(mask)
        mask = mask.resize((x2 - x1, y2 - y1), resample=Image.NEAREST)
        mask = np.array(mask)
        binary_mask = (mask > 0.5).astype(np.uint8)


        # Place the binary mask onto the full mask
        full_mask[y1:y2, x1:x2] = np.maximum(full_mask[y1:y2, x1:x2], binary_mask)
    cmap = plt.get_cmap('jet')
    colored_mask = cmap(full_mask / 1.0)
    colored_mask = (colored_mask[:, :, :3] * 255).astype(np.uint8)
    if isinstance(image, Image.Image):
        image = np.array(image)
    blended_image = image.copy()
    mask_indices = full_mask > 0
    alpha = 0.5

    for c in range(3):
        blended_image[:, :, c] = np.where(mask_indices,
                                          (1 - alpha) * image[:, :, c] + alpha * colored_mask[:, :, c],
                                          image[:, :, c])

    fig, ax = plt.subplots()
    ax.imshow(blended_image)
    plt.show()

Generowanie danych wyjściowych

Po wczytaniu modelu i utworzeniu metod narzędziowych możesz przekazać do modelu dane obrazu i tekstu, aby wygenerować odpowiedzi. Modele PaliGemma są trenowane z użyciem określonej składni promptów do konkretnych zadań, takich jak answer, caption i detect. Więcej informacji o składni zadań w promptach PaliGemma znajdziesz w artykule Prompt i instrukcje systemowe PaliGemma.

Przygotuj obraz do użycia w prompcie generowania, wczytując obraz testowy do obiektu za pomocą tego kodu:

target_size = (224, 224)
image_url = 'https://storage.googleapis.com/keras-cv/models/paligemma/cow_beach_1.png'
cow_image = read_image(image_url, target_size)
matplotlib.pyplot.imshow(cow_image)

Odpowiadanie w określonym języku

Poniższy przykładowy kod pokazuje, jak poprosić model PaliGemma o informacje o obiekcie widocznym na przesłanym obrazie. W tym przykładzie użyto składni answer {lang} i wyświetlono dodatkowe pytania w innych językach:

prompt = 'answer en where is the cow standing?\n'
# prompt = 'svar no hvor står kuen?\n'
# prompt = 'answer fr quelle couleur est le ciel?\n'
# prompt = 'responda pt qual a cor do animal?\n'

output = paligemma.generate(
    inputs={
        "images": cow_image,
        "prompts": prompt,
    }
)
print(output)

Użyj prompta detect

Poniższy przykładowy kod używa składni promptu detect do zlokalizowania obiektu na podanym obrazie. Kod korzysta z wcześniej zdefiniowanych funkcji parse_bbox_and_labels() i display_boxes(), aby interpretować dane wyjściowe modelu i wyświetlać wygenerowane ramki ograniczające.

prompt = 'detect cow\n'
output = paligemma.generate(
    inputs={
        "images": cow_image,
        "prompts": prompt,
    }
)
boxes, labels = parse_bbox_and_labels(output)
display_boxes(cow_image, boxes, labels, target_size)

Użyj prompta segment

Ten przykładowy kod korzysta z segment składni prompta, aby zlokalizować obszar obrazu zajmowany przez obiekt. Korzysta z biblioteki big_vision Google, aby interpretować dane wyjściowe modelu i generować maskę dla segmentowanego obiektu.

Zanim zaczniesz, zainstaluj bibliotekę big_vision i jej zależności, jak pokazano w tym przykładzie kodu:

import os
import sys

# TPUs with
if "COLAB_TPU_ADDR" in os.environ:
  raise "It seems you are using Colab with remote TPUs which is not supported."

# Fetch big_vision repository if python doesn't know about it and install
# dependencies needed for this notebook.
if not os.path.exists("big_vision_repo"):
  !git clone --quiet --branch=main --depth=1 \
     https://github.com/google-research/big_vision big_vision_repo

# Append big_vision code to python import path
if "big_vision_repo" not in sys.path:
  sys.path.append("big_vision_repo")


# Install missing dependencies. Assume jax~=0.4.25 with GPU available.
!pip3 install -q "overrides" "ml_collections" "einops~=0.7" "sentencepiece"

W tym przykładzie segmentacji wczytaj i przygotuj inny obraz, na którym znajduje się kot.

cat = read_image('https://big-vision-paligemma.hf.space/file=examples/barsik.jpg', target_size)
matplotlib.pyplot.imshow(cat)

Oto funkcja, która pomoże Ci przeanalizować dane wyjściowe segmentu z PaliGemma

import  big_vision.evaluators.proj.paligemma.transfers.segmentation as segeval
reconstruct_masks = segeval.get_reconstruct_masks('oi')
def parse_segments(detokenized_output: str) -> tuple[np.ndarray, np.ndarray]:
  matches = re.finditer(
      '<loc(?P<y0>\d\d\d\d)><loc(?P<x0>\d\d\d\d)><loc(?P<y1>\d\d\d\d)><loc(?P<x1>\d\d\d\d)>'
      + ''.join(f'<seg(?P<s{i}>\d\d\d)>' for i in range(16)),
      detokenized_output,
  )
  boxes, segs = [], []
  fmt_box = lambda x: float(x) / 1024.0
  for m in matches:
    d = m.groupdict()
    boxes.append([fmt_box(d['y0']), fmt_box(d['x0']), fmt_box(d['y1']), fmt_box(d['x1'])])
    segs.append([int(d[f's{i}']) for i in range(16)])
  return np.array(boxes), np.array(reconstruct_masks(np.array(segs)))

Wysyłanie zapytania do modelu PaliGemma w celu segmentacji kota na obrazie

prompt = 'segment cat\n'
output = paligemma.generate(
    inputs={
        "images": cat,
        "prompts": prompt,
    }
)

Wyświetlanie wygenerowanej maski z PaliGemma

bboxes, seg_masks = parse_segments(output)
display_segment_output(cat, bboxes, seg_masks, target_size)

Prompty zbiorcze

W ramach jednego promptu możesz podać więcej niż 1 polecenie promptu jako grupę instrukcji. Poniższy przykład pokazuje, jak sformułować tekst prompta, aby podać kilka instrukcji.

prompts = [
    'answer en where is the cow standing?\n',
    'answer en what color is the cow?\n',
    'describe en\n',
    'detect cow\n',
    'segment cow\n',
]
images = [cow_image, cow_image, cow_image, cow_image, cow_image]
outputs = paligemma.generate(
    inputs={
        "images": images,
        "prompts": prompts,
    }
)
for output in outputs:
    print(output)