<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>Paweł Dubiel Tech Blog: Glossario</title>
  <link>https://paweldubiel.com/it</link>
  <atom:link href="https://paweldubiel.com/it/glossary.xml" rel="self" type="application/rss+xml" />
  <description>Note su AI, modelli linguistici e ingegneria del software.</description>
  <language>it</language>
  <lastBuildDate>Sun, 11 Oct 2026 00:00:00 GMT</lastBuildDate>
<item>
  <title>Overfitting</title>
  <link>https://paweldubiel.com/it/glossary/overfitting</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/overfitting</guid>
  <pubDate>Sun, 11 Oct 2026 15:59:40 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Gestisci un chiosco dei gelati. Per 10 giorni hai annotato su un quaderno la temperatura a mezzogiorno e il numero di palline vendute.</description>
  <content:encoded><![CDATA[<p>Gestisci un chiosco dei gelati. Per 10 giorni hai annotato su un quaderno la temperatura a mezzogiorno e il numero di palline vendute. Da questi appunti vuoi ricavare una regola: domani sono previsti 24°C, quanto gelato preparare?</p>
<p>La regola più semplice è una retta: «ogni grado in più vuol dire qualche pallina in più». Nell'esempio di questa nota, sui giorni annotati sbaglia tipicamente di 27,5 palline, perché non vede che nel caldo più intenso le vendite calano. Si può allora dare alla regola più libertà e permettere alla curva di piegarsi. La più flessibile delle curve provate passa esattamente per tutti e 10 i punti. Il suo errore sui giorni del quaderno è 0.</p>
<p>Sembra la regola perfetta. Solo che i giorni del quaderno sono già passati, e la regola deve funzionare domani. Su 400 nuovi giorni dello stesso chiosco la curva «perfetta» sbaglia tipicamente di 236,5 palline. Una curva moderatamente flessibile, che sul quaderno andava peggio (10,9), sui nuovi giorni sbaglia di 16,8.</p>
<p>L'<strong>overfitting</strong> è la situazione in cui un modello ha un errore piccolo sui dati usati per l'addestramento e, al confronto, un errore troppo grande su dati nuovi dello stesso tipo (<a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio e Courville, <em>Deep Learning</em>, §5.2</a>). Il modello si è adattato a caratteristiche del proprio insieme di dati che al di fuori di esso non si ripetono. Il problema opposto si chiama <strong>underfitting</strong>: la regola è troppo semplice per descrivere bene perfino i dati che ha visto. Così si comporta la retta del nostro esempio.</p>
<p><img src="https://paweldubiel.com/assets/overfitting-smooth-rule-versus-tangled-line-through-every-point.webp" alt="Due chioschi dei gelati affiancati: sopra il primo una linea liscia corre con un arco dolce tra i punti, sopra il secondo una linea aggrovigliata tocca ogni punto e schizza lontano fuori dall&#x27;inquadratura." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="da-dove-nasce-questa-differenza">Da dove nasce questa differenza</h2>
<p>Ogni annotazione del quaderno è fatta di due cose: una regolarità (fa più caldo, quindi più gelati) e il caso (proprio quel giorno è arrivata una gita). La regola deve cogliere la prima e tralasciare il secondo. Il modello però non sa che cosa sia l'una e che cosa l'altro. Vede soltanto dei punti.</p>
<p>Quanto caso il modello assorbirà dipende dalla sua flessibilità, che in letteratura si chiama <strong>capacity</strong>: la capacità di adattarsi a molte forme diverse. La curva dell'esempio è descritta da 2 a 10 numeri, che si scelgono in base ai dati; il loro numero è il grado della curva più uno. Una curva di grado 9 ha 10 di questi numeri per 10 giorni, quindi riesce a centrare ogni punto, con tutto il caso che contiene. Gli autori del manuale lo descrivono così: un modello molto flessibile può rappresentare la relazione giusta, ma anche una quantità di altre che si adattano altrettanto bene ai dati di addestramento, ed è poco probabile che scelga proprio quella che reggerà in seguito (§5.2).</p>
<p>L'andamento tipico è questo: al crescere della flessibilità l'errore sui dati di addestramento diminuisce, mentre l'errore sui dati nuovi prima diminuisce e poi comincia a crescere (§5.2, figura 5.3). Ne segue una regola pratica. Un modello non si valuta sui dati su cui è stato addestrato, e la flessibilità non si sceglie in base all'errore su quei dati, perché questo indicherà sempre la più alta. Una parte dei dati si mette da parte: il <strong><a href="https://paweldubiel.com/glossary/validation-set" hreflang="pl">validation set [Polski]</a></strong> serve a scegliere le impostazioni e un <strong>test set</strong> separato alla valutazione finale (§5.3).</p>
<h2 id="prova-tu-stesso">Prova tu stesso</h2>
<p>Qui sotto c'è lo stesso chiosco. Tutti i numeri di questa nota si possono riprodurre: dopo aver cliccato «Ricomincia» si vedono 10 giorni, e gli esperimenti 1–5 impostano i casi descritti.</p>
<div id="overfitting-lab"></div>
<p>Vale la pena fare due cose che un grafico statico non mostra. Primo, attiva «Altri 24 quaderni» e varia il grado: con un grado basso le linee grigie restano vicine tra loro, con uno alto si disperdono in tutte le direzioni, anche se ognuna proviene dallo stesso chiosco. Secondo, trascina un punto molto in alto. La curva di grado 2 si sposterà solo di poco, mentre la curva di grado 9 si ricostruirà per tutta la sua lunghezza pur di centrarlo.</p>
<h2 id="che-cosa-aiuta">Che cosa aiuta</h2>
<ul>
<li><strong>Più dati.</strong> Con 80 giorni la stessa curva di grado 9 sbaglia tipicamente di 14,8 palline sul quaderno e di 15,9 sui nuovi giorni. La differenza quasi scompare, perché la curva non può più centrare ogni punto (§5.2).</li>
<li><strong>Meno flessibilità.</strong> Una curva di grado 3 su 10 giorni: 10,9 sul quaderno, 16,8 sui nuovi giorni.</li>
<li><strong>Regularization</strong>, cioè una modifica del modo di addestrare che mira a ridurre l'errore sui dati nuovi e non su quelli di addestramento (§5.2.2). Un esempio è la penalità per i coefficienti grandi, imparentata con il <a href="https://paweldubiel.com/glossary/weight-decay" hreflang="pl">Weight decay [Polski]</a>: la curva di grado 9 con penalità λ = 0,01 sbaglia di 5,8 sul quaderno e di 21,2 sui nuovi giorni, invece che di 236,5.</li>
</ul>
<p>Nessuna di queste impostazioni si può scegliere guardando soltanto l'errore sui dati di addestramento.</p>
<h2 id="limiti">Limiti</h2>
<ul>
<li>È un esempio mio, con una sola grandezza in ingresso e dati simulati. Qui il solo caso produce tipicamente 15 palline di errore, e sui nuovi giorni nessuna regola scenderà più in basso.</li>
<li>La forma «prima meglio, poi peggio» è tipica, non garantita. Gli autori osservano che nelle reti profonde è difficile perfino stabilire la flessibilità effettiva di un modello, perché dipende anche dall'algoritmo di addestramento (§5.2). Il numero di parametri di un LLM non dice quindi, da solo, se il modello è in overfitting.</li>
<li>Un errore piccolo sui dati nuovi riguarda dati della stessa provenienza. Se il chiosco si trasferisce al mare, il quaderno della città non promette nulla.</li>
</ul>
<h2 id="collegamenti">Collegamenti</h2>
<ul>
<li><a href="https://paweldubiel.com/glossary/weight-decay" hreflang="pl">Weight decay [Polski]</a> limita la grandezza dei pesi ed è uno dei modi per ridurre la differenza tra l'errore sui dati di addestramento e quello sui dati nuovi.</li>
<li><a href="https://paweldubiel.com/glossary/grokking" hreflang="pl">Grokking [Polski]</a> descrive i casi in cui un modello che sembra in overfitting, dopo un lungo addestramento ulteriore, comincia a funzionare bene sui dati nuovi.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> su un insieme piccolo richiede lo stesso controllo: dati separati, che il modello non ha visto durante l'addestramento.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> è un problema diverso: lì il modello perde una vecchia capacità dopo un nuovo addestramento, qui fin dall'inizio si trasferisce male al di fuori dei propri dati di addestramento.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Time horizon</title>
  <link>https://paweldubiel.com/it/glossary/time-horizon</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/time-horizon</guid>
  <pubDate>Sun, 11 Oct 2026 15:02:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Nella valutazione degli agenti, il time horizon descrive la lunghezza dei compiti alla quale un agente raggiunge un livello di successo prescelto.</description>
  <content:encoded><![CDATA[<p>Nella valutazione degli agenti, il <strong>time horizon</strong> descrive la lunghezza dei compiti alla quale un agente raggiunge un livello di successo prescelto. La lunghezza si misura con il tempo necessario a una persona, non con il tempo di esecuzione dell'AI.</p>
<p>Per la variante al 50% raccogliamo i tentativi riusciti e falliti dell'agente su compiti con tempi umani diversi. Adattiamo una curva della probabilità di successo e poi leggiamo il tempo in cui essa interseca il 50%. È una previsione per la distribuzione dei compiti di quella durata; non significa che ciascuno di essi abbia la stessa probabilità di essere portato a termine. <a href="https://metr.org/time-horizons/" rel="noopener noreferrer">METR: definizione e metodologia</a>.</p>
<p>Un esempio didattico: se la curva adattata raggiunge il 50% a due ore, l'orizzonte è di due ore. L'agente può portare a termine con successo un compito molto più in fretta. Il risultato, da solo, non dice nemmeno con quale tasso di successo svolgerà un compito di un altro ambito.</p>
<p>La lettura richiede una relazione sensata tra il tempo umano e la difficoltà per l'AI. Quando la curva è piatta, una piccola variazione delle probabilità può spostare di molto la sua intersezione con la soglia. <a href="https://paweldubiel.com/it/articles/un-orizzonte-metr-piu-lungo-non-significa-compiti-proporzionalmente-piu">L'articolo sulla conversione dell'orizzonte di METR</a> mostra questo problema con un esempio numerico e discute un nuovo adattamento ai dati di METR. <a href="https://arxiv.org/html/2610.12466v1#S2" rel="noopener noreferrer">Nguyen e Fithian, §2–3</a>.</p>
<p>Quando si confrontano gli orizzonti bisogna conservare le informazioni sull'insieme di compiti, sull'ambiente dell'agente, sul budget di tentativi e sulla soglia di successo adottata.</p>]]></content:encoded>
</item>
<item>
  <title>Item response theory</title>
  <link>https://paweldubiel.com/it/glossary/item-response-theory</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/item-response-theory</guid>
  <pubDate>Sun, 11 Oct 2026 15:01:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>La item response theory (IRT) è una famiglia di metodi che, dalle risposte ai singoli compiti, stimano congiuntamente le capacità di chi li esegue e la difficoltà dei compiti.</description>
  <content:encoded><![CDATA[<p>La <strong>item response theory (IRT)</strong> è una famiglia di metodi che, dalle risposte ai singoli compiti, stimano congiuntamente le capacità di chi li esegue e la difficoltà dei compiti. Nella valutazione dell'AI chi esegue è un agente, e la risposta può essere il successo o il fallimento di un tentativo completo.</p>
<p>Supponiamo che due agenti risolvano gli stessi tre compiti. Il primo di solito se la cava con A e B, il secondo anche con C. La sola percentuale di successi fornisce una classifica. La IRT cerca in più di stimare quanto sia difficile C rispetto agli altri compiti e quale differenza di capacità spieghi lo schema delle risposte. È un esempio didattico; una tabella così piccola non basta per un adattamento affidabile.</p>
<p>Nel semplice modello di Rasch la probabilità di successo cresce quando le capacità dell'agente sono maggiori rispetto alla difficoltà del compito. Entrambe le grandezze sono latenti: le inferiamo dai risultati, invece di identificare subito la difficoltà con la lunghezza delle istruzioni o con il tempo umano. Le diverse varianti della IRT aggiungono ulteriori parametri e ipotesi.</p>
<p>Nell'<a href="https://paweldubiel.com/it/articles/un-orizzonte-metr-piu-lungo-non-significa-compiti-proporzionalmente-piu">analisi degli orizzonti di METR</a> gli autori collegano la difficoltà latente al tempo di lavoro umano per mezzo di una curva appresa. Aggiungono gli effetti delle famiglie di compiti e la variabilità dei risultati delle ripetizioni. Questo permette di verificare in quale intervallo il tempo distingua davvero i compiti difficili da quelli facili per l'AI. <a href="https://arxiv.org/html/2610.12466v1#S2.SS3" rel="noopener noreferrer">Nguyen e Fithian, §2.3 e §3.1</a>.</p>
<p>Una buona previsione delle risposte non dimostra che il parametro appreso copra tutti i tipi di capacità dell'agente. Nell'interpretazione bisogna verificare le ipotesi del modello e i risultati sui compiti non utilizzati durante l'adattamento.</p>]]></content:encoded>
</item>
<item>
  <title>Elastic Weight Consolidation</title>
  <link>https://paweldubiel.com/it/glossary/elastic-weight-consolidation</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/elastic-weight-consolidation</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modello smista le domande dei clienti verso i reparti «consegna» e «resi». Ora deve imparare a riconoscere i reclami, ma i vecchi messaggi non si possono più conservare.</description>
  <content:encoded><![CDATA[<p>Un modello smista le domande dei clienti verso i reparti «consegna» e «resi». Ora deve imparare a riconoscere i reclami, ma i vecchi messaggi non si possono più conservare. Non è quindi possibile ripeterli durante l'addestramento. Tutto ciò che resta del vecchio compito è il modello stesso: milioni di numeri regolati nel corso dell'addestramento precedente, chiamati pesi.</p>
<p>Si può addestrare il modello sui reclami senza alcun vincolo. In tal caso i pesi si spostano dove conviene al nuovo compito, compresi quelli da cui dipendeva il riconoscimento di consegna e resi. Si può anche penalizzare ogni variazione allo stesso modo, ma allora il modello resta così aggrappato alle vecchie impostazioni da imparare male il nuovo. Serve una risposta alla domanda: <strong>quali pesi si possono toccare e quali è meglio di no?</strong></p>
<p>L'<strong>Elastic Weight Consolidation (EWC)</strong> aggiunge all'apprendimento del nuovo compito una penalità per l'allontanamento dei pesi dai valori che avevano dopo il vecchio compito, e la penalità è tanto maggiore quanto più quel peso era importante per il vecchio compito. Gli autori lo paragonano a una molla agganciata a ogni peso: rigida per i pesi importanti, lasca per gli altri (<a href="https://arxiv.org/abs/1612.00796" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §2</a>).</p>
<p><img src="https://paweldubiel.com/assets/elastic-weight-consolidation-stiff-and-loose-springs.webp" alt="Una fila di dischetti agganciati con molle a dei paletti: i dischetti sulle molle spesse e rigide restano al loro posto, quelli sulle molle sottili e lasche si spostano verso un cerchio rosso." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="due-pesi-un-nuovo-compito">Due pesi, un nuovo compito</h2>
<p>Prendiamo solo due pesi. Dopo l'addestramento su consegna e resi valgono entrambi 1. Il primo è molto importante per i vecchi reparti (importanza 10), il secondo quasi indifferente (importanza 0,1). Il nuovo compito richiede soltanto che <strong>la somma dei due pesi sia 4</strong>. Lo soddisfano molte configurazioni: (2, 2), ma anche (1, 3).</p>
<ul>
<li><strong>Senza protezione</strong> l'addestramento sposta i due pesi in ugual misura, fino a (2, 2). Il nuovo compito è stato appreso, ma il peso importante si è allontanato di 1 e la perdita sul vecchio compito sale da 0 a 5,05.</li>
<li><strong>Una penalità uniforme</strong> per entrambi i pesi li ferma a metà strada, a (1,67; 1,67). Il vecchio compito soffre meno, ma la somma è 3,33 invece di 4.</li>
<li><strong>EWC</strong> trasferisce quasi tutto lo spostamento sul peso poco importante: (1,02; 2,80). La somma è 3,82 e la perdita sul vecchio compito è appena 0,16.</li>
</ul>
<p>La perdita è un numero che dice quanto il modello sbaglia; più è piccola, meglio è. Nell'esperimento qui sotto puoi variare la forza della penalità λ e il tipo di protezione. Il risultato è calcolato in modo esatto per questo esempio a due pesi; non è la simulazione di una rete vera.</p>
<div id="ewc-spring-lab"></div>
<h2 id="come-si-sa-quale-peso-è-importante">Come si sa quale peso è importante</h2>
<p>In una rete vera nessuno fornisce le importanze in partenza. Si stimano al termine del vecchio compito, finché i suoi dati sono ancora disponibili: si verifica quanto una piccola variazione di un dato peso cambia le risposte del modello sui vecchi esempi. Il lavoro usa a questo scopo la diagonale della <em>matrice di informazione di Fisher</em>, cioè un solo numero di importanza per ogni peso. Poi i dati si possono eliminare; restano i vecchi valori dei pesi e le loro importanze.</p>
<p>Durante il nuovo addestramento si minimizza la somma di due termini (equazione 3 del lavoro):</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>L</mi><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>L</mi><mi>B</mi></msub><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>+</mo><munder><mo>∑</mo><mi>i</mi></munder><mfrac><mi>λ</mi><mn>2</mn></mfrac><msub><mi>F</mi><mi>i</mi></msub><mtext> </mtext><mo stretchy="false">(</mo><msub><mi>θ</mi><mi>i</mi></msub><mo>−</mo><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">L(\theta) = L_B(\theta) + \sum_i \frac{\lambda}{2} F_i \,(\theta_i - \theta^*_{A,i})^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">L</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.6491em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3714em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">λ</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.2472em;vertical-align:-0.3831em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7387em;"><span style="top:-2.453em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3831em;"><span></span></span></span></span></span></span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">L_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> è la perdita sul nuovo compito, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">\theta_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> è il valore corrente del peso numero <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup></mrow><annotation encoding="application/x-tex">\theta^*_{A,i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1059em;vertical-align:-0.4114em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6887em;"><span style="top:-2.4247em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4114em;"><span></span></span></span></span></span></span></span></span></span> il suo valore dopo il vecchio compito, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">F_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> la sua importanza, e <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi></mrow><annotation encoding="application/x-tex">\lambda</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span></span></span></span> dice quanto il vecchio compito conta rispetto al nuovo. Nel nostro esempio <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mo stretchy="false">(</mo><mn>10</mn><mo separator="true">;</mo><mtext> </mtext><mn>0,1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F = (10;\ 0{,}1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">10</span><span class="mpunct">;</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> e <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\lambda = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>.</p>
<h2 id="limiti-del-metodo">Limiti del metodo</h2>
<p>L'importanza è un'approssimazione calcolata in un solo punto, separatamente per ogni peso. Gli stessi autori mostrano che la loro stima risulta a volte troppo sicura su quali pesi siano irrilevanti, e la definiscono la principale debolezza del metodo (§2.2 e §3). Nei loro esperimenti con i giochi Atari un agente con EWC imparava molti giochi uno dopo l'altro, ma non raggiungeva le reti separate addestrate per ciascun gioco. I risultati riguardano il riconoscimento di cifre e i giochi, non i grandi modelli linguistici. I nostri due pesi e i messaggi dei clienti sono una semplificazione mia.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> è un forte peggioramento delle vecchie capacità dopo un nuovo addestramento; EWC cerca di limitarlo senza accedere ai vecchi dati.</li>
<li><a href="https://paweldubiel.com/it/glossary/experience-replay">Experience Replay</a> risolve lo stesso problema in un altro modo: conserva una parte dei vecchi esempi invece delle importanze dei pesi.</li>
<li><a href="https://paweldubiel.com/it/glossary/continual-learning">Continual Learning</a> definisce l'obiettivo, cioè l'apprendimento di compiti successivi conservando quelli precedenti; EWC è uno dei metodi.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> è l'ulteriore addestramento di un modello già pronto; EWC ne modifica l'obiettivo, aggiungendo una penalità per lo spostamento dei pesi importanti.</li>
</ul>
<p><em>Testo e illustrazione sono stati preparati con l'aiuto dell'AI. I due pesi, le loro importanze e la dimostrazione sono un esempio didattico mio e semplificato; l'illustrazione è una metafora, non uno schema della struttura del modello.</em></p>]]></content:encoded>
</item>
<item>
  <title>Reservoir Sampling</title>
  <link>https://paweldubiel.com/it/glossary/reservoir-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/reservoir-sampling</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modello per l&apos;assistenza clienti impara da messaggi che arrivano uno dopo l&apos;altro. Vuoi conservarne alcuni per le ripetizioni future, ma hai solo quattro posti in memoria.</description>
  <content:encoded><![CDATA[<p>Un modello per l'assistenza clienti impara da messaggi che arrivano uno dopo l'altro. Vuoi conservarne alcuni per le ripetizioni future, ma hai solo quattro posti in memoria. Non sai nemmeno quanti messaggi arriveranno ancora: venti o due milioni.</p>
<p>Tenere i primi quattro? Allora la memoria conosce solo l'inizio. Tenere sempre gli ultimi quattro? Allora conosce solo la fine. Un'estrazione equa di «quattro dal totale» richiederebbe di conservare tutto oppure di conoscere in anticipo il numero di messaggi. La domanda è: <strong>come dare a ogni messaggio la stessa probabilità, con un numero fisso di posti e un flusso di lunghezza ignota?</strong></p>
<p>Il <strong>Reservoir Sampling</strong> è un modo per mantenere un campione casuale di dimensione fissa durante un unico passaggio su dati di cui non conosciamo in anticipo la quantità. Dopo ogni nuovo messaggio la memoria, qui chiamata serbatoio, contiene un campione casuale equo di tutto ciò che è arrivato fino a quel momento. La versione più semplice, l'Algorithm R, è descritta da <a href="https://doi.org/10.1145/3147.3165" rel="noopener noreferrer">Vitter, <em>Random Sampling with a Reservoir</em>, §2</a>, che la attribuisce ad Alan Waterman.</p>
<p><img src="https://paweldubiel.com/assets/reservoir-sampling-pebble-stream-four-slot-tray.webp" alt="Un lungo flusso di sassolini e conchiglie scorre accanto a un piccolo vassoio di legno con quattro incavi; una mano toglie un sassolino dal vassoio, l&#x27;altra mette al suo posto un sassolino preso dal flusso." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="la-ricetta-in-due-passi">La ricetta in due passi</h2>
<ol>
<li>I primi quattro messaggi entrano in memoria senza estrazione.</li>
<li>Il messaggio numero <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> (il quinto, il sesto e ogni successivo) entra in memoria con probabilità <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>. Se è entrato, sostituisce uno dei quattro salvati, scelto a caso.</li>
</ol>
<p>Il quinto messaggio entra quindi con probabilità 4/5, il centesimo con probabilità 4/100. I nuovi messaggi hanno una probabilità di entrare sempre più bassa, ma i vecchi sono già stati esposti molte volte al rischio di essere scartati, e i due effetti si compensano esattamente. Verifichiamolo dopo il quinto messaggio. Entra con probabilità 4/5. Il primo messaggio esce solo se il quinto è entrato (4/5) ed è finito proprio al suo posto (1/4), cioè con probabilità 1/5. Resta con probabilità 4/5: la stessa del quinto. Dopo <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> messaggi ciascuno di essi è in memoria con probabilità <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>.</p>
<h2 id="una-probabilità-uguale-non-è-una-garanzia">Una probabilità uguale non è una garanzia</h2>
<p>Nell'esperimento il flusso ha 20 messaggi. Diciotto riguardano la consegna e due, il nono e il quindicesimo, riguardano i resi. Ogni avvio fa scorrere un flusso del genere 2000 volte e conta quanto spesso una data posizione è rimasta in memoria alla fine. Le estrazioni sono vere, quindi i risultati differiscono ogni volta di una frazione di punto percentuale.</p>
<div id="reservoir-sampling-lab"></div>
<p>Con il Reservoir Sampling ogni barra vale circa il 20%, cioè 4/20. Allo stesso tempo, nella maggior parte delle esecuzioni nessuno dei due resi resta in memoria. Il valore esatto è 3060/4845, cioè circa il 63%: tante sono, fra tutte le quaterne scelte tra 20 messaggi, quelle composte soltanto dai diciotto messaggi sulla consegna. Il metodo è equo verso i singoli messaggi, ma non si preoccupa che ogni categoria abbia un rappresentante.</p>
<h2 id="dove-tutto-questo-conta">Dove tutto questo conta</h2>
<p>Nell'addestramento con ripetizioni il Reservoir Sampling è talvolta il modo in cui si scrive nel buffer: non occorre conoscere la lunghezza del flusso né i confini tra i compiti. <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, algoritmo 2</a> lo usano proprio così. Nei loro esperimenti su compiti con immagini funzionava bene, tranne che con memorie molto piccole, dove dal buffer sparivano le classi precedenti; in quel caso andavano meglio le strategie che curano una rappresentazione uguale delle classi (§4.4). È un risultato per la classificazione di immagini, non per gli LLM.</p>
<p>L'algoritmo in sé non riguarda il machine learning. Il lavoro di Vitter del 1985 descrive l'estrazione di record da un nastro magnetico di lunghezza ignota e propone varianti più veloci che, invece di estrarre a ogni record, calcolano quanti record saltare. I messaggi dei clienti e il flusso di 20 posizioni sono un esempio mio.</p>
<ul>
<li><a href="https://paweldubiel.com/it/glossary/experience-replay">Experience Replay</a> ha bisogno di un buffer con vecchi esempi; il Reservoir Sampling è uno dei modi per decidere che cosa vi entra.</li>
<li><a href="https://paweldubiel.com/it/glossary/continual-learning">Continual Learning</a> presuppone l'apprendimento da un flusso di dati con memoria limitata, cioè una situazione in cui non si può conservare tutto.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> può aggravarsi quando da una memoria piccola escono tutti gli esempi di una vecchia categoria.</li>
</ul>
<p><em>Testo e illustrazione sono stati preparati con l'aiuto dell'AI. Il flusso di messaggi e la dimostrazione sono un esempio didattico mio e semplificato; l'illustrazione è una metafora, non uno schema dell'algoritmo.</em></p>]]></content:encoded>
</item>
<item>
  <title>Experience Replay</title>
  <link>https://paweldubiel.com/it/glossary/experience-replay</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/experience-replay</guid>
  <pubDate>Sun, 11 Oct 2026 08:22:26 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modello ha imparato a smistare le domande dei clienti verso i reparti «consegna» e «resi». Ora lo addestri ulteriormente a riconoscere i reclami, per esempio «Il prodotto è arrivato danneggiato».</description>
  <content:encoded><![CDATA[<p>Un modello ha imparato a smistare le domande dei clienti verso i reparti «consegna» e «resi». Ora lo addestri ulteriormente a riconoscere i reclami, per esempio «Il prodotto è arrivato danneggiato». Se negli esercizi successivi vede soltanto reclami, può gestire peggio il già noto «Dov'è il pacco?». Il vecchio archivio completo non è disponibile. Si può tornare almeno su qualche messaggio conservato?</p>
<p>L'<strong>Experience Replay (ER)</strong> consiste nel conservare una parte degli esempi precedenti e nel riutilizzarli per l'addestramento. Nella variante semplice, al batch di nuovi dati mescoliamo esempi presi da una memoria chiamata <em>replay buffer</em>. È un contenitore di dati per le ripetizioni, non una registrazione di tutto ciò che il modello sa. Questo addestramento congiunto è descritto da <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, algoritmo 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/experience-replay-card-box-returning-examples.webp" alt="Schede blu scuro e ocra conservate tornano da una piccola cassetta in una fila di nuove schede rosse: una metafora delle ripetizioni durante l&#x27;addestramento successivo." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="che-cosa-entra-nellesercizio-successivo">Che cosa entra nell'esercizio successivo</h2>
<p>Prima di perdere l'archivio abbiamo salvato quattro messaggi insieme ai reparti corretti. Ora abbiamo quattro nuovi reclami. Senza ripetizioni il modello impara su quattro nuovi messaggi. Con le ripetizioni si esercita anche su quattro vecchi: riceve di nuovo il segnale che «Dov'è il pacco?» appartiene alla consegna. In questo piccolo esempio usiamo l'intero buffer; i buffer più grandi di solito forniscono una porzione estratta a caso.</p>
<p>Non basta però contare i posti in memoria. Quattro domande salvate sulla consegna non contengono nemmeno un esempio di reso. Sostituendone due con «Come rispedisco un acquisto?» e «Voglio restituire una camicia», il numero di ripetizioni resta lo stesso, ma copre entrambi i reparti precedenti. L'esperimento qui sotto <strong>conta gli esempi nel batch di dati; non prevede l'accuratezza del modello</strong>.</p>
<div id="experience-replay-lab"></div>
<h2 id="le-ripetizioni-aiutano-solo-sui-dati-disponibili">Le ripetizioni aiutano solo sui dati disponibili</h2>
<p>Il modello ottiene l'occasione di esercitarsi sulle risposte precedenti, ma non la garanzia di conservare tutte le capacità. Un piccolo campione casuale può tralasciare del tutto una categoria rara; i ricercatori hanno osservato questo problema con buffer molto piccoli (§4.4 dello stesso lavoro). I nostri messaggi sono un esempio mio, non il risultato di quegli esperimenti. L'effetto dell'addestramento va verificato su messaggi vecchi e nuovi separati, non usati per l'addestramento. Il buffer occupa inoltre memoria e richiede di conservare i dati scelti.</p>
<p>Vedi anche: <a href="https://paweldubiel.com/it/glossary/reservoir-sampling">Reservoir Sampling</a> — un modo per decidere quali esempi di un flusso entrano in un buffer di dimensione fissa, che dà a ciascuno la stessa probabilità.</p>
<p>Nei giochi, nel <a href="https://paweldubiel.com/glossary/reinforcement-learning" hreflang="pl">Reinforcement Learning [Polski]</a> — l'apprendimento di azioni in base a ricompense — si conservano la situazione, l'azione, la ricompensa e la situazione successiva. Estrarre a caso queste registrazioni riduce la dipendenza da eventi che si susseguono immediatamente (<a href="https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf#page=7" rel="noopener noreferrer">Mnih et al., <em>Human-level control through deep reinforcement learning</em>, Methods, «Training algorithm for deep Q-networks»</a>). Sono dati diversi da un messaggio con il reparto corretto; i risultati ottenuti su Atari non vanno trasferiti direttamente agli LLM.</p>
<ul>
<li><a href="https://paweldubiel.com/it/glossary/continual-learning">Continual Learning</a> definisce l'obiettivo di proseguire l'addestramento conservando le capacità precedenti; l'ER è uno dei modi per raggiungerlo.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> descrive un forte peggioramento delle vecchie capacità, che le ripetizioni possono limitare.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> è l'ulteriore addestramento di un modello; il replay ne cambia la selezione dei dati. Il semplice incollare vecchi messaggi in una conversazione non è un aggiornamento del modello di questo tipo.</li>
</ul>
<p><em>Testo e illustrazione sono stati preparati con l'aiuto dell'AI. I messaggi e la dimostrazione sono un esempio didattico mio e semplificato; l'illustrazione è una metafora, non uno schema della struttura del modello.</em></p>]]></content:encoded>
</item>
<item>
  <title>Continual Learning</title>
  <link>https://paweldubiel.com/it/glossary/continual-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/it/glossary/continual-learning</guid>
  <pubDate>Sat, 10 Oct 2026 20:03:52 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Un modello smista i messaggi dei clienti verso i reparti «ordini» e «resi». Sa riconoscere «Dov&apos;è il mio pacco?». Ora l&apos;azienda apre un reparto reclami.</description>
  <content:encoded><![CDATA[<p>Un modello smista i messaggi dei clienti verso i reparti «ordini» e «resi». Sa riconoscere «Dov'è il mio pacco?». Ora l'azienda apre un reparto reclami. Addestri ulteriormente il modello su messaggi che parlano di prodotti danneggiati. I reclami vengono smistati sempre meglio, ma anche una parte delle domande sulla consegna comincia a finire nel nuovo reparto. Controllare soltanto i reclami darebbe una falsa impressione di progresso.</p>
<p>Ti serve <strong>insegnare al modello cose nuove conservando le capacità precedenti</strong>. È l'obiettivo del <strong>Continual Learning</strong>: l'apprendimento su dati o compiti che arrivano in sequenza, tenendo conto di ciò che il modello ha imparato prima. Il nome indica un problema e una famiglia di approcci; non garantisce che il modello non dimentichi. Questa esigenza è descritta da <a href="https://arxiv.org/html/1612.00796v2#S1" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §1</a>.</p>
<p><img src="https://paweldubiel.com/assets/continual-learning-embroidered-sampler-growing-repertoire.webp" alt="Su un unico pezzo di stoffa restano ricamati cerchi e triangoli, mentre l&#x27;ago aggiunge un nuovo motivo ondulato: una metafora dello sviluppo di nuove capacità conservando quelle precedenti." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="che-cosa-cambiamo-nelladdestramento-e-nella-verifica">Che cosa cambiamo nell'addestramento e nella verifica</h2>
<p>Supponiamo che l'archivio completo degli esempi usati nell'addestramento precedente non sia più disponibile. Prima di eliminarlo ne abbiamo conservato un piccolo campione: 20 messaggi di cui conosciamo il reparto corretto. Uno dei metodi possibili consiste nel mescolare questo campione ai nuovi esempi di reclami. In questo modo l'addestramento successivo riceve anche il segnale di continuare a gestire correttamente «Dov'è il mio pacco?». Il riutilizzo di vecchi esempi è una delle strategie descritte da <a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven e Tolias, <em>Three scenarios for continual learning</em>, §3.3</a>.</p>
<p>Vedi anche: <a href="https://paweldubiel.com/it/glossary/experience-replay">Experience Replay</a> — conservare un piccolo campione di vecchi esempi e mescolarlo al nuovo addestramento.</p>
<p>Il team di valutazione conserva un test separato di vecchi messaggi, che <strong>non usiamo per l'addestramento</strong>. Dopo ogni aggiornamento controlliamo le categorie vecchie e quelle nuove. I numeri qui sotto sono un esempio inventato, non il risultato di uno studio; ogni test contiene 100 messaggi.</p>

























<table><thead><tr><th>Variante del modello</th><th>Vecchi messaggi corretti</th><th>Reclami corretti</th></tr></thead><tbody><tr><td>Prima del nuovo addestramento</td><td>90/100</td><td>0/100 — la categoria non esiste</td></tr><tr><td>Dopo l'addestramento sui soli reclami</td><td>40/100</td><td>92/100</td></tr><tr><td>Dopo l'addestramento con il campione di vecchi messaggi</td><td>89/100</td><td>87/100</td></tr></tbody></table>
<p>L'ultima variante conserva meglio la capacità precedente, anche se riconosce i reclami peggio della seconda. La tabella mostra <strong>che cosa confrontare</strong>; non promette un risultato simile dopo aver aggiunto 20 esempi.</p>
<h2 id="le-condizioni-cambiano-la-difficoltà">Le condizioni cambiano la difficoltà</h2>
<p>Nel nostro esempio il modello sceglie da solo tra tutti i reparti che conosce. Un suggerimento del tipo «questo è un messaggio della nuova categoria» renderebbe il test più facile. La disponibilità di suggerimenti simili e dei confini tra i compiti conta quando si confrontano i metodi (<a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven e Tolias, §2–2.3</a>). Un campione piccolo può tralasciare le domande rare; una buona media non dimostra che ogni capacità sia stata conservata.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> descrive un forte peggioramento delle vecchie capacità; la sua dimostrazione mostra come il nuovo addestramento modifica le impostazioni condivise.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> è l'ulteriore addestramento di un modello su esempi selezionati. Dopo ogni nuovo addestramento controlliamo anche le capacità precedenti.</li>
<li><a href="https://paweldubiel.com/glossary/knowledge-distillation" hreflang="pl">Knowledge Distillation [Polski]</a> può trasmettere indicazioni da un modello più vecchio a quello in aggiornamento; è una strategia diversa dal conservare i messaggi originali (§3.3 del lavoro di van de Ven e Tolias).</li>
</ul>
<p><em>Testo e illustrazione sono stati preparati con l'aiuto dell'AI; i messaggi, la dimensione del campione e i risultati della tabella sono un esempio didattico mio. L'illustrazione mostra l'obiettivo di conservare le capacità precedenti, non la struttura del modello.</em></p>]]></content:encoded>
</item>
</channel>
</rss>