> 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/legacy/legacy-serverless/classification.md).

# वर्गीकरण

Roboflow पर होस्ट किए गए classification models पर inference चलाएँ।

{% tabs %}
{% tab title="Python" %}
**स्थानीय और होस्ट की गई इमेज पर अनुमान लगाना**

निर्भरताएँ इंस्टॉल करने के लिए, `pip install inference-sdk`.

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

CLIENT = InferenceHTTPClient(
    api_url="https://classify.roboflow.com",
    api_key="API_KEY"
).configure(InferenceConfiguration(api_key_transport="header"))

result = CLIENT.infer(your_image.jpg, model_id="vehicle-classification-eapcd/2")
```

{% endtab %}

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

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

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

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

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

fetch("https://classify.roboflow.com/your-model/42", {
    method: "POST",
    headers: {
        "Authorization": "Bearer YOUR_KEY",
        "Content-Type": "application/x-www-form-urlencoded"
    },
    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);
    });
```

{% endtab %}

{% tab title="Swift" %}
**base64 का उपयोग करके स्थानीय इमेज अपलोड करना**

```swift
import UIKit

// इमेज लोड करें और Base64 में बदलें
let image = UIImage(named: "your-image-path") // अपलोड करने के लिए इमेज का पथ, जैसे: image.jpg
let imageData = image?.jpegData(compressionQuality: 1)
let fileContent = imageData?.base64EncodedString()
let postData = fileContent!.data(using: .utf8)

// API_KEY, मॉडल और मॉडल संस्करण के साथ Inference Server अनुरोध शुरू करें
var request = URLRequest(url: URL(string: "https://classify.roboflow.com/your-model/your-model-version?name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
request.setValue("Bearer YOUR_APIKEY", forHTTPHeaderField: "Authorization")
request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = postData

// POST अनुरोध निष्पादित करें
URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
    
    // प्रतिक्रिया को स्ट्रिंग में पार्स करें
    guard let data = data else {
        print(String(describing: error))
        return
    }
    
    // प्रतिक्रिया स्ट्रिंग को डिक्शनरी में बदलें
    do {
        let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
    } catch {
        print(error.localizedDescription)
    }
    
    // स्ट्रिंग प्रतिक्रिया प्रिंट करें
    print(String(data: data, encoding: .utf8)!)
}).resume()
```

{% endtab %}
{% endtabs %}

## रिस्पॉन्स ऑब्जेक्ट के फ़ॉर्मैट

{% tabs %}
{% tab title="एकल-लेबल वर्गीकरण" %}
**एकल-लेबल वर्गीकरण**

होस्ट किया गया API अनुमान रूट एक `JSON` ऑब्जेक्ट लौटाता है, जिसमें पूर्वानुमानों की एक ऐरे होती है। हर पूर्वानुमान में ये गुण होते हैं:

* `time` = इमेज को प्रोसेस करने और पूर्वानुमान लौटाने में लगा कुल समय, सेकंड में
* `image` = इमेज के बारे में जानकारी रखने वाला ऑब्जेक्ट `width` और `height`
  * `width` पूर्वानुमानित इमेज की ऊँचाई
  * `height` = पूर्वानुमानित इमेज की ऊँचाई
* `predictions` = पूर्वानुमान के लिए सभी अनुमानित वर्गों और उनसे जुड़े विश्वास मानों का संग्रह
  * `class` = वर्गीकरण का लेबल
  * `confidence` = मॉडल का यह विश्वास कि इमेज में पहचाने गए वर्गीकरण की वस्तुएँ मौजूद हैं
* `top` = सबसे अधिक विश्वास वाला अनुमानित वर्ग
* `confidence` = सबसे अधिक अनुमानित विश्वास स्कोर
* `image_path` = अनुमानित इमेज का पथ
* `prediction_type` = अनुमान लगाने के लिए इस्तेमाल किया गया मॉडल प्रकार, `ClassificationModel` इस मामले में

{% code overflow="wrap" %}

```json
// JSON ऑब्जेक्ट का एक उदाहरण
{
  "time": 0.19064618100037478,
  "image": {
    "width": 210,
    "height": 113
  },
  "predictions": [
    {
      "class": "real-image",
      "confidence": 0.7149
    },
    {
      "class": "illustration",
      "confidence": 0.2851
    }
  ],
  "top": "real-image",
  "confidence": 0.7149,
  "image_path": "/cropped-images-1.jpg",
  "prediction_type": "ClassificationModel"
}
```

