So greifen Sie auf GLM 4.1V 9B Thinking zu – ohne GPU

GLM 4.1V 9B Thinking ist ein bahnbrechendes KI-Modell, weil es Bilder sehen und gleichzeitig seine Gedankengänge Schritt für Schritt erklären kann. Diese Methode wird als Chain-of-Thought (CoT) bezeichnet, und GLM beherrscht sie besser als jedes andere Vision-Language-Modell seiner Größe. Sie werden sehen, wie es im Vergleich zu größeren Modellen abschneidet und wie Sie es selbst ausprobieren können – auch ohne teure GPU.

Was hat GLM 4.1V 9B Thinking bei VLM-Modellen verändert?

Als weltweit erstes VLM-Modell mit Chain-of-Thought (CoT) Reasoning hat GLM nicht nur mit seinen leistungsstarken Fähigkeiten beeindruckt, sondern auch Anerkennung dafür erhalten, dass es trotz seiner geringen Größe (9B) eine mit Qwen 2.5 72B vergleichbare Leistung erzielt. Werfen wir nun einen genaueren Blick auf die detaillierten Spezifikationen und Benchmark-Ergebnisse von GLM.

Eigenschaften von GLM 4.1V 9B Thinking

Sie können direkt auf Hugging Face eine kostenlose Testversion starten!

Wie erzielt GLM 4.1V 9B Thinking diese Verbesserungen?

1. SFT-Verstärkung:
   Die Trainingsbeispiele enthalten explizite Chain-of-Thought (CoT)-Annotationen, sodass das Modell lernt, „zuerst zu denken, dann zu antworten“. Dies unterscheidet sich von traditionellen Modellen, die nur eine Antwort ausgeben, ohne die Denkschritte zu zeigen.
2. RLCS-Verstärkung:
   Die Belohnung des Modells basiert nicht nur auf der Korrektheit – es bewertet auch die Qualität des Reasoning-Prozesses und der Erklärungen, was kohärenteres und gründlicheres internes Denken fördert.
3. Architektonische Unterstützung:
   Ein ViT-Bildencoder speist über einen MLP-Projektor in den LLM-Decoder ein, sodass das Modell nahtlos explizite Reasoning-Pfade aus visuellen Eingaben generieren kann – nicht nur reines Abrufen oder Mustervergleiche.
4. Starke Reasoning-Grundlage:
   Ein weiterer entscheidender Faktor: Das Basismodell – GLM‑4‑9B 0414 – besitzt bereits robuste Reasoning-Fähigkeiten. Beispiele:
   • Es zeigt hervorragende mathematische Reasoning- und allgemeine Aufgabenleistungen und rangiert unter den quelloffenen Modellen seiner Größenklasse ganz oben.
   • Architektonisch und trainingsseitig profitiert GLM‑4‑9B von autoregressivem Blank‑Infilling Pre‑Training und anschließendem Fine‑Tuning, das logische und mehrschrittige Reasoning-Fähigkeiten stärkt.

Weitere Details finden Sie im Paper: GLM-4.1V-Thinking: Towards Versatile Multimodal Reasoning with Scalable Reinforcement Learning.

GLM 4.1V 9B Thinking vs. Qwen 2.5 VL 72B

Benchmark	GLM 4.1V 9B Thinking	Qwen 2.5 VL 72B	Gewinner
MMMU (Bild)	68,0	70,2	Qwen 2.5 VL
MMMU‑Pro	57,1	51,1	GLM
VideoMMMU	61,0	60,2	GLM
mvBench (Video)	70,4	64,6	GLM
AITZ_EM (Agent)	83,2	35,3*	GLM
Agent (OSWorld)	14,9	8,8	GLM
Agent (AndroidWorld)	41,7	35,0	GLM
Agent (WebVoyageSom)	69,0	40,4	GLM
Agent (Webquest‑SingleQA)	72,1	60,5	GLM
Agent (Webquest‑MultiQA)	54,7	52,1	GLM
Coding (Design2Code)	64,7	41,9	GLM
Coding (Flame‑VLM‑Code)	72,5	46,3	GLM
OCRBench	84,2	85,1	Qwen 2.5 VL
VideoMME (ohne Text)	68,2	73,3	Qwen 2.5 VL
VideoMME (mit Text)	73,6	79,1	Qwen 2.5 VL
MMVU	59,4	62,9	Qwen 2.5 VL

Wählen Sie GLM 4.1V 9B Thinking, wenn Ihr Fokus auf multimodalem Reasoning, Agent-Fähigkeiten, MINT-Problemlösung oder Coding liegt.

Wählen Sie Qwen 2.5 VL 72B, wenn Sie sich auf Dokumenten-/Bild-/Video-Verständnis konzentrieren – insbesondere OCR, strukturierte Extraktion und visuelle Wahrnehmung.

Wenn Sie weitere Details erfahren möchten, lesen Sie diesen Artikel: GLM 4.1V 9B Thinking vs Qwen2.5 VL 72B: Which Fits What?

Dort finden Sie auch einen Vergleich mit anderen führenden Modellen.

Von THUDM

Wie greife ich auf GLM 4.1V 9B Thinking zu?

1. Lokaler Zugriff

Noch beeindruckender: GLM 4.1V 9B Thinking hat nur 9 Milliarden Parameter und kann daher auf GPUs wie der RTX 4090 oder sogar der RTX 3090 ausgeführt werden. Im Vergleich zu anderen Modellen mit mehrfach mehr Parametern erzielt GLM mit deutlich geringerer Größe herausragende Leistungen – eine Errungenschaft, die zweifellos die Stärke des Reinforcement Learnings unterstreicht.

Von THUDM

Installationsanleitung

Installation:

pip install git+https://github.com/huggingface/transformers.git

Grundlegende Verwendung:

from transformers import AutoProcessor, Glm4vForConditionalGeneration
import torch

MODEL_PATH = "THUDM/GLM-4.1V-9B-Thinking"

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "url": "https://upload.wikimedia.org/wikipedia/commons/f/fa/Grayscale_8bits_palette_sample_image.png"
            },
            {
                "type": "text",
                "text": "describe this image"
            }
        ],
    }
]

processor = AutoProcessor.from_pretrained(MODEL_PATH, use_fast=True)
model = Glm4vForConditionalGeneration.from_pretrained(
    pretrained_model_name_or_path=MODEL_PATH,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt"
).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=8192)
output_text = processor.decode(generated_ids[0][inputs["input_ids"].shape[1]:], skip_special_tokens=False)
print(output_text)

Falls der Kauf einer GPU zu teuer erscheint, können Sie die kostengünstigen und zuverlässigen Cloud-GPUs von Novita AI nutzen – RTX 4090 für nur 0,69 $ pro Stunde oder RTX 3090 für nur 0,21 $ pro Stunde!

Probieren Sie Novita AIs leistungsstarke GPUs aus

2. Direkte API-Integration

Schritt 1: Einloggen und auf die Modellbibliothek zugreifen

Loggen Sie sich in Ihr Konto ein und klicken Sie auf den Button Modellbibliothek.

GLM 4.1V 9B jetzt ausprobieren!

Schritt 2: Wählen Sie Ihr Modell

Durchsuchen Sie die verfügbaren Optionen und wählen Sie das Modell aus, das Ihren Anforderungen entspricht.

Schritt 3: Starten Sie Ihre kostenlose Testversion

Beginnen Sie Ihre kostenlose Testversion, um die Fähigkeiten des ausgewählten Modells zu erkunden.

Schritt 4: Holen Sie sich Ihren API-Key

Zur Authentifizierung an der API erhalten Sie einen neuen API-Key. Rufen Sie die Seite „Einstellungen“ auf und kopieren Sie den API-Key wie im Bild gezeigt.

Schritt 5: Installieren Sie die API

Installieren Sie die API mit dem für Ihre Programmiersprache spezifischen Paketmanager.

Importieren Sie nach der Installation die erforderlichen Bibliotheken in Ihre Entwicklungsumgebung. Initialisieren Sie die API mit Ihrem API-Key, um mit Novita AI LLM zu interagieren. Dies ist ein Beispiel für die Verwendung der Chat Completions API für Python-Benutzer.

from openai import OpenAI
  
client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="session_kgNdXtDPt2zYc95i-nDWPaW4Zl_e7nf4VDpukuIVBKpko1-LE8xCasG4YK7c-3c1xnPzGYRuocFk_DhkPUUQyQ==",
)

model = "thudm/glm-4.1v-9b-thinking"
stream = True # or False
max_tokens = 4000
system_content = ""Be a helpful assistant""
temperature = 1
top_p = 1
min_p = 0
top_k = 50
presence_penalty = 0
frequency_penalty = 0
repetition_penalty = 1
response_format = { "type": "text" }

chat_completion_res = client.chat.completions.create(
    model=model,
    messages=[
        {
            "role": "system",
            "content": system_content,
        },
        {
            "role": "user",
            "content": "Hi there!",
        }
    ],
    stream=stream,
    max_tokens=max_tokens,
    temperature=temperature,
    top_p=top_p,
    presence_penalty=presence_penalty,
    frequency_penalty=frequency_penalty,
    response_format=response_format,
    extra_body={
      "top_k": top_k,
      "repetition_penalty": repetition_penalty,
      "min_p": min_p
    }
  )

