Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Penalità di presenza e di frequenza

Lezione 14 di 16 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Combattere le ripetizioni
  2. Penalità di presenza: una sanzione fissa
  3. Penalità di frequenza: una sanzione cumulativa
  4. Configurazioni per intento
  5. Diagnostica prima di regolare
  6. Due modi per rovinare tutto
  7. Punti chiave

Combattere le ripetizioni

I modelli linguistici hanno una tendenza naturale a ripetersi. Questo si manifesta in tre modi riconoscibili: la stessa parola che riecheggia in un paragrafo, strutture frasali identiche che si ripetono riga dopo riga, oppure interi paragrafi riformulati senza aggiungere nuove informazioni. La temperatura non risolve il problema: aumentare la casualità globale degrada la coerenza senza garantire varietà lessicale. I parametri presence_penalty e frequency_penalty offrono un controllo molto più fine, a patto di capire cosa li distingue.

Penalità di presenza: una sanzione fissa

La penalità di presenza applica una sanzione singola e fissa a ogni token apparso almeno una volta nella risposta generata. Non importa se il token è stato usato una volta o quindici: la penalità rimane identica. L’effetto è spingere il modello ad attingere a parole non ancora utilizzate, ampliando così il vocabolario della risposta. Chiedi dieci aggettivi per descrivere il mare e vedrai subito la differenza: senza penalità, le varianti tendono a ruotare attorno a tre o quattro campi semantici.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

# Nessuna penalità — il modello potrebbe ripetersi
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "List 10 adjectives to describe the sea."}],
    presence_penalty=0.0
)
print("No penalty:", response.choices[0].message.content)

# Con penalità di presenza — favorisce la diversità del vocabolario
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "List 10 adjectives to describe the sea."}],
    presence_penalty=1.0
)
print("With penalty:", response.choices[0].message.content)

Il parametro accetta valori da -2.0 a 2.0, con 0.0 come default. Un valore positivo penalizza i token già visti, producendo maggiore diversità; un valore negativo fa l’opposto e favorisce la ripetizione, utile solo in casi molto specifici come la generazione di ritornelli o formule ripetute. In produzione, resta nell’intervallo 0.0–1.5.

Penalità di frequenza: una sanzione cumulativa

La penalità di frequenza funziona diversamente: la sanzione è cumulativa e cresce con il numero di occorrenze del token. Più una parola viene ripetuta, meno diventa probabile alla successiva occorrenza. Mentre la penalità di presenza amplia il vocabolario, questa rallenta progressivamente le parole che tornano troppo spesso, risultando particolarmente efficace contro i loop nei testi lunghi.

# Nessuna penalità di frequenza
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Write a paragraph about artificial intelligence."}],
    frequency_penalty=0.0
)
print("No penalty:", response.choices[0].message.content)

# Con penalità di frequenza — riduce i token molto frequenti
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Write a paragraph about artificial intelligence."}],
    frequency_penalty=0.8
)
print("With penalty:", response.choices[0].message.content)

Come il precedente, varia da -2.0 a 2.0 con default 0.0; un valore positivo penalizza sempre più i token frequenti. Tuttavia, il suo intervallo utile in produzione è più stretto: 0.0–1.0, perché la sua natura cumulativa lo rende più aggressivo a parità di valori.

La tabella seguente riassume le differenze.

CaratteristicaPenalità di presenzaPenalità di frequenza
AttivazioneAlla 1ª occorrenzaA ogni occorrenza
CrescitaFissa (stessa penalità)Cumulativa (aumenta)
EffettoDiversità del vocabolarioRiduce le ripetizioni
Ideale perEsplorare nuovi argomentiEvitare loop lessicali

Configurazioni per intento

In pratica, regoli questi due parametri insieme alla temperatura, in base a ciò che la tua applicazione deve produrre. Un chatbot ha bisogno di una leggera diversità e di zero ripetizioni, niente di più. La scrittura creativa spinge la penalità di presenza per arricchire il vocabolario, mantenendo moderata quella di frequenza. L’estrazione di dati, invece, disabilita entrambe: lì la ripetizione è legittima e lo stesso nome di campo può dover apparire dieci volte. Il riassunto sta nel mezzo, con una penalità sufficiente a evitare il copia-incolla del testo sorgente.

# Chatbot — leggera diversità, nessuna ripetizione
CONFIG_CHATBOT = {
    "temperature": 0.7,
    "presence_penalty": 0.3,
    "frequency_penalty": 0.3
}

# Scrittura creativa — vocabolario ricco, nessun loop
CONFIG_CREATIF = {
    "temperature": 0.9,
    "presence_penalty": 0.8,
    "frequency_penalty": 0.5
}

# Estrazione dati — nessuna penalità (risposta esatta)
CONFIG_EXTRACTION = {
    "temperature": 0.0,
    "presence_penalty": 0.0,
    "frequency_penalty": 0.0
}

# Riassunto — un po' di diversità per evitare copia-incolla
CONFIG_RESUME = {
    "temperature": 0.3,
    "presence_penalty": 0.2,
    "frequency_penalty": 0.4
}

Diagnostica prima di regolare

Regolare questi parametri “a orecchio” porta rapidamente a aggiustamenti arbitrari. Misura invece. La funzione seguente calcola un rapporto di diversità (parole uniche su totale) e isola le parole più lunghe di tre lettere che appaiono più di due volte, filtrando così articoli e preposizioni la cui ripetizione è normale. Eseguila sullo stesso prompt con tre valori di frequency_penalty e vedrai il rapporto salire, poi stabilizzarsi: quel plateau indica il valore oltre il quale non guadagni più nulla.

def analyze_repetition(text: str) -> dict:
    """Analizza il tasso di ripetizione del testo generato."""
    words = text.lower().split()
    total = len(words)
    unique = len(set(words))

    # Conta le parole che appaiono più di 2 volte
    from collections import Counter
    counts = Counter(words)
    repeated = {w: c for w, c in counts.items() if c > 2 and len(w) > 3}

    return {
        "total_words": total,
        "unique_words": unique,
        "diversity_ratio": round(unique / total, 3) if total > 0 else 0,
        "repeated_words": dict(sorted(repeated.items(), key=lambda x: -x[1])[:10])
    }

# Test con e senza penalità
for fp in [0.0, 0.5, 1.0]:
    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": "Write a long paragraph about renewable energy."}],
        max_tokens=500,
        frequency_penalty=fp
    )
    text = response.choices[0].message.content
    stats = analyze_repetition(text)
    print(f"frequency_penalty={fp} | Diversity: {stats['diversity_ratio']} | Repeated: {stats['repeated_words']}")

Due modi per rovinare tutto

Il primo è esagerare. Oltre 1.5, il modello evita così tanto le parole comuni da sostituirle con alternative inappropriate: il testo diventa sconnesso, costellato di termini rari usati male. In una spiegazione del teorema di Pitagora, penalità a 2.0 impediscono al modello di ripetere “lato” e “triangolo”, proprio le parole di cui la dimostrazione ha bisogno.

# SBAGLIATO — penalità troppo forte
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Explain the Pythagorean theorem."}],
    presence_penalty=2.0,
    frequency_penalty=2.0
)
# Risultato: testo sconnesso, termini rari usati male

Il secondo è combinare penalità elevate con temperatura alta. Ogni meccanismo aggiunge la sua quota di casualità allo stesso processo di selezione e la loro sovrapposizione produce un testo quasi casuale. Come per temperature e top_p, la disciplina è regolare un parametro alla volta.

# DA EVITARE — troppa casualità
{"temperature": 1.5, "presence_penalty": 1.5, "frequency_penalty": 1.5}

# CORRETTO — regola un parametro alla volta
{"temperature": 0.7, "presence_penalty": 0.5, "frequency_penalty": 0.3}

Punti chiave

  • Penalità di presenza: sanzione fissa non appena un token è visto — amplia il vocabolario
  • Penalità di frequenza: sanzione cumulativa proporzionale alla frequenza — combatte i loop
  • Entrambe variano da -2.0 a 2.0, default 0.0
  • In produzione, per la maggior parte dei casi, resta nell’intervallo 0.0–1.0
  • Non combinare valori alti con temperatura alta
  • Disabilita le penalità per estrazione e classificazione (dove la ripetizione è accettabile)