GLM-4.7 : Guide d'exécution locale

Un guide sur la façon d'exécuter le modèle GLM-4.7 de Z.ai sur votre propre appareil local !

GLM-4.7 est le dernier modèle de réflexion de Z.ai, offrant de meilleures performances en codage, en agent et en chat que GLM-4.6. Il atteint des performances SOTA sur SWE-bench (73,8 %, +5,8), SWE-bench Multilingual (66,7 %, +12,9) et Terminal Bench 2.0 (41,0 %, +16,5).

Le modèle complet de 355 milliards de paramètres nécessite 400 Go d’espace disque, tandis que le GGUF dynamique 2 bits Unsloth réduit la taille à 134 Go (-75%). GLM-4.7-GGUF

Tous les téléchargements utilisent Unsloth Dynamic 2.0 pour des performances SOTA en 5-shot MMLU et Aider, ce qui signifie que vous pouvez exécuter et affiner des LLM GLM quantifiés avec une perte de précision minimale.

⚙️ Guide d'utilisation

La quantification dynamique 2 bits UD-Q2_K_XL utilise 135 Go d’espace disque - cela fonctionne bien avec 1 carte 24 Go et 128 Go de RAM avec le déchargement MoE. Le UD-TQ1 GGUF 1 bit fonctionne aussi nativement dans Ollama!

Vous devez utiliser --jinja pour les quantifications llama.cpp - cela utilise nos modèles de chat fixes et active le bon modèle ! Vous pourriez obtenir des résultats incorrects si vous n'utilisez pas --jinja

Les quantifications 4 bits tiendront sur un GPU 1x 40 Go (avec les couches MoE déchargées vers la RAM). Attendez-vous à environ 5 jetons/s avec cette configuration si vous disposez aussi de 165 Go de RAM supplémentaires. Il est recommandé d’avoir au moins 205 Go de RAM pour exécuter ce modèle 4 bits. Pour des performances optimales, vous aurez besoin d’au moins 205 Go de mémoire unifiée ou de 205 Go de RAM+VRAM combinées pour 5+ jetons/s. Pour apprendre à augmenter la vitesse de génération et à gérer des contextes plus longs, lisez ici.

Bien que ce ne soit pas indispensable, pour de meilleures performances, faites en sorte que votre VRAM + RAM combinées soient égales à la taille de la quantification que vous téléchargez. Sinon, le déchargement sur disque dur / SSD fonctionnera avec llama.cpp, mais l’inférence sera plus lente. Utilisez aussi --fit on dans llama.cpp pour activer automatiquement l'utilisation maximale du GPU !

Paramètres recommandés

Utilisez des paramètres distincts pour différents cas d’usage. Paramètres recommandés pour les usages par défaut et les usages agentiques multi-tours :

Paramètres par défaut (la plupart des tâches)	Terminal Bench, SWE Bench Verified
température = 1.0	température = 0.7
top_p = 0.95	top_p = 1.0
131072 nombre maximal de nouveaux jetons	16384 nombre maximal de nouveaux jetons

• Utilisez --jinja pour les variantes llama.cpp - nous avons aussi corrigé certains problèmes de modèles de chat !

• Fenêtre de contexte maximale : 131,072

Exécuter les tutoriels GLM-4.7 :

Consultez nos guides étape par étape pour exécuter GLM-4.7 dans Ollama et llama.cpp.

✨ Exécuter dans llama.cpp

1

Obtenez la dernière version 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 souhaitez simplement une inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez normalement - 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 -DLLAMA_CURL=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

Si vous souhaitez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q2_K_XL) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp à être enregistré à un emplacement spécifique. N'oubliez pas que le modèle a une longueur de contexte maximale de 128K uniquement.

export LLAMA_CACHE="unsloth/GLM-4.7-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/GLM-4.7-GGUF:UD-Q2_K_XL \
    --jinja \
    --ctx-size 16384 \
    --flash-attn on \
    --temp 1.0 \
    --top-p 0.95 \
    --fit on

Utilisez --fit on introduit le 15 décembre 2025 pour une utilisation maximale de votre GPU et CPU.

En option, essayez -ot ".ffn_.*_exps.=CPU" pour décharger toutes les couches MoE vers le CPU ! Cela permet effectivement de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l'expression regex pour faire tenir davantage de couches si vous disposez de plus de capacité GPU.

Si vous avez un peu plus de mémoire GPU, essayez -ot ".ffn_(up|down)_exps.=CPU" Cela décharge les couches MoE de projection montante et descendante.

Essayez -ot ".ffn_(up)_exps.=CPU" si vous avez encore plus de mémoire GPU. Cela décharge uniquement les couches MoE de projection montante.

Et enfin, déchargez toutes les couches via -ot ".ffn_.*_exps.=CPU" Cela utilise le moins de VRAM.

Vous pouvez aussi personnaliser la regex, par exemple -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" signifie décharger les couches MoE gate, up et down, mais uniquement à partir de la 6e couche.

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir UD-Q2_K_XL (quantification dynamique 2 bits) ou d'autres versions quantifiées comme Q4_K_XL . Nous recommandons d’utiliser notre quantification dynamique 2,7 bits UD-Q2_K_XL pour équilibrer taille et précision.

pip install -U huggingface_hub
hf download unsloth/GLM-4.7-GGUF \
    --local-dir unsloth/GLM-4.7-GGUF \
    --include "*UD-Q2_K_XL*" # Utilisez "*UD-TQ1_0*" pour le dynamique 1 bit

4

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, selon le nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous n'avez qu'une inférence CPU.

