Ling-2.5-1T (1 trillion de paramètres)

Exécutez Ling-2.5-1T — le LLM open-source à 1 trillion de paramètres d'Ant Group avec attention linéaire hybride sur les GPU Clore.ai

Ling-2.5-1T par Ant Group (publié le 16 février 2026) est l'un des plus grands modèles de langage open source jamais publiés — 1 billion de paramètres au total avec 63B actifs. Il introduit une architecture d'attention linéaire hybride qui permet une inférence efficace sur des longueurs de contexte allant jusqu'à 1 million de tokens. Parallèlement, Ant Group a publié Ring-2.5-1T, le premier modèle de pensée au monde à architecture linéaire hybride. Ensemble, ils représentent une nouvelle frontière de l'IA open source — compétitifs avec GPT-5.2, DeepSeek V3.2 et Kimi K2.5 sur les benchmarks de raisonnement et d'agentivité.

HuggingFace : inclusionAI/Ling-2.5-1T Modèle compagnon : inclusionAI/Ring-2.5-1T (variante pensée/raisonnement) Licence : Open source (Licence Ant Group InclusionAI)

Principales caractéristiques

• 1 billion de paramètres au total, 63B actifs — échelle massive avec activation de type MoE efficace

• Attention linéaire hybride — combine MLA (Multi-head Linear Attention) avec Lightning Linear Attention pour un débit exceptionnel sur de longues séquences

• Fenêtre de contexte de 1M tokens — via l'extension YaRN depuis le natif 256K, gère des bases de code entières et des documents de la taille d'un livre

• Raisonnement de pointe — approche les performances des modèles de pensée tout en utilisant ~4× moins de tokens de sortie

• Capacités agentiques — entraîné avec Agentic RL, compatible avec Claude Code, OpenCode et OpenClaw

• Compagnon Ring-2.5-1T — la variante dédiée au raisonnement atteint un niveau médaille d'or IMO 2025 et CMO 2025

Détails de l'architecture

Composant	Détails
Paramètres totaux	1T (1 000B)
Paramètres actifs	63B
Architecture	Attention linéaire hybride (MLA + Lightning Linear)
Données de pré-entraînement	29T tokens
Contexte natif	256K tokens
Contexte étendu	1M tokens (YaRN)
Date de sortie	16 février 2026

Exigences

Exécuter Ling-2.5-1T en pleine précision nécessite des ressources substantielles. Les versions quantifiées le rendent plus accessible.

Configuration	Quantifié (Q4 GGUF)	FP8	BF16 (Complet)
GPU	8× RTX 4090	8× H100 80GB	16× H100 80GB
VRAM	8×24GB (192GB)	8×80GB (640GB)	16×80GB (1,28TB)
RAM	256GB	512GB	1TB
Disque	600GB	1,2TB	2TB+
CUDA	12.0+	12.0+	12.0+

Configuration Clore.ai recommandée :

• Quantifié (Q4) : 8× RTX 4090 (~4–16 $/jour) — utilisable pour l'expérimentation et des charges modérées

• Production (FP8) : 8× H100 (~24–48 $/jour) — qualité complète avec un bon débit

• Remarque : Ceci est un modèle extrêmement grand. Pour les utilisateurs soucieux du budget, envisagez les modèles plus petits de la famille Ling sur HuggingFace.

Démarrage rapide avec vLLM

vLLM est le framework de service recommandé pour Ling-2.5-1T :

# Installer vLLM
pip install vllm

# Servir Ling-2.5-1T avec parallélisme tensoriel sur 8 GPU
vllm serve inclusionAI/Ling-2.5-1T \
    --tensor-parallel-size 8 \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# Pour réduire la mémoire, limitez la longueur du contexte :
vllm serve inclusionAI/Ling-2.5-1T \
    --tensor-parallel-size 8 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.95 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

Démarrage rapide avec llama.cpp (Quantifié)

Pour les configurations GPU grand public, des quantifications GGUF sont disponibles :

# Installer llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Télécharger un GGUF quantifié (vérifiez HuggingFace pour les quants disponibles)
huggingface-cli download inclusionAI/Ling-2.5-1T-GGUF \
    --include "*.Q4_K_M.gguf" \
    --local-dir ./models/

# Servir avec llama-server (ajustez -ngl selon le nombre de vos GPU)
./build/bin/llama-server \
    -m ./models/Ling-2.5-1T-Q4_K_M.gguf \
    -ngl 99 \
    -c 8192 \
    --host 0.0.0.0 \
    --port 8000

Exemples d'utilisation

1. Complétion de conversation via l'API OpenAI

