Top k

def top_k_sampling(logits, k):
    """
    Wendet Top-k Sampling auf die Logits an
    """
    # Sortiere und behalte nur die k größten Werte
    top_k_logits, top_k_indices = torch.topk(logits, k=k, dim=-1)
    
    # Setze alle anderen Logits auf -infinity
    logits_masked = torch.full_like(logits, float('-inf'))
    logits_masked.scatter_(-1, top_k_indices, top_k_logits)
    
    # Wende Softmax an für Wahrscheinlichkeiten
    probs = torch.softmax(logits_masked, dim=-1)
    
    return probs

import anthropic

client = anthropic.Anthropic()

# Top k für kontrollierte Kreativität
response = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1000,
    top_k=40,  # Nur die 40 wahrscheinlichsten Tokens
    messages=[{
        "role": "user",
        "content": "Schreibe einen kurzen Dialog zwischen zwei Charakteren"
    }]
)

# Sehr niedriges k für präzise Antworten
precise_response = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=100,
    top_k=5,
    messages=[{
        "role": "user",
        "content": "Was ist die Quadratwurzel von 144?"
    }]
)

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-pro')

# Kombination von Top k und Top p
generation_config = genai.types.GenerationConfig(
    top_k=100,   # Erste Filterung: Top 100 Tokens
    top_p=0.8,   # Zweite Filterung: 80% Wahrscheinlichkeitsmasse
    temperature=0.7
)

response = model.generate_content(
    "Erkläre Machine Learning in einfachen Worten",
    generation_config=generation_config
)

# Nur Top k ohne Top p
strict_config = genai.types.GenerationConfig(
    top_k=10,
    top_p=1.0,  # Deaktiviert Top p
    temperature=0.5
)

response = model.generate_content(
    "Liste die Planeten unseres Sonnensystems auf",
    generation_config=strict_config
)

# Test mit verschiedenen k-Werten
k_values = [1, 5, 20, 50, 100]
prompt = "Ein kreativer Name für ein Café wäre"

results = {}
for k in k_values:
    response = client.messages.create(
        model="claude-3-opus-20240229",
        max_tokens=20,
        top_k=k,
        messages=[{"role": "user", "content": prompt}]
    )
    results[k] = response.content[0].text
    
# Ausgabe der Ergebnisse
for k, result in results.items():
    print(f"k={k}: {result}")
    
# Mögliche Ausgabe:
# k=1: "Kaffeepause"  (immer dasselbe)
# k=5: "Bohnenglück"
# k=20: "Traumtasse & Co."
# k=50: "Der verzauberte Löffel"
# k=100: "Wolke 7 - Kaffee & Poesie"

def get_adaptive_k(prompt_type, confidence_threshold=0.8):
    """
    Passt k basierend auf dem Prompt-Typ und der
    Konfidenz der Top-Tokens an
    """
    base_k_values = {
        "factual": 10,
        "creative": 100,
        "code": 20,
        "conversation": 50
    }
    
    # Analysiere die Wahrscheinlichkeitsverteilung
    # Wenn Top-Token sehr wahrscheinlich, reduziere k
    # Wenn Verteilung flach, erhöhe k
    
    return adjusted_k

# Strategie 1: Erst k, dann p (Google Gemini Standard)
# 1. Filtere auf Top 50 Tokens
# 2. Davon nimm die, die 90% Wahrscheinlichkeit abdecken

config_k_then_p = {
    "top_k": 50,
    "top_p": 0.9
}

# Strategie 2: Nur k für harte Begrenzung
config_only_k = {
    "top_k": 30,
    "top_p": 1.0  # Deaktiviert
}

# Strategie 3: Niedriges k mit hohem p
# Für fokussierte aber nicht zu repetitive Ausgaben
config_balanced = {
    "top_k": 20,
    "top_p": 0.95
}

def test_k_values(prompt, k_range, num_samples=5):
    """
    Testet verschiedene k-Werte und bewertet die Ausgaben
    """
    results = []
    
    for k in k_range:
        outputs = []
        for _ in range(num_samples):
            response = generate_with_k(prompt, k)
            outputs.append(response)
        
        # Bewerte Vielfalt
        diversity = calculate_diversity(outputs)
        
        # Bewerte Kohärenz
        coherence = calculate_coherence(outputs)
        
        results.append({
            'k': k,
            'diversity': diversity,
            'coherence': coherence,
            'samples': outputs
        })
    
    return results

# Verwendung
k_range = [5, 10, 20, 40, 80, 160]
results = test_k_values(
    "Schreibe einen Slogan für ein Umweltprojekt",
    k_range
)

# Finde optimales k
optimal_k = find_optimal_k(results, 
    diversity_weight=0.6, 
    coherence_weight=0.4
)