5 sencillos pasos a seguir

5 sencillos pasos a seguir

Actualizado el 8 de marzo de 2020

En este tutorial, aprenderá a crear un proyecto de chatbot en Python.

Introducción

Los chatbots son muy útiles tanto para empresas como para clientes.

La mayoría de la gente prefiere hablar directamente desde un chat en lugar de llamar a los centros de servicio.

Código en pantalla

Facebook ha publicado datos que han demostrado el valor de los bots. De hecho, más de Se envían 2 mil millones de mensajes por mes entre particulares y empresas.

Según la investigación de HubSpot, 71% de las personas quieren soporte al cliente de aplicaciones de mensajería Así que esta es una forma rápida de resolver sus problemas.

Dicho eso, el Chatbots tenga un futuro brillante en los negocios.

Ahora vamos a crear un proyecto interesante en Chatbot. Vamos a implementar un chatbot en empezar de la nada.

Este software comprenderá de qué está hablando el usuario y puede dar una respuesta adecuada.

Que tener de antemano

Keras

Para implementar el chatbot, primero usaremos Keras. Es una biblioteca de aprendizaje profundo, NLTK, que es un conjunto de herramientas de procesamiento del lenguaje natural (NLP). También necesitamos algunas bibliotecas útiles. Ejecute el siguiente comando para asegurarse de que todas las bibliotecas estén instaladas:

 pip install tensorflow keras pickle nltk

Si quieres aprender Python gratis, aquí tienes la guía principal.

Si quieres conocer el mejor alojamiento de Python, lee nuestra guía.

¿Cómo funcionan los chatbots?

Los chatbots no son más que un software inteligente capaz de interactuar y comunicarse con personas como los humanos.

Interesante, ¿no?

Ahora veremos cómo funcionan realmente.

Todos los chatbots son conceptos PNL (Procesamiento natural del lenguaje). La PNL incluye dos cosas:

  • NLU (Comprensión del lenguaje natural): Es la capacidad de las máquinas para comprender el lenguaje humano como el inglés. Francés, etc …
  • NLG (Generación de lenguaje natural): Es la capacidad de una máquina para generar texto similar a oraciones escritas por humanos.

Imagina que un usuario le hace una pregunta a un chatbot:

Oye, ¿cuál es la noticia de hoy?

El chatbot dividirá la frase del usuario en dos cosas:

  1. La intencion y
  2. Entidad

La intención de esta oración podría ser have_news porque se refiere a una acción que el usuario desea realizar.

Entidad da detalles específicos sobre la intención, por lo que ” hoy Será la entidad.

Por lo tanto, se utiliza un modelo de aprendizaje automático para reconocer las intenciones y entidades del chat.

La estructura del archivo del proyecto.

Archivos de proyecto de chatbot

Una vez que el proyecto esté completo, tendrá todos estos archivos.

Echemos un vistazo rápido a cada archivo. Esto le dará una idea de cómo se implementará el proyecto.

  • Train_chatbot.py : En este archivo, crearemos y entrenaremos el modelo de aprendizaje profundo o aprendizaje profundo. Este último clasificará e identificará lo que el usuario le pide al robot.
  • Gui_Chatbot.py : En este archivo crearemos una interfaz gráfica de usuario para chat con nuestro chatbot capacitado.
  • Intents.json : El archivo de intenciones contiene todos los datos que usaremos para entrenar el modelo. Incluye una colección de etiquetas con sus correspondientes patrones y respuestas.
  • Chatbot_model.h5 : Este es un archivo de formato de datos jerárquico en el que hemos guardado los pesos y la arquitectura de nuestro modelo entrenado.
  • Classes.pkl : El archivo pickle se puede usar para guardar todos los nombres de etiquetas para clasificar cuando predecimos el mensaje.
  • Words.pkl : El archivo de pepinillos words.pkl contiene todas las palabras únicas que componen el vocabulario de nuestro modelo.

Descargue el código fuente y el conjunto de datos: https://drive.google.com/drive/folders/1r6MrrdE8V0bWBxndGfJxJ4Om62dJ2OMP?usp=sharing

Estos son los 5 sencillos pasos para crear este chatbot:

Paso 1. Importar bibliotecas y cargar datos

Paso 1: carga los datos

Cree un nuevo archivo de Python y asígnele un nombre train_chatbot.

A continuación, importaremos todos los módulos necesarios. Luego leeremos el archivo de datos JSON en nuestro programa Python.

Python 
 import numpy as np
 from keras.models import Sequential
 from keras.layers import Dense, Activation, Dropout
 from keras.optimizers import SGD
 import random
 import nltk
 from nltk.stem import WordNetLemmatizer
 lemmatizer = WordNetLemmatizer()
 import json
 import pickle
 intents_file = open('intents.json').read()
 intents = json.loads(intents_file) 

