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

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

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

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

इंस्टॉल करना

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

npm install @litertjs/core

Wasm फ़ाइलें, node_modules/@litertjs/core/wasm/ में मौजूद होती हैं. आसानी के लिए, पूरे wasm/ फ़ोल्डर को कॉपी करें और दिखाएं. इसके बाद, पैकेज इंपोर्ट करें और Wasm फ़ाइलें लोड करें:

import {loadLiteRt} from '@litertjs/core;

// Host LiteRT's Wasm files on your server.
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 =
    await new Tensor(image, /* shape */ [1, 3, 224, 224]).moveTo('webgpu');

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

// Clean up and get outputs
inputTensor.delete();
const outputTensorCpu = await outputs[0].moveTo('wasm');
const outputData = outputTensorCpu.toTypedArray();
outputTensorCpu.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() की मदद से, मॉडल के इनपुट और आउटपुट के बारे में ज़्यादा जानकारी पाई जा सकती है.