Te damos la bienvenida a la 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 una conversión, un tiempo de ejecución y una optimización eficientes.

LiteRT 2.x contiene la API de tiempo de ejecución más reciente, la API de CompiledModel, que mejora la API de Interpreter (también conocida como APIs de TensorFlow Lite), en particular, a través de la aceleración por hardware y el rendimiento general para las aplicaciones de IA y AA en el dispositivo. La API de CompiledModel está en versión beta y disponible en Kotlin y C++.

Funciones clave de LiteRT

Modelos compatibles

LiteRT admite la conversión optimizada de frameworks de PyTorch, TensorFlow y JAX a formato .tflite o .litertlm.

Optimiza el desarrollo con LiteRT

Selección automática del acelerador en comparación con la creación explícita de delegados. Distribución de modelos y tiempo de ejecución de la NPU sencillos Manejo eficiente de búferes de E/S y ejecución asíncrona para un rendimiento superior

Rendimiento de GPU de primer nivel

Con la tecnología de ML Drift, ahora compatible con los modelos de AA y de IA generativa en las APIs de GPU.

Aceleración unificada de la NPU

Acelera tu modelo con un acceso simplificado a la NPU de los principales proveedores de chipsets.

Compatibilidad simplificada con LLM con LiteRT

Puedes usar LiteRT-LM, que funciona con LiteRT. LiteRT-LM admite los LLM más recientes y funciones útiles, como la multimodalidad, la decodificación restringida, etcétera.

Flujo de trabajo de desarrollo

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

Identificar 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 convierte en una buena opción 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.

Cómo obtener y preparar el modelo

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

Puedes obtener un modelo de LiteRT de las siguientes maneras:

• Obtén un modelo previamente entrenado: Para cargas de trabajo de AA populares, como segmentación de imágenes, 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 previamente entrenado
  AA clásico (formato .tflite)	Visita Kaggle o HuggingFace. P. ej., modelos de segmentación de imágenes y app de ejemplo.
  IA generativa (formato .litertlm)	Página de Hugging Face de LiteRT p.ej., Gemma Family

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

  Framework del modelo	Modelos de ejemplo	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 optimizarlo aún más con la API de Generative [USUARIO PRO]

  Nuestra biblioteca de APIs generativas proporciona elementos básicos integrados en PyTorch para componer modelos Transformer, como Gemma, TinyLlama y otros, con abstracciones aptas 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 para dispositivos móviles, LiteRT. Consulta la documentación de la API generativa.

Cuantización [USUARIO PRO]

AI Edge Quantizer para desarrolladores avanzados es una herramienta para cuantificar modelos de LiteRT convertidos. Su objetivo es facilitar que los usuarios avanzados se esfuercen por lograr un rendimiento óptimo en modelos que exigen muchos recursos (p.ej., modelos de IA generativa).

Para los modelos de aprendizaje automático y los modelos de IA generativa, consulta la documentación de Ai-Edge-Quantization.

Requisitos previos para comenzar

• Python 3.10 a 3.12
• Archivo de modelo .tflite
• Encontrarás más detalles en la sección de la plataforma correspondiente

Integra el modelo en tu app en plataformas perimetrales

Puedes implementar tus modelos de LiteRT para ejecutar inferencias completamente en el dispositivo en dispositivos Android, iOS, Web, IoT y de escritorio. LiteRT contiene APIs para Python, Java y Kotlin para Android, Swift para iOS y C++ para microdispositivos.

Usa las siguientes guías para implementar un modelo de LiteRT en tu plataforma preferida:

*Disponible próximamente

Ejemplo de código Kotlin

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

// Prepare I/O buffers and fill in the data
val inputBuffers = compiledModel.createInputBuffers()
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

val outputBuffers = compiledModel.createOutputBuffers()

// Execute model
compiledModel.run(inputBuffers, outputBuffers)

// Access model output
val output = outputBuffers.get(0).readFloat()

inputBuffers.forEach { it.close() }
outputBuffers.forEach { it.close() }
compiledModel.close()

Ejemplo de código en C++

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));
LITERT_ASSIGN_OR_RETURN(auto input_buffers,compiled_model.CreateInputBuffers(signature_index));
LITERT_ASSIGN_OR_RETURN(auto output_buffers,compiled_model.CreateOutputBuffers(signature_index));
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

Elige un backend

La forma más sencilla de incorporar back-ends en LiteRT es confiar en la inteligencia integrada del tiempo de ejecución. Con los cambios más recientes, LiteRT simplifica significativamente la configuración, ya que permite especificar el backend de destino como una opción.

El núcleo de LiteRT v2.x es el objeto CompiledModel. Cuando cargas un modelo, LiteRT usa el hardware disponible del sistema y la lógica de prioridad interna para seleccionar el backend óptimo sin necesidad de configuración manual. Consulta el backend para obtener más detalles.

Documentación y asistencia adicionales

App de ejemplo de LiteRT v2.x Consulta la app de ejemplo de segmentación de imágenes de LiteRT

Para los usuarios existentes de TensorFlow Lite Consulta la guía de migración

Cobertura de operaciones Operadores compatibles

Modelos de LLM compatibles LiteRT Hugging Face y Gen API: muestras

Herramientas Página de herramientas de LiteRT: Rendimiento, generación de perfiles, informes de errores, etcétera