IBM Granite 4.0

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

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

Découvrez comment exécuter les GGUF dynamiques Granite-4.0 d’Unsloth ou affiner/RL le modèle. Vous pouvez fine-tuner 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éversements Unsloth Granite-4.0 :

GGUF dynamiques	4 bits dynamique + 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, y compris les quantifications Float8 dynamiques, etc.

Explications sur les 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/affinage.

• H-Small (MoE) : Cheval de bataille de l’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 minimal recommandé : 16,384

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

Modèle de conversation :

<|start_of_role|>system<|end_of_role|>Vous êtes un assistant utile. Veuillez vous assurer que les réponses soient 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|>Centre de recherche Almaden, San José, Californie<|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 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' 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 llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez -DGGML_CUDA=ON à -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 pour charger directement 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 de combien de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous faites une inférence uniquement 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

🦥 Affiner 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 l’affinage. L’entraînement est 2 fois plus rapide, utilise 50 % de VRAM en moins et prend en charge des contextes 6 fois plus longs. 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 en faire un agent de support qui comprend les interactions avec les 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 aussi 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 du 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 2 fois plus de mémoire
    full_finetuning = False, # Nous avons maintenant le fine-tuning complet !
    # token = "hf_...",      # en utiliser un si vous utilisez des modèles à accès restreint
)

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

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