Update Guide.md

Update Guide.md

Create 1_Besoins.md

Update Guide.md

Create 2_Deja_Fait_Admin.md

Create 3_Acculturation.md

Create 4_Impacts.md

Create 1_Revue_Technique_LLM.md

Create 2_RAG.md

Create 3_Evaluations.md

Create 1_Socle_minimal.md

Create 2_Socle_avance.md

Create 3_Socle_Production.md

Create 4_Infras_administrations.md

Added ressources for "Acculturation des agents"

Ce sont deux présentations à faire en 30 minutes chacune. Nous avons des "learning Lunchs" à la dtnum, peut-être avez vous une occasion semblable pour faire découvrir ce sujet. En tout cas, voici des supports

Ajout de mon administration

Objectif partie besoins

Update README.md

Added self to list

Add files via upload

Ajout cas d'usage

cas d'usage expérimenté actuellement à la BdF

Update 1_Socle_minimal.md

First draft
Un peu abrupte, à retravailler, mais les éléments sont là

Update 1_Socle_minimal.md

Update 1_Socle_minimal.md

Update 1_Socle_minimal.md

Update 3_Socle_Production.md

Add files via upload

Create ressources

Delete III-Deploiements/ressources

Update 2_Socle_avance.md

Add files via upload

Update 3_Socle_Production.md

Update 1_Socle_minimal.md

Update 2_Socle_avance.md

Add files via upload

Update 2_Socle_avance.md

Update 4_Impacts.md

Proposition pour la section impacts environnementaux

fix typo sur la partie deploiement, déplacement de fichiers dans des répertoires dédiées (images,ressources)

add finetuning part

Update README.md

Added draft for section evaluation

Update Guide.md add an existing benchmark

Update Guide.md

passage à quarto et deploiement CI/CD

Update 3_Socle_Production.qmd

Update 1_Socle_minimal.qmd

Update 3_Socle_Production.qmd

Update 1_Socle_minimal.qmd

.github/workflows/main.yaml

@@ -0,0 +1,30 @@
+on:
+  workflow_dispatch:
+  push:
+    branches: main
+
+name: Quarto Publish
+
+jobs:
+  build-deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Update runner
+        run: |
+            sudo apt-get update
+            sudo apt-get install libcurl4-openssl-dev
+            sudo apt-get install libharfbuzz-dev libfribidi-dev libfontconfig1-dev
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Quarto
+        uses: quarto-dev/quarto-actions/setup@v2
+
+      - name: Render and Publish
+        uses: quarto-dev/quarto-actions/publish@v2
+        with:
+          target: gh-pages
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Guide.md

@@ -1,42 +1,84 @@
 # Guide du LLM
 
-## Identifier clairement le besoin (Johnny / Hélène)
+## PARTIE I. Accompagnement au changement
 
-* besoin
+### 1. Besoins (Johnny Hélène)
 
-* données (collecter)
+	Vision high level de l'intérêt des LLMs
 
-## Environnement institutionnel et informatique (Katia / Bruno)
+### 2. Ce qui est déjà fait dans l’administration (Johnny Hélène Thibault)
 
-* juridique de chaque admin
+	cas d’usage
+ 	des infras
+  	des modeles
+   	des datasets/open data ?
 
-* infra (sspcloud et autres clouds)
+### 3. Besoin d’Acculturation (Supports!) (Johnny Hélène CamilleB)
 
-## Benchmark LLM (Zhanna / Malo)
+	Comment embarquer les métiers/personnels moins techniques
+ 	Points d'attention à partager sur l'utilisation de tels outils
 
-* typologie LLM / choix non exhaustif de LLM testé ici
+### 4. Impacts et limites (Katia Bruno Hélène)
 
-### Evaluation avant finetuning (Daphné)
+	a. Environnementaux (poids de l’entraînement, poids de l’utilisation)
+
+	b. Légaux (RGPD, chartes de l’IA, IA Act, ...)
+
+	c. Sécurité (Renvoyer vers le guide de l’ANSSI)
 
