Einschnitt in Zwei

Einführung

In diesem Projekt lernst du, wie man einen Subword-Tokenizer implementiert, was ein entscheidender Schritt bei natürlichen Sprachverarbeitungstasks ist. Tokenisierung ist der Prozess, bei dem eine Zeichenkette in kleinere Einheiten, die Tokens genannt werden, aufgeteilt wird, die einzelne Wörter, Zeichen oder Subwörter sein können. Dieses Projekt konzentriert sich auf die Subword-Ebene der Tokenisierung, die in der englischen und anderen lateinischen Sprachen häufig verwendet wird.

👀 Vorschau

['I','studied', 'in', 'LabEx', 'for', '1', '0', 'days', 'and', 'completed', 'the', '[UNK]', '[UNK]', 'course', '.']

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie man eine Subword-Tokenizer-Funktion implementiert, die die Zeichenebene der Tokenisierung mit dem greedy longest-match-first-Algorithmus durchführt
• Wie man den Subword-Tokenizer mit einem bereitgestellten Beispiel testet und die Ausgabe analysiert
• Wie man den Tokenisierungsalgorithmus und seine Implementierung versteht

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Die Wichtigkeit der Tokenisierung bei natürlichen Sprachverarbeitungstasks zu verstehen
• Ein Kernkomponenten eines natürlichen Sprachverarbeitungspipelines zu implementieren
• Unterschiede zwischen Zeichenebene und Subword-Ebene der Tokenisierung zu erkennen
• Den greedy longest-match-first-Algorithmus anzuwenden, um Text in Subwörter zu tokenisieren

Skills Graph

Verstehen des Tokenisierungsprozesses

In diesem Schritt wirst du über den Tokenisierungsprozess und seine Wichtigkeit bei natürlichen Sprachverarbeitungstasks lernen.

Tokenisierung ist der Prozess, bei dem eine Zeichenkette in kleinere Einheiten, die Tokens genannt werden, aufgeteilt wird. Diese Tokens können einzelne Wörter, Zeichen oder Subwörter sein, je nachdem welche spezifische Tokenisierungsmethode verwendet wird.

Bei natürlichen Sprachverarbeitungstasks unterstützen die meisten maschinellen Lernmodelle keine Zeichenkettendaten direkt. Damit die Modelle effektiv lernen können, müssen Zeichenkettendaten numerisiert werden, was ein Prozess genannt wird, der als Tokenisierung bekannt ist. Die Tokenisierung ist auch die Vorbereitung für die Numerisierung, und die Numerisierung erfordert eine Zuordnung, die von einer Zuordnungstabelle bereitgestellt wird.

Die Zeichenebene der Tokenisierung ist eine Methode, die Zeichenketten basierend auf den kleinsten Symbolen einer Sprache aufteilt und wird häufig bei der englischen Tokenisierung verwendet.

Die Subword-Ebene der Tokenisierung wird häufig in der englischen und anderen lateinischen Sprachen verwendet und ist eine Verbesserung gegenüber der Wortebene der Tokenisierung.

Implementiere den Subword-Tokenizer

In diesem Schritt wirst du eine Subword-Tokenizer-Funktion implementieren, die die Zeichenebene der Tokenisierung für englische Wörter mit dem greedy longest-match-first-Algorithmus durchführt. Diese Funktion entfernt auch alle Symbole, einschließlich Leerzeichen, aus der Eingabezeichenkette.

Öffne die Datei subword_tokenizer.py in deinem Code-Editor. Diese Datei enthält einen Skelett der subword_tokenizer()-Funktion. Deine Aufgabe besteht darin, die fehlenden Teile der Funktion auszufüllen.

Die Funktion sollte folgende Anforderungen erfüllen:

1. Die Funktion sollte eine Zeichenkette als Eingabe akzeptieren. Diese Funktion erhält eine Zeichenkette, die englische Zeichen, Zahlen und Satzzeichen enthält. Die Zeichenkette wurde dir zur Verfügung gestellt, und du kannst den Inhalt der Zeichenkette nicht ändern.
2. Die Funktion sollte das Tokenisierungsresultat als Liste zurückgeben.

Hier ist der vollständige Code für die subword_tokenizer()-Funktion:

import re

