PsicBot: Un chatbot de Telegram con machine learning

Un chatbot es un programa de computadora que puede simular y procesar conversaciones humanas (ya sean escritas o habladas), lo que permite a los humanos interactuar con dispositivos digitales, al igual que comunicarse con personas reales.

Un chatbot puede ser tan simple como un programa simple, que responde a consultas simples con una sola línea de respuesta, o tan complejo como un asistente digital, que se puede aprender y desarrollar para proporcionar un nivel cada vez mayor de personalización al recopilar y procesar información.

Se desarrollará un chatbot llamado “PsicBot”, que responderá preguntas sobre la salud mental y sus enfermedades, y aprenderá a responder diferentes preguntas con la misma respuesta a través del aprendizaje automático.

Para crear nuestro bot, tenemos que hablar con el “BotFather” que controla todos los bots de Telegram. Una vez que inicie una conversación con él, tendrá la opción de crear su propio bot. Una vez creado, el token que necesitará será proporcionado para construirlo.

Crearemos una carpeta para el proyecto e instalaremos las librerías que necesitaremos utilizando las siguientes líneas de código en la cmd:

pip install nltk
pip install tensorflow
pip install python-telegram-bot

Crearemos un archivo llamado credenciales.py, en el que crearemos variables, a las que asignaremos el token y el nombre de nuestro bot:

bot_token="<token de tu bot>"
bot_user_bot="<nombre de tu bot>"

Crearemos un archivo llamado entrenador.py ​​el cual se encargará de entrenar a nuestro bot. Una vez creado y abierto, escribiremos todas las importaciones de las bibliotecas que usaremos:

import nltk
import json
import pickle
import numpy as np
import rando
mnltk.download('punkt')
nltk.download('wordnet')
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import SGD

Iniciaremos las variables que utilizaremos para guardar nuestros datos de lenguaje natural:

palabras=[]
tags=[]
documentos=[]
ignorar=['?','!']
archivo=open('intents.json'),encoding="utf8").read()
intentos=json.loads(archivo)

Crearemos el archivo “intents.json” que contiene todas las intenciones que nuestros usuarios quieren decir, el cual deberá verse de la siguiente manera:

{"intents":[
{"tag": "saludos",
"patterns":["Hola", "que onda", "como estas", "Como Estas", "alguien ahi?", "buenos dias", "buenas", "\\."],
"responses": ["Hola, como estas?","Hola, como te encuentras hoy?"],
"context": [""]}
]}

Importamos nuestro archivo “intents.json” al archivo “entrenador.py” con el siguiente ciclo:

• Primero tokenizamos cada palabra de nuestras preguntas.
• Después le agregamos nuestras palabras.
• Agregamos a documentos la dupla de la palabra tokenizada y el nombre de la clase a la que pertenece.
• Agregamos los tag a tags para categorizarlas.

for intento in intentos['intents']:
    for patrones in intento['patterns']:
         p = nltk.word_tokenize(patrones)
         palabras.extend(p)
         documentos.append((p, intento['tag']))
         if intento['tag'] not in tags:
             tags.append(intento['tag'])

Después limpiamos las palabras, borrando los caracteres “!” y “?” y posteriormente los ordenamos de la siguiente manera:

palabras = [lemmatizer.lemmatize(p.lower()) for p in palabras if p          
            not in ignorar]
palabras = sorted(list(set(palabras)))
tags = sorted(list(set(tags)))

Volvemos nuestras variables ‘dummys’ para que las palabras vuelvan a su forma base y esto lo hacemos de la siguiente manera:

pickle.dump(palabras, open('palabras.pkl', 'wb'))
pickle.dump(tags, open('tags.pkl', 'wb'))

Después crearemos nuestros datos para entrenar nuestro bot, después los utilizaremos para entrenarlos. Una vez realizado este paso creamos nuestra red neuronal de tres capas, en donde la primera tiene 128 neuronas, la segunda 64 neuronas y la tercera 16 neuronas las cuales son el número de intenciones en nuestro archivo “intents.json”.

Ahora ya hecho nuestro modelo de entrenamiento para nuestro bot, creamos un archivo llamado app.py en cual contendrá la configuración de nuestro bot.

Importamos todas las librerías necesarias para que nuestro bot funcione de la manera correcta utilizando las siguientes líneas de código:

import loggin
import telegram
import json
import random
import nltk
import pickle
import numpy as np
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
from credentials import bot_token
from tensorflow.keras.models import load_model
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()

Extraemos la información de nuestros archivos “intents.json”, “modelo.h5”, “palabras.pkl”, “tags.pkl” y configuraremos nuestro bot:

modelo = load_model('modelo.h5')
intentos = json.loads(open('intents.json',encoding="utf8").read())
palabras = pickle.load(open('palabras.pkl', 'rb'))
tags = pickle.load(open('tags.pkl', 'rb'))
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - 
                    %(message)s', level=logging.INFO)
logger = logging.getLogger()
TOKEN = bot_token

Una vez hecho lo anterior crearemos las siguientes funciones:

• limpiarTexto() : Limpia el texto introducido por el usuario.
• busqueda() : Guarda todas las sentencias ya procesadas y limpias para después ser utilizadas para predecir la clase a la que pertenecen.
• predecirTag() : Predice la clase a la que pertenece la pregunta del usuario. Regresa una lista con todos las intenciones y la probabilidad de coincidir.
• obtenerRespuesta() : Toma la lista de intenciones y su probabilidad de coincidir y, verifica el archivo “intents.json” para generar la respuesta con la mayor probabilidad.
• predecirRespuesta() : Predice la clase del mensaje del usuario con la respuesta más probable.
• responder() : Recibe los mensajes del usuario y manda la respuesta que predecimos.

Creamos un enlazador para poder comunicarnos con el bot, también se creará manejadores que serán los que llamaran a nuestra función responder():

updater=Updater(my_bot.token, use_context=True)
dp=updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(MessageHandler(Filters.text, responder))
updater.start_polling()

Una vez realizado todo lo anterior solo queda correr el código para probar nuestro chatbot. Abrimos nuestra carpeta en nuestra cmd y utilizamos los siguientes comandos para entrenar nuestro bot y despues activarlo:

python entrenador.py
python app.py

Ahora podemos abrir nuestra app de Telegram y buscar el nombre de nuestro bot y empezar la conversación.

Repositorio de Github:

GitHub - VesnaPivac/PsicBot: Chatbot que informa sobre salud mental