Inhaltsverzeichnis[Ausblenden][Zeigen]
Sprachanrufe werden im Kommunikationsbereich zugunsten von Text und Bildern verdrängt. Laut einer Facebook-Umfrage kaufen mehr als die Hälfte der Käufer lieber bei einem Unternehmen, mit dem sie sprechen können. Chatten ist zur neuen gesellschaftlich akzeptierten Kommunikationsform geworden.
Es ermöglicht Unternehmen, jederzeit und von jedem Ort aus mit ihren Kunden zu kommunizieren. Chatbots erfreuen sich bei Unternehmen und Kunden aufgrund ihrer einfachen Bedienbarkeit und kürzeren Wartezeiten immer größerer Beliebtheit.
Chatbots oder automatisierte Konversationsprogramme bieten Kunden eine individuellere Möglichkeit, über eine textbasierte Schnittstelle auf Dienste zuzugreifen. Die neuesten KI-gestützten Chatbots können eine Anfrage (Frage, Befehl, Befehl usw.) erkennen, die von einer Person (oder einem anderen Bot, Inception) in einer bestimmten Umgebung gestellt wird, und entsprechend reagieren (Antwort, Aktion usw.).
In diesem Beitrag gehen wir darauf ein, was Chatbots sind, welche Vorteile sie haben, welche Anwendungsfälle es gibt und wie man eigene Chatbots erstellt tiefe Lernen Chatbot unter anderem in Python.
Fangen wir an.
Was sind Chatbots?
Ein Chatbot wird häufig als eine der fortschrittlichsten und vielversprechendsten Formen der Mensch-Maschine-Interaktion bezeichnet. Diese digitalen Assistenten verbessern das Kundenerlebnis, indem sie die Interaktionen zwischen Menschen und Diensten optimieren.
Gleichzeitig bieten sie Unternehmen neue Möglichkeiten, den Kundenkontaktprozess effizienter zu gestalten, wodurch herkömmliche Supportkosten gesenkt werden können.
Kurz gesagt handelt es sich um KI-basierte Software, die mit Menschen in ihrer natürlichen Sprache kommunizieren soll. Diese Chatbots interagieren häufig über Audio- oder schriftliche Techniken und können problemlos menschliche Sprachen nachahmen, um auf menschenähnliche Weise mit Menschen in Kontakt zu treten.
Chatbots lernen aus ihren Interaktionen mit Benutzern und werden mit der Zeit realistischer und effizienter. Sie können ein breites Spektrum an Geschäftsaktivitäten abwickeln, z. B. die Genehmigung von Ausgaben, die Online-Interaktion mit Verbrauchern und die Generierung von Leads.
Erstellen Sie Ihren eigenen Deep-Learning-Chatbot mit Python
Es gibt viele verschiedene Arten von Chatbots im Bereich Maschinelles Lernen und KI. Einige Chatbots sind virtuelle Assistenten, während andere nur zum Gespräch da sind und wieder andere als Kundendienstmitarbeiter fungieren.
Sie haben wahrscheinlich einige von ihnen gesehen, die von Unternehmen mit der Beantwortung von Anfragen beauftragt werden. In diesem Tutorial erstellen wir einen kleinen Chatbot, um häufig gestellte Fragen zu beantworten.
1. Pakete installieren
Unser erster Schritt besteht darin, die folgenden Pakete zu installieren.
2. Trainingsdaten
Jetzt ist es an der Zeit herauszufinden, welche Art von Informationen wir unserem Chatbot geben müssen. Wir müssen keine großen Datensätze herunterladen, da es sich um einen einfachen Chatbot handelt.
Wir verwenden nur die Informationen, die wir selbst erstellt haben. Um der Lektion effektiv folgen zu können, müssen Sie eine .JSON-Datei mit demselben Format wie der unten gezeigten erstellen. Meine Datei heißt „intents.json“.
Die JSON-Datei wird verwendet, um eine Reihe von Nachrichten zu erstellen, die der Benutzer wahrscheinlich eingeben und einer Reihe relevanter Antworten zuordnen wird. Jedes Wörterbuch in der Datei verfügt über ein Tag, das angibt, zu welcher Gruppe jede Nachricht gehört.
Wir werden diese Informationen verwenden, um a zu trainieren neuronale Netzwerk um eine Wortgruppe als eines der Tags in unserer Datei zu kategorisieren.
Wir können dann einfach eine Antwort dieser Gruppen entgegennehmen und sie dem Benutzer bereitstellen. Der Chatbot wird besser und komplizierter, wenn Sie ihn mit zusätzlichen Tags, Antworten und Mustern anbieten.
3. Laden von JSON-Daten
Wir beginnen mit dem Laden unserer .json-Daten und dem Importieren einiger Module. Stellen Sie Ihre.json-Datei im selben Verzeichnis zusammen wie Ihre Python-Skript. Unsere .json-Daten werden nun in der Datenvariablen gespeichert.
4. Datenextraktion
Jetzt ist es an der Zeit, die benötigten Informationen aus unserer JSON-Datei zu extrahieren. Alle Muster sowie die Klasse/das Tag, zu dem sie gehören, sind erforderlich.
Wir benötigen außerdem eine Liste aller eindeutigen Begriffe in unseren Mustern (aus Gründen, die wir später erläutern). Erstellen wir also einige leere Listen, um den Überblick über diese Werte zu behalten.
Jetzt durchlaufen wir unsere JSON-Daten und rufen die benötigten Informationen ab. Anstatt sie als Zeichenfolgen zu verwenden, verwenden wir den Tokenizer nltk.word, um jedes Muster in eine Liste von Wörtern umzuwandeln.
Dann fügen wir in unserer docs_x-Liste jedes Muster zusammen mit dem zugehörigen Tag zur docs_y-Liste hinzu.
5. Wortstammbildung
Das Finden des Wortstamms wird als Stemming bezeichnet. Beispielsweise könnte der Stamm des Wortes „thats“ „that“ sein, während der Stamm des Wortes „happening“ „happen“ lauten könnte.
Wir werden diese Stemming-Technik verwenden, um den Wortschatz unseres Modells zu reduzieren und herauszufinden, was Sätze im Allgemeinen bedeuten. Dieser Code generiert einfach eine eindeutige Liste von Wortstämmen, die in der nächsten Phase unserer Datenvorbereitung verwendet werden.
6. Beutel voller Wörter
Jetzt, da wir unsere Daten importiert und einen Stammwortschatz erstellt haben, ist es an der Zeit, über eine Menge Wörter zu sprechen. Neuronale Netze und Algorithmen für maschinelles Lernen erfordern, wie wir alle wissen, numerische Eingaben. Unsere Saitenliste reicht also nicht aus. Wir brauchen einen Mechanismus, um Zahlen in unseren Sätzen darzustellen, und da kommt eine Menge Wörter ins Spiel.
Jede Phrase wird durch eine Liste mit der Länge der Anzahl der Begriffe im Vokabular unseres Modells dargestellt. Jedes Wort in unserem Wortschatz wird durch eine Stelle in der Liste repräsentiert. Wenn die Position in der Liste eine 1 ist, erscheint das Wort in unserer Aussage; wenn es eine 0 ist, kommt das Wort nicht in unserem Satz vor.
Wir nennen es einen Wortbeutel, weil wir die Reihenfolge, in der die Wörter in der Phrase vorkommen, nicht kennen; Wir wissen nur, dass sie im Vokabular unseres Modells vorkommen.
Zusätzlich zur Strukturierung unserer Eingabe müssen wir auch unsere Ausgabe so formatieren, dass das neuronale Netzwerk sie versteht. Wir erstellen Ausgabelisten, deren Länge der Anzahl der Beschriftungen/Tags in unserem Datensatz entspricht, ähnlich einer Tüte voller Wörter. Jede Stelle in der Liste stellt ein eindeutiges Label/Tag dar, und eine 1 an einer dieser Stellen gibt an, welches Label/Tag dargestellt wird.
Schließlich verwenden wir NumPy-Arrays, um unsere Trainingsdaten und -ausgaben zu speichern.
7. Modellentwicklung
Nachdem wir alle unsere Daten vorverarbeitet haben, können wir nun mit dem Erstellen und Trainieren eines Modells beginnen. Für unsere Ziele verwenden wir ein sehr einfaches Feed-Forward-Neuronales Netzwerk mit zwei verborgenen Schichten.
Der Zweck unseres Netzwerks besteht darin, eine Sammlung von Wörtern zu betrachten und sie einer Klasse zuzuordnen (einem unserer Tags aus der JSON-Datei). Wir beginnen mit der Festlegung der Architektur unseres Modells. Denken Sie daran, dass Sie mit einigen Zahlen experimentieren können, um ein besseres Modell zu finden! Maschinelles Lernen basiert größtenteils auf Versuch und Irrtum.
8. Modellschulung und -speicherung
Jetzt, da wir es eingerichtet haben, ist es an der Zeit, unser Modell anhand unserer Daten zu trainieren! Dies erreichen wir, indem wir unsere Daten an das Modell anpassen. Die Anzahl der von uns bereitgestellten Epochen gibt an, wie oft das Modell während des Trainings denselben Daten ausgesetzt wird.
Sobald wir das Training abgeschlossen haben, können wir das Modell im Dateimodell speichern. tflearn ist ein Skript, das in anderen Skripten verwendet werden kann.
9. Verwendung eines Chatbots
Jetzt können Sie mit Ihrem Bot chatten.
Vorteile von Chatbot
- Da von Bots erwartet wird, dass sie 365 Tage im Jahr, 24 Stunden am Tag und ohne Bezahlung im Einsatz sind, erhöhen sich die Verfügbarkeit und die Reaktionsgeschwindigkeit.
- Diese Bots sind perfekte Werkzeuge, um die drei Schlüsselfaktoren von Big Data zu bewältigen: Volumen, Geschwindigkeit und Vielfalt.
- Chatbots sind Software, mit deren Hilfe man die Verbraucher eines Unternehmens kennenlernen und verstehen kann.
- Es verfügt über eine überlegene Leistung und geringe Wartungskosten, obwohl es über die besten Vorteile verfügt.
- Chatbot-Anwendungen erzeugen Daten, die gespeichert und für Analysen und Prognosen verwendet werden können.
Anwendungsfall
- Lösen von Kundenanfragen
- Beantwortung häufig gestellter Fragen
- Kunden dem Support-Team zuweisen
- Sammeln von Kundenfeedback
- Neue Angebote empfehlen
- Shoppen Sie mit Conversational Commerce
- IT-Helpdesk
- Buchung von Unterkünften
- Überweisung
Zusammenfassung
Chatbots werden, wie andere KI-Technologien auch, eingesetzt, um menschliche Fähigkeiten zu erweitern und den Menschen die Freiheit zu geben, kreativer und einfallsreicher zu sein, indem sie ihnen ermöglichen, mehr Zeit für strategische statt für taktische Aufgaben zu verwenden.
Unternehmen, Mitarbeiter und Verbraucher werden wahrscheinlich in naher Zukunft von erweiterten Chatbot-Funktionen wie schnelleren Empfehlungen und Vorhersagen sowie einem einfachen Zugriff auf hochauflösende Videokonferenzen aus einem Gespräch heraus profitieren, wenn KI mit der Entwicklung von kombiniert wird 5G-Technologie.
Diese und andere Möglichkeiten werden noch untersucht, aber mit der Weiterentwicklung von Internetkonnektivität, KI, NLP und maschinellem Lernen werden sie immer häufiger auftreten.
Chwoo
Hallo,
Vielen Dank für dieses Programm.
Ich habe eine Frage.
„bag_of_words“ ist nicht definiert. Ich kann diesen Fehler nicht verstehen.
Können Sie mir sagen, wie ich diesen Fehler beheben kann??
Vielen Dank für dieses Programm!! Haben Sie einen guten Tag
Eichelhäher
Bitte fügen Sie eine Funktion hinzu, bevor Sie den Chatbot-Bereich verwenden:
//////////////////////////////////////////////////// /////////////////////////////
def bag_of_words(s, Wörter):
bag = [0 für _ in range(len(words))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) für Wort in s_words]
für se in s_words:
für i, w in enumerate(words):
wenn w == se:
Tasche[i] = 1
Rückgabe numpy.array (Beutel)
// Es wird Ihr Problem definitiv lösen. //
/////////////////////////////////////////////// //////////////////////////
Ich teile den vollständigen Code mit Ihnen, damit Sie sich ein klares Bild davon machen können.
//////////////////////////////////////////////// /////////
importiere nltk
aus nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
importiere numpy
tflearn importieren
Tensorflow importieren
Zufall importieren
json importieren
Gurke importieren
mit open(“intents.json“) als Datei:
data = json.load (Datei)
Versuchen:
mit open("data.pickle", "rb") als f:
Wörter, Labels, Training, Ausgabe = pickle.load(f)
außer:
Wörter = []
Etiketten = []
docs_x = []
docs_y = []
für Absicht in Daten[„Absichten“]:
für Muster in Absicht[„Muster“]:
wrds = nltk.word_tokenize(Muster)
Wörter.Erweitern (Wörter)
docs_x.append(wrds)
docs_y.append(intent[„tag“])
if intention[„tag“] nicht in Labels:
label.append(intent["tag"])
Wörter = [stemmer.stem(w.lower()) für w in Wörtern, wenn w != „?“]
Wörter = sortiert (Liste (Satz (Wörter)))
Etiketten = sortiert (Etiketten)
Ausbildung = []
Ausgabe = []
out_empty = [0 für _ in range(len(labels))]
für x, doc in enumerate(docs_x):
Tasche = []
wrds = [stemmer.stem(w.lower()) für w im Dokument]
für w in Worten:
wenn w in wrds:
bag.append(1)
sonst:
bag.append(0)
Output_row = out_empty[:]
Output_row[labels.index(docs_y[x])] = 1
training.append (Tasche)
Ausgabe.append (Ausgabe_Zeile)
Training = numpy.array(Training)
Ausgabe = numpy.array (Ausgabe)
mit open("data.pickle", "wb") als f:
pickle.dump((Wörter, Labels, Training, Ausgabe), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[None, len(training[0])])
net = tflearn.fully_connected (net, 8)
net = tflearn.fully_connected (net, 8)
net = tflearn.fully_connected(net, len(output[0]), Aktivierung=“softmax“)
net = tflearn.regression(net)
model = tflearn.DNN(net)
Versuchen:
model.load("model.tflearn")
außer:
model.fit(Training, Ausgabe, n_epoch=1500, batch_size=8, show_metric=True)
model.save("model.tflearn")
def bag_of_words(s, Wörter):
bag = [0 für _ in range(len(words))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) für Wort in s_words]
für se in s_words:
für i, w in enumerate(words):
wenn w == se:
Tasche[i] = 1
Rückgabe numpy.array (Beutel)
def chat():
print(“Beginnen Sie mit dem Bot zu sprechen (geben Sie quit ein, um zu stoppen)!”)
während wahr:
inp = input(“Sie: “)
if inp.lower() == „beenden“:
brechen
Ergebnisse = model.predict([bag_of_words(inp, words)])
result_index = numpy.argmax(Ergebnisse)
tag = label[results_index]
für tg in data[„intents“]:
if tg['tag'] == tag:
Antworten = tg['Antworten']
print(random.choice(Antworten))
Plaudern()
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
Vielen Dank,
Viel Spaß beim Codieren!
Lu
Hallo,
Könnten Sie mir eine Vorstellung von dem Prozess geben, der durchzuführen ist, wenn Sie einen Chatbot in Python erstellen möchten, die Informationen jedoch aus einer Umfrage in Excel stammen. Danke schön!