> 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/rf-detr.md).

# RF-DETR

RF-DETR Roboflow का एक रियल-टाइम ऑब्जेक्ट डिटेक्शन और इंस्टेंस सेगमेंटेशन मॉडल है, जिसमें कीपॉइंट डिटेक्शन और सिमेंटिक सेगमेंटेशन वैरिएंट्स हैं। इसे Roboflow पर ट्रेन करें, इसे Serverless C के माध्यम से चलाएँ

## RF-DETR ऑब्जेक्ट डिटेक्शन

RF-DETR, Roboflow का ट्रांसफ़ॉर्मर-आधारित रियल-टाइम डिटेक्शन मॉडल है। इसके ज़रिए COCO पर प्रीट्रेन किए गए ऑब्जेक्ट डिटेक्शन चेकपॉइंट पर इन्फ़रेंस चलाएँ [Serverless Cloud API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api)के माध्यम से, या [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).

### RF-DETR ऑब्जेक्ट डिटेक्शन API

नीचे दिए गए चरणों में RF-DETR को [Serverless Cloud API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api) के ज़रिए चलाया गया है और नतीजों को [supervision](https://supervision.roboflow.com/).

{% stepper %}
{% step %}
**अपनी API Key पाएँ**

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

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

{% endstep %}

{% step %}
**डिपेंडेंसी इंस्टॉल करें**

ये दोनों पैकेज मॉडल को कॉल करते हैं और इसके नतीजे दिखाते हैं:

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

{% endstep %}

{% step %}
**मॉडल चलाएँ**

नमूना इमेज पर `rfdetr-small` चलाएँ और बॉक्स व लेबल जोड़ें:

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

image_url = "https://media.roboflow.com/quickstart/traffic.jpg"
image = sv.load_image_from_url(image_url)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
).configure(InferenceConfiguration(api_key_transport="header"))
result = client.infer(image, model_id="rfdetr-small")

detections = sv.Detections.from_inference(result)

annotated = sv.BoxAnnotator().annotate(image.copy(), detections)
annotated = sv.LabelAnnotator().annotate(annotated, detections)

cv2.imwrite("traffic-annotated.png", annotated)
```

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-ccf613f155ad9e3e50d2520e5d45bbd68dff5bde%2Frf-detr-detection.webp?alt=media" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

{% 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) सर्वर के लिए।
* निजी एंडपॉइंट के लिए अपना [Dedicated Deployment](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) URL इस्तेमाल करें।
  {% endhint %}

### RF-DETR ऑब्जेक्ट डिटेक्शन मॉडल और बेंचमार्क

इन्फरेंस चलाते समय इनमें से किसी भी उपनाम को `model_id` के रूप में पास करें। SDK हर उपनाम को उसके अंतर्निहित Roboflow प्रोजेक्ट संस्करण से जोड़ता है।

<table data-search="false"><thead><tr><th>उपनाम</th><th>इनपुट आकार</th><th>mAP50-95</th><th>ONNX लेटेंसी (ms)*</th><th>TensorRT FP16 (ms)*</th></tr></thead><tbody><tr><td><code>rfdetr-nano</code></td><td>384x384</td><td>48.4</td><td>9.7</td><td>6.2</td></tr><tr><td><code>rfdetr-small</code></td><td>512x512</td><td>53.0</td><td>12.9</td><td>8.3</td></tr><tr><td><code>rfdetr-medium</code></td><td>576x576</td><td>54.7</td><td>16.3</td><td>9.5</td></tr><tr><td><code>rfdetr-large</code></td><td>704x704</td><td>56.5</td><td>25.6</td><td>11.6</td></tr><tr><td><code>rfdetr-xlarge</code></td><td>700x700</td><td>58.6</td><td>41.6</td><td>14.9</td></tr><tr><td><code>rfdetr-2xlarge</code></td><td>880x880</td><td>60.1</td><td>53.4</td><td>21.7</td></tr></tbody></table>

## RF-DETR इंस्टेंस सेगमेंटेशन

RF-DETR इंस्टेंस सेगमेंटेशन चेकपॉइंट भी उपलब्ध कराता है, जो बॉक्स के साथ मास्क का अनुमान लगाते हैं। इन्हें [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api)के ज़रिए चलाएँ, या [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).

### RF-DETR इंस्टेंस सेगमेंटेशन API

अपनी API कुंजी सेट करें और ऊपर बताए अनुसार निर्भरताएँ इंस्टॉल करें। फिर सेगमेंटेशन चेकपॉइंट चलाएँ और उसके मास्क बनाएँ:

```python
import os
import cv2
import supervision as sv
from inference_sdk import InferenceHTTPClient

