Qwen3.8-27B (VLM dense, une carte)

Déployez Qwen3.8-27B sur Clore.ai — le modèle vision-langage dense 27B d'Alibaba qui fonctionne sur une seule RTX 4090 en Q4 et une seule RTX 5090 en FP8

Statut (août 2026) : Qwen a publié Qwen3.8-27B le 14 août 2026 sous Apache 2.0, avec un checkpoint FP8 officiel un jour plus tard. Poids : Qwen/Qwen3.8-27B et Qwen/Qwen3.8-27B-FP8. 27B dense, vision-langage native, contexte de 262 144 jetons extensible jusqu’à 1 M avec YaRN, prise en charge dès le premier jour dans vLLM, SGLang et llama.cpp.

La plupart de ce qui est sorti cet été ne peut pas être loué. GLM-5.2 fait 756 Go en FP8. MiniMax M3 fait 854 Go. Kimi K3 fait 1,5 To et ne tient sur aucune machine répertoriée sur Clore.ai, quelle que soit la quantization. Qwen3.8-27B est le contrepoids : 27B de paramètres denses, 15,4 Go en Q4, une carte, un conteneur, terminé. C’est le modèle pour lequel ce marché est réellement conçu — lors de la dernière capture, 677 serveurs avaient une carte de 24 Go ou plus disponible.

Ce n’est pas non plus un modèle allégé. Il gère nativement les images et la vidéo, expose un reasoning_effort réglage, et sa pile d’attention hybride maintient le cache KV assez petit pour qu’un long contexte sur une carte grand public soit réaliste plutôt que théorique.

Spécifications clés

Propriété

Valeur

Paramètres

27B (dense)

Architecture

64 couches, Gated DeltaNet hybride + Gated Attention, MTP

Modalité

Texte, image, vidéo en entrée → texte en sortie

Contexte natif

262 144 tokens

Contexte étendu

1 000 000 tokens (YaRN)

Licence

Apache 2.0

Date de sortie

14 août 2026

Poids

BF16 55,6 Go · FP8 30,9 Go · Q4_K_S GGUF 15,4 Go

Outils principaux

vLLM, SGLang, llama.cpp, Ollama

Pourquoi celui-ci

Ça tient. Q4 sur une seule RTX 3090 ou 4090 à 0,07–0,42 $/h; FP8 sur une RTX PRO 6000 ou 2× cartes de 24 Go
Apache 2.0 — usage commercial, fine-tuning et redistribution sans clause de revenus, contrairement à Kimi K3 (licence personnalisée avec seuil de revenus) ou MiniMax M3 (licence communautaire)
Attention hybride — 3 blocs de couche sur 4 sont des Gated DeltaNet (attention linéaire), donc le cache KV augmente beaucoup plus lentement avec le contexte que dans un transformeur standard. C’est ce qui rend un contexte de plus de 100K utilisable sur 24 Go
Vision intégrée — diagrammes, documents, captures d’écran et vidéo de plusieurs heures, sans VLM séparé à déployer
Contrôle du raisonnement — reasoning_effort à faible / moyen / xhigh, plus preserve_thinking pour transporter le raisonnement d’un tour à l’autre pour les agents

Exigences

Une seule carte, c’est tout l’intérêt. Une seule RTX 4090 en Q4 vous donne un modèle vision-langage de classe frontale pour à peu près le prix d’un café par jour. Passez à une RTX 5090 ou à une RTX PRO 6000 seulement si vous voulez une qualité FP8 ou un contexte très long.

Q4_K_S GGUF

Q8 / FP8

BF16

Poids

15,4 Go

~31 Go

55,6 Go

GPU

1× RTX 3090/4090 24 Go

1× RTX PRO 6000 96 Go, ou 2× RTX 5090

2× RTX PRO 6000, ou 4× RTX 5090

Contexte pratique

~64K

~200K

262K complet

RAM système

32 Go

64 Go

96GB

Disque

25 Go

45 Go

80 Go

CUDA

12.8+

