> 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

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

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

## PaliGemma 2 API

{% 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="कैप्शन दें",
    max_new_tokens=64,
)
print(result["response"])
```

{% endstep %}
{% endstepper %}

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

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

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-347b3a4f648046dbc28be92bf99d3bd420e351bd%2Fpaligemma2-caption.webp?alt=media" 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` Serverless Cloud 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}` ID से बुला सकते हैं (देखें [संस्करण, प्रशिक्षण, और मॉडल](https://docs.roboflow.com/models/hi/versions-trainings-and-models.md))। देखें [Inference दस्तावेज़](https://docs.roboflow.com/deployment/self-hosted/self-hosted) अतिरिक्त प्रॉम्प्ट प्रारूपों और समर्थित चेकपॉइंट्स के लिए।

## कस्टम वेट्स अपलोड करें

Roboflow के बाहर प्रशिक्षित किए गए PaliGemma 2 मॉडल को चलाने के लिए, उसके वेट्स को किसी Project में इसके साथ अपलोड करें [Roboflow CLI](https://docs.roboflow.com/reference/platform/cli/install-and-set-up-the-cli):

```bash
roboflow upload_model -p my-project -v 1 -t paligemma2-3b-pt-224 -m ./paligemma2-finetuned
```

सेट करें `-t` उस रिज़ॉल्यूशन पर जिसे आपने ट्रेन किया था (उदा.: `paligemma2-3b-pt-448`)। जोड़ें `-peft` LoRA वेट्स के लिए। देखें [कस्टम वेट्स अपलोड करें](https://docs.roboflow.com/models/hi/model-weights/upload-custom-weights.md) Python SDK और प्रशिक्षण संस्करण आवश्यकताओं के लिए।

## PaliGemma 1 (legacy)

मूल 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/) अनोटेटरों को बॉक्स बनाने के लिए दें।
