Detecting Functional Memorization in Code Language Models

Este artigo introduz um framework de avaliação contrafactual demonstrando que modelos de linguagem de código podem memorizar lógica funcional além da sobreposição textual literal, necessitando de novas métricas de auditoria que avaliem a similaridade baseada em execução em vez de apenas correspondência de texto.

O essencial

Imagine que você tem uma biblioteca gigante de códigos de computador, como um enorme livro de receitas repleto de milhões de receitas. Você treina um chef de IA superinteligente (um Grande Modelo de Linguagem) para ler cada página dessa biblioteca para que ele possa aprender a cozinhar.

Agora, imagine que você pede a esse chef de IA para escrever uma nova receita para "Tofu Apimentado".

A Forma Antiga de Verificar (Similaridade Textual)
Anteriormente, os pesquisadores verificavam se a IA estava "trapaceando" (memorizando) olhando para as palavras. Se a IA escrevesse uma receita que parecesse quase exatamente com uma no livro — usando os mesmos ingredientes, a mesma estrutura de frases e a mesma ortografia — eles diziam: "Aha! Ela memorizou essa receita!"

Mas aqui está o problema: Duas receitas podem fazer exatamente o mesmo prato delicioso, mas parecer completamente diferentes no papel. Uma pode dizer "adicione 2 xícaras de farinha", enquanto a outra diz "despeje 480ml de pó branco". Elas são funcionalmente idênticas (fazem o mesmo bolo), mas textualmente diferentes.

A Nova Descoberta (Memorização Funcional)
Este artigo diz: "Descobrimos que o chef de IA está memorizando a lógica das receitas, não apenas as palavras."

Mesmo quando a IA muda as palavras, os nomes das variáveis e a estrutura das frases, ela ainda pode estar seguindo secretamente os mesmos passos exatos da biblioteca. É como se a IA tivesse aprendido uma fórmula secreta para o "molho especial" de uma empresa específica do livro. Mesmo que ela escreva uma receita nova que pareça totalmente diferente, se ela ainda usar exatamente essa fórmula secreta, ela vazou o segredo comercial da empresa.

Como Eles Pegaram (O Teste Contrafactual)
Para provar isso, os pesquisadores montaram um experimento inteligente, como um "teste de gêmeos":

1. O Chef "Experiente" (Modelo Alvo): Esta IA foi treinada na biblioteca específica que contém as receitas secretas.
2. O Chef "Ingênuo" (Modelo de Referência): Esta IA é exatamente o mesmo modelo, mas nunca viu aquelas receitas secretas específicas. Ela viu apenas a biblioteca geral.

Eles pediram a ambos os chefs para escreverem uma receita baseada em um comando simples (como "Faça um molho para a cidade X").

• Se o Chef Ingênuo adivinhasse um molho aleatório e genérico, mas o Chef Experiente escrevesse um molho que usava a exata mesma lógica secreta como a da biblioteca (mesmo com palavras diferentes), eles sabiam que o Chef Experiente havia memorizado a lógica.

Os Resultados
O estudo descobriu que, embora os detectores de "correspondência de texto" perdessem a maioria desses casos, os detectores de "correspondência de lógica" os capturavam.

• Detectores de texto diziam: "Essas receitas parecem diferentes. Sem trapaça."
• Detectores de lógica diziam: "Espere, essas receitas produzem exatamente o mesmo resultado usando exatamente os mesmos passos ocultos. Isso é memorização!"

Por Que Isso Importa
O artigo conclui que não podemos apenas verificar se uma IA está copiando palavras. Temos que verificar se ela está copiando o cérebro por trás do código. Se um algoritmo de negociação proprietário de uma empresa ou regras de moderação de conteúdo estiverem nos dados de treinamento, a IA pode reproduzir essa lógica secreta em um novo disfarce, vazando informações sensíveis mesmo que não copie uma única palavra literalmente.