./llama.cpp/llama-cli \
    --model unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf \
    --jinja \
    --temp 1.0 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --seed 3407 \
    --fit on

🦙 Exécuter dans Ollama

1

Installez ollama si ce n’est pas déjà fait ! Pour exécuter d’autres variantes du modèle, voir ici.

apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh

2

Exécutez le modèle ! Notez que vous pouvez appeler ollama servedans un autre terminal si cela échoue ! Nous incluons toutes nos corrections et les paramètres suggérés (température, etc.) dans params dans notre téléchargement Hugging Face !

OLLAMA_MODELS=unsloth ollama serve &

OLLAMA_MODELS=unsloth ollama run hf.co/unsloth/GLM-4.7-GGUF:TQ1_0

3

Pour exécuter d'autres quantifications, vous devez d'abord fusionner les fichiers GGUF découpés en un seul, comme dans le code ci-dessous. Ensuite, vous devrez exécuter le modèle localement.

./llama.cpp/llama-gguf-split --merge \
  GLM-4.7-GGUF/GLM-4.7-UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf \
	merged_file.gguf

OLLAMA_MODELS=unsloth ollama serve &

OLLAMA_MODELS=unsloth ollama run merged_file.gguf

✨ Déployer avec llama-server et la bibliothèque de complétion d'OpenAI

Pour utiliser llama-server pour le déploiement, utilisez la commande suivante :

./llama.cpp/llama-server \
    --model unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf \
    --alias "unsloth/GLM-4.7" \
    --fit on \
    --prio 3 \
    --temp 1.0 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --port 8001 \
    --jinja

Ensuite, utilisez la bibliothèque Python d'OpenAI après pip install openai :

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",
    messages = [{"role": "user", "content": "What is 2+2?"},],
)
print(completion.choices[0].message.content)

🔨Appel d'outils avec GLM 4.7

Voir Tool Calling Guide pour plus de détails sur la façon de faire 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 subtract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Il était une fois dans une galaxie très très lointaine...",
        "Il y avait 2 amis qui aimaient les paresseux et le code...",
        "Le monde touchait à sa fin parce que chaque paresseux avait évolué pour avoir une intelligence surhumaine...",
        "À l'insu d'un ami, l'autre a 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"La commande a échoué : {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,
    "subtract_number": subtract_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": "subtract_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 puis exécutez) qui analyseront automatiquement les appels de fonction et appelleront l'endpoint OpenAI pour n'importe quel modèle :

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 0.7,
    top_p = 0.95,
    top_k = 40,
    min_p = 0.01,
    repetition_penalty = 1.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"Using model = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Current messages = {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, "repetition_penalty" :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),})
        else:
            has_tool_calls = False
    return messages

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

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

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "What is today's date plus 3 days?"}],
}]
unsloth_inference(messages, temperature = 0.7, top_p = 1.0, top_k = -1, min_p = 0.00)

Appel d'outil pour exécuter du code Python généré pour GLM 4.7

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Create a Fibonacci function in Python and find fib(20)."}],
}]
unsloth_inference(messages, temperature = 0.7, top_p = 1.0, top_k = -1, min_p = 0.00)

🏂 Améliorer la vitesse de génération

Utilisez --fit on introduit le 15 décembre 2025 pour une utilisation maximale de votre GPU et CPU. Voir https://github.com/ggml-org/llama.cpp/pull/16653 --fit on décharge automatiquement autant que possible du modèle vers le GPU, puis place le reste sur le CPU.

Si vous avez plus de VRAM, vous pouvez essayer de décharger davantage de couches MoE, ou de décharger des couches entières.

Normalement, -ot ".ffn_.*_exps.=CPU" décharge toutes les couches MoE vers le CPU ! Cela permet effectivement de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l'expression regex pour faire tenir davantage de couches si vous disposez de plus de capacité GPU.

Si vous avez un peu plus de mémoire GPU, essayez -ot ".ffn_(up|down)_exps.=CPU" Cela décharge les couches MoE de projection montante et descendante.

Essayez -ot ".ffn_(up)_exps.=CPU" si vous avez encore plus de mémoire GPU. Cela décharge uniquement les couches MoE de projection montante.

Vous pouvez aussi personnaliser la regex, par exemple -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" signifie décharger les couches MoE gate, up et down, mais uniquement à partir de la 6e couche.

Llama.cpp introduit aussi un mode à haut débit. Utilisez llama-parallel. En savoir plus ici. Vous pouvez aussi quantifier le cache KV en 4 bits par exemple pour réduire les déplacements VRAM / RAM, ce qui peut aussi accélérer le processus de génération.

📐Comment gérer un long contexte (128K complet)

Pour faire tenir un contexte plus long, vous pouvez utiliser la quantification du cache KV pour quantifier les caches K et V en moins de bits. Cela peut aussi augmenter la vitesse de génération grâce à la réduction des transferts de données RAM / VRAM. Les options autorisées pour la quantification K (la valeur par défaut est f16) sont les suivantes.

--cache-type-k f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1

Vous devriez utiliser les _1 variantes pour une précision légèrement meilleure, bien que ce soit un peu plus lent. Par exemple q4_1, q5_1

Vous pouvez aussi quantifier le cache V, mais vous devrez compiler llama.cpp avec la prise en charge de Flash Attention via -DGGML_CUDA_FA_ALL_QUANTS=ON, et utiliser --flash-attn pour l’activer. Ensuite, vous pouvez l'utiliser avec --cache-type-k :

--cache-type-v f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1