Transducing Language Models

Este artigo apresenta um quadro teórico e algoritmos para transformar modelos de linguagem pré-treinados em novos modelos funcionais através da composição com transdutores de estado finito, permitindo a adaptação de inferência para diferentes formatos de saída (como bytes, palavras ou aminoácidos) sem alterar os parâmetros do modelo original.

O essencial

Imagine que você tem um chef de cozinha de elite (o Modelo de Linguagem) que é especialista em cozinhar apenas com ingredientes pré-embalados (tokens ou subpalavras). Ele sabe exatamente como combinar esses pacotes para criar pratos deliciosos.

O problema é que, às vezes, o cliente (a aplicação final) não quer o prato servido em pacotes. O cliente quer o prato desembrulhado, em gramas exatas (bytes), ou talvez ele queira o prato cortado em fatias de palavras específicas, ou até mesmo transformado em um ingrediente totalmente diferente, como transformar DNA em proteínas.

Até agora, a solução era: "Ok, o chef faz o prato, e depois a gente pega uma tesoura e tenta cortar os pacotes manualmente para servir ao cliente." Isso funciona, mas é bagunçado, lento e você perde informações sobre o sabor original (a probabilidade) durante o corte.

Este artigo apresenta uma nova abordagem: o "Tradutor Mágico" (Transdutor).

A Ideia Central: O Tradutor Mágico

Em vez de cortar o prato depois de pronto, o autores propõem colocar um tradutor automático entre o chef e o cliente.

1. O Chef (Modelo de Linguagem): Continua fazendo o que faz de melhor: gerando sequências de seus "pacotes" favoritos.
2. O Tradutor (Transdutor de Estado Finito): É uma máquina simples, como um túnel de controle ou um filtro de peneira. Ele pega cada pacote que sai do chef e o transforma instantaneamente no formato que o cliente pediu.
   • Se o cliente quer bytes, o tradutor desembrulha cada pacote.
   • Se o cliente quer palavras, o tradutor cola os pacotes juntos e coloca um espaço no lugar certo.
   • Se o cliente quer proteínas, o tradutor pega 3 letras de DNA e as transforma em 1 aminoácido.

O Grande Desafio: O "Efeito Borboleta" da Probabilidade

Aqui está a parte difícil (e genial da solução):

Quando o tradutor muda o formato, uma única palavra do cliente pode ter sido criada por milhões de combinações diferentes de pacotes do chef.

• Exemplo: A palavra "hello" pode vir de um único pacote, ou de "he" + "ll" + "o", ou "h" + "e" + "l" + "l" + "o".
• Para saber a probabilidade real de "hello", você teria que somar a chance de todas essas combinações. Fazer isso manualmente seria como tentar contar cada gota de chuva em uma tempestade: impossível e demorado.

O papel resolve isso criando um mapa de rotas. Eles desenvolveram algoritmos que, em vez de contar gota por gota, olham para o túnel inteiro e dizem: "Ok, todas as rotas que passam por aqui terminam em 'hello', então vamos somar a probabilidade de todo esse grupo de uma só vez".

As Analogias do Papel

1. O Tradutor como um "Filtro de Café":
   Imagine que o modelo de linguagem é a água fervendo com pó de café (os tokens). O cliente quer o café coado (as palavras). O tradutor é o filtro. O algoritmo do papel não tenta ver cada grão de café individualmente; ele calcula o fluxo total de café que passa pelo filtro para saber exatamente o quanto de café vai na xícara.

2. A "Decomposição" (Quociente e Resto):
   O papel divide o problema em duas partes para facilitar a matemática:

   • O Quociente (A Parte Fácil): São os casos onde, não importa o que o chef faça depois, o resultado final será o que queremos. É como se o tradutor já tivesse certeza: "Se o chef começar com 'A', o cliente vai receber 'B', ponto final".
   • O Resto (A Parte Difícil): São os casos onde o chef precisa fazer algo específico para o tradutor funcionar. É como um "caminho de volta" onde precisamos olhar com mais cuidado.
   • O algoritmo é inteligente: ele foca nos caminhos mais prováveis e ignora os que têm chance zero, economizando tempo.

