Anfängerprogrammierung in Python: Den einfachsten KI-Chatbegleiter erstellen, der möglich ist.
Wenn Sie jemals einen der KI-Chatbots da draußen verwendet haben, fragen Sie sich vielleicht, wie sie funktionieren und ob Sie selbst einen erstellen können. Mit Python ist das mehr als möglich, und hier werden wir besprechen, wie man den einfachsten Chatbot überhaupt erstellt und Ihnen einige Ratschläge zur Verbesserung gibt.
Über NLTK mit Python lernen
Einer der überzeugendsten Gründe für die Verwendung von Python ist seine modulare Natur. Das haben wir in unserem einfachen Ausgaben-Tracker gesehen, als wir Tkinter verwendeten, um eine grundlegende Benutzeroberfläche für unsere Anwendung zu erstellen. Chatbots müssen jedoch nicht so anspruchsvoll sein, und wir können einen ohne Probleme in einem Terminal ausführen. Ich werde keine Benutzeroberfläche für diese App entwerfen, aber Sie können es gerne selbst versuchen.
Die Grundlage unserer App ist NLTK (Natural Language Toolkit), eine Python-Bibliothek, die uns die grundlegenden Bausteine für einen Chatbot zur Verfügung stellt. Um NLTK zu installieren, öffnen Sie den Speicherort Ihrer Python-Installation in einem Terminal und geben Sie ein:
pip install nltkSie sollten sehen, dass die NLTK-Bibliothek heruntergeladen und aktualisiert wird. Wie bei allen anderen Includes müssen wir NLTK am Anfang unseres Codes importieren, so:
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')Vielleicht ist Ihnen aufgefallen, dass wir dort einige "Download"-Schlüsselwörter hinzugefügt haben. Dies ermöglicht es uns, den Basisdatensatz herunterzuladen, einschließlich der Antworten und Informationen, die unser sehr einfacher Chatbot bereits kennt. Lassen Sie uns eintauchen und den Chatbot zum Laufen bringen.
Die Gestaltung der Benutzeroberfläche des Chatbots
Wir halten es einfach mit der Chatbot-Oberfläche, sodass es ähnlich sein wird, wie wir unsere einfache To-Do-Liste in Python gemacht haben. Wir werden das Terminalfenster für unsere Eingaben und Ausgaben verwenden.
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'))Dies gibt unserem Chatbot die grundlegenden Interaktionen und Eingabewörter sowie die Anfänge einer Möglichkeit, Fragen zu behandeln. Lassen Sie uns nun ansehen, wie dieser KI-Bot Eingaben aufnehmen wird und wie er verstehen wird, was wir eingeben.
Wie man seinen Bots das Lesen beibringt
Vielleicht ist Ihnen das Wort "tokenisieren" in den vorherigen Imports aufgefallen. "Tokens" sind das, was Bots verwenden, um zu verstehen, was wir sagen. Um zu bestimmen, welches Thema Sie besprechen möchten, verwenden wir Tokens und Tagging sowie den Umgang mit Dingen wie Fragen:
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'Den Bau des Gehirns unseres Bots (rudimentär)
Da dies ein einfacher KI-Chatbot ist, werden wir keine komplexen Denkprozesse durchführen. Stattdessen werden wir eine Methode zur Verarbeitung von Benutzereingaben entwickeln und die Stimmung bestimmen:
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']Wir verwenden das vader_lexicon, um zu bestimmen, wie sich die Eingabesentiment des Benutzers anfühlt, und von dort aus können wir bestimmen, welche Art von Ausgabe wir ihnen geben werden.
Mit unserem Bot sprechen
Um das Codieren abzurunden, werden wir die Chat-Oberfläche finalisieren:
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()Dies ermöglicht es uns, ein grundlegendes Gespräch mit unserem Chatbot zu führen und einige seiner Antworten zu erhalten.
Alles zusammenbringen und Möglichkeiten zur Verbesserung
Wenn wir unseren Chatbot ausführen, sollten wir etwas Ähnliches sehen:
An diesem Punkt kann der Bot Ihre Eingabe lesen und Ihnen eine zufällige Antwort geben, aber er kann nicht wirklich denken und auf Sie antworten. Aufgrund des Tokenisierungssystems kann er jedoch herausfinden, was Sie zu fragen versuchen. Er hat nur keine Daten, um darauf zu antworten.
Um einen KI-Chatbot mit einer ordentlichen Wissensbasis zu erstellen, müssten Sie in Wortnetze eintauchen und lernen, wie man Daten serialisiert, was weit über das hinausgeht, was wir hier tun möchten. Wenn Sie jedoch einen funktionaleren Chatbot erstellen möchten, gibt es viele Ressourcen, die Ihnen das Notwendige beibringen können. Wie immer ist dieser Code auf meinem GitHub zum Download oder für Kommentare verfügbar.
Es gibt viele Dinge, die wir mit diesem Bot verbessern können, von einer tatsächlichen Wissensbasis bis hin zur Aufrüstung der Benutzeroberfläche zu etwas Eleganterem und Einladenderem. Experimentiere damit und schau, was du herausbekommst!