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 frameworków i ujednolica 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 za pomocą XNNPack w WebAssembly (Wasm) i na procesorze graficznym za pomocą interfejsu WebGPU API.
  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/. Aby ułatwić sobie pracę, skopiuj i wyświetl cały folder wasm/. Następnie zaimportuj pakiet i wczytaj pliki Wasm:

import {loadLiteRt} from '@litertjs/core;

// Host LiteRT's Wasm files on your server.
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 =
    await new Tensor(image, /* shape */ [1, 3, 224, 224]).moveTo('webgpu');

// Run the model
const outputs = model(inputTensor);
// You can also use model([inputTensor])
// or model({'input_tensor_name': inputTensor})

// Clean up and get outputs
inputTensor.delete();
const outputTensorCpu = await outputs[0].moveTo('wasm');
const outputData = outputTensorCpu.toTypedArray();
outputTensorCpu.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 końcowym 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 biblioteka LiteRT.js mogła 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().