# Les LLM et les techniques de prompt > Page d'accueil de la compétence: [[Générer du code]] > [!tip] Tags > #GénérationDeCode #IAGénérative #LLM #Programmation #Développement #PromptEngineering #Prompting > [!NOTE] Fil directeur > Ce chapitre posera les bases solides de votre compréhension des fonctions. Nous allons définir précisément ce qu'est une fonction, explorer les contraintes qui déterminent son "domaine de vie", et passer en revue les fonctions élémentaires qui constituent les briques de toute modélisation complexe. Une maîtrise de ces concepts est indispensable pour aborder sereinement les chapitres futurs, notamment sur la dérivation et l'intégration. > [!example] Contenu de ce cours > - Comprendre les principes de base du fonctionnement des LLM. > - Appréhender l'importance d'un *prompt* bien structuré. > - Maîtriser les principales techniques de *prompting* (Zero-shot, Few-shot, Chain-of-Thought, etc.). > - Développer une approche critique et itérative de la conception de *prompts*. # Rappels sur le fonctionnement d'un LLM Avant de nous lancer dans les techniques de *prompting*, il est crucial de se remémorer brièvement ce qu'est un LLM et comment il fonctionne. Cela nous aidera à mieux comprendre pourquoi certaines techniques sont plus efficaces que d'autres. > [!definition] Large Language Model (LLM) > Un **Large Language Model (LLM)** est un type de modèle de langage basé sur l'architecture *Transformer*, entraîné sur d'immenses corpus de données textuelles et de code. Sa fonction principale est de prédire le prochain mot (ou *token*) dans une séquence, ce qui lui permet de générer du texte cohérent et contextuellement pertinent, de traduire, de résumer, de répondre à des questions, et bien plus encore. ## Architecture et Entraînement Comme vu dans le cours d'Introduction à l'IA Générative, les LLM sont fondamentalement des réseaux de neurones profonds, principalement basés sur l'architecture **Transformer**. * **Pré-entraînement :** Les modèles sont d'abord entraînés sur des quantités massives de texte (des milliards, voire des milliers de milliards de *tokens*) provenant d'internet (livres, articles, pages web, etc.). Lors de cette phase, le modèle apprend les relations statistiques entre les mots, la grammaire, la sémantique et même une certaine forme de "connaissance du monde" encodée dans le texte. * **Fine-tuning (Réglage fin) :** Après le pré-entraînement, les modèles subissent souvent une phase de *fine-tuning* sur des tâches spécifiques (par exemple, la conversation, la génération de code) et sont alignés avec les intentions humaines via des techniques comme le *Reinforcement Learning from Human Feedback* (RLHF). ## Le Principe de Prédiction du Prochain Token Au cœur du fonctionnement d'un LLM se trouve un processus probabiliste : étant donné une séquence de mots d'entrée (le *prompt*), le modèle calcule la probabilité de chaque mot possible de la langue pour être le prochain mot de la séquence. Il sélectionne ensuite le mot le plus probable (ou échantillonne parmi les plus probables) et répète le processus. Considérons l'exemple simple : "Le ciel est..." Le LLM va calculer des probabilités pour des mots comme "bleu", "nuageux", "gris", "grand", etc. Si $P(\text{bleu} | \text{Le ciel est}) = 0.8$, $P(\text{nuageux} | \text{Le ciel est}) = 0.15$, et d'autres mots ont des probabilités très faibles, le modèle choisira très probablement "bleu". Ce processus itératif de prédiction et d'ajout du mot généré à la séquence d'entrée est ce qui permet aux LLM de générer des réponses longues et cohérentes. > [!note] Les "Tokens" > Les LLM ne traitent pas directement les mots, mais des unités appelées *tokens*. Un *token* peut être un mot entier, une partie de mot, un caractère de ponctuation, ou même un espace. Par exemple, "ordinateur" est un *token*, mais "superordinateur" pourrait être "super" + "ordinateur". La tokenisation est la première étape du traitement de l'entrée. ## Limites et Précautions Malgré leur puissance, les LLM présentent des limites importantes dont il faut être conscient : * **Hallucinations :** Les LLM peuvent générer des informations fausses mais présentées de manière très convaincante. Ils ne "savent" pas ce qui est vrai ou faux, ils génèrent ce qui est statistiquement plausible. * **Biais :** Étant entraînés sur des données existantes, les LLM peuvent reproduire et amplifier les biais présents dans ces données (stéréotypes, préjugés). * **Manque de raisonnement profond :** Les LLM excellent dans la reconnaissance de motifs et la génération de texte, mais ils ne "comprennent" pas le monde comme un être humain. Leur raisonnement est une simulation basée sur des corrélations statistiques. * **Contexte limité :** La "fenêtre de contexte" (la quantité de texte que le modèle peut traiter en une seule fois) est finie. Les informations en dehors de cette fenêtre sont "oubliées". > [!warning] Fiabilité des LLM > Ne considérez jamais la sortie d'un LLM comme une vérité absolue. Toujours vérifier les faits, surtout pour des informations critiques ou sensibles. # Prompting : L'art et la science de l'interaction Le *prompting* est l'ensemble des techniques et des stratégies utilisées pour concevoir les entrées (les *prompts*) des LLM afin d'obtenir les sorties désirées. C'est une compétence cruciale car la qualité de la sortie du LLM est directement proportionnelle à la qualité du *prompt*. ## Qu'est-ce qu'un Prompt ? > [!definition] Prompt > Un **prompt** est l'instruction ou la question textuelle que l'on soumet à un Large Language Model pour le guider dans la génération d'une réponse. Il peut inclure des consignes, des exemples, du contexte, et des contraintes de format. ## Principes Fondamentaux d'un Prompt Efficace Un bon *prompt* est clair, spécifique et fournit suffisamment de contexte. Voici les éléments clés à considérer : 1. **Clarté et Spécificité :** Évitez l'ambiguïté. Soyez aussi précis que possible sur ce que vous attendez. * *Mauvais prompt :* "Écris quelque chose sur les voitures." (Trop vague) * *Bon prompt :* "Rédige un paragraphe de 100 mots décrivant les avantages des véhicules électriques pour l'environnement, en utilisant un ton informatif et accessible au grand public." 2. **Contexte :** Fournissez toutes les informations nécessaires au LLM pour qu'il puisse générer une réponse pertinente. * Si vous voulez un résumé d'un article, incluez l'article. Si vous voulez une réponse à une question, donnez les informations de base. 3. **Rôle ou Persona :** Demandez au LLM d'adopter un rôle ou une personnalité spécifique. Cela peut grandement influencer le style et le contenu de la réponse. * "Agis comme un expert en cybersécurité..." * "Tu es un professeur de littérature..." 4. **Format de Sortie :** Spécifiez le format dans lequel vous souhaitez recevoir la réponse (liste, JSON, Markdown, tableau, code Python, etc.). * "Génère une liste à puces des étapes..." * "Fournis la réponse au format JSON avec les clés 'titre' et 'contenu'..." 5. **Contraintes :** Définissez des limites sur la longueur, le ton, le style, le vocabulaire, etc. * "La réponse ne doit pas dépasser 50 mots." * "Utilise un langage formel et évite les acronymes." > [!example] Prompt Structuré > ``` > Tu es un assistant spécialisé en gestion de projet. > Ton rôle est de fournir des conseils concis et actionnables. > > Question : Quelles sont les trois étapes clés pour démarrer un nouveau projet agile ? > > Fournis une liste numérotée, chaque point ne dépassant pas une phrase. > Le ton doit être professionnel et direct. > ``` ## Techniques Avancées de Prompting Au-delà des principes fondamentaux, il existe des techniques plus élaborées pour optimiser les performances des LLM. ### Zero-shot Prompting C'est la forme la plus simple de *prompting*. Vous posez une question ou donnez une instruction sans fournir d'exemple. Le modèle utilise ses connaissances pré-entraînées pour générer une réponse. > [!example] Zero-shot Prompt > ``` > Traduis la phrase suivante en français : "The quick brown fox jumps over the lazy dog." > ``` ### Few-shot Prompting Avec le *few-shot prompting*, vous incluez quelques exemples d'entrées et de sorties attendues directement dans le *prompt*. Cela aide le modèle à comprendre le motif ou la tâche que vous attendez. C'est particulièrement utile pour des tâches spécifiques ou des formats complexes. > [!note] Apprentissage "In-context" > Le *few-shot prompting* n'est pas un *fine-tuning*. Le modèle n'est pas modifié ; il utilise les exemples comme un "apprentissage en contexte" pour mieux comprendre la tâche *dans la session actuelle*. > [!example] Few-shot Prompt > ``` > Convertis le texte en JSON. > > Texte : Nom: Alice, Age: 30, Ville: Paris > JSON : {"Nom": "Alice", "Age": 30, "Ville": "Paris"} > > Texte : Nom: Bob, Age: 25, Ville: Londres > JSON : {"Nom": "Bob", "Age": 25, "Ville": "Londres"} > > Texte : Nom: Charlie, Age: 35, Ville: Berlin > JSON : > ``` > *Sortie attendue :* `{"Nom": "Charlie", "Age": 35, "Ville": "Berlin"}` ### Chain-of-Thought (CoT) Prompting Cette technique encourage le LLM à "réfléchir à voix haute" et à décomposer un problème complexe en étapes intermédiaires. Cela améliore considérablement la capacité du modèle à résoudre des problèmes de raisonnement, arithmétiques ou logiques. L'ajout de la phrase "Pensons étape par étape" ou "Raisonnez en détail" est souvent suffisant. > [!example] Chain-of-Thought Prompt (Calcul simple) > **Sans CoT :** > ``` > Question : Si j'ai 5 pommes et que j'en donne 2 à mon ami, puis j'en achète 3 de plus, combien de pommes ai-je au total ? > ``` > *Sortie possible (moins fiable) :* "6" > > **Avec CoT :** > ``` > Question : Si j'ai 5 pommes et que j'en donne 2 à mon ami, puis j'en achète 3 de plus, combien de pommes ai-je au total ? > Pensons étape par étape. > ``` > *Sortie probable :* > "1. J'ai commencé avec 5 pommes. > 2. J'en ai donné 2, donc $5 - 2 = 3$ pommes. > 3. J'en ai acheté 3 de plus, donc $3 + 3 = 6$ pommes. > Au total, j'ai 6 pommes." La décomposition en étapes permet au LLM de suivre un chemin de raisonnement plus structuré, réduisant ainsi les erreurs. ### Retrieval Augmented Generation (RAG) Le RAG est une technique avancée qui combine les LLM avec des systèmes de récupération d'informations (comme des bases de données ou des moteurs de recherche). Au lieu de se fier uniquement à ses connaissances internes (qui peuvent être obsolètes ou incorrectes), le LLM est d'abord alimenté avec des documents pertinents récupérés dynamiquement. > [!tip] Importance du RAG pour les Ingénieurs > Le RAG est fondamental pour construire des applications d'IA générative fiables et vérifiables. Il permet de réduire les hallucinations, d'intégrer des données en temps réel ou propriétaires, et d'améliorer la traçabilité des réponses. C'est une compétence que vous approfondirez dans des cours futurs. **Comment ça marche (simplifié) :** 1. L'utilisateur pose une question. 2. Un système de récupération d'informations recherche des documents pertinents dans une base de connaissances externe (par exemple, la documentation technique de votre entreprise). 3. Ces documents pertinents sont ajoutés au *prompt* de l'utilisateur. 4. Le LLM reçoit le *prompt* enrichi des documents et génère une réponse basée sur ces informations. > [!example] RAG (Conceptuel) > **Prompt sans RAG :** "Quel est le protocole de sécurité pour l'accès VPN de l'entreprise ?" > *Problème :* Le LLM pourrait halluciner ou donner une réponse générique. > > **Prompt avec RAG :** > (Documents récupérés : "Politique d'Accès VPN V3.1.pdf", "Guide de Configuration VPN.docx") > ``` > En te basant sur les documents suivants : > > --- Début Document 1 --- > [Contenu du "Politique d'Accès VPN V3.1.pdf"] > --- Fin Document 1 --- > > --- Début Document 2 --- > [Contenu du "Guide de Configuration VPN.docx"] > --- Fin Document 2 --- > > Question : Quel est le protocole de sécurité recommandé pour l'accès VPN de l'entreprise, et quelles sont les étapes pour le configurer ? > ``` > *Avantage :* Le LLM répondra avec des informations précises et vérifiables, extraites des documents fournis. ## Évaluation et Itération des Prompts Le *prompting* est rarement un succès du premier coup. C'est un processus itératif d'expérimentation, d'évaluation et d'amélioration. 1. **Testez :** Envoyez votre *prompt* au LLM et observez la sortie. 2. **Évaluez :** La sortie est-elle pertinente ? Complète ? Dans le bon format ? Respecte-t-elle les contraintes ? 3. **Raffine :** Modifiez votre *prompt* en fonction de l'évaluation. Changez la formulation, ajoutez du contexte, spécifiez le rôle, ajustez les contraintes. 4. **Répétez :** Continuez le cycle jusqu'à obtenir la qualité de sortie désirée. > [!tip] Versioning des Prompts > Pour des applications critiques, il est judicieux de versionner vos *prompts* comme vous le feriez pour du code. Cela permet de suivre les améliorations et de revenir à des versions antérieures si nécessaire. ## Bonnes Pratiques et Pièges à Éviter | Bonnes Pratiques | Pièges à Éviter | | :----------------------------------------------- | :---------------------------------------------------- | | Soyez clair, concis et explicite. | Soyez vague ou ambigu. | | Fournissez un contexte suffisant. | Assumez que le LLM "sait" ce que vous voulez dire. | | Spécifiez le format de sortie désiré. | Ne donnez aucune directive de format. | | Définissez un rôle ou une persona pour le LLM. | Laissez le LLM choisir son ton ou son style. | | Utilisez des exemples (few-shot) si nécessaire. | Attendez des résultats parfaits en zero-shot pour des tâches complexes. | | Décomposez les tâches complexes (CoT). | Demandez des réponses directes à des problèmes complexes. | | Itérez et testez vos prompts. | Pensez que le premier prompt sera le bon. | | Validez les informations générées. | Faites confiance aveuglément aux réponses du LLM. | > [!warning] Prompt Injection > C'est une vulnérabilité de sécurité où un utilisateur malveillant manipule le LLM en insérant des instructions dans son entrée pour lui faire ignorer les instructions initiales ou effectuer des actions non désirées. Par exemple, un utilisateur pourrait tenter de faire divulguer des informations sensibles ou de générer du contenu inapproprié. Des techniques de *prompt engineering* robustes et des gardes-fous sont nécessaires pour mitiger ce risque. # ➡️ C'est la fin **Prochaines étapes :** Les concepts abordés ici, notamment le RAG, serviront de base solide pour des compétences futures où vous apprendrez à intégrer les LLM dans des systèmes logiciels plus larges et à les utiliser pour résoudre des problèmes d'ingénierie concrets. --- - Cours précèdent: `cours-de-départ` - Prochain cours: [[Cours 2 - Générer du code]] - Page d'accueil de la compétence: [[Générer du code]] # 🗓️ Historique - Dernière MAJ: `04-Septembre-2025` - Rédigé par: [[Hamilton DE ARAUJO]]