Turinys[Slėpti][Rodyti]
Balso skambučiai komunikacijos sektoriuje palaipsniui atsisakoma teksto ir vaizdų. „Facebook“ apklausos duomenimis, daugiau nei pusė pirkėjų mieliau perka iš įmonės, su kuria galėtų pasikalbėti. Pokalbiai tapo nauju socialiai priimtinu bendravimo būdu.
Tai leidžia įmonėms susisiekti su savo klientais bet kuriuo metu ir iš bet kurios vietos. Pokalbių robotai vis labiau populiarėja tarp įmonių ir klientų dėl jų naudojimo paprastumo ir trumpesnio laukimo laiko.
Pokalbių robotai arba automatinės pokalbių programos suteikia klientams labiau pritaikytą būdą prieiti prie paslaugų per tekstinę sąsają. Naujausi AI valdomi pokalbių robotai gali atpažinti užklausą (klausimą, komandą, įsakymą ir t. t.), pateiktą asmens (arba kito roboto, pradžios) konkrečioje aplinkoje ir tinkamai reaguoti (atsakymas, veiksmas ir pan.).
Šiame įraše apžvelgsime, kas yra pokalbių robotai, jų pranašumus, naudojimo atvejus ir kaip susikurti savo gilus mokymasis pokalbių robotas Python, be kita ko.
Pradėkime.
Taigi, kas yra pokalbių robotai?
Pokalbių robotas dažnai vadinamas viena pažangiausių ir perspektyviausių žmogaus ir mašinos sąveikos formų. Šie skaitmeniniai asistentai pagerina klientų patirtį supaprastindami žmonių ir paslaugų sąveiką.
Kartu jie suteikia įmonėms naujų galimybių optimizuoti kontaktų su klientais procesą siekiant efektyvumo, o tai gali sumažinti įprastines palaikymo išlaidas.
Trumpai tariant, tai AI pagrįsta programinė įranga, skirta bendrauti su žmonėmis jų natūraliomis kalbomis. Šie pokalbių robotai dažnai sąveikauja naudodami garso ar rašytines technikas ir gali lengvai imituoti žmonių kalbas, kad užmegztų ryšį su žmonėmis panašiu būdu.
Pokalbių robotai mokosi iš bendravimo su vartotojais, laikui bėgant tampa realesni ir efektyvesni. Jie gali atlikti įvairią verslo veiklą, pavyzdžiui, leisti išleisti išlaidas, bendrauti su vartotojais internete ir generuoti potencialius klientus.
Sukurkite savo gilaus mokymosi pokalbių robotą su python
Šioje srityje yra daug skirtingų pokalbių robotų rūšių mašininis mokymasis ir AI. Kai kurie pokalbių robotai yra virtualūs padėjėjai, o kiti yra tiesiog skirti bendrauti, o kiti yra klientų aptarnavimo agentai.
Tikriausiai matėte kai kuriuos iš įmonių, kurios atsakinėja į užklausas. Šioje mokymo programoje sukursime nedidelį pokalbių robotą, kad atsakytume į dažnai užduodamus klausimus.
1. Paketų diegimas
Pirmasis mūsų žingsnis yra įdiegti šiuos paketus.
2. Mokymų duomenys
Dabar atėjo laikas išsiaiškinti, kokios rūšies informacijos turėsime pateikti savo pokalbių robotui. Mums nereikia atsisiųsti didelių duomenų rinkinių, nes tai paprastas pokalbių robotas.
Naudosime tik tą informaciją, kurią sukūrėme patys. Norėdami efektyviai sekti pamoką, turėsite sugeneruoti .JSON failą tokiu pačiu formatu, kaip parodyta toliau. Mano failas pavadintas „intents.json“.
JSON failas naudojamas pranešimų rinkiniui sukurti, kurį vartotojas gali įvesti ir susieti su atitinkamų atsakymų rinkiniu. Kiekvienas failo žodynas turi žymą, identifikuojančią, kuriai grupei priklauso kiekvienas pranešimas.
Šią informaciją naudosime mokydami a neuroninis tinklas kad priskirtumėte žodžių frazę vienai iš failo žymų.
Tada galime tiesiog paimti atsakymą iš tų grupių ir pateikti jį vartotojui. Pokalbių robotas bus geresnis ir sudėtingesnis, jei pasiūlysite jį su papildomomis žymomis, atsakymais ir šablonais.
3. JSON duomenų įkėlimas
Pradėsime įkeldami savo .json duomenis ir importuodami kai kuriuos modulius. Surinkite savo.json failą tame pačiame kataloge kaip ir jūsų Python scenarijus. Mūsų .json duomenys dabar bus išsaugoti duomenų kintamajame.
4. Duomenų ištraukimas
Dabar atėjo laikas iš mūsų JSON failo išgauti reikalingą informaciją. Reikalingi visi modeliai, taip pat klasė / žyma, kuriai jie priklauso.
Mums taip pat reikės visų unikalių mūsų šablonų terminų sąrašo (dėl priežasčių, kurias paaiškinsime vėliau), todėl sukurkime keletą tuščių sąrašų, kad galėtume sekti šias reikšmes.
Dabar peržiūrėsime JSON duomenis ir gausime reikalingą informaciją. Užuot turėję juos kaip eilutes, naudosime nltk.word tokenizer, kad kiekvieną šabloną paverstume žodžių sąrašu.
Tada savo docs_x sąraše kiekvieną šabloną kartu su susijusia žyma įtrauksime į sąrašą docs_y.
5. Žodžių kamienas
Žodžio šaknies radimas yra žinomas kaip kamienas. Pavyzdžiui, žodžio „tai“ kamienas gali būti „tas“, o žodžio „vyksta“ kamienas gali būti „atsitikti“.
Naudosime šią kamieno techniką, kad apkarpytume savo modelio žodyną ir pabandytume išsiaiškinti, ką apskritai reiškia sakiniai. Šis kodas tiesiog sugeneruos unikalų kamieninių žodžių sąrašą, kuris bus naudojamas kitame duomenų rengimo etape.
6. Maišelis žodžių
Atėjo laikas kalbėti apie daugybę žodžių dabar, kai importavome savo duomenis ir sugeneravome kamieninį žodyną. Neuronų tinklai ir mašininio mokymosi algoritmams, kaip visi žinome, reikia skaitmeninės įvesties. Taigi mūsų styginių sąrašas jo neiškirps. Mums reikia mechanizmo, skirto skaičiams pavaizduoti sakiniuose, todėl atsiranda žodžių maišas.
Kiekviena frazė bus pavaizduota mūsų modelio žodyne esančių terminų ilgio sąrašu. Kiekvienas žodis mūsų žodyne bus nurodytas sąraše. Jei padėtis sąraše yra 1, žodis rodomas mūsų teiginyje; jei jis yra 0, žodis mūsų sakinyje nerodomas.
Mes tai vadiname žodžių maišu, nes nežinome, kokia seka žodžiai pasirodo frazėje; žinome tik tai, kad jie egzistuoja mūsų modelio žodyne.
Be įvesties struktūrizavimo, mes taip pat turime suformatuoti savo išvestį taip, kad neuroninis tinklas ją suprastų. Sukursime išvesties sąrašus, atitinkančius etikečių / žymų skaičių mūsų duomenų rinkinyje, panašius į žodžių maišelį. Kiekviena sąrašo vieta reiškia unikalią etiketę / žymą, o 1 bet kurioje iš šių vietų nurodo, kuri etiketė / žyma yra atstovaujama.
Galiausiai, mes naudosime NumPy masyvus, kad saugotume savo mokymo duomenis ir išvestį.
7. Modelio kūrimas
Esame pasirengę pradėti kurti ir mokyti modelį dabar, kai iš anksto apdorojome visus savo duomenis. Savo tikslams naudosime labai paprastą nukreipimo į priekį neuroninį tinklą su dviem paslėptais sluoksniais.
Mūsų tinklo tikslas bus peržiūrėti žodžių rinkinį ir priskirti juos klasei (viena iš mūsų žymų iš JSON failo). Pradėsime nustatydami savo modelio architektūrą. Atminkite, kad galite žaisti su kai kuriais skaičiais, kad sukurtumėte geresnį modelį! Mašininis mokymasis dažniausiai remiasi bandymais ir klaidomis.
8. Modelių mokymas ir taupymas
Dabar, kai jį nustatėme, atėjo laikas treniruoti modelį pagal mūsų duomenis! Tai pasieksime pritaikydami savo duomenis prie modelio. Mūsų pateikiamas epochų skaičius yra tai, kiek kartų modelis bus veikiamas tais pačiais duomenimis treniruočių metu.
Mes galime išsaugoti modelį failo modelyje, kai baigsime jį mokyti. tflearn yra scenarijus, kuris gali būti naudojamas kituose scenarijuose.
9. Pokalbių roboto naudojimas
Dabar galite pradėti kalbėtis su savo robotu.
„Chatbot“ pranašumai
- Kadangi tikimasi, kad robotai veiks 365 dienas per metus, 24 valandas per parą be užmokesčio, todėl padidės pasiekiamumas ir reakcijos greitis.
- Šie robotai yra puikūs įrankiai sprendžiant tris pagrindinius didelių duomenų Vs: apimtis, greitis ir įvairovė.
- Pokalbių robotai yra programinė įranga, kurią galima naudoti norint sužinoti apie įmonės vartotojus ir juos suprasti.
- Jis pasižymi didele galia, nes turi pigių techninės priežiūros išlaidų po didžiausių privalumų.
- „Chatbot“ programos kuria duomenis, kurie gali būti išsaugoti ir naudojami analizei ir prognozėms.
Naudojimo atvejis
- Klientų užklausų sprendimas
- Atsakymas į dažniausiai užduodamus klausimus
- Klientų priskyrimas palaikymo komandai
- Klientų atsiliepimų rinkimas
- Rekomenduojame naujus pasiūlymus
- Apsipirkite su pokalbio prekyba
- IT pagalbos tarnyba
- Nakvynės užsakymas
- Pinigų pervedimas
Išvada
Pokalbių robotai, kaip ir kitos dirbtinio intelekto technologijos, bus naudojami žmonių įgūdžiams tobulinti ir išlaisvinti žmones, kad jie būtų kūrybiškesni ir vaizdingesni, nes leis daugiau laiko skirti strateginėms, o ne taktinėms užduotims.
Tikėtina, kad įmonės, darbuotojai ir vartotojai artimiausiu metu gaus naudos iš patobulintų pokalbių robotų funkcijų, pvz., greitesnių rekomendacijų ir prognozių, taip pat lengvos prieigos prie didelės raiškos vaizdo konferencijų pokalbio metu, kai dirbtinis intelektas bus derinamas su 5G technologija.
Šios ir kitos galimybės vis dar tiriamos, tačiau tobulėjant interneto ryšiui, dirbtiniam intelektui, NLP ir mašininiam mokymuisi jos taps vis labiau paplitusios.
Chwoo
Sveiki,
Ačiū už šią programą.
Aš turiu klausimą.
„bag_of_words“ neapibrėžtas. Negaliu suprasti šios klaidos.
Ar galite man pasakyti, kaip aš galiu išspręsti šią klaidą?
Ačiū už šią programą!! Geros dienos
Kėkštas
Prieš naudodami pokalbių roboto skyrių, pridėkite funkciją:
/////////////////////////////////////////////////// //////////////////////////////
def bag_of_words(s, words):
krepšys = [0 už _ diapazone(len(žodžiai))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) reiškia žodį s_words]
s_words:
i, w išvardijant (žodžius):
jei w == se:
maišelis [i] = 1
grąžinti numpy.array(bag)
// Tai tikrai išspręs jūsų problemą. //
/////////////////////////////////////////////////// ///////////////////////////
Dalinuosi su jumis visu kodu, kad susidarytumėte aiškų jo vaizdą.
/////////////////////////////////////////////////// //////////
importuoti nltk
iš nltk.stem.lancaster importo LancasterStemmer
stemmer = LancasterStemmer()
importuoti numpy
importuoti tflearn
importo tensorflow
importuoti atsitiktinai
importuoti Json
importuoti marinatą
su open („intents.json“) kaip failas:
duomenys = json.load(failas)
bandyti:
su open ("data.pickle", "rb") kaip f:
žodžiai, etiketės, mokymas, produkcija = marinatas.load(f)
išskyrus:
žodžiai = []
etiketės = []
docs_x = []
docs_y = []
intent in data ["intents"]:
intent modeliui ["modeliai"]:
wrds = nltk.word_tokenize(pattern)
žodžiai.pailginti(wrds)
docs_x.append(wrds)
docs_y.append(intent["žyma"])
jei ketinimas ["žyma"] nėra etiketėse:
labels.append(intent["žyma"])
žodžiai = [stemmer.stem(w.lower()) w žodžiais, jei w != "?"]
žodžiai = surūšiuoti(list(set(žodžiai)))
etiketės = surūšiuotos (etiketės)
mokymas = []
išvestis = []
out_empty = [0 _ diapazone(len(etiketes))]
x, doc in enumerate(docs_x):
krepšys = []
wrds = [stemmer.stem(w.lower()) w doc]
w žodžiais:
jei w wrds:
bag.append (1)
Kitas:
bag.append (0)
output_row = out_empty[:]
output_row[labels.index(docs_y[x])] = 1
mokymas.pridėti(bag)
output.append(output_row)
mokymas = numpy.array(treniruotė)
išvestis = numpy.array(output)
su open ("data.pickle", "wb") kaip f:
pickle.dump((žodžiai, etiketės, mokymas, produkcija), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Nėra, len(mokymas[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)
modelis = tflearn.DNN(net)
bandyti:
model.load("modelis.tflearn")
išskyrus:
modelis.fit(treniruotė, produkcija, n_epoch=1500, partijos_dydis=8, show_metric=tiesa)
model.save("modelis.tflearn")
def bag_of_words(s, words):
krepšys = [0 už _ diapazone(len(žodžiai))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) reiškia žodį s_words]
s_words:
i, w išvardijant (žodžius):
jei w == se:
maišelis [i] = 1
grąžinti numpy.array(bag)
def chat ():
print („Pradėkite kalbėti su robotu (norėdami sustabdyti įveskite quit)!)
o tiesa:
inp = įvestis („Tu:“)
if inp.lower() == "quit":
pertrauka
rezultatai = model.predict([žodžių_maišas(įvestis, žodžiai)])
rezultatų_indeksas = numpy.argmax(results)
žyma = etiketės[results_index]
tg in data ["intents"]:
if tg['tag'] == žyma:
atsakymai = tg['atsakymai']
spausdinti(atsitiktinis.pasirinkimas(atsakymai))
pokalbis ()
////////////////////////////////////////////////// ///////////////
Ačiū, kad puošiatės.
Laimingo kodavimo!
Lu
Sveiki,
Ar galėtumėte duoti man idėją apie procesą, kurį reikia atlikti tuo atveju, jei norite sukurti pokalbių robotą „python“, tačiau informacija gaunama iš „Excel“ apklausos. Ačiū!