QwenLong-L1.5: Long-Context Reasoning mit speichergestützter KI

Large Language Models (LLMs) entwickeln sich im Bereich logisches Schlussfolgern rasant weiter. Long-Context Reasoning bleibt jedoch weiterhin eine der anspruchsvollsten Herausforderungen. Zwar haben Pretraining-Verfahren die Kontextfenster bereits auf Hunderttausende Tokens erweitert, doch Post-Training-Methoden, mit denen Modelle über extrem große Dokumente hinweg zuverlässig argumentieren können, befinden sich noch in einer frühen Entwicklungsphase.

QwenLong-L1.5, vorgestellt vom Alibaba Tongyi Lab, setzt genau an dieser Stelle an. Das Modell nutzt einen vollständigen Post-Training-Ansatz, der mehrere zentrale Komponenten miteinander verbindet:

• Datensynthese für lange Kontexte
• Reinforcement Learning, das für lange Sequenzen optimiert wurde
• Ein Memory-Management-Framework, das über das physische Kontextfenster des Modells hinausgeht

In diesem Artikel werden folgende Themen behandelt:

• Was QwenLong-L1.5 besonders macht
• Wie die speichergestützte Reasoning-Architektur funktioniert
• Wie QwenLong-L1.5 auf einem Cloud-GPU-Server ausgeführt wird
• Praktischer Inference-Code für Long-Context-Workloads

Wichtige Erkenntnisse

• QwenLong-L1.5 wurde gezielt für Long-Context Reasoning entwickelt und adressiert typische Einschränkungen klassischer LLMs beim Umgang mit großen Dokumenten oder langen Konversationen.
• QwenLong-L1.5 basiert auf dem Modell Qwen3-30B-A3B-Thinking und bietet starke Fähigkeiten in den Bereichen Reasoning und Planung.
• Statt sich auf einfache Trainingsaufgaben zu stützen, nutzt das Modell strukturierte Datensynthese und Multi-Hop-Reasoning-Aufgaben, die reale Anwendungsszenarien besser abbilden.
• Das Modell führt Adaptive Entropy-Controlled Policy Optimization (AEPO) ein, um Reinforcement Learning bei sehr langen Sequenzen zu stabilisieren.
• Es wird mit Reinforcement-Learning-Methoden trainiert, die speziell auf lange Sequenzen ausgelegt sind. Dazu gehört AEPO, das Stabilität und Lerneffizienz verbessert.
• Ein mehrstufiges Memory-Fusion-Framework ermöglicht Reasoning über das native Kontextfenster von 256K Tokens hinaus, indem Informationen zusammengefasst, gespeichert und iterativ wiederverwendet werden.
• Diese Verbesserungen stärken nicht nur Long-Context-Aufgaben, sondern auch die allgemeine Reasoning-Qualität, etwa in Mathematik, Tool-Nutzung und dialogischer Kohärenz.
• Obwohl das Modell ein natives Kontextfenster von 256K Tokens besitzt, kann es durch sein Memory-Management-Framework effektiv über Informationen nahezu unbegrenzter Länge hinweg argumentieren.

Was ist QwenLong-L1.5?

QwenLong-L1.5 ist ein Long-Context-Reasoning-Modell, das auf Qwen3-30B-A3B-Thinking aufbaut. Es erweitert das Basismodell durch fortschrittliche Post-Training-Techniken. Dadurch kann es über Dokumente argumentieren, die deutlich größer als 256K Tokens sind, Multi-Hop-Reasoning über weit verteilte Informationen hinweg durchführen und auch bei extrem langen Eingabesequenzen ein stabiles Training beibehalten.

Warum Long-Context Post-Training wichtig ist

Viele LLMs scheitern nicht daran, dass ihnen Informationen fehlen. Häufig entstehen Probleme, weil sie:

• früher genannte Fakten aus dem Blick verlieren
• Schwierigkeiten mit Multi-Hop-Reasoning haben
• bei Long-Sequence-Reinforcement-Learning mit Gradient Collapse konfrontiert werden

Zentrale Innovationen in QwenLong-L1.5

Long-Context Data Synthesis Pipeline

QwenLong-L1.5 verbessert Long-Context Reasoning auf drei zentrale Arten. Erstens verwendet das Modell nicht nur einfache Aufgaben nach dem Muster „finde eine einzelne Information“, sondern erzeugt anspruchsvollere Trainingsdaten. Dafür werden Dokumente in kleinere Fakten zerlegt und Fragen erstellt, bei denen das Modell Informationen aus vielen unterschiedlichen Textbereichen miteinander verknüpfen muss. Zweitens kommen Reinforcement-Learning-Techniken zum Einsatz, die speziell dafür entwickelt wurden, das Training bei sehr langen Eingaben stabil zu halten. Dazu zählt AEPO, eine Methode, die kontrolliert steuert, wie das Modell bei zunehmender Textlänge lernt. Drittens enthält QwenLong-L1.5 ein Speichersystem, weil manche Aufgaben größer sind als das, was ein Modell auf einmal verarbeiten kann. Dieses System ermöglicht es, wichtige Informationen über mehrere Schritte hinweg zusammenzufassen, zu speichern und erneut zu verwenden. So kann das Modell auch über sein reguläres Kontextfenster hinaus effektiv argumentieren.

