> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/glm-47-flash.md).

# GLM-4.7-Flash

> GLM-4.7-Flash est un **modèle Mixture-of-Experts de 30 milliards de paramètres** de langage par Zhipu AI qui n'active que 3 milliards de paramètres par token. Il offre des performances exceptionnelles sur les tâches de codage et de raisonnement, atteignant 59,2 % sur SWE-bench tout en ne nécessitant que 10-12 Go de VRAM pour l'inférence en FP16. Publié sous la **licence MIT**, c'est un choix idéal pour les développeurs cherchant une qualité de modèle de pointe à des coûts abordables sur GPU unique.

## En un coup d'œil

* **Taille du modèle**: 30B au total / 3B actifs (MoE)
* **Licence**: MIT (entièrement commercial)
* **Contexte**: 128K tokens
* **Performance**: 59,2 % SWE-bench, 75,4 % HumanEval
* **VRAM**: \~10-12 Go FP16, \~6 Go INT8
* **Vitesse**: \~45-60 tok/s sur RTX 4090

## Pourquoi GLM-4.7-Flash ?

**Performances efficaces**: GLM-4.7-Flash surpasse les attentes pour sa catégorie. Malgré l'utilisation de seulement 3 milliards de paramètres actifs, il dépasse de nombreux modèles denses de 70 milliards+ sur les benchmarks de codage. L'architecture MoE fournit la qualité d'un modèle 30B au coût d'inférence d'un modèle 7B.

**Adapté au GPU unique**: Contrairement aux modèles massifs nécessitant des configurations multi-GPU, GLM-4.7-Flash fonctionne confortablement sur un seul RTX 4090 ou un A100 40GB. Cela le rend parfait pour le développement, l'affinage et les déploiements en production rentables.

**Spécialiste du codage**: Avec 59,2 % sur SWE-bench, GLM-4.7-Flash excelle dans les tâches d'ingénierie logicielle — génération de code, débogage, refactorisation et documentation technique. Il comprend plus de 20 langages de programmation avec une forte conscience du contexte.

**Sous licence MIT**: Aucune restriction d'utilisation. Déployez commercialement, affinez ou modifiez sans soucis de licence. Les poids complets et les recettes d'entraînement sont librement disponibles.

## Recommandations GPU

| GPU          | VRAM | Performance | Coût quotidien\* |
| ------------ | ---- | ----------- | ---------------- |
| **RTX 4090** | 24GB | \~50 tok/s  | \~$2.10          |
| **RTX 3090** | 24GB | \~35 tok/s  | \~$1.10          |
| A100 40 Go   | 40GB | \~80 tok/s  | \~$3.50          |
| A100 80GB    | 80GB | \~90 tok/s  | \~$4.00          |
| H100         | 80GB | \~120 tok/s | \~$6.00          |

**Meilleur rapport qualité/prix**: Le RTX 4090 offre le meilleur compromis entre performances et coût pour GLM-4.7-Flash.

\*Prix estimés du marketplace Clore.ai

## Déployer avec vLLM

### Installer vLLM

```bash
pip install vllm>=0.6.0
# ou la dernière version
pip install git+https://github.com/vllm-project/vllm.git
```

### Configuration GPU unique

```bash
vllm serve THUDM/glm-4-flash \
  --model THUDM/glm-4-flash \
  --tensor-parallel-size 1 \
  --dtype float16 \
  --max-model-len 32768 \
  --served-model-name glm-4.7-flash \
  --trust-remote-code
```

### Interroger le serveur

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="glm-4.7-flash",
    messages=[
        {"role": "system", "content": "Vous êtes un développeur Python expert."},
        {"role": "user", "content": "Écrivez une application FastAPI avec SQLAlchemy asynchrone et authentification JWT"}
    ],
    max_tokens=2048,
    temperature=0.7
)

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

## Déployer avec SGLang

SGLang offre souvent un meilleur débit pour les modèles MoE :

```bash
pip install "sglang[all]>=0.3.0"

# Lancer le serveur
python -m sglang.launch_server \
  --model-path THUDM/glm-4-flash \
  --port 30000 \
  --host 0.0.0.0 \
  --dtype float16 \
  --tp-size 1 \
  --context-length 32768
```

