Innholdsfortegnelse[Gjemme seg][Forestilling]
Talesamtaler fases ut til fordel for tekst og bilde i kommunikasjonssektoren. I følge en Facebook-undersøkelse foretrekker mer enn halvparten av kjøperne å kjøpe fra et selskap de kan snakke med. Chatting har blitt den nye sosialt akseptable kommunikasjonsmåten.
Det gjør det mulig for bedrifter å kommunisere med sine kunder når som helst og fra hvor som helst. Chatbots blir stadig mer populær blant bedrifter og kunder på grunn av deres brukervennlighet og reduserte ventetider.
Chatbots, eller automatiserte samtaleprogrammer, gir klienter en mer tilpasset metode for å få tilgang til tjenester gjennom et tekstbasert grensesnitt. De nyeste AI-drevne chatbotene kan gjenkjenne en spørring (spørsmål, kommando, ordre osv.) laget av en person (eller en annen bot, start) i et spesifikt miljø og svare på riktig måte (svar, handling osv.).
I dette innlegget vil vi gå over hva chatboter er, deres fordeler, bruksområder og hvordan du lager dine egne dyp læring chatbot i Python, blant annet.
La oss komme i gang.
Så, hva er chatbots?
En chatbot blir ofte referert til å være en av de mest avanserte og lovende formene for menneske-maskin-interaksjon. Disse digitale assistentene forbedrer kundeopplevelsen ved å effektivisere interaksjoner mellom mennesker og tjenester.
Samtidig gir de bedrifter nye muligheter for å optimalisere kundekontaktprosessen for effektivitet, noe som kan kutte konvensjonelle støtteutgifter.
I et nøtteskall er det AI-basert programvare som er ment å kommunisere med mennesker på deres naturlige språk. Disse chatbotene samhandler ofte via lyd- eller skriftlige teknikker, og de kan lett etterligne menneskelige språk for å få kontakt med mennesker på en menneskelignende måte.
Chatbots lærer av deres interaksjoner med brukere, og blir mer realistiske og effektive over tid. De kan håndtere et bredt spekter av forretningsaktiviteter, som å godkjenne utgifter, engasjere seg med forbrukere på nettet og generere potensielle kunder.
Lag din egen deep learning chatbot med python
Det er mange forskjellige typer chatbots innen maskinlæring og AI. Noen chatboter er virtuelle assistenter, mens andre bare er der for å snakke med, mens andre er kundeserviceagenter.
Du har sikkert sett noen av de som er ansatt av bedrifter for å svare på henvendelser. Vi lager en liten chatbot i denne opplæringen for å svare på ofte forespurte spørsmål.
1. Installere pakker
Vårt første trinn er å installere følgende pakker.
2. Treningsdata
Nå er det på tide å finne ut hvilken type informasjon vi trenger for å gi chatboten vår. Vi trenger ikke å laste ned noen store datasett fordi dette er en enkel chatbot.
Vi bruker kun informasjonen vi har laget selv. For å følge leksjonen effektivt, må du generere en .JSON-fil med samme format som det som vises nedenfor. Filen min heter "intents.json."
JSON-filen brukes til å lage et sett med meldinger som brukeren sannsynligvis vil legge inn og kartlegge til et sett med relevante svar. Hver ordbok i filen har en kode som identifiserer hvilken gruppe hver melding tilhører.
Vi vil bruke denne informasjonen til å trene en nevrale nettverket å kategorisere en frase med ord som en av kodene i filen vår.
Vi kan da bare ta et svar fra disse gruppene og gi det til brukeren. Chatboten blir bedre og mer komplisert hvis du tilbyr den med flere tagger, svar og mønstre.
3. JSON-data laster inn
Vi starter med å laste inn .json-dataene våre og importere noen moduler. Sett sammen din.json-fil i samme katalog som din Python-manus. Våre .json-data vil nå bli lagret i datavariabelen.
4. Datautvinning
Nå er det på tide å trekke ut informasjonen vi trenger fra JSON-filen vår. Alle mønstrene, samt klassen/brikken de tilhører, er obligatoriske.
Vi trenger også en liste over alle de unike termene i mønstrene våre (av grunner vi skal forklare senere), så la oss lage noen tomme lister for å holde styr på disse verdiene.
Nå skal vi gå gjennom JSON-dataene våre og hente informasjonen vi trenger. I stedet for å ha dem som strenger, bruker vi nltk.word tokenizer for å transformere hvert mønster til en liste med ord.
Deretter, i docs_x-listen vår, legger vi til hvert mønster, sammen med tilhørende tag, til docs_y-listen.
5. Ordstamme
Å finne roten til et ord er kjent som stammer. For eksempel kan stammen til ordet "det"-stammen være "det", mens stammen til ordet "skjer" kan være "skje".
Vi bruker denne stemmingsteknikken for å kutte ned modellens ordforråd og prøve å finne ut hva setninger generelt innebærer. Denne koden vil ganske enkelt generere en unik liste over avstammede ord som vil bli brukt i neste fase av dataforberedelsen vår.
6. Pose med ord
Det er på tide å snakke om en pose med ord nå som vi har importert dataene våre og generert et vokabular. Nevrale nettverk og maskinlæringsalgoritmer, som vi alle vet, krever numerisk input. Så strenglisten vår kommer ikke til å kutte den. Vi trenger en mekanisme for å representere tall i setningene våre, det er der en pose med ord kommer inn.
Hver setning vil bli representert av en liste over lengden på antall termer i modellens vokabular. Hvert ord i vokabularet vårt vil bli representert med en plass i listen. Hvis posisjonen i listen er en 1, vises ordet i vår uttalelse; hvis det er en 0, vises ikke ordet i setningen vår.
Vi kaller det en pose med ord fordi vi ikke vet rekkefølgen ordene vises i i frasen; alt vi vet er at de finnes i modellens vokabular.
I tillegg til å strukturere våre input, må vi også formatere utdataene våre slik at det nevrale nettverket forstår det. Vi bygger utdatalister som er lengden på antall etiketter/tagger i datasettet vårt, som ligner på en pose med ord. Hvert sted på listen representerer en unik etikett/tag, og en 1 på alle disse stedene indikerer hvilken etikett/tag som er representert.
Til slutt vil vi bruke NumPy-matriser til å lagre treningsdata og utdata.
7. Modellutvikling
Vi er klare til å begynne å bygge og trene en modell nå som vi har forhåndsbehandlet alle dataene våre. Vi vil bruke et veldig grunnleggende feed-forward nevralt nettverk med to skjulte lag for våre mål.
Nettverkets formål vil være å se på en samling ord og tilordne dem til en klasse (en av taggene våre fra JSON-filen). Vi begynner med å etablere vår modells arkitektur. Husk at du kan leke med noen av tallene for å komme opp med en bedre modell! Maskinlæring er for det meste basert på prøving og feiling.
8. Modellopplæring og sparing
Det er på tide å trene modellen vår på dataene våre nå som vi har satt den opp! Vi vil oppnå dette ved å tilpasse dataene våre til modellen. Antall epoker vi gir er antall ganger modellen vil bli eksponert for de samme dataene under trening.
Vi kan lagre modellen til filmodellen når vi er ferdige med opplæringen. tflearn er et skript som kan brukes i andre skript.
9. Bruke en chatbot
Nå kan du begynne å chatte med boten din.
Fordeler med Chatbot
- Siden roboter forventes å operere 365 dager i året, 24 timer i døgnet, uten lønn, øker tilgjengeligheten og reaksjonshastigheten.
- Disse robotene er perfekte verktøy for å takle big datas tre sentrale Vs: volum, hastighet og variasjon.
- Chatbots er programvare som kan brukes til å lære om og forstå en bedrifts forbrukere.
- Den har overlegen kraft at den har en billig vedlikeholdskostnad etter å ha hatt toppfordeler.
- Chatbot-applikasjoner lager data som kan bevares og brukes til analyser og prognoser.
Usecase
- Løse kundespørsmål
- Svare på ofte stilte spørsmål
- Tildele kunder til støtteteam
- Samler inn tilbakemeldinger fra kunder
- Anbefaler nye tilbud
- Handle med samtalehandel
- IT Helpdesk
- Bestilling av overnatting
- Pengeoverføring
konklusjonen
Chatbots, som andre AI-teknologier, vil bli brukt til å øke menneskelige ferdigheter og frigjøre mennesker til å være mer kreative og fantasifulle ved å la dem bruke mer tid på strategiske i stedet for taktiske oppgaver.
Bedrifter, ansatte og forbrukere vil sannsynligvis dra nytte av forbedrede chatbot-funksjoner som raskere anbefalinger og spådommer, samt enkel tilgang til høyoppløselige videokonferanser fra en samtale, i nær fremtid, når AI kombineres med utvikling av 5G-teknologi.
Disse og andre muligheter blir fortsatt undersøkt, men etter hvert som internettforbindelse, AI, NLP og maskinlæring utvikler seg, vil de bli mer utbredt.
Chwoo
Hallo,
Takk for dette programmet.
Jeg har et spørsmål.
"bag_of_words" er ikke definert. Jeg kan ikke forstå denne feilen.
Kan du fortelle meg hvordan jeg kan løse denne feilen??
Takk for dette programmet!! Ha en fin dag
Jay
Vennligst legg til en funksjon før du bruker chatbot-delen:
///////////////////////////////////////////// ///////////////////////////
def bag_of_words(s, words):
bag = [0 for _ innen rekkevidde(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:
bag[i] = 1
returner numpy.array(bag)
// Det vil definitivt løse problemet ditt. //
////////////////////////////////////////////////// //////////////////////////
Jeg deler hele koden med deg, slik at du får et klart bilde av den.
///////////////////////////////////////////// /////////
importer nltk
fra nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
import numpy
importere tflearn
importere tensorflow
Import tilfeldig
importer json
importere sylteagurk
med open(“intents.json”) som fil:
data = json.load(fil)
prøve:
med open(“data.pickle”, “rb”) som f:
ord, etiketter, trening, output = pickle.load(f)
unntatt:
ord = []
etiketter = []
docs_x = []
docs_y = []
for intensjoner i data[“hensikter”]:
for mønster i intensjon["mønstre"]:
wrds = nltk.word_tokenize(mønster)
words.extend(wrds)
docs_x.append(wrds)
docs_y.append(intent[“tag”])
if intent[“tag”] ikke i etiketter:
labels.append(intent[“tag”])
ord = [stemmer.stem(w.lower()) for w i ord hvis w != “?”]
ord = sortert(liste(sett(ord)))
etiketter = sortert(etiketter)
trening = []
utgang = []
out_empty = [0 for _ i området(len(etiketter))]
for x, doc i enumerate(docs_x):
bag = []
wrds = [stemmer.stem(w.lower()) for w i doc]
for w i ord:
hvis w i wrds:
bag.append(1)
ellers:
bag.append(0)
output_row = tom_tom[:]
output_row[labels.index(docs_y[x])] = 1
training.append(bag)
output.append(output_row)
trening = numpy.array(trening)
output = numpy.array(output)
med open(“data.pickle”, “wb”) som f:
pickle.dump((ord, etiketter, opplæring, output), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Ingen, len(trening[0])])
net = tflearn.full_connected(net, 8)
net = tflearn.full_connected(net, 8)
net = tflearn.fully_connected(net, len(output[0]), activation=”softmax”)
net = tflearn.regression(net)
modell = tflearn.DNN(net)
prøve:
model.load(“model.tflearn”)
unntatt:
model.fit(trening, output, n_epoch=1500, batch_size=8, show_metric=True)
model.save(“model.tflearn”)
def bag_of_words(s, words):
bag = [0 for _ innen rekkevidde(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:
bag[i] = 1
returner numpy.array(bag)
def chat():
print(“Begynn å snakke med boten (skriv quit for å stoppe)!”)
mens sant:
inp = input(“Du:“)
if inp.lower() == “avslutt”:
bryte
resultater = model.predict([bag_of_words(inp, words)])
resultater_indeks = numpy.argmax(resultater)
tag = etiketter[resultatindeks]
for tg i data[“intents”]:
if tg['tag'] == tag:
svar = tg['svar']
print(random.choice(responses))
chat()
////////////////////////////////////////////////// ///////////////
Takk skal du ha,
God koding!
Lu
Hallo,
Kan du gi meg en ide om prosessen som skal gjennomføres i tilfelle jeg ønsker å lage en chatbot i python, men informasjonen er hentet fra en spørreundersøkelse i excel. Takk skal du ha!