Filloni me LiteRT.js

Ky është një udhëzues LiteRT.js nga fundi në fund që mbulon procesin e konvertimit të një modeli PyTorch për të ekzekutuar në shfletues me përshpejtim WebGPU. Ky shembull përdor ResNet18 për modelin e vizionit dhe TensorFlow.js për përpunimin para dhe pas.

Udhëzuesi do të mbulojë hapat e mëposhtëm:

  1. Konvertoni modelin tuaj PyTorch në LiteRT duke përdorur AI Edge Torch .
    1. Shtoni paketën LiteRT në aplikacionin tuaj të internetit.
  2. Ngarkoni modelin.
  3. Shkruani logjikën para dhe pas përpunimit.

Konverto në LiteRT

Përdorni fletoren PyTorch Converter për të kthyer një model PyTorch në formatin e duhur .tflite . Për një udhëzues të thelluar mbi llojet e gabimeve që mund të hasni dhe si t'i rregulloni ato, shihni AI Edge Torch Converter README .

Modeli juaj duhet të jetë i pajtueshëm me torch.export.export , që do të thotë se duhet të jetë i eksportueshëm me TorchDynamo. Prandaj, nuk duhet të ketë asnjë degë të kushtëzuar python që varen nga vlerat e kohës së ekzekutimit brenda tensorëve. Nëse shihni gabimet e mëposhtme gjatë torch.export.export , modeli juaj nuk mund të eksportohet me torch.export.export . Modeli juaj gjithashtu nuk duhet të ketë ndonjë dimension dinamik të hyrjes ose daljes në tensorët e tij. Kjo përfshin dimensionin e grupit.

Ju gjithashtu mund të filloni me një model PyTorch të përputhshëm me TensorRT ose të eksportueshëm me ONNX:

  • Një version i një modeli i pajtueshëm me TensorRT mund të jetë një pikënisje e mirë, pasi disa lloje të konvertimeve TensorRT kërkojnë gjithashtu që modelet të jenë të eksportueshme në TorchDynamo . Nëse përdorni ndonjë funksion NVIDIA / CUDA në model, do t'ju duhet t'i zëvendësoni ato me funksione standarde PyTorch.

  • Një model PyTorch i eksportueshëm nga ONNX mund të jetë një pikënisje e mirë, megjithëse disa modele ONNX përdorin TorchScript në vend të TorchDynamo për të eksportuar, në të cilin rast modeli mund të mos jetë i eksportueshëm nga TorchDynamo (megjithëse ka të ngjarë më afër se kodi i modelit origjinal).

Për më shumë informacion, shihni Konvertimi i modeleve PyTorch në LiteRT .

Shto paketën LiteRT

Instaloni paketën @litertjs/core nga npm:

npm install @litertjs/core

Importoni paketën dhe ngarkoni skedarët e saj Wasm:

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

// They are located in node_modules/@litertjs/core/wasm/
// Serve them statically on your server.
await loadLiteRt(`your/path/to/wasm/`);

Ngarkoni modelin

Importoni dhe inicializoni LiteRT.js dhe shërbimet e konvertimit LiteRT-TFJS. Ju gjithashtu duhet të importoni TensorFlow.js për të kaluar tensorët në LiteRT.js.

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

// TensorFlow.js imports
import * as tf from '@tensorflow/tfjs';
import '@tensorflow/tfjs-backend-webgpu'; // Only WebGPU is supported
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 LiteRt use the same GPU device as TFJS (for tensor conversion)
  const backend = tf.backend() as WebGPUBackend;
  setWebGpuDevice(backend.device);
  // ...
}

main();

Ngarko modelin e konvertuar LiteRT:

const model = await loadAndCompile('path_to_model.tflite', {
  accelerator: 'webgpu', // or 'wasm'
});

Shkruani tubacionin e modelit

Shkruani logjikën para dhe pas përpunimit që lidh modelin me aplikacionin tuaj. Rekomandohet përdorimi i TensorFlow.js për përpunim para dhe pas, por nëse nuk është i shkruar në TensorFlow.js, mund të telefononi await tensor.data për të marrë vlerën si një ArrayBuffer ose await tensor.array për të marrë një grup të strukturuar JS.

Më poshtë është një shembull i tubacionit nga fundi në fund për ResNet18:

// Wrap in a tf.tidy call to automatically clean up intermediate TensorFlow.js tensors.
// (Note: tidy only supports synchronous functions).
const top5 = 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
  const imageData = 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]);

  // You can pass inputs as a single tensor, an array, or a JS Object
  // where keys are the tensor names in the TFLite model.
  // When passing an Object, the output is also an Object.
  // Here, we're passing a single tensor, so the output is an array.
  const probabilities = runWithTfjsTensors(model, imageData)[0];

  // Get the top five classes.
  return tf.topk(probabilities, 5);
});

