LLaMA-Factory est un cadre de réglage fin efficace et unifié LLM/VLM qui prend en charge LoRA, QLoRA et les processus de formation et d'évaluation complets des paramètres, et convient à une itération rapide par les équipes modèles.

LLaMA-Factory

Paramètres et statistiques de base

LLaMA-Factory est un cadre de réglage fin unifié et efficace, officiellement positionné comme « Réglage fin unifié et efficace de plus de 100 LLM et VLM », couvrant le lien de formation complet, depuis le réglage fin des instructions jusqu'à l'alignement des préférences.

Projets	Informations publiques
Positionnement officiel	Réglage fin unifié et efficace de plus de 100 LLM et VLM
Licence Open Source	Apache-2.0
Étoiles GitHub	~73 400
Fourches GitHub	~9 000
Problèmes ouverts	~980
Contributeurs	290+
Nombre de sorties	36 sorties
Dernière version	v0.9.5 (2026-05-30)
Première création	2023-05-28
Documentation officielle	lamafactory.readthedocs.io
Modèles pris en charge	Plus de 100 LLM et VLM
Stratégie de formation	Pré-formation, SFT, modélisation des récompenses, PPO, DPO, KTO, ORPO, SimPO
Bits de quantification	QLoRA 2/3/4/5/6/8 bits

Limite du produit : LLaMA-Factory se concentre sur les liens de formation et d'évaluation et ne remplace pas les passerelles d'inférence en ligne, les plates-formes de flux de travail de la couche d'application d'entreprise ou les outils d'annotation de données. Si tout ce dont vous avez besoin est d'appeler des API d'inférence prêtes à l'emploi sans formation ni réglage fin, LLaMA-Factory augmentera considérablement la complexité de la mise en œuvre.

Position sur le marché : dans le cadre de formation open source, LLaMA-Factory, axolotl, Hugging Face TRL et Unsloth constituent le principal paysage concurrentiel. La principale différence de LLaMA-Factory réside dans « zéro entrée de code + couverture de modèle la plus large », plutôt que dans la vitesse de formation ou dans l'optimisation ultime d'un seul modèle. Le tableau suivant montre les principales différences par rapport à des frameworks similaires :

Dimensions	LLaMA-Usine	axolotl	Visage câlin TRL	Insouciant
Seuil de code	Zéro code (interface utilisateur Web + YAML)	Configuration YAML requise	Script Python requis	Script Python requis
Couverture du modèle	100+ (y compris VLM/multimodal)	~50	Illimité (dépend des Transformers)	~20
Stratégies de formation	8 types (dont RLHF)	~5 types	6 types	3 types
Soutien quantitatif	Série complète 2-8 bits	4/8 bits	4/8 bits	4 bits
Interface utilisateur Web	Carte LLaMA intégrée	Aucun	Aucun	Aucun
Formation distribuée	DeepSpeed ​​+ Mégatron	Vitesse profonde	Vitesse profonde	Vitesse profonde
Le seuil matériel le plus bas	QLoRA 2 bits ne nécessite que 4 Go	8 Go+	8 Go+	6 Go+
Licence Open Source	Apache-2.0	Apache-2.0	Apache-2.0	Apache-2.0

Reconnaissance des utilisateurs et du marché de LLaMA-Factory

Taille de la communauté : plus de 73 400 étoiles et plus de 9 000 forks sur GitHub, ce qui en fait l'un des projets les plus regardés dans le domaine du réglage fin de l'open source. Plus de 290 contributeurs et 36 versions indiquent que le projet a dépassé le stade expérimental précoce et a formé un mécanisme de collaboration communautaire relativement stable.

