LiteRT per Android

LiteRT consente di eseguire modelli TensorFlow, PyTorch e JAX nelle tue app per Android. Il sistema LiteRT fornisce ambienti di esecuzione predefiniti e personalizzabili per l'esecuzione di modelli su Android in modo rapido ed efficiente, incluse opzioni per l'accelerazione hardware.

Ad esempio, per le applicazioni Android che utilizzano LiteRT, consulta il repository Esempi di LiteRT.

Modelli di machine learning

LiteRT utilizza modelli TensorFlow, PyTorch e JAX convertiti in un formato di modello di machine learning più piccolo, portatile ed efficiente. Puoi utilizzare modelli predefiniti con LiteRT su Android oppure creare i tuoi modelli e convertirli nel formato LiteRT.

Questa pagina descrive l'utilizzo di modelli di machine learning già creati e non tratta la creazione, l'addestramento, il test o la conversione dei modelli. Scopri di più su come scegliere, modificare, creare e convertire i modelli di machine learning per LiteRT nella pagina Modelli.

Eseguire modelli su Android

Un modello LiteRT in esecuzione all'interno di un'app per Android riceve i dati, li elabora e genera una previsione in base alla logica del modello. Un modello LiteRT richiede un ambiente di runtime speciale per l'esecuzione e i dati passati al modello devono essere in un formato specifico, chiamato tensore. Quando un modello elabora i dati, operazione nota come esecuzione di un'inferenza, genera risultati di previsione come nuovi tensori e li trasmette all'app per Android in modo che possa intraprendere un'azione, ad esempio mostrare il risultato a un utente o eseguire una logica di business aggiuntiva.

Figura 1. Flusso di esecuzione funzionale per i modelli LiteRT nelle app per Android.

A livello di progettazione funzionale, l'app per Android deve avere i seguenti elementi per eseguire un modello LiteRT:

• Ambiente di runtime LiteRT per l'esecuzione del modello
• Gestore di input del modello per trasformare i dati in tensori
• Gestore dell'output del modello per ricevere i tensori dei risultati dell'output e interpretarli come risultati della previsione

Le sezioni seguenti descrivono in che modo le librerie e gli strumenti LiteRT forniscono questi elementi funzionali.

Crea app con LiteRT

Questa sezione descrive il percorso consigliato e più comune per implementare LiteRT nella tua app per Android. Devi prestare particolare attenzione alle sezioni ambiente di runtime e librerie di sviluppo. Se hai sviluppato un modello personalizzato, assicurati di esaminare la sezione Percorsi di sviluppo avanzati.

Opzioni dell'ambiente di runtime

Esistono diversi modi per attivare un ambiente di runtime per l'esecuzione di modelli nella tua app per Android. Ecco le opzioni preferite:

• LiteRT nell'ambiente di runtime dei servizi Google Play (consigliato)
• Ambiente di runtime LiteRT autonomo

In generale, devi utilizzare l'ambiente di runtime fornito da Google Play Services perché è più efficiente in termini di spazio rispetto all'ambiente standard, in quanto viene caricato dinamicamente, mantenendo le dimensioni dell'app più ridotte. Google Play Services utilizza automaticamente anche la release più recente e stabile del runtime LiteRT, offrendoti funzionalità aggiuntive e prestazioni migliorate nel tempo. Se offri la tua app su dispositivi che non includono Google Play Services o se devi gestire da vicino l'ambiente di runtime ML, devi utilizzare il runtime LiteRT standard. Questa opzione raggruppa codice aggiuntivo nella tua app, consentendoti di avere un maggiore controllo sul runtime ML nella tua app a costo di aumentare le dimensioni del download dell'app.

Per accedere a questi ambienti runtime nella tua app per Android, aggiungi le librerie di sviluppo LiteRT al tuo ambiente di sviluppo dell'app. Per informazioni su come utilizzare gli ambienti di runtime standard nella tua app, consulta la sezione successiva.

Biblioteche

Puoi accedere all'API Interpreter utilizzando i servizi Google Play. Puoi utilizzare le librerie core e support di LiteRT nella tua app per Android. Per i dettagli di programmazione sull'utilizzo delle librerie e degli ambienti di runtime di LiteRT, consulta Strumenti di sviluppo per Android.