Paso 2. Procesar previamente los datos

Preprocesar los datos

El modelo no toma datos brutos. Se necesita mucho procesamiento previo para que la máquina comprenda fácilmente.

Para los datos textuales, existen varias técnicas de preprocesamiento. El primero es el tokenización. Consiste en descomponer las frases en palabras.

Observando el archivo d‘intenciones, vemos que cada etiqueta contiene una lista de patrones y respuestas.

Nosotros Tokens cada patrón y agregue las palabras a una lista.

También creamos una lista de clases y documentos para agregar todas las intenciones asociadas con los modelos.

Python 
 words=[]
 classes = []
 documents = []
 ignore_letters = ['!', '?', ',', '.']
 for intent in intents['intents']:
     for pattern in intent['patterns']:
         #tokenize each word
         word = nltk.word_tokenize(pattern)
         words.extend(word)        
         #add documents in the corpus
         documents.append((word, intent['tag']))
         # add to our classes list
         if intent['tag'] not in classes:
             classes.append(intent['tag'])
 print(documents) 

Otra técnica es la lematización.

Consiste en convertir las palabras en forma de lema para reducir todas las palabras canónicas.

A modo de ejemplo, las palabras jugar, jugar, jugar, jugar, etc. todo será reemplazado por el juego.

Así, podemos reducir el número total de palabras de nuestro vocabulario. Entonces ahora nosotros lematización cada palabra y elimine las palabras duplicadas.

Python 
 # lemmaztize and lower each word and remove duplicates
 words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_letters]
 words = sorted(list(set(words)))
 # sort classes
 classes = sorted(list(set(classes)))
 # documents = combination between patterns and intents
 print (len(documents), "documents")
 # classes = intents
 print (len(classes), "classes", classes)
 # words = all words, vocabulary
 print (len(words), "unique lemmatized words", words)
 pickle.dump(words,open('words.pkl','wb'))
 pickle.dump(classes,open('classes.pkl','wb')) 

Al final, las palabras contienen el vocabulario de nuestro proyecto mientras que las clases incluyen todas las entidades a clasificar.

Para guardar el objeto Python en un archivo, usamos el método pickle.dump (). Estos archivos serán útiles después de que se complete la capacitación y cuando programemos los chats.

Paso 3. Crea datos de prueba y entrenamiento

Paso 3. Crea datos de prueba y entrenamiento

Para entrenar el modelo, convertiremos cada modelo de entrada en números.

Vamos primero lematizar cada palabra de la plantilla.

Para hacer esto, debe crear una lista de ceros de la misma longitud que el número de todas las palabras. Estableceremos el valor 1 solo para los índices que contienen la palabra en los modelos. Del mismo modo, crearemos la salida estableciendo el valor 1 para la clase de entrada a la que pertenece el modelo.

Python 
 # create the training data
 training = []
 # create empty array for the output
 output_empty = [0] * len(classes)
 # training set, bag of words for every sentence
 for doc in documents:
     # initializing bag of words
     bag = []
     # list of tokenized words for the pattern
     word_patterns = doc[0]
     # lemmatize each word - create base word, in attempt to represent related words
     word_patterns = [lemmatizer.lemmatize(word.lower()) for word in word_patterns]
     # create the bag of words array with 1, if word is found in current pattern
     for word in words:
         bag.append(1) if word in word_patterns else bag.append(0)
         
     # output is a '0' for each tag and '1' for current tag (for each pattern)
     output_row = list(output_empty)
     output_row[classes.index(doc[1])] = 1
     training.append([bag, output_row])
 # shuffle the features and make numpy array
 random.shuffle(training)
 training = np.array(training)
 # create training and testing lists. X - patterns, Y - intents
 train_x = list(training[:,0])
 train_y = list(training[:,1])
 print("Training data is created"

Paso 4. Entrena al modelo

Plantilla de chatbot

La arquitectura de nuestro modelo será una red neuronal compuesta por 3 capas densas.

La primera capa contiene 128 neuronas, el segundo tiene 64 y el último tendrá las mismas neuronas que el número de clases.

Se introducen capas de abandono para reducir el sobreajuste del modelo. Hemos utilizado Optimizador SGD y ajustó los datos para comenzar a entrenar el modelo.

Cuando la formación de 200 eras se completará, guardamos el modelo entrenado usando la función Keras model.save (” chatbot_model.h5 “).

Python 
 # deep neural networds model
 model = Sequential()
 model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
 model.add(Dropout(0.5))
 model.add(Dense(64, activation='relu'))
 model.add(Dropout(0.5))
 model.add(Dense(len(train_y[0]), activation='softmax'))
 # Compiling model. SGD with Nesterov accelerated gradient gives good results for this model
 sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
 model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=['accuracy'])
 #Training and saving the model 
 hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)
 model.save('chatbot_model.h5', hist)
 print("model is created")

