Resource-Efficient Iterative LLM-Based NAS with Feedback Memory

Este artigo propõe um pipeline de busca de arquitetura neural (NAS) eficiente em recursos que utiliza modelos de linguagem grandes (LLMs) em um ciclo fechado com memória de feedback histórica para iterativamente gerar e refinar arquiteturas de redes neurais convolucionais para classificação de imagens em uma única GPU de consumo, alcançando melhorias significativas de precisão sem necessidade de fine-tuning ou infraestrutura em nuvem.

O essencial

Imagine que você quer construir o carro mais eficiente do mundo, mas não tem um engenheiro chefe, apenas um assistente de escritório muito inteligente (mas um pouco esquecido) e uma oficina pequena.

O artigo que você leu descreve exatamente como eles ensinaram esse "assistente" (uma Inteligência Artificial chamada LLM) a projetar redes neurais (o "cérebro" dos computadores) sozinho, gastando muito pouco dinheiro e energia.

Aqui está a explicação simplificada, usando analogias do dia a dia:

1. O Problema: Projetar Carros é Caro

Normalmente, para criar a melhor arquitetura de rede neural, os cientistas usam métodos que exigem supercomputadores gigantescos e meses de trabalho. É como tentar projetar um carro novo testando milhões de modelos em pistas de corrida reais. É caro demais para a maioria das pessoas.

2. A Solução: O Assistente que Aprende com os Erros

Os autores criaram um sistema onde uma Inteligência Artificial (o "assistente") tenta escrever o código de um novo "cérebro" de computador.

• A Oficina (GPU): Eles usaram apenas uma placa de vídeo comum (uma RTX 4090), que você pode comprar em uma loja de eletrônicos. É como fazer engenharia em uma garagem, não numa fábrica gigante.
• O Teste Rápido: Em vez de treinar o carro por anos, eles o dirigem apenas por uma volta rápida (uma "época" de treino) para ver se ele funciona. Se o carro quebra na primeira volta, eles sabem que o projeto estava ruim.

3. O Segredo: A "Memória de Feedback" (O Caderno de Anotações)

Aqui está a parte mais genial. Muitas IAs tentam algo, falham e esquecem tudo, começando do zero na próxima tentativa.

• A Analogia do Caderno: Imagine que o assistente tem um caderno de anotações com apenas as últimas 5 tentativas.
• O que está no caderno? Não é apenas "funcionou" ou "não funcionou". É um registro detalhado:
  1. O Problema: "O motor superaqueceu porque o radiador era pequeno."
  2. A Sugestão: "Vamos aumentar o tamanho do radiador."
  3. O Resultado: "O carro quebrou de novo, mas agora o motor não superaqueceu."
• A Regra de Ouro: Eles usam uma "janela deslizante". O assistente olha apenas para as últimas 5 tentativas para decidir o próximo passo. Isso evita que o caderno fique gigante e confuso (como tentar lembrar de tudo o que aconteceu nos últimos 10 anos), mantendo o foco no que acabou de acontecer.

4. A Dupla de Especialistas

Para não sobrecarregar o cérebro do assistente, eles dividiram o trabalho em duas pessoas (dois modelos de IA):

1. O Arquiteto (Code Generator): É o cara que desenha o carro e escreve o código. Ele foca apenas em criar algo que funcione.
2. O Mecânico Sênior (Prompt Improver): É o cara que analisa o caderno de anotações, olha para o carro quebrado, entende por que falhou e dá instruções claras para o Arquiteto sobre como consertar.

Isso é como ter um desenhista e um engenheiro experiente trabalhando juntos, em vez de uma única pessoa tentando fazer tudo de uma vez.

5. O Resultado: Melhoria Contínua

O sistema funciona em um ciclo:

1. O Arquiteto cria um projeto.
2. O Mecânico testa (na garagem).
3. Se falhar, o Mecânico escreve no caderno o que deu errado e como tentar de novo.
4. O Arquiteto lê o caderno e cria uma versão melhorada.

O que aconteceu na prática?
Eles testaram isso em três "pistas" diferentes (conjuntos de dados de imagens).