Approbation de l'entreprise : le README officiel répertorie clairement l'adoption par Amazon (utilisé sur SageMaker HyperPod pour l'extraction multimodale d'informations de documents financiers), NVIDIA (intégration de RTX AI Toolkit), Alibaba Cloud (intégration d'images PAI-DSW), etc. Ces cas montrent que LLaMA-Factory a été incluse dans l'écosystème d'infrastructure d'IA des principaux fournisseurs de cloud.

Citation académique : L'article « LLaMAFactory : Unified Efficient Fine-Tuning of 100+ Language Models » a été publié dans ACL 2024 (System Demonstrations) et bénéficie d'une reconnaissance académique.

Éléments non divulgués : échelle de clientèle commerciale, indicateurs de conversion payante et données sur les revenus officiellement non divulgués. Les données basées sur le marché seront soumises à des divulgations officielles ultérieures.

Avantage en termes de coût : utiliser l'open source pour abaisser le seuil de puissance de calcul pour la personnalisation des modèles

LLaMA-Factory elle-même est entièrement open source et gratuite, et le principal coût d'utilisation provient des ressources informatiques et de l'investissement humain. Ce qui suit commence par la structure de coûts à trois niveaux.

Côté C/Individuel : les chercheurs individuels peuvent exécuter le réglage fin de QLoRA sur un GPU à carte unique (tel que RTX 4090 24 Go), avec des besoins en mémoire vidéo aussi faibles que 6 Go (QLoRA 2 bits). Associé à des ensembles de données open source sur Hugging Face ou ModelScope, le coût en puissance de calcul d'une seule expérience de réglage fin peut être contrôlé à plusieurs dizaines de yuans. La version gratuite de Google Colab vous permet de réaliser des expériences à petite échelle.

Développeurs/Équipe API : Le coût évident est la location d'instances GPU. LoRA/QLoRA peut réduire le coût d'un réglage précis unique à 10 % à 30 % de la formation complète des paramètres. Le tableau suivant montre les coûts matériels estimés sous différentes configurations (en prenant comme exemple les prix à la demande des GPU cloud grand public) :

Stratégie de mise au point	Exigences en matière de mémoire vidéo (modèle 7B)	Exigences en matière de mémoire vidéo (modèle 70B)	Estimation du temps de formation unique (7B)	Estimation du coût du GPU Cloud (7B)
Paramètres complets (bf16)	~60 Go	~600 Go	4-8 heures	10-30$
LoRA (16 bits)	~16 Go	~160 Go	2-4 heures	5-15 $
QLoRA (8 bits)	~10 Go	~80 Go	2-4 heures	3-10 $
QLoRA (4 bits)	~6 Go	~48 Go	3-5 heures	3-8 $
QLoRA (2 bits)	~4 Go	~24 Go	4-6 heures	2-6 $

Remarque : Le tableau ci-dessus est une valeur estimée. Le coût réel varie en fonction de l'architecture du modèle, de la longueur de la séquence, de la taille de l'ensemble de données, du modèle de GPU (A100/H100/4090) et de la stratégie tarifaire du fournisseur de cloud. La facturation en temps réel fournie par le fournisseur de cloud prévaudra.

Entreprise/privatisation : les entreprises peuvent déployer une puissance de calcul privée, mais elles doivent supporter des coûts supplémentaires :

• Coût de la gouvernance des données : l'investissement humain dans le nettoyage des données de formation, l'examen de la qualité des annotations et l'examen de la conformité aux droits d'auteur dépasse généralement le coût de la puissance de calcul.
• Coût de gestion des expériences : comparaison des expériences multiversions et recherche de super paramètres. La gestion des points de contrôle nécessite la prise en charge d'une infrastructure de suivi des expériences (telle que W&B, MLflow).
• Cluster Scheduling Cost : La formation multi-cartes/multi-nœuds nécessite la configuration de DeepSpeed ​​​​ou Megatron, ce qui implique des capacités d'exploitation et de maintenance.
• Coût de gouvernance du modèle : évaluation A/B de la gestion des versions de modèle affinée, examen de l'alignement de la sécurité.

Avantages cachés : l'accès à la formation unifié peut réduire le coût de maintenance d'"un script de formation pour chaque modèle" d'environ 60 à 80 % (estimé). L'équipe n'a pas besoin de réécrire le chargement des données, le cycle de formation et la logique d'évaluation lors du changement de modèle.

Principales fonctions de LLaMA-Factory

• Portail de réglage fin unifié pour plus de 100 modèles : Couvrant les familles de modèles grand public telles que LLaMA, Qwen, DeepSeek, Gemma, Mistral, GLM et Phi, vous pouvez changer de modèle avec un seul ensemble de portails de configuration. En utilisation réelle, changer de modèle nécessite uniquement de modifier le champ model_name_or_path dans YAML, ce qui réduit considérablement l'écriture de scripts d'adaptation.
• 8 stratégies de formation : de la pré-formation (Pre-training), du réglage fin supervisé (SFT), de la modélisation des récompenses (Reward Modeling) à l'alignement des préférences PPO/DPO/KTO/ORPO/SimPO, couvrant l'ensemble du lien depuis le réglage fin des instructions jusqu'à l'alignement des valeurs. Les équipes peuvent mettre en cascade des pipelines de formation en plusieurs étapes dans le même cadre.
• Couverture complète du réglage fin efficace des paramètres : prend en charge plus de 10 méthodes efficaces de paramètres telles que LoRA, QLoRA (2/3/4/5/6/8 bits), DoRA, LongLoRA, LoRA+, LoftQ, PiSSA, etc. LoRA peut affiner les modèles 7B sur 16 Go de mémoire vidéo, et QLoRA 2 bits peut même fonctionner sur 4 Go de mémoire vidéo, abaissant considérablement le seuil expérimental.
• Intégration d'algorithmes d'optimisation avancés : intégrez des optimiseurs de formation de pointe tels que GaLore, BAdam, APOLLO, Adam-mini, Muon, OFT, Mixture-of-Depths, etc. Ces algorithmes réduisent les coûts de formation à partir de dimensions telles que la compression de gradient (GaLore), l'optimisation de la mémoire (APOLLO) et le regroupement de paramètres (BAdam).
• Technologie d'accélération d'ingénierie intégrée : l'intégration native de FlashAttention-2, Unsloth, Liger Kernel, KTransformers et d'autres bibliothèques d'accélération peut être automatiquement activée sans modifier le script de formation. FlashAttention-2 peut accélérer l'entraînement en séquence longue de 2 à 4 fois.
• Surveillance et visualisation des expériences : La carte LLaMA intégrée (Gradio Web UI) fournit une courbe d'entraînement en temps réel et une surveillance du taux de perte/d'apprentissage ; il prend également en charge des outils de gestion d'expériences externes tels que WandB, TensorBoard, MLflow et SwanLab.
• Prise en charge de la formation multimodale : prend non seulement en charge le LLM textuel, mais prend également en charge le réglage fin des modèles de langage visuel (VLM) tels que LLaVA, Qwen2.5-VL, InternVL, MiniCPM-V et les modèles de compréhension audio tels que Qwen2-Audio et Qwen2.5-Omni.
• Déploiement d'inférence intégré : une fois la formation terminée, vous pouvez directement démarrer le service API de style OpenAI (prend en charge le backend vLLM ou SGLang) et déployer les poids LoRA produits par la formation ou le modèle complet fusionné en tant que point final d'inférence en un seul clic, réduisant ainsi le travail de la formation à l'inférence.

les coûts de changement de processus.

Synergie : les fonctionnalités ci-dessus n'existent pas isolément. « Couverture multimodèle + configuration unifiée » signifie que l'équipe n'a pas besoin de réécrire les cycles de chargement des données et de formation lors du changement de modèle ; « Bibliothèque efficace de réglage fin des paramètres + d'accélération » permet aux équipes à faibles ressources d'affiner les modèles 70B+ ; « Intégration formation + déploiement d'API » compresse les liens d'ingénierie depuis l'expérimentation vers en ligne dans un seul cadre, évitant ainsi le travail de conversion de poids et d'adaptation entre les scripts de formation et les services d'inférence.

Evolution du modèle et de la version de LLaMA-Factory

LLaMA-Factory a connu des itérations rapides depuis sa création le 28/05/2023. L'axe principal de l'évolution des versions s'articule autour des trois directions « l'expansion de la couverture du modèle, l'enrichissement de la stratégie de formation et la mise à niveau de l'infrastructure d'ingénierie ».

Version principale

Version	Dates	Changements clés
v0.9.5	2026-05-30	Ajout de Qwen3.5/3.6, Gemma 4, adaptation Transformers v5 ; la dernière des 36 versions
v0.9.4	2025-12-31	Version principale annuelle, intégration de la stabilité et des capacités, couvrant l'entrée unifiée de réglage fin multi-modèles
v0.9.3	2025-06-16	Prise en charge étendue des modèles pour Llama 4, Gemma 3, Qwen3, InternVL3, Qwen2.5-Omni et d'autres modèles
v0.9.2	~2025-03	Présentation de la prise en charge intégrée de l'algorithme OFT/OFTv2 du backend de formation Megatron-core
v0.9.1	~2024-12	Développez continuellement de nouveaux modèles tels que DeepSeek V3, optimisez l'interface utilisateur Web et la gestion des expériences
v0.8.x	2024-06/09	Établir une infrastructure multimodèle et multistratégie pour prendre en charge LLaMA 3, Qwen2, GLM-4, etc.

Premiers jalons

• 2023-05-28 : Le projet a été créé pour la première fois, avec pour objectif initial de peaufiner la série LLaMA.
• 2024-03 : L'article a été accepté par l'ACL 2024 et l'influence académique a été considérablement améliorée.
• 2024-06 : la v0.8.0 est sortie, l'architecture multimodèle est devenue stable et le nombre d'étoiles de la communauté a dépassé les 10 000.
• 2025-01 : DeepSeek R1 a été rapidement adapté après sa sortie, reflétant les capacités de suivi du modèle dès le jour 0.

Règles d'évolution des versions

Le rythme des versions de LLaMA-Factory présente les caractéristiques de « l'adaptation est terminée dans les 1 à 7 jours après la sortie d'un nouveau modèle ». Par exemple, DeepSeek R1 a été publié le 20/01/2025 et le projet a terminé son support en quelques jours. Cette rapidité de mise à jour est due à son architecture d'enregistrement de modèles de plug-in : l'ajout d'une famille de modèles ne nécessite généralement que la fourniture de fichiers de configuration et de modèles, sans modifier le code de formation de base. Pour les acheteurs, cela signifie que l'adoption de LLaMA-Factory réduit le risque de changements de chaîne d'outils dus au changement de modèle.

Avantages techniques de LLaMA-Factory

Conception architecturale

LLaMA-Factory adopte une architecture « couche d'abstraction de configuration unifiée + enregistrement de modèle de plug-in ». Le moteur de formation principal est encapsulé via les bibliothèques PEFT (Parameter-Efficient Fine-Tuning) et Transformers, et la couche supérieure décrit le chemin du modèle, l'ensemble de données, la stratégie de formation et les hyperparamètres via la configuration YAML. La valeur fondamentale de cette conception est :

• Interface de formation indépendante du modèle : Le script de formation est découplé du modèle. Pour ajouter un nouveau modèle, il suffit d'enregistrer le fichier de configuration et le modèle de dialogue, sans modifier le code du cycle de formation.
• Les stratégies sont enfichables : LoRA, QLoRA, le réglage fin des paramètres complets et d'autres stratégies sont gérées de manière uniforme via la bibliothèque peft, et la stratégie de formation peut être modifiée en changeant d'éléments de configuration sans modifier le processus de chargement et d'évaluation des données.
• Prise en charge de plusieurs backends : en plus du DDP natif de PyTorch, il prend en charge les stratégies distribuées telles que DeepSpeed ​​​​ZeRO (étape 1-3) et Megatron-core, qui conviennent aux scénarios multi-cartes mono-machine à multi-machines multi-cartes.

Pourquoi LLaMA-Factory peut-elle réaliser un « réglage fin de grands modèles avec peu de ressources » ?

Le mécanisme central comporte trois couches de superposition :

1. Couche de compression de quantification : Grâce aux bibliothèques de quantification telles que bitsandbytes, AQLM, AWQ, GPTQ, HQQ, EETQ, etc., le poids du modèle est compressé de 16 bits à 2 à 8 bits, réduisant considérablement l'utilisation de la mémoire. En prenant QLoRA 4 bits comme exemple, les besoins en mémoire vidéo du modèle 70B sont réduits de ~ 600 Go à ~ 80 Go, permettant à un seul 4 × A100 de fonctionner.
2. Couche efficace des paramètres : LoRA/DoRA et d'autres méthodes n'entraînent que 0,1 % à 1 % des paramètres d'origine. La quantité de calcul du gradient de rétro-propagation est considérablement réduite et la vitesse d'entraînement est augmentée de 2 à 5 fois par rapport au réglage fin complet des paramètres.
3. Couche d'accélération informatique : FlashAttention-2 augmente la vitesse d'entraînement du mécanisme d'attention de 2 à 4 fois grâce au calcul de blocs et à l'optimisation prenant en compte les IO ; Liger Kernel fusionne plusieurs cœurs pour réduire la lecture et l'écriture de la mémoire vidéo ; Unsloth améliore encore le débit de formation LoRA grâce à des noyaux CUDA optimisés manuellement.

Effet réel : ces trois couches de superposition compressent le réglage fin des paramètres complets 70B qui nécessitait à l'origine 8 × A100 (~ 100 $/heure) à une expérience QLoRA de 1 × RTX 4090 (~ 1 $/heure). Le coût de la formation est réduit d'environ deux ordres de grandeur, permettant aux développeurs individuels et aux équipes de petite et moyenne taille de participer à une personnalisation à grande échelle de modèles.

Limite d'adaptation

Scénario	Avantages LLaMA-Factory	Limite inappropriée
Mise au point des instructions (SFT)	Seuil zéro, configurer et exécuter	Non applicable lorsqu'une personnalisation approfondie des cycles de formation (telle que des fonctions de perte personnalisées) est requise
Alignement des préférences (DPO/PPO)	Processus intégré complet	Lorsqu'un RLHF à grande échelle (des dizaines de milliers d'échantillonnages rapides) est requis, un cadre RL externe doit être utilisé
Mise au point multimodale (VLM)	Couvre l'architecture VLM grand public	Prise en charge limitée de la formation aux modalités vidéo/3D
Formation distribuée	Intégration DeepSpeed/Mégatron	La pré-formation à grande échelle (entraîner des centaines de milliards de modèles de paramètres à partir de zéro) n'est pas son objectif de conception
Déploiement d'inférence de production	API vLLM/SGLang intégrée	Pour l'inférence de production à haute concurrence, il est recommandé d'utiliser un moteur d'inférence dédié (tel que TGI, déploiement indépendant de vLLM)

