LiteRT w przypadku internetu z użyciem LiteRT.js

LiteRT.js to wydajne środowisko wykonawcze WebAI Google przeznaczone dla aplikacji internetowych w środowisku produkcyjnym. 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. Wnioskowanie z akceleracją sprzętową w przeglądarce: uruchamiaj modele z wyjątkową wydajnością procesora, przyspieszoną przez XNNPack, który jest mapowany na lekki WebAssembly (Wasm). W przypadku skalowania GPU i dedykowanego sprzętu (np. NPU), LiteRT.js natywnie udostępnia zarówno WebGPU jak i nowy WebNN co umożliwia precyzyjną optymalizację pod kątem konkretnej platformy.
2. Zgodność z wieloma platformami: uprość semantykę programowania, kompilując z preferowanej platformy ML natywnie: PyTorch, JAX lub TensorFlow.
3. Iteracja w istniejących potokach: gotowa integracja z istniejącymi architekturami TensorFlow.js przez analizowanie natywnie obsługiwanych tensorów TensorFlow.js jako bezpośrednich danych wejściowych i wyjściowych.

Instalacja

Zainstaluj pakiet @litertjs/core z npm:

npm install @litertjs/core

Pliki Wasm znajdują się w 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 reszta ekosystemu LiteRT, i obsługuje istniejące modele w 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 litert-torch.

import litert_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 = litert_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 go uruchomić 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',
    // Can select from 'webnn', 'webgpu', & 'wasm'.
    // Additionally, you can pass an array of accelerators e.g. ['webnn', 'wasm']
    // if you would like to fallback to CPU execution,
    // Note that ONLY cpu fallback is supported for now
    // (i.e. specifying ['webnn', 'webgpu']) will lead to compilation errors
});
// 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

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

1. Wyjątkowa wydajność GPU i sprzętu: modele LiteRT.js wykorzystują akcelerację WebGPU, co zapewnia optymalną wydajność w architekturach przeglądarek. Dzięki obsłudze WebGPU i nadchodzącego WebNN LiteRT.js oferuje elastyczną akcelerację sprzętową na różnych urządzeniach brzegowych.
2. Łatwiejsza ścieżka konwersji modelu: ścieżka konwersji LiteRT.js prowadzi bezpośrednio z PyTorch do LiteRT. Ścieżka konwersji z PyTorch do TensorFlow.js jest znacznie bardziej skomplikowana, ponieważ 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 jest 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. Szczegółowe informacje 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 mógł 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) przez 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. Transponuj dane wejściowe: możliwe jest też, że konwerter zmienił układ danych wejściowych i wyjściowych modelu w porównaniu z tym, co używa TensorFlow.js. Może być konieczne transponowanie danych wejściowych, aby pasowały do modelu, a danych wyjściowych, aby pasowały do reszty 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 model.getInputDetails() i model.getOutputDetails().