> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/computer-vision/yolov9-v10.md).

# YOLOv9/v10 डिटेक्शन

> **अत्याधुनिक रीयल-टाइम ऑब्जेक्ट डिटेक्शन — GPU पर नवीनतम YOLO मॉडलों को प्रशिक्षित करें और तैनात करें**

YOLO (You Only Look Once) रीयल-टाइम ऑब्जेक्ट डिटेक्शन के लिए स्वर्ण मानक बना हुआ है। YOLOv9 ने Programmable Gradient Information (PGI) और Generalized Efficient Layer Aggregation Network (GELAN) पेश किए, जबकि YOLOv10 ने dual-label assignments के साथ NMS-मुक्त डिटेक्शन लाया। दोनों NVIDIA GPUs पर शीर्ष-स्तरीय सटीकता/गति संतुलन प्रदान करते हैं।

* **YOLOv9 GitHub:** [WongKinYiu/yolov9](https://github.com/WongKinYiu/yolov9) — 8K+ ⭐
* **YOLOv10 GitHub:** [THU-MIG/yolov10](https://github.com/THU-MIG/yolov10) — 10K+ ⭐
* **Ultralytics (एकीकृत):** [ultralytics/ultralytics](https://github.com/ultralytics/ultralytics) — 32K+ ⭐

***

## YOLOv9 बनाम YOLOv10 बनाम YOLOv8 — त्वरित तुलना

| मॉडल     | mAP50-95 | गति (A100) | पैरामीटर | NMS       |
| -------- | -------- | ---------- | -------- | --------- |
| YOLOv8x  | 53.9     | 14.2ms     | 68.2M    | आवश्यक    |
| YOLOv9e  | 55.6     | 16.8ms     | 57.3M    | आवश्यक    |
| YOLOv10x | 54.4     | 10.7ms     | 29.5M    | **मुक्त** |
| YOLOv10b | 53.0     | 8.8ms      | 19.1M    | **मुक्त** |
| YOLOv10s | 46.8     | 4.2ms      | 7.2M     | **मुक्त** |

{% hint style="success" %}
**YOLOv10 NMS-मुक्त है** — कोई post-processing Non-Maximum Suppression चरण नहीं। इससे end-to-end deployment संभव होता है और यह विशेष रूप से edge/embedded परिदृश्यों और TensorRT deployment के लिए लाभकारी है।
{% endhint %}

***

## उपयोग के मामले

* **सुरक्षा एवं निगरानी** — रीयल-टाइम व्यक्ति/वाहन/ऑब्जेक्ट डिटेक्शन
* **स्वायत्त वाहन** — पैदल यात्री और बाधा डिटेक्शन
* **विनिर्माण QC** — उत्पादन लाइनों पर दोष डिटेक्शन
* **रिटेल विश्लेषण** — ग्राहक प्रवाह और उत्पाद डिटेक्शन
* **मेडिकल इमेजिंग** — X-ray और स्कैन में असामान्यता डिटेक्शन
* **खेल विश्लेषण** — खिलाड़ी और गेंद ट्रैकिंग
* **कृषि** — फसल रोग और कीट डिटेक्शन

***

## पूर्वापेक्षाएँ

* GPU किराये के साथ Clore.ai खाता
* कस्टम मॉडल प्रशिक्षण के लिए प्रशिक्षण डेटा या COCO pretrained weights का उपयोग करें
* Python और कमांड लाइन का बुनियादी ज्ञान

***

## चरण 1 — Clore.ai पर GPU किराए पर लें

1. पर जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. अपने कार्य के आधार पर GPU चुनें:
   * **केवल इन्फ़रेंस:** RTX 3080/3090 या RTX 4080 — उत्कृष्ट मूल्य/प्रदर्शन
   * **छोटे मॉडल प्रशिक्षण:** RTX 4090 24GB
   * **बड़े मॉडल प्रशिक्षण (YOLOv9e/YOLOv10x):** A100 40/80GB

{% hint style="info" %}
**रीयल-टाइम इन्फ़रेंस के लिए** (वीडियो स्ट्रीम), RTX 3090 या RTX 4090 मॉडल संस्करण के आधार पर 100–500 FPS प्रदान करता है। सबसे छोटा YOLOv10n भी TensorRT के साथ 4090 पर 1000+ FPS पर चलता है।
{% endhint %}

***

## चरण 2 — Ultralytics कंटेनर तैनात करें

आधिकारिक Ultralytics Docker image एकीकृत API के माध्यम से YOLOv8, YOLOv9, और YOLOv10 का समर्थन करती है:

**Docker इमेज:**

```
ultralytics/ultralytics:latest
```

**पोर्ट:**

```
22
8000
```

**Environment Variables:**

```
NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
```

**डिस्क:** कम से कम 20GB (pretrained weights + आपका dataset)

***

## चरण 3 — कनेक्ट करें और सत्यापित करें

```bash
ssh root@<server-ip> -p <ssh-port>

# GPU जांचें
nvidia-smi

# Ultralytics स्थापना जांचें
python3 -c "import ultralytics; ultralytics.checks()"

# GPU जानकारी, CUDA version, और model availability दिखना चाहिए
```

***

## चरण 4 — pretrained models के साथ त्वरित इन्फ़रेंस

### YOLOv10 इन्फ़रेंस (NMS-मुक्त)

```python
from ultralytics import YOLO
import cv2

# YOLOv10 model लोड करें (यदि मौजूद नहीं है तो स्वतः डाउनलोड होता है)
model = YOLO("yolov10x.pt")  # विकल्प: n, s, m, b, l, x

# किसी image पर inference चलाएँ
results = model("https://ultralytics.com/images/bus.jpg")

# परिणाम प्रदर्शित करें
for result in results:
    boxes = result.boxes
    print(f"{len(boxes)} ऑब्जेक्ट्स का पता चला")
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].tolist()
        print(f"  {model.names[cls]}: {conf:.2f} पर {[int(x) for x in xyxy]}")

# एनोटेटेड image सहेजें
results[0].save("output.jpg")
```

### YOLOv9 इन्फ़रेंस

```python
from ultralytics import YOLO

# YOLOv9 model लोड करें
model = YOLO("yolov9e.pt")  # विकल्प: t, s, m, c, e

# अधिकतम throughput के लिए batch inference
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # समानांतर में 8 images संसाधित करें
    device="cuda",
    conf=0.25,      # विश्वास सीमा
    iou=0.45,       # NMS IoU threshold (v10 के लिए आवश्यक नहीं)
    imgsz=640,
    half=True       # 2x speedup के लिए FP16
)
```

### रीयल-टाइम वीडियो स्ट्रीम इन्फ़रेंस

```python
from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# webcam (device=0) या video file के लिए
cap = cv2.VideoCapture("input_video.mp4")

# वीडियो properties प्राप्त करें
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# आउटपुट लिखने वाला
out = cv2.VideoWriter(
    "output_video.mp4",
    cv2.VideoWriter_fourcc(*"mp4v"),
    fps,
    (width, height)
)

frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame, conf=0.25, verbose=False)
    annotated = results[0].plot()
    out.write(annotated)
    frame_count += 1
    
    if frame_count % 100 == 0:
        print(f"{frame_count} फ़्रेम प्रोसेस किए गए")

cap.release()
out.release()
print("हो गया! आउटपुट output_video.mp4 में सहेजा गया")
```

***

## चरण 5 — कस्टम मॉडल को प्रशिक्षित करें

### अपना डेटासेट तैयार करें

YOLO एक विशिष्ट directory structure और label format का उपयोग करता है:

```
dataset/
├── images/
│   ├── train/          # प्रशिक्षण images (.jpg/.png)
│   ├── val/            # validation images
│   └── test/           # test images (optional)
└── labels/
    ├── train/          # label files (.txt)
    ├── val/
    └── test/
```

प्रत्येक label file (छवि के समान नाम वाली, `.txt` विस्तार) में शामिल होता है:

```
# class_id center_x center_y width height (सभी 0-1 के बीच सामान्यीकृत)
0 0.512 0.334 0.256 0.412
1 0.123 0.654 0.089 0.123
```

### डेटासेट कॉन्फ़िगरेशन बनाएं

```bash
cat > /workspace/custom_dataset.yaml << 'EOF'
# dataset configuration
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

# classes की संख्या
nc: 3

# class names
names:
  0: person
  1: car
  2: bicycle
EOF
```

### Roboflow से import करें (अनुशंसित)

```python
# Roboflow इंस्टॉल करें
pip install roboflow

from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("your-workspace").project("your-project")
version = project.version(1)
dataset = version.download("yolov9")

# Dataset अब ./your-project-1/ पर है
```

### YOLOv10 को प्रशिक्षित करें

```python
from ultralytics import YOLO

# pretrained YOLOv10 model लोड करें (transfer learning)
model = YOLO("yolov10m.pt")  # मध्यम संस्करण — अच्छा संतुलन

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=16,               # अपने GPU VRAM के अनुसार समायोजित करें
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov10_custom",
    patience=50,            # प्रारंभिक रोक
    save=True,
    save_period=10,         # हर 10 एपॉक्स पर चेकपॉइंट सहेजें
    plots=True,
    val=True,
    augment=True,           # डेटा ऑग्मेंटेशन
    degrees=10.0,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.1,
    copy_paste=0.1,
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    amp=True                # स्वचालित मिश्रित परिशुद्धता (FP16)
)

print(f"प्रशिक्षण पूरा! सर्वश्रेष्ठ mAP: {results.results_dict['metrics/mAP50-95(B)']:.3f}")
```

### YOLOv9 को प्रशिक्षित करें

```python
from ultralytics import YOLO

model = YOLO("yolov9e.pt")

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=8,               # v9e बड़ा है, कम batch की आवश्यकता है
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)
```

{% hint style="info" %}
**प्रशिक्षण सुझाव:**

* **बैच आकार:** से शुरू करें `batch=16` for RTX 4090, `batch=32` for A100 40GB
* **छवि आकार:** `imgsz=640` मानक है; उच्च-रिज़ॉल्यूशन कार्यों के लिए 1280 उपयोग करें
* **एपॉक्स:** 100 epochs fine-tuning के लिए सामान्य हैं, scratch से training के लिए 300+
* **AMP (मिक्स्ड प्रिसिजन):** हमेशा सक्षम करें `amp=True` 1.5–2x speedup के लिए
  {% endhint %}

***

## चरण 6 — अधिकतम गति के लिए TensorRT में निर्यात करें

```python
from ultralytics import YOLO

# प्रशिक्षित model लोड करें
model = YOLO("/workspace/runs/yolov10_custom/weights/best.pt")

# सर्वोत्तम गति/सटीकता संतुलन के लिए TensorRT में निर्यात करें (FP16)
model.export(
    format="engine",        # TensorRT इंजन
    device="cuda",
    half=True,              # FP16
    dynamic=False,          # अधिकतम TRT अनुकूलन के लिए स्थिर आकृतियाँ
    batch=1,                # बैच आकार 1 (रीयल-टाइम) के लिए अनुकूलित करें
    imgsz=640,
    workspace=4             # GB में TRT वर्कस्पेस
)
# इस रूप में सहेजा गया: best.engine

# TRT engine लोड करें और चलाएँ
trt_model = YOLO("best.engine")
results = trt_model("image.jpg")
```

### ONNX में निर्यात करें

```python
# डिप्लॉयमेंट लचीलापन के लिए ONNX में निर्यात करें
model.export(
    format="onnx",
    opset=17,
    half=True,              # FP16 weights
    dynamic=True,           # गतिशील batch size
    simplify=True
)
```

***

## चरण 7 — REST API के रूप में सर्व करें

```bash
pip install fastapi uvicorn python-multipart

cat > /workspace/yolo_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse, FileResponse
from ultralytics import YOLO
from PIL import Image
import io
import uuid
import os

app = FastAPI(title="YOLOv10 डिटेक्शन API")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ठीक", "model": "yolov10x", "device": "cuda"}

@app.post("/detect")
async def detect(
    file: UploadFile = File(...),
    conf: float = 0.25,
    iou: float = 0.45,
    return_image: bool = False
):
    # अपलोड की गई छवि पढ़ें
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    
    # डिटेक्शन चलाएँ
    results = model(img, conf=conf, iou=iou, verbose=False)
    result = results[0]
    
    # प्रतिक्रिया बनाएं
    detections = []
    for box in result.boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": round(float(box.conf[0]), 4),
            "bbox": [round(x, 2) for x in box.xyxy[0].tolist()],
            "class_id": int(box.cls[0])
        })
    
    response = {
        "count": len(detections),
        "detections": detections,
        "image_size": list(result.orig_shape)
    }
    
    if return_image:
        output_path = f"/tmp/{uuid.uuid4()}.jpg"
        result.save(filename=output_path)
        return FileResponse(output_path, media_type="image/jpeg")
    
    return JSONResponse(response)

@app.post("/detect/batch")
async def detect_batch(files: list[UploadFile] = File(...)):
    results = []
    for file in files:
        data = await file.read()
        img = Image.open(io.BytesIO(data)).convert("RGB")
        res = model(img, verbose=False)[0]
        results.append({
            "filename": file.filename,
            "count": len(res.boxes),
            "detections": [
                {"class": model.names[int(b.cls[0])], "conf": float(b.conf[0])}
                for b in res.boxes
            ]
        })
    return JSONResponse({"results": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/yolo_api.py &

# API का परीक्षण करें
curl -X POST "http://localhost:8000/detect" \\
    -F "file=@test_image.jpg" | python3 -m json.tool
```

***

## चरण 8 — अपने मॉडल का सत्यापन और बेंचमार्क करें

```python
from ultralytics import YOLO

model = YOLO("yolov10x.pt")

# COCO dataset पर मान्य करें
metrics = model.val(
    data="coco.yaml",
    imgsz=640,
    batch=32,
    device="cuda",
    half=True
)

print(f"mAP50:    {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")
print(f"परिशुद्धता: {metrics.box.mp:.3f}")
print(f"रिकॉल:    {metrics.box.mr:.3f}")

# गति बेंचमार्क करें
model.benchmark(
    format="engine",   # कई export formats की तुलना करें
    imgsz=640,
    half=True,
    device="cuda"
)
```

***

## परिणाम डाउनलोड करें

```bash
# अपनी स्थानीय मशीन से:
scp -P <ssh-port> root@<server-ip>:/workspace/runs/yolov10_custom/weights/best.pt ./
scp -P <ssh-port> root@<server-ip>:/workspace/output_video.mp4 ./

# पूरे training run को डाउनलोड करें
rsync -avz -e "ssh -p <ssh-port>" \\
    root@<server-ip>:/workspace/runs/ \\
    ./yolo_training_runs/
```

***

## समस्या निवारण

### प्रशिक्षण के दौरान CUDA Out of Memory

```python
# बैच आकार कम करें
model.train(data="data.yaml", batch=4, imgsz=640)

# या gradient checkpointing सक्षम करें
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)
```

### धीमी प्रशिक्षण गति

```python
# caching सक्षम करें (dataset को RAM/GPU में लोड करता है)
model.train(data="data.yaml", cache=True)  # RAM में cache करें
model.train(data="data.yaml", cache="disk")  # डिस्क में cache करें

# workers बढ़ाएँ (सावधानी: बहुत अधिक होने पर धीमा हो सकता है)
model.train(data="data.yaml", workers=8)
```

### कम mAP / खराब डिटेक्शन

```bash
# सुनिश्चित करें कि labels सही हैं (सामान्यीकृत, 0-1 के भीतर)
python3 -c \"
from ultralytics.data.utils import check_det_dataset
check_det_dataset('custom_dataset.yaml')
"

# प्रशिक्षण नमूनों को विज़ुअलाइज़ करें
python3 -c \"
from ultralytics import YOLO
model = YOLO('yolov10m.pt')
model.train(data='data.yaml', epochs=1, batch=4, plots=True)
# /workspace/runs/train/exp/train_batch*.jpg जांचें
"
```

***

## प्रदर्शन संदर्भ (Clore.ai GPUs)

| मॉडल         | GPU      | बैच | FPS (इन्फ़रेंस) | mAP50-95 |
| ------------ | -------- | --- | --------------- | -------- |
| YOLOv10n     | RTX 3090 | 1   | 1,200           | 38.5     |
| YOLOv10s     | RTX 3090 | 1   | 780             | 46.8     |
| YOLOv10m     | RTX 4090 | 1   | 950             | 51.3     |
| YOLOv10x     | RTX 4090 | 1   | 380             | 54.4     |
| YOLOv9e      | A100 40G | 1   | 720             | 55.6     |
| YOLOv10x TRT | RTX 4090 | 1   | 920             | 54.2     |

***

## अतिरिक्त संसाधन

* [Ultralytics दस्तावेज़ीकरण](https://docs.ultralytics.com/)
* [YOLOv9 पेपर](https://arxiv.org/abs/2402.13616)
* [YOLOv10 पेपर](https://arxiv.org/abs/2405.14458)
* [Roboflow Universe](https://universe.roboflow.com/) — 100K+ सार्वजनिक डेटासेट
* [Ultralytics HUB](https://hub.ultralytics.com/) — क्लाउड प्रशिक्षण प्लेटफ़ॉर्म
* [COCO डेटासेट](https://cocodataset.org/) — मानक बेंचमार्क डेटासेट

***

*Clore.ai GPU रेंटल्स पर YOLOv9 और YOLOv10, कस्टम ऑब्जेक्ट डिटेक्शन मॉडल को प्रशिक्षित करने और रीयल-टाइम इन्फ़ेरेंस पाइपलाइनों को तैनात करने का एक किफायती तरीका प्रदान करते हैं — AWS SageMaker या Google Vertex AI की अतिरिक्त जटिलता के बिना।*

***

## Clore.ai GPU अनुशंसाएँ

| उपयोग-प्रकरण       | अनुशंसित GPU    | Clore.ai पर अनुमानित लागत                 |
| ------------------ | --------------- | ----------------------------------------- |
| विकास/परीक्षण      | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| प्रोडक्शन इनफ़रेंस | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| बड़े-बैच प्रशिक्षण | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

> 💡 इस गाइड के सभी उदाहरण [Clore.ai](https://clore.ai/marketplace) GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/computer-vision/yolov9-v10.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.