Adaptive Entropy-Controlled Policy Optimization (AEPO)

Das Training mit langen Sequenzen kann bei herkömmlichem Reinforcement Learning zu Policy Collapse führen. QwenLong-L1.5 nutzt dafür AEPO, eine Methode, die:

• Entropy Constraints dynamisch anpasst
• Gradient Explosion reduzieren hilft
• Curriculum Learning mit schrittweise längeren Sequenzen unterstützt

Memory Management über das Kontextfenster hinaus

QwenLong-L1.5 verwendet ein mehrstufiges Memory-Fusion-Framework, um Reasoning über Informationen zu ermöglichen, die das native 256K-Token-Kontextfenster deutlich überschreiten. Im ersten Schritt führt das Modell ein Single-Pass-Reasoning über einen großen Textabschnitt aus, der noch in den verfügbaren Kontext passt. Dabei extrahiert es wichtige Signale und Zwischenergebnisse des Reasonings. Diese relevanten Details werden anschließend zusammengefasst und in eine strukturierte Memory-Repräsentation komprimiert, die wesentliche Fakten erhält und redundante Informationen entfernt.

Im nächsten Schritt wird dieser Speicher iterativ aktualisiert, während das Modell neue Dokumentabschnitte verarbeitet. Dadurch können bereits gespeicherte Informationen verfeinert, erweitert oder korrigiert werden. Abschließend sorgt ein fusionbasierter Reinforcement-Learning-Ansatz dafür, dass der Reasoning-Prozess des Modells mit den Memory-Updates abgestimmt bleibt. So unterstützt der gespeicherte Kontext die Genauigkeit der Schlussfolgerungen direkt, statt irrelevant zu werden oder vom eigentlichen Ziel abzuweichen. Zusammengenommen ermöglichen diese Schritte QwenLong-L1.5, sehr große Dokumentströme zu verarbeiten, über lange Textabschnitte hinweg kohärent zu bleiben und mehrstufige iterative Reasoning-Schleifen auszuführen, die in einem einzelnen Kontextfenster nicht möglich wären.

QwenLong-L1.5 Performance

Ein Benchmark-Vergleich zeigt, dass QwenLong-L1.5-30B-A3B durchgehend besser abschneidet als sein Basismodell Qwen3-30B-A3B-Thinking und gleichzeitig mit führenden Long-Context-Modellen wie Gemini-2.5-Pro, Gemini-2.5-Flash-Thinking, DeepSeek-R1 und Qwen3-Max-Thinking sehr konkurrenzfähig bleibt. In verschiedenen Long-Context-Aufgaben, darunter Multi-Document Reading Comprehension (MRCR), CorpusQA, dokumentbasiertes mathematisches Reasoning (DocMath) und LongBench-Evaluierungen, erzielt QwenLong-L1.5 starke und ausgewogene Ergebnisse. Besonders relevant ist, dass das Modell deutliche Verbesserungen bei reasoning-intensiven und memory-lastigen Benchmarks wie LongBench-V1, Frames und LongBench-V2 erreicht und damit insgesamt die höchste oder nahezu höchste durchschnittliche Genauigkeit erzielt. Diese Resultate verdeutlichen, dass die Post-Training-Strategien und das Memory-Fusion-Framework von QwenLong-L1.5 zu praktischen Verbesserungen für reale Long-Context-Reasoning-Aufgaben führen und nicht nur auf einzelne Benchmarks beschränkt sind.

Warum QwenLong-L1.5 auf Cloud GPUs ausführen?

Cloud-GPU-Server eignen sich besonders gut für Long-Context Inference, weil sie folgende Vorteile bieten:

• NVIDIA-GPUs mit großem Speicher, etwa H100- und H200-Modelle
• Planbare Infrastrukturkosten
• Effiziente und unkomplizierte GPU-Einrichtung
• Vollen SSH- und CUDA-Zugriff

Empfohlene GPU-Konfiguration

Schritt 1: Cloud-GPU-Server erstellen

Erstellen Sie zunächst einen Cloud-GPU-Server, der die benötigten Rechenressourcen für die Ausführung des Modells bereitstellt.

Wählen Sie:

• Image: Ubuntu 22.04
• GPU: H100 oder A100
• 80 GB VRAM, da lange Kontexte viel Speicher benötigen

Eine passende Einrichtungsanleitung im Ressourcenbereich kann genutzt werden, um mehr über die Erstellung eines Cloud-GPU-Servers zu erfahren.