def subword_tokenizer(text, vocab) -> list:
    """
    Tokenisiert die Eingabetext in Subwörter basierend auf einem bereitgestellten Vokabular.

    Args:
    - text (str): Eingabetext, der tokenisiert werden soll.
    - vocab (list): Vokabularliste, die Subwörter enthält.

    Returns:
    - list: Liste von Subword-Token.
    """

    def is_in_vocab(word) -> bool:
        """
        Überprüft, ob ein gegebenes Wort im Vokabular enthalten ist.

        Args:
        - word (str): Wort, das überprüft werden soll.

        Returns:
        - bool: True, wenn das Wort im Vokabular enthalten ist, andernfalls False.
        """
        return word in vocab

    def find_longest_match(word) -> tuple:
        """
        Findet das längste passende Subwort für ein gegebenes Wort im Vokabular.

        Args:
        - word (str): Wort, für das ein Match gefunden werden soll.

        Returns:
        - tuple: Ein Tupel, das das längste passende Subwort und den verbleibenden Teil des Worts enthält.
        """
        for i in range(len(word), 0, -1):
            subword = word[:i]
            if is_in_vocab(subword):
                return subword, word[i:]
        return "[UNK]", ""

    tokens = []
    ## Entferne nicht-alphanumerische Zeichen und teile den Text in Wörter auf
    words = re.findall(r"\b\w+\b", text)

    for word in words:
        while word:
            subword, remaining = find_longest_match(word)
            tokens.append(subword)
            word = remaining

    return tokens


if __name__ == "__main__":
    ## Beispielverwendung:
    vocab = [
        "I",
        "studied",
        "in",
        "LabEx",
        "for",
        "1",
        "0",
        "days",
        "and",
        "completed",
        "the",
        "course",
    ]
    text = "I studied in LabEx for 10 days and completed the TensorFlow Serving course."

    tokenization_result = subword_tokenizer(text, vocab)
    print(tokenization_result)

Teste den Subword-Tokenizer

In diesem Schritt wirst du die subword_tokenizer()-Funktion mit dem bereitgestellten Beispiel testen und die Ausgabe verifizieren.

Führe das Skript subword_tokenizer.py in deinem Terminal aus:

python3 subword_tokenizer.py

Die Ausgabe sollte ähnlich der folgenden sein:

['I','studied', 'in', 'LabEx', 'for', '1', '0', 'days', 'and', 'completed', 'the', '[UNK]', '[UNK]', 'course', '.']

Beobachte die Ausgabe und vergewissere dich, dass der Tokenisierungsprozess wie erwartet funktioniert. Die Funktion sollte den Eingabetext in eine Liste von Subwörtern tokenisieren, wobei unbekannte Wörter durch das [UNK]-Token dargestellt werden.

Verstehe den Tokenisierungsalgorithmus

In diesem Schritt wirst du tiefer in die Implementierung der subword_tokenizer()-Funktion eintauchen und den Tokenisierungsalgorithmus verstehen.

Die subword_tokenizer()-Funktion verwendet einen greedy longest-match-first-Algorithmus, um den Eingabetext zu tokenisieren. Hier ist, wie der Algorithmus funktioniert:

1. Die Funktion entfernt zunächst alle nicht-alphanumerischen Zeichen aus dem Eingabetext und teilt den Text in einzelne Wörter auf.
2. Für jedes Wort versucht die Funktion, das längste passende Subwort im bereitgestellten Vokabular zu finden.
3. Wenn ein Subwort im Vokabular gefunden wird, wird es zur Liste der Tokens hinzugefügt. Wenn kein Subwort gefunden wird, wird das [UNK]-Token zur Liste hinzugefügt.
4. Der Prozess wird fortgesetzt, bis alle Wörter im Eingabetext tokenisiert sind.

Die is_in_vocab()-Funktion ist eine Hilfsfunktion, die überprüft, ob ein gegebenes Wort im bereitgestellten Vokabular vorhanden ist.

Die find_longest_match()-Funktion ist der Kern des Tokenisierungsalgorithmus. Sie iteriert durch das Wort, beginnend mit dem längstmöglichen Subwort, und überprüft, ob das aktuelle Subwort im Vokabular ist. Wenn ein Match gefunden wird, gibt sie das Subwort und den verbleibenden Teil des Worts zurück. Wenn kein Match gefunden wird, gibt sie das [UNK]-Token und einen leeren String zurück.

Das Verständnis des Tokenisierungsalgorithmus wird dir helfen, den Subword-Tokenizer weiter zu verbessern oder ihn auf verschiedene Anwendungsfälle anzupassen.

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Labs absolvieren, um deine Fähigkeiten zu verbessern.