LiteRT për ueb me LiteRT.js

LiteRT.js është koha e ekzekutimit WebAI me performancë të lartë e Google, që synon aplikacionet web të prodhimit. Është një vazhdim i paketës LiteRT, duke siguruar mbështetje për shumë korniza dhe duke unifikuar kohën tonë të ekzekutimit bazë në të gjitha platformat.

LiteRT.js mbështet karakteristikat kryesore të mëposhtme:

  1. Mbështetje brenda shfletuesit për modelet LiteRT : Ekzekutoni modele me performancën më të mirë në klasën e tyre në CPU, të përshpejtuara nga XNNPack në WebAssembly (Wasm) dhe GPU duke përdorur API-n WebGPU .
  2. Pajtueshmëria me shumë korniza : Përdorni Kornizën tuaj të preferuar ML: PyTorch, Jax ose TensorFlow.
  3. Ndërtoni mbi tubacionet ekzistuese : Integroni me tubacionet ekzistuese të TensorFlow.js duke mbështetur tenzorët e TensorFlow.js si hyrje dhe dalje.

Instalimi

Instaloni paketën @litertjs/core nga npm:

npm install @litertjs/core

Skedarët Wasm ndodhen në node_modules/@litertjs/core/wasm/ . Për lehtësi, kopjoni dhe shfaqni të gjithë dosjen wasm/ . Pastaj, importoni paketën dhe ngarkoni skedarët 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/`);

Konvertimi i modelit

LiteRT.js përdor të njëjtin format .tflite si Android dhe iOS, dhe mbështet modelet ekzistuese në Kaggle dhe Huggingface . Nëse keni një model të ri PyTorch, do t'ju duhet ta konvertoni atë.

Konvertoni një model PyTorch në LiteRT

Për të konvertuar një model PyTorch në LiteRT, përdorni konvertuesin ai-edge-torch .

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')

Ekzekutoni modelin e konvertuar

Pasi ta keni konvertuar modelin në një skedar .tflite , mund ta ekzekutoni atë në shfletues.

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();

Integro në kanalet ekzistuese të TensorFlow.js

Duhet të merrni në konsideratë integrimin e LiteRT.js në kanalet tuaja TensorFlow.js për arsyet e mëposhtme:

  1. Performanca më e mirë në klasën e WebGPU-së : Modelet e konvertuara që funksionojnë në LiteRT.js WebGPU janë të optimizuara për performancën e shfletuesit dhe janë veçanërisht të shpejta në shfletuesit e bazuar në Chromium.
  2. Shteg më i lehtë i konvertimit të modelit : Shtegu i konvertimit LiteRT.js shkon direkt nga PyTorch në LiteRT. Shtegu i konvertimit nga PyTorch në TensorFlow.js është dukshëm më i ndërlikuar, duke kërkuar që ju të shkoni nga PyTorch -> ONNX -> TensorFlow -> TensorFlow.js.
  3. Mjete për korrigjimin e gabimeve : Shtegu i konvertimit LiteRT.js vjen me mjete për korrigjimin e gabimeve .

LiteRT.js është projektuar për të funksionuar brenda tubacioneve TensorFlow.js dhe është i pajtueshëm me përpunimin paraprak dhe pas përpunimit të TensorFlow.js, kështu që e vetmja gjë që ju nevojitet për të migruar është vetë modeli.

Integroni LiteRT.js në tubacionet TensorFlow.js me hapat e mëposhtëm:

  1. Konvertoni modelin tuaj origjinal TensorFlow, JAX ose PyTorch në .tflite . Për detaje, shihni seksionin e konvertimit të modelit .
  2. Instaloni paketat @litertjs/core dhe @litertjs/tfjs-interop NPM.
  3. Importoni dhe përdorni backend-in WebGPU të TensorFlow.js . Kjo është e nevojshme që LiteRT.js të ndërveprojë me TensorFlow.js.
  4. Zëvendësoni ngarkimin e modelit TensorFlow.js me ngarkimin e modelit LiteRT.js .
  5. Zëvendësoni model.predict (inputs) ose model.execute (inputs) të TensorFlow.js me runWithTfjsTensors (liteRtModel, inputs). runWithTfjsTensors merr të njëjtët tensorë hyrës që përdorin modelet TensorFlow.js dhe nxjerr në pah tensorët TensorFlow.js.
  6. Testoni që tubacioni i modelit të japë rezultatet që prisni.

Përdorimi i LiteRT.js me runWithTfjsTensors mund të kërkojë gjithashtu ndryshimet e mëposhtme në të dhënat hyrëse të modelit:

  1. Rirenditja e hyrjeve : Në varësi të mënyrës se si konvertuesi i ka renditur hyrjet dhe daljet e modelit, mund t'ju duhet të ndryshoni rendin e tyre ndërsa i kaloni ato.
  2. Transpozimi i të dhënave hyrëse : Është gjithashtu e mundur që konvertuesi të ketë ndryshuar paraqitjen e të dhënave hyrëse dhe dalëse të modelit krahasuar me atë që përdor TensorFlow.js. Mund t'ju duhet të transpozoni të dhënat hyrëse që të përputhen me modelin dhe të dhënat dalëse që të përputhen me pjesën tjetër të tubacionit.
  3. Riemërto hyrjet : Nëse po përdorni hyrje të emërtuara, edhe emrat mund të kenë ndryshuar.

Mund të merrni më shumë informacion në lidhje me të dhënat hyrëse dhe dalëse të modelit me model.getInputDetails() dhe model.getOutputDetails() .