> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/models/hi/supported-models/paligemma2.md).

# PaliGemma 2

PaliGemma 2 Google का विज़न-लैंग्वेज मॉडल है। यह एक छवि और एक टेक्स्ट प्रॉम्प्ट स्वीकार करता है और टेक्स्ट प्रतिक्रिया लौटाता है। हम PaliGemma 2 का समर्थन अपने [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api), [समर्पित डिप्लॉयमेंट्स](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments), और [स्व-होस्टेड इनफ़रेंस](https://docs.roboflow.com/deployment/self-hosted/self-hosted).

## PaliGemma 2 एपीआई

{% stepper %}
{% step %}

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

एक Roboflow खाता बनाएँ, अपनी कुंजी यहाँ खोजें [Roboflow API सेटिंग्स पेज](https://app.roboflow.com/settings/api) और इसे अपने शेल में उपलब्ध कराएँ:

```bash
export ROBOFLOW_API_KEY="your-key-here"
```

{% endstep %}

{% step %}

### निर्भरताएँ इंस्टॉल करें

इंस्टॉल करें [Inference SDK](https://docs.roboflow.com/deployment/self-hosted/self-hosted):

```bash
pip install -U inference-sdk supervision
```

{% endstep %}

{% step %}

### मॉडल चलाएँ

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

```python
import os
import supervision as sv
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

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"],
).configure(InferenceConfiguration(api_key_transport="header"))
result = client.infer_lmm(
    image,
    model_id="paligemma2-3b-pt-224",
    prompt="caption en",
    max_new_tokens=64,
)
print(result["response"])
```

{% endstep %}
{% endstepper %}

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

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

<figure><img src="/files/d6a9ec497eeda6f5ccac420e92159a86aa979f64" alt=""><figcaption></figcaption></figure>

## PaliGemma 2 इनफ़रेंस गति

लेटेंसी मापी गई [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) 1x NVIDIA L4 पर, बैच आकार 1 के साथ, एक निश्चित प्रॉम्प्ट से greedy decoding का उपयोग करके ठीक 128 टोकन जनरेट करते हुए। लेटेंसी आउटपुट लंबाई के साथ स्केल करती है, इसलिए अन्य लंबाइयों का अनुमान लगाने के लिए tokens/sec का उपयोग करें।

<table data-search="false"><thead><tr><th>उपनाम</th><th>लेटेंसी, 128 टोकन (ms)</th><th>टोकन/सेकंड</th></tr></thead><tbody><tr><td><code>paligemma2-3b-pt-224</code></td><td>3986</td><td>32</td></tr></tbody></table>

{% hint style="info" %}
सेट करें `api_url` को अपने डिप्लॉयमेंट लक्ष्य से मिलाने के लिए:

* `https://serverless.roboflow.com` सर्वरलेस क्लाउड API के लिए।
* `http://localhost:9001` एक स्थानीय [इन्फ़रेंस](https://docs.roboflow.com/deployment/self-hosted/self-hosted) सर्वर के लिए।
* आपका [डेडिकेटेड डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) एक निजी एंडपॉइंट के लिए URL।
  {% endhint %}

आप Roboflow पर अपना PaliGemma 2 चेकपॉइंट प्रशिक्षित कर सकते हैं और उसे उसके प्रति-मॉडल `{workspace}/{model-slug}` ID बदलें (देखें [संस्करण, प्रशिक्षण, और मॉडल](/models/hi/versions-trainings-and-models.md)। देखें [इनफ़रेंस दस्तावेज़ीकरण](https://docs.roboflow.com/deployment/self-hosted/self-hosted) अतिरिक्त प्रॉम्प्ट फ़ॉर्मैट और समर्थित चेकपॉइंट्स के लिए।

## PaliGemma 1 (लेगेसी)

मूल PaliGemma रिलीज़ अभी भी [`inference`](https://docs.roboflow.com/deployment/self-hosted/self-hosted) पैकेज के माध्यम से आपके अपने हार्डवेयर पर लोड की जा सकती है। नए प्रोजेक्ट्स को ऊपर दिए गए PaliGemma 2 का उपयोग करना चाहिए; यह अनुभाग मौजूदा इंटीग्रेशन्स के लिए रखा गया है।

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

```bash
pip install "inference[transformers]"
```

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

### दृश्य प्रश्नोत्तर

```python
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>` और टोकनों को बॉक्स में डिकोड करें:

```python
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](https://supervision.roboflow.com/) बॉक्स बनाने के लिए annotators को दें।