Se connecter à l'API d'OpenAI

Création d'un traducteur de langue avec OpenAI

Création d'un assistant vocal avec OpenAI

Python

### Création d'un traducteur de langue

![Description](https://i.imgur.com/wz32sUQ.png)

Comme nous avons pu le voir lors du précédent chapitre, nous utiliserons l'API d'OpenAI pour créer un traducteur de langue en Python.
Cela peut paraître complexe lorsqu'on pense aux grands noms tels que Google Traduction ou encore Deepl. Mais vous allez voir que l'API d'OpenAI va nous simplifier la vie.

Dans ce chapitre nous aborderons deux traducteurs, le premier sera très simpliste, nous permettant de traduire un texte en une seule langue, mais le second sera quand a lui un peut plus complexe, nous permettant de choisir une traduction entre plusieurs langues avec une réponse de l'IA Ecrite et Orale. 

### Coder la base du programme
Nous allons nous référer a la partie "Chat Completion" de la documentation de l'API (Si vous ne voyez pas de quoi je parle, merci de vous référer au chapitre précédent).
Dans un premier temps, nous importons la bibliothèque d'openai puis nous créons une variable avec comme valeur notre APIKey d'OpenAI comme ceci:
``` python
import openai
openai.api_key = "VOTRE_API_KEY"
```
Une fois cela fait, nous nous référons à la documentation pour créer notre completion, nous créeons une varible qui contiendra le modèle de language que nous utiliserons ainsi que les rôles et ses exemples afin de donner un contexte a GPT.
``` python
completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": ""},
    {"role": "user", "content": ""}
  ]
)
```
Bien, pour l'instant nous ne lui donnons pas de contexte, on verra cela un peu plus tard dans ce chapitre.
Pour finir, nous devrons afficher le résultat de cette opération (donc la réponse de GPT), pour ce faire, nous utilisons simplement la fonction print.
``` python
print(completion.choices[0].message.content)
```
Alors, observons cette ligne, c'est quoi ce charabia me diriez vous ?
Je vais vous l'expliquer mais avant, voyez de vous même la réponse de GPT si je lui demande uniquement de m'afficher le résultat du calcul:
``` json
{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "\n\nMessage de réponse",
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}
```
Nous n'obtenons pas directement la réponse attendu mais un tas d'autres informations utiles, sauf que cela ne nous intéresse pas. Donc le 
``` python 
print(completion.choices[0].message.content)
```
correspond à afficher uniquement le message de réponse qui nous intéresse (content).

### Coder un traducteur de langue Français - Anglais simple
Bien, passons au vif du sujet, nous allons reprendre la base de code que nous avons écrite précedemment et ajouter un contexte afin que l'AI sache comment se comporter face à nos questions.
Pour ce faire nous allons lui assigner des rôles et créer un échange RLHF comme vu au précedent chapitre, rappelez vous de:

- system
- user
- assistant

Pour ce faire, nous allons demander au système de se comporter en tant que traducteur de langue Français - Anglais.
Le code pourrait ressembler à cela:
``` python
import openai
openai.api_key = "VOTRE_API_KEY"

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "Tu es un traducteur de langue Français - Anglais"},
    {"role": "user", "content": ""}
  ]
)

print(completion.choices[0].message)
```
Maintenant, nous allons lui donner un exemple afin de renforcer cette mise en contexte.
``` python
import openai
openai.api_key = "VOTRE_API_KEY"

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "Tu es un traducteur de langue Français - Anglais"},
    {"role": "user", "content": "GCA est le meilleur serveur destiné aux développeurs."},
	{"role": "assistant", "content": "GCA is the best server for developers."}
  ]
)

print(completion.choices[0].message)
```
Nous avons donc donné un contexte a GPT en lui indiquant qu'il est un traducteur de langue Français - Anglais et nous lui avons donné un exemple "GCA est le meilleur serveur destiné aux développeurs." auquel il devrait répondre "GCA is the best server for developers."
Bien, nous allons désormais faire en sorte que l'utilisateur puisse demander une traduction au chatbot que nous avons créé. Pour ce faire nous créerons une variable avec un input stockant le texte de l'utilisateur a traduire. Une fois cette variable crée, nous ajoutons un nouveau rôle "user" contenant cette demande afin qu'elle soit traitée par l'IA.
``` python
import openai
openai.api_key = "VOTRE_API_KEY"

user_text = input("Que voulez vous traduire ?: \n")

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "Tu es un traducteur de langue Français - Anglais"},
    {"role": "user", "content": "GCA est le meilleur serveur discord destiné aux développeurs."},
    {"role": "assistant", "content": "GCA is the best discord server for developers."},
    {"role": "user", "content": user_text}
  ]
)

print(completion.choices[0].message.content)
```
Bien, maintenant que notre programme est prêt, testons le avec
``` 
Input:
Je suis le canard de bain qui aide les développeurs
Output: 
I am the rubber duck that helps developers.
```
Nous voyons que notre traducteur de langue assez simpliste fonctionne grâce à l'IA. Passons désormais a un traducteur de langue un peu plus complexe.

### Coder un traducteur de langues vocal
Nous avons vu précedemment comment coder un traducteur de langues simple Français - Anglais. Maintenant, a partir du même code, nous allons créer un traducteur de langue similaire qui prendrait en compte plusieurs langues en permettant à l'utilisateur de choisir celle qu'il souhaite. De plus, ce traducteur permettra de répondre à l'utilisateur directement en vocal.

Reprenons notre code initial
``` python
import openai
openai.api_key = "VOTRE_API_KEY"

user_text = input("Que voulez vous traduire ?: \n")

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "Tu es un traducteur de langue Français - Anglais"},
    {"role": "user" , "content": user_text}
  ]
)

print(completion.choices[0].message.content)
```
Vous voyez que dans le rôle System nous avons indiqué à GPT qu'il doit traduire en anglais, remplaçons cela par une variable afin de plus tard, laisser la possibilité à l'utilisateur de choisir une langue.
``` python
import openai
openai.api_key = "VOTRE_API_KEY"

user_text = input("Que voulez vous traduire ?: \n")
langue = ""

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", f"content": "Tu es un traducteur de langue Français - {langue}"},
    {"role": "user", "content": user_text}
  ]
)

print(completion.choices[0].message.content)
```
Dans un premier temps, nous allons nous concentrer sur la sortie vocale de l'IA. Pour ce faire nous utiliserons la bibliothèque "pyttsx3". Cette bibliothèque permet de convertir du text en speech.
Pour l'installation, nous importerons cette bibliothèque et nous initialiserons le text to speech de la réponse de l'IA.
``` python
import openai
import pyttsx3

openai.api_key = "VOTRE_API_KEY"

engine = pyttsx3.init() # Initialisation de pyttsx3.init() dans la variable "engine"
voices = engine.getProperty('voices') # Initialisation dans la variable "voices" des propriétées de celle-ci

user_text = input("Que voulez vous traduire ?: \n")
langue = ""

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": f"Tu es un traducteur de langue Français - {langue}"},
    {"role": "user", "content": user_text}
  ]
)

response = completion.choices[0].message.content
print(response)
engine.setProperty('voice', voices[0].id) # Set des propriétées de la voix
engine.say(response) # Speech la réponse de l'IA
engine.runAndWait()
```
Bien, nous avons donc notre réponse qui ressort en text to speech.
Désormais nous allons créer un petit input contenu dans la variable "langue" afin de permettre à l'utilisateur de choisir une langue.
``` python
import openai
import pyttsx3

openai.api_key = "VOTRE_API_KEY"

engine = pyttsx3.init()
voices = engine.getProperty('voices')


langue = input("En quelle langue pouvez vous traduire: ")


print(langue)
user_text = input("Que voulez vous traduire ?: \n")

completion = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": f"Tu es un traducteur de langue Français vers {langue}"},
    {"role": "user", "content": user_text}
  ]
)

response = completion.choices[0].message.content
print(response)
engine.setProperty('voice', voices[0].id)
engine.say(response)
engine.runAndWait()

```
Et nous voilà avec un traducteur de langue text to speech fonctionnel.

Le code source est disponible sur [le github du projet](https://github.com/creators-area/translate-with-openai)

<data>NE PAS SUPPRIMER CETTE LIGNE!</data>

Nous découvrirons les fondement de l'API d'OpenAI pour vous aussi, créer vos propres projets d'intelligence artificielle.