> 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="पायथन" %}
**स्थानीय और होस्ट की गई छवियों पर अनुमान लगाना**

निर्भरताएँ इंस्टॉल करने के लिए, `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="जावास्क्रिप्ट" %}
**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("स्थिति " + response.status + " के साथ अनुरोध विफल हुआ");
        return response.json();
    })
    .then((data) => {
        console.log(data);
    })
    .catch((error) => {
        console.log(error.message);
    });
```

{% endtab %}

{% tab title="स्विफ्ट" %}
**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

// पोस्ट अनुरोध निष्पादित करें
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` अनुमानों की एक array वाला ऑब्जेक्ट लौटाता है। प्रत्येक अनुमान के निम्नलिखित गुण होते हैं:

* `समय` = छवि को संसाधित करने और पूर्वानुमान लौटाने में लगने वाला कुल समय, सेकंड में
* `image` = एक ऑब्जेक्ट जो छवि की जानकारी रखता है `width` और `height`
  * `width` पूर्वानुमानित छवि की ऊँचाई
  * `height` = पूर्वानुमानित छवि की ऊँचाई
* `पूर्वानुमान` = पूर्वानुमान के लिए सभी पूर्वानुमानित वर्गों और उनसे संबद्ध विश्वास मानों का संग्रह
  * `class` = वर्गीकरण का लेबल
  * `विश्वास` = इस बात पर मॉडल का विश्वास कि छवि में पहचाने गए वर्ग के ऑब्जेक्ट मौजूद हैं
* `शीर्ष` = सबसे अधिक विश्वास वाला पूर्वानुमानित वर्ग
* `विश्वास` = सबसे अधिक पूर्वानुमानित विश्वास स्कोर
* `छवि_पथ` = पूर्वानुमानित छवि का पथ
* `पूर्वानुमान_प्रकार` = अनुमान लगाने के लिए उपयोग किया गया मॉडल प्रकार, `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` अनुमानों की एक array वाला ऑब्जेक्ट लौटाता है। प्रत्येक अनुमान के निम्नलिखित गुण होते हैं:

* `समय` = छवि को संसाधित करने और पूर्वानुमान लौटाने में लगने वाला कुल समय, सेकंड में
* `image` = एक ऑब्जेक्ट जो छवि की जानकारी रखता है `width` और `height`
  * `width` पूर्वानुमानित छवि की ऊँचाई
  * `height` = पूर्वानुमानित छवि की ऊँचाई
* `पूर्वानुमान` = पूर्वानुमान के लिए सभी पूर्वानुमानित वर्गों और उनसे संबद्ध विश्वास मानों का संग्रह
  * `class` = वर्गीकरण का लेबल
  * `विश्वास` = इस बात पर मॉडल का विश्वास कि छवि में पहचाने गए वर्ग के ऑब्जेक्ट मौजूद हैं
* `पूर्वानुमानित_वर्ग` = एक ऐसा ऐरे जो मॉडल पूर्वानुमानों में लौटाए गए सभी वर्गीकरणों (लेबल/वर्गों) की सूची रखता है
* `छवि_पथ` = पूर्वानुमानित छवि का पथ
* `पूर्वानुमान_प्रकार` = अनुमान लगाने के लिए उपयोग किया गया मॉडल प्रकार, `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 कर सकते हैं। या यदि आपकी छवि पहले से कहीं और होस्ट की गई है, तो आप क्वेरी स्ट्रिंग में `image` पैरामीटर के रूप में एक URL पास कर सकते हैं।

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

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

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

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

{% 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":"निषिद्ध"
}j
```

{% endtab %}
{% endtabs %}