Intégration d'Unsloth

Unsloth est un framework open source pour le fine-tuning et l'apprentissage par renforcement qui entraîne les LLM (comme Llama, OpenAI gpt-oss, Mistral, Gemma, DeepSeek, etc.) jusqu'à 2× plus rapidement avec jusqu'à 80 % de VRAM en moins. Unsloth permet l'entraînement, l'évaluation, l'exécution et le déploiement avec d'autres moteurs d'inférence comme llama.cpp, Ollama et vLLM.

La bibliothèque offre un flux de travail rationalisé, compatible avec Hugging Face, pour l’entraînement, l’évaluation, l’inférence et le déploiement, et est entièrement compatible avec SFTTrainer.

Fonctionnalités clés

Prise en charge de l'entraînement pour tous les modèles compatibles avec les transformers : synthèse vocale (TTS), multimodal, BERT, RL et plus
Prend en charge le fine-tuning complet, le pré-entraînement, LoRA, QLoRA, l'entraînement 8 bits et plus
Fonctionne sur Linux, Windows, Colab, Kaggle ; GPU NVIDIA, bientôt configurations AMD & Intel
Prend en charge la plupart des fonctionnalités prises en charge par TRL, y compris RLHF (GSPO, GRPO, DPO, etc.)
Les noyaux Triton écrits à la main et un moteur de rétropropagation manuel garantissent l'absence de dégradation de la précision (0 % d'erreur d'approximation)

Installation

pip install

Installation locale (Linux recommandé) :

pip install unsloth

Vous pouvez également installer unsloth conformément à la documentation officielle. Une fois installé, vous pouvez intégrer unsloth à votre flux de travail de manière très simple ; au lieu de charger AutoModelForCausalLM, il vous suffit de charger un FastLanguageModel comme suit :

import torch
from trl import SFTConfig, SFTTrainer
from unsloth import FastLanguageModel

max_length = 2048 # Supports automatic RoPE Scaling, so choose any number

# Load model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/mistral-7b",
    max_seq_length=max_length,
    dtype="auto",  # For auto-detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
    load_in_4bit=True,  # Use 4bit quantization to reduce memory usage. Can be False
)

# Do model patching and add fast LoRA weights
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0,  # Dropout = 0 is currently optimized
    bias="none",  # Bias = "none" is currently optimized
    use_gradient_checkpointing=True,
    random_state=3407,
)

training_args = SFTConfig(output_dir="./output", max_length=max_length)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

Le modèle enregistré est entièrement compatible avec la bibliothèque transformers de Hugging Face. En savoir plus sur unsloth dans leur dépôt officiel.

Installation Docker

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Accédez à Jupyter Lab à l’adresse http://localhost:8888 et commencez le fine-tuning !

Entraînement

Voici quelques paramètres essentiels que vous pouvez activer ou désactiver avant l’entraînement :

max_seq_length = 2048 – Contrôle la longueur du contexte. Bien que Llama-3 prenne en charge 8192, nous recommandons 2048 pour les tests. Unsloth permet un fine-tuning avec un contexte 4 fois plus long.
dtype = "auto" – Pour la détection automatique ; utilisez torch.float16 ou torch.bfloat16 pour les GPU plus récents.
load_in_4bit = True – Active la quantification en 4 bits, réduisant l’utilisation mémoire de 4× pour le fine-tuning. La désactiver permet d’activer le fine-tuning LoRA en 16 bits.
Pour activer l'ajustement complet (FFT), définissez full_finetuning = True. Pour l'ajustement en 8 bits, définissez load_in_8bit = True. Remarque : seule une méthode d'entraînement peut être définie sur True à la fois.

Pour plus d'informations sur la configuration des hyperparamètres et des fonctionnalités d'Unsloth, consultez leur guide de documentation ici.

Enregistrer le modèle

Unsloth vous permet d'enregistrer directement le modèle affiné sous forme d'un petit fichier appelé adaptateur LoRA. Vous pouvez également le publier sur le hub Hugging Face si vous souhaitez téléverser votre modèle ! N'oubliez pas d'obtenir un jeton Hugging Face et d'ajouter votre jeton !

Enregistrer au format GGUF

Pour enregistrer au format GGUF, Unsloth utilise llama.cpp. Pour enregistrer localement :

model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")

Pour pousser sur le hub :

model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")

Enregistrer dans vLLM

Pour enregistrer en 16 bits pour vLLM, utilisez :

model.save_pretrained_merged("model", tokenizer, save_method = "merged_16bit",)
model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "")

Update on GitHub

TRL