YOLO26

हमारे Serverless Hosted API के माध्यम से YOLO26 model family का उपयोग करें

YOLO26 ऑब्जेक्ट डिटेक्शन

YOLO26 ऑब्जेक्ट डिटेक्शन के माध्यम से चलता है Serverless Hosted API, COCO पर pretrained. Self-hosted deployment के लिए, देखें Roboflow Inference.

कोड नमूना

यह नमूना एक test image डाउनलोड करता है, inference चलाता है inference-sdk, response को के साथ decode करता है supervision, और disk पर एक annotated PNG लिखता है.

1

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

एक Roboflow खाता बनाएं, अपनी key यहाँ पर ढूँढें Roboflow API settings page और इसे अपने shell में उपलब्ध कराएँ:

export ROBOFLOW_API_KEY="your-key-here"

2

निर्भरताएँ इंस्टॉल करें

SDK और supervision एनोटेशन के लिए library इंस्टॉल करें:

pip install inference-sdk supervision opencv-python

3

मॉडल चलाएँ

चलाएँ yolo26n-640 एक sample image पर और boxes तथा labels annotate करें:

import os
import cv2
import numpy as np
import requests
import supervision as sv
from inference_sdk import InferenceHTTPClient

image_url = "https://media.roboflow.com/quickstart/traffic.jpg"
content = requests.get(image_url).content
image = cv2.imdecode(np.frombuffer(content, np.uint8), cv2.IMREAD_COLOR)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.infer(image, model_id="yolo26n-640")
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 को अपने deployment target से मिलाएँ:

• https://serverless.roboflow.com Serverless Hosted API के लिए।

• http://localhost:9001 एक local Inference server.

• आपका Dedicated Deployment एक private endpoint के लिए URL.

Pretrained models और benchmarks

इनमें से किसी भी alias को बतौर पास करें model_id। inference-sdk हर alias को उसके pretrained Roboflow Universe model में client-side resolve करता है; yolov26* prefix variants वही models resolve करते हैं.

उपनाम	इनपुट आकार	mAP50-95	ONNX latency (ms)*	TensorRT FP16 (ms)*
yolo26n-640	640x640	40.9	3.5	2.2
yolo26s-640	640x640	48.6	4.7	3.0
yolo26m-640	640x640	53.1	8.4	4.4
yolo26l-640	640x640	55.0	10.7	5.6
yolo26x-640	640x640	57.5	18.4	8.0

YOLO26 इंस्टेंस सेगमेंटेशन

YOLO26 इंस्टेंस सेगमेंटेशन के माध्यम से चलता है Serverless Hosted API, COCO पर pretrained. Self-hosted deployment के लिए, देखें Roboflow Inference.

कोड नमूना

अपनी API key सेट करें और ऊपर दिखाए अनुसार dependencies इंस्टॉल करें, फिर चलाएँ yolo26n-seg-640 और masks तथा labels को annotate करें:

import os
import cv2
import numpy as np
import requests
import supervision as sv
from inference_sdk import InferenceHTTPClient

image_url = "https://media.roboflow.com/quickstart/traffic.jpg"
content = requests.get(image_url).content
image = cv2.imdecode(np.frombuffer(content, np.uint8), cv2.IMREAD_COLOR)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.infer(image, model_id="yolo26n-seg-640")
detections = sv.Detections.from_inference(result)

annotated = sv.MaskAnnotator().annotate(image.copy(), detections)
annotated = sv.BoxAnnotator().annotate(annotated, detections)
annotated = sv.LabelAnnotator().annotate(annotated, detections)
cv2.imwrite("traffic-annotated.png", annotated)

Pretrained models और benchmarks

इनमें से किसी भी alias को बतौर पास करें model_id; yolov26* prefix variants वही models resolve करते हैं। Box और mask mAP end-to-end (NMS-free) COCO val values.

