Table des matières[Cacher][Montrer]
Les appels vocaux sont progressivement supprimés au profit du texte et des visuels dans le secteur de la communication. Selon un sondage Facebook, plus de la moitié des acheteurs préfèrent acheter auprès d'une entreprise avec laquelle ils peuvent parler. Le chat est devenu le nouveau mode de communication socialement acceptable.
Il permet aux entreprises de communiquer avec leurs clients à tout moment et de n'importe où. Les chatbots gagnent en popularité auprès des entreprises et des clients en raison de leur facilité d'utilisation et de la réduction des temps d'attente.
Les chatbots, ou programmes de conversation automatisés, offrent aux clients une méthode plus personnalisée pour accéder aux services via une interface textuelle. Les nouveaux chatbots alimentés par l'IA peuvent reconnaître une requête (question, commande, commande, etc.) faite par une personne (ou un autre bot, inception) dans un environnement spécifique et y répondre de manière appropriée (réponse, action, etc.).
Dans cet article, nous verrons ce que sont les chatbots, leurs avantages, leurs cas d'utilisation et comment créer le vôtre l'apprentissage en profondeur chatbot en Python, entre autres.
Commençons.
Alors, que sont les chatbots ?
Un chatbot est souvent considéré comme l'une des formes d'interaction homme-machine les plus avancées et les plus prometteuses. Ces assistants numériques améliorent l'expérience client en rationalisant les interactions entre les personnes et les services.
Simultanément, ils offrent aux entreprises de nouvelles options pour optimiser le processus de contact client pour plus d'efficacité, ce qui peut réduire les dépenses d'assistance conventionnelles.
En un mot, il s'agit d'un logiciel basé sur l'IA destiné à communiquer avec les humains dans leur langage naturel. Ces chatbots interagissent souvent via des techniques audio ou écrites, et ils peuvent facilement imiter les langues humaines afin de se connecter avec les humains d'une manière humaine.
Les chatbots apprennent de leurs interactions avec les utilisateurs, devenant plus réalistes et efficaces au fil du temps. Ils peuvent gérer un large éventail d'activités commerciales, telles que l'autorisation de dépenses, l'interaction avec les consommateurs en ligne et la génération de prospects.
Créer votre propre chatbot d'apprentissage en profondeur avec python
Il existe de nombreux types distincts de chatbots dans le domaine de machine learning et IA. Certains chatbots sont des assistants virtuels, tandis que d'autres sont juste là pour converser, tandis que d'autres sont des agents du service client.
Vous avez probablement vu certains de ceux employés par les entreprises pour répondre aux demandes de renseignements. Nous allons créer un petit chatbot dans ce tutoriel pour répondre aux questions fréquemment posées.
1. Installation de packages
Notre première étape consiste à installer les packages suivants.
2. Données d'entraînement
Il est maintenant temps de déterminer le type d'informations dont nous aurons besoin pour donner à notre chatbot. Nous n'avons pas besoin de télécharger de grands ensembles de données car il s'agit d'un simple chatbot.
Nous n'utiliserons que les informations que nous avons créées nous-mêmes. Pour suivre efficacement la leçon, vous devrez générer un fichier .JSON au même format que celui présenté ci-dessous. Mon fichier s'appelle "intents.json".
Le fichier JSON est utilisé pour créer un ensemble de messages que l'utilisateur est susceptible d'entrer et de mapper à un ensemble de réponses pertinentes. Chaque dictionnaire du fichier possède une balise qui identifie le groupe auquel appartient chaque message.
Nous utiliserons ces informations pour former un Réseau neuronal pour catégoriser une phrase de mots comme l'une des balises de notre fichier.
Nous pouvons alors simplement prendre une réponse de ces groupes et la fournir à l'utilisateur. Le chatbot sera meilleur et plus compliqué si vous le proposez avec des balises, des réponses et des modèles supplémentaires.
3. Chargement des données JSON
Nous allons commencer par charger nos données .json et importer quelques modules. Assemblez votre fichier.json dans le même répertoire que votre Script Python. Nos données .json seront désormais enregistrées dans la variable data.
4. Extraction de données
Il est maintenant temps d'extraire les informations dont nous avons besoin de notre fichier JSON. Tous les modèles, ainsi que la classe/tag auquel ils appartiennent, sont requis.
Nous aurons également besoin d'une liste de tous les termes uniques dans nos modèles (pour des raisons que nous expliquerons plus tard), créons donc des listes vides pour garder une trace de ces valeurs.
Nous allons maintenant parcourir nos données JSON et récupérer les informations dont nous avons besoin. Plutôt que de les avoir sous forme de chaînes, nous utiliserons nltk.word tokenizer pour transformer chaque modèle en une liste de mots.
Ensuite, dans notre liste docs_x, nous ajouterons chaque modèle, ainsi que sa balise associée, à la liste docs_y.
5. Mots-clés
Trouver la racine d'un mot s'appelle la recherche de la racine. Par exemple, le radical du mot "c'est" pourrait être "cela", tandis que le radical du mot "se passe" pourrait être "arriver".
Nous utiliserons cette technique de radicalisation pour réduire le vocabulaire de notre modèle et essayer de comprendre ce que les phrases impliquent en général. Ce code générera simplement une liste unique de mots radicaux qui seront utilisés dans la prochaine phase de notre préparation des données.
6. Sac de mots
Il est temps de parler d'un sac de mots maintenant que nous avons importé nos données et généré un vocabulaire radical. Les réseaux de neurones et les algorithmes d'apprentissage automatique, comme nous le savons tous, nécessitent une entrée numérique. Donc, notre liste de chaînes ne va pas le couper. Nous avons besoin d'un mécanisme pour représenter les nombres dans nos phrases, c'est là qu'intervient un sac de mots.
Chaque phrase sera représentée par une liste de la longueur du nombre de termes dans le vocabulaire de notre modèle. Chaque mot de notre vocabulaire sera représenté par une place dans la liste. Si la position dans la liste est un 1, le mot apparaît dans notre relevé ; si c'est un 0, le mot n'apparaît pas dans notre phrase.
Nous l'appelons un sac de mots parce que nous ne connaissons pas l'ordre dans lequel les mots apparaissent dans la phrase ; tout ce que nous savons, c'est qu'ils existent dans le vocabulaire de notre modèle.
En plus de structurer notre entrée, nous devons également formater notre sortie afin que le réseau neuronal la comprenne. Nous allons construire des listes de sortie qui sont la longueur du nombre d'étiquettes/tags dans notre ensemble de données, semblable à un sac de mots. Chaque emplacement de la liste représente une étiquette/étiquette unique, et un 1 dans l'un de ces emplacements indique quelle étiquette/étiquette est représentée.
Enfin, nous utiliserons des tableaux NumPy pour stocker nos données d'entraînement et notre sortie.
7. Développement de modèles
Nous sommes prêts à commencer à créer et à former un modèle maintenant que nous avons prétraité toutes nos données. Nous utiliserons un réseau de neurones à rétroaction très basique avec deux couches cachées pour nos objectifs.
Le but de notre réseau sera de regarder une collection de mots et de les affecter à une classe (une de nos balises du fichier JSON). Nous allons commencer par établir l'architecture de notre modèle. Gardez à l'esprit que vous pouvez jouer avec certains chiffres pour trouver un meilleur modèle ! Apprentissage automatique repose principalement sur des essais et des erreurs.
8. Formation et sauvegarde du modèle
Il est temps d'entraîner notre modèle sur nos données maintenant que nous l'avons configuré ! Nous y parviendrons en ajustant nos données au modèle. Le nombre d'époques que nous fournissons correspond au nombre de fois où le modèle sera exposé aux mêmes données pendant l'entraînement.
Nous pouvons enregistrer le modèle dans le modèle de fichier une fois que nous avons fini de l'entraîner. tflearn est un script qui peut être utilisé dans d'autres scripts.
9. Utiliser un chatbot
Vous pouvez maintenant commencer à discuter avec votre bot.
Avantages du chatbot
- Comme les robots sont censés fonctionner 365 jours par an, 24 heures sur XNUMX, sans rémunération, augmentez la disponibilité et la vitesse de réaction.
- Ces bots sont des outils parfaits pour s'attaquer aux trois principaux V du Big Data : volume, vélocité et variété.
- Les chatbots sont des logiciels qui peuvent être utilisés pour connaître et comprendre les consommateurs d'une entreprise.
- Il a une puissance supérieure qui a un coût de maintenance bon marché après avoir eu les meilleurs avantages.
- Les applications Chatbot créent des données qui peuvent être conservées et utilisées à des fins d'analyse et de prévision.
Cas d'utilisation
- Résoudre les requêtes des clients
- Répondre aux questions fréquemment posées
- Affectation des clients à l'équipe de support
- Collecte des retours clients
- Recommander de nouvelles offres
- Achetez avec le commerce conversationnel
- Helpdesk IT
- Réservation d'hébergement
- Transfert d'argent
Conclusion
Les chatbots, comme d'autres technologies d'IA, seront utilisés pour augmenter les compétences humaines et libérer les humains pour qu'ils soient plus créatifs et imaginatifs en leur permettant de consacrer plus de temps à des tâches stratégiques plutôt que tactiques.
Les entreprises, les employés et les consommateurs bénéficieront probablement de fonctionnalités de chatbot améliorées telles que des recommandations et des prédictions plus rapides, ainsi que d'un accès facile à la vidéoconférence haute définition à partir d'une conversation, dans un avenir proche, lorsque l'IA sera combinée au développement de Technologie 5G.
Ces possibilités et d'autres sont encore à l'étude, mais à mesure que la connectivité Internet, l'IA, la PNL et l'apprentissage automatique progressent, elles deviendront plus courantes.
Chwoo
Bonjour,
Merci pour ce programme.
J'ai une question.
"sac_de_mots" n'est pas défini. Je ne peux pas comprendre cette erreur.
Pourriez-vous me dire comment puis-je résoudre cette erreur ??
Merci pour ce programme !! Passe une bonne journée
Geai
Veuillez ajouter une fonction avant d'utiliser la section chatbot :
////////////////////////////////////////////////////////// /////////////////////////////////
def bag_of_words(s, mots):
sac = [0 pour _ dans la plage (len (mots))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) pour mot dans s_words]
pour soi en s_words :
pour i, w dans énumérer(mots):
si w == se :
sac[i] = 1
return numpy.array(sac)
// Cela résoudra définitivement votre problème. //
////////////////////////////////////////////////////////////////////// //////////////////////////
Je partage le code complet avec vous, afin que vous en ayez une image claire.
/////////////////////////////////////////////////////////////// /////////
importer nltk
depuis nltk.stem.lancaster importer LancasterStemmer
stemmer = LancasterStemmer()
importer numpy
importer tflearn
importer un flux tenseur
importer au hasard
importer json
importer des cornichons
avec open("intents.json") comme fichier :
data = json.load(fichier)
Essai:
avec open("data.pickle", "rb") comme f :
mots, étiquettes, formation, sortie = pickle.load(f)
sauf:
mots = []
étiquettes = []
docs_x = []
docs_y = []
pour l'intention dans les données["intentions"] :
pour pattern in intent["patterns"] :
wrds = nltk.word_tokenize(motif)
mots.extend(wrds)
docs_x.append(wrds)
docs_y.append(intention["tag"])
si l'intention ["tag"] n'est pas dans les étiquettes :
labels.append(intention["tag"])
mots = [stemmer.stem(w.lower()) pour w en mots si w != "?"]
mots = triés(liste(ensemble(mots)))
étiquettes = triées (étiquettes)
formation = []
sortie = []
out_empty = [0 pour _ dans la plage (len (étiquettes))]
pour x, doc dans enumerate(docs_x):
sac = []
wrds = [stemmer.stem(w.lower()) pour w dans doc]
pour w en mots :
si w en mots :
sac.append(1)
autre:
sac.append(0)
sortie_row = out_empty[:]
sortie_row[labels.index(docs_y[x])] = 1
training.append(sac)
sortie.append(sortie_ligne)
formation = numpy. tableau (formation)
sortie = numpy.array (sortie)
avec open("data.pickle", "wb") comme f :
pickle.dump((mots, étiquettes, formation, sortie), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Aucun, len(formation[0])])
net = tflearn.fully_connected (net, 8)
net = tflearn.fully_connected (net, 8)
net = tflearn.fully_connected(net, len(output[0]), activation=”softmax”)
net = tflearn.regression(net)
modèle = tflearn.DNN(net)
Essai:
model.load("model.tflearn")
sauf:
model.fit(formation, sortie, n_epoch=1500, batch_size=8, show_metric=True)
model.save("model.tflearn")
def bag_of_words(s, mots):
sac = [0 pour _ dans la plage (len (mots))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) pour mot dans s_words]
pour soi en s_words :
pour i, w dans énumérer(mots):
si w == se :
sac[i] = 1
return numpy.array(sac)
def chat() :
print("Commencez à parler avec le bot (tapez quit pour arrêter)!")
tandis que True:
inp = input("Vous :")
si inp.lower() == "quitter":
pause
résultats = model.predict([bag_of_words(inp, words)])
index_résultats = numpy.argmax(résultats)
balise = étiquettes[results_index]
pour tg dans data["intents"] :
si tg['tag'] == tag :
réponses = tg['réponses']
print(random.choice(réponses))
discuter()
////////////////////////////////////////////////// ///////////////
Je vous remercie,
Bonne codage!
Lu
Bonjour,
Pourriez-vous me donner une idée de la démarche à effectuer dans le cas où l'on souhaite créer un chatbot en python, mais l'information est obtenue à partir d'un sondage sous excel. Merci!