Comment créer un Chatbot avec Python

Mise à jour: 23 octobre 2024

Dans ce tutoriel, nous allons explorer comment créer un projet de chatbot avec Python, un langage de programmation polyvalent et largement utilisé. Les chatbots jouent aujourd’hui un rôle central dans l’interaction entre les entreprises et leurs clients, en offrant un service immédiat et accessible.

Les préférences des consommateurs évoluent : de plus en plus de personnes préfèrent interagir via une boîte de discussion plutôt que de passer des appels téléphoniques, jugés plus longs et contraignants. Selon des données récentes de Facebook, plus de 2 milliards de messages sont échangés chaque mois entre particuliers et entreprises, soulignant l’importance des chatbots dans les interactions commerciales.

De plus, une étude de HubSpot révèle que 65% des consommateurs souhaitent bénéficier d’un service client via des applications de messagerie. Cela montre que l’intégration de chatbots dans les services d’assistance est non seulement un gain de temps, mais également un moyen de fournir une réponse immédiate aux besoins des clients.

Dans ce projet passionnant, nous allons implémenter un chatbot à partir de zéro. Ce chatbot sera capable de comprendre les intentions de l’utilisateur et de répondre de manière pertinente, illustrant l’un des nombreux usages des chatbots dans les entreprises modernes.

Ce qu’il faut avoir au préalable

Pour implémenter le chatbot, nous allons d’abord utiliser Keras. C’est une bibliothèque Deep Learning, NLTK, qui est une boîte à outils de traitement du langage naturel ou Natural Language Processing (NLP). Nous avons aussi besoin de quelques bibliothèques utiles.

Exécutez la commande ci-dessous pour vous assurer que toutes les bibliothèques sont installées :

 pip install tensorflow keras pickle nltk

Si vous voulez apprendre Python gratuitement, voici le guide principal.

Comment fonctionnent les Chatbots ?

Les chatbots sont des logiciels intelligents conçus pour interagir avec les utilisateurs de manière naturelle, presque comme le ferait un humain. Leur capacité à comprendre et à répondre en langage naturel les rend essentiels dans diverses applications, qu’il s’agisse du service client, du commerce en ligne ou des réseaux sociaux.

Mais, comment fonctionnent-ils réellement ?

Les chatbots reposent sur des concepts avancés de Traitement du Langage Naturel (NLP), une branche de l’intelligence artificielle (IA) qui permet aux machines de comprendre et de générer des réponses dans un langage humain. Le NLP est composé de deux sous-domaines clés :

Exemple de fonctionnement

Prenons l’exemple suivant : un utilisateur pose une question au chatbot :

Hey, quelles sont les nouvelles d’aujourd’hui ?

Le chatbot décompose cette phrase en deux éléments principaux :

1. L’intention : Ce que l’utilisateur souhaite accomplir. Ici, l’intention serait « obtenir des nouvelles».
2. L’entité : Les informations spécifiques concernant l’intention. Dans cet exemple, l’entité serait « aujourd’hui », car elle donne un cadre temporel à la demande.

Grâce à un modèle d’apprentissage automatique, le chatbot peut identifier ces intentions et entités, ce qui lui permet de formuler une réponse pertinente et adaptée à la question de l’utilisateur.

La structure du fichier de projet

Une fois que vous aurez complété ce projet de chatbot en Python, vous obtiendrez une série de fichiers essentiels pour son fonctionnement. Examinons rapidement chaque fichier pour comprendre comment ils contribuent à la réalisation du projet.

Téléchargez le code source et le dataset : https://drive.google.com/drive/folders/1r6MrrdE8V0bWBxndGfJxJ4Om62dJ2OMP?usp=sharing

Comment créer votre propre chatbot ?

Voici un guide en 5 étapes simples pour créer un chatbot en Python. Nous allons utiliser des bibliothèques populaires et des techniques de machine learning pour construire un modèle qui pourra comprendre et répondre à des questions posées en langage naturel.

Étape 1. Importer des bibliothèques et charger les données

Commencez par créer un fichier Python, nommé train_chatbot.py. Nous allons importer les bibliothèques nécessaires et charger le fichier de données JSON, qui contiendra les intentions (intents) que le chatbot devra comprendre.

Python 
 import numpy as np
 from keras.models import Sequential
 from keras.layers import Dense, Activation, Dropout
 from keras.optimizers import SGD
 import random
 import nltk
 from nltk.stem import WordNetLemmatizer
 lemmatizer = WordNetLemmatizer()
 import json
 import pickle
 intents_file = open('intents.json').read()
 intents = json.loads(intents_file) 

Étape 2. Prétraiter les données

Avant de pouvoir entraîner le modèle, nous devons prétraiter les données textuelles. Cela inclut la tokenisation (découper les phrases en mots) et la lemmatisation (réduire les mots à leur forme canonique). Ces techniques permettent au modèle de mieux comprendre et interpréter les phrases.

