diff --git a/(docs)/fr/docs/advanced_applications/mrkl/page.mdx b/(docs)/fr/docs/advanced_applications/mrkl/page.mdx
index 235c5c3b644..f5a788b961e 100644
--- a/(docs)/fr/docs/advanced_applications/mrkl/page.mdx
+++ b/(docs)/fr/docs/advanced_applications/mrkl/page.mdx
@@ -1,55 +1,55 @@
-export const metadata = { sidebar_position: 2, title: "🟡 LLMs Using Tools" };
+export const metadata = { sidebar_position: 2, title: "🟡 Les LLMs utilisant des outils" };
-# 🟡 LLMs Using Tools
+# 🟡 Les LLMs utilisant des outils
-MRKL Systems(@karpas2022mrkl) (Modular Reasoning, Knowledge and Language, pronounced "miracle")
-are a **neuro-symbolic architecture** that combine LLMs (neural computation) and external
-tools like calculators (symbolic computation), to solve complex problems.
+Les systèmes MRKL(@karpas2022mrkl) (Modular Reasoning, Knowledge and Language, prononcé "miracle")
+sont une **architecture neuro-symbolique** qui combine les LLMs (calcul neuronal) et des outils
+externes comme les calculatrices (calcul symbolique) pour résoudre des problèmes complexes.
-A MRKL system is composed of a set of modules (e.g. a calculator, weather API, database, etc.) and a router that decides how to 'route' incoming natural language queries to the appropriate module.
+Un système MRKL est composé d'un ensemble de modules (par exemple, une calculatrice, une API météo, une base de données, etc.) et d'un routeur qui décide comment 'router' les requêtes en langage naturel vers le module approprié.
-A simple example of a MRKL system is a LLM that can
-use a calculator app. This is a single module system, where the LLM is the router.
-When asked, `What is 100*100?`, the LLM can choose to
-extract the numbers from the prompt, and then tell the MRKL System to use a calculator
-app to compute the result. This might look like the following:
+Un exemple simple d'un système MRKL est un LLM qui peut
+utiliser une application calculatrice. C'est un système à module unique, où le LLM est le routeur.
+Lorsqu'on lui demande `Combien fait 100*100 ?`, le LLM peut choisir d'
+extraire les nombres de la requête, puis dire au système MRKL d'utiliser une application
+calculatrice pour calculer le résultat. Cela pourrait ressembler à ceci :
- What is 100*100?
+ Combien fait 100*100 ?
CALCULATOR[100*100]
-The MRKL system would see the word `CALCULATOR` and plug `100*100` into the calculator app.
-This simple idea can easily be expanded to various symbolic computing tools.
+Le système MRKL verrait le mot `CALCULATOR` et insérerait `100*100` dans l'application calculatrice.
+Cette idée simple peut facilement être étendue à divers outils de calcul symbolique.
-Consider the following additional examples of applications:
+Voici d'autres exemples d'applications :
-- A chatbot that is able to respond to questions about a financial database by
- extracting information to form a SQL query from a users' text.
+- Un chatbot capable de répondre à des questions sur une base de données financière en
+ extrayant des informations pour former une requête SQL à partir du texte des utilisateurs.
- What is the price of Apple stock right now?
+ Quel est le prix actuel de l'action Apple ?
- The current price is DATABASE[SELECT price FROM stock WHERE company =
+ Le prix actuel est DATABASE[SELECT price FROM stock WHERE company =
"Apple" AND time = "now"].
-- A chatbot that is able to respond to questions about the weather by extracting
- information from the prompt and using a weather API to retrieve the information.
+- Un chatbot capable de répondre à des questions sur la météo en extrayant
+ des informations du prompt et en utilisant une API météo pour récupérer l'information.
- What is the weather like in New York?
+ Quel temps fait-il à Paris ?
- The weather is WEATHER_API[New York].
+ Le temps est WEATHER_API[Paris].
-- Or even much more complex tasks that depend on multiple datasources, such as the
- following:
+- Ou même des tâches beaucoup plus complexes qui dépendent de plusieurs sources de données,
+ comme l'exemple suivant :
-Example MRKL System (AI21)
+Exemple de système MRKL (AI21)
-## An Example
+## Un exemple
-I have reproduced an example MRKL System from the original paper, using Dust.tt,
-linked [here](https://dust.tt/w/ddebdfcdde/a/98bdd65cb7).
-The system reads a math problem (e.g. `What is 20 times 5^6?`), extracts the numbers and the operations,
-and reformats them for a calculator app (e.g. `20*5^6`). It then sends the reformatted equation
-to Google's calculator app, and returns the result. Note that the original paper performs prompt tuning on the router (the LLM), but I do not in this example. Let's walk through how this works:
+J'ai reproduit un exemple de système MRKL tiré de l'article original, en utilisant Dust.tt,
+accessible [ici](https://dust.tt/w/ddebdfcdde/a/98bdd65cb7).
+Le système lit un problème mathématique (par exemple `Combien fait 20 fois 5^6 ?`), extrait les nombres et les opérations,
+et les reformate pour une application calculatrice (par exemple `20*5^6`). Il envoie ensuite l'équation reformatée
+à l'application calculatrice de Google et renvoie le résultat. Notez que l'article original effectue un ajustement du prompt sur le routeur (le LLM), ce que je ne fais pas dans cet exemple. Voyons comment cela fonctionne :
-First, I made a simple dataset in the Dust `Datasets` tab.
+Tout d'abord, j'ai créé un simple jeu de données dans l'onglet `Datasets` de Dust.
-Then, I switched to the `Specification` tab and loaded the dataset using an `input` block.
+Ensuite, je suis passé à l'onglet `Specification` et j'ai chargé le jeu de données en utilisant un bloc `input`.
-Next, I created a `llm` block that extracts the numbers and operations. Notice how
-in the prompt I told it we would be using Google's calculator. The model I use (GPT-3)
-likely has some knowledge of Google's calculator from pretraining.
+Ensuite, j'ai créé un bloc `llm` qui extrait les nombres et les opérations. Remarquez comment
+dans le prompt, j'ai indiqué que nous utiliserions la calculatrice Google. Le modèle que j'utilise (GPT-3)
+a probablement une certaine connaissance de la calculatrice Google grâce à son pré-entraînement.
-Then, I made a `code` block, which runs some simple javascript code to remove
-spaces from the completion.
+Puis, j'ai créé un bloc `code` qui exécute un simple code javascript pour supprimer
+les espaces de la complétion.
-Finally, I made a `search` block that sends the reformatted equation to Google's calculator.
+Enfin, j'ai créé un bloc `search` qui envoie l'équation reformatée à la calculatrice Google.
-Below we can see the final results, which are all correct!
+Ci-dessous, nous pouvons voir les résultats finaux, qui sont tous corrects !
-Feel free to clone and experiment with this playground [here](https://dust.tt/w/ddebdfcdde/a/98bdd65cb7).
+N'hésitez pas à cloner et expérimenter avec ce playground [ici](https://dust.tt/w/ddebdfcdde/a/98bdd65cb7).
## Notes
-MRKL was developed by [AI21](https://www.ai21.com/) and originally used their
-J-1 (Jurassic 1)(@lieberjurassic) LLM.
+MRKL a été développé par [AI21](https://www.ai21.com/) et utilisait initialement leur
+LLM J-1 (Jurassic 1)(@lieberjurassic).
-## More
+## Pour aller plus loin
-See [this example](https://python.langchain.com/docs/modules/agents/how_to/mrkl) of a MRKL System
-built with LangChain.
+Consultez [cet exemple](https://python.langchain.com/docs/modules/agents/how_to/mrkl) d'un système MRKL
+construit avec LangChain.
diff --git a/(docs)/fr/docs/advanced_applications/overview/page.mdx b/(docs)/fr/docs/advanced_applications/overview/page.mdx
index 09a08e0b53e..2eea2cadbfd 100644
--- a/(docs)/fr/docs/advanced_applications/overview/page.mdx
+++ b/(docs)/fr/docs/advanced_applications/overview/page.mdx
@@ -2,7 +2,5 @@ export const metadata = { sidebar_position: 1, title: "🟢 Introduction" };
# 🟢 Introduction
-We have seen a number of prompting/prompt engineering methods thus far.
-Now we will cover some advanced applications of prompting that can solve
-complex reasoning tasks by performing searches for information via the internet,
-or other external sources.
+Nous avons vu jusqu'à présent plusieurs méthodes de prompting/ingénierie de prompts.
+Nous allons maintenant aborder des applications avancées du prompting qui peuvent résoudre des tâches de raisonnement complexes en effectuant des recherches d'informations via internet ou d'autres sources externes.
diff --git a/(docs)/fr/docs/advanced_applications/pal/page.mdx b/(docs)/fr/docs/advanced_applications/pal/page.mdx
index a5dfd16dbe1..370e068cf1a 100644
--- a/(docs)/fr/docs/advanced_applications/pal/page.mdx
+++ b/(docs)/fr/docs/advanced_applications/pal/page.mdx
@@ -1,11 +1,11 @@
-export const metadata = { sidebar_position: 4, title: "🟡 Code as Reasoning" };
+export const metadata = { sidebar_position: 4, title: "🟡 Le Code comme Raisonnement" };
-# 🟡 Code as Reasoning
+# 🟡 Le Code comme Raisonnement
-[Program-aided Language Models (PAL)](https://reasonwithpal.com)(@gao2022pal) are another example of a MRKL system.
-When given a question, PALs are able to **write code** that solves this question. They send the
-code to a programmatic runtime to get the result. PAL works in contrast to CoT; PAL's intermediate
-reasoning is code, while CoT's is natural language.
+Les [Program-aided Language Models (PAL)](https://reasonwithpal.com)(@gao2022pal) sont un autre exemple de système MRKL.
+Lorsqu'une question leur est posée, les PAL sont capables d'**écrire du code** qui résout cette question. Ils envoient le
+code à un environnement d'exécution programmatique pour obtenir le résultat. PAL fonctionne différemment de CoT ; le raisonnement intermédiaire de PAL
+est du code, tandis que celui de CoT est en langage naturel.
-PAL Example (Gao et al.)
+Exemple PAL (Gao et al.)
-One important thing to note it that PAL actually interleaves natural language (NL) and code.
-In the above image, in blue are natural language reasoning that PAL generates. Although it
-is not shown in the image, PAL actually generates '\#' before each line of NL reasoning, so
-that they are interpreted as comments by the programmatic runtime.
+Un point important à noter est que PAL entrelace en réalité le langage naturel (NL) et le code.
+Dans l'image ci-dessus, en bleu se trouve le raisonnement en langage naturel que PAL génère. Bien que
+ce ne soit pas montré dans l'image, PAL génère en fait '\#' avant chaque ligne de raisonnement NL,
+afin qu'elles soient interprétées comme des commentaires par l'environnement d'exécution.
-## Example
+## Exemple
-Let's look at an example of PAL solving a math question. I use a 3-shot prompt,
-which is a simplified version of [this one](https://github.com/reasoning-machines/pal/blob/main/pal/prompt/math_prompts.py)(@gao2022pal).
+Examinons un exemple de PAL résolvant une question mathématique. J'utilise un prompt à 3 exemples,
+qui est une version simplifiée de [celui-ci](https://github.com/reasoning-machines/pal/blob/main/pal/prompt/math_prompts.py)(@gao2022pal).
-I will use langchain, a Python package for chaining LLM functionality for this. First, a few installations are needed:
+Je vais utiliser langchain, un package Python pour chaîner les fonctionnalités LLM.
+Tout d'abord, quelques installations sont nécessaires :
```python
!pip install langchain==0.0.26
!pip install openai
from langchain.llms import OpenAI
import os
-os.environ["OPENAI_API_KEY"] = "sk-YOUR_KEY_HERE"
+os.environ["OPENAI_API_KEY"] = "sk-VOTRE_CLE_ICI"
```
-Then, we can create an instance of GPT-3 davinci-002 (an API call happens when we use this object)
+Ensuite, nous pouvons créer une instance de GPT-3 davinci-002 (un appel API se produit lorsque nous utilisons cet objet)
```python
llm = OpenAI(model_name='text-davinci-002', temperature=0)
```
-Here is the few shot prompt:
+Voici le prompt à quelques exemples :
```python
MATH_PROMPT = '''
-Q: There were nine computers in the server room. Five more computers were installed each day, from monday to thursday. How many computers are now in the server room?
+Q: Il y avait neuf ordinateurs dans la salle des serveurs. Cinq ordinateurs supplémentaires ont été installés chaque jour, du lundi au jeudi. Combien y a-t-il maintenant d'ordinateurs dans la salle des serveurs ?
-# solution in Python:
-"""There were nine computers in the server room. Five more computers were installed each day, from monday to thursday. How many computers are now in the server room?"""
+# solution en Python:
+"""Il y avait neuf ordinateurs dans la salle des serveurs. Cinq ordinateurs supplémentaires ont été installés chaque jour, du lundi au jeudi. Combien y a-t-il maintenant d'ordinateurs dans la salle des serveurs ?"""
computers_initial = 9
computers_per_day = 5
-num_days = 4 # 4 days between monday and thursday
+num_days = 4 # 4 jours entre lundi et jeudi
computers_added = computers_per_day * num_days
computers_total = computers_initial + computers_added
result = computers_total
return result
-Q: Shawn has five toys. For Christmas, he got two toys each from his mom and dad. How many toys does he have now?
+Q: Shawn a cinq jouets. Pour Noël, il a reçu deux jouets de sa mère et deux de son père. Combien de jouets a-t-il maintenant ?
-# solution in Python:
-"""Shawn has five toys. For Christmas, he got two toys each from his mom and dad. How many toys does he have now?"""
+# solution en Python:
+"""Shawn a cinq jouets. Pour Noël, il a reçu deux jouets de sa mère et deux de son père. Combien de jouets a-t-il maintenant ?"""
toys_initial = 5
mom_toys = 2
dad_toys = 2
@@ -73,10 +74,10 @@ total_toys = toys_initial + total_received
result = total_toys
-Q: Jason had 20 lollipops. He gave Denny some lollipops. Now Jason has 12 lollipops. How many lollipops did Jason give to Denny?
+Q: Jason avait 20 sucettes. Il en a donné quelques-unes à Denny. Maintenant Jason a 12 sucettes. Combien de sucettes Jason a-t-il données à Denny ?
-# solution in Python:
-"""Jason had 20 lollipops. He gave Denny some lollipops. Now Jason has 12 lollipops. How many lollipops did Jason give to Denny?"""
+# solution en Python:
+"""Jason avait 20 sucettes. Il en a donné quelques-unes à Denny. Maintenant Jason a 12 sucettes. Combien de sucettes Jason a-t-il données à Denny ?"""
jason_lollipops_initial = 20
jason_lollipops_after = 12
denny_lollipops = jason_lollipops_initial - jason_lollipops_after
@@ -84,29 +85,29 @@ result = denny_lollipops
Q: {question}
-# solution in Python:
+# solution en Python:
'''
```
-Now we can pass the combined prompt to GPT-3.
+Maintenant, nous pouvons passer le prompt combiné à GPT-3.
```python
llm_out = llm(MATH_PROMPT.format(question=question))
print(llm_out)
```
-The output is:
+La sortie est :
- Emma took a 60 minute plane ride to seattle. She then took a 2 hour train
- ride to portland, and then a 30 minute bus ride to vancouver. How long did
- it take her to get to vancouver?
+ Emma a pris un vol de 60 minutes vers Seattle. Elle a ensuite pris un train
+ pendant 2 heures jusqu'à Portland, puis un bus pendant 30 minutes jusqu'à Vancouver.
+ Combien de temps lui a-t-il fallu pour arriver à Vancouver ?
plane_ride = 60
- train_ride = 2 * 60 # 2 hours in minutes
+ train_ride = 2 * 60 # 2 heures en minutes
bus_ride = 30
@@ -116,17 +117,17 @@ The output is:
-Finally, we can pass this code to a Python runtime to get the answer:
+Enfin, nous pouvons passer ce code à un environnement d'exécution Python pour obtenir la réponse :
```python
exec(llm_out)
print(result)
```
-The output is **210**, which is correct.
+La sortie est **210**, ce qui est correct.
-See the Jupyter notebook for this example [here](https://github.com/trigaten/Learn_Prompting/tree/main/docs/code_examples/PAL.ipynb).
+Voir le notebook Jupyter pour cet exemple [ici](https://github.com/trigaten/Learn_Prompting/tree/main/docs/code_examples/PAL.ipynb).
-## More
+## Plus d'informations
-Also see [PAL's colab example](https://colab.research.google.com/drive/1u4_RsdI0E79PCMDdcPiJUzYhdnjoXeXc?usp=sharing#scrollTo=Ba0ycacK4i1V).
+Voir aussi [l'exemple colab de PAL](https://colab.research.google.com/drive/1u4_RsdI0E79PCMDdcPiJUzYhdnjoXeXc?usp=sharing#scrollTo=Ba0ycacK4i1V).
diff --git a/(docs)/fr/docs/advanced_applications/react/page.mdx b/(docs)/fr/docs/advanced_applications/react/page.mdx
index df51ccc4a3b..5c04ccf7605 100644
--- a/(docs)/fr/docs/advanced_applications/react/page.mdx
+++ b/(docs)/fr/docs/advanced_applications/react/page.mdx
@@ -1,25 +1,25 @@
export const metadata = {
sidebar_position: 3,
- title: "🟡 LLMs that Reason and Act",
+ title: "🟡 LLMs qui Raisonnent et Agissent",
};
-# 🟡 LLMs that Reason and Act
+# 🟡 LLMs qui Raisonnent et Agissent
-ReAct(@yao2022react)(reason, act) is a paradigm for enabling language models to solve complex
-tasks using natural language reasoning. ReAct is designed for tasks in which the LLM is
-allowed to perform certain actions. For example, as in a MRKL system, a LLM may be able
-to interact with external APIs to retrieve information. When asked a question, the LLM
-could choose to perform an action to retrieve information, and then answer the question
-based on the retrieved information.
+ReAct(@yao2022react)(reason, act) est un paradigme permettant aux modèles de langage de résoudre des tâches
+complexes en utilisant le raisonnement en langage naturel. ReAct est conçu pour les tâches dans lesquelles le LLM est
+autorisé à effectuer certaines actions. Par exemple, comme dans un système MRKL, un LLM peut interagir
+avec des API externes pour récupérer des informations. Lorsqu'une question lui est posée, le LLM peut
+choisir d'effectuer une action pour récupérer des informations, puis répondre à la question
+en se basant sur les informations récupérées.
-ReAct Systems can be thought of as MRKL systems, with the added ability to **reason
-about** the actions they can perform.
+Les systèmes ReAct peuvent être considérés comme des systèmes MRKL, avec la capacité supplémentaire de **raisonner
+sur** les actions qu'ils peuvent effectuer.
-Examine the following image. The question in the top box is sourced from HotPotQA(@yang2018hotpotqa),
-a question answering dataset that requires complex reasoning. ReAct is able to answer the question by
-first reasoning about the question (Thought 1), and then performing an action (Act 1) to send a query
-to Google. It then receives an observation (Obs 1), and continues with this thought, action, observation
-loop until it reaches a conclusion (Act 3).
+Examinez l'image suivante. La question dans la boîte supérieure provient de HotPotQA(@yang2018hotpotqa),
+un jeu de données de questions-réponses qui nécessite un raisonnement complexe. ReAct peut répondre à la question
+en raisonnant d'abord sur la question (Thought 1), puis en effectuant une action (Act 1) pour envoyer une requête
+à Google. Il reçoit ensuite une observation (Obs 1) et continue avec cette boucle de pensée, action, et observation,
+jusqu'à ce qu'il atteigne une conclusion (Act 3).
-ReAct System (Yao et al.)
+Système ReAct (Yao et al.)
-Readers with knowledge of reinforcement learning may recognize this process as similar to the classic
-RL loop of state, action, reward, state,... ReAct provides some formalization for
-this in their paper.
+Les lecteurs familiers avec l'apprentissage par renforcement reconnaîtront ce processus comme similaire à la boucle
+classique de RL : état, action, récompense, état,... ReAct fournit une certaine formalisation de
+ce concept dans leur article.
-## Results
+## Résultats
-Google used the PaLM(@chowdhery2022palm) LLM in experiments with ReAct.
-Comparisons to standard prompting (question only), CoT, and other configurations
-show that ReAct's performance is promising for complex reasoning tasks. Google
-also performs studies on the FEVER dataset(@thorne2018fever), which covers
-fact extraction and verification.
+Google a utilisé le LLM PaLM(@chowdhery2022palm) dans des expériences avec ReAct.
+Les comparaisons avec le prompting standard (question uniquement), CoT et d'autres configurations
+montrent que les performances de ReAct sont prometteuses pour les tâches de raisonnement complexes. Google
+effectue également des études sur le jeu de données FEVER(@thorne2018fever), qui couvre
+l'extraction et la vérification des faits.
-ReAct Results (Yao et al.)
+Résultats ReAct (Yao et al.)
diff --git a/(docs)/fr/docs/missing.json b/(docs)/fr/docs/missing.json
index 4be7aefb17e..891607db1ad 100644
--- a/(docs)/fr/docs/missing.json
+++ b/(docs)/fr/docs/missing.json
@@ -1,39 +1,4 @@
[
- {
- "slug": "advanced_applications",
- "title": "🚀 Advanced Applications",
- "position": 20,
- "subpages": [
- {
- "slug": "overview",
- "title": "🟢 Introduction",
- "position": 1,
- "href": "\\docs\\advanced_applications\\overview",
- "subpages": null
- },
- {
- "slug": "mrkl",
- "title": "🟡 LLMs Using Tools",
- "position": 2,
- "href": "\\docs\\advanced_applications\\mrkl",
- "subpages": null
- },
- {
- "slug": "react",
- "title": "🟡 LLMs that Reason and Act",
- "position": 3,
- "href": "\\docs\\advanced_applications\\react",
- "subpages": null
- },
- {
- "slug": "pal",
- "title": "🟡 Code as Reasoning",
- "position": 4,
- "href": "\\docs\\advanced_applications\\pal",
- "subpages": null
- }
- ]
- },
{
"slug": "applied_prompting",
"title": "🧪 Applied Prompting",