Indholdsfortegnelse[Skjule][At vise]
Taleopkald udfases til fordel for tekst og billeder i kommunikationssektoren. Ifølge en Facebook-undersøgelse foretrækker mere end halvdelen af køberne at købe fra en virksomhed, som de kan tale med. Chat er blevet den nye socialt acceptable kommunikationsform.
Det gør det muligt for virksomheder at kommunikere med deres kunder til enhver tid og fra ethvert sted. Chatbots vinder i stigende grad popularitet blandt virksomheder og kunder på grund af deres brugervenlighed og reducerede ventetider.
Chatbots eller automatiserede samtaleprogrammer giver kunderne en mere tilpasset metode til at få adgang til tjenester via en tekstbaseret grænseflade. De nyeste AI-drevne chatbots kan genkende en forespørgsel (spørgsmål, kommando, ordre osv.) lavet af en person (eller en anden bot, start) i et specifikt miljø og reagere korrekt (svar, handling osv.).
I dette indlæg gennemgår vi, hvad chatbots er, deres fordele, use cases, og hvordan du laver dine egne dyb læring chatbot i Python, blandt andet.
Lad os komme igang.
Så hvad er chatbots?
En chatbot omtales ofte som en af de mest avancerede og lovende former for menneske-maskine-interaktion. Disse digitale assistenter forbedrer kundeoplevelsen ved at strømline interaktioner mellem mennesker og tjenester.
Samtidig giver de virksomheder nye muligheder for at optimere kundekontaktprocessen til effektivitet, hvilket kan reducere konventionelle supportudgifter.
I en nøddeskal er det AI-baseret software, der er beregnet til at kommunikere med mennesker på deres naturlige sprog. Disse chatbots interagerer ofte via lyd- eller skriftlige teknikker, og de kan nemt efterligne menneskelige sprog for at forbinde med mennesker på en menneskelignende måde.
Chatbots lærer af deres interaktioner med brugerne og bliver mere realistiske og effektive over tid. De kan håndtere en lang række forretningsaktiviteter, såsom godkendelse af udgifter, interaktion med forbrugere online og generering af kundeemner.
Opret din egen deep learning chatbot med python
Der er mange forskellige slags chatbots inden for machine learning og AI. Nogle chatbots er virtuelle assistenter, mens andre bare er der for at tale med, mens andre er kundeserviceagenter.
Du har sikkert set nogle af dem, der er ansat af virksomheder til at besvare forespørgsler. Vi laver en lille chatbot i denne tutorial for at besvare ofte anmodede forespørgsler.
1. Installation af pakker
Vores første skridt er at installere følgende pakker.
2. Træningsdata
Nu er det tid til at finde ud af, hvilken type information vi skal give vores chatbot. Vi behøver ikke at downloade store datasæt, fordi dette er en simpel chatbot.
Vi bruger kun de oplysninger, vi selv har oprettet. For effektivt at følge med i lektionen skal du generere en .JSON-fil med samme format som det, der ses nedenfor. Min fil hedder "intents.json."
JSON-filen bruges til at oprette et sæt meddelelser, som brugeren sandsynligvis vil indtaste og knytte til et sæt relevante svar. Hver ordbog i filen har et tag, der identificerer, hvilken gruppe hver besked tilhører.
Vi bruger disse oplysninger til at træne en neurale netværk at kategorisere en sætning af ord som et af tags i vores fil.
Vi kan så bare tage et svar fra disse grupper og give det til brugeren. Chatbotten bliver bedre og mere kompliceret, hvis du tilbyder den med yderligere tags, svar og mønstre.
3. JSON-data indlæsning
Vi starter med at indlæse vores .json-data og importere nogle moduler. Saml din.json-fil i samme mappe som din Python script. Vores .json-data vil nu blive gemt i datavariablen.
4. Dataudtræk
Nu er det tid til at udtrække de oplysninger, vi har brug for, fra vores JSON-fil. Alle mønstrene, såvel som den klasse/mærke, de tilhører, er påkrævet.
Vi har også brug for en liste over alle de unikke termer i vores mønstre (af grunde, som vi vil forklare senere), så lad os oprette nogle tomme lister for at holde styr på disse værdier.
Nu gennemgår vi vores JSON-data og henter de oplysninger, vi har brug for. I stedet for at have dem som strenge, bruger vi nltk.word tokenizer til at transformere hvert mønster til en liste med ord.
Derefter, i vores docs_x-liste, tilføjer vi hvert mønster sammen med dets tilhørende tag til docs_y-listen.
5. Ordstamme
At finde roden til et ord er kendt som stammer. For eksempel kan stammen af ordet "det"-stammen være "det", hvorimod stammen af ordet "der sker" kan være "ske".
Vi vil bruge denne stammeteknik til at trimme vores models ordforråd ned og forsøge at finde ud af, hvad sætninger generelt betyder. Denne kode vil ganske enkelt generere en unik liste over opstammede ord, som vil blive brugt i den næste fase af vores dataforberedelse.
6. Pose med ord
Det er tid til at tale om en pose ord nu, hvor vi har importeret vores data og genereret et ordforråd. Neurale netværk og maskinlæringsalgoritmer, som vi alle ved, kræver numerisk input. Så vores strengeliste kommer ikke til at klippe den. Vi har brug for en mekanisme til at repræsentere tal i vores sætninger, og det er her en pose ord kommer ind.
Hver sætning vil blive repræsenteret af en liste over længden af antallet af termer i vores models ordforråd. Hvert ord i vores ordforråd vil blive repræsenteret af en plads på listen. Hvis positionen i listen er en 1, optræder ordet i vores erklæring; hvis det er et 0, optræder ordet ikke i vores sætning.
Vi kalder det en pose ord, fordi vi ikke kender rækkefølgen, hvori ordene optræder i sætningen; alt, hvad vi ved, er, at de findes i vores models ordforråd.
Udover at strukturere vores input, skal vi også formatere vores output, så det neurale netværk forstår det. Vi bygger outputlister, der er længden af antallet af etiketter/tags i vores datasæt, svarende til en pose ord. Hvert sted på listen repræsenterer en unik etiket/tag, og et 1 på enhver af disse placeringer angiver, hvilken etiket/tag der er repræsenteret.
Endelig vil vi bruge NumPy-arrays til at gemme vores træningsdata og output.
7. Modeludvikling
Vi er klar til at begynde at bygge og træne en model nu, hvor vi har forbehandlet alle vores data. Vi vil bruge et meget grundlæggende feed-forward neuralt netværk med to skjulte lag til vores mål.
Vores netværks formål vil være at se på en samling af ord og tildele dem til en klasse (et af vores tags fra JSON-filen). Vi starter med at etablere vores models arkitektur. Husk, at du kan lege med nogle af tallene for at komme med en bedre model! Maskinelæring er for det meste baseret på forsøg og fejl.
8. Modeltræning og opsparing
Det er tid til at træne vores model på vores data, nu hvor vi har sat den op! Det opnår vi ved at tilpasse vores data til modellen. Antallet af epoker, vi leverer, er antallet af gange, modellen vil blive udsat for de samme data under træning.
Vi kan gemme modellen i filmodellen, når vi er færdige med at træne den. tflearn er et script, der kan bruges i andre scripts.
9. Brug af en chatbot
Nu kan du begynde at chatte med din bot.
Fordele ved Chatbot
- Da bots forventes at fungere 365 dage om året, 24 timer i døgnet, uden løn, øger tilgængeligheden og reaktionshastigheden.
- Disse bots er perfekte værktøjer til at tackle big datas tre centrale V'er: volumen, hastighed og variation.
- Chatbots er software, der kan bruges til at lære om og forstå en virksomheds forbrugere.
- Den har overlegen kraft, at den har en billig vedligeholdelsesomkostning efter at have haft de bedste fordele.
- Chatbot-applikationer skaber data, der kan bevares og bruges til analyser og prognoser.
Usecase
- Løsning af kundeforespørgsler
- Besvarelse af ofte stillede spørgsmål
- Tildele kunder til supportteam
- Indsamling af kundefeedback
- Anbefaler nye tilbud
- Shop med samtalehandel
- IT Helpdesk
- Booking af overnatningssteder
- Pengeoverførsel
Konklusion
Chatbots, ligesom andre AI-teknologier, vil blive brugt til at øge menneskelige færdigheder og befri mennesker til at være mere kreative og fantasifulde ved at give dem mulighed for at bruge mere tid på strategiske frem for taktiske opgaver.
Virksomheder, medarbejdere og forbrugere vil sandsynligvis drage fordel af forbedrede chatbot-funktioner såsom hurtigere anbefalinger og forudsigelser, samt nem adgang til high-definition videokonferencer inde fra en samtale, i den nærmeste fremtid, når AI kombineres med udvikling af 5G teknologi.
Disse og andre muligheder bliver stadig undersøgt, men efterhånden som internetforbindelse, AI, NLP og maskinlæring udvikler sig, vil de blive mere udbredte.
Chwoo
Hej,
Tak for dette program.
Jeg har et spørgsmål.
"pose_of_words" er ikke defineret. Jeg kan ikke forstå denne fejl.
Kan du fortælle mig hvordan jeg kan løse denne fejl??
Tak for dette program!! Hav en god dag
Jay
Tilføj venligst en funktion, før du bruger chatbot-sektionen:
///////////////////////////////////////////////////////////////////////////// ////////////////////////////
def pose_of_ord(s, ord):
taske = [0 for _ inden for rækkevidde(len(ord))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) for ord i s_words]
for se i s_words:
for i, w i enumerate(ord):
hvis w == se:
taske[i] = 1
returner numpy.array(bag)
// Det vil helt sikkert løse dit problem. //
///////////////////////////////////////////////// // ////////////////////////////////
Jeg deler den komplette kode med dig, så du får et klart billede af den.
/////////////////////////////////////////////////////////////////////////////////// /////////
import nltk
fra nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
import numpy
importere tflern
importere tensorflow
Import tilfældigt
importere json
importere lage
med open(“intents.json”) som fil:
data = json.load(fil)
prøve:
med open(“data.pickle”, “rb”) som f:
ord, etiketter, træning, output = pickle.load(f)
undtagen:
ord = []
etiketter = []
docs_x = []
docs_y = []
for hensigt i data["hensigter"]:
for mønster i hensigt["mønstre"]:
wrds = nltk.word_tokenize(mønster)
words.extend(wrds)
docs_x.append(wrds)
docs_y.append(intent[“tag”])
hvis hensigt["tag"] ikke er i etiketter:
labels.append(intent[“tag”])
ord = [stemmer.stem(w.lower()) for w i ord hvis w != “?”]
ord = sorteret(liste(sæt(ord)))
etiketter = sorteret(etiketter)
træning = []
output = []
out_empty = [0 for _ i området(len(etiketter))]
for x, doc i enumerate(docs_x):
taske = []
wrds = [stemmer.stem(w.lower()) for w i doc]
for w i ord:
hvis w i wrds:
taske.append(1)
andet:
taske.append(0)
output_row = ud_tom[:]
output_row[labels.index(docs_y[x])] = 1
training.append(pose)
output.append(output_række)
træning = numpy.array(træning)
output = numpy.array(output)
med open(“data.pickle”, “wb”) som f:
pickle.dump((ord, etiketter, træning, output), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Ingen, len(træning[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)
model = tflearn.DNN(net)
prøve:
model.load(“model.tflearn”)
undtagen:
model.fit(træning, output, n_epoch=1500, batch_size=8, show_metric=True)
model.save(“model.tflearn”)
def pose_of_ord(s, ord):
taske = [0 for _ inden for rækkevidde(len(ord))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) for ord i s_words]
for se i s_words:
for i, w i enumerate(ord):
hvis w == se:
taske[i] = 1
returner numpy.array(bag)
def chat():
print("Begynd at tale med botten (skriv quit for at stoppe)!")
mens det er sandt:
inp = input(“Du:“)
if inp.lower() == "afslut":
bryde
resultater = model.predict([pose_of_words(inp, words)])
resultater_indeks = numpy.argmax(resultater)
tag = etiketter[resultater_indeks]
for tg i data[“hensigter”]:
if tg['tag'] == tag:
svar = tg['svar']
print(random.choice(responses))
snak()
////////////////////////////////////////////////// ///////////////
Tak,
God kodning!
Lu
Hej,
Kan du give mig en idé om processen, der skal udføres i tilfælde af, at du ønsker at oprette en chatbot i python, men informationen er hentet fra en undersøgelse i excel. Tak skal du have!