Wrong Code, Right Structure: Learning Netlist Representations from Imperfect LLM-Generated RTL

Este trabalho propõe um framework de aumento de dados que aproveita a estrutura preservada em RTLs gerados por LLMs, mesmo quando funcionalmente imperfeitos, para treinar representações de netlist que superam a escassez de dados rotulados e generalizam bem para circuitos reais.

O essencial

Imagine que você quer ensinar um robô a entender como funcionam circuitos eletrônicos complexos, como os chips dentro do seu celular. Para isso, o robô precisa de "livros didáticos" (dados) que mostrem o desenho do circuito e expliquem o que cada parte faz.

O problema é que esses "livros" são secretos (protegidos por direitos autorais) e caríssimos para criar. É como tentar aprender a cozinhar um prato gourmet, mas só tendo acesso a três receitas de um livro antigo, enquanto o mundo inteiro tem milhões de pratos diferentes.

Aqui entra a ideia genial deste trabalho: E se usarmos um "chef de cozinha" (uma Inteligência Artificial chamada LLM) que é ótimo em desenhar receitas, mas que às vezes comete erros de cálculo?

A Grande Descoberta: "Receita Errada, Estrutura Certa"

Normalmente, se uma receita diz "adicione 2 xícaras de açúcar" mas o chef escreve "3 xícaras", a receita é considerada inútil. Mas os autores descobriram algo fascinante:

Mesmo quando o código gerado pela IA está funcionalmente errado (o chip não faria o cálculo matemático correto), a estrutura do desenho (como as peças estão conectadas) ainda se parece muito com a estrutura de um chip real e perfeito.

É como se o chef tivesse escrito a receita do bolo com a quantidade errada de fermento, mas tivesse desenhado o molde do bolo, a forma de misturar os ingredientes e a ordem dos passos perfeitamente. Para o robô que está aprendendo a reconhecer o formato do bolo, o erro na quantidade de fermento não importa tanto. O "esqueleto" do desenho está correto.

A Solução: O Pipeline de "Cozinha de Massa"

Os autores criaram um sistema em três etapas para transformar esse "chef bagunçado" em uma ferramenta poderosa:

1. Geração em Massa (A Fábrica de Receitas):
   Eles pedem para a IA gerar milhares de códigos de circuitos baseados em descrições simples (ex: "faça um multiplicador"). A IA gera muito, rápido e barato. Muitos desses códigos têm erros, mas a estrutura visual do circuito é rica e variada.

2. O Filtro de Qualidade (O Chefe de Cozinha Crítico):
   Como nem tudo o que a IA faz é bom, eles criaram um filtro inteligente. Em vez de verificar se o código funciona perfeitamente (o que é caro e difícil), eles verificam se o desenho do circuito gerado se parece com o desenho de um circuito real.

   • Analogia: Se a IA desenhou um carro com 4 rodas e um volante, mesmo que o motor não ligue, o desenho é útil para ensinar o robô a reconhecer "o que é um carro". Se a IA desenhou um carro com 3 rodas e um leme, o filtro descarta esse desenho.

3. A Votação de Arquitetura (O Concurso de Criatividade):
   Para garantir que o robô aprenda que um carro pode ser um sedan, um SUV ou um esportivo (e não apenas um modelo fixo), eles usam a IA para gerar versões diferentes do mesmo circuito. Depois, a própria IA atua como um juiz, escolhendo as versões mais criativas e diversas para o treinamento. Isso evita que o robô aprenda apenas um jeito de fazer as coisas.

O Resultado: Um Robô que Aprende com o Mundo Real

Eles testaram esse sistema em duas tarefas:

• Identificar partes do circuito: Como dizer onde termina o "motor" e começa a "transmissão" em um chip gigante.
• Classificar o chip: Dizer se aquele chip é um processador de vídeo ou um controlador de memória.

O resultado foi impressionante:
O robô treinado com esses "dados imperfeitos" gerados pela IA aprendeu tão bem (ou até melhor) quanto robôs treinados com poucos dados perfeitos e caros.

