GLM-4.7: Leitfaden zum Ausführen lokal

Ein Leitfaden, wie man das Z.ai-GLM-4.7-Modell auf deinem eigenen lokalen Gerät ausführt!

GLM-4.7 ist das neueste Thinking-Modell von Z.ai und liefert stärkere Leistungen bei Coding, Agenten und Chat als GLM-4.6. Es erreicht SOTA-Performance bei SWE-bench (73,8 %, +5,8), SWE-bench Multilingual (66,7 %, +12,9) und Terminal Bench 2.0 (41,0 %, +16,5).

Das vollständige Modell mit 355B Parametern benötigt 400 GB Festplattenspeicher, während Unsloth Dynamic 2-bit GGUF die Größe reduziert auf 134 GB (-75%). GLM-4.7-GGUF

Alle Uploads verwenden Unsloth Dynamic 2.0 für SOTA-5-Shot-MMLU- und Aider-Performance, was bedeutet, dass Sie quantisierte GLM-LLMs mit minimalem Genauigkeitsverlust ausführen und feinabstimmen können.

⚙️ Verwendungshandbuch

Das dynamische 2-Bit-Quant UD-Q2_K_XL belegt 135 GB Festplattenspeicher – das funktioniert gut auf einer 1x24GB-Karte und 128GB RAM mit MoE-Offloading. Das 1-Bit-UD-TQ1-GGUF funktioniert auch nativ in Ollama!

Sie müssen --jinja für llama.cpp-Quants verwenden – das nutzt unsere festen Chat-Vorlagen und aktiviert die korrekte Vorlage! Sie können falsche Ergebnisse erhalten, wenn Sie --jinja

Die 4-Bit-Quants passen in eine 1x40GB-GPU (mit auf RAM ausgelagerten MoE-Layern). Rechnen Sie mit etwa 5 Tokens/s mit diesem Setup, wenn Sie zusätzlich 165 GB RAM zur Verfügung haben. Es wird empfohlen, mindestens 205 GB RAM zu haben, um dieses 4-Bit-Modell auszuführen. Für optimale Leistung benötigen Sie mindestens 205 GB einheitlichen Speicher oder 205 GB kombinierten RAM+VRAM für 5+ Tokens/s. Um zu erfahren, wie Sie die Generierungsgeschwindigkeit erhöhen und längere Kontexte unterbringen können, lesen Sie hier.

Auch wenn es nicht zwingend erforderlich ist: Für die beste Leistung sollten VRAM und RAM zusammen der Größe des Quants entsprechen, das Sie herunterladen. Wenn nicht, funktioniert das Auslagern auf Festplatte/SSD mit llama.cpp, allerdings wird die Inferenz langsamer. Verwenden Sie außerdem --fit on in llama.cpp um die maximale GPU-Nutzung automatisch zu aktivieren!

Empfohlene Einstellungen

Verwenden Sie unterschiedliche Einstellungen für verschiedene Anwendungsfälle. Empfohlene Einstellungen für Standard- und mehrstufige agentische Anwendungsfälle:

Standard-Einstellungen (die meisten Aufgaben)	Terminal Bench, SWE Bench Verified
temperature = 1.0	temperature = 0.7
top_p = 0.95	top_p = 1.0
131072 max new tokens	16384 max new tokens

• Verwenden Sie --jinja für llama.cpp-Varianten – wir haben auch einige Probleme mit Chat-Vorlagen behoben!

• Maximales Kontextfenster: 131,072

GLM-4.7-Tutorials ausführen:

Sehen Sie sich unsere Schritt-für-Schritt-Anleitungen zum Ausführen von GLM-4.7 in Ollama und llama.cpp.

✨ In llama.cpp ausführen

1

Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. Für Apple-Mac-/Metal-Geräte, setzen Sie -DGGML_CUDA=OFF und fahren Sie dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.

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

