PaliGemma 2

हमारे Serverless Cloud API के माध्यम से Google के PaliGemma 2 विज़न-लैंग्वेज मॉडल का उपयोग करें

PaliGemma 2 गूगल का विज़न-लैंग्वेज मॉडल है। यह एक छवि और एक टेक्स्ट प्रॉम्प्ट स्वीकार करता है और एक टेक्स्ट प्रतिक्रिया लौटाता है। हम PaliGemma 2 को अपने सर्वरलेस क्लाउड API, समर्पित डिप्लॉयमेंट्स , और स्व-होस्टेड इनफ़ेरेंस.

कोड उदाहरण

1

अपनी API कुंजी प्राप्त करें

एक Roboflow खाता बनाएँ, अपनी कुंजी यहाँ खोजें Roboflow API सेटिंग्स पेज और इसे अपने शेल में उपलब्ध कराएँ:

export ROBOFLOW_API_KEY="your-key-here"

2

निर्भरताओं को इंस्टॉल करें

इंस्टॉल करें Inference SDK:

pip install -U inference-sdk supervision

3

मॉडल चलाएँ

नमूना प्रीट्रेंड paligemma2-3b-pt-224 चेकपॉइंट को एक कैप्शन प्रॉम्प्ट के साथ कॉल करता है।

import os
import supervision as sv
from inference_sdk import InferenceHTTPClient

image = sv.load_image_from_url("https://media.roboflow.com/quickstart/dog.jpeg")

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.infer_lmm(
    image,
    model_id="paligemma2-3b-pt-224",
    prompt="caption en",
    max_new_tokens=64,
)
print(result["response"])

ऊपर दिया गया कोड मॉडल की प्रतिक्रिया को टर्मिनल पर प्रिंट करता है:

यहाँ एक कुत्ता एक आदमी के कंधे पर दिखाई दे रहा है

इन्फरेंस गति

लेटेंसी मापी गई Roboflow Inference 1x NVIDIA L4 पर, बैच साइज़ 1 के साथ, एक निश्चित प्रॉम्प्ट से greedy decoding का उपयोग करके ठीक 128 टोकन जनरेट करते हुए। लेटेंसी आउटपुट लंबाई के साथ स्केल होती है, इसलिए अन्य लंबाइयों का अनुमान लगाने के लिए tokens/sec का उपयोग करें।

उपनाम	लेटेंसी, 128 टोकन (मि.से.)	टोकन/सेकंड
paligemma2-3b-pt-224	3986	32

सेट करें api_url अपने डिप्लॉयमेंट लक्ष्य से मेल कराने के लिए:

• https://serverless.roboflow.com सर्वरलेस क्लाउड API के लिए।

• http://localhost:9001 एक स्थानीय इन्फरेंस सर्वर के लिए।

• आपका समर्पित डिप्लॉयमेंट एक निजी एंडपॉइंट के लिए URL।

आप Roboflow पर अपना खुद का PaliGemma 2 चेकपॉइंट ट्रेन कर सकते हैं और इसे उसके प्रति-मॉडल {workspace}/{model-slug} ID में बदलें (देखें संस्करण, प्रशिक्षण और मॉडल ) द्वारा कॉल कर सकते हैं। देखें इनफ़ेरेंस दस्तावेज़ीकरण अतिरिक्त प्रॉम्प्ट फ़ॉर्मैट और समर्थित चेकपॉइंट्स के लिए।

PaliGemma 1 (लेगेसी)

मूल PaliGemma रिलीज़ अभी भी inference पैकेज के माध्यम से अपने हार्डवेयर पर लोड की जा सकती है। नई परियोजनाओं को ऊपर दिया गया PaliGemma 2 उपयोग करना चाहिए; यह अनुभाग मौजूदा इंटीग्रेशन्स के लिए रखा गया है।

पैकेज इंस्टॉल करें:

pip install "inference[transformers]"

का उपयोग करें inference-gpu[transformers] एक GPU मशीन पर।

विज़ुअल प्रश्न-उत्तर

from PIL import Image

from inference.models.paligemma.paligemma import PaliGemma

model = PaliGemma("paligemma-3b-mix-224", api_key="YOUR_API_KEY")

image = Image.open("image.jpeg")
result = model.predict(image, "इस छवि में कितने कुत्ते हैं?")

print(result)

ऑब्जेक्ट डिटेक्शन

PaliGemma डिटेक्शन्स को <loc####> टोकन के रूप में आउटपुट करता है, JSON के बजाय, इसलिए दृश्यांकन से पहले प्रतिक्रिया को पार्स करना होगा। इस प्रकार प्रॉम्प्ट करें detect <class>; <class> और टोकनों को बॉक्स में डिकोड करें:

import re
from typing import List, Optional, Tuple

import numpy as np
import supervision as sv

_DETECT_RE = re.compile(r"(.*?)" + r"<loc(\d{4})>" * 4 + r"\s*([^;<>]+)? ?(?:; )?")


def from_pali_gemma(
    response: str,
    resolution_wh: Tuple[int, int],
    class_list: Optional[List[str]] = None,
) -> sv.Detections:
    width, height = resolution_wh
    xyxy_list, class_name_list = [], []

    while response:
        match = _DETECT_RE.match(response)
        if not match:
            break

        groups = list(match.groups())
        before = groups.pop(0)
        name = groups.pop()
        y1, x1, y2, x2 = [int(value) / 1024 for value in groups[:4]]
        y1, x1, y2, x2 = map(round, (y1 * height, x1 * width, y2 * height, x2 * width))

        content = match.group()
        if before:
            response = response[len(before):]
            content = content[len(before):]

        xyxy_list.append([x1, y1, x2, y2])
        class_name_list.append(name.strip())
        response = response[len(content):]

    class_name = np.array(class_name_list)
    class_id = (
        np.array([class_list.index(name) for name in class_name])
        if class_list is not None
        else None
    )
    return sv.Detections(
        xyxy=np.array(xyxy_list),
        class_id=class_id,
        data={"class_name": class_name},
    )


classes = ["person", "car", "backpack"]
response = model.predict(image, "detect person; car; backpack")[0]
detections = from_pali_gemma(response, resolution_wh=image.size, class_list=classes)

परिणामस्वरूप प्राप्त sv.Detections को supervision बॉक्स बनाने के लिए annotators को पास करें।