Descripción general de LiteRT Next

LiteRT Next es un nuevo conjunto de APIs que mejora LiteRT, en particular en términos de aceleración de hardware y rendimiento para aplicaciones de IA y AA integradas en el dispositivo. Las APIs son una versión alfa y están disponibles en Kotlin y C++.

La API de LiteRT Next Compiled Model se basa en la API de TensorFlow Lite Interpreter y simplifica el proceso de carga y ejecución de modelos para el aprendizaje automático integrado en el dispositivo. Las nuevas APIs proporcionan una nueva forma optimizada de usar la aceleración de hardware, lo que elimina la necesidad de lidiar con el modelo FlatBuffers, la interoperabilidad del búfer de E/S y los delegados. Las APIs de LiteRT Next no son compatibles con las APIs de LiteRT. Para usar las funciones de LiteRT Next, consulta la guía de Inicio.

Para ver ejemplos de implementaciones de LiteRT Next, consulta las siguientes aplicaciones de demostración:

Guía de inicio rápido

Ejecutar la inferencia con las APIs de LiteRT Next implica los siguientes pasos clave:

  1. Carga un modelo compatible.
  2. Asigna los búferes de tensores de entrada y salida.
  3. Invoca el modelo compilado.
  4. Lee las inferencias en un búfer de salida.

En los siguientes fragmentos de código, se muestra una implementación básica de todo el proceso en Kotlin y 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()

Para obtener más información, consulta las guías Cómo comenzar a usar Kotlin y Cómo comenzar a usar C++.

Características clave

LiteRT Next incluye los siguientes beneficios y funciones clave:

  • Nueva API de LiteRT: Agiliza el desarrollo con la selección automática de aceleradores, la ejecución asíncrona real y el manejo eficiente de los búferes de E/S.
  • Rendimiento de GPU de primera clase: Usa la aceleración de GPU de última generación para la IA integrada en el dispositivo. La nueva interoperabilidad de búferes habilita la copia cero y minimiza la latencia en varios tipos de búferes de GPU.
  • Inferencia de IA generativa superior: Habilita la integración más sencilla con el mejor rendimiento para los modelos de IA generativa.
  • Unified NPU Acceleration: Ofrece acceso sin problemas a las NPU de los principales proveedores de chipsets con una experiencia de desarrollador coherente. La aceleración de la NPU de LiteRT está disponible a través de un Programa de acceso anticipado.

Mejoras clave

LiteRT Next (API de modelo compilado) contiene las siguientes mejoras clave en LiteRT (API de intérprete de TFLite). Para obtener una guía integral para configurar tu aplicación con LiteRT Next, consulta la guía Cómo comenzar.

  • Uso del acelerador: Ejecutar modelos en la GPU con LiteRT requiere la creación explícita de delegados, llamadas a funciones y modificaciones de gráficos. Con LiteRT, solo debes especificar el acelerador.
  • Interoperabilidad de búferes de hardware nativo: LiteRT no proporciona la opción de búferes y fuerza todos los datos a través de la memoria de la CPU. Con LiteRT Next, puedes pasar búferes de hardware de Android (AHWB), búferes de OpenCL, búferes de OpenGL y otros búferes especializados.
  • Ejecución asíncrona: LiteRT Next incluye una API asíncrona rediseñada que proporciona un mecanismo asíncrono real basado en cercas de sincronización. Esto permite tiempos de ejecución generales más rápidos mediante el uso de hardware diverso, como CPUs, GPUs, CPUs y NPU, para diferentes tareas.
  • Carga de modelos: LiteRT Next no requiere un paso de compilación independiente cuando se carga un modelo.