> 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/inkling-2-small.md).

# Inkling 2 Small - Exécution en local

Découvrez comment exécuter localement Inkling 2 Small de Thinking Machines Lab avec Unsloth et llama.cpp.

**Inkling 2 Small** de [Thinking Machines Lab](https://thinkingmachines.ai/news/inkling-2-small/) est un modèle **de 594 milliards de paramètres** à mélange d’experts avec **17 milliards de paramètres actifs**. Il accepte des entrées textuelles et des images, et produit du texte, avec une fenêtre de contexte de **1 million de jetons** . Ce guide vous montrera comment l’exécuter localement avec des GGUF. Inkling 2 Small obtient 72,1 % sur DeepSWE v1.1 et 86,3 % sur SWEBench Pro v2 (Hard). Merci à Thinking Machines pour l’accès dès le premier jour.

Exécutez-le localement avec les GGUF dynamiques d’Unsloth : [**Inkling-2-Small-GGUF**](https://huggingface.co/unsloth/Inkling-2-Small-GGUF). UD-IQ1\_S (1 bit dynamique) nécessite 171,7 Go contre 394 Go (NVFP4), conserve 89,7 % de la précision du top 1 % et est 57 % plus petit.

<a href="https://unsloth.ai/docs/models/inkling-2#run-inkling-2-small-tutorials" class="button primary">Tutoriels pour exécuter Inkling 2 Small</a><a href="https://unsloth.ai/docs/models/inkling-2#quantization-analysis" class="button secondary">Résultats de quantification</a>

#### ⚙️ Guide d’utilisation

La quantification la plus légère, `UD-IQ1_S`, nécessite **171,7 Go d’espace disque pour les poids seuls**. Les exemples ci-dessous utilisent la quantification 2 bits `UD-IQ2_XXS` (**190,6 Go**). Choisissez une quantification adaptée à la mémoire disponible **RAM + VRAM**, ou à la mémoire unifiée.

{% hint style="success" %}
Prévoyez de la mémoire supplémentaire pour le système d’exploitation, le cache KV, les tampons d’exécution et le projecteur de vision. La taille du fichier ne correspond pas à la mémoire totale nécessaire à l’inférence. Commencez avec un contexte de 32K ; les contextes plus longs nécessitent davantage de mémoire.
{% endhint %}

**Paramètres recommandés**

Utilisez ces paramètres comme point de départ. Thinking Machines évalue Inkling 2 Small avec une **température de 1.0** et un effort de raisonnement **xhigh** .

| Température | Top-p | Top-k | Min-p |
| ----------- | ----- | ----- | ----- |
| `1.0`       | `1.0` | `0`   | `0.0` |

* **Fenêtre de contexte maximale :** `1,048,576` jetons.
* Utilisez le **modèle de conversation intégré**. Dans llama.cpp, activez-le avec `--jinja`.

**Modifier l’effort de raisonnement**

Le modèle GGUF utilise par défaut **high**. Choisissez `low` pour un raisonnement plus bref, ou `xhigh` pour les tâches difficiles, ou `none` pour demander des réponses sans raisonnement. Le paramètre `none` ne garantit pas strictement l’absence de raisonnement.

| Niveau d’effort | aucun | minimal | faible | moyen | élevé | très élevé / maximal |
| --------------- | ----- | ------- | ------ | ----- | ----- | -------------------- |
| Valeur          | 0.0   | 0.1     | 0.2    | 0.7   | 0.9   | 0.99                 |

### Exécuter les tutoriels Inkling 2 Small :

Utilisez un environnement d’exécution **Unsloth / llama.cpp compatible avec Inkling 2**. Les versions antérieures compatibles avec Inkling d’origine ne reconnaîtront peut-être pas la nouvelle architecture `inkling2` .

#### 🦥 Exécuter Inkling 2 Small dans Unsloth

{% stepper %}
{% step %}
**Installer et lancer Unsloth**

Téléchargez [**Unsloth Desktop**](https://unsloth.ai/download) pour **macOS, Windows ou Linux**. Ou installez-le depuis votre terminal :

**macOS, Linux, WSL :**

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

**Windows PowerShell :**

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

{% endstep %}

{% step %}
**Rechercher et télécharger Inkling 2 Small**

Ouvrez **Chat** ou **Model hub**, recherchez **Inkling-2-Small** et sélectionnez [**unsloth/Inkling-2-Small-GGUF**](https://huggingface.co/unsloth/Inkling-2-Small-GGUF). Téléchargez la quantification de votre choix. Pour les images en entrée, utilisez également le projecteur de vision correspondant `mmproj-F16.gguf` (**658 Mo**).
{% endstep %}

{% step %}
**Exécuter Inkling 2 Small**

Chargez le modèle, commencez avec **32 768 jetons de contexte**, et utilisez les paramètres ci-dessus. Vous pouvez ajuster la longueur du contexte, l’échantillonnage et le niveau d’effort de raisonnement dans les paramètres du modèle. Pour en savoir plus, consultez notre [guide d’inférence Unsloth](https://unsloth.ai/docs/new/studio/chat).

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FsZTREyAjLXIj4ELXLDsz%2Fimage.png?alt=media&amp;token=130fd6b0-941e-4784-bf96-59220e55c743" alt=""><figcaption></figcaption></figure>

Nous lui avons demandé de créer un petit jeu Flappy Bird avec UD-IQ1\_S, et le résultat était satisfaisant ! Nous fournissons également ci-dessous le code généré

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FMV608A1O4RDQ25uBAko7%2Fimage.png?alt=media&amp;token=059b77ec-f05f-4642-9e53-b99accdc2243" alt="" width="188"><figcaption></figcaption></figure>

{% code overflow="wrap" expandable="true" %}

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
<title>Flappy Bird</title>
<style>
  * { margin: 0; padding: 0; box-sizing: border-box; -webkit-tap-highlight-color: transparent; }
  html, body {
    height: 100%;
    overflow: hidden;
    background: linear-gradient(#1a2a6c, #203a43, #2c5364);
    display: flex;
    justify-content: center;
    align-items: center;
    font-family: 'Courier New', monospace;
  }
  #wrap {
    position: relative;
    box-shadow: 0 0 60px rgba(0,0,0,.6), 0 0 0 6px #3a2a1a, 0 0 0 12px #57422f;
    border-radius: 4px;
    overflow: hidden;
  }
  canvas {
    display: block;
    background: #70c5ce;
    cursor: pointer;
  }
  #hint {
    position: absolute;
    bottom: 8px;
    left: 0; right: 0;
    text-align: center;
    color: rgba(255,255,255,.85);
    font-size: 12px;
    pointer-events: none;
    text-shadow: 1px 1px 2px #000;
  }
</style>
</head>
<body>
<div id="wrap">
  <canvas id="game" width="400" height="560"></canvas>
  <div id="hint">ESPACE / CLIC / TOUCHER pour battre des ailes &nbsp;•&nbsp; P = pause</div>
</div>

<script>
(() => {
  const canvas = document.getElementById('game');
  const ctx = canvas.getContext('2d');
  const W = canvas.width, H = canvas.height;

  // ---------- Constantes du jeu ----------
  const GRAVITY = 0.38;
  const FLAP = -7.2;
  const PIPE_W = 62;
  const PIPE_GAP = 145;
  const PIPE_SPEED = 2.6;
  const PIPE_SPAWN = 1550;      // ms entre les tuyaux
  const GROUND_H = 72;
  const BIRD_X = 105;
  const BIRD_R = 14;

  // ---------- État ----------
  const STATE = { MENU: 0, PLAY: 1, OVER: 2, PAUSED: 3 };
  let state = STATE.MENU;
  let bird, pipes, score, best = 0, frame, lastPipe, groundX, flash;
  let clouds = [];

  try { best = parseInt(localStorage.getItem('flappy_best') || '0', 10) || 0; } catch (e) { best = 0; }

  function reset() {
    bird = { y: H / 2 - 40, vy: 0, rot: 0, wing: 0 };
    pipes = [];
    score = 0;
    frame = 0;
    lastPipe = 0;
    groundX = 0;
    flash = 0;
    clouds = [];
    for (let i = 0; i < 5; i++) {
      clouds.push({ x: Math.random() * W, y: 30 + Math.random() * 150, s: 0.6 + Math.random() * 0.8, v: 0.3 + Math.random() * 0.3 });
    }
  }
  reset();

  // ---------- Commandes ----------
  function flap() {
    if (state === STATE.MENU) { state = STATE.PLAY; bird.vy = FLAP; return; }
    if (state === STATE.OVER) { reset(); state = STATE.MENU; return; }
    if (state === STATE.PAUSED) { state = STATE.PLAY; return; }
    bird.vy = FLAP;
  }
  window.addEventListener('keydown', e => {
    if (e.code === 'Space' || e.code === 'ArrowUp') { e.preventDefault(); flap(); }
    if (e.code === 'KeyP') {
      if (state === STATE.PLAY) state = STATE.PAUSED;
      else if (state === STATE.PAUSED) state = STATE.PLAY;
    }
  });
  canvas.addEventListener('mousedown', flap);
  canvas.addEventListener('touchstart', e => { e.preventDefault(); flap(); }, { passive: false });

  // ---------- Mise à jour ----------
  function update(dt) {
    frame++;
    groundX = (groundX - PIPE_SPEED) % 48;
    clouds.forEach(c => { c.x -= c.v; if (c.x < -80) { c.x = W + 40; c.y = 30 + Math.random() * 150; } });

    if (state !== STATE.PLAY) {
      if (state === STATE.MENU) {
        bird.y = H / 2 - 40 + Math.sin(frame / 22) * 10;
        bird.wing = Math.sin(frame / 6) * 0.6;
      }
      if (flash > 0) flash -= dt;
      return;
    }

    bird.vy += GRAVITY;
    bird.y += bird.vy;
    bird.rot = Math.max(-0.5, Math.min(1.35, bird.vy / 9));
    bird.wing = Math.sin(frame / 5) * 0.7;

    // Générer les tuyaux
    const now = performance.now();
    if (now - lastPipe > PIPE_SPAWN) {
      lastPipe = now;
      const gapY = 90 + Math.random() * (H - GROUND_H - 180);
      pipes.push({ x: W + 20, gapY, passed: false });
    }

    // Déplacer les tuyaux et attribuer les points
    for (const p of pipes) {
      p.x -= PIPE_SPEED;
      if (!p.passed && p.x + PIPE_W < BIRD_X) { p.passed = true; score++; }
    }
    pipes = pipes.filter(p => p.x + PIPE_W > -10);

    // Collisions
    const groundY = H - GROUND_H;
    if (bird.y + BIRD_R >= groundY) { bird.y = groundY - BIRD_R; die(); }
    if (bird.y - BIRD_R <= 0) { bird.y = BIRD_R; bird.vy = 0; }
    for (const p of pipes) {
      if (BIRD_X + BIRD_R > p.x && BIRD_X - BIRD_R < p.x + PIPE_W) {
        if (bird.y - BIRD_R < p.gapY || bird.y + BIRD_R > p.gapY + PIPE_GAP) { die(); break; }
      }
    }
    if (flash > 0) flash -= dt;
  }

  function die() {
    if (state !== STATE.PLAY) return;
    state = STATE.OVER;
    flash = 220;
    if (score > best) {
      best = score;
      try { localStorage.setItem('flappy_best', String(best)); } catch (e) {}
    }
  }

  // ---------- Fonctions utilitaires de dessin ----------
  function drawBackground() {
    // Dégradé du ciel
    const g = ctx.createLinearGradient(0, 0, 0, H - GROUND_H);
    g.addColorStop(0, '#4ec0ca');
    g.addColorStop(0.7, '#71d3dc');
    g.addColorStop(1, '#a8e6ec');
    ctx.fillStyle = g;
    ctx.fillRect(0, 0, W, H - GROUND_H);

    // Soleil
    ctx.fillStyle = '#fff8c9';
    ctx.beginPath(); ctx.arc(W - 70, 62, 30, 0, Math.PI * 2); ctx.fill();
    ctx.fillStyle = 'rgba(255,248,201,.35)';
    ctx.beginPath(); ctx.arc(W - 70, 62, 46, 0, Math.PI * 2); ctx.fill();

    // Nuages
    ctx.fillStyle = 'rgba(255,255,255,.9)';
    for (const c of clouds) {
      ctx.save(); ctx.translate(c.x, c.y); ctx.scale(c.s, c.s);
      ctx.beginPath();
      ctx.arc(0, 0, 14, 0, Math.PI * 2);
      ctx.arc(14, -6, 12, 0, Math.PI * 2);
      ctx.arc(28, 0, 14, 0, Math.PI * 2);
      ctx.arc(14, 5, 15, 0, Math.PI * 2);
      ctx.fill();
      ctx.restore();
    }

    // Collines au loin
    ctx.fillStyle = '#5dbb63';
    ctx.beginPath();
    ctx.moveTo(0, H - GROUND_H);
    for (let x = 0; x <= W; x += 40) {
      ctx.lineTo(x, H - GROUND_H - 26 - Math.sin((x + 200) / 55) * 14);
    }
    ctx.lineTo(W, H - GROUND_H);
    ctx.closePath(); ctx.fill();

    // Buissons proches
    ctx.fillStyle = '#3fa34d';
    ctx.fillRect(0, H - GROUND_H - 6, W, 8);
  }

  function drawPipe(p) {
    const topH = p.gapY, botY = p.gapY + PIPE_GAP, botH = H - GROUND_H - botY;
    const grad = ctx.createLinearGradient(p.x, 0, p.x + PIPE_W, 0);
    grad.addColorStop(0, '#5aa832');
    grad.addColorStop(0.18, '#8ee06a');
    grad.addColorStop(0.35, '#73c74f');
    grad.addColorStop(0.55, '#4f9c2c');
    grad.addColorStop(0.8, '#3d7d22');
    grad.addColorStop(1, '#2c5c17');

    function pipeBody(y, h, capAtBottom) {
      ctx.fillStyle = grad;
      ctx.fillRect(p.x, y, PIPE_W, h);
      ctx.strokeStyle = '#1e4010'; ctx.lineWidth = 2;
      ctx.strokeRect(p.x, y, PIPE_W, h);
      // Embout
      const capH = 24, capY = capAtBottom ? y + h - capH : y;
      ctx.fillStyle = grad;
      ctx.fillRect(p.x - 4, capY, PIPE_W + 8, capH);
      ctx.strokeRect(p.x - 4, capY, PIPE_W + 8, capH);
    }
    pipeBody(0, topH, true);
    pipeBody(botY, botH, false);
  }

  function drawGround() {
    const y = H - GROUND_H;
    // Herbe
    ctx.fillStyle = '#ded895';
    ctx.fillRect(0, y, W, GROUND_H);
    ctx.fillStyle = '#7ee35b';
    ctx.fillRect(0, y, W, 16);
    ctx.fillStyle = '#4cbb2e';
    for (let x = groundX; x < W + 48; x += 48) {
      ctx.beginPath();
      ctx.moveTo(x, y + 16); ctx.lineTo(x + 12, y + 2); ctx.lineTo(x + 24, y + 16);
      ctx.fill();
    }
    // Stries de terre
    ctx.fillStyle = '#c9bd7a';
    for (let x = groundX; x < W + 48; x += 48) {
      ctx.fillRect(x + 6, y + 34, 22, 6);
      ctx.fillRect(x + 26, y + 52, 18, 6);
    }
    ctx.strokeStyle = '#3a2a1a'; ctx.lineWidth = 3;
    ctx.beginPath(); ctx.moveTo(0, y + 1.5); ctx.lineTo(W, y + 1.5); ctx.stroke();
  }

  function drawBird() {
    ctx.save();
    ctx.translate(BIRD_X, bird.y);
    ctx.rotate(bird.rot);

    // Corps
    const bg = ctx.createRadialGradient(-4, -4, 2, 0, 0, BIRD_R + 2);
    bg.addColorStop(0, '#ffe873');
    bg.addColorStop(0.6, '#ffd23f');
    bg.addColorStop(1, '#e0a92e');
    ctx.fillStyle = bg;
    ctx.beginPath(); ctx.ellipse(0, 0, BIRD_R + 2, BIRD_R, 0, 0, Math.PI * 2); ctx.fill();
    ctx.strokeStyle = '#7a5b12'; ctx.lineWidth = 2; ctx.stroke();

    // Aile
    ctx.save();
    ctx.translate(-4, 0);
    ctx.rotate(bird.wing);
    ctx.fillStyle = '#f4b63f';
    ctx.beginPath(); ctx.ellipse(-4, 2, 9, 6.5, 0, 0, Math.PI * 2); ctx.fill();
    ctx.strokeStyle = '#7a5b12'; ctx.stroke();
    ctx.restore();

    // Œil
    ctx.fillStyle = '#fff';
    ctx.beginPath(); ctx.arc(7, -4, 5.5, 0, Math.PI * 2); ctx.fill();
    ctx.strokeStyle = '#333'; ctx.lineWidth = 1.2; ctx.stroke();
    ctx.fillStyle = '#222';
    ctx.beginPath(); ctx.arc(8.5, -4, 2.6, 0, Math.PI * 2); ctx.fill();

    // Bec
    ctx.fillStyle = '#ff6b35';
    ctx.beginPath();
    ctx.moveTo(BIRD_R - 1, -1);
    ctx.lineTo(BIRD_R + 9, 2.5);
    ctx.lineTo(BIRD_R - 1, 6);
    ctx.closePath(); ctx.fill();
    ctx.strokeStyle = '#a83a12'; ctx.lineWidth = 1.5; ctx.stroke();

    ctx.restore();
  }

  function drawText(text, x, y, size, color = '#fff', stroke = '#000') {
    ctx.font = `bold ${size}px 'Courier New', monospace`;
    ctx.textAlign = 'center';
    ctx.lineWidth = Math.max(2, size / 8);
    ctx.strokeStyle = stroke;
    ctx.strokeText(text, x, y);
    ctx.fillStyle = color;
    ctx.fillText(text, x, y);
  }

  function drawMedal(cx, cy, s) {
    const colors = ['#cd7f32', '#c0c0c0', '#ffd700', '#b9f2ff'];
    const idx = score >= 40 ? 3 : score >= 30 ? 2 : score >= 20 ? 1 : 0;
    ctx.fillStyle = colors[idx];
    ctx.beginPath(); ctx.arc(cx, cy, 20 * s, 0, Math.PI * 2); ctx.fill();
    ctx.strokeStyle = '#5a4a1a'; ctx.lineWidth = 2; ctx.stroke();
    ctx.fillStyle = 'rgba(255,255,255,.5)';
    ctx.beginPath(); ctx.arc(cx - 5 * s, cy - 5 * s, 7 * s, 0, Math.PI * 2); ctx.fill();
    drawText(['BRONZE','SILVER','GOLD','PLATINUM'][idx], cx, cy + 34 * s, 10, '#fff');
  }

  function draw() {
    ctx.clearRect(0, 0, W, H);
    drawBackground();
    pipes.forEach(drawPipe);
    drawGround();
    drawBird();

    if (state === STATE.PLAY || state === STATE.PAUSED) {
      drawText(String(score), W / 2, 78, 52);
    }

    if (state === STATE.MENU) {
      drawText('FLAPPY', W / 2, 130, 56, '#ffd23f', '#5a3a00');
      drawText('BIRD', W / 2, 190, 56, '#ffd23f', '#5a3a00');
      drawText('Appuyez ou utilisez Espace pour battre des ailes', W / 2, 300, 17);
      drawText('Record : ' + best, W / 2, 330, 15, '#fff');
    }

    if (state === STATE.PAUSED) {
      ctx.fillStyle = 'rgba(0,0,0,.45)'; ctx.fillRect(0, 0, W, H);
      drawText('EN PAUSE', W / 2, H / 2 - 10, 40);
      drawText('Appuyez sur P pour reprendre', W / 2, H / 2 + 28, 16);
    }

    if (state === STATE.OVER) {
      if (flash > 0) { ctx.fillStyle = `rgba(255,255,255,${flash / 220 * 0.8})`; ctx.fillRect(0, 0, W, H); }
      // Panneau de fin de partie
      ctx.fillStyle = 'rgba(0,0,0,.35)'; ctx.fillRect(0, 0, W, H);
      ctx.fillStyle = '#f5deb3';
      ctx.strokeStyle = '#5a3a1a'; ctx.lineWidth = 4;
      const px = W / 2 - 130, py = 150, pw = 260, ph = 190;
      ctx.beginPath(); ctx.roundRect(px, py, pw, ph, 10); ctx.fill(); ctx.stroke();
      drawText('FIN DE PARTIE', W / 2, py + 38, 30, '#e74c3c', '#3a1000');
      drawText('Score : ' + score, px + 130, py + 78, 20, '#333', 'rgba(0,0,0,0)');
      drawText('Record :  ' + best, px + 130, py + 104, 20, '#333', 'rgba(0,0,0,0)');
      drawMedal(px + 55, py + 140, 1);
      drawText('Touchez pour réessayer', px + 165, py + 148, 16, '#2c5c17', 'rgba(0,0,0,0)');
    }
  }

  // ---------- Boucle principale ----------
  let last = performance.now();
  function loop(now) {
    const dt = Math.min(50, now - last);
    last = now;
    update(dt);
    draw();
    requestAnimationFrame(loop);
  }
  requestAnimationFrame(loop);
})();
</script>
</body>
</html>

```

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

#### 🦙 Exécuter Inkling 2 Small dans llama.cpp

Installation [llama.cpp](https://github.com/ggml-org/llama.cpp) avec la prise en charge d’Inkling 2 : le projet amont prend désormais directement en charge le modèle. Exécutez les commandes suivantes depuis votre répertoire llama.cpp dans Bash (macOS, Linux ou WSL).

Sur 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 la boîte à outils [CUDA](https://developer.nvidia.com/cuda-downloads). Sur macOS, installez les outils en ligne de commande de Xcode et CMake ; utilisez `-DGGML_CUDA=OFF` (Metal est activé par défaut). Utilisez `OFF` également pour les compilations CPU uniquement.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev git -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
```

**1. Télécharger le modèle et le projecteur de vision**

```bash
pip install -U huggingface_hub
hf download unsloth/Inkling-2-Small-GGUF \
    --include "UD-IQ2_XXS/*" "mmproj-F16.gguf" \
    --local-dir Inkling-2-Small-GGUF
```

Conservez **les cinq fragments** dans le même dossier. Indiquez le premier fragment à llama.cpp ; les autres se chargent automatiquement. Tant que le dépôt est privé, les téléchargements nécessitent un accès et `hf auth login`.

**2. Lancer le serveur de chat local**

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \
    -m Inkling-2-Small-GGUF/UD-IQ2_XXS/Inkling-2-Small-UD-IQ2_XXS-00001-of-00005.gguf \
    --mmproj Inkling-2-Small-GGUF/mmproj-F16.gguf \
    --jinja -ngl 99 -c 32768 \
    --temp 1.0 --top-p 1.0 --top-k 0 --min-p 0.0 \
    --chat-template-kwargs '{"reasoning_effort":"high"}'
```

{% endcode %}

Ouvrez [**http://localhost:8080**](http://localhost:8080) pour discuter et téléverser des images. Diminuez `-ngl` si le modèle ne tient pas dans la VRAM, ou utilisez `-ngl 0` pour l’inférence sur CPU. Pour une utilisation en texte seul, omettez `--mmproj`.

#### Analyse de la quantification

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fa3FEbHeane8hoZhRLuV5%2Fimage.png?alt=media&amp;token=84c3f9ed-cdcb-46d1-b715-283d47499ce7" alt=""><figcaption></figcaption></figure>

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FHY57QxZ6VDo8haLPyusw%2Fimage.png?alt=media&amp;token=504b0604-944c-47f4-a725-b1883c1c9464" alt=""><figcaption></figcaption></figure>

Les résultats de la [fiche du modèle GGUF d’Unsloth](https://huggingface.co/unsloth/Inkling-2-Small-GGUF) comparent chaque quantification au GGUF de référence sur **64 × 4 096 jetons de WikiText-2**, avec un cache KV F16. **La concordance du jeton le plus probable n’est pas un score de précision sur un benchmark de tâches.** Les tailles n’incluent pas le projecteur de vision.

| Quantification | Taille (Go) | KLD moyen ↓ | Même jeton le plus probable ↑ |
| -------------- | ----------- | ----------- | ----------------------------- |
| `UD-IQ1_S`     | 171.7       | 0.0922      | 89.7%                         |
| `UD-IQ1_M`     | 178.5       | 0.0829      | 90.2%                         |
| `UD-IQ2_XXS`   | 190.6       | 0.0577      | 91.8%                         |
| `UD-Q2_K_XL`   | 205.0       | 0.0450      | 92.7%                         |
| `UD-IQ3_XXS`   | 226.0       | 0.0364      | 93.3%                         |
| `UD-Q3_K_XL`   | 285.1       | 0.0176      | 95.3%                         |
| `UD-Q4_K_XL`   | 354.2       | 0.0029      | 98.0%                         |
| `UD-Q8_K_XL`   | 386.5       | 0.0027      | 98.1%                         |
| `BF16`         | 484.4       |             |                               |

**BF16** est une conversion sans perte qui préserve les **experts NVFP4 des couches 0 à 39** et stocke les autres poids en BF16. **UD-Q8\_K\_XL** préserve ces mêmes experts NVFP4 et quantifie les autres poids sur 8 bits.


---

# 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/inkling-2-small.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.
