GLM-4.7-Flash : comment l'exécuter en local

Exécutez et fine-tunez GLM-4.7-Flash localement sur votre appareil !

GLM-4.7-Flash est le nouveau modèle de raisonnement MoE 30B de Z.ai, conçu pour un déploiement local, offrant des performances de premier ordre pour le codage, les flux de travail agentiques et le chat. Il utilise ~3,6B de paramètres, prend en charge un contexte de 200K et domine les benchmarks SWE-Bench, GPQA et de raisonnement/chat.

GLM-4.7-Flash fonctionne sur 24 Go de RAM/VRAM/mémoire unifiée (32 Go pour la précision complète), et vous pouvez désormais affiner avec Unsloth. Pour exécuter GLM 4.7 Flash avec vLLM, voir GLM-4.7-Flash

Mise à jour du 21 janv. : llama.cpp correction d’un bug spécifiant le mauvais scoring_func: "softmax" (devrait être "sigmoid"). Cela provoquait des boucles et de mauvais résultats. Nous avons mis à jour les GGUF — veuillez retélécharger le modèle pour obtenir de bien meilleurs résultats.

Vous pouvez maintenant utiliser les paramètres recommandés par Z.ai et obtenir d’excellents résultats :

• Pour un cas d’usage général : --temp 1.0 --top-p 0.95

• Pour l’appel d’outils : --temp 0.7 --top-p 1.0

• Pénalité de répétition : Désactivez-la, ou définissez --repeat-penalty 1.0

22 janv. : l’inférence plus rapide est arrivée, car la correction FA pour CUDA a maintenant été fusionnée.

Tutoriel d’exécutionLe fine-tuning

GGUF de GLM-4.7-Flash à exécuter : unsloth/GLM-4.7-Flash-GGUF

⚙️ Guide d’utilisation

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. Si ce n’est pas le cas, llama.cpp peut quand même fonctionner via un déchargement sur SSD/HDD, mais l’inférence sera plus lente.

Après avoir parlé avec l’équipe de Z.ai, elle recommande d’utiliser ses paramètres d’échantillonnage GLM-4.7 :

Paramètres par défaut (la plupart des tâches)	Terminal Bench, SWE Bench Verified
temperature = 1.0	temperature = 0.7
top_p = 0.95	top_p = 1.0
repeat penalty = désactivée ou 1.0	repeat penalty = désactivée ou 1.0

• Pour un cas d’usage général : --temp 1.0 --top-p 0.95

• Pour l’appel d’outils : --temp 0.7 --top-p 1.0

• Si vous utilisez llama.cpp, définissez --min-p 0.01 car la valeur par défaut de llama.cpp est 0.05

• Parfois, vous devrez expérimenter pour voir quels paramètres fonctionnent le mieux pour votre cas d’usage.

Pour le moment, nous ne recommandons pas d’exécuter ce GGUF avec Ollama en raison d’éventuels problèmes de compatibilité avec le modèle de chat. Le GGUF fonctionne bien avec llama.cpp (ou des backends tels que LM Studio, Jan).

N’oubliez pas de désactiver la pénalité de répétition ! Ou définissez --repeat-penalty 1.0

• Fenêtre de contexte maximale : 202,752

🖥️ Exécuter GLM-4.7-Flash

Selon votre cas d’utilisation, vous devrez utiliser différents réglages. Certains GGUF finissent par avoir une taille similaire parce que l’architecture du modèle (comme modèles d’OpenAI incluent une fonctionnalité qui permet aux utilisateurs d’ajuster le « niveau d’effort de raisonnement » du modèle. Cela vous donne le contrôle sur le compromis entre les performances du modèle et sa vitesse de réponse (latence), qui dépend du nombre de jetons que le modèle utilisera pour réfléchir.) a des dimensions non divisibles par 128, donc certaines parties ne peuvent pas être quantifiées avec moins de bits.

Comme ce guide utilise du 4 bits, vous aurez besoin d’environ 18 Go de RAM/mémoire unifiée. Nous recommandons d’utiliser au moins une précision 4 bits pour de meilleures performances.

