Affiner Gemma 4 avec Unsloth
Unsloth est une bibliothèque open source qui rend l'affinage des LLM jusqu'à 2x plus rapide tout en utilisant 60% moins de mémoire. Elle y parvient grâce à des kernels CUDA personnalisés et des boucles d'entraînement optimisées — sans aucune perte de précision par rapport à l'entraînement standard.
Gemma 4 est entièrement pris en charge par Unsloth, y compris les quatre variantes (E2B, E4B, 26B MoE, 31B). Ce guide couvre l'installation, la préparation des datasets, la configuration de l'entraînement et l'exportation de votre modèle affiné.
Pourquoi affiner avec Unsloth ?
Entraînement 2x plus rapide
Les kernels Triton personnalisés optimisent les couches d'attention, MLP et embedding. Un affinage qui prend 10 heures avec les méthodes standards prend ~5 heures avec Unsloth.
60% moins de mémoire
Le checkpointing intelligent des gradients et la gestion de la mémoire vous permettent d'affiner des modèles plus grands sur des GPU plus petits. Le modèle E4B peut être affiné sur une seule RTX 3090.
Aucune perte de précision
Les optimisations d'Unsloth sont mathématiquement équivalentes à l'entraînement standard. Vous obtenez la même qualité de modèle avec moins de calcul — sans approximations ni compromis.
Export facile
Exportez les modèles affinés vers GGUF (pour Ollama/llama.cpp), SafeTensors (pour vLLM), ou poussez directement vers Hugging Face — tout cela en une seule commande.
Installation
Installez Unsloth avec pip. Nécessite Python 3.10+ et PyTorch 2.0+ :
pip install unslothDémarrage rapide : affiner E4B
Un exemple minimal pour affiner Gemma 4 E4B avec LoRA sur votre propre dataset :
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="google/gemma-4-e4b-it",
max_seq_length=4096,
load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(
model, r=16, lora_alpha=16,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
)
# Train with your dataset
from trl import SFTTrainer
trainer = SFTTrainer(
model=model, tokenizer=tokenizer,
train_dataset=dataset,
max_seq_length=4096,
)
trainer.train()Préparer votre dataset
Unsloth prend en charge plusieurs formats de dataset pour affiner Gemma 4 :
unslothPage.datasets.formats.0.title
Conversations avec tours utilisateur/assistant. Meilleur pour l'affinage de chatbot et d'assistant.
unslothPage.datasets.formats.1.title
Texte brut pour pré-entraînement continu ou adaptation au domaine.
unslothPage.datasets.formats.2.title
Paires choisies/rejetées pour l'entraînement basé sur les préférences.
Configuration matérielle pour l'affinage
unslothPage.hardware.desc
| unslothPage.hardware.headers.model | unslothPage.hardware.headers.gpu | unslothPage.hardware.headers.time |
|---|---|---|
| E2B LoRA | RTX 3060 (12 GB) | ~15 min / 1K steps |
| E4B LoRA | RTX 4060 Ti (16 GB) | ~25 min / 1K steps |
| E4B QLoRA | RTX 3060 (12 GB) | ~30 min / 1K steps |
| 27B MoE LoRA | RTX 4090 (24 GB) | ~60 min / 1K steps |
| 27B MoE QLoRA | RTX 4070 Ti (16 GB) | ~90 min / 1K steps |
Exporter votre modèle
Après l'affinage, exportez vers votre format préféré :
# Save to GGUF for Ollama
model.save_pretrained_gguf("gemma4-custom", tokenizer, quantization_method="q4_k_m")
# Save to SafeTensors for vLLM
model.save_pretrained_merged("gemma4-custom-merged", tokenizer)
# Push to Hugging Face
model.push_to_hub_merged("your-username/gemma4-custom", tokenizer)FAQ Unsloth + Gemma 4
Qu'est-ce qu'Unsloth ?
Unsloth est une bibliothèque d'affinage open source qui rend l'entraînement LLM 2x plus rapide et utilise 60% moins de mémoire grâce à des kernels CUDA personnalisés. Elle prend en charge Gemma 4, Llama, Mistral et d'autres familles de modèles populaires.
Puis-je affiner Gemma 4 E4B sur un GPU grand public ?
Oui. Avec QLoRA 4 bits d'Unsloth, vous pouvez affiner E4B sur une RTX 4060 (8 Go). LoRA nécessite une RTX 3090 (24 Go). Les modèles plus grands nécessitent des GPU professionnels (A100/H100) ou des instances cloud.
Qu'est-ce que LoRA vs QLoRA ?
LoRA (Low-Rank Adaptation) ajoute de petites matrices entraînables au modèle tout en gardant les poids de base figés. QLoRA quantifie en plus le modèle de base à 4 bits, réduisant considérablement la mémoire. Les deux produisent des résultats de qualité similaire.
Combien de données me faut-il pour l'affinage ?
Pour l'adaptation au domaine, 1K-10K exemples de haute qualité sont souvent suffisants. Pour le réglage des instructions, 5K-50K paires de conversation fonctionnent bien. La qualité importe plus que la quantité — 1K excellents exemples valent mieux que 100K bruyants.
Puis-je fusionner les poids LoRA dans le modèle de base ?
Oui. Unsloth prend en charge la fusion des poids LoRA dans le modèle de base pour le déploiement sans la surcharge de l'adaptateur. Exportez en tant que modèle fusionné unique au format GGUF ou SafeTensors.
Unsloth prend-il en charge le modèle MoE ?
Oui, Unsloth prend en charge l'affinage du modèle MoE Gemma 4 26B A4B. En raison de l'architecture MoE, LoRA est généralement appliqué aux couches partagées et au routage des experts, nécessitant plus de VRAM que les modèles denses avec un nombre de paramètres actifs similaire.
unslothPage.faq.items.6.q
unslothPage.faq.items.6.a
unslothPage.faq.items.7.q
unslothPage.faq.items.7.a
unslothPage.faq.items.8.q
unslothPage.faq.items.8.a
unslothPage.faq.items.9.q
unslothPage.faq.items.9.a
Commencer à affiner Gemma 4
Installez Unsloth, préparez votre dataset et créez un modèle Gemma 4 personnalisé en quelques heures.