Quel outil pour créer un chatbot avec Python ?

Dans ce didacticiel, vous apprendrez comment créer un projet de chatbot en Python.

Plan de l'article

Présentation

Les chatbots sont très utiles tant pour les entreprises que pour les clients.

Lire également : Comment trouver un trou dans une piscine Intex tubulaire ?

La plupart des gens préfèrent parler directement à partir d’un chat plutôt que d’appeler des centres de service.

A voir aussi : Comment choisir le bon traiteur pour votre mariage ?

Facebook a publié des données qui ont prouvé la valeur des robots. En fait, plus de 2 milliards de messages sont envoyés chaque mois entre particuliers et entreprises.

Selon une étude HubSpot, 71 % des personnes souhaitent bénéficier d’une assistance client via des applications de messagerie. C’est donc un moyen rapide de résoudre vos problèmes.

Cela dit, les chatbots ont un bel avenir dans les entreprises.

Créons maintenant un projet intéressant dans Chatbot. Nous allons déployer un chatbot à partir de zéro .

Ce logiciel comprendra de quoi parle l’utilisateur et peut donner une réponse adéquate.

Ce que vous devez avoir au préalable

Pour déployer le chatbot, nous allons d’abord utiliser Keras. Il s’agit d’une bibliothèque d’apprentissage profond, NLTK, qui est une suite d’outils de traitement du langage naturel (NLP). Nous avons également besoin de quelques bibliothèques utiles. Exécutez la commande suivante pour vous assurer que toutes les bibliothèques sont installées :

installation de pipeline tensorflow keras pickle nltk Si vous souhaitez apprendre Python gratuitement, voici le guide principal.

Si vous souhaitez connaître le meilleur hébergement Python, lisez notre guide.

Comment fonctionnent les chatbots ?

Les chatbots sont simplement des logiciels intelligents qui peuvent interagir et communiquer avec des personnes comme des humains.

C’est intéressant, n’est-ce pas ?

Voyons maintenant comment ils fonctionnent réellement.

Tous les chatbots sont inclus dans les concepts de la PNL (traitement du langage naturel). La PNL comprend deux choses :

  • NLU (Natural Language Comprehension) : c’est la capacité des machines à comprendre le langage humain tel que l’anglais. français, etc…
  • NLG (Natural Language Generation) : C’est la capacité d’une machine à générer du texte similaire à des phrases écrites par des humains.

Imaginez qu’un utilisateur pose une question à un chatbot :

Bonjour, quelles sont les nouvelles aujourd’hui ? Le chatbot divisera la phrase de l’utilisateur en deux choses :

  1. Intention et
  2. entité

L’intention de cette phrase pourrait être have_news car elle fait référence à une action que l’utilisateur souhaite effectuer.

L’entité donne des détails spécifiques sur l’intention, donc « aujourd’hui » sera l’entité.

Par conséquent, un modèle d’apprentissage automatique est utilisé pour reconnaître le les intentions et les entités du chat.

La structure du dossier de projet

Une fois le projet terminé, vous aurez tous ces fichiers.

Examinons rapidement chaque fichier. Cela vous donnera une idée de la façon dont le projet sera mis en œuvre.

  • Train_chatbot.py : Dans ce fichier, nous allons créer et entraîner le modèle d’apprentissage profond ou d’apprentissage profond. Ce dernier va classer et identifier ce que l’utilisateur demande au robot.
  • Gui_Chatbot.py : C’est dans ce fichier que nous allons créer une interface utilisateur graphique pour discuter avec notre chatbot entraîné.
  • Indents.json : Le fichier d’intention contient toutes les données que nous allons utiliser pour entraîner le modèle. Il comprend une collection d’étiquettes avec leurs modèles et réponses correspondants.
  • ChatBot_Model.h5 : Il s’agit d’un fichier de format de des données hiérarchiques dans lesquelles nous stockons les poids et l’architecture de notre modèle entraîné.
  • Classes.pkl : Le fichier de cornichon peut être utilisé pour enregistrer tous les noms de balises afin de les classer lorsque nous prédisons le message.
  • Words.pkl : Le fichier pickle words.pkl contient tous les mots uniques qui composent le vocabulaire de notre modèle.

Téléchargez le code source et l’ensemble de données : https://drive.google.com/drive/folders/1r6MrrdE8V0bWBxndGfJxJ4Om62dJ2OMP?usp=sharing

Comment créer votre propre chatbot ?

Voici les 5 étapes simples pour créez ce chatbot :

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

Créez un nouveau fichier Python et appelez-le train_chatbot.

Ensuite, nous allons importer tous les modules nécessaires. Ensuite, nous allons lire le fichier de données JSON dans notre programme Python.

Étape 2. Données de prétraitement Python import Numpy en tant que NP Importation séquentielle de Keras.Models de keras.layers import Dense, Activate, Dropout à partir de keras.optimizers import SGD importation aléatoire importation NLTK à partir de nltk.stem import WordNetLemmatizer Lemmatizer = WordNetLemmatizer () import json cornichon d’importation intents_file = ouvrir (‘intents.json’) .read () intents = json.loads (intents_file)

