LiteRT para Android

LiteRT te permite ejecutar modelos de TensorFlow, PyTorch y JAX en tus apps para Android. El sistema LiteRT proporciona entornos de ejecución prediseñados y personalizables para ejecutar modelos en Android de forma rápida y eficiente, incluidas opciones para la aceleración por hardware.

Para ver ejemplos de aplicaciones para Android que usan LiteRT, consulta el repositorio de muestras de LiteRT.

Modelos de aprendizaje automático

LiteRT usa modelos de TensorFlow, PyTorch y JAX que se convierten en un formato de modelo de aprendizaje automático más pequeño, portátil y eficiente. Puedes usar modelos prediseñados con LiteRT en Android o crear tus propios modelos y convertirlos al formato de LiteRT.

En esta página, se explica cómo usar modelos de aprendizaje automático ya creados y no se abordan la creación, el entrenamiento, las pruebas ni la conversión de modelos. Obtén más información para elegir, modificar, compilar y convertir modelos de aprendizaje automático para LiteRT en la página Modelos.

Ejecuta modelos en Android

Un modelo de LiteRT que se ejecuta dentro de una app para Android toma datos, los procesa y genera una predicción basada en la lógica del modelo. Un modelo de LiteRT requiere un entorno de ejecución especial para ejecutarse, y los datos que se pasan al modelo deben tener un formato de datos específico, llamado tensor. Cuando un modelo procesa los datos, lo que se conoce como ejecutar una inferencia, genera resultados de predicción como tensores nuevos y los pasa a la app para Android para que pueda tomar medidas, como mostrar el resultado a un usuario o ejecutar lógica empresarial adicional.

Figura 1: Flujo de ejecución funcional para modelos de LiteRT en apps para Android.

En el nivel de diseño funcional, tu app para Android necesita los siguientes elementos para ejecutar un modelo de LiteRT:

• Entorno de ejecución de LiteRT para ejecutar el modelo
• Controlador de entrada del modelo para transformar datos en tensores
• Controlador de salida del modelo para recibir tensores de resultados de salida y, luego, interpretarlos como resultados de predicción

En las siguientes secciones, se describe cómo las bibliotecas y las herramientas de LiteRT proporcionan estos elementos funcionales.

Crea apps con LiteRT

En esta sección, se describe la ruta recomendada y más común para implementar LiteRT en tu app para Android. Debes prestar especial atención a las secciones entorno de ejecución y bibliotecas de desarrollo. Si desarrollaste un modelo personalizado, asegúrate de revisar la sección Rutas de desarrollo avanzadas.

Opciones del entorno de ejecución

Existen varias formas de habilitar un entorno de ejecución para ejecutar modelos en tu app para Android. Estas son las opciones preferidas:

• LiteRT en el entorno de ejecución de los Servicios de Google Play (recomendado)
• Entorno de ejecución de LiteRT independiente

En general, debes usar el entorno de ejecución que proporcionan los Servicios de Google Play, ya que es más eficiente en cuanto al espacio que el entorno estándar, porque se carga de forma dinámica, lo que mantiene el tamaño de tu app más pequeño. Los Servicios de Google Play también usan automáticamente la versión estable más reciente del tiempo de ejecución de LiteRT, lo que te brinda funciones adicionales y un mejor rendimiento con el tiempo. Si ofreces tu app en dispositivos que no incluyen los Servicios de Google Play o necesitas administrar de cerca tu entorno de ejecución de AA, debes usar el entorno de ejecución estándar de LiteRT. Esta opción incluye código adicional en tu app, lo que te permite tener más control sobre el tiempo de ejecución del AA en tu app a costa de aumentar el tamaño de descarga de la app.

Para acceder a estos entornos de ejecución en tu app para Android, agrega bibliotecas de desarrollo de LiteRT a tu entorno de desarrollo de apps. Para obtener información sobre cómo usar los entornos de ejecución estándar en tu app, consulta la siguiente sección.

Bibliotecas

