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.
Sommaire
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 nltk
Vous 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
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):
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"""
cleaned = user_input.lower().translate(str.maketrans('', '', string.punctuation))
tokens = word_tokenize(cleaned)
tagged = pos_tag(tokens)
return tokens, tagged def extract_topic(self, tokens, question_word):
"""Extract the main topic after a question word"""
try:
q_pos = tokens.index(question_word.lower())
topic_words = tokens(q_pos + 2:)
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'
}
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
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)
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'))
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:
return f"That's an interesting question about {topic}. Let me think... "
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)
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 saisie 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 apprendre à sérialiser les 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 !
