A revolução da memória condicional para LLMs

Se você está atualizado com os desenvolvimentos recentes de IA e LLMs, provavelmente já percebeu que grande parte do progresso ainda se dá através da construção de modelos maiores ou de um melhor roteamento computacional. Bem, e se houver mais uma rota alternativa? Junto veio o Engram! Um método revolucionário de DeepSeek AI que está alterando nossa perspectiva sobre o dimensionamento de modelos de linguagem.

Que problema o Engrama resolve?

Considere um cenário: você digita “Alexandre, o Grande” em um modelo de linguagem. Agora, ele gasta recursos computacionais valiosos para reconstruir esta frase comum do zero, toda vez. É como ter um matemático brilhante que precisa contar todos os 10 dígitos antes de resolver qualquer equação complexa.

Os modelos atuais de transformadores não possuem uma maneira dedicada de simplesmente “procurar” padrões comuns. Eles simulam a recuperação de memória por meio de computação, que é ineficiente. Engram apresenta o que os pesquisadores chamam memória condicional, um complemento à computação condicional que vemos em Mistura de Especialistas (MoE) modelos.

Os resultados falam por si. Em testes de benchmark, o Engram-27B mostrou melhorias notáveis ​​em relação aos modelos MoE comparáveis:

• Ganho de 5,0 pontos em tarefas de raciocínio BBH
• Melhoria de 3,4 pontos nos testes de conhecimento MMLU
• Aumento de 3,0 pontos na geração de código HumanEval
• Precisão de 97,0 vs 84,2 em testes de agulha no palheiro de múltiplas consultas

Principais recursos do engrama:

Os principais recursos do Engram são:

• Alocação de dispersão: Identificamos uma lei de escala em forma de U que direciona a alocação best de capacidade, apresentando a compensação entre computação neural (MoE) versus memória estática (Engram) como um dilema.
• Verificação Empírica: O modelo Engram-27B fornece um ganho consistente sobre as linhas de base do MoE nos domínios de conhecimento, raciocínio, código e matemática sob condições de restrições estritas de isoparâmetros e iso-FLOPs.
• Análise Mecanística: Os resultados da nossa análise indicam que o Engram permite que as camadas iniciais fiquem livres da reconstrução de padrões estáticos, o que pode resultar na manutenção da profundidade efetiva para raciocínios complexos.
• Eficiência do sistema: O módulo usa endereçamento determinístico que permite a incorporação de tabelas de grande tamanho para serem movidas para a memória do host com apenas um ligeiro aumento no tempo de inferência.

Como o Engrama realmente funciona?

O engrama foi comparado a uma tabela de consulta de alta velocidade no caso de modelos de linguagem que podem acessar facilmente padrões frequentes.

A Arquitetura Central

A abordagem do Engram é baseada em uma ideia muito simples, mas também muito poderosa: é baseada em embeddings de N-gramas (sequências de N tokens consecutivos) que podem ser consultados em tempo constante O(1). Em vez de manter todas as combinações possíveis de palavras armazenadas, ele emprega funções hash para mapear padrões para incorporações de maneira eficiente.

Existem três partes principais nesta arquitetura:

• Compressão do tokenizador: Antes de procurar padrões, o Engram padroniza os tokens, então “Apple” e “apple” referem-se ao mesmo conceito. Isso resulta em uma redução de 23% no tamanho efetivo do vocabulário, tornando o sistema mais eficiente.
• Hashing de múltiplas cabeças: Para evitar colisões (ou seja, mapeamento de padrões diferentes para o mesmo native), o Engram emprega múltiplas funções hash. Por exemplo, pense nisso como se houvesse várias listas telefônicas diferentes – se uma lhe der o número errado, as outras o protegerão.
• Controle baseado no contexto: Esta é a parte inteligente. Nem toda memória recuperada é pertinente, então o Engram emprega mecanismos semelhantes aos da atenção para determinar o quanto confiar em cada pesquisa de acordo com o contexto atual. Se um padrão estiver fora do lugar, o valor do portão cairá para zero e o padrão será efetivamente desconsiderado.

A descoberta da lei de escala

Entre as inúmeras descobertas interessantes, destaca-se a lei de escala em forma de U. Os pesquisadores conseguiram identificar o desempenho best quando cerca de 75-80% da capacidade foi alocada para o MoE e apenas 20-25% para a memória Engram.

MoE completo (100%) significa nenhuma memória dedicada para o modelo e, portanto, nenhum uso adequado de computação para reconstruir os padrões comuns. Nenhum MoE (0%) significa que o modelo não conseguiu realizar um raciocínio sofisticado devido a ter muito pouca capacidade computacional. O ponto perfeito é onde ambos estão equilibrados.

Introdução ao Engrama

1. Instalar Pitão com versão 3.8 e superior.
2. Instalar numpy usando o seguinte comando:

pip set up numpy  

Prática: Compreendendo o hash N-gram

Vamos observar como o mecanismo de hash principal do Engram funciona com uma tarefa prática.

Implementando pesquisa básica de hash de N-gram

Nesta tarefa, veremos como o Engram usa hashing determinístico para mapear sequências de tokens para embeddings, evitando completamente a necessidade de armazenar todos os N-gramas possíveis separadamente.

1: Configurando o ambiente

