LALAME AFFICHÉ

Les modèles de petits langues (SLM) ont un impact significatif dans l'IA. Ils offrent des performances solides tout en étant efficaces et rentables. Un exemple hors concours est le LLAMA 3.2 3b. Il fonctionne exceptionnellement bien dans les tâches de génération (RAG) de récupération (RAG), réduisant les coûts de calcul et l'utilisation de la mémoire tout en maintenant une grande précision. Cet article explore comment affiner le modèle LLAMA 3.2 3B. Découvrez comment les modèles plus petits peuvent exceller dans les tâches de chiffon et repousser les limites de ce que les solutions d'IA compactes peuvent atteindre.

Table des matières

• Qu'est-ce que Llama 3.2 3b?
• Finetuning Llama 3.2 3b
• Lora
• Bibliothèques requises
• Importer les bibliothèques
• Initialiser le modèle et les tokeniseurs
• Initialiser le modèle de PEFT
• Informatique
• Configuration des paramètres de l'entraîneur
• Affiner le modèle
• Tester et enregistrer le modèle
• Conclusion
• Questions fréquemment posées

Qu'est-ce que Llama 3.2 3b?

Le modèle LLAMA 3.2 3B, développé par Meta, est un SLM multilingue avec 3 milliards de paramètres, conçu pour des tâches telles que la réponse aux questions, le résumé et les systèmes de dialogue. Il surpasse de nombreux modèles open source sur les références de l'industrie et soutient diverses langues. Disponible en différentes tailles, LLAMA 3.2 offre des performances de calcul efficaces et comprend des versions quantifiées pour un déploiement plus rapide et économe en mémoire dans des environnements mobiles et bords.

Lire aussi: les 13 meilleurs modèles de petits langues (SLMS)

Finetuning Llama 3.2 3b

Le réglage fin est essentiel pour adapter le SLM ou les LLM à des domaines ou des tâches spécifiques, tels que les applications médicales, juridiques ou de chiffon. Alors que la pré-formation permet aux modèles linguistiques de générer du texte sur divers sujets, le réglage fin recroqueville le modèle sur les données spécifiques au domaine ou spécifiques à la tâche pour améliorer la pertinence et les performances. Pour aborder le coût de calcul élevé de la réglage fin de tous les paramètres, des techniques telles que les paramètres efficaces au réglage fin (PEFT) se concentrent sur la formation uniquement d'un sous-ensemble des paramètres du modèle, en optimisant l'utilisation des ressources tout en maintenant les performances.

Lora

L'une de ces méthodes PEFT est l'adaptation à faible rang (LORA).

Dans LORA, la matrice de poids dans SLM ou LLM est décomposée en un produit de deux matrices de bas rang.

 W = wa * wb

Si w a des lignes M et N colonnes, alors elle peut être décomposée en WA avec des lignes et des colonnes R, et WB avec des lignes R et n colonnes. Ici R est beaucoup moins que m ou n. Ainsi, plutôt que de former des valeurs m * n, nous ne pouvons entraîner que les valeurs R * (Mn). R est appelé rang qui est l'hyperparamètre que nous pouvons choisir.

 Def lora_linear (x):<br> h = x @ w # Linear régulier<br> h = échelle * (x @ w_a @ w_b) # Mise à jour de faible rang<br> retour h

Découvrez: le réglage fin économe en paramètres de modèles de grande langue avec Lora et Qlora

Implémentons Lora sur le modèle 3B LLAMA 3.2.

Bibliothèques requises

• Usres - 2024.12.9
• ensembles de données - 3.1.0

L'installation de la version paresseuse ci-dessus installera également les bibliothèques compatibles Pytorch, Transformers et Nvidia GPU. Nous pouvons utiliser Google Colab pour accéder au GPU.

Regardons la mise en œuvre maintenant!

Importer les bibliothèques

 Depuis peu importe FastLanguageModel, IS_BFLOAT16_SUPPORTED, TRAMENT_ON_RESPONSES_ONLY

à partir des ensembles de données Importer Load_dataset, ensemble de données

De TRL Import Sfttrainer, APPLICATION_CHAT_TEMPLAT

De Transformers Import TrainingArguments, DataCollatorforseQ2Seq, TextStreamer

Importer une torche

Initialiser le modèle et les tokeniseurs

 max_seq_length = 2048 
