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 assistant vocal

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

Lors des deux précedents cours, nous avons découvert l'utilisation de l'API d'OpenAI afin de créer, ensemble, un traducteur de langue grâce à l'IA. Aujourd'hui, nous allons, grâce aux notions apprises lors des précedents cours, créer un assistant vocal spécialisé dans le domaine de votre choix. Cet assistant sera capable d'écouter et d'assimiler une question humaine, de traiter la question et d'y répondre a l'oral en fonction de l'entrainement et du contexte qu'elle a reçu. De plus, il sera capable de conserver les anciennes questions / réponses afin d'améliorer son entrainement.

> <mark>Disclaimer</mark>
Pour poursuivre ce tutoriel, je vous invite fortement à voir mes deux derniers cours sur le sujet afin de ne pas être perdu
>

### Créer la base de notre IA
Pour commencer nous allons importer la bibliothèque d'OpenAI, ainsi qu'indiquer notre Api Key, puis, contrairement aux autres cours, nous introduirons notre rôle "system" (qui sera spécialisé en mini plantes pour ce cas là) dans une variable.
``` python
import openai

openai.api_key = "VOTRE_API_KEY"

syst_init = {"role":"system", "content": "Tu es un assistant spécialisé en mini plantes"}
```
Bien désormais nous allons faire en sorte que notre IA apprenne d'elle même en fonction des questions / réponses (ce que l'ont appel RLHF). Nous incluons donc notre variables contenant le rôle system dans une liste qui nous servira par la suite a stocker ces données.
 ``` python
import openai

openai.api_key = "VOTRE_API_KEY"

syst_init = {"role":"system", "content": "Tu es un assistant spécialisé en mini plantes"}
add_rlhf = [syst_init]
```
Une fois que nous avons ceci, nous allons créer une boucle infini afin de permettre à l'utilisateur et a l'IA d'alimenter cette liste au fur et a mesure de notre échange avec celle ci.
Dans cette boucle, nous placerons la variable d'entré de l'utilisateur que nous initialiserons dans le rôle "user", que nous placerons dans la liste "add_rlhf". 
``` python
while True:
  user_text = input("User: ") # Variable contenant l'entré utilisateur
  user_text_format = {"role":"user", "content": user_text} # Variable contenant le rôle "user" avec comme contenu l'entrée utilisateur
  add_rlhf.append(user_text_format) # Ajout du rôle utilisateur a la liste RLHF
```
Une fois que nous avons défini le rôle "user", nous allons ajouter notre completion comme vu lors du précédent cours. Celui-ci prendra pour "message" la fameuse liste RLHF et la réponse de l'IA sera ajoutée a la liste.
``` python
while True:
  user_text = input("User: ")
  user_text_format = {"role":"user", "content": user_text}
  add_rlhf.append(user_text_format)
  completion = openai.ChatCompletion.create(
    model = "gpt-3.5-turbo",
    messages = add_rlhf )
  response = completion.choices[0].message.content
  print("IA: ", response)
  add_rlhf.append({"role":"assistant", "content": response})
```
Bien, nous avons donc notre base d'assistant qui fonctionne pour l'instant uniquement à l'écrit.
Testons cela en lui posant deux questions:
- Comment arroser un cactus
- De quoi parlons nous ? (Afin de vérifier si l'IA a bien sauvegardé les dernières questions / réponses comme prévu)
``` shell
Input: Comment arroser un cactus
Output:  Pour arroser un cactus, il est important de suivre quelques étapes clés. Tout d'abord, utilisez de l'eau à température ambiante pour éviter de choquer la plante. Ensuite, assurez-vous que le sol soit bien sec avant d'arroser à nouveau. Un arrosage excessif peut endommager les cactus, il est donc préférable d'attendre que le sol soit complètement sec entre chaque arrosage. Enfin, évitez de laisser de l'eau stagnante dans la soucoupe du pot, car cela peut favoriser la pourriture des racines. Un arrosage modéré et régulier est la clé pour garder un cactus en bonne santé.
--
Input: De quoi parlons nous ?
Output: Nous parlons de la façon d'arroser les cactus.
```
Nous voyons donc que notre base d'IA fonctionne, elle répond à nos questions en enregistrant nos précédents échanges.
> <mark>Attention !
</mark>Nous avons précédemment vu que la tarification d'OpenAI fonctionnait par token, le fait d'effectuer une boucle infini peut être dangereux si vous faites une erreur.
Pour plus de renseignements, veuillez consulter le premier cours
>

### Permettre l'Input Oral et l'Output Vocal
Nous allons commencer par créer l'entrée vocale de l'utilisateur permettant a celui-ci de transmettre son prompt directement à l'oral. Ce prompt sera stocké dans la variable "user_text" créee précédemment. Pour ce faire, nous utiliserons la bibliothèque "speech_recognition".
Importons donc cette bibliothèque et initialisons  la.
``` python
import speech_recognition as sr

# Initialisation
r = sr.Recognizer()
```
Une fois l'initialisation effectué, nous entrons dans notre boucle infini, ouvrons le microphone par defaut de l'ordinateur et attribuons la variable "user_text" à l'entrée vocale de l'utilisateur.
``` python
while True:
  # Input
  with sr.Microphone() as source:
    print("Ecoute...")
    audio = r.listen(source)
    
  # Completion
  user_text = r.recognize_google(audio, language="fr-FR")
  print(user_text)
```
Maintenant la reconnaissance vocale effectuée, nous allons programmer la réponse vocale de l'IA. Pour ce faire, comme lors du précédent cours, nous utiliserons la bibliothèque "pyttsx3" que nous initialiserons comme précédement:
``` python
import pyttsx3

# Initialisation
engine = pyttsx3.init()
voices = engine.getProperty('voices')
```
Et nous démarrerons l'écoute de la varibale "response" générée par l'IA:
``` python
# Output vocal
  engine.setProperty('voice', voices[0].id)
  engine.say(response)
  engine.runAndWait()
```
Tout cela assemblé avec notre code de chatbot créé précédemment nous donne le code fonctionnel suivant:
``` python
import openai
import pyttsx3
import speech_recognition as sr

openai.api_key = "VOTRE_API_KEY"

# Initialisation
r = sr.Recognizer()
engine = pyttsx3.init()
voices = engine.getProperty('voices')
syst_init = {"role":"system", "content": "Tu es un assistant spécialisé en mini plantes"}
add_rlhf = [syst_init]

while True:
  # Input
  with sr.Microphone() as source:
    print("Ecoute...")
    audio = r.listen(source)
    
  # Completion
  user_text = r.recognize_google(audio, language="fr-FR")
  print(user_text)
  #user_text = input("User: ")
  user_text_format = {"role":"user", "content": user_text}
  add_rlhf.append(user_text_format)
  completion = openai.ChatCompletion.create(
    model = "gpt-3.5-turbo",
    messages = add_rlhf )
  response = completion.choices[0].message.content
  print("IA: ", response)

  # Output vocal
  engine.setProperty('voice', voices[0].id)
  engine.say(response)
  engine.runAndWait()
  add_rlhf.append({"role":"assistant", "content": response})
```
Vous pouvez le tester, votre code est désormais fonctionnel ! Vous pouvez poser des questions à votre chatbot a l'oral et il vous répondra en vocal tout en enregistrant et prenant en compte les échanges passés.

Le code source est disponible sur [le github du projet](https://github.com/creators-area/voice-assistant-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.