> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/minimax-m3.1-flash.md).

# MiniMax-M3.1-Flash : exécution locale

Exécutez MiniMax-M3.1-Flash localement avec les GGUF dynamiques d’Unsloth.

MiniMax-M3.1-Flash est le nouveau modèle de MiniMax **428B** multimodal MoE, avec 23B de paramètres actifs et un contexte de **1M**, conçu pour le codage et les usages agentiques. Découvrez comment exécuter MiniMax-M3.1-Flash à l’aide des [GGUF Unsloth](https://huggingface.co/unsloth/MiniMax-M3.1-Flash-GGUF) en local avec Unsloth Desktop ou llama.cpp.

Notre version de 129,4 Go **1 bit** atteint **environ 89,9 % de précision top-1** ; la version de 143,9 Go **2 bits** atteint **91.5%**, et la version 4 bits UD-Q4\_K\_XL de 249,4 Go atteint 98,0 %. En codage, Q2 atteint 91,2 % et Q4, 97,6 %. Nous avons pondéré les performances des quantifications dans **sept catégories**: codage, mathématiques, dialogue, outils, multilinguisme, raisonnement et usages agentiques. Merci à MiniMax pour l’accès dès le premier jour.

### ⚙️ Guide d’utilisation

MiniMax-M3.1-Flash prend en charge le texte, les images et la vidéo, et ajoute une attention éparse dans toutes les couches, la QAT pour l’attention et les experts routés, ainsi que DSpark.

Pour UD-Q2\_K\_XL en 2 bits, prévoyez au moins 160 Go de RAM + VRAM (ou de mémoire unifiée) ; pour UD-Q4\_K\_XL en 4 bits, prévoyez au moins 256 Go. Ces estimations de planification supposent un contexte texte de 16K et un seul emplacement parallèle.

Prévoyez de conserver l’intégralité des poids quantifiés en RAM et en VRAM, même si seuls 23B paramètres sont actifs par jeton. Utilisez le déchargement sur le processeur lorsque la mémoire GPU est limitée.

#### Configuration requise pour MiniMax-M3.1-Flash :

**Tableau : configuration matérielle requise** (RAM + VRAM, ou mémoire unifiée).

| 1 bit  | 2 bits | 3 bits     | 4 bits | 8 bits (sans perte) |
| ------ | ------ | ---------- | ------ | ------------------- |
| 134 Go | 150 Go | 176–208 Go | 256 Go | 272 Go              |

Estimations de planification pour un contexte texte de 16K et un seul emplacement, avec environ 20 à 32 Gio de marge au-delà des poids pour le cache KV, l’environnement d’exécution et le système d’exploitation. Les capacités mémoire sont exprimées en Gio, souvent commercialisés sous l’appellation Go. Les contextes plus longs, la vision et DSpark nécessitent davantage de mémoire.

Pour le format 3 bits, prévoyez au moins 176 Go pour `UD-IQ3_XXS`, au moins 192 Go pour `UD-IQ3_S`, ou au moins 208 Go pour `UD-Q3_K_XL`. La colonne 8 bits désigne `UD-Q8_K_XL`, le GGUF de plus haute précision répertorié ici.

**Tailles des poids :** Les téléchargements ci-dessous sont indiqués en Go décimaux. Commencez avec un contexte de 16K, puis augmentez-le selon la mémoire disponible.

| Quantification | Taille du téléchargement (Go) | Taille des poids (Gio) |
| -------------- | ----------------------------- | ---------------------- |
| `UD-IQ1_M`     | 129,4 GB                      | 120,5 Gio              |
| `UD-IQ2_XXS`   | 134,9 GB                      | 125,7 Gio              |
| `UD-Q2_K_XL`   | 143,9 GB                      | 134,0 Gio              |
| `UD-IQ3_XXS`   | 160,0 GB                      | 149,1 Gio              |
| `UD-IQ3_S`     | 175,5 GB                      | 163,4 Gio              |
| `UD-Q3_K_XL`   | 194,0 GB                      | 180,6 Gio              |
| `UD-Q4_K_XL`   | 249,4 GB                      | 232,3 Gio              |
| `UD-Q8_K_XL`   | 259,1 GB                      | 241,3 Gio              |

### Paramètres recommandés

Utilisez les configurations recommandées par MiniMax :

| Paramètre   | Valeur            |
| ----------- | ----------------- |
| Température | `1.0`             |
| Top-p       | `0.95`            |
| Top-k       | `0` (désactivé)   |
| Min-p       | `0.0` (désactivé) |

#### Niveau de raisonnement

Le modèle utilise un raisonnement adaptatif. Définissez `reasoning_effort` sur `low`, `medium`, `high`, `xhigh` ou `max`. Nous utilisons `high` ; le niveau de raisonnement est indépendant des limites de contexte et de jetons de sortie.

```bash
--chat-template-kwargs '{"reasoning_effort":"high"}'
```

### 📊 Analyse de la quantification

UD-Q8\_K\_XL est une conversion sans perte directe des fichiers safetensors d’origine. MiniMax utilise NVFP4 pour les couches MoE et MXFP8 pour le reste ; nous avons conservé NVFP4 + BF16 pour UD-Q8\_K\_XL.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FwPOGpnK3wxeulnC9lrJq%2Fminimax-kld.png?alt=media&amp;token=c7fb9b86-729f-45f1-827a-c8acee92d0a5" alt="MiniMax-M3.1-Flash GGUF KLD by file size across seven evaluation categories. Lower is better."><figcaption><p>KLD moyen en fonction de la taille du fichier. Plus la valeur est faible, mieux c’est ; l’axe vertical est logarithmique.</p></figcaption></figure>

Nous avons testé les versions quantifiées de MiniMax M3.1 Flash que nous avons produites et les versions génériques de llama.cpp + imatrix sur plusieurs domaines différents afin de vérifier que nos algorithmes de quantification ne sont pas surajustés à un domaine particulier. Nous montrons ainsi qu’Unsloth Dynamic v3 fonctionne remarquablement bien dans tous les domaines.

Nous avons également réalisé des graphiques pour le top 1 % et montrons que UD3 reste performant même avec moins de bits, par rapport aux dispositions naïves de llama.cpp avec imatrix.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FEGL7IdsBG2LJa8kp9krw%2Fsize_vs_top1_per_axis.png?alt=media&amp;token=1898d4b7-b4b4-46a7-b5e2-9a9a4915cdce" alt=""><figcaption></figcaption></figure>

**Accord top-1 par quantification :**

| Quantification | Taille du fichier | Top-1 en conversation générale | Top-1 en mathématiques |
| -------------- | ----------------- | ------------------------------ | ---------------------- |
| `UD-IQ1_M`     | 129,4 GB          | 86.2%                          | 94.9%                  |
| `UD-IQ2_XXS`   | 134,9 GB          | 87.5%                          | 95.3%                  |
| `UD-Q2_K_XL`   | 143,9 GB          | 88.5%                          | 95.7%                  |
| `UD-IQ3_XXS`   | 160,0 GB          | 89.9%                          | 96.3%                  |
| `UD-IQ3_S`     | 175,5 GB          | 91.2%                          | 96.8%                  |
| `UD-Q3_K_XL`   | 194,0 GB          | 92.6%                          | 97.4%                  |
| `UD-Q4_K_XL`   | 249,4 GB          | 97.3%                          | 99.0%                  |
| `UD-Q8_K_XL`   | 259,1 GB          | 97.8%                          | 99.3%                  |

À taille comparable ou inférieure, les quantifications dynamiques présentent un KLD plus faible et un meilleur taux d’accord. **UD-Q3\_K\_XL (194,0 Go)** surpasse la quantification générique **IQ4\_XS (environ 230 Go)** en matière d’accord top-1 dans les sept catégories.

**Choisir une quantification :** Q2 offre un taux d’accord de 88,5 % en conversation générale et de 95,7 % en mathématiques, pour 143,9 Go. Q4 porte ces taux à 97,3 % et 99,0 %, et fait passer l’accord multilingue de 90,8 % avec Q3 à 97,6 %. Q8 ajoute 9,7 Go pour un gain de fidélité plus modeste.

## Tutoriels pour exécuter MiniMax-M3.1-Flash :

Nous utilisons **UD-Q2\_K\_XL** pour les exemples. L’entrée d’images et DSpark sont activés automatiquement dans Unsloth.

### 🦥 Guide Unsloth

[Unsloth Desktop](https://unsloth.ai/docs/desktop) est notre interface open source pour macOS, Windows et Linux. Téléchargez des GGUF et configurez l’échantillonnage ainsi que le déchargement vers le processeur ou le GPU dans une seule application.

{% stepper %}
{% step %}

### Installer Unsloth

Télécharger [Unsloth Desktop](https://unsloth.ai/download) pour votre système d’exploitation. Utilisez une version prenant en charge MiniMax-M3.1, ou la PR de llama.cpp ci-dessous.

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Télécharger Unsloth</a>
{% endstep %}

{% step %}

### Rechercher et télécharger MiniMax-M3.1-Flash

Dans **Unsloth Chat** ou dans le **hub de modèles**, recherchez **MiniMax-M3.1-Flash** et sélectionnez [unsloth/MiniMax-M3.1-Flash-GGUF](https://huggingface.co/unsloth/MiniMax-M3.1-Flash-GGUF). Téléchargez votre quantification ; nous utilisons `UD-Q2_K_XL` (143,9 Go).
{% endstep %}

{% step %}

### Exécuter MiniMax-M3.1-Flash

Chargez le modèle avec les paramètres recommandés : **contexte de 16K**, **un emplacement parallèle** et `high` pour l’effort de raisonnement. Utilisez le modèle de conversation inclus et ajustez le déchargement vers le processeur ou le GPU en fonction de la mémoire disponible.

Pour en savoir plus, consultez le [guide d’inférence Unsloth](https://unsloth.ai/docs/fr/nouveau/studio/chat.md).
{% endstep %}

{% step %}

### Servir MiniMax-M3.1-Flash avec l’API Unsloth

Avec un environnement d’exécution compatible, servez le modèle à l’aide de `unsloth run` et des options de llama-server :

```bash
unsloth run --model unsloth/MiniMax-M3.1-Flash-GGUF:UD-Q2_K_XL \
    --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":"high"}' \
    --host 127.0.0.1 --port 8080
```

Discutez sur `http://localhost:8080` ; l’URL de base de l’API compatible avec OpenAI est `http://localhost:8080/v1`.
{% endstep %}

{% step %}

### Connecter vos outils

Connectez votre client API à ce point de terminaison à l’aide d’un ID de modèle issu de `/v1/models`. Laissez le serveur en cours d’exécution.
{% endstep %}
{% endstepper %}

### 🦙 Exécuter MiniMax-M3.1-Flash dans llama.cpp

{% stepper %}
{% step %}

### Compiler llama.cpp avec la prise en charge de MiniMax-M3.1

Compiler [PR #31192](https://github.com/ggml-org/llama.cpp/pull/31192) à l’aide de Bash sous Linux, WSL ou macOS.

Sous Ubuntu / WSL, installez les dépendances de compilation :

```bash
sudo apt-get update
sudo apt-get install -y build-essential cmake git libssl-dev
```

Pour NVIDIA, installez le [toolkit CUDA](https://developer.nvidia.com/cuda-downloads). Sous macOS, installez les outils de ligne de commande Xcode et CMake ; utilisez `-DGGML_CUDA=OFF` (Metal est activé par défaut). Utilisez `OFF` également pour les compilations exclusivement sur CPU.

```bash
git clone https://github.com/ggml-org/llama.cpp
git -C llama.cpp fetch origin pull/31192/head:minimax-m31
git -C llama.cpp checkout minimax-m31
cmake llama.cpp -B llama.cpp/build \
    -DCMAKE_BUILD_TYPE=Release \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --target llama-server
```

{% endstep %}

{% step %}

### Télécharger le fichier GGUF

Installez l’interface de ligne de commande Hugging Face et téléchargez **les quatre fragments** de `UD-Q2_K_XL`:

```bash
pip install -U huggingface_hub
hf download unsloth/MiniMax-M3.1-Flash-GGUF \
    --local-dir unsloth/MiniMax-M3.1-Flash-GGUF \
    --include "UD-Q2_K_XL/*"
```

Gardez tous les fragments ensemble et indiquez `--model` le premier ; llama.cpp chargera les autres. Pour une autre quantification, modifiez le filtre de téléchargement et le chemin du modèle.
{% endstep %}

{% step %}

### Exécuter MiniMax-M3.1-Flash

Démarrez le serveur de chat local :

```bash
./llama.cpp/build/bin/llama-server \
    --model unsloth/MiniMax-M3.1-Flash-GGUF/UD-Q2_K_XL/MiniMax-M3.1-Flash-UD-Q2_K_XL-00001-of-00004.gguf \
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 0 \\
    --min-p 0.0 \\
    --chat-template-kwargs '{"reasoning_effort":"high"}' \
    --host 127.0.0.1 --port 8080
```

{% endstep %}
{% endstepper %}

#### Entrées image

Pour les entrées image, téléchargez séparément le `mmproj-BF16.gguf` projecteur de vision (environ 1,74 Go) :

```bash
hf download unsloth/MiniMax-M3.1-Flash-GGUF \
    --local-dir unsloth/MiniMax-M3.1-Flash-GGUF \
    --include "mmproj-BF16.gguf"
```

Ajoutez cette option au serveur et prévoyez davantage de mémoire pour le projecteur et le traitement des images :

```bash
--mmproj unsloth/MiniMax-M3.1-Flash-GGUF/mmproj-BF16.gguf
```

### ⚡ DSpark – décodage spéculatif

M3.1 remplace le [MTP](https://unsloth.ai/docs/fr/modeles/mtp.md) de type EAGLE par **DSpark** : un modèle brouillon propose des jetons que le modèle principal vérifie, ce qui peut accélérer le décodage. Cette méthode nécessite un modèle brouillon MiniMax-M3.1 compatible et davantage de mémoire.

[PR #31192](https://github.com/ggml-org/llama.cpp/pull/31192) prend en charge DSpark ; les commandes ci-dessus utilisent le décodage standard. Avec un modèle brouillon compatible, ajoutez ces options et remplacez le nom de fichier par son chemin local :

```bash
--spec-type draft-dspark \\
    -md MiniMax-M3.1-Flash-DSpark-BF16.gguf \\
    --spec-draft-p-min 0
```

## 📊 Benchmarks

### Benchmarks KLD et Top-1 des fichiers GGUF

Sur les sept catégories, **UD-Q2\_K\_XL atteint environ 85,3 à 95,7 % de concordance Top-1**, **UD-Q4\_K\_XL, environ 97,3 à 99,0 %**, et **UD-Q8\_K\_XL, environ 97,8 à 99,3 %**. Q4 économise 9,7 Go par rapport à Q8, avec un écart de concordance minime ; Q8 présente également une KLD plus faible sur l’ensemble des mesures.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FLKBqgmIgiNf9wTXbGNsX%2Fminimax-top1.png?alt=media&amp;token=3a155732-d550-4397-86b2-c3d134e5912d" alt="MiniMax-M3.1-Flash GGUF top-1 agreement by file size across seven evaluation categories. Higher is better."><figcaption><p>Concordance des jetons Top-1 sur sept catégories. Plus la valeur est élevée, mieux c’est ; les valeurs indiquées sont des estimations lues sur les graphiques.</p></figcaption></figure>

### Benchmarks officiels

[Les résultats officiels de MiniMax](https://huggingface.co/MiniMaxAI/MiniMax-M3.1-Flash) sont présentés ci-dessous.

| Benchmark                | MiniMax-M3.1-Flash | DeepSeek-V4.1-Flash-1017 |
| ------------------------ | ------------------ | ------------------------ |
| Automation-Bench v1.0.6  | 62.8               | 60.5                     |
| Terminal Bench 4.0       | 38.1               | 42.3                     |
| DeepSWE v1.1             | 73.7               | 77.0                     |
| NL2Repo-Bench            | 61.2               | 68.2                     |
| BabyVision (avec outils) | 91.0               | 92.5                     |
| HLE (sans outils)†       | 43.4               | 42.6                     |
| OSWorld 2.0              | 61.7               | —                        |
| LOCA-Bench 256K          | 60.3               | —                        |

† HLE utilise le sous-ensemble texte uniquement. Outils d’évaluation : Codex 0.149.1 pour Terminal Bench ; mini-SWE-agent 2.4.5 pour DeepSWE ; Claude Code 2.1.233 pour NL2Repo. Les deux derniers utilisent un contexte de 512K. Les scores dépendent de la configuration et de l’effort de raisonnement ; — signifie qu’aucun résultat n’a été publié.


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/modeles/minimax-m3.1-flash.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