Pour le moment, nous ne recommandons pas d’exécuter ce GGUF avec Ollama en raison d’éventuels problèmes de compatibilité avec le modèle de chat. Le GGUF fonctionne bien avec llama.cpp (ou des backends tels que LM Studio, Jan).

N’oubliez pas de désactiver la pénalité de répétition ! Ou définissez --repeat-penalty 1.0

Tutoriel Llama.cpp (GGUF) :

Instructions pour exécuter dans llama.cpp (notez que nous utiliserons 4 bits pour s’adapter à la plupart des appareils) :

1

Obtenez la dernière llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Changez -DGGML_CUDA=ON en -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.

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

2

Vous pouvez effectuer un téléchargement direct depuis Hugging Face. Vous pouvez augmenter le contexte jusqu’à 200K selon la quantité de RAM/VRAM disponible.

Vous pouvez aussi essayer les paramètres d’échantillonnage GLM-4.7 recommandés par Z.ai :

• Pour un cas d’usage général : --temp 1.0 --top-p 0.95

• Pour l’appel d’outils : --temp 0.7 --top-p 1.0

• N’oubliez pas de désactiver la pénalité de répétition !

Suivez ceci pour le les cas d’utilisation d’instructions générales :

./llama.cpp/llama-cli \
    -hf unsloth/GLM-4.7-Flash-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \
    --temp 1.0 --top-p 0.95 --min-p 0.01

Suivez ceci pour le appel d’outils :

./llama.cpp/llama-cli \
    -hf unsloth/GLM-4.7-Flash-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \
    --temp 0.7 --top-p 1.0 --min-p 0.01

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub). Vous pouvez choisir UD-Q4_K_XL ou d’autres versions quantifiées. Si les téléchargements se bloquent, voir Hugging Face Hub, débogage XET

pip install -U huggingface_hub
hf download unsloth/GLM-4.7-Flash-GGUF \\
    --local-dir unsloth/GLM-4.7-Flash-GGUF \\
    --include "*UD-Q2_K_XL*"

4

Puis exécutez le modèle en mode conversation :

./llama.cpp/llama-cli \
    --model unsloth/GLM-4.7-Flash-GGUF/GLM-4.7-Flash-UD-Q4_K_XL.gguf \\
    --ctx-size 16384 \
    --seed 3407 \
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01

Aussi, ajustez la fenêtre de contexte selon les besoins, jusqu’à 202752

➿Réduction des répétitions et des boucles

MISE À JOUR DU 21 JANV. : llama.cpp a corrigé un bug spécifiant le mauvais "scoring_func": "softmax" qui provoquait des boucles et de mauvais résultats (devrait être sigmoid) Nous avons mis à jour les GGUF. Veuillez retélécharger le modèle pour obtenir de bien meilleurs résultats.

Cela signifie que vous pouvez maintenant utiliser les paramètres recommandés par Z.ai et obtenir d’excellents résultats :

• Pour un cas d’usage général : --temp 1.0 --top-p 0.95

• Pour l’appel d’outils : --temp 0.7 --top-p 1.0

• Si vous utilisez llama.cpp, définissez --min-p 0.01 car la valeur par défaut de llama.cpp est 0.05

• N’oubliez pas de désactiver la pénalité de répétition ! Ou définissez --repeat-penalty 1.0

Nous avons ajouté "scoring_func": "sigmoid" en config.json pour le modèle principal - voir.

Pour le moment, nous ne recommandons pas d’exécuter ce GGUF avec Ollama en raison d’éventuels problèmes de compatibilité avec le modèle de chat. Le GGUF fonctionne bien avec llama.cpp (ou des backends tels que LM Studio, Jan).

🐦Exemple Flappy Bird avec UD-Q4_K_XL

