Advanced Level

Natural Language Processing

Verstehen Sie, wie Computer menschliche Sprache verarbeiten, analysieren und verstehen können. Von grundlegenden Textverarbeitungstechniken bis hin zu modernen Transformer-Modellen.

20 min Lesezeit

Praktische Beispiele

Was Sie lernen werden

•Grundlagen der Textverarbeitung und Tokenisierung
•Sentiment Analysis und Named Entity Recognition
•Moderne Transformer-Modelle wie BERT und GPT
•Praktische Implementation mit Python und Hugging Face

Was ist Natural Language Processing?

Natural Language Processing (NLP) ist ein Teilbereich der Künstlichen Intelligenz, der sich mit der Interaktion zwischen Computern und menschlicher Sprache beschäftigt. NLP ermöglicht es Maschinen, menschliche Sprache zu verstehen, zu interpretieren und darauf zu reagieren.

Von einfachen Textanalysewerkzeugen bis hin zu komplexen Chatbots und Übersetzungssystemen - NLP ist die Grundlage für viele moderne AI-Anwendungen, die wir täglich nutzen.

Grundlegende NLP-Konzepte

1. Tokenisierung

Der Prozess der Aufspaltung von Text in einzelne Wörter, Sätze oder andere bedeutungsvolle Einheiten.

import nltk
from nltk.tokenize import word_tokenize, sent_tokenize

text = "Hallo Welt! Wie geht es dir heute?"

# Wort-Tokenisierung
words = word_tokenize(text)
print(words)
# ['Hallo', 'Welt', '!', 'Wie', 'geht', 'es', 'dir', 'heute', '?']

# Satz-Tokenisierung
sentences = sent_tokenize(text)
print(sentences)
# ['Hallo Welt!', 'Wie geht es dir heute?']

2. Part-of-Speech Tagging

Identifizierung von Wortarten (Nomen, Verben, Adjektive, etc.) für grammatikalische Analyse.

import spacy

# Deutsches Sprachmodell laden
nlp = spacy.load("de_core_news_sm")

text = "The quick brown fox jumps over the lazy dog."
doc = nlp(text)

for token in doc:
    print(f"{token.text}: {token.pos_} - {token.tag_}")

# Der: DET - ART
# schnelle: ADJ - ADJA
# braune: ADJ - ADJA
# Fuchs: NOUN - NN
# springt: VERB - VVFIN

3. Named Entity Recognition (NER)

Erkennung und Klassifizierung von Entitäten wie Personen, Orte, Organisationen im Text.

import spacy

nlp = spacy.load("de_core_news_sm")

text = """Apple Inc. wurde 1976 von Steve Jobs in Cupertino gegründet. 
         Heute hat das Unternehmen seinen Hauptsitz in Kalifornien."""

doc = nlp(text)

for ent in doc.ents:
    print(f"{ent.text}: {ent.label_}")

# Apple Inc.: ORG (Organisation)
# 1976: DATE (Datum)
# Steve Jobs: PER (Person)
# Cupertino: LOC (Ort)
# Kalifornien: LOC (Ort)

Sentiment Analysis implementieren

Sentiment Analysis ermöglicht es, die emotionale Tönung von Texten zu bewerten - positiv, negativ oder neutral.

from transformers import pipeline

# Deutsches Sentiment-Modell laden
sentiment_pipeline = pipeline(
    "sentiment-analysis",
    model="oliverguhr/german-sentiment-bert",
    tokenizer="oliverguhr/german-sentiment-bert"
)

texts = [
    "Ich liebe dieses Produkt! Es ist fantastisch.",
    "Das war eine schreckliche Erfahrung.",
    "Das Wetter ist heute okay."
]

for text in texts:
    result = sentiment_pipeline(text)[0]
    print(f"Text: {text}")
    print(f"Sentiment: {result['label']} (Konfidenz: {result['score']:.2f})")
    print("-" * 50)