Por que isso é importante?

Antes, a pesquisa em segurança de chips e engenharia estava travada porque faltavam dados. Era como tentar aprender a dirigir apenas com um simulador de 10 minutos. Agora, com essa técnica, podemos criar "simuladores infinitos" e baratos.

Mesmo que a IA cometa erros na lógica, ela nos dá a estrutura necessária para entender o mundo dos chips. É como aprender a andar de bicicleta: você pode cair e errar o equilíbrio várias vezes (dados imperfeitos), mas o seu cérebro aprende a estrutura do equilíbrio (o padrão) e, no final, você anda perfeitamente.

Em resumo: Eles transformaram um problema (código de IA com erros) em uma solução (dados abundantes e baratos), provando que, às vezes, para aprender a estrutura de algo, não precisamos de perfeição, apenas de um bom "esqueleto".

Resumo técnico

Título: Código Errado, Estrutura Correta: Aprendizado de Representações de Netlist a partir de RTL Imperfeito Gerado por LLMs

1. O Problema

O aprendizado de representações de netlists (listas de conexões de portas lógicas) é fundamental para tarefas downstream como detecção de pirataria de IP, compreensão funcional, engenharia reversa e auditoria de segurança de hardware. No entanto, esse campo enfrenta um gargalo crítico: a escassez de dados rotulados de alta qualidade.

• Proteção de Propriedade Intelectual (IP): Projetos reais são protegidos, tornando impossível obter grandes conjuntos de dados com anotações precisas.
• Limitações dos Métodos Atuais: As abordagens existentes dependem de conjuntos de dados pequenos (como ISCAS-85 ou EPFL) ou de anotação manual, o que limita a escalabilidade e a capacidade de generalização para designs complexos do mundo real.
• O Dilema dos LLMs: Embora os Modelos de Linguagem (LLMs) possam gerar código RTL (Register-Transfer Level) em escala, o código gerado frequentemente contém erros funcionais, o que historicamente impediu seu uso em análise de circuitos, onde a correção funcional é tradicionalmente considerada essencial.

2. Metodologia Proposta

Os autores propõem um framework de aprendizado de representação end-to-end que transforma a "imperfeição funcional" dos LLMs em uma vantagem, explorando a observação chave de que a estrutura da netlist sintetizada preserva padrões estruturais indicativos da funcionalidade pretendida, mesmo quando o código RTL original é funcionalmente incorreto.

O framework consiste em três estágios principais:

A. Augmentation de Dados de Circuitos (Geração e Filtragem)
O objetivo é gerar um corpus massivo e diversificado de netlists a partir de especificações funcionais ou RTL existente.

1. Pipeline de Geração Baseada em LLM: O sistema aceita especificações funcionais (ou extrai especificações de RTL existente) e usa o LLM para regenerar o RTL. Isso permite a criação de implementações arquiteturalmente diversas (ex.: diferentes tipos de somadores ou multiplicadores) para a mesma função, algo que métodos baseados em regras não conseguem fazer.
2. Feedback de Síntese: Um agente de depuração analisa logs de ferramentas de síntese (como o Synopsys Design Compiler) para garantir que o código gerado seja sintetizável, corrigindo erros de sintaxe ou de interface.
3. Mecanismos de Filtragem e Seleção:
   • Filtragem em Nível de Netlist (Similaridade Estrutural): Para designs que visam replicar uma arquitetura de referência, calcula-se a similaridade coseno entre os embeddings gráficos da netlist gerada e a "golden netlist". Designs com similaridade abaixo de um limiar $\tau$ são descartados, mantendo apenas aqueles que preservam padrões estruturais relevantes.
   • Votação de Arquitetura (Nível RTL): Para promover diversidade arquitetural, o LLM atua como avaliador, votando em um lote de designs gerados para selecionar aqueles com maior complexidade e diversidade de implementação. Isso cria um conjunto de treinamento rico em variações arquitetônicas.

B. Aprendizado de Representação de Netlist