Une seule RTX 5090 (32 Go) ne suffit pas pour FP8. Les poids seuls font 30,9 Go. Il faut de la marge pour le cache KV et les activations, donc FP8 nécessite soit une carte de 96 Go, soit deux GPU. Sur une seule 5090, utilisez Q6 ou Q4 — voir Compatibilité CUDA et PyTorch pour la bonne image de base sur Blackwell.

Option A — Ollama (chemin le plus rapide)

ollama pull qwen3.8:27b
ollama run qwen3.8:27b

# Point de terminaison compatible OpenAI
ollama serve &
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8:27b",
    "messages": [{"role": "user", "content": "Refactorez ce gestionnaire pour utiliser context.Context et ajoutez des tentatives de réessai."}],
    "temperature": 0.7
  }'

Le tag par défaut est Q4_K_M (~16 Go). Utilisez qwen3.8:27b-q8_0 si vous avez loué une carte de 96 Go.

Option B — vLLM (production)

Une seule carte de 24 Go, checkpoint AWQ INT4 communautaire :

# docker-compose.yml
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports: ["8000:8000"]
    volumes: [hf_cache:/root/.cache/huggingface]
    command: >
      --model cyankiwi/Qwen3.8-27B-AWQ-INT4
      --max-model-len 65536
      --gpu-memory-utilization 0.92
      --served-model-name qwen3.8-27b
      --enable-auto-tool-choice
      --tool-call-parser hermes
    deploy:
      resources:
        reservations:
          devices: [{driver: nvidia, count: 1, capabilities: [gpu]}]
    shm_size: "8gb"
volumes:
  hf_cache:

Qwen ne fournit officiellement que BF16 et FP8. Les checkpoints 4 bits sont des versions communautaires — cyankiwi/Qwen3.8-27B-AWQ-INT4 et RedHatAI/Qwen3.8-27B-INT4 sont les plus téléchargés, et unsloth/Qwen3.8-27B-NVFP4 cible spécifiquement les cartes Blackwell.

FP8 sur deux GPU :

vllm serve Qwen/Qwen3.8-27B-FP8 \\
  --tensor-parallel-size 2 \
  --max-model-len 262144 \\
  --gpu-memory-utilization 0.90 \\
  --enable-chunked-prefill

L’entrée vidéo nécessite un indicateur supplémentaire :

vllm serve Qwen/Qwen3.8-27B --media-io-kwargs '{"video": {"num_frames": -1}}'

Dépassez la fenêtre native avec YaRN :

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.8-27B \\
  --hf-overrides '{"text_config": {"rope_parameters": {"rope_type": "yarn", "factor": 4.0, "original_max_position_embeddings": 262144}}}' \\
  --max-model-len 1000000

Option C — llama.cpp / GGUF (cartes de 24 Go)

# Q4_K_S — 15,4 Go, confortable sur une carte de 24 Go
huggingface-cli download unsloth/Qwen3.8-27B-GGUF \\
  --include "*UD-Q4_K_S*" --local-dir /workspace/qwen38