Paso 5. Interactuar con el chatbot

charlar con el chatbot

Nuestro modelo está listo para charlar.

Ahora vamos a crear una hermosa interfaz gráfica para nuestro chatbot en un nuevo archivo.

Puedes nombrar el archivo como gui_chatbot.py

En nuestro archivo GUI usaremos el módulo Tkinter para construir la estructura de la aplicación de escritorio. Luego, capturaremos el mensaje del usuario y rehaceremos algunos preprocesos antes de ingresar el mensaje en nuestro modelo entrenado.

El modelo luego predecirá la etiqueta del mensaje del usuario. Luego, seleccionaremos aleatoriamente la respuesta en la lista de respuestas de nuestro archivo de intenciones o ” intenciones “.

Aquí está el código fuente completo para el archivo GUI.

Python 
 import nltk
 from nltk.stem import WordNetLemmatizer
 lemmatizer = WordNetLemmatizer()
 import pickle
 import numpy as np
 from keras.models import load_model
 model = load_model('chatbot_model.h5')
 import json
 import random
 intents = json.loads(open('intents.json').read())
 words = pickle.load(open('words.pkl','rb'))
 classes = pickle.load(open('classes.pkl','rb'))
 def clean_up_sentence(sentence):
     # tokenize the pattern - splitting words into array
     sentence_words = nltk.word_tokenize(sentence)
     # stemming every word - reducing to base form
     sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]
     return sentence_words
 # return bag of words array: 0 or 1 for words that exist in sentence
 def bag_of_words(sentence, words, show_details=True):
     # tokenizing patterns
     sentence_words = clean_up_sentence(sentence)
     # bag of words - vocabulary matrix
     bag = [0]*len(words)  
     for s in sentence_words:
         for i,word in enumerate(words):
             if word == s: 
                 # assign 1 if current word is in the vocabulary position
                 bag[i] = 1
                 if show_details:
                     print ("found in bag: %s" % word)
     return(np.array(bag))
 def predict_class(sentence):
     # filter below  threshold predictions
     p = bag_of_words(sentence, words,show_details=False)
     res = model.predict(np.array([p]))[0]
     ERROR_THRESHOLD = 0.25
     results = [[i,r] for i,r in enumerate(res) if r>ERROR_THRESHOLD]
     # sorting strength probability
     results.sort(key=lambda x: x[1], reverse=True)
     return_list = []
     for r in results:
         return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
     return return_list
 def getResponse(ints, intents_json):
     tag = ints[0]['intent']
     list_of_intents = intents_json['intents']
     for i in list_of_intents:
         if(i['tag']== tag):
             result = random.choice(i['responses'])
             break
     return result
 #Creating tkinter GUI
 import tkinter
 from tkinter import *
 def send():
     msg = EntryBox.get("1.0",'end-1c').strip()
     EntryBox.delete("0.0",END)
     if msg != '':
         ChatBox.config(state=NORMAL)
         ChatBox.insert(END, "You: " + msg + 'nn')
         ChatBox.config(foreground="#446665", font=("Verdana", 12 )) 
         ints = predict_class(msg)
         res = getResponse(ints, intents)
         
         ChatBox.insert(END, "Bot: " + res + 'nn')           
         ChatBox.config(state=DISABLED)
         ChatBox.yview(END)
 root = Tk()
 root.title("Chatbot")
 root.geometry("400x500")
 root.resizable(width=FALSE, height=FALSE)
 #Create Chat window
 ChatBox = Text(root, bd=0, bg="white", height="8", width="50", font="Arial",)
 ChatBox.config(state=DISABLED)
 #Bind scrollbar to Chat window
 scrollbar = Scrollbar(root, command=ChatBox.yview, cursor="heart")
 ChatBox['yscrollcommand'] = scrollbar.set
 #Create Button to send message
 SendButton = Button(root, font=("Verdana",12,'bold'), text="Send", width="12", height=5,
                     bd=0, bg="#f9a602", activebackground="#3c9d9b",fg='#000000',
                     command= send )
 #Create the box to enter message
 EntryBox = Text(root, bd=0, bg="white",width="29", height="5", font="Arial")
 #EntryBox.bind("<Return>", send)
 #Place all components on the screen
 scrollbar.place(x=376,y=6, height=386)
 ChatBox.place(x=6,y=6, height=386, width=370)
 EntryBox.place(x=128, y=401, height=90, width=265)
 SendButton.place(x=6, y=401, height=90)
 root.mainloop()

Descubra más proyectos de Python con el código fuente.

Ejecuta el chatbot

Ahora tenemos dos archivos separados, uno es el train_chatbot.py, que usaremos primero para entrenar el modelo.

Recursos adicionales:

Aina strauss
Últimos artículos de Aina Strauss (ver todo)

Deja una respuesta