> 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 का vision-language model है। यह एक image और एक text prompt स्वीकार करता है और एक text response लौटाता है। हम 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).

## कोड नमूना

{% 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

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="कैप्शन अंग्रेज़ी में",
    max_new_tokens=64,
)
print(result["response"])
```

{% endstep %}
{% endstepper %}

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

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

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

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

विलंबता मापी गई [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 टोकन (मि.से.)</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` एक लोकल [Inference](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}` आईडी (देखें [संस्करण, प्रशिक्षण, और मॉडल](/models/hi/versions-trainings-and-models.md)). देखें [इनफ़रेंस दस्तावेज़ीकरण](https://docs.roboflow.com/deployment/self-hosted/self-hosted) अतिरिक्त प्रॉम्प्ट प्रारूपों और समर्थित चेकपॉइंट्स के लिए।

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

मूल PaliGemma रिलीज़ अभी भी [`इनफ़रेंस`](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 के बजाय, इसलिए उत्तर को विज़ुअलाइज़ करने से पहले पार्स करना होगा। इसके साथ प्रॉम्प्ट करें `पता लगाएँ <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, "पता लगाएँ person; car; backpack")[0]
detections = from_pali_gemma(response, resolution_wh=image.size, class_list=classes)
```

परिणामी `sv.Detections` को [supervision](https://supervision.roboflow.com/) बॉक्स खींचने के लिए एनोटेटर्स को दें।