-* libraire d'eval ?
-* librarie d'annotation (label studio / autres)
 
-### Finetuning (ev.) et évaluation post-finetuning (Conrad )
+## PARTIE II. Développements autour des LLMs (pour les data scientists)
 
-* Trainer (TRL)
-* qlora
+### 1. Revue technique de l’état de l’art LLM (Malo Jérôme)
 
-## Benchmark RAG (Johnny / )
+	a. Architectures principales LLM
+
+	b. Méthodes de fine-tuning  (Conrad)
+
+	c. Prompt engineer (lien vers prompt guide)
+
+	d. Quoi faire quand ? (arbre de décision)
 
-* Librairie utilisée (RAG : Langchain/LLamaindex)
+### 2. RAG (Hugo Malo Jérôme Daphné Katia)
 
-* Techniques autour des LLM (RAG,parser)
+	a. pipelines,
 
+ 	b. Benchmark des différentes bases vectorielles (Katia)
+
+	c. presentations de modules avec RETEX, CODE!)
 
-## Production (Camille Brier / Conrad / Jérôme)
+### 3. Évaluations (Zhanna Daphné)
 
-* docker (image) et déploiement de l'image sur un cluster (Sspcloud ou autre) / pc local
+	a. Métriques (biais, hallucinations, ...)
+
+	b. Datasets
+
+	c. Librairies/Frameworks (CODE!)
+
+	d. Méthodologie (arbre de décision pour le décideur)
 
-* vllm en api (back)
+### PARTIE III. Deploiements
 
-* streamlit/dash et autres lib (front)
+### 1. Socle minimal pour un LLM (Camille Jérôme Conrad)
+
+	a. vLLM + docker ? (CODE!)
+
+### 2. Socle avancé (Camille Jérôme Conrad)
+
+	Optimisation, Monitoring, UX/UI (CODE!)
+
+### 3. Socle pour production (Camille Jérôme Conrad)
+
+	Orchestrateur (CODE!)
+
+	Nvidia etc.
+
+### 4. Infras dispos pour l’administration (Thibault Katia)
+
+	SSP Cloud (Onyxia)
+
+	Cloud PI
+
+	Clouds privés (SECNUMCLOUD, Sens?)
+
+	(NuboNyxia à terme)

I-Accompagnement/1_Besoins.qmd

@@ -0,0 +1,16 @@
+# Guide du LLM
+
+## PARTIE I. Accompagnement au changement
+
+### 1. Besoins (Johnny Hélène)
+
+	Vision high level de l'intérêt des LLMs
+
+Les cas d'usages des LLMs sont variés et avant de se lancer et innover grâce aux LLMs, il est nécessaire de bien identifier le besoin qui amène l'utilisation d'un LLM. Pour quoi faire ? Pour quels usages ? Est-ce pour de la génération de texte ? Pour de la classification ?
+L'objectif de ce chapitre est d'accompagner la réflexion autour de l'identification du besoin et de la collecte des données, avec les différents types de cas d'usages impliquant des LLMs.
+
+ Les cas d'usages :
+
+ * cas d'usages autour de la génération de contenu
+ * cas d'usage autour de la classification et de la recherche de contenu
+ * cas d'usage autour des interactions conversationnelles

I-Accompagnement/2_Deja_Fait_Admin.qmd

@@ -0,0 +1,13 @@
+# Guide du LLM
+
+## PARTIE I. Accompagnement au changement
+
+### 2. Ce qui est déjà fait ou expérimenté dans l’administration (Johnny Hélène Thibault)
+
+	cas d’usage
+* Dans une enquête incluant un champ « Commentaire », celui-ci peut être analysé par des LLMs afin d’identifier les thématiques saillantes exprimées dans ce champ. Ensuite, pour chacune de ces thématiques, les LLMs peuvent être utilisés pour dégager le sentiment prédominant (ex : positif, négatif, neutre) associé à chacune d’entre elles. In fine, grâce aux LLMs, le champ « Commentaire » peut ainsi être divisé en un nombre N de thématiques, et, pour chacune de ces thématiques, un contenu peut être généré afin de faire ressortir le sentiment majoritaire des répondants à l’enquête.
+
+  des infras
+  des modeles
+  des datasets/open data ?
+

