Towards Cold-Start Drafting and Continual Refining: A Value-Driven Memory Approach with Application to NPU Kernel Synthesis

O artigo apresenta o EvoKernel, um framework de agentes autoevolutivos que utiliza uma abordagem de memória orientada a valor para superar a escassez de dados na síntese de kernels para NPUs, melhorando drasticamente a precisão e o desempenho através de rascunhos iniciais e refinamento contínuo sem necessidade de ajuste fino custoso.

O essencial

Imagine que você é um mestre cozinheiro (um Modelo de Inteligência Artificial) famoso por fazer pratos incríveis na cozinha da sua cidade natal (o mundo CUDA, onde há milhões de receitas e ingredientes). Você é um gênio culinário.

Agora, imagine que você é enviado para uma ilha remota e desconhecida (o mundo NPU, uma arquitetura de hardware específica e nova). O problema? Na ilha, não há livros de receitas, não há ingredientes comuns e ninguém sabe cozinhar como você. Se você tentar cozinhar usando apenas o que sabe da sua cidade natal, vai falhar miseravelmente. Isso é o que os cientistas chamam de "Cold Start" (Início Frio): tentar fazer algo complexo sem dados ou exemplos prévios.

O papel que você leu apresenta uma solução genial chamada EvoKernel. Vamos entender como ele funciona com uma analogia simples:

1. O Problema: O "Muro de Dados"

Na ilha (NPU), os melhores chefs do mundo (os modelos de IA mais avançados) tentam cozinhar, mas falham. Eles tentam 100 vezes e só acertam 11 pratos. O resto queima ou fica sem sal.

• Por que? Porque eles estão tentando memorizar receitas antigas que não funcionam na nova cozinha.
• O erro comum: Tentar reescrever todo o cérebro do chef (ajustar o modelo) para aprender a nova cozinha. Isso é caro, demorado e difícil de conseguir os ingredientes (dados) necessários.

2. A Solução: O "Caderno de Anotações Mágico" (EvoKernel)

Em vez de mudar o cérebro do chef, os autores criaram um sistema de memória inteligente chamado EvoKernel. Pense nele como um caderno de anotações vivo que o chef carrega consigo.

O processo funciona em duas fases principais, como se fosse uma jornada de aprendizado:

Fase 1: O Rascunho (Drafting) – "Tentar e Errar"

O chef pega um ingrediente novo e tenta fazer o prato.

• Ele olha no caderno: "Já tentei algo parecido antes? O que funcionou?"
• Ele escreve uma receita (o código).
• Ele testa na cozinha. Se queimar, o caderno registra: "Isso não funcionou, não use isso de novo."
• Se o prato ficar pronto (mesmo que feio), o caderno registra: "Isso funcionou! Guarde isso como base."
• O Segredo: O caderno não guarda apenas o que foi tentado, ele aprende o que vale a pena tentar. Ele usa uma "bússola de valor" (Value-Driven) para decidir qual receita antiga ajuda mais agora.

Fase 2: O Refinamento (Refining) – "Tornar o prato perfeito"

Agora que o prato está pronto e comestível, o chef quer que ele seja mais rápido e mais saboroso.

• Ele olha no caderno: "Qual foi a melhor maneira de cortar esse legume que encontrei antes?"
• Ele tenta pequenas mudanças para acelerar o cozimento.
• A cada tentativa, o caderno atualiza sua "bússola": "Ah, essa técnica de corte reduziu o tempo em 30%? Anotei isso como algo valioso!"
• Com o tempo, o prato que levava 10 minutos passa a levar 3 minutos.

3. A Grande Magia: O Caderno que Aprende Sozinho

O que torna o EvoKernel especial é que ele não precisa de um professor humano ensinando o chef a cada passo.

• Memória Compartilhada: Se o chef aprendeu a cortar uma cenoura rápido em um prato, ele usa esse conhecimento para cortar um tomate em outro prato. O caderno conecta experiências diferentes.
• Aprendizado de Valor: O sistema não guarda tudo. Ele aprende a filtrar o que é "lixo" e o que é "ouro". Ele sabe que, no início, o importante é apenas fazer o prato sair (corretude). Depois, o importante é fazer rápido (velocidade). O caderno muda de foco sozinho.