Em Resumo:
A IA não é apenas uma fotocopiadora; ela é uma imitadora. Ela pode aprender a ideia de uma receita secreta e reescrevê-la com sua própria voz. Os autores criaram novas ferramentas para flagrar a IA quando ela faz essa "imitação de lógica", mostrando que as verificações de segurança atuais estão focadas demais em ortografia e gramática, perdendo o tipo de cópia mais profundo e perigoso.

Resumo técnico

Resumo Técnico: Detectando Memorização Funcional em Modelos de Linguagem de Código

Declaração do Problema

Grandes Modelos de Linguagem (LLMs) treinados em corpora de código são cada vez mais utilizados para geração de código. Pesquisas anteriores investigaram extensivamente a "extração de dados de treinamento", onde os modelos reproduzem exemplos de treinamento de forma literal ou quase literal. No entanto, os métodos de auditoria existentes baseiam-se quase exclusivamente em métricas de similaridade textual (ex: BLEU, distância de edição). Essa abordagem falha em capturar um risco crítico: a memorização funcional.

O código pode ser funcionalmente equivalente sendo textualmente dissimilar. Variáveis podem ser renomeadas, o fluxo de controle pode ser reestruturado, comentários podem ser adicionados ou removidos, ou algoritmos inteiramente diferentes podem ser empregados para alcançar a mesma lógica. Se um LLM internaliza lógica funcional proprietária (ex: algoritmos de negociação, regras de recomendação) de seus dados de treinamento e a reproduz em uma forma reestruturada, as métricas textuais padrão falharão em detectar o vazamento. Este artigo aborda a lacuna na detecção e quantificação dessa "memorização funcional" além da sobreposição superficial de tokens.

Metodologia

Os autores propõem uma configuração contrafactual para distinguir memorização de generalização, aproveitando a transparência de treinamento do modelo de código aberto Olmo-3-32B.

1. Configuração Experimental

• Modelo Alvo ($M_T$): O checkpoint de midtraining do Olmo-3-32B, que foi exposto ao código alvo (CraneCode, um subconjunto filtrado do the-stack-v2-smol).
• Modelo de Referência ($M_R$): O checkpoint de pré-treinamento do Olmo-3-32B, que compartilha a mesma arquitetura e pré-treinamento, mas não foi exposto aos dados de midtraining específicos.
• Dados: 7.422 funções Python do corpus CraneCode, filtradas para conter "lógica funcional significativa" (regras de negócio, algoritmos proprietários) usando um LLM-como-juiz.
• Procedimento: Ambos os modelos são instigados com assinaturas de funções e até 250 tokens precedentes. Os modelos geram continuações usando decodificação gananciosa (greedy decoding). A saída gerada ($x^*$) é comparada contra os dados de treinamento originais ($x$).

2. Definição de Memorização Funcional Contrafactual

Uma amostra é definida como contrafactualmente memorizada funcionalmente se:

1. Baixa Sobreposição Textual: A geração do alvo possui baixa similaridade textual com o dado real ($SIM_{text} < \tau_{text}$).
2. Alta Sobreposição Funcional: A geração do alvo é funcionalmente equivalente ao dado real ($SIM_{func} \ge \tau_{func}$).
3. Divergência Contrafactual: O modelo de referência (não exposto) não produz uma saída funcionalmente equivalente para o mesmo prompt.

3. Métricas de Avaliação

O estudo emprega um conjunto abrangente de métricas para medir a similaridade, categorizadas como:

• Métricas Textuais: Correspondência exata, BLEU, similaridade de edição e Longest Common Substring (LCS).
• Métricas Estruturais: CodeBLEU (variantes de sintaxe e fluxo de dados) e Distância de Edição de Árvore (TSED).
• LLM-as-a-Judge (LLM como Juiz): Três prompts distintos (Song et al., Nikiema et al., e um prompt customizado de equivalência funcional) para avaliar a similaridade semântica.
• Baseada em Execução: HyClone, um detector de dois estágios que gera entradas de teste, executa ambas as funções e compara as saídas para verificar a equivalência funcional.