Puedes acceder a la API de Interpreter con los Servicios de Google Play. Puedes usar las bibliotecas core y support de LiteRT en tu app para Android. Para obtener detalles de programación sobre el uso de las bibliotecas y los entornos de ejecución de LiteRT, consulta Herramientas de desarrollo para Android.

Obtén modelos

Para ejecutar un modelo en una app para Android, se requiere un modelo en formato LiteRT. Puedes usar modelos prediseñados o crear uno y convertirlo al formato Lite. Para obtener más información sobre cómo obtener modelos para tu app para Android, consulta la página Modelos de LiteRT.

Cómo controlar los datos de entrada

Todos los datos que pases a un modelo de AA deben ser un tensor con una estructura de datos específica, a menudo denominada forma del tensor. Para procesar datos con un modelo, el código de tu app debe transformar los datos de su formato nativo, como datos de imagen, texto o audio, en un tensor con la forma requerida para tu modelo.

Ejecuta inferencias

El procesamiento de datos a través de un modelo para generar un resultado de predicción se conoce como ejecutar una inferencia. Para ejecutar una inferencia en una app para Android, se requiere un entorno de ejecución de LiteRT, un modelo y datos de entrada.

La velocidad a la que un modelo puede generar una inferencia en un dispositivo en particular depende del tamaño de los datos procesados, la complejidad del modelo y los recursos de procesamiento disponibles, como la memoria y la CPU, o los procesadores especializados llamados aceleradores. Los modelos de aprendizaje automático pueden ejecutarse más rápido en estos procesadores especializados, como las unidades de procesamiento gráfico (GPU) y las unidades de procesamiento tensorial (TPU), con controladores de hardware LiteRT llamados delegados. Para obtener más información sobre los delegados y la aceleración de hardware del procesamiento de modelos, consulta la descripción general de la aceleración de hardware.

Cómo controlar los resultados de salida

Los modelos generan resultados de predicción como tensores, que tu app para Android debe controlar tomando medidas o mostrando un resultado al usuario. Los resultados del modelo pueden ser tan simples como un número que corresponde a un solo resultado (0 = perro, 1 = gato, 2 = pájaro) para una clasificación de imágenes, o bien pueden ser mucho más complejos, como varios cuadros de límite para varios objetos clasificados en una imagen, con calificaciones de confianza de predicción entre 0 y 1.

Rutas de desarrollo avanzadas

Cuando uses modelos de LiteRT más sofisticados y personalizados, es posible que debas utilizar enfoques de desarrollo más avanzados que los que se describen anteriormente. En las siguientes secciones, se describen técnicas avanzadas para ejecutar modelos y desarrollarlos para LiteRT en apps para Android.

Entornos de ejecución avanzados

Además de los entornos de ejecución estándar y de los servicios de Google Play para LiteRT, existen otros entornos de ejecución que puedes usar con tu app para Android. Lo más probable es que uses estos entornos si tienes un modelo de aprendizaje automático que utiliza operaciones de AA que no son compatibles con el entorno de ejecución estándar de LiteRT.

• Tiempo de ejecución flexible para LiteRT
• Entorno de ejecución de LiteRT compilado de forma personalizada

El tiempo de ejecución flexible de LiteRT te permite incluir operadores específicos que requiere tu modelo. Como opción avanzada para ejecutar tu modelo, puedes compilar LiteRT para Android y, así, incluir operadores y otras funciones necesarias para ejecutar tu modelo de aprendizaje automático de TensorFlow. Para obtener más información, consulta Cómo compilar LiteRT para Android.

APIs de C y C++

LiteRT también proporciona una API para ejecutar modelos con C y C++. Si tu app usa el NDK de Android, deberías considerar usar esta API. También puedes considerar usar esta API si deseas poder compartir código entre varias plataformas. Para obtener más información sobre esta opción de desarrollo, consulta la página Herramientas de desarrollo.

Ejecución de modelos basada en servidores

