# Classification

{% tabs %}
{% tab title="Python" %}

#### स्थानीय और होस्ट की गई छवियों पर अनुमान लगाना

निर्भरता स्थापित करने के लिए, `pip install inference-sdk`.

```python
from inference_sdk import InferenceHTTPClient

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

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

{% endtab %}

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

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

**स्थानीय छवि पर इनफर करना**

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

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

axios({
    method: "POST",
    url: "https://classify.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_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);
});
```

{% 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, मॉडल, और मॉडल संस्करण के साथ इनफरेंस सर्वर अनुरोध प्रारम्भ करें
var request = URLRequest(url: URL(string: "https://classify.roboflow.com/your-model/your-model-version?api_key=YOUR_APIKEY&name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
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="Single-Label Classification" %}

#### Single-Label Classification

होस्ट किया गया API inference मार्ग एक लौटाता है `JSON` एक ऑब्जेक्ट जिसमें predictions की एक array होती है। प्रत्येक prediction के निम्नलिखित गुण होते हैं:

* `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="Multi-Label Classification" %}

#### Multi-Label Classification

होस्ट किया गया API inference मार्ग एक लौटाता है `JSON` एक ऑब्जेक्ट जिसमें predictions की एक array होती है। प्रत्येक prediction के निम्नलिखित गुण होते हैं:

* `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 %}

## inferencejs के साथ एज inference

## Inference API का उपयोग करना

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

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

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

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

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

| Name     | प्रकार | Description                                                 |
| -------- | ------ | ----------------------------------------------------------- |
| api\_key | string | आपकी API key (आपके Workspace API settings पृष्ठ से प्राप्त) |

{% tabs %}
{% tab title="200: OK " %}

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

{% endtab %}

{% tab title="403: Forbidden " %}

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

{% endtab %}
{% endtabs %}