LiteRT na Androida

LiteRT umożliwia uruchamianie modeli TensorFlow, PyTorch i JAX w aplikacjach na Androida. System LiteRT udostępnia gotowe i konfigurowalne środowiska wykonawcze do szybkiego i wydajnego uruchamiania modeli na Androidzie, w tym opcje akceleracji sprzętowej.

Przykłady aplikacji na Androida korzystających z LiteRT znajdziesz w repozytorium LiteRT samples.

modele uczenia maszynowego,

LiteRT korzysta z modeli TensorFlow, PyTorch i JAX, które są przekształcane w mniejszy, przenośny i wydajniejszy format modelu uczenia maszynowego. Możesz używać gotowych modeli z LiteRT na Androidzie lub tworzyć własne modele i konwertować je do formatu LiteRT.

Na tej stronie omawiamy korzystanie z gotowych modeli uczenia maszynowego. Nie opisujemy tworzenia, trenowania, testowania ani konwertowania modeli. Więcej informacji o wybieraniu, modyfikowaniu, tworzeniu i konwertowaniu modeli uczenia maszynowego na potrzeby LiteRT znajdziesz na stronie Modele.

Uruchamianie modeli na Androidzie

Model LiteRT działający w aplikacji na Androida przyjmuje dane, przetwarza je i generuje prognozę na podstawie logiki modelu. Model LiteRT wymaga specjalnego środowiska wykonawczego, a dane przekazywane do modelu muszą mieć określony format, zwany tensorem. Gdy model przetwarza dane, co nazywamy wnioskowaniem, generuje wyniki prognozowania w postaci nowych tensorów i przekazuje je do aplikacji na Androida, aby mogła ona podjąć działania, np. wyświetlić wynik użytkownikowi lub wykonać dodatkową logikę biznesową.

Rysunek 1. Funkcjonalny przepływ wykonywania modeli LiteRT w aplikacjach na Androida.

Na poziomie projektu funkcjonalnego aplikacja na Androida musi zawierać te elementy, aby uruchomić model LiteRT:

• Środowisko wykonawcze LiteRT do wykonywania modelu.
• Funkcja obsługi danych wejściowych modelu do przekształcania danych w tensory.
• Moduł obsługi danych wyjściowych modelu do odbierania tensorów wyników wyjściowych i interpretowania ich jako wyników prognozy.

W sekcjach poniżej opisujemy, jak biblioteki i narzędzia LiteRT zapewniają te elementy funkcjonalne.

Tworzenie aplikacji za pomocą LiteRT

W tej sekcji opisujemy zalecaną i najczęstszą ścieżkę wdrażania LiteRT w aplikacji na Androida. Największą uwagę należy zwrócić na sekcje środowisko wykonawcze i biblioteki deweloperskie. Jeśli masz opracowany model niestandardowy, zapoznaj się z sekcją Zaawansowane ścieżki rozwoju.

Opcje środowiska wykonawczego

Środowisko wykonawcze do uruchamiania modeli w aplikacji na Androida możesz włączyć na kilka sposobów. Oto preferowane opcje:

• LiteRT w środowisku wykonawczym usług Google Play (zalecane)
• Samodzielne środowisko wykonawcze LiteRT

Ogólnie rzecz biorąc, należy używać środowiska wykonawczego udostępnianego przez usługi Google Play, ponieważ jest ono bardziej wydajne pod względem miejsca niż środowisko standardowe, ponieważ wczytuje się dynamicznie, dzięki czemu rozmiar aplikacji jest mniejszy. Usługi Google Play automatycznie używają też najnowszej stabilnej wersji środowiska wykonawczego LiteRT, co z czasem zapewnia dodatkowe funkcje i lepszą wydajność. Jeśli oferujesz aplikację na urządzeniach, które nie mają Usług Google Play, lub musisz ściśle zarządzać środowiskiem wykonawczym ML, użyj standardowego środowiska wykonawczego LiteRT. Ta opcja dołącza do aplikacji dodatkowy kod, co pozwala uzyskać większą kontrolę nad środowiskiem wykonawczym ML w aplikacji, ale zwiększa rozmiar pobierania aplikacji.

Dostęp do tych środowisk wykonawczych w aplikacji na Androida uzyskasz, dodając do środowiska programistycznego aplikacji biblioteki programistyczne LiteRT. Więcej informacji o tym, jak używać w aplikacji standardowych środowisk wykonawczych, znajdziesz w następnej sekcji.

Biblioteki

Dostęp do interfejsu Interpreter API możesz uzyskać za pomocą usług Google Play. W aplikacji na Androida możesz używać bibliotek LiteRT core i support. Szczegółowe informacje o programowaniu dotyczące korzystania z bibliotek LiteRT i środowisk wykonawczych znajdziesz w artykule Narzędzia deweloperskie na Androida.

