> 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/tutorials/minimax-m27.md).

# MiniMax-M2.7 - Comment exécuter localement

MiniMax-M2.7 est un nouveau modèle ouvert pour les cas d’usage de codage agentique et de chat. Le modèle atteint des performances SOTA dans SWE-Pro (56,22 %) et Terminal Bench 2 (57,0 %).

La **230B de paramètres** (10B actifs) le modèle est le successeur de [MiniMax-M25](/docs/fr/modeles/tutorials/minimax-m25.md) et possède un **fenêtre de contexte de 200K** fenêtre. Le bf16 non quantifié nécessite **457 Go**. Unsloth dynamique **4 bits** GGUF réduit la taille à **108 Go** **(-60%)** pour qu'il puisse s'exécuter sur un **128 Go de RAM** apparei&#x6C;**:** [**MiniMax-M2.7 GGUF**](https://huggingface.co/unsloth/MiniMax-M2.7-GGUF)

Tous les envois utilisent Unsloth [Dynamique 2.0](/docs/fr/bases/dynamic-3.0-ggufs.md) pour des performances SOTA de quantification - ainsi, les couches importantes sont remontées à des bits plus élevés (par ex. 8 ou 16 bits). Merci à MiniMax pour l’accès dès le jour 0.

{% hint style="success" %}
NOUVEAUX benchmarks GGUF MiniMax-M2.7 disponibles ! [Voir ici](#gguf-benchmarks)
{% endhint %}

### :gear: Guide d'utilisation

La quantification dynamique 4 bits `UD-IQ4_XS` utilise **108 Go** d’espace disque - cela tient bien sur un **Mac avec mémoire unifiée de 128 Go** pour \~15+ tokens/s, et fonctionne aussi plus vite avec un **GPU 1x16 Go et 96 Go de RAM** pour 25+ tokens/s. **2 bits** les quantifications ou la plus grande quantification 2 bits tiendront sur un appareil de 96 Go.

Pour une précision quasi **pleine précision**, utilisez `Q8_0` (8 bits) qui utilise 243 Go et tiendra sur un appareil / Mac avec 256 Go de RAM pour 15+ tokens/s.

{% hint style="success" %}
Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier du modèle quantifié que vous téléchargez. Sinon, llama.cpp peut quand même fonctionner via le déchargement SSD/HDD, mais l’inférence sera plus lente.
{% endhint %}

### Paramètres recommandés

MiniMax recommande d’utiliser les paramètres suivants pour de meilleures performances : `temperature=1.0`, `top_p = 0.95`, `top_k = 40`.

{% columns %}
{% column %}

| Paramètres par défaut (la plupart des tâches) |
| --------------------------------------------- |
| `temperature = 1.0`                           |
| `top_p = 0.95`                                |
| `top_k = 40`                                  |
| {% endcolumn %}                               |

{% column %}

* **Fenêtre de contexte maximale :** `196,608`
* Prompt système par défaut :

{% code overflow="wrap" %}

```
Vous êtes un assistant utile. Votre nom est MiniMax-M2.7 et vous avez été créé par MiniMax.
```

{% endcode %}
{% endcolumn %}
{% endcolumns %}

## Exécuter les tutoriels MiniMax-M2.7 :

Pour faire fonctionner MiniMax-M2.7 sur un appareil doté de 128 Go de RAM, nous utiliserons la version 4 bits [`UD-IQ4_XS` quant](https://huggingface.co/unsloth/MiniMax-M2.7-GGUF?show_file_info=UD-IQ4_XS%2FMiniMax-M2.7-UD-IQ4_XS-00001-of-00004.gguf). Vous pouvez maintenant exécuter MiniMax-M2.7 en [llama.cpp](#run-in-llama.cpp) et [Unsloth Studio](#run-in-unsloth-studio).

{% hint style="warning" %}
N’utilisez PAS CUDA 13.2 pour exécuter un modèle, car cela peut provoquer du charabia ou de mauvaises sorties. NVIDIA travaille sur un correctif.
{% endhint %}

### 🦥 Exécuter dans Unsloth Studio

MiniMax-M2.7 peut désormais s’exécuter en [Unsloth Studio](/docs/fr/nouveau/studio.md), notre nouvelle interface web open source pour l’IA locale. Unsloth Studio vous permet d’exécuter des modèles localement sur **MacOS, Windows**, Linux et :

{% columns %}
{% column %}

* Rechercher, télécharger, [exécuter des GGUF](/docs/fr/nouveau/studio.md#run-models-locally) et des modèles safetensor
* [**Auto-réparation** appel d'outils](/docs/fr/nouveau/studio.md#execute-code--heal-tool-calling) + **recherche web**
* [**Exécution de code**](/docs/fr/nouveau/studio.md#run-models-locally) (Python, Bash)
* [Inférence automatique](https://unsloth.ai/docs/desktop#feature-deep-dive) réglage des paramètres (temp, top-p, etc.)
* Utilise llama.cpp pour une inférence rapide CPU + GPU et le déchargement CPU
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/93caac3ea9f36e951db039e5d7f695e27763705e" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Installer Unsloth

Exécutez dans votre terminal :

**macOS, Linux, WSL :**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

**Windows PowerShell :**

```bash
irm https://unsloth.ai/install.ps1 | iex
```

{% endstep %}

{% step %}

#### Lancer Unsloth

**MacOS, Linux, WSL et Windows :**

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

**Puis ouvrez `http://localhost:8888` dans votre navigateur.**
{% endstep %}

{% step %}

#### Rechercher et télécharger MiniMax-M2.7

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d'intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment.

Vous pouvez choisir `UD-IQ4_XS` (quantification dynamique 4 bits) ou d’autres versions quantifiées comme `UD-Q4_K_XL` . Si les téléchargements se bloquent, consultez [Dépannage de Hugging Face Hub, XET](/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

Puis allez dans l’onglet [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) onglet et recherchez MiniMax-M2.7 dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités. Le téléchargement prendra un certain temps en raison de la taille, veuillez donc patienter. Pour garantir une inférence rapide, assurez-vous d’avoir [suffisamment de RAM/VRAM](#usage-guide), sinon l'inférence fonctionnera toujours, mais Unsloth la déchargera vers votre CPU.

<div data-with-frame="true"><figure><img src="/files/4c08e0326c6da8504e2fa8fe4adec75e4682310e" alt=""><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### Exécuter MiniMax-M2.7

Les paramètres d'inférence doivent être définis automatiquement lors de l'utilisation d'Unsloth Studio ; toutefois, vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur de contexte, le gabarit de conversation et d'autres paramètres.

Pour plus d'informations, vous pouvez consulter notre [Guide d'inférence Unsloth Studio](/docs/fr/nouveau/studio/chat.md).
{% endstep %}
{% endstepper %}

### ✨ Exécuter dans llama.cpp

{% hint style="warning" %}
N’utilisez PAS CUDA 13.2 pour exécuter un modèle, car cela peut provoquer du charabia ou de mauvaises sorties. NVIDIA travaille sur un correctif.
{% endhint %}

{% stepper %}
{% step %}
Obtenez la dernière version de `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez également suivre les instructions de compilation ci-dessous. Remplacez `-DGGML_CUDA=ON` par `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement une inférence sur CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.

{% code overflow="wrap" %}

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

{% endcode %}
{% endstep %}

{% step %}
Si vous souhaitez utiliser `llama.cpp` directement pour charger des modèles, vous pouvez faire ce qui suit : (:IQ4\_XS) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). Cela ressemble à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` pour l'enregistrer dans un emplacement spécifique. N'oubliez pas que le modèle a seulement une longueur de contexte maximale de 200K.

Suivez ceci pour **la plupart des paramètres par défaut** cas d'utilisation :

```bash
export LLAMA_CACHE="unsloth/MiniMax-M2.7-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/MiniMax-M2.7-GGUF:UD-IQ4_XS \\
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 40
```

{% endstep %}

{% step %}
Téléchargez le modèle (après avoir installé `pip install huggingface_hub hf_transfer`). Vous pouvez choisir UD-IQ4\_XS (quantification dynamique 4 bits) ou d’autres versions quantifiées comme `UD-Q6_K_XL` . Nous recommandons d’utiliser notre quantification dynamique 4 bits UD-IQ4\_XS pour équilibrer taille et précision. Si les téléchargements se bloquent, voir [Dépannage de Hugging Face Hub, XET](/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

```bash
hf download unsloth/MiniMax-M2.7-GGUF \\
    --local-dir unsloth/MiniMax-M2.7-GGUF \\
    --include "*UD-IQ4_XS*" # Utilisez "*Q8_0*" pour 8 bits
```

{% endstep %}

{% step %}
Vous pouvez modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur du contexte, `--n-gpu-layers 2` pour le déchargement GPU sur le nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n'avez qu'une inférence CPU.

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/MiniMax-M2.7-GGUF/UD-IQ4_XS/MiniMax-M2.7-UD-IQ4_XS-00001-of-00004.gguf \\
    --temp 1.0 \
    --top-p 0.95 \
    --top-k 40
```

{% endcode %}
{% endstep %}
{% endstepper %}

#### 🦙 Llama-server et bibliothèque de complétion d’OpenAI

Pour déployer MiniMax-M2.7 en production, nous utilisons `llama-server` ou l’API OpenAI. Dans un nouveau terminal, par exemple via tmux, déployez le modèle via :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \
    --model unsloth/MiniMax-M2.7-GGUF/UD-IQ4_XS/MiniMax-M2.7-UD-IQ4_XS-00001-of-00004.gguf \\
    --alias "unsloth/MiniMax-M2.7" \\
    --prio 3 \\
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01 \
    --top-k 40 \\
    --port 8001
```

{% endcode %}

Puis dans un nouveau terminal, après avoir fait `pip install openai`, faites :

{% code overflow="wrap" %}

```python
from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/MiniMax-M2.7",
    messages = [{"role": "user", "content": "Create a Snake game."},],
)
print(completion.choices[0].message.content)
```

{% endcode %}

## 📊 Benchmarks

### Benchmarks GGUF

Voici ci-dessous les benchmarks KLD 99 % pour MiniMax-M2.7. En bas à gauche, c’est mieux :

<figure><img src="/files/81419a30b21a85d9801bd59b1a2166dd17854a35" alt=""><figcaption></figcaption></figure>

Comme MiniMax-M2.7 utilise la même architecture que MiniMax-M2.5, les benchmarks de quantification GGUF pour M2.7 devraient être très similaires à ceux de M2.5. Nous nous référerons donc également aux précédents benchmarks de quantification réalisés pour M2.5 :

<figure><img src="/files/f321cef04ad4b89bb6fd902546aad9817950e88b" alt=""><figcaption></figcaption></figure>

[Benjamin Marie (tiers) a évalué](https://x.com/bnjmn_marie/status/2027043753484021810/photo/1) **MiniMax-M2.5** en utilisant **les quantifications GGUF d’Unsloth** sur un **suite mixte de 750 invites** (LiveCodeBench v6, MMLU Pro, GPQA, Math500), en rapportant à la fois **la précision globale** et **l'augmentation relative de l'erreur** (à quelle fréquence le modèle quantifié fait des erreurs par rapport à l'original).

Les quantifications Unsloth, quelle que soit leur précision, sont bien meilleures que leurs équivalents non-Unsloth, tant en précision qu’en erreur relative (malgré une taille inférieure de 8 Go).

**Résultats clés :**

* **Meilleur compromis qualité/taille ici : `unsloth UD-Q4_K_XL`.**\
  C’est le plus proche de l’original : seulement **6,0 points** en dessous, et « seulement » **+22.8%** erreurs de plus que la référence.
* **Les autres quantifications Unsloth Q4 sont très proches les unes des autres (\~64,5–64,9 de précision).**\
  `IQ4_NL`, `MXFP4_MOE`, et `UD-IQ2_XXS` ont tous à peu près la même qualité sur ce benchmark, avec **\~33–35%** d’erreurs de plus que l’original.
* Les GGUF d’Unsloth offrent de bien meilleures performances que les autres GGUF non-Unsloth, par ex. voir `lmstudio-community - Q4_K_M` (malgré une taille inférieure de 8 Go) et `AesSedai - IQ3_S`.

### Benchmarks officiels

<figure><img src="/files/6607262a6b5c8c6f6f9b9b8caf9d063499302950" alt=""><figcaption></figcaption></figure>


---

# 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, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/fr/modeles/tutorials/minimax-m27.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