• No começo, os projetos eram ruins (como um carro de papelão).
• Depois de 2.000 tentativas (que levaram apenas 18 horas de trabalho na placa de vídeo), os projetos ficaram incríveis.
• Um dos assistentes (DeepSeek-Coder) começou com 28% de eficiência e chegou a 69%. Outro (Qwen2.5) começou com 50% e chegou a 71,5%.

Por que isso é importante?

• Barato: Não precisa de supercomputadores de nuvem. Qualquer pesquisador com uma placa de vídeo boa pode fazer isso.
• Inteligente: A IA aprende com os fracassos, não apenas com os sucessos. Ela entende por que algo deu errado.
• Eficiente: Como o assistente compartilha a memória da placa de vídeo com o treinamento do modelo, ele "aprende" a criar projetos que são leves e eficientes, perfeitos para funcionar em celulares ou dispositivos pequenos.

Resumo da Ópera:
Os autores mostraram que, se você der a uma IA um caderno de anotações simples com os últimos erros e acertos, e deixar ela trabalhar em uma oficina pequena, ela consegue projetar "cérebros" de computador cada vez melhores, sem precisar de milhões de dólares em infraestrutura. É como transformar um estagiário em um engenheiro-chefe através da prática e da reflexão constante.

Resumo técnico

Título: NAS Iterativo Baseado em LLMs com Memória de Feedback Eficiente em Recursos

Autores: Xiaojie Gu, Dmitry Ignatov, Radu Timofte (Universidade de Würzburg, Alemanha)

---

1. O Problema

A Busca de Arquitetura Neural (NAS) automatiza o design de redes neurais, mas os métodos convencionais (como aprendizado por reforço ou algoritmos evolutivos) exigem recursos computacionais massivos (milhares de dias-GPU). Métodos mais recentes baseados em Grandes Modelos de Linguagem (LLMs) tentam gerar código de rede neural diretamente, mas frequentemente operam em espaços de busca restritos (baseados em células pré-definidas) ou tratam a geração como um processo de "um único tiro" (single-shot), descartando o feedback de falhas e não permitindo melhoria iterativa.

O objetivo deste trabalho é criar um pipeline de NAS que seja:

• Eficiente em recursos: Executável em uma única GPU de consumo (ex: RTX 4090).
• Sem ajuste fino (fine-tuning): Utilizando LLMs pré-treinados e "congelados" (≤7B parâmetros).
• Iterativo e adaptativo: Capaz de aprender com seus próprios erros e sucessos passados em um espaço de código aberto e não restrito.

---

2. Metodologia

Os autores propõem um pipeline em laço fechado composto por três módulos principais, operando em um espaço de código Python/PyTorch não restrito:

A. Arquitetura do Pipeline

1. Gerador de Código (Code Generator): Um LLM instruído gera a implementação completa de uma arquitetura de rede neural (classe nn.Module do PyTorch) baseada em um prompt que inclui a melhor arquitetura atual e sugestões de melhoria.
2. Avaliador (Evaluator):
   • Validação Rápida: Verifica se o código é executável e se a saída tem a forma correta.
   • Treinamento Proxy: Treina o modelo por apenas uma época (one-epoch) no conjunto de dados (CIFAR-10, CIFAR-100 ou ImageNette) usando SGD. A acurácia obtida serve como sinal de ranking rápido para guiar a busca, evitando o custo de treinamento completo.
3. Melhorador de Prompt (Prompt Improver): Analisa os resultados (acurácia ou mensagem de erro) e gera sugestões estruturadas para a próxima iteração.

B. Memória de Feedback Histórica (O Núcleo da Inovação)

Diferente de métodos anteriores que descartam trajetórias de falha, este sistema mantém uma memória deslizante (sliding window) dos últimos K=5 tentativas de melhoria.

• Estrutura de Dados: Cada entrada na memória é um triplo diagnóstico estruturado:
  1. Problema Identificado: A falha ou deficiência na arquitetura anterior.
  2. Sugestão de Modificação: O que foi proposto para corrigir.
  3. Resultado: Se a mudança resultou em ganho de acurácia ou em um novo erro.
