Mulai menggunakan LiteRT.js

Ini adalah panduan LiteRT.js end-to-end yang mencakup proses mengonversi model PyTorch agar berjalan di browser dengan akselerasi WebGPU. Contoh ini menggunakan ResNet18 untuk model visi, dan TensorFlow.js untuk pra-pemrosesan dan pasca-pemrosesan.

Panduan ini akan membahas langkah-langkah berikut:

  1. Konversi model PyTorch Anda ke LiteRT menggunakan AI Edge Torch.
    1. Tambahkan paket LiteRT ke aplikasi web Anda.
  2. Muat model.
  3. Tulis logika pra-pemrosesan dan pasca-pemrosesan.

Mengonversi ke LiteRT

Gunakan notebook PyTorch Converter untuk mengonversi model PyTorch ke format .tflite yang sesuai. Untuk panduan mendalam tentang jenis error yang mungkin Anda alami dan cara memperbaikinya, lihat README AI Edge Torch Converter.

Model Anda harus kompatibel dengan torch.export.export, yang berarti model tersebut harus dapat diekspor dengan TorchDynamo. Oleh karena itu, tidak boleh ada cabang kondisional python yang bergantung pada nilai runtime dalam tensor. Jika Anda melihat error berikut selama torch.export.export, model Anda tidak dapat diekspor dengan torch.export.export. Model Anda juga tidak boleh memiliki dimensi input atau output dinamis pada tensornya. Ini mencakup dimensi batch.

Anda juga dapat memulai dengan model PyTorch yang kompatibel dengan TensorRT atau dapat diekspor ke ONNX:

  • Versi model yang kompatibel dengan TensorRT dapat menjadi titik awal yang baik, karena beberapa jenis konversi TensorRT juga memerlukan model yang dapat diekspor TorchDynamo. Jika Anda menggunakan operasi NVIDIA / CUDA dalam model, Anda harus menggantinya dengan operasi PyTorch standar.

  • Model PyTorch yang dapat diekspor ke ONNX dapat menjadi titik awal yang baik, meskipun beberapa model ONNX menggunakan TorchScript, bukan TorchDynamo untuk diekspor. Dalam hal ini, model mungkin tidak dapat diekspor ke TorchDynamo (meskipun kemungkinan lebih dekat daripada kode model asli).

Untuk mengetahui informasi selengkapnya, lihat Mengonversi model PyTorch ke LiteRT.

Tambahkan paket LiteRT

Instal paket @litertjs/core dari npm:

npm install @litertjs/core

Impor paket dan muat file Wasm-nya:

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

Memuat model

Impor dan inisialisasi LiteRT.js dan utilitas konversi LiteRT-TFJS. Anda juga perlu mengimpor TensorFlow.js untuk meneruskan tensor ke 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();

Muat model LiteRT yang dikonversi:

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

Menulis pipeline model

Tulis logika pra-pemrosesan dan pasca-pemrosesan yang menghubungkan model ke aplikasi Anda. Penggunaan TensorFlow.js untuk pra-pemrosesan dan pasca-pemrosesan direkomendasikan, tetapi jika tidak ditulis dalam TensorFlow.js, Anda dapat memanggil await tensor.data untuk mendapatkan nilai sebagai ArrayBuffer atau await tensor.array untuk mendapatkan array JS terstruktur.

Berikut adalah contoh pipeline end-to-end untuk 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);
}

Menguji dan memecahkan masalah

Lihat bagian berikut tentang cara menguji aplikasi dan menangani error.

Menguji dengan input palsu

Setelah memuat model, sebaiknya uji model dengan input palsu terlebih dahulu. Tindakan ini akan menangkap error runtime sebelum Anda menghabiskan waktu untuk menulis logika pra-pemrosesan dan pasca-pemrosesan untuk pipeline model Anda. Untuk memeriksanya, Anda dapat menggunakan Penguji Model LiteRT.js atau mengujinya secara manual.

Penguji Model LiteRT.js

Penguji Model LiteRT.js menjalankan model Anda di GPU dan CPU menggunakan input acak untuk memverifikasi bahwa model berjalan dengan benar di GPU. Pengujian ini akan memeriksa hal berikut:

  • Apakah jenis data input dan output didukung.
  • Apakah semua operasi tersedia di GPU.
  • Seberapa dekat output GPU cocok dengan output CPU referensi.
  • Performa inferensi GPU.

Untuk menjalankan Penguji Model LiteRT.js, jalankan npm i @litertjs/model-tester, lalu npx model-tester. Tab browser akan terbuka agar Anda dapat menjalankan model.

Pengujian model manual

Jika lebih memilih untuk menguji model secara manual daripada menggunakan penguji model LiteRT.js (@litertjs/model-tester), Anda dapat membuat input palsu dan menjalankan model dengan runWithTfjsTensors.

Untuk membuat input palsu, Anda perlu mengetahui nama dan bentuk tensor input. Elemen ini dapat ditemukan dengan LiteRT.js dengan memanggil model.getInputDetails atau model.getOutputDetails. Cara mudah untuk menemukannya adalah dengan menyetel titik henti sementara setelah model dibuat. Atau, gunakan Penjelajah Model.

Setelah mengetahui bentuk dan nama input serta output, Anda dapat menguji model dengan input palsu. Hal ini memberikan keyakinan bahwa model akan berjalan sebelum Anda menulis bagian pipeline machine learning lainnya. Hal ini akan menguji bahwa semua operasi model didukung. Contoh:

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

Jenis error

Beberapa model LiteRT mungkin tidak didukung oleh LiteRT.js. Error biasanya dikelompokkan ke dalam kategori berikut:

  • Ketidakcocokan Bentuk: Bug yang diketahui hanya memengaruhi GPU.
  • Operasi Tidak Didukung: Runtime tidak mendukung operasi dalam model. Backend WebGPU memiliki cakupan yang lebih terbatas daripada CPU, jadi jika Anda melihat error ini di GPU, Anda dapat menjalankan model di CPU.
  • Jenis Tensor yang Tidak Didukung: LiteRT.js hanya mendukung tensor int32 dan float32 untuk input dan output model.
  • Model Terlalu Besar: LiteRT.js memiliki batasan ukuran model yang dapat dimuatnya.

Operasi Tidak Didukung

Hal ini menunjukkan bahwa backend yang digunakan tidak mendukung salah satu operasi dalam model. Anda harus menulis ulang model PyTorch asli untuk menghindari operasi ini dan mengonversinya kembali, atau Anda dapat menjalankan model di CPU.

Dalam kasus BROADCAST_TO, hal ini dapat diselesaikan dengan membuat dimensi batch yang sama untuk setiap tensor input ke model. Kasus lainnya mungkin lebih rumit.

Jenis Tensor Tidak Didukung

LiteRT.js hanya mendukung tensor int32 dan float32 untuk input dan output model.

Model Terlalu Besar

Hal ini biasanya muncul sebagai panggilan ke Aborted() atau kegagalan alokasi memori pada waktu pemuatan model. LiteRT.js memiliki batasan ukuran model yang dapat dimuat, jadi jika Anda melihat pesan ini, model Anda mungkin terlalu besar. Anda dapat mencoba menguantisasi bobot dengan ai-edge-quantizer, tetapi pertahankan komputasi pada float32 atau float16, dan input serta output model sebagai float32 atau int32.