From 29468c90993662e0ca41a111b18df1237ba9a1e6 Mon Sep 17 00:00:00 2001 From: Kim NOEL Date: Sun, 16 Feb 2025 22:09:19 +0100 Subject: [PATCH] translated to fr communication, unit0 unit1 --- units/fr/_toctree.yml | 50 +++ units/fr/communication/live1.mdx | 7 + units/fr/communication/next-units.mdx | 7 + units/fr/unit0/discord101.mdx | 42 +++ units/fr/unit0/introduction.mdx | 172 +++++++++ units/fr/unit0/onboarding.mdx | 52 +++ units/fr/unit1/README.md | 19 + units/fr/unit1/actions.mdx | 120 +++++++ units/fr/unit1/agent-steps-and-structure.mdx | 142 ++++++++ units/fr/unit1/conclusion.mdx | 19 + units/fr/unit1/dummy-agent-library.mdx | 336 ++++++++++++++++++ units/fr/unit1/final-quiz.mdx | 24 ++ units/fr/unit1/get-your-certificate.mdx | 18 + units/fr/unit1/introduction.mdx | 38 ++ .../fr/unit1/messages-and-special-tokens.mdx | 33 ++ units/fr/unit1/observations.mdx | 45 +++ units/fr/unit1/quiz1.mdx | 171 +++++++++ units/fr/unit1/quiz2.mdx | 117 ++++++ units/fr/unit1/thoughts.mdx | 55 +++ units/fr/unit1/tools.mdx | 298 ++++++++++++++++ units/fr/unit1/tutorial.mdx | 221 ++++++++++++ units/fr/unit1/what-are-agents.mdx | 44 +++ units/fr/unit1/what-are-llms.mdx | 220 ++++++++++++ units/fr/unit2/README.md | 0 units/fr/unit3/README.md | 0 units/fr/unit4/README.md | 0 26 files changed, 2250 insertions(+) create mode 100644 units/fr/_toctree.yml create mode 100644 units/fr/communication/live1.mdx create mode 100644 units/fr/communication/next-units.mdx create mode 100644 units/fr/unit0/discord101.mdx create mode 100644 units/fr/unit0/introduction.mdx create mode 100644 units/fr/unit0/onboarding.mdx create mode 100644 units/fr/unit1/README.md create mode 100644 units/fr/unit1/actions.mdx create mode 100644 units/fr/unit1/agent-steps-and-structure.mdx create mode 100644 units/fr/unit1/conclusion.mdx create mode 100644 units/fr/unit1/dummy-agent-library.mdx create mode 100644 units/fr/unit1/final-quiz.mdx create mode 100644 units/fr/unit1/get-your-certificate.mdx create mode 100644 units/fr/unit1/introduction.mdx create mode 100644 units/fr/unit1/messages-and-special-tokens.mdx create mode 100644 units/fr/unit1/observations.mdx create mode 100644 units/fr/unit1/quiz1.mdx create mode 100644 units/fr/unit1/quiz2.mdx create mode 100644 units/fr/unit1/thoughts.mdx create mode 100644 units/fr/unit1/tools.mdx create mode 100644 units/fr/unit1/tutorial.mdx create mode 100644 units/fr/unit1/what-are-agents.mdx create mode 100644 units/fr/unit1/what-are-llms.mdx create mode 100644 units/fr/unit2/README.md create mode 100644 units/fr/unit3/README.md create mode 100644 units/fr/unit4/README.md diff --git a/units/fr/_toctree.yml b/units/fr/_toctree.yml new file mode 100644 index 00000000..09a1a5f3 --- /dev/null +++ b/units/fr/_toctree.yml @@ -0,0 +1,50 @@ +- title: UnitĂ© 0. Bienvenue dans le cours + sections: + - local: unit0/introduction + title: Bienvenue dans le cours đŸ€— + - local: unit0/onboarding + title: IntĂ©gration + - local: unit0/discord101 + title: (Optionnel) Discord 101 +- title: Live 1. Comment fonctionne le cours et Q&R + sections: + - local: communication/live1 + title: Live 1. Comment fonctionne le cours et Q&R +- title: UnitĂ© 1. Introduction aux Agents + sections: + - local: unit1/introduction + title: Introduction + - local: unit1/what-are-agents + title: Qu'est-ce qu'un Agent ? + - local: unit1/quiz1 + title: Quiz rapide 1 + - local: unit1/what-are-llms + title: Que sont les LLMs ? + - local: unit1/messages-and-special-tokens + title: Messages et Tokens SpĂ©ciaux + - local: unit1/tools + title: Que sont les Outils ? + - local: unit1/quiz2 + title: Quiz rapide 2 + - local: unit1/agent-steps-and-structure + title: Comprendre les Agents IA Ă  travers le cycle PensĂ©e-Action-Observation + - local: unit1/thoughts + title: PensĂ©e, Raisonnement Interne et l'Approche Re-Act + - local: unit1/actions + title: Actions, permettant Ă  l'Agent d'interagir avec son environnement + - local: unit1/observations + title: Observer, intĂ©grer les retours pour rĂ©flĂ©chir et s'adapter + - local: unit1/dummy-agent-library + title: BibliothĂšque d'Agents Factices + - local: unit1/tutorial + title: CrĂ©ons notre premier Agent avec Smolagents + - local: unit1/final-quiz + title: Quiz Final de l'UnitĂ© 1 + - local: unit1/get-your-certificate + title: Obtenez votre certificat + - local: unit1/conclusion + title: Conclusion +- title: Quand les prochaines unitĂ©s seront-elles publiĂ©es ? + sections: + - local: communication/next-units + title: Prochaines unitĂ©s diff --git a/units/fr/communication/live1.mdx b/units/fr/communication/live1.mdx new file mode 100644 index 00000000..4e25ecae --- /dev/null +++ b/units/fr/communication/live1.mdx @@ -0,0 +1,7 @@ +# Live 1 : Comment fonctionne le cours et premiĂšre session de questions-rĂ©ponses + +Dans ce premier live stream du cours Agents, nous avons expliquĂ© comment le cours **fonctionne** (contenu, unitĂ©s, dĂ©fis, et plus encore) et avons rĂ©pondu Ă  vos questions. + + + +Pour savoir quand la prochaine session en direct est prĂ©vue, consultez notre **serveur Discord**. Nous vous enverrons Ă©galement un email. Si vous ne pouvez pas participer, ne vous inquiĂ©tez pas, nous **enregistrons toutes les sessions en direct**. \ No newline at end of file diff --git a/units/fr/communication/next-units.mdx b/units/fr/communication/next-units.mdx new file mode 100644 index 00000000..6ee8f9a2 --- /dev/null +++ b/units/fr/communication/next-units.mdx @@ -0,0 +1,7 @@ +Quand les prochaines unitĂ©s seront-elles publiĂ©es ? +Voici le calendrier de publication : + +Next Units +N'oubliez pas de vous inscrire au cours ! En vous inscrivant, nous pourrons vous envoyer les liens dĂšs que chaque unitĂ© est publiĂ©e, ainsi que des mises Ă  jour et des dĂ©tails sur les dĂ©fis Ă  venir. + +Continuez Ă  apprendre, restez gĂ©nial đŸ€— \ No newline at end of file diff --git a/units/fr/unit0/discord101.mdx b/units/fr/unit0/discord101.mdx new file mode 100644 index 00000000..920c824c --- /dev/null +++ b/units/fr/unit0/discord101.mdx @@ -0,0 +1,42 @@ +(Optionnel) Discord 101 [[discord-101]] +L'Ă©tiquette sur Discord +Ce guide est conçu pour vous aider Ă  dĂ©buter sur Discord, une plateforme de chat gratuite trĂšs prisĂ©e dans les communautĂ©s de gaming et de machine learning. + +Rejoignez le serveur Discord de la communautĂ© Hugging Face, qui compte plus de 100 000 membres, en cliquant ici. C'est un excellent endroit pour se connecter avec d'autres passionnĂ©s ! + +Le cours Agents sur la communautĂ© Discord de Hugging Face +Commencer sur Discord peut sembler un peu intimidant, alors voici un guide rapide pour vous orienter. + + + +Le serveur communautaire HF rĂ©unit une communautĂ© dynamique aux intĂ©rĂȘts variĂ©s, offrant des opportunitĂ©s d'apprentissage Ă  travers des discussions sur des articles, des Ă©vĂ©nements et bien plus encore. + +AprĂšs vous ĂȘtre inscrit, prĂ©sentez-vous dans le canal #introduce-yourself. + +Nous avons crĂ©Ă© 4 canaux pour le cours sur les Agents : + +agents-course-announcements : pour les derniĂšres informations sur le cours. +🎓-agents-course-general : pour les discussions gĂ©nĂ©rales et bavardages. +agents-course-questions : pour poser des questions et aider vos camarades. +agents-course-showcase : pour prĂ©senter vos meilleurs agents. +De plus, vous pouvez consulter : + +smolagents : pour les discussions et l'assistance concernant la bibliothĂšque. +Conseils pour utiliser Discord efficacement +Comment rejoindre un serveur +Si vous n'ĂȘtes pas trĂšs familier avec Discord, vous pouvez consulter ce guide expliquant comment rejoindre un serveur. + +Voici un rĂ©sumĂ© rapide des Ă©tapes : + +Cliquez sur le lien d'invitation. +Connectez-vous avec votre compte Discord ou crĂ©ez-en un si vous n'en avez pas. +VĂ©rifiez que vous n'ĂȘtes pas un agent IA ! +Configurez votre pseudo et votre avatar. +Cliquez sur « Rejoindre le serveur ». +Comment utiliser Discord efficacement +Voici quelques conseils pour tirer le meilleur parti de Discord : + +Les canaux vocaux sont disponibles, bien que le chat textuel soit plus utilisĂ©. +Vous pouvez formater votre texte en utilisant le style markdown, ce qui est particuliĂšrement utile pour Ă©crire du code. Notez toutefois que le markdown n'est pas aussi efficace pour les liens. +Pensez Ă  ouvrir des fils de discussion pour les conversations longues afin de garder vos Ă©changes bien organisĂ©s. +Nous espĂ©rons que ce guide vous sera utile ! Si vous avez des questions, n'hĂ©sitez pas Ă  nous les poser sur Discord đŸ€—. \ No newline at end of file diff --git a/units/fr/unit0/introduction.mdx b/units/fr/unit0/introduction.mdx new file mode 100644 index 00000000..98458db4 --- /dev/null +++ b/units/fr/unit0/introduction.mdx @@ -0,0 +1,172 @@ +# Bienvenue au cours đŸ€— AI Agents [[introduction]] + +
+Vignette du cours AI Agents +
L'arriÚre-plan de l'image a été généré à l'aide de Scenario.com +
+
+ + +Bienvenue dans le sujet le plus passionnant de l'IA aujourd'hui : **Les Agents** ! + +Ce cours gratuit vous emmĂšnera dans un voyage, **du dĂ©butant Ă  l'expert**, pour comprendre, utiliser et construire des agents IA. + +Cette premiĂšre unitĂ© va vous aider Ă  dĂ©marrer : + +- DĂ©couvrez le **programme du cours**. +- **Choisissez le parcours** que vous souhaitez suivre (soit en autoformation, soit en suivant le processus de certification). +- **Obtenez plus d'informations sur le processus de certification et les dates limites**. +- Faites connaissance avec l'Ă©quipe derriĂšre le cours. +- CrĂ©ez votre **compte Hugging Face**. +- **Inscrivez-vous Ă  notre serveur Discord** et rencontrez vos camarades ainsi que nous. + +C'est parti ! + +## Que pouvez-vous attendre de ce cours ? [[expect]] + +Dans ce cours, vous allez : + +- 📖 Étudier les agents IA en **thĂ©orie, en conception et en pratique**. +- đŸ§‘â€đŸ’» Apprendre Ă  **utiliser des bibliothĂšques d'agents IA Ă©tablies** telles que [smolagents](https://huggingface.co/docs/smolagents/en/index), [LangChain](https://www.langchain.com/), et [LlamaIndex](https://www.llamaindex.ai/). +- đŸ’Ÿ **Partager vos agents** sur le Hugging Face Hub et explorer les agents crĂ©Ă©s par la communautĂ©. +- 🏆 Participer Ă  des challenges oĂč vous **Ă©valuerez vos agents par rapport Ă  ceux des autres Ă©tudiants**. +- 🎓 **Obtenir un certificat de rĂ©ussite** en complĂ©tant les exercices. + +Et bien plus encore ! + +À la fin de ce cours, vous comprendrez **comment fonctionnent les Agents et comment construire vos propres Agents en utilisant les derniĂšres bibliothĂšques et outils**. + +N'oubliez pas de **vous inscrire au cours !** + +(Nous respectons votre vie privĂ©e. Nous collectons votre adresse email afin de pouvoir **vous envoyer les liens dĂšs que chaque unitĂ© est publiĂ©e et vous fournir des informations sur les challenges et les mises Ă  jour**.) + +## À quoi ressemble le cours ? [[course-look-like]] + +Le cours se compose de : + +- *UnitĂ©s fondamentales* : oĂč vous apprenez les **concepts des Agents en thĂ©orie**. +- *Pratique* : oĂč vous apprendrez **Ă  utiliser des bibliothĂšques d'agents IA existantes** pour entraĂźner vos agents dans des environnements uniques. Ces sessions pratiques se feront dans des **Hugging Face Spaces** avec un environnement prĂ©configurĂ©. +- *Exercices basĂ©s sur des cas d'utilisation* : oĂč vous appliquerez les concepts appris pour rĂ©soudre un problĂšme rĂ©el de votre choix. +- *Le Challenge* : vous mettrez votre agent en compĂ©tition contre d'autres agents dans un challenge. Il y aura Ă©galement [un classement](https://huggingface.co/spaces/huggingface-projects/AI-Agents-Leaderboard) (pas encore disponible) pour comparer les performances des agents. + +Ce **cours est un projet vivant, Ă©voluant avec vos retours et contributions !** N'hĂ©sitez pas Ă  [ouvrir des issues et des PR sur GitHub](https://github.com/huggingface/agents-course) et Ă  participer aux discussions sur notre serveur Discord. + +AprĂšs avoir suivi le cours, vous pouvez Ă©galement nous envoyer vos retours [👉 via ce formulaire](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog) + +## Quel est le programme ? [[syllabus]] + +Voici le **programme gĂ©nĂ©ral du cours**. Une liste plus dĂ©taillĂ©e des sujets sera publiĂ©e avec chaque unitĂ©. + +| Chapter | Topic | Description | +| :---- | :---- | :---- | +| 0 | IntĂ©gration | Vous prĂ©parer avec les outils et plateformes que vous utiliserez. | +| 1 | Fondamentaux des Agents | Expliquer les outils, les pensĂ©es, les actions, les observations et leurs formats. Expliquer les LLM, les messages, les tokens spĂ©ciaux et les modĂšles de chat. PrĂ©senter un cas d'usage simple en utilisant des fonctions Python comme outils. | +| 2 | Frameworks | Comprendre comment les fondamentaux sont implĂ©mentĂ©s dans des bibliothĂšques populaires : smolagents, LangGraph, LlamaIndex | +| 3 | Cas d'utilisation | Construisons quelques cas d'utilisation rĂ©els (les PRs đŸ€— des constructeurs d'agents expĂ©rimentĂ©s sont les bienvenus) | +| 4 | Projet final | Construisez un agent pour un benchmark sĂ©lectionnĂ© et dĂ©montrez votre comprĂ©hension des Agents sur le classement Ă©tudiant 🚀 | + +*Nous prĂ©voyons Ă©galement de publier quelques unitĂ©s bonus, restez Ă  l'Ă©coute !* + +## Quels sont les prĂ©requis ? + +Pour pouvoir suivre ce cours, vous devez avoir : + +- Une connaissance de base de Python +- Une connaissance de base des LLM (nous avons une section dans l'UnitĂ© 1 pour rappeler ce qu'ils sont) + + +## De quels outils ai-je besoin ? [[tools]] + +Vous n'avez besoin que de 2 choses : + +- *Un ordinateur* avec une connexion internet. +- Un *compte Hugging Face* : pour pousser et charger des modĂšles, des agents, et crĂ©er des Spaces. Si vous n'avez pas encore de compte, vous pouvez en crĂ©er un **[ici](https://hf.co/join)** (c'est gratuit). + +Outils nĂ©cessaires pour le cours + +## Le processus de certification [[certification-process]] + +Deux voies + +Vous pouvez choisir de suivre ce cours en *mode auditeur libre*, ou de rĂ©aliser les activitĂ©s et *obtenir l'un des deux certificats que nous dĂ©livrerons*. + +Si vous suivez le cours en auditeur libre, vous pouvez participer Ă  tous les challenges et faire les exercices si vous le souhaitez, et **vous n'avez pas besoin de nous en informer**. + +Le processus de certification est **entiĂšrement gratuit** : + +- *Pour obtenir une certification des fondamentaux* : vous devez complĂ©ter l'UnitĂ© 1 du cours. Ceci est destinĂ© aux Ă©tudiants qui souhaitent se tenir Ă  jour avec les derniĂšres tendances en matiĂšre d'Agents. +- *Pour obtenir un certificat de rĂ©ussite* : vous devez complĂ©ter l'UnitĂ© 1, l'un des exercices de cas d'utilisation que nous proposerons pendant le cours, ainsi que le challenge final. + +Il y a une date limite pour le processus de certification : tous les exercices doivent ĂȘtre terminĂ©s avant le **1er mai 2025**. + +Date limite + +## Quel est le rythme recommandĂ© ? [[recommended-pace]] + +Chaque chapitre de ce cours est conçu **pour ĂȘtre complĂ©tĂ© en 1 semaine, avec environ 3 Ă  4 heures de travail par semaine**. + +Comme il y a une date limite, nous vous proposons un rythme recommandĂ© : + +Rythme recommandĂ© + +## Comment tirer le meilleur parti du cours ? [[advice]] + +Pour tirer le meilleur parti du cours, nous vous donnons quelques conseils : + +1. Rejoignez des groupes d'Ă©tude sur Discord : Ă©tudier en groupe est toujours plus facile. Pour cela, vous devez rejoindre notre serveur Discord et vĂ©rifier votre compte Hugging Face. +2. **Faites les quiz et les exercices** : la meilleure façon d'apprendre est par la pratique et l'auto-Ă©valuation. +3. **DĂ©finissez un planning pour rester en phase** : vous pouvez utiliser notre planning de rythme recommandĂ© ci-dessous ou crĂ©er le vĂŽtre. + +Conseils pour le cours + +## Qui sommes-nous ? [[who-are-we]] + +À propos des auteurs : + +### Joffrey Thomas + +Joffrey est ingĂ©nieur en machine learning chez Hugging Face et a construit et dĂ©ployĂ© des agents IA en production. Joffrey sera votre principal instructeur pour ce cours. + +- [Suivez Joffrey sur Hugging Face](https://huggingface.co/Jofthomas) +- [Suivez Joffrey sur X](https://x.com/Jthmas404) +- [Suivez Joffrey sur Linkedin](https://www.linkedin.com/in/joffrey-thomas/) + +### Ben Burtenshaw + +Ben est ingĂ©nieur en machine learning chez Hugging Face et a donnĂ© plusieurs cours sur diverses plateformes. L'objectif de Ben est de rendre le cours accessible Ă  tous. + +- [Suivez Ben sur Hugging Face](https://huggingface.co/burtenshaw) +- [Suivez Ben sur X](https://x.com/ben_burtenshaw) +- [Suivez Ben sur Linkedin](https://www.linkedin.com/in/ben-burtenshaw/) + +### Thomas Simonini + +Thomas est ingĂ©nieur en machine learning chez Hugging Face et a animĂ© avec succĂšs les cours Deep RL et ML for games. Thomas est un grand fan des Agents et est impatient de voir ce que la communautĂ© va construire. + +- [Suivez Thomas sur Hugging Face](https://huggingface.co/ThomasSimonini) +- [Suivez Thomas sur X](https://x.com/ThomasSimonini) +- [Suivez Thomas sur Linkedin](https://www.linkedin.com/in/simoninithomas/) + +## Remerciements + +Nous tenons Ă  exprimer notre gratitude aux personnes suivantes pour leurs contributions inestimables Ă  ce cours : + +- **[Pedro Cuenca](https://huggingface.co/pcuenq)** – Pour ses conseils et son expertise dans la rĂ©vision des supports +- **[Aymeric Roucher](https://huggingface.co/m-ric)** – Pour ses incroyables espaces de dĂ©monstration (dĂ©codage et agent final) +- **[Joshua Lochner](https://huggingface.co/Xenova)** – Pour son espace de dĂ©monstration incroyable sur la tokenisation + +## J'ai trouvĂ© un bug, ou je souhaite amĂ©liorer le cours [[contribute]] + +Les contributions sont **les bienvenues** đŸ€— + +- Si vous *avez trouvĂ© un bug 🐛 dans un notebook*, veuillez ouvrir une issue et **dĂ©crire le problĂšme**. +- Si vous *souhaitez amĂ©liorer le cours*, vous pouvez ouvrir une Pull Request. +- Si vous *voulez ajouter une section complĂšte ou une nouvelle unitĂ©*, le mieux est d'ouvrir une issue et **dĂ©crire le contenu que vous souhaitez ajouter avant de commencer Ă  l'Ă©crire afin que nous puissions vous guider**. + +## J'ai encore des questions [[questions]] + +Veuillez poser vos questions sur notre serveur Discord #ai-agents-discussions. + +Maintenant que vous avez toutes les informations, embarquons â›” + +Il est temps de dĂ©marrer diff --git a/units/fr/unit0/onboarding.mdx b/units/fr/unit0/onboarding.mdx new file mode 100644 index 00000000..c5409b0c --- /dev/null +++ b/units/fr/unit0/onboarding.mdx @@ -0,0 +1,52 @@ +# IntĂ©gration : Vos Premiers Pas â›” + +Il est temps de dĂ©marrer + +Maintenant que vous avez tous les dĂ©tails, commençons ! Nous allons rĂ©aliser quatre choses : + +1. **CrĂ©ez votre compte Hugging Face** si ce n'est pas dĂ©jĂ  fait +2. **Inscrivez-vous sur Discord et prĂ©sentez-vous** (ne soyez pas timide đŸ€—) +3. **Suivez le cours Hugging Face Agents** sur le Hub +4. **Faites passer le mot** Ă  propos du cours + +### Étape 1 : CrĂ©ez votre compte Hugging Face + +(Si ce n'est pas dĂ©jĂ  fait) crĂ©ez un compte Hugging Face ici. + +### Étape 2 : Rejoignez notre communautĂ© Discord + +đŸ‘‰đŸ» Rejoignez notre serveur Discord ici. + +Lorsque vous rejoignez, n'oubliez pas de vous prĂ©senter dans `#introduce-yourself`. + +Nous disposons de plusieurs canaux liĂ©s aux agents IA : +- `agents-course-announcements` : pour les **derniĂšres informations du cours**. +- `🎓-agents-course-general` : pour **les discussions gĂ©nĂ©rales et les bavardages**. +- `agents-course-questions` : pour **poser des questions et aider vos camarades**. +- `agents-course-showcase` : pour **prĂ©senter vos meilleurs agents**. + +De plus, vous pouvez consulter : + +- `smolagents` : pour **les discussions et l'assistance concernant la bibliothĂšque**. + +Si c'est votre premiĂšre utilisation de Discord, nous avons rĂ©digĂ© un guide Discord 101 pour vous donner les meilleures pratiques. Consultez [la section suivante](discord101). + +### Étape 3 : Suivez l'organisation du cours Hugging Face Agents + +Restez Ă  jour avec les derniers matĂ©riels de cours, mises Ă  jour, et annonces **en suivant l'organisation du cours Hugging Face Agents**. + +👉 Rendez-vous ici et cliquez sur **suivre**. + +Suivre + +### Étape 4 : Faites passer le mot Ă  propos du cours + +Aidez-nous Ă  rendre ce cours plus visible ! Il y a deux façons de nous aider : + +1. Montrez votre soutien en ⭐ aimant le dĂ©pĂŽt du cours. + +Favoriser le dĂ©pĂŽt + +2. Partagez votre parcours d'apprentissage : Faites savoir aux autres **que vous suivez ce cours** ! Nous avons prĂ©parĂ© une illustration que vous pouvez utiliser dans vos publications sur les rĂ©seaux sociaux. + +ici + + diff --git a/units/fr/unit1/actions.mdx b/units/fr/unit1/actions.mdx new file mode 100644 index 00000000..e66d0ef6 --- /dev/null +++ b/units/fr/unit1/actions.mdx @@ -0,0 +1,120 @@ +# Actions : Permettre Ă  l'Agent d'Interagir avec son Environnement + + +Dans cette section, nous explorons les Ă©tapes concrĂštes qu'un agent d'IA entreprend pour interagir avec son environnement. + +Nous aborderons la maniĂšre dont les actions sont reprĂ©sentĂ©es (en utilisant du JSON ou du code), l'importance de l'approche stop and parse, et nous prĂ©senterons diffĂ©rents types d'agents. + + +Les actions sont les Ă©tapes concrĂštes qu'un **agent d'IA entreprend pour interagir avec son environnement**. + +Que ce soit pour naviguer sur le web Ă  la recherche d'informations ou pour contrĂŽler un dispositif physique, chaque action est une opĂ©ration dĂ©libĂ©rĂ©e exĂ©cutĂ©e par l'agent. + +Par exemple, un agent assistant au service client pourrait rĂ©cupĂ©rer des donnĂ©es client, proposer des articles de support ou transfĂ©rer des problĂšmes Ă  un reprĂ©sentant humain. + +## Types d'Actions des Agents + +Il existe plusieurs types d'agents qui rĂ©alisent des actions de maniĂšres diffĂ©rentes : + +| Type d'Agent | Description | +|---------------------------|-------------------------------------------------------------------------------------------------------| +| JSON Agent | L'action Ă  entreprendre est spĂ©cifiĂ©e au format JSON. | +| Code Agent | L'agent gĂ©nĂšre un bloc de code qui est interprĂ©tĂ© de maniĂšre externe. | +| Agent Ă  appel de fonction | Il s'agit d'une sous-catĂ©gorie de l'agent JSON qui a Ă©tĂ© affinĂ© pour gĂ©nĂ©rer un nouveau message pour chaque action. | + +Les actions elles-mĂȘmes peuvent remplir de nombreux objectifs : + +| Type d'Action | Description | +|-----------------------------|----------------------------------------------------------------------------------------------------------| +| Collecte d'informations | Effectuer des recherches sur le web, interroger des bases de donnĂ©es ou rĂ©cupĂ©rer des documents. | +| Utilisation d'outils | Effectuer des appels API, rĂ©aliser des calculs et exĂ©cuter du code. | +| Interaction avec l'environnement | Manipuler des interfaces numĂ©riques ou contrĂŽler des dispositifs physiques. | +| Communication | Interagir avec les utilisateurs via le chat ou collaborer avec d'autres agents. | + +Une partie cruciale d'un agent est sa **capacitĂ© Ă  ARRÊTER la gĂ©nĂ©ration de nouveaux tokens lorsque l'action est terminĂ©e**, et cela est vrai pour tous les formats d'agents : JSON, code ou appel de fonction. Cela Ă©vite la production de sorties non dĂ©sirĂ©es et garantit que la rĂ©ponse de l'agent soit claire et prĂ©cise. + +Le LLM ne gĂšre que du texte et l'utilise pour dĂ©crire l'action qu'il souhaite entreprendre ainsi que les paramĂštres Ă  fournir Ă  l'outil. + +## L'approche Stop and Parse + +Une mĂ©thode clĂ© pour implĂ©menter des actions est l'**approche stop and parse**. Cette mĂ©thode garantit que la sortie de l'agent est structurĂ©e et prĂ©visible : + +1. **GĂ©nĂ©ration dans un format structurĂ©** : + + L'agent produit l'action envisagĂ©e dans un format clair et prĂ©dĂ©fini (JSON ou code). + +2. **ArrĂȘt de la gĂ©nĂ©ration** : + + Une fois l'action terminĂ©e, **l'agent arrĂȘte de gĂ©nĂ©rer des tokens supplĂ©mentaires**. Cela Ă©vite la production de sorties additionnelles ou erronĂ©es. + +3. **Analyse de la sortie** : + + Un parseur externe lit l'action formatĂ©e, dĂ©termine quel outil appeler, et extrait les paramĂštres requis. + +Par exemple, un agent ayant besoin de vĂ©rifier la mĂ©tĂ©o pourrait produire la sortie suivante : + +```json +Thought: I need to check the current weather for New York. +Action : +{ + "action": "get_weather", + "action_input": {"location": "New York"} +} +``` + +Le framework peut ensuite analyser facilement le nom de la fonction Ă  appeler et les arguments Ă  fournir. + +Ce format clair et lisible par machine minimise les erreurs et permet aux outils externes de traiter avec prĂ©cision la commande de l'agent. + +> **Remarque :** Les agents Ă  appel de fonction fonctionnent de maniĂšre similaire en structurant chaque action de sorte qu'une fonction dĂ©signĂ©e soit invoquĂ©e avec les bons arguments. +> Nous approfondirons ces types d'agents dans une unitĂ© future. + +## Agents Code + +Une approche alternative consiste Ă  utiliser des *agents [gĂ©nĂ©rateur de] code*. +L'idĂ©e est : **au lieu de produire un simple objet JSON**, un agent code gĂ©nĂšre un **bloc de code exĂ©cutable — typiquement dans un langage de haut niveau comme Python**. + +Agents Code + +Cette approche offre plusieurs avantages : + +- **ExpressivitĂ© :** Le code peut naturellement reprĂ©senter une logique complexe, incluant des boucles, des conditionnels et des fonctions imbriquĂ©es, offrant ainsi une flexibilitĂ© supĂ©rieure au JSON. +- **ModularitĂ© et rĂ©utilisabilitĂ© :** Le code gĂ©nĂ©rĂ© peut inclure des fonctions et des modules rĂ©utilisables pour diffĂ©rentes actions ou tĂąches. +- **DĂ©bogage amĂ©liorĂ© :** GrĂące Ă  une syntaxe de programmation bien dĂ©finie, les erreurs de code sont souvent plus faciles Ă  dĂ©tecter et corriger. +- **IntĂ©gration directe :** Les agents code peuvent s'intĂ©grer directement avec des bibliothĂšques et des API externes, permettant ainsi des opĂ©rations plus complexes comme le traitement de donnĂ©es ou la prise de dĂ©cision en temps rĂ©el. + +Par exemple, un agent code chargĂ© de rĂ©cupĂ©rer la mĂ©tĂ©o pourrait gĂ©nĂ©rer l'extrait Python suivant : + +```python +# Exemple d'Agent Code : RĂ©cupĂ©rer des informations mĂ©tĂ©orologiques +def get_weather(city): + import requests + api_url = f"https://api.weather.com/v1/location/{city}?apiKey=YOUR_API_KEY" + response = requests.get(api_url) + if response.status_code == 200: + data = response.json() + return data.get("weather", "Aucune information mĂ©tĂ©o disponible") + else: + return "Erreur : Impossible de rĂ©cupĂ©rer les donnĂ©es mĂ©tĂ©o." + +# ExĂ©cuter la fonction et prĂ©parer la rĂ©ponse finale +result = get_weather("New York") +final_answer = f"La mĂ©tĂ©o actuelle Ă  New York est : {result}" +print(final_answer) +``` + +Dans cet exemple, l'agent code : + +- RĂ©cupĂšre des donnĂ©es mĂ©tĂ©o **via un appel API**, +- Traite la rĂ©ponse, +- Et utilise la fonction `print()` pour afficher la rĂ©ponse finale. + +Cette mĂ©thode **suit Ă©galement l'approche stop and parse** en dĂ©limitant clairement le bloc de code et en signalant quand l'exĂ©cution est terminĂ©e (ici, par l'affichage de `final_answer`). + +--- + +Nous avons vu que les actions font le lien entre le raisonnement interne de l'agent et ses interactions rĂ©elles en exĂ©cutant des tĂąches claires et structurĂ©es — que ce soit via JSON, du code ou des appels de fonctions. + +Cette exĂ©cution dĂ©libĂ©rĂ©e garantit que chaque action est prĂ©cise et prĂȘte pour un traitement externe via l'approche stop and parse. Dans la section suivante, nous explorerons les Observations pour voir comment les agents capturent et intĂšgrent les retours de leur environnement. + +AprĂšs cela, nous serons **finalement prĂȘts Ă  construire notre premier Agent !** diff --git a/units/fr/unit1/agent-steps-and-structure.mdx b/units/fr/unit1/agent-steps-and-structure.mdx new file mode 100644 index 00000000..85797521 --- /dev/null +++ b/units/fr/unit1/agent-steps-and-structure.mdx @@ -0,0 +1,142 @@ +# Comprendre les agents d'IA Ă  travers le cycle PensĂ©e-Action-Observation + +Planification de l'UnitĂ© 1 + +Dans les sections prĂ©cĂ©dentes, nous avons appris : + +- **Comment les outils sont mis Ă  disposition de l'agent dans le prompt systĂšme**. +- **Comment les agents d'IA sont des systĂšmes capables de "raisonner", planifier et interagir avec leur environnement**. + +Dans cette section, **nous explorerons l'ensemble du Workflow de l'Agent IA**, un cycle que nous avons dĂ©fini comme PensĂ©e-Action-Observation (Thought-Action-Observation). + +Puis, nous approfondirons chacune de ces Ă©tapes. + +## Les Composants de Base + +Les agents fonctionnent selon un cycle continu de : **penser (PensĂ©e) → agir (Action) et observer (Observation)** (**thinking (Thought) → acting (Act) and observing (Observe)**). + +DĂ©composons ensemble ces actions : + +1. **PensĂ©e** : La partie LLM de l'agent dĂ©cide de la prochaine Ă©tape. +2. **Action** : L'agent passe Ă  l'action en appelant les outils avec les arguments associĂ©s. +3. **Observation** : Le modĂšle analyse la rĂ©ponse renvoyĂ©e par l'outil. + +## Le Cycle Thought-Action-Observation + +Les trois composants fonctionnent ensemble dans une boucle continue. Pour utiliser une analogie issue de la programmation, l'agent utilise une **boucle while** : la boucle continue jusqu'Ă  ce que l'objectif de l'agent soit atteint. + +Visuellement, cela ressemble Ă  ceci : + +Cycle PensĂ©e, Action, Observation + +Dans de nombreux frameworks d'agents, **les rĂšgles et directives sont intĂ©grĂ©es directement dans le prompt systĂšme**, garantissant que chaque cycle respecte une logique dĂ©finie. + +Dans une version simplifiĂ©e, notre prompt systĂšme pourrait ressembler Ă  ceci : + +Cycle PensĂ©e, Action, Observation + +Nous voyons ici que dans le Message SystĂšme, nous avons dĂ©fini : + +- Le *comportement de l'Agent*. +- Les *outils auxquels notre Agent a accĂšs*, comme nous l'avons dĂ©crit dans la section prĂ©cĂ©dente. +- Le *Cycle PensĂ©e-Action-Observation*, que nous intĂ©grons dans les instructions du LLM. + +Prenons un petit exemple pour comprendre le processus avant d'approfondir chacune des Ă©tapes. + +## Alfred, l'Agent mĂ©tĂ©o + +Nous avons crĂ©Ă© Alfred, l'Agent mĂ©tĂ©o. + +Un utilisateur demande Ă  Alfred : « Quel temps fait-il Ă  New York aujourd'hui ? » + +Agent Alfred + +La mission d'Alfred est de rĂ©pondre Ă  cette question en utilisant un outil d'API mĂ©tĂ©o. + +Voici comment le cycle se dĂ©roule : + +### PensĂ©e + +**Raisonnement Interne :** + +AprĂšs avoir reçu la requĂȘte, le dialogue interne d'Alfred pourrait ĂȘtre : + +*"L'utilisateur a besoin d'informations mĂ©tĂ©orologiques actuelles pour New York. J'ai accĂšs Ă  un outil qui rĂ©cupĂšre les donnĂ©es mĂ©tĂ©o. D'abord, je dois appeler l'API mĂ©tĂ©o pour obtenir des dĂ©tails Ă  jour."* + +Cette Ă©tape montre l'agent dĂ©composant le problĂšme en Ă©tapes : d'abord, rassembler les donnĂ©es nĂ©cessaires. + +Agent Alfred + +### Action + +**Utilisation de l'Outil :** + +En se basant sur son raisonnement et sur le fait qu'Alfred connaĂźt l'outil `get_weather`, Alfred prĂ©pare une commande au format JSON qui appelle l'outil API mĂ©tĂ©o. Par exemple, sa premiĂšre action pourrait ĂȘtre : + +PensĂ©e : Je dois vĂ©rifier la mĂ©tĂ©o actuelle pour New York. + +``` +{ + "action": "get_weather", + "action_input": { + "location": "New York" + } +} +``` + +Ici, l'action prĂ©cise clairement quel outil appeler (par exemple, get_weather) et quel paramĂštre passer (la « location » : « New York »). + +Agent Alfred + +### Observation + +**Retour d'information de l'Environnement :** + +AprĂšs l'appel Ă  l'outil, Alfred reçoit une observation. Cela pourrait ĂȘtre les donnĂ©es mĂ©tĂ©o brutes renvoyĂ©es par l'API, par exemple : + +*"MĂ©tĂ©o actuelle Ă  New York : partiellement nuageux, 15°C, 60% d'humiditĂ©."* + +Agent Alfred + +Cette observation est ensuite ajoutĂ©e au prompt en tant que contexte supplĂ©mentaire. Elle agit comme un retour du monde rĂ©el, confirmant si l'action a rĂ©ussi et fournissant les dĂ©tails nĂ©cessaires. + +### PensĂ©e mise Ă  jour + +**RĂ©flexion :** + +Avec l'observation en main, Alfred met Ă  jour son raisonnement interne : + +*"Maintenant que j'ai les donnĂ©es mĂ©tĂ©o pour New York, je peux prĂ©parer une rĂ©ponse pour l'utilisateur."* + +Agent Alfred + +### Action finale + +Alfred gĂ©nĂšre ensuite une rĂ©ponse finale formatĂ©e comme nous le lui avons indiquĂ© : + +PensĂ©e : J'ai maintenant les donnĂ©es mĂ©tĂ©o. La mĂ©tĂ©o actuelle Ă  New York est partiellement nuageuse avec une tempĂ©rature de 15°C et 60% d'humiditĂ©. + +RĂ©ponse finale : La mĂ©tĂ©o actuelle Ă  New York est partiellement nuageuse avec une tempĂ©rature de 15°C et 60% d'humiditĂ©. + +Cette action finale renvoie la rĂ©ponse Ă  l'utilisateur, bouclant ainsi le cycle. + +Agent Alfred + +Ce que nous voyons dans cet exemple : + +- **Les agents itĂšrent dans une boucle jusqu'Ă  ce que l'objectif soit atteint :** + Le processus d'Alfred est cyclique. Il commence par une pensĂ©e, passe Ă  l'action en appelant un outil, puis observe le rĂ©sultat. Si l'observation avait indiquĂ© une erreur ou des donnĂ©es incomplĂštes, Alfred aurait pu reprendre le cycle pour corriger son approche. + +- **IntĂ©gration des outils :** + La capacitĂ© d'appeler un outil (comme une API mĂ©tĂ©o) permet Ă  Alfred d'aller **au-delĂ  de la connaissance statique et de rĂ©cupĂ©rer des donnĂ©es en temps rĂ©el**, un aspect essentiel de nombreux agents d'IA. + +- **Adaptation dynamique :** + Chaque cycle permet Ă  l'agent d'intĂ©grer des informations fraĂźches (observations) dans son raisonnement (pensĂ©e), garantissant que la rĂ©ponse finale est bien informĂ©e et prĂ©cise. + +Cet exemple illustre le concept fondamental du *cycle ReAct* (un concept que nous allons dĂ©velopper dans la section suivante) : **l'interaction entre PensĂ©e, Action et Observation permet aux agents d'IA de rĂ©soudre de maniĂšre itĂ©rative des tĂąches complexes**. + +En comprenant et en appliquant ces principes, vous pouvez concevoir des agents qui non seulement rĂ©flĂ©chissent Ă  leurs tĂąches, mais utilisent Ă©galement efficacement des outils externes pour les accomplir, tout en affinant continuellement leur production en fonction des retours de l'environnement. + +--- + +Plongeons maintenant plus en profondeur dans la PensĂ©e, l'Action et l'Observation en tant qu'Ă©tapes individuelles du processus. diff --git a/units/fr/unit1/conclusion.mdx b/units/fr/unit1/conclusion.mdx new file mode 100644 index 00000000..2cd4386a --- /dev/null +++ b/units/fr/unit1/conclusion.mdx @@ -0,0 +1,19 @@ +# Conclusion [[conclusion]] + +FĂ©licitations pour avoir terminĂ© cette premiĂšre UnitĂ© đŸ„ł + +Vous venez de **maĂźtriser les fondamentaux des Agents** et vous avez crĂ©Ă© votre premier Agent IA ! + +Il est **normal que vous soyez encore un peu confus par certains Ă©lĂ©ments**. Les Agents sont un sujet complexe et il est courant de mettre un certain temps Ă  tout comprendre. + +**Prenez le temps de bien assimiler le contenu** avant de continuer. Il est important de maĂźtriser ces Ă©lĂ©ments et d'avoir une base solide avant de passer Ă  la partie amusante. + +Et si vous rĂ©ussissez le quiz, n'oubliez pas de rĂ©cupĂ©rer votre certificat 🎓 👉 [ici](https://huggingface.co/spaces/agents-course/unit1-certification-app) + +Exemple de Certificat + +Dans la prochaine unitĂ© (bonus), vous allez apprendre **Ă  affiner un Agent pour qu'il puisse appeler des fonctions (c'est-Ă -dire pour ĂȘtre capable d'appeler des outils en fonction de l'invite de l'utilisateur)**. + +Enfin, nous serions ravis **d'entendre ce que vous pensez du cours et comment nous pourrions l'amĂ©liorer**. Si vous avez des retours, veuillez 👉 [remplir ce formulaire](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog) + +### Continuez d'apprendre, restez gĂ©nial đŸ€— diff --git a/units/fr/unit1/dummy-agent-library.mdx b/units/fr/unit1/dummy-agent-library.mdx new file mode 100644 index 00000000..292c2ea9 --- /dev/null +++ b/units/fr/unit1/dummy-agent-library.mdx @@ -0,0 +1,336 @@ +# BibliothĂšque d'Agents Factices + +Planification de l'UnitĂ© 1 + +Ce cours est indĂ©pendant de tout framework car nous souhaitons **nous concentrer sur les concepts des agents d'IA et Ă©viter de nous enliser dans les spĂ©cificitĂ©s d'un framework particulier**. + +De plus, nous voulons que les Ă©tudiants puissent utiliser les concepts qu'ils apprennent dans ce cours dans leurs propres projets, en utilisant le framework de leur choix. + +Ainsi, pour cette UnitĂ© 1, nous utiliserons une bibliothĂšque d'agents factices et une API serverless simple pour accĂ©der Ă  notre moteur LLM. + +Vous n'utiliseriez probablement pas ces outils en production, mais ils serviront de bon **point de dĂ©part pour comprendre le fonctionnement des agents**. + +AprĂšs cette section, vous serez prĂȘt Ă  **crĂ©er un agent simple** en utilisant `smolagents` + +Et dans les unitĂ©s suivantes, nous utiliserons Ă©galement d'autres bibliothĂšques d'agents d'IA telles que `LangGraph`, `LangChain` et `LlamaIndex`. + +Pour simplifier, nous utiliserons une fonction Python simple comme Tool et Agent. + +Nous utiliserons des packages intĂ©grĂ©s de Python tels que `datetime` et `os` afin que vous puissiez l'essayer dans n'importe quel environnement. + +Vous pouvez suivre le processus [dans ce notebook](https://huggingface.co/agents-course/notebooks/blob/main/dummy_agent_library.ipynb) et **exĂ©cuter le code vous-mĂȘme**. + +## API serverless + +Dans l'Ă©cosystĂšme Hugging Face, il existe une fonctionnalitĂ© pratique appelĂ©e API serverless qui vous permet d'exĂ©cuter facilement des infĂ©rences sur de nombreux modĂšles. Aucune installation ou dĂ©ploiement n'est requis. + +```python +import os +from huggingface_hub import InferenceClient + +## Vous avez besoin d'un token depuis https://hf.co/settings/tokens. Si vous exĂ©cutez ceci sur Google Colab, vous pouvez le configurer dans l'onglet "settings" sous "secrets". Assurez-vous de l'appeler "HF_TOKEN" +os.environ["HF_TOKEN"] = "hf_xxxxxxxxxxxxxx" + +client = InferenceClient("meta-llama/Llama-3.2-3B-Instruct") +# si les sorties des cellules suivantes sont incorrectes, le modĂšle gratuit peut ĂȘtre surchargĂ©. Vous pouvez Ă©galement utiliser ce point d'accĂšs public qui contient Llama-3.2-3B-Instruct +# client = InferenceClient("https://jc26mwg228mkj8dw.us-east-1.aws.endpoints.huggingface.cloud") +``` + +```python +output = client.text_generation( + "The capital of France is", + max_new_tokens=100, +) + +print(output) +``` + +output: +``` +Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. La capitale de la France est Paris. +``` + +Comme nous l'avons vu dans la section LLM, si nous faisons simplement du dĂ©codage, **le modĂšle s'arrĂȘtera uniquement lorsqu'il prĂ©dit un token EOS**, et cela ne se produit pas ici car il s'agit d'un modĂšle conversationnel (chat) et **nous n'avons pas appliquĂ© le template de chat attendu**. + +Si nous ajoutons maintenant les tokens spĂ©ciaux relatifs au [modĂšle Llama-3.2-3B-Instruct](https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct) que nous utilisons, le comportement change et il produit dĂ©sormais le token EOS attendu. + +```python +prompt = """<|begin_of_text|><|start_header_id|>user<|end_header_id|> +The capital of France is<|eot_id|><|start_header_id|>assistant<|end_header_id|>""" +output = client.text_generation( + prompt, + max_new_tokens=100, +) + +print(output) +``` + +output: +``` +The capital of France is Paris. +``` + +Utiliser la mĂ©thode "chat" est une façon bien plus pratique et fiable d'appliquer les templates de chat : +```python +output = client.chat.completions.create( + messages=[ + {"role": "user", "content": "La capitale de la France est"}, + ], + stream=False, + max_tokens=1024, +) +print(output.choices[0].message.content) +``` + +output: +``` +Paris. +``` + +La mĂ©thode de chat est la mĂ©thode **RECOMMANDÉE** Ă  utiliser afin d'assurer une transition fluide entre les modĂšles, mais comme ce notebook est uniquement Ă  des fins pĂ©dagogiques, nous continuerons Ă  utiliser la mĂ©thode "text_generation" pour comprendre les dĂ©tails. + +## Agent factice + +Dans les sections prĂ©cĂ©dentes, nous avons vu que le cƓur d'une bibliothĂšque d'agents consiste Ă  ajouter des informations dans le prompt systĂšme. + +Ce prompt systĂšme est un peu plus complexe que celui que nous avons vu prĂ©cĂ©demment, mais il contient dĂ©jĂ  : + +1. **Informations sur les outils** +2. **Instructions de cycle** (Thought → Action → Observation) + +``` +RĂ©pondez du mieux que vous pouvez aux questions suivantes. Vous avez accĂšs aux outils suivants: + +get_weather: Obtenez la mĂ©tĂ©o actuelle dans un lieu donnĂ© + +La maniĂšre d'utiliser les outils consiste Ă  spĂ©cifier un blob JSON. +Plus prĂ©cisĂ©ment, ce JSON doit contenir une clĂ© `action` (avec le nom de l'outil Ă  utiliser) et une clĂ© `action_input` (avec l'entrĂ©e destinĂ©e Ă  l'outil). + +Les seules valeurs qui devraient figurer dans le champ "action" sont: +get_weather: Obtenez la mĂ©tĂ©o actuelle dans un lieu donnĂ©, args: {"location": {"type": "string"}} +exemple d'utilisation : + +{{ + "action": "get_weather", + "action_input": {"location": "New York"} +}} + +UTILISEZ TOUJOURS le format suivant: + +Question : la question Ă  laquelle vous devez rĂ©pondre +RĂ©flexion : vous devez toujours rĂ©flĂ©chir Ă  une action Ă  entreprendre. Une seule action Ă  la fois dans ce format: +Action: + +$JSON_BLOB (dans une cellule markdown) + +Observation : le rĂ©sultat de l'action. Cette Observation est unique, complĂšte et constitue la source de vĂ©ritĂ©. +... (ce cycle RĂ©flexion/Action/Observation peut se rĂ©pĂ©ter plusieurs fois, vous devez effectuer plusieurs Ă©tapes si nĂ©cessaire. Le $JSON_BLOB doit ĂȘtre formatĂ© en markdown et n'utiliser qu'une SEULE action Ă  la fois.) + +Vous devez toujours terminer votre sortie avec le format suivant: + +RĂ©flexion : Je connais dĂ©sormais la rĂ©ponse finale +Final Answer: la rĂ©ponse finale Ă  la question d'entrĂ©e initiale + +Commencez maintenant! Rappel: utilisez TOUJOURS exactement les caractĂšres `Final Answer:` lorsque vous fournissez une rĂ©ponse dĂ©finitive. +``` + +Puisque nous utilisons la mĂ©thode "text_generation", nous devons appliquer le prompt manuellement: +```python +prompt = f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|> +{SYSTEM_PROMPT} +<|eot_id|><|start_header_id|>user<|end_header_id|> +Quel temps fait-il Ă  Londres ? +<|eot_id|><|start_header_id|>assistant<|end_header_id|> +""" +``` + +Nous pouvons Ă©galement le faire ainsi, ce qui est ce qui se passe dans la mĂ©thode `chat` : +```python +messages = [ + {"role": "system", "content": SYSTEM_PROMPT}, + {"role": "user", "content": "Quel temps fait-il Ă  Londres ?"}, +] +from transformers import AutoTokenizer +tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct") + +tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) +``` + +Le prompt est maintenant : +``` +<|begin_of_text|><|start_header_id|>system<|end_header_id|> +RĂ©pondez du mieux que vous pouvez aux questions suivantes. Vous avez accĂšs aux outils suivants: + +get_weather: Obtenez la mĂ©tĂ©o actuelle dans un lieu donnĂ© + +La maniĂšre d'utiliser les outils consiste Ă  spĂ©cifier un blob JSON. +Plus prĂ©cisĂ©ment, ce JSON doit contenir une clĂ© `action` (avec le nom de l'outil Ă  utiliser) et une clĂ© `action_input` (avec l'entrĂ©e destinĂ©e Ă  l'outil). + +Les seules valeurs qui devraient figurer dans le champ "action" sont: +get_weather: Obtenez la mĂ©tĂ©o actuelle dans un lieu donnĂ©, args: {"location": {"type": "string"}} +exemple d'utilisation : + +{{ + "action": "get_weather", + "action_input": {"location": "New York"} +}} + +UTILISEZ TOUJOURS le format suivant: + +Question : la question Ă  laquelle vous devez rĂ©pondre +RĂ©flexion : vous devez toujours rĂ©flĂ©chir Ă  une action Ă  entreprendre. Une seule action Ă  la fois dans ce format: +Action: + +$JSON_BLOB (dans une cellule markdown) + +Observation : le rĂ©sultat de l'action. Cette Observation est unique, complĂšte et constitue la source de vĂ©ritĂ©. +... (ce cycle RĂ©flexion/Action/Observation peut se rĂ©pĂ©ter plusieurs fois, vous devez effectuer plusieurs Ă©tapes si nĂ©cessaire. Le $JSON_BLOB doit ĂȘtre formatĂ© en markdown et n'utiliser qu'une SEULE action Ă  la fois.) + +Vous devez toujours terminer votre sortie avec le format suivant: + +RĂ©flexion : Je connais dĂ©sormais la rĂ©ponse finale +Final Answer: la rĂ©ponse finale Ă  la question d'entrĂ©e initiale + +Commencez maintenant! Rappel: utilisez TOUJOURS exactement les caractĂšres `Final Answer:` lorsque vous fournissez une rĂ©ponse dĂ©finitive. +<|eot_id|><|start_header_id|>user<|end_header_id|> +Quel temps fait-il Ă  Londres ? +<|eot_id|><|start_header_id|>assistant<|end_header_id|> +``` + +DĂ©codons ! +```python +output = client.text_generation( + prompt, + max_new_tokens=200, +) + +print(output) +``` + +output: + +``` +Action: +``` +{ + "action": "get_weather", + "action_input": {"location": "London"} +} +``` +RĂ©flexion : Je vais vĂ©rifier la mĂ©tĂ©o Ă  Londres. +Observation : La mĂ©tĂ©o actuelle Ă  Londres est principalement nuageuse avec un maximum de 12°C et un minimum de 8°C. +``` + +Voyez-vous le problĂšme ? +> La rĂ©ponse a Ă©tĂ© hallucinĂ©e par le modĂšle. Nous devons arrĂȘter avant d'exĂ©cuter rĂ©ellement la fonction ! +ArrĂȘtons-nous maintenant sur "Observation" afin de ne pas halluciner la vĂ©ritable rĂ©ponse de la fonction. + +```python +output = client.text_generation( + prompt, + max_new_tokens=200, + stop=["Observation:"] +) + +print(output) +``` + +output: + +``` +Action: +``` +{ + "action": "get_weather", + "action_input": {"location": "London"} +} +``` +RĂ©flexion : Je vais vĂ©rifier la mĂ©tĂ©o Ă  Londres. +Observation: +``` + +Beaucoup mieux ! + +CrĂ©ons maintenant une fonction factice pour obtenir la mĂ©tĂ©o. Dans une situation rĂ©elle, vous appelleriez probablement une API. + +```python +# Fonction factice +def get_weather(location): + return f"la mĂ©tĂ©o Ă  {location} est ensoleillĂ©e avec des tempĂ©ratures basses. \n" + +get_weather('London') +``` + +output: +``` +'la mĂ©tĂ©o Ă  London est ensoleillĂ©e avec des tempĂ©ratures basses. \n' +``` + +ConcatĂ©nons le prompt de base, la complĂ©tion jusqu'Ă  l'exĂ©cution de la fonction et le rĂ©sultat de la fonction en tant qu'Observation, puis reprenons la gĂ©nĂ©ration. + +```python +new_prompt = prompt + output + get_weather('London') +final_output = client.text_generation( + new_prompt, + max_new_tokens=200, +) + +print(final_output) +``` + +Voici le nouveau prompt: +``` +<|begin_of_text|><|start_header_id|>system<|end_header_id|> +RĂ©pondez du mieux que vous pouvez aux questions suivantes. Vous avez accĂšs aux outils suivants: + +get_weather: Obtenez la mĂ©tĂ©o actuelle dans un lieu donnĂ© + +La maniĂšre d'utiliser les outils consiste Ă  spĂ©cifier un blob JSON. +Plus prĂ©cisĂ©ment, ce JSON doit contenir une clĂ© `action` (avec le nom de l'outil Ă  utiliser) et une clĂ© `action_input` (avec l'entrĂ©e destinĂ©e Ă  l'outil). + +Les seules valeurs qui devraient figurer dans le champ "action" sont: +get_weather: Obtenez la mĂ©tĂ©o actuelle dans un lieu donnĂ©, args: {"location": {"type": "string"}} +exemple d'utilisation : + +{{ + "action": "get_weather", + "action_input": {"location": "New York"} +}} + +UTILISEZ TOUJOURS le format suivant: + +Question : la question Ă  laquelle vous devez rĂ©pondre +RĂ©flexion : vous devez toujours rĂ©flĂ©chir Ă  une action Ă  entreprendre. Une seule action Ă  la fois dans ce format: +Action: + +$JSON_BLOB (dans une cellule markdown) + +Observation : le rĂ©sultat de l'action. Cette Observation est unique, complĂšte et constitue la source de vĂ©ritĂ©. +... (ce cycle RĂ©flexion/Action/Observation peut se rĂ©pĂ©ter plusieurs fois, vous devez effectuer plusieurs Ă©tapes si nĂ©cessaire. Le $JSON_BLOB doit ĂȘtre formatĂ© en markdown et n'utiliser qu'une SEULE action Ă  la fois.) + +Vous devez toujours terminer votre sortie avec le format suivant: + +RĂ©flexion : Je connais dĂ©sormais la rĂ©ponse finale +Final Answer: la rĂ©ponse finale Ă  la question d'entrĂ©e initiale + +Commencez maintenant! Rappel: utilisez TOUJOURS exactement les caractĂšres `Final Answer:` lorsque vous fournissez une rĂ©ponse dĂ©finitive. +<|eot_id|><|start_header_id|>user<|end_header_id|> +Quel temps fait-il Ă  Londres ? +<|eot_id|><|start_header_id|>assistant<|end_header_id|> +``` + +Output: +``` +Final Answer: La mĂ©tĂ©o Ă  Londres est ensoleillĂ©e avec des tempĂ©ratures basses. +``` + +--- + +Nous avons appris comment crĂ©er des Agents Ă  partir de zĂ©ro en utilisant du code Python, et nous **avons constatĂ© Ă  quel point ce processus peut ĂȘtre fastidieux**. Heureusement, de nombreuses bibliothĂšques d'agents simplifient ce travail en prenant en charge la majeure partie de la charge de travail pour vous. + +Maintenant, nous sommes prĂȘts **Ă  crĂ©er notre premier vrai Agent** en utilisant la bibliothĂšque `smolagents`. + + + + + diff --git a/units/fr/unit1/final-quiz.mdx b/units/fr/unit1/final-quiz.mdx new file mode 100644 index 00000000..c215450c --- /dev/null +++ b/units/fr/unit1/final-quiz.mdx @@ -0,0 +1,24 @@ +# Quiz de l'UnitĂ© 1 + +Planification de l'UnitĂ© 1 + +Bravo d'avoir terminĂ© la premiĂšre unitĂ© ! Testons maintenant votre comprĂ©hension des concepts clĂ©s abordĂ©s jusqu'Ă  prĂ©sent. + +Une fois que vous aurez rĂ©ussi le quiz, passez Ă  la section suivante pour rĂ©clamer votre certificat. + +Bonne chance ! + +## Quiz + +Voici le quiz interactif. Le quiz est hĂ©bergĂ© sur le Hub de Hugging Face dans un espace. Il vous guidera Ă  travers une sĂ©rie de questions Ă  choix multiples afin de tester votre comprĂ©hension des concepts clĂ©s abordĂ©s dans cette unitĂ©. Une fois le quiz terminĂ©, vous pourrez voir votre score et une rĂ©partition des rĂ©ponses correctes. + +Un point important : **n'oubliez pas de cliquer sur Soumettre aprĂšs avoir rĂ©ussi, sinon votre note d'examen ne sera pas sauvegardĂ©e !** + + + +Vous pouvez Ă©galement accĂ©der au quiz 👉 [ici](https://huggingface.co/spaces/agents-course/unit_1_quiz) diff --git a/units/fr/unit1/get-your-certificate.mdx b/units/fr/unit1/get-your-certificate.mdx new file mode 100644 index 00000000..1b6ee2e7 --- /dev/null +++ b/units/fr/unit1/get-your-certificate.mdx @@ -0,0 +1,18 @@ +# Obtenez votre certificat + +Planification de l'UnitĂ© 1 + +Maintenant que vous avez rĂ©ussi le quiz, **vous pouvez obtenir votre certificat 🎓** + +Pour obtenir ce certificat, vous devez complĂ©ter l'UnitĂ© 1 du cours Agents et **rĂ©ussir au moins 80% du quiz final**. + + + +Vous pouvez Ă©galement accĂ©der au processus de certification 👉 [ici](https://huggingface.co/spaces/agents-course/unit1-certification-app) + +Une fois que vous aurez reçu votre certificat, vous pourrez l'ajouter Ă  votre profil LinkedIn đŸ§‘â€đŸ’Œ ou le partager sur X, Bluesky, etc. **Nous serions trĂšs fiers et ravis de vous fĂ©liciter si vous taguez @huggingface**! đŸ€— diff --git a/units/fr/unit1/introduction.mdx b/units/fr/unit1/introduction.mdx new file mode 100644 index 00000000..b10fcb04 --- /dev/null +++ b/units/fr/unit1/introduction.mdx @@ -0,0 +1,38 @@ +# Introduction aux Agents + +Vignette + +Bienvenue dans cette premiĂšre unitĂ©, oĂč **vous allez construire une base solide dans les fondamentaux des Agents IA** comprenant : + +- **Comprendre les Agents** + - Qu'est-ce qu'un Agent, et comment fonctionne-t-il ? + - Comment les Agents prennent-ils des dĂ©cisions en utilisant le raisonnement et la planification ? + +- **Le RĂŽle des LLM (Large Language Models) dans les Agents** + - Comment les LLM servent de « cerveau » derriĂšre un Agent. + - Comment les LLM structurent les conversations via le systĂšme de messages. + +- **Outils et Actions** + - Comment les Agents utilisent des outils externes pour interagir avec l'environnement. + - Comment construire et intĂ©grer des outils pour votre Agent. + +- **Le The Agent Workflow :** + - *Think* → *Act* → *Observe* (*Penser* → *Agir* → *Observer*). + +AprĂšs avoir explorĂ© ces sujets, **vous construirez votre premier Agent** en utilisant `smolagents` ! + +Votre Agent, nommĂ© Alfred, rĂ©alisera une tĂąche simple et dĂ©montrera comment appliquer ces concepts en pratique. + +Vous apprendrez mĂȘme comment **publier votre Agent sur Hugging Face Spaces**, afin de le partager avec vos amis et collĂšgues. + +Enfin, Ă  la fin de cette UnitĂ©, vous passerez un quiz. RĂ©ussissez-le, et vous **obtiendrez votre premiĂšre certification du cours** : le 🎓 Certificat des Fondamentaux des Agents. + +Exemple de Certificat + +Cette UnitĂ© est votre **point de dĂ©part essentiel**, posant les bases pour comprendre les Agents avant de passer Ă  des sujets plus avancĂ©s. + +Planification de l'UnitĂ© 1 + +C'est une grande unitĂ©, alors **prenez votre temps** et n'hĂ©sitez pas Ă  revenir sur ces sections de temps en temps. + +PrĂȘt ? Plongeons dans l'aventure ! 🚀 diff --git a/units/fr/unit1/messages-and-special-tokens.mdx b/units/fr/unit1/messages-and-special-tokens.mdx new file mode 100644 index 00000000..de22f65c --- /dev/null +++ b/units/fr/unit1/messages-and-special-tokens.mdx @@ -0,0 +1,33 @@ +# Messages et Tokens SpĂ©ciaux + +Maintenant que nous comprenons comment fonctionnent les LLMs, examinons **comment ils structurent leurs gĂ©nĂ©rations via des modĂšles de chat**. + +Tout comme avec ChatGPT, les utilisateurs interagissent gĂ©nĂ©ralement avec les Agents via une interface de chat. Par consĂ©quent, nous souhaitons comprendre comment les LLMs gĂšrent les chats. + +> **Q** : Mais
 Lorsque j'interagis avec ChatGPT/Hugging Chat, j'ai une conversation en utilisant des messages de chat, et non une seule sĂ©quence de prompt +> +> **A** : C'est exact ! Mais il s'agit en rĂ©alitĂ© d'une abstraction de l'interface utilisateur. Avant d'ĂȘtre injectĂ©s dans le LLM, tous les messages de la conversation sont concatĂ©nĂ©s en un seul prompt. Le modĂšle ne « se souvient » pas de la conversation : il la lit en intĂ©gralitĂ© Ă  chaque fois. + +Jusqu'Ă  prĂ©sent, nous avons parlĂ© des prompts comme Ă©tant la sĂ©quence de tokens envoyĂ©e dans le modĂšle. Mais lorsque vous discutez avec des systĂšmes tels que ChatGPT ou Hugging Chat, **vous Ă©changez en rĂ©alitĂ© des messages**. Dans les coulisses, ces messages sont **concatĂ©nĂ©s et formatĂ©s en un prompt que le modĂšle peut comprendre**. + +