Exemple de tokenisation : Si l’utilisateur pose la question « Quelle est la météo aujourd’hui ?», la phrase sera décomposée en mots : ["Quelle", "est", "la", "météo", "aujourd'hui"].

Exemple de lemmatisation : Les mots « jouer », « jouant », « joue », et «joué» seront tous ramenés à leur forme racine : «jouer». Cela aide à réduire la complexité du modèle en regroupant des variations similaires d’un mot.

Python 
 words=[]
 classes = []
 documents = []
 ignore_letters = ['!', '?', ',', '.']
 for intent in intents['intents']:
     for pattern in intent['patterns']:
         #tokenize each word
         word = nltk.word_tokenize(pattern)
         words.extend(word)        
         #add documents in the corpus
         documents.append((word, intent['tag']))
         # add to our classes list
         if intent['tag'] not in classes:
             classes.append(intent['tag'])
 print(documents) 

Le fichier words.pkl contiendra tous les mots lemmatisés, et classes.pkl stockera toutes les intentions (ou « tags ») du chatbot, telles que météo, salutations, ou nouvelles.

Python 
 # lemmaztize and lower each word and remove duplicates
 words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_letters]
 words = sorted(list(set(words)))
 # sort classes
 classes = sorted(list(set(classes)))
 # documents = combination between patterns and intents
 print (len(documents), "documents")
 # classes = intents
 print (len(classes), "classes", classes)
 # words = all words, vocabulary
 print (len(words), "unique lemmatized words", words)
 pickle.dump(words,open('words.pkl','wb'))
 pickle.dump(classes,open('classes.pkl','wb')) 

À la fin, les mots contiennent le vocabulaire de notre projet tandis que les classes comprennent toutes les entités à classer.

Pour enregistrer l’objet Python dans un fichier, nous avons utilisé la méthode pickle.dump(). Ces fichiers seront utiles une fois la formation terminée et lorsque nous prévoyons les tchats.

Étape 3. Créer des données de formation et de test

Pour entraîner le modèle, nous devons transformer chaque phrase d’entrée en vecteur numérique (bag of words). Cela signifie qu’on crée une liste de zéros pour chaque mot du vocabulaire, avec une valeur de 1 si le mot apparaît dans la phrase.

Exemple de bag of words : Si la phrase est : « Quelle est la météo aujourd’hui ?», le vecteur pourrait ressembler à [0, 1, 1, 0, 1, …], où 1 représente les mots qui apparaissent dans la phrase et 0 ceux qui n’y apparaissent pas.

Python 
 # create the training data
 training = []
 # create empty array for the output
 output_empty = [0] * len(classes)
 # training set, bag of words for every sentence
 for doc in documents:
     # initializing bag of words
     bag = []
     # list of tokenized words for the pattern
     word_patterns = doc[0]
     # lemmatize each word - create base word, in attempt to represent related words
     word_patterns = [lemmatizer.lemmatize(word.lower()) for word in word_patterns]
     # create the bag of words array with 1, if word is found in current pattern
     for word in words:
         bag.append(1) if word in word_patterns else bag.append(0)
         
     # output is a '0' for each tag and '1' for current tag (for each pattern)
     output_row = list(output_empty)
     output_row[classes.index(doc[1])] = 1
     training.append([bag, output_row])
 # shuffle the features and make numpy array
 random.shuffle(training)
 training = np.array(training)
 # create training and testing lists. X - patterns, Y - intents
 train_x = list(training[:,0])
 train_y = list(training[:,1])
 print("Training data is created"

Étape 4. Former le modèle

L’architecture de notre modèle sera un réseau neuronal composé de trois couches denses.

La première couche contient 128 neurones, la seconde à 64 et la dernière aura les mêmes neurones que le nombre de classes.

Les couches de décrochage sont introduites pour réduire le sur-ajustement du modèle. Nous avons utilisé l’optimiseur SGD et ajusté les données pour commencer à former le modèle.

Lorsque la formation de 200 époques sera terminée, nous enregistrons le modèle formé en utilisant la fonction Keras model.save (« chatbot_model.h5 »).

Python 
 # deep neural networds model
 model = Sequential()
 model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
 model.add(Dropout(0.5))
 model.add(Dense(64, activation='relu'))
 model.add(Dropout(0.5))
 model.add(Dense(len(train_y[0]), activation='softmax'))
 # Compiling model. SGD with Nesterov accelerated gradient gives good results for this model
 sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
 model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
 #Training and saving the model 
 hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)
 model.save('chatbot_model.h5', hist)
 print("model is created")

Étape 5. Interagir avec le chatbot

Le modèle est maintenant prêt à fonctionner !

Nous allons maintenant créer une belle interface graphique pour notre chatbot dans un nouveau fichier. Vous pouvez nommer le fichier comme gui_chatbot.py

Dans notre fichier GUI, nous utiliserons le module TKinter pour construire la structure de l’application de bureau. Puis, nous allons capturer le message de l’utilisateur et refaire quelques prétraitements avant d’entrer le message dans notre modèle formé.