Wenn Sie llama.cpp direkt zum Laden von Modellen verwenden möchten, können Sie Folgendes tun: (:Q2_K_XL) ist der Quantisierungstyp. Sie können auch über Hugging Face herunterladen (Punkt 3). Dies ist ähnlich wie ollama run . Verwenden Sie export LLAMA_CACHE="folder" um zu erzwingen, dass llama.cpp an einem bestimmten Ort gespeichert wird. Denken Sie daran, dass das Modell nur eine maximale Kontextlänge von 128K hat.

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

Verwenden Sie --fit on am 15. Dez. 2025 eingeführt für maximale Nutzung Ihrer GPU und CPU.

Optional können Sie -ot ".ffn_.*_exps.=CPU" verwenden, um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Und schließlich lagern Sie alle Layer aus via -ot ".ffn_.*_exps.=CPU" Dies verwendet am wenigsten VRAM.

Sie können den Regex auch anpassen, zum Beispiel -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" bedeutet, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht.

3

Laden Sie das Modell herunter via (nach der Installation von pip install huggingface_hub hf_transfer ). Sie können auswählen UD-Q2_K_XL (dynamisches 2-Bit-Quant) oder andere quantisierte Versionen wie Q4_K_XL . Wir empfehlen unser dynamisches 2,7-Bit-Quant UD-Q2_K_XL zu verwenden, um Größe und Genauigkeit auszubalancieren.

pip install -U huggingface_hub
hf download unsloth/GLM-4.7-GGUF \
    --local-dir unsloth/GLM-4.7-GGUF \
    --include "*UD-Q2_K_XL*" # Verwenden Sie "*UD-TQ1_0*" für Dynamic 1bit

4

Sie können --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 2 für GPU-Offloading, also für wie viele Layer. Versuchen Sie, dies anzupassen, wenn Ihrem GPU-Speicher der Platz ausgeht. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben.

./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

🦙 In Ollama ausführen

1

Installieren Sie ollama falls Sie es noch nicht getan haben! Um weitere Varianten des Modells auszuführen, sehen Sie hier.

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

2

Führen Sie das Modell aus! Beachten Sie, dass Sie ollama servein einem anderen Terminal aufrufen können, falls es fehlschlägt! Wir enthalten alle unsere Korrekturen und vorgeschlagenen Parameter (temperature usw.) in params in unserem Hugging-Face-Upload!

OLLAMA_MODELS=unsloth ollama serve &

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

3

Um andere Quants auszuführen, müssen Sie zuerst die geteilten GGUF-Dateien zu einer einzigen zusammenführen, wie im folgenden Code. Danach müssen Sie das Modell lokal ausführen.

./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

✨ Bereitstellen mit llama-server und der Completion-Bibliothek von OpenAI

Um llama-server für die Bereitstellung zu verwenden, nutzen Sie folgenden Befehl:

./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

Verwenden Sie anschließend die Python-Bibliothek von OpenAI nach 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": "Wie viel ist 2+2?"},],
)
print(completion.choices[0].message.content)

🔨Tool-Calling mit GLM 4.7

