Panoramica di LiteRT Next

LiteRT Next è un nuovo insieme di API che migliora LiteRT, in particolare in termini di accelerazione hardware e prestazioni per le applicazioni di ML e AI on-device. Le API sono una release alpha e sono disponibili in Kotlin e C++.

L'API LiteRT Next Compiled Model si basa sull'API Interprete TensorFlow Lite e semplifica il processo di caricamento ed esecuzione del modello per il machine learning on-device. Le nuove API offrono un nuovo modo semplificato per utilizzare l'accelerazione hardware, eliminando la necessità di gestire i modelli FlatBuffers, l'interoperabilità dei buffer I/O e i delegati. Le API LiteRT Next non sono compatibili con le API LiteRT. Per utilizzare le funzionalità di LiteRT Next, consulta la guida Inizia.

Per esempi di implementazioni di LiteRT Next, consulta le seguenti applicazioni demo:

Guida rapida

L'esecuzione dell'inferenza con le API LiteRT Next 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 deduzioni in un buffer di output.

I seguenti snippet di codice mostrano un'implementazione di base dell'intera procedura in Kotlin e C++.

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

Kotlin

// 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 ulteriori informazioni, consulta le guide Guida introduttiva a Kotlin e Guida introduttiva a C++.

Funzionalità principali

LiteRT Next offre i seguenti vantaggi e funzionalità principali:

  • Nuova API LiteRT: semplifica lo sviluppo con la selezione automatica dell'acceleratore, l'esecuzione veramente asincrona e la gestione efficiente dei buffer I/O.
  • Migliore rendimento GPU: utilizza l'accelerazione GPU all'avanguardia per il ML on-device. La nuova interoperabilità dei buffer consente la copia zero e minimizza la latenza tra i vari tipi di buffer della GPU.
  • Inferenza dell'IA generativa superiore: abilita l'integrazione più semplice con il rendimento migliore per i modelli di IA generativa.
  • Accelerazione NPU unificata: offre accesso senza interruzioni alle NPU dei principali fornitori di chipset con un'esperienza di sviluppo coerente. L'accelerazione NPU di LiteRT è disponibile tramite un programma di accesso in anteprima.

Miglioramenti principali

LiteRT Next (API modello compilato) contiene i seguenti miglioramenti chiave rispetto a LiteRT (API interprete TFLite). Per una guida completa alla configurazione della tua applicazione con LiteRT Next, consulta la guida Inizia.

  • Utilizzo dell'acceleratore: l'esecuzione di modelli su GPU con LiteRT richiede la creazione esplicita di delegati, chiamate di funzioni e modifiche al grafico. Con LiteRT Next, è sufficiente specificare l'acceleratore.
  • Interoperabilità dei buffer hardware nativi: LiteRT non offre la possibilità di utilizzare i buffer e forza tutti i dati a passare attraverso la memoria della CPU. Con LiteRT Next, puoi passare AHWB (Android Hardware Buffers), buffer OpenCL, buffer OpenGL o altri buffer specializzati.
  • Esecuzione asincrona: LiteRT Next è dotato di un'API asincrona riprogettata, che fornisce un vero meccanismo asincrono basato su barriere di sincronizzazione. In questo modo, è possibile ottenere tempi di esecuzione complessivi più rapidi grazie all'utilizzo di hardware diversi, come CPU, GPU, CPU e NPU, per attività diverse.
  • Caricamento del modello: LiteRT Next non richiede un passaggio del generatore separato per caricare un modello.