À titre d’exemple, nous avons effectué la longue conversation suivante en utilisant UD-Q4_K_XL via ./llama.cpp/llama-cli --model unsloth/GLM-4.7-Flash-GGUF/GLM-4.7-Flash-UD-Q4_K_XL.gguf --fit on --temp 1.0 --top-p 0.95 --min-p 0.01 :

Salut
Combien font 2+2
Créer un jeu Flappy Bird en Python
Créer un jeu totalement différent en Rust
Trouver les bugs dans les deux
Faire le 1er jeu que j’ai mentionné, mais dans un fichier HTML autonome
Trouver les bugs et montrer le jeu corrigé

ce qui a rendu le jeu Flappy Bird suivant au format HTML :

Jeu Flappy Bird en HTML (extensible)

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
    <title>Flappy Bird corrigé</title>
    <style>
        body {
            margin: 0;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            background-color: #222;
            font-family: 'Arial', sans-serif;
            overflow: hidden;
            user-select: none;
            -webkit-user-select: none;
            touch-action: none; /* Empêche le zoom sur mobile */
        }

        #game-container {
            position: relative;
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
        }

        canvas {
            background-color: #87CEEB;
            display: block;
            border-radius: 4px;
        }

        /* Superpositions de l’interface */
        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            text-align: center;
        }

        #score-display {
            position: absolute;
            top: 40px;
            left: 50%;
            transform: translateX(-50%);
            font-size: 48px;
            font-weight: bold;
            color: white;
            text-shadow: 3px 3px 0 #000;
            z-index: 10;
            font-family: 'Courier New', Courier, monospace;
        }

        #start-screen, #game-over-screen {
            background: rgba(0, 0, 0, 0.7);
            width: 100%;
            height: 100%;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            color: white;
            pointer-events: auto; /* Autoriser les clics */
            cursor: pointer;
        }

        h1 { margin: 0 0 10px 0; font-size: 60px; text-shadow: 4px 4px 0 #000; line-height: 1; }
        p { font-size: 22px; margin: 10px 0; color: #ddd; }
        
        .btn {
            background: linear-gradient(to bottom, #ffeb3b, #fbc02d);
            border: 3px solid #fff;
            color: #333;
            padding: 15px 40px;
            font-size: 28px;
            font-weight: bold;
            cursor: pointer;
            border-radius: 8px;
            box-shadow: 0 6px 0 #c49000, 0 10px 10px rgba(0,0,0,0.3);
            text-transform: uppercase;
            transition: all 0.1s;
            margin-top: 10px;
        }

        .btn:active {
            transform: translateY(4px);
            box-shadow: 0 2px 0 #c49000, 0 4px 4px rgba(0,0,0,0.3);
        }

        .score-board {
            background: #ded895;
            border: 2px solid #543847;
            padding: 20px 40px;
            border-radius: 10px;
            box-shadow: 4px 4px 0 #543847;
            margin-bottom: 30px;
            display: none;
            border: 4px solid #543847;
        }
        
        .score-board h2 { margin: 0 0 5px 0; color: #e86101; font-size: 40px; }
        .score-board span { font-size: 20px; color: #543847; display: block; text-align: center; }

    </style>
</head>
<body>

    <div id="game-container">
        <canvas id="gameCanvas" width="400" height="600"></canvas>
        
        <div id="score-display">0</div>

        <div id="ui-layer">
            <div id="start-screen">
                <h1>FLAPPY<br>BIRD</h1>
                <p>Appuyez ou pressez Espace pour commencer</p>
                <button class="btn" style="display:none;" id="touch-instruction">Cliquez pour commencer</button>
            </div>

            <div id="game-over-screen">
                <h1>FIN DE PARTIE</h1>
                <div class="score-board" id="score-board">
                    <h2>Score : <span id="final-score">0</span></h2>
                </div>
                <button class="btn" id="restart-btn">Réessayer</button>
            </div>
        </div>
    </div>

<script>
    const canvas = document.getElementById('gameCanvas');
    const ctx = canvas.getContext('2d');

    // --- Constantes ---
    const GRAVITY = 0.35; // Gravité légèrement plus forte pour une meilleure sensation
    const JUMP_STRENGTH = -6.5;
    const PIPE_GAP = 180;
    const PIPE_WIDTH = 60;
    const PIPE_SPEED = 2.5;
    const PIPE_SPAWN_RATE = 100;

    // --- État ---
    let frames = 0;
    let score = 0;
    let isGameOver = false;
    let isPlaying = false;
    let gameLoopId;

    const ui = {
        startScreen: document.getElementById('start-screen'),
        gameOverScreen: document.getElementById('game-over-screen'),
        scoreDisplay: document.getElementById('score-display'),
        scoreBoard: document.getElementById('score-board'),
        finalScore: document.getElementById('final-score'),
        restartBtn: document.getElementById('restart-btn')
    };

    const bird = {
        x: 80,
        y: 150,
        radius: 12, // Rayon fixé
        velocity: 0,
        
        draw: function() {
            // Faire pivoter l’oiseau selon la vitesse pour un effet visuel
            let angle = Math.min(Math.PI / 4, Math.max(-Math.PI / 4, (this.velocity * 0.1)));
            
            ctx.save();
            ctx.translate(this.x, this.y);
            ctx.rotate(angle);
            
            // Dessiner le corps
            ctx.fillStyle = '#FFD700';
            ctx.beginPath();
            ctx.arc(0, 0, this.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // Œil
            ctx.fillStyle = 'white';
            ctx.beginPath();
            ctx.arc(4, -4, 4, 0, Math.PI * 2);
            ctx.fill();
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(6, -4, 2, 0, Math.PI * 2);
            ctx.fill();
            
            // Aile
            ctx.fillStyle = '#FFA500';
            ctx.beginPath();
            ctx.arc(-4, 4, 5, 0, Math.PI * 2);
            ctx.fill();

            ctx.restore();
        },

        update: function() {
            this.velocity += GRAVITY;
            this.y += this.velocity;
        },

        jump: function() {
            this.velocity = JUMP_STRENGTH;
        },

        reset: function() {
            this.y = 150;
            this.velocity = 0;
        }
    };

    let pipes = [];

    function createPipe() {
        const minHeight = 50;
        const maxPos = canvas.height - PIPE_GAP - minHeight;
        const topHeight = Math.floor(Math.random() * (maxPos - minHeight + 1)) + minHeight;
        
        pipes.push({
            x: canvas.width,
            topHeight: topHeight,
            bottomY: topHeight + PIPE_GAP,
            width: PIPE_WIDTH,
            passed: false
        });
    }

    function drawPipes() {
        ctx.fillStyle = '#2ecc71';
        ctx.strokeStyle = '#27ae60';
        ctx.lineWidth = 2;
        
        pipes.forEach(pipe => {
            // Tuyau du haut
            ctx.fillRect(pipe.x, 0, pipe.width, pipe.topHeight);
            ctx.strokeRect(pipe.x, 0, pipe.width, pipe.topHeight);
            
            // Tuyau du bas
            ctx.fillRect(pipe.x, pipe.bottomY, pipe.width, canvas.height - pipe.bottomY);
            ctx.strokeRect(pipe.x, pipe.bottomY, pipe.width, canvas.height - pipe.bottomY);

            // Capuchon
            const capH = 20;
            ctx.fillStyle = '#27ae60'; 
            ctx.fillRect(pipe.x - 2, pipe.topHeight - capH, pipe.width + 4, capH);
            ctx.fillRect(pipe.x - 2, pipe.bottomY, pipe.width + 4, capH);
        });
    }

    function updatePipes() {
        if (frames % PIPE_SPAWN_RATE === 0) createPipe();

        for (let i = 0; i < pipes.length; i++) {
            let p = pipes[i];
            p.x -= PIPE_SPEED;

            // --- DÉTECTION DES COLLISIONS CORRIGÉE ---
            // Considérer l’oiseau comme un cercle de rayon 'bird.radius'
            // Le tuyau est un rectangle : x, x+w, y_top, y_bottom
            let birdLeft = bird.x - bird.radius;
            let birdRight = bird.x + bird.radius;
            let birdTop = bird.y - bird.radius;
            let birdBottom = bird.y + bird.radius;

            // Chevauchement horizontal
            if (birdRight > p.x && birdLeft < p.x + p.width) {
                // Chevauchement vertical (toucher le tuyau du haut OU du bas)
                if (birdTop < p.topHeight || birdBottom > p.bottomY) {
                    gameOver();
                }
            }

            // --- SCORE CORRIGÉ ---
            // Si le tuyau est hors écran à gauche, et n’a pas encore été compté
            if (p.x + p.width < 0 && !p.passed) {
                score++;
                p.passed = true;
                ui.scoreDisplay.innerText = score;
            }

            if (p.x < -60) {
                pipes.shift();
                i--;
            }
        }
    }

    function checkCollisions() {
        // Sol
        if (bird.y + bird.radius >= canvas.height) {
            gameOver();
        }
        // Plafond
        if (bird.y - bird.radius <= 0) {
            bird.y = bird.radius;
            bird.velocity = 0;
        }
    }

    function drawBackground() {
        // Effacer
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        
        // Sol
        ctx.fillStyle = '#654321';
        ctx.fillRect(0, canvas.height - 10, canvas.width, 10);
        
        // Nuages
        ctx.fillStyle = "rgba(255, 255, 255, 0.6)";
        for(let i=0; i<4; i++) {
            let x = (frames * 0.5 + i * 150) % (canvas.width + 100) - 50;
            let y = (i * 40) + 20;
            let scale = 1 + (Math.sin(frames * 0.02 + i) * 0.1);
            let size = 30 * scale;
            ctx.beginPath();
            ctx.arc(x, y, size, 0, Math.PI * 2);
            ctx.arc(x + 20*scale, y - 10*scale, size * 1.2, 0, Math.PI * 2);
            ctx.arc(x + 40*scale, y, size, 0, Math.PI * 2);
            ctx.fill();
        }
    }

    function update() {
        if (!isPlaying) return;
        bird.update();
        updatePipes();
        checkCollisions();
        frames++;
    }

    function draw() {
        drawBackground();
        drawPipes();
        bird.draw();
    }

    function loop() {
        update();
        draw();
        if (isPlaying || !isGameOver) {
            gameLoopId = requestAnimationFrame(loop);
        }
    }

    function startGame() {
        isPlaying = true;
        isGameOver = false;
        
        // Interface
        ui.startScreen.style.display = 'none';
        ui.gameOverScreen.style.display = 'none';
        ui.scoreBoard.style.display = 'none';
        
        // Logique
        bird.reset();
        pipes = [];
        score = 0;
        frames = 0;
        ui.scoreDisplay.innerText = '0';
        
        loop();
    }

    function gameOver() {
        isPlaying = false;
        isGameOver = true;
        cancelAnimationFrame(gameLoopId);
        
        ui.finalScore.innerText = score;
        ui.gameOverScreen.style.display = 'flex';
        ui.scoreBoard.style.display = 'block';
    }

    // --- Gestion des entrées ---

    function handleInput(e) {
        if (e.type === 'keydown' && e.code === 'Space') e.preventDefault();

        if (isPlaying) {
            bird.jump();
        } else if (!isGameOver) {
            // Clic sur l’écran de démarrage (ou tout clic si le jeu n’a pas commencé)
            startGame();
        }
    }

    // Clavier
    window.addEventListener('keydown', (e) => {
        if (e.code === 'Space') handleInput(e);
    });

    // Souris / Tactile
    window.addEventListener('mousedown', handleInput);
    window.addEventListener('touchstart', (e) => {
        // Empêcher le zoom/le défilement
        // e.preventDefault(); 
        handleInput(e);
    }, {passive: false});

    // Interactions de l’interface
    ui.restartBtn.addEventListener('click', (e) => {
        e.stopPropagation();
        startGame();
    });
    
    // Autoriser le clic sur l’overlay de fin de partie pour recommencer
    ui.gameOverScreen.addEventListener('mousedown', (e) => {
        if(e.target === ui.gameOverScreen) startGame();
    });
    ui.gameOverScreen.addEventListener('touchstart', (e) => {
        if(e.target === ui.gameOverScreen) {
            e.preventDefault();
            startGame();
        }
    });

    // Dessin initial
    drawBackground();
    bird.reset();
    bird.draw();

</script>
</body>
</html>

Et nous avons pris quelques captures d’écran (le 4 bits fonctionne) :

🦥 Affinage de GLM-4.7-Flash

Unsloth prend désormais en charge l’affinage de GLM-4.7-Flash, cependant vous devrez utiliser transformers v5. Le modèle 30B ne tient pas sur un GPU Colab gratuit ; toutefois, vous pouvez utiliser notre notebook. L’affinage LoRA 16 bits de GLM-4.7-Flash utilisera environ 60 Go de VRAM:

• Notebook SFT LoRA de GLM-4.7-Flash

Vous pouvez parfois rencontrer un manque de mémoire lors de l’utilisation d’un A100 40 Go de VRAM. Vous devrez utiliser un H100/A100 80 Go de VRAM pour des exécutions plus fluides.

Google Colabcolab.research.google.com

Lors de l’affinage des MoE, il n’est probablement pas judicieux d’affiner la couche routeur, nous l’avons donc désactivée par défaut. Si vous voulez conserver ses capacités de raisonnement (optionnel), vous pouvez utiliser un mélange de réponses directes et d’exemples de raisonnement pas à pas. Utilisez au moins 75 % de raisonnement et 25 % sans raisonnement dans votre jeu de données pour que le modèle conserve ses capacités de raisonnement.

🦙 Service et déploiement Llama-server

Pour déployer GLM-4.7-Flash en production, nous utilisons llama-server Dans un nouveau terminal, par exemple via tmux, déployez le modèle avec :

./llama.cpp/llama-server \
    --model unsloth/GLM-4.7-Flash-GGUF/GLM-4.7-Flash-UD-Q4_K_XL.gguf \\
    --alias "unsloth/GLM-4.7-Flash" \\
    --seed 3407 \
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01 \\
    --ctx-size 16384 \
    --port 8001

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

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/GLM-4.7-Flash",
    messages = [{"role": "user", "content": "Combien font 2+2 ?"},],
)
print(completion.choices[0].message.content)

Ce qui affichera

L’utilisateur pose une question simple : « Combien font 2+2 ? » La réponse est 4. Fournissez la réponse.

2 + 2 = 4.

💻 GLM-4.7-Flash dans vLLM

Vous pouvez maintenant utiliser notre nouveau quant FP8 Dynamic du modèle pour une inférence premium et rapide. Installez d’abord vLLM depuis nightly :

uv pip install --upgrade --force-reinstall vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly/cu130
uv pip install --upgrade --force-reinstall git+https://github.com/huggingface/transformers.git
uv pip install --force-reinstall numba

Puis servez la version FP8 dynamique d’Unsloth du modèle. Nous avons activé FP8 pour réduire de 50 % l’utilisation mémoire du cache KV, et sur 4 GPU. Si vous avez 1 GPU, utilisez CUDA_VISIBLE_DEVICES='0' et définissez --tensor-parallel-size 1 ou supprimez cet argument. Pour désactiver FP8, supprimez --quantization fp8 --kv-cache-dtype fp8

export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
CUDA_VISIBLE_DEVICES='0,1,2,3' vllm serve unsloth/GLM-4.7-Flash-FP8-Dynamic \\
    --served-model-name unsloth/GLM-4.7-Flash \\
    --tensor-parallel-size 4 \\
    --tool-call-parser glm47 \\
    --reasoning-parser glm45 \\
    --enable-auto-tool-choice \\
    --dtype bfloat16 \\
    --seed 3407 \
    --max-model-len 200000 \\
    --gpu-memory-utilization 0.95 \\
    --max_num_batched_tokens 16384 \\
    --port 8001 \
    --kv-cache-dtype fp8

Vous pouvez ensuite appeler le modèle servi via l’API OpenAI :

from openai import AsyncOpenAI, OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8001/v1"
client = OpenAI( # or AsyncOpenAI
    api_key=openai_api_key,
    base_url=openai_api_base,
)

⭐ Décodage spéculatif vLLM GLM-4.7-Flash

Nous avons constaté que l’utilisation du module MTP (prédiction multi-token) de GLM 4.7 Flash fait chuter le débit de génération de 13 000 tokens sur 1 B200 à 1 300 tokens ! (10x plus lent) Sur Hopper, cela devrait heureusement aller.

    --speculative-config.method mtp \\
    --speculative-config.num_speculative_tokens 1

Seulement 1 300 tokens/s de débit sur 1xB200 (130 tokens/s de décodage par utilisateur)

Et 13 000 tokens/s de débit sur 1xB200 (toujours 130 tokens/s de décodage par utilisateur)

🔨Appel d’outils avec GLM-4.7-Flash

Voir Tool Calling Guide pour plus de détails sur la manière d'effectuer des appels d'outils. Dans un nouveau terminal (si vous utilisez tmux, utilisez CTRL+B+D), nous créons quelques outils comme l'addition de 2 nombres, l'exécution de code Python, l'exécution de fonctions Linux et bien plus encore :

import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Il y a longtemps dans une galaxie lointaine, très lointaine...",
        "Il y avait 2 amis qui adoraient les paresseux et le code...",
        "Le monde touchait à sa fin parce que tous les paresseux avaient évolué pour avoir une intelligence surhumaine...",
        "À l'insu de l'un des amis, l'autre avait accidentellement codé un programme pour faire évoluer les paresseux...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Impossible d'exécuter les commandes 'rm, sudo, dd, chmod' car elles sont dangereuses"
        print(msg); return msg
    print(f"Exécution de la commande terminal `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Échec de la commande : {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "substract_number": substract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Additionner deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multiplier deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "Soustraire deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Écrit une histoire aléatoire.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Effectuer des opérations depuis le terminal.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "La commande que vous souhaitez lancer, par ex. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Appeler un interpréteur Python avec du code Python qui sera exécuté.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Le code Python à exécuter",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Nous utilisons ensuite les fonctions ci-dessous (copiez-collez et exécutez) qui analyseront automatiquement les appels de fonction et appelleront le point de terminaison OpenAI pour n'importe quel modèle :

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 0.7,
    top_p = 1.0,
    top_k = -1,
    repetition_penalty = 0.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"Utilisation du modèle = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Messages actuels = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "dry_multiplier" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        sinon :
            has_tool_calls = False
    return messages

Après avoir lancé GLM-4.7-Flash via llama-server comme dans GLM-4.7-Flash ou voir Tool Calling Guide pour plus de détails, nous pouvons alors effectuer des appels d’outils :

Appel d’outil pour les opérations mathématiques pour GLM 4.7

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Quelle est la date d’aujourd’hui plus 3 jours ?"}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = -1, min_p = 0.01)

Appel d’outil pour exécuter le code Python généré pour GLM-4.7-Flash

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Crée une fonction Fibonacci en Python et trouve fib(20)."}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = -1, min_p = 0.01)

Benchmarks

GLM-4.7-Flash est le modèle 30B le plus performant sur tous les benchmarks sauf AIME 25.

Benchmark	GLM-4.7-Flash	Qwen3-30B-A3B-Thinking-2507	GPT-OSS-20B
AIME 25	91.6	85.0	91.7
GPQA	75.2	73.4	71.5
LCB v6	64.0	66.0	61.0
HLE	14.4	9.8	10.9
SWE-bench Verified	59.2	22.0	34.0
τ²-Bench	79.5	49.0	47.7
BrowseComp	42.8	2.29	28.3