+DerriĂšre les modĂšles +
Nous voyons ici la différence entre ce que nous voyons dans l'interface utilisateur et le prompt envoyée au modÚle.
+
+ +C'est lĂ  qu'interviennent les modĂšles de chat. Ils servent de **pont entre les messages de conversation (tours d'utilisateur et d'assistant) et les exigences de formatage spĂ©cifiques** de votre LLM choisi. En d'autres termes, les modĂšles de chat structurent la communication entre l'utilisateur et l'agent, en s'assurant que chaque modĂšle — malgrĂ© ses tokens spĂ©ciaux uniques — reçoive le prompt correctement formatĂ©e. + +Nous parlons Ă  nouveau des tokens spĂ©ciaux, car ce sont eux que les modĂšles utilisent pour dĂ©limiter le dĂ©but et la fin des tours de l'utilisateur et de l'assistant. De mĂȘme que chaque LLM utilise son propre token EOS (End Of Sequence), ils emploient Ă©galement diffĂ©rentes rĂšgles de formatage et dĂ©limiteurs pour les messages dans la conversation. + +## Messages : Le systĂšme sous-jacent des LLMs +### Messages SystĂšme + +Les messages systĂšme (Ă©galement appelĂ©s prompts systĂšme) dĂ©finissent **comment le modĂšle doit se comporter**. Ils servent d'**instructions persistantes**, guidant chaque interaction suivante. + +Par exemple : + +```python +system_message = { + "role": "system", + "content": "Vous ĂȘtes un agent de service client professionnel. Soyez toujours poli, clair et utile." +} diff --git a/units/fr/unit1/observations.mdx b/units/fr/unit1/observations.mdx new file mode 100644 index 00000000..10866e74 --- /dev/null +++ b/units/fr/unit1/observations.mdx @@ -0,0 +1,45 @@ +# Observer : IntĂ©grer le retour d'information pour rĂ©flĂ©chir et s'adapter + +Les observations sont **la maniĂšre dont un agent perçoit les consĂ©quences de ses actions**. + +Elles fournissent des informations cruciales qui alimentent le processus de rĂ©flexion de l'agent et orientent ses actions futures. + +Ce sont **des signaux provenant de l'environnement** — qu'il s'agisse de donnĂ©es issues d'une API, de messages d'erreur ou de journaux systĂšme — qui guident le prochain cycle de rĂ©flexion. + +Dans la phase d'observation, l'agent : + +- **Collecte des retours :** reçoit des donnĂ©es ou une confirmation que son action a rĂ©ussi (ou non). +- **Ajoute les rĂ©sultats :** intĂšgre la nouvelle information dans son contexte existant, mettant ainsi Ă  jour sa mĂ©moire. +- **Adapte sa stratĂ©gie :** utilise ce contexte mis Ă  jour pour affiner ses rĂ©flexions et ses actions ultĂ©rieures. + +Par exemple, si une API mĂ©tĂ©o renvoie les donnĂ©es *"partiellement nuageux, 15°C, 60 % d'humiditĂ©"*, cette observation est ajoutĂ©e Ă  la mĂ©moire de l'agent (Ă  la fin du prompt). + +L'agent l'utilise ensuite pour dĂ©cider si des informations supplĂ©mentaires sont nĂ©cessaires ou s'il est prĂȘt Ă  fournir une rĂ©ponse finale. + +Cette **intĂ©gration itĂ©rative des retours d'information assure que l'agent reste dynamiquement alignĂ© avec ses objectifs**, apprenant et s'ajustant constamment en fonction des rĂ©sultats concrets. + +Ces observations **peuvent prendre de nombreuses formes**, allant de la lecture de texte sur une page web Ă  la surveillance de la position d'un bras robotisĂ©. On peut les considĂ©rer comme des "logs" d'outils qui fournissent un retour textuel sur l'exĂ©cution d'une action. + +| Type d'observation | Exemple | +|----------------------------|---------------------------------------------------------------------------------------------| +| Retour systĂšme | Messages d'erreur, notifications de succĂšs, codes de statut | +| Modifications de donnĂ©es | Mises Ă  jour de base de donnĂ©es, modifications du systĂšme de fichiers, changements d'Ă©tat | +| DonnĂ©es environnementales | RelevĂ©s de capteurs, mĂ©triques systĂšme, utilisation des ressources | +| Analyse des rĂ©ponses | RĂ©ponses d'API, rĂ©sultats de requĂȘtes, sorties de calcul | +| ÉvĂ©nements temporels | Dates limites atteintes, tĂąches programmĂ©es terminĂ©es | + +## Comment les rĂ©sultats sont-ils ajoutĂ©s ? + +AprĂšs avoir effectuĂ© une action, le framework suit les Ă©tapes suivantes dans l'ordre : + +1. **Analyser l'action** pour identifier la ou les fonctions Ă  appeler et les arguments Ă  utiliser. +2. **ExĂ©cuter l'action.** +3. **Ajouter le rĂ©sultat** en tant qu'**Observation**. + +--- + +Nous avons maintenant appris le cycle de pensĂ©e-action-observation de l'agent. + +Si certains aspects vous semblent encore un peu flous, ne vous inquiĂ©tez pas — nous reviendrons sur ces concepts et les approfondirons dans les prochaines unitĂ©s. + +Il est maintenant temps de mettre vos connaissances en pratique en codant votre tout premier agent ! diff --git a/units/fr/unit1/quiz1.mdx b/units/fr/unit1/quiz1.mdx new file mode 100644 index 00000000..48cb64e9 --- /dev/null +++ b/units/fr/unit1/quiz1.mdx @@ -0,0 +1,171 @@ +# Petit Quiz (non notĂ©) [[quiz1]] + +Jusqu'Ă  prĂ©sent, vous avez compris la vue d'ensemble des Agents, ce qu'ils sont et comment ils fonctionnent. Il est temps de passer Ă  un court quiz, car **se tester soi-mĂȘme** est la meilleure façon d'apprendre et [d'Ă©viter l'illusion de compĂ©tence](https://www.coursera.org/lecture/learning-how-to-learn/illusions-of-competence-BuFzf). Cela vous aidera Ă  dĂ©terminer **les points sur lesquels vous devez renforcer vos connaissances**. + +Ce quiz est optionnel et n'est pas notĂ©. + +--- + +### Q1 : Qu'est-ce qu'un Agent ? +Laquelle des propositions suivantes dĂ©crit le mieux un Agent IA ? + + + +--- + +### Q2 : Quel est le rĂŽle de la planification chez un Agent ? +Pourquoi un Agent a-t-il besoin de planifier avant d'agir ? + + + +--- + +### Q3 : Comment les outils amĂ©liorent-ils les capacitĂ©s d'un Agent ? +Pourquoi les outils sont-ils essentiels pour un Agent ? + + + +--- + +### Q4 : Quelle est la principale diffĂ©rence entre Actions et Outils ? +Quelle est la principale diffĂ©rence entre les Actions et les Outils ? + + + +--- + +### Q5 : Quel rĂŽle jouent les Large Language Models (LLMs) dans les Agents ? +Comment les LLM contribuent-ils aux fonctionnalitĂ©s d'un Agent ? + + + +--- + +### Q6 : Lequel des exemples suivants illustre le mieux un Agent IA ? +Quel exemple concret illustre le mieux un Agent IA en action ? + + + +--- + +FĂ©licitations pour avoir terminĂ© ce Quiz đŸ„ł, si certains Ă©lĂ©ments vous ont Ă©chappĂ©, prenez le temps de relire le chapitre pour renforcer vos connaissances. Si vous le rĂ©ussissez, vous ĂȘtes prĂȘt Ă  plonger plus en profondeur dans le « cerveau de l'Agent » : les LLM. diff --git a/units/fr/unit1/quiz2.mdx b/units/fr/unit1/quiz2.mdx new file mode 100644 index 00000000..a057092b --- /dev/null +++ b/units/fr/unit1/quiz2.mdx @@ -0,0 +1,117 @@ +# VĂ©rification rapide personnelle (non notĂ©e) [[quiz2]] + +Hein ?! Un autre quiz ? On sait, on sait, ... 😅 Mais ce court quiz non notĂ© est lĂ  pour **vous aider Ă  renforcer les concepts clĂ©s que vous venez d'apprendre**. + +Ce quiz porte sur les modĂšles de langage de grande taille (LLMs), les systĂšmes de messages et les outils ; des composants essentiels pour comprendre et construire des agents d'IA. + +### Q1 : Laquelle des propositions suivantes dĂ©crit le mieux un outil d'IA ? + + + +--- + +### Q2 : Comment les agents d'IA utilisent-ils les outils comme moyen d'« agir » dans un environnement ? + + + +--- + +### Q3 : Qu'est-ce qu'un modĂšle de langage de grande taille (LLM) ? + + + +--- + +### Q4 : Laquelle des propositions suivantes dĂ©crit le mieux le rĂŽle des tokens spĂ©ciaux dans les LLMs ? + + + +--- + +### Q5 : Comment les modĂšles de chat d'IA traitent-ils les messages des utilisateurs en interne ? + + + +--- + +Vous avez compris ? Super ! Maintenant, **plongeons dans le flux complet de l'Agent et commençons Ă  construire votre premier Agent IA !** diff --git a/units/fr/unit1/thoughts.mdx b/units/fr/unit1/thoughts.mdx new file mode 100644 index 00000000..f0f2453a --- /dev/null +++ b/units/fr/unit1/thoughts.mdx @@ -0,0 +1,55 @@ +# PensĂ©e : Raisonnement Interne et l'Approche Re-Act + + +Dans cette section, nous plongeons dans le fonctionnement interne d'un agent d'IA — sa capacitĂ© Ă  raisonner et Ă  planifier. Nous explorerons comment l'agent utilise son dialogue interne pour analyser l'information, dĂ©composer des problĂšmes complexes en Ă©tapes gĂ©rables, et dĂ©cider de l'action Ă  entreprendre ensuite. De plus, nous prĂ©sentons l'approche Re-Act, une technique d'invite qui encourage le modĂšle Ă  rĂ©flĂ©chir « Ă©tape par Ă©tape » avant d'agir. + + +Les pensĂ©es reprĂ©sentent les **processus internes de raisonnement et de planification de l'agent** pour rĂ©soudre la tĂąche. + +Cela exploite la capacitĂ© du Large Language Model (LLM) de l'agent **Ă  analyser l'information lorsqu'elle est prĂ©sentĂ©e dans son prompt**. + +Pensez-y comme le dialogue interne de l'agent, oĂč il considĂšre la tĂąche Ă  accomplir et Ă©labore sa stratĂ©gie. + +Les pensĂ©es de l'agent sont responsables d'accĂ©der aux observations actuelles et de dĂ©cider quelles seront les prochaines actions. + +GrĂące Ă  ce processus, l'agent peut **dĂ©composer des problĂšmes complexes en Ă©tapes plus petites et gĂ©rables**, rĂ©flĂ©chir sur des expĂ©riences passĂ©es et ajuster continuellement ses plans en fonction des nouvelles informations. + +Voici quelques exemples de pensĂ©es courantes : + +| Type de PensĂ©e | Exemple | +|------------------------|-----------------------------------------------------------------------------------------------------------| +| Planification | "Je dois dĂ©composer cette tĂąche en trois Ă©tapes : 1) recueillir les donnĂ©es, 2) analyser les tendances, 3) gĂ©nĂ©rer le rapport" | +| Analyse | "D'aprĂšs le message d'erreur, le problĂšme semble provenir des paramĂštres de connexion Ă  la base de donnĂ©es" | +| Prise de DĂ©cision | "Étant donnĂ© les contraintes budgĂ©taires de l'utilisateur, je devrais recommander l'option de milieu de gamme" | +| RĂ©solution de ProblĂšme | "Pour optimiser ce code, je devrais d'abord le profiler pour identifier les goulets d'Ă©tranglement" | +| IntĂ©gration de la MĂ©moire | "L'utilisateur avait mentionnĂ© sa prĂ©fĂ©rence pour Python plus tĂŽt, donc je fournirai des exemples en Python" | +| Auto-RĂ©flexion | "Ma derniĂšre approche n'a pas bien fonctionnĂ©, je devrais essayer une stratĂ©gie diffĂ©rente" | +| DĂ©finition d'Objectifs | "Pour accomplir cette tĂąche, je dois d'abord Ă©tablir les critĂšres d'acceptation" | +| Priorisation | "La vulnĂ©rabilitĂ© de sĂ©curitĂ© doit ĂȘtre traitĂ©e avant d'ajouter de nouvelles fonctionnalitĂ©s" | + +> **Remarque :** Dans le cas des LLMs ajustĂ©s pour l'appel de fonction, le processus de pensĂ©e est optionnel. +> *Si vous n'ĂȘtes pas familier avec l'appel de fonction, plus de dĂ©tails seront donnĂ©s dans la section Actions.* + +## L'approche Re-Act + +Une mĂ©thode clĂ© est l'**approche Re-Act**, qui est la concatĂ©nation de "Raisonnement" (Reasoning) et "Action" (Act). + +Re-Act est une technique de prompting simple qui ajoute "RĂ©flĂ©chissons Ă©tape par Ă©tape" avant de laisser le LLM dĂ©coder les tokens suivants. + +En effet, inviter le modĂšle Ă  rĂ©flĂ©chir "Ă©tape par Ă©tape" encourage le processus de dĂ©codage vers des tokens **qui gĂ©nĂšrent un plan**, plutĂŽt qu'une solution finale, puisque le modĂšle est incitĂ© Ă  **dĂ©composer** le problĂšme en *sous-tĂąches*. + +Cela permet au modĂšle d'examiner les sous-Ă©tapes plus en dĂ©tail, ce qui conduit gĂ©nĂ©ralement Ă  moins d'erreurs que d'essayer de gĂ©nĂ©rer directement la solution finale. + +
+ReAct +
Le (d) est un exemple de l'approche Re-Act oĂč nous invitons "RĂ©flĂ©chissons Ă©tape par Ă©tape"
+
+ + +Nous avons rĂ©cemment observĂ© un vif intĂ©rĂȘt pour les stratĂ©gies de raisonnement. C'est ce qui sous-tend des modĂšles comme Deepseek R1 ou l'o1 d'OpenAI, qui ont Ă©tĂ© ajustĂ©s pour "rĂ©flĂ©chir avant de rĂ©pondre". + +Ces modĂšles ont Ă©tĂ© entraĂźnĂ©s pour inclure systĂ©matiquement des sections spĂ©cifiques de _rĂ©flexion_ (encadrĂ©es par les tokens spĂ©ciaux `` et ``). Il ne s'agit pas simplement d'une technique d'invite comme Re-Act, mais d'une mĂ©thode d'entraĂźnement oĂč le modĂšle apprend Ă  gĂ©nĂ©rer ces sections aprĂšs avoir analysĂ© des milliers d'exemples montrant ce que nous attendons de lui. + + +--- +Maintenant que nous comprenons mieux le processus de pensĂ©e, approfondissons la seconde partie du processus : l'Action. diff --git a/units/fr/unit1/tools.mdx b/units/fr/unit1/tools.mdx new file mode 100644 index 00000000..5c6aeb66 --- /dev/null +++ b/units/fr/unit1/tools.mdx @@ -0,0 +1,298 @@ +# Qu'est-ce que les Outils ? + +Planification de l'UnitĂ© 1 + +Un aspect crucial des agents d'IA est leur capacitĂ© Ă  prendre des **actions**. Comme nous l'avons vu, cela se fait par l'utilisation des **outils**. + +Dans cette section, nous verrons ce que sont les outils, comment les concevoir efficacement, et comment les intĂ©grer dans votre agent via le message systĂšme. + +En fournissant Ă  votre agent les bons outils — et en dĂ©crivant clairement le fonctionnement de ces outils — vous pouvez augmenter de maniĂšre spectaculaire ce que votre IA peut accomplir. Plongeons-nous dedans ! + +## Qu'est-ce que les outils d'IA ? + +Un **outil est une fonction fournie au LLM**. Cette fonction doit remplir un **objectif clair**. + +Voici quelques outils couramment utilisĂ©s dans les agents d'IA : + +| Outil | Description | +|---------------------|-------------------------------------------------------------------------------------------------| +| Recherche Web | Permet Ă  l'agent de rĂ©cupĂ©rer des informations Ă  jour depuis Internet. | +| GĂ©nĂ©ration d'images | CrĂ©e des images Ă  partir de descriptions textuelles. | +| RĂ©cupĂ©ration | RĂ©cupĂšre des informations Ă  partir d'une source externe. | +| Interface API | Interagit avec une API externe (GitHub, YouTube, Spotify, etc.). | + +Ce ne sont que des exemples, car en rĂ©alitĂ©, vous pouvez crĂ©er un outil pour n'importe quel cas d'utilisation ! + +Un bon outil doit ĂȘtre quelque chose qui **complĂ©mente la puissance d'un LLM**. + +Par exemple, si vous devez effectuer des opĂ©rations arithmĂ©tiques, fournir un **outil calculatrice** Ă  votre LLM donnera de meilleurs rĂ©sultats que de se fier aux capacitĂ©s natives du modĂšle. + +De plus, **les LLMs prĂ©disent la complĂ©tion d'une invite en se basant sur leurs donnĂ©es d'entraĂźnement**, ce qui signifie que leur connaissance interne n'inclut que les Ă©vĂ©nements antĂ©rieurs Ă  leur entraĂźnement. Par consĂ©quent, si votre agent a besoin de donnĂ©es Ă  jour, vous devez les fournir via un outil. + +Par exemple, si vous demandez directement Ă  un LLM (sans outil de recherche) la mĂ©tĂ©o d'aujourd'hui, le LLM pourrait inventer une mĂ©tĂ©o alĂ©atoire. + +MĂ©tĂ©o + +- Un outil doit contenir : + + - Une **description textuelle de ce que fait la fonction**. + - Un *callable* (quelque chose pour effectuer une action). + - Des *arguments* avec typage. + - (Optionnel) Des sorties avec typage. + +## Comment fonctionnent les outils ? + +Comme nous l'avons vu, les LLMs ne peuvent recevoir que des entrĂ©es textuelles et gĂ©nĂ©rer des sorties textuelles. Ils ne peuvent pas appeler des outils par eux-mĂȘmes. Par _fournir des outils Ă  un Agent_, nous **enseignons** au LLM l'existence des outils et lui demandons de gĂ©nĂ©rer du texte qui invoquera ces outils lorsqu'il en aura besoin. Par exemple, si nous fournissons un outil pour vĂ©rifier la mĂ©tĂ©o d'un lieu via Internet, puis que nous demandons au LLM la mĂ©tĂ©o Ă  Paris, le LLM reconnaĂźtra que cette question constitue une opportunitĂ© pertinente pour utiliser l'outil "mĂ©tĂ©o" que nous lui avons enseignĂ©. Le LLM gĂ©nĂ©rera du _texte_, sous forme de code, pour invoquer cet outil. Il incombe Ă  l'**Agent** d'analyser la sortie du LLM, de reconnaĂźtre qu'un appel Ă  un outil est requis, et d'invoquer l'outil au nom du LLM. La sortie de l'outil sera ensuite renvoyĂ©e au LLM, qui composera sa rĂ©ponse finale pour l'utilisateur. + +La sortie d'un appel d'outil est un autre type de message dans la conversation. Les Ă©tapes d'appel d'outil ne sont gĂ©nĂ©ralement pas montrĂ©es Ă  l'utilisateur : l'Agent rĂ©cupĂšre la conversation, appelle l'(les) outil(s), obtient les sorties, les ajoute en tant que nouveau message dans la conversation, et renvoie la conversation mise Ă  jour au LLM. Du point de vue de l'utilisateur, c'est comme si le LLM avait utilisĂ© l'outil, mais en rĂ©alitĂ©, c'est notre code applicatif (l'**Agent**) qui l'a fait. + +Nous parlerons beaucoup plus de ce processus lors de sessions futures. + +## Comment fournir des outils Ă  un LLM ? + +La rĂ©ponse complĂšte peut sembler complexe, mais nous utilisons essentiellement le prompt systĂšme pour fournir au modĂšle des descriptions textuelles des outils disponibles : + +Prompt systĂšme pour les outils + +Pour que cela fonctionne, nous devons ĂȘtre trĂšs prĂ©cis et rigoureux concernant : + +1. **Ce que fait l'outil** +2. **Les entrĂ©es exactes qu'il attend** + +C'est la raison pour laquelle les descriptions d'outils sont gĂ©nĂ©ralement fournies en utilisant des structures expressives mais prĂ©cises, telles que des langages informatiques ou du JSON. Il n'est pas _nĂ©cessaire_ de procĂ©der ainsi, tout format prĂ©cis et cohĂ©rent fonctionnerait. + +Si cela semble trop thĂ©orique, comprenons-le Ă  travers un exemple concret. + +Nous allons implĂ©menter un outil **calculatrice** simplifiĂ© qui se contentera de multiplier deux entiers. Voici une implĂ©mentation en Python : + +```python +def calculator(a: int, b: int) -> int: + """Multiplie deux entiers.""" + return a * b + +print(calculator.to_string()) +``` + +Ainsi, notre outil s'appelle `calculator`, il **multiplie deux entiers**, et il requiert les entrĂ©es suivantes : + +- **`a`** (*int*): Un entier. +- **`b`** (*int*): Un entier. + +La sortie de l'outil est un autre nombre entier que nous pouvons dĂ©crire ainsi : +- (*int*): Le produit de `a` et `b`. + +Tous ces dĂ©tails sont importants. Rassemblons-les dans une chaĂźne de texte qui dĂ©crit notre outil pour que le LLM puisse le comprendre. + +``` +Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: int +``` + +> **Rappel :** Cette description textuelle est *ce que nous voulons que le LLM sache Ă  propos de l'outil*. + +Lorsque nous passons la chaĂźne prĂ©cĂ©dente dans l'entrĂ©e du LLM, le modĂšle la reconnaĂźtra comme un outil et saura quelles entrĂ©es fournir et ce qu'il doit attendre en sortie. + +Si nous souhaitons fournir des outils supplĂ©mentaires, nous devons rester cohĂ©rents et utiliser toujours le mĂȘme format. Ce processus peut ĂȘtre fragile, et nous pourrions accidentellement nĂ©gliger certains dĂ©tails. + +Existe-t-il une meilleure mĂ©thode ? + +### Sections d'auto-formatage des outils + +Notre outil a Ă©tĂ© Ă©crit en Python, et l'implĂ©mentation fournit dĂ©jĂ  tout ce dont nous avons besoin : + +- Un nom descriptif de ce qu'il fait : `calculator` +- Une description plus dĂ©taillĂ©e, fournie par le commentaire docstring de la fonction : `Multiplie deux entiers.` +- Les entrĂ©es et leur type : la fonction attend clairement deux `int`. +- Le type de la sortie. + +Il y a une raison pour laquelle on utilise des langages de programmation : ils sont expressifs, concis et prĂ©cis. + +Nous pourrions fournir le code source Python comme _spĂ©cification_ de l'outil pour le LLM, mais la maniĂšre dont l'outil est implĂ©mentĂ© n'a pas d'importance. Tout ce qui compte, c'est son nom, ce qu'il fait, les entrĂ©es qu'il attend et la sortie qu'il fournit. + +Nous tirerons parti des fonctionnalitĂ©s d'introspection de Python pour exploiter le code source et construire automatiquement une description de l'outil. Tout ce dont nous avons besoin, c'est que l'implĂ©mentation de l'outil utilise des annotations de types, des docstrings et des noms de fonction pertinents. Nous Ă©crirons un peu de code pour extraire les parties pertinentes du code source. + +Une fois cela fait, il nous suffira d'utiliser un dĂ©corateur Python pour indiquer que la fonction `calculator` est un outil : + +```python +@tool +def calculator(a: int, b: int) -> int: + """Multiplie deux entiers.""" + return a * b + +print(calculator.to_string()) +``` + +Notez le dĂ©corateur `@tool` avant la dĂ©finition de la fonction. + +Avec l'implĂ©mentation que nous verrons ensuite, nous serons capables d'extraire automatiquement le texte suivant Ă  partir du code source : + +``` +Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: int +``` + +Comme vous pouvez le constater, c'est la mĂȘme chose que nous avons Ă©crit manuellement prĂ©cĂ©demment ! + +### ImplĂ©mentation gĂ©nĂ©rique d'un outil + +Nous crĂ©ons une classe gĂ©nĂ©rique `Tool` que nous pouvons rĂ©utiliser chaque fois que nous avons besoin d'utiliser un outil. + +> **Avertissement :** Cette implĂ©mentation d'exemple est fictive mais ressemble de prĂšs aux implĂ©mentations rĂ©elles dans la plupart des bibliothĂšques. + +```python +class Tool: + """ + Une classe reprĂ©sentant un morceau de code rĂ©utilisable (Outil). + + Attributs: + name (str): Nom de l'outil. + description (str): Une description textuelle de ce que fait l'outil. + func (callable): La fonction que cet outil encapsule. + arguments (list): Une liste d'arguments. + outputs (str ou list): Le(s) type(s) de retour de la fonction encapsulĂ©e. + """ + def __init__(self, + name: str, + description: str, + func: callable, + arguments: list, + outputs: str): + self.name = name + self.description = description + self.func = func + self.arguments = arguments + self.outputs = outputs + + def to_string(self) -> str: + """ + Retourne une reprĂ©sentation sous forme de chaĂźne de l'outil, + incluant son nom, sa description, ses arguments, et ses sorties. + """ + args_str = ", ".join([ + f"{arg_name}: {arg_type}" for arg_name, arg_type in self.arguments + ]) + + return ( + f"Tool Name: {self.name}," + f" Description: {self.description}," + f" Arguments: {args_str}," + f" Outputs: {self.outputs}" + ) + + def __call__(self, *args, **kwargs): + """ + Invoque la fonction sous-jacente (callable) avec les arguments fournis. + """ + return self.func(*args, **kwargs) +``` + +Cela peut sembler compliquĂ©, mais en y allant pas Ă  pas, nous pouvons voir ce qu'elle fait. Nous dĂ©finissons une classe **`Tool`** qui inclut : + +- **`name`** (*str*): Le nom de l'outil. +- **`description`** (*str*): Une brĂšve description de ce que fait l'outil. +- **`function`** (*callable*): La fonction que l'outil exĂ©cute. +- **`arguments`** (*list*): Les paramĂštres d'entrĂ©e attendus. +- **`outputs`** (*str* ou *list*): Les sorties attendues de l'outil. +- **`__call__()`** : Appelle la fonction lorsque l'instance de l'outil est invoquĂ©e. +- **`to_string()`** : Convertit les attributs de l'outil en une reprĂ©sentation textuelle. + +Nous pourrions crĂ©er un outil avec cette classe en utilisant le code suivant : + +```python +calculator_tool = Tool( + "calculator", # nom + "Multiplie deux entiers.", # description + calculator, # fonction Ă  appeler + [("a", "int"), ("b", "int")], # entrĂ©es (noms et types) + "int", # sortie +) +``` + +Mais nous pouvons Ă©galement utiliser le module `inspect` de Python pour rĂ©cupĂ©rer toutes les informations pour nous ! C'est ce que fait le dĂ©corateur `@tool`. + +> Si cela vous intĂ©resse, vous pouvez afficher la section suivante pour voir l'implĂ©mentation du dĂ©corateur. + +
+code du décorateur + +```python +def tool(func): + """ + Un décorateur qui crée une instance de Tool à partir de la fonction donnée. + """ + # Récupérer la signature de la fonction + signature = inspect.signature(func) + + # Extraire les paires (nom_param, annotation_param) pour les entrées + arguments = [] + for param in signature.parameters.values(): + annotation_name = ( + param.annotation.__name__ + if hasattr(param.annotation, '__name__') + else str(param.annotation) + ) + arguments.append((param.name, annotation_name)) + + # Déterminer l'annotation de retour + return_annotation = signature.return_annotation + if return_annotation is inspect._empty: + outputs = "Pas d'annotation de retour" + else: + outputs = ( + return_annotation.__name__ + if hasattr(return_annotation, '__name__') + else str(return_annotation) + ) + + # Utiliser la docstring de la fonction comme description (par défaut si vide) + description = func.__doc__ or "No description provided." + + # Le nom de la fonction devient le nom de l'outil + name = func.__name__ + + # Retourner une nouvelle instance de Tool + return Tool( + name=name, + description=description, + func=func, + arguments=arguments, + outputs=outputs + ) +``` + +
+ +Pour rĂ©itĂ©rer, avec ce dĂ©corateur en place, nous pouvons implĂ©menter notre outil comme ceci : + +```python +@tool +def calculator(a: int, b: int) -> int: + """Multiplie deux entiers.""" + return a * b + +print(calculator.to_string()) +``` + +Et nous pouvons utiliser la mĂ©thode `to_string` de `Tool` pour rĂ©cupĂ©rer automatiquement un texte adaptĂ© Ă  ĂȘtre utilisĂ© comme description d'un outil pour un LLM : + +``` +Nom de l'outil: calculator, Description: Multiplie deux entiers., Arguments: a: int, b: int, Sorties: int +``` + +La description est **injectĂ©e** dans le prompt systĂšme. Prenant l'exemple avec lequel nous avons commencĂ© cette section, voici Ă  quoi cela ressemblerait aprĂšs avoir remplacĂ© le `tools_description` : + +Prompt systĂšme pour les outils + +Dans la section [Actions](actions), nous en apprendrons plus sur la façon dont un Agent peut **appeler** cet outil que nous venons de crĂ©er. + +--- + +Les outils jouent un rĂŽle crucial dans l'amĂ©lioration des capacitĂ©s des agents d'IA. + +Pour rĂ©sumer, nous avons appris : + +- *Ce que sont les outils* : des fonctions qui offrent des capacitĂ©s supplĂ©mentaires aux LLMs, comme effectuer des calculs ou accĂ©der Ă  des donnĂ©es externes. +- *Comment dĂ©finir un outil* : en fournissant une description textuelle claire, des entrĂ©es, des sorties, et une fonction exĂ©cutable. +- *Pourquoi les outils sont essentiels* : ils permettent aux Agents de surmonter les limites de l'entraĂźnement statique des modĂšles, de gĂ©rer des tĂąches en temps rĂ©el, et d'effectuer des actions spĂ©cialisĂ©es. + +Maintenant, nous pouvons passer au [Workflow de l'Agent](agent-steps-and-structure) oĂč vous verrez comment un Agent observe, rĂ©flĂ©chit et agit. Cela **rassemble tout ce que nous avons vu jusqu'Ă  prĂ©sent** et prĂ©pare le terrain pour crĂ©er votre propre Agent IA entiĂšrement fonctionnel. + +Mais d'abord, il est temps pour un autre court quiz ! diff --git a/units/fr/unit1/tutorial.mdx b/units/fr/unit1/tutorial.mdx new file mode 100644 index 00000000..affddcc7 --- /dev/null +++ b/units/fr/unit1/tutorial.mdx @@ -0,0 +1,221 @@ +# CrĂ©ons notre premier Agent avec smolagents + +Dans la section prĂ©cĂ©dente, nous avons appris comment crĂ©er des Agents Ă  partir de zĂ©ro en utilisant du code Python, et nous avons **vu Ă  quel point ce processus peut ĂȘtre fastidieux**. Heureusement, de nombreuses bibliothĂšques d'agents simplifient ce travail en **se chargeant de la majeure partie du travail lourd pour vous**. + +Dans ce tutoriel, **vous crĂ©erez votre tout premier Agent** capable d'exĂ©cuter des actions telles que la gĂ©nĂ©ration d'images, la recherche sur le web, la vĂ©rification de fuseaux horaires et bien plus encore ! + +Vous publierez Ă©galement votre agent **sur un Hugging Face Space afin de le partager avec vos amis et collĂšgues**. + +C'est parti ! + +## Qu'est-ce que smolagents ? + +smolagents + +Pour crĂ©er cet Agent, nous allons utiliser `smolagents`, une bibliothĂšque qui **fournit un cadre facilitant le dĂ©veloppement de vos agents**. + +Cette bibliothĂšque lĂ©gĂšre est conçue pour la simplicitĂ©, tout en masquant une grande partie de la complexitĂ© liĂ©e Ă  la construction d'un Agent, vous permettant ainsi de vous concentrer sur la conception du comportement de votre agent. + +Nous approfondirons smolagents dans la prochaine unitĂ©. En attendant, vous pouvez Ă©galement consulter ce billet de blog ou le dĂ©pĂŽt GitHub de la bibliothĂšque. + +En bref, `smolagents` est une bibliothĂšque qui se concentre sur le **codeAgent**, un type d'agent qui exĂ©cute des **"Actions"** via des blocs de code, puis **"Observe"** les rĂ©sultats en exĂ©cutant le code. + +Voici un exemple de ce que nous allons construire ! + +Nous avons Ă©quipĂ© notre agent d'un **outil de gĂ©nĂ©ration d'images** et lui avons demandĂ© de gĂ©nĂ©rer une image d'un chat. + +L'agent dans `smolagents` aura les **mĂȘmes comportements que celui personnalisĂ© que nous avons construit prĂ©cĂ©demment** : il va **penser, agir et observer en cycle** jusqu'Ă  atteindre une rĂ©ponse finale : + + + +Excitant, n'est-ce pas ? + +## Construisons notre Agent ! + +Pour commencer, dupliquez ce Space : https://huggingface.co/spaces/agents-course/First_agent_template +> Merci Ă  Aymeric pour ce template ! 🙌 + +Dupliquer cet Space signifie **crĂ©er une copie locale sur votre propre profil** : +Duplicate + +Tout au long de cette leçon, le seul fichier que vous aurez Ă  modifier est le (actuellement incomplet) **"app.py"**. Vous pouvez consulter l'[original dans le template](https://huggingface.co/spaces/agents-course/First_agent_template/blob/main/app.py). Pour trouver le vĂŽtre, allez dans votre copie du Space, cliquez sur l'onglet `Files` puis sur `app.py` dans la liste des rĂ©pertoires. + +Analysons le code ensemble : + +- Le fichier commence par quelques importations de bibliothĂšques simples mais nĂ©cessaires + +```python +from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool +import datetime +import requests +import pytz +import yaml +from tools.final_answer import FinalAnswerTool +``` + +Comme indiquĂ© prĂ©cĂ©demment, nous utiliserons directement la classe **CodeAgent** de **smolagents**. + +### Les Outils + +Entrons maintenant dans le vif du sujet avec les outils ! Si vous souhaitez un rappel sur les outils, n'hĂ©sitez pas Ă  consulter la section [Outils](tools) du cours. + +```python +@tool +def my_custom_tool(arg1: str, arg2: int) -> str: # il est important de spĂ©cifier le type de retour + # Conservez ce format pour la description de l'outil et des arguments, mais n'hĂ©sitez pas Ă  modifier l'outil + """Un outil qui ne fait encore rien + Arguments: + arg1: le premier argument + arg2: le deuxiĂšme argument + """ + return "Quelle magie allez-vous crĂ©er ?" + +@tool +def get_current_time_in_timezone(timezone: str) -> str: + """Un outil qui rĂ©cupĂšre l'heure locale actuelle dans un fuseau horaire spĂ©cifiĂ©. + Arguments: + timezone: Une chaĂźne reprĂ©sentant un fuseau horaire valide (par exemple, 'America/New_York'). + """ + try: + # CrĂ©er l'objet fuseau horaire + tz = pytz.timezone(timezone) + # Obtenir l'heure actuelle dans ce fuseau horaire + local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S") + return f"L'heure locale actuelle dans {timezone} est : {local_time}" + except Exception as e: + return f"Erreur lors de la rĂ©cupĂ©ration de l'heure pour le fuseau horaire '{timezone}' : {str(e)}" +``` + +Les outils sont ce que nous vous encourageons Ă  construire dans cette section ! Nous vous donnons deux exemples : + +1. Un **outil factice non fonctionnel** que vous pouvez modifier pour crĂ©er quelque chose d'utile. +2. Un **outil rĂ©ellement fonctionnel** qui rĂ©cupĂšre l'heure actuelle quelque part dans le monde. + +Pour dĂ©finir votre outil, il est important de : + +1. Fournir des types d'entrĂ©e et de sortie pour votre fonction, comme dans `get_current_time_in_timezone(timezone: str) -> str:` +2. Fournir une **docstring bien formatĂ©e**. `smolagents` s'attend Ă  ce que tous les arguments aient une **description textuelle dans la docstring**. + +### L'Agent + +Il utilise [`Qwen/Qwen2.5-Coder-32B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) comme moteur LLM. C'est un modĂšle trĂšs performant auquel nous accĂ©derons via l'API serverless. + +```python +final_answer = FinalAnswerTool() +model = HfApiModel( + max_tokens=2096, + temperature=0.5, + model_id='Qwen/Qwen2.5-Coder-32B-Instruct', + custom_role_conversions=None, +) + +with open("prompts.yaml", 'r') as stream: + prompt_templates = yaml.safe_load(stream) + +# Nous crĂ©ons notre CodeAgent +agent = CodeAgent( + model=model, + tools=[final_answer], # ajoutez vos outils ici (ne supprimez pas final_answer) + max_steps=6, + verbosity_level=1, + grammar=None, + planning_interval=None, + name=None, + description=None, + prompt_templates=prompt_templates +) + +GradioUI(agent).launch() +``` + +Cet Agent utilise toujours l'`InferenceClient` que nous avons vu dans une section prĂ©cĂ©dente derriĂšre la classe **HfApiModel** ! + +Nous fournirons des exemples plus dĂ©taillĂ©s lors de la prĂ©sentation du cadre dans l'UnitĂ© 2. Pour l'instant, vous devez vous concentrer sur **l'ajout de nouveaux outils Ă  la liste des outils** en utilisant le paramĂštre `tools` de votre Agent. + +Par exemple, vous pourriez utiliser le `DuckDuckGoSearchTool` qui a Ă©tĂ© importĂ© dans la premiĂšre ligne du code, ou vous pouvez examiner le `image_generation_tool` qui est chargĂ© depuis le Hub plus tard dans le code. + +**Ajouter des outils donnera de nouvelles capacitĂ©s Ă  votre agent**, alors soyez crĂ©atif ! + +Le fichier complet **"app.py"** : + +```python +from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool +import datetime +import requests +import pytz +import yaml +from tools.final_answer import FinalAnswerTool + +from Gradio_UI import GradioUI + +# Voici un exemple d'un outil qui ne fait encore rien. Épatez-nous avec votre crĂ©ativitĂ© ! +@tool +def my_custom_tool(arg1: str, arg2: int) -> str: # il est important de spĂ©cifier le type de retour + # Conservez ce format pour la description de l'outil et des arguments, mais n'hĂ©sitez pas Ă  modifier l'outil + """Un outil qui ne fait encore rien + Arguments: + arg1: le premier argument + arg2: le deuxiĂšme argument + """ + return "Quelle magie allez-vous crĂ©er ?" + +@tool +def get_current_time_in_timezone(timezone: str) -> str: + """Un outil qui rĂ©cupĂšre l'heure locale actuelle dans un fuseau horaire spĂ©cifiĂ©. + Arguments: + timezone: Une chaĂźne reprĂ©sentant un fuseau horaire valide (par exemple, 'America/New_York'). + """ + try: + # CrĂ©er l'objet fuseau horaire + tz = pytz.timezone(timezone) + # Obtenir l'heure actuelle dans ce fuseau horaire + local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S") + return f"L'heure locale actuelle dans {timezone} est : {local_time}" + except Exception as e: + return f"Erreur lors de la rĂ©cupĂ©ration de l'heure pour le fuseau horaire '{timezone}' : {str(e)}" + + +final_answer = FinalAnswerTool() +model = HfApiModel( + max_tokens=2096, + temperature=0.5, + model_id='Qwen/Qwen2.5-Coder-32B-Instruct', + custom_role_conversions=None, +) + +# Importer l'outil depuis le Hub +image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True) + +with open("prompts.yaml", 'r') as stream: + prompt_templates = yaml.safe_load(stream) + +agent = CodeAgent( + model=model, + tools=[final_answer], # ajoutez vos outils ici (ne supprimez pas final_answer) + max_steps=6, + verbosity_level=1, + grammar=None, + planning_interval=None, + name=None, + description=None, + prompt_templates=prompt_templates +) + +GradioUI(agent).launch() +``` + +Votre **objectif** est de vous familiariser avec le Space et l'Agent. + +Actuellement, l'agent dans le template **n'utilise aucun outil, alors essayez de lui fournir certains des outils prĂ©fabriquĂ©s ou mĂȘme de crĂ©er de nouveaux outils vous-mĂȘme !** + +Nous attendons avec impatience vos incroyables agents dans le canal Discord **#agents-course-showcase**! + +--- + +FĂ©licitations, vous avez construit votre premier Agent ! N'hĂ©sitez pas Ă  le partager avec vos amis et collĂšgues. + +Comme c'est votre premiĂšre tentative, il est tout Ă  fait normal qu'il soit un peu boguĂ© ou lent. Dans les unitĂ©s futures, nous apprendrons Ă  construire des Agents encore meilleurs. + +La meilleure façon d'apprendre est d'essayer, alors n'hĂ©sitez pas Ă  le mettre Ă  jour, Ă  ajouter plus d'outils, Ă  essayer avec un autre modĂšle, etc. + +Dans la prochaine section, vous allez remplir le quiz final et obtenir votre certificat ! diff --git a/units/fr/unit1/what-are-agents.mdx b/units/fr/unit1/what-are-agents.mdx new file mode 100644 index 00000000..3867d689 --- /dev/null +++ b/units/fr/unit1/what-are-agents.mdx @@ -0,0 +1,44 @@ +# Qu'est-ce qu'un Agent ? + +Planification de l'UnitĂ© 1 + +À la fin de cette section, vous vous sentirez Ă  l'aise avec le concept d'agents et leurs diverses applications dans l'IA. + +Pour expliquer ce qu'est un Agent, commençons par une analogie. + +## La Vue d'Ensemble : Alfred l'Agent + +Voici Alfred. Alfred est un **Agent**. + +Voici Alfred + +Imaginez qu'Alfred **reçoive une commande**, par exemple : « Alfred, je voudrais un cafĂ© s'il te plaĂźt. » + +Je voudrais un cafĂ© + +Parce qu'Alfred **comprend le langage naturel**, il saisit rapidement notre demande. + +Avant de satisfaire la commande, Alfred se livre au **raisonnement et Ă  la planification**, dĂ©terminant les Ă©tapes et les outils dont il a besoin pour : + +1. Aller Ă  la cuisine +2. Utiliser la machine Ă  cafĂ© +3. PrĂ©parer le cafĂ© +4. Ramener le cafĂ© + +Raisonnement et planification + +Une fois qu'il a Ă©tabli un plan, il **doit agir**. Pour exĂ©cuter son plan, **il peut utiliser les outils qu'il connaĂźt**. + +Dans ce cas, pour prĂ©parer un cafĂ©, il utilise une machine Ă  cafĂ©. Il active la machine Ă  cafĂ© pour prĂ©parer le cafĂ©. + +PrĂ©parer le cafĂ© + +Enfin, Alfred nous apporte le cafĂ© fraĂźchement prĂ©parĂ©. + +Apporter le cafĂ© + +Et voilĂ  ce qu'est un Agent : un **modĂšle d'IA capable de raisonner, de planifier et d'interagir avec son environnement**. + +On l'appelle Agent parce qu'il possĂšde de l'_agency_ (la capacitĂ© d'agir), autrement dit, il peut interagir avec l'environnement. + +Planification de l'UnitĂ© 1 + +Dans la section prĂ©cĂ©dente, nous avons appris que chaque Agent a besoin **d'un modĂšle d'IA Ă  son cƓur**, et que les LLMs sont le type de modĂšle d'IA le plus courant pour cet usage. + +Maintenant, nous allons dĂ©couvrir ce que sont les LLMs et comment ils alimentent les Agents. + +Cette section offre une explication technique concise sur l'utilisation des LLMs. Si vous souhaitez approfondir, vous pouvez consulter notre cours gratuit de traitement du langage naturel. + +## Qu'est-ce qu'un modĂšle de langage de grande taille ? + +Un LLM est un type de modĂšle d'IA qui excelle dans **la comprĂ©hension et la gĂ©nĂ©ration du langage humain**. Ils sont entraĂźnĂ©s sur d'immenses quantitĂ©s de donnĂ©es textuelles, ce qui leur permet d'apprendre des motifs, la structure, et mĂȘme les nuances du langage. Ces modĂšles se composent gĂ©nĂ©ralement de plusieurs millions de paramĂštres. + +La plupart des LLMs d'aujourd'hui sont **basĂ©s sur l'architecture Transformer** — une architecture d'apprentissage profond basĂ©e sur l'algorithme "Attention", qui a suscitĂ© un intĂ©rĂȘt considĂ©rable depuis la sortie de BERT de Google en 2018. + +
+Transformer +
L'architecture originale du Transformer ressemblait à ceci, avec un encodeur à gauche et un décodeur à droite. +
+
+ +Il existe 3 types de transformers : + +1. **Encodeurs** + Un Transformer basĂ© sur un encodeur prend en entrĂ©e un texte (ou d'autres donnĂ©es) et produit une reprĂ©sentation dense (ou embedding) de ce texte. + + - **Exemple** : BERT de Google + - **Cas d'utilisation** : Classification de texte, recherche sĂ©mantique, reconnaissance d'entitĂ©s nommĂ©es + - **Taille typique** : Des millions de paramĂštres + +2. **DĂ©codeurs** + Un Transformer basĂ© sur un dĂ©codeur se concentre **sur la gĂ©nĂ©ration de nouveaux tokens pour complĂ©ter une sĂ©quence, un token Ă  la fois**. + + - **Exemple** : Llama de Meta + - **Cas d'utilisation** : GĂ©nĂ©ration de texte, chatbots, gĂ©nĂ©ration de code + - **Taille typique** : Des milliards (au sens amĂ©ricain, c'est-Ă -dire 10^9) de paramĂštres + +3. **Seq2Seq (Encodeur–DĂ©codeur)** + Un Transformer sĂ©quence-Ă -sĂ©quence _combine_ un encodeur et un dĂ©codeur. L'encodeur traite d'abord la sĂ©quence d'entrĂ©e pour en extraire une reprĂ©sentation contextuelle, puis le dĂ©codeur gĂ©nĂšre une sĂ©quence de sortie. + + - **Exemple** : T5, BART + - **Cas d'utilisation** : Traduction, rĂ©sumĂ©, paraphrase + - **Taille typique** : Des millions de paramĂštres + +Bien que les modĂšles de langage de grande taille existent sous diffĂ©rentes formes, les LLMs sont typiquement des modĂšles basĂ©s sur le dĂ©codeur avec des milliards de paramĂštres. Voici quelques-uns des LLMs les plus connus : + +| **ModĂšle** | **Fournisseur** | +|-----------------|-------------------------------------| +| **Deepseek-R1** | DeepSeek | +| **GPT4** | OpenAI | +| **Llama 3** | Meta (Facebook AI Research) | +| **SmolLM2** | Hugging Face | +| **Gemma** | Google | +| **Mistral** | Mistral | + +Le principe fondamental d'un LLM est simple mais trĂšs efficace : **son objectif est de prĂ©dire le token suivant, Ă©tant donnĂ© une sĂ©quence de tokens prĂ©cĂ©dents**. Un "token" est l'unitĂ© d'information avec laquelle travaille un LLM. Vous pouvez considĂ©rer un "token" comme s'il s'agissait d'un "mot", mais pour des raisons d'efficacitĂ©, les LLMs n'utilisent pas des mots entiers. + +Par exemple, alors que le français compte environ 100 000 mots (l'anglais 600 000), un LLM peut avoir un vocabulaire d'environ 32 000 tokens (comme c'est le cas avec Llama 2). La tokenisation fonctionne souvent sur des unitĂ©s sous-mot pouvant ĂȘtre combinĂ©es. + +Par exemple, les tokens "intĂ©ress" et "ant" peuvent se combiner pour former "intĂ©ressant", ou "Ă©" peut ĂȘtre ajoutĂ© pour former "intĂ©ressĂ©". + +Vous pouvez expĂ©rimenter avec diffĂ©rents tokenizers dans le terrain de jeu interactif ci-dessous : + + + +Chaque LLM possĂšde des **tokens spĂ©ciaux** propres au modĂšle. Le LLM utilise ces tokens pour ouvrir et fermer les composants structurĂ©s de sa gĂ©nĂ©ration. Par exemple, pour indiquer le dĂ©but ou la fin d'une sĂ©quence, d'un message ou d'une rĂ©ponse. De plus, les invites (ou prompt) que nous passons au modĂšle sont Ă©galement structurĂ©es avec des tokens spĂ©ciaux. Le plus important d'entre eux est le **token de fin de sĂ©quence** (EOS). + +Les formes des tokens spĂ©ciaux varient grandement selon les fournisseurs de modĂšles. + +Le tableau ci-dessous illustre cette diversitĂ© : + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ModÚleFournisseurToken EOSFonctionnalité
GPT4OpenAI<|endoftext|>Fin du texte du message
Llama 3Meta (Facebook AI Research)<|eot_id|>Fin de la séquence
Deepseek-R1DeepSeek<|end_of_sentence|>Fin du texte du message
SmolLM2Hugging Face<|im_end|>Fin de l'instruction ou du message
GemmaGoogle<end_of_turn>Fin du tour de conversation
+ + + +Nous ne vous demandons pas de mĂ©moriser ces tokens spĂ©ciaux, mais il est important d'apprĂ©cier leur diversitĂ© et le rĂŽle qu'ils jouent dans la gĂ©nĂ©ration de texte par les LLMs. Si vous souhaitez en savoir plus sur les tokens spĂ©ciaux, vous pouvez consulter la configuration du modĂšle dans son dĂ©pĂŽt Hub. Par exemple, vous pouvez trouver les tokens spĂ©ciaux du modĂšle SmolLM2 dans son tokenizer_config.json. + + + +## Comprendre la prĂ©diction du token suivant + +On dit que les LLMs sont **autoregressifs**, ce qui signifie que **la sortie d'une passe devient l'entrĂ©e de la suivante**. Cette boucle continue jusqu'Ă  ce que le modĂšle prĂ©dise que le token suivant est le token EOS, moment oĂč le modĂšle peut s'arrĂȘter. + +Gif visuel de dĂ©codage autoregressif + +En d'autres termes, un LLM dĂ©codera le texte jusqu'Ă  atteindre le token EOS. Mais que se passe-t-il lors d'une boucle de dĂ©codage unique ? + +Bien que le processus complet puisse ĂȘtre assez technique dans le cadre de l'apprentissage des agents, voici un aperçu succinct : + +- Une fois le texte d'entrĂ©e **tokenisĂ©**, le modĂšle calcule une reprĂ©sentation de la sĂ©quence qui capture des informations sur la signification et la position de chaque token. +- Cette reprĂ©sentation est ensuite traitĂ©e par le modĂšle, qui produit des scores classant la probabilitĂ© que chaque token de son vocabulaire soit le suivant dans la sĂ©quence. + +Gif visuel du dĂ©codage + +En se basant sur ces scores, plusieurs stratĂ©gies existent pour sĂ©lectionner les tokens afin de complĂ©ter la phrase. + +- La stratĂ©gie de dĂ©codage la plus simple serait de toujours choisir le token ayant le score maximum. + +Vous pouvez interagir vous-mĂȘme avec le processus de dĂ©codage grĂące Ă  SmolLM2 dans cet espace (n'oubliez pas, il dĂ©code jusqu'Ă  atteindre un token **EOS** qui est **<|im_end|>** pour ce modĂšle) : + + + +- Mais il existe des stratĂ©gies de dĂ©codage plus avancĂ©es. Par exemple, le *beam search* (recherche par faisceaux) explore plusieurs sĂ©quences candidates pour trouver celle ayant le score total maximum – mĂȘme si certains tokens individuels prĂ©sentent des scores plus faibles. + + + +Si vous souhaitez en savoir plus sur le dĂ©codage, vous pouvez jeter un Ɠil au [cours de NLP](https://huggingface.co/learn/nlp-course). + +## L'attention est tout ce dont vous avez besoin + +Un aspect clĂ© de l'architecture Transformer est **l'Attention**. Lors de la prĂ©diction du mot suivant, tous les mots d'une phrase ne sont pas Ă©galement importants ; des mots comme "France" et "capitale" dans la phrase *"La capitale de la France est 
"* portent le plus de sens. + +Gif visuel de l'Attention + +Ce processus d'identification des mots les plus pertinents pour prĂ©dire le token suivant s'est rĂ©vĂ©lĂ© incroyablement efficace. + +Bien que le principe de base des LLMs — prĂ©dire le token suivant — soit restĂ© constant depuis GPT-2, des avancĂ©es significatives ont Ă©tĂ© rĂ©alisĂ©es dans la montĂ©e en Ă©chelle des rĂ©seaux de neurones et dans le fonctionnement du mĂ©canisme d'attention pour des sĂ©quences toujours plus longues. + +Si vous avez dĂ©jĂ  interagi avec des LLMs, vous connaissez probablement le terme *longueur de contexte*, qui fait rĂ©fĂ©rence au nombre maximum de tokens que le LLM peut traiter, ainsi qu'Ă  la _durĂ©e d'attention_ maximale dont il dispose. + +## L'importance de bien formuler les invites pour le LLM + +Étant donnĂ© que la seule tĂąche d'un LLM est de prĂ©dire le token suivant en examinant chaque token d'entrĂ©e, et de choisir ceux qui sont "importants", la formulation de votre sĂ©quence d'entrĂ©e revĂȘt une importance capitale. + +La sĂ©quence d'entrĂ©e que vous fournissez Ă  un LLM est appelĂ©e _prompt_. Une conception minutieuse du prompt facilite **l'orientation de la gĂ©nĂ©ration du LLM vers la sortie souhaitĂ©e**. + +## Comment sont entraĂźnĂ©s les LLMs ? + +Les LLMs sont entraĂźnĂ©s sur de grands ensembles de donnĂ©es textuelles, oĂč ils apprennent Ă  prĂ©dire le mot suivant dans une sĂ©quence grĂące Ă  un objectif d'apprentissage auto-supervisĂ© ou de modĂ©lisation de langage masquĂ©e. + +GrĂące Ă  cet apprentissage non supervisĂ©, le modĂšle apprend la structure de la langue et les **motifs sous-jacents du texte, ce qui lui permet de gĂ©nĂ©raliser Ă  des donnĂ©es inĂ©dites**. + +AprĂšs ce _prĂ©-entraĂźnement_ initial, les LLMs peuvent ĂȘtre ajustĂ©s via un apprentissage supervisĂ© pour rĂ©aliser des tĂąches spĂ©cifiques. Par exemple, certains modĂšles sont entraĂźnĂ©s pour des structures conversationnelles ou l'utilisation d'outils, tandis que d'autres se concentrent sur la classification ou la gĂ©nĂ©ration de code. + +## Comment puis-je utiliser les LLMs ? + +Vous avez deux options principales : + +1. **ExĂ©cuter localement** (si vous disposez du matĂ©riel nĂ©cessaire). + +2. **Utiliser un service Cloud/API** (par exemple, via l'API d'infĂ©rence sans serveur de Hugging Face). + +Tout au long de ce cours, nous utiliserons principalement des modĂšles via des API sur le Hub de Hugging Face. Par la suite, nous explorerons comment exĂ©cuter ces modĂšles localement sur votre matĂ©riel. + +## Comment les LLMs sont-ils utilisĂ©s dans les Agents IA ? + +Les LLMs sont un composant clĂ© des Agents IA, **fournissant la base pour comprendre et gĂ©nĂ©rer le langage humain**. + +Ils peuvent interprĂ©ter les instructions de l'utilisateur, maintenir le contexte dans les conversations, dĂ©finir un plan et dĂ©cider quels outils utiliser. + +Nous explorerons ces Ă©tapes en dĂ©tail dans cette UnitĂ©, mais pour l'instant, ce qu'il faut retenir, c'est que le LLM est **le cerveau de l'Agent**. + +--- + +Cela fait beaucoup d'informations ! Nous avons couvert les bases de ce que sont les LLMs, comment ils fonctionnent, et leur rĂŽle dans l'alimentation des agents IA. + +Si vous souhaitez plonger encore plus profondĂ©ment dans le monde fascinant des modĂšles de langage et du traitement du langage naturel, n'hĂ©sitez pas Ă  consulter notre cours gratuit de NLP. + +Maintenant que nous comprenons le fonctionnement des LLMs, il est temps de voir **comment les LLMs structurent leurs gĂ©nĂ©rations dans un contexte conversationnel**. + +Pour exĂ©cuter ce notebook, **vous avez besoin d'un token Hugging Face** que vous pouvez obtenir sur https://hf.co/settings/tokens. + +Vous devez Ă©galement demander l'accĂšs aux modĂšles Meta Llama. diff --git a/units/fr/unit2/README.md b/units/fr/unit2/README.md new file mode 100644 index 00000000..e69de29b diff --git a/units/fr/unit3/README.md b/units/fr/unit3/README.md new file mode 100644 index 00000000..e69de29b diff --git a/units/fr/unit4/README.md b/units/fr/unit4/README.md new file mode 100644 index 00000000..e69de29b