Ao longo da última década, os smartphones passaram a incorporar aceleradores cada vez mais potentes e específicos para determinadas funções, como as GPUs e, mais recentemente, as NPUs (Unidades de Processamento Neural) mais potentes. Ao acelerar seus modelos de IA utilizando GPUs e NPUs móveis, é possível alcançar uma velocidade até 25 vezes maior em comparação com a CPU, além de reduzir o consumo de energia em até 5 vezes. No entanto, atingir esses ganhos excepcionais de desempenho tem sido um grande desafio para a maioria dos desenvolvedores, pois exige lidar com APIs específicas de hardware no caso de inferência via GPU, ou com SDKs, formatos e runtimes proprietários de cada fabricante no caso da inferência via NPU.
Ouvindo o seu feedback, a equipe do Google AI Edge tem o prazer de anunciar uma série de melhorias no LiteRT, que resolvem os desafios mencionados acima e facilitam ainda mais a aceleração de IA em dispositivos móveis, com desempenho aprimorado. A nova versão traz uma API de LiteRT completamente renovada, tornando a inferência de aprendizado de máquina no dispositivo mais simples do que nunca. Também inclui os avanços mais recentes em aceleração por GPU, novo suporte a NPU, desenvolvido em parceria com a MediaTek e a Qualcomm (já disponível para acesso antecipado) e recursos avançados de inferência para maximizar o desempenho em aplicações no dispositivo. Vamos aos detalhes!
As GPUs sempre estiveram no centro da proposta de aceleração do LiteRT, oferecendo o suporte mais amplo e a melhoria de desempenho mais consistente. O MLDrift, nossa versão mais recente de aceleração de GPU, eleva ainda mais esse padrão, com desempenho mais rápido e avanços que permitem o suporte a modelos consideravelmente maiores, por meio de:
Isso resulta em um desempenho consideravelmente mais rápido do que o das CPUs, das versões anteriores do nosso delegado de GPU do TFLite e até mesmo de outros frameworks com suporte a GPU, especialmente em modelos do tipo CNN e Transformer.
Confira exemplos em nossa documentação e experimente hoje mesmo a aceleração de GPU.
As NPUs, aceleradores específicos para IA, estão se tornando cada vez mais comuns em smartphones topo de linha. Elas permitem executar modelos de IA de forma muito mais eficiente e, em muitos casos, consideravelmente mais rápida. Em nossos testes internos, quando comparadas às CPUs, essa aceleração pode ser até 25 vezes mais rápida e até 5 vezes mais eficiente em termos de consumo de energia. (Maio de 2025, com base em testes internos)
Normalmente, cada fabricante fornece seus próprios SDKs, incluindo compiladores, runtime e outras dependências, para compilar e executar modelos em seus respectivos SoCs. Esses SDKs precisam corresponder exatamente à versão específica do SoC e exigem download e instalação corretos. Agora, o LiteRT oferece uma forma unificada de desenvolver e implantar modelos em NPUs, abstraindo toda essa complexidade.
Estamos entusiasmados com a parceria com a MediaTek e a Qualcomm para permitir que desenvolvedores acelerem uma ampla variedade de modelos clássicos de aprendizado de máquina, como modelos de visão, áudio e processamento de linguagem natural, nas NPUs dessas plataformas. O suporte a novos modelos e domínios continuará a ser ampliado ao longo do próximo ano.
Este recurso está disponível em pré-lançamento privado. Para solicitar acesso antecipado, inscreva-se aqui.
Facilitamos o uso de GPUs e NPUs mais do que nunca ao simplificar o processo na versão mais recente das APIs do LiteRT. Com as atualizações mais recentes, a configuração foi consideravelmente simplificada, permitindo especificar o back-end de destino como uma opção. Como exemplo, veja como um desenvolvedor pode indicar o uso de aceleração com 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 você pode ver, a nova API CompiledModel simplifica consideravelmente a forma de especificar o modelo e os back-ends de destino para aceleração.
Embora o uso de back-ends de alto desempenho seja útil, o desempenho ideal da sua aplicação pode ser limitado por gargalos de memória ou processador. Com as novas APIs do LiteRT, é possível contornar esses desafios aproveitando a interoperabilidade de buffers integrada, que elimina operações custosas de cópia de memória, além da execução assíncrona, que permite utilizar processadores ociosos em paralelo.
A nova API TensorBuffer oferece uma maneira eficiente de lidar com os dados de entrada e saída no LiteRT. Ela permite utilizar diretamente dados armazenados na memória do hardware (por exemplo, buffers do OpenGL), como entradas ou saídas do seu CompiledModel, eliminando totalmente a necessidade de cópias custosas via CPU.
auto tensor_buffer = *litert::TensorBuffer::CreateFromGlBuffer(tensor_type, opengl_buffer);Isso reduz consideravelmente o overhead desnecessário da CPU e melhora o desempenho.
Além disso, a API TensorBuffer permite conversões diretas, sem cópias intermediárias, entre diferentes tipos de memória de hardware quando o sistema oferece suporte. Imagine transformar dados diretamente de um buffer OpenGL para um buffer OpenCL, ou até mesmo para um Android HardwareBuffer, sem qualquer transferência intermediária via CPU.
Essa técnica é fundamental para lidar com os volumes crescentes de dados e as exigências de desempenho impostas por modelos de IA cada vez mais complexos. Confira em nossa documentação exemplos de uso do TensorBuffer.
A execução assíncrona permite que diferentes partes do modelo de IA ou tarefas independentes sejam executadas de forma concorrente na CPU, na GPU e nas NPUs, aproveitando de forma oportunista os ciclos de processamento disponíveis em cada unidade para melhorar a eficiência e a capacidade de resposta. Por exemplo:
Em aplicações que exigem interações em tempo real com IA, uma tarefa pode ser iniciada em um processador e continuar com outras operações em outro. O processamento paralelo reduz a latência e proporciona uma experiência de usuário mais fluida e interativa. Ao gerenciar e sobrepor eficientemente os cálculos entre múltiplos processadores, a execução assíncrona maximiza a capacidade de processamento do sistema e garante que a aplicação de IA continue responsiva, mesmo sob cargas computacionais elevadas.
A execução assíncrona é implementada utilizando mecanismos no nível do sistema operacional (como sync fences no Android/Linux), permitindo que um acelerador de hardware seja acionado diretamente após a conclusão de outro, sem necessidade de intervenção da CPU. Isso reduz a latência (em até 2 vezes, como podemos ver em nossa demonstração assíncrona com GPU), diminui o consumo de energia e torna o pipeline mais determinístico.
Confira abaixo o snippet do código que demonstra a inferência assíncrona com entrada via buffer 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);Mais exemplos de código estão disponíveis em nossa documentação sobre como aproveitar a execução assíncrona.
Nossa sugestão é que você experimente os recursos mais recentes de aceleração e as técnicas de otimização de desempenho para oferecer aos seus usuários a melhor experiência possível com os modelos de IA mais avançados. Para ajudar você a começar, confira nosso aplicativo de exemplo, com demonstrações totalmente integradas de como usar todos os recursos.
Todos os novos recursos do LiteRT mencionados neste blog estão disponíveis em: https://github.com/google-ai-edge/LiteRT
Para mais novidades sobre o Google AI Edge, confira nossas atualizações em GenAI no dispositivo e nosso novo serviço AI Edge Portal, com ampla cobertura de benchmarks no dispositivo e evals.
Explore este anúncio e todas as atualizações do Google I/O 2025 no io.google a partir de 22 de maio.
Agradecemos aos membros da equipe e aos colaboradores pelas contribuições que tornaram possíveis os avanços desta versão: 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, Yu-Hui Chen
Anunciamos a disponibilidade geral do Llama 4 MaaS na Vertex AI
Levando a inteligência do Gemini para as APIs do Google Home
Modelos de linguagem pequenos no dispositivo com multimodalidade, RAG e chamada de função
IA do Google para desenvolvedores de jogos
Novos recursos do Google Pay para melhorar seus fluxos de pagamento
A API Gemini e a Internet das Coisas