image_url = "https://media.roboflow.com/quickstart/traffic.jpg"
image = sv.load_image_from_url(image_url)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.infer(image, model_id="rfdetr-seg-preview")

detections = sv.Detections.from_inference(result)

annotated = sv.MaskAnnotator().annotate(image.copy(), detections)
annotated = sv.LabelAnnotator().annotate(annotated, detections)

cv2.imwrite("traffic-annotated.png", annotated)
```

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-ef481717e6be56837c022e17751f42458d9f288d%2Frf-detr-segmentation.webp?alt=media" alt=""><figcaption></figcaption></figure>

### RF-DETR इंस्टेंस सेगमेंटेशन मॉडल और बेंचमार्क

इन्फरेंस चलाते समय इनमें से किसी भी उपनाम को `model_id` के रूप में पास करें। SDK हर उपनाम को उसके अंतर्निहित Roboflow प्रोजेक्ट संस्करण से जोड़ता है। आँकड़े COCO `val`.

<table data-search="false"><thead><tr><th>उपनाम</th><th>इनपुट आकार</th><th>मास्क mAP50-95</th><th>ONNX लेटेंसी (ms)*</th><th>TensorRT FP16 (ms)*</th></tr></thead><tbody><tr><td><code>rfdetr-seg-nano</code></td><td>312x312</td><td>40.3</td><td>15.8</td><td>10.5</td></tr><tr><td><code>rfdetr-seg-small</code></td><td>384x384</td><td>43.1</td><td>19.3</td><td>11.9</td></tr><tr><td><code>rfdetr-seg-medium</code></td><td>432x432</td><td>45.3</td><td>23.9</td><td>14.1</td></tr><tr><td><code>rfdetr-seg-large</code></td><td>504x504</td><td>47.1</td><td>30.1</td><td>15.4</td></tr><tr><td><code>rfdetr-seg-xlarge</code></td><td>624x624</td><td>48.8</td><td>51.2</td><td>19.1</td></tr><tr><td><code>rfdetr-seg-2xlarge</code></td><td>768x768</td><td>49.9</td><td>89.6</td><td>25.6</td></tr></tbody></table>

## RF-DETR सिमेंटिक सेगमेंटेशन

RF-DETR सिमेंटिक सेगमेंटेशन हर पिक्सेल को एक क्लास देता है। एक ही क्लास वाले क्षेत्रों को अलग-अलग ऑब्जेक्ट में बाँटने के बजाय एक ही लेबल दिया जाता है। प्रीट्रेंड चेकपॉइंट ADE20K के 150 दृश्य वर्गों (उदाहरण: आकाश, इमारत, सड़क, कार, व्यक्ति) को कवर करते हैं। इन्हें [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api), या इसका स्वयं होस्ट करने के लिए उपयोग करें [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).

### RF-DETR सिमैंटिक सेगमेंटेशन API

ऊपर बताए अनुसार अपनी API key सेट करें और निर्भरताएँ इंस्टॉल करें (supervision 0.32.0 या बाद का संस्करण), फिर पहले से प्रशिक्षित चेकपॉइंट चलाएँ और उसकी क्लासों को ड्रॉ करें:

```python
import os

import cv2
import supervision as sv
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

image_url = "https://media.roboflow.com/docs/mountain-lake-boats.jpg"
image = sv.load_image_from_url(image_url)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
).configure(InferenceConfiguration(
    api_key_transport="header",
    client_downsizing_disabled=True,
))
result = client.infer(image, model_id="rfdetr-pretrains/rfdetr-sem-large-ade20k")

detections = sv.Detections.from_inference(result)

palette = sv.ColorPalette.from_hex([
    "#22C55E", "#38BDF8", "#8B5CF6", "#F59E0B", "#EC4899",
    "#EF4444", "#2563EB", "#14B8A6", "#A3E635", "#FDE047",
])
annotated = sv.MaskAnnotator(
    color=palette, opacity=0.35, color_lookup=sv.ColorLookup.INDEX
).annotate(image.copy(), detections)
annotated = sv.PolygonAnnotator(color=sv.Color.WHITE, thickness=2).annotate(
    annotated, detections
)
annotated = sv.LabelAnnotator(
    color=palette,
    color_lookup=sv.ColorLookup.INDEX,
    text_position=sv.Position.CENTER_OF_MASS,
    text_scale=0.8,
    smart_position=True,
).annotate(annotated, detections)

cv2.imwrite("lake-annotated.png", annotated)
print(detections.data["class_name"])
```

`sv.Detections.from_inference` परिणाम की हर क्लास को एक डिटेक्शन में बदलता है, जिसका मास्क उस क्लास के हर पिक्सेल को कवर करता है। इससे आप उसे किसी भी मास्क एनोटेटर से ड्रॉ कर सकते हैं। क्लास के नाम परिणाम के `class_map`से लिए जाते हैं और क्लास ID 0 (पृष्ठभूमि) को छोड़ दिया जाता है। क्लाइंट-साइड डाउनसाइज़िंग बंद रखें, ताकि मास्क इनपुट इमेज के आकार से मेल खाए।

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-afa78b6bde2a63ba07fb99e000a029cf0fb7c00e%2Frf-detr-semantic-segmentation.webp?alt=media" alt="Wooden boats on a mountain lake with RF-DETR semantic segmentation predictions: water, boats, a pier, trees, and rocks each in their own color and labeled"><figcaption><p>ऊपर दिए गए उदाहरण से पहले से प्रशिक्षित RF-DETR Large ADE20K का आउटपुट। फ़ोटो: <a href="https://www.pexels.com/photo/wooden-boat-and-a-scenic-view-of-a-lake-and-mountains-14211208/">Christian Thöni</a>, <a href="https://www.pexels.com/license/">Pexels लाइसेंस</a>. क्रॉप किया गया।</p></figcaption></figure>

### RF-DETR सिमैंटिक सेगमेंटेशन मॉडल और प्रशिक्षण

इनमें से कोई भी मॉडल ID, इन्फ़रेंस चलाते समय `model_id` के रूप में दें। इनमें से हर मॉडल ADE20K पर पहले से प्रशिक्षित है।

<table data-search="false"><thead><tr><th>मॉडल ID</th><th>इनपुट आकार</th></tr></thead><tbody><tr><td><code>rfdetr-pretrains/rfdetr-sem-nano-ade20k</code></td><td>312x312</td></tr><tr><td><code>rfdetr-pretrains/rfdetr-sem-small-ade20k</code></td><td>384x384</td></tr><tr><td><code>rfdetr-pretrains/rfdetr-sem-medium-ade20k</code></td><td>432x432</td></tr><tr><td><code>rfdetr-pretrains/rfdetr-sem-large-ade20k</code></td><td>500x500</td></tr><tr><td><code>rfdetr-pretrains/rfdetr-sem-xlarge-ade20k</code></td><td>560x560</td></tr><tr><td><code>rfdetr-pretrains/rfdetr-sem-2xlarge-ade20k</code></td><td>880x880</td></tr></tbody></table>

अपनी क्लासों को सेगमेंट करने के लिए, एक [सिमैंटिक सेगमेंटेशन प्रोजेक्ट](https://docs.roboflow.com/models/hi/supported-tasks/semantic-segmentation.md#fine-tuning-a-semantic-segmentation-model)बनाएँ, फिर RF-DETR और एक आकार चुनें [कस्टम ट्रेनिंग](https://docs.roboflow.com/models/hi/train/train-a-model.md#web-app). आप इसका उपयोग भी कर सकते हैं [न्यूरल आर्किटेक्चर सर्च](https://docs.roboflow.com/models/hi/train/neural-architecture-search.md) अपनी सटीकता और लेटेंसी की ज़रूरतों के अनुसार मॉडलों की तुलना करने के लिए। ऊपर दी गई तालिकाओं में बॉक्स या मास्क mAP के बजाय, सिमैंटिक सेगमेंटेशन की सटीकता का मूल्यांकन करें [मीन इंटरसेक्शन ओवर यूनियन (mIoU)](https://docs.roboflow.com/models/hi/evaluate/evaluate-trained-models.md)के आधार पर।

## RF-DETR कीपॉइंट डिटेक्शन

RF-DETR कीपॉइंट डिटेक्शन एक प्रीव्यू चेकपॉइंट है, जिसे COCO पर्सन कीपॉइंट्स पर प्रीट्रेन किया गया है। इसे [सर्वरलेस क्लाउड API](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api)के ज़रिए चलाएँ, या [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted).

{% hint style="info" %}
का उपयोग करके इसे खुद होस्ट करें। यह चेकपॉइंट प्रीव्यू में है। बाद के रिलीज़ में इसकी सटीकता और आउटपुट फ़ॉर्मैट बदल सकते हैं।
{% endhint %}

### RF-DETR कीपॉइंट डिटेक्शन API

ऊपर बताए अनुसार अपनी API कुंजी सेट करें और निर्भरताएँ इंस्टॉल करें, फिर `rfdetr-keypoint-preview` चलाएँ और कीपॉइंट्स को एनोटेट करें:

```python
import os
import cv2
import numpy as np
import supervision as sv
from inference_sdk import InferenceHTTPClient

COCO_KEYPOINTS = [
    "nose", "left_eye", "right_eye", "left_ear", "right_ear",
    "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
    "left_wrist", "right_wrist", "left_hip", "right_hip",
    "left_knee", "right_knee", "left_ankle", "right_ankle",
]

image_url = "https://media.roboflow.com/notebooks/examples/person-walking.png"
image = sv.load_image_from_url(image_url)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.infer(image, model_id="rfdetr-keypoint-preview")

# हर prediction में केवल वे keypoints होते हैं जिन्हें मॉडल देख सकता है, इसलिए उन्हें
# skeleton के अपेक्षित 17 COCO स्लॉट में रखें और जो दिखाई नहीं दे रहे, उन्हें चिह्नित करें।
xy, visible = [], []
for prediction in result["predictions"]:
    found = {point["class"]: (point["x"], point["y"]) for point in prediction["keypoints"]}
    xy.append([found.get(name, (0, 0)) for name in COCO_KEYPOINTS])
    visible.append([name in found for name in COCO_KEYPOINTS])

key_points = sv.KeyPoints(xy=np.array(xy, dtype=np.float32), visible=np.array(visible))

annotated = sv.EdgeAnnotator(color=sv.Color.GREEN, thickness=3).annotate(image.copy(), key_points)
annotated = sv.VertexAnnotator(color=sv.Color.RED, radius=5).annotate(annotated, key_points)
cv2.imwrite("person-walking-annotated.png", annotated)
```

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-58cd1b0b1df35e71787197ce73cd5294b67a9a74%2Frf-detr-keypoint.webp?alt=media" alt=""><figcaption></figcaption></figure>

### RF-DETR कीपॉइंट डिटेक्शन मॉडल और बेंचमार्क

इन्फ़रेंस चलाते समय उपनाम को `model_id` के रूप में दें। सटीकता COCO `val` से प्राप्त AP50-95 है, जिसकी गणना ऑब्जेक्ट कीपॉइंट सिमिलैरिटी (OKS) से की जाती है। यह COCO का मानक कीपॉइंट मेट्रिक है, इसलिए इसकी तुलना ऊपर दिए गए बॉक्स और मास्क mAP से नहीं की जा सकती।

<table data-search="false"><thead><tr><th>उपनाम</th><th>इनपुट आकार</th><th>कीपॉइंट AP50-95</th><th>पैरामीटर (M)</th><th>लेटेंसी (ms)†</th></tr></thead><tbody><tr><td><code>rfdetr-keypoint-preview</code></td><td>576x576</td><td>71.8</td><td>126.4</td><td>9.7</td></tr></tbody></table>

Roboflow अभी इस चेकपॉइंट के लिए पहले से बना TensorRT इंजन उपलब्ध नहीं कराता, इसलिए inference-models\[trt10] `inference-models[trt10]` एक्स्ट्रा इंस्टॉल करने पर भी Inference इसे ONNX Runtime पर चलाता है। तालिका में दी गई लेटेंसी हासिल करने के लिए, [rfdetr](https://github.com/roboflow/rf-detr) पैकेज का उपयोग करके आपको खुद इंजन बनाना होगा।

***

† प्रकाशित कीपॉइंट सटीकता और लेटेंसी के आँकड़े [RF-DETR बेंचमार्क में](https://rfdetr.roboflow.com/latest/#keypoints): लेटेंसी, बैच आकार 1 पर 1x NVIDIA T4 के TensorRT FP16 की है और इसमें केवल मॉडल का समय मापा गया है। यह ऊपर दी गई तालिकाओं से अलग GPU और अलग पाइपलाइन है, इसलिए दोनों लेटेंसी सेटों की सीधे तुलना नहीं की जा सकती।

\* लेटेंसी मापी गई है [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted) के साथ 1x NVIDIA L4 पर, बैच आकार 1 में, 1,000 इन्फ़रेंस का औसत (100 वार्मअप)। डिफ़ॉल्ट `inference-gpu` इंस्टॉल, CUDA execution provider पर ONNX चलाता है; जबकि `inference-models[trt10]` एक्स्ट्रा जोड़ने पर पहले से निर्मित TensorRT FP16 इंजन अपने-आप चुना जाता है। COCO `val2017`पर FP16 की सटीकता, FP32 की सटीकता से 0.2 mAP के भीतर रहती है। सटीकता प्रकाशित COCO `val` स्पेक के अनुसार है (देखें [RF-DETR की घोषणा](https://blog.roboflow.com/rf-detr/)).

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

Roboflow के बाहर प्रशिक्षित RF-DETR मॉडल चलाने के लिए, उसके वेट को इस [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 rfdetr-medium -m ./output -f checkpoint_best_total.pth
```

से किसी Project पर अपलोड करें। `-t` को अपने प्रशिक्षित वैरिएंट पर सेट करें (उदाहरण: `rfdetr-small`, `rfdetr-seg-medium`)। Python SDK और प्रशिक्षण संस्करण की आवश्यकताओं के लिए देखें [कस्टम वेट अपलोड करें](https://docs.roboflow.com/models/hi/model-weights/upload-custom-weights.md) ।

## लाइसेंस

मॉडल के आकार के आधार पर RF-DETR दो लाइसेंसों का उपयोग करता है:

* **Apache 2.0** (Nano, Small, Medium और Large डिटेक्शन, सभी सेगमेंटेशन आकार, और Keypoint): व्यावसायिक उपयोग के लिए मुफ़्त, जिसमें स्वयं-होस्ट किए गए और क्लोज़्ड-सोर्स उत्पाद भी शामिल हैं। कोई लाइसेंस शुल्क नहीं और अपना कोड ओपन-सोर्स करने की आवश्यकता नहीं।
* **PML 1.0** (XL और 2XL डिटेक्शन, सभी सिमैंटिक सेगमेंटेशन आकार, और RF-DETR Pose कीपॉइंट मॉडल; Roboflow Platform Model License): Roboflow पर डिप्लॉय करने पर व्यावसायिक उपयोग शामिल है; व्यावसायिक रूप से स्वयं-होस्ट करने के लिए Enterprise ऐड-ऑन आवश्यक है।

विवरण के लिए देखें [मॉडल लाइसेंस](https://docs.roboflow.com/models/hi/model-licenses.md) ।