llama-server -m /workspace/qwen38/*UD-Q4_K_S*.gguf \\
  --host 0.0.0.0 --port 8080 \
  -ngl 999 -c 65536 --flash-attn

Quants plus petits du même dépôt, pour les cartes plus limitées : UD-Q3_K_XL 13,1 Go, UD-Q2_K_XL 9,8 Go, UD-IQ2_S 8,4 Go.

Effort de raisonnement

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

resp = client.chat.completions.create(
    model="qwen3.8-27b",
    messages=[{"role": "user", "content": "Planifiez la migration par étapes."}],
    extra_body={"reasoning_effort": "xhigh"},   # xhigh (par défaut) | moyen | faible
)

Descendez à faible pour la classification, l’extraction et l’acheminement — la différence de qualité y est faible et la facture en tokens n’est qu’une fraction. Réservez xhigh pour les agents et le travail de code en plusieurs étapes.

Recommandations GPU Clore.ai

Configuration

VRAM

Mode

Contexte

Coût Clore.ai

1× RTX 3090

24GB

Q4 GGUF

~64K

0,07–0,21 $/h

1× RTX 4090

24GB

Q4 AWQ

~64K

0,14–0,42 $/h

1× RTX 5090

32 Go

Q6 GGUF

~96K

0,25–0,77 $/h

2× RTX 5090

64 Go

FP8, TP=2

~200K

0,50–1,54 $/h

1× RTX PRO 6000

96GB

FP8

262K complet

$0.92–1.38/hr

4× RTX 5090

128 Go

BF16, TP=4

262K complet

$1.00–3.08/hr

Meilleur rapport qualité-prix : un seul RTX 4090 à partir de 0,14 $/h en Q4. Si le prix de la configuration complète vous paraît élevé, rappelez-vous que la plupart des rigs multi-GPU permettent la location partielle — vous pouvez retirer une carte d’un boîtier de huit cartes.

Benchmarks

Les chiffres ci-dessous sont ceux de Qwen lui-même, tirés de la fiche modèle du 14 août 2026. Des reproductions indépendantes étaient encore en cours d’arrivée au moment de la rédaction.

Qwen évalue le 27B face à des modèles bien plus grands sur des suites de code et d’agents (SWE-bench Pro, DeepSWE, QwenSWEBench) en utilisant le banc d’essai Claude Code avec un contexte de 256K. L’affirmation importante pour le déploiement n’est pas un score unique : c’est qu’un 27B dense exécuté sur une seule carte grand public se place dans la même conversation que des modèles MoE qui exigent un rack. Considérez le tableau du fournisseur comme une hypothèse de départ et mesurez-le sur votre propre jeu de tâches — ici, c’est peu coûteux, puisqu’une heure de 4090 coûte environ vingt cents.

Cas d’usage

Assistant de codage sur un seul GPU — un conteneur, une carte, un point de terminaison compatible OpenAI
Compréhension de documents et de captures d’écran — vision native, sans pipeline séparé
Analyse vidéo — vidéo de plusieurs heures en un seul passage avec l’indicateur de trames de vLLM
RAG à long contexte — 262K natif, et l’attention hybride maintient le cache KV abordable
Agents d’exécution — preserve_thinking garde le raisonnement cohérent d’un appel d’outil à l’autre
Sur site et en environnement isolé — Apache 2.0, rien n’appelle à l’extérieur
Affinage LoRA — le 27B dense se prête bien à Unsloth et LLaMA-Factory sur une seule carte de 24 Go

Dépannage

Problème

Correctif

aucune image de noyau n’est disponible sur une 5090

Ancienne compilation CUDA — utilisez une image cu128, voir compatibilité

OOM en FP8 sur une seule RTX 5090

Attendu : 30,9 Go de poids sur une carte de 32 Go. Utilisez Q6/Q4, ou TP=2

OOM avec un long contexte sur 24 Go

Réduisez --max-model-len à 32 768, ou descendez à UD-Q3_K_XL

YaRN refusé

Nécessite une version récente de vLLM/SGLang ; faites-le passer via --hf-overrides, pas comme indicateur autonome

Entrée vidéo ignorée

Ajoutez --media-io-kwargs '{"video": {"num_frames": -1}}' (vLLM only)

Appels d’outils abandonnés

--enable-auto-tool-choice --tool-call-parser hermes

La qualité chute au-delà d’environ 600K

YaRN étend les positions, pas la compréhension — gardez le contenu critique près de la fin du prompt

Étapes suivantes

Prédécesseur : Qwen3.6-27B — le 27B dense d’avril qu’il remplace
Frère/sœur multimodal(e) : Qwen3.5-Omni — ajoute l’entrée audio et la sortie vocale
Montez en gamme : GLM-5.2 ou Mistral Small 4 quand 27B ne suffit pas
Déploiement : vLLM · SGLang · Ollama
Affinez-le : Unsloth

Liens

Qwen3.8-27B sur Hugging Face · FP8 · GGUF
Recette vLLM · Livre de cuisine SGLang
Blog Qwen
Louez un GPU : RTX 4090 · RTX 5090 · Place de marché

PrécédentQwen3.6-27B (dense, un seul GPU)

SuivantGLM-5.2 (MIT, contexte 1M)

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?