IBM Granite 4.0

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

IBM lance les modèles Granite-4.0 avec 3 tailles, dont Nano (350M et 1B), Micro (3B), Tiny (7B/1B actifs) et Small (32B/9B actifs). Entraînée sur 15T de jetons, 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.

Découvrez comment exécuter Unsloth Granite-4.0 Dynamic GGUF 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

Téléchargements Unsloth Granite-4.0 :

Dynamic GGUF	Dynamic 4-bit + FP8	Instruct 16 bits
H-350M 350M H-1B 1B H-Small H-Tiny H-Micro Micro	Dynamic 4-bit Instruct : H-Micro Micro FP8 Dynamic : H-Small FP8 H-Tiny FP8	H-350M 350M H-1B 1B H-Small H-Tiny H-Micro Micro

Vous pouvez également consulter notre collection Granite-4.0 pour tous les fichiers téléversés, y compris les quants 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 embarquée et en périphérie, ainsi que de recherche/fine-tuning.

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

• H-Tiny (MoE) : Rapide, économique pour les tâches à grand volume et faible complexité ; optimisé pour une utilisation locale et en périphérie (7B au total, 1B actif).

• H-Micro (Dense) : Léger, efficace pour les charges de travail à grand volume et faible complexité ; idéal pour un 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

• Fenêtre de longueur de contexte maximale : 131 072 (contexte 128K)

Modèle de chat :

<|start_of_role|>system<|end_of_role|>Vous êtes un assistant utile. Veuillez vous assurer que les réponses sont professionnelles, exactes et sûres.<|end_of_text|>
<|start_of_role|>user<|end_of_role|>Veuillez citer un laboratoire IBM Research situé aux États-Unis. Vous devez uniquement afficher son nom et son emplacement.<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>Almaden Research Center, San Jose, California<|end_of_text|>

🦙 Ollama : tutoriel pour exécuter Granite-4.0

1. Installez ollama si ce n’est pas déjà 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 les paramètres suggérés (température, etc.) dans params dans notre téléversement sur Hugging Face ! Vous pouvez changer le nom du modèle 'granite-4.0-h-small-GGUF' en 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 : tutoriel pour exécuter Granite-4.0

1. Obtenez la dernière version de llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d’habitude - la prise en charge de Metal est activée 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 également 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 BF16 en 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écutez le test Flappy Bird d’Unsloth

2. Modifiez --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, selon 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 : tutoriel pour exécuter Granite-4.0

Si vous avez déjà Docker Desktop, tout ce que vous avez à faire est 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

🦥 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 % de VRAM en moins 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 gratuit de fine-tuning

• 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 qui fournit une assistance en temps réel aux agents de support.

Nous vous montrons également comment entraîner un modèle à l’aide de 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,     # Le 4 bits utilise beaucoup moins de mémoire
    load_in_8bit = False,    # Un peu plus précis, utilise 2x plus de mémoire
    full_finetuning = False, # Nous avons maintenant le fine-tuning complet !
    # token = "hf_...",      # utilisez-en un si vous utilisez des modèles à accès restreint
)

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

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