Inhoudsopgave[Zich verstoppen][Laten zien]
In de communicatiesector worden spraakoproepen uitgefaseerd ten gunste van tekst en beeld. Volgens een Facebook-enquête koopt meer dan de helft van de kopers het liefst bij een bedrijf waarmee ze kunnen praten. Chatten is de nieuwe sociaal aanvaardbare manier van communiceren geworden.
Het stelt bedrijven in staat om op elk moment en vanaf elke locatie met hun klanten te communiceren. Chatbots winnen steeds meer aan populariteit bij bedrijven en klanten vanwege hun gebruiksgemak en kortere wachttijden.
Chatbots, of geautomatiseerde gespreksprogramma's, bieden klanten een meer aangepaste methode om toegang te krijgen tot services via een op tekst gebaseerde interface. De nieuwste AI-aangedreven chatbots kunnen een vraag (vraag, commando, bestelling, etc.) van een persoon (of een andere bot, aanvang) in een specifieke omgeving herkennen en gepast reageren (antwoord, actie, etc.).
In dit bericht bespreken we wat chatbots zijn, hun voordelen, gebruiksscenario's en hoe u er zelf een kunt maken diepgaand leren chatbot in onder andere Python.
Laten we beginnen.
Dus, wat zijn chatbots?
Een chatbot wordt vaak genoemd als een van de meest geavanceerde en veelbelovende vormen van mens-machine-interactie. Deze digitale assistenten verbeteren de klantervaring door de interactie tussen mensen en diensten te stroomlijnen.
Tegelijkertijd bieden ze bedrijven nieuwe opties om het klantcontactproces te optimaliseren voor efficiëntie, waardoor conventionele ondersteuningskosten kunnen worden verlaagd.
In een notendop, het is op AI gebaseerde software die bedoeld is om met mensen te communiceren in hun natuurlijke taal. Deze chatbots communiceren vaak via audio of geschreven technieken, en ze kunnen gemakkelijk menselijke talen nabootsen om op een mensachtige manier contact met mensen te maken.
Chatbots leren van hun interacties met gebruikers en worden na verloop van tijd realistischer en efficiënter. Ze kunnen een breed scala aan zakelijke activiteiten aan, zoals het autoriseren van uitgaven, online contact met consumenten en het genereren van leads.
Uw eigen deep learning-chatbot maken met python
Er zijn veel verschillende soorten chatbots op het gebied van: machine learning en AI. Sommige chatbots zijn virtuele assistenten, terwijl andere er gewoon zijn om mee te praten, terwijl andere klantenservicemedewerkers zijn.
Je hebt vast wel eens mensen gezien die door bedrijven worden gebruikt om vragen te beantwoorden. We zullen in deze tutorial een kleine chatbot maken om veelgestelde vragen te beantwoorden.
1. Pakketten installeren
Onze eerste stap is om de volgende pakketten te installeren.
2. Trainingsgegevens
Nu is het tijd om erachter te komen wat voor soort informatie we onze chatbot moeten geven. We hoeven geen grote datasets te downloaden omdat dit een simpele chatbot is.
We gebruiken alleen de informatie die we zelf hebben gemaakt. Om de les effectief te volgen, moet u een .JSON-bestand genereren met hetzelfde formaat als hieronder. Mijn bestand heet 'intents.json'.
Het JSON-bestand wordt gebruikt om een reeks berichten te maken die de gebruiker waarschijnlijk zal invoeren en toewijzen aan een reeks relevante antwoorden. Elk woordenboek in het bestand heeft een tag die aangeeft tot welke groep elk bericht behoort.
We gebruiken deze informatie om te trainen a neuraal netwerk om een woordgroep te categoriseren als een van de tags in ons bestand.
We kunnen dan gewoon een reactie van die groepen nemen en aan de gebruiker verstrekken. De chatbot wordt beter en ingewikkelder als je hem aanbiedt met extra tags, antwoorden en patronen.
3. JSON-gegevens laden
We beginnen met het laden van onze .json-gegevens en het importeren van enkele modules. Verzamel uw.json-bestand in dezelfde map als uw Python-script. Onze .json-gegevens worden nu opgeslagen in de gegevensvariabele.
4. Gegevensextractie
Nu is het tijd om de informatie die we nodig hebben uit ons JSON-bestand te extraheren. Alle patronen, evenals de klasse/tag waartoe ze behoren, zijn vereist.
We hebben ook een lijst nodig van alle unieke termen in onze patronen (om redenen die we later zullen uitleggen), dus laten we een paar lege lijsten maken om deze waarden bij te houden.
Nu zullen we onze JSON-gegevens doorlopen en de informatie ophalen die we nodig hebben. In plaats van ze als strings te gebruiken, gebruiken we nltk.word tokenizer om elk patroon om te zetten in een lijst met woorden.
Vervolgens voegen we in onze docs_x-lijst elk patroon, samen met de bijbehorende tag, toe aan de docs_y-lijst.
5. Woordstamming
Het vinden van de wortel van een woord staat bekend als stammen. De stam van de stam van het woord 'dat is' kan bijvoorbeeld 'dat' zijn, terwijl de stam van het woord 'gebeurt' kan zijn 'gebeuren'.
We zullen deze stamtechniek gebruiken om de woordenschat van ons model in te korten en proberen te achterhalen wat zinnen in het algemeen inhouden. Deze code genereert eenvoudigweg een unieke lijst van gestemde woorden die in de volgende fase van onze gegevensvoorbereiding zal worden gebruikt.
6. Zak met woorden
Het is tijd om over een zak woorden te spreken nu we onze gegevens hebben geïmporteerd en een gestemde woordenschat hebben gegenereerd. Neurale netwerken en machine learning-algoritmen, zoals we allemaal weten, vereisen numerieke invoer. Dus onze stringlijst zal het niet redden. We hebben een mechanisme nodig om getallen in onze zinnen weer te geven, en dat is waar een zak met woorden binnenkomt.
Elke zin wordt weergegeven door een lijst met de lengte van het aantal termen in de woordenschat van ons model. Elk woord in ons vocabulaire wordt vertegenwoordigd door een plaats in de lijst. Als de positie in de lijst een 1 is, verschijnt het woord in onze verklaring; als het een 0 is, komt het woord niet voor in onze zin.
We noemen het een zak met woorden omdat we niet weten in welke volgorde de woorden in de zin voorkomen; het enige dat we weten is dat ze in de woordenschat van ons model voorkomen.
Naast het structureren van onze invoer, moeten we onze uitvoer ook zodanig formatteren dat het neurale netwerk deze begrijpt. We bouwen uitvoerlijsten die de lengte hebben van het aantal labels/tags in onze dataset, vergelijkbaar met een zak met woorden. Elke plaats in de lijst vertegenwoordigt een uniek label/tag, en een 1 op een van die locaties geeft aan welk label/tag wordt weergegeven.
Ten slotte gebruiken we NumPy-arrays om onze trainingsgegevens en uitvoer op te slaan.
7. Modelontwikkeling
We zijn klaar om te beginnen met het bouwen en trainen van een model nu we al onze gegevens hebben voorverwerkt. We gebruiken een heel basaal feed-forward neuraal netwerk met twee verborgen lagen voor onze doelstellingen.
Het doel van ons netwerk is om naar een verzameling woorden te kijken en deze toe te wijzen aan een klasse (een van onze tags uit het JSON-bestand). We beginnen met het vaststellen van de architectuur van ons model. Houd er rekening mee dat je met sommige nummers kunt spelen om een beter model te bedenken! machine learning is grotendeels gebaseerd op vallen en opstaan.
8. Modeltraining en -besparing
Het is tijd om ons model op onze gegevens te trainen nu we het hebben ingesteld! We zullen dit bereiken door onze gegevens aan het model aan te passen. Het aantal tijdvakken dat we bieden, is het aantal keren dat het model tijdens de training aan dezelfde gegevens wordt blootgesteld.
We kunnen het model opslaan in het bestandsmodel zodra we het hebben getraind. tflearn is een script dat in andere scripts kan worden gebruikt.
9. Een chatbot gebruiken
Nu kunt u beginnen met chatten met uw bot.
Voordelen van Chatbot
- Omdat van bots wordt verwacht dat ze 365 dagen per jaar, 24 uur per dag werken, zonder betaling, verhoogt u de beschikbaarheid en reactiesnelheid.
- Deze bots zijn perfecte tools om de drie belangrijkste V's van big data aan te pakken: volume, snelheid en variatie.
- Chatbots zijn software die kan worden gebruikt om de consumenten van een bedrijf te leren kennen en begrijpen.
- Het heeft een superieur vermogen dat het lage onderhoudskosten heeft na het hebben van topvoordelen.
- Chatbot-applicaties creëren gegevens die kunnen worden bewaard en gebruikt voor analyses en prognoses.
Gebruikssituatie
- Vragen van klanten oplossen
- Veelgestelde vragen beantwoorden
- Klanten toewijzen aan het ondersteuningsteam
- Feedback van klanten verzamelen
- Nieuwe aanbiedingen aanbevelen
- Winkelen met conversational commerce
- IT Helpdesk
- Accommodaties boeken
- Overschrijving
Conclusie
Chatbots zullen, net als andere AI-technologieën, worden gebruikt om menselijke vaardigheden te vergroten en mensen te bevrijden om creatiever en fantasierijker te zijn door hen meer tijd te laten besteden aan strategische in plaats van tactische taken.
Bedrijven, werknemers en consumenten zullen waarschijnlijk profiteren van verbeterde chatbotfuncties zoals snellere aanbevelingen en voorspellingen, evenals gemakkelijke toegang tot high-definition videoconferenties vanuit een gesprek, in de nabije toekomst, wanneer AI wordt gecombineerd met de ontwikkeling van 5G-technologie.
Deze en andere mogelijkheden worden nog onderzocht, maar naarmate internetconnectiviteit, AI, NLP en machine learning vorderen, zullen ze steeds vaker voorkomen.
Chwoo
Hallo,
Bedankt voor dit programma.
Ik heb een vraag.
"bag_of_words" is niet gedefinieerd. Ik kan deze fout niet begrijpen.
Kunt u mij vertellen hoe ik deze fout kan oplossen??
Bedankt voor dit programma!! Fijne dag
Vlaamse gaai
Voeg een functie toe voordat je de chatbot-sectie gebruikt:
////////////////////////////////////////////////// /////////////////////////////
def bag_of_words(s, woorden):
tas = [0 voor _ in bereik(len(woorden))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) voor woord in s_words]
voor se in s_words:
voor i, w in enumerate(woorden):
als w == se:
zak[i] = 1
retourneer numpy.array(tas)
// Het zal je probleem zeker oplossen. //
////////////////////////////////////////////////// //////////////////////////
Ik deel de volledige code met je, zodat je er een duidelijk beeld van krijgt.
////////////////////////////////////////////////// /////////
importeer nltk
van nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
importeer numpy
importeer tflearn
tensorflow importeren
willekeurig importeren
json importeren
import augurk
met open(“intents.json”) als bestand:
data = json.load(bestand)
Probeer het volgende:
met open(“data.pickle”, “rb”) als f:
woorden, labels, training, output = pickle.load(f)
behalve:
woorden = []
etiketten = []
docs_x = []
docs_y = []
voor intentie in gegevens[“intenties”]:
voor patroon in opzet [“patronen”]:
wrds = nltk.word_tokenize(patroon)
woorden.extend(wrds)
docs_x.append(wrds)
docs_y.append(intentie[“tag”])
indien intentie[“tag”] niet in labels:
labels.append(intentie[“tag”])
woorden = [stemmer.stem(w.lager()) voor w in woorden if w != “?”]
woorden = gesorteerd(lijst(set(woorden)))
labels = gesorteerd (labels)
opleiding = []
uitgang = []
out_empty = [0 voor _ binnen bereik(len(labels))]
voor x, doc in enumerate(docs_x):
tas = []
wrds = [stemmer.stem(w.lower()) voor w in doc]
voor w in woorden:
als w in wrds:
tas.toevoegen(1)
anders:
tas.toevoegen(0)
output_row = out_empty[:]
uitvoer_rij[labels.index(docs_y[x])] = 1
training.append(tas)
uitvoer.append(uitvoerrij)
training = numpy.array(training)
output = numpy.array (output)
met open(“data.pickle”, “wb”) als f:
augurk.dump((woorden, labels, training, output), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Geen, len(training[0])])
net = tflearn.volledig_verbonden(netto, 8)
net = tflearn.volledig_verbonden(netto, 8)
net = tflearn.fully_connected(net, len(output[0]), activatie=”softmax”)
net = tflearn.regression(netto)
model = tflearn.DNN(netto)
Probeer het volgende:
model.load(“model.tflearn”)
behalve:
model.fit(training, uitvoer, n_epoch=1500, batch_size=8, show_metric=True)
model.save(“model.tflearn”)
def bag_of_words(s, woorden):
tas = [0 voor _ in bereik(len(woorden))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) voor woord in s_words]
voor se in s_words:
voor i, w in enumerate(woorden):
als w == se:
zak[i] = 1
retourneer numpy.array(tas)
zeker chat():
print ("Begin met de bot te praten (typ quit om te stoppen)!")
terwijl waar:
inp = invoer ("Jij: ")
if inp.lower() == "stop":
breken
resultaten = model.predict([bag_of_words(inp, words)])
results_index = numpy.argmax(resultaten)
tag = labels[resultaten_index]
voor tg in data[“intenties”]:
if tg['tag'] == tag:
reacties = tg['reacties']
print(willekeurige.keuze(antwoorden))
chatten()
////////////////////////////////////////////////// ///////////////
Dank je,
Veel plezier met coderen!
Lu
Hallo,
Kunt u mij een idee geven van het uit te voeren proces als u een chatbot in python wilt maken, maar de informatie is verkregen uit een enquête in Excel. Bedankt!