Os Resultados (A Prova de Que Funciona)

Os cientistas testaram isso em uma bancada de testes chamada KernelBench (adaptada para a ilha NPU).

• Antes: Os melhores chefs (modelos de IA) acertavam apenas 11% dos pratos.
• Com EvoKernel: Eles acertaram 83% dos pratos!
• Velocidade: Além de acertar, os pratos ficaram, em média, 3,6 vezes mais rápidos do que a primeira tentativa.

Resumo em uma Frase

O EvoKernel é como dar a um chef novato em uma cozinha desconhecida um caderno de anotações inteligente que aprende sozinho com cada erro e acerto, compartilhando lições entre diferentes pratos, permitindo que ele se torne um mestre mesmo sem ter um livro de receitas prévio.

Isso é revolucionário porque permite que a Inteligência Artificial domine hardwares novos e específicos (como chips de IA chineses ou especializados) sem precisar de milhões de dados de treinamento, apenas com "pouca memória" e muita persistência.

Resumo técnico

Resumo Técnico: EvoKernel

1. O Problema: A "Parede de Dados" em Arquiteturas Específicas de Domínio (DSAs)

O artigo aborda um desafio crítico na implantação de Grandes Modelos de Linguagem (LLMs) em domínios de programação escassos em dados, especificamente a síntese de kernels para aceleradores de hardware emergentes, como NPUs (Unidades de Processamento Neural), TPUs e chips neuromórficos.

• O Dilema do "Cold-Start" (Arranque Frio): Diferente do ecossistema maduro da NVIDIA (CUDA), que possui décadas de repositórios de código para treinamento, plataformas emergentes como a Ascend C (Huawei) sofrem de uma "Parede de Dados". Existem poucos exemplos públicos, documentação esotérica e feedback de compiladores opaco.
• Falha de Generalização: Modelos de ponta (como GPT-5.2, DeepSeek-V3.2) que alcançam alta precisão em CUDA sofrem um colapso catastrófico quando aplicados a DSLs (Linguagens de Domínio Específico) como Ascend C. Por exemplo, a precisão de GPT-5.2 cai de 92% em tarefas CUDA para apenas 14% em tarefas Ascend C.
• Limitações das Abordagens Atuais:
  • Fine-tuning Supervisionado (SFT): Exige milhares de exemplos rotulados por especialista, o que é proibitivamente caro e lento em ecossistemas novos.
  • RL Paramétrico: Requer muitas amostras online e corre o risco de "esquecimento catastrófico" das capacidades gerais do modelo.
  • RAG Tradicional: Falha quando o banco de dados de referência é esparsamente populado, pois a similaridade semântica superficial não garante a eficácia do código gerado.

2. Metodologia: EvoKernel

Os autores propõem o EvoKernel, um framework de agente auto-evolutivo que trata a síntese de kernels como uma tarefa de Aprendizado por Reforço (RL) baseada em Memória, sem atualizar os pesos do modelo base (LLM).

O processo é formulado como um Processo de Decisão de Markov baseado em Memória (M-MDP), dividido em duas fases principais:

A. Arquitetura de Memória e Recuperação Orientada a Valor
O núcleo da inovação é um mecanismo de recuperação que não depende apenas de similaridade semântica, mas aprende Q-valores específicos para cada estágio para avaliar a utilidade de experiências passadas.

• Memória Heterogênea: Armazena templates de API, experiências de sucesso/fracasso, traços de geração e melhores práticas.
• Recuperação Orientada a Valor (Value-Driven Retrieval): O agente aprende a selecionar o contexto ideal baseado no objetivo atual:
  • Estágio de Drafting (Rascunho): O Q-valor ($Q_1$) estima a probabilidade de um item de memória contribuir para a correção funcional (compilação e execução correta).
  • Estágio de Refinamento (Otimização): O Q-valor ($Q_2$) estima a contribuição para a redução de latência.
• Atualização Unificada: Utiliza uma regra de atualização Monte-Carlo para ajustar os Q-valores com base no feedback do verificador, permitindo que o agente aprenda dinamicamente sem re-treinar o LLM.

B. Pipeline de Duas Etapas

