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.

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 por hardware. Si bien la API de Interpreter (anteriormente 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 las aplicaciones de IA en el dispositivo.

Funciones clave de LiteRT

Optimiza el desarrollo con LiteRT

Comparación entre la selección automática de aceleradores y la creación explícita de delegados Manejo eficiente de búferes de E/S y ejecución asíncrona para un rendimiento superior Consulta la documentación sobre la inferencia integrada en el dispositivo.

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. Consulta la documentación sobre la aceleración por GPU.

Aceleración unificada de la NPU

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

Asistencia superior de LLM

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

Amplia compatibilidad con frameworks de AA

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

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

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 completamente en el dispositivo con un alto rendimiento en las plataformas de Android, iOS, Web, escritorio y IoT.

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

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 acelerador de hardware

La forma más sencilla de incorporar back-ends en LiteRT es confiar en la inteligencia integrada del tiempo de ejecución. Con la API de CompiledModel, LiteRT simplifica significativamente la configuración con la capacidad de especificar el backend de destino como una opción. Consulta la guía de inferencia 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 ejemplo de LiteRT

• Si ya usas TensorFlow Lite, consulta la guía de migración.

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