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

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

Ling-2.5-1T d’Ant Group (publié le 16 février 2026) est l’un des plus grands modèles de langage open source jamais publiés — 1 000 milliards de paramètres au total, 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. En parallèle, Ant Group a publié Ring-2.5-1T, le premier modèle de réflexion au monde à architecture linéaire hybride. Ensemble, ils représentent une nouvelle frontière de l’IA open source — compétitifs face à GPT-5.2, DeepSeek V3.2 et Kimi K2.5 sur les benchmarks de raisonnement et d’agents.

HuggingFace : inclusionAI/Ling-2.5-1T Modèle compagnon : inclusionAI/Ring-2.5-1T (variante de réflexion/raisonnement) Licence : Open source (licence InclusionAI d’Ant Group)

Caractéristiques clés

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

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

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

• Raisonnement de pointe — se rapproche des performances d’un modèle de réflexion tout en utilisant environ 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 de raisonnement dédiée atteint le niveau médaille d’or à l’IMO 2025 et à la 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

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines listées aujourd'hui sont des 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et des 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est vendue en serveur nu sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Exécuter Ling-2.5-1T en pleine précision nécessite d’importantes ressources. 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.8+	12.8+	12.8+

Configuration Clore.ai recommandée :

• Quantifié (Q4) : 8× RTX 4090 (1,12–3,36 $/h) — utilisable pour l’expérimentation et des charges de travail modérées

• Production (FP8) : 8× H100 (~8,32 $/h) — qualité complète avec un bon débit

• Remarque : Il s’agit d’un modèle extrêmement volumineux. Pour les utilisateurs soucieux de leur budget, envisagez les modèles plus petits de la famille Ling sur HuggingFace.

Démarrage rapide avec vLLM

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

# Installer vLLM
pip install vllm

# Diffuser 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 sur 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 sur HuggingFace les quantifications disponibles)
huggingface-cli download inclusionAI/Ling-2.5-1T-GGUF \\
    --include "*.Q4_K_M.gguf" \\
    --local-dir ./models/

# Diffuser avec llama-server (ajustez -ngl selon votre nombre de 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 chat 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="not-needed"
)

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant de raisonnement de classe mondiale. Réfléchissez étape par étape."},
        {"role": "user", "content": "Prouve que la racine carrée de 2 est irrationnelle."}
    ],
    temperature=0.1,
    max_tokens=4096
)

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

2. Analyse de documents à long contexte

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 gros document
with open("full_codebase.txt", "r") as f:
    codebase = f.read()  # Peut représenter 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 à la recherche de vulnérabilités de sécurité et de problèmes d’architecture:\n\n{codebase}"}
    ],
    temperature=0.1,
    max_tokens=8192
)

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

3. Utilisation d’outils agentique

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 produits",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "category": {"type": "string", "enum": ["électronique", "vêtements", "livres"]},
                    "max_price": {"type": "number"}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[{"role": "user", "content": "Trouvez-moi un ordinateur portable à moins de 1000 $ avec de bons avis"}],
    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 réflexion (raisonnement)
Architecture	Attention linéaire hybride	Attention linéaire hybride
Idéal pour	Chat général, codage, tâches agentiques	Mathématiques, raisonnement formel, problèmes complexes
Style de sortie	Réponses directes	Raisonnement en chaîne de pensée
Efficacité en tokens	Élevée (moins de tokens de sortie)	Utilise davantage 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 — Avec 1T de paramètres, même une quantification Q4 nécessite environ 500 Go de stockage et plus de 192 Go de VRAM. Assurez-vous que votre instance Clore.ai dispose d’assez d’espace disque et de plusieurs GPU avant de télécharger.

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

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

4. Envisagez Ring-2.5-1T pour les tâches de raisonnement — Si votre cas d’usage porte principalement sur 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 mémoire et repérer les OOM pendant la génération avec de longs contextes.

Dépannage

Problème	Solution
Mémoire CUDA insuffisante	Réduisez --max-model-len; assurez-vous que --tensor-parallel-size correspond 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 également que vous disposez de NVLink entre les GPU
Le téléchargement du modèle échoue	Le modèle fait environ 2 To en BF16. Assurez-vous d’avoir suffisamment d’espace disque. Utilisez --resume-download avec l’option huggingface-cli
vLLM ne prend pas en charge cette architecture	Assurez-vous d’utiliser vLLM ≥0.7.0 avec --trust-remote-code; les couches d’attention personnalisées nécessitent cette option
GGUF non disponible	Vérifiez unsloth ou les quantifications communautaires ; le modèle peut prendre du temps à être quantifié par la communauté
Réponses de mauvaise qualité	Utilisez une température ≤0,1 pour les tâches factuelles ; ajoutez un prompt système ; assurez-vous de ne pas tronquer le contexte

Pour aller plus loin

• 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 réflexion

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

• Documentation vLLM — Framework de diffusion