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

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

LiteRT.js में ये मुख्य सुविधाएं उपलब्ध हैं:

1. XNNPack जीपीयू और खास हार्डवेयर स्केलिंग (जैसे, एनपीयू) के लिए, LiteRT.js में WebGPU API और WebNN API, दोनों की सुविधा मिलती है. इससे प्लैटफ़ॉर्म के हिसाब से ऑप्टिमाइज़ेशन किया जा सकता है.
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, LiteRT इकोसिस्टम के बाकी हिस्सों की तरह ही .tflite फ़ॉर्मैट का इस्तेमाल करता है. साथ ही, यह Kaggle और Huggingface पर मौजूद मॉडल के साथ काम करता है. अगर आपके पास कोई नया PyTorch मॉडल है, तो आपको उसे कन्वर्ट करना होगा.

PyTorch मॉडल को LiteRT में कन्वर्ट करना

PyTorch मॉडल को LiteRT में कन्वर्ट करने के लिए, litert-torch कन्वर्टर का इस्तेमाल करें.

import litert_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 = litert_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',
    // Can select from 'webnn', 'webgpu', & 'wasm'.
    // Additionally, you can pass an array of accelerators e.g. ['webnn', 'wasm']
    // if you would like to fallback to CPU execution,
    // Note that ONLY cpu fallback is supported for now
    // (i.e. specifying ['webnn', 'webgpu']) will lead to compilation errors
});
// 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 पाइपलाइन में इंटिग्रेट करना

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

1. जीपीयू और हार्डवेयर की बेहतरीन परफ़ॉर्मेंस: LiteRT.js मॉडल, ब्राउज़र आर्किटेक्चर में ऑप्टिमाइज़ की गई परफ़ॉर्मेंस के लिए, WebGPU ऐक्सेलरेटर का इस्तेमाल करते हैं. WebGPU और आने वाले WebNN के साथ काम करने की सुविधा की मदद से, LiteRT.js अलग-अलग तरह के एज डिवाइसों पर हार्डवेयर ऐक्सेलरेटर की सुविधा देता है.
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 एनपीएम पैकेज इंस्टॉल करें.
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() की मदद से, मॉडल के इनपुट और आउटपुट के बारे में ज़्यादा जानकारी पाई जा सकती है.