Natural Language Processing für nicht-englische Sprachen: Herausforderungen und Lösungsansätze

import spacy

# Laden des deutschen Sprachmodells
nlp = spacy.load('de_core_news_sm')

# Beispieltext
text = "Die Katze sitzt auf dem Dach des Hauses."
doc = nlp(text)

# Tokenisierung und POS-Tagging
print("=== Detailed Spacy Analysis ===")
for token in doc:
    print(f"""
    Token: {token.text}
    POS: {token.pos_} (Details: {token.tag_})
    Lemma: {token.lemma_}
    Abhängigkeit: {token.dep_}
    """)

# Dependency Parsing visualisieren
from spacy import displacy
html = displacy.render(doc, style="dep")
print("\nDependency Parse Struktur wurde generiert")

# Named Entity Recognition
print("\n=== Named Entities ===")
for ent in doc.ents:
    print(f"Entity: {ent.text}, Label: {ent.label_} ({spacy.explain(ent.label_)})")

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
import nltk

def preprocess_german_text(text):
    """
    Umfassende Vorverarbeitung für deutschen Text
    """
    # Satztokenisierung
    sentences = sent_tokenize(text, language='german')
    
    # Stoppwörter laden
    stop_words = set(stopwords.words('german'))
    processed_sentences = []
    
    for sentence in sentences:
        # Tokenisierung
        tokens = word_tokenize(sentence, language='german')
        
        # Kleinschreibung und Filterung
        tokens = [word.lower() for word in tokens 
                 if word.isalpha() and word.lower() not in stop_words]
        
        processed_sentences.append(tokens)
    
    return processed_sentences

# Beispiel
text = """
Der schnelle braune Fuchs springt über den faulen Hund. 
Das Wetter ist heute besonders schön!
"""

processed_text = preprocess_german_text(text)
print("Verarbeitete Sätze:", processed_text)

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification

class GermanSentimentAnalyzer:
    def __init__(self):
        self.model_name = "oliverguhr/german-sentiment-bert"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
        self.pipeline = pipeline(
            "sentiment-analysis",
            model=self.model,
            tokenizer=self.tokenizer
        )
    
    def analyze(self, texts):
        """
        Führt Sentiment-Analyse für deutsche Texte durch
        """
        if isinstance(texts, str):
            texts = [texts]
        
        results = self.pipeline(texts)
        
        return [{
            'text': text,
            'sentiment': result['label'],
            'confidence': round(result['score'], 4)
        } for text, result in zip(texts, results)]

# Beispielverwendung
analyzer = GermanSentimentAnalyzer()
test_texts = [
    "Dieser Film war wirklich fantastisch!",
    "Die Qualität war leider sehr enttäuschend.",
    "Das Produkt ist okay, aber der Preis zu hoch."
]

results = analyzer.analyze(test_texts)
for result in results:
    print(f"\nText: {result['text']}")
    print(f"Sentiment: {result['sentiment']}")
    print(f"Konfidenz: {result['confidence']}")

from compound_split import compound_split
import spacy

class GermanCompoundAnalyzer:
    def __init__(self):
        self.nlp = spacy.load('de_core_news_sm')
    
    def analyze_compound(self, word):
        """
        Analysiert ein deutsches Kompositum
        """
        # Basis-Splitting
        splits = compound_split(word, language='de')
        
        # Linguistische Analyse der Teile
        analysis = []
        for part in splits:
            doc = self.nlp(part)
            analysis.append({
                'part': part,
                'pos': doc[0].pos_,
                'lemma': doc[0].lemma_
            })
        
        return {
            'original': word,
            'parts': analysis,
            'count': len(splits)
        }

# Beispielverwendung
analyzer = GermanCompoundAnalyzer()
compounds = [
    'Bundesausbildungsförderungsgesetz',
    'Kindergartentisch',
    'Arbeitsplatzbeschreibung'
]

for word in compounds:
    analysis = analyzer.analyze_compound(word)
    print(f"\nAnalyse von '{analysis['original']}':")
    print(f"Anzahl Teile: {analysis['count']}")
    for part in analysis['parts']:
        print(f"- {part['part']} ({part['pos']}, Lemma: {part['lemma']})")

# Beispieltext
text = """
Der alte Mann ging durch den verschneiten Wald. 
Die Kinder spielten mit ihren neuen Spielzeugen.
Die Häuser waren mit Lichtern geschmückt.
"""

doc = nlp(text)

# Lemmatisierung und morphologische Analyse
print("=== Lemmatisierung und Morphologie ===")
for token in doc:
    print(f"""
    Wort: {token.text}
    Lemma: {token.lemma_}
    Wortart: {token.pos_}
    Morphologische Details: {token.morph}
    """)

# Beispielausgabe für "Häuser":
# Wort: Häuser
# Lemma: Haus
# Wortart: NOUN
# Morphologische Details: Case=Nom|Gender=Neut|Number=Plur

# Beispieltext mit verschiedenen Entitäten
text_ner = """
Die Deutsche Bank in Frankfurt hat zusammen mit der Berliner Sparkasse und 
dem Vorstandsvorsitzenden Thomas Müller ein neues Projekt in München gestartet. 
Das Bundesamt für Sicherheit in der Informationstechnik (BSI) in Bonn 
unterstützt die Initiative.
"""

doc = nlp(text_ner)

# Entitäten ausgeben
print("\n=== Named Entities ===")
for ent in doc.ents:
    print(f"""
    Text: {ent.text}
    Label: {ent.label_}
    Erklärung: {spacy.explain(ent.label_)}
    """)