> 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/cosmos-3-edge.md).

# Cosmos 3 Edge

हमारे सर्वरलेस क्लाउड API के माध्यम से NVIDIA के Cosmos 3 Edge विज़न-लैंग्वेज वर्ल्ड मॉडल का उपयोग करें

Cosmos 3 Edge, NVIDIA का विज़न-लैंग्वेज "वर्ल्ड मॉडल" है। इसे भौतिक दृश्यों को समझने के लिए विशेष रूप से तैयार किया गया है: वस्तुओं के बीच स्थानिक संबंधों पर तर्क करना, सुरक्षा शर्तों के अनुसार दृश्यों की जाँच करना और आगे क्या होने की संभावना है, इसका अनुमान लगाना। यह एक छवि और टेक्स्ट प्रॉम्प्ट स्वीकार करता है और टेक्स्ट में जवाब देता है। इसके व्यवहार को दिशा देने के लिए वैकल्पिक सिस्टम प्रॉम्प्ट भी दिया जा सकता है। हम Cosmos 3 Edge को इन माध्यमों से उपलब्ध कराते हैं: [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api), [समर्पित डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments)और [स्वयं होस्ट किया गया इन्फ़रेंस](https://inference.roboflow.com/).

{% hint style="info" %}
Cosmos 3 Edge को स्वयं होस्ट करने के लिए CUDA-सक्षम GPU ज़रूरी है। यह CPU पर नहीं चल सकता। इसे [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api)पर, GPU वाले [समर्पित डिप्लॉयमेंट](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) पर या GPU-संचालित [स्वयं होस्ट किए गए इन्फ़रेंस](https://inference.roboflow.com/) सर्वर पर चलाएँ।
{% endhint %}

## Cosmos 3 Edge 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://inference.roboflow.com/):

```bash
pip install inference-sdk
```

{% endstep %}

{% step %}

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

इस उदाहरण में, `nvidia/cosmos-3-edge` मॉडल से किसी छवि के बारे में भौतिक तर्क का प्रश्न पूछा जाता है और जवाब प्रिंट किया जाता है।

```python
import os
import cv2
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

image = cv2.imread("my-image.jpg")
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="nvidia/cosmos-3-edge",
    prompt="What is likely going to happen next in this scene?",
    max_new_tokens=128,
)
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-cb5b18a7741195d6a2a5be4d730ddea029cc0ce7%2Fcosmos-3-edge-reasoning.webp?alt=media" alt="Cosmos 3 Edge predicting what will happen next in a street scene with a red SUV"><figcaption><p>Cosmos 3 Edge अनुमान लगाता है कि दृश्य में आगे क्या होने की संभावना है।</p></figcaption></figure>

## Cosmos 3 Edge को ट्रेन करें

आप Cosmos 3 Edge को किसी मल्टीमॉडल प्रोजेक्ट पर फ़ाइन-ट्यून कर सकते हैं। प्रोजेक्ट में "Train" खोलें, "Custom Training" पर क्लिक करें, फिर मॉडल आर्किटेक्चर की सूची में "Cosmos 3" चुनें। Cosmos 3 बीटा में है और इसके लिए सशुल्क प्लान ज़रूरी है। बाकी प्रक्रिया के लिए देखें: [मॉडल ट्रेन करें](https://docs.roboflow.com/models/hi/train/train-a-model.md) और डेटासेट तैयार करने का तरीका जानने के लिए देखें: [मल्टीमॉडल डेटा को एनोटेट करें](https://docs.roboflow.com/datasets/annotate/annotate/annotate-multimodal-data) ।

## वर्कफ़्लो में Cosmos 3 Edge का उपयोग करें

Cosmos 3 Edge यहाँ उपलब्ध है [वर्कफ़्लो](https://docs.roboflow.com/workflows) "Cosmos 3" ब्लॉक के रूप में। यह ब्लॉक एक इमेज और वैकल्पिक टेक्स्ट `prompt` (डिफ़ॉल्ट `"Describe what's in this image."`) और वैकल्पिक सिस्टम प्रॉम्प्ट लेता है, और मॉडल का टेक्स्ट जवाब देता है। आप इस आउटपुट को पार्स करने, फ़िल्टर करने या सूचनाएँ भेजने के लिए आगे के ब्लॉक्स से जोड़ सकते हैं।

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

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

## स्वयं होस्ट किए गए Inference के साथ Cosmos 3 Edge चलाएँ

Cosmos 3 Edge ऐसे [Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) सर्वर पर भी चलता है जिसे आप स्वयं होस्ट करते हैं।

{% hint style="warning" %}
स्वयं होस्ट किए गए Cosmos 3 Edge के लिए CUDA-सक्षम GPU और GPU Inference सर्वर Docker इमेज का Cosmos बिल्ड आवश्यक है ( `-cosmos3` प्रत्यय वाले टैग, जैसे: `roboflow/roboflow-inference-server-gpu:1.3.9-cosmos3`)। मॉडल प्री-रिलीज़ `transformers` बिल्ड पर निर्भर करता है, जो केवल इन इमेज में शामिल होते हैं। मानक `latest` इमेज इसे नहीं चला सकती, और pip से `inference` Python पैकेज इंस्टॉल करना अपने आप में पर्याप्त नहीं है।
{% endhint %}

Cosmos इमेज के साथ स्थानीय सर्वर शुरू करें:

```bash
pip install inference-cli
inference server start --image roboflow/roboflow-inference-server-gpu:1.3.9-cosmos3  # serves http://localhost:9001
```

फिर उसी SDK कोड को अपने सर्वर पर निर्देशित करें:

```python
import os
from inference_sdk import InferenceHTTPClient

client = InferenceHTTPClient(
    api_url="http://127.0.0.1:9001",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)

result = client.infer_lmm(
    inference_input="./my-image.jpg",
    model_id="nvidia/cosmos-3-edge",
    prompt="What is likely going to happen next in this scene?",
)
print(result["response"])
```

## Inference Python पैकेज के साथ Cosmos 3 Edge चलाएँ

आप मॉडल को HTTP सर्वर के बिना, उसी प्रक्रिया में भी चला सकते हैं, इसके लिए [Inference](https://inference.roboflow.com/) Python पैकेज का उपयोग करें। चूँकि Cosmos की निर्भरताएँ केवल `-cosmos3` Docker इमेज में शामिल होती हैं, इसलिए अपनी स्क्रिप्ट उसी इमेज के भीतर चलाएँ। `app.py`:

```python
from inference import get_model

model = get_model("nvidia/cosmos-3-edge", api_key="YOUR_ROBOFLOW_API_KEY")

result = model.infer(
    "https://media.roboflow.com/dog.jpeg",
    prompt="What is likely going to happen next in this scene?",
)

print(result[0].response)
```

फिर इसे Cosmos इमेज के अंदर चलाएँ:

```bash
docker run --rm --gpus all \
  -v $(pwd):/workspace -w /workspace \
  -v /tmp/model-cache:/tmp/model-cache -e MODEL_CACHE_DIR=/tmp/model-cache \
  --entrypoint python3 \
  roboflow/roboflow-inference-server-gpu:1.3.9-cosmos3 app.py
```

यह `/tmp/model-cache` माउंट डाउनलोड किए गए वेट को अलग-अलग रन के बीच सुरक्षित रखता है। यह वही कैश डायरेक्टरी है जिसका उपयोग `inference server start` करता है।
