Pour des applications spécifiques comme les assistants virtuels dans la finance ou l'éducation, un modèle de langage généraliste manque souvent de précision. Recourir à un entraînement complet est coûteux et chronophage. Llama-Factory offre une solution intermédiaire, permettant d'adapter efficacement des modèles comme ChatGLM à des domaines métier.

Cette bibliothèque open source structure le processus de fine-tuning en modules configurables, accessibles via une interface graphique ou des fichiers de configuration. Elle prend en charge plus de 100 architectures de modèles, dont ChatGLM, Qwen et LLaMA, en masquatn les différences d'implémentation sous une couche d'abstraction uniforme.

Adaptation aux spécificités de ChatGLM

ChatGLM3-6B, basé sur l'architecture GLM, présente des particularités structurelles. Sa couche d'attention fusionne les projections Q, K et V en un seul module query_key_value. Appliquer directement une configuration LoRA prévue pour d'autres modèles échouerait. Llama-Factory détecte automatiquement le type de modèle et ajuste les points d'injection des adaptateurs LoRA en conséquence, par exemple en ciblant spécifiquement cette couche fusionnée.

Optimisation des ressources avec QLoRA

La technique QLoRA, intégrée dans Llama-Factory, combine la quantification en 4 bits (NF4) avec des adaptateurs de faible rang (LoRA). Cette approche réduit drastiquement l'empreinte mémoire, permettant de fine-tuner ChatGLM3-6B sur un GPU grand public comme la RTX 3090 (24 Go de VRAM).

Voici un exemple de commande pour lancer un entraînement via l'interface en ligne de commande :

CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --model_name_or_path chemin/vers/chatglm3-6b \
    --do_train \
    --dataset donnees_finance \
    --finetuning_type lora \
    --lora_target query_key_value \
    --output_dir ./resultats/chatglm-finance \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --learning_rate 2e-5 \
    --num_train_epochs 5 \
    --fp16 \
    --plot_loss

Les paramètres clés sont :

• --finetuning_type lora : active le fine-tuning paramétriquement efficace.
• --lora_target query_key_value : cible la couche d'attention spécifique à ChatGLM.
• --gradient_accumulation_steps 4 : simule un batch size effectif plus grand pour une stabilité accrue.
• --fp16 : réduit l'usage mémoire par le calcul en demi-précision.

Interface graphique et flux simplifié

Une interface web est également disponible :

python src/webui.py --port 8080

Elle permet de charger un jeu de données au format Alpaca (champs instruction, input, output), de configurer les hyperparamètres et de lancer l'entraînement sans écrire de code, facilitant la participation des experts métier.

Déploiement du modèle affiné

Une fois l'entraînement terminé, le modèle peut être exporté dans différents formats. L'exemple suivant fusionne les poids LoRA avec le modèle de base et applique une quantification 4 bits :

python src/export_model.py \
    --model_name_or_path chemin/vers/chatglm3-6b \
    --adapter_name_or_path ./resultats/chatglm-finance \
    --export_dir ./modeles/assistant-finance-4bit \
    --export_quantization_bit 4

Le résultat peut ensuite être servi via un framework comme FastAPI pour créer une API dédiée.

Bonnes pratiques

1. Validation initiale : Lancez un entraînement court sur un petit échantillon pour vérifier la qualité des données et la configuration.
2. Gestion de la séquence : Ajustez max_length (ex: 1024, 2048) selon la longueur moyenne de vos données pour éviter les erreurs de mémoire (OOM).
3. Taille du batch : Utilisez une taille de batch par appareil modeste (2-4) combinée à l'accumulation de gradients.
4. Sauvegardes : Conifgurez save_steps et save_total_limit pour créer des points de contrôle réguliers et limiter l'espace disque utilisé.

Ce processus accélère considérablement le cycle de développement, permettant de transformer une idée de produit en prototype fonctionnel basé sur un grand modèle de langage en quelques heures seulement.