const values = await top5.values.data();
const indices = await top5.indices.data();
top5.values.dispose(); // Clean up the tfjs tensors.
top5.indices.dispose();

// 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);
}

Testimi dhe zgjidhja e problemeve

Referojuni seksioneve të mëposhtme mbi mënyrat për të testuar aplikacionin tuaj dhe për të trajtuar gabimet.

Testimi me inpute false

Pas ngarkimit të një modeli, është mirë që së pari të testoni modelin me hyrje të rreme. Kjo do të kapë çdo gabim në kohën e ekzekutimit përpara se të kaloni kohën duke shkruar logjikën e përpunimit para dhe pas përpunimit për tubacionin tuaj të modelit. Për ta kontrolluar këtë, mund të përdorni testuesin e modelit LiteRT.js ose ta provoni manualisht.

Testuesi i modelit LiteRT.js

Testuesi i modelit LiteRT.js ekzekuton modelin tuaj në GPU dhe CPU duke përdorur hyrje të rastësishme për të verifikuar që modeli funksionon saktë në GPU. Ai kontrollon sa vijon:

  • Nëse mbështeten llojet e të dhënave hyrëse dhe dalëse.
  • Nëse të gjitha funksionet janë të disponueshme në GPU.
  • Sa afër përputhen daljet e GPU-së me daljet e referencës së CPU-së.
  • Performanca e konkluzionit të GPU.

Për të ekzekutuar testuesin e modelit LiteRT.js, ekzekutoni npm i @litertjs/model-tester dhe më pas npx model-tester . Do të hapë një skedë shfletuesi për ju që të ekzekutoni modelin tuaj.

Testimi manual i modelit

Nëse preferoni të testoni manualisht modelin në vend që të përdorni testuesin e modelit LiteRT.js ( @litertjs/model-tester ), mund të gjeneroni hyrje të rreme dhe ta ekzekutoni modelin me runWithTfjsTensors .

Për të gjeneruar inpute të rreme, duhet të dini emrat dhe format e tensorëve të hyrjes. Këto mund të gjenden me LiteRT.js duke telefonuar model.getInputDetails ose model.getOutputDetails . Një mënyrë e thjeshtë për t'i gjetur ato është të vendosni një pikë ndërprerjeje pasi të krijohet modeli. Përndryshe, përdorni Model Explorer .

Pasi të njihni format dhe emrat e hyrjes dhe daljes, mund ta provoni modelin me një hyrje të rreme. Kjo jep njëfarë besimi se modeli do të funksionojë përpara se të shkruani pjesën tjetër të tubacionit të mësimit të makinerisë. Kjo do të testonte nëse të gjitha operacionet e modelit mbështeten. Për shembull:

// 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 = runWithTfjsTensors(model, fakeInputs);
console.log(outputs);

Llojet e gabimeve

Disa modele LiteRT mund të mos mbështeten nga LiteRT.js. Gabimet zakonisht ndahen në këto kategori:

  • Mospërputhja e formës : Një gabim i njohur që prek vetëm GPU-në.
  • Operacioni nuk mbështetet : Koha e ekzekutimit nuk mbështet një operacion në model. Backend-i WebGPU ka mbulim më të kufizuar se CPU, kështu që nëse po e shihni këtë gabim në GPU, mund të jeni në gjendje ta ekzekutoni modelin në CPU.
  • Lloji i tensorit të pambështetur : LiteRT.js mbështet vetëm tensorët int32 dhe float32 për hyrjet dhe daljet e modelit.
  • Modeli shumë i madh : LiteRT.js është i kufizuar në madhësinë e modeleve që mund të ngarkojë.

Operacioni nuk mbështetet

Kjo tregon që mbështetja që përdoret nuk mbështet një nga operacionet në model. Ju do të duhet të rishkruani modelin origjinal PyTorch për të shmangur këtë funksion dhe për ta ri-konvertuar atë, ose mund të jeni në gjendje ta ekzekutoni modelin në CPU.

Në rastin e BROADCAST_TO , kjo mund të zgjidhet duke e bërë dimensionin e grupit të njëjtë për çdo tensor hyrës në model. Rastet e tjera mund të jenë më të ndërlikuara.

Lloji i tensorit i pambështetur

LiteRT.js mbështet vetëm tensorët int32 dhe float32 për hyrjet dhe daljet e modelit.

Modeli shumë i madh

Kjo zakonisht shfaqet si një thirrje për Aborted() ose një dështim i alokimit të memories në kohën e ngarkimit të modelit. LiteRT.js është i kufizuar në madhësinë e modeleve që mund të ngarkojë, kështu që nëse po e shihni këtë, modeli juaj mund të jetë shumë i madh. Mund të provoni të kuantizoni peshat me kuantizuesin ai-edge , por mbani llogaritjet në float32 ose float16 dhe modeloni hyrjet dhe daljet si float32 ose int32.