• Propriedade de Markov: A decisão de melhoria no passo $t$ depende apenas da melhor arquitetura atual e da janela limitada de histórico recente, evitando o estouro de contexto (context overflow) e mantendo o tamanho do prompt constante.
• Tratamento de Falhas: Falhas de execução de código são tratadas como sinais de aprendizado de primeira classe, permitindo que o LLM aprenda a evitar padrões de erro estruturais.

C. Especialização Dual de LLMs

Para reduzir a carga cognitiva por chamada e otimizar o uso de VRAM compartilhada:

• Um LLM atua apenas como Gerador de Código.
• Outro LLM atua como Melhorador de Prompt (raciocínio diagnóstico).
• Ambos compartilham a mesma GPU com o treinamento da arquitetura, o que implicitamente favorece a descoberta de modelos compactos e eficientes para hardware limitado.

---

3. Contribuições Principais

1. Pipeline Iterativo em Laço Fechado: Um sistema que descobre arquiteturas progressivamente melhores através de geração de código, avaliação e refinamento de prompts, sem necessidade de fine-tuning do LLM.
2. Mecanismo de Memória de Feedback Histórica: Uma janela deslizante de tentativas passadas que permite ao LLM mitigar a repetição de estratégias falhas e construir sobre sucessos, tratando falhas de código como dados de treinamento.
3. Eficiência e Acessibilidade: Demonstração empírica de que LLMs pequenos (≤7B parâmetros) e congelados podem realizar NAS eficaz em uma única GPU de consumo (RTX 4090), completando 2000 iterações em ~18 horas de GPU.
4. Espaço de Busca Aberto: Ao contrário de métodos baseados em células fixas, o sistema opera no espaço de código executável, permitindo a invenção de padrões arquitetônicos verdadeiramente novos.

---

4. Resultados Experimentais

Os experimentos foram conduzidos em CIFAR-10, CIFAR-100 e ImageNette com três LLMs diferentes: DeepSeek-Coder-6.7B, Qwen2.5-7B e GLM-5.

• Desempenho Geral: Todos os modelos mostraram tendências de melhoria estatisticamente significativas (correlação de Spearman $\rho$ positiva) em comparação com a geração de "um único tiro" (baseline inicial).
• DeepSeek-Coder-6.7B:
  • CIFAR-10: Melhorou de 28.2% para 69.2% (ganho absoluto de +41.0%).
  • Alta taxa de sucesso (76%) e estabilidade.
• Qwen2.5-7B:
  • CIFAR-10: Alcançou a maior acurácia de pico (71.5%), superando o DeepSeek, apesar de uma taxa de sucesso menor (18.8%) devido a uma estratégia de exploração mais arriscada e ambiciosa.
  • Melhorou de 50.0% para 71.5%.
• GLM-5:
  • Demonstrou a maior taxa de sucesso (91%) e consistência, embora tenha rodado apenas 100 iterações.
  • CIFAR-10: Melhorou de 43.2% para 62.0%.
• Estudo de Ablação: A remoção da memória de feedback histórica ou da arquitetura de referência fez com que a busca estagnasse ou degradasse, confirmando que o modelamento causal das falhas passadas é crítico para a melhoria iterativa.

---

5. Significado e Impacto

Este trabalho estabelece um novo paradigma para a Busca de Arquitetura Neural (NAS):

• Democratização do NAS: Torna a busca de arquiteturas acessível para pesquisadores com orçamentos limitados e sem acesso a infraestrutura em nuvem massiva.
• Hardware-Aware: Ao operar em um ambiente onde o LLM e o treinamento compartilham VRAM, o sistema descobre implicitamente modelos compactos e eficientes, ideais para dispositivos de borda (edge devices).
• Aprendizado com Falhas: Demonstra que, em tarefas complexas de geração de código, as falhas são tão informativas quanto os sucessos. A capacidade de um LLM pequeno de aprender com um histórico estruturado de erros é um avanço significativo sobre métodos que apenas retêm "elites" (melhores soluções).
• Reprodutibilidade: O pipeline é totalmente reproduzível, sem fine-tuning de modelos, e o código está disponível publicamente.

Em resumo, o artigo prova que, com o design correto de feedback e memória, LLMs pequenos e congelados podem atuar como agentes eficazes de busca de arquitetura, superando a geração estática e oferecendo uma alternativa viável e econômica aos métodos tradicionais de NAS.