Descripción general de LiteRT

LiteRT es el framework integrado en el dispositivo de Google para la implementación de AA y GenAI de alto rendimiento en plataformas perimetrales, con conversión, tiempo de ejecución y optimización eficientes.

La versión más reciente de LiteRT 2.x presenta la API de CompiledModel, una interfaz de tiempo de ejecución moderna diseñada para maximizar la aceleración de hardware. Si bien la API de Interpreter (antes TensorFlow Lite) sigue disponible para la retrocompatibilidad, la API de CompiledModel es la opción recomendada para los desarrolladores que buscan un rendimiento de vanguardia en aplicaciones de IA integradas en el dispositivo.

Funciones clave de LiteRT

Optimiza el desarrollo con LiteRT

Selección automática del acelerador en comparación con la creación explícita de delegados. Administración eficiente de búferes de E/S y ejecución asíncrona para un rendimiento superior. Consulta la documentación de inferencia integrada en el dispositivo.

Rendimiento de GPU de primera clase

Con tecnología de ML Drift, ahora compatible con modelos de AA y de IA generativa en las APIs de GPU. Consulta la documentación de aceleración de GPU.

Aceleración unificada de NPU

Acelera tu modelo con el acceso simplificado a la NPU de los principales proveedores de chipsets. Consulta la documentación de aceleración de NPU.

Compatibilidad superior con LLM

LiteRT ofrece una implementación de alto rendimiento para modelos de IA generativa en plataformas móviles, de escritorio y web. Consulta la documentación de implementación de GenAI.

Amplia compatibilidad con frameworks de AA

LiteRT admite la conversión optimizada de frameworks de PyTorch, TensorFlow y JAX al formato .tflite o .litertlm. Consulta la documentación de conversión de modelos.

Comienza a usar la API de CompiledModel

• Para modelos de AA clásicos, consulta las siguientes apps de demostración.

  • App de Kotlin de segmentación de imágenes: Inferencia de CPU/GPU/NPU.
  • App de C++ de segmentación de imágenes: Inferencia de CPU/GPU/NPU con ejecución asíncrona.

• Para modelos de GenAI, consulta las siguientes apps de demostración:

  • App de C++ de similitud semántica de EmbeddingGemma: Inferencia de CPU/GPU/NPU.

Flujo de trabajo del desarrollo

LiteRT ejecuta inferencias completamente integrado en el dispositivo en Android, iOS, la Web, IoT y en computadoras de escritorio o portátiles. Independientemente del dispositivo, el siguiente es el flujo de trabajo más común, con vínculos a instrucciones adicionales.

Identifica la solución más adecuada para el desafío de AA

LiteRT ofrece a los usuarios un alto nivel de flexibilidad y personalización cuando se trata de resolver problemas de aprendizaje automático, lo que lo hace adecuado para los usuarios que requieren un modelo específico o una implementación especializada. Los usuarios que buscan soluciones listas para usar pueden preferir MediaPipe Tasks, que proporciona soluciones listas para usar para tareas comunes de aprendizaje automático, como la detección de objetos, la clasificación de texto y la inferencia de LLM.

Obtén y prepara el modelo

Un modelo de LiteRT se representa en un formato portátil eficiente conocido como FlatBuffers, que usa la .tflite extensión de archivo.

Puedes obtener un modelo de LiteRT de las siguientes maneras:

• Obtén un modelo entrenado previamente: Para cargas de trabajo de AA populares, como la segmentación de imágenes, la detección de objetos, etcétera.

  El enfoque más simple es usar un modelo de LiteRT que ya esté en formato .tflite. Estos modelos no requieren pasos de conversión adicionales.

  Tipo de modelo	Fuente del modelo entrenado previamente
  AA clásico (.tflite formato)	Visita Kaggle o HuggingFace Por ejemplo, modelos de segmentación de imágenes y app de ejemplo
  IA generativa (.litertlm formato)	Página de Hugging Face de LiteRT Por ejemplo, familia Gemma

• Convierte el modelo de PyTorch, TensorFlow o JAX que elijas en un modelo de LiteRT si decides no usar un modelo entrenado previamente. [USUARIO PRO]

  Framework de modelo	Modelos de muestra	Herramienta de conversión
  PyTorch	Hugging Face Torchvision	Vínculo
  TensorFlow	Modelos de Kaggle Hugging Face	Vínculo
  Jax	Hugging Face	Vínculo

• Crea tu LLM para una mayor optimización con la API de Generativa [USUARIO PRO]

  Nuestra biblioteca de la API de Generativa proporciona componentes básicos integrados de PyTorch para componer modelos de Transformer, como Gemma, TinyLlama y otros, con abstracciones optimizadas para dispositivos móviles, a través de las cuales podemos garantizar la conversión y la ejecución de alto rendimiento en nuestro tiempo de ejecución móvil, LiteRT. Consulta la documentación de la API Generativa.

Optimiza [USUARIO PRO]

AI Edge Quantizer para desarrolladores avanzados es una herramienta para cuantificar modelos de LiteRT convertidos. Su objetivo es facilitar a los usuarios avanzados la búsqueda de un rendimiento óptimo en modelos que requieren muchos recursos (p.ej., modelos de GenAI).

Consulta más detalles en la documentación de AI Edge Quantizer.

Integra el modelo en tu app en plataformas perimetrales

LiteRT te permite ejecutar modelos de AA por completo integrado en el dispositivo con un alto rendimiento en plataformas de Android, iOS, la Web, computadoras de escritorio y IoT.

Usa las siguientes guías para integrar un modelo de LiteRT en la plataforma que prefieras:

En los siguientes fragmentos de código, se muestra una implementación básica en Kotlin y C++.

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

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

// Fill the input buffer
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

// Invoke
compiledModel.run(inputBuffers, outputBuffers)

// Read the output
val output = outputBuffers.get(0).readFloat()

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto env, GetEnvironment());
LITERT_ASSIGN_OR_RETURN(auto options, GetOptions());
LITERT_ASSIGN_OR_RETURN(
    auto compiled_model,
    CompiledModel::Create(env, "/path/to/mymodel.tflite", options));

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

// Fill the input buffer
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

// Read the output
LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

Elige un backend

La forma más sencilla de incorporar backends en LiteRT es confiar en la inteligencia integrada del tiempo de ejecución. Con la API de CompiledModel, LiteRT simplifica la configuración de manera significativa con la capacidad de especificar el backend de destino como una opción. Consulta la guía de inferencia integrada en el dispositivo para obtener más detalles.

Documentación y asistencia adicionales

• **Repositorio de GitHub de LiteRT-Samples** para obtener más apps de muestra de LiteRT.

• Para los usuarios existentes de TensorFlow Lite, consulta la guía de migración.

• **Página de herramientas de LiteRT** para obtener información sobre el rendimiento, la generación de perfiles, los informes de errores, etcétera.