💻 computer science

Before Parc Fermé: RL-Time Pruning for Efficient Embodied LLMs in Autonomous Driving

O artigo propõe o "Before Parc Fermé" (BPF), uma nova estratégia de poda que realiza compressão iterativa de modelos durante o Aprendizado por Reforço para otimizar controladores de LLM incorporados para direção autônoma, alcançando um desempenho-memória superior e até 27% de maior vazão de decodificação em comparação com a poda pós-treinamento ou a seleção de modelos densos menores.

Autores originais: Luca Benfenati, Ali Azimi, Matteo Risso, Fabio Carapellese, Daniele Jahier Pagliari, Alessio Burrello

Publicado 2026-06-01

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Luca Benfenati, Ali Azimi, Matteo Risso, Fabio Carapellese, Daniele Jahier Pagliari, Alessio Burrello

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você tem um motorista robô brilhante e superinteligente chamado RobotxR1. Este motorista é alimentado por um "cérebro" chamado Modelo de Linguagem de Grande Escala (LLM). Pense neste cérebro como um engenheiro de Fórmula 1 de classe mundial que leu todos os livros sobre direção, conhece a física de cada carro e consegue entender qualquer instrução que você lhe dê em linguagem comum.

No entanto, há um problema: este engenheiro é grande demais. Ele carrega uma mochila enorme cheia de livros (memória) e demora muito para pensar antes de dar instruções (latência). Se você tentar colocar essa mochila pesada em um carro de corrida pequeno e rápido (o robô real), o carro se tornará lento demais para correr em tempo real. É como tentar correr uma maratona carregando um piano.

O Problema: Quando Encolher o Cérebro?

Para tornar o robô mais rápido, os engenheiros geralmente tentam "podar" o cérebro. A poda é como editar um manuscrito: você corta frases, parágrafos ou capítulos inteiros que não são necessários, tornando o livro mais curto e leve.

Mas aqui está a parte complicada: Quando você faz essa edição?

Depois que a corrida termina? (Pós-treinamento): Você treina o cérebro completo, deixa que ele aprenda tudo e, depois, tenta diminuí-lo. O problema é que o cérebro já memorizou as partes pesadas e "erradas", e cortá-las pode quebrar sua capacidade de dirigir.
Antes do treinamento começar? (Pré-treinamento): Você corta o cérebro primeiro e depois o treina. O problema é que você ainda não sabe quais partes são realmente inúteis até que o cérebro tenha tentado dirigir.

A Solução: "Before Parc Fermé" (BPF)

Os autores deste artigo propõem uma nova estratégia chamada Before Parc Fermé (BPF).

Para entender o nome, imagine a Fórmula 1. Antes de uma corrida, os carros entram em um "Parc Fermé" (uma garagem trancada) onde são selados. Ninguém tem permissão para tocar ou modificar os carros depois disso. O carro que entra na garagem é o carro que corre.

No mundo do treinamento de IA, o "Parc Fermé" é o momento em que o treinamento é finalizado e o modelo é travado no lugar. Os autores argumentam que você não deve esperar até que o modelo esteja trancado na garagem para começar a editá-lo. Em vez disso, você deve começar a editá-lo enquanto o carro ainda está sendo ajustado na pista.

Eles chamam isso de RL-Time Pruning (Poda em Tempo de Aprendizado por Reforço).

Como Funciona: As Duas Variantes

O artigo testa duas maneiras de fazer essa edição "na pista":

BPF-RL (A Edição Iterativa): Imagine que o motorista robô está aprendendo a dirigir em uma pista de corrida. A cada poucas voltas, os engenheiros intervêm, olham as notas do motorista e dizem: "Você não precisa deste parágrafo específico sobre a pressão dos pneus; vamos cortá-lo". Então, o motorista continua as próximas voltas com as notas mais leves, aprendendo a se adaptar à falta daquela informação imediatamente. Eles repetem esse processo até que as notas tenham o tamanho ideal.
BPF-SFT/RL (A Edição em Dois Estágios): Primeiro, eles fazem uma edição leve enquanto o motorista aprende as regras básicas (Ajuste Fino Supervisionado - SFT). Depois, quando o motorista começa a correr em simulações em tempo real (Aprendizado por Reforço - RL), eles fazem a edição pesada, cortando mais excessos enquanto o motorista está reagindo ativamente à pista.

Os Resultados: Mais Leve, Mais Rápido e Mais Inteligente

Os pesquisadores testaram isso em uma configuração de direção autônoma real com duas partes:

DecisionxR1: O "Cérebro" que decide o que fazer.
MPCxR1: As "Mãos" que realmente dirigem o carro.

Aqui está o que eles descobriram:

Melhores Trocas (Trade-offs): Se você apenas escolhesse um cérebro naturalmente menor e mais fraco (um modelo de 1.5B) em vez de um grande, o carro dirigiria pior. Mas, se eles pegassem o cérebro grande e usassem o método BPF-SFT/RL para encolhê-lo, o "mini-cérebro" resultante foi 1,69 vezes melhor em equilibrar tamanho e desempenho do que simplesmente escolher o cére-braço pequeno desde o início. Ele manteve a "inteligência" do modelo grande, mas com o "peso" do modelo pequeno.
Velocidade no Mundo Real: Quando colocaram esses modelos em um carro robô real equipado com um computador Jetson AGX Orin, os modelos podados foram 27% mais rápidos na geração de instruções.
A Armadilha da Verbosidade: Eles descobriram uma reviravolta surpreendente. Às vezes, tornar um modelo menor não tornava todo o sistema mais rápido. Por quê? Porque o modelo menor às vezes começava a escrever frases mais longas para explicar suas decisões. É como um corredor mais leve que começa a falar sozinho o tempo todo, atrasando a si mesmo. Isso os ensinou que você não pode olhar apenas para o tamanho do modelo; você tem que observar todo o fluxo de trabalho.

A Conclusão

O artigo afirma que, para robôs que precisam pensar e agir em tempo real (como carros autônomos), você não deve esperar o treinamento terminar para tornar a IA menor. Em vez disso, você deve encolhê-la enquanto ela está aprendendo, permitindo que o robô se adapte à sua própria "cirurgia" em tempo real.

Esta abordagem "Before Parc Fermé" cria um motorista robô que é leve o suficiente para ser rápido, mas inteligente o suficiente para lidar com tarefas de direção complexas, superando tanto os modelos originais pesados quanto os modelos naturalmente pequenos.

Resumo Técnico: Before Parc Fermé (BPF) para LLMs Incorporados Eficientes

Declaração do Problema

Modelos de Linguagem de Grande Escala (LLMs) incorporados estão sendo cada vez mais implantados em pipelines de controle robótico, como a condução autônoma, para interpretar comandos de linguagem natural e adaptar parâmetros de controle. No entanto, esses modelos enfrentam desafios significários de implantação devido ao overhead de memória e à latência de geração, o que dificulta a execução em tempo real em hardware restrito (ex: Jetson AGX Orin).

Embora a poda (pruning) ofereça uma solução para reduzir o tamanho do modelo e o custo computacional, o momento ideal para a poda dentro do pipeline de treinamento específico dos LLMs incorporados permanece incerto. Esses sistemas normalmente passam por Ajuste Fino Supervisionado (SFT) seguido por Aprendizado por Reforço (RL) com feedback de malha fechada (closed-loop).

Poda pós-treinamento (após SFT e RL) comprime o modelo final, mas não oferece aos pesos restantes nenhuma oportunidade de se adaptarem às estruturas removidas.
Poda pré-RL (após SFT, antes do RL) remove estruturas antes que o modelo tenha aprendido os comportamentos específicos de malha fechada necessários para a tarefa, potencialmente descartando componentes críticos.
Seleção direta de modelos densos menores (ex: 1.5B vs. 3B parâmetros) frequentemente resulta em um compromisso subótimo entre o tamanho do modelo e a adaptabilidade de controle, já que modelos maiores oferecem capacidades de raciocínio significativamente melhores que os modelos menores não conseguem igualar.

O desafio central é determinar quando realizar a poda para maximizar a retenção das capacidades de raciocínio e controle, minimizando o uso de recursos.

Metodologia: Before Parc Fermé (BPF)

Os autores propõem o Before Parc Fermé (BPF), uma família de estratégias de poda que integra a compressão diretamente ao processo de treinamento, especificamente acoplando a poda com a fase de RL. O nome "Parc Fermé" refere-se ao período da Fórmula 1 onde os carros são bloqueados para modificações; aqui, ele denota metaforicamente a etapa de pós-treinamento onde a arquitetura é fixada. O BPF comprime o modelo antes desse bloqueio, enquanto ele ainda está sendo otimizado para o comportamento de malha fechada.

O framework utiliza o LLM-Pruner com uma pontuação de importância baseada em Taylor para realizar a poda estruturada. O artigo avalia duas variantes principais de BPF contra diversos baselines:

BPF-RL (Poda Iterativa durante o RL):
- O modelo passa por um SFT completo sem poda.
- Durante a fase de RL, a poda é realizada iterativamente em intervalos predefinidos ( $\Delta t_{RL}$ ).
- Em cada intervalo, os grupos de parâmetros com as menores pontuações são removidos para atingir incrementalmente a proporção de poda alvo.
- Isso permite que os pesos restantes se adaptem às estruturas removidas enquanto ainda recebem o feedback de tarefa de malha fechada.
BPF-SFT/RL (Poda Dividida):
- Estágio SFT: Uma compressão parcial é aplicada após uma fase inicial de aquecimento (warm-up), removendo uma parte do modelo ( $\rho_{SFT}$ ).
- Estágio RL: A compressão restante ( $\rho - \rho_{SFT}$ ) é alcançada iterativamente durante o RL, de forma semelhante ao BPF-RL.
- Esta abordagem aproveita o SFT para remover estruturas claramente redundantes com base em prompts de tarefa, enquanto conta com o feedback do RL para refinar a compressão com base no desempenho de malha fechada.

