# Vollständige Text-Preprocessing Pipeline:

import re
from bs4 import BeautifulSoup

def preprocess_text(text: str) -> str | None:
    # 1. Encoding normalisieren
    text = text.encode('utf-8', errors='ignore').decode('utf-8')
    
    # 2. HTML-Tags entfernen
    text = BeautifulSoup(text, 'html.parser').get_text()
    
    # 3. URLs entfernen (optional)
    text = re.sub(r'https?://\S+', '[URL]', text)
    
    # 4. Whitespace normalisieren
    text = ' '.join(text.split())
    
    # 5. Sonderzeichen bereinigen (vorsichtig!)
    # Achtung: Nicht zu aggressiv – Satzzeichen sind wichtig!
    text = re.sub(r'[^\w\s\.,!?;:\'\"()\-–—€$%@#]', '', text)
    
    # 6. Längen filtern
    word_count = len(text.split())
    if word_count < 5:
        return None  # Zu kurz
    if word_count > 512:
        text = ' '.join(text.split()[:512])  # Truncate
    
    return text.strip()

# Labels normalisieren
def normalize_label(label: str) -> str:
    return label.strip().lower().replace(' ', '_')

# Exact Deduplication:
import hashlib

def deduplicate_exact(dataset: list[dict]) -> list[dict]:
    seen = set()
    unique = []
    for item in dataset:
        h = hashlib.md5(item['text'].encode()).hexdigest()
        if h not in seen:
            seen.add(h)
            unique.append(item)
    return unique

# Fuzzy Deduplication (ähnliche Texte):
# Nutze MinHash / LSH für effiziente Near-Duplicate Detection
# Library: datasketch
from datasketch import MinHash, MinHashLSH
# → findet auch Duplikate mit kleinen Abweichungen

# Tokenisierung mit dem richtigen Tokenizer:
from transformers import AutoTokenizer

# WICHTIG: Immer den Tokenizer des Basismodells nutzen!
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")

# Token-Länge messen VOR dem Training:
lengths = [len(tokenizer(text)['input_ids']) for text in texts]
print(f"Median: {sorted(lengths)[len(lengths)//2]} Token")
print(f"P95:    {sorted(lengths)[int(len(lengths)*0.95)]} Token")
print(f"Max:    {max(lengths)} Token")

# max_length basierend auf P95 wählen (nicht Max!)
# → spart Speicher, verliert nur 5% der Länge

# Klassifikation (JSON):
{"text": "Das Produkt ist toll!", "label": "positiv"}
{"text": "Lieferung kam nie an.", "label": "negativ"}

# Instruction Following / Chat (JSON):
{"instruction": "Übersetze auf Englisch:", 
 'input': "Das Wetter ist schön.",
 'output': "The weather is nice."}

# NER (JSON mit Spans):
{"text": "Apple wurde 1976 in Cupertino gegründet.",
 'entities': [{"start": 0, "end": 5, "label": "ORG"},
               {"start": 22, "end": 31, "label": "LOC"}]}

Empfohlene Augmentation-Pipeline:

  1. Originaldaten bereinigen (Preprocessing)
  2. Back-Translation für wichtige/seltene Klassen (×2)
  3. LLM-Paraphrase für kritische Beispiele (×2–3)
  4. Synonym-Replacement für schnelle Vervielfachung (×1)

  Ergebnis: Dataset-Größe ×5–8 mit hoher Qualität

Wichtig: Augmentierte Daten IMMER separat labeln
  → z.B. source: "original" vs. source: "augmented"
  → ermöglicht Qualitäts-Analyse nach dem Training

# Imbalance messen:
import pandas as pd
df = pd.read_csv('train.csv')
counts = df['label'].value_counts()
print(counts)
# negativ    4750
# positiv     250
# → Ratio 19:1 → starke Imbalance!

# Faustregel:
# < 3:1    → meist okay, kein Balancing nötig
# 3:1–10:1 → Balancing empfohlen
# > 10:1   → Balancing dringend nötig

# Imbalance Ratio:
ratio = counts.max() / counts.min()
print(f"Imbalance Ratio: {ratio:.1f}:1")