Talaan ng nilalaman[Tago][Ipakita]
Tinatanggal ang mga voice call pabor sa text at visual sa sektor ng komunikasyon. Ayon sa isang poll sa Facebook, higit sa kalahati ng mga mamimili ay mas gustong bumili mula sa isang kumpanya na maaari nilang kausapin. Ang pakikipag-chat ay naging bagong katanggap-tanggap na paraan ng komunikasyon sa lipunan.
Nagbibigay-daan ito sa mga negosyo na makipag-ugnayan sa kanilang mga kliyente anumang oras at mula sa anumang lokasyon. Ang mga chatbot ay lalong nagiging popular sa mga kumpanya at customer dahil sa kanilang kadalian ng paggamit at pinababang oras ng paghihintay.
Ang mga chatbot, o mga automated na programa sa pakikipag-usap, ay nagbibigay sa mga kliyente ng mas customized na paraan upang ma-access ang mga serbisyo sa pamamagitan ng text-based na interface. Ang pinakabagong AI-powered chatbots ay maaaring makilala ang isang query (tanong, command, order, atbp.) na ginawa ng isang tao (o isa pang bot, inception) sa isang partikular na kapaligiran at tumugon nang naaangkop (sagot, aksyon, atbp.).
Sa post na ito, tatalakayin natin kung ano ang mga chatbot, ang mga benepisyo ng mga ito, mga kaso ng paggamit, at kung paano gumawa ng iyong sarili malalim na pag-aaral chatbot sa Python, bukod sa iba pang mga bagay.
Magsimula na tayo.
Kaya, ano ang chatbots?
Ang isang chatbot ay madalas na tinutukoy bilang isa sa mga pinaka-advance at promising na paraan ng pakikipag-ugnayan ng tao-machine. Pinapabuti ng mga digital assistant na ito ang karanasan ng customer sa pamamagitan ng pag-streamline ng mga pakikipag-ugnayan sa pagitan ng mga tao at serbisyo.
Sabay-sabay, binibigyan nila ang mga negosyo ng mga bagong opsyon para i-optimize ang proseso ng pakikipag-ugnayan sa customer para sa kahusayan, na maaaring makabawas sa mga karaniwang gastos sa suporta.
Sa madaling sabi, ito ay AI-based na software na nilalayong makipag-usap sa mga tao sa kanilang natural na mga wika. Ang mga chatbot na ito ay madalas na nakikipag-ugnayan sa pamamagitan ng audio o nakasulat na mga diskarte, at madali nilang gayahin ang mga wika ng tao upang kumonekta sa mga tao sa paraang katulad ng tao.
Natututo ang mga Chatbot mula sa kanilang mga pakikipag-ugnayan sa mga user, na nagiging mas makatotohanan at mahusay sa paglipas ng panahon. Magagawa nila ang malawak na hanay ng mga aktibidad sa negosyo, tulad ng pagpapahintulot sa paggastos, pakikipag-ugnayan sa mga consumer online, at pagbuo ng mga lead.
Gumagawa ng sarili mong deep learning chatbot gamit ang python
Mayroong maraming natatanging mga uri ng chatbots sa larangan ng machine learning at AI. Ang ilang mga chatbot ay mga virtual na katulong, habang ang iba ay nariyan lamang upang makipag-usap, habang ang iba ay mga ahente ng serbisyo sa customer.
Marahil ay nakita mo na ang ilan sa mga nagtatrabaho sa mga negosyo upang sagutin ang mga katanungan. Gagawa kami ng maliit na chatbot sa tutorial na ito para sagutin ang mga madalas na hinihiling na mga query.
1. Pag-install ng mga pakete
Ang aming unang hakbang ay i-install ang mga sumusunod na pakete.
2. Data ng Pagsasanay
Ngayon ay oras na para malaman kung anong uri ng impormasyon ang kakailanganin naming ibigay sa aming chatbot. Hindi namin kailangang mag-download ng anumang malalaking dataset dahil isa itong simpleng chatbot.
Gagamitin lang namin ang impormasyong ginawa namin mismo. Upang epektibong masundan ang aralin, kakailanganin mong bumuo ng .JSON file na may parehong format tulad ng nakikita sa ibaba. Ang aking file ay pinangalanang "intents.json."
Ang JSON file ay ginagamit upang lumikha ng isang hanay ng mga mensahe na malamang na ipasok ng user at imapa sa isang hanay ng mga nauugnay na sagot. Ang bawat diksyunaryo sa file ay may tag na tumutukoy kung saang grupo kabilang ang bawat mensahe.
Gagamitin namin ang impormasyong ito para sanayin ang a neural network upang ikategorya ang isang parirala ng mga salita bilang isa sa mga tag sa aming file.
Maaari na lang tayong kumuha ng tugon mula sa mga pangkat na iyon at ibigay ito sa user. Magiging mas mahusay at mas kumplikado ang chatbot kung inaalok mo ito ng mga karagdagang tag, tugon, at pattern.
3. Naglo-load ng data ng JSON
Magsisimula kami sa pamamagitan ng pag-load sa aming .json data at pag-import ng ilang module. I-assemble ang iyong.json file sa parehong direktoryo ng iyong script ng Python. Ise-save na ngayon ang aming .json data sa variable ng data.
4. Pagkuha ng Data
Ngayon ay oras na upang kunin ang impormasyong kailangan namin mula sa aming JSON file. Ang lahat ng mga pattern, pati na rin ang klase/tag kung saan sila nabibilang, ay kinakailangan.
Kakailanganin din namin ang isang listahan ng lahat ng natatanging termino sa aming mga pattern (para sa mga kadahilanang ipapaliwanag namin sa ibang pagkakataon), kaya gumawa tayo ng ilang mga blangkong listahan upang masubaybayan ang mga halagang ito.
Ngayon ay susuriin namin ang aming data ng JSON at kukunin ang impormasyong kailangan namin. Sa halip na gawin ang mga ito bilang mga string, gagamitin namin ang nltk.word tokenizer upang gawing isang listahan ng mga salita ang bawat pattern.
Pagkatapos, sa aming listahan ng docs_x, idaragdag namin ang bawat pattern, kasama ang nauugnay na tag nito, sa listahan ng docs_y.
5. Word Stemming
Ang paghahanap ng ugat ng isang salita ay kilala bilang stemming. Halimbawa, ang stem ng salitang “that” stem ay maaaring “that,” samantalang ang stem ng salitang “happening” ay maaaring “happen.”
Gagamitin namin ang pamamaraang ito ng stemming upang bawasan ang bokabularyo ng aming modelo at subukang malaman kung ano ang ipinahihiwatig ng mga pangungusap sa pangkalahatan. Ang code na ito ay bubuo lamang ng isang natatanging listahan ng mga stemmed na salita na gagamitin sa susunod na yugto ng aming paghahanda ng data.
6. Bag ng mga Salita
Oras na para magsalita tungkol sa isang bag ng mga salita ngayong na-import na namin ang aming data at nakabuo ng stemmed na bokabularyo. Neural network at machine learning algorithm, gaya ng alam nating lahat, ay nangangailangan ng numerical input. Kaya't ang aming listahan ng string ay hindi mapuputol. Kailangan namin ng mekanismo upang kumatawan sa mga numero sa aming mga pangungusap, kung saan pumapasok ang isang bag ng mga salita.
Ang bawat parirala ay kakatawanin ng isang listahan ng haba ng bilang ng mga termino sa bokabularyo ng aming modelo. Ang bawat salita sa aming bokabularyo ay kakatawanin ng isang lugar sa listahan. Kung ang posisyon sa listahan ay 1, ang salita ay lilitaw sa aming pahayag; kung ito ay isang 0, ang salita ay hindi lilitaw sa aming pangungusap.
Tinatawag namin itong isang bag ng mga salita dahil hindi namin alam ang pagkakasunud-sunod kung saan lumilitaw ang mga salita sa parirala; ang alam lang natin ay umiiral sila sa bokabularyo ng ating modelo.
Bilang karagdagan sa pagbubuo ng ating input, dapat din nating i-format ang ating output upang maunawaan ito ng neural network. Bubuo kami ng mga listahan ng output na ang haba ng bilang ng mga label/tag sa aming dataset, katulad ng isang bag ng mga salita. Ang bawat lugar sa listahan ay kumakatawan sa isang natatanging label/tag, at ang 1 sa alinman sa mga lokasyong iyon ay nagpapahiwatig kung aling label/tag ang kinakatawan.
Panghuli, gagamitin namin ang mga array ng NumPy upang iimbak ang aming data at output ng pagsasanay.
7. Pagbuo ng Modelo
Handa na kaming magsimulang bumuo at magsanay ng modelo ngayong na-preprocess na namin ang lahat ng aming data. Gagamitin namin ang isang napakapangunahing feed-forward neural network na may dalawang nakatagong layer para sa aming mga layunin.
Ang layunin ng aming network ay tingnan ang isang koleksyon ng mga salita at italaga ang mga ito sa isang klase (isa sa aming mga tag mula sa JSON file). Magsisimula kami sa pamamagitan ng pagtatatag ng arkitektura ng aming modelo. Tandaan na maaari mong paglaruan ang ilan sa mga numero upang makabuo ng isang mas mahusay na modelo! Pag-aaral ng machine karamihan ay batay sa pagsubok at pagkakamali.
8. Pagsasanay sa Modelo at Pagtitipid
Oras na para sanayin ang aming modelo sa aming data ngayong na-set up na namin ito! Makakamit namin ito sa pamamagitan ng pag-angkop ng aming data sa modelo. Ang bilang ng mga panahon na ibinibigay namin ay ang dami ng beses na malantad ang modelo sa parehong data sa panahon ng pagsasanay.
Maaari naming i-save ang modelo sa modelo ng file kapag natapos na namin ang pagsasanay nito. Ang tflearn ay isang script na maaaring gamitin sa ibang mga script.
9. Paggamit ng chatbot
Ngayon ay maaari ka nang magsimulang makipag-chat sa iyong bot.
Mga Benepisyo ng Chatbot
- Dahil ang mga bot ay inaasahang magpapatakbo ng 365 araw sa isang taon, 24 na oras sa isang araw, nang walang bayad, taasan ang kakayahang magamit at bilis ng reaksyon.
- Ang mga bot na ito ay perpektong tool para sa pagharap sa tatlong pangunahing Vs ng malaking data: dami, bilis, at pagkakaiba-iba.
- Ang mga chatbots ay software na magagamit upang matutunan at maunawaan ang mga consumer ng isang kumpanya.
- Mayroon itong superyor na kapangyarihan na mayroon itong murang gastos sa pagpapanatili pagkatapos magkaroon ng mga nangungunang benepisyo.
- Ang mga Chatbot Application ay gumagawa ng data na maaaring mapanatili at magamit para sa analytics at mga hula.
Usecase
- Paglutas ng mga tanong ng customer
- Pagsagot sa mga madalas itanong
- Pagtatalaga ng mga customer upang suportahan ang koponan
- Pagkolekta ng feedback ng customer
- Inirerekomenda ang mga bagong alok
- Mamili gamit ang pakikipag-usap na komersyo
- IT Helpdesk
- Nagbu-book ng mga tirahan
- Paglipat ng pera
Konklusyon
Ang mga chatbot, tulad ng iba pang mga teknolohiya ng AI, ay gagamitin upang dagdagan ang mga kasanayan ng tao at palayain ang mga tao na maging mas malikhain at mapanlikha sa pamamagitan ng pagbibigay-daan sa kanila na gumugol ng mas maraming oras sa estratehiko kaysa sa mga taktikal na gawain.
Ang mga negosyo, empleyado, at consumer ay malamang na makinabang mula sa mga pinahusay na feature ng chatbot gaya ng mas mabilis na mga rekomendasyon at hula, pati na rin ang madaling pag-access sa high-definition na video conferencing mula sa isang pag-uusap, sa malapit na hinaharap, kapag ang AI ay pinagsama sa pagbuo ng 5G na teknolohiya.
Iniimbestigahan pa rin ang mga ito at ang iba pang mga posibilidad, ngunit habang umuusad ang koneksyon sa internet, AI, NLP, at machine learning, magiging mas laganap ang mga ito.
Chwoo
Kamusta,
Salamat sa programang ito.
May tanong ako.
Ang “bag_of_words” ay hindi tinukoy. Hindi ko maintindihan ang error na ito.
Maaari mo bang sabihin sa akin kung paano ko malulutas ang error na ito??
Salamat sa programang ito!! Magkaroon ka ng magandang araw
Ibon ng dyey
Mangyaring magdagdag ng isang function bago gamitin ang seksyon ng chatbot:
////////////////////////////////////////////// ///////////////////////////
def bag_of_words(s, words):
bag = [0 para sa _ sa saklaw(len(mga salita))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para sa salita sa s_words]
para sa s_words:
para sa i, w sa enumerate(mga salita):
kung w == se:
bag[i] = 1
ibalik ang numpy.array(bag)
// Siguradong malulutas nito ang iyong isyu. //
// ///. // ///.
Ibinabahagi ko sa iyo ang kumpletong code, para makakuha ka ng malinaw na larawan nito.
//////////////////////////////////////////////// /////////
import nltk
mula sa nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer()
import numpy
import tflearn
pag-import ng tensorflow
import random
import json
mag-import ng atsara
na may open("intents.json") bilang file:
data = json.load(file)
subukan:
na may open("data.pickle", "rb") bilang f:
salita, label, pagsasanay, output = pickle.load(f)
maliban sa:
salita = []
mga etiketa = []
docs_x = []
docs_y = []
para sa layunin sa data["mga layunin"]:
para sa pattern sa layunin["mga pattern"]:
wrd = nltk.word_tokenize(pattern)
words.extend(wrds)
docs_x.append(wrds)
docs_y.append(intent[“tag”])
kung ang layunin[“tag”] ay wala sa mga label:
labels.append(intent[“tag”])
salita = [stemmer.stem(w.lower()) para sa w sa mga salita kung w != “?”]
salita = pinagsunod-sunod(listahan(set(mga salita)))
mga label = pinagsunod-sunod (mga label)
pagsasanay = []
output = []
out_empty = [0 para sa _ sa saklaw(len(mga label))]
para sa x, doc sa enumerate(docs_x):
bag = []
wrd = [stemmer.stem(w.lower()) para sa w sa doc]
para sa w sa mga salita:
kung w sa wrds:
bag.append(1)
kung hindi:
bag.append(0)
output_row = out_empty[:]
output_row[labels.index(docs_y[x])] = 1
training.append(bag)
output.append(output_row)
pagsasanay = numpy.array(training)
output = numpy.array(output)
na may open("data.pickle", "wb") bilang f:
pickle.dump((mga salita, label, pagsasanay, output), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Wala, len(training[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)
modelo = tflearn.DNN(net)
subukan:
model.load(“model.tflearn”)
maliban sa:
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 para sa _ sa saklaw(len(mga salita))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para sa salita sa s_words]
para sa s_words:
para sa i, w sa enumerate(mga salita):
kung w == se:
bag[i] = 1
ibalik ang numpy.array(bag)
def chat():
print("Simulan ang pakikipag-usap sa bot (i-type ang huminto upang huminto)!")
habang Totoo:
inp = input("Ikaw:")
kung inp.lower() == “quit”:
masira
resulta = model.predict([bag_of_words(inp, words)])
results_index = numpy.argmax(mga resulta)
tag = mga label[results_index]
para sa tg sa data[“intent”]:
kung tg['tag'] == tag:
mga tugon = tg['mga tugon']
print(random.choice(mga tugon))
chat()
////////////////////////////////////////////// ///////////////
Salamat sa iyo,
Maligayang coding!
Lu
Kamusta,
Maaari mo ba akong bigyan ng ideya ng proseso na isasagawa sa kaso ng pagnanais na lumikha ng isang chatbot sa python, ngunit ang impormasyon ay nakuha mula sa isang survey sa excel. Salamat!