Ottenere modelli

Per eseguire un modello in un'app per Android è necessario un modello in formato LiteRT. Puoi utilizzare modelli predefiniti o crearne uno e convertirlo nel formato Lite. Per saperne di più su come ottenere modelli per la tua app per Android, consulta la pagina Modelli di LiteRT.

Gestire i dati di input

Tutti i dati che trasmetti a un modello ML devono essere un tensore con una struttura di dati specifica, spesso chiamata forma del tensore. Per elaborare i dati con un modello, il codice dell'app deve trasformare i dati dal formato nativo, ad esempio dati di immagine, testo o audio, in un tensore nella forma richiesta per il modello.

Eseguire inferenze

L'elaborazione dei dati tramite un modello per generare un risultato di previsione è nota come esecuzione di un'inferenza. L'esecuzione di un'inferenza in un'app per Android richiede un ambiente di runtime LiteRT, un modello e dati di input.

La velocità con cui un modello può generare un'inferenza su un determinato dispositivo dipende dalle dimensioni dei dati elaborati, dalla complessità del modello e dalle risorse di calcolo disponibili, come memoria e CPU, o da processori specializzati chiamati acceleratori. I modelli di machine learning possono essere eseguiti più velocemente su questi processori specializzati, come le unità di elaborazione grafica (GPU) e le unità di elaborazione tensoriale (TPU), utilizzando driver hardware LiteRT chiamati delegati. Per ulteriori informazioni sui delegati e sull'accelerazione hardware dell'elaborazione dei modelli, consulta la panoramica sull'accelerazione hardware.

Gestire i risultati dell'output

I modelli generano risultati di previsione come tensori, che devono essere gestiti dalla tua app per Android intraprendendo un'azione o mostrando un risultato all'utente. I risultati dell'output del modello possono essere semplici come un numero corrispondente a un singolo risultato (0 = cane, 1 = gatto, 2 = uccello) per una classificazione delle immagini, oppure molto più complessi, come più bounding box per diversi oggetti classificati in un'immagine, con valutazioni di confidenza della previsione comprese tra 0 e 1.

Percorsi di sviluppo avanzati

Quando utilizzi modelli LiteRT più sofisticati e personalizzati, potresti dover utilizzare approcci di sviluppo più avanzati rispetto a quelli descritti sopra. Le sezioni seguenti descrivono tecniche avanzate per l'esecuzione di modelli e il loro sviluppo per LiteRT nelle app per Android.

Ambienti di runtime avanzati

Oltre agli ambienti di runtime standard e di runtime di Google Play Services per LiteRT, esistono altri ambienti di runtime che puoi utilizzare con la tua app per Android. L'uso più probabile di questi ambienti è se hai un modello di machine learning che utilizza operazioni di ML non supportate dall'ambiente di runtime standard per LiteRT.

• Runtime flessibile per LiteRT
• Runtime LiteRT personalizzato

L'ambiente di esecuzione Flex di LiteRT consente di includere operatori specifici richiesti per il modello. Come opzione avanzata per l'esecuzione del modello, puoi creare LiteRT per Android per includere operatori e altre funzionalità necessarie per l'esecuzione del modello di machine learning TensorFlow. Per saperne di più, consulta Creare LiteRT per Android.

API C e C++

LiteRT fornisce anche un'API per l'esecuzione di modelli utilizzando C e C++. Se la tua app utilizza l'NDK Android, ti consigliamo di utilizzare questa API. Potresti anche prendere in considerazione l'utilizzo di questa API se vuoi poter condividere il codice tra più piattaforme. Per saperne di più su questa opzione di sviluppo, consulta la pagina Strumenti di sviluppo.

Esecuzione del modello basata su server