उपनाम	इनपुट आकार	Box mAP50-95	Mask mAP50-95	ONNX latency (ms)*	TensorRT FP16 (ms)*
yolo26n-seg-640	640x640	39.6	33.9	8.3	6.8
yolo26s-seg-640	640x640	47.3	40.0	10.8	8.5
yolo26m-seg-640	640x640	52.5	44.1	16.4	11.9
yolo26l-seg-640	640x640	54.4	45.5	18.4	12.8
yolo26x-seg-640	640x640	56.5	47.0	28.9	15.7

YOLO26 Keypoint Detection

YOLO26 keypoint/pose detection के माध्यम से चलता है Serverless Hosted API, COCO पर pretrained. Self-hosted deployment के लिए, देखें Roboflow Inference.

कोड नमूना

अपनी API key सेट करें और ऊपर दिखाए अनुसार dependencies इंस्टॉल करें, फिर चलाएँ yolo26n-pose-640 और keypoints को annotate करें:

import os
import cv2
import numpy as np
import requests
import supervision as sv
from inference_sdk import InferenceHTTPClient

image_url = "https://media.roboflow.com/notebooks/examples/person-walking.png"
content = requests.get(image_url).content
image = cv2.imdecode(np.frombuffer(content, np.uint8), cv2.IMREAD_COLOR)

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.infer(image, model_id="yolo26n-pose-640")
key_points = sv.KeyPoints.from_inference(result)

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

Pretrained models और benchmarks

इनमें से किसी भी alias को बतौर पास करें model_id; yolov26* prefix variants वही models resolve करते हैं। mAP end-to-end (NMS-free) COCO val values.

उपनाम	इनपुट आकार	mAP50-95	ONNX latency (ms)*	TensorRT FP16 (ms)*
yolo26n-pose-640	640x640	57.2	3.8	2.3
yolo26s-pose-640	640x640	63.0	5.1	3.3
yolo26m-pose-640	640x640	68.8	9.0	4.6
yolo26l-pose-640	640x640	70.4	11.2	5.8
yolo26x-pose-640	640x640	71.6	19.1	8.3

YOLO26 Semantic Segmentation

YOLO26 semantic segmentation (yolo26-sem) Roboflow पर semantic segmentation के लिए अनुशंसित architecture है। यह Cityscapes pretrained weights का उपयोग करता है और डिफ़ॉल्ट resolution 1024x1024 पर train होता है। पाँच sizes में उपलब्ध: n, s, m, l, x.

एक YOLO26-SEM model train करने के लिए, एक semantic segmentation Project बनाएँ और अपनी architecture के रूप में YOLO26 चुनें। आप यह भी custom-trained weights upload कर सकते हैं YOLO26-SEM models के लिए.

Cityscapes pretrained models (19 classes) भी public models के रूप में उपलब्ध हैं जिन्हें आप एक Workflow बिना training के चला सकते हैं.

Pretrained models और benchmarks

इनमें से किसी भी Cityscapes-pretrained alias को as the model_id; yolov26* prefix variants वही models resolve करते हैं। वे केवल ONNX backend पर चलते हैं; कोई prebuilt TensorRT engine प्रकाशित नहीं की गई है.

उपनाम	इनपुट आकार	ONNX latency (ms)*
yolo26n-sem-1024	1024x1024	23.3
yolo26s-sem-1024	1024x1024	25.9
yolo26m-sem-1024	1024x1024	34.6
yolo26l-sem-1024	1024x1024	35.8
yolo26x-sem-1024	1024x1024	53.2

---

* Latency मापी जाती है Roboflow Inference 1x NVIDIA L4 पर, batch size 1, 1,000 inferences का औसत (100 warmup)। डिफ़ॉल्ट inference-gpu install CUDA execution provider पर ONNX चलाता है; inference-models[trt10] extra स्वतः एक prebuilt TensorRT FP16 engine चुनता है। FP16, COCO पर FP32 accuracy से 0.1 mAP के भीतर मेल खाता है val2017. Accuracy प्रकाशित COCO val spec (स्रोत).