I-Accompagnement/3_Acculturation.qmd

@@ -0,0 +1,8 @@
+# Guide du LLM
+
+## PARTIE I. Accompagnement au changement
+
+### 3. Besoin d’Acculturation (Supports!) (Johnny Hélène CamilleB)
+
+	Comment embarquer les métiers/personnels moins techniques
+ 	Points d'attention à partager sur l'utilisation de tels outils

I-Accompagnement/4_Impacts.qmd

@@ -0,0 +1,26 @@
+# Guide du LLM
+
+## PARTIE I. Accompagnement au changement
+
+### 4. Impacts (Katia Bruno Hélène)
+
+	a. Environnementaux (poids de l’entraînement, poids de l’utilisation)
+
+Le numérique est responsable de 2,5% de l’empreinte carbone de la France (17,2 Mt de CO2e & 20 millions de tonnes de déchets) selon l’étude [ARCEP & ADEME de 2023](https://www.arcep.fr/uploads/tx_gspublication/note-synthese-au-gouvernement-prospective-2030-2050_mars2023.pdf). Par contre, il n’existe aucun référentiel à ce jour pour mesurer l’impact environnemental des projets d’intelligence artificielle. À titre d'exemple, les émissions liées à l'entraînement de GPT-3 sont estimées à 552 tonnes de CO2eq [1] et son utilisation en janvier 2023 représenterait 10 113 tonnes de CO2eq [2]. Les ressources en eau, métaux et d'autres matériaux pour la fabrication et opération des infrastructures sont également conséquents. 
+
+Afin de permettre aux acteurs du numérique d’évaluer l’impact environnemental de leurs projets d’intelligence artificielle, et de communiquer sur le caractère frugal de ces derniers, l'Ecolab du MTECT prépare avec l'AFNOR un [document de référence](https://normalisation.afnor.org/nos-solutions/afnor-spec/intelligence-artificielle-frugale/), qui devra être disponible en juillet.
+
+À l'heure actuelle, pour estimer la consommation énergétique et les émissions de CO2 liées à l’exécution du code, les data-scientists peuvent utiliser la librairie [CodeCarbon](https://github.com/mlco2/codecarbon), à mettre en place avant l'usage, et/ou [Green Algorithms](https://www.green-algorithms.org/), qui peut être utilisé pour estimer un usage futur ou passé.
+
+Le coût environnementale lié aux infrastructures de calcul est mis à disposition par le groupe EcoInfo du CNRS à travers l'outil [EcoDiag](https://ecoinfo.cnrs.fr/ecodiag-calcul/). Des estimations plus précises pour la fabrication de GPUs seront disponibles prochainement.
+
+[1] https://arxiv.org/pdf/2104.10350.pdf
+
+[2] [Data For Good - Livre Blanc de l'IA Générative](https://issuu.com/dataforgood/docs/dataforgood_livreblanc_iagenerative_v1.0?fr=sZGE0MjYyNjE5MTU)
+
+
+
+	b. Légaux (RGPD, chartes de l’IA, IA Act, ...)
+
+	c. Sécurité (Renvoyer vers le guide de l’ANSSI)
+

II-Developpements/1_Revue_Technique_LLM.qmd

@@ -0,0 +1,127 @@
+# 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).
+
+	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()
+
+# 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)

II-Developpements/2_RAG.qmd

@@ -0,0 +1,9 @@
+# Guide du LLM
+
+## PARTIE II. Développements autour des LLMs (pour les data scientists)
+
+### 2. RAG (Hugo Malo Jérôme Daphné)
+
+	a. pipelines,
+
+	b. presentations de modules avec RETEX, CODE!)