Uzyskiwanie modeli

Uruchomienie modelu w aplikacji na Androida wymaga modelu w formacie LiteRT. Możesz użyć gotowych modeli lub utworzyć własny i przekonwertować go na format Lite. Więcej informacji o uzyskiwaniu modeli na potrzeby aplikacji na Androida znajdziesz na stronie Modele LiteRT.

Obsługa danych wejściowych

Wszystkie dane przekazywane do modelu ML muszą być tensorem o określonej strukturze danych, często nazywanej kształtem tensora. Aby przetwarzać dane za pomocą modelu, kod aplikacji musi przekształcać dane z ich natywnego formatu, np. obrazu, tekstu lub dźwięku, w tensor o kształcie wymaganym przez model.

Uruchamianie wnioskowania

Przetwarzanie danych przez model w celu wygenerowania wyniku prognozy jest nazywane wnioskowaniem. Przeprowadzenie wnioskowania w aplikacji na Androida wymaga środowiska wykonawczego LiteRT, modelu i danych wejściowych.

Szybkość, z jaką model może generować wnioski na danym urządzeniu, zależy od rozmiaru przetwarzanych danych, złożoności modelu i dostępnych zasobów obliczeniowych, takich jak pamięć i procesor, lub specjalnych procesorów zwanych akceleratorami. Modele uczenia maszynowego mogą działać szybciej na tych wyspecjalizowanych procesorach, takich jak procesory graficzne (GPU) i jednostki tensorowe (TPU), przy użyciu sterowników sprzętowych LiteRT zwanych delegatami. Więcej informacji o delegatach i akceleracji sprzętowej przetwarzania modeli znajdziesz w omówieniu akceleracji sprzętowej.

Obsługa wyników

Modele generują wyniki prognozy w postaci tensorów, które muszą być obsługiwane przez aplikację na Androida poprzez podjęcie działania lub wyświetlenie wyniku użytkownikowi. Wyniki modelu mogą być proste, np. liczba odpowiadająca pojedynczemu wynikowi (0 = pies, 1 = kot, 2 = ptak) w przypadku klasyfikacji obrazu, lub znacznie bardziej złożone, np. wiele pól ograniczających dla kilku sklasyfikowanych obiektów na obrazie, z ocenami pewności prognozy w zakresie od 0 do 1.

Zaawansowane ścieżki rozwoju

W przypadku bardziej zaawansowanych i dostosowanych modeli LiteRT może być konieczne zastosowanie bardziej zaawansowanych metod programowania niż opisane powyżej. W kolejnych sekcjach opisujemy zaawansowane techniki wykonywania modeli i ich tworzenia na potrzeby LiteRT w aplikacjach na Androida.

Zaawansowane środowiska wykonawcze

Oprócz standardowych środowisk wykonawczych i środowisk wykonawczych Usług Google Play dla LiteRT istnieją dodatkowe środowiska wykonawcze, których możesz używać w aplikacji na Androida. Najprawdopodobniej będziesz ich używać, jeśli masz model uczenia maszynowego, który korzysta z operacji ML nieobsługiwanych przez standardowe środowisko wykonawcze LiteRT.

• Elastyczne środowisko wykonawcze dla LiteRT
• Niestandardowe środowisko wykonawcze LiteRT

Środowisko wykonawcze Flex LiteRT umożliwia uwzględnienie konkretnych operatorów wymaganych przez model. Jako opcję zaawansowaną uruchamiania modelu możesz utworzyć LiteRT na Androida, aby uwzględnić operatory i inne funkcje wymagane do uruchomienia modelu uczenia maszynowego TensorFlow. Więcej informacji znajdziesz w artykule Tworzenie LiteRT na Androida.

Interfejsy API C i C++

LiteRT udostępnia też interfejs API do uruchamiania modeli w C i C++. Jeśli Twoja aplikacja korzysta z Android NDK, rozważ użycie tego interfejsu API. Warto też rozważyć użycie tego interfejsu API, jeśli chcesz udostępniać kod na wielu platformach. Więcej informacji o tej opcji znajdziesz na stronie Narzędzia programistyczne.

Wykonanie modelu na serwerze

Ogólnie rzecz biorąc, modele w aplikacji należy uruchamiać na urządzeniu z Androidem, aby zapewnić użytkownikom mniejsze opóźnienia i większą prywatność danych. Jednak w niektórych przypadkach lepszym rozwiązaniem jest uruchomienie modelu na serwerze w chmurze, poza urządzeniem. Na przykład jeśli masz duży model, którego nie można łatwo skompresować do rozmiaru, który zmieści się na urządzeniach z Androidem użytkowników, lub który nie może być na nich wykonywany z odpowiednią wydajnością. To rozwiązanie może być też preferowane, jeśli priorytetem jest stała wydajność modelu na wielu urządzeniach.