1. Drafting Frio (Cold-Start Drafting): O objetivo é encontrar um kernel funcional inicial. O agente usa uma política $\epsilon$-greedy sobre $Q_1$ para recuperar contextos que maximizam a chance de sucesso na compilação e correção. A recompensa é binária (+1 para viável, -1 para falha).
2. Refinamento Contínuo (Continual Refining): Uma vez que um kernel viável é encontrado, o foco muda para otimização de desempenho. O agente seleciona pontos de partida e recupera traços de otimização usando $Q_2$. A recompensa é relativa à latência atual (ex: tanh do log da redução de latência), normalizada via PopArt para estabilidade.

C. Verificação Multi-Gate
O sistema emprega um verificador robusto com três portas de segurança:

1. Anti-Hacking: Garante que a lógica computacional esteja realmente no kernel Ascend C e não "trapaceando" usando chamadas PyTorch de alto nível ou lógica no código de ligação (glue code).
2. Compilação: Verifica se o código compila no toolchain específico.
3. Correção: Compara a saída do kernel com uma referência PyTorch.

3. Contribuições Principais

1. Pipeline Unificado de Drafting e Refinamento: Um framework de duas etapas sobre uma memória compartilhada que transita de "viabilidade" para "otimização de latência".
2. Recuperação Evolutiva Orientada a Valor: Introdução de um mecanismo que aprende Q-valores específicos para o estágio, quantificando a utilidade da memória histórica sem atualizar os pesos do modelo.
3. Validação Empírica em Cenário de Cold-Start: Demonstração de que a acumulação de experiência guiada por valor permite que modelos de propósito geral dominem a síntese de kernels em ecossistemas de hardware escassos em dados.

4. Resultados Experimentais

Os experimentos foram conduzidos no KernelBench NPU (Ascend C), com extensões para conjuntos de operadores de Atenção e kernels mHC (DeepSeek).

• Melhoria de Precisão (Correção): O EvoKernel aumentou a taxa de correção de modelos de ponta (GPT-5.2) de 11,0% para 83,0% em tarefas NPU, superando significativamente o baseline "Codex" (46,0%) e o refinamento iterativo padrão (22,0%).
• Aceleração de Desempenho: Através do refinamento iterativo, o sistema alcançou um speedup mediano de 3,60x em relação ao primeiro rascunho viável. Em casos extremos, foram observados speedups superiores a 200x.
• Transferência de Conhecimento (Generalização):
  • Entre Níveis de Dificuldade: O conhecimento acumulado em tarefas fáceis (Nível 1) acelerou significativamente a resolução de tarefas difíceis (Nível 2), reduzindo o tempo de "aquecimento" em 4 iterações.
  • Entre Backbones: Memórias construídas por modelos fortes (GPT-5.2) melhoraram drasticamente o desempenho de modelos mais fracos (DeepSeek, Qwen), aumentando a taxa de compilação de 26% para 80% no DeepSeek.
  • Fora da Distribuição (OOD): O método generalizou com sucesso para novos conjuntos de operadores (Attention Set) e arquiteturas recentes (kernels mHC do DeepSeek), demonstrando que não é apenas memorização de templates.

5. Significado e Impacto

O trabalho demonstra que a acumulação de experiência guiada por valor é uma alternativa viável e eficiente ao fine-tuning massivo para domínios de dados escassos.

• Democratização de Expertise: Permite que modelos de propósito geral adquiram expertise em síntese de kernels para hardware nicho sem a necessidade de dados de treinamento massivos ou especialistas humanos constantes.
• Viabilidade de Agentes Não-Paramétricos: Confirma que a capacidade de in-context learning de LLMs modernos, combinada com uma memória evolutiva inteligente, é suficiente para superar a lacuna de desempenho em arquiteturas emergentes.
• Futuro: O framework sugere um caminho para sistemas de IA autônomos que podem dominar novas linguagens e arquiteturas de hardware com dados mínimos, adaptando-se dinamicamente conforme o hardware se diversifica.

Em suma, o EvoKernel resolve o problema do "cold-start" na programação de hardware especializado transformando a síntese de código em um processo de aprendizado contínuo e orientado a valor, superando as limitações de modelos estáticos e abordagens tradicionais de RL.