3. DNA para Proteínas (A Tradução Biológica):
   Imagine que o DNA é um código de 4 letras (A, C, G, T) e as proteínas são um código de 20 letras. O tradutor pega 3 letras de DNA e as transforma em 1 letra de proteína. O papel mostra como calcular a chance de uma proteína específica aparecer, somando todas as combinações de DNA que poderiam gerar aquela proteína, sem precisar re-treinar o modelo de DNA do zero.

Por que isso é importante?

• Sem Re-treinamento: Você não precisa ensinar o chef a cozinhar de novo. Você apenas muda o "prato de serviço" (o tradutor). Isso economiza milhões de dólares e tempo de computação.
• Precisão: Você mantém a "alma" do modelo original. A probabilidade de uma palavra ser dita é calculada com base em todas as formas que ela poderia ter sido gerada, não apenas na forma mais óbvia.
• Versatilidade: Funciona para transformar texto em bytes, corrigir erros de digitação, traduzir DNA, ou adaptar modelos para qualquer unidade que você imaginar, desde que você possa desenhar as regras do tradutor.

Resumo em uma frase

Este trabalho cria uma ponte matemática inteligente que permite pegar modelos de linguagem existentes (que falam em "subpalavras") e fazê-los falar fluentemente em "bytes", "palavras" ou "aminoácidos", calculando as probabilidades corretas sem precisar recriar o modelo do zero. É como dar um novo idioma ao seu assistente de IA sem precisar ensiná-lo a falar de novo, apenas mudando o tradutor que ele usa.

Resumo técnico

Aqui está um resumo técnico detalhado do artigo "Transducing Language Models", apresentado em português:

1. O Problema: A Incompatibilidade de Strings (String Mismatch)

Os modelos de linguagem modernos (LLMs) definem distribuições de probabilidade sobre sequências de tokens (subpalavras), mas muitas tarefas downstream exigem formatos de saída diferentes, como:

• Nível de bytes: Para correção ortográfica ou análise de caracteres.
• Nível de palavras: Para linguística psicológica ou geração controlada.
• Nível de aminoácidos: Para biologia computacional (conversão de sequências de DNA para proteínas).

O problema central é que, embora seja trivial amostrar uma string do modelo e transformá-la (ex: converter tokens para bytes), operações probabilísticas rigorosas sobre a string transformada tornam-se intratáveis. Especificamente:

• Calcular a probabilidade de uma string transformada específica é difícil, pois múltiplas sequências de tokens originais podem mapear para a mesma string de saída.
• Condicionar a geração em uma saída transformada (ex: "gere o próximo byte") requer somar probabilidades sobre todas as fontes possíveis que levam a esse estado, o que é exponencialmente complexo sem um método formal.

Atualmente, a prática comum é usar pós-processamento ad hoc, o que quebra a coerência probabilística do modelo.

2. Metodologia: Modelos de Linguagem Transduzidos

Os autores propõem um framework formal para tratar transformações de string-para-string como componentes de primeira classe no pipeline de modelagem de linguagem.

Conceito Central

Um Modelo de Linguagem Transduzido ($p_Y$) é definido aplicando uma transformação determinística $f$ (codificada por um Transdutor de Estado Finito - FST) a um modelo de linguagem fonte ($p_X$).

• Se $X \sim p_X$, então $Y = f(X) \sim p_Y$.
• A probabilidade de uma string alvo $y$ é a soma das probabilidades de todas as strings fonte $x$ que mapeiam para $y$: $p_Y(y) = \sum_{x \in f^{-1}(y)} p_X(x)$.

Decomposição do "Precobertura" (Precov er)

Para calcular probabilidades de prefixos de forma autoregressiva (necessária para geração passo a passo), o algoritmo precisa somar probabilidades sobre o conjunto de strings fonte que cobrem o prefixo alvo. O artigo introduz uma decomposição matemática desse conjunto em duas partes:

1. Quociente ($Q(y)$): Um conjunto prefixo-livre de strings fonte que são "cilindros". Isso significa que, uma vez que uma string fonte entra neste conjunto, todas as suas extensões também mapeiam para o prefixo alvo. A probabilidade pode ser calculada usando apenas a probabilidade de prefixo do modelo fonte.
2. Restante ($R(y)$): Strings fonte que mapeiam para o prefixo alvo, mas cujas extensões nem sempre o fazem (requerem verificação exata da string completa).

