Taula de continguts[Amaga][Espectacle]
Les trucades de veu s'estan eliminant gradualment a favor de textos i visuals en el sector de la comunicació. Segons una enquesta de Facebook, més de la meitat dels compradors prefereixen comprar a una empresa amb qui puguin parlar. El xat s'ha convertit en el nou mode de comunicació socialment acceptable.
Permet a les empreses comunicar-se amb els seus clients en qualsevol moment i des de qualsevol lloc. Els chatbots estan guanyant cada cop més popularitat entre les empreses i els clients a causa de la seva facilitat d'ús i els temps d'espera reduïts.
Els chatbots, o programes de conversa automatitzats, proporcionen als clients un mètode més personalitzat per accedir als serveis mitjançant una interfície basada en text. Els nous chatbots basats en IA poden reconèixer una consulta (pregunta, ordre, ordre, etc.) feta per una persona (o un altre bot, inici) en un entorn específic i respondre adequadament (resposta, acció, etc.).
En aquesta publicació, explicarem què són els chatbots, els seus avantatges, casos d'ús i com fer-ne els vostres. aprenentatge profund chatbot a Python, entre altres coses.
Comencem
Aleshores, què són els chatbots?
Sovint es coneix que un chatbot és una de les formes més avançades i prometedores d'interacció home-màquina. Aquests assistents digitals milloren l'experiència del client racionalitzant les interaccions entre persones i serveis.
Simultàniament, proporcionen a les empreses noves opcions per optimitzar el procés de contacte amb el client per a l'eficiència, cosa que pot reduir les despeses de suport convencionals.
En poques paraules, és un programari basat en IA que està pensat per comunicar-se amb els humans en els seus llenguatges naturals. Aquests robots de xat sovint interactuen mitjançant tècniques d'àudio o escrites, i poden imitar fàcilment els idiomes humans per connectar-se amb els humans d'una manera semblant a l'humà.
Els chatbots aprenen de les seves interaccions amb els usuaris, fent-se més realistes i eficients amb el pas del temps. Poden gestionar una àmplia gamma d'activitats empresarials, com ara autoritzar despeses, relacionar-se amb consumidors en línia i generar clients potencials.
Creant el teu propi chatbot d'aprenentatge profund amb Python
Hi ha molts tipus diferents de chatbots en el camp de màquina d'aprenentatge i IA. Alguns chatbots són assistents virtuals, mentre que d'altres només estan allà per conversar, mentre que altres són agents d'atenció al client.
Segurament heu vist alguns dels empleats de les empreses per respondre les consultes. En aquest tutorial farem un petit bot de xat per respondre les consultes sol·licitades amb freqüència.
1. Instal·lació de paquets
El nostre primer pas és instal·lar els paquets següents.
2. Dades de formació
Ara és el moment d'esbrinar quin tipus d'informació haurem de donar al nostre chatbot. No necessitem baixar cap conjunt de dades gran perquè es tracta d'un simple chatbot.
Només utilitzarem la informació que hem creat nosaltres mateixos. Per seguir amb eficàcia la lliçó, haureu de generar un fitxer .JSON amb el mateix format que el que es veu a continuació. El meu fitxer es diu "intents.json".
El fitxer JSON s'utilitza per crear un conjunt de missatges que és probable que l'usuari introdueixi i assigni un conjunt de respostes rellevants. Cada diccionari del fitxer té una etiqueta que identifica a quin grup pertany cada missatge.
Utilitzarem aquesta informació per entrenar a xarxa neural per categoritzar una frase de paraules com una de les etiquetes del nostre fitxer.
Aleshores, només podem prendre una resposta d'aquests grups i proporcionar-la a l'usuari. El chatbot serà millor i més complicat si l'oferiu amb etiquetes, respostes i patrons addicionals.
3. Càrrega de dades JSON
Començarem carregant les nostres dades .json i important alguns mòduls. Munta el teu fitxer.json al mateix directori que el teu Script Python. Les nostres dades .json ara es desaran a la variable de dades.
4. Extracció de dades
Ara és el moment d'extreure la informació que necessitem del nostre fitxer JSON. Tots els patrons, així com la classe/etiqueta a la qual pertanyen, són obligatoris.
També necessitarem una llista de tots els termes únics dels nostres patrons (per motius que explicarem més endavant), així que creem algunes llistes en blanc per fer un seguiment d'aquests valors.
Ara repassarem les nostres dades JSON i recuperarem la informació que necessitem. En lloc de tenir-los com a cadenes, utilitzarem nltk.word tokenizer per transformar cada patró en una llista de paraules.
Aleshores, a la nostra llista docs_x, afegirem cada patró, juntament amb la seva etiqueta associada, a la llista docs_y.
5. Derivació de paraules
Trobar l'arrel d'una paraula es coneix com a derivació. Per exemple, la tija de la paraula "thats" pot ser "això", mentre que la tija de la paraula "happening" podria ser "happen".
Utilitzarem aquesta tècnica de derivació per retallar el vocabulari del nostre model i intentar esbrinar què impliquen les frases en general. Aquest codi només generarà una llista única de paraules derivades que s'utilitzarà en la següent fase de la nostra preparació de dades.
6. Bossa de Paraules
És hora de parlar d'una bossa de paraules ara que hem importat les nostres dades i hem generat un vocabulari derivat. Xarxes neuronals i els algorismes d'aprenentatge automàtic, com tots sabem, requereixen entrada numèrica. Així que la nostra llista de cadenes no la reduirà. Necessitem un mecanisme per representar els números a les nostres frases, que és on entra una bossa de paraules.
Cada frase estarà representada per una llista de la longitud del nombre de termes del vocabulari del nostre model. Cada paraula del nostre vocabulari estarà representada per un lloc a la llista. Si la posició a la llista és un 1, la paraula apareix a la nostra declaració; si és un 0, la paraula no apareix a la nostra frase.
En diem bossa de paraules perquè desconeixem la seqüència en què apareixen les paraules a la frase; tot el que sabem és que existeixen en el vocabulari del nostre model.
A més d'estructurar la nostra entrada, també hem de formatar la nostra sortida perquè la xarxa neuronal l'entengui. Crearem llistes de sortida que tinguin la longitud del nombre d'etiquetes/etiquetes del nostre conjunt de dades, de manera similar a una bossa de paraules. Cada lloc de la llista representa una etiqueta/etiqueta única i un 1 a qualsevol d'aquestes ubicacions indica quina etiqueta/etiqueta s'està representant.
Finalment, utilitzarem matrius NumPy per emmagatzemar les nostres dades d'entrenament i sortida.
7. Desenvolupament del model
Estem preparats per començar a crear i entrenar un model ara que hem preprocessat totes les nostres dades. Utilitzarem una xarxa neuronal de feed-forward molt bàsica amb dues capes ocultes per als nostres objectius.
El propòsit de la nostra xarxa serà mirar una col·lecció de paraules i assignar-les a una classe (una de les nostres etiquetes del fitxer JSON). Començarem establint l'arquitectura del nostre model. Tingues en compte que pots jugar amb alguns dels números per crear un model millor! L'aprenentatge automàtic es basa principalment en assaig i error.
8. Model Training & Estalvi
És hora d'entrenar el nostre model amb les nostres dades ara que l'hem configurat! Ho aconseguirem ajustant les nostres dades al model. El nombre d'èpoques que proporcionem és el nombre de vegades que el model estarà exposat a les mateixes dades durant l'entrenament.
Podem desar el model al model de fitxer un cop acabem d'entrenar-lo. tflearn és un script que es pot utilitzar en altres scripts.
9. Ús d'un chatbot
Ara pots començar a xatejar amb el teu bot.
Avantatges de Chatbot
- Com que s'espera que els robots funcionin els 365 dies de l'any, les 24 hores del dia, sense pagament, augmenta la disponibilitat i la velocitat de reacció.
- Aquests robots són eines perfectes per abordar les tres Vs claus de big data: volum, velocitat i varietat.
- Els chatbots són programari que es pot utilitzar per conèixer i comprendre els consumidors d'una empresa.
- Té una potència superior que té un cost de manteniment econòmic després de tenir els màxims beneficis.
- Les aplicacions de Chatbot creen dades que es poden conservar i utilitzar per a analítiques i previsions.
Cas d'ús
- Resolució de consultes dels clients
- Respondre preguntes freqüents
- Assignació de clients a l'equip de suport
- Recollida de comentaris dels clients
- Recomanant noves ofertes
- Compreu amb comerç conversacional
- Servei d'assistència informàtica
- Reserva d'allotjament
- Transferència de diners
Conclusió
Els chatbots, com altres tecnologies d'IA, s'utilitzaran per augmentar les habilitats humanes i alliberar els humans perquè siguin més creatius i imaginatius, permetent-los dedicar més temps a tasques estratègiques que no pas tàctiques.
És probable que les empreses, els empleats i els consumidors es beneficiïn de les funcions de chatbot millorades, com ara recomanacions i prediccions més ràpides, així com un accés fàcil a videoconferències d'alta definició des d'una conversa, en un futur proper, quan la IA es combina amb el desenvolupament de Tecnologia 5G.
Aquestes i altres possibilitats encara s'estan investigant, però a mesura que avancin la connectivitat a Internet, la IA, la PNL i l'aprenentatge automàtic, seran més freqüents.
Chwoo
Hola,
Gràcies per aquest programa.
Tinc una pregunta.
"bag_of_words" no està definit. No puc entendre aquest error.
Em podries dir com puc solucionar aquest error?
Gràcies per aquest programa!! Que tinguis un bon dia
Gaig
Afegiu una funció abans d'utilitzar la secció de chatbot:
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////
def bag_of_words(s, words):
bossa = [0 per _ a l'interval(len(paraules))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) per a paraula en s_words]
per si en s_words:
per i, w en enumerate(paraules):
si w == se:
bossa [i] = 1
retornar numpy.array (bossa)
// Definitivament resoldrà el vostre problema. //
///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////
Estic compartint el codi complet amb vosaltres, de manera que en tingueu una imatge clara.
///////////////////////////////////////////////////////////////////////// //////////
import Natural Language Toolkit
des de nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer ()
importar numpy
importar tflearn
importar tensorflow
importació aleatòria
importació json
importar escabetx
amb open(“intents.json”) com a fitxer:
dades = json.load(fitxer)
provar:
amb open(“data.pickle”, “rb”) com a f:
paraules, etiquetes, formació, sortida = pickle.load(f)
excepte:
paraules = []
etiquetes = []
docs_x = []
docs_y = []
per a la intenció a les dades["intents"]:
per al patró en intent[“patrons”]:
wrds = nltk.word_tokenize (patró)
paraules.estendre (paraules)
docs_x.append(wrds)
docs_y.append(intent[“etiqueta”])
si intent[“etiqueta”] no a les etiquetes:
labels.append(intent[“etiqueta”)
paraules = [stemmer.stem(w.lower()) per a w en paraules si w != “?”]
paraules = ordenades (llista (conjunt (paraules)))
etiquetes = ordenats (etiquetes)
formació = []
sortida = []
out_empty = [0 per _ dins l'interval(len(etiquetes))]
per a x, doc a enumerate(docs_x):
bossa = []
wrds = [stemmer.stem(w.lower()) per a w al document]
per w amb paraules:
si w en wrds:
bag.append(1)
en cas contrari:
bag.append(0)
fila_sortida = sortida_buida[:]
fila_sortida[etiquetes.index(docs_y[x])] = 1
formació.afegir (bossa)
output.append(fila_sortida)
entrenament = numpy.array (entrenament)
sortida = numpy.array (sortida)
amb open ("data.pickle", "wb") com a f:
pickle.dump((paraules, etiquetes, formació, sortida), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(forma=[Cap, len(entrenament[0])])
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, len(sortida[0]), activation="softmax")
net = tflearn.regression(net)
model = tflearn.DNN(net)
provar:
model.load ("model.tflearn")
excepte:
model.fit(formació, sortida, n_epoch=1500, batch_size=8, show_metric=True)
model.save ("model.tflearn")
def bag_of_words(s, words):
bossa = [0 per _ a l'interval(len(paraules))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) per a paraula en s_words]
per si en s_words:
per i, w en enumerate(paraules):
si w == se:
bossa [i] = 1
retornar numpy.array (bossa)
xat definitiu():
print("Comença a parlar amb el bot (escriviu sortir per aturar)!")
mentre que és cert:
inp = entrada ("Vostè: ")
if inp.lower() == “sort”:
trencar
resultats = model.predict([bag_of_words(inp, mots)])
resultats_índex = numpy.argmax(resultats)
etiqueta = etiquetes[results_index]
per a tg a les dades[“intents”]:
if tg['etiqueta'] == etiqueta:
respostes = tg['respostes']
print(random.choice(respostes))
xat ()
///////////////////////////////////////////////////////////////////////// ////////////////
Gràcies,
Feliç codificació!
Lu
Hola,
Em podries fer una idea del procés a dur a terme en el cas de voler crear un chatbot en python, però la informació s'obté d'una enquesta en excel. Gràcies!