> 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/deployment/hi/self-hosted/sdks/luxonis-oak.md).

# Luxonis OAK

Myriad X VPU acceleration के साथ अपना Roboflow Train मॉडल अपने OpenCV AI Kit में डिप्लॉय करें।

यह [Luxonis OAK (OpenCV AI Kit)](https://shop.luxonis.com/) एक एज डिवाइस है, जिसका उपयोग एम्बेडेड कंप्यूटर विज़न सिस्टम तैनात करने के लिए लोकप्रिय रूप से किया जाता है।

OAK डिवाइस एक होस्ट मशीन के साथ जोड़े जाते हैं, जो डाउनस्ट्रीम एप्लिकेशन के संचालन को नियंत्रित करती है। कुछ शानदार प्रेरणा के लिए देखें [Luxonis के उपयोग के मामले](https://docs.luxonis.com/en/latest/#example-use-cases) और [Roboflow के केस स्टडीज़](https://blog.roboflow.com/tag/case-studies/).

**वैसे:** अगर आपके पास अभी तक OAK डिवाइस नहीं है, तो आप इसे [Roboflow Store से खरीद सकते हैं](https://store.roboflow.com/) और 10% की छूट पा सकते हैं।

### कार्य का समर्थन

होस्ट किए गए API द्वारा निम्नलिखित टास्क प्रकार समर्थित हैं:

| कार्य का प्रकार                                                                                                                                                           | Luxonis OAK के साथ समर्थित डिप्लॉयमेंट |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- |
| <p>ऑब्जेक्ट डिटेक्शन:</p><ul><li>Roboflow पर प्रशिक्षित YOLOv8 मॉडल (सभी आकार: Nano, Small, Medium, Large, X Large)</li><li>Roboflow पर प्रशिक्षित YOLOv11 मॉडल</li></ul> | ✅                                      |
| वर्गीकरण                                                                                                                                                                  |                                        |
| इंस्टेंस सेगमेंटेशन                                                                                                                                                       |                                        |
| सिमेंटिक सेगमेंटेशन                                                                                                                                                       |                                        |

### Luxonis OAK पर मॉडल डिप्लॉय करें

#### समर्थित Luxonis डिवाइस और होस्ट की आवश्यकताएँ

Roboflow Inference Server निम्नलिखित डिवाइसों को सपोर्ट करता है:

* OAK-D
* OAK-D-Lite
* OAK-D-POE
* OAK-1 (डेप्थ के बिना)

#### इंस्टॉलेशन

इंस्टॉल करें `roboflowoak`, `depthai`, और `opencv-python` पैकेज:

```bash
pip install roboflowoak
pip install depthai
pip install opencv-python
```

अब आप `roboflowoak` पैकेज का उपयोग करके अपना कस्टम-प्रशिक्षित Roboflow मॉडल चला सकते हैं।

#### इन्फ़रेंस चलाना: डिप्लॉयमेंट

यदि आप Depth क्षमताओं के बिना OAK डिवाइस पर डिप्लॉय कर रहे हैं, तो `depth=False` rf `इंस्टैंशिएट (बनाते) समय` ऑब्जेक्ट सेट करें। Depth वाले OAK मॉडल के नाम में "D" जुड़ा होता है, जैसे OAK-D और OAK-D-Lite।

साथ ही, इसे टिप्पणी के रूप में निष्क्रिय करें: `max_depth = np.amax(depth)` और `cv2.imshow("depth", depth/max_depth)`

```python
from roboflowoak import RoboflowOak
import cv2
import time
import numpy as np

if __name__ == '__main__':
    # RoboflowOak मॉड्यूल के साथ एक ऑब्जेक्ट (rf) इंस्टैंशिएट करना
    rf = RoboflowOak(model="YOUR-MODEL-ID", confidence=0.05, overlap=0.5,
    version="YOUR-MODEL-VERSION-#", api_key="YOUR-PRIVATE_API_KEY", rgb=True,
    depth=True, device=None, blocking=True)
    # हमारा मॉडल चलाना और डिटेक्शन के साथ वीडियो आउटपुट दिखाना
    while True:
        t0 = time.time()
        # rf.detect() फ़ंक्शन मॉडल का अनुमान चलाता है
        result, frame, raw_frame, depth = rf.detect()
        predictions = result["predictions"]
        #{
        #    predictions:
        #    [ {
        #        x: (मध्य),
        #        y:(मध्य),
        #        width:
        #        height:
        #        depth: ###->
        #        confidence:
        #        class:
        #        mask: {
        #    ]
        #}
        #frame - प्रीप्रोसेसिंग के बाद का फ़्रेम, जिसमें पूर्वानुमान शामिल हैं
        #raw_frame - आपके OAK से प्राप्त मूल फ़्रेम
        #depth - raw_frame का डेप्थ मैप, जिसे केंद्र कैमरे के केंद्र के अनुसार रेक्टिफ़ाई किया गया है
        
        # timing: बेंचमार्किंग के लिए
        t = time.time()-t0
        print("FPS ", 1/t)
        print("PREDICTIONS ", [p.json() for p in predictions])

        # डेप्थ की गणना के लिए पैरामीटर सेट करना
        # यदि आप Depth के बिना OAK का उपयोग कर रहे हैं, तो नीचे की 2 पंक्तियों को टिप्पणी के रूप में चिह्नित करें
        max_depth = np.amax(depth)
        cv2.imshow("depth", depth/max_depth)
        # वीडियो फ़ीड को लगातार आने वाले फ़्रेम के रूप में दिखाना
        cv2.imshow("frame", frame)
    
        # OAK अनुमान विंडो बंद करने / अनुमान रोकने के लिए: CTRL+q या CTRL+c
        if cv2.waitKey(1) == ord('q'):
            break
```

नीचे दिया गया कोड दर्ज करें (प्लेसहोल्डर टेक्स्ट को अपनी Python स्क्रिप्ट के पाथ से बदलने के बाद)

```bash
# विंडो बंद करने के लिए (अनुमान रोकें या समाप्त करें), अपने कीबोर्ड पर CTRL+c दबाएँ
python3 /path/to/[YOUR-PYTHON-FILE].py
```

होस्ट डिवाइस के रूप में Apple Macbook Air (M1) का उपयोग करने पर अनुमान की गति (मिलीसेकंड में) औसतन लगभग 15 ms, यानी 66 FPS रही। ***ध्यान दें**: OAK के साथ उपयोग किया जाने वाला होस्ट डिवाइस FPS पर बहुत बड़ा असर डालता है। अपना सिस्टम बनाते समय इसे ध्यान में रखें।*

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

यदि आपको अपना OAK डिवाइस सेट अप करने में समस्या आ रही है, तो Luxonis के इंस्टॉलेशन निर्देश देखें और सुनिश्चित करें कि आप RGB उदाहरण को सफलतापूर्वक चला सकते हैं [Luxonis इंस्टॉलेशन](https://docs.luxonis.com/en/latest/#demo-script)पर। आप यहाँ मदद के लिए पोस्ट भी कर सकते हैं: [Roboflow फ़ोरम](https://discuss.roboflow.com/).

### यह भी देखें

* [Luxonis OAK सेटअप के लिए चरण-दर-चरण मार्गदर्शिका](https://blog.roboflow.com/opencv-ai-kit-deployment/)
* [M1 Chip का उपयोग करते समय इंस्टॉलेशन संबंधी समस्या · Issue #299 · luxonis/depthai · GitHub](https://github.com/luxonis/depthai/issues/299) (depthai SDK)
