0Pricing
AI Prompt Engineering · Lezione

Zero-shot, one-shot e few-shot

Scegliere il numero di esempi.

Zero-shot, one-shot e few-shot è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.

Lo spettro degli shot

Gli shot indicano il numero di esempi etichettati inseriti nel prompt prima della query effettiva. Lo zero-shot si basa interamente sui priori appresi dal modello; il few-shot condiziona il modello su una piccola distribuzione specifica dell'attività al momento dell'inferenza, senza modificare i pesi.

Si tratta dell'apprendimento in contesto (ICL): il trasformatore tratta gli esempi come parte della sequenza ed esegue implicitamente una sorta di regressione meta-appresa su di essi. La scelta di k (numero di shot) è un iperparametro da ottimizzare empiricamente, non una best practice fissa.

from dataclasses import dataclass

@dataclass
class ICLConfig:
    k: int           # number of demonstrations
    selection: str   # 'static' | 'dynamic'
    order: str       # 'random' | 'similarity' | 'curriculum'

# Zero-shot is simply k=0
cfg = ICLConfig(k=0, selection='static', order='random')

Quando lo zero-shot dà il meglio

Preferisca lo zero-shot quando il task è ben rappresentato nel pre-addestramento (riepilogo, traduzione, classificazione comune) e quando gli esempi rischiano di influenzare il formato dell'output. Nei modelli ottimizzati per le istruzioni, una direttiva chiara e concisa accompagnata da uno schema di output spesso funziona meglio di esempi che ancorano sottilmente lo stile.

Lo zero-shot riduce inoltre al minimo il costo in token e la latenza, evitando il bias della classe maggioritaria, per cui il modello tende a prevedere eccessivamente la classe dominante nelle dimostrazioni.

# Zero-shot with explicit schema beats vague few-shot
PROMPT = (
    'Classify sentiment as POSITIVE, NEGATIVE, or NEUTRAL.\n'
    'Respond with only the label.\n\n'
    'Text: ' + user_text + '\nLabel:'
)

One-shot come ancora per il formato

Lo one-shot dà il meglio quando il task è concettualmente chiaro, ma il formato dell'output è insolito o rigido. Una singola dimostrazione insegna la forma esatta (chiavi JSON, delimitatori, uso di maiuscole e minuscole) in modo molto più affidabile di una descrizione in prosa.

Utilizzi il one-shot quando desidera vincolare la struttura senza consumare troppi token né rischiare la distorsione della distribuzione delle etichette introdotta da più esempi.

ONE_SHOT = (
    'Extract entities as JSON.\n\n'
    'Input: Apple released the iPhone in Cupertino.\n'
    'Output: {"org": ["Apple"], "product": ["iPhone"], "loc": ["Cupertino"]}\n\n'
    'Input: ' + query + '\nOutput:'
)

Few-shot e curva di k

Le prestazioni al variare di k raramente seguono un andamento monotono. In genere aumentano, raggiungono un plateau e poi peggiorano quando gli esempi sovraffollano il contesto, diluiscono l'attenzione e allontanano la query corrente dal focus di recenza del modello.

Esegua empiricamente una scansione di k in {1, 2, 4, 8, 16} su un set di dati messo da parte per la valutazione. Il valore ottimale di k dipende dalla complessità del task, dalla lunghezza degli esempi e dall'utilizzo effettivo del contesto da parte del modello, che di solito è molto inferiore alla finestra dichiarata.

def sweep_k(eval_set, candidates, ks=(1,2,4,8,16)):
    results = {}
    for k in ks:
        acc = evaluate(build_prompt(candidates[:k]), eval_set)
        results[k] = acc
    return max(results, key=results.get)

Perché ICL funziona: inferenza implicita

La ricerca interpreta ICL come un'inferenza bayesiana implicita eseguita dal modello: le dimostrazioni aiutano a individuare il concetto latente del task che il modello ha già appreso durante il pre-addestramento. Gli esempi fungono da evidenza che restringe la distribuzione a posteriori sui task, non da nuova conoscenza.

Questo spiega un risultato controintuitivo: anche etichette errate nelle dimostrazioni possono preservare gran parte dell'accuratezza, perché il segnale dominante è dato dal formato e dallo spazio delle etichette, non dalla corrispondenza tra input ed etichetta.

# Min, Lyu et al. (2022): label correctness matters less than
#   - the input distribution
#   - the label space (which classes exist)
#   - the format / structure
# Implication: invest in representative inputs + valid label set

Compromessi tra budget di token e costi

Ogni shot consuma contesto e denaro. Con dimostrazioni lunghe, quattro esempi possono superare di gran lunga la query. Calcoli una metrica di costo per punto di accuratezza: se k=8 offre un vantaggio dello 0,5% rispetto a k=4 al doppio dei token, in produzione vince k=4.

Per le pipeline ad alto throughput, preferisca il prompt caching del blocco statico di esempi, in modo che le dimostrazioni ripetute vengano fatturate ed elaborate una sola volta.

def cost_efficiency(acc_by_k, tokens_by_k, price_per_1k):
    return {
        k: acc_by_k[k] / (tokens_by_k[k] / 1000 * price_per_1k)
        for k in acc_by_k
    }
# Pick the k maximizing accuracy per dollar, not raw accuracy

Bias della classe maggioritaria e della posizione