Le modèle ne prend pas de données brutes. Vous devez subir de nombreux prétraitements pour que la machine puisse facilement le comprendre.

Pour les données textuelles, il existe plusieurs techniques de prétraitement. Le premier est la tokenisation. Il consiste à diviser des phrases en mots.

En regardant le fichier d’intention, nous constatons que chaque balise contient une liste de modèles et de réponses.

Nous jetons chaque modèle et ajoutons les mots à une liste.

Également nous créons une liste de classes et de documents pour y ajouter toutes les intentions associées aux modèles.

Python mots = cours = documents = ignore_letters = Pour l’intention dans les intentions : pour le motif dans l’intention : #tokenize chaque mot word = nltk.word_tokenize (modèle) words.extend (mot) documents #add dans le corpus documents.append (mot, intention) # ajouter à notre liste de cours Si l’intention n’est pas dans les cours : classes.append impression (documents) Une autre technique est la lemmatisation.

Il consiste à convertir des mots sous la forme d’un slogan pour réduire tous les mots canoniques.

Par exemple, les mots play, play, play, etc. seront remplacés par play.

De cette façon, nous pouvons réduire le nombre total de mots de notre vocabulaire. Maintenant, nous lemmatisons chaque mot et supprimons les doublons.

Python # Lemmaztize et téléchargez chaque mot et supprimez les doublons mots = mots = ordonné (liste (set (mots))) Nombre de types de sorts classes = ordonné (list (set (classes))) Nombre de documents = combinaison de modèles et d’intentions print (len (documents), « documents ») Nbre de classes = intentions print (len (classes), « classes », classes) Nombre de mots = tous les mots, vocabulaire print (len (mots), « mots lemmatisés uniques », mots) pickle.dump (mots, open (‘words.pl’, ‘wb’)) pickle.dump (classes, open (‘classes.pkl’, ‘wb’)) Au final, les mots contiennent le vocabulaire de notre projet, tandis que les classes incluent toutes les entités qui vont être classées.

Pour graver l’objet Python dans un fichier, nous utilisons la méthode pickle.dump (). Ces fichiers seront utiles une fois la formation terminée et lorsque nous planifierons des chats.

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

Pour entraîner le modèle, nous allons convertir chaque modèle d’entrée en chiffres.

Tout d’ abord, nous allons lemmatiser chaque mot du modèle.

Pour ce faire, vous devez créer une liste de zéros de la même longueur que le nombre de tous les mots. Nous allons définir la valeur 1 uniquement pour les index qui contiennent le mot dans les modèles. De même, nous allons créer la sortie en définissant la valeur 1 pour la classe d’entrée à laquelle appartient le modèle.

Étape 4. Ex le modèle Python # créer des données d’entraînement formation = # créer un tableau vide pour la sortie output_empty =* len (classes) # set d’entraînement, sac de mots pour chaque phrase pour les documents contenus dans les documents : # sac de mots d’initialisation sac = # liste de mots symbolisés pour le motif word_patterns = doc # lemmatisez chaque mot : créez un mot de base, dans le but de représenter des mots apparentés word_patterns = # crée le tableau de sacs de mots avec 1, si le mot est dans le modèle actuel par word in mots : bag.append (1) si mot dans word_patterns sinon bag.append (0) # la sortie est un « 0 » pour chaque étiquette et « 1 » pour l’étiquette courante (pour chaque motif) output_row = liste (output_empty) output_row)] = 1 training.append () # Mélangez les fonctionnalités et créez un tableau numpy random.shuffle (entraînement) formation = np.array (formation) # créer des listes de formation et des tests. X : motifs, Y : intentions train_x = list (formation) train_y = list (formation) print (« Les données d’entraînement sont créées »

L’architecture de notre modèle sera un réseau de neurones composé de 3 canapés denses.

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

Des couches déroulantes sont introduites pour réduire le surajustement du modèle. Nous utilisons l’optimiseur SGD et ajustons les données pour démarrer entraîner le modèle.

Lorsque la formation à 200 époques est terminée, nous enregistrons le modèle entraîné à l’aide de la fonction Keras model.save (« chatbot_model.h5″).

Étape 5. Interagissez avec le chatbot Python # Modèle de réseaux de neurones profonds model=sequential () model.add (Dense (128, input_shape= (len (train_x),), activation=’revue’)) model.add (abandon (0.5)) model.add (Denso (64, activation=’ relire ‘)) model.add (abandon (0.5)) model.add (Denso (len (train_y), activation=’ softmax ‘)) # Modèle de construction. Le gradient accéléré SGD de Nesterov donne de bons résultats pour ce modèle sgd = SGD (lr = 0,01, désintégration = 1-6, impulsion = 0,9, nesterov = vrai) model.compile (loss=’categorical_crossentropy’, optimiseur=sgd, métriques =) #Training et enregistrez le modèle hist = model.fit (np.array (train_x), np.array (train_y), temps = 200, taille_lot = 5, verbeux = 1) model.save (‘chatbot_model.h5’, hist) print (« le modèle est créé »)