{% endcode %}
{% endtab %}

{% tab title="बहु-लेबल वर्गीकरण" %}
**बहु-लेबल वर्गीकरण**

होस्ट किया गया API अनुमान रूट एक `JSON` ऑब्जेक्ट लौटाता है, जिसमें पूर्वानुमानों की एक ऐरे होती है। हर पूर्वानुमान में ये गुण होते हैं:

* `time` = इमेज को प्रोसेस करने और पूर्वानुमान लौटाने में लगा कुल समय, सेकंड में
* `image` = इमेज के बारे में जानकारी रखने वाला ऑब्जेक्ट `width` और `height`
  * `width` पूर्वानुमानित इमेज की ऊँचाई
  * `height` = पूर्वानुमानित इमेज की ऊँचाई
* `predictions` = पूर्वानुमान के लिए सभी अनुमानित वर्गों और उनसे जुड़े विश्वास मानों का संग्रह
  * `class` = वर्गीकरण का लेबल
  * `confidence` = मॉडल का यह विश्वास कि इमेज में पहचाने गए वर्गीकरण की वस्तुएँ मौजूद हैं
* `predicted_classes` = मॉडल के पूर्वानुमानों में लौटाए गए सभी वर्गीकरणों (लेबलों/वर्गों) की सूची वाला ऐरे
* `image_path` = अनुमानित इमेज का पथ
* `prediction_type` = अनुमान लगाने के लिए इस्तेमाल किया गया मॉडल प्रकार, `ClassificationModel` इस मामले में

<pre class="language-json" data-overflow="wrap"><code class="lang-json"><strong>// JSON ऑब्जेक्ट का एक उदाहरण
</strong>{
  "time": 0.19291414400004214,
  "image": {
    "width": 113,
    "height": 210
  },
  "predictions": {
    "dent": {
      "confidence": 0.5253503322601318
    },
    "severe": {
      "confidence": 0.5804202556610107
    }
  },
  "predicted_classes": [
    "dent",
    "severe"
  ],
  "image_path": "/car-model-343.jpg",
  "prediction_type": "ClassificationModel"
}
</code></pre>

{% endtab %}
{% endtabs %}

## API संदर्भ

## अनुमान API का उपयोग करना

<mark style="color:हरा;">`POST`</mark> `https://classify.roboflow.com/:datasetSlug/:versionNumber`

आप base64 में एन्कोड की गई छवि को सीधे अपने मॉडल एंडपॉइंट पर POST कर सकते हैं। या अगर आपकी छवि पहले से कहीं और होस्ट की गई है, तो URL को क्वेरी स्ट्रिंग में `image` पैरामीटर के रूप में पास कर सकते हैं।

#### पाथ पैरामीटर

| नाम         | प्रकार   | विवरण                                                                                                     |
| ----------- | -------- | --------------------------------------------------------------------------------------------------------- |
| datasetSlug | स्ट्रिंग | डेटासेट के नाम का URL-सुरक्षित संस्करण। मुख्य प्रोजेक्ट दृश्य पर URL देखकर आप इसे वेब UI में पा सकते हैं। |
|             | स्ट्रिंग | आपके डेटासेट के संस्करण की पहचान करने वाली संस्करण संख्या।                                                |

#### क्वेरी पैरामीटर

| नाम      | प्रकार   | विवरण                                                             |
| -------- | -------- | ----------------------------------------------------------------- |
| api\_key | स्ट्रिंग | आपकी API कुंजी (आपके वर्कस्पेस की API सेटिंग वाले पेज से प्राप्त) |

{% tabs %}
{% tab title="200: ठीक है " %}

```json
{
   "predictions":{
      "bird":{
         "confidence":0.5282308459281921
      },
      "cat":{
         "confidence":0.5069406032562256
      },
      "dog":{
         "confidence":0.49514248967170715
      }
   },
   "predicted_classes":[
      "bird",
      "cat"
   ]
}
```

{% endtab %}

{% tab title="403: निषिद्ध " %}

```json
{
   "message":"Forbidden"
}j
```

{% endtab %}
{% endtabs %}