In generale, dovresti eseguire i modelli nella tua app su un dispositivo Android per sfruttare una latenza inferiore e una maggiore privacy dei dati per i tuoi utenti. Tuttavia, in alcuni casi, l'esecuzione di un modello su un server cloud, al di fuori del dispositivo, è una soluzione migliore. Ad esempio, se hai un modello di grandi dimensioni che non si comprime facilmente fino a raggiungere una dimensione adatta ai dispositivi Android dei tuoi utenti o che può essere eseguito con prestazioni ragionevoli su questi dispositivi. Questo approccio potrebbe essere la tua soluzione preferita anche se la coerenza delle prestazioni del modello su un'ampia gamma di dispositivi è la massima priorità.

Google Cloud offre una suite completa di servizi per l'esecuzione di modelli di AI. Per ulteriori informazioni, consulta la pagina sui prodotti di AI e machine learning di Google Cloud.

Sviluppo e ottimizzazione di modelli personalizzati

I percorsi di sviluppo più avanzati includono probabilmente lo sviluppo di modelli di machine learning personalizzati e la loro ottimizzazione per l'utilizzo su dispositivi Android. Se prevedi di creare modelli personalizzati, assicurati di prendere in considerazione l'applicazione di tecniche di quantizzazione ai modelli per ridurre i costi di memoria ed elaborazione. Per ulteriori informazioni su come creare modelli ad alte prestazioni da utilizzare con LiteRT, consulta la sezione Best practice per le prestazioni nella sezione Modelli.

Versioni di Android supportate

Importante:mantieni aggiornate le dipendenze per garantire la compatibilità con le funzionalità e gli aggiornamenti della sicurezza più recenti.

API Compiled Model e API Interpreter

• API Compiled Model: esecuzione compilata AOT/JIT con priorità per gli acceleratori, interoperabilità unificata dei buffer e pipeline asincrone.
• API Interpreter: compatibile con il codice in stile TensorFlow Lite esistente.

Puoi scegliere una delle due API in fase di runtime. La maggior parte delle nuove funzionalità di rendimento e acceleratore si trova nell'API Compiled Model.

Per esempi di implementazione, vedi:

• Segmentazione delle immagini (Kotlin, CPU/GPU)
• Segmentazione asincrona (C++, CPU/GPU/NPU)
• Similarità semantica (C++) - Esempio locale

Comune e CPU

GPU

NPU

Guida rapida (API Compiled Model)

L'esecuzione dell'inferenza con l'API Compiled Model prevede i seguenti passaggi chiave:

1. Carica un modello compatibile.
2. Alloca i buffer dei tensori di input e output.
3. Richiama il modello compilato.
4. Leggi le inferenze in un buffer di output.

I seguenti snippet di codice mostrano un'implementazione di base dell'intero processo in Kotlin e 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()

Per saperne di più, consulta le guide Guida introduttiva a Kotlin e Guida introduttiva a C++.

Funzionalità chiave (API Compiled Model)

• Selezione e asincronia dell'acceleratore chiavi in mano: scegli CPU/GPU/NPU al momento della creazione ed esegui l'operazione in modo asincrono senza delegare la gestione.
• Buffer unificati zero-copy: condividi i buffer AHWB/GL/OpenCL/WebGPU/Metal tra pre/post-elaborazione e inferenza.
• Velocità effettiva pronta per l'IA generativa: ottimizzata per modelli di grandi dimensioni con memorizzazione nella cache della memoria e fallback di GPU/NPU.

L'API Interpreter rimane il percorso di compatibilità per le codebase TensorFlow Lite esistenti. Utilizzala quando hai bisogno di un comportamento stabile del delegato o di wrapper di terze parti che si aspettano l'interprete classico.

Acceleratori

• CPU (impostazione predefinita): XNNPACK ottimizzato, forme dinamiche supportate.
• GPU:backend OpenCL oggi; i backend WebGPU e Metal sono disponibili tramite l'API Compiled Model.
• NPU: Qualcomm AI Engine Direct e MediaTek NeuroPilot sono supportati per AOT/JIT; Pixel AOT è disponibile; è previsto il supporto di NPU Apple/Intel.

Quando scegliere un'API

• Utilizza l'API Compiled Model quando vuoi il percorso più veloce per GPU/NPU, buffer zero-copy o esecuzione asincrona.
• Utilizza l'API Interpreter quando hai bisogno della massima compatibilità con codice, strumenti o delegati TensorFlow Lite esistenti.