• Transformação Gráfica: As netlists são convertidas em grafos não direcionados ($G = (V, E)$), onde os nós são portas lógicas e as arestas são fios.
• Extração de Features: Cada nó recebe um vetor de características inicial contendo informações de conectividade (PI/PO), função lógica (one-hot) e propriedades estruturais (grau de entrada/saída).
• Treinamento GNN: Um Graph Neural Network (GNN), especificamente utilizando a abordagem de amostragem GraphSAINT para escalabilidade, é treinado para aprender embeddings robustos que capturam tanto a estrutura quanto a intenção funcional latente.

C. Tarefas de Classificação
O modelo treinado é avaliado em duas tarefas:

1. Classificação em Nível de Nó: Identificação de limites de sub-circuitos (ex.: onde termina um somador e começa um registrador).
2. Classificação em Nível de Grafo: Identificação de componentes funcionais completos (ex.: classificar se um IP é um módulo de CPU, memória, etc.).

3. Principais Contribuições

1. Reavaliação do Valor do RTL Imperfeito: O trabalho demonstra que as características estruturais das netlists são robustas a erros funcionais no RTL fonte, fornecendo uma base principial para o uso de supervisão "ruidosa" no aprendizado de hardware.
2. Framework de Aprendizado Custo-Efetivo: É o primeiro framework a sistematicamente utilizar RTL gerado por LLMs (funcionalmente imperfeito) para aprendizado de representação. Reduz o custo de preparação de dados em ordens de grandeza em comparação com anotação manual, exigindo apenas especificações de design.
3. Escalabilidade para Cenários Reais: O método escala de tarefas em nível de operador (ex.: somadores simples) para o nível de IP (ex.: SoCs completos), superando a limitação de generalização dos métodos anteriores.

4. Resultados Experimentais

Os experimentos foram conduzidos em benchmarks de escala crescente, desde operadores aritméticos até SoCs de código aberto (PicoRV32 e NEORV32).

• Desempenho em Identificação de Sub-circuitos:
  • O modelo treinado com dados aumentados por LLM (LLM-Aug-t2) alcançou 93,79% de F1-Macro, superando a linha de base (GNN-RE treinada em dados reais limitados) em 3,64%.
  • Isso prova que dados sintéticos de alta qualidade podem enriquecer o espaço de características e substituir dados reais escassos.
• Generalização Arquitetural:
  • O uso do mecanismo de "Votação de Arquitetura" resultou em um F1-Micro de 94,45%, superando significativamente o uso de dados brutos gerados por LLM sem filtragem (92,47%). Isso confirma que a diversidade arquitetural introduzida pelo LLM melhora a generalização para arquiteturas não vistas.
• Estudo de Caso em Nível de IP (SoC):
  • Ao treinar em dados do PicoRV32 e testar no NEORV32 (sem acesso aos dados de teste durante o treino), o método proposto (LLM-Filtered) alcançou um F1 de 68,35% na identificação dos limites da CPU.
  • Isso representou um ganho de 8,31% em relação ao método de LLM bruto e uma melhoria substancial em relação a métodos baseados em regras (58,28%), demonstrando a capacidade de delimitar com precisão a funcionalidade de IPs complexos em designs não vistos.

5. Significado e Impacto

Este trabalho rompe o gargalo de dados na representação de circuitos integrados. Ao demonstrar que a estrutura importa mais que a funcionalidade perfeita para o aprendizado de representações, os autores abrem caminho para o uso de grandes volumes de dados sintéticos gerados por IA.

• Viabilidade Prática: Oferece uma solução prática para a falta de dados rotulados em segurança de hardware e engenharia reversa.
• Mudança de Paradigma: Transita o foco de métodos baseados em regras (que apenas variam a topologia local) para métodos baseados em LLMs que exploram o espaço de design arquitetural completo.
• Aplicabilidade: O framework é escalável para designs industriais complexos, permitindo a análise de IPs protegidos e a detecção de falhas ou malwares em hardware sem a necessidade de acesso ao código fonte original ou anotações manuais extensivas.