DTYPE = Aucun # Aucun pour la détection automatique.
load_in_4bit = true # Utilisez la quantification 4 bits pour réduire l'utilisation de la mémoire. Peut être faux.

modèle, tokenizer = fastLanguageModel.from_pretraind (
	Model_name = "Unsloth / llama-3.2-3b-instructe",
	max_seq_length = max_seq_length,
	dtype = dtype,
	load_in_4bit = load_in_4bit,
	# token = "hf _...", # Utiliser si vous utilisez des modèles fermés comme Meta-Lama / Llama-3.2-11b
)

Pour les autres modèles pris en charge par un peu, nous pouvons nous référer à ce document.

Initialiser le modèle de PEFT

 modèle = fastLanguageModel.get_peft_model (
	modèle,
	r = 16,
	cible_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                  	"gate_proj", "up_proj", "down_proj",],
	lora_alpha = 16,
	lora_dropout = 0, 
	biais = "aucun",
	use_gradient_checkpointing = "Unsloth",
	random_state = 42,
	use_rslora = false, 
	loftq_config = aucun,
)

Description de chaque paramètre

• R : Rang de Lora; Des valeurs plus élevées améliorent la précision mais utilisent plus de mémoire (suggérée: 8–128).
• Target_Modules : modules pour affiner; Incluez tout pour de meilleurs résultats
• lora_alpha : facteur de mise à l'échelle; généralement égal ou double le rang r.
• lora_dropout : taux d'abandon; réglé sur 0 pour une formation optimisée et plus rapide.
• biais : type de biais; «Aucun» est optimisé pour la vitesse et le sur-ajustement minimal.
• use_gradient_checkpointing : réduit la mémoire pour la formation à long contexte; «Unnuh» est fortement recommandé.
• Random_State : graine pour les courses déterministes, garantissant des résultats reproductibles (par exemple, 42).
• use_rslora : automatise la sélection alpha; Utile pour Lora stabilisé au rang.
• LOFTQ_CONFIG : Initialise LORA avec les vecteurs singuliers Top R pour une meilleure précision, bien que la mémoire.

Informatique

Nous utiliserons les données de chiffon pour Finetune. Téléchargez les données de HuggingFace.

 DataSet = Load_Dataset ("Neural-Bridge / Rag-Dataset-1200", Split = "Train")

L'ensemble de données a trois clés comme suit:

Ensemble de données ({fonctionnalités: [«contextes», «question», «réponse»], num_rows: 960})

Les données doivent être dans un format spécifique en fonction du modèle de langue. Lisez plus de détails ici .

Alors, convertissons les données en format requis:

 def convert_dataset_to_dict (ensemble de données):
    dataSet_DICT = {
        "rapide": [],
        "achèvement": []
    }

    pour la ligne dans l'ensemble de données:
        user_content = f "Context: {row ['context']} \ nQuestion: {row ['question']}"
        Assistant_Content = Row ['Response']

        dataset_dict ["invite"].
            {"rôle": "utilisateur", "contenu": user_content}
        ])
        dataset_dict ["complétion"].
            {"Role": "Assistant", "Content": Assistant_Content}
        ])
    return dataSet_Dict
    
    
converti_data = convert_dataset_to_dict (ensemble de données)
dataSet = dataSet.from_dict (convertid_data)
dataSet = dataSet.map (application_chat_template, fn_kwargs = {"tokenizer": tokenizer})

Le message de l'ensemble de données sera le suivant:

Configuration des paramètres de l'entraîneur

Nous pouvons initialiser l'entraîneur pour la fin de la SLM:

 Trainer = sfttrainer (
	modèle = modèle,
	tokenizer = tokenizer,
	Train_dataset = ensemble de données,
	max_seq_length = max_seq_length,
	data_collator = datacollatorforseq2seq (tokenizer = tokenizer),
	dataset_num_proc = 2,
	Emballage = false, # peut rendre la formation 5x plus rapidement pour les séquences courtes.
	Args = TrainingArguments (
    	per_device_train_batch_size = 2,
    	gradient_accumulation_steps = 4,
    	warmup_steps = 5,
    	# num_train_epochs = 1, # définissez-le pour 1 exécution complète de formation.
    	max_steps = 6, # en utilisant un petit nombre pour tester
    	apprentissage_rate = 2e-4,
    	fp16 = not is_bfloat16_supported (),
    	bf16 = is_bfloat16_supported (),
    	logging_steps = 1,
    	optim = "adamw_8bit",
    	poids_decay = 0,01,
    	lr_scheduler_type = "linéaire",
    	graine = 3407,
    	output_dir = "sorties",
    	report_to = "Aucun", # Utilisez-le pour wandb etc.
	),
)

Description de certains des paramètres:

• per_device_train_batch_size: taille du lot par périphérique; Augmentez pour utiliser plus de mémoire GPU mais surveillez les inefficacités de rembourrage (suggéré: 2).
• gradient_accumulation_steps: simule des tailles de lots plus grandes sans utilisation de mémoire supplémentaire; Augmentation pour les courbes de perte plus lisses (suggérées: 4).
• Max_steps: étapes de formation totale; Définissez des exécutions plus rapides (par exemple, 60), ou utilisez `num_train_epochs` pour les passes de données complètes (par exemple, 1–3).
• Learning_rate: contrôle la vitesse de formation et la convergence; Des taux inférieurs (par exemple, 2E-4) améliorent la précision mais la formation lente.

Faites le train de modèle sur les réponses uniquement en spécifiant le modèle de réponse:

 Trainer = Train_on_Responses_Only (
	entraîneur,
	instruction_PART = " utilisateur  \ n \ n",
	Response_Part = " Assistant  \ n \ n",
)

Affiner le modèle

 Trainer_Stats = Trainer.Train ()

Voici les statistiques de formation:

Tester et enregistrer le modèle

Utilisons le modèle pour l'inférence:

 FastLanguageModel.For_inference (modèle)

messages = [
	{"rôle": "utilisateur", "contenu": "Contexte: le ciel est généralement clair pendant la journée. Question: Quelle est la couleur de l'eau?"},
]]
entrées = tokenizer.apply_chat_template (
	messages,
	tokenize = true,
	add_generation_prompt = true,
	return_tensers = "pt",
) .To ("Cuda")

text_streamer = textStreamer (tokenizer, skip_prompt = true)
_ = modèle.generate (input_ids = entrées, streamer = text_streamer, max_new_tokens = 128,
               	use_cache = true, température = 1,5, min_p = 0,1)

Pour économiser les poids formés, y compris les poids Lora, utilisez le code ci-dessous

 Model.save_pretraned_merged ("modèle", tokenizer, sauve_method = "Merged_16bit")

Découvrez: Guide des modèles de grande langue au réglage fin

Conclusion

LALAME FIEUX 3.2 3B pour les tâches de chiffon présente l'efficacité des modèles plus petits dans la fourniture de performances élevées avec des coûts de calcul réduits. Des techniques comme LORA optimisent l'utilisation des ressources tout en maintenant la précision. Cette approche permet des applications spécifiques au domaine, rendant une IA avancée plus accessible, évolutive et rentable, ce qui stimule l'innovation dans la génération et la démocratisation de l'IA pour la récupération pour les défis du monde réel.

Lire aussi: commencer avec Meta Llama 3.2

Questions fréquemment posées

Q1. Qu'est-ce que le chiffon?

A. RAG combine les systèmes de récupération avec des modèles génératifs pour améliorer les réponses en les ancrant dans les connaissances externes, ce qui le rend idéal pour des tâches telles que la réponse aux questions et le résumé.

Q2. Pourquoi choisir Llama 3.2 3b pour le réglage fin?

A. LLAMA 3.2 3B offre un équilibre entre les performances, l'efficacité et l'évolutivité, ce qui le rend adapté aux tâches de chiffon tout en réduisant les exigences de calcul et de mémoire.

Q3. Qu'est-ce que Lora et comment améliore-t-il le réglage fin?

A. L'adaptation de faible rang (LORA) minimise l'utilisation des ressources en formant uniquement des matrices de bas rang au lieu de tous les paramètres du modèle, permettant un réglage fin efficace sur le matériel contraint.

Q4. Quel ensemble de données est utilisé pour le réglage fin dans cet article?

A. Hugging Face fournit l'ensemble de données RAG, qui contient du contexte, des questions et des réponses, pour affiner le modèle LLAMA 3.2 3B pour une meilleure performance des tâches.

Q5. Le modèle affiné peut-il être déployé sur des appareils Edge?

A. Oui, LLAMA 3.2 3B, en particulier dans sa forme quantifiée, est optimisée pour un déploiement économe en mémoire sur les environnements Edge et Mobile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!