Le modèle va ensuite prédire la balise du message de l’utilisateur. Ensuite, nous allons sélectionner aléatoirement la réponse dans la liste des réponses de notre fichier d’intentions ou d’« intents ».

Voici le code source complet du fichier GUI.

Python 
 import nltk
 from nltk.stem import WordNetLemmatizer
 lemmatizer = WordNetLemmatizer()
 import pickle
 import numpy as np
 from keras.models import load_model
 model = load_model('chatbot_model.h5')
 import json
 import random
 intents = json.loads(open('intents.json').read())
 words = pickle.load(open('words.pkl','rb'))
 classes = pickle.load(open('classes.pkl','rb'))
 def clean_up_sentence(sentence):
     # tokenize the pattern - splitting words into array
     sentence_words = nltk.word_tokenize(sentence)
     # stemming every word - reducing to base form
     sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]
     return sentence_words
 # return bag of words array: 0 or 1 for words that exist in sentence
 def bag_of_words(sentence, words, show_details=True):
     # tokenizing patterns
     sentence_words = clean_up_sentence(sentence)
     # bag of words - vocabulary matrix
     bag = [0]*len(words)  
     for s in sentence_words:
         for i,word in enumerate(words):
             if word == s: 
                 # assign 1 if current word is in the vocabulary position
                 bag[i] = 1
                 if show_details:
                     print ("found in bag: %s" % word)
     return(np.array(bag))
 def predict_class(sentence):
     # filter below  threshold predictions
     p = bag_of_words(sentence, words,show_details=False)
     res = model.predict(np.array([p]))[0]
     ERROR_THRESHOLD = 0.25
     results = [[i,r] for i,r in enumerate(res) if r>ERROR_THRESHOLD]
     # sorting strength probability
     results.sort(key=lambda x: x[1], reverse=True)
     return_list = []
     for r in results:
         return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
     return return_list
 def getResponse(ints, intents_json):
     tag = ints[0]['intent']
     list_of_intents = intents_json['intents']
     for i in list_of_intents:
         if(i['tag']== tag):
             result = random.choice(i['responses'])
             break
     return result
 #Creating tkinter GUI
 import tkinter
 from tkinter import *
 def send():
     msg = EntryBox.get("1.0",'end-1c').strip()
     EntryBox.delete("0.0",END)
     if msg != '':
         ChatBox.config(state=NORMAL)
         ChatBox.insert(END, "You: " + msg + '\n\n')
         ChatBox.config(foreground="#446665", font=("Verdana", 12 )) 
         ints = predict_class(msg)
         res = getResponse(ints, intents)
         
         ChatBox.insert(END, "Bot: " + res + '\n\n')           
         ChatBox.config(state=DISABLED)
         ChatBox.yview(END)
 root = Tk()
 root.title("Chatbot")
 root.geometry("400x500")
 root.resizable(width=FALSE, height=FALSE)
 #Create Chat window
 ChatBox = Text(root, bd=0, bg="white", height="8", width="50", font="Arial",)
 ChatBox.config(state=DISABLED)
 #Bind scrollbar to Chat window
 scrollbar = Scrollbar(root, command=ChatBox.yview, cursor="heart")
 ChatBox['yscrollcommand'] = scrollbar.set
 #Create Button to send message
 SendButton = Button(root, font=("Verdana",12,'bold'), text="Send", width="12", height=5,
                     bd=0, bg="#f9a602", activebackground="#3c9d9b",fg='#000000',
                     command= send )
 #Create the box to enter message
 EntryBox = Text(root, bd=0, bg="white",width="29", height="5", font="Arial")
 #EntryBox.bind("<Return>", send)
 #Place all components on the screen
 scrollbar.place(x=376,y=6, height=386)
 ChatBox.place(x=6,y=6, height=386, width=370)
 EntryBox.place(x=128, y=401, height=90, width=265)
 SendButton.place(x=6, y=401, height=90)
 root.mainloop()

Découvrez plus de projets Python avec le code source.

Exécuter le chatbot

Nous avons présentement deux fichiers distincts, l’un est le train_chatbot.py, que nous allons d’abord utiliser pour former le modèle.

 python train_chatbot.py

Ressources complémentaires :

• À propos
• Articles récents

Suivez moi

Jacques Tremblay

Webmaster depuis plus de 18 ans. J'ai pu développer plusieurs expertises dans le domaine de la création et de l'hébergement de sites Web.
Je me suis intéressé aussi au référencement de site Web le SEO. Il s'agit d'un domaine débordant de défis dans lequel tout le monde essaie de suivre les recommandations infinies de Google.

Suivez moi

Les derniers articles par Jacques Tremblay (tout voir)

• Avis Chemicloud - 7 novembre 2024
• Meilleurs Plugins Cache WordPress - 21 octobre 2024
• Avis Gandi - 18 octobre 2024

Previous

4 étapes simples pour transférer votre domaine existant vers un nouvel hébergeur

Next

Comment créer un site Web ? Guide complet de A à Z pour les débutants