> 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/models/hi/train/neural-architecture-search.md).

# न्यूरल आर्किटेक्चर सर्च

उत्तम मॉडल आर्किटेक्चर की स्वचालित खोज करें और साथ ही अपने मॉडल को फाइन-ट्यून करें।

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-a09482f629727fe1cfe37ef9c7c0052ee9b40694%2Fnas-mining-curve.png?alt=media" alt="NAS results page showing a Pareto frontier of trained models plotted across latency and accuracy."><figcaption><p>NAS परिणाम पृष्ठ स्पीड-बनाम-एक्यूरेसी Pareto फ्रंटियर पर हर प्रशिक्षित मॉडल दिखाता है।</p></figcaption></figure>

Roboflow का Neural Architecture Search (NAS) एक शक्तिशाली नई सुविधा है, जो आपके डेटासेट पर दर्जनों मॉडल आर्किटेक्चर को अपने-आप प्रशिक्षित करती है और स्पीड-बनाम-एक्यूरेसी ट्रेडऑफ़ कर्व पर सबसे अच्छे विकल्प सामने लाती है। इससे चुनने के लिए कई मॉडल विकल्प मिलते हैं और प्रति मॉडल लागत पारंपरिक मॉडल प्रशिक्षण रणनीतियों से कम होती है।