Notre modèle est prêt à discuter.

Créons maintenant une belle interface graphique pour notre chatbot dans un nouveau fichier.

Vous pouvez nommer le fichier en tant que gui_chatbot.py

Dans notre fichier GUI, nous utiliserons le module Tkinter pour créer la structure de l’application de bureau. Nous saisirons ensuite le message de l’utilisateur et effectuerons un prétraitement avant de le saisir dans notre modèle formé.

Le modèle prédit l’étiquette du message de l’utilisateur. Ensuite, nous sélectionnerons aléatoirement la réponse dans la liste des réponses de notre dossier d’intention ou d’ « intentions ».

Voix le code source complet du fichier GUI.

Python import à partir de nltk.stem import WordNetLemmatizer Lemmatizer = WordNetLemmatizer () cornichon d’importation import numpy en tant que np à partir de keras.models import load_model modèle= load_model (‘chatbot_model.h5’) json importar importación aleatoria intents = json.loads (open (‘intents.json’) .read ()) mots = pickle.load (open (‘words.pkl’, ‘rb’)) classes = pickle.load (open (‘classes.pkl’, ‘rb’)) def clean_up_sentence (phrase) : # tokenize the pattern – diviseur de palabras en array sentence_words = nltk.word_tokenize (oración) # derivando cada palabra – base réductible à la forma sentence_words = dévolver sentence_words # devuelve bolsa de palabras matriz : 0 o 1 para palabras que existen en la oración def bag_of_words (oración, palabras, show_details=true) : # patrones de tokenización sentence_words = clean_up_sentence (phrase) # bolsa de palabras – Matriz de vocabulario sac = *len (palabras) para s en sentence_words : para i, palabra en enumerate (palabras) : si palabra == s : # asignar 1 si la palabra actual está en la posición de vocabulario bolsa = 1 si show_details : print (« encontrado en la bolsa : %s » % palabra) revenir (np.array (bolsa)) def predict_class (cours) : # prédicciones de filtro por debajo del umbral p = bag_of_words (oración, palabras, show_details=false) res = model.predict (np.array ()) ERROR_THRESHOLD = 0,25 results = para i, r en enumerar (res) si r>

error_threshold] # probabilidad de fuerza de clasificación results.sort (clave=lambda x : x, inverso=verdadero) return_list = para r en los résultats : return_list.append ({« intención » : classes], « probabilité » : str (r)}) retour return_list def GetResponse (ints, intents_json) : tag = ints list_of_intents = intents_json para i en list_of_intents : si (étiquette i==) : resultado = aleatorio.choice (i) barboteuse résultats volver #Creating interface graphique utilisateur tkinter importar tkinter Importation de tkinter* def send () : msg = entrybox.get (« 1.0″, ‘fin 1c’) .strip () entrybox.delete (« 0.0″, FIN) c’est msg ! = « : Chatbox.config (estado=normal) ChatBox.insert (FIN, « Tú : » mensaje ‘ n  n’) Chatbox.config (premier plan = » #446665 «, police = (« Verdana », 12)) ints = predict_class (classe prédictive) res = GetResponse (entiers, intentions) ChatBox.insert (FIN, « Bot : » res ‘ n  n’) Chatbox.config (state=deshabilitado) Chatbox.yView (FIN) racine = Tk () root.title (« Chatbot ») root.geometry (« 400×500″) root.resizable (ancho=faux, alto=faux) Ventana de chat #Create ChatBox = Texto (raíz, bd = 0, bg = « blanc », altura = « 8″, ancho = « 50″, fuente = « Arial »,) Chatbox.config (state=deshabilitado) #Bind Barra de desplazamiento a la ventana de chat barre de défilement = barre de défilement (racine, commande=chatbox.yview, curseur = « cœur ») ChatBox = scrollbar.set Botón #Create para enviar el mensaje SendButton = Botón (racine, police = (« Verdana », 12, ‘Negrita’), texte = « Enviar », ancho = « 12″, altura = 5, bd=0, bg= » #f9a602 «, arrière-plan actif = » #3c9d9b «, fg=’ #000000 ‘, commande= Enviar) #Create el cuadro para introducir el mensaje EntryBox = Texte (raíz, bd = 0, bg = « blanc », anco = « 29″, hauteur = « 5″, police = « Arial ») #EntryBox .bind (« », envoyer) #Place Tous les composants de l’écran scrollbar.place (x=376, y=6, hauteur=386) Chatbox.place (x = 6, y = 6, hauteur = 386, largeur = 370) EntryBox.place (x = 128, y = 401, hauteur = 90, largeur = 265) SendButton.place (x = 6, y = 401, hauteur = 90) root.mainloop () Découvrez plus des projets Python avec le code source.

Exécutez le chatbot

Nous avons maintenant deux fichiers distincts, l’un esta le le train_chatbot.py, que nous allons d’abord utiliser pour l’ancien modèle.

Ressources supplémentaires : python train_chatbot.py

  • 4 applications professionnelles pour le traitement du langage Natural Language Processing (NLP)
  • Créer un chatbot avec un système expert

vous pourriez aussi aimer