Baselines para Comparação:

Poda Pós-Treinamento (PTP): Poda aplicada após o SFT e RL completos.
PTP + Recuperação: PTP seguido de etapas adicionais de RL para recuperar o desempenho.
Poda no estágio de SFT: Etapa única de compressão durante o SFT antes do RL.
Modelos Densos Menores: Uso direto de arquiteturas menores (ex: Qwen2.5-1.5B) da mesma família de modelos.

Principais Contribuições

Introdução do BPF: Uma nova receita de poda que acopla RL com poda estruturada para controladores de LLM incorporados, demonstrando que o tempo de compressão é uma escolha de design crítica.
Compromisso entre Desempenho e Eficiência: Os autores mostram que as estratégias BPF, particularmente o BPF-SFT/RL, alcançam compromissos superiores entre o tamanho do modelo e o desempenho da tarefa em comparação com a poda pós-treinamento ou simplesmente selecionar modelos densos menores.
Avaliação de Ponta a Ponta: O trabalho enfatiza que a poda de LLMs incorporados deve ser avaliada de forma holística. Mudanças na contagem de tokens gerados devido à poda podem alterar a latência e o comportamento downstream, necessitando de uma avaliação de pipeline completo em vez de apenas análise de métricas isoladas.

Resultados Experimentais

Os métodos foram avaliados no RobotxR1, um pipeline de condução autônoma composto por dois módulos:

DecisionxR1: Avalia se o comportamento atual corresponde às instruções do usuário.
MPCxR1: Adapta os parâmetros de Controle Preditivo de Modelo (MPC).

1. Desempenho da Tarefa e Adaptabilidade

Superioridade do BPF-SFT/RL: No módulo DecisionxR1 (3B parâmetros), o BPF-SFT/RL alcançou o melhor compromisso. Com uma proporção de poda de 45%, ele melhorou a adaptabilidade de controle em 11,4% em relação ao PTP+R e em 17% em relação ao PTP.
Comparação com Modelos Menores: Ao comprimir o modelo de 3B, o BPF-SFT/RL alcançou um compromisso tamanho–desempenho de ponta a ponta 1,69× melhor do que a seleção direta do modelo denso de 1.5B. Especificamente, o BPF-SFT/RL reduziu os parâmetros em 0,91B com uma perda de 7,61% na adaptabilidade, enquanto a mudança para o modelo de 1.5B reduziu os parâmetros em 1,55B, mas incorreu em uma perda de 21,7%.
Poda Conjunta: A poda conjunta de ambos os módulos revelou que o MPCxR1 é mais sensível à poda do que o DecisionxR1. Uma poda moderada do MPCxR1 (ex: 10%) combinada com uma poda maior do DecisionxR1 (ex: 30-45%) produziu os melhores resultados de Pareto-otimização.

2. Implantação Embarcada (Jetson AGX Orin)

Throughput e Memória: Os modelos podados mostraram melhorias significativas no throughput de decodificação e na pegada de memória. Por exemplo, podar o DecisionxR1 em 45% reduziu a memória de 2,07GB para 1,51GB e aumentou o throughput de 45 para 58 tokens/seg.
Nuance de Latência: O artigo observa que reduzir parâmetros não reduz automaticamente a latência de ponta a ponta. A poda pode aumentar a verbosidade dos tokens gerados (ex: MPCxR1 gerando mais texto), o que pode anular os ganhos computacionais. A configuração ideal para latência (20% de poda no DecisionxR1, 0% no MPCxR1) reduziu a latência em 19,5% com apenas uma queda de 0,8% no desempenho da tarefa.

Significância e Alegações

O artigo afirma que o BPF-SFT/RL representa a estratégia mais eficaz para implantar LLMs incorporados em condução autônoma. Sua principal significância reside em demonstrar que:

O Tempo Importa: Realizar a poda durante a fase de RL, enquanto o modelo ainda está se adaptando ao feedback de malha fechada, preserva mais capacidade de raciocínio e controle do que realizar a poda após a conclusão do treinamento.
Eficiência vs. Capacidade: É possível comprimir modelos maiores e mais capazes significativamente (ex: 45%) mantendo níveis de desempenho próximos ao modelo grande original do que o que é alcançável simplesmente mudando para um modelo denso menor.
Avaliação Holística: A compressão eficaz para sistemas robóticos requer a avaliação de todo o pipeline de controle, pois as mudanças induzidas pela poda na extensão da geração de tokens podem impactar criticamente a latência downstream e o comportamento do sistema.

Os autores reconhecem limitações, incluindo a falta de treinamento conjunto para módulos podados (o MPCxR1 foi treinado nos outputs do DecisionxR1 não podado), o uso de intervalos de poda fixos e a ausência de poda consciente de quantização, que atualmente exige preenchimento (padding) para alinhar dimensões para runtimes de inferência.