Siehe Tool Calling Guide für weitere Details dazu, wie Tool-Calling durchgeführt wird. In einem neuen Terminal (wenn Sie tmux verwenden, nutzen Sie CTRL+B+D) erstellen wir einige Tools wie das Addieren von 2 Zahlen, das Ausführen von Python-Code, das Ausführen von Linux-Funktionen und vieles mehr:

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([
        "Es war einmal in einer weit, weit entfernten Galaxie...",
        "Es gab 2 Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil sich jedes Faultier zu übermenschlicher Intelligenz entwickelte...",
        "Unbekannt für den einen Freund hatte der andere versehentlich ein Programm geschrieben, um Faultiere weiterzuentwickeln...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Kann die Befehle 'rm, sudo, dd, chmod' nicht ausführen, da sie gefährlich sind"
        print(msg); return msg
    print(f"Führe Terminalbefehl `{command}` aus")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Befehl fehlgeschlagen: {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": "Zwei Zahlen addieren.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Zwei Zahlen multiplizieren.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "subtract_number",
            "description": "Zwei Zahlen subtrahieren.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Die erste Zahl.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Die zweite Zahl.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Schreibt eine zufällige Geschichte.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Operationen im Terminal ausführen.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "Der Befehl, den Sie ausführen möchten, z. B. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Einen Python-Interpreter mit etwas Python-Code aufrufen, der ausgeführt wird.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Der auszuführende Python-Code",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Wir verwenden dann die folgenden Funktionen (kopieren, einfügen und ausführen), die die Funktionsaufrufe automatisch parsen und für jedes Modell den OpenAI-Endpunkt aufrufen:

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"Verwende Modell = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Aktuelle Nachrichten = {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

Nachdem GLM 4.7 über llama-server wie in GLM-4.7 oder siehe Tool Calling Guide für weitere Details gestartet wurde, können wir dann einige Tool-Aufrufe durchführen:

Tool-Aufruf für mathematische Operationen für GLM 4.7

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Wie lautet das heutige Datum plus 3 Tage?"}],
}]
unsloth_inference(messages, temperature = 0.7, top_p = 1.0, top_k = -1, min_p = 0.00)

Tool-Aufruf zum Ausführen von generiertem Python-Code für GLM 4.7

messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Erstelle eine Fibonacci-Funktion in Python und finde fib(20)."}],
}]
unsloth_inference(messages, temperature = 0.7, top_p = 1.0, top_k = -1, min_p = 0.00)

🏂 Die Generierungsgeschwindigkeit verbessern

Verwenden Sie --fit on am 15. Dez. 2025 eingeführt für maximale Nutzung Ihrer GPU und CPU. Siehe https://github.com/ggml-org/llama.cpp/pull/16653 --fit on lagert automatisch so viel vom Modell wie möglich auf die GPU aus und legt den Rest auf die CPU.

Wenn Sie mehr VRAM haben, können Sie versuchen, mehr MoE-Layer oder ganze Layer auszulagern.

Normalerweise -ot ".ffn_.*_exps.=CPU" lagert alle MoE-Layer auf die CPU aus! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert die MoE-Layer für Up- und Down-Projektionen aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur die MoE-Layer für Up-Projektionen aus.

Sie können den Regex auch anpassen, zum Beispiel -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" bedeutet, Gate-, Up- und Down-MoE-Layer auszulagern, aber nur ab der 6. Schicht.

Llama.cpp führt außerdem einen High-Throughput-Modus ein. Verwenden Sie llama-parallel. Lesen Sie mehr darüber hier. Sie können auch den KV-Cache auf 4 Bit quantisieren zum Beispiel um den VRAM-/RAM-Datenverkehr zu reduzieren, was den Generierungsprozess ebenfalls beschleunigen kann.

📐Wie man langen Kontext unterbringt (volle 128K)

Um längeren Kontext unterzubringen, können Sie KV-Cache-Quantisierung verwenden, um die K- und V-Caches auf niedrigere Bits zu quantisieren. Dies kann auch die Generierungsgeschwindigkeit aufgrund des geringeren RAM-/VRAM-Datenverkehrs erhöhen. Die zulässigen Optionen für die K-Quantisierung (Standard ist f16) sind unten aufgeführt.

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

Sie sollten die _1 Varianten verwenden, um die Genauigkeit etwas zu erhöhen, auch wenn es etwas langsamer ist. Zum Beispiel q4_1, q5_1

Sie können auch den V-Cache quantisieren, aber dafür müssen Sie llama.cpp mit Flash Attention-Unterstützung kompilieren via -DGGML_CUDA_FA_ALL_QUANTS=ON , und--flash-attn verwenden, um es zu aktivieren. Dann können Sie es zusammen mit --cache-type-k --cache-type-v f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1 :

verwenden