inteligência artificial

Ensinei uma IA a criar atalhos no próprio pensamento

25 de setembro de 20268 min de leiturainteligência artificial · pesquisa · memória · raciocínio

Quando você era criança, calcular 7 + 8 provavelmente exigia algum esforço. Talvez contasse nos dedos, ou começasse no 7 e fosse avançando até chegar ao 15. Hoje, basta olhar para “7 + 8” e o resultado aparece. O raciocínio não desapareceu; ele foi praticado tantas vezes que acabou se transformando em um atalho.

Nos últimos meses, tentei fazer uma IA pequena aprender algo parecido. A ideia era descobrir se um modelo poderia guardar não apenas uma informação, mas um procedimento já parcialmente “digerido”, de modo que, ao encontrá-lo novamente, precisasse de menos etapas internas para chegar à resposta. Neste artigo, conto o que funcionou, o que não funcionou e, principalmente, o que acabou sendo necessário para que o atalho aparecesse.

O que você vai encontrar aqui:

O problema: uma IA que “pensa em voltas”
A ideia: a memória é o próprio modelo, levemente modificado
Primeira vitória: a memória lembra, mas não encurta nada
A pista escondida: saber compor não bastava
O atalho sem ninguém ensinar a compor: consolidar ensaiando
Os limites deste resultado
Considerações Finais
Links indicativos

O problema: uma IA que “pensa em voltas”

Existe uma família de modelos de linguagem que, em vez de empilhar dezenas de camadas diferentes, reutiliza um mesmo bloco várias vezes sobre o estado interno. Cada passagem funciona como uma etapa de raciocínio que acontece “por dentro”, sem produzir uma palavra. Problemas mais difíceis podem exigir mais dessas passagens. Um exemplo conhecido é o Huginn, um modelo de 3,5 bilhões de parâmetros construído nessa linha.

Para estudar a ideia de forma controlada, montei uma versão de brinquedo: um modelo pequeno que recebe um número entre 0 e 10 e uma sequência de oito operações do tipo “multiplica por 3 e soma 5”, sempre calculadas com resto da divisão por 11. Assim, os valores permanecem entre 0 e 10.

O modelo aprende a executar uma operação a cada volta. Uma sequência com oito operações, portanto, exige nove voltas para produzir a resposta: oito para executar o procedimento e uma adicional para entregar o resultado.

A pergunta central era simples: se o modelo já tiver visto um determinado trecho de raciocínio, será que consegue armazená-lo de uma maneira que torne sua execução mais barata da próxima vez?

A ideia: a memória é o próprio modelo, levemente modificado

Grande parte dos sistemas de memória usados em IA funciona como um arquivo externo. Informações são armazenadas em algum lugar e recuperadas quando necessário. Eu queria experimentar algo diferente, mais próximo da ideia de que aprender significa modificar o próprio sistema que aprendeu.

Quando você aprende alguma coisa, não cria necessariamente uma gaveta separada para guardar aquela informação. O seu cérebro muda, e essa mudança passa a fazer parte daquilo que você é capaz de recuperar depois.

Aqui, a memória assume uma forma parecida: uma pequena perturbação nos próprios pesos do modelo, escrita pelo modelo durante o uso. É uma abordagem relacionada aos chamados “pesos rápidos” (fast weights), uma ideia que existe há décadas e que voltou a receber atenção em trabalhos como o Titans, do Google.

Sempre que o modelo precisa registrar algo novo, ele atualiza uma matriz pequena usando uma regra simples, chamada regra delta. A atualização compara aquilo que a matriz produziria atualmente com o que deveria produzir e corrige a diferença:

# regra delta: corrige a memória na direção do que ela deveria lembrar
erro = valor - memoria @ chave
memoria = (1 - esquecimento) * memoria + taxa * erro @ chave.T

O experimento é organizado em sessões. Primeiro, o modelo recebe definições como “o codinome C significa estas quatro operações”. Depois, aparecem problemas que usam apenas o codinome, sem repetir as operações.

As operações originais não estão disponíveis em nenhum outro lugar do texto. Se o modelo consegue resolver esses problemas, a informação precisa ter sido preservada pela perturbação dos pesos.

Primeira vitória: a memória lembra, mas não encurta nada