## Déployer avec Ollama

Configuration simple pour le développement local :

```bash
# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Tirer le modèle (téléchargera ~18 Go)
ollama pull glm4:7b-chat

# Exécuter en mode interactif
ollama run glm4:7b-chat

# Mode API
ollama serve
```

Ensuite, interrogez via l'API REST :

```python
import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'glm4:7b-chat',
        'prompt': 'Expliquez l'architecture MoE dans GLM-4.7-Flash',
        'stream': False
    }
)

print(response.json()['response'])
```

## Modèle Docker

```dockerfile
FROM nvidia/cuda:12.1-devel-ubuntu22.04

# Installer Python 3.10
RUN apt-get update && apt-get install -y python3.10 python3-pip curl

# Installer vLLM
RUN pip install vllm>=0.6.0 transformers

# Pré-télécharger le modèle (optionnel)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('THUDM/glm-4-flash', trust_remote_code=True)"

EXPOSE 8000

CMD ["vllm", "serve", "THUDM/glm-4-flash", \
     "--host", "0.0.0.0", \
     "--port", "8000", \
     "--tensor-parallel-size", "1", \
     "--dtype", "float16", \
     "--trust-remote-code"]
```

Construire et exécuter :

```bash
docker build -t glm-4.7-flash .
docker run --gpus all -p 8000:8000 glm-4.7-flash
```

## Exemple de génération de code

GLM-4.7-Flash excelle dans la génération de code complexe :

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="glm-4.7-flash",
    messages=[
        {"role": "user", 
         "content": """Créez une classe Python pour un limiteur de débit avec :
- Algorithme du seau à jetons
- Support async/await  
- Backend Redis
- Décorateur pour limiter les appels de fonction
- Gestion d'erreurs appropriée"""}
    ],
    max_tokens=2048,
    temperature=0.3
)

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

## Conseils pour les utilisateurs de Clore.ai

* **Optimisation de la mémoire**: Utilisez `--dtype float16` pour réduire l'utilisation de la VRAM. Pour les GPU 16 Go, ajoutez `--max-model-len 16384` pour limiter le contexte.
* **Traitement par batch**: Augmentez `--max-num-seqs` pour un débit plus élevé lors du service de requêtes multiples.
* **Quantification**: Pour RTX 3060/4060 (12 Go), utilisez des versions quantifiées AWQ ou GPTQ pour une utilisation d'environ \~6 Go de VRAM.
* **Préemption**: GLM-4.7-Flash gère les interruptions avec élégance — idéal pour les instances préemptibles Clore.ai.
* **Longueur de contexte**: Le contexte par défaut de 128K peut être excessif. Définissez `--max-model-len 32768` pour la plupart des applications.

## Dépannage

| Problème                  | Solution                                                        |
| ------------------------- | --------------------------------------------------------------- |
| `OutOfMemoryError`        | Réduisez `--max-model-len` ou utilisez `--dtype float16`        |
| Chargement lent du modèle | Pré-cachez avec `huggingface-cli download THUDM/glm-4-flash`    |
| Erreurs d'importation     | Mettez à jour transformers : `pip install transformers>=4.40.0` |
| Performances médiocres    | Activez Flash Attention : `pip install flash-attn`              |
| Connexion refusée         | Vérifiez le pare-feu : `ufw allow 8000`                         |

## Modèles alternatifs

Si GLM-4.7-Flash ne correspond pas à vos besoins :

* **Qwen2.5-Coder-7B**: Meilleur pour le codage pur, empreinte plus petite
* **CodeQwen1.5-7B**: Spécialiste du codage chinois + anglais
* **GLM-4-9B**: Frère plus grand avec de meilleures capacités de raisonnement
* **DeepSeek-V3**: MoE de 671B pour des performances ultimes (multi-GPU)

## Ressources

* [GLM-4-Flash sur Hugging Face](https://huggingface.co/THUDM/glm-4-flash)
* [Rapport technique GLM-4](https://arxiv.org/abs/2406.12793)
* [Documentation vLLM](https://docs.vllm.ai/)
* [SGLang GitHub](https://github.com/sgl-project/sglang)
* [Plateforme Zhipu AI](https://open.bigmodel.cn/)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/glm-47-flash.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.