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

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

YOLO (You Only Look Once) रीयल-टाइम ऑब्जेक्ट डिटेक्शन के लिए स्वर्ण मानक बना हुआ है। YOLOv9 ने Programmable Gradient Information (PGI) और Generalized Efficient Layer Aggregation Network (GELAN) पेश किए, जबकि YOLOv10 ने dual-label असाइनमेंट के साथ 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 vs YOLOv10 vs 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-फ्री है** — कोई पोस्ट-प्रोसेसिंग नॉन-मैक्सिमम सप्रेशन चरण नहीं। इससे एंड-टू-एंड तैनाती संभव होती है और यह एज़/एम्बेडेड परिदृश्यों तथा TensorRT तैनाती के लिए खासकर लाभकारी है।
{% endhint %}

***

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

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

***

## पूर्व-आवश्यकताएँ

* GPU किराये के साथ Clore.ai खाता
* कस्टम मॉडल प्रशिक्षण के लिए प्रशिक्षण डेटा या COCO प्रीट्रेंड वेट्स का उपयोग
* बुनियादी 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 4090 पर TensorRT के साथ 1000+ FPS पर चलता है।
{% endhint %}

***

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

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

**Docker इमेज:**

```
ultralytics/ultralytics:latest
```

**पोर्ट्स:**

```
22
8000
```

**पर्यावरण चर:**

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

**डिस्क:** 20GB न्यूनतम (प्रिट्रेंड वेट्स + आपका डेटासेट)

***

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

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

# GPU जांचें
nvidia-smi

# Ultralytics इंस्टॉलेशन जांचें
python3 -c "import ultralytics; ultralytics.checks()"

# GPU जानकारी, CUDA संस्करण, और मॉडल उपलब्धता दिखनी चाहिए
```

***

## चरण 4 — प्रीट्रेंड मॉडलों के साथ त्वरित इनफरेंस

### YOLOv10 इनफरेंस (NMS-फ्री)

```python
from ultralytics import YOLO
import cv2

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

# किसी इमेज पर इनफरेंस चलाएँ
results = model("https://ultralytics.com/images/bus.jpg")

# परिणाम दिखाएँ
for result in results:
    boxes = result.boxes
    print(f"Detected {len(boxes)} objects")
    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} at {[int(x) for x in xyxy]}")

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

### YOLOv9 इनफरेंस

```python
from ultralytics import YOLO

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

# अधिकतम थ्रूपुट के लिए बैच इनफरेंस
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # समानांतर 8 इमेज प्रोसेस करें
    device="cuda",
    conf=0.25,      # कॉन्फिडेंस थ्रेशोल्ड
    iou=0.45,       # NMS IoU थ्रेशोल्ड (v10 के लिए आवश्यक नहीं)
    imgsz=640,
    half=True       # 2x स्पीडअप के लिए FP16
)
```

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

```python
from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# वेबकैम (device=0) या वीडियो फ़ाइल के लिए
cap = cv2.VideoCapture("input_video.mp4")

# वीडियो गुण प्राप्त करें
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"Processed {frame_count} frames")

cap.release()
out.release()
print("Done! Output saved to output_video.mp4")
```

***

## चरण 5 — एक कस्टम मॉडल ट्रेन करें

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

YOLO एक विशिष्ट निर्देशिका संरचना और लेबल प्रारूप का उपयोग करता है:

```
dataset/
├── images/
│   ├── train/          # प्रशिक्षण इमेजेज (.jpg/.png)
│   ├── val/            # वैलिडेशन इमेजेज
│   └── test/           # टेस्ट इमेजेज (वैकल्पिक)
└── labels/
    ├── train/          # लेबल फ़ाइलें (.txt)
    ├── val/
    └── test/
```

प्रत्येक लेबल फ़ाइल (इमेज के समान नाम, `.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'
# डेटासेट कॉन्फ़िगरेशन
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

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

# क्लास नाम
names:
  0: person
  1: car
  2: bicycle
EOF
```

### Roboflow से इम्पोर्ट करें (सिफारिश की गई)

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

# डेटासेट अब ./your-project-1/ में है
```

### YOLOv10 ट्रेन करें

```python
from ultralytics import YOLO

# प्रिट्रेंड YOLOv10 मॉडल लोड करें (ट्रांसफर लर्निंग)
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"Training complete! Best 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 बड़ा है, इसलिए कम बैच चाहिए
    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` RTX 4090 के लिए, `batch=32` A100 40GB के लिए
* **इमेज साइज:** `imgsz=640` मानक है; उच्च-रिज़ॉल्यूशन कार्यों के लिए 1280 का उपयोग करें
* **एपोच:** फाइन-ट्यूनिंग के लिए 100 एपोच सामान्य है, स्क्रैच से ट्रेनिंग के लिए 300+
* **AMP (मिक्स्ड प्रिसिशन):** हमेशां सक्षम करें `amp=True` 1.5–2x स्पीडअप के लिए
  {% endhint %}

***

## चरण 6 — अधिकतम गति के लिए TensorRT में एक्सपोर्ट करें

```python
from ultralytics import YOLO

# प्रशिक्षित मॉडल लोड करें
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             # TRT वर्कस्पेस GB में
)
# सहेजा गया रूप: best.engine

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

### ONNX में एक्सपोर्ट करें

```python
# तैनाती लचीलापन के लिए ONNX में एक्सपोर्ट करें
model.export(
    format="onnx",
    opset=17,
    half=True,              # FP16 वेट्स
    dynamic=True,           # डायनामिक बैच साइज
    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 Detection API")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ok", "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 डेटासेट पर सत्यापन
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"Precision: {metrics.box.mp:.3f}")
print(f"Recall:    {metrics.box.mr:.3f}")

# गति का बेंचमार्क
model.benchmark(
    format="engine",   # कई एक्सपोर्ट फॉर्मैट की तुलना करें
    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 ./

# पूरे प्रशिक्षण रन को डाउनलोड करें
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)

# या ग्रेडिएंट चेकपॉइंटिंग सक्षम करें
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)
```

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

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

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

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

```bash
# सत्यापित करें कि लेबल सही हैं (सामान्यीकृत, 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 यूनिवर्स](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.12/gpu/hr            |
| उत्पादन इन्फरेंस   | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |
| बड़े-बैच प्रशिक्षण | A100 80GB         | \~$1.20/gpu/hr            |

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