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

# Neural Architecture Search

<figure><img src="/files/c57a18d202c9f2223d59663c934f463ade6ab176" alt="NAS results page showing a Pareto frontier of trained models plotted across latency and accuracy."><figcaption><p>NAS results page गति-विरुद्ध-शुद्धता Pareto frontier के साथ प्रशिक्षित हर model को दिखाता है।</p></figcaption></figure>

Roboflow का Neural Architecture Search (NAS) एक शक्तिशाली नया feature है, जो आपके dataset पर automatically दर्जनों model architectures को train करता है और speed-vs-accuracy tradeoff curve के साथ सबसे अच्छे options दिखाता है, जिससे पारंपरिक model training strategies की तुलना में प्रति model कम cost पर चुनने के लिए कई model options generate होते हैं।

जैसा कि बताया गया है [RF-DETR paper में](https://arxiv.org/html/2511.09554v2), यही Neural Architecture Search strategy है जिसने RF-DETR की SOTA model architecture बनाई। Roboflow इस strategy को सभी Roboflow customers के लिए उपलब्ध करा रहा है, जिससे कोई भी अपने use case के लिए SOTA models बना सके।

Neural Architecture Search:

* आपके data characteristics के आधार पर उस model architecture की पहचान करता है जो आपके use case के लिए सबसे उपयुक्त है
* उस architecture को आपके data पर fine-tune करता है
* 5,000 से अधिक configurations का परीक्षण करता है, जिसके परिणामस्वरूप 10-100 प्रशिक्षित models मिलते हैं, जो हर latency point पर accuracy के लिए optimized होते हैं।

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

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

जब आप production में जाने वाले model को चुन रहे हों, तो NAS चलाना लगभग हमेशा worthwhile होता है। क्योंकि Pareto frontier पर मौजूद हर mined model आपके data पर पूरी तरह trained होता है, आप सिर्फ एक size नहीं चुनते — आप अपने specific deployment target के लिए सबसे अच्छा speed/accuracy tradeoff चुनते हैं। वास्तविक customer runs में, NAS नियमित रूप से समान latency पर single RF-DETR Medium fine-tune से बेहतर प्रदर्शन करता है, और अक्सर काफी बड़े margin से।

इन स्थितियों में NAS का उपयोग करें:

* आपको दिए गए latency budget पर बेहतर accuracy, या दिए गए accuracy target पर बेहतर latency चाहिए।
* आप production के लिए model तैयार कर रहे हैं और speed/accuracy curve के along options की तुलना करना चाहते हैं।
* अन्यथा आप hyperparameter sweep चलाते या कई model sizes को एक के बाद एक train करते।
* आपको state-of-the-art performance चाहिए।

NAS शायद जरूरत से ज्यादा हो सकता है यदि:

* आपका use case सीधा-सादा है और "good enough" model पर्याप्त है (जैसे: अच्छी रोशनी वाले environment में लोगों का पता लगाना)। Exploratory या early-stage projects के लिए, आमतौर पर एक single fine-tune सही विकल्प होता है।
* आप केवल सबसे बड़ा RF-DETR checkpoint चाहते हैं (जैसे: RF-DETR XXL) और छोटे trade-off points की परवाह नहीं करते।

## लागत, credits, और plan availability

NAS उन सभी paid Roboflow plans पर उपलब्ध है जिनमें usage-based billing शामिल है। Trial, Free, और Public plan users के पास NAS का access नहीं है। Legacy plans जिनमें usage-based billing नहीं है, उन्हें NAS run शुरू करने से पहले इसे enable करने के लिए कहा जाएगा।

NAS runs standard Roboflow training rate पर billed होते हैं — **प्रशिक्षण समय के 30 मिनट पर 1 credit** — किसी भी अन्य training job जैसी ही hourly rate। एक run दर्जनों trained models produce करता है, इसलिए cost *प्रति model* उन्हें अलग-अलग train करने की तुलना में कम होती है, लेकिन एक single NAS job के लिए कुल credit spend single fine-tune से अधिक होता है।

आम तौर पर जिन ranges के लिए योजना बनानी चाहिए:

* लगभग 2,500 images वाला object detection dataset आमतौर पर लगभग 18 घंटे (\~36 credits) चलता है।
* **Instance Segmentation NAS** object detection NAS की तुलना में अधिक GPU-intensive है — लगभग 1.5–2x लंबे runs की अपेक्षा करें।

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

{% hint style="warning" %}
यदि आपके workspace में flex billing disabled है और run के बीच आपके included credits खत्म हो जाते हैं, तो NAS स्वतः रुक जाएगा। Included-credit balance की परवाह किए बिना run पूरा होने देने के लिए, शुरू करने से पहले flex billing enable करें।
{% endhint %}

## NAS बनाम YOLO-NAS

{% hint style="info" %}
यहाँ वर्णित "Neural Architecture Search" engine वही नहीं है **YOLO-NAS**, जो एक single YOLO-based architecture है और Roboflow model list में भी दिखाई देती है। यदि आपने विशेष रूप से NAS का उपयोग करने के लिए upgrade किया है, तो सुनिश्चित करें कि आप Train page पर **Neural Architecture Search** engine चुन रहे हैं — YOLO-NAS model architecture नहीं।
{% endhint %}

Roboflow NAS RF-DETR का उपयोग करके एक मजबूत foundation से शुरू होता है, जो अपने backbone में अधिक world knowledge शामिल करता है। इसके बाद, NAS आपके dataset के अनुसार architecture को tailor करता है — उदाहरण के लिए, यदि आपके data को fewer decoder layers वाले model से लाभ मिलता है, तो NAS उस architecture को automatically discover और deliver कर सकता है।

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

NAS वर्तमान में समर्थन करता है:

* Object Detection
* Instance Segmentation

अन्य वर्तमान सीमाएँ:

* Raw weights (`.pt`, `.onnx`, आदि) को third-party inference servers पर उपयोग के लिए डाउनलोड नहीं किया जा सकता। NAS models Roboflow Serverless Hosted API, Dedicated Deployments, Workflows, Batch Processing, और self-hosted पर चलते हैं [Roboflow Inference](https://inference.roboflow.com/install/). NAS weights डाउनलोड करने और चलाने के लिए, हम Roboflow Inference की अनुशंसा करते हैं।
* NAS-discovered model weights Roboflow के [Platform Model License](https://roboflow.com/platform-model-license-1-0)के अंतर्गत licensed हैं, जिसके लिए आपके पास अच्छी स्थिति वाला Roboflow account होना आवश्यक है।

## NAS training run शुरू करें

{% stepper %}
{% step %}
**Train tab खोलें और Neural Architecture Search engine चुनें**

अपने project में Train tab खोलें (at `https://app.roboflow.com/YOUR_WORKSPACE/YOUR_PROJECT_NAME/train`) और **Neural Architecture Search** engine चुनें।

<figure><img src="/files/ba519c5697c139cd726b1f32af1ea536bfbe5469" alt="Train tab engine selector with Neural Architecture Search highlighted."><figcaption><p>Train tab पर Neural Architecture Search engine चुनें।</p></figcaption></figure>
{% endstep %}

{% step %}
**एक backbone चुनें**

जिन project types में multiple model variants होते हैं (जैसे: object detection Fast, Standard, और Plus प्रदान करता है), आगे बढ़ने से पहले आपको एक backbone चुनना होगा। अपने use case के अनुरूप variant पर क्लिक करें। जिन project types में single variant होता है (जैसे: instance segmentation), वह स्वतः चयनित हो जाता है।
{% endstep %}

{% step %}
**एक dataset version चुनें या बनाएँ**

कोई मौजूदा dataset version चुनें या नया बनाएँ। कुछ tips:

* हम NAS training के लिए अपने dataset में augmentations जोड़ने की अनुशंसा नहीं करते।
* आपके validation split में कम से कम **15 images**होनी चाहिए। NAS को एक स्थिर Pareto frontier खोजने के लिए पर्याप्त validation data चाहिए; API 15 से कम validation images वाले training requests को reject कर देगा।

<figure><img src="/files/994580b4cc1ab357ab4f200164c719da11248f0c" alt="Dataset version selector for a NAS training run."><figcaption><p>अपने NAS run के लिए एक dataset version चुनें या बनाएँ।</p></figcaption></figure>
{% endstep %}

{% step %}

#### एक backbone चुनें (केवल object detection)

Object detection projects के लिए, आप तीन backbone options में से चुन सकते हैं:

* **Fast** - सबसे तेज training, सबसे कम-latency models खोजता है। CPU या edge deployment के लिए सबसे अच्छा, जहाँ inference speed सर्वोच्च प्राथमिकता है।
* **Standard** - संतुलित training time, विस्तृत latency range में models खोजता है। Edge या GPU deployment के लिए सबसे अच्छा, जहाँ आप अच्छा speed-vs-accuracy tradeoff चाहते हैं।
* **Plus** - सबसे सटीक models खोजता है। Cloud GPU deployment के लिए सबसे अच्छा, जहाँ latency से अधिक accuracy महत्वपूर्ण है।

Instance segmentation projects एक single backbone का उपयोग करते हैं और यह चरण छोड़ देते हैं।
{% endstep %}

{% step %}
**Training शुरू करें**

क्लिक करें **Start Training** ताकि run शुरू किया जा सके।

<figure><img src="/files/2c08d764d2f4bb3bb5c86fb63e2d425aee18004f" alt="Start Training button on the NAS configuration page."><figcaption><p>Configuration page से NAS run शुरू करें।</p></figcaption></figure>
{% endstep %}
{% endstepper %}

## NAS results page पढ़ना

<figure><img src="/files/c57a18d202c9f2223d59663c934f463ade6ab176" alt="NAS results page with purple dots representing trained models along the Pareto frontier."><figcaption><p>हर बैंगनी dot एक पूरी तरह प्रशिक्षित model है जो deployment के लिए उपलब्ध है।</p></figcaption></figure>

Results page आपके data पर NAS द्वारा mined और trained हर model को दिखाती है, Pareto frontier के साथ plotted — प्रत्येक latency point पर खोजा गया सबसे अच्छा model। हर बैंगनी dot एक पूरी तरह प्रशिक्षित model है जिसे आप deploy कर सकते हैं। Mining आगे बढ़ने के साथ frontier live update होती रहती है, इसलिए आप full run पूरा होने से पहले ही candidates का मूल्यांकन शुरू कर सकते हैं।

**एक metric चुनना.** F1, mAP\@50, और mAP\@50:95 के बीच toggle करें ताकि frontier का मूल्यांकन उस metric के साथ किया जा सके जो आपके use case के लिए महत्वपूर्ण है। अलग-अलग metrics के लिए frontier पर अलग-अलग models दिखाई दे सकते हैं — यह अपेक्षित है। उस metric को चुनें जो production में model का मूल्यांकन करने के आपके तरीके को सबसे निकट से दर्शाता हो, फिर अपने target latency पर सबसे अच्छा model चुनें। हम अधिकांश use cases के लिए F1 की अनुशंसा करते हैं।

**Models को star करना.** जिन भी models का आप उपयोग करना चाहते हैं, उन्हें star करें। Star किए गए models Workflow model picker में दिखाई देते हैं; unstar किए गए models results page पर रहते हैं लेकिन picker से छिपाए जाते हैं ताकि वह cluttered न हो। जितने चाहें उतने models को star करें — starring निःशुल्क है और वापस बदला जा सकता है।

**Star किए गए model का उपयोग करना.** इसे Workflow में model block का उपयोग करके वैसे ही चुनें जैसे किसी अन्य Roboflow model को चुनते हैं।

Run के दौरान NAS द्वारा दिखाए जाने वाले live training charts (Training Progress Band और Epoch Snapshot views) के बारे में अधिक जानकारी के लिए देखें [Training Results देखें](/roboflow/roboflow-hi/train/training-results.md).

## एक NAS run रोकना

एक NAS job के दो phases होते हैं — **training** और **mining** — जो उसी job में एक के बाद एक चलते हैं। Run रोकने के आपके पास दो तरीके हैं:

* **जल्दी रोकें** (जब आप current frontier से संतुष्ट हों, तब अनुशंसित)। Phase के आधार पर "Stop Training Early" या "Stop Mining" पर क्लिक करें। उस बिंदु तक mined models रखे जाते हैं और deploy किए जा सकते हैं। पूरे हो चुके काम के लिए उपयोग किए गए credits billed किए जाते हैं। विवरण के लिए देखें [Early Stopping](/roboflow/roboflow-hi/train/stop-training-early.md) ।
* **रद्द करें** (जब आप run को पूरी तरह छोड़ना चाहते हों)। "Cancel Training" पर क्लिक करें। कोई weights save नहीं होते, लेकिन यदि आप job में जल्दी cancel करते हैं तो credits वापस कर दिए जाते हैं। देखें [एक Training Job रद्द करें](/roboflow/roboflow-hi/train/cancel-a-training-job.md).

{% hint style="info" %}
NAS runs तब भी स्वतः रुक जाते हैं जब model converge हो जाता है — यानी, सभी target epochs समाप्त होने से पहले peak performance तक पहुँच जाता है। Results page पर एक banner संकेत देता है कि ऐसा हुआ है। आपकी ओर से किसी कार्रवाई की आवश्यकता नहीं है।
{% endhint %}

## NAS-discovered models को deploy करना

NAS-discovered models ठीक वैसे ही deploy होते हैं जैसे कोई अन्य Roboflow-trained model। आप उन्हें इन पर चला सकते हैं:

* **Roboflow Serverless Hosted API** (code examples नीचे देखें)।
* **Dedicated Deployments** अधिक throughput या reserved capacity के लिए।
* **Workflows** और **Batch Processing** vision pipelines बनाने और चलाने के लिए।
* **Self-hosted** [**Roboflow Inference**](https://inference.roboflow.com/install/) अपने स्वयं के hardware पर (Docker, edge, या cloud)।

### Roboflow Inference के साथ NAS models को local रूप से चलाना

इंस्टॉल करें और शुरू करें [Roboflow Inference](https://inference.roboflow.com/install/) अपने hardware पर, फिर `inference-sdk` को `http://localhost:9001` पर point करें और इसे अपने NAS model ID के साथ ठीक वैसे ही call करें जैसे किसी अन्य Roboflow model को करते हैं। नीचे दिए गए code examples hosted endpoint और local Inference server दोनों के साथ काम करते हैं — बस `api_url`.

### Roboflow Serverless Hosted 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}",
    params={"api_key": API_KEY},
    headers={"Content-Type": "application/x-www-form-urlencoded"},
    data=image_data,
)

print(response.json())
```

{% endtab %}

{% tab title="Python (inference-sdk)" %}
dependencies install करने के लिए, `pip install inference-sdk`.

```python
from inference_sdk import InferenceHTTPClient

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

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

{% endtab %}

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

नाम की local file के लिए JSON predictions प्राप्त करना `your_image_path.png`:

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

URL के माध्यम से web पर कहीं और hosted image पर inference करना (यह न भूलें कि [इसे URL encode करें](https://www.urlencoder.org/)):

```bash
curl -X POST "https://serverless.roboflow.com/your-workspace/the-model-id-here?\
api_key=roboflow-API-KEY&\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png"
```

{% endtab %}

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

हम उपयोग कर रहे हैं [axios](https://github.com/axios/axios) इस उदाहरण में POST request करने के लिए, इसलिए पहले चलाएँ `npm install axios` dependency install करने के लिए।

**Local Image पर inference करना**

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

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

axios({
    method: "POST",
    url: "https://serverless.roboflow.com/your-workspace/the-model-id-here",
    params: {
        api_key: "roboflow-API-KEY"
    },
    data: image,
    headers: {
        "Content-Type": "application/x-www-form-urlencoded"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});
```

**URL के माध्यम से कहीं और hosted Image पर inference करना**

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

axios({
    method: "POST",
    url: "https://serverless.roboflow.com/your-workspace/the-model-id-here",
    params: {
        api_key: "roboflow-API-KEY",
        image: "https://i.imgur.com/PEEvqPN.png"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});
```

{% endtab %}
{% endtabs %}