Schritt 2: Umgebung einrichten

Bereiten Sie die Systemumgebung vor, indem Sie die erforderlichen Treiber, Bibliotheken und Abhängigkeiten installieren. So ist der GPU-Server für KI-Entwicklung und Modellausführung vorbereitet.

# Update system
sudo apt update && sudo apt upgrade -y

			

# Install Python tools
sudo apt install -y python3-pip git

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate

Schritt 3: Abhängigkeiten installieren

Installieren Sie die benötigten Softwarepakete, Frameworks und Bibliotheken, die für die Ausführung des Modells erforderlich sind.

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121


# Verify Installation
python - <<EOF
import torch
print("Torch version:", torch.__version__)
print("CUDA available:", torch.cuda.is_available())
EOF

Schritt 4: Bei Hugging Face anmelden

Authentifizieren Sie sich bei Hugging Face, um auf Modelle, Datensätze und Tokens zuzugreifen, die für das Herunterladen und Ausführen vortrainierter Modelle benötigt werden.

pip install -U huggingface_hub
hf auth login

Fügen Sie Ihr Hugging-Face-Zugriffstoken ein, sobald Sie dazu aufgefordert werden. Das Token kann in Hugging Face unter Settings und Access Tokens erstellt werden.

Schritt 5: QwenLong-L1.5 auf den Cloud-GPU-Server herunterladen

Laden Sie das Modell QwenLong-L1.5 auf Ihren Cloud-GPU-Server herunter.

hf download Tongyi-Zhiwen/QwenLong-L1.5-30B-A3B

Schritt 6: verl installieren

# Install verl, we use the 0.4 version of verl
git clone --branch v0.4 https://github.com/volcengine/verl.git
cd verl
pip3 install -e .

Schritt 7: Modell verwenden

Laden Sie das QwenLong-L1.5-Modell und starten Sie Inference-Läufe oder Experimente, um die Long-Context-Reasoning-Fähigkeiten zu nutzen.

# Load the model
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Tongyi-Zhiwen/QwenLong-L1.5-30B-A3B"

tokenizer = AutoTokenizer.from_pretrained(model_name)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

Verwenden Sie device_map="auto", um die Modellgewichte effizient über den GPU-Speicher zu verteilen.

Schritt 8: Beispiel für Long-Context Inference

Führen Sie eine Inference mit längeren Eingabesequenzen aus, um zu sehen, wie QwenLong-L1.5 Long-Context- und Multi-Hop-Reasoning in der Praxis verarbeitet.

Langen Roman aus dem Internet herunterladen

import requests

url = "https://www.gutenberg.org/files/1342/1342-0.txt"
output_file = "novel.txt"

response = requests.get(url)
response.raise_for_status()

with open(output_file, "w", encoding="utf-8") as f:
    f.write(response.text)

print("Novel downloaded successfully.")

Ersetzen Sie die URL durch Ihre eigene Datenquelle.

Roman laden und vorbereiten

Dieser Schritt ist optional.

def load_novel(path):
    with open(path, "r", encoding="utf-8") as f:
        text = f.read()

    # Optional cleanup
    start_marker = "*** START OF"
    end_marker = "*** END OF"

    if start_marker in text:
        text = text.split(start_marker)[-1]
    if end_marker in text:
        text = text.split(end_marker)[0]

    return text.strip()

novel_text = load_novel("novel.txt")
print(f"Novel length (characters): {len(novel_text)}")

Long-Context Prompt erstellen

question = (
    "Who is the main protagonist of the novel, "
    "and how does her personality evolve throughout the story?"
)

template = """
Please read the following novel and answer the question below.

<novel>
{novel}
</novel>

Question:
{question}

Format your response as:
"Therefore, the answer is (your answer here)"
"""

prompt = template.format(
    novel=novel_text,
    question=question
)

Tokenisieren und Inference ausführen

Long-Context Inference benötigt erhebliche GPU-Ressourcen. Stellen Sie daher sicher, dass ausreichend GPU-Speicher verfügbar ist.

messages = [
    {"role": "user", "content": prompt}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

inputs = tokenizer(
    [text],
    return_tensors="pt"
).to(model.device)

			

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=2000,
        temperature=0.7,
        top_p=0.95
    )

output_ids = outputs[0][len(inputs.input_ids[0]):].tolist()

try:
    # token id for </think>
    end_think_idx = len(output_ids) - output_ids[::-1].index(151668)
except ValueError:
    end_think_idx = 0

thinking = tokenizer.decode(
    output_ids[:end_think_idx],
    skip_special_tokens=True
).strip()

final_answer = tokenizer.decode(
    output_ids[end_think_idx:],
    skip_special_tokens=True
).strip()

print("Reasoning:\n", thinking)
print("\nAnswer:\n", final_answer)