import numpy as np
from typing import Record

# Configuration
MAX_NGRAM = 3
VOCAB_SIZE = 1000
NUM_HEADS = 4
EMBEDDING_DIM = 128 

2: Crie um simulador simples de compactação de tokenizer

def compress_token(token_id: int) -> int:
    # Simulate normalization by mapping related tokens
    # In actual Engram, this makes use of NFKC normalization
    return token_id % (VOCAB_SIZE // 2)


def compress_sequence(token_ids: Record(int)) -> np.ndarray:
    return np.array((compress_token(tid) for tid in token_ids))

3: Implemente a função hash

def hash_ngram(tokens: Record(int),
               ngram_size: int,
               head_idx: int,
               table_size: int) -> int:
    # Multiplicative-XOR hash as utilized in Engram
    multipliers = (2 * i + 1 for i in vary(ngram_size))
    combine = 0

    for i, token in enumerate(tokens(-ngram_size:)):
        combine ^= token * multipliers(i)

    # Add head-specific variation
    combine ^= head_idx * 10007

    return combine % table_size


# Check it
sample_tokens = (42, 108, 256, 512)
compressed = compress_sequence(sample_tokens)

hash_value = hash_ngram(
    compressed.tolist(),
    ngram_size=2,
    head_idx=0,
    table_size=5003
)

print(f"Hash worth for 2-gram: {hash_value}")

4: Crie uma pesquisa de incorporação de vários cabeçalhos

def multi_head_lookup(token_sequence: Record(int),
                      embedding_tables: Record(np.ndarray)) -> np.ndarray:
    compressed = compress_sequence(token_sequence)
    embeddings = ()

    for ngram_size in vary(2, MAX_NGRAM + 1):
        for head_idx in vary(NUM_HEADS):
            desk = embedding_tables(ngram_size - 2)(head_idx)
            table_size = desk.form(0)
            hash_idx = hash_ngram(
                compressed.tolist(),
                ngram_size,
                head_idx,
                table_size
            )
            embeddings.append(desk(hash_idx))

    return np.concatenate(embeddings)


# Initialize random embedding tables
tables = (
    (
        np.random.randn(5003, EMBEDDING_DIM // NUM_HEADS)
        for _ in vary(NUM_HEADS)
    )
    for _ in vary(MAX_NGRAM - 1)
)

consequence = multi_head_lookup((42, 108, 256), tables)
print(f"Retrieved embedding form: {consequence.form}")

Saída:

Compreendendo seus resultados:

Valor hash 292: Seu padrão de 2 gramas está localizado neste índice na tabela de incorporação. O valor muda junto com seus tokens de entrada, mostrando assim o mapeamento determinístico.

Forma (256,): Um whole de 8 incorporações foram recuperadas (2 tamanhos de N gramas × 4 cabeças cada), onde cada incorporação tem uma dimensão de 32 (EMBEDDING_DIM = 128 / NUM_HEADS = 4). Concatenado: 8 × 32 = 256 dimensões.

Observação: Você também pode ver a implementação do Engram por meio da lógica central do Módulo engrama.

Ganhos de desempenho no mundo actual

O fato de o Engram poder ajudar nas tarefas de conhecimento é uma grande vantagem, mas na verdade torna o raciocínio e a geração de código significativamente melhores da mesma forma.

O engrama transfere o reconhecimento de padrões locais para pesquisas de memória e, portanto, os mecanismos de atenção também podem funcionar no contexto world. A melhoria no desempenho neste caso é muito significativa. Durante o teste de benchmark RULER com janelas de contexto de 32k, o Engram conseguiu alcançar:

• NIAH multiconsulta: 97,0 (vs 84,2 linha de base)
• Rastreamento de variáveis: 89,0 (vs 77,0 da linha de base)
• Extração de palavras comuns: 99,6 (vs 73,0 linha de base)

Conclusão

O Engram revela caminhos de pesquisa muito interessantes. É possível substituir as funções fixas por hashing aprendido? E se a memória for dinâmica e atualizada em tempo actual durante a inferência? Qual será a resposta em termos de processamento de contextos maiores?

O repositório Engram do DeepSeek-AI possui detalhes técnicos e códigos completos, e o método já está sendo adotado em sistemas da vida actual. A principal conclusão é que o desenvolvimento da IA ​​não é apenas uma questão de modelos maiores ou de melhores rotas. Às vezes é uma busca pelas ferramentas adequadas para os modelos e às vezes essa ferramenta é simplesmente um sistema de memória muito eficiente.

Perguntas frequentes

Estagiário de Ciência de Dados na Analytics Vidhya
Atualmente estou trabalhando como Trainee de Ciência de Dados na Analytics Vidhya, onde me concentro na construção de soluções baseadas em dados e na aplicação de técnicas de IA/ML para resolver problemas de negócios do mundo actual. Meu trabalho me permite explorar análises avançadas, aprendizado de máquina e aplicações de IA que capacitam as organizações a tomar decisões mais inteligentes e baseadas em evidências.
Com uma base sólida em ciência da computação, desenvolvimento de software program e análise de dados, sou apaixonado por aproveitar a IA para criar soluções impactantes e escaláveis ​​que preencham a lacuna entre tecnologia e negócios.
📩 Você também pode entrar em contato comigo em (e-mail protegido)