Frequency Penalty

Frequency Penalty ist ein Parameter, der die Wahrscheinlichkeit reduziert, dass ein Token wiederholt wird, basierend darauf, wie oft es bereits im generierten Text vorkam. Je häufiger ein Token erscheint, desto stärker wird es bestraft.

Was ist Frequency Penalty?

Frequency Penalty wendet eine Strafe auf Tokens an, die bereits im generierten Text erschienen sind. Die Strafe skaliert mit der Häufigkeit des Auftretens - ein Token, das dreimal vorkam, erhält eine dreimal höhere Strafe als ein Token, das nur einmal vorkam.

Einfach erklärt: Stell dir vor, die KI hat eine "Strafpunkte-Liste". Jedes Mal, wenn sie ein Wort verwendet, bekommt dieses Wort Strafpunkte. Bei der nächsten Wortauswahl werden Wörter mit vielen Strafpunkten unwahrscheinlicher gewählt.

Mathematische Grundlage

Die Formel für Frequency Penalty lautet:

logit_neu = logit_original - (frequency_penalty × anzahl_vorkommen)

Dabei gilt:

• logit_neu: Angepasster Logit-Wert des Tokens
• logit_original: Ursprünglicher Logit-Wert vom Modell
• frequency_penalty: Eingestellter Penalty-Wert (z.B. 0.5)
• anzahl_vorkommen: Wie oft das Token bereits vorkam

Wie funktioniert Frequency Penalty?

Beispielberechnung

Nehmen wir an, die KI generiert einen Text über Katzen:

In diesem Beispiel würde "Haustier" jetzt wahrscheinlicher gewählt werden als "Katze", obwohl "Katze" ursprünglich einen höheren Logit hatte.

Anwendungsbereiche

Positive Werte (0.0 bis 2.0)

Positive Frequency Penalty reduziert Wiederholungen und eignet sich für:

• Kreatives Schreiben: Vermeidet repetitive Phrasen und fördert Wortvielfalt
• Artikel und Essays: Verhindert übermäßige Wiederholung von Schlüsselwörtern
• Dialoge: Macht Konversationen natürlicher und weniger redundant
• Produktbeschreibungen: Sorgt für abwechslungsreiche Formulierungen

Negative Werte (-2.0 bis 0.0)

Negative Frequency Penalty fördert Wiederholungen und kann nützlich sein für:

• Technische Dokumentation: Konsistente Verwendung von Fachbegriffen
• Markensprache: Wiederholung wichtiger Markenbegriffe
• Lernmaterialien: Verstärkung von Schlüsselkonzepten
• SEO-Texte: Häufigere Verwendung von Keywords (mit Vorsicht!)

Praktische Code-Beispiele

OpenAI GPT-4

from openai import OpenAI

client = OpenAI()

# Moderate Frequency Penalty für natürliche Texte
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Schreibe einen Blogbeitrag über gesunde Ernährung"
    }],
    frequency_penalty=0.6,  # Reduziert Wiederholungen moderat
    temperature=0.8
)

# Hohe Frequency Penalty für sehr vielfältige Texte
creative_response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Generiere 10 kreative Slogans für ein Café"
    }],
    frequency_penalty=1.5,  # Starke Reduktion von Wiederholungen
    temperature=0.9
)

# Negative Frequency Penalty für konsistente Terminologie
technical_response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Erkläre die Funktionsweise einer REST API"
    }],
    frequency_penalty=-0.3,  # Fördert Wiederholung von Fachbegriffen
    temperature=0.7
)

Vergleich: Mit und ohne Frequency Penalty

# Test der Auswirkungen von Frequency Penalty
prompt = "Erzähle eine Geschichte über einen Wald"

# Ohne Frequency Penalty
without_penalty = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    frequency_penalty=0.0,
    max_tokens=150
)

# Mit hoher Frequency Penalty
with_penalty = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    frequency_penalty=1.2,
    max_tokens=150
)

# Analysiere Wortwiederholungen
def count_word_frequency(text):
    words = text.lower().split()
    frequency = {}
    for word in words:
        frequency[word] = frequency.get(word, 0) + 1
    return frequency

freq_without = count_word_frequency(without_penalty.choices[0].message.content)
freq_with = count_word_frequency(with_penalty.choices[0].message.content)

print("Top wiederholte Wörter OHNE Penalty:")
for word, count in sorted(freq_without.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"{word}: {count}x")

print("
Top wiederholte Wörter MIT Penalty:")
for word, count in sorted(freq_with.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"{word}: {count}x")

Frequency Penalty vs. Presence Penalty

Es ist wichtig, den Unterschied zwischen Frequency und Presence Penalty zu verstehen:

Beispiel: Kombination beider Penalties

# Optimale Kombination für vielfältige, aber kohärente Texte
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Schreibe eine Produktbeschreibung für ein Smartphone"
    }],
    frequency_penalty=0.7,  # Reduziert starke Wiederholungen
    presence_penalty=0.3,   # Fördert leichte Themenvielfalt
    temperature=0.8
)

# Für kreatives Brainstorming
creative = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Generiere innovative Geschäftsideen"
    }],
    frequency_penalty=1.0,  # Starke Variation
    presence_penalty=0.6,   # Neue Themen fördern
    temperature=0.9
)

Optimale Werte finden

Allgemeine Richtlinien

Test-Framework für optimale Werte

def test_frequency_penalty_values(prompt, penalty_range, samples=3):
    """
    Testet verschiedene Frequency Penalty Werte
    """
    results = []
    
    for penalty in penalty_range:
        outputs = []
        metrics = {
            'penalty': penalty,
            'avg_unique_words': 0,
            'avg_repetition_rate': 0,
            'readability': 0
        }
        
        for _ in range(samples):
            response = client.chat.completions.create(
                model="gpt-4",
                messages=[{"role": "user", "content": prompt}],
                frequency_penalty=penalty,
                max_tokens=200
            )
            
            text = response.choices[0].message.content
            outputs.append(text)
            
            # Analysiere Metriken
            words = text.lower().split()
            unique_words = len(set(words))
            total_words = len(words)
            
            metrics['avg_unique_words'] += unique_words / samples
            metrics['avg_repetition_rate'] += (1 - unique_words/total_words) / samples
        
        metrics['samples'] = outputs
        results.append(metrics)
    
    return results

# Teste verschiedene Werte
penalty_values = [-0.5, 0.0, 0.3, 0.6, 0.9, 1.2, 1.5]
results = test_frequency_penalty_values(
    "Beschreibe die Vorteile von Remote-Arbeit",
    penalty_values
)

# Visualisiere Ergebnisse
for result in results:
    print(f"Penalty: {result['penalty']}")
    print(f"Durchschn. einzigartige Wörter: {result['avg_unique_words']:.1f}")
    print(f"Wiederholungsrate: {result['avg_repetition_rate']:.2%}")
    print("-" * 40)

Praktische Anwendungstipps

Do's and Don'ts

Spezialfälle

Listicles und Aufzählungen

# Für Listicles: Mittlere Frequency Penalty
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Liste 10 Tipps für besseren Schlaf auf"
    }],
    frequency_penalty=0.8,  # Vermeidet "Schlaf" in jedem Punkt
    presence_penalty=0.4,   # Fördert verschiedene Aspekte
)

Längere Texte

# Für längere Texte: Vorsichtig mit hohen Werten
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "Schreibe ein 1000-Wort Essay über Klimawandel"
    }],
    frequency_penalty=0.4,  # Niedriger für längere Texte
    max_tokens=1500
)
# Zu hohe Werte können bei langen Texten zu inkohärenten Ergebnissen führen

API-Verfügbarkeit

Fortgeschrittene Techniken

Dynamische Anpassung

class DynamicPenaltyManager:
    """
    Passt Frequency Penalty basierend auf der bisherigen Ausgabe an
    """
    def __init__(self, base_penalty=0.5):
        self.base_penalty = base_penalty
        self.history = []
    
    def calculate_penalty(self, generated_text):
        """
        Berechnet optimale Penalty basierend auf Textanalyse
        """
        words = generated_text.lower().split()
        unique_ratio = len(set(words)) / len(words) if words else 1
        
        # Wenn zu viele Wiederholungen, erhöhe Penalty
        if unique_ratio < 0.7:
            return min(self.base_penalty + 0.3, 2.0)
        # Wenn zu wenig Kohärenz, reduziere Penalty
        elif unique_ratio > 0.95:
            return max(self.base_penalty - 0.2, -0.5)
        else:
            return self.base_penalty
    
    def generate_adaptive(self, prompt, client):
        """
        Generiert Text mit adaptiver Frequency Penalty
        """
        penalty = self.base_penalty
        
        if self.history:
            # Analysiere vorherige Generierungen
            recent_text = " ".join(self.history[-3:])
            penalty = self.calculate_penalty(recent_text)
        
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            frequency_penalty=penalty
        )
        
        generated = response.choices[0].message.content
        self.history.append(generated)
        
        return generated, penalty

# Verwendung
manager = DynamicPenaltyManager(base_penalty=0.6)
for i in range(5):
    text, used_penalty = manager.generate_adaptive(
        f"Schreibe Absatz {i+1} einer Geschichte",
        client
    )
    print(f"Penalty verwendet: {used_penalty}")