LiteRT.js का इस्तेमाल शुरू करना

यह LiteRT.js की एंड-टू-एंड गाइड है. इसमें PyTorch मॉडल को WebGPU ऐक्सेलरेटर के साथ ब्राउज़र में चलाने के लिए बदलने की प्रोसेस के बारे में बताया गया है. इस उदाहरण में, विज़न मॉडल के लिए ResNet18 का इस्तेमाल किया गया है. साथ ही, प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग के लिए TensorFlow.js का इस्तेमाल किया गया है.

इस गाइड में, ये चरण शामिल होंगे:

1. AI Edge Torch का इस्तेमाल करके, अपने PyTorch मॉडल को LiteRT में बदलें.
   1. अपने वेब ऐप्लिकेशन में LiteRT पैकेज जोड़ें.
2. मॉडल लोड करें.
3. प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग का लॉजिक लिखें.

LiteRT में बदलना

PyTorch मॉडल को सही .tflite फ़ॉर्मैट में बदलने के लिए, PyTorch Converter नोटबुक का इस्तेमाल करें. आपको किस तरह की गड़बड़ियां मिल सकती हैं और उन्हें ठीक करने के तरीके के बारे में ज़्यादा जानने के लिए, AI Edge Torch Converter README देखें.

आपका मॉडल, torch.export.export के साथ काम करना चाहिए. इसका मतलब है कि इसे TorchDynamo के साथ एक्सपोर्ट किया जा सकता हो. इसलिए, इसमें कोई भी ऐसी Python कंडीशनल ब्रांच नहीं होनी चाहिए जो टेंसर में मौजूद रनटाइम वैल्यू पर निर्भर करती हो. अगर आपको torch.export.export के दौरान ये गड़बड़ियां दिखती हैं, तो इसका मतलब है कि आपका मॉडल torch.export.export के साथ एक्सपोर्ट नहीं किया जा सकता. आपके मॉडल के टेंसर में, डाइनैमिक इनपुट या आउटपुट डाइमेंशन नहीं होने चाहिए. इसमें बैच डाइमेंशन शामिल है.

TensorRT के साथ काम करने वाले या ONNX फ़ॉर्मैट में एक्सपोर्ट किए जा सकने वाले PyTorch मॉडल का इस्तेमाल भी किया जा सकता है:

• मॉडल का TensorRT के साथ काम करने वाला वर्शन, एक अच्छा शुरुआती पॉइंट हो सकता है. ऐसा इसलिए, क्योंकि TensorRT कन्वर्ज़न के कुछ टाइप के लिए, मॉडल को TorchDynamo एक्सपोर्ट करने की सुविधा की ज़रूरत होती है. अगर आपने मॉडल में NVIDIA / CUDA ऑपरेशंस का इस्तेमाल किया है, तो आपको उन्हें स्टैंडर्ड PyTorch ऑपरेशंस से बदलना होगा.

• ONNX फ़ॉर्मैट में एक्सपोर्ट किए जा सकने वाले PyTorch मॉडल का इस्तेमाल किया जा सकता है. हालांकि, कुछ ONNX मॉडल एक्सपोर्ट करने के लिए, TorchDynamo के बजाय TorchScript का इस्तेमाल करते हैं. ऐसे में, हो सकता है कि मॉडल को TorchDynamo फ़ॉर्मैट में एक्सपोर्ट न किया जा सके. हालांकि, यह मूल मॉडल कोड से ज़्यादा सटीक होता है.

ज़्यादा जानकारी के लिए, PyTorch मॉडल को LiteRT में बदलें लेख पढ़ें.

LiteRT पैकेज जोड़ना

npm से @litertjs/core पैकेज इंस्टॉल करें:

npm install @litertjs/core

पैकेज इंपोर्ट करें और उसकी Wasm फ़ाइलें लोड करें:

import {loadLiteRt} from '@litertjs/core';

// They are located in node_modules/@litertjs/core/wasm/
// Serve them statically on your server.
await loadLiteRt(`your/path/to/wasm/`);

मॉडल लोड करना

LiteRT.js और LiteRT-TFJS कन्वर्ज़न यूटिलिटी को इंपोर्ट करें और शुरू करें. आपको LiteRT.js को टेंसर पास करने के लिए, TensorFlow.js को भी इंपोर्ट करना होगा.

import {CompileOptions, loadAndCompile, loadLiteRt, setWebGpuDevice} from '@litertjs/core';
import {runWithTfjsTensors} from '@litertjs/tfjs-interop';

// TensorFlow.js imports
import * as tf from '@tensorflow/tfjs';
import '@tensorflow/tfjs-backend-webgpu'; // Only WebGPU is supported
import {WebGPUBackend} from '@tensorflow/tfjs-backend-webgpu';

