Innehållsförteckning[Dölj][Visa]
Röstsamtal fasas ut till förmån för text och bild inom kommunikationssektorn. Enligt en Facebook-undersökning föredrar mer än hälften av köparna att köpa från ett företag som de kan prata med. Att chatta har blivit det nya socialt acceptabla kommunikationssättet.
Det gör det möjligt för företag att kommunicera med sina kunder när som helst och från vilken plats som helst. Chatbots blir allt mer populära bland företag och kunder på grund av deras användarvänlighet och minskade väntetider.
Chatbots, eller automatiserade konversationsprogram, ger kunderna en mer anpassad metod för att komma åt tjänster via ett textbaserat gränssnitt. De senaste AI-drivna chatbotarna kan känna igen en fråga (fråga, kommando, order, etc.) gjord av en person (eller en annan bot, start) i en specifik miljö och svara på lämpligt sätt (svar, åtgärd, etc.).
I det här inlägget kommer vi att gå över vad chatbotar är, deras fördelar, användningsfall och hur du gör din egen djupt lärande chatbot i Python bland annat.
Låt oss börja.
Så, vad är chatbots?
En chatbot hänvisas ofta till att vara en av de mest avancerade och lovande formerna av interaktion mellan människa och maskin. Dessa digitala assistenter förbättrar kundupplevelsen genom att effektivisera interaktioner mellan människor och tjänster.
Samtidigt ger de företag nya alternativ för att optimera kundkontaktsprocessen för effektivitet, vilket kan minska konventionella supportkostnader.
I ett nötskal är det AI-baserad programvara som är tänkt att kommunicera med människor på deras naturliga språk. Dessa chatbots interagerar ofta via ljud eller skriftliga tekniker, och de kan lätt efterlikna mänskliga språk för att få kontakt med människor på ett mänskligt sätt.
Chatbots lär sig av sina interaktioner med användare och blir mer realistiska och effektiva med tiden. De kan hantera ett brett utbud av affärsaktiviteter, som att godkänna utgifter, engagera sig med konsumenter online och generera potentiella kunder.
Skapa din egen deep learning chatbot med python
Det finns många olika typer av chatbots inom området maskininlärning och AI. Vissa chatbots är virtuella assistenter, medan andra bara är där för att prata med, medan andra är kundtjänstagenter.
Du har säkert sett några av de som är anställda av företag för att svara på förfrågningar. Vi kommer att skapa en liten chatbot i den här handledningen för att svara på vanliga frågor.
1. Installera paket
Vårt första steg är att installera följande paket.
2. Träningsdata
Nu är det dags att ta reda på vilken typ av information vi behöver för att ge vår chatbot. Vi behöver inte ladda ner några stora datamängder eftersom detta är en enkel chatbot.
Vi kommer bara att använda den information som vi har skapat själva. För att effektivt följa med i lektionen måste du skapa en .JSON-fil med samma format som det som visas nedan. Min fil heter "intents.json."
JSON-filen används för att skapa en uppsättning meddelanden som användaren sannolikt kommer att mata in och mappa till en uppsättning relevanta svar. Varje ordlista i filen har en tagg som identifierar vilken grupp varje meddelande tillhör.
Vi kommer att använda denna information för att träna en neurala nätverk att kategorisera en fras med ord som en av taggarna i vår fil.
Vi kan sedan bara ta ett svar från dessa grupper och ge det till användaren. Chatboten blir bättre och mer komplicerad om du erbjuder den med ytterligare taggar, svar och mönster.
3. JSON-data laddas
Vi börjar med att ladda in våra .json-data och importera några moduler. Sätt ihop filen din.json i samma katalog som din Python-manus. Vår .json-data kommer nu att sparas i datavariabeln.
4. Dataextraktion
Nu är det dags att extrahera informationen vi behöver från vår JSON-fil. Alla mönster, såväl som klassen/taggen som de tillhör, krävs.
Vi behöver också en lista över alla unika termer i våra mönster (av skäl som vi kommer att förklara senare), så låt oss skapa några tomma listor för att hålla reda på dessa värden.
Nu ska vi gå igenom våra JSON-data och hämta den information vi behöver. Istället för att ha dem som strängar använder vi nltk.word tokenizer för att omvandla varje mönster till en lista med ord.
Sedan, i vår docs_x-lista, lägger vi till varje mönster, tillsammans med dess tillhörande tagg, till docs_y-listan.
5. Ordstamling
Att hitta roten till ett ord kallas stemming. Till exempel kan stammen av ordet "det där"-stammen vara "det", medan stammen av ordet "händer" kan vara "hända".
Vi kommer att använda den här stemmingstekniken för att trimma ner vår modells ordförråd och försöka ta reda på vad meningar innebär i allmänhet. Den här koden kommer helt enkelt att generera en unik lista med stammade ord som kommer att användas i nästa fas av vår dataförberedelse.
6. Påse med ord
Det är dags att tala om en påse med ord nu när vi har importerat vår data och skapat ett ordförråd. Neurala nätverk och maskininlärningsalgoritmer, som vi alla vet, kräver numerisk inmatning. Så vår stränglista kommer inte att klippa det. Vi behöver en mekanism för att representera siffror i våra meningar, det är där en påse med ord kommer in.
Varje fras kommer att representeras av en lista över längden på antalet termer i vår modells vokabulär. Varje ord i vårt ordförråd kommer att representeras av en plats i listan. Om positionen i listan är en 1:a förekommer ordet i vårt uttalande; om det är en 0, förekommer inte ordet i vår mening.
Vi kallar det en påse med ord eftersom vi inte vet i vilken ordning orden förekommer i frasen; allt vi vet är att de finns i vår modells vokabulär.
Förutom att strukturera vår input måste vi också formatera vår output så att det neurala nätverket förstår det. Vi kommer att skapa utdatalistor som motsvarar längden på antalet etiketter/taggar i vår datauppsättning, liknande en påse med ord. Varje plats i listan representerar en unik etikett/tagg, och en 1 på någon av dessa platser anger vilken etikett/tagg som representeras.
Slutligen kommer vi att använda NumPy-arrayer för att lagra vår träningsdata och utdata.
7. Modellutveckling
Vi är redo att börja bygga och träna en modell nu när vi har förbehandlat all vår data. Vi kommer att använda ett mycket grundläggande neuralt nätverk med två dolda lager för våra mål.
Vårt nätverks syfte kommer att vara att titta på en samling ord och tilldela dem till en klass (en av våra taggar från JSON-filen). Vi börjar med att fastställa vår modells arkitektur. Tänk på att du kan leka med några av siffrorna för att komma på en bättre modell! Maskininlärning är mest baserat på trial and error.
8. Modellutbildning och sparande
Det är dags att träna vår modell på vår data nu när vi har satt upp den! Vi kommer att uppnå detta genom att anpassa vår data till modellen. Antalet epoker vi tillhandahåller är antalet gånger modellen kommer att exponeras för samma data under träning.
Vi kan spara modellen till filmodellen när vi har tränat klart den. tflearn är ett skript som kan användas i andra skript.
9. Använda en chatbot
Nu kan du börja chatta med din bot.
Fördelar med Chatbot
- Eftersom bots förväntas fungera 365 dagar om året, 24 timmar om dygnet, utan lön, ökar tillgängligheten och reaktionshastigheten.
- Dessa bots är perfekta verktyg för att tackla big datas tre nyckel-Vs: volym, hastighet och variation.
- Chatbots är programvara som kan användas för att lära sig om och förstå ett företags konsumenter.
- Den har överlägsen kraft att den har en billig underhållskostnad efter att ha haft de bästa fördelarna.
- Chatbot-applikationer skapar data som kan bevaras och användas för analyser och prognoser.
Användningsfall
- Lösning av kundfrågor
- Svarar på vanliga frågor
- Tilldela kunder till supportteam
- Samla in kundfeedback
- Rekommenderar nya erbjudanden
- Handla med konversationshandel
- IT Helpdesk
- Bokning av boende
- Pengaröverföring
Slutsats
Chatbots, liksom andra AI-tekniker, kommer att användas för att öka mänskliga färdigheter och befria människor att vara mer kreativa och fantasifulla genom att låta dem spendera mer tid på strategiska snarare än taktiska uppgifter.
Företag, anställda och konsumenter kommer sannolikt att dra nytta av förbättrade chatbot-funktioner som snabbare rekommendationer och förutsägelser, samt enkel tillgång till högupplösta videokonferenser inifrån en konversation, inom en snar framtid, när AI kombineras med utveckling av 5G-teknik.
Dessa och andra möjligheter undersöks fortfarande, men i takt med att internetuppkoppling, AI, NLP och maskininlärning utvecklas kommer de att bli vanligare.
Chwoo
Hallå,
Tack för detta program.
Jag har en fråga.
"påse_med_ord" är inte definierad. Jag kan inte förstå det här felet.
Kan du berätta för mig hur jag kan lösa detta fel??
Tack för detta program!! Ha en bra dag
Jay
Lägg till en funktion innan du använder chatbotsektionen:
////////////////////////////////////////////// ////////////////////////////
def bag_of_words(s, words):
bag = [0 för _ inom intervallet(len(ord))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) för ord i s_words]
för se i s_words:
för i, w i enumerate(ord):
om w == se:
påse[i] = 1
returnera numpy.array(bag)
// Det kommer definitivt att lösa ditt problem. //
////////////////////////////////////////////////// //////////////////////////
Jag delar hela koden med dig så att du får en tydlig bild av den.
////////////////////////////////////////////////////////////////////////////////////////////
importera nltk
från nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
importera numpy
importera tlärn
importera tensorflöde
importera slumpmässigt
importera json
importera knipa
med open(“intents.json”) som fil:
data = json.load(fil)
prova:
med open(“data.pickle”, “rb”) som f:
ord, etiketter, utbildning, output = pickle.load(f)
bortsett från:
ord = []
etiketter = []
docs_x = []
docs_y = []
för avsikt i data["avsikter"]:
för mönster i avsikt["mönster"]:
wrds = nltk.word_tokenize(mönster)
words.extend(wrds)
docs_x.append(wrds)
docs_y.append(intent[“tagg”])
if intent[“tag”] inte i etiketter:
labels.append(intent[“tagg”])
words = [stemmer.stem(w.lower()) för w i ord om w != “?”]
ord = sorterad(lista(set(ord)))
etiketter = sorterad(etiketter)
träning = []
output = []
out_empty = [0 för _ inom intervallet(len(etiketter))]
för x, doc i enumerate(docs_x):
väska = []
wrds = [stemmer.stem(w.lower()) för w i doc]
för w i ord:
om w i wrds:
bag.append(1)
annan:
bag.append(0)
output_row = out_empty[:]
output_row[labels.index(docs_y[x])] = 1
training.append(påse)
output.append(output_rad)
träning = numpy.array(träning)
output = numpy.array(output)
med open(“data.pickle”, “wb”) som f:
pickle.dump((ord, etiketter, utbildning, 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)
modell = tflearn.DNN(net)
prova:
model.load(“model.tflearn”)
bortsett från:
model.fit(training, output, n_epoch=1500, batch_size=8, show_metric=True)
model.save(“model.tflearn”)
def bag_of_words(s, words):
bag = [0 för _ inom intervallet(len(ord))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) för ord i s_words]
för se i s_words:
för i, w i enumerate(ord):
om w == se:
påse[i] = 1
returnera numpy.array(bag)
def chat():
print("Börja prata med boten (skriv quit för att sluta)!")
medan sant:
inp = input(“Du:“)
if inp.lower() == “avsluta”:
bryta
resultat = model.predict([påse_av_ord(inp, ord)])
results_index = numpy.argmax(results)
tagg = etiketter[resultatindex]
för tg i data["avsikter"]:
if tg['tag'] == tagg:
svar = tg['svar']
print(random.choice(responses))
chatt()
////////////////////////////////////////////////// ///////////////
Tack,
Lycklig kodning!
Lu
Hallå,
Kan du ge mig en uppfattning om processen att genomföra i fallet med att vilja skapa en chatbot i python, men informationen är hämtad från en undersökning i excel. Tack!