# Produire un outil numérique à l'aide d'un LLM > 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 #Automatisation #Productivité #Python #Code > [!NOTE] Fil directeur > L'objectif de ce chapitre est de vous fournir les méthodologies et les bonnes pratiques pour exploiter efficacement les LLM dans diverses taches quotidiennes et d'un ingénieur. Nous mettrons l'accent sur l'ingénierie des prompts, la vérification critique des sorties, et les considérations éthiques et de sécurité. Préparez-vous à transformer votre approche de la production numérique ! > [!example] Contenu de ce cours > - **La production de présentations (PPTX)** : Comment structurer et générer le contenu textuel de vos supports. > - **La structuration et la rédaction de documents écrits** : De l'ébauche au rapport final. > - **La génération de code Python** : Pour créer des programmes simples ou des outils de calcul. # Les LLM comme assistants à la production de contenu structuré ## Génération de présentations PPTX (contenu textuel) Un LLM ne peut pas générer directement un fichier `.pptx` avec des mises en page graphiques. Cependant, il peut produire le **contenu textuel structuré** (titres, puces, résumés, notes de l'orateur) qui servira de base à votre présentation. > [!tip] La clé est la structuration > Pensez au LLM comme un expert en contenu qui peut vous aider à organiser vos idées et à les formuler de manière concise pour chaque diapositive. ### Stratégies de Prompting pour les présentations Pour obtenir un contenu pertinent, vos prompts doivent être clairs, spécifiques et contextualisés. * **Définissez le sujet et l'objectif :** Quel est le message principal ? * **Spécifiez le public :** Ingénieurs, grand public, direction ? Le ton et le niveau de détail varieront. * **Indiquez le nombre de diapositives ou la durée :** Cela aide le LLM à ajuster la granularité du contenu. * **Précisez la structure souhaitée :** Introduction, points clés, conclusion, appel à l'action. * **Demandez des éléments spécifiques :** Titres de diapositives, puces, notes de l'orateur. > [!example] Exemple de prompt pour une présentation > ``` > Crée-moi le plan et le contenu textuel pour une présentation PowerPoint de 10 diapositives sur "L'impact de l'IA Générative sur l'ingénierie logicielle". > Le public est composé d'étudiants en école d'ingénieurs (1ère année). > Chaque diapositive doit inclure : > - Un titre clair. > - 3 à 5 points clés sous forme de puces. > - Une suggestion de note de l'orateur (2-3 phrases). > Structure : Introduction, 3-4 points d'impact majeurs, défis, opportunités, conclusion, Q&A. > ``` ### Affinement et Relecture Le contenu généré par le LLM est une **première ébauche**. Il est crucial de : * **Vérifier la pertinence et l'exactitude** des informations. * **Adapter le style et le ton** à votre propre voix et au contexte spécifique. * **Ajouter des exemples concrets** ou des données spécifiques que le LLM ne peut pas inventer de manière fiable. * **Penser aux visuels** : Le LLM ne les génère pas, mais le contenu textuel peut vous inspirer pour choisir des images, graphiques ou schémas pertinents. ## Structuration et rédaction de documents (rapports, articles) Les LLM sont des outils puissants pour vous aider à surmonter la page blanche et à organiser des informations complexes dans des documents structurés comme des rapports techniques, des mémoires ou des articles. ### De l'idée au plan détaillé Un des usages les plus efficaces est la génération de plans. * **Génération de plan :** Fournissez le sujet, l'objectif, le public, la longueur approximative et les sections principales attendues. * **Développement de sections :** Une fois le plan validé, demandez au LLM de développer le contenu de chaque section, paragraphe par paragraphe. > [!example] Exemple de prompt pour un plan de rapport > ``` > Je dois rédiger un rapport technique de 15 pages sur "L'optimisation des performances des systèmes distribués par l'apprentissage automatique". > Le public est composé d'ingénieurs expérimentés en systèmes. > Propose-moi un plan détaillé avec 5 sections principales, chaque section ayant 3-4 sous-sections. > Inclue une introduction, une revue de la littérature, les approches proposées, les résultats attendus/discussions, et une conclusion. > ``` ### Aide à la rédaction et à la reformulation Les LLM peuvent également : * **Rédiger des ébauches de paragraphes :** En lui fournissant des points clés ou des phrases d'accroche. * **Résumer des textes longs :** Utile pour la revue de littérature ou les conclusions. * **Reformuler des phrases :** Pour améliorer la clarté, la concision ou le style. * **Vérifier la grammaire et l'orthographe :** Bien qu'il ne remplace pas un correcteur professionnel, il peut attraper de nombreuses erreurs. > [!note] L'importance de la vérification humaine > Le LLM peut "halluciner" des faits ou des références. **Toute information factuelle générée doit être vérifiée croisée avec des sources fiables.** La responsabilité du contenu final vous incombe. > De plus, le style généré peut être générique. Votre touche personnelle est essentielle pour un document de qualité. # Produire du code avec un LLM : le cas de Python C'est là que les LLM deviennent de véritables assistants pour l'ingénieur, transformant des descriptions textuelles en lignes de code fonctionnelles. Votre connaissance de Python (pré-requis) sera essentielle pour évaluer, modifier et déboguer le code généré. ## Principes fondamentaux de la génération de code par LLM Les LLM ont été entraînés sur d'immenses corpus de texte et de code source (GitHub, Stack Overflow, documentation, etc.). Ils apprennent à identifier des motifs et à générer du code qui correspond à des requêtes en langage naturel. ### Avantages * **Gain de temps :** Automatisation des tâches répétitives, génération rapide de squelettes de code. * **Aide à la découverte :** Exploration de différentes manières de résoudre un problème, suggestion de bibliothèques. * **Débogage assisté :** Identification d'erreurs, explication de code. * **Apprentissage :** Comprendre comment d'autres pourraient aborder un problème. ### Limites et "Hallucinations" > [!definition] Hallucination de code > Une "hallucination" en matière de code se produit lorsque le LLM génère du code qui semble plausible mais est en réalité incorrect, non fonctionnel, ou ne répond pas aux spécifications. Cela peut inclure des fonctions inventées, des syntaxes erronées ou des logiques défectueuses. * **Code non optimisé :** Le code généré n'est pas toujours le plus efficace ou le plus élégant. * **Erreurs subtiles :** Le LLM peut introduire des bugs logiques difficiles à détecter. * **Dépendance aux prompts :** La qualité du code dépend directement de la clarté et de la précision de votre prompt. * **Manque de compréhension sémantique profonde :** Le LLM ne "comprend" pas le code comme un humain ; il prédit la séquence de tokens la plus probable. > [!warning] Vérification systématique > **Ne faites jamais confiance aveuglément au code généré par un LLM.** Testez-le, déboguez-le et comprenez-le avant de l'intégrer dans un projet. ## Techniques de Prompting pour la génération de code Python Un bon prompt est la clé d'un bon code. #### 1. Clarté et Spécificité * **Décrivez la tâche :** Que doit faire le programme ? * **Spécifiez les entrées :** Quels sont les types de données, les formats, les contraintes ? * **Décrivez les sorties :** Quel est le format attendu du résultat ? * **Mentionnez les bibliothèques :** Si vous avez des préférences (ex: `numpy`, `pandas`, `matplotlib`). * **Exemples (Few-shot prompting) :** Fournir un exemple d'entrée et la sortie attendue peut grandement améliorer la qualité. > [!tip] Itération et Raffinement > Commencez par un prompt simple, puis raffinez-le en fonction des premières réponses du LLM. Demandez des ajouts (commentaires, gestion d'erreurs, tests unitaires). ### Exemples de Prompts * **Génération de fonction simple :** ``` Écris une fonction Python nommée `calculer_moyenne` qui prend une liste de nombres flottants en entrée et retourne leur moyenne. Gère le cas où la liste est vide en retournant 0.0. ``` * **Avec commentaires et gestion d'erreurs :** ``` Modifie la fonction `calculer_moyenne` pour inclure des commentaires explicatifs et une gestion d'erreur robuste si l'entrée n'est pas une liste ou contient des éléments non numériques. ``` * **Utilisation de bibliothèques spécifiques :** ``` Écris un script Python utilisant la bibliothèque `numpy` pour calculer l'écart-type d'un tableau de nombres. Le script doit prendre une liste Python comme entrée et la convertir en tableau numpy. ``` # Cas pratiques : Outils de calcul et programmes simples Voyons comment appliquer ces principes pour créer des outils numériques basiques. ## Exemple 1: Un outil de conversion d'unités de température **Problème :** Créer un programme Python qui convertit des températures de Celsius en Fahrenheit et vice-versa. **Démarche avec LLM :** 1. **Prompt initial :** ``` Écris un programme Python qui offre deux fonctions : 1. `celsius_vers_fahrenheit(celsius)` : convertit une température en Celsius en Fahrenheit. 2. `fahrenheit_vers_celsius(fahrenheit)` : convertit une température en Fahrenheit en Celsius. Les formules sont : Fahrenheit = Celsius * 9/5 + 32 Celsius = (Fahrenheit - 32) * 5/9 Ajoute un petit programme principal qui demande à l'utilisateur de choisir une conversion et d'entrer une valeur, puis affiche le résultat. ``` 2. **Code Python généré (exemple typique) :** ```python # -*- coding: utf-8 -*- """ Module de conversion de températures. """ def celsius_vers_fahrenheit(celsius: float) -> float: """ Convertit une température de Celsius en Fahrenheit. Args: celsius (float): La température en degrés Celsius. Returns: float: La température en degrés Fahrenheit. """ fahrenheit = (celsius * 9/5) + 32 return fahrenheit def fahrenheit_vers_celsius(fahrenheit: float) -> float: """ Convertit une température de Fahrenheit en Celsius. Args: fahrenheit (float): La température en degrés Fahrenheit. Returns: float: La température en degrés Celsius. """ celsius = (fahrenheit - 32) * 5/9 return celsius if __name__ == "__main__": print("--- Outil de Conversion de Température ---") while True: print("\nChoisissez une option :") print("1. Celsius vers Fahrenheit") print("2. Fahrenheit vers Celsius") print("3. Quitter") choix = input("Entrez votre choix (1/2/3) : ") if choix == '1': try: temp_c = float(input("Entrez la température en Celsius : ")) temp_f = celsius_vers_fahrenheit(temp_c) print(f"{temp_c}°C est égal à {temp_f:.2f}°F") except ValueError: print("Entrée invalide. Veuillez entrer un nombre.") elif choix == '2': try: temp_f = float(input("Entrez la température en Fahrenheit : ")) temp_c = fahrenheit_vers_celsius(temp_f) print(f"{temp_f}°F est égal à {temp_c:.2f}°C") except ValueError: print("Entrée invalide. Veuillez entrer un nombre.") elif choix == '3': print("Merci d'avoir utilisé l'outil. Au revoir !") break else: print("Choix invalide. Veuillez choisir 1, 2 ou 3.") ``` > [!example] Analyse du code généré > Le LLM a correctement implémenté les fonctions, les docstrings, et un menu interactif avec gestion des erreurs basique. C'est une excellente base pour un outil simple. ## Exemple 2: Un script d'analyse de données basique (Moyenne et Écart-type) **Problème :** Créer un script Python qui calcule la moyenne et l'écart-type d'une liste de nombres, en utilisant si possible la bibliothèque `math` ou `numpy`. **Démarche avec LLM :** 1. **Prompt initial :** ``` Écris un script Python qui prend une liste de nombres en entrée et calcule : 1. La moyenne arithmétique. 2. L'écart-type (population). Utilise la bibliothèque `math` pour la racine carrée. Le script doit inclure des fonctions pour ces calculs et un exemple d'utilisation. ``` 2. **Formules mathématiques :** * Moyenne arithmétique : $ \bar{x} = \frac{1}{n} \sum_{i=1}^n x_i $ * Écart-type (population) : $ \sigma = \sqrt{\frac{1}{n} \sum_{i=1}^n (x_i - \bar{x})^2} $ 3. **Code Python généré (exemple typique) :** ```python # -*- coding: utf-8 -*- """ Script d'analyse statistique basique. """ import math def calculer_moyenne(data: list[float]) -> float: """ Calcule la moyenne arithmétique d'une liste de nombres. Args: data (list[float]): Une liste de nombres flottants. Returns: float: La moyenne des nombres. Retourne 0.0 si la liste est vide pour éviter une division par zéro. """ if not data: return 0.0 return sum(data) / len(data) def calculer_ecart_type(data: list[float]) -> float: """ Calcule l'écart-type (population) d'une liste de nombres. Args: data (list[float]): Une liste de nombres flottants. Returns: float: L'écart-type des nombres. Retourne 0.0 si la liste est vide ou contient un seul élément. """ if not data or len(data) < 2: # L'écart-type est indéfini ou 0 pour moins de 2 éléments return 0.0 mean = calculer_moyenne(data) variance = sum([(x - mean) ** 2 for x in data]) / len(data) return math.sqrt(variance) if __name__ == "__main__": # Exemple d'utilisation liste_nombres = [10.5, 12.3, 14.0, 11.8, 13.2, 10.0] print(f"Liste des nombres : {liste_nombres}") moyenne = calculer_moyenne(liste_nombres) ecart_type = calculer_ecart_type(liste_nombres) print(f"Moyenne : {moyenne:.2f}") print(f"Écart-type : {ecart_type:.2f}") # Exemple avec une liste vide liste_vide = [] print(f"\nListe vide : {liste_vide}") print(f"Moyenne : {calculer_moyenne(liste_vide):.2f}") print(f"Écart-type : {calculer_ecart_type(liste_vide):.2f}") # Exemple avec un seul élément liste_un_element = [5.0] print(f"\nListe avec un seul élément : {liste_un_element}") print(f"Moyenne : {calculer_moyenne(liste_un_element):.2f}") print(f"Écart-type : {calculer_ecart_type(liste_un_element):.2f}") ``` > [!note] Vérification des résultats et des formules > Il est crucial de vérifier que les formules mathématiques sont correctement implémentées, surtout pour des calculs statistiques où il existe des variantes (ex: écart-type de population vs. échantillon). Ici, le LLM a bien implémenté la formule de l'écart-type de population. # Débogage et optimisation avec un LLM Les LLM ne se contentent pas de générer du code ; ils peuvent aussi vous aider à l'améliorer. ## Débogage Si votre code ne fonctionne pas ou génère une erreur, vous pouvez copier-coller le code et le message d'erreur dans le LLM. > [!example] Prompt pour déboguer > ``` > J'ai ce code Python et il me donne l'erreur suivante : [Coller l'erreur ici]. > Peux-tu m'expliquer pourquoi et me proposer une correction ? > [Coller le code ici] > ``` > Le LLM peut souvent identifier des erreurs de syntaxe, des problèmes de logique, ou des utilisations incorrectes de bibliothèques. ## Optimisation et Amélioration Vous pouvez demander au LLM d'optimiser votre code pour la performance, la lisibilité, ou de lui ajouter des fonctionnalités. > [!example] Prompt pour optimisation > ``` > J'ai ce code Python. Peux-tu le rendre plus performant et plus lisible ? > Ajoute également des commentaires si nécessaire et assure-toi qu'il gère les cas d'erreur courants. > [Coller le code ici] > ``` > Le LLM peut suggérer des algorithmes plus efficaces, l'utilisation de list comprehensions, ou des structures de données plus adaptées. > [!warning] Ne pas déléguer la compréhension > Bien que le LLM puisse corriger ou optimiser le code, il est impératif que **vous compreniez la correction ou l'optimisation**. C'est ainsi que vous apprenez et développez vos propres compétences d'ingénieur. # Éthique et Bonnes Pratiques L'utilisation des LLM dans la production numérique s'accompagne de responsabilités. * **Vérification et Validation :** Toujours vérifier les faits, la logique et la fonctionnalité du contenu et du code générés. La qualité de votre travail final est sous votre responsabilité. * **Attribution et Responsabilité :** Si vous utilisez le code ou le texte généré par un LLM dans un contexte professionnel ou académique, il est bon de mentionner l'aide de l'outil, surtout si des parties significatives sont directement issues de sa génération. La responsabilité légale et éthique du résultat final vous incombe. * **Sécurité et Confidentialité des Données :** Ne jamais soumettre d'informations sensibles, confidentielles ou personnelles aux LLM publics. Utilisez des environnements sécurisés si vous travaillez avec des données critiques. * **Dépendance vs. Autonomie :** Les LLM sont des assistants, pas des substituts à votre expertise. Utilisez-les pour augmenter votre productivité, pas pour vous empêcher de développer vos propres compétences critiques. > [!theorem] La responsabilité finale incombe toujours à l'ingénieur. > Quel que soit le degré d'automatisation ou d'assistance fourni par un LLM, la validation, la compréhension et la responsabilité des livrables (rapports, codes, présentations) incombent entièrement à l'ingénieur humain. # ➡️ C'est la fin Ce chapitre vous a montré comment les LLM peuvent être intégrés dans votre flux de travail pour la production de contenu structuré et la génération de code. De la conception d'une présentation à la création d'un outil de calcul Python, ces modèles sont de puissants catalyseurs pour votre productivité et votre créativité. Vous avez appris l'importance de l'ingénierie des prompts, la nécessité d'une vérification rigoureuse et les considérations éthiques inhérentes à l'utilisation de ces technologies. En tant qu'ingénieurs, votre capacité à interagir efficacement avec ces outils, à critiquer leurs sorties et à les intégrer judicieusement, sera une compétence clé dans le monde numérique de demain. Les LLM évoluent rapidement, et avec eux, les possibilités de créer des outils numériques toujours plus sophistiqués. Continuez à expérimenter, à apprendre et à repousser les limites de ce qui est possible. Le futur de l'ingénierie est collaboratif, et les LLM sont désormais des membres à part entière de cette collaboration. --- - Cours précèdent: [[Cours 1 - Générer du code]] - Prochain cours: [[Exercices - 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]]