LiteRT לאתרים עם LiteRT.js

‫LiteRT.js הוא זמן הריצה של WebAI של Google, עם ביצועים גבוהים, שמיועד לאפליקציות אינטרנט לייצור. היא מהווה המשך של מחסנית LiteRT, ומבטיחה תמיכה במסגרות מרובות ואיחוד של זמן הריצה הבסיסי שלנו בכל הפלטפורמות.

‫LiteRT.js תומך בתכונות הליבה הבאות:

1. הסקת מסקנות בדפדפן עם האצת חומרה: הפעלת מודלים עם ביצועים יוצאי דופן של המעבד, שמואצים על ידי XNNPack שמופה ל-WebAssembly ‏ (Wasm) קל משקל. לצורך שינוי קנה מידה של GPU ושל חומרה ייעודית (כמו NPU),‏ LiteRT.js מציג באופן מובנה את ממשק WebGPU API ואת ממשק WebNN API המתפתח, ומאפשר אופטימיזציה ספציפית לפלטפורמה ברמת דיוק גבוהה.
2. תאימות למספר frameworks: אפשר לייעל את סמנטיקת הפיתוח על ידי קומפילציה מ-framework ML המועדף באופן מקורי: PyTorch, ‏ JAX או TensorFlow.
3. חזרה על צינורות עיבוד נתונים קיימים: שילוב מוכן לשימוש עם ארכיטקטורות קיימות של TensorFlow.js באמצעות ניתוח של טנסורים של TensorFlow.js שנתמכים באופן מקורי כקלט ופלט ישירים של גבולות.

התקנה

מתקינים את חבילת @litertjs/core מ-npm:

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 משתמש באותו פורמט .tflite כמו שאר המערכת האקולוגית של LiteRT, והוא תומך במודלים קיימים ב-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. ביצועים יוצאי דופן של GPU וחומרה: מודלים של LiteRT.js משתמשים בהאצת WebGPU כדי לשפר את הביצועים בארכיטקטורות שונות של דפדפנים. הספרייה LiteRT.js תומכת ב-WebGPU וב-WebNN (שיושק בקרוב), ומציעה האצת חומרה גמישה במגוון מכשירי קצה.
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. מתקינים את חבילות ה-NPM‏ @litertjs/core ו-@litertjs/tfjs-interop.
3. מייבאים ומשתמשים בקצה העורפי (backend) של 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. בודקים שצינור המודל מוציא את התוצאות שאתם מצפים להן.

יכול להיות שיהיה צורך לבצע גם את השינויים הבאים בקלט של המודל כדי להשתמש ב-LiteRT.js עם runWithTfjsTensors:

1. שינוי הסדר של נתוני הקלט: יכול להיות שתצטרכו לשנות את הסדר של נתוני הקלט כשמעבירים אותם, בהתאם לסדר שבו הכלי להמרת המודל הזין את נתוני הקלט והפלט של המודל.
2. החלפת מיקום של קלט: יכול להיות גם שהממיר שינה את הפריסה של הקלט והפלט של המודל בהשוואה למה שמשמש את TensorFlow.js. יכול להיות שתצטרכו להפוך את הקלט כדי להתאים למודל, ואת הפלט כדי להתאים לשאר צינור העיבוד.
3. שינוי השם של קלט: אם אתם משתמשים בקלט עם שם, יכול להיות שהשמות השתנו גם כן.

אפשר לקבל מידע נוסף על הקלט והפלט של המודל באמצעות model.getInputDetails() ו-model.getOutputDetails().