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';

// Load the LiteRT.js Wasm files from a CDN.
await loadLiteRt('https://cdn.jsdelivr.net/npm/@litertjs/core/wasm/')
// Alternatively, host them from your server.
// They are located in node_modules/@litertjs/core/wasm/
await loadLiteRt(`your/path/to/wasm/`);

मॉडल लोड करना

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

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

// TensorFlow.js imports
import * as tf from '@tensorflow/tfjs';
import '@tensorflow/tfjs-backend-webgpu';
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 TFJS use the same GPU device as LiteRT.js (for tensor conversion)
  const device = await getWebGpuDevice();
  tf.removeBackend('webgpu');
  tf.registerBackend('webgpu', () => new WebGPUBackend(device, device.adapterInfo));
  await tf.setBackend('webgpu');
  // ...
}

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 imageData = 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
  return 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]);
});

// Run the model
const outputs = await runWithTfjsTensors(model, [imageData]);
const probabilities = outputs[0];

// Get the top five classes.
const top5 = tf.topk(probabilities, 5);

const values = await top5.values.data();
const indices = await top5.indices.data();

// Clean up TFJS tensors
tf.dispose(outputs);
tf.dispose(top5);
tf.dispose(imageData);

// 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 मॉडल टेस्टर

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

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

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 = await 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 के तौर पर रखें.