GLM 4.1V 9B Thinking est un modèle d’IA révolutionnaire car il peut à la fois voir les images et expliquer son raisonnement étape par étape. C’est ce qu’on appelle le raisonnement en chaîne de pensée (CoT), et GLM le fait mieux que tout autre modèle de langage visuel de sa taille. Vous verrez comment il se compare à des modèles plus grands et comment vous pouvez l’essayer vous-même, même si vous ne disposez pas d’un GPU coûteux.
Quels changements GLM 4.1V 9B Thinking a-t-il apportés aux modèles VLM ?
En tant que premier modèle VLM au monde doté d’un raisonnement en chaîne de pensée (CoT), GLM a non seulement impressionné par ses capacités puissantes, mais a également été reconnu pour avoir atteint des performances comparables à Qwen 2.5 72B, malgré un modèle beaucoup plus petit de 9B. Examinons maintenant de plus près les spécifications détaillées et les résultats des benchmarks de GLM.
Attributs de GLM 4.1V 9B Thinking
Vous pouvez commencer un essai gratuit directement sur Hugging Face !
Comment GLM 4.1V 9B Thinking réalise-t-il ces améliorations ?
- Renforcement par SFT :
Les échantillons d’entraînement incluent des annotations explicites Chaîne de Pensée (CoT), ce qui permet au modèle d’apprendre à « réfléchir d’abord, puis répondre. » Cela diffère des modèles traditionnels qui ne produisent qu’une réponse sans montrer les étapes de raisonnement. - Renforcement par RLCS :
La récompense du modèle n’est pas basée uniquement sur l’exactitude, mais évalue également la qualité du processus de raisonnement et des explications, encourageant une réflexion interne plus cohérente et approfondie. - Support architectural :
Un encodeur visuel ViT alimente un projecteur MLP, puis le décodeur LLM, permettant au modèle de générer de manière transparente des chemins de raisonnement explicites à partir d’une entrée visuelle, plutôt qu’un simple rappel ou une correspondance de motifs. - Fondation solide en raisonnement :
Un autre facteur clé : le modèle de base — GLM‑4‑9B 0414 — possède déjà de solides capacités de raisonnement. Par exemple :- Il démontre un excellent raisonnement mathématique et des performances générales sur les tâches, se classant parmi les meilleurs modèles open‑source de sa taille.
- Sur le plan architectural et d’entraînement, GLM‑4‑9B bénéficie d’un pré‑entraînement par remplissage de blancs autorégressif et d’un fine‑tuning ultérieur qui renforcent les compétences de raisonnement logique et multi‑étapes.
Vous pouvez obtenir plus de détails dans l’article : 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 | Gagnant |
|---|---|---|---|
| MMMU (image) | 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 |
| Codage (Design2Code) | 64.7 | 41.9 | GLM |
| Codage (Flame‑VLM‑Code) | 72.5 | 46.3 | GLM |
| OCRBench | 84.2 | 85.1 | Qwen 2.5 VL |
| VideoMME (sans texte) | 68.2 | 73.3 | Qwen 2.5 VL |
| VideoMME (avec texte) | 73.6 | 79.1 | Qwen 2.5 VL |
| MMVU | 59.4 | 62.9 | Qwen 2.5 VL |
Choisissez GLM 4.1V 9B Thinking si votre priorité est le raisonnement multimodal, les capacités d’agent, la résolution de problèmes STEM ou le codage.
Choisissez Qwen 2.5 VL 72B si vous vous concentrez sur la compréhension de documents/images/vidéos, en particulier l’OCR, l’extraction structurée et la perception visuelle.
Si vous souhaitez consulter plus de détails, vous pouvez voir cet article : GLM 4.1V 9B Thinking vs Qwen2.5 VL 72B : Lequel correspond à quoi ?
Il fournit également une comparaison avec d’autres modèles de premier plan.
De THUDM
Comment accéder à GLM 4.1V 9B Thinking ?
1. Accès local
Encore plus impressionnant, GLM 4.1V 9B Thinking n’a que 9 milliards de paramètres, ce qui lui permet de fonctionner sur des GPU comme le RTX 4090 ou même le 3090. Comparé à d’autres modèles avec plusieurs fois plus de paramètres, GLM obtient des performances remarquables avec une taille beaucoup plus petite — une réalisation qui souligne sans aucun doute la puissance de l’apprentissage par renforcement.
De THUDM
Guide d’installation
Installation :
pip install git+https://github.com/huggingface/transformers.git
Utilisation de base :
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)
Si l’achat d’un GPU vous semble trop coûteux, vous pouvez profiter des GPU cloud économiques et fiables de Novita AI — comme le RTX 4090 pour seulement 0,69 $ par heure ou le RTX 3090 pour seulement 0,21 $ par heure !
2. Intégration directe via API
Étape 1 : Connectez-vous et accédez à la bibliothèque de modèles
Connectez-vous à votre compte et cliquez sur le bouton Bibliothèque de modèles.
Essayez GLM 4.1V 9B maintenant !
Étape 2 : Choisissez votre modèle
Parcourez les options disponibles et sélectionnez le modèle qui correspond à vos besoins.
Étape 3 : Commencez votre essai gratuit
Démarrez votre essai gratuit pour explorer les capacités du modèle sélectionné.
Étape 4 : Obtenez votre clé API
Pour vous authentifier auprès de l’API, nous vous fournirons une nouvelle clé API. En entrant dans la page « Paramètres », vous pouvez copier la clé API comme indiqué sur l’image.
Étape 5 : Installez l’API
Installez l’API à l’aide du gestionnaire de packages spécifique à votre langage de programmation.
Après l’installation, importez les bibliothèques nécessaires dans votre environnement de développement. Initialisez l’API avec votre clé API pour commencer à interagir avec Novita AI LLM. Voici un exemple d’utilisation de l’API de complétion de chat pour les utilisateurs Python.
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)
Construire un outil simple de reconnaissance d’images avec MCP et GLM
Si vous souhaitez exploiter les capacités de GLM — par exemple, construire un outil simple de reconnaissance d’images pour démontrer son intégration de la reconnaissance visuelle et du raisonnement — vous pouvez utiliser la fonctionnalité MCP prise en charge par Novita AI. Voici le code d’exemple :
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")
Si vous souhaitez obtenir les détails, vous pouvez consulter cet article : Comment construire votre premier serveur MCP avec Novita AI !
GLM 4.1V 9B Thinking est facile à utiliser, super intelligent et ne nécessite pas de matériel coûteux. Vous pouvez tester ses capacités de reconnaissance d’images et de raisonnement avec seulement quelques lignes de code, que ce soit sur votre propre machine ou dans le cloud. Si vous voulez voir jusqu’où l’IA multimodale est arrivée, essayez GLM !
Qu’est-ce qui est spécial avec GLM 4.1V 9B Thinking ?
C’est le premier modèle qui peut à la fois « voir » et montrer ses étapes de raisonnement, pas seulement donner des réponses.
Puis-je essayer GLM 4.1V 9B sans disposer d’un GPU puissant ?
Oui ! Vous pouvez utiliser des GPU cloud abordables ou l’essayer gratuitement sur le Playground Novita AI.
Comment puis-je intégrer GLM 4.1V 9B Thinking dans mes propres projets ?
Vous pouvez l’exécuter localement avec Python et Hugging Face, y accéder via l’API de Novita AI, ou même construire vos propres outils de reconnaissance d’images en utilisant MCP comme montré dans les exemples de code fournis.
Novita AI est la plateforme cloud tout-en-un qui alimente vos ambitions en IA. API intégrées, serverless, instances GPU — les outils rentables dont vous avez besoin. Éliminez les infrastructures, commencez gratuitement et faites de votre vision IA une réalité.
