Índice del contenido[Esconder][Espectáculo]
Las llamadas de voz se están eliminando gradualmente en favor del texto y las imágenes en el sector de la comunicación. Según una encuesta de Facebook, más de la mitad de los compradores prefieren comprar a una empresa con la que puedan hablar. El chat se ha convertido en el nuevo modo de comunicación socialmente aceptable.
Permite a las empresas comunicarse con sus clientes en cualquier momento y desde cualquier lugar. Los chatbots están ganando cada vez más popularidad entre empresas y clientes debido a su facilidad de uso y tiempos de espera reducidos.
Los chatbots, o programas conversacionales automatizados, brindan a los clientes un método más personalizado para acceder a los servicios a través de una interfaz basada en texto. Los chatbots con tecnología de inteligencia artificial más nuevos pueden reconocer una consulta (pregunta, comando, orden, etc.) realizada por una persona (u otro bot, inicio) en un entorno específico y responder adecuadamente (respuesta, acción, etc.).
En esta publicación, repasaremos qué son los chatbots, sus beneficios, casos de uso y cómo crear los suyos propios. deep learning chatbot en Python, entre otras cosas.
Empecemos.
Entonces, ¿qué son los chatbots?
Con frecuencia se hace referencia a un chatbot como una de las formas más avanzadas y prometedoras de interacción hombre-máquina. Estos asistentes digitales mejoran la experiencia del cliente al agilizar las interacciones entre personas y servicios.
Simultáneamente, brindan a las empresas nuevas opciones para optimizar el proceso de contacto con el cliente para lograr eficiencia, lo que puede reducir los gastos de soporte convencionales.
En pocas palabras, es un software basado en IA que está destinado a comunicarse con los humanos en sus idiomas naturales. Estos chatbots a menudo interactúan a través de audio o técnicas escritas, y pueden imitar fácilmente los lenguajes humanos para conectarse con los humanos de una manera similar a la humana.
Los chatbots aprenden de sus interacciones con los usuarios y se vuelven más realistas y eficientes con el tiempo. Pueden manejar una amplia gama de actividades comerciales, como autorizar gastos, interactuar con consumidores en línea y generar clientes potenciales.
Creando tu propio chatbot de aprendizaje profundo con python
Hay muchos tipos distintos de chatbots en el campo de máquina de aprendizaje y IA. Algunos chatbots son asistentes virtuales, mientras que otros solo están ahí para conversar, mientras que otros son agentes de servicio al cliente.
Probablemente haya visto a algunos de los empleados por las empresas para responder consultas. Haremos un pequeño chatbot en este tutorial para responder consultas frecuentes.
1. Instalar paquetes
Nuestro primer paso es instalar los siguientes paquetes.
2. Datos de entrenamiento
Ahora es el momento de averiguar qué tipo de información necesitaremos darle a nuestro chatbot. No necesitamos descargar grandes conjuntos de datos porque este es un chatbot simple.
Solo utilizaremos la información que hemos creado nosotros mismos. Para seguir la lección de manera efectiva, deberá generar un archivo .JSON con el mismo formato que el que se muestra a continuación. Mi archivo se llama "intents.json".
El archivo JSON se usa para crear un conjunto de mensajes que es probable que el usuario ingrese y asigne a un conjunto de respuestas relevantes. Cada diccionario del archivo tiene una etiqueta que identifica a qué grupo pertenece cada mensaje.
Usaremos esta información para entrenar a un red neural para categorizar una frase de palabras como una de las etiquetas en nuestro archivo.
Entonces podemos simplemente tomar una respuesta de esos grupos y proporcionársela al usuario. El chatbot será mejor y más complicado si lo ofrece con etiquetas, respuestas y patrones adicionales.
3. Carga de datos JSON
Comenzaremos cargando nuestros datos .json e importando algunos módulos. Reúna su archivo.json en el mismo directorio que su Script de Python. Nuestros datos .json ahora se guardarán en la variable de datos.
4. Extracción de datos
Ahora es el momento de extraer la información que necesitamos de nuestro archivo JSON. Todos los patrones, así como la clase/etiqueta a la que pertenecen, son obligatorios.
También necesitaremos una lista de todos los términos únicos en nuestros patrones (por razones que explicaremos más adelante), así que vamos a crear algunas listas en blanco para realizar un seguimiento de estos valores.
Ahora recorreremos nuestros datos JSON y recuperaremos la información que necesitamos. En lugar de tenerlos como cadenas, usaremos el tokenizador nltk.word para transformar cada patrón en una lista de palabras.
Luego, en nuestra lista docs_x, agregaremos cada patrón, junto con su etiqueta asociada, a la lista docs_y.
5. Derivación de palabras
Encontrar la raíz de una palabra se conoce como derivación. Por ejemplo, la raíz de la palabra "eso" podría ser "eso", mientras que la raíz de la palabra "sucediendo" podría ser "suceder".
Usaremos esta técnica de lematización para reducir el vocabulario de nuestro modelo y tratar de descubrir qué implican las oraciones en general. Este código simplemente generará una lista única de palabras derivadas que se usarán en la siguiente fase de nuestra preparación de datos.
6. Bolsa de palabras
Es hora de hablar sobre una bolsa de palabras ahora que importamos nuestros datos y generamos un vocabulario derivado. Redes neuronales y los algoritmos de aprendizaje automático, como todos sabemos, requieren una entrada numérica. Así que nuestra lista de cadenas no va a ser suficiente. Necesitamos un mecanismo para representar números en nuestras oraciones, que es donde entra una bolsa de palabras.
Cada frase estará representada por una lista de la longitud del número de términos en el vocabulario de nuestro modelo. Cada palabra de nuestro vocabulario estará representada por un lugar en la lista. Si la posición en la lista es un 1, la palabra aparece en nuestro enunciado; si es un 0, la palabra no aparece en nuestra oración.
Lo llamamos bolsa de palabras porque no sabemos la secuencia en la que aparecen las palabras en la frase; todo lo que sabemos es que existen en el vocabulario de nuestro modelo.
Además de estructurar nuestra entrada, también debemos formatear nuestra salida para que la red neuronal la entienda. Crearemos listas de salida que tengan la longitud de la cantidad de etiquetas/etiquetas en nuestro conjunto de datos, similar a una bolsa de palabras. Cada lugar en la lista representa una etiqueta/etiqueta única, y un 1 en cualquiera de esas ubicaciones indica qué etiqueta/etiqueta se representa.
Finalmente, usaremos arreglos NumPy para almacenar nuestros datos de entrenamiento y salida.
7. Desarrollo de modelos
Estamos listos para comenzar a construir y entrenar un modelo ahora que hemos preprocesado todos nuestros datos. Utilizaremos una red neuronal feed-forward muy básica con dos capas ocultas para nuestros objetivos.
El propósito de nuestra red será mirar una colección de palabras y asignarlas a una clase (una de nuestras etiquetas del archivo JSON). Comenzaremos estableciendo la arquitectura de nuestro modelo. ¡Tenga en cuenta que puede jugar con algunos de los números para obtener un mejor modelo! Aprendizaje automático se basa principalmente en prueba y error.
8. Entrenamiento y ahorro modelo
¡Es hora de entrenar nuestro modelo en nuestros datos ahora que lo hemos configurado! Lo lograremos ajustando nuestros datos al modelo. El número de épocas que proporcionamos es el número de veces que el modelo estará expuesto a los mismos datos durante el entrenamiento.
Podemos guardar el modelo en el modelo de archivo una vez que hayamos terminado de entrenarlo. tflearn es un script que se puede usar en otros scripts.
9. Usar un chatbot
Ahora puedes comenzar a chatear con tu bot.
Beneficios de los chatbots
- Como se espera que los bots operen los 365 días del año, las 24 horas del día, sin pago, aumente la disponibilidad y la velocidad de reacción.
- Estos bots son herramientas perfectas para abordar las tres V clave de big data: volumen, velocidad y variedad.
- Los chatbots son un software que se puede utilizar para conocer y comprender a los consumidores de una empresa.
- Tiene una potencia superior que tiene un costo de mantenimiento económico después de tener los mejores beneficios.
- Las aplicaciones de chatbot crean datos que pueden conservarse y utilizarse para análisis y pronósticos.
Caso de uso
- Resolución de consultas de clientes
- Respondiendo preguntas frecuentes
- Asignación de clientes al equipo de soporte
- Recopilación de comentarios de los clientes
- Recomendar nuevas ofertas
- Compra con comercio conversacional
- Helpdesk de TI
- Reserva de alojamiento
- Transferencia de dinero
Conclusión
Los chatbots, al igual que otras tecnologías de IA, se utilizarán para aumentar las habilidades humanas y liberar a los humanos para que sean más creativos e imaginativos al permitirles dedicar más tiempo a tareas estratégicas que tácticas.
Es probable que las empresas, los empleados y los consumidores se beneficien de las características mejoradas de los chatbots, como recomendaciones y predicciones más rápidas, así como un fácil acceso a videoconferencias de alta definición desde una conversación, en un futuro próximo, cuando la IA se combine con el desarrollo de tecnología 5G.
Estas y otras posibilidades aún se están investigando, pero a medida que progresen la conectividad a Internet, la IA, la PNL y el aprendizaje automático, se volverán más frecuentes.
chwoo
Hola,
Gracias por este programa.
Tengo una pregunta.
“bag_of_words” no está definido. No puedo entender este error.
Me podrian decir como puedo solucionar este error??
¡¡Gracias por este programa!! Que tengas un buen día
arrendajo
Agregue una función antes de usar la sección de chatbot:
////////////////////////////////////////////////////// ///////////////////////////
def bolsa_de_palabras(s, palabras):
bolsa = [0 para _ en rango (len (palabras))]
s_palabras = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para palabra en s_words]
para se en s_words:
para i, w en enumerar (palabras):
si w == si:
bolsa[i] = 1
volver numpy.array(bolsa)
// Definitivamente resolverá su problema. //
////////////////////////////////////////////////// //////////////////////////
Estoy compartiendo el código completo contigo, para que tengas una idea clara de él.
//////////////////////////////////////////////////// /////////
importar nltk
de nltk.stem.lancaster importar LancasterStemmer
tallo = Lancaster Stemmer ()
importar numpy
importar tflearn
importar flujo de tensor
importar al azar
importar json
importar pepinillos
con open(“intents.json”) como archivo:
datos = json.load(archivo)
tratar:
con abierto(“data.pickle”, “rb”) como f:
palabras, etiquetas, entrenamiento, salida = pickle.load(f)
excepto:
palabras = []
etiquetas = []
documentos_x = []
documentos_y = []
para la intención en los datos [“intentos”]:
para patrón en intención [“patrones”]:
wrds = nltk.word_tokenize(patrón)
palabras.extender(palabras)
docs_x.append(palabras)
docs_y.append(intento[“etiqueta”])
si la intención [“etiqueta”] no está en las etiquetas:
etiquetas.append(intento[“etiqueta”])
palabras = [stemmer.stem(w.lower()) for w en palabras si w != “?”]
palabras = ordenado(lista(conjunto(palabras)))
etiquetas = ordenado(etiquetas)
entrenamiento = []
salida = []
out_empty = [0 para _ en rango (len (etiquetas))]
para x, doc en enumerar (docs_x):
bolsa = []
wrds = [stemmer.stem(w.lower()) para w en doc]
para w en palabras:
si w en palabras:
bolsa.anexar(1)
más:
bolsa.anexar(0)
salida_fila = salida_vacío[:]
salida_fila[etiquetas.index(docs_y[x])] = 1
entrenamiento.anexar(bolsa)
salida.append(salida_fila)
entrenamiento = numpy.array(entrenamiento)
salida = numpy.array(salida)
con abierto(“data.pickle”, “wb”) como f:
pickle.dump((palabras, etiquetas, entrenamiento, salida), f)
tensorflow.reset_default_graph ()
net = tflearn.input_data(shape=[Ninguno, len(entrenamiento[0])])
red = tflearn.fully_connected (red, 8)
red = tflearn.fully_connected (red, 8)
net = tflearn.fully_connected(net, len(salida[0]), activación=”softmax”)
red = tflearn.regresión (red)
modelo = tflearn.DNN (red)
tratar:
modelo.load(“modelo.tflearn”)
excepto:
model.fit(entrenamiento, salida, n_epoch=1500, batch_size=8, show_metric=True)
modelo.guardar(“modelo.tflearn”)
def bolsa_de_palabras(s, palabras):
bolsa = [0 para _ en rango (len (palabras))]
s_palabras = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para palabra en s_words]
para se en s_words:
para i, w en enumerar (palabras):
si w == si:
bolsa[i] = 1
volver numpy.array(bolsa)
definitivamente chat():
print(“Empiece a hablar con el bot (escriba quit para parar)!”)
mientras cierto:
entrada = entrada ("Tú:")
if inp.lower() == “salir”:
romper
resultados = modelo.predecir([bolsa_de_palabras(inp, palabras)])
índice_resultados = numpy.argmax(resultados)
etiqueta = etiquetas[resultados_índice]
para tg en datos[“intentos”]:
if tg['etiqueta'] == etiqueta:
respuestas = tg['respuestas']
imprimir (al azar.elección (respuestas))
charlar()
////////////////////////////////////////////////// ///////////////
Gracias,
¡Feliz codificación!
Lu
Hola,
Me podrías dar una idea del proceso a realizar en el caso de querer crear un chatbot en python, pero la información la obtengo de una encuesta en excel. ¡Gracias!