> 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/nemotron-3.5-super-vl.md).

# NVIDIA Nemotron 3.5 Super VL : Guide d’exécution locale

Exécutez Nemotron 3.5 Super VL localement avec les GGUF Unsloth.

NVIDIA Nemotron-3.5-Super-VL-120B-A12B est un **120B de paramètres, 12B actifs** modèle MoE hybride de raisonnement avec **jusqu’à 1 M de jetons de contexte**. Il accepte du texte, des images et de la vidéo pour la compréhension de documents, l’utilisation de l’ordinateur et les workflows d’agent, et génère du texte.

Il prend en charge la sortie JSON et l’appel d’outils, et inclut une tête Multi-Token Prediction (MTP) intégrée. Les GGUF Unsloth vont de **46,1 Go (1 bit) à 132 Go (8 bits)**. Nous avons également créé des quants NVFP4 (79 Go) et ajouté le module LiLiCorr DSpark. **Quants Unsloth :** [NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-GGUF](https://huggingface.co/unsloth/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-GGUF)

<a href="/docs/fr/modeles/nemotron-3.5-super-vl.md#run-nemotron-35-super-vl-guide" class="button primary">Guide Nemotron-3.5-Super-VL</a><a href="/docs/fr/modeles/nemotron-3.5-bolt.md" class="button secondary">Guide d’exécution de Nemotron-3.5-Bolt</a>

### ⚙️ Guide d’utilisation

**Exigences de Nemotron 3.5 Super VL**

Le plus petit **Le GGUF 1 bit fait 46,1 Go**; prévoyez au moins **64 Go de RAM ou de mémoire unifiée**. Le **GGUF 4 bits fait 86,9 Go**, avec environ **128 Go** recommandés. Vous pouvez également répartir le modèle entre la RAM système et la VRAM du GPU. Vous pouvez aussi exécuter le mode NVFP4, qui est une conversion directe sans perte de NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-NVFP4.

| Quantization         | Taille du GGUF | Mémoire minimale estimée |
| -------------------- | -------------- | ------------------------ |
| UD-IQ1\_M (1-bit)    | 46,1 Go        | 64 Go                    |
| UD-IQ2\_XXS (2-bit)  | 51,1 Go        | 64 Go                    |
| UD-IQ2\_M (2-bit)    | 55,9 Go        | 80 Go                    |
| UD-Q2\_K\_XL (2-bit) | 57,8 Go        | 80 Go                    |
| UD-IQ3\_XXS (3-bit)  | 59,8 Go        | 80 Go                    |
| UD-Q3\_K\_XL (3-bit) | 65,8 Go        | 96 Go                    |
| NVFP4 (4-bit)        | 79 Go          | 96 Go                    |
| UD-Q4\_K\_XL (4-bit) | 86,9 Go        | 128 Go                   |
| UD-Q5\_K\_XL (5-bit) | 111 Go         | 160 Go                   |
| UD-Q6\_K\_XL (6-bit) | 121 Go         | 160 Go                   |
| Q8\_0 (8-bit)        | 132 Go         | 192 Go                   |

Les chiffres de mémoire sont **des estimations de planification** pour un contexte modeste, incluant une marge pour le système d’exploitation, l’exécution, le cache KV et le projecteur de vision. La taille du fichier GGUF seule ne correspond pas à l’exigence en RAM. Des contextes plus longs et la vidéo nécessitent plus de mémoire ; toutes les pondérations du modèle doivent être stockées même si seuls 12B paramètres sont actifs par jeton. Ne comptez la mémoire unifiée qu’une seule fois.

Un **système à mémoire unifiée de 128 Go**comme DGX Spark, correspond au budget mémoire 4 bits suggéré. NVIDIA documente la prise en charge de DGX Spark via NIM ; ces estimations mémoire GGUF ne sont pas des résultats de performance mesurés.

### Paramètres recommandés

NVIDIA recommande ces paramètres :

| Paramètre     | Valeur |
| ------------- | ------ |
| `température` | `1.0`  |
| `top_p`       | `0.95` |

Commencez avec **un contexte de 16 K** et augmentez-le selon la mémoire disponible. Le modèle prend en charge jusqu’à **1 M de jetons**, mais votre runtime ou profil NIM peut avoir une limite inférieure. Les jetons d’invite et de sortie se partagent ce budget. Les exemples servent une requête à la fois.

**Réflexion activée ou désactivée**

Le modèle prend en charge `enable_thinking=True` (par défaut) pour le raisonnement et `enable_thinking=False` pour les réponses directes. NVIDIA NIM accepte cela via les kwargs du modèle de chat. Pour les GGUF locaux, utilisez le template de chat du modèle et les contrôles de réflexion pris en charge par votre runtime.

{% hint style="info" %}
Nemotron 3.5 Super VL est fourni avec **MTP (prédiction multi-jetons)**, qui est activé par défaut dans Unsloth pour accélérer la sortie. Vous pouvez le désactiver dans les paramètres. Consultez notre [guide MTP](https://unsloth.ai/docs/models/mtp).
{% endhint %}

### Guide d’exécution de Nemotron 3.5 Super VL <a href="#run-nemotron-35-super-vl-guide" id="run-nemotron-35-super-vl-guide"></a>

Pour ce tutoriel, nous utiliserons **UD-Q4\_K\_XL (86,9 Go)** avec environ **128 Go de mémoire**. Choisissez un quant plus petit dans le tableau ci-dessus si vous avez moins de mémoire.

#### 🦥 Exécutez Nemotron 3.5 Super VL dans Unsloth Desktop <a href="#run-nemotron-35-super-vl-in-unsloth-desktop" id="run-nemotron-35-super-vl-in-unsloth-desktop"></a>

Exécutez Nemotron 3.5 Super VL directement dans [Unsloth Desktop](https://unsloth.ai/docs/desktop) sur **macOS, Windows et Linux**. Recherchez, téléchargez et discutez avec le modèle dans l’application.

{% stepper %}
{% step %}

#### **Configurer Unsloth**

La façon la plus simple de commencer est de télécharger [l’application Unsloth Desktop](/docs/fr/desktop.md).

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

* <i class="fa-apple">:apple:</i> [Télécharger pour macOS](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Télécharger pour Windows](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Télécharger pour Linux](https://unsloth.ai/download/linux)

Vous pouvez également l’installer manuellement :

{% tabs %}
{% tab title="Installation native" %}
**MacOS, Linux, WSL :**

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

**Windows :**

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

{% endtab %}

{% tab title="Docker" %}
Le [L'image Docker Unsloth](https://hub.docker.com/r/unsloth/unsloth) `unsloth/unsloth` est disponible sur Docker. [Lire le guide.](https://unsloth.ai/docs/get-started/install/docker)
{% endtab %}

{% tab title="Homebrew" %}
Installer Unsloth Desktop :

{% code collapsedlinecount="10" %}

```bash
brew install --cask unsloth
```

{% endcode %}

Mettre à jour Unsloth Desktop :

```bash
brew upgrade --cask unsloth
```

{% endtab %}

{% tab title="WinGet" %}
Installer Unsloth Desktop :

```powershell
winget install --id UnslothAI.Unsloth -e
```

Mettre à jour Unsloth Desktop :

```powershell
winget upgrade --id UnslothAI.Unsloth -e
```

{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

#### Configurer et exécuter Nemotron 3.5 Super VL

Rendez-vous sur [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) ou le hub de modèles et recherchez Nemotron 3.5 Super VL dans la barre de recherche, puis téléchargez le modèle et le quant souhaités. Vous êtes maintenant prêt à exécuter le modèle !

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth, mais vous pouvez toujours les modifier manuellement. Vous pouvez également éditer la longueur du contexte, le template de chat et d’autres paramètres.

Pour essayer la compréhension d’image, joignez un PNG ou un JPEG et demandez **« Quelle est cette image ? »**

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FrTV33NAoY62hmlGHaEyw%2Fnemotron-super-vl-unsloth-desktop.png?alt=media&amp;token=e38fc0f5-bae6-442f-8c6f-4e9c54d326aa" alt="" width="563"><figcaption></figcaption></figure>

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

{% step %}

#### Servir Nemotron 3.5 Super VL avec l’API Unsloth

Servir Nemotron 3.5 Super VL avec `unsloth run`. Vous pouvez transmettre des drapeaux llama-server pour la taille du contexte, les couches GPU et d’autres paramètres. Consultez notre [documentation API](https://unsloth.ai/docs/basics/api) ou [unsloth start](https://unsloth.ai/docs/integrations/unsloth-start).

{% code overflow="wrap" %}

```bash
unsloth run --model unsloth/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-GGUF:UD-IQ2_XXS \\
    --ctx-size 4096 --parallel 1 --alias nemotron-super-vl \\
    --host 127.0.0.1 --port 8001
```

{% endcode %}
{% endstep %}

{% step %}

#### Unsloth est maintenant prêt

Vous pouvez également faire beaucoup d’autres choses avec Nemotron 3.5 Super VL via Unsloth Desktop, par exemple :

* **Connecter des outils :** [Claude Code](/docs/fr/notions-de-base/claude-code.md), [Codex](/docs/fr/notions-de-base/codex.md), [recherche web](/docs/fr/nouveau/studio/chat.md#advanced-web-search), [MCP](/docs/fr/notions-de-base/mcp.md) et plus encore
* **Entraîner des modèles :** Affiner du texte, de la diffusion, [des embeddings](/docs/fr/notions-de-base/embedding-finetuning.md), et plus encore
* **Générer des médias :** Créer et entraîner [des images](/docs/fr/notions-de-base/diffusion-image.md), des vidéos, [TTS](/docs/fr/notions-de-base/text-to-speech-tts-fine-tuning.md) localement
  {% endstep %}
  {% endstepper %}

### Benchmarks KLD

Nous avons utilisé UD-3 pour convertir Nemotron Super et avons réalisé du KLD général ainsi qu’un jeu de données KLD de texte inédit pour évaluer le surapprentissage - en général UD-Q4\_K\_XL est le meilleur en termes de KLD par rapport à l’espace disque - NVFP4 est aussi généralement correct, et UD-Q3\_K\_XL est également raisonnable.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FI0Lb9lHn00vouMw6Lj8n%2Fnemotron35_super_vl_kld_vs_disk(2).png?alt=media&amp;token=7aea3a84-5740-45e3-b542-2982133cafdb" alt=""><figcaption></figcaption></figure>

#### 🦙 Exécutez Nemotron 3.5 Super VL dans llama.cpp <a href="#run-nemotron-35-super-vl-in-llama.cpp" id="run-nemotron-35-super-vl-in-llama.cpp"></a>

{% stepper %}
{% step %}
**Compiler llama.cpp**

Installez la dernière version de 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 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.

```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
```

La vidéo a besoin à la fois de `ffmpeg` et `ffprobe` dans votre PATH. Poursuivez les commandes ci-dessous à partir de ce `llama.cpp` répertoire.
{% endstep %}

{% step %}
**Téléchargez le GGUF Unsloth**

Téléchargez le modèle et son projecteur de vision :

{% code overflow="wrap" %}

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -U huggingface_hub

hf download unsloth/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-GGUF \\
    --local-dir models/nemotron-super-vl \\
    --include "*UD-Q4_K_XL*.gguf" "*mmproj*.gguf"
```

{% endcode %}

Définissez les chemins vers le modèle téléchargé et son projecteur correspondant. Pour un GGUF découpé, gardez tous les shards ensemble et pointez vers le **premier shard**. Ajustez les noms de fichiers ci-dessous pour correspondre à votre téléchargement.

```bash
MODEL_FILE="models/nemotron-super-vl/NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-UD-Q4_K_XL.gguf"
MMPROJ_FILE="models/nemotron-super-vl/mmproj-BF16.gguf"
```

{% endstep %}

{% step %}
**Exécuter du texte et des images**

Pour le texte :

```bash
./llama.cpp/llama-cli \\
    --model "$MODEL_FILE" --ctx-size 16384 --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0 \\
    --prompt "Explique ce que fait un modèle vision-langage."
```

Pour une image, définissez le chemin vers votre propre PNG ou JPEG RGB. Pour les PDF, rendez d’abord les pages en images :

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-mtmd-cli \\
    --model "$MODEL_FILE" --mmproj "$MMPROJ_FILE" \\
    --ctx-size 16384 --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0 \\
    --image /path/to/picture.jpg \\
    --prompt "Décrivez cette image et extrayez tout texte visible."
```

{% endcode %}
{% endstep %}

{% step %}
**Exécuter la vidéo**

Démarrez la CLI multimodale :

```bash
./llama.cpp/llama-mtmd-cli \\
    --model "$MODEL_FILE" --mmproj "$MMPROJ_FILE" \\
    --ctx-size 16384 --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0
```

Puis saisissez ces lignes **dans la CLI**:

```
/video /path/to/video.mp4
Résumez la vidéo et décrivez les événements clés.
```

La fiche du modèle recommande **des clips MP4 de 1 à 2 minutes**. NIM échantillonne à 2 FPS, jusqu’à 256 images ; l’échantillonnage local dépend du runtime. Commencez par un court clip et augmentez le contexte si nécessaire, car les images de la vidéo consomment des jetons d’invite.
{% endstep %}
{% endstepper %}

#### Service et déploiement de llama-server <a href="#llama-server-serving-and-deployment" id="llama-server-serving-and-deployment"></a>

{% stepper %}
{% step %}
**Démarrer llama-server**

Créez un répertoire media et démarrez le serveur :

{% code overflow="wrap" %}

```bash
mkdir -p media
./llama.cpp/llama-server \\
    --model "$MODEL_FILE" --mmproj "$MMPROJ_FILE" \\
    --alias nemotron-super-vl \\
    --ctx-size 16384 --parallel 1 --temp 1.0 --top-p 0.95 --top-k 0 --min-p 0.0 \\
    --media-path "$PWD/media" \\
    --host 127.0.0.1 --port 8001
```

{% endcode %}

Ouvrez **<http://127.0.0.1:8001>** sur la même machine pour discuter avec le serveur llama.cpp.
{% endstep %}

{% step %}
**Envoyer une requête API**

Pour la vidéo, copiez un court clip dans `media/clip.mp4`, puis exécutez cette commande dans un autre terminal :

{% code overflow="wrap" %}

```bash
curl http://127.0.0.1:8001/v1/chat/completions \\
    -H 'Content-Type: application/json' \\
    -d '{
      "model": "nemotron-super-vl",
      "messages": [{"role": "user", "content": [
        {"type": "text", "text": "Résumez cette vidéo."},
        {"type": "input_video", "input_video": {"url": "file://clip.mp4"}}
      ]}],
      "max_tokens": 1024
    }'
```

{% endcode %}

`--media-path` permet au serveur de lire les médias locaux à partir de ce répertoire. Pour les requêtes texte uniquement, utilisez `"content": "Combien font 2+2 ?"` à la place du tableau de contenu.
{% endstep %}
{% endstepper %}

#### 📊 Tests de performance

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FBjoqDdZWELPnsSztDMlZ%2Faccuracy_plot(1).png?alt=media&amp;token=e4994520-d7a8-4d06-b183-fd6182c878d3" 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 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/nemotron-3.5-super-vl.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.