I prompt few-shot nascondono diversi bias. Il bias della classe maggioritaria porta il modello a preferire la classe più frequente nelle dimostrazioni. Il bias di recenza attribuisce un peso eccessivo all'ultimo esempio. Il bias dei token comuni favorisce i token che compaiono più spesso.

Le tecniche di calibrazione, come la calibrazione contestuale, stimano il prior del modello su un input privo di contenuto (per esempio, il token N/A) e lo dividono, stabilizzando notevolmente i classificatori few-shot.

# Contextual calibration (Zhao et al. 2021)
p_cf = model_probs(prompt_with_input('N/A'))  # content-free prior
W = 1.0 / p_cf                                  # diagonal correction
def calibrated(probs):
    return normalize(W * probs)

Bilanciare il set di dimostrazioni

Per contrastare il bias della classe maggioritaria, bilanci le classi nelle dimostrazioni e ne vari l'ordine. Per una classificazione binaria con k=4, utilizzi 2 esempi positivi e 2 negativi, mescolati, anziché un rapporto 3:1.

Per i task di generazione, bilanci le dimensioni rilevanti (lunghezza, tono, difficoltà), così il modello non collassa in un'unica modalità, quella osservata più spesso.

import random

def balanced_demos(pool, k, label_fn):
    by_label = {}
    for ex in pool:
        by_label.setdefault(label_fn(ex), []).append(ex)
    per = k // len(by_label)
    picks = [e for lst in by_label.values() for e in random.sample(lst, per)]
    random.shuffle(picks)
    return picks

Few-shot vs fine-tuning

Il few-shot è lo strumento giusto quando il task cambia spesso, i dati sono scarsi o non può ospitare un modello ottimizzato. Il fine-tuning è preferibile quando dispone di migliaia di esempi, ha bisogno della latenza minima per chiamata o desidera incorporare il formato nel modello, così da mantenere brevi i prompt.

Un percorso comune in produzione consiste nel prototipare con il few-shot, raccogliere le tracce riuscite e poi distillarle in un fine-tuning, eliminando del tutto i token degli esempi.

# Decision heuristic
if num_labeled < 500 or task_volatility == 'high':
    strategy = 'few-shot ICL'
elif latency_budget_ms < 200 or prompt_token_cost_dominant:
    strategy = 'fine-tune + zero-shot'
else:
    strategy = 'few-shot now, distill later'

I task di ragionamento richiedono più dei soli shot

Per il ragionamento in più passaggi, le semplici coppie few-shot domanda-risposta possono danneggiare le prestazioni: il modello impara a saltare direttamente a una risposta che non sa giustificare. Abbini il few-shot a dimostrazioni chain-of-thought che mostrino la traccia del ragionamento, non solo l'etichetta finale.

Il numero di shot interagisce con la profondità del ragionamento; spesso 2 esempi CoT di alta qualità superano 8 esempi con la sola risposta nei benchmark di aritmetica e logica.

COT_SHOT = (
    'Q: A shop had 23 apples, used 20, bought 6 more. How many now?\n'
    'A: Start 23, minus 20 leaves 3, plus 6 is 9. Answer: 9\n\n'
    'Q: ' + question + '\nA:'
)

Un harness di valutazione per k

Consideri la selezione degli shot come una ricerca empirica supportata da un harness. Metta da parte un set di validazione, controlli l'ordine degli esempi usando più seed e riporti media e varianza, perché l'accuratezza few-shot può variare di diversi punti solo a causa dell'ordine.

Registri il conteggio dei token e la latenza per ogni k, così la scelta finale ottimizzerà l'obiettivo complessivo e non soltanto l'accuratezza.

def harness(pool, val, ks, seeds=5):
    report = {}
    for k in ks:
        accs = []
        for s in range(seeds):
            demos = balanced_demos(pool, k, label_fn)
            accs.append(evaluate(build_prompt(demos), val))
        report[k] = (mean(accs), stdev(accs))
    return report

Controllo rapido

Verifichi la propria comprensione della selezione degli shot e dei bias di ICL.

Riepilogo

Punti chiave:

  • k è un iperparametro regolabile: esegua una scansione e osservi la curva di crescita, plateau e degrado.
  • Lo zero-shot è adatto ai task ben noti; il one-shot ancora i formati rigidi; il few-shot condiziona il modello su una distribuzione di task.
  • ICL funziona individuando un task appreso nel pre-addestramento, quindi il formato e lo spazio delle etichette prevalgono sulla correttezza delle etichette.
  • Contrasti i bias della classe maggioritaria, di recenza e dei token comuni bilanciando, mescolando e applicando la calibrazione contestuale.
  • Ottimizzi l'accuratezza per euro, abbini i task di ragionamento a esempi CoT e distilli i prompt few-shot stabili in modelli sottoposti a fine-tuning.

Domande Frequenti

La lezione «Zero-shot, one-shot e few-shot» è gratuita?

Sì — il testo completo di «Zero-shot, one-shot e few-shot» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.

Cosa imparerò in «Zero-shot, one-shot e few-shot»?

Scegliere il numero di esempi. Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Prompt Engineering?

Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Zero-shot, one-shot e few-shot»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?

Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Zero-shot, one-shot e few-shot
  2. Progettare esempi efficaci
  3. Ordine e attualità degli esempi
  4. Selezione dinamica few-shot
← Torna a AI Prompt Engineering