Principais Contribuições

1. Formalização da Memorização Funcional: O artigo define e operacionaliza o conceito de extração de lógica funcional de LLMs sem cópia literal, distinguindo-a da generalização.
2. Estrutura Contrafactual para Código: Ele adapta a estrutura de memorização contrafactual (previamente usada para linguagem natural) para o código, utilizando a transparência de treinamento específica do Olmo-3 para criar uma comparação rigorosa de "exposto vs. não exposto".
3. Conjunto Abrangente de Métricas: O trabalho avalia um amplo espectro de métricas de similaridade, demonstrando que métricas baseadas em texto são insuficientes para detectar vazamento funcional.
4. Evidência Empírica: O trabalho fornece a primeira evidência em larga escala de que LLMs de código exibem memorização funcional em uma taxa significativa, mesmo quando a sobreposição textual é baixa.

Resultados

O estudo analisa 7.422 funções e encontra mudanças sistemáticas na similaridade do modelo de referência para o modelo alvo em todas as métricas.

• Memorização Verbatim (Literal): Consistente com trabalhos anteriores, o modelo alvo produz correspondências exatas (0,11%) e correspondências quase literais (BLEU $\ge$ 0,75, 0,58%) que o modelo de referência não produz.
• Memorização Funcional:
  • Métricas Estruturais: CodeBLEU (DFG) e TSED identificaram 1,8% e 2,1% das amostras como contrafactualmente memorizadas, respectivamente, apesar dos baixos escores de BLEU.
  • LLM-as-a-Judge: Usando o prompt de equivalência funcional conservador dos autores, 3,9% das amostras foram identificadas como memorizadas funcionalmente (baixo BLEU, alta similaridade funcional e divergência contrafactual). Outros prompts geraram taxas mais altas (até 14,0%), sugerindo sensibilidade ao design do prompt.
  • Baseada em Execução: Sob o teste mais rigoroso do HyClone, 0,28% das gerações foram verificadas como funcionalmente idênticas aos dados de treinamento enquanto o modelo de referência falhou em fazê-lo. Isso é considerado um limite inferior devido aos desafios de execução (ex: dependências ausentes, estado de classe).
• Correlação de Métricas: Métricas textuais (BLEU, Edição) são altamente correlacionadas entre si, mas fracamente correlacionadas com métricas baseadas em execução (HyClone), confirmando que capturam sinais distintos.

Exemplo: O artigo destaca um caso onde o modelo alvo reproduziu uma lógica de comissão codificada (hard-coded) do treinamento usando uma implementação reestruturada (nomes de variáveis e fluxo de controle diferentes), enquanto o modelo de referência alucinou uma lógica não relacionada. Métricas textuais (BLEU = 0,26) falharam em sinalizar isso, enquanto métricas funcionais (LLM-judge = 0,8, Execução = 0,95) tiveram sucesso.

Significância e Alegações

O artigo alega que os regimes de auditoria atuais que dependem apenas de sobreposição textual são insuficientes para modelos de código. Os resultados demonstram que a memorização funcional ocorre em uma ordem de magnitude semelhante à memorização quase literal quando medida por métricas funcionais apropriadas.

Os autores afirmam que:

• Modelos podem internalizar e reproduzir lógica proprietária mesmo quando a forma superficial é significativamente alterada.
• As proteções de privacidade e propriedade intelectual baseadas em similaridade de texto provavelmente estão subestimando o risco de vazamento de dados de treinamento.
• Há uma necessidade urgente de métricas de auditoria que vão além da sobreposição textual, incorporando análise estrutural, julgamento semântico baseado em LLM e verificação baseada em execução.

O trabalho conclui motivando o desenvolvimento de regimes de auditoria mais robustos e técnicas de medição aprimoradas para similaridade funcional, observando que os métodos atuais baseados em execução ainda são limitados pela complexidade dos ambientes de código do mundo real.