Une fois vLLM ou llama-server en cours d'exécution :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="non-nécessaire"
)

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant de raisonnement de classe mondiale. Pensez étape par étape."},
        {"role": "user", "content": "Prove that the square root of 2 is irrational."}
    ],
    temperature=0.1,
    max_tokens=4096
)

print(response.choices[0].message.content)

2. Analyse de documents longue portée

L'attention linéaire hybride de Ling-2.5-1T le rend exceptionnellement efficace pour les longs documents :

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

# Charger un grand document
with open("full_codebase.txt", "r") as f:
    codebase = f.read()  # Peut contenir des centaines de milliers de tokens

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Vous êtes un architecte logiciel senior."},
        {"role": "user", "content": f"Analysez cette base de code pour des vulnérabilités de sécurité et des problèmes d'architecture:\n\n{codebase}"}
    ],
    temperature=0.1,
    max_tokens=8192
)

print(response.choices[0].message.content)

3. Utilisation agentique des outils

Ling-2.5-1T est entraîné avec Agentic RL pour l'appel d'outils :

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Rechercher dans la base de données produit",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "category": {"type": "string", "enum": ["electronics", "clothing", "books"]},
                    "max_price": {"type": "number"}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[{"role": "user", "content": "Trouvez-moi un portable à moins de 1000 $ avec de bonnes évaluations"}],
    tools=tools,
    tool_choice="auto"
)

print(response.choices[0].message.tool_calls)

Ling-2.5-1T vs Ring-2.5-1T

Aspect	Ling-2.5-1T	Ring-2.5-1T
Type	Modèle instantané (rapide)	Modèle de pensée (raisonnement)
Architecture	Attention linéaire hybride	Attention linéaire hybride
Idéal pour	Chat général, codage, tâches agentiques	Maths, raisonnement formel, problèmes complexes
Style de sortie	Réponses directes	Raisonnement en chaîne de pensée
Efficacité des tokens	Élevée (moins de tokens de sortie)	Utilise plus de tokens pour le raisonnement
IMO 2025	Compétitif	Niveau médaille d'or

Conseils pour les utilisateurs de Clore.ai

1. Ce modèle nécessite du matériel sérieux — À 1T de paramètres, même la quantification Q4 nécessite ~500GB de stockage et 192GB+ de VRAM. Assurez-vous que votre instance Clore.ai dispose d'un disque et de multi-GPU suffisants avant le téléchargement.

2. Commencez par --max-model-len 8192 — Lors des premiers tests, utilisez un contexte court pour vérifier que le modèle se charge et fonctionne correctement. Augmentez la longueur du contexte une fois que tout fonctionne.

3. Utilisez un stockage persistant — Le modèle pèse 1–2TB. Attachez un grand volume persistant sur Clore.ai pour éviter de retélécharger. Téléchargez une fois avec huggingface-cli download.

4. Envisagez Ring-2.5-1T pour les tâches de raisonnement — Si votre cas d'utilisation est principalement les mathématiques, la logique ou le raisonnement formel, le modèle compagnon Ring-2.5-1T est spécifiquement optimisé pour le raisonnement en chaîne de pensée.

5. Surveillez la mémoire GPU — Avec des configurations 8-GPU, utilisez nvidia-smi -l 1 pour surveiller l'utilisation de la mémoire et surveiller les OOM pendant la génération avec de longs contextes.

Dépannage

Problème	Solution
CUDA out of memory	Réduire --max-model-len; assurez-vous --tensor-parallel-size corresponde au nombre de GPU ; essayez --gpu-memory-utilization 0.95
Génération très lente	L'attention linéaire nécessite un échauffement ; les premières requêtes peuvent être lentes. Vérifiez aussi que vous avez NVLink entre les GPU
Échec du téléchargement du modèle	Le modèle fait ~2TB en BF16. Assurez-vous d'avoir suffisamment d'espace disque. Utilisez --resume-download le flag avec huggingface-cli
vLLM ne prend pas en charge l'architecture	Assurez-vous d'utiliser vLLM ≥0.7.0 avec --trust-remote-code; les couches d'attention personnalisées nécessitent ce flag
GGUF non disponible	Vérifiez unsloth ou les quantifications communautaires ; il se peut que le modèle prenne du temps avant d'être quantifié par la communauté
Réponses de mauvaise qualité	Utilisez une température ≤0.1 pour les tâches factuelles ; ajoutez une invitation système ; assurez-vous de ne pas tronquer le contexte

Lectures complémentaires

• Annonce officielle (BusinessWire) — détails de la sortie et benchmarks

• HuggingFace — Ling-2.5-1T — poids du modèle et documentation

• HuggingFace — Ring-2.5-1T — Modèle compagnon de pensée

• Miroir ModelScope — Téléchargements plus rapides en Asie

• Documentation vLLM — Framework de service