Chemin d'utilisation de LLaMA-Factory

LLaMA-Factory propose quatre entrées, adaptées aux équipes ayant des parcours techniques et des scénarios différents :

Méthode de saisie	Convient à la foule	Commande de démarrage	Conditions préalables
Ligne de commande YAML	Développeurs avec une expérience en ingénierie ML	llamafactory-cli train examples/train_lora/qwen3_lora_sft.yaml	Python 3.11+, PyTorch 2.0+, GPU
Interface utilisateur Web (Tableau LLaMA)	Chercheur en algorithmes, novice	llamafactory-cli webui	Comme ci-dessus, ouvrez automatiquement l'interface Gradio
Conteneurs Docker	Équipe DevOps/Plateforme	docker run -it --gpus=all hiyouga/llamafactory:latest	Docker + boîte à outils de conteneur NVIDIA
API de style OpenAI	Scénario de déploiement d'inférence	API_PORT=8000 exemples d'API llamafactory-cli/inference/qwen3.yaml	Fichier de poids une fois l'entraînement terminé

Étapes typiques : 3 commandes pour effectuer un réglage fin

Le flux de travail principal de LLaMA-Factory peut être condensé en 3 commandes :

# 1. Formation : LoRA peaufinant Qwen3-4B
exemples de train llamafactory-cli/train_lora/qwen3_lora_sft.yaml