A probabilidade do prefixo alvo é então:
$$\vec{p}_Y(y) = \sum_{x \in Q(y)} \vec{p}_X(x) + \sum_{x \in R(y)} p_X(x)$$

Algoritmos

O papel apresenta algoritmos eficientes para realizar essa decomposição:

• Algoritmo Exato: Utiliza uma busca em largura (BFS) sobre o espaço de estados do transdutor para identificar cilíndros e membros do restante.
• Otimizações:
  • Lazy Determinization: Evita a determinização explícita e cara do transdutor, rastreando "fronteiras" de estados.
  • Cortes de Universalidade: Identifica estados "IP-universais" (Input-Projection Universal) onde qualquer entrada subsequente produz saída válida, permitindo cortar a busca e classificar imediatamente como quociente.
  • Poda (Pruning): Para casos onde a decomposição é muito grande, o algoritmo poda candidatos de baixa probabilidade, mantendo uma massa de probabilidade acumulada acima de um limiar $\tau$, garantindo uma aproximação eficiente.

3. Principais Contribuições

1. Framework Geral: Formaliza a criação de novos modelos de linguagem a partir de transformações determinísticas, permitindo que modelos pré-treinados operem em unidades diferentes das de treinamento sem re-treinamento.
2. Interface Autoregressiva: Demonstra como equipar modelos transduzidos com a interface familiar de distribuição de próximo símbolo e probabilidades de prefixo, tornando-os compatíveis com sistemas existentes.
3. Algoritmos Eficientes: Desenvolve métodos exatos e aproximados para marginalizar sobre strings fonte, utilizando propriedades de transdutores de estado finito para evitar explosão combinatória.
4. Condições de Finitude: Estabelece condições teóricas (como monotonicidade de prefixo e "segurança" de estados) sob as quais a decomposição é finita e computável exatamente.

4. Resultados Experimentais

Os autores validaram o framework em três domínios distintos, utilizando modelos como GPT-2, LLaMA e Phi-4:

• Tokens para Bytes: Conversão de modelos baseados em subpalavras para modelos de nível de byte.
  • Resultado: Alta eficiência e precisão. Aproximações com poda leve ($\tau \le 10^{-3}$) produziram divergências de Jensen-Shannon (JSD) muito baixas em relação à distribuição exata, com custo computacional viável.
• Tokens para Palavras (Penn Treebank): Inserção de limites ortográficos de palavras.
  • Desafio: Esta transformação não é monotônica de prefixo estrito (requer olhar para o contexto futuro), gerando um conjunto de "restante" não vazio.
  • Resultado: O método lidou com a complexidade contextual, embora com maior custo computacional devido à necessidade de verificar strings completas no conjunto restante.
• DNA para Aminoácidos: Conversão de sequências de nucleotídeos para sequências de proteínas.
  • Desafio: Mapeamento de 3 para 1, com crescimento exponencial de candidatos.
  • Resultado: O uso de poda foi essencial para manter a tratabilidade, permitindo a inferência em modelos de DNA pré-treinados para gerar proteínas.

Em todos os casos, o método demonstrou ser uma alternativa viável ao re-treinamento, permitindo adaptar modelos existentes a requisitos de saída específicos com precisão controlada.

5. Significado e Impacto

• Reutilização de Modelos: Permite que modelos de linguagem massivos e pré-treinados sejam aplicados em domínios onde a unidade de tokenização original é inadequada (ex: biologia, linguística fina) sem o custo proibitivo de re-treinamento.
• Correção de Viés de Tokenização: Resolve problemas conhecidos onde a tokenização subpalavra distorce estimativas de probabilidade para palavras ou caracteres, permitindo análises linguísticas e psicológicas mais precisas.
• Generalização Teórica: Estende trabalhos anteriores (que focavam apenas em transformações monotônicas estritas) para um framework geral que lida com transformações complexas e não monotônicas através da decomposição quociente-restante.
• Eficiência: Mostra que é possível realizar inferência exata ou aproximada de alta qualidade em tempo real para muitas aplicações, superando a intratabilidade teórica anterior.

Em resumo, o artigo fornece as ferramentas teóricas e algorítmicas para "transduzir" modelos de linguagem, transformando distribuições sobre tokens em distribuições válidas sobre qualquer unidade definida por um transdutor de estado finito, abrindo novas possibilidades para aplicações especializadas em IA.