Durante la última década, los teléfonos celulares incorporaron aceleradores específicos cada vez más potentes, incluidas las GPU y, recientemente, las NPU (unidades de procesamiento neuronal) más potentes. Si aceleras los modelos de IA en GPU y NPU móviles, puedes acelerar tus modelos hasta 25 veces en comparación con la CPU, al tiempo que se reduce el consumo de energía hasta 5 veces. Sin embargo, aprovechar estos beneficios de rendimiento sobresalientes resultó ser un desafío para la mayoría de los desarrolladores, ya que requiere explorar APIs de hardware específico en caso de inferencia de GPU o explorar SDK, formatos y tiempos de ejecución específicos del proveedor para la inferencia de NPU.
El equipo de Google AI Edge, que tuvo en cuenta los comentarios de los desarrolladores, hoy se complace en anunciar múltiples mejoras en LiteRT que resuelven los desafíos mencionados y permiten acelerar más fácilmente la IA en dispositivos móviles con un mayor rendimiento. Nuestra nueva versión incluye una nueva API LiteRT, que hace que la inferencia de aprendizaje automático en el dispositivo sea más fácil que nunca. Además, la última aceleración de GPU de vanguardia, el nuevo soporte de NPU desarrollado junto con MediaTek y Qualcomm (de código abierto para acceso anticipado) y las funciones avanzadas de inferencia permiten maximizar el rendimiento de las aplicaciones en el dispositivo. ¡Empecemos!
Las GPU siempre tuvieron un lugar central en la historia de aceleración de LiteRT, ya que proporcionan una compatibilidad más amplia y mejoras de rendimiento más consistentes. MLDrift, nuestra última versión de aceleración de GPU, eleva aun más la vara con un rendimiento más rápido y mejoras que ofrecen compatibilidad con modelos de un tamaño significativamente mayor, gracias a las siguientes funciones:
De esta manera, se logra un rendimiento significativamente más rápido que con las CPU, que el de las versiones anteriores de nuestro delegado de GPU TFLite e incluso de otros marcos de trabajo habilitados para GPU, especialmente para los modelos CNN y Transformer.
Encuentra ejemplos en nuestra documentación y prueba la aceleración de GPU hoy mismo.
Las NPU, aceleradores específicos de IA, son cada vez más comunes en los teléfonos principales. Permiten ejecutar modelos de IA de manera mucho más eficiente y, en muchos casos, con una rapidez increíble. Según nuestras pruebas internas, en comparación con las CPU, esta aceleración puede ser hasta 25 veces más rápida y 5 veces más eficiente en el consumo de energía. (Mayo de 2025, basado en pruebas internas).
Por lo general, cada proveedor proporciona sus propios SDK, incluidos compiladores, entornos de ejecución y otras dependencias, para compilar y ejecutar modelos en sus SoC. El SDK debe coincidir con precisión con la versión específica del SoC y requiere una descarga e instalación adecuadas. LiteRT ahora proporciona una manera uniforme de desarrollar e implementar modelos en NPU, con las que se eliminan todas estas complejidades.
Nos entusiasma asociarnos con MediaTek y Qualcomm para permitir a los desarrolladores acelerar una amplia variedad de modelos clásicos de aprendizaje automático, como los modelos de visión, audio y PNL, en las NPU de MediaTek y Qualcomm. Continuaremos agregando compatibilidad con modelos y dominios durante el próximo año.
Esta función está disponible en una versión preliminar privada. Para acceder de forma anticipada, solicítala aquí.
Logramos que las GPU y NPU sean más fáciles que nunca de usar, ya que simplificamos el proceso en la última versión de las APIs de LiteRT. Con los últimos cambios, simplificamos en gran medida la configuración con la capacidad de especificar el backend de destino como una opción. Este es un ejemplo de cómo un desarrollador especificaría la aceleración de GPU:
// 1. Load model.
auto model = *Model::Load("mymodel.tflite");
// 2. Create a compiled model targeting GPU.
auto compiled_model = *CompiledModel::Create(model, kLiteRtHwAcceleratorGpu);Como puedes ver, la nueva API CompiledModel simplifica en gran medida la forma de especificar el modelo y los backends objetivo para la aceleración.
Si bien el uso de backends de alto rendimiento es útil, el rendimiento óptimo de tu aplicación puede sufrir los cuellos de botella de la memoria o el procesador. Con las nuevas APIs de LiteRT, puedes superar estos desafíos aprovechando la interoperabilidad de búfer incorporada, a fin de eliminar costosas operaciones de copia de memoria, y la ejecución asincrónica para utilizar procesadores inactivos en paralelo.
Con la nueva API de TensorBuffer, cuentas con una forma eficiente de manejar los datos de entrada/salida con LiteRT. Te permite utilizar directamente los datos de la memoria de hardware, como los búferes de OpenGL, como entradas o salidas para tu CompiledModel, por lo que ya no es necesario realizar costosas copias de CPU.
auto tensor_buffer = *litert::TensorBuffer::CreateFromGlBuffer(tensor_type, opengl_buffer);De esta manera, se reduce en gran medida la sobrecarga innecesaria de CPU y aumenta el rendimiento.
Además, la API TensorBuffer permite realizar conversiones sin copia entre diferentes tipos de memoria de hardware, siempre que el sistema lo admita. Imagina transformar sin esfuerzo los datos de un búfer de OpenGL a un búfer de OpenCL, o incluso a un búfer de hardware de Android, sin ninguna transferencia intermedia de CPU.
Esta técnica es clave para manejar los crecientes volúmenes de datos y el exigente rendimiento requerido por los modelos de IA cada vez más complejos. Puedes encontrar ejemplos en nuestra documentación sobre cómo usar TensorBuffer.
La ejecución asíncrona permite que diferentes partes del modelo de IA o tareas independientes se ejecuten simultáneamente en CPU, GPU y NPU, con lo que puedes aprovechar oportunamente los ciclos de cómputo disponibles de diferentes procesadores para mejorar la eficiencia y la capacidad de respuesta. Por ejemplo:
En aplicaciones que requieren interacciones de IA en tiempo real, se puede iniciar una tarea en un procesador y continuar con otras operaciones en otro. El procesamiento en paralelo minimiza la latencia y proporciona una experiencia de usuario más fluida e interactiva. Al administrar y superponer eficazmente los cálculos en varios procesadores, la ejecución asíncrona maximiza el rendimiento del sistema y garantiza que la aplicación de la IA siga siendo fluida y reactiva, incluso con cargas computacionales pesadas.
La ejecución asíncrona se implementa mediante el uso de mecanismos a nivel del sistema operativo (por ejemplo, cercas de sincronización en Android/Linux), que permiten que un acelerador de hardware se active al completar otro acelerador directamente y sin involucrar a la CPU. Así, se reducen la latencia (hasta 2 veces en nuestra demostración asíncrona de GPU) y el consumo de energía, al tiempo que la canalización es más determinista.
El siguiente es el fragmento de código que muestra la inferencia asíncrona con la entrada del búfer de OpenGL:
// Create an input TensorBuffer based on tensor_type that wraps the given OpenGL
// Buffer. env is an LiteRT environment to use existing EGL display and context.
auto tensor_buffer_from_opengl = *litert::TensorBuffer::CreateFromGlBuffer(env,
tensor_type, opengl_buffer);
// Create an input event and attach it to the input buffer. Internally, it
// creates and inserts a fence sync object into the current EGL command queue.
auto input_event = *Event::CreateManaged(env, LiteRtEventTypeEglSyncFence);
tensor_buffer_from_opengl.SetEvent(std::move(input_event));
// Create the input and output TensorBuffers…
// Run async inference
compiled_model1.RunAsync(input_buffers, output_buffers);Puedes encontrar más ejemplos de código en nuestra documentación sobre cómo aprovechar la ejecución asíncrona.
Te animamos a que pruebes las últimas capacidades de aceleración y técnicas de mejora del rendimiento para ofrecer a tus usuarios la mejor experiencia posible mientras aprovechas los últimos modelos de IA. Si necesitas ayuda para comenzar, echa un vistazo a nuestra aplicación de ejemplo, que incluye casos completamente integrados de cómo usar todas las funciones.
Puedes encontrar todas las nuevas funciones de LiteRT mencionadas en este blog en: https://github.com/google-ai-edge/LiteRT
Para ver más novedades de Google AI Edge, lee las novedades de IA generativa integrada en el dispositivo y nuestro nuevo servicio de portal de AI Edge, y accede a una amplia cobertura de comparativas y evaluaciones integradas en el dispositivo.
Explora este anuncio y todas las novedades de Google I/O 2025 en io.google a partir del 22 de mayo.
Gracias a los miembros del equipo y colaboradores por sus contribuciones para hacer posible los avances en esta versión: Advait Jain, Alan Kelly, Alexander Shaposhnikov, Andrei Kulik, Andrew Zhang, Akshat Sharma, Byungchul Kim, Chunlei Niu, Chuo-Ling Chang, Claudio Basile, Cormac Brick, David Massoud, Dillon Sharlet, Eamon Hugh, Ekaterina Ignasheva, Fengwu Yao, Frank Ban, Frank Barchard, Gerardo Carranza, Grant Jensen, Henry Wang, Ho Ko, Jae Yoo, Jiuqiang Tang, Juhyun Lee, Julius Kammerl, Khanh LeViet, Kris Tonthat, Lin Chen, Lu Wang, Luke Boyer, Marissa Ikonomidis, Mark Sherwood, Matt Kreileder, Matthias Grundmann, Misha Gutman, Pedro Gonnet, Ping Yu, Quentin Khan, Raman Sarokin, Sachin Kotwani, Steven Toribio, Suleman Shahid, Teng-Hui Zhu, Volodymyr Kysenko, Wai Hon Law, Weiyi Wang, Youchuan Hu y Yu-Hui Chen.
Nuevas funciones de Google Pay para mejorar tus flujos de pago
Llevamos la inteligencia de Gemini a las API de Google Home
Anunciamos la disponibilidad general de Llama 4 como MaaS en Vertex AI
Modelos de lenguaje pequeños en el dispositivo con multimodalidad, RAG y llamada a funciones
Google AI para desarrolladores de juegos
La API de Gemini y la Internet de las cosas