Codage pour débutants en Python : créer le compagnon de chat IA le plus simple possible
Si vous avez déjà utilisé l'un des chatbots IA, vous vous demandez peut-être comment ils fonctionnent et si vous pouvez en créer un vous-même. Avec Python, c'est plus que possible, et nous expliquerons ici comment créer le chatbot le plus simple possible et vous donnerons quelques conseils pour le mettre à niveau.
En savoir plus sur NLTK avec Python
L’une des raisons les plus convaincantes d’utiliser Python est sa nature modulaire. Nous l'avons vu dans notre simple outil de suivi des dépenses, lorsque nous avons utilisé Tkinter pour créer une interface graphique de base pour notre application. Cependant, les chatbots n’ont pas besoin d’être aussi sophistiqués et nous pouvons en exécuter un dans un terminal sans problème. Je ne concevrai pas d'interface utilisateur pour cette application, mais vous pouvez l'essayer vous-même.
La base de notre application est NLTK (Natual Language Toolkit), une bibliothèque Python qui nous donne les éléments de base d'un chatbot. Pour installer NLTK, ouvrez l'emplacement de votre installation Python dans un terminal et tapez :
pip install nltkVous devriez voir la bibliothèque NLTK en cours de téléchargement et de mise à jour. Comme pour tout autre inclusion, nous devrons importer NLTK en haut de notre code, comme ceci :
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')
Vous avez peut-être remarqué que nous y avons ajouté des mots-clés « téléchargement ». Cela nous permet de télécharger l’ensemble de données de base comprenant les réponses et les informations que notre très simple chatbot connaît déjà. Voyons comment faire fonctionner le chatbot.
Création de l'interface du chatbot
Nous allons garder les choses simples avec l'interface du chatbot, ce sera donc similaire à la façon dont nous avons créé notre simple liste de tâches en Python. Nous utiliserons la fenêtre du terminal pour nos entrées et sorties.
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'))
Cela donne à notre chatbot l'interaction de base et les mots d'invite ainsi que les débuts d'une façon de traiter les questions. Voyons maintenant comment ce robot IA prendra en compte les invites et comment il comprendra ce que nous tapons.
Comment apprendre à vos robots à lire
Vous avez peut-être remarqué le mot « tokenize » dans les importations précédentes. Les « jetons » sont ce que les robots utilisent pour comprendre ce que nous disons. Pour déterminer le sujet dont vous souhaitez discuter, nous utiliserons des jetons et des balises, ainsi que des éléments tels que des questions :
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'
Construire le cerveau (rudimentaire) de notre robot
Comme il s’agit d’un simple chatbot IA, nous n’effectuerons aucun traitement de pensée complexe. Au lieu de cela, nous développerons une méthode pour traiter les entrées des utilisateurs et déterminer le sentiment :
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']
Nous utilisons vader_lexicon pour nous dire ce que ressent l'utilisateur et à partir de là, nous pouvons déterminer le type de sortie que nous lui donnerons.
Parler à notre robot
Pour compléter le codage, nous finaliserons l'interface 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()
Cela nous permet d'avoir une conversation basique avec notre chatbot, et d'obtenir certaines de ses réponses.
Rassembler tout cela et les moyens de s'améliorer
Lorsque nous exécutons notre chatbot, nous devrions voir quelque chose comme ceci :
À ce stade, le robot peut lire votre entrée et vous donner une réponse aléatoire, mais il ne peut pas réellement vous répondre ni vous répondre. Cependant, grâce au système de tokenisation, il peut comprendre ce que vous essayez de demander. Il n’a tout simplement aucune donnée avec laquelle répondre.
Pour créer un chatbot IA avec une base de connaissances appropriée, vous devez plonger dans les réseaux de mots et en apprendre davantage sur la sérialisation des données, ce qui va bien au-delà de ce que nous voulons faire ici. Cependant, si vous souhaitez créer un chatbot plus fonctionnel, il existe de nombreuses ressources qui peuvent vous apprendre ce que vous devez savoir. Comme toujours, ce code est disponible sur mon GitHub en téléchargement ou en commentaires.
Il y a beaucoup de choses que nous pouvons améliorer avec ce bot, depuis la fourniture d'une véritable base de connaissances jusqu'à la mise à niveau de l'interface utilisateur vers quelque chose de plus élégant et plus invitant. Expérimentez cela et voyez ce que vous obtenez !