En general, debes ejecutar modelos en tu app en un dispositivo Android para aprovechar la menor latencia y la mayor privacidad de los datos para tus usuarios. Sin embargo, hay casos en los que ejecutar un modelo en un servidor de la nube, fuera del dispositivo, es una mejor solución. Por ejemplo, si tienes un modelo grande que no se comprime fácilmente a un tamaño que se ajuste a los dispositivos Android de tus usuarios o que no se puede ejecutar con un rendimiento razonable en esos dispositivos. Este enfoque también puede ser tu solución preferida si la prioridad principal es el rendimiento coherente del modelo en una amplia variedad de dispositivos.

Google Cloud ofrece un paquete completo de servicios para ejecutar modelos de IA. Para obtener más información, consulta la página de productos de IA y aprendizaje automático de Google Cloud.

Desarrollo y optimización de modelos personalizados

Es probable que las rutas de desarrollo más avanzadas incluyan el desarrollo de modelos personalizados de aprendizaje automático y la optimización de esos modelos para su uso en dispositivos Android. Si planeas compilar modelos personalizados, asegúrate de aplicar técnicas de cuantificación a los modelos para reducir los costos de memoria y procesamiento. Para obtener más información sobre cómo compilar modelos de alto rendimiento para usar con LiteRT, consulta Prácticas recomendadas de rendimiento en la sección Modelos.

Versiones de Android compatibles

Importante: Mantén tus dependencias actualizadas para garantizar la compatibilidad con las funciones y actualizaciones de seguridad más recientes.

Comparación entre la API de Compiled Model y la API de Interpreter

• API de Compiled Model: Ejecución compilada con prioridad en el acelerador, AOT/JIT con interoperabilidad de búfer unificada y canalizaciones asíncronas.
• API del intérprete: Es compatible con versiones anteriores del código de estilo de TensorFlow Lite existente.

Puedes elegir cualquiera de las dos APIs en el tiempo de ejecución. La mayoría de las nuevas funciones de rendimiento y aceleración se encuentran en la API de Compiled Model.

Para ver ejemplos de implementación, consulta los siguientes vínculos:

• Segmentación de imágenes (Kotlin, CPU/GPU)
• Segmentación asíncrona (C++, CPU/GPU/NPU)
• Similitud semántica (C++): Muestra local

Común y CPU

GPU

NPU

Guía de inicio rápido (API de Compiled Model)

Ejecutar la inferencia con la API de Compiled Model 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++.

// 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()

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

Funciones clave (API de Compiled Model)

• Selección de acelerador llave en mano y asíncrona: Elige la CPU, la GPU o la NPU en el momento de la creación y ejecuta de forma asíncrona sin canalización de delegados.
• Búferes unificados de copia cero: Comparte búferes de AHWB, GL, OpenCL, WebGPU y Metal en el procesamiento previo y posterior, y en la inferencia.
• Capacidad de procesamiento lista para la generación: Se optimizó para modelos grandes con almacenamiento en caché de memoria y GPU/NPU de respaldo.

La API de Interpreter sigue siendo la ruta de compatibilidad para las bases de código existentes de TensorFlow Lite. Úsala cuando necesites un comportamiento estable del delegado o wrappers de terceros que esperen el intérprete clásico.

Aceleradores

• CPU (predeterminado): XNNPACK optimizado, admite formas dinámicas.
• GPU: Backend de OpenCL hoy; los backends de WebGPU y Metal están disponibles a través de la API de Compiled Model.
• NPU: Se admiten Qualcomm AI Engine Direct y MediaTek NeuroPilot para AOT/JIT; Pixel AOT está disponible; se planea la compatibilidad con NPU de Apple/Intel.

Cuándo elegir una API

• Usa la API de Compiled Model cuando quieras la ruta más rápida a la GPU o la NPU, búferes de copia cero o ejecución asíncrona.
• Usa la API de Interpreter cuando necesites la máxima compatibilidad con el código, las herramientas o los delegados existentes de TensorFlow Lite.