Índice analítico[Ocultar][Mostrar]
As chamadas de voz estanse eliminando gradualmente a favor do texto e as imaxes no sector da comunicación. Segundo unha enquisa de Facebook, máis da metade dos compradores prefiren mercar a unha empresa coa que poden falar. O chat converteuse no novo modo de comunicación socialmente aceptable.
Permite ás empresas comunicarse cos seus clientes en calquera momento e desde calquera lugar. Os chatbots están gañando cada vez máis popularidade entre as empresas e os clientes debido á súa facilidade de uso e aos tempos de espera reducidos.
Os chatbots, ou programas de conversa automatizados, ofrecen aos clientes un método máis personalizado para acceder aos servizos a través dunha interface baseada en texto. Os chatbots máis novos con IA poden recoñecer unha consulta (pregunta, comando, orde, etc.) feita por unha persoa (ou outro bot, inicio) nun ambiente específico e responder adecuadamente (resposta, acción, etc.).
Nesta publicación, explicaremos o que son os chatbots, os seus beneficios, os casos de uso e como crear o teu propio. aprendizaxe profunda chatbot en Python, entre outras cousas.
Comecemos.
Entón, que son os chatbots?
A miúdo refírese que un chatbot é unha das formas máis avanzadas e prometedoras de interacción humano-máquina. Estes asistentes dixitais melloran a experiencia do cliente ao racionalizar as interaccións entre persoas e servizos.
Simultaneamente, proporcionan ás empresas novas opcións para optimizar o proceso de contacto co cliente para lograr a eficiencia, o que pode reducir os gastos de soporte convencional.
En poucas palabras, é un software baseado en IA que está destinado a comunicarse cos humanos nas súas linguas naturais. Estes chatbots adoitan interactuar a través de técnicas de audio ou escritas, e poden imitar facilmente as linguaxes humanas para conectarse con humanos dun xeito similar ao humano.
Os chatbots aprenden das súas interaccións cos usuarios, volvéndose máis realistas e eficientes co paso do tempo. Poden xestionar unha ampla gama de actividades comerciais, como autorizar gastos, interactuar cos consumidores en liña e xerar clientes potenciales.
Crea o teu propio chatbot de aprendizaxe profunda con Python
Hai moitos tipos distintos de chatbots no campo de aprendizaxe de máquina e AI. Algúns chatbots son asistentes virtuais, mentres que outros só están aí para conversar, mentres que outros son axentes de atención ao cliente.
Probablemente xa viches a algúns dos empregados das empresas para responder preguntas. Neste tutorial faremos un pequeno chatbot para responder ás consultas máis frecuentes.
1. Instalación de paquetes
O noso primeiro paso é instalar os seguintes paquetes.
2. Datos de formación
Agora é o momento de descubrir que tipo de información necesitaremos darlle ao noso chatbot. Non necesitamos descargar ningún conxunto de datos grande porque este é un chatbot simple.
Só utilizaremos a información que creamos nós mesmos. Para seguir eficazmente a lección, terás que xerar un ficheiro .JSON co mesmo formato que o que se ve a continuación. O meu ficheiro chámase "intents.json".
O ficheiro JSON úsase para crear un conxunto de mensaxes que é probable que o usuario introduza e mapee a un conxunto de respostas relevantes. Cada dicionario do ficheiro ten unha etiqueta que identifica a que grupo pertence cada mensaxe.
Usaremos esta información para adestrar a rede neural para categorizar unha frase de palabras como unha das etiquetas do noso ficheiro.
Despois podemos simplemente tomar unha resposta deses grupos e proporcionarlla ao usuario. O chatbot será mellor e máis complicado se o ofreces con etiquetas, respostas e patróns adicionais.
3. Carga de datos JSON
Comezaremos cargando os nosos datos .json e importando algúns módulos. Ensambla o teu ficheiro.json no mesmo directorio que o teu Script Python. Os nosos datos .json agora gardaranse na variable de datos.
4. Extracción de datos
Agora é o momento de extraer a información que necesitamos do noso ficheiro JSON. Todos os patróns, así como a clase/etiqueta á que pertencen, son obrigatorios.
Tamén necesitaremos unha lista de todos os termos únicos dos nosos patróns (por razóns que explicaremos máis adiante), así que imos crear algunhas listas en branco para facer un seguimento destes valores.
Agora repasaremos os nosos datos JSON e recuperaremos a información que necesitamos. En lugar de telos como cadeas, usaremos nltk.word tokenizer para transformar cada patrón nunha lista de palabras.
Despois, na nosa lista docs_x, engadiremos cada patrón, xunto coa súa etiqueta asociada, á lista docs_y.
5. Derivado da palabra
Buscar a raíz dunha palabra coñécese como derivación. Por exemplo, a raíz da palabra "thats" pode ser "iso", mentres que a raíz da palabra "happening" podería ser "happen".
Usaremos esta técnica de derivación para recortar o vocabulario do noso modelo e tentar descubrir o que implican as frases en xeral. Este código simplemente xerará unha lista única de palabras derivadas que se utilizarán na seguinte fase da nosa preparación de datos.
6. Bolsa de palabras
É hora de falar dunha bolsa de palabras agora que importamos os nosos datos e xeramos un vocabulario derivado. redes neuronais e os algoritmos de aprendizaxe automática, como todos sabemos, requiren entrada numérica. Entón, a nosa lista de cadeas non a vai cortar. Necesitamos un mecanismo para representar números nas nosas frases, que é onde entra unha bolsa de palabras.
Cada frase estará representada por unha lista da lonxitude do número de termos do vocabulario do noso modelo. Cada palabra do noso vocabulario estará representada por un lugar na lista. Se a posición na lista é un 1, a palabra aparece na nosa declaración; se é un 0, a palabra non aparece na nosa oración.
Chamámoslle bolsa de palabras porque descoñecemos a secuencia na que aparecen as palabras na frase; o único que sabemos é que existen no vocabulario do noso modelo.
Ademais de estruturar a nosa entrada, tamén debemos formatear a nosa saída para que a rede neuronal o entenda. Crearemos listas de saída que teñan a lonxitude do número de etiquetas/etiquetas do noso conxunto de datos, de forma similar a unha bolsa de palabras. Cada lugar da lista representa unha etiqueta/etiqueta única e un 1 en calquera desas localizacións indica que etiqueta/etiqueta se está a representar.
Finalmente, usaremos matrices NumPy para almacenar os nosos datos e saídas de adestramento.
7. Desenvolvemento do modelo
Estamos preparados para comezar a construír e adestrar un modelo agora que xa procesamos todos os nosos datos. Utilizaremos unha rede neuronal de avance moi básica con dúas capas ocultas para os nosos obxectivos.
O propósito da nosa rede será ollar unha colección de palabras e asignalas a unha clase (unha das nosas etiquetas do ficheiro JSON). Comezaremos por establecer a arquitectura do noso modelo. Ten en conta que podes xogar con algúns dos números para crear un modelo mellor! Aprendizaxe automática baséase principalmente en proba e erro.
8. Adestramento e aforro de modelos
É hora de adestrar o noso modelo sobre os nosos datos agora que o configuramos. Conseguiremos isto axustando os nosos datos ao modelo. O número de épocas que proporcionamos é o número de veces que o modelo estará exposto aos mesmos datos durante o adestramento.
Podemos gardar o modelo no modelo de ficheiro unha vez que rematemos de adestralo. tflearn é un script que se pode usar noutros scripts.
9. Usando un chatbot
Agora podes comezar a falar co teu bot.
Beneficios de Chatbot
- Como espérase que os bots operen os 365 días do ano, as 24 horas do día, sen pagar, aumente a dispoñibilidade e a velocidade de reacción.
- Estes bots son ferramentas perfectas para abordar as tres Vs clave do big data: volume, velocidade e variedade.
- Os chatbots son software que se pode usar para coñecer e comprender os consumidores dunha empresa.
- Ten unha potencia superior que ten un custo de mantemento barato despois de ter os principais beneficios.
- As aplicacións Chatbot crean datos que se poden conservar e utilizar para análises e previsións.
Caso de uso
- Resolución de consultas dos clientes
- Respondendo preguntas frecuentes
- Asignación de clientes ao equipo de soporte
- Recopilación de comentarios dos clientes
- Recomendando novas ofertas
- Compra con comercio conversacional
- Helpdesk de TI
- Reserva de aloxamentos
- Transferencia de diñeiro
Conclusión
Os chatbots, como outras tecnoloxías de intelixencia artificial, utilizaranse para aumentar as habilidades humanas e liberar aos humanos para que sexan máis creativos e imaxinativos, permitíndolles dedicar máis tempo a tarefas estratéxicas en lugar de tácticas.
É probable que as empresas, os empregados e os consumidores se beneficien de funcións de chatbot melloradas, como recomendacións e predicións máis rápidas, así como do fácil acceso a videoconferencias de alta definición desde unha conversa, nun futuro próximo, cando a IA se combine co desenvolvemento de tecnoloxía 5G.
Estas e outras posibilidades aínda se están investigando, pero a medida que avancen a conectividade a Internet, a intelixencia artificial, a PNL e a aprendizaxe automática, iranse facendo máis frecuentes.
Chwoo
Ola,
Grazas por este programa.
Teño unha pregunta.
"bag_of_words" non está definido. Non podo entender este erro.
Poderías dicirme como podo resolver este erro??
Grazas por este programa!! Que teñas un bo día
Gaio
Engade unha función antes de usar a sección chatbot:
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////
def bolsa_de_palabras(s, palabras):
bolsa = [0 para _ no rango(len(palabras))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para palabra en s_words]
por se en s_words:
para i, w en enumerate(palabras):
se w == se:
bolsa [i] = 1
devolver numpy.array(bolsa)
// Definitivamente resolverá o teu problema. //
//////////////////////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////
Estou compartindo o código completo contigo, para que teñas unha imaxe clara do mesmo.
///////////////////////////////////////////////////////////////////////// /////////
importar nltk
de nltk.stem.lancaster import LancasterStemmer
stemmer = LancasterStemmer ()
importar numpy
importar tflearn
importar tensorflow
importación aleatoria
importar json
importar escabeche
con open(“intents.json”) como ficheiro:
datos = json.load (ficheiro)
tentar:
con open(“data.pickle”, “rb”) como f:
palabras, etiquetas, adestramento, saída = pickle.load(f)
excepto:
palabras = []
etiquetas = []
docs_x = []
docs_y = []
para intención en datos[“intentos”]:
para o patrón en intent[“patróns”]:
wrds = nltk.word_tokenize (patrón)
palabras.estender (palabras)
docs_x.append(wrds)
docs_y.append(intento[“etiqueta”])
se intent[“etiqueta”] non está nas etiquetas:
labels.append(intento[“etiqueta”])
palabras = [stemmer.stem(w.lower()) para w en palabras se w != “?”]
palabras = ordenadas (lista (conxunto(palabras)))
etiquetas = ordenadas (etiquetas)
adestramento = []
saída = []
out_empty = [0 para _ no rango(len(etiquetas))]
para x, doc en enumerate(docs_x):
bolsa = []
wrds = [stemmer.stem(w.lower()) para w no documento]
para w en palabras:
se w en palabras:
bolsa.apend(1)
senón:
bolsa.apend(0)
fila_saída = saída_baleira[:]
fila_saída[labels.index(docs_y[x])] = 1
adestramento.apend(bolsa)
output.append(fila_saída)
adestramento = numpy.array (adestramento)
saída = numpy.array(saída)
con open(“data.pickle”, “wb”) como f:
pickle.dump((palabras, etiquetas, adestramento, saída), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(forma=[Ningún, len(adestramento[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)
tentar:
model.load(“model.tflearn”)
excepto:
model.fit(formación, saída, n_epoch=1500, batch_size=8, show_metric=True)
model.save ("modelo.tflearn")
def bolsa_de_palabras(s, palabras):
bolsa = [0 para _ no rango(len(palabras))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para palabra en s_words]
por se en s_words:
para i, w en enumerate(palabras):
se w == se:
bolsa [i] = 1
devolver numpy.array(bolsa)
chat def():
print("Comezar a falar co bot (escriba saír para parar)!")
mentres que é verdadeiro:
inp = input ("Ti: ")
if inp.lower() == “saír”:
break
resultados = model.predict([bag_of_words(inp, words)])
results_index = numpy.argmax(resultados)
tag = etiquetas[results_index]
para tg en datos[“intentos”]:
if tg['etiqueta'] == etiqueta:
respostas = tg['respostas']
print(random.choice(respostas))
chat ()
///////////////////////////////////////////////////////////////////////// ////////////////
Grazas,
Feliz codificación!
Lu
Ola,
Poderías darme unha idea do proceso a levar a cabo no caso de querer crear un chatbot en python, pero a información obtense dunha enquisa en excel. Grazas!