Natural Language Processing (NLP)

1. Tokenisierung: Aufteilung des Textes in kleinere Einheiten wie Wörter oder Sätze.
2. Entfernung von Stoppwörtern: Entfernung häufiger Wörter, die keinen wesentlichen Beitrag zur Bedeutung des Textes leisten.
3. Stemming und Lemmatisierung: Reduktion von Wörtern auf ihre Grundform.
4. Konvertierung in Kleinbuchstaben: Vereinheitlichung des Textes durch Umwandlung in Kleinbuchstaben.
5. Entfernung von Sonderzeichen: Entfernung von Satzzeichen und anderen nicht-alphanumerischen Zeichen.

import tensorflow as tf
import tensorflow_datasets as tfds
import re
import numpy as np

# Beispieltext
text = "Natural Language Processing (NLP) befasst sich mit der Interaktion zwischen Computern und menschlicher Sprache."

# Tokenisierung
tokens = tf.keras.preprocessing.text.text_to_word_sequence(text)
print("Tokens:", tokens)

# Entfernung von Stoppwörtern
stopwords = set(tfds.features.text.SubwordTextEncoder.build_from_corpus(
    ['der', 'die', 'und', 'mit', 'sich', 'auf', 'ist'], target_vocab_size=2**15).decode(1))

tokens = [word for word in tokens if word not in stopwords]
print("Tokens ohne Stoppwörter:", tokens)

# Konvertierung in Kleinbuchstaben und Entfernung von Sonderzeichen
tokens = [re.sub(r'[^\w\s]', '', word.lower()) for word in tokens]
print("Tokens nach Vorverarbeitung:", tokens)

3. Embeddings

Embeddings sind Vektordarstellungen von Wörtern, die deren semantische Bedeutung in einem kontinuierlichen Vektorraum erfassen. Zu den bekanntesten Embedding-Methoden gehören Word2Vec und GloVe.

3.1 Word2Vec

Word2Vec erstellt Wortvektoren, indem es das Kontextfenster eines Wortes in einem Textkorpus betrachtet. Es gibt zwei Hauptansätze: Continuous Bag of Words (CBOW) und Skip-gram.

Beispiel: Verwendung von Word2Vec in TensorFlow

import gensim.downloader as api

# Laden des vortrainierten Word2Vec-Modells
word2vec_model = api.load("word2vec-google-news-300")

# Anzeigen des Vektors für ein bestimmtes Wort
vector = word2vec_model['computer']
print("Vektor für 'computer':", vector)

3.2 GloVe

GloVe (Global Vectors for Word Representation) ist eine weitere Technik zur Erstellung von Wortvektoren, die auf globalen Wort-Kofrequenzen in einem Textkorpus basiert.

Beispiel: Verwendung von GloVe in TensorFlow

import numpy as np

# Laden von GloVe-Vektoren
embeddings_index = {}
with open('glove.6B.100d.txt', encoding='utf-8') as f:
    for line in f:
        values = line.split()
        word = values[0]
        vector = np.asarray(values[1:], dtype='float32')
        embeddings_index[word] = vector

# Anzeigen des Vektors für ein bestimmtes Wort
vector = embeddings_index.get('computer')
print("Vektor für 'computer':", vector)

3.3 Wann sollte man Word2Vec oder GloVe verwenden?

3.3.1 Word2Vec:

• Kontextbezogene Aufgaben: Word2Vec ist besonders nützlich, wenn Sie den Kontext eines Wortes in einem Satz oder Dokument erfassen möchten. Es verwendet lokale Kontextinformationen, um die Vektoren zu generieren.
• Anpassung an spezifische Domänen: Wenn Sie ein Modell für eine spezifische Domäne (z.B. medizinische Texte, juristische Dokumente) anpassen möchten, können Sie Word2Vec auf Ihrem eigenen Korpus trainieren, um domänenspezifische Bedeutungen zu erfassen.

Beispiel: Verwendung von Word2Vec für sentimentale Analysen in Produktbewertungen, wo der Kontext der Wörter in den Bewertungen wichtig ist.

import gensim
from gensim.models import Word2Vec

# Training eines Word2Vec-Modells auf einem eigenen Textkorpus
sentences = [["Ich", "liebe", "dieses", "Produkt"], ["Dieses", "Produkt", "ist", "furchtbar"]]
word2vec_model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)

3.3.2 GloVe:

• Globale Kofrequenz-Informationen: GloVe nutzt globale Kofrequenzstatistiken, um Wortvektoren zu erzeugen. Es ist besonders nützlich, wenn Sie große Korpora mit verschiedenen Kontexten haben, da es die globale Struktur der Daten besser erfasst.
• Vortrainierte Modelle: Wenn Sie schnell starten möchten, können Sie vortrainierte GloVe-Modelle verwenden, die auf großen Korpora wie Wikipedia oder Common Crawl trainiert wurden.

Beispiel: Verwendung von GloVe für Named Entity Recognition (NER) in allgemeinen Texten, wo globale Bedeutungen und Kofrequenzen wichtig sind.

import numpy as np

# Laden von vortrainierten GloVe-Vektoren
embeddings_index = {}
with open('glove.6B.100d.txt', encoding='utf-8') as f:
    for line in f:
        values = line.split()
        word = values[0]
        vector = np.asarray(values[1:], dtype='float32')
        embeddings_index[word] = vector

4. Sequenzmodelle

4.1 Beispiel: Aufbau eines LSTM-Modells in TensorFlow für Textklassifikation

import tensorflow as tf
from tensorflow.keras import layers, models, preprocessing

# Beispieltextdaten
texts = ["Natural Language Processing macht Spaß!", "TensorFlow ist ein leistungsstarkes Werkzeug."]
labels = [1, 0]

# Tokenisierung und Sequenzierung
tokenizer = preprocessing.text.Tokenizer(num_words=10000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
padded_sequences = preprocessing.sequence.pad_sequences(sequences, maxlen=10)

# Aufbau des LSTM-Modells
model = models.Sequential([
    layers.Embedding(input_dim=10000, output_dim=64, input_length=10),
    layers.LSTM(64),
    layers.Dense(1, activation='sigmoid')
])

# Kompilieren des Modells
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Trainieren des Modells
model.fit(padded_sequences, labels, epochs=10)

In diesem Beispiel erstellen wir ein LSTM-Modell zur Klassifikation von Texten. Das Modell besteht aus einer Embedding-Schicht, einer LSTM-Schicht und einer Ausgabeschicht.

4.2 Wann sollte man RNN, LSTM oder GRU verwenden?

4.2.1 RNN (Recurrent Neural Networks):

• Kurze Sequenzen: RNNs sind geeignet für Aufgaben mit kurzen Sequenzen und weniger komplexen Abhängigkeiten.
• Einfache Implementierung: Sie sind einfacher zu implementieren und zu verstehen, eignen sich aber nicht gut für lange Sequenzen aufgrund des Problems des verschwindenden Gradienten.

Beispiel: Verwendung von RNNs für die Erkennung von Handschriften oder einfache Spracherkennungsaufgaben.

from tensorflow.keras import layers, models

model = models.Sequential([
    layers.SimpleRNN(50, activation='relu', input_shape=(timesteps, input_dim)),
    layers.Dense(1, activation='sigmoid')
])

4.2.2 LSTM (Long Short-Term Memory):

• Lange Sequenzen: LSTMs sind ideal für Aufgaben mit langen Sequenzen und komplexen Abhängigkeiten. Sie sind in der Lage, Informationen über lange Zeiträume zu speichern.
• Zeitreihenanalyse und Vorhersage: Sie werden häufig in Zeitreihenanalyse, maschineller Übersetzung und Textgenerierung verwendet.

Beispiel: Verwendung von LSTMs für die Vorhersage von Aktienkursen oder für maschinelle Übersetzungsmodelle.

model = models.Sequential([
    layers.LSTM(50, activation='tanh', input_shape=(timesteps, input_dim)),
    layers.Dense(1, activation='sigmoid')
])

4.2.3 GRU (Gated Recurrent Unit):

• Effiziente Berechnung: GRUs sind eine vereinfachte Version von LSTMs und benötigen weniger Rechenleistung, sind dabei aber fast genauso leistungsfähig.
• Kompromiss zwischen Leistung und Komplexität: Sie bieten einen guten Kompromiss zwischen der Fähigkeit, lange Abhängigkeiten zu lernen, und der Rechenkomplexität.

Beispiel: Verwendung von GRUs für die Sentiment-Analyse in Social-Media-Posts oder für Chatbots.

model = models.Sequential([
    layers.GRU(50, activation='tanh', input_shape=(timesteps, input_dim)),
    layers.Dense(1, activation='sigmoid')
])