# Output:
# Text: Ich liebe dieses Produkt! Es ist fantastisch.
# Sentiment: POSITIVE (Konfidenz: 0.99)
# --------------------------------------------------
# Text: Das war eine schreckliche Erfahrung.
# Sentiment: NEGATIVE (Konfidenz: 0.95)
# --------------------------------------------------

Moderne Transformer-Modelle

BERT

Bidirectional Encoder Representations from Transformers - Versteht Kontext in beide Richtungen für besseres Textverständnis.

GPT

Generative Pre-trained Transformer - Spezialisiert auf Textgenerierung und autoregressive Sprachmodellierung.

use BERT for text classification

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import pipeline

# Deutsches BERT-Modell für Klassifikation
model_name = "dbmdz/bert-base-german-cased"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Text-Klassifikationspipeline erstellen
classifier = pipeline(
    "text-classification",
    model="deutsche-telekom/gbert-base-fine-tuned-toxic-text-classification",
    tokenizer=tokenizer
)

# Beispieltext klassifizieren
text = "This is a really interesting article about NLP!"
result = classifier(text)

print(f"Text: {text}")
print(f"Klassifikation: {result[0]['label']}")
print(f"Konfidenz: {result[0]['score']:.3f}")

# Eigene Tokenisierung
tokens = tokenizer.tokenize(text)
print(f"Tokens: {tokens}")
# ['Das', 'ist', 'ein', 'wirklich', 'interessant', '##er', 'Artikel', ...]

Erweiterte NLP-Techniken

Word Embeddings

Vektorielle Darstellung von Wörtern, die semantische Ähnlichkeiten erfassen.

from gensim.models import Word2Vec
from sklearn.feature_extraction.text import TfidfVectorizer

# Word2Vec Modell trainieren
sentences = [
    ["ich", "liebe", "machine", "learning"],
    ["deep", "learning", "ist", "fantastisch"],
    ["nlp", "macht", "fun"],
    ["python", "ist", "great", "für", "ai"]
]

model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)

# Ähnliche Wörter finden
similar_words = model.wv.most_similar("learning", topn=3)
print("Similar words to'learning':", similar_words)

# Word-Vektor abrufen
vector = model.wv["learning"]
print(f"Vektor-Dimension: {len(vector)}")

# TF-IDF Vektorisierung
documents = [
    "Machine Learning ist ein Teilbereich der KI",
    "Deep Learning verwendet neuronale Netzwerke",
    "NLP verarbeitet menschliche Sprache"
]

tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(documents)
print(f"TF-IDF Matrix Shape: {tfidf_matrix.shape}")

Topic Modeling

Automatische Identifizierung von Themen in großen Textsammlungen mit LDA.

from gensim import corpora, models
from gensim.utils import simple_preprocess

# Beispieldokumente
documents = [
    "Machine Learning Algorithmen lernen aus Daten",
    "Deep Learning uses neural networks for complex tasks",
    "NLP enables computers to understand human speech",
    "Computer Vision analysiert und interpretiert Bilder",
    "Reinforcement Learning lernt durch Belohnung und Bestrafung"
]

# Preprocessing
texts = [simple_preprocess(doc) for doc in documents]

# Dictionary und Corpus erstellen
dictionary = corpora.Dictionary(texts)
corpus = [dictionary.doc2bow(text) for text in texts]

# LDA Modell trainieren
lda_model = models.LdaModel(
    corpus=corpus,
    id2word=dictionary,
    num_topics=2,
    random_state=42,
    passes=10,
    alpha='auto',
    per_word_topics=True
)

# Topics anzeigen
for idx, topic in lda_model.print_topics(-1):
    print(f'Topic {idx}: {topic}')

NLP Best Practices

✓Data quality: Use clean, representative training data
✓Preprocessing: Konsistente Textvorverarbeitung (Normalisierung, Tokenisierung)
✓Evaluation: Use multiple metrics for comprehensive evaluation
✓Multilingual: Select language-specific models for better results