> 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/self-hosted/sdks/web-browser/inferencejs-reference.md).

# inferencejs संदर्भ

\`inferencejs\` के लिए संदर्भ, Roboflow के साथ बनाए गए computer vision applications को web/JavaScript environments में डिप्लॉय करने के लिए एक edge library

{% hint style="info" %}
इसके बारे में और जानें `inferencejs` , हमारा वेब SDK, [यहाँ](https://docs.roboflow.com/deployment/hi/self-hosted/sdks/web-browser.md)
{% endhint %}

### इंस्टॉलेशन

यह लाइब्रेरी ब्राउज़र में उपयोग के लिए बनाई गई है। इसके लिए vite, webpack, parcel आदि जैसे बंडलर का उपयोग करें। यह मानते हुए कि आपका बंडलर सेट अप है, इसे इंस्टॉल करने के लिए यह कमांड चलाएँ:

`npm install inferencejs`

### शुरू करें

सबसे पहले `InferenceEngine`को इनिशियलाइज़ करें। इससे एक बैकग्राउंड वर्कर शुरू होगा, जो यूज़र इंटरफ़ेस को ब्लॉक किए बिना मॉडल डाउनलोड और\
एक्ज़ीक्यूट कर सकता है।

```typescript
import { InferenceEngine } from "inferencejs";

const PUBLISHABLE_KEY = "rf_a6cd..."; // replace with your own publishable key from Roboflow

const inferEngine = new InferenceEngine();

// Load a model by its model id, copied from the model's page on Roboflow.
const workerId = await inferEngine.startWorkerByModelId("[MODEL ID]", PUBLISHABLE_KEY);

