Codificación para principiantes en Python: creación del compañero de chat de IA más simple posible
Si alguna vez ha utilizado alguno de los chatbots de IA que existen, es posible que se pregunte cómo funcionan y si podría crear uno usted mismo. Con Python, eso es más que posible, y aquí cubriremos cómo construir el chatbot más simple posible y le daremos algunos consejos para actualizarlo.
Aprendiendo sobre NLTK con Python
Una de las razones más convincentes para utilizar Python es su naturaleza modular. Vimos esto en nuestro sencillo rastreador de gastos, cuando usamos Tkinter para crear una GUI básica para nuestra aplicación. Los chatbots no tienen por qué ser tan sofisticados, y podemos ejecutar uno en una terminal sin problemas. No diseñaré una interfaz de usuario para esta aplicación, pero puedes probarla tú mismo.
La base de nuestra aplicación es NLTK (Natual Language Toolkit), una biblioteca de Python que nos brinda los componentes básicos de un chatbot. Para instalar NLTK, abra la ubicación de su instalación de Python en una terminal y escriba:
pip install nltkDebería ver que la biblioteca NLTK se descarga y actualiza. Al igual que cualquier otra inclusión, tendremos que importar NLTK en la parte superior de nuestro código, así:
import nltk
from nltk.tokenize import word_tokenize
from nltk.sentiment import SentimentIntensityAnalyzer
from nltk.corpus import stopwords
from nltk.tag import pos_tag
import string
import random
import re
# Download required NLTK data
nltk.download('punkt_tab')
nltk.download('vader_lexicon')
nltk.download('stopwords')
nltk.download('averaged_perceptron_tagger_eng')Es posible que hayas notado que hemos agregado algunas palabras clave de "descarga" allí. Esto nos permite descargar el conjunto de datos básicos, incluidas las respuestas y la información que nuestro chatbot muy simple ya conoce. Profundicemos en cómo hacer que el chatbot funcione.
Creando la interfaz del Chatbot
Lo mantendremos simple con la interfaz del chatbot, por lo que será similar a cómo hicimos nuestra lista simple de tareas pendientes en Python. Usaremos la ventana de terminal para nuestra entrada y salida.
class SmartAIChatbot:
def __init__(self):
# Enhanced knowledge base with question-answer pairs
self.knowledge_base = {
'greetings': {
'patterns': ['hello', 'hi', 'hey'],
'responses': [
"Hi there! How can I help you today?",
"Hello! Nice to meet you!",
"Hey! What's on your mind?"
]
},
'questions': {
'what': {
'patterns': ['what is', 'what are', 'what can'],
'responses': [
"Let me think about {topic}...",
"Regarding {topic}, I would say...",
"When it comes to {topic}, here's what I know..."
]
},
'how': {
'patterns': ['how do', 'how can', 'how does'],
'responses': [
"Here's a way to approach {topic}...",
"When dealing with {topic}, you might want to...",
"The process for {topic} typically involves..."
]
},
'why': {
'patterns': ['why is', 'why do', 'why does'],
'responses': [
"The reason for {topic} might be...",
"Thinking about {topic}, I believe...",
"Let me explain why {topic}..."
]
}
},
'farewell': {
'patterns': ['bye', 'goodbye', 'see you'],
'responses': [
"Goodbye! Have a great day!",
"See you later!",
"Bye! Come back soon!"
]
}
}
self.sentiment_analyzer = SentimentIntensityAnalyzer()
self.stop_words = set(stopwords.words('english'))Esto le brinda a nuestro chatbot la interacción básica y las palabras clave, así como el comienzo de una forma de manejar las preguntas. Ahora, veamos cómo este robot de IA aceptará las indicaciones y cómo entenderá lo que escribimos.
Cómo enseñar a leer a tus robots
Es posible que hayas notado la palabra "tokenizar" en las importaciones anteriores. Los "tokens" son lo que usan los robots para entender lo que decimos. Para determinar qué tema desea discutir, usaremos tokens y etiquetas, además de manejar cosas como preguntas:
def tokenize_and_tag(self, user_input):
"""Clean, tokenize, and POS tag user input"""
# Clean and tokenize
cleaned = user_input.lower().translate(str.maketrans('', '', string.punctuation))
tokens = word_tokenize(cleaned)
# POS tagging
tagged = pos_tag(tokens)
return tokens, tagged
def extract_topic(self, tokens, question_word):
"""Extract the main topic after a question word"""
# Find the question word's position
try:
q_pos = tokens.index(question_word.lower())
# Get everything after the question word and auxiliary verbs
topic_words = tokens[q_pos + 2:] # Skip question word and auxiliary verb
# Remove stop words from topic
topic = ' '.join([word for word in topic_words if word not in self.stop_words])
return topic if topic else "that"
except ValueError:
return "that"
def identify_question_type(self, user_input, tagged_tokens):
"""Identify the type of question and extract relevant information"""
question_words = {
'what': 'what', 'why': 'why', 'how': 'how',
'when': 'when', 'where': 'where', 'who': 'who'
}
# Check if it's a question
is_question = any([
user_input.endswith('?'),
any(word.lower() in question_words for word, tag in tagged_tokens),
any(pattern in user_input.lower() for qtype in self.knowledge_base['questions']
for pattern in self.knowledge_base['questions'][qtype]['patterns'])
])
if not is_question:
return None, None
# Identify question type and topic
for q_type, q_info in self.knowledge_base['questions'].items():
for pattern in q_info['patterns']:
if pattern in user_input.lower():
topic = self.extract_topic(user_input.split(), q_type)
return q_type, topic
return 'general', 'that'Construyendo el cerebro (rudimentario) de nuestro robot
Como se trata de un chatbot de IA simple, no realizaremos ningún procesamiento de pensamiento complejo. En su lugar, desarrollaremos un método para procesar la entrada del usuario y determinar el sentimiento:
def get_response(self, user_input):
"""Generate a more thoughtful response based on input type"""
tokens, tagged_tokens = self.tokenize_and_tag(user_input)
# Check for greetings and farewells first
for category in ['greetings', 'farewell']:
if any(pattern in user_input.lower() for pattern in self.knowledge_base[category]['patterns']):
return random.choice(self.knowledge_base[category]['responses'])
# Handle questions
q_type, topic = self.identify_question_type(user_input, tagged_tokens)
if q_type:
if q_type in self.knowledge_base['questions']:
template = random.choice(self.knowledge_base['questions'][q_type]['responses'])
return template.format(topic=topic)
else:
# Handle general questions
return f"That's an interesting question about {topic}. Let me think... "
# If not a question, use sentiment analysis for response
sentiment = self.analyze_sentiment(user_input)
if sentiment > 0.2:
return "I sense your enthusiasm! Tell me more about your thoughts on this."
elif sentiment < -0.2:
return "I understand this might be challenging. Would you like to explore this further?"
else:
return "I see what you mean. Can you elaborate on that?"
def analyze_sentiment(self, text):
"""Analyze the sentiment of user input"""
scores = self.sentiment_analyzer.polarity_scores(text)
return scores['compound']Usamos vader_lexicon para decirnos cómo se siente el sentimiento de entrada del usuario y desde allí podemos determinar qué tipo de resultado le daremos.
Hablando con nuestro robot
Para completar la codificación, finalizaremos la interfaz de chat:
def chat(self):
"""Main chat loop"""
print("Bot: Hi! I'm a smarter chatbot now. I can handle questions! Type 'bye' to exit.")
while True:
user_input = input("You: ")
if user_input.lower() in ['bye', 'goodbye', 'exit']:
print("Bot:", random.choice(self.knowledge_base['farewell']['responses']))
break
response = self.get_response(user_input)
print("Bot:", response)
# Create and run the chatbot
if __name__ == "__main__":
chatbot = SmartAIChatbot()
chatbot.chat()Esto nos permite tener una charla básica con nuestro chatbot y obtener algunas de sus respuestas.
Reuniéndolo todo y formas de mejorar
Cuando ejecutamos nuestro chatbot, deberíamos ver algo como esto:
En este punto, el bot puede leer su entrada y darle una respuesta aleatoria, pero en realidad no puede pensar ni responderle. Sin embargo, gracias al sistema de tokenización, puede descubrir lo que intentas preguntar. Simplemente no tiene ningún dato para responder.
Para crear un chatbot de IA con una base de conocimientos adecuada, sería necesario sumergirse en las redes de palabras y aprender a serializar datos, lo cual va mucho más allá de lo que queremos hacer aquí. Sin embargo, si desea crear un chatbot más funcional, existen muchos recursos que pueden enseñarle lo que necesita saber. Como siempre, este código está disponible en mi GitHub para descargarlo o comentarlo.
Hay muchas cosas que podemos mejorar con este bot, desde darle una base de conocimientos real hasta actualizar la interfaz de usuario a algo más elegante y atractivo. ¡Experimente con esto y vea lo que se le ocurre!