IBM Granite 4.0

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

IBM publie les modèles Granite-4.0 en 3 tailles comprenant Nano (350M & 1B), Micro (3B), Tiny (7B/1B actif) et Small (32B/9B actif). Entraînés sur 15T 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.

Apprendre comment exécuter les GGUF dynamiques Unsloth Granite-4.0 ou affiner/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 de fine-tuning

Uploads Unsloth Granite-4.0 :

GGUF dynamiques	Dynamique 4-bit + FP8	Instruct 16-bit
H-350M 350M H-1B 1B H-Small H-Tiny H-Micro Micro	Instruct dynamique 4-bit : 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 uploads 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 solides capacités de suivi d'instructions, permettant des applications avancées d'IA sur appareil et en edge ainsi que des usages de recherche/affinage.

• H-Small (MoE) : Outil de travail d'entreprise pour les tâches quotidiennes, prend en charge plusieurs sessions long-contexte sur des GPU d'entrée comme le L40S (32B total, 9B actif).

• H-Tiny (MoE) : Rapide, économique pour des tâches à fort volume et faible complexité ; optimisé pour une utilisation locale et en edge (7B 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 edge (3B total).

• Micro (Dense) : Option dense alternative lorsque Mamba2 n'est pas entièrement pris en charge (3B 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 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 énumérer 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. Installez 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 s'il échoue ! Nous incluons toutes nos corrections et paramètres suggérés (température, etc.) dans params dans notre upload Hugging Face ! Vous pouvez changer le nom du modèle 'granite-4.0-h-small-GGUF' par 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 le dernier 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 une inférence CPU.

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 voulez 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). Ceci est similaire à ollama run

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

1. OU télécharger 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 BF16 pleine précision).

# !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écuter le test Flappy Bird d'Unsloth

2. éditer --threads 32 pour le nombre de threads CPU, --ctx-size 16384 pour la longueur du contexte (Granite-4.0 prend en charge une longueur de contexte de 128K !), --n-gpu-layers 99 pour le déchargement GPU sur le nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n'avez qu'une 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 (fine-tuning) de Granite-4.0 dans Unsloth

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

• Granite-4.0 notebook de fine-tuning gratuit

• Granite-4.0-350M notebook de fine-tuning

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

Nous vous montrons aussi 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,     # 4bit 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 le fine-tuning complet !
    # token = "hf_...",      # en utiliser un si vous utilisez des modèles restreints
)

Si vous avez une ancienne version d'Unsloth et/ou si vous effectuez le fine-tuning localement, installez la dernière version d'Unsloth :

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