Depois de algumas tentativas frustradas — que dariam material para um artigo próprio — cheguei a uma arquitetura que funcionou bastante bem. A perturbação passou a funcionar como a própria entrada que o modelo enxerga na posição correspondente ao codinome. Quando aparece “C”, a memória insere ali as quatro operações que haviam sido associadas a ele.

Em três treinos independentes, os resultados foram:

100% de acerto nos problemas com codinome, contra 9% — o nível esperado de um chute — sem a memória;
nenhum prejuízo nos problemas normais, que não usam codinome;
aquilo que havia sido gravado no “dia 1” continuava sendo recuperado depois de vários “dias” de novas gravações.

Parecia que a memória estava funcionando. Havia, porém, um detalhe importante: ela não estava tornando o raciocínio mais curto.

O modelo continuava precisando de nove voltas. Ele recuperava o procedimento e depois o executava passo a passo, exatamente como faria se as operações estivessem escritas no texto original. A memória havia reduzido a quantidade de informação que precisava ser lida — um codinome no lugar de quatro operações —, mas não havia reduzido o trabalho interno.

Era como a criança que decorou que “7 + 8” significa contar oito números depois do 7. Ela sabe o procedimento, mas continua contando nos dedos.

A pista escondida: saber compor não bastava

A primeira explicação parecia óbvia: talvez o modelo simplesmente não soubesse combinar operações.

Ele conseguia aplicar “multiplica por 3 e soma 5” a um número, mas não necessariamente sabia reconhecer que duas operações consecutivas desse tipo podem ser representadas por uma única operação equivalente. Então fiz um segundo treino para ensinar justamente essa composição.

O modelo aprendeu. Chegou a 100% de acerto ao identificar qual operação única equivalia a quatro operações consecutivas.

E, ainda assim, nada mudou.

As respostas continuavam exigindo nove voltas.

Foi nesse ponto que apareceu o problema mais interessante. O modelo havia aprendido a composição, mas a forma como o procedimento estava representado continuava impondo um custo. Ele aprendera que a operação em uma posição do texto deveria agir sobre o resultado produzido pela posição anterior.

O codinome ocupava quatro posições. Mesmo quando a memória fornecia uma operação já combinada, a informação ainda precisava atravessar essas quatro posições. Cada uma delas representava uma volta adicional.

O gargalo, portanto, não era a capacidade de compor operações. Era a geometria da representação.

A solução foi ensinar ao modelo que posições vazias não precisam consumir uma volta. Ele poderia saltar diretamente para o último valor útil. A memória passou então a registrar algo como “operação combinada, vazio, vazio, vazio”.

Foi aí que o atalho apareceu:

um codinome seguido de quatro operações: 6 voltas, contra 9 quando tudo estava escrito;
dois codinomes consecutivos, representando oito operações no total: 3 voltas, contra 9.

Um teste de controle ajudou a confirmar a interpretação. Quando a memória era forçada a registrar apenas a primeira operação, em vez da combinação, o desempenho caía para perto do nível do chute. O que estava sendo transportado pela memória era, de fato, um procedimento já resumido.

O atalho sem ninguém ensinar a compor: consolidar ensaiando

Ainda havia uma questão importante. Até aqui, eu havia ensinado explicitamente ao modelo como combinar as operações, fornecendo a resposta correta. O atalho funcionava, mas a principal peça da solução havia sido entregue de antemão.

A pergunta seguinte foi mais difícil: será que o próprio modelo conseguiria descobrir essa representação?

As primeiras tentativas foram um fracasso. Retirei o treinamento específico de composição e deixei o modelo livre para decidir o que deveria gravar na memória. O resultado ficou próximo do chute, inclusive em procedimentos com apenas uma operação.

Ao analisar o estado interno, ficou claro o motivo. Simplesmente ler uma definição como “C significa estas quatro operações” não fazia com que o procedimento fosse representado de maneira útil. Esse modelo sabia transportar números de uma volta para outra, mas não sabia transportar um procedimento.

Ler uma receita não é o mesmo que entender o que ela faz.

A mudança decisiva foi colocar um ensaio no momento da gravação. Em vez de apenas ler a definição, o modelo executa o procedimento usando todas as 11 entradas possíveis — 0, 1, 2, até 10 — e observa os resultados produzidos.

É uma espécie de simulação. O procedimento é executado uma vez pelo caminho lento, e uma pequena rede recebe a tabela formada por pares do tipo “entrou isto, saiu aquilo”. A partir desse comportamento, ela decide o que deve ser gravado na memória.

O detalhe mais importante é que essa rede não recebe a resposta correta do que deveria armazenar. O único sinal que recebe é posterior: depois que algo foi gravado, o sistema observa se o problema apresentado com o codinome consegue ser resolvido em poucas voltas.

Em três treinos independentes, o resultado foi:

o caso com um codinome seguido de quatro operações foi resolvido em 6 voltas nos três treinos, contra 9 no caminho normal, com 96% de acerto;
a rede responsável pela gravação descobriu sozinha a operação combinada em cerca de 80% dos casos, enquanto o chute daria menos de 1%;
quase nunca apareceu a estratégia de simplesmente gravar a primeira operação, que seria uma forma mais fácil de tentar obter algum atalho.

Acerto da resposta por volta de raciocínio: com a memória, a conta que levava 9 voltas passa a levar 6 ou 3

Acerto da resposta a cada volta de raciocínio, média de 3 treinos. Com o procedimento consolidado na memória, a mesma conta de 8 operações fica pronta em 6 voltas (um codinome) ou 3 (dois codinomes), contra 9 do caminho normal.

Antes de executar os experimentos, eu havia previsto que a descoberta passaria de 80%. A média ficou em 79,8%, portanto a previsão falhou por pouco. Mesmo assim, o desempenho final chegou a 96%. Uma possível explicação é que a memória não precisa armazenar exatamente a combinação correta em todos os casos: ela pode registrar uma mistura de operações que ainda produz um comportamento funcional.

O paralelo com a aprendizagem humana também chamou minha atenção. Pesquisas em neurociência sugerem que o cérebro consolida memórias por meio da reencenação de experiências, inclusive durante o sono. Aqui, o atalho também apareceu apenas depois que o modelo teve a oportunidade de ensaiar o procedimento antes de armazená-lo.

Os limites deste resultado

Seria fácil parar no resultado anterior e deixar a história parecer mais completa do que realmente é. Mas há limitações importantes:

É um modelo minúsculo, aplicado a uma tarefa sintética. Nada disso foi testado ainda em um modelo de linguagem de verdade.
A capacidade de pular posições vazias foi ensinada diretamente. O modelo não descobriu essa propriedade sozinho.
O ensaio utiliza todas as 11 entradas possíveis. Em um problema com milhões de entradas, seria necessário trabalhar com uma amostra, e isso ainda não foi testado.
Nas operações utilizadas aqui, a combinação de quatro operações sempre pode ser expressa como uma operação conhecida. Procedimentos cuja combinação produza algo realmente novo continuam sendo uma questão em aberto.

Todas as previsões foram registradas antes de cada rodada, e os experimentos foram repetidos com três sementes aleatórias. Tanto as previsões que deram certo quanto aquelas que falharam foram mantidas no registro.

Considerações Finais

O principal resultado desta série de experimentos foi uma mudança na forma como penso sobre memória em IA.

Fazer o modelo guardar uma informação não foi a parte difícil. Relativamente cedo, ele já conseguia recuperar codinomes com 100% de acerto. O problema interessante era outro: fazer com que a memória carregasse o raciocínio já processado, em vez de apenas reproduzir as instruções que ainda precisariam ser executadas.

Para isso, três elementos acabaram sendo necessários. Primeiro, a memória precisava ser uma modificação do próprio modelo. Depois, o modelo precisava ter a possibilidade de saltar etapas vazias, evitando que a representação do procedimento impusesse um custo desnecessário. Por fim, era preciso ensaiar o procedimento antes de gravá-lo.

Os próximos experimentos que considero mais interessantes são deixar o modelo decidir sozinho o que vale a pena consolidar, sem receber uma definição explícita, e testar procedimentos cuja combinação não corresponda simplesmente a algo que o modelo já conhece.

Se o primeiro desses caminhos funcionar, talvez apareça algo bastante próximo daquela criança que, depois de fazer 7 + 8 vezes suficientes, deixa de contar nos dedos e passa simplesmente a enxergar 15.