LiteRT.js के साथ वेब के लिए LiteRT

LiteRT.js, Google का हाई परफ़ॉर्मेंस WebAI रनटाइम है. यह प्रोडक्शन Web ऐप्लिकेशन को टारगेट करता है. यह LiteRT स्टैक का ही एक हिस्सा है. इससे यह पक्का होता है कि मल्टी-फ़्रेमवर्क काम करता है. साथ ही, यह सभी प्लैटफ़ॉर्म पर हमारे कोर रनटाइम को एक साथ लाता है.

LiteRT.js में ये मुख्य सुविधाएं काम करती हैं:

1. ब्राउज़र में LiteRT मॉडल के साथ काम करने की सुविधा: सीपीयू पर सबसे अच्छी परफ़ॉर्मेंस वाले मॉडल चलाएं. इन्हें WebAssembly (Wasm) पर XNNPack की मदद से और WebGPU एपीआई का इस्तेमाल करके जीपीयू पर तेज़ी से चलाया जा सकता है.
2. एक से ज़्यादा फ़्रेमवर्क के साथ काम करता है: अपने पसंदीदा एमएल फ़्रेमवर्क का इस्तेमाल करें: PyTorch, Jax या TensorFlow.
3. मौजूदा पाइपलाइन पर काम करना: TensorFlow.js के टेंसर को इनपुट और आउटपुट के तौर पर इस्तेमाल करके, मौजूदा TensorFlow.js पाइपलाइन के साथ इंटिग्रेट करें.

इंस्टॉल करना

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

npm install @litertjs/core

Wasm फ़ाइलें, node_modules/@litertjs/core/wasm/ में मौजूद होती हैं. आसानी के लिए, पूरे wasm/ फ़ोल्डर को कॉपी करें और उसे दिखाएं. इसके बाद, पैकेज इंपोर्ट करें और 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, Android और iOS के लिए इस्तेमाल किए जाने वाले .tflite फ़ॉर्मैट का इस्तेमाल करता है. साथ ही, यह Kaggle और Huggingface पर मौजूद मॉडल के साथ काम करता है. अगर आपके पास कोई नया PyTorch मॉडल है, तो आपको उसे बदलना होगा.

PyTorch मॉडल को LiteRT में बदलना

PyTorch मॉडल को LiteRT में बदलने के लिए, ai-edge-torch converter का इस्तेमाल करें.

import ai_edge_torch

# Load your torch model. We're using resnet for this example.
resnet18 = torchvision.models.resnet18(torchvision.models.ResNet18_Weights.IMAGENET1K_V1)

sample_inputs = (torch.randn(1, 3, 224, 224),)

# Convert the model to LiteRT.
edge_model = ai_edge_torch.convert(resnet18.eval(), sample_inputs)

# Export the model.
edge_model.export('resnet.tflite')

बदले गए मॉडल को चलाना

मॉडल को .tflite फ़ाइल में बदलने के बाद, इसे ब्राउज़र में चलाया जा सकता है.

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

// Load the model hosted from your server. This makes an http(s) request.
const model = await loadAndCompile('/path/to/model.tflite', {
    accelerator: 'webgpu', // or 'wasm' for XNNPack CPU inference
});
// The model can also be loaded from a Uint8Array if you want to fetch it yourself.

// Create image input data
const image = new Float32Array(224 * 224 * 3).fill(0);
const inputTensor = new Tensor(image, /* shape */ [1, 3, 224, 224]);

// Run the model
const outputs = await model.run(inputTensor);
// You can also use `await model.run([inputTensor]);`
// or `await model.run({'input_tensor_name': inputTensor});`

// Clean up and get outputs
inputTensor.delete();
const output = outputs[0];
const outputData = await output.data();
output.delete();

मौजूदा TensorFlow.js पाइपलाइन में इंटिग्रेट करना

आपको इन वजहों से, TensorFlow.js पाइपलाइन में LiteRT.js को इंटिग्रेट करना चाहिए:

