GLM-4.7: Anleitung zum lokalen Betrieb

Eine Anleitung, wie man das Z.ai GLM-4.7-Modell auf dem eigenen lokalen Gerät ausführt!

GLM-4.7 ist Z.ais neuestes Denkmodell und liefert stärkere Leistungen bei Codierung, Agenten und Chat als GLM-4.6. Es erreicht SOTA-Leistungen in 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 355B-Parameter-Modell benötigt 400GB Festplattenspeicher, während das Unsloth Dynamic 2-bit GGUF die Größe auf 134GB (-75%). GLM-4.7-GGUF

Alle Uploads verwenden Unsloth Dynamic 2.0 für SOTA 5-shot MMLU- und Aider-Leistungen, das heißt, Sie können quantisierte GLM-LLMs mit minimalem Genauigkeitsverlust ausführen und feinabstimmen.

⚙️ Gebrauchsanleitung

Die 2-Bit-dynamische Quantisierung UD-Q2_K_XL verwendet 135GB Festplattenspeicher – das funktioniert gut in 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 – dies nutzt unsere festen Chat-Vorlagen und aktiviert die korrekte Vorlage! Sie könnten falsche Ergebnisse erhalten, wenn Sie nicht --jinja

Die 4-Bit-Quants passen in eine 1x40GB-GPU (mit MoE-Schichten, die in den RAM ausgelagert werden). Erwarten Sie mit diesem Setup etwa 5 Tokens/s, wenn Sie zusätzlich 165GB RAM haben. Es wird empfohlen, mindestens 205GB RAM zu haben, um dieses 4-Bit auszuführen. Für optimale Leistung benötigen Sie mindestens 205GB einheitlichen Speicher oder 205GB kombinierter RAM+VRAM für 5+ Tokens/s. Um zu erfahren, wie Sie die Generationsgeschwindigkeit erhöhen und längere Kontexte unterbringen, hier lesen.

Obwohl es nicht zwingend erforderlich ist, sollten Sie für die beste Leistung dafür sorgen, dass VRAM + RAM zusammen der Größe des Quant entsprechen, das Sie herunterladen. Falls nicht, funktioniert Festplatten-/SSD-Offloading mit llama.cpp, nur die Inferenz wird 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 Multi-Turn-Agenten-Anwendungsfälle:

Standardeinstellungen (die meisten Aufgaben)	Terminal Bench, SWE Bench verifiziert
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 einige Probleme mit Chat-Vorlagen behoben!

• Maximales Kontextfenster: 131,072

GLM-4.7 Tutorials ausführen:

Siehe 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 das neueste llama.cpp auf GitHub hier. Sie können auch den untenstehenden Build-Anweisungen folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder einfach CPU-Inferenz wünschen.

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 speichert. 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 eingeführt am 15. Dez. 2025 für maximale Nutzung Ihrer GPU und CPU.

Optional können Sie versuchen -ot ".ffn_.*_exps.=CPU" um alle MoE-Schichten auf die CPU auszulagern! Dies ermöglicht es effektiv, alle Nicht-MoE-Schichten auf einer GPU unterzubringen und die Generationsgeschwindigkeit zu verbessern. Sie können den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert up- und down-Projektions-MoE-Schichten aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur up-Projektions-MoE-Schichten aus.

Und schließlich alle Schichten auslagern über -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-Schichten auszulagern, jedoch 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 wählen UD-Q2_K_XL (dynamische 2-Bit-Quantisierung) oder andere quantisierte Versionen wie Q4_K_XL . Wir empfehlen die Verwendung unserer 2,7-Bit-dynamischen Quantisierung UD-Q2_K_XL um Größe und Genauigkeit auszugleichen.

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 das GPU-Offloading für wie viele Schichten. Versuchen Sie, es anzupassen, wenn Ihre GPU nicht mehr genügend Speicher hat. 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, siehe 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 aufrufen können ollama servein einem anderen Terminal, falls es fehlschlägt! Wir fügen alle unsere Fixes und vorgeschlagenen Parameter (Temperatur usw.) in params in unserem Hugging Face-Upload hinzu!

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 GGUF-Split-Dateien zu einer Datei wie im folgenden Code zusammenführen. Dann 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