Google Cloud oferuje pełny pakiet usług do uruchamiania modeli AI. Więcej informacji znajdziesz na stronie Google Cloud poświęconej usługom związanym ze sztuczną inteligencją i uczeniem maszynowym.

Opracowywanie i optymalizacja modeli niestandardowych

Bardziej zaawansowane ścieżki rozwoju prawdopodobnie obejmują tworzenie niestandardowych modeli uczenia maszynowego i optymalizowanie ich pod kątem używania na urządzeniach z Androidem. Jeśli planujesz tworzyć modele niestandardowe, rozważ zastosowanie do nich technik kwantyzacji, aby zmniejszyć koszty pamięci i przetwarzania. Więcej informacji o tym, jak tworzyć modele o wysokiej wydajności do używania z LiteRT, znajdziesz w sekcji Modele w artykule Sprawdzone metody dotyczące wydajności.

Obsługiwane wersje Androida

Ważne: dbaj o aktualność zależności, aby zapewnić zgodność z najnowszymi funkcjami i aktualizacjami zabezpieczeń.

Interfejs Compiled Model API a interfejs Interpreter API

• Compiled Model API – wykonanie skompilowane w pierwszej kolejności na akceleratorze, AOT/JIT z ujednoliconą interoperacyjnością buforów i potokami asynchronicznymi.
• Interfejs API interpretera – wstecznie zgodny z dotychczasowym kodem w stylu TensorFlow Lite.

Możesz wybrać dowolny interfejs API w czasie działania. Większość nowych funkcji związanych z wydajnością i akceleratorami jest dostępna w interfejsie Compiled Model API.

Przykładowe implementacje znajdziesz w tych artykułach:

• Segmentacja obrazu (Kotlin, CPU/GPU)
• Asynchroniczna segmentacja (C++, CPU/GPU/NPU)
• Podobieństwo semantyczne (C++) – lokalny przykład

Wspólne i CPU

GPU

NPU

Krótkie wprowadzenie (interfejs Compiled Model API)

Przeprowadzanie wnioskowania za pomocą interfejsu Compiled Model API obejmuje te kluczowe kroki:

1. Wczytaj zgodny model.
2. Przydziel bufory tensorów wejściowych i wyjściowych.
3. Wywołaj skompilowany model.
4. Odczytaj wnioski do bufora wyjściowego.

Poniższe fragmenty kodu pokazują podstawową implementację całego procesu w językach Kotlin i C++.

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));

// Invoke
compiled_model.Run(input_buffers, output_buffers);

// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.CPU)
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

Więcej informacji znajdziesz w przewodnikach Pierwsze kroki z Kotlinem i Pierwsze kroki z C++.

Najważniejsze funkcje (interfejs Compiled Model API)

• Wybór akceleratora „pod klucz” i asynchroniczność – wybierz procesor, procesor graficzny lub NPU podczas tworzenia i uruchamiaj asynchronicznie bez delegowania.
• Ujednolicone bufory bez kopiowania – udostępniaj bufory AHWB/GL/OpenCL/WebGPU/Metal w ramach przetwarzania wstępnego i końcowego oraz wnioskowania.
• Przepustowość gotowa do generowania – zoptymalizowana pod kątem dużych modeli z pamięcią podręczną i przełączaniem awaryjnym na GPU/NPU.

Interfejs Interpreter API pozostaje ścieżką zgodności dla istniejących baz kodu TensorFlow Lite. Używaj go, gdy potrzebujesz stabilnego działania delegata lub opakowań innych firm, które oczekują klasycznego interpretera.

Akceleratory

• CPU (domyślnie): zoptymalizowany pod kątem XNNPACK, obsługuje dynamiczne kształty.
• GPU: obecnie backend OpenCL; backendy WebGPU i Metal są dostępne w interfejsie Compiled Model API.
• NPU: obsługiwane są Qualcomm AI Engine Direct i MediaTek NeuroPilot w przypadku AOT/JIT; dostępna jest funkcja Pixel AOT; planowana jest obsługa NPU Apple/Intel.

Kiedy wybrać interfejs API

• Używaj interfejsu Compiled Model API, gdy chcesz uzyskać najszybszy dostęp do procesora graficznego lub NPU, buforów bez kopiowania lub wykonywania asynchronicznego.
• Użyj interfejsu Interpreter API, gdy potrzebujesz maksymalnej zgodności z dotychczasowym kodem, narzędziami lub delegatami TensorFlow Lite.