1. WebGPU की सबसे अच्छी परफ़ॉर्मेंस: LiteRT.js WebGPU पर चलने वाले कनवर्ट किए गए मॉडल, ब्राउज़र की परफ़ॉर्मेंस के लिए ऑप्टिमाइज़ किए जाते हैं. साथ ही, ये Chromium पर आधारित ब्राउज़र पर बहुत तेज़ी से काम करते हैं.
2. मॉडल कन्वर्ज़न पाथ को आसान बनाया गया: LiteRT.js कन्वर्ज़न पाथ, PyTorch से सीधे LiteRT पर जाता है. PyTorch से TensorFlow.js में मॉडल को बदलने का तरीका ज़्यादा मुश्किल है. इसके लिए, आपको PyTorch -> ONNX -> TensorFlow -> TensorFlow.js का इस्तेमाल करना होगा.
3. डीबग करने वाले टूल: LiteRT.js कन्वर्ज़न पाथ के साथ डीबग करने वाले टूल मिलते हैं.

LiteRT.js को TensorFlow.js पाइपलाइन में काम करने के लिए डिज़ाइन किया गया है. यह TensorFlow.js की प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग के साथ काम करता है. इसलिए, आपको सिर्फ़ मॉडल को माइग्रेट करना होगा.

यहां दिया गया तरीका अपनाकर, LiteRT.js को TensorFlow.js पाइपलाइन में इंटिग्रेट करें:

1. अपने ओरिजनल TensorFlow, JAX या PyTorch मॉडल को .tflite में बदलें. ज़्यादा जानकारी के लिए, मॉडल कन्वर्ज़न सेक्शन देखें.
2. @litertjs/core और @litertjs/tfjs-interop NPM पैकेज इंस्टॉल करें.
3. TensorFlow.js WebGPU बैकएंड को इंपोर्ट करें और उसका इस्तेमाल करें. LiteRT.js को TensorFlow.js के साथ इंटरऑपरेट करने के लिए, यह ज़रूरी है.
4. TensorFlow.js मॉडल लोड करने की जगह, LiteRT.js मॉडल लोड करने का इस्तेमाल करें.
5. TensorFlow.js model.predict(inputs) या model.execute(inputs) को runWithTfjsTensors(liteRtModel, inputs) से बदलें. runWithTfjsTensors, TensorFlow.js मॉडल के इस्तेमाल किए गए इनपुट टेंसर लेता है और TensorFlow.js टेंसर आउटपुट करता है.
6. जांच करें कि मॉडल पाइपलाइन से, आपकी उम्मीद के मुताबिक नतीजे मिल रहे हैं या नहीं.

runWithTfjsTensors के साथ LiteRT.js का इस्तेमाल करने के लिए, मॉडल इनपुट में ये बदलाव भी करने पड़ सकते हैं:

1. इनपुट का क्रम बदलना: मॉडल के इनपुट और आउटपुट को कन्वर्टर ने किस क्रम में रखा है, इसके आधार पर आपको इनपुट का क्रम बदलना पड़ सकता है.
2. इनपुट ट्रांसपोज़ करना: ऐसा भी हो सकता है कि कन्वर्टर ने मॉडल के इनपुट और आउटपुट के लेआउट को TensorFlow.js के इस्तेमाल किए गए लेआउट की तुलना में बदल दिया हो. आपको मॉडल से मैच करने के लिए, अपने इनपुट को ट्रांसपोज़ करना पड़ सकता है. साथ ही, पाइपलाइन के बाकी हिस्सों से मैच करने के लिए, आउटपुट को ट्रांसपोज़ करना पड़ सकता है.
3. इनपुट के नाम बदलें: अगर नाम वाले इनपुट का इस्तेमाल किया जा रहा है, तो हो सकता है कि उनके नाम भी बदल गए हों.

model.getInputDetails() और model.getOutputDetails() की मदद से, मॉडल के इनपुट और आउटपुट के बारे में ज़्यादा जानकारी पाई जा सकती है.