async function main() {
  // Initialize TensorFlow.js WebGPU backend
  await tf.setBackend('webgpu');

  // Initialize LiteRT.js's Wasm files
  await loadLiteRt('your/path/to/wasm/');

  // Make LiteRt use the same GPU device as TFJS (for tensor conversion)
  const backend = tf.backend() as WebGPUBackend;
  setWebGpuDevice(backend.device);
  // ...
}

main();

बदले गए LiteRT मॉडल को लोड करें:

const model = await loadAndCompile('path_to_model.tflite', {
  accelerator: 'webgpu', // or 'wasm'
});

मॉडल पाइपलाइन लिखना

प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग का लॉजिक लिखें, जो मॉडल को आपके ऐप्लिकेशन से कनेक्ट करता हो. प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग के लिए TensorFlow.js का इस्तेमाल करने का सुझाव दिया जाता है. हालांकि, अगर इसे TensorFlow.js में नहीं लिखा गया है, तो await tensor.data को कॉल करके, वैल्यू को ArrayBuffer के तौर पर या await tensor.array को कॉल करके, स्ट्रक्चर्ड JS ऐरे के तौर पर पाया जा सकता है.

ResNet18 के लिए, यहां एंड-टू-एंड पाइपलाइन का एक उदाहरण दिया गया है:

// Wrap in a tf.tidy call to automatically clean up intermediate TensorFlow.js tensors.
// (Note: tidy only supports synchronous functions).
const top5 = tf.tidy(() => {
  // Get RGB data values from an image element and convert it to range [0, 1).
  const image = tf.browser.fromPixels(dogs, 3).div(255);

  // These preprocessing steps come from https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py#L315
  // The mean and standard deviation for the image normalization come from https://github.com/pytorch/vision/blob/main/torchvision/transforms/_presets.py#L38
  const imageData = image.resizeBilinear([224, 224])
    .sub([0.485, 0.456, 0.406])
    .div([0.229, 0.224, 0.225])
    .reshape([1, 224, 224, 3])
    .transpose([0, 3, 1, 2]);

  // You can pass inputs as a single tensor, an array, or a JS Object
  // where keys are the tensor names in the TFLite model.
  // When passing an Object, the output is also an Object.
  // Here, we're passing a single tensor, so the output is an array.
  const probabilities = runWithTfjsTensors(model, imageData)[0];

  // Get the top five classes.
  return tf.topk(probabilities, 5);
});

const values = await top5.values.data();
const indices = await top5.indices.data();
top5.values.dispose(); // Clean up the tfjs tensors.
top5.indices.dispose();

// Print the top five classes.
const classes = ... // Class names are loaded from a JSON file in the demo.
for (let i = 0; i < 5; ++i) {
  const text = `${classes[indices[i]]}: ${values[i]}`;
  console.log(text);
}

जांच करना और समस्या हल करना

अपने ऐप्लिकेशन की जांच करने और गड़बड़ियों को ठीक करने के तरीकों के बारे में जानने के लिए, यहां दिए गए सेक्शन देखें.

नकली इनपुट के साथ टेस्टिंग

मॉडल लोड करने के बाद, सबसे पहले फ़र्ज़ी इनपुट के साथ मॉडल की जांच करना अच्छा होता है. इससे आपको मॉडल पाइपलाइन के लिए प्री और पोस्ट प्रोसेसिंग लॉजिक लिखने में समय बर्बाद करने से पहले ही, रनटाइम से जुड़ी गड़बड़ियों का पता चल जाएगा. इसकी जांच करने के लिए, LiteRT.js Model Tester का इस्तेमाल करें या इसे मैन्युअल तरीके से टेस्ट करें.

LiteRT.js Model Tester

LiteRT.js Model Tester, आपके मॉडल को GPU और CPU पर चलाता है. इसके लिए, वह रैंडम इनपुट का इस्तेमाल करता है. इससे यह पुष्टि की जाती है कि मॉडल, GPU पर सही तरीके से काम कर रहा है. यह इन चीज़ों की जांच करता है:

• इनपुट और आउटपुट डेटा टाइप इस्तेमाल किए जा सकते हैं या नहीं.
• क्या सभी ऑप्स, जीपीयू पर उपलब्ध हैं.
• जीपीयू के आउटपुट, सीपीयू के रेफ़रंस आउटपुट से कितने मिलते-जुलते हैं.
• जीपीयू इन्फ़रेंस की परफ़ॉर्मेंस.

LiteRT.js Model Tester को चलाने के लिए, npm i @litertjs/model-tester और फिर npx model-tester चलाएं. इससे आपके ब्राउज़र में एक टैब खुलेगा, ताकि आप अपना मॉडल चला सकें.