जैसा कि [RF-DETR पेपर में समझाया गया है](https://arxiv.org/html/2511.09554v2), इसी Neural Architecture Search रणनीति से RF-DETR का SOTA मॉडल आर्किटेक्चर तैयार हुआ। Roboflow यह रणनीति सभी Roboflow ग्राहकों के लिए उपलब्ध करा रहा है, ताकि कोई भी अपने उपयोग के मामले के लिए SOTA मॉडल बना सके।

Neural Architecture Search:

* आपके डेटा की विशेषताओं के आधार पर उस मॉडल आर्किटेक्चर की पहचान करता है जो आपके उपयोग के मामले के लिए सबसे उपयुक्त है
* उस आर्किटेक्चर को आपके डेटा पर फाइन-ट्यून करता है
* 5,000 से अधिक कॉन्फ़िगरेशन का परीक्षण करता है, जिससे 10–100 प्रशिक्षित मॉडल मिलते हैं, जो हर लेटेंसी स्तर पर एक्यूरेसी के लिए अनुकूलित होते हैं।

{% embed url="<https://youtu.be/ZtGXkuo1qiE>" %}

## Neural Architecture Search का उपयोग कब करें

प्रोडक्शन में इस्तेमाल होने वाला मॉडल चुनते समय NAS चलाना लगभग हमेशा फ़ायदेमंद होता है। चूँकि Pareto फ्रंटियर पर खोजा गया हर मॉडल आपके डेटा पर पूरी तरह प्रशिक्षित होता है, इसलिए आप सिर्फ़ कोई आकार नहीं चुनते—आप अपने खास डिप्लॉयमेंट लक्ष्य के लिए स्पीड और एक्यूरेसी के बीच सबसे अच्छा संतुलन चुनते हैं। ग्राहकों के वास्तविक रन में, समान लेटेंसी पर NAS अक्सर एक RF-DETR Medium फाइन-ट्यून से बेहतर प्रदर्शन करता है, और कई बार काफ़ी बड़े अंतर से।

इन स्थितियों में NAS चुनें:

* आपको किसी तय लेटेंसी बजट पर बेहतर एक्यूरेसी चाहिए, या किसी तय एक्यूरेसी लक्ष्य पर बेहतर लेटेंसी चाहिए।
* आप प्रोडक्शन के लिए मॉडल तैयार कर रहे हैं और स्पीड/एक्यूरेसी कर्व पर विकल्पों की तुलना करना चाहते हैं।
* अन्यथा आप हाइपरपैरामीटर स्वीप चलाते या अलग-अलग मॉडल आकारों को एक के बाद एक प्रशिक्षित करते।
* आपको अत्याधुनिक प्रदर्शन चाहिए।

NAS ज़रूरत से ज़्यादा हो सकता है, अगर:

* आपका उपयोग का मामला सीधा-सादा है और “काफ़ी अच्छा” मॉडल पर्याप्त है (उदाहरण: अच्छी रोशनी वाले वातावरण में लोगों का पता लगाना)। शुरुआती खोज या परियोजना के आरंभिक चरणों में, आमतौर पर एक फाइन-ट्यून ही सही विकल्प होता है।
* आप केवल सबसे बड़ा RF-DETR चेकपॉइंट चाहते हैं (उदाहरण: RF-DETR XXL) और छोटे ट्रेडऑफ़ विकल्पों की परवाह नहीं करते।

## लागत, क्रेडिट और प्लान की उपलब्धता

NAS Core पर उपलब्ध है, जिसमें Free Tier भी शामिल है।

NAS रन का बिलिंग प्रशिक्षण समय के लिए Roboflow की मानक प्रशिक्षण दर पर होता है—ठीक किसी भी अन्य प्रशिक्षण जॉब की तरह (देखें [क्रेडिट पृष्ठ](https://roboflow.com/credits))। एक रन से दर्जनों प्रशिक्षित मॉडल मिलते हैं, इसलिए लागत *प्रति मॉडल* हर मॉडल को अलग-अलग प्रशिक्षित करने की तुलना में कम होती है, लेकिन एक NAS जॉब पर कुल क्रेडिट खर्च एक फाइन-ट्यून से अधिक होता है।

बजट की योजना बनाने के लिए सामान्य अनुमान:

* लगभग 2,500 इमेज वाले ऑब्जेक्ट डिटेक्शन डेटासेट को आमतौर पर लगभग 18 घंटे (\~36 क्रेडिट) लगते हैं।
* **इंस्टेंस सेगमेंटेशन NAS** ऑब्जेक्ट डिटेक्शन NAS की तुलना में GPU का अधिक उपयोग करता है—रन लगभग 1.5–2 गुना अधिक लंबे होने की अपेक्षा करें।

शुरू करने से पहले Train UI अनुमानित अवधि और क्रेडिट लागत दिखाता है। अगर अनुमानित प्रशिक्षण समय एक दिन से अधिक है, तो जॉब शुरू होने से पहले आपसे पुष्टि करने को कहा जाएगा।

NAS रन में प्रशिक्षण और आर्किटेक्चर खोज का बिल अलग-अलग बनता है, इसलिए आप दोनों के लिए [क्रेडिट सीमा](https://docs.roboflow.com/models/hi/train/train-a-model.md#set-a-credit-cap) सेट कर सकते हैं। केवल प्रशिक्षण चरण पर सीमा लगाने से खोज चरण की सीमा तय नहीं होगी, और इसका उलटा भी सही है।

{% hint style="warning" %}
शुरू करने से पहले अपना क्रेडिट बैलेंस जाँच लें। [Flex Billing प्रबंधित करें](https://docs.roboflow.com/platform/billing-and-plans/enable-or-disable-flex-billing) शामिल और प्रीपेड क्रेडिट से अधिक खर्च को नियंत्रित करने के लिए।
{% endhint %}

## NAS बनाम YOLO-NAS

{% hint style="info" %}
यहाँ वर्णित “Neural Architecture Search” इंजन, **YOLO-NAS**से अलग है। YOLO-NAS एक YOLO-आधारित आर्किटेक्चर है, जो Roboflow की मॉडल सूची में भी दिखाई देता है। अगर आपने खास तौर पर NAS का उपयोग करने के लिए अपग्रेड किया है, तो Train पृष्ठ पर **Neural Architecture Search** इंजन चुनना सुनिश्चित करें—YOLO-NAS मॉडल आर्किटेक्चर नहीं।
{% endhint %}

Roboflow NAS, RF-DETR का उपयोग करके एक अधिक मज़बूत आधार से शुरू होता है, जिसका बैकबोन दुनिया के बारे में अधिक जानकारी समेटे हुए है। इसके बाद NAS आर्किटेक्चर को आपके डेटासेट के अनुसार ढालता है—उदाहरण के लिए, अगर आपका डेटा कम डिकोडर लेयर वाले मॉडल से बेहतर परिणाम देता है, तो NAS उस आर्किटेक्चर को अपने-आप खोजकर उपलब्ध करा सकता है।

## समर्थित कार्य और ज्ञात सीमाएँ

NAS फ़िलहाल इन कार्यों का समर्थन करता है:

* ऑब्जेक्ट डिटेक्शन
* इंस्टेंस सेगमेंटेशन
* सेमांटिक सेगमेंटेशन

अन्य मौजूदा सीमाएँ:

* रॉ वेट्स (`.pt`, `.onnx`, आदि) को तृतीय-पक्ष इन्फ़रेंस सर्वर पर उपयोग के लिए डाउनलोड नहीं किया जा सकता। NAS मॉडल Roboflow Serverless Cloud API, Dedicated Deployments, Workflows, Batch Processing और सेल्फ़-होस्टेड [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/self-hosted)पर चलते हैं। NAS वेट्स डाउनलोड करके चलाने के लिए, हम Roboflow Inference की सलाह देते हैं।
* NAS द्वारा खोजे गए मॉडल वेट्स Roboflow के [Platform Model License](https://roboflow.com/platform-model-license-1-0)के अंतर्गत लाइसेंस प्राप्त हैं, जिसके लिए आपका Roboflow खाता अच्छी स्थिति में होना आवश्यक है।

## NAS ट्रेनिंग रन शुरू करें

{% stepper %}
{% step %}
**Train टैब खोलें और Neural Architecture Search इंजन चुनें**

अपने प्रोजेक्ट में Train टैब खोलें (यहाँ: `https://app.roboflow.com/YOUR_WORKSPACE/YOUR_PROJECT_NAME/train`) और **Neural Architecture Search** इंजन चुनें।

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-9c88c779f5a8dde416ae742243ffb374d1802fd8%2Fnas-select-engine.png?alt=media" alt="Train tab engine selector with Neural Architecture Search highlighted."><figcaption><p>Train टैब में Neural Architecture Search इंजन चुनें।</p></figcaption></figure>
{% endstep %}

{% step %}
**बैकबोन चुनें**

एक से अधिक मॉडल वेरिएंट वाले प्रोजेक्ट प्रकारों के लिए (उदाहरण: ऑब्जेक्ट डिटेक्शन में Fast, Standard और Plus उपलब्ध हैं), आगे बढ़ने से पहले आपको एक बैकबोन चुनना होगा। अपने उपयोग के हिसाब से उपयुक्त वेरिएंट पर क्लिक करें। एक ही वेरिएंट वाले प्रोजेक्ट प्रकारों के लिए (उदाहरण: इंस्टेंस सेगमेंटेशन), यह अपने आप चुना जाता है।
{% endstep %}

{% step %}
**डेटासेट वर्शन चुनें या बनाएँ**

मौजूदा डेटासेट वर्शन चुनें या नया बनाएँ। कुछ सुझाव:

* हम NAS ट्रेनिंग के लिए अपने डेटासेट में ऑगमेंटेशन जोड़ने की सलाह नहीं देते।
* आपके वैलिडेशन स्प्लिट में कम-से-कम **15 इमेज**होनी चाहिए। स्थिर Pareto फ्रंटियर खोजने के लिए NAS को पर्याप्त वैलिडेशन डेटा चाहिए; 15 से कम वैलिडेशन इमेज वाले ट्रेनिंग अनुरोध API द्वारा अस्वीकार कर दिए जाएँगे।

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-02bb1b7e47d2cf1970692961d95adc5a2568b5c0%2Fnas-select-version.png?alt=media" alt="Dataset version selector for a NAS training run."><figcaption><p>अपने NAS रन के लिए डेटासेट वर्शन चुनें या बनाएँ।</p></figcaption></figure>
{% endstep %}

{% step %}

#### बैकबोन चुनें

ऑब्जेक्ट डिटेक्शन प्रोजेक्ट में आप बैकबोन के तीन विकल्पों में से चुन सकते हैं:

* **Fast** - सबसे तेज़ ट्रेनिंग; सबसे कम लेटेंसी वाले मॉडल खोजता है। CPU या एज डिप्लॉयमेंट के लिए सबसे उपयुक्त, जहाँ इन्फ़रेंस की गति सर्वोच्च प्राथमिकता होती है।
* **Standard** - ट्रेनिंग समय संतुलित; अलग-अलग लेटेंसी वाले मॉडल खोजता है। एज या GPU डिप्लॉयमेंट के लिए सबसे उपयुक्त, जहाँ आप गति और सटीकता के बीच अच्छा संतुलन चाहते हैं।
* **Plus** - सबसे सटीक मॉडल खोजता है। क्लाउड GPU डिप्लॉयमेंट के लिए सबसे उपयुक्त, जहाँ लेटेंसी से अधिक सटीकता मायने रखती है।

सेमांटिक सेगमेंटेशन प्रोजेक्ट में Standard और Plus में से चुना जा सकता है। इंस्टेंस सेगमेंटेशन प्रोजेक्ट में एक ही बैकबोन होता है, इसलिए यह चरण छोड़ दिया जाता है।
{% endstep %}

{% step %}
**ट्रेनिंग शुरू करें**

क्लिक करें **Start Training** ताकि रन शुरू हो जाए।

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-82ea8de41405493849bbdc9c9284990331d993a7%2Fnas-start-train.png?alt=media" alt="Start Training button on the NAS configuration page."><figcaption><p>कॉन्फ़िगरेशन पेज से NAS रन शुरू करें।</p></figcaption></figure>
{% endstep %}
{% endstepper %}

## NAS परिणाम पेज को समझना

<figure><img src="https://3815805500-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fcmo9mhfIjYrvFFy1U7dk%2Fuploads%2Fgit-blob-a09482f629727fe1cfe37ef9c7c0052ee9b40694%2Fnas-mining-curve.png?alt=media" alt="NAS results page with purple dots representing trained models along the Pareto frontier."><figcaption><p>हर बैंगनी बिंदु एक पूरी तरह से प्रशिक्षित मॉडल दर्शाता है, जिसे डिप्लॉय किया जा सकता है।</p></figcaption></figure>

परिणाम पेज पर वे सभी मॉडल दिखते हैं जिन्हें NAS ने आपके डेटा पर खोजा और प्रशिक्षित किया है। इन्हें Pareto फ्रंटियर पर दर्शाया जाता है—हर लेटेंसी बिंदु पर खोजा गया सबसे अच्छा मॉडल। हर बैंगनी बिंदु एक पूरी तरह से प्रशिक्षित मॉडल है, जिसे आप डिप्लॉय कर सकते हैं। मॉडल खोजने की प्रक्रिया आगे बढ़ने के साथ फ्रंटियर लाइव अपडेट होता रहता है, इसलिए पूरा रन समाप्त होने से पहले ही आप उम्मीदवारों का मूल्यांकन शुरू कर सकते हैं।

**मेट्रिक चुनना।** अपने उपयोग के लिए महत्वपूर्ण मेट्रिक के आधार पर फ्रंटियर का मूल्यांकन करने के लिए F1, mAP\@50 और mAP\@50:95 के बीच टॉगल करें। अलग-अलग मेट्रिक के लिए फ्रंटियर पर अलग-अलग मॉडल दिखाई दे सकते हैं—यह अपेक्षित है। वह मेट्रिक चुनें जो उत्पादन में मॉडल का मूल्यांकन करने के आपके तरीके को सबसे अच्छी तरह दर्शाती हो, फिर अपनी लक्षित लेटेंसी के लिए सबसे अच्छा मॉडल चुनें। अधिकांश उपयोगों के लिए हम F1 की सलाह देते हैं।

**मॉडलों को स्टार करना।** जिन मॉडलों का उपयोग करना चाहते हैं, उन्हें स्टार करें। स्टार किए गए मॉडल Workflow के मॉडल पिकर में दिखाई देते हैं; बिना स्टार वाले मॉडल परिणाम पेज पर बने रहते हैं, लेकिन पिकर को व्यवस्थित रखने के लिए उसमें छिपे रहते हैं। आप जितने चाहें उतने मॉडल स्टार करें—स्टार करना मुफ़्त है और इसे वापस भी किया जा सकता है। किसी तैयार मॉडल को स्टार करने से उसका [मॉडल मूल्यांकन](https://docs.roboflow.com/models/hi/evaluate/evaluate-trained-models.md) भी शुरू हो जाता है, जिससे आपको सटीकता और लेटेंसी के परिणाम उस ऑप्टिमाइज़ेशन के साथ मिलते हैं जो स्टार करने पर पहले से शुरू होता है। जिस मॉडल का मूल्यांकन पहले से मौजूद है—चाहे वह प्रतीक्षा में हो, चल रहा हो या पूरा हो चुका हो—उसका दोबारा मूल्यांकन नहीं किया जाता। मूल्यांकन केवल उन वर्कस्पेस में चलता है जहाँ Model Evaluation उपलब्ध है।

**स्टार किए गए मॉडल का उपयोग करना।** Workflow में मॉडल ब्लॉक का उपयोग करके उसे चुनें, ठीक वैसे ही जैसे आप किसी अन्य Roboflow मॉडल को चुनते हैं।

किसी रन के दौरान NAS जिन लाइव ट्रेनिंग चार्ट को दिखाता है (Training Progress Band और Epoch Snapshot व्यू), उनके बारे में अधिक जानकारी के लिए देखें [ट्रेनिंग के नतीजे देखें](https://docs.roboflow.com/models/hi/evaluate/training-results.md).

## NAS रन रोकना

NAS जॉब के दो चरण होते हैं - **ट्रेनिंग** और **माइनिंग** - जो एक ही जॉब में लगातार चलते हैं। रन रोकने के दो तरीके हैं:

* **समय से पहले रोकें** (जब आप मौजूदा फ्रंटियर से संतुष्ट हों, तो यह तरीका सुझाया जाता है)। चरण के आधार पर "Stop Training Early" या "Stop Mining" पर क्लिक करें। उस समय तक माइन किए गए मॉडल सुरक्षित रहते हैं और उन्हें डिप्लॉय किया जा सकता है। पूरे हो चुके काम के लिए क्रेडिट का शुल्क लिया जाता है। विवरण के लिए देखें [ट्रेनिंग जॉब रोकें या रद्द करें](https://docs.roboflow.com/models/hi/train/cancel-a-training-job.md) ।
* **रद्द करें** (जब आप पूरा रन छोड़ना चाहते हों)। "Cancel Training" पर क्लिक करें। कोई वेट सेव नहीं होता, लेकिन जॉब की शुरुआत में रद्द करने पर क्रेडिट वापस कर दिए जाते हैं। देखें [ट्रेनिंग जॉब रोकें या रद्द करें](https://docs.roboflow.com/models/hi/train/cancel-a-training-job.md).

{% hint style="info" %}
मॉडल के कन्वर्ज होने पर NAS रन अपने-आप भी रुक जाते हैं—यानी, सभी लक्षित epoch पूरे होने से पहले ही अधिकतम प्रदर्शन पर पहुँचने पर। ऐसा होने पर परिणाम पेज पर एक बैनर दिखाई देता है। आपको कोई कार्रवाई करने की आवश्यकता नहीं है।
{% endhint %}

## NAS द्वारा खोजे गए मॉडल डिप्लॉय करना

NAS द्वारा खोजे गए मॉडल को किसी भी अन्य Roboflow-प्रशिक्षित मॉडल की तरह ही डिप्लॉय किया जाता है। आप इन्हें यहाँ चला सकते हैं:

* **Roboflow Serverless Cloud API** (नीचे दिए गए कोड उदाहरण देखें)।
* **Dedicated Deployments** अधिक थ्रूपुट या आरक्षित क्षमता के लिए।
* **Workflows** और **Batch Processing** विज़न पाइपलाइन बनाने और चलाने के लिए।
* **स्वयं-होस्ट किया गया** [**Roboflow Inference**](https://docs.roboflow.com/deployment/self-hosted/self-hosted) अपने हार्डवेयर पर (Docker, edge या cloud)।

### Roboflow Inference के साथ NAS मॉडल स्थानीय रूप से चलाना

इंस्टॉल करें और शुरू करें [Roboflow Inference](https://docs.roboflow.com/deployment/self-hosted/inference-server/install) अपने हार्डवेयर पर, फिर `inference-sdk` को `http://localhost:9001` पर सेट करें और अपने NAS मॉडल ID के साथ वैसे ही कॉल करें जैसे आप किसी अन्य Roboflow मॉडल के लिए करते हैं। नीचे दिए गए कोड उदाहरण होस्ट किए गए एंडपॉइंट और स्थानीय Inference सर्वर, दोनों के साथ काम करते हैं—बस `api_url`.

### Roboflow Serverless Cloud API

{% tabs %}
{% tab title="Python (requests)" %}

```python
import base64

import requests

API_KEY = "roboflow-API-KEY"
MODEL_ID = "your-workspace/the-model-id-here"
IMAGE_PATH = "your_image_path.png"

with open(IMAGE_PATH, "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

response = requests.post(
    f"https://serverless.roboflow.com/{MODEL_ID}",
    headers={
        "Content-Type": "application/x-www-form-urlencoded",
        "Authorization": f"Bearer {API_KEY}",
    },
    data=image_data,
)

print(response.json())
```

{% endtab %}

{% tab title="Python (inference-sdk)" %}
निर्भरताएँ इंस्टॉल करने के लिए, `pip install inference-sdk`.

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

CLIENT = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key="roboflow-API-KEY"
).configure(InferenceConfiguration(api_key_transport="header"))

result = CLIENT.infer("your_image_path.png", model_id="your-workspace/the-model-id-here")
print(result)
```

{% endtab %}

{% tab title="cURL" %}
**Linux या MacOS**

नाम की स्थानीय फ़ाइल के लिए JSON पूर्वानुमान प्राप्त करना `your_image_path.png`:

```bash
base64 your_image_path.png | curl -d @- \
-H "Authorization: Bearer roboflow-API-KEY" \
"https://serverless.roboflow.com/your-workspace/the-model-id-here"
```

वेब पर कहीं और होस्ट की गई इमेज के URL के ज़रिए अनुमान लगाना (इसे URL encode करना [न भूलें](https://www.urlencoder.org/)):

```bash
curl -X POST \
-H "Authorization: Bearer roboflow-API-KEY" \
"https://serverless.roboflow.com/your-workspace/the-model-id-here?\
image=https%3A%2F%2Fexample.com%2Fyour-image.jpg"
```

{% endtab %}

{% tab title="Javascript" %}
**Node.js**

ये उदाहरण अंतर्निहित `fetch` API का उपयोग करते हैं। यह Node.js 18 और उसके बाद के संस्करणों तथा आधुनिक ब्राउज़रों में काम करता है, इसलिए कोई निर्भरता इंस्टॉल करने की ज़रूरत नहीं है।

**स्थानीय इमेज पर अनुमान लगाना**

```javascript
const fs = require("fs");

const image = fs.readFileSync("your_image_path.png", {
    encoding: "base64"
});

fetch("https://serverless.roboflow.com/your-workspace/the-model-id-here", {
    method: "POST",
    headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        "Authorization": "Bearer roboflow-API-KEY"
    },
    body: image
})
    .then((response) => {
        if (!response.ok) throw new Error("Request failed with status " + response.status);
        return response.json();
    })
    .then((data) => {
        console.log(data);
    })
    .catch((error) => {
        console.log(error.message);
    });
```

**URL के ज़रिए कहीं और होस्ट की गई इमेज पर अनुमान लगाना**

```javascript
fetch(
    "https://serverless.roboflow.com/your-workspace/the-model-id-here?image=" +
        encodeURIComponent("https://example.com/your-image.jpg"),
    {
        method: "POST",
        headers: {
            "Authorization": "Bearer roboflow-API-KEY"
        }
    }
)
    .then((response) => {
        if (!response.ok) throw new Error("Request failed with status " + response.status);
        return response.json();
    })
    .then((data) => {
        console.log(data);
    })
    .catch((error) => {
        console.log(error.message);
    });
```

{% endtab %}
{% endtabs %}