# 2. Test de dialogue : chargez les poids LoRA entraînés pour l'interaction
exemples de chat llamafactory-cli/inference/qwen3_lora_sft.yaml

# 3. Exporter la fusion : fusionner les poids LoRA dans le modèle de base
llamafactory-cli export examples/merge_lora/qwen3_lora_sft.yaml

Exemple de configuration YAML typique

# qwen3_lora_sft.yaml
model_name_or_path : Qwen/Qwen3-4B-Instruct
modèle : qwen
étape : sft
finetuning_type : lora
lora_target : tout
ensemble de données : identité, alpaca_en_demo
rép_ensemble de données : données
cutoff_len : 1024
taux_d'apprentissage : 1.0e-4
num_train_epochs : 3.0
per_device_train_batch_size : 4
gradient_accumulation_steps : 4
fp16 : vrai

Description des paramètres de configuration : finetuning_type contrôle la stratégie de réglage fin (lora/freeze/full), lora_target spécifie le module injecté par LoRA, dataset utilise le nom du jeu de données enregistré dans data/dataset_info.json.

Suggestions de chemin d'atterrissage

Lors de la présentation effective de l’équipe LLaMA-Factory, il est recommandé de procéder en trois étapes :

1. Pilote (1 à 2 semaines) : sélectionnez une tâche commerciale spécifique (telle que la classification des intentions de service client, l'achèvement du code), utilisez le modèle officiel + l'ensemble de données publiques pour exécuter l'ensemble du processus SFT et vérifiez les avantages de la formation.
2. Contraste (2-4 semaines) : effectuez une comparaison A/B avec la solution existante (ou la solution d'ingénierie Prompt) sur la tâche pilote. Les indicateurs quantitatifs incluent l'amélioration de la précision, le changement de délai et le coût du GPU. Point d'acceptation clé : si les performances du modèle entraîné sur l'ensemble de validation sont améliorées de plus de 5 % et si le coût de la puissance de calcul se situe dans une plage acceptable.
3. Extension (janvier-mars) : couvrez davantage de scénarios commerciaux, établissez un pipeline standardisé de préparation des données → formation → évaluation → déploiement, et introduisez la gestion des expériences et le contrôle des versions des modèles.

Prix des produits

LLaMA-Factory elle-même est entièrement open source et gratuite (licence Apache-2.0), mais les coûts impliqués dans le processus d'utilisation se concentrent sur les niveaux suivants :

Type de coût	Individu/Chercheur	Équipe de développement	Entreprise
Licence de logiciel	Gratuit	Gratuit	Gratuit
Puissance de calcul GPU	Sur demande 0,5 à 5 $/heure	Mensuel 500-5000 $	Cluster privé + exploitation et maintenance
Préparation des données	Utiliser des ensembles de données publiques	Annotation + main d'œuvre de nettoyage	Plateforme d'annotation + revue de conformité
Gestion des expériences	Version gratuite Colab/W&B	Hébergement W&B/MLflow	Plateforme d'expérimentation auto-construite
Déploiement et exploitation	Docker autonome	K8 + CI/CD	Passerelle d'inférence + surveillance
Évaluation du modèle	Manuel + script simple	Pipeline d'évaluation automatisée	Évaluation multidimensionnelle + tests de l'équipe rouge

Restrictions de licence open source : La licence Apache-2.0 autorise une utilisation commerciale, mais vous devez faire attention aux restrictions de licence du modèle de base affiné lui-même (telles que la licence Meta de LLaMA, la licence Google de Gemma, la licence Alibaba de Qwen). La licence du modèle de base peut contenir des conditions supplémentaires (telles que la nécessité de demander une autorisation commerciale si les utilisateurs actifs mensuels dépassent le seuil, l'interdiction d'utilisation dans des secteurs spécifiques, etc.), et ces restrictions sont indépendantes de la licence LLaMA-Factory.

Conseil sur les coûts cachés : bien que LLaMA-Factory abaisse le seuil technique pour un réglage précis unique, la gestion de la qualité des données est souvent l'élément de coût le plus important dans les projets réels - les modèles formés avec des données de faible qualité nécessitent un réglage précis itératif répété. Bien que le coût d’une seule expérience soit faible, les coûts cumulés du GPU et de la main d’œuvre peuvent être bien plus élevés que prévu.

Scénarios d'application de LLaMA-Factory

• Personnalisation du modèle interne : injectez le corpus de l'industrie (finance, droit, médecine, fabrication) dans des modèles généraux pour améliorer la précision de la compréhension des scénarios verticaux. Par exemple, les institutions financières doivent faire en sorte que les modèles comprennent la terminologie des rapports financiers et les exigences de conformité réglementaire. L'injection de 500 à 5 000 conversations sur le terrain via SFT peut améliorer considérablement cela. Dans de tels scénarios, la stratégie QLoRA de LLaMA-Factory peut réduire les coûts de personnalisation de plusieurs centaines de milliers de yuans à des milliers de yuans.
• Distillation des connaissances et amélioration des petits modèles : utilisez de grands modèles (tels que DeepSeek-R1, GPT-4o) pour générer des données d'instructions de haute qualité, puis utilisez LLaMA-Factory pour affiner les petits modèles (tels que Qwen3-4B, Gemma-2B) afin d'améliorer les performances des petits modèles sur des tâches spécifiques tout en maintenant la vitesse d'inférence. Ceci est particulièrement utile dans les scénarios de déploiement hors ligne ou en périphérie où les appels aux API externes ne sont pas autorisés.
• Personnalisation du modèle multimodal : réglage fin multimodal de domaine de modèles de langage visuel tels que Qwen2.5-VL et InternVL, adapté à des tâches telles que la compréhension des graphiques, le post-traitement OCR et la génération de rapports d'imagerie médicale. LLaMA-Factory couvre uniformément les entrées de formation textuelle et multimodale, éliminant le besoin de basculer entre plusieurs cadres.
• Alignement des préférences et contrôle de sécurité : utilisez des stratégies d'alignement des préférences telles que DPO/PPO/KTO pour ajuster la sortie du modèle afin de se conformer aux spécifications commerciales et aux exigences de sécurité. Il convient à des scénarios tels que l'examen du contenu, la conformité linguistique du service client et le ton de marque unifié. L'alignement des préférences nécessite des ensembles de données de préférences appariées (bonnes/mauvaises réponses), et la méthode KTO intégrée de LLaMA-Factory peut compléter l'alignement avec uniquement des données de « bonnes réponses ».
• Recherche et construction de référence : les équipes académiques doivent exécuter des évaluations unifiées sur plusieurs modèles. Le système de configuration unifié de LLaMA-Factory peut standardiser les variables expérimentales (modèles, ensembles de données, hyperparamètres) et améliorer la reproductibilité des résultats expérimentaux.

Points clés de la vérification de la scène : Avant de choisir LLaMA-Factory, assurez-vous de confirmer "si un réglage fin est vraiment nécessaire". Si l’ingénierie Prompt + RAG suffit, le rapport coût-rendement du réglage fin peut être négatif. La fenêtre de valeur pour un réglage précis se situe dans les scénarios où « un format/style/connaissance spécifique doit être appris et ne peut pas être accompli via des invites contextuelles ».

Groupes applicables de LLaMA-Factory

• Ingénieurs en algorithmes et chercheurs en ML : nécessité de comparer fréquemment les différences de performances de différents modèles sur la même tâche, ou de vérifier l'effet de nouvelles stratégies de formation. L'entrée unifiée à LLaMA-Factory peut standardiser les expériences et réduire les biais dans les conclusions causés par les différences dans les scripts. Pour ce type d’utilisateur, la ligne de commande YAML est plus efficace que l’interface utilisateur Web.
• MLOps et équipe de plateforme : le processus de formation doit être standardisé, automatisé et intégré aux outils de plateforme tels que CI/CD, le suivi des expériences et l'enregistrement des modèles. Les capacités de déploiement d'API de LLaMA-Factory et les images Docker le rendent adapté à l'intégration dans les pipelines MLOps.
• Développeurs indépendants et petites équipes : Scénarios avec un budget limité mais nécessitant une personnalisation du modèle. Avec QLoRA + cloud GPU, une expérience de réglage fin du domaine peut être réalisée pour quelques dollars par jour. La combinaison de Google Colab Free Edition + LLaMA-Factory rend possible un démarrage sans budget.
• Équipe de recherche académique : Un cadre de formation open source reproductible est nécessaire pour soutenir les expériences de thèse. L'article de LLaMA-Factory a été publié dans ACL 2024. La communauté est active et convient comme plate-forme pédagogique et expérimentale.

Ne correspond pas aux limites :

• Si l'objectif de l'équipe est simplement d'appeler une API modèle standard, sans formation ni réglage fin, LLaMA-Factory ne convient pas.
• Si l'équipe a besoin de cycles de formation profondément personnalisés (tels que des fonctions de perte personnalisées, des stratégies de planification spéciales), la couche d'abstraction de LLaMA-Factory peut devenir une limitation, et il est préférable d'utiliser directement PyTorch + Transformers.
• Si l'équipe a besoin de pré-entraîner un modèle de 100 milliards de paramètres à partir de zéro, il est recommandé d'utiliser directement Megatron-LM ou NeMo. L'objectif de conception de LLaMA-Factory est un réglage précis plutôt qu'une pré-formation à grande échelle.
• Si l'équipe ne dispose pas de ressources GPU ou de budget cloud, même si QLoRA abaisse le seuil, une seule expérience nécessite toujours au moins 4 Go de mémoire vidéo, ce qui rend la formation CPU pure irréaliste.

Résumé et Outlook

La valeur fondamentale de LLaMA-Factory est d'unifier les exigences de formation « multi-modèle, multi-stratégie et multi-modalité » dans un seul cadre, de remplacer le codage de script par une configuration YAML et de réduire la personnalisation du modèle de « exiger des instructions de formation manuscrites » à « modifier les fichiers de configuration ». Il présente des avantages évidents en termes de rapidité de suivi écologique (adaptation jour 0 des nouveaux modèles) et d'échelle communautaire dans le cadre de formation open source. La prise en charge de plusieurs backends matériels tels que Huawei Ascend NPU et AMD ROCm élargit également ses limites de déploiement.

Limites actuelles :

• La formation dépend profondément de l'écosystème Hugging Face et offre une prise en charge limitée pour les modèles avec une architecture non Transformers.
• La mise en œuvre de l'alignement des préférences (PPO/DPO) convient aux expériences à petite et moyenne échelle, et le RLHF au niveau de la production à grande échelle doit encore être complété par des cadres d'apprentissage par renforcement externe.
• Le site de documentation officielle est toujours marqué comme WIP (Work in Progress), et certaines fonctions avancées ne sont pas bien documentées. Lorsque vous rencontrez des problèmes, vous devez vous appuyer sur les problèmes GitHub et les discussions de la communauté.
• Le soutien commercial et les SLA ne sont pas divulgués, et les achats au niveau de l'entreprise doivent évaluer si le soutien communautaire répond aux exigences de production.

Évaluation des risques d'approvisionnement/d'adoption :

• Si l'équipe dispose déjà d'une infrastructure MLOps (enregistrement de modèle, suivi des expériences, planification de cluster GPU), LLaMA-Factory peut être rapidement intégrée en tant que couche de formation légère. Il est recommandé d'utiliser 1 à 2 scénarios commerciaux à titre pilote pendant 2 à 4 semaines, en se concentrant sur la vérification des trois indicateurs d'amélioration de l'effet de formation, de consommation d'énergie de calcul et de fréquence d'intervention manuelle.
• Si l'équipe construit des capacités de formation à partir de zéro, les coûts cachés (gouvernance des données, gestion des expériences, évaluation du modèle) peuvent dépasser de loin le coût d'apprentissage de l'outil lui-même. Il est recommandé de confirmer d’abord si les normes de qualité et d’évaluation des données sont en place avant de sélectionner un cadre.
• Avant le déploiement en production, assurez-vous de vérifier si la licence du modèle de base utilisée pour le réglage fin couvre les scénarios d'utilisation attendus, en particulier la limite mensuelle d'utilisateurs actifs et les conditions de licence commerciale. Cette partie du risque de conformité est indépendante de LLaMA-Factory, mais affecte directement si les résultats de la formation peuvent être mis en ligne.

Outils associés : Visage câlin, replicate

Informations de version

• v0.9.5 ：Les notes de version officielles incluent les mises à jour d'adaptation liées à Qwen3.5/3.6, Gemma 4 et Transformers v5. （2026-05-30）
• v0.9.4 ：La version principale annuelle entreprend l’itération stable des capacités de réglage fin multi-modèles. （2025-12-31）
• v0.9.3 ：Les notes de version couvrent Llama4, Gemma3, Qwen3, InternVL3, Qwen2.5-Omni et d'autres modèles pris en charge. （2025-06-16）