✨ Mit llama-server und OpenAIs Completion-Bibliothek bereitstellen

Um llama-server für die Bereitstellung zu verwenden, benutzen Sie den 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 OpenAI-Python-Bibliothek nachdem Sie 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)

🔨Tool-Aufrufe mit GLM 4.7

Siehe Tool Calling Guide für weitere Details zur Durchführung von Tool-Aufrufen. In einem neuen Terminal (wenn Sie tmux verwenden, drücken Sie STRG+B+D) erstellen wir einige Tools wie das Addieren von 2 Zahlen, Ausführen von Python-Code, 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 substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Vor langer Zeit in einer Galaxie weit, weit entfernt...",
        "Es gab 2 Freunde, die Faultiere und Code liebten...",
        "Die Welt ging unter, weil jedes Faultier sich zu übermenschlicher Intelligenz entwickelt hatte...",
        "Ohne dass ein Freund es wusste, codierte der andere versehentlich ein Programm, um Faultiere zu entwickeln...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Kann 'rm, sudo, dd, chmod' Befehle 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,
    "substract_number": substract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Addiere zwei Zahlen.",
            "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": "Multipliziert zwei Zahlen.",
            "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": "substract_number",
            "description": "Subtrahiert zwei Zahlen.",
            "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": "Führt Operationen aus dem Terminal aus.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "Der Befehl, den Sie starten möchten, z. B. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Ruft einen Python-Interpreter mit etwas Python-Code auf, der ausgeführt wird.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Der auszuführende Python-Code",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Dann verwenden wir die unten stehenden Funktionen (kopieren, einfügen und ausführen), die Funktionsaufrufe automatisch parsen und den OpenAI-Endpunkt für jedes Modell 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

Nach dem Start von GLM 4.7 über llama-server wie in GLM-4.7 oder siehe Tool Calling Guide für weitere Details, 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": "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)

Tool-Aufruf zum Ausführen generierten Python-Codes für 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)

🏂 Generationsgeschwindigkeit verbessern

Verwenden Sie --fit on eingeführt am 15. Dez. 2025 für maximale Nutzung Ihrer GPU und CPU. Siehe https://github.com/ggml-org/llama.cpp/pull/16653 --fit on auto lagert so viel des Modells 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-Schichten auszulagern oder ganze Schichten selbst auszulagern.

Normalerweise, -ot ".ffn_.*_exps.=CPU" lagert alle MoE-Schichten auf die CPU aus! Dies ermöglicht es effektiv, alle Nicht-MoE-Schichten auf einer GPU unterzubringen und die Generationsgeschwindigkeit zu verbessern. Sie können den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn Sie mehr GPU-Kapazität haben.

Wenn Sie etwas mehr GPU-Speicher haben, versuchen Sie -ot ".ffn_(up|down)_exps.=CPU" Dies lagert up- und down-Projektions-MoE-Schichten aus.

Versuchen Sie -ot ".ffn_(up)_exps.=CPU" wenn Sie noch mehr GPU-Speicher haben. Dies lagert nur up-Projektions-MoE-Schichten 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-Schichten auszulagern, jedoch nur ab der 6. Schicht.

Llama.cpp führt auch einen Hochdurchsatzmodus 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 VRAM-/RAM-Bewegungen zu reduzieren, was den Generationsprozess auch beschleunigen kann.

📐Wie man langen Kontext unterbringt (vollständig 128K)

Um längere Kontexte unterzubringen, können Sie KV-Cache-Quantisierung verwenden, um die K- und V-Caches auf niedrigere Bits zu quantisieren. Dies kann auch die Generationsgeschwindigkeit aufgrund reduzierter RAM-/VRAM-Datenbewegung erhöhen. Die erlaubten Optionen für K-Quantisierung (Standard ist f16) umfassen die folgenden.

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

Sie sollten die _1 Varianten für etwas erhöhte Genauigkeit verwenden, obwohl sie etwas langsamer sind. Zum Beispiel q4_1, q5_1

Sie können auch den V-Cache quantisieren, aber Sie müssen llama.cpp mit Flash Attention kompilieren Unterstützung über -DGGML_CUDA_FA_ALL_QUANTS=ON, und verwenden Sie --flash-attn 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