//make inferences against the model
const result = await inferEngine.infer(workerId, img);
```

मॉडल आईडी मॉडल के पेज पर दिखाई देती है और इसका फ़ॉर्मैट यह होता है `workspace/model-slug` (उदाहरण: `my-workspace/hard-hat-abc-1-yolov8n-t1`)। पुराने प्रोजेक्ट-वर्शन वाले मॉडल को प्रोजेक्ट स्लग और वर्शन नंबर का उपयोग करके `startWorker` से लोड किया जा सकता है। कई प्रशिक्षित मॉडल वाले वर्शन के लिए, पुरानी `{project}/{version}` आईडी, वर्शन के एलियास के ज़रिए रिज़ॉल्व होती है—यदि कोई एलियास मौजूद हो। एलियास न होने पर यह तभी काम करती है, जब वर्शन में केवल एक मॉडल हो; अन्यथा आईडी अस्पष्ट होती है और आपको मॉडल को उसकी अपनी मॉडल आईडी से लोड करना चाहिए। देखें: [पुरानी आईडी कैसे रिज़ॉल्व होती हैं](https://docs.roboflow.com/models/model-ids).

## API

### InferenceEngine

**`new InferenceEngine()`**

एक नया InferenceEngine इंस्टेंस बनाता है।

**`startWorkerByModelId(modelId: string, publishableKey: string): Promise<number>`**

दिए गए मॉडल आईडी के लिए एक नया वर्कर शुरू करता है और `workerId`लौटाता है। मॉडल लोड करने का यह अनुशंसित तरीका है। `modelId` मॉडल के पेज पर दिखाई जाने वाली पूरी `workspace/model-slug` आईडी है, और यह बिना वर्शन वाले तथा कई मॉडल वाले वर्शन—दोनों के लिए काम करती है। `publishableKey` आवश्यक है और इसे Roboflow में अपने प्रोजेक्ट की सेटिंग्स से प्राप्त किया जा सकता है।

**`startWorker(modelName: string, modelVersion: number, publishableKey: string): Promise<number>`**

प्रोजेक्ट URL स्लग और पूर्णांक वर्शन से पहचाने गए पुराने मॉडल को लोड करता है और `workerId`लौटाता है। नए इंटीग्रेशन के लिए `startWorkerByModelId` का उपयोग करें। `publishableKey` आवश्यक है और इसे Roboflow में अपने प्रोजेक्ट की सेटिंग्स से प्राप्त किया जा सकता है।

**`infer(workerId: number, img: CVImage | ImageBitmap): Promise<Inference>`**

दिए गए `workerId`. `img` का उपयोग करके किसी इमेज पर अनुमान लगाएँ। इसे `new CVImage(HTMLImageElement | HTMLVideoElement | ImageBitmap | TFJS.Tensor)` या [`createImageBitmap`](https://developer.mozilla.org/en-US/docs/Web/API/createImageBitmap)

**`stopWorker(workerId: number): Promise<void>`**

दिए गए `workerId`.

### `YOLO Lite` `YOLOv8` `YOLOv5`

किसी YOLO Lite, YOLOv8 या YOLOv5 ऑब्जेक्ट डिटेक्शन मॉडल पर `InferenceEngine` का उपयोग करके अनुमान लगाने पर नीचे दिए गए प्रकार का ऐरे मिलता है:

```typescript
type RFObjectDetectionPrediction = {
    class?: string;
    confidence?: number;
    bbox?: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    color?: string;
};
```

### `GazeDetections`

किसी Gaze मॉडल पर `InferenceEngine` का उपयोग करके अनुमान लगाने का परिणाम। नीचे दिए गए प्रकार का ऐरे:

```typescript
type GazeDetections = {
    leftEye: { x: number; y: number };
    rightEye: { x: number; y: number };
    yaw: number;
    pitch: number;
}[];
```

**`leftEye.x`**

बाएँ आँख की x स्थिति, 0 और 1 के बीच फ़्लोटिंग-पॉइंट संख्या के रूप में। इसे इनपुट इमेज की चौड़ाई के प्रतिशत के रूप में मापा जाता है।

**`leftEye.y`**

बाएँ आँख की y स्थिति, 0 और 1 के बीच फ़्लोटिंग-पॉइंट संख्या के रूप में। इसे इनपुट इमेज की ऊँचाई के प्रतिशत के रूप में मापा जाता है।

**`rightEye.x`**

दाएँ आँख की x स्थिति, 0 और 1 के बीच फ़्लोटिंग-पॉइंट संख्या के रूप में। इसे इनपुट इमेज की चौड़ाई के प्रतिशत के रूप में मापा जाता है।

**`rightEye.y`**

दाएँ आँख की y स्थिति, 0 और 1 के बीच फ़्लोटिंग-पॉइंट संख्या के रूप में। इसे इनपुट इमेज की ऊँचाई के प्रतिशत के रूप में मापा जाता है।

**`yaw`**

दृश्य दृष्टि का यॉ, रेडियन में मापा जाता है।

**`pitch`**

दृश्य दृष्टि का पिच, रेडियन में मापा जाता है।

### `CVImage`

कंप्यूटर विज़न के कार्यों में उपयोग की जा सकने वाली इमेज को दर्शाने वाली क्लास। यह इमेज में बदलाव करने और उसे रूपांतरित करने के लिए कई विधियाँ प्रदान करती है।

#### **कंस्ट्रक्टर**

द `CVImage(image)` क्लास कंस्ट्रक्टर क्लास का एक नया इंस्टेंस शुरू करता है। यह नीचे दिए गए प्रकारों में से किसी एक की एक इमेज स्वीकार करता है:

* `ImageBitmap`: इमेज का एक वैकल्पिक `ImageBitmap` प्रतिनिधित्व।
* `HTMLImageElement`: इमेज का एक वैकल्पिक `HTMLImageElement` प्रतिनिधित्व।
* `tf.Tensor`: इमेज का एक वैकल्पिक `tf.Tensor` प्रतिनिधित्व।
* `tf.Tensor4D`: एक वैकल्पिक 4D `tf.Tensor` प्रतिनिधित्व।

#### **विधियाँ**

**`bitmap()`**

एक ऐसा प्रॉमिस लौटाता है जो इमेज के `ImageBitmap` प्रतिनिधित्व में रिज़ॉल्व होता है। यदि इमेज पहले से ही बिटमैप है, तो यह कैश किया हुआ बिटमैप लौटाता है।

**`tensor()`**

इमेज का `tf.Tensor` प्रतिनिधित्व लौटाता है। यदि इमेज पहले से ही टेंसर है, तो यह कैश किया हुआ टेंसर लौटाता है।

**`tensor4D()`**

एक ऐसा प्रॉमिस लौटाता है जो इमेज के 4D `tf.Tensor` प्रतिनिधित्व में रिज़ॉल्व होता है। यदि इमेज पहले से ही 4D टेंसर है, तो यह कैश किया हुआ 4D टेंसर लौटाता है।

**`array()`**

इमेज का JavaScript ऐरे प्रतिनिधित्व लौटाने वाले प्रॉमिस को लौटाता है। यदि इमेज पहले से ही टेंसर है, तो यह टेंसर को ऐरे में बदलता है।

**`dims()`**

इमेज के आयामों वाला ऐरे लौटाता है। यदि इमेज बिटमैप है, तो यह `[width, height]`लौटाता है। यदि इमेज टेंसर है, तो यह टेंसर का आकार लौटाता है। यदि इमेज HTML इमेज एलिमेंट है, तो यह लौटाता है `[width, height]`.

**`dispose()`**

मेमोरी खाली करने के लिए इमेज के टेंसर प्रतिनिधित्वों को डिस्पोज़ करता है।

**`static fromArray(array: tf.TensorLike)`**

दिए गए टेंसर-जैसे ऐरे से एक नया `CVImage` इंस्टेंस बनाता है।