मैन्युअल तरीके से मॉडल की टेस्टिंग करना

अगर आपको LiteRT.js मॉडल टेस्टर (@litertjs/model-tester) का इस्तेमाल करने के बजाय, मॉडल को मैन्युअल तरीके से टेस्ट करना है, तो फ़र्ज़ी इनपुट जनरेट किए जा सकते हैं. इसके बाद, runWithTfjsTensors की मदद से मॉडल को चलाया जा सकता है.

फ़र्ज़ी इनपुट जनरेट करने के लिए, आपको इनपुट टेंसर के नाम और आकार पता होने चाहिए. इन्हें LiteRT.js की मदद से ढूंढा जा सकता है. इसके लिए, model.getInputDetails या model.getOutputDetails को कॉल करें. उन्हें ढूंढने का आसान तरीका यह है कि मॉडल बनने के बाद, ब्रेकपॉइंट सेट किया जाए. इसके अलावा, मॉडल एक्सप्लोरर का इस्तेमाल करें.

इनपुट और आउटपुट के शेप और नाम जानने के बाद, मॉडल को फ़र्ज़ी इनपुट के साथ टेस्ट किया जा सकता है. इससे आपको यह भरोसा मिलता है कि मशीन लर्निंग पाइपलाइन का बाकी हिस्सा लिखने से पहले, मॉडल काम करेगा. इससे यह जांच की जाएगी कि सभी मॉडल ऑपरेशन काम कर रहे हैं या नहीं. उदाहरण के लिए:

// Imports, initialization, and model loading...
// Create fake inputs for the model
const fakeInputs = model.getInputDetails().map(
    ({shape, dtype}) => tf.ones(shape, dtype));

// Run the model
const outputs = runWithTfjsTensors(model, fakeInputs);
console.log(outputs);

गड़बड़ी के प्रकार

ऐसा हो सकता है कि कुछ LiteRT मॉडल, LiteRT.js के साथ काम न करें. गड़बड़ियां आम तौर पर इन कैटगरी में आती हैं:

• शेप मैच न होना: यह एक ऐसा बग है जो सिर्फ़ जीपीयू पर असर डालता है.
• ऑपरेशन काम नहीं करता: रनटाइम, मॉडल में किसी ऑपरेशन के साथ काम नहीं करता. WebGPU बैकएंड, सीपीयू की तुलना में कम कवरेज देता है. इसलिए, अगर आपको जीपीयू पर यह गड़बड़ी दिख रही है, तो हो सकता है कि आप मॉडल को सीपीयू पर चला पाएं.
• Tensor टाइप काम नहीं करता: LiteRT.js, मॉडल के इनपुट और आउटपुट के लिए सिर्फ़ int32 और float32 टेंसर इस्तेमाल करता है.
• मॉडल बहुत बड़ा है: LiteRT.js, मॉडल के साइज़ के हिसाब से ही उन्हें लोड कर सकता है.

यह कार्रवाई नहीं की जा सकती

इससे पता चलता है कि इस्तेमाल किया जा रहा बैकएंड, मॉडल में मौजूद किसी एक ऑपरेशन के साथ काम नहीं करता है. इस ऑप से बचने के लिए, आपको ओरिजनल PyTorch मॉडल को फिर से लिखना होगा और उसे फिर से बदलना होगा. इसके अलावा, मॉडल को सीपीयू पर भी चलाया जा सकता है.

BROADCAST_TO के मामले में, इस समस्या को हल करने के लिए, मॉडल के हर इनपुट टेंसर के लिए बैच डाइमेंशन को एक जैसा बनाया जा सकता है. अन्य मामलों में ज़्यादा जटिलताएं हो सकती हैं.

इस तरह के टेंसर का इस्तेमाल नहीं किया जा सकता

LiteRT.js, मॉडल के इनपुट और आउटपुट के लिए सिर्फ़ int32 और float32 टेंसर के साथ काम करता है.

मॉडल बहुत बड़ा है

आम तौर पर, यह Aborted() को कॉल करने या मॉडल लोड होने के समय मेमोरी असाइन करने में गड़बड़ी के तौर पर दिखता है. LiteRT.js, लोड किए जा सकने वाले मॉडल के साइज़ को सीमित करता है. इसलिए, अगर आपको यह मैसेज दिख रहा है, तो हो सकता है कि आपका मॉडल बहुत बड़ा हो. ai-edge-quantizer की मदद से, वेट को क्वांटाइज़ किया जा सकता है. हालांकि, कंप्यूटेशन को float32 या float16 पर रखें. साथ ही, मॉडल के इनपुट और आउटपुट को float32 या int32 के तौर पर रखें.