if stream:
    for chunk in chat_completion_res:
        print(chunk.choices[0].delta.content or "", end="")
else:
    print(chat_completion_res.choices[0].message.content)
  
  

Erstellen Sie ein einfaches Bilderkennungstool mit MCP und GLM

Wenn Sie die Fähigkeiten von GLM nutzen möchten – zum Beispiel um ein einfaches Bilderkennungstool zu bauen, das die Integration von visueller Erkennung und Reasoning demonstriert – können Sie die von Novita AI unterstützte MCP-Funktionalität verwenden. Hier ist der Beispielcode:

import os
import sys
from mcp.server.fastmcp import FastMCP
import requests
import uvicorn
from starlette.applications import Starlette
from starlette.routing import Mount

base_url = "https://api.novita.ai/v3"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {os.environ['NOVITA_API_KEY']}"
}

mcp = FastMCP("Novita_API")

@mcp.tool()
def list_models() -> str:
    """
    List all available models from the Novita API.
    """
    url = base_url + "/openai/models"
    response = requests.request("GET", url, headers=headers)
    data = response.json()["data"]

    text = ""
    for i, model in enumerate(data, start=1):
        text += f"Model id: {model['id']}\
"
        text += f"Model description: {model['description']}\
"
        text += f"Model type: {model['model_type']}\
\
"

    return text

@mcp.tool()
def get_model(model_id: str, message) -> str:
    """
    Provide a model ID and a message to get a response from the Novita API.
    """
    url = base_url + "/openai/chat/completions"
    payload = {
        "model": model_id,
        "messages": [
            {
                "content": message,
                "role": "user",
            }
        ],
        "max_tokens": 200,
        "response_format": {
            "type": "text",
        },
    }
    response = requests.request("POST", url, json=payload, headers=headers)
    content = response.json()["choices"][0]["message"]["content"]
    return content

@mcp.tool()
def vision_chat(model_id: str, image_url: str, question: str) -> str:
    """
    Use GLM-4.1V-9B-Thinking to answer a question about an image.
    """
    url = base_url + "/openai/chat/completions"
    payload = {
        "model": model_id,
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": image_url,
                        }
                    },
                    {
                        "type": "text",
                        "text": question,
                    }
                ]
            }
        ],
        "max_tokens": 500
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()["choices"][0]["message"]["content"]

if __name__ == "__main__":
   # Run using stdio transport
   mcp.run(transport="stdio")

Wenn Sie die Details erfahren möchten, lesen Sie diesen Artikel: So erstellen Sie Ihren ersten MCP-Server mit Novita AI!

GLM 4.1V 9B Thinking ist einfach zu bedienen, extrem intelligent und benötigt keine teure Hardware. Sie können seine Bilderkennungs- und Reasoning-Fähigkeiten mit nur wenigen Codezeilen testen, entweder auf Ihrem eigenen Rechner oder in der Cloud. Wenn Sie sehen möchten, wie weit multimodale KI gekommen ist, probieren Sie GLM aus!

Was ist das Besondere an GLM 4.1V 9B Thinking?

Es ist das erste Modell, das sowohl „sehen“ als auch seine Gedankenschritte zeigen kann – nicht nur Antworten liefert.

Kann ich GLM 4.1V 9B ausprobieren, wenn ich keine leistungsstarke GPU habe?

Ja! Sie können kostengünstige Cloud-GPUs nutzen oder es kostenlos auf der Novita AI Playground ausprobieren.

Wie kann ich GLM 4.1V 9B Thinking in meine eigenen Projekte integrieren?

Sie können es lokal mit Python und Hugging Face ausführen, über die API von Novita AI darauf zugreifen oder sogar eigene Bilderkennungstools mit MCP erstellen, wie in den bereitgestellten Codebeispielen gezeigt.

Novita AI ist die All-in-One-Cloud-Plattform, die Ihre KI-Ambitionen fördert. Integrierte APIs, serverlos, GPU-Instanz – die kosteneffizienten Tools, die Sie brauchen. Verzichten Sie auf Infrastruktur, starten Sie kostenlos und verwirklichen Sie Ihre KI-Vision.

Empfohlene Artikel

• Anleitung: So greifen Sie lokal, per API und auf der Cloud-GPU auf Qwen2.5-VL-72B zu
• Deepseek v3 vs Llama 3.3 70b: Sprachaufgaben vs. Code & Mathe
• Qwen3 Embedding 8B: Leistungsstarke Suche, flexible Anpassung und mehrsprachig