IBM Granite 4.0

Comment exécuter IBM Granite-4.0 avec les GGUF d'Unsloth sur llama.cpp, Ollama et comment l'affiner !

IBM publie les modèles Granite-4.0 en 3 tailles comprenant Nano (350M et 1B), Micro (3B), Tiny (7B/1B actifs) et Small (32B/9B actifs). Entraînés sur 15T de tokens, la nouvelle architecture hybride (H) Mamba d’IBM permet aux modèles Granite-4.0 de fonctionner plus rapidement avec une utilisation mémoire réduite.

Apprenez comment exécuter les GGUF dynamiques Unsloth Granite-4.0 ou affinez/RL le modèle. Vous pouvez affiner Granite-4.0 avec notre notebook Colab gratuit pour un cas d’utilisation d’agent de support.

Tutoriel d’exécutionTutoriel d’affinage

Téléversements Unsloth Granite-4.0 :

GGUF dynamiques	Dynamique 4 bits + FP8	Instruct 16 bits
H-350M 350M H-1B 1B H-Small H-Tiny H-Micro Micro	Instruct dynamique 4 bits : H-Micro Micro FP8 dynamique : H-Small FP8 H-Tiny FP8	H-350M 350M H-1B 1B H-Small H-Tiny H-Micro Micro

Vous pouvez aussi consulter notre collection Granite-4.0 pour tous les téléversements incluant les quantifications Dynamic Float8, etc.

Explications des modèles Granite-4.0 :

• Nano et H-Nano : Les modèles 350M et 1B offrent de fortes capacités de suivi d’instructions, permettant des applications avancées d’IA sur appareil et en périphérie ainsi que la recherche/l’affinage.

• H-Small (MoE) : Cheval de bataille pour l’entreprise pour les tâches quotidiennes, prend en charge plusieurs sessions à long contexte sur des GPU d’entrée comme le L40S (32B au total, 9B actifs).

• H-Tiny (MoE) : Rapide, rentable pour des tâches à fort volume et faible complexité ; optimisé pour un usage local et en périphérie (7B au total, 1B actif).

• H-Micro (Dense) : Léger, efficace pour des charges de travail à fort volume et faible complexité ; idéal pour le déploiement local et en périphérie (3B au total).

• Micro (Dense) : Option dense alternative lorsque Mamba2 n’est pas entièrement pris en charge (3B au total).

Exécuter les tutoriels Granite-4.0

⚙️ Paramètres d’inférence recommandés

IBM recommande ces paramètres :

temperature=0.0, top_p=1.0, top_k=0

• Température de 0.0

• Top_K = 0

• Top_P = 1.0

• Contexte minimum recommandé : 16 384

• Longueur maximale de fenêtre de contexte : 131 072 (contexte 128K)

Modèle de chat :

<|start_of_role|>system<|end_of_role|>Vous êtes un assistant serviable. Veuillez vous assurer que les réponses sont professionnelles, précises et sûres.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Veuillez indiquer un laboratoire de recherche IBM situé aux États-Unis. Vous ne devez afficher que son nom et son emplacement.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>Almaden Research Center, San Jose, Californie<|end_of_text|>

🦙 Ollama : Exécuter le tutoriel Granite-4.0

1. Installer ollama si vous ne l’avez pas encore fait !

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

1. Exécutez le modèle ! Notez que vous pouvez appeler ollama servedans un autre terminal si cela échoue ! Nous incluons toutes nos corrections et paramètres suggérés (température etc.) dans params dans notre téléversement Hugging Face ! Vous pouvez changer le nom du modèle 'granite-4.0-h-small-GGUF' pour n’importe quel modèle Granite comme 'granite-4.0-h-micro:Q8_K_XL'.

ollama run hf.co/unsloth/granite-4.0-h-small-GGUF:UD-Q4_K_XL

📖 llama.cpp : Exécuter le tutoriel Granite-4.0

1. Obtenez la dernière llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous voulez simplement l’inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d’habitude - le support Metal est activé 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-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

1. Si vous souhaitez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_XL) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run

./llama.cpp/llama-cli \
    -hf unsloth/granite-4.0-h-small-GGUF:UD-Q4_K_XL

1. OU téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir Q4_K_M, ou d’autres versions quantifiées (comme la précision complète BF16).

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/granite-4.0-h-small-GGUF",
    local_dir = "unsloth/granite-4.0-h-small-GGUF",
    allow_patterns = ["*UD-Q4_K_XL*"], # Pour Q4_K_M
)

1. Exécutez le test Flappy Bird d’Unsloth

2. Modifier --threads 32 pour le nombre de threads CPU, --ctx-size 16384 pour la longueur de contexte (Granite-4.0 prend en charge une longueur de contexte de 128K !), --n-gpu-layers 99 pour le déchargement GPU du nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le également si vous avez uniquement de l’inférence CPU.

3. Pour le mode conversation :

./llama.cpp/llama-mtmd-cli \
    --model unsloth/granite-4.0-h-small-GGUF/granite-4.0-h-small-UD-Q4_K_XL.gguf \
    --jinja \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.0 \
    --top-k 0 \
    --top-p 1.0

🐋 Docker : Exécuter le tutoriel Granite-4.0

Si vous avez déjà Docker Desktop, il vous suffit d’exécuter la commande ci-dessous et c’est terminé :

docker model pull hf.co/unsloth/granite-4.0-h-small-GGUF:UD-Q4_K_XL

🦥 Affinage de Granite-4.0 dans Unsloth

Unsloth prend désormais en charge tous les modèles Granite 4.0 incluant nano, micro, tiny et small pour l’affinage. L’entraînement est 2x plus rapide, utilise 50 % de VRAM en moins et prend en charge des longueurs de contexte 6x plus longues. Les modèles Granite-4.0 micro et tiny tiennent confortablement dans un GPU T4 de 15 Go de VRAM.

• Granite-4.0 notebook d’affinage gratuit

• Granite-4.0-350M notebook d’affinage

Ce notebook entraîne un modèle pour devenir un agent de support qui comprend les interactions clients, avec analyse et recommandations. Cette configuration vous permet d’entraîner un bot qui fournit une assistance en temps réel aux agents de support.

Nous vous montrons également comment entraîner un modèle en utilisant des données stockées dans une feuille Google.

Configuration Unsloth pour Granite-4.0 :

!pip install --upgrade unsloth
from unsloth import FastLanguageModel
import torch
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/granite-4.0-h-micro",
    max_seq_length = 2048,   # Longueur de contexte - peut être plus longue, mais utilise plus de mémoire
    load_in_4bit = True,     # 4 bits utilise beaucoup moins de mémoire
    load_in_8bit = False,    # Un peu plus précis, utilise 2x la mémoire
    full_finetuning = False, # Nous avons maintenant l’affinage complet !
    # token = "hf_...",      # en utiliser un si vous utilisez des modèles restreints
)

Si vous avez une ancienne version d’Unsloth et/ou affinez localement, installez la dernière version d’Unsloth :

pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo