diff --git a/.nojekyll b/.nojekyll index 906ebcd..6626cc1 100644 --- a/.nojekyll +++ b/.nojekyll @@ -1 +1 @@ -a6d60d5a \ No newline at end of file +26a880a5 \ No newline at end of file diff --git a/II-Developpements/1_Revue_Technique_LLM.html b/II-Developpements/1_Revue_Technique_LLM.html index 082b3b8..e96c2ba 100644 --- a/II-Developpements/1_Revue_Technique_LLM.html +++ b/II-Developpements/1_Revue_Technique_LLM.html @@ -6,8 +6,10 @@ + + -Guide d’installation des LLM +Guide d’installation des LLM - Guide du LLM @@ -217,76 +253,171 @@

On this page

+
+
+

Guide du LLM

+
-
-

Guide du LLM

-
-

PARTIE II. Développements autour des LLMs (pour les data scientists)

-
-

1. Revue technique de l’état de l’art LLM (Malo Jérôme)

-
a. Architectures principales LLM
-
-b. Méthodes de fine-tuning  (Conrad)
-
-Les LLM sont des réseaux de neurones de taille importante et font l'objet d'entraînement avec des ressources colossales (*e.g*: quelques dizaines de milliers de GPUs dernier modèle pendant 3 mois pour `GPT-4`). L'entraînement permet d'apprendre un jeu de données particulier, en réglant l'ensemble des poids du modèles (*e.g*: `Mixtral 8x22B` est une architecture à 141 milliards de poids; 175 milliards pour `GPT-3`). Les LLM sont entraînés à répondre à plusieurs tâches génériques et ne sont pas forcément pertinent pour des cas d'utilisation particulier.
-
-Pour répondre à ce besoin, plusieurs méthodes relevant du principe de fine-tuning sont possibles. Le fine-tuning consiste à reprendre un modèle déjà entraîné et à l'adapter sur un jeu de données particulier sur une ou plusieurs tâches spécifiques. En général, il s'agit de modifier une partie ou l'ensemble des poids pour que le modèle soit plus précis pour les tâches voulues. Le fine-tuning garde en grande partie les bénéfices de l'entraînement initial, *i.e* les connaissances antérieurs déjà apprises. Repartir d'un modèle déjà entraîné pourra réduire le temps d'entraînement requis pour le fine-tuning, en fonction de la similarité entre la nouvelle tâche souhaitée et son jeu de données et les entraînements précédents.
+

 
-Pour des petits modèles de langages, il est possible de ré-entraîner en modifiant l'ensemble des poids. Pour des modèles plus grands, modifier l'ensemble des poids peut s'avérer couteux en temps et en GPUs. Plusieurs approches permettent de ré-entraîner à moindre coût :
-* réentrainer seulement un sous-ensemble de poids
-* modifier la tête de modélisation de la langue (`lm_head`) pour certains modèles, soit en réentrainant depuis les poids entraînés, soit en réinitialisant ces poids.
-* garder l'intégralité du modèle et rajouter des poids à entraîner puis utiliser l'approximation de bas rang avec `LORA` (`Low-Rank Adaptation`) pour l'entraînement et l'inférence.
-* utiliser des versions quantisées, i.e. des modèles où les poids ont été tronqués à une précision inférieure (possibilité de combiner avec la technique précédente, sous le nom de qLORA).
+    

+    
Author

+    

+             
équipe KALLM 

+          

+  

+    
+    

+    
Published

+    

+      
June 7, 2024

+    

+  

+  
+    
+  

+  
 
-Entraînement avec qLORA en pratique :
 
-En plus de la librairie `transformers` et `datasets`, les librairies `peft`, `bitsandbytes` et `trl` permettent de simplifier l'entraînement avec qLORA
+
-(inspiré du [notebook suivant](https://www.kaggle.com/code/kingabzpro/mistral-7b-instruct-4bit-qlora-fine-tuning) ) -```python -

%%capture %pip install -U bitsandbytes %pip install -U transformers %pip install -U peft %pip install -U trl %pip install -U sentencepiece %pip install -U protobuf

-

from transformers import AutoModelForCausalLM, AutoTokenizer,TrainingArguments from peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model from datasets import load_dataset import torch from trl import SFTTrainer

-

base_model = “teknium/OpenHermes-2.5-Mistral-7B” new_model = “Mistral-7b-instruct-teletravail”

-

path_to_training_file=“Dataset_public_accords_teletravail_Dares_train.parquet” path_to_test_file=“Dataset_public_accords_teletravail_Dares_test.parquet”

-

dataset=load_dataset(“parquet”, data_files={‘train’: path_to_training_file, ‘test’: path_to_test_file})

-

bnb_config = BitsAndBytesConfig( load_in_4bit= True, bnb_4bit_quant_type= “nf4”, bnb_4bit_compute_dtype= torch.bfloat16, bnb_4bit_use_double_quant= False, )

-

model = AutoModelForCausalLM.from_pretrained( base_model, quantization_config=bnb_config, torch_dtype=torch.bfloat16, device_map=“auto”, trust_remote_code=True, ) model.config.use_cache = False # silence the warnings. Please re-enable for inference! model.config.pretraining_tp = 1 model.gradient_checkpointing_enable()

+
+

PARTIE II. Développements autour des LLMs (pour les data scientists)

+
+

1. Revue technique de l’état de l’art LLM (Malo Jérôme)

+
+

a. Architectures principales LLM

+
+

b. Méthodes de fine-tuning (Conrad)

+

Les LLM sont des réseaux de neurones de taille importante et font l’objet d’entraînement avec des ressources colossales (e.g: quelques dizaines de milliers de GPUs dernier modèle pendant 3 mois pour GPT-4). L’entraînement permet d’apprendre un jeu de données particulier, en réglant l’ensemble des poids du modèles (e.g: Mixtral 8x22B est une architecture à 141 milliards de poids; 175 milliards pour GPT-3). Les LLM sont entraînés à répondre à plusieurs tâches génériques et ne sont pas forcément pertinent pour des cas d’utilisation particulier.

+

Pour répondre à ce besoin, plusieurs méthodes relevant du principe de fine-tuning sont possibles. Le fine-tuning consiste à reprendre un modèle déjà entraîné et à l’adapter sur un jeu de données particulier sur une ou plusieurs tâches spécifiques. En général, il s’agit de modifier une partie ou l’ensemble des poids pour que le modèle soit plus précis pour les tâches voulues. Le fine-tuning garde en grande partie les bénéfices de l’entraînement initial, i.e les connaissances antérieures déjà apprises. Repartir d’un modèle déjà entraîné pourra réduire le temps d’entraînement requis pour le fine-tuning, en fonction de la similarité entre la nouvelle tâche souhaitée et son jeu de données et les entraînements précédents.

+

Pour des petits modèles de langages, il est possible de ré-entraîner en modifiant l’ensemble des poids. Pour des modèles plus grands, modifier l’ensemble des poids peut s’avérer couteux en temps et en GPUs. Plusieurs approches permettent de ré-entraîner à moindre coût :

+
    +
  • réentrainer seulement un sous-ensemble de poids
    • +
  • modifier la tête de modélisation de la langue (lm_head) pour certains modèles, soit en réentrainant depuis les poids entraînés, soit en réinitialisant ces poids.
    • +
  • garder l’intégralité du modèle et rajouter des poids à entraîner puis utiliser l’approximation de bas rang avec LORA (Low-Rank Adaptation) pour l’entraînement et l’inférence.
    • +
  • utiliser des versions quantisées, i.e. des modèles où les poids ont été tronqués à une précision inférieure (possibilité de combiner avec la technique précédente, sous le nom de qLORA).
    • +
+

Entraînement avec qLORA en pratique :

+

En plus de la librairie transformers et datasets, les librairies peft, bitsandbytes et trl permettent de simplifier l’entraînement avec qLORA

+

(inspiré du notebook suivant )

+
%%capture
+%pip install -U bitsandbytes
+%pip install -U transformers
+%pip install -U peft
+%pip install -U trl
+%pip install -U sentencepiece
+%pip install -U protobuf
+
+from transformers import AutoModelForCausalLM, AutoTokenizer,TrainingArguments
+from peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model
+from datasets import load_dataset
+import torch
+from trl import SFTTrainer
+
+base_model = "teknium/OpenHermes-2.5-Mistral-7B"
+new_model = "Mistral-7b-instruct-teletravail"
+
+path_to_training_file="Dataset_public_accords_teletravail_Dares_train.parquet"
+path_to_test_file="Dataset_public_accords_teletravail_Dares_test.parquet"
+
+
+dataset=load_dataset("parquet", data_files={'train': path_to_training_file, 'test': path_to_test_file})
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit= True,
+    bnb_4bit_quant_type= "nf4",
+    bnb_4bit_compute_dtype= torch.bfloat16,
+    bnb_4bit_use_double_quant= False,
+)
+
+model = AutoModelForCausalLM.from_pretrained(
+        base_model,
+        quantization_config=bnb_config,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        trust_remote_code=True,
+)
+model.config.use_cache = False # silence the warnings. Please re-enable for inference!
+model.config.pretraining_tp = 1
+model.gradient_checkpointing_enable()
+
+# Load tokenizer
+tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+tokenizer.padding_side = 'right'
+tokenizer.pad_token = tokenizer.eos_token
+tokenizer.add_eos_token = True
+tokenizer.add_bos_token, tokenizer.add_eos_token
+
+
+model = prepare_model_for_kbit_training(model)
+peft_config = LoraConfig(
+    lora_alpha=16,
+    lora_dropout=0.1,
+    r=64,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj","gate_proj"]
+)
+model = get_peft_model(model, peft_config)
+
+training_arguments = TrainingArguments(
+    output_dir="./results",
+    num_train_epochs=1,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=1,
+    optim="paged_adamw_32bit",
+    save_steps=25,
+    logging_steps=25,
+    learning_rate=2e-4,
+    weight_decay=0.001,
+    fp16=False,
+    bf16=False,
+    max_grad_norm=0.3,
+    max_steps=-1,
+    warmup_ratio=0.03,
+    group_by_length=True,
+    lr_scheduler_type="constant",
+)
+
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=dataset["train"],
+    peft_config=peft_config,
+    max_seq_length= None,
+    dataset_text_field="text",
+    tokenizer=tokenizer,
+    args=training_arguments,
+    packing= False,
+)
+
+trainer.train()
+
+trainer.model.save_pretrained(new_model)
+
+

c. Prompt engineer (lien vers prompt guide)

-
-

Load tokenizer

-

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True) tokenizer.padding_side = ‘right’ tokenizer.pad_token = tokenizer.eos_token tokenizer.add_eos_token = True tokenizer.add_bos_token, tokenizer.add_eos_token

-

model = prepare_model_for_kbit_training(model) peft_config = LoraConfig( lora_alpha=16, lora_dropout=0.1, r=64, bias=“none”, task_type=“CAUSAL_LM”, target_modules=[“q_proj”, “k_proj”, “v_proj”, “o_proj”,“gate_proj”] ) model = get_peft_model(model, peft_config)

-

training_arguments = TrainingArguments( output_dir=“./results”, num_train_epochs=1, per_device_train_batch_size=4, gradient_accumulation_steps=1, optim=“paged_adamw_32bit”, save_steps=25, logging_steps=25, learning_rate=2e-4, weight_decay=0.001, fp16=False, bf16=False, max_grad_norm=0.3, max_steps=-1, warmup_ratio=0.03, group_by_length=True, lr_scheduler_type=“constant”, )

-

trainer = SFTTrainer( model=model, train_dataset=dataset[“train”], peft_config=peft_config, max_seq_length= None, dataset_text_field=“text”, tokenizer=tokenizer, args=training_arguments, packing= False, )

-

trainer.train()

-

trainer.model.save_pretrained(new_model)

-
```
-
-
-c. Prompt engineer (lien vers prompt guide)
-
-d. Quoi faire quand ? (arbre de décision)
+
+

d. Quoi faire quand ? (arbre de décision)

+
+
diff --git a/search.json b/search.json index dd8449d..2e0add6 100644 --- a/search.json +++ b/search.json @@ -114,7 +114,7 @@ "href": "II-Developpements/1_Revue_Technique_LLM.html", "title": "Guide du LLM", "section": "", - "text": "a. Architectures principales LLM\n\nb. Méthodes de fine-tuning (Conrad)\n\nLes LLM sont des réseaux de neurones de taille importante et font l'objet d'entraînement avec des ressources colossales (*e.g*: quelques dizaines de milliers de GPUs dernier modèle pendant 3 mois pour `GPT-4`). L'entraînement permet d'apprendre un jeu de données particulier, en réglant l'ensemble des poids du modèles (*e.g*: `Mixtral 8x22B` est une architecture à 141 milliards de poids; 175 milliards pour `GPT-3`). Les LLM sont entraînés à répondre à plusieurs tâches génériques et ne sont pas forcément pertinent pour des cas d'utilisation particulier.\n\nPour répondre à ce besoin, plusieurs méthodes relevant du principe de fine-tuning sont possibles. Le fine-tuning consiste à reprendre un modèle déjà entraîné et à l'adapter sur un jeu de données particulier sur une ou plusieurs tâches spécifiques. En général, il s'agit de modifier une partie ou l'ensemble des poids pour que le modèle soit plus précis pour les tâches voulues. Le fine-tuning garde en grande partie les bénéfices de l'entraînement initial, *i.e* les connaissances antérieurs déjà apprises. Repartir d'un modèle déjà entraîné pourra réduire le temps d'entraînement requis pour le fine-tuning, en fonction de la similarité entre la nouvelle tâche souhaitée et son jeu de données et les entraînements précédents.\n\nPour des petits modèles de langages, il est possible de ré-entraîner en modifiant l'ensemble des poids. Pour des modèles plus grands, modifier l'ensemble des poids peut s'avérer couteux en temps et en GPUs. Plusieurs approches permettent de ré-entraîner à moindre coût :\n* réentrainer seulement un sous-ensemble de poids\n* modifier la tête de modélisation de la langue (`lm_head`) pour certains modèles, soit en réentrainant depuis les poids entraînés, soit en réinitialisant ces poids.\n* garder l'intégralité du modèle et rajouter des poids à entraîner puis utiliser l'approximation de bas rang avec `LORA` (`Low-Rank Adaptation`) pour l'entraînement et l'inférence.\n* utiliser des versions quantisées, i.e. des modèles où les poids ont été tronqués à une précision inférieure (possibilité de combiner avec la technique précédente, sous le nom de qLORA).\n\nEntraînement avec qLORA en pratique :\n\nEn plus de la librairie `transformers` et `datasets`, les librairies `peft`, `bitsandbytes` et `trl` permettent de simplifier l'entraînement avec qLORA\n\n(inspiré du [notebook suivant](https://www.kaggle.com/code/kingabzpro/mistral-7b-instruct-4bit-qlora-fine-tuning) )\n\n```python\n%%capture %pip install -U bitsandbytes %pip install -U transformers %pip install -U peft %pip install -U trl %pip install -U sentencepiece %pip install -U protobuf\nfrom transformers import AutoModelForCausalLM, AutoTokenizer,TrainingArguments from peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model from datasets import load_dataset import torch from trl import SFTTrainer\nbase_model = “teknium/OpenHermes-2.5-Mistral-7B” new_model = “Mistral-7b-instruct-teletravail”\npath_to_training_file=“Dataset_public_accords_teletravail_Dares_train.parquet” path_to_test_file=“Dataset_public_accords_teletravail_Dares_test.parquet”\ndataset=load_dataset(“parquet”, data_files={‘train’: path_to_training_file, ‘test’: path_to_test_file})\nbnb_config = BitsAndBytesConfig( load_in_4bit= True, bnb_4bit_quant_type= “nf4”, bnb_4bit_compute_dtype= torch.bfloat16, bnb_4bit_use_double_quant= False, )\nmodel = AutoModelForCausalLM.from_pretrained( base_model, quantization_config=bnb_config, torch_dtype=torch.bfloat16, device_map=“auto”, trust_remote_code=True, ) model.config.use_cache = False # silence the warnings. Please re-enable for inference! model.config.pretraining_tp = 1 model.gradient_checkpointing_enable()", + "text": "Les LLM sont des réseaux de neurones de taille importante et font l’objet d’entraînement avec des ressources colossales (e.g: quelques dizaines de milliers de GPUs dernier modèle pendant 3 mois pour GPT-4). L’entraînement permet d’apprendre un jeu de données particulier, en réglant l’ensemble des poids du modèles (e.g: Mixtral 8x22B est une architecture à 141 milliards de poids; 175 milliards pour GPT-3). Les LLM sont entraînés à répondre à plusieurs tâches génériques et ne sont pas forcément pertinent pour des cas d’utilisation particulier.\nPour répondre à ce besoin, plusieurs méthodes relevant du principe de fine-tuning sont possibles. Le fine-tuning consiste à reprendre un modèle déjà entraîné et à l’adapter sur un jeu de données particulier sur une ou plusieurs tâches spécifiques. En général, il s’agit de modifier une partie ou l’ensemble des poids pour que le modèle soit plus précis pour les tâches voulues. Le fine-tuning garde en grande partie les bénéfices de l’entraînement initial, i.e les connaissances antérieures déjà apprises. Repartir d’un modèle déjà entraîné pourra réduire le temps d’entraînement requis pour le fine-tuning, en fonction de la similarité entre la nouvelle tâche souhaitée et son jeu de données et les entraînements précédents.\nPour des petits modèles de langages, il est possible de ré-entraîner en modifiant l’ensemble des poids. Pour des modèles plus grands, modifier l’ensemble des poids peut s’avérer couteux en temps et en GPUs. Plusieurs approches permettent de ré-entraîner à moindre coût :\n\nréentrainer seulement un sous-ensemble de poids\nmodifier la tête de modélisation de la langue (lm_head) pour certains modèles, soit en réentrainant depuis les poids entraînés, soit en réinitialisant ces poids.\ngarder l’intégralité du modèle et rajouter des poids à entraîner puis utiliser l’approximation de bas rang avec LORA (Low-Rank Adaptation) pour l’entraînement et l’inférence.\nutiliser des versions quantisées, i.e. des modèles où les poids ont été tronqués à une précision inférieure (possibilité de combiner avec la technique précédente, sous le nom de qLORA).\n\nEntraînement avec qLORA en pratique :\nEn plus de la librairie transformers et datasets, les librairies peft, bitsandbytes et trl permettent de simplifier l’entraînement avec qLORA\n(inspiré du notebook suivant )\n%%capture\n%pip install -U bitsandbytes\n%pip install -U transformers\n%pip install -U peft\n%pip install -U trl\n%pip install -U sentencepiece\n%pip install -U protobuf\n\nfrom transformers import AutoModelForCausalLM, AutoTokenizer,TrainingArguments\nfrom peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model\nfrom datasets import load_dataset\nimport torch\nfrom trl import SFTTrainer\n\nbase_model = \"teknium/OpenHermes-2.5-Mistral-7B\"\nnew_model = \"Mistral-7b-instruct-teletravail\"\n\npath_to_training_file=\"Dataset_public_accords_teletravail_Dares_train.parquet\"\npath_to_test_file=\"Dataset_public_accords_teletravail_Dares_test.parquet\"\n\n\ndataset=load_dataset(\"parquet\", data_files={'train': path_to_training_file, 'test': path_to_test_file})\n\nbnb_config = BitsAndBytesConfig(\n load_in_4bit= True,\n bnb_4bit_quant_type= \"nf4\",\n bnb_4bit_compute_dtype= torch.bfloat16,\n bnb_4bit_use_double_quant= False,\n)\n\nmodel = AutoModelForCausalLM.from_pretrained(\n base_model,\n quantization_config=bnb_config,\n torch_dtype=torch.bfloat16,\n device_map=\"auto\",\n trust_remote_code=True,\n)\nmodel.config.use_cache = False # silence the warnings. Please re-enable for inference!\nmodel.config.pretraining_tp = 1\nmodel.gradient_checkpointing_enable()\n\n# Load tokenizer\ntokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)\ntokenizer.padding_side = 'right'\ntokenizer.pad_token = tokenizer.eos_token\ntokenizer.add_eos_token = True\ntokenizer.add_bos_token, tokenizer.add_eos_token\n\n\nmodel = prepare_model_for_kbit_training(model)\npeft_config = LoraConfig(\n lora_alpha=16,\n lora_dropout=0.1,\n r=64,\n bias=\"none\",\n task_type=\"CAUSAL_LM\",\n target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",\"gate_proj\"]\n)\nmodel = get_peft_model(model, peft_config)\n\ntraining_arguments = TrainingArguments(\n output_dir=\"./results\",\n num_train_epochs=1,\n per_device_train_batch_size=4,\n gradient_accumulation_steps=1,\n optim=\"paged_adamw_32bit\",\n save_steps=25,\n logging_steps=25,\n learning_rate=2e-4,\n weight_decay=0.001,\n fp16=False,\n bf16=False,\n max_grad_norm=0.3,\n max_steps=-1,\n warmup_ratio=0.03,\n group_by_length=True,\n lr_scheduler_type=\"constant\",\n)\n\ntrainer = SFTTrainer(\n model=model,\n train_dataset=dataset[\"train\"],\n peft_config=peft_config,\n max_seq_length= None,\n dataset_text_field=\"text\",\n tokenizer=tokenizer,\n args=training_arguments,\n packing= False,\n)\n\ntrainer.train()\n\ntrainer.model.save_pretrained(new_model)", "crumbs": [ "II-Developpements", "Revue technique des LLM" @@ -125,7 +125,7 @@ "href": "II-Developpements/1_Revue_Technique_LLM.html#partie-ii.-développements-autour-des-llms-pour-les-data-scientists", "title": "Guide du LLM", "section": "", - "text": "a. Architectures principales LLM\n\nb. Méthodes de fine-tuning (Conrad)\n\nLes LLM sont des réseaux de neurones de taille importante et font l'objet d'entraînement avec des ressources colossales (*e.g*: quelques dizaines de milliers de GPUs dernier modèle pendant 3 mois pour `GPT-4`). L'entraînement permet d'apprendre un jeu de données particulier, en réglant l'ensemble des poids du modèles (*e.g*: `Mixtral 8x22B` est une architecture à 141 milliards de poids; 175 milliards pour `GPT-3`). Les LLM sont entraînés à répondre à plusieurs tâches génériques et ne sont pas forcément pertinent pour des cas d'utilisation particulier.\n\nPour répondre à ce besoin, plusieurs méthodes relevant du principe de fine-tuning sont possibles. Le fine-tuning consiste à reprendre un modèle déjà entraîné et à l'adapter sur un jeu de données particulier sur une ou plusieurs tâches spécifiques. En général, il s'agit de modifier une partie ou l'ensemble des poids pour que le modèle soit plus précis pour les tâches voulues. Le fine-tuning garde en grande partie les bénéfices de l'entraînement initial, *i.e* les connaissances antérieurs déjà apprises. Repartir d'un modèle déjà entraîné pourra réduire le temps d'entraînement requis pour le fine-tuning, en fonction de la similarité entre la nouvelle tâche souhaitée et son jeu de données et les entraînements précédents.\n\nPour des petits modèles de langages, il est possible de ré-entraîner en modifiant l'ensemble des poids. Pour des modèles plus grands, modifier l'ensemble des poids peut s'avérer couteux en temps et en GPUs. Plusieurs approches permettent de ré-entraîner à moindre coût :\n* réentrainer seulement un sous-ensemble de poids\n* modifier la tête de modélisation de la langue (`lm_head`) pour certains modèles, soit en réentrainant depuis les poids entraînés, soit en réinitialisant ces poids.\n* garder l'intégralité du modèle et rajouter des poids à entraîner puis utiliser l'approximation de bas rang avec `LORA` (`Low-Rank Adaptation`) pour l'entraînement et l'inférence.\n* utiliser des versions quantisées, i.e. des modèles où les poids ont été tronqués à une précision inférieure (possibilité de combiner avec la technique précédente, sous le nom de qLORA).\n\nEntraînement avec qLORA en pratique :\n\nEn plus de la librairie `transformers` et `datasets`, les librairies `peft`, `bitsandbytes` et `trl` permettent de simplifier l'entraînement avec qLORA\n\n(inspiré du [notebook suivant](https://www.kaggle.com/code/kingabzpro/mistral-7b-instruct-4bit-qlora-fine-tuning) )\n\n```python\n%%capture %pip install -U bitsandbytes %pip install -U transformers %pip install -U peft %pip install -U trl %pip install -U sentencepiece %pip install -U protobuf\nfrom transformers import AutoModelForCausalLM, AutoTokenizer,TrainingArguments from peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model from datasets import load_dataset import torch from trl import SFTTrainer\nbase_model = “teknium/OpenHermes-2.5-Mistral-7B” new_model = “Mistral-7b-instruct-teletravail”\npath_to_training_file=“Dataset_public_accords_teletravail_Dares_train.parquet” path_to_test_file=“Dataset_public_accords_teletravail_Dares_test.parquet”\ndataset=load_dataset(“parquet”, data_files={‘train’: path_to_training_file, ‘test’: path_to_test_file})\nbnb_config = BitsAndBytesConfig( load_in_4bit= True, bnb_4bit_quant_type= “nf4”, bnb_4bit_compute_dtype= torch.bfloat16, bnb_4bit_use_double_quant= False, )\nmodel = AutoModelForCausalLM.from_pretrained( base_model, quantization_config=bnb_config, torch_dtype=torch.bfloat16, device_map=“auto”, trust_remote_code=True, ) model.config.use_cache = False # silence the warnings. Please re-enable for inference! model.config.pretraining_tp = 1 model.gradient_checkpointing_enable()", + "text": "Les LLM sont des réseaux de neurones de taille importante et font l’objet d’entraînement avec des ressources colossales (e.g: quelques dizaines de milliers de GPUs dernier modèle pendant 3 mois pour GPT-4). L’entraînement permet d’apprendre un jeu de données particulier, en réglant l’ensemble des poids du modèles (e.g: Mixtral 8x22B est une architecture à 141 milliards de poids; 175 milliards pour GPT-3). Les LLM sont entraînés à répondre à plusieurs tâches génériques et ne sont pas forcément pertinent pour des cas d’utilisation particulier.\nPour répondre à ce besoin, plusieurs méthodes relevant du principe de fine-tuning sont possibles. Le fine-tuning consiste à reprendre un modèle déjà entraîné et à l’adapter sur un jeu de données particulier sur une ou plusieurs tâches spécifiques. En général, il s’agit de modifier une partie ou l’ensemble des poids pour que le modèle soit plus précis pour les tâches voulues. Le fine-tuning garde en grande partie les bénéfices de l’entraînement initial, i.e les connaissances antérieures déjà apprises. Repartir d’un modèle déjà entraîné pourra réduire le temps d’entraînement requis pour le fine-tuning, en fonction de la similarité entre la nouvelle tâche souhaitée et son jeu de données et les entraînements précédents.\nPour des petits modèles de langages, il est possible de ré-entraîner en modifiant l’ensemble des poids. Pour des modèles plus grands, modifier l’ensemble des poids peut s’avérer couteux en temps et en GPUs. Plusieurs approches permettent de ré-entraîner à moindre coût :\n\nréentrainer seulement un sous-ensemble de poids\nmodifier la tête de modélisation de la langue (lm_head) pour certains modèles, soit en réentrainant depuis les poids entraînés, soit en réinitialisant ces poids.\ngarder l’intégralité du modèle et rajouter des poids à entraîner puis utiliser l’approximation de bas rang avec LORA (Low-Rank Adaptation) pour l’entraînement et l’inférence.\nutiliser des versions quantisées, i.e. des modèles où les poids ont été tronqués à une précision inférieure (possibilité de combiner avec la technique précédente, sous le nom de qLORA).\n\nEntraînement avec qLORA en pratique :\nEn plus de la librairie transformers et datasets, les librairies peft, bitsandbytes et trl permettent de simplifier l’entraînement avec qLORA\n(inspiré du notebook suivant )\n%%capture\n%pip install -U bitsandbytes\n%pip install -U transformers\n%pip install -U peft\n%pip install -U trl\n%pip install -U sentencepiece\n%pip install -U protobuf\n\nfrom transformers import AutoModelForCausalLM, AutoTokenizer,TrainingArguments\nfrom peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model\nfrom datasets import load_dataset\nimport torch\nfrom trl import SFTTrainer\n\nbase_model = \"teknium/OpenHermes-2.5-Mistral-7B\"\nnew_model = \"Mistral-7b-instruct-teletravail\"\n\npath_to_training_file=\"Dataset_public_accords_teletravail_Dares_train.parquet\"\npath_to_test_file=\"Dataset_public_accords_teletravail_Dares_test.parquet\"\n\n\ndataset=load_dataset(\"parquet\", data_files={'train': path_to_training_file, 'test': path_to_test_file})\n\nbnb_config = BitsAndBytesConfig(\n load_in_4bit= True,\n bnb_4bit_quant_type= \"nf4\",\n bnb_4bit_compute_dtype= torch.bfloat16,\n bnb_4bit_use_double_quant= False,\n)\n\nmodel = AutoModelForCausalLM.from_pretrained(\n base_model,\n quantization_config=bnb_config,\n torch_dtype=torch.bfloat16,\n device_map=\"auto\",\n trust_remote_code=True,\n)\nmodel.config.use_cache = False # silence the warnings. Please re-enable for inference!\nmodel.config.pretraining_tp = 1\nmodel.gradient_checkpointing_enable()\n\n# Load tokenizer\ntokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)\ntokenizer.padding_side = 'right'\ntokenizer.pad_token = tokenizer.eos_token\ntokenizer.add_eos_token = True\ntokenizer.add_bos_token, tokenizer.add_eos_token\n\n\nmodel = prepare_model_for_kbit_training(model)\npeft_config = LoraConfig(\n lora_alpha=16,\n lora_dropout=0.1,\n r=64,\n bias=\"none\",\n task_type=\"CAUSAL_LM\",\n target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",\"gate_proj\"]\n)\nmodel = get_peft_model(model, peft_config)\n\ntraining_arguments = TrainingArguments(\n output_dir=\"./results\",\n num_train_epochs=1,\n per_device_train_batch_size=4,\n gradient_accumulation_steps=1,\n optim=\"paged_adamw_32bit\",\n save_steps=25,\n logging_steps=25,\n learning_rate=2e-4,\n weight_decay=0.001,\n fp16=False,\n bf16=False,\n max_grad_norm=0.3,\n max_steps=-1,\n warmup_ratio=0.03,\n group_by_length=True,\n lr_scheduler_type=\"constant\",\n)\n\ntrainer = SFTTrainer(\n model=model,\n train_dataset=dataset[\"train\"],\n peft_config=peft_config,\n max_seq_length= None,\n dataset_text_field=\"text\",\n tokenizer=tokenizer,\n args=training_arguments,\n packing= False,\n)\n\ntrainer.train()\n\ntrainer.model.save_pretrained(new_model)", "crumbs": [ "II-Developpements", "Revue technique des LLM" diff --git a/sitemap.xml b/sitemap.xml index c6e0f3c..30691ce 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -2,50 +2,50 @@ https://etalab.github.io/programme10pourcent-kallm/III-Deploiements/3_Socle_Production.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/III-Deploiements/2_Socle_avance.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/I-Accompagnement/4_Impacts.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/I-Accompagnement/3_Acculturation.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/II-Developpements/3_Evaluations.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/II-Developpements/1_Revue_Technique_LLM.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/Guide.html - 2024-06-06T14:42:40.620Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/II-Developpements/2_RAG.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/I-Accompagnement/1_Besoins.html - 2024-06-06T14:42:40.620Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/I-Accompagnement/2_Deja_Fait_Admin.html - 2024-06-06T14:42:40.620Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/III-Deploiements/4_Infras_administrations.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z https://etalab.github.io/programme10pourcent-kallm/III-Deploiements/1_Socle_minimal.html - 2024-06-06T14:42:40.624Z + 2024-06-07T10:13:47.220Z