Wie man in Python einen Chatbot erstellt

Posted on Fr 07 April 2023 in Artificial Intelligence, Chatbots, Python Basics • 4 min read

In dieser Anleitung werden wir Schritt für Schritt lernen, wie man in Python einen Chatbot erstellt. Wir werden verschiedene Konzepte wie Natural Language Processing (NLP) und Machine Learning (ML) verwenden, um eine interaktive Kommunikation zwischen den Benutzern und unserem Chatbot zu ermöglichen.

Schritt 1: Installation von Bibliotheken

Bevor wir mit der Programmierung beginnen, müssen wir sicherstellen, dass wir alle erforderlichen Bibliotheken installiert haben. In diesem Artikel werden wir folgende Bibliotheken verwenden:

  1. NLTK: Diese Bibliothek wird verwendet, um Textdaten zu verarbeiten, insbesondere bei der Analyse von Texten.

  2. Sklearn: Diese Bibliothek wird zum Trainieren unseres Chatbot-Modells verwendet.

  3. Flask: Diese Bibliothek wird zum Erstellen einer Webanwendung verwendet, um unseren Bot der Außenwelt zugänglich zu machen.

Lassen Sie uns nun diese Bibliotheken installieren, indem wir den folgenden Befehl in der Eingabeaufforderung ausführen:

    !pip install nltk flask scikit-learn

Schritt 2: Korpusdaten sammeln

Der erste Schritt bei der Erstellung eines Chatbots ist das Sammeln von relevanten Daten, die uns helfen, das Modell zu trainieren. Wir werden ein Korpus von Texten verwenden, die Frage-Antwort-Paare enthalten.

Ein Korpus ist eine Zusammenstellung von Texten, die von maschinellen Lernalgorithmen verwendet werden, um ein Modell zu trainieren. In unserem Fall benötigen wir ein Korpus von Dialogen, das von menschlichen Schreibenden verfasst wurde, um unser Modell auf die Sprache und die unterschiedlichen Schreibstile der Benutzer anzupassen.

Es gibt viele Korpora, die Sie aus dem Internet herunterladen oder sammeln können. Wir werden in diesem Artikel das Cornell Movie Dialog Corpus verwenden. Sie können es über diesen Link herunterladen und entpacken.

Schritt 3: Vorverarbeitung der Daten

Die Vorverarbeitung von Textdaten ist sehr wichtig, um unser Modell korrekt zu trainieren und eine präzise Interpretation der Benutzeranforderungen zu gewährleisten. Wir müssen die Rohdaten bereinigen, lemmatisieren und tokenisieren, bevor wir sie verwenden können.

Bereinigung

Das Entfernen von Sonderzeichen, Ziffern und anderen gelegentlich auftretenden Zeichen ist eine gängige Praxis bei der Vorverarbeitung von Textdaten. Wir werden die Daten von unerwünschten Zeichen bereinigen, einschließlich Interpunktion und HTML-Tags, damit wir nur die wichtigen Wörter beibehalten. 

    import re
    def text_clean(text):
        text = re.sub(r"-", " ", text)
        text = re.sub(r"\d+", "", text)
        text = text.lower()
        text = re.sub(r"\s+", " ", text)
        text = re.sub(r"[^a-zA-Z0-9\s]", "", text)
        return text

Tokenisierung

Die Tokenisierung ist der Akt des Aufteilens eines Dokuments in einzelne Wörter oder Phrasen. Wir werden das NLTK-Tool zur Tokenisierung verwenden. 

    import nltk
    nltk.download("punkt")

    from nltk.tokenize import word_tokenize
    def tokenize(text):
        tokens = word_tokenize(text)
        return tokens

Lemmatisierung

Die Lemmatisierung ist der Akt des Umwandeln eines Wortes in seine normalisierte Form. Wir werden das WordNetLemmatizer-Tool aus dem NLTK-Paket verwenden, das jedem Wort seine Grundform zuweist.

    nltk.download("wordnet")

    from nltk.stem import WordNetLemmatizer
    lemmatizer = WordNetLemmatizer()

    def lemmatize(tokens):
        lemmas = []
        for word, tag in pos_tag(tokens):
            tag = tag[0].lower()
            tag = tag if tag in ["a", "r", "n", "v"] else None
            if not tag:
                lemma = word
            else:
                lemma = lemmatizer.lemmatize(word, tag)
            lemmas.append(lemma)
        return lemmas

Der vollständige Code für die Vorverarbeitung:

    from nltk.tokenize import word_tokenize
    from nltk import pos_tag
    from nltk.stem import WordNetLemmatizer
    import re
    import nltk
    nltk.download("punkt")
    nltk.download("wordnet")

    def text_clean(text):
        text = re.sub(r"-", " ", text)
        text = re.sub(r"\d+", "", text)
        text = text.lower()
        text = re.sub(r"\s+", " ", text)
        text = re.sub(r"[^a-zA-Z0-9\s]", "", text)
        return text

    def tokenize(text):
        tokens = word_tokenize(text)
        return tokens

    lemmatizer = WordNetLemmatizer()

    def lemmatize(tokens):
        lemmas = []
        for word, tag in pos_tag(tokens):
            tag = tag[0].lower()
            tag = tag if tag in ["a", "r", "n", "v"] else None
            if not tag:
                lemma = word
            else:
                lemma = lemmatizer.lemmatize(word, tag)
            lemmas.append(lemma)
        return lemmas

Schritt 4: Datenbereitestellung und Modell-Training

Um unser Modell zu trainieren, müssen wir das Korpus, das wir im Schritt 2 gesammelt haben, vorbereiten. Wir müssen die Daten in Fragen-Antwort-Paare aufteilen und die Datenpunkte in zusammenhängenden Vektoren darstellen, die vom Modell verarbeitet werden können.

Fragen-Antwort-Paare

Wir müssen die Dialoge aus einer langen Liste von Zeilen in Frage-Antwort-Paare aufteilen. Dieser Schritt wird als Data Cleaning bezeichnet.

Datenpunkte konvertieren

Wir müssen aus den Informationen für jede Frage-Antwort-Kombination Vektoren als Eingabe für unser ML-Modell erstellen. Wir verwenden für jeden Token in jeder Frage ein Bag-of-Words-Modell. Um aus diesen Vektoren eine Matrix für ML-Algorithmen zu erstellen, werden wir das TfidfVectorizer-Modell aus dem Scikit-Learn-Paket verwenden.

Modelltraining

Wir werden ein ML-Modell trainieren, um die Antworten für die Anfragen vorherzusagen. Wir verwenden das Spacy-Paket, das auf Machine Learning und NLP spezialisiert ist und uns viel Arbeit bei der Entwicklung unserer Modelle abnimmt.

Der vollständige Code für die Datenbereitstellung und das Modelltraining

    import numpy as np
    import json
    import string
    import warnings
    warnings.filterwarnings("ignore")
    from nltk import pos_tag
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.metrics.pairwise import cosine_similarity
    import spacy
    from spacy.lang.en.stop_words import STOP_WORDS
    import requests

    # Laden der Daten vom Korpus
    data = open('movie_lines.txt', encoding='utf-8', errors='ignore').read().split('\n')
    data = [text_clean(line) for line in data]

    # Extrahieren der Frage-Antwort-Paare
    pairs = []
    for i in range(len(data)-1):
        pairs.append(tokenize(data[i]) + tokenize(data[i+1]))

    # Vektorisierung der Frage-Antwort-Paare
    vectors = TfidfVectorizer(tokenizer=lemmatize, stop_words=set(list(string.punctuation) + list(STOP_WORDS)))
    X = vectors.fit_transform(pairs)

    # Definition des Modells
    nlp = spacy.load("en_core_web_md")
    def give_answer(text):
        question_tokens = vectors.transform([text])
        most_similar = (-1, None)
        for i in range(len(X)):
            sim = cosine_similarity(X[i], question_tokens)
            if sim > most_similar[0]:
                most_similar = (sim, i)
        match = pairs[most_similar[1]]
        match = [word for word in match if word not in set(list(string.punctuation) + list(STOP_WORDS))]
        prediction = nlp(" ").join(match)
        return prediction

Schritt 5: Erstellen der Webanwendung und Starten des Chatbots

Um unser Modell zugänglich zu machen und unseren Chatbot zu erstellen, müssen wir eine Webanwendung erstellen, die mithilfe von Flask erstellt wird.

Flask-App erstellen

Wir werden eine kleine Webanwendung erstellen, die auf Anfragen reagiert, die über die URL übergeben werden. Wir können den folgenden Code verwenden, um unsere Flask-App zu erstellen.

    from flask import Flask, request
    app = Flask(__name__)

    @app.route('/')
    def index():
        return "Hello! I'm a chatbot."

    @app.route('/chatbot', methods=['POST'])
    def chatbot():
        user_text = request.form['message']
        answer = give_answer(user_text)
        return answer

Starten der Anwendung

Wir können unseren Chatbot jetzt starten, indem wir die Anwendung ausführen und es von einer URL aus verfügbar machen. 

    app.run()

Schritt 6: Testen des Chatbots

Jetzt, da unser Chatbot bereit ist, können wir ihn testen, indem wir Anfragen an ihn senden und seine Reaktionen überprüfen.

Wir haben gesehen, wie man in dieser Anleitung Schritt für Schritt einen einfachen Chatbot mit Python entwickeln kann. Wichtig ist beim Entwickeln eines Chatbots immer, dass wir Wert auf eine saubere, zuvor durchdachte Datenbereitstellung legen und die Verarbeitung mittels Machine Learning modellieren. Viel Spaß beim Ausprobieren!

Artificial Intelligence Chatbots Python Basics