LiteRT w przypadku internetu z użyciem LiteRT.js

LiteRT.js to środowisko wykonawcze WebAI o wysokiej wydajności od Google, przeznaczone do produkcyjnych aplikacji internetowych. Jest to kontynuacja stosu LiteRT, która zapewnia obsługę wielu platform i ujednolica nasze podstawowe środowisko wykonawcze na wszystkich platformach.

LiteRT.js obsługuje te podstawowe funkcje:

  1. Obsługa modeli LiteRT w przeglądarce: uruchamiaj modele o najlepszej w swojej klasie wydajności na procesorze, przyspieszane przez XNNPack na WebAssembly (Wasm) i GPU za pomocą interfejsu WebGPU.
  2. Zgodność z wieloma platformami: używaj preferowanej platformy ML: PyTorch, Jax lub TensorFlow.
  3. Korzystanie z dotychczasowych potoków: integracja z dotychczasowymi potokami TensorFlow.js dzięki obsłudze tensorów TensorFlow.js jako danych wejściowych i wyjściowych.

Instalacja

Zainstaluj pakiet @litertjs/core z npm:

npm install @litertjs/core

Pliki Wasm znajdują się w katalogu node_modules/@litertjs/core/wasm/. Dla wygody skopiuj i udostępnij cały folder wasm/. Następnie zaimportuj pakiet i wczytaj pliki 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/`);

Konwersja modelu

LiteRT.js używa tego samego formatu .tflite co Android i iOS, a także obsługuje istniejące modele na platformach Kaggle i Huggingface. Jeśli masz nowy model PyTorch, musisz go przekonwertować.

Konwertowanie modelu PyTorch na LiteRT

Aby przekonwertować model PyTorch na LiteRT, użyj konwertera 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')

Uruchamianie przekonwertowanego modelu

Po przekonwertowaniu modelu na plik .tflite możesz uruchomić go w przeglądarce.

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

Integracja z istniejącymi potokami TensorFlow.js

Warto zintegrować LiteRT.js z potokami TensorFlow.js z tych powodów:

  1. Najlepsza w swojej klasie wydajność WebGPU: przekonwertowane modele działające w LiteRT.js WebGPU są zoptymalizowane pod kątem wydajności przeglądarki i działają szczególnie szybko w przeglądarkach opartych na Chromium.
  2. Łatwiejsza ścieżka konwersji modelu: ścieżka konwersji LiteRT.js prowadzi bezpośrednio z PyTorch do LiteRT. Ścieżka konwersji z PyTorch na TensorFlow.js jest znacznie bardziej skomplikowana i wymaga przejścia z PyTorch -> ONNX -> TensorFlow -> TensorFlow.js.
  3. Narzędzia do debugowania: ścieżka konwersji LiteRT.js zawiera narzędzia do debugowania.

LiteRT.js został zaprojektowany do działania w potokach TensorFlow.js i jest zgodny z przetwarzaniem wstępnym i postprocesingiem TensorFlow.js, więc jedyną rzeczą, którą musisz przenieść, jest sam model.

Aby zintegrować LiteRT.js z potokami TensorFlow.js, wykonaj te czynności:

  1. Przekonwertuj oryginalny model TensorFlow, JAX lub PyTorch na .tflite. Więcej informacji znajdziesz w sekcji Konwersja modelu.
  2. Zainstaluj pakiety NPM @litertjs/core i @litertjs/tfjs-interop.
  3. Zaimportuj i użyj backendu TensorFlow.js WebGPU. Jest to wymagane, aby LiteRT.js współpracował z TensorFlow.js.
  4. Zastąp wczytywanie modelu TensorFlow.js wczytywaniem modelu LiteRT.js.
  5. Zastąp TensorFlow.js model.predict(inputs) lub model.execute(inputs) funkcją runWithTfjsTensors(liteRtModel, inputs). runWithTfjsTensors przyjmuje te same tensory wejściowe, których używają modele TensorFlow.js, i zwraca tensory TensorFlow.js.
  6. Sprawdź, czy potok modelu zwraca oczekiwane wyniki.

Używanie LiteRT.js z runWithTfjsTensors może też wymagać wprowadzenia tych zmian w danych wejściowych modelu:

  1. Zmień kolejność danych wejściowych: w zależności od tego, jak konwerter uporządkował dane wejściowe i wyjściowe modelu, może być konieczne zmienienie ich kolejności podczas przekazywania.
  2. Transponowanie danych wejściowych: możliwe jest też, że konwerter zmienił układ danych wejściowych i wyjściowych modelu w porównaniu z tym, jakich używa TensorFlow.js. Może być konieczne transponowanie danych wejściowych, aby były zgodne z modelem, oraz danych wyjściowych, aby były zgodne z pozostałą częścią potoku.
  3. Zmień nazwy danych wejściowych: jeśli używasz nazwanych danych wejściowych, nazwy mogły się też zmienić.

Więcej informacji o danych wejściowych i wyjściowych modelu znajdziesz w sekcjach model.getInputDetails() i model.getOutputDetails().