Hoe je een miljoen tokens in een gewone GPU past met Kimi Linear

Heb je je ooit afgevraagd waarom het werken met lange teksten in LLMs zo duur is? Het draait allemaal om de KV-cache. Wanneer je een enorm document aan een model voedt, zwelt zijn "geheugen" (de cache) op tot obscene groottes, en vreet al je videogeheugen op. De mensen bij MoonshotAI hebben besloten dat het tijd is om hier iets aan te doen, en lanceerden Kimi Linear. Dit is niet zomaar een ander "verbeterd" model—het is een poging om de attention-architectuur te heroverwegen zodat we kunnen werken met een miljoen-token context zonder een serverfarm te hoeven kopen.

Wat is het probleem met standaard attention

Het standaard Full Attention-mechanisme (dat in klassieke transformers) is een gulzig beest. De complexiteit groeit kwadratisch met de tekstlengte. Wil je een twee keer zo grote context? Maak je dan maar klaar om vier keer zoveel resources te gebruiken. Populaire oplossingen zoals Flash Attention of DeepSeek's MLA (Multi-head Latent Attention) helpen, maar lossen het probleem niet radicaal op als het gaat om echt lange sequenties.

Kimi Linear pakt het anders aan. De ontwikkelaars gebruikten een hybride methode die de sterke punten van transformers en RNN-achtige structuren combineert.

Hoe Kimi Delta Attention werkt

De kern van het project is het Kimi Delta Attention (KDA)-mechanisme. Zonder in hardcore wiskunde te duiken, is het een evolutie van het Gated DeltaNet-concept. De belangrijkste truc hier is slim "vergeten".

In een standaard RNN wordt het geheugen beperkt door een vaste staatgrootte. KDA gebruikt een gating-mechanisme dat bepaalt welke informatie uit het verleden in deze gecomprimeerde staat moet worden bewaard en welke kan worden weggegooid. Dit stelt het model in staat om hoge nauwkeurigheid te behouden, zelfs over enorme afstanden, waar conventionele lineaire modellen beginnen te "drijven" en de draad van het verhaal verliezen.

Wat dit in de praktijk oplevert

De ontwikkelaars introduceerden een architectuur waarin KDA en MLA (Global Attention) worden gemengd in een verhouding van 3:1. Deze combinatie leverde verschillende indrukwekkende resultaten op:

1. Geheugenbesparing. KV-cache vereisten daalden met 75%. Dit is cruciaal bij het deployen van het model op je eigen hardware.
2. Generatiesnelheid. Bij een context van 1 miljoen tokens neemt de token-doorvoer tot 6x toe vergeleken met standaard architecturen.
3. Eerlijke context. Benchmark-tests op RULER tonen aan dat het model daadwerkelijk "ziet" en informatie gebruikt doorheen alle 128k (en tot 1M) tokens, niet alleen doet alsof.

De onderstaande grafieken tonen hoe Kimi Linear (blauwe lijn) uitloopt in snelheid naarmate de contextlengte groeit:

Uitproberen

MoonshotAI heeft niet achtergehouden en releasede modelgewichten op Hugging Face. Er is een base-versie en een Instruct-variant met 48 miljard parameters. Dankzij de Mixture-of-Experts (MoE)-architectuur worden slechts 3 miljard parameters geactiveerd tijdens de berekening, waardoor het model verrassend licht is voor zijn klasse.

Om te beginnen heb je de nieuwste PyTorch en de fla-core bibliotheek nodig. De code ziet er vrij standaard uit voor iedereen die met transformers heeft gewerkt:

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "moonshotai/Kimi-Linear-48B-A3B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

# Обычный чат-шаблон
messages = [
    {"role": "system", "content": "You are a helpful assistant provided by Moonshot-AI."},
    {"role": "user", "content": "Расскажи, в чем преимущество линейного внимания перед обычным?"}
]

input_ids = tokenizer.apply_chat_template(
    messages, 
    add_generation_prompt=True, 
    return_tensors="pt"
).to(model.device)

generated_ids = model.generate(inputs=input_ids, max_new_tokens=500)
response = tokenizer.batch_decode(generated_ids)[0]
print(response)

Als je dit in productie wilt deployen, werkt het model goed samen met vLLM. Je kunt een OpenAI-compatibele API opstarten met een enkele terminalopdracht, met een enorme max-model-len.

Is het de moeite waard om te downloaden

Het project ziet er veelbelovend uit voor degenen die RAG-systemen bouwen of lange logs en documenten analyseren.

Wie zou zeker eens nader moeten kijken:

• Degenen die tegen de geheugenlimiet van GPU's zijn aangelopen bij het werken met lange contexten.
• Ontwikkelaars die om antwoordsnelheid (TPOT) in real time geven.
• Onderzoekers die op zoek zijn naar alternatieven voor standaard transformers.

Aan de negatieve kant is de architectuur relatief nieuw, en ondersteuning in tools van derden (zoals kwantisatie of specifieke optimizers) komt mogelijk niet direct beschikbaar. Maar het hebben van kant-en-klare KDA-kernels in de FLA-bibliotheek is bemoedigend.

Kimi Linear is een goed voorbeeld dat algoritme-optimalisatie nog steeds grotere winst kan opleveren dan simpelweg meer teraflops stapelen. Als je een hele bibliotheek of enorme codebase in één keer moet "verwerken"—dit is waarschijnlijk een van de meest interessante tools die momenteel beschikbaar zijn.