RF-DETR

Roboflow के RF-DETR मॉडल का उपयोग self-hosted मॉडल के रूप में या हमारे Serverless Cloud API के माध्यम से करें

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

RF-DETR Roboflow का ट्रांसफ़ॉर्मर-आधारित रीयल-टाइम डिटेक्शन मॉडल है। COCO-पूर्व-प्रशिक्षित ऑब्जेक्ट डिटेक्शन चेकपॉइंट्स के साथ इनफ़रेंस चलाएँ, के माध्यम से सर्वरलेस क्लाउड API, या स्वयं-होस्ट करने के लिए उपयोग करके Roboflow Inference.

कोड नमूना

नीचे दिए गए चरण RF-DETR को के माध्यम से चलाते हैं सर्वरलेस क्लाउड API और परिणामों को supervision.

1

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

एक Roboflow खाता बनाएं, अपनी कुंजी को देखें Roboflow API सेटिंग्स पृष्ठ और इसे अपने शेल में उपलब्ध कराएँ:

export ROBOFLOW_API_KEY="your-key-here"

2

निर्भरताएँ स्थापित करें

ये दो पैकेज मॉडल को कॉल करते हैं और उसके परिणामों को आरेखित करते हैं:

pip install -U inference-sdk supervision

3

मॉडल चलाएँ

चलाएँ rfdetr-small एक नमूना छवि पर और बक्सों तथा लेबलों को एनोटेट करें:

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-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)

सेट करें api_url अपने डिप्लॉयमेंट लक्ष्य से मिलाएँ:

• https://serverless.roboflow.com सर्वरलेस क्लाउड API के लिए।

• http://localhost:9001 स्थानीय इनफ़रेंस सर्वर।

• आपका समर्पित डिप्लॉयमेंट एक निजी एंडपॉइंट के लिए URL।

पूर्व-प्रशिक्षित मॉडल और बेंचमार्क

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

उपनाम	इनपुट आकार	mAP50-95	ONNX विलंबता (ms)*	TensorRT FP16 (ms)*
rfdetr-nano	384x384	48.4	9.7	6.2
rfdetr-small	512x512	53.0	12.9	8.3
rfdetr-medium	576x576	54.7	16.3	9.5
rfdetr-large	704x704	56.5	25.6	11.6
rfdetr-xlarge	700x700	58.6	41.6	14.9
rfdetr-2xlarge	880x880	60.1	53.4	21.7

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

RF-DETR इंस्टेंस सेगमेंटेशन चेकपॉइंट भी प्रदान करता है, जो बक्सों के साथ-साथ मास्क की भविष्यवाणी करते हैं। उन्हें के माध्यम से चलाएँ सर्वरलेस क्लाउड API, या स्वयं-होस्ट करने के लिए उपयोग करके Roboflow Inference.

कोड नमूना

जैसा ऊपर दिखाया गया है, अपनी API कुंजी सेट करें और निर्भरताएँ स्थापित करें, फिर एक सेगमेंटेशन चेकपॉइंट चलाएँ और उसके मास्क आरेखित करें:

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)

पूर्व-प्रशिक्षित मॉडल और बेंचमार्क

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

उपनाम	इनपुट आकार	मास्क mAP50-95	ONNX विलंबता (ms)*	TensorRT FP16 (ms)*
rfdetr-seg-nano	312x312	40.3	15.8	10.5
rfdetr-seg-small	384x384	43.1	19.3	11.9
rfdetr-seg-medium	432x432	45.3	23.9	14.1
rfdetr-seg-large	504x504	47.1	30.1	15.4
rfdetr-seg-xlarge	624x624	48.8	51.2	19.1
rfdetr-seg-2xlarge	768x768	49.9	89.6	25.6

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

RF-DETR कीपॉइंट डिटेक्शन एक पूर्वावलोकन चेकपॉइंट है, जिसे COCO व्यक्ति कीपॉइंट्स पर पूर्व-प्रशिक्षित किया गया है। इसे के माध्यम से चलाएँ सर्वरलेस क्लाउड API, या स्वयं-होस्ट करने के लिए उपयोग करके Roboflow Inference.

यह चेकपॉइंट पूर्वावलोकन में है। बाद के रिलीज़ में इसकी सटीकता और आउटपुट फ़ॉर्मेट बदल सकते हैं।

कोड नमूना

जैसा ऊपर दिखाया गया है, अपनी API कुंजी सेट करें और निर्भरताएँ स्थापित करें, फिर rfdetr-keypoint-preview चलाएँ और कीपॉइंट्स को एनोटेट करें:

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 सूचीबद्ध होते हैं जिन्हें मॉडल देख सकता है, इसलिए उन्हें इसमें रखें
# स्केलेटन द्वारा अपेक्षित 17 COCO स्लॉट्स में रखें और गायब वालों को not visible चिह्नित करें।
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)

पूर्व-प्रशिक्षित मॉडल और बेंचमार्क

उपनाम को model_id इनफ़रेंस चलाते समय। सटीकता COCO val AP50-95 को object keypoint similarity (OKS) के साथ स्कोर किया जाता है, जो मानक COCO keypoint metric है, इसलिए यह ऊपर दिए गए box और mask mAP से तुलना नहीं करता।

उपनाम	इनपुट आकार	कीपॉइंट AP50-95	पैरामीटर (M)	विलंबता (ms)†
rfdetr-keypoint-preview	576x576	71.8	126.4	9.7

Roboflow अभी इस चेकपॉइंट के लिए कोई prebuilt TensorRT engine प्रकाशित नहीं करता, इसलिए जब आप inference-models[trt10] extra स्थापित करते हैं, तब भी Inference इसे ONNX Runtime पर चलाता है। तालिका में दी गई विलंबता तक पहुँचने के लिए आपको स्वयं के साथ engine बनाना होगा rfdetr पैकेज।

---

† कीपॉइंट सटीकता और विलंबता वे आँकड़े हैं जो RF-DETR बेंचमार्क: विलंबता TensorRT FP16 है, 1x NVIDIA T4 पर batch size 1 के साथ, केवल मॉडल का समय लिया गया है। यह ऊपर दी गई तालिकाओं से अलग GPU और अलग pipeline है, इसलिए विलंबता के दोनों सेट सीधे तुलना योग्य नहीं हैं।

* विलंबता मापी जाती है Roboflow Inference 1x NVIDIA L4 पर, batch size 1 के साथ, 1,000 इनफ़रेंस (100 warmup) का औसत। डिफ़ॉल्ट inference-gpu इंस्टॉल ONNX को CUDA execution provider पर चलाता है; inference-models[trt10] extra जोड़ने से एक prebuilt TensorRT FP16 engine अपने-आप चुन लिया जाता है। FP16, COCO val2017पर FP32 सटीकता के 0.2 mAP के भीतर मेल खाता है। सटीकता प्रकाशित COCO val विशिष्टता (देखें RF-DETR की घोषणा).