@mcptoolshop/backpropagate 1.5.0 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/README.es.md +37 -24
  2. package/README.fr.md +37 -24
  3. package/README.hi.md +37 -24
  4. package/README.it.md +120 -107
  5. package/README.ja.md +37 -24
  6. package/README.md +40 -27
  7. package/README.pt-BR.md +37 -24
  8. package/README.zh.md +36 -23
  9. package/package.json +1 -1
package/README.it.md CHANGED
@@ -15,9 +15,9 @@
15
15
  <a href="https://mcp-tool-shop-org.github.io/backpropagate/"><img src="https://img.shields.io/badge/Landing_Page-live-blue" alt="Landing Page"></a>
16
16
  </p>
17
17
 
18
- # Addestra un adattatore. Caricalo su Ollama. Passa oltre
18
+ # Ottimizza un modello QLoRA da 32 miliardi di parametri oppure un modello end-to-end da 7 miliardi di parametri su una singola GPU. Caricalo su Ollama
19
19
 
20
- Backpropagate è una libreria Python per l'affinamento di modelli linguistici di grandi dimensioni su una singola GPU. Tre righe di codice addestrano un modello da 7B su una scheda da 16 GB. Un comando aggiuntivo lo esporta su Ollama in modo che tu possa eseguire `ollama run` per il tuo modello affinato. Funziona perfettamente su Windows.
20
+ Esegui il fine-tuning di modelli linguistici di grandi dimensioni su una **singola** GPU, dimensionata in base alla scheda che hai effettivamente. Tre righe di codice Python per il fine-tuning di un modello da 7 a 34 miliardi di parametri su una singola scheda consumer da 32 GB (RTX 5090); un flag — `--full-ft-offload` — esegue il fine-tuning completo di un modello di classe 7B scaricando lo stato dell'ottimizzatore nella RAM del sistema. Un comando aggiuntivo esporta i risultati su Ollama, quindi esegui `ollama run` con il tuo modello ottimizzato. Si adatta in modo efficiente fino a 16 GB. Ottime prestazioni su Windows.
21
21
 
22
22
  ```python
23
23
  from backpropagate import Trainer
@@ -32,7 +32,7 @@ backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --oll
32
32
  ollama run my-model
33
33
  ```
34
34
 
35
- Questo è tutto. Non c'è un file di configurazione YAML. Non c'è una procedura di avvio con `accelerate launch`. Non c'è un tutorial separato per "convertilo ora in GGUF". Se hai una GPU CUDA e un file JSONL con i tuoi dati di addestramento, ti servono solo tre righe per ottenere un modello affinato funzionante.
35
+ Questo è tutto. Non c'è un file di configurazione YAML. Non c'è una procedura complessa con `accelerate launch`. Non c'è un tutorial separato del tipo "ora convertilo in GGUF". Se hai una GPU CUDA e un file JSONL con i tuoi dati di addestramento, ti servono solo tre righe per ottenere un modello affinato funzionante.
36
36
 
37
37
  ## Installa
38
38
 
@@ -56,74 +56,79 @@ pipx install "backpropagate[full]" # adds everything: unsloth, ui, monitor
56
56
 
57
57
  Preferisci Docker? Anche `docker pull ghcr.io/mcp-tool-shop-org/backpropagate:latest` funziona. Sono disponibili immagini sia per `linux/amd64` che per `linux/arm64`, quindi gli utenti di Apple Silicon e ARM Linux ottengono un'immagine nativa. Un file `compose.yaml` standard per "UI in un container" si trova nella directory principale del repository: `docker compose up` avvia l'interfaccia utente web su `http://localhost:7860` con un volume persistente `~/.backpropagate`.
58
58
 
59
- ## Dove si colloca Backpropagate
59
+ ## Dove si colloca Backpropagate nello spazio degli strumenti
60
60
 
61
- Esistono diverse buone librerie per l'affinamento di LLM. Ognuna di esse è ottima per cose diverse:
61
+ Esistono diverse buone librerie per l'affinamento di LLM. Ognuna di esse è ottima in ambiti diversi:
62
62
 
63
- - **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)**: se ti piacciono le configurazioni YAML e desideri una community di ricette da cui copiare.
64
- - **[LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)**: se desideri DPO/PPO/RLHF e un'interfaccia utente web.
65
- - **[Unsloth](https://github.com/unslothai/unsloth)**: se hai bisogno dell'addestramento più rapido possibile e utilizzi una famiglia di modelli supportata.
66
- - **[torchtune](https://github.com/pytorch/torchtune)**: se desideri le ricette PyTorch native di Meta che puoi modificare.
63
+ - **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)** — se ti piacciono le configurazioni YAML e desideri una community di ricette da cui copiare
64
+ - **[LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)** — se vuoi DPO/PPO/RLHF e un'interfaccia utente web
65
+ - **[Unsloth](https://github.com/unslothai/unsloth)** — se hai bisogno dell'addestramento più rapido possibile e utilizzi una famiglia di modelli supportata
66
+ - **[torchtune](https://github.com/pytorch/torchtune)** — se desideri le ricette PyTorch native di Meta che puoi modificare
67
67
 
68
- Backpropagate è l'opzione mancante: **un'API Python di 3 righe per gli utenti singoli su una singola GPU di consumo che desiderano addestrare un adattatore e caricarlo.** Nessun YAML, nessuna GUI, nessun RL online (PPO/GRPO), nessun nodo multiplo. Solo il ciclo di cui tutti hanno realmente bisogno e il passaggio di esportazione che crea problemi.
68
+ Backpropagate è l'opzione mancante: **un'API Python a 3 righe per gli utenti singoli su una singola GPU consumer che desiderano addestrare un adattatore e caricarlo.** Nessun YAML, nessuna GUI, nessun RL online (PPO/GRPO), nessun nodo multiplo. Solo il ciclo di cui tutti hanno realmente bisogno e il passaggio di esportazione che crea problemi.
69
69
 
70
- Se hai provato una delle librerie di cui sopra e hai avuto problemi con la procedura di configurazione dei file, o hai riscontrato una lacuna nella famiglia di modelli, o hai desiderato impostazioni predefinite per Windows, Backpropagate è la soluzione giusta per te.
70
+ Se hai provato una delle librerie sopra elencate e ti sei scontrato con la procedura del file di configurazione, o hai riscontrato un problema con la famiglia di modelli, o desideravi impostazioni predefinite per Windows, Backpropagate è quello che fa per te.
71
71
 
72
- ## Cosa puoi affinare su una GPU di consumo da 16 GB
72
+ ## Cosa puoi ottimizzare su una singola GPU
73
73
 
74
- Ecco i limiti pratici su una scheda da 16 GB (RTX 4080 / 5080 / 4070 Ti Super):
74
+ Backpropagate dimensiona l'esecuzione in base alla tua scheda. Ecco i limiti pratici su una GPU consumer da **32 GB** (RTX 5090) con 64 GB di RAM del sistema: la configurazione su cui viene eseguito il fine-tuning è la seguente:
75
75
 
76
- | Modello | Metodo | Stato |
76
+ | Dimensione del modello | Metodo | Stato su una scheda da 32 GB |
77
77
  |---|---|---|
78
- | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Buono. Lunghezza di sequenza completa, spazio sufficiente. |
79
- | SmolLM3-3B / Qwen2.5-3B / Llama-3.2-3B / Llama-3.2-1B | `mode="full"` (affinamento completo) | v1.4: passa `--mode=full` in `backprop train` o `Trainer(..., mode="full")`. Carica i pesi a precisione completa (bf16): niente 4 bit, niente adattatore; il checkpointing del gradiente e l'Adam a 8 bit a pagine mantengono l'impronta entro i 16 GB. |
80
- | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Standard. ~7-8 GB. Impostazioni predefinite di Backpropagate. |
81
- | Llama-3 13B | QLoRA + sample packing | Stretto, ma funziona. Utilizza sequenze più brevi. |
82
- | Mixtral 8x7B (47 miliardi di parametri totali) | — | Fuori portata: la quantizzazione a 2 bit (AQLM / QuIP#) interrompe il contratto di adattatore unificabile + esportazione GGUF, quindi è stata abbandonata nella [breve descrizione della traiettoria v1.5](docs/V1_5_BRIEF.md). Su una scheda da 16 GB, utilizza una base ≤8B. |
78
+ | 7B (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | QLoRA | Ottimo — circa 7–8 GB. Lunghezza della sequenza completa, ampio margine di manovra. |
79
+ | **14B** (Qwen2.5-14B) | QLoRA | **Il punto ideale per l'uso quotidiano — circa 8,5 GB**, misurato. rank/alpha 32, paged 8-bit AdamW, 4096 ctx. |
80
+ | 24B (Mistral-Small-24B) | QLoRA | Circa 18 GB. Si adatta con un buon margine a 4096 ctx. |
81
+ | **32B** (Qwen2.5-32B) | QLoRA | **Si adatta appena — circa 26 GB** con `max_len 2048` + paged 8-bit AdamW. Limite massimo. |
82
+ | ≤6B | `mode="full"` (affinamento completo) | Fine-tuning completo su GPU pura: pesi bf16, nessun adattatore. Il limite massimo per la scheda è di 6B su 32 GB. |
83
+ | **Classe 7B** (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | `mode="full" --full-ft-offload` | **Fine-tuning completo tramite CPU-offload FSDP2:** scarica i parametri e l'ottimizzatore nella RAM del sistema da 64 GB. Più lento (limitato dalla larghezza di banda); Linux/WSL2. |
83
84
 
84
- `mode="full"` supporta modelli fino a **4 miliardi di parametri**. Le quattro impostazioni nella riga di affinamento completo sopra sono autentici ~3B (numero effettivo di parametri 3,08–3,24B) e si adattano a una scheda da 16 GB. La classe 3,8–4B (Phi-4-mini-3,8B, Qwen-3.5-4B) è accettata anche dal limite massimo, ma richiede una scheda da **24 GB o superiore** per l'affinamento completo: i soli pesi e i gradienti si avvicinano già a 16 GB prima dell'ottimizzatore e delle attivazioni, quindi su una scheda da 16 GB utilizza `mode="lora"` per questi (si trovano nella riga LoRA). I modelli >4B restituiscono `RUNTIME_FULL_FT_MODEL_TOO_LARGE`.
85
+ Due cose per cui la maggior parte delle librerie per singola GPU ti indirizzano altrove: **QLoRA da 24–34B** e **fine-tuning completo su scheda singola di classe 7B**. Backpropagate esegue queste operazioni su una singola scheda consumer, quindi esporta direttamente il risultato su Ollama.
85
86
 
86
- La quantizzazione a 2 bit (AQLM / QuIP#) è **fuori portata**. È stata prevista per la v1.4, quindi è stata abbandonata nella [breve descrizione della traiettoria v1.5](docs/V1_5_BRIEF.md): una base a 2 bit non può essere unita in modo pulito ai pesi a precisione completa, il che interrompe il contratto di adattatore unificabile → GGUF → Ollama (il punto principale della pipeline). Le leve di ottimizzazione che Backpropagate offre sono invece il percorso di calcolo FP8 v1.5 (`--fp8`, Blackwell/Hopper) e `mode="full"` per i modelli ≤4B: entrambi rimangono unificabili ed esportabili.
87
+ **Il limite massimo per il fine-tuning completo è adattato alla scheda.** Deriva dall'aritmetica della memoria di addestramento a 4 termini (pesi + gradienti + ottimizzatore + attivazioni) rispetto alla VRAM *rilevata*: **16 GB → 4B, 24 GB → 5B, 32 GB → 6B** su GPU pura. `--full-ft-offload` lo estende a **classe 7B** scaricando i parametri e lo stato dell'ottimizzatore nella RAM del sistema tramite FSDP2 `fully_shard` + `CPUOffloadPolicy` (più lento, limitato dalla larghezza di banda PCIe/CPU; richiede circa 64 GB di RAM del sistema e un backend NCCL, ovvero Linux/WSL2). Sovrascrivi esplicitamente il limite con `--full-ft-ceiling-billions`. Un modello che supera anche il limite di offload termina con `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, indicando la soluzione (`--full-ft-offload` o LoRA/QLoRA). Consulta [la pagina completa del manuale sul fine-tuning](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) per i calcoli della VRAM e il confronto sulla qualità di Biderman 2024 / Thinking Machines 2025.
87
88
 
88
- Per i modelli da 3B e inferiori, l'affinamento completo (non solo LoRA) è fattibile su 16 GB ed è ora disponibile nella v1.4 come `mode="full"`. Passa `Trainer(..., mode="full")` o `backprop train --mode=full --model phi-4-mini-3.8b` per abilitarlo. Un blocco rigido rifiuta la modalità per i modelli > 4B con `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, indicando LoRA e le impostazioni predefinite inferiori a 4B come opzioni di ripristino. Consulta [la pagina del manuale sull'affinamento completo](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) per i calcoli di configurazione e il confronto di qualità Biderman 2024 / Thinking Machines 2025. Per i modelli da 7B in su, l'affinamento completo richiede una GPU da 24 GB o superiore: valuta la possibilità di noleggiare un'A100 nel cloud o attieniti a LoRA, che le ricerche più recenti dimostrano che corrisponde alla qualità dell'affinamento completo nella maggior parte delle attività post-addestramento (vedi [la sezione anti-presentazione](#what-backpropagate-is-not-for) per le citazioni).
89
+ ### Si adatta fino a 16 GB
90
+
91
+ Il limite di 16 GB (RTX 4080 / 5080 / 4070 Ti Super) offre comunque ottime prestazioni: QLoRA da 7B con circa 7–8 GB e vero fine-tuning completo di un modello reale da ~3B (SmolLM3-3B, Qwen2.5-3B, Llama-3.2-3B/1B) all'interno di 16 GB tramite `mode="full"` (pesi bf16 + checkpointing del gradiente + paged 8-bit AdamW). Lo stesso codice seleziona la dimensione del batch e il limite massimo per il fine-tuning completo in base alla scheda rilevata, senza flag da modificare tra le diverse configurazioni.
92
+
93
+ La quantizzazione a 2 bit (AQLM / QuIP#) è **fuori dall'ambito**: una base a 2 bit non può essere unita correttamente ai pesi in piena precisione, il che interrompe il contratto di esportazione dell'adattatore unificabile → GGUF → Ollama (che è lo scopo principale della pipeline). Invece, Backpropagate offre i seguenti strumenti: QLoRA, `mode="full"`, `--full-ft-offload` e il percorso di calcolo FP8 (`--fp8`, Blackwell/Hopper), tutti che rimangono unificabili ed esportabili.
89
94
 
90
95
  ## Per cosa NON è adatto Backpropagate
91
96
 
92
- Se il tuo caso d'uso è tra quelli elencati di seguito, otterrai risultati migliori con una libreria diversa: Backpropagate non è la scelta giusta e cercare di farlo funzionare costerebbe più che semplicemente utilizzare lo strumento giusto. Leggere questa sezione prima di iniziare ti eviterà di installare e poi abbandonare il progetto:
97
+ Se il tuo caso d'uso rientra nelle seguenti categorie, otterrai risultati migliori con una libreria diversa: Backpropagate non è la scelta giusta e cercare di farlo funzionare costerebbe più che semplicemente utilizzare lo strumento corretto. Leggere questa sezione prima di iniziare ti eviterà di installare e poi abbandonare il progetto:
93
98
 
94
- - **Ottimizzazione completa dei parametri per modelli da 7B+** — Backpropagate utilizza LoRA/QLoRA, che addestra un piccolo adattatore anziché aggiornare tutti i pesi. Per i modelli da 7B e superiori, l'ottimizzazione completa richiede 24 GB o più di memoria GPU e non è adatta per una scheda consumer da 16 GB. Per i modelli da 3B e inferiori, l'ottimizzazione completa è fattibile con 16 GB ed è disponibile nella versione 1.4 come `mode="full"` (passare `Trainer(..., mode="full")` o `--mode=full` dalla riga di comando; un controllo rigido genera `RUNTIME_FULL_FT_MODEL_TOO_LARGE` per i modelli > 4B e nomina LoRA + i preset inferiori a 4B come soluzioni alternative). Nel complesso: le ricerche recenti ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) mostrano che LoRA, con la configurazione corretta, corrisponde alla qualità dell'ottimizzazione completa nella maggior parte delle attività di post-addestramento (seguire le istruzioni, adattamento al dominio, personalità/stile) con il 67% della potenza di calcolo. Quindi, per il lavoro che la maggior parte degli utenti desidera, non si perde nulla utilizzando LoRA. `mode="full"` è disponibile per i casi in cui si è misurata una differenza di qualità e si è deciso di utilizzare una maggiore potenza di calcolo. Se si ha realmente bisogno dell'ottimizzazione completa di un modello da 7B+, utilizzare direttamente HuggingFace `transformers.Trainer` su una scheda da 24 GB o superiore.
95
- - **RL online — PPO / GRPO / RLVR** — Backpropagate esegue un addestramento SFT a fase singola più un'ottimizzazione delle preferenze senza riferimento (ORPO è disponibile nella versione 1.5; SimPO/KTO sono in programma). Ciò che *non* fa è l'apprendimento per rinforzo online: PPO, GRPO o RLVR, che richiedono un modello di ricompensa o un ciclo di generazione e valutazione in aggiunta alla fase di addestramento. Per questi, utilizzare direttamente TRL o LLaMA-Factory. (L'ottimizzazione delle preferenze senza riferimento si adatta all'ambito a fase singola perché non è necessario mantenere un modello di riferimento separato in memoria; vedere la nota ORPO in [Guida rapida](#guida-rapida)).
96
- - **Addestramento multi-nodo** — una singola GPU su una singola macchina. L'addestramento multi-GPU su una singola macchina funziona (tramite `accelerate launch`), ma non è ufficialmente supportato.
97
- - **Addestramento macOS con CUDA** — Apple Silicon non dispone di CUDA, quindi il percorso CUDA deve essere eseguito su una macchina Linux o Windows con una GPU NVIDIA. È comunque possibile eseguire il modello addestrato su un Mac tramite Ollama. **Novità nella versione 1.5:** un percorso MLX sperimentale (`--backend mlx`) addestra un adattatore LoRA nativamente su Apple Silicon — vedere [Apple Silicon (MLX)](#apple-silicon-mlx--sperimentale-v15). È solo per LoRA-SFT ed è stato implementato, ma non ancora verificato su hardware reale, quindi per qualsiasi cosa oltre a un LoRA SFT (ORPO, ottimizzazione completa, FP8, esecuzioni multiple), è comunque consigliabile utilizzare il percorso CUDA.
98
- - **Qualsiasi cosa al di fuori delle famiglie di modelli testate** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Altri modelli spesso funzionano, ma non sono inclusi nei test CI.
99
+ - **Ottimizzazione fine con tutti i parametri oltre il limite di offload (≈13B+)** — Esegue la retropropagazione dell'ottimizzazione fine completa fino a **~6 GB di GPU pura e ~7 GB tramite `--full-ft-offload`** su una scheda da 32 GB (vedere [la sezione](#what-you-can-fine-tune-on-one-gpu)). Un'ottimizzazione fine *veramente completa* di un modello da 13B+ supera tale limite: richiede FSDP multi-GPU o una scheda più grande (utilizzare `transformers.Trainer` su più GPU oppure noleggiare una A100/H100). Prima di utilizzare tutta questa potenza di calcolo, tuttavia: ricerche recenti ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) dimostrano che LoRA, con la configurazione corretta, offre una qualità di ottimizzazione fine paragonabile a quella completa per la maggior parte delle attività post-addestramento (seguimento delle istruzioni, adattamento al dominio, personalità/stile) con circa il 67% della potenza di calcolo necessaria. Quindi, QLoRA fino a 34B, che Backpropagate esegue su una singola scheda, non comporta alcuna perdita per il lavoro che la maggior parte degli utenti desidera svolgere.
100
+ - **Apprendimento per rinforzo online — PPO / GRPO / RLVR** — Backpropagate esegue l'ottimizzazione fine monostadio (SFT) più l'ottimizzazione delle preferenze senza riferimenti (ORPO nella versione 1.5; SimPO + KTO nella versione 1.6). Non esegue l'apprendimento per rinforzo online — PPO, GRPO o RLVR —, che richiede un modello di ricompensa o un ciclo di generazione e valutazione in aggiunta alla fase di addestramento. Per queste attività, utilizzare direttamente TRL o LLaMA-Factory. (L'ottimizzazione delle preferenze senza riferimenti si adatta all'ambito monostadio perché non è necessario memorizzare un modello di riferimento separato; vedere la nota su ORPO nella sezione [Quick Start](#quick-start).)
101
+ - **Addestramento multi-nodo** — una singola GPU su una sola macchina. L'utilizzo di più GPU su una singola macchina funziona (tramite `accelerate launch`), ma non è ufficialmente supportato.
102
+ - **Addestramento macOS con CUDA** — Apple Silicon non dispone di CUDA, quindi il percorso CUDA viene eseguito su un sistema Linux o Windows con una GPU NVIDIA. È comunque possibile eseguire il modello addestrato su un Mac tramite Ollama. Un percorso MLX **sperimentale e non verificato** (`--backend mlx`) addestra in modo nativo un adattatore LoRA su Apple Silicon — vedere [Apple Silicon (MLX)](#apple-silicon-mlx--unverified-preview). È solo per LoRA-SFT e **non è stato testato su hardware reale** (nessun supporto), quindi, per qualsiasi cosa oltre a un SFT LoRA (ORPO, ottimizzazione fine completa, FP8, esecuzioni multiple), è consigliabile utilizzare il percorso CUDA.
103
+ - **Qualsiasi modello al di fuori delle famiglie di modelli testate** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Altri modelli spesso funzionano, ma non sono inclusi nei test CI.
99
104
 
100
- Se hai bisogno di una di queste cose, utilizza una delle librerie elencate sopra. Sono più adatte a questo scopo.
105
+ Se si necessita di una qualsiasi di queste funzionalità, utilizzare una delle librerie elencate sopra. Sono più adatte a questo scopo.
101
106
 
102
107
  ## Cosa offre Backpropagate
103
108
 
104
- Quattro cose, in una singola installazione:
109
+ Quattro elementi, in un'unica installazione:
105
110
 
106
- **1. Una vera API a 3 righe che funziona senza un file di configurazione.**
107
- Lo snippet all'inizio di questo README viene eseguito dall'inizio alla fine. Nessuna configurazione `accelerate`, nessun YAML, nessuna sovrascrittura Hydra. Basta `Trainer(model).train(data)` e si ottiene un modello ottimizzato.
111
+ **1. Una vera API di 3 righe che funziona senza un file di configurazione.**
112
+ Lo snippet all'inizio di questo README viene eseguito dall'inizio alla fine. Non è necessario `accelerate config`, YAML o override Hydra. Basta `Trainer(model).train(data)` e si ottiene un modello ottimizzato.
108
113
 
109
114
  **2. Windows che funziona davvero.**
110
- La maggior parte delle librerie ML trattano Windows come un ripensamento. Backpropagate è testata in modo completo su Windows + RTX 5080. La libreria gestisce le peculiarità del runtime per te: sa come pre-tokenizzare i dati in modo che l'elaborazione parallela di Windows non si blocchi, disabilita automaticamente xformers sulle schede RTX 40/50 dove causerebbe problemi e seleziona le impostazioni del caricatore di dati che non causano errori. Non è necessario sapere nulla di tutto questo. Funziona semplicemente.
115
+ La maggior parte delle librerie ML trattano Windows come un'aggiunta successiva. Backpropagate viene testata in modo completo su Windows + RTX 5080. La libreria gestisce le peculiarità dell'ambiente di runtime: sa come pre-tokenizzare i dati in modo che l'elaborazione parallela di Windows non si blocchi, disabilita automaticamente xformers sulle schede RTX 40/50 dove causerebbe problemi e seleziona le impostazioni del caricatore di dati che non causano errori. Non è necessario sapere nulla di tutto questo. Funziona semplicemente.
111
116
 
112
- **3. Progettato per esecuzioni non presidiate.**
117
+ **3. Progettato per esecuzioni senza supervisione.**
113
118
  L'addestramento richiede ore. Non si vuole doverlo monitorare costantemente. Backpropagate è progettata per essere lasciata in esecuzione:
114
119
 
115
- - Se si esaurisce la memoria GPU, dimezza automaticamente la dimensione del batch e riprova, fino a tre volte. Nessuna regolazione manuale.
116
- - Se la GPU diventa troppo calda, si mette in pausa fino a quando le cose non si raffreddano e poi continua.
117
- - Ogni checkpoint viene scritto in modo atomico: se il laptop si blocca durante il salvataggio, il checkpoint precedente e valido rimane intatto.
120
+ - Se la memoria della GPU si esaurisce, dimezza automaticamente le dimensioni del batch e riprova, fino a tre volte. Non è necessario effettuare alcuna regolazione manuale.
121
+ - Se la GPU diventa troppo calda, si mette in pausa finché non si raffredda e poi continua.
122
+ - Ogni checkpoint viene scritto in modo atomico: se il laptop si blocca durante il salvataggio, il checkpoint precedente valido rimane intatto.
118
123
  - Ogni esecuzione di addestramento riceve un ID univoco che viene stampato su ogni riga del log, su ogni checkpoint e su ogni voce di Weights & Biases. Se qualcosa va storto, un singolo ID consente a un manutentore di correlare tutto.
119
- - Gli errori sono accompagnati da codici stabili (`RUNTIME_GPU_OOM`, `DEP_OLLAMA_REGISTRATION_FAILED`, ecc.) in modo da poter cercare nei log e nella [guida alla risoluzione dei problemi](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) per trovare la soluzione. I guasti specifici di CUDA hanno una [pagina dedicata alla risoluzione dei problemi di CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/).
124
+ - Gli errori sono accompagnati da codici stabili (`RUNTIME_GPU_OOM`, `DEP_OLLAMA_REGISTRATION_FAILED`, ecc.) in modo che sia possibile cercare nei log e nella [guida alla risoluzione dei problemi](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) per trovare la soluzione. I guasti specifici di CUDA hanno una pagina dedicata per la [risoluzione dei problemi di CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/).
120
125
 
121
126
  **4. Un solo comando, dall'adattatore addestrato a `ollama run`.**
122
127
  Molte librerie addestrano un modello. Poche di esse si mettono di mezzo quando si vuole effettivamente utilizzarlo. Backpropagate esporta in GGUF (il formato utilizzato da Ollama) e registra un modello Ollama con un solo comando. Si passa da "addestramento completato" a "posso chattare con il mio modello ottimizzato" in circa 30 secondi.
123
128
 
124
129
  ## Guida rapida
125
130
 
126
- Il repository include un piccolo set di dati di esempio in modo che lo snippet all'inizio di questo README funzioni su un'installazione pulita:
131
+ Il repository include un piccolo set di dati di esempio, quindi lo snippet all'inizio di questo README funziona su una nuova installazione:
127
132
 
128
133
  ```bash
129
134
  pipx install "backpropagate[standard]"
@@ -136,18 +141,18 @@ trainer.export('gguf', quantization='q4_k_m')
136
141
  "
137
142
  ```
138
143
 
139
- Questo addestra un adattatore Qwen 2.5 7B su 5 brevi conversazioni in formato ShareGPT, quindi esporta il risultato in GGUF. Per i propri dati, formattare il file JSONL con un esempio per riga:
144
+ Questo addestra un adattatore Qwen 2.5 da 7B su 5 brevi conversazioni in formato ShareGPT, quindi esporta il risultato in GGUF. Per i propri dati, formattare il file JSONL con un esempio per riga:
140
145
 
141
146
  ```jsonl
142
147
  {"conversations": [{"from": "human", "value": "What is Python?"}, {"from": "gpt", "value": "A programming language."}]}
143
148
  {"conversations": [{"from": "human", "value": "Explain recursion."}, {"from": "gpt", "value": "A function that calls itself."}]}
144
149
  ```
145
150
 
146
- I formati Alpaca (`instruction` / `output`), OpenAI chat (`messages`) e testo semplice funzionano anche: Backpropagate rileva automaticamente il formato.
151
+ I formati Alpaca (`instruction` / `output`), OpenAI chat (`messages`) e testo semplice funzionano anche; Backpropagate rileva automaticamente il formato.
147
152
 
148
- ### Ottimizzazione delle preferenze (ORPO)
153
+ ### Ottimizzazione delle preferenze (ORPO, SimPO, KTO)
149
154
 
150
- Novità nella versione 1.5: addestrare con le preferenze anziché con semplici dimostrazioni. ORPO non richiede riferimenti ed è a fase singola: integra il segnale di preferenza nella fase SFT, quindi non è necessario un modello di ricompensa o di riferimento separato e la struttura a 3 righe rimane invariata. Passare `--method orpo` (CLI) o `method="orpo"` (Python) e fornire un set di dati di righe `{prompt, chosen, rejected}` (o solo `{chosen, rejected}`):
155
+ Addestrare sulle preferenze anziché su semplici dimostrazioni. ORPO non richiede riferimenti ed è una singola fase: integra il segnale di preferenza nella fase SFT, quindi non esiste un modello di ricompensa o di riferimento separato e la struttura a 3 righe rimane invariata. Passare `--method orpo` (CLI) o `method="orpo"` (Python) e fornire un set di dati con righe nel formato `{prompt, chosen, rejected}` (o solo `{chosen, rejected}`):
151
156
 
152
157
  ```jsonl
153
158
  {"prompt": "What is Python?", "chosen": "A high-level programming language known for readability.", "rejected": "idk look it up"}
@@ -166,15 +171,19 @@ trainer.export("gguf", quantization="q4_k_m")
166
171
  backprop train --data preferences.jsonl --method orpo --steps 100
167
172
  ```
168
173
 
169
- Il tasso di apprendimento predefinito si riduce automaticamente a `8e-6` per ORPO (la perdita è più marcata rispetto al semplice SFT); regola `--orpo-beta` (predefinito `0.1`) per ponderare la penalità del rapporto di probabilità. Nella versione 1.5, ORPO è impostato su `mode="lora"`. SimPO e KTO sono previsti come sviluppi successivi; per l'RL online (PPO/GRPO), consulta [What Backpropagate is NOT for](#what-backpropagate-is-not-for).
174
+ Il tasso di apprendimento predefinito si riduce automaticamente a `8e-6` per ORPO (la perdita è più marcata rispetto al semplice SFT); regola `--orpo-beta` (predefinito `0.1`) per ponderare la penalità del rapporto delle probabilità. ORPO è solo in modalità `"lora"`.
175
+
176
+ **Novità nella versione 1.6: SimPO e KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) è indipendente dai dati di riferimento, utilizza una ricompensa normalizzata in base alla lunghezza e accetta gli stessi dati a coppie `{prompt, scelto, rifiutato}` di ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) accetta dati **non a coppie** `{prompt, completamento, etichetta}` — valutazioni positive/negative per ogni esempio — per l'ampia classe di feedback che non sono coppie A/B curate; bilancia automaticamente i pesi della perdita desiderabile/indesiderabile in base al conteggio delle etichette. Entrambi sono solo in modalità `"lora"` e rimangono nell'ambito SFT su una singola GPU (nessun modello di riferimento separato). Consulta il [manuale sull'ottimizzazione delle preferenze](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) per capire quale utilizzare. Per l'RL online (PPO/GRPO), consulta [Cosa NON è Backpropagate](#what-backpropagate-is-not-for).
170
177
 
171
178
  ### SFT con traccia del ragionamento (distillazione R1)
172
179
 
173
- Nuovo nella versione 1.5: esegui la distillazione di un modello di ragionamento in modo semplice. Passa `--reasoning-trace` (CLI) o `Trainer(..., reasoning_trace=True)` (Python) e fornisci tracce che mantengano una catena di pensiero `<think>...</think>` all'interno del turno dell'assistente: la metà di SFT puro di [DeepSeek-R1](https://arxiv.org/abs/2501.12948), senza necessità di RL. Backpropagate mantiene `<think>` nell'obiettivo di addestramento, elimina le tracce vuote o troppo lunghe (filtraggio della lunghezza della traccia) e aumenta il valore predefinito di `max_seq_length` a 8192 per la catena di pensiero più lunga. In modo cruciale, `<think>` rimane in **testo semplice**: nessun token speciale, nessuna ridimensionamento dell'embedding, quindi il GGUF unificato può comunque essere esportato su Ollama come qualsiasi altro modello ottimizzato. Solo SFT. Consulta la [ricetta reasoning-trace](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/#reasoning-trace-sft-r1-distillation) per la forma del set di dati e i token regolabili.
180
+ Novità nella versione 1.5: distilla un modello di ragionamento in modo semplice. Passa `--reasoning-trace` (CLI) o `Trainer(..., reasoning_trace=True)` (Python) e fornisci tracce che mantengono una catena di pensiero `<think>...</think>` all'interno del turno dell'assistente — la metà SFT pura della distillazione di [DeepSeek-R1](https://arxiv.org/abs/2501.12948), senza necessità di RL. Backpropagate mantiene `<think>` nell'obiettivo di addestramento, elimina le tracce vuote o troppo lunghe (filtraggio della lunghezza delle tracce) e aumenta il valore predefinito di `max_seq_length` a 8192 per la catena di pensiero più lunga. Fondamentalmente, `<think>` rimane in **testo semplice** — nessun token speciale, nessuna ridimensionamento dell'embedding — quindi l'adattatore unificato esporta ancora in GGUF e può essere utilizzato con Ollama come qualsiasi altro modello ottimizzato. Solo SFT. Consulta la [ricetta per la traccia del ragionamento](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/#reasoning-trace-sft-r1-distillation) per la forma del set di dati e i token regolabili.
181
+
182
+ ### Apple Silicon (MLX) — anteprima non verificata
174
183
 
175
- ### Apple Silicon (MLX) — sperimentale, versione 1.5
184
+ > ⚠️ **Anteprima non verificata: non fa parte delle funzionalità supportate.** Il percorso MLX è stato creato ed è stato sottoposto a test unitari, ma **non** è stato testato su hardware Apple Silicon reale (`mlx-lm` è disponibile solo per Apple e non può essere eseguito sui sistemi NVIDIA su cui viene sviluppato Backpropagate). Considerare tutto quanto segue come sperimentale, utilizzarlo a proprio rischio e [segnalare eventuali anomalie](#reporting-bugs) se lo si esegue su un Mac della serie M.
176
185
 
177
- Nuovo nella versione 1.5: **un'API, due percorsi.** CUDA rimane il backend canonico e verificato; MLX è un secondo percorso che esegue l'addestramento su un Mac della serie M tramite il toolchain [`mlx_lm.lora`](https://github.com/ml-explore/mlx-lm) di Apple (memoria unificata, senza CUDA). La stessa struttura di 3 righe seleziona il percorso in base all'hardware: `backend='auto'` (predefinito) indirizza a CUDA su NVIDIA e a MLX su Apple Silicon, quindi le configurazioni CUDA esistenti sono identiche a livello di byte.
186
+ Novità nella versione 1.5: **un'API, due opzioni.** CUDA rimane il backend canonico e verificato; MLX è una seconda opzione che esegue l'addestramento su un Mac della serie M tramite lo strumento [`mlx_lm.lora`](https://github.com/ml-explore/mlx-lm) di Apple (memoria unificata, nessuna necessità di CUDA). La stessa struttura a 3 righe seleziona l'opzione in base all'hardware: `backend='auto'` (predefinito) indirizza verso CUDA su NVIDIA e verso MLX su Apple Silicon, quindi le configurazioni CUDA esistenti sono identiche.
178
187
 
179
188
  ```python
180
189
  from backpropagate import Trainer
@@ -188,26 +197,26 @@ trainer.train("examples/quickstart.jsonl", steps=100)
188
197
  backprop train --data my_data.jsonl --backend mlx --steps 100
189
198
  ```
190
199
 
191
- Nella versione 1.5, il percorso MLX è **solo LoRA SFT** — nessun ORPO, nessun FP8, nessun `mode='full'`, nessun addestramento multiplo su MLX per ora (ognuno viene rifiutato con `CONFIG_INVALID_SETTING`; utilizza `backend='cuda'`/`'auto'` su una macchina NVIDIA per queste opzioni). L'adattatore risultante è in formato safetensors e può essere esportato su Ollama tramite lo stesso percorso del percorso CUDA.
200
+ Nella versione 1.5, l'opzione MLX è **solo SFT LoRA** — nessun ORPO, nessun FP8, nessuna modalità `'full'`, nessun addestramento multiplo su MLX (ognuno viene rifiutato con `CONFIG_INVALID_SETTING`; utilizza `backend='cuda'`/`'auto'` su una macchina NVIDIA per queste opzioni). L'adattatore risultante è in formato safetensors e può essere esportato verso Ollama tramite lo stesso percorso dell'opzione CUDA.
192
201
 
193
- > ⚠️ **Stato reale:** il percorso MLX viene fornito nella versione 1.5 **costruito + testato con unità (simulato)** ma **non ancora verificato su Apple Silicon reale** — `mlx-lm` è solo per Apple e non potrebbe essere eseguito sulla macchina NVIDIA su cui è stato creato questo progetto. Consideralo come sperimentale (lo stesso approccio del percorso FP8) e, per favore, [segnala eventuali anomalie](#reporting-bugs) una volta che sarà in esecuzione su un Mac della serie M. Forzare `--backend mlx` su un host non Apple genera un errore con `CONFIG_INVALID_SETTING`; la mancanza del toolchain `mlx_lm` su un Mac genera `DEP_MLX_UNAVAILABLE`.
202
+ > Forzare `--backend mlx` su un host non Apple genera l'errore `CONFIG_INVALID_SETTING`; la mancanza di una toolchain `mlx_lm` su un Mac genera `DEP_MLX_UNAVAILABLE`.
194
203
 
195
- Per flussi di lavoro end-to-end più completi (ottimizzazione e caricamento su HF-Hub, ripresa dopo esaurimento della memoria, SLAO multi-esecuzione in una lunga campagna, ecc.), consulta la [pagina delle ricette del manuale](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
204
+ Per flussi di lavoro end-to-end più completi (ottimizzazione e caricamento su HF Hub, ripresa dopo esaurimento della memoria, SLAO multi-esecuzione in una lunga campagna, ecc.), consulta la [pagina delle ricette del manuale](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
196
205
 
197
206
  ### Interfaccia utente web (opzionale)
198
207
 
199
- Se preferisci fare clic invece di digitare Python, installa il componente aggiuntivo dell'interfaccia utente e avvia:
208
+ Se preferisci fare clic invece di digitare in Python, installa il pacchetto aggiuntivo dell'interfaccia utente e avvia:
200
209
 
201
210
  ```bash
202
211
  pipx install "backpropagate[ui]"
203
212
  backprop ui --port 7862
204
213
  ```
205
214
 
206
- Si apre un'interfaccia web locale all'indirizzo `http://localhost:7862` per sfogliare i set di dati, convalidare i formati e assemblare visivamente una configurazione di addestramento. L'addestramento stesso viene eseguito tramite `backprop train` (l'addestramento basato sull'interfaccia utente è in programma: il pulsante Avvia mostra attualmente tale nota). L'interfaccia utente è locale per impostazione predefinita. Per esporla ad altri dispositivi, consulta [Web UI](#web-ui) di seguito per il contratto di sicurezza `--share` + `--auth`.
215
+ Si apre un'interfaccia web locale all'indirizzo `http://localhost:7862` per sfogliare i set di dati, convalidare i formati e assemblare visivamente una configurazione di addestramento. L'addestramento stesso viene eseguito tramite `backprop train` (l'addestramento basato sull'interfaccia utente è in programma — il pulsante Avvia mostra attualmente tale nota). L'interfaccia utente è locale per impostazione predefinita. Per renderla accessibile da altri dispositivi, consulta la sezione [Interfaccia utente web](#web-ui) qui sotto per il contratto di sicurezza `--share` + `--auth`.
207
216
 
208
217
  ## Addestramento multi-esecuzione
209
218
 
210
- Se desideri eseguire l'ottimizzazione in modo incrementale su più set di dati (ad esempio, se ricevi nuovi dati di addestramento ogni settimana e desideri aggiungerli senza dimenticare ciò che hai appreso in precedenza), la modalità `multi_run` di Backpropagate è ciò che fa per te:
219
+ Se desideri ottimizzare in modo incrementale su più set di dati — ad esempio, se ricevi nuovi dati di addestramento ogni settimana e vuoi aggiungerli senza dimenticare ciò che hai imparato prima — la modalità `multi_run` di Backpropagate è quella giusta per te:
211
220
 
212
221
  ```python
213
222
  from backpropagate import Trainer
@@ -222,7 +231,7 @@ result = trainer.multi_run(
222
231
  )
223
232
  ```
224
233
 
225
- Questo esegue cinque passaggi di addestramento, unendo l'adattatore tra le esecuzioni in modo da preservare le conoscenze precedenti incorporando al contempo nuovi esempi. La tecnica si basa su recenti ricerche sull'apprendimento continuo: consulta [References](#references) in fondo a questo file README.
234
+ Questo esegue cinque passaggi di addestramento, unendo l'adattatore tra le esecuzioni in modo da preservare le conoscenze precedenti e incorporare nuovi esempi. La tecnica si basa su recenti ricerche sull'apprendimento continuo — consulta la sezione [Riferimenti](#references) in fondo a questo file README.
226
235
 
227
236
  La versione CLI:
228
237
 
@@ -230,9 +239,9 @@ La versione CLI:
230
239
  backprop multi-run --data my_data.jsonl --runs 5 --steps 100 --samples 1000
231
240
  ```
232
241
 
233
- ## Riprendi da un checkpoint
242
+ ## Ripresa da un checkpoint
234
243
 
235
- Un addestramento di 5 esecuzioni che si interrompe alla quarta esecuzione può essere ripreso. Ogni sessione multi-esecuzione scrive l'ID dell'esecuzione nella cronologia e nel manifesto del checkpoint su disco, quindi riprendere da dove ti sei interrotto richiede un solo comando:
244
+ Un addestramento di 5 esecuzioni che si interrompe alla quarta esecuzione può essere ripreso. Ogni sessione multi-esecuzione scrive l'ID dell'esecuzione nella cronologia e nel manifesto dei checkpoint su disco, quindi riprendere da dove ti sei interrotto richiede un solo comando:
236
245
 
237
246
  ```bash
238
247
  backprop resume <run-id>
@@ -240,11 +249,11 @@ backprop multi-run --data ... --resume <run-id>
240
249
  backprop train --data ... --resume <run-id> # single-run resume
241
250
  ```
242
251
 
243
- Il comportamento predefinito di `backprop multi-run` (nessun `--resume`) rileva automaticamente una voce in corso nella stessa directory di output e la continua. Per forzare un nuovo inizio, punta a una directory di output nuova.
252
+ Il comportamento predefinito di `backprop multi-run` (nessun `--resume`) rileva automaticamente una voce in corso nella stessa directory di output e la continua. Per forzare un nuovo inizio, punta a una nuova directory di output.
244
253
 
245
254
  ## Cronologia dell'addestramento
246
255
 
247
- Ogni invocazione di `backprop train` e `backprop multi-run` registra una riga in `<output>/run_history.json`: modello utilizzato, set di dati, iperparametri, stato, perdita finale, cronologia delle perdite. Puoi elencare e ispezionare le esecuzioni passate:
256
+ Ogni invocazione di `backprop train` e `backprop multi-run` registra una riga in `<output>/run_history.json` — modello utilizzato, set di dati, iperparametri, stato, perdita finale, cronologia delle perdite. Puoi elencare e ispezionare le esecuzioni passate:
248
257
 
249
258
  ```bash
250
259
  backprop list-runs # last 20 runs
@@ -255,7 +264,7 @@ backprop show-run abcd1234 # detail view (partial ID is fine)
255
264
 
256
265
  ## Monitoraggio degli esperimenti
257
266
 
258
- Backpropagate rileva automaticamente i tracker di esperimenti installati (Weights & Biases, TensorBoard, MLflow) e li integra. Se `wandb` è installato e sei connesso, ogni esecuzione registra automaticamente su W&B con un nome di esecuzione che corrisponde all'ID di esecuzione su disco, in modo da poter cercare in W&B, nei tuoi log e in `run_history.json` utilizzando un unico identificatore.
267
+ Backpropagate rileva automaticamente i tracker di esperimenti installati (Weights & Biases, TensorBoard, MLflow) e li configura. Se `wandb` è installato e sei autenticato, ogni esecuzione registra automaticamente i dati su W&B con un nome che corrisponde all'ID dell'esecuzione salvato sul disco, in modo da poter effettuare ricerche su W&B, nei tuoi log e nel file `run_history.json` utilizzando un unico identificatore.
259
268
 
260
269
  ```bash
261
270
  pip install backpropagate[monitoring] # installs wandb + psutil
@@ -263,25 +272,25 @@ wandb login # one-time setup
263
272
  backprop train --data my_data.jsonl
264
273
  ```
265
274
 
266
- Sovrascrivi con `Trainer(report_to=["wandb"])`, `Trainer(report_to=["tensorboard"])` o `Trainer(report_to="none")` per disattivare.
275
+ È possibile sovrascrivere le impostazioni con `Trainer(report_to=["wandb"])`, `Trainer(report_to=["tensorboard"])` o `Trainer(report_to="none")` per disattivare la funzionalità.
267
276
 
268
277
  ## Interfaccia utente web
269
278
 
270
- L'interfaccia web Reflex è un'opzione: installala con `pipx install "backpropagate[ui]"` e avviala:
279
+ L'interfaccia web di Reflex è attivabile; installala con `pipx install "backpropagate[ui]"` e avviala:
271
280
 
272
281
  ```bash
273
282
  backprop ui --port 7862
274
283
  ```
275
284
 
276
- L'interfaccia utente viene eseguita localmente su `http://localhost:7862`. Oggi copre la metà del flusso di lavoro relativa alla **navigazione / convalida / configurazione**: puntala a un set di dati, controlla il formato e le statistiche rilevate automaticamente, scegli un modello e assembla una configurazione di esecuzione. **L'avvio dell'esecuzione viene eseguito dalla CLI** (`backprop train` / `backprop multi-run`); il pulsante Avvia nell'interfaccia utente mostra una nota che indica questo. L'addestramento basato sull'interfaccia utente è un successivo sviluppo: fino ad allora, l'interfaccia utente è il punto di accesso e la CLI è il trigger.
285
+ L'interfaccia utente viene eseguita localmente all'indirizzo `http://localhost:7862`. Attualmente, copre la metà del flusso di lavoro relativa a **esplorazione / convalida / configurazione**: punta l'interfaccia su un set di dati, verifica il formato e le statistiche rilevate automaticamente, seleziona un modello e crea una configurazione per l'esecuzione. **L'avvio dell'esecuzione viene eseguito dalla riga di comando** (`backprop train` / `backprop multi-run`); il pulsante "Avvia" nell'interfaccia utente visualizza una nota che indica dove avviare l'esecuzione. L'addestramento guidato dall'interfaccia utente è un aggiornamento futuro; per ora, l'interfaccia utente funge da punto di accesso e la riga di comando è il trigger.
277
286
 
278
- Per esporlo ad altri dispositivi (altre persone sulla tua rete, un URL pubblico, ecc.), devi associare `--share` (o `--host`) a `--auth`:
287
+ Per renderla accessibile ad altri dispositivi (altre persone sulla tua rete, un URL pubblico, ecc.), devi combinare `--share` (o `--host`) con `--auth`:
279
288
 
280
289
  ```bash
281
290
  backprop ui --share --auth alice:hunter2
282
291
  ```
283
292
 
284
- `backprop ui --share` senza `--auth` termina con un errore. Il motivo: `--share` pubblica un URL a cui chiunque su Internet può accedere e, senza autenticazione, ciò significa che chiunque può avviare la tua pipeline di addestramento e leggere il tuo token HuggingFace. Non è possibile disattivare questa funzione: se non vuoi impostare le credenziali, utilizza invece il port forwarding SSH:
293
+ `backprop ui --share` senza `--auth` genera un errore. Il motivo: `--share` pubblica un URL a cui chiunque su Internet può accedere e, in assenza di autenticazione, ciò significa che chiunque può controllare la tua pipeline di addestramento e leggere il tuo token HuggingFace. Non è possibile disattivare questa funzionalità; se non desideri impostare le credenziali, utilizza invece il port forwarding SSH:
285
294
 
286
295
  ```bash
287
296
  # On the client:
@@ -291,32 +300,32 @@ backprop ui # no --share
291
300
  # Then open http://localhost:7860 in your local browser
292
301
  ```
293
302
 
294
- Consulta [handbook/security.md](https://mcp-tool-shop-org.github.io/backpropagate/handbook/security/) per il modello completo delle minacce.
303
+ Consulta [handbook/security.md](https://mcp-tool-shop-org.github.io/backpropagate/handbook/security/) per la descrizione completa del modello di minaccia.
295
304
 
296
305
  Le operazioni di scrittura sul file system dall'interfaccia utente sono limitate a una singola directory:
297
306
 
298
307
  - Predefinito: `~/.backpropagate/ui-outputs`
299
308
  - Sovrascrittura: imposta `BACKPROPAGATE_UI__OUTPUT_DIR=/path/you/own`
300
- - La sovrascrittura viene convalidata tramite una lista di esclusione: i percorsi di sistema o di credenziali (`/etc`, `~/.ssh`, `~/.aws`, `C:\Windows\System32`, ecc.) vengono rifiutati.
309
+ - La sovrascrittura viene convalidata tramite una lista di esclusione: i percorsi di sistema o delle credenziali (`/etc`, `~/.ssh`, `~/.aws`, `C:\Windows\System32`, ecc.) vengono rifiutati.
301
310
 
302
311
  ## Note sulla piattaforma
303
312
 
304
- **Requisiti:** Python 3.10+ · GPU CUDA (8 GB+ di VRAM) · PyTorch 2.0+
313
+ **Requisiti:** Python 3.10+ · GPU CUDA (8 GB o più di VRAM) · PyTorch 2.0+
305
314
 
306
- Python 3.10 raggiungerà la fine del ciclo di vita a ottobre 2026 ed è previsto che venga eliminato nella versione 1.5. Per le nuove installazioni, preferisci Python 3.11 o 3.12: la versione 3.11 è quella più testata.
315
+ Python 3.10 è supportato almeno fino alla versione v1.6; il supporto terminerà a ottobre 2026 e la rimozione è prevista nella prima versione successiva. Per le nuove installazioni, preferisci Python 3.11 o 3.12: la versione 3.11 è quella più testata.
307
316
 
308
- Backpropagate gestisce le peculiarità di runtime dell'addestramento su diverse piattaforme, ma non può risolvere i problemi di installazione. I due più comuni sono:
317
+ Backpropagate gestisce le peculiarità di runtime dell'addestramento su diverse piattaforme, ma non può risolvere i problemi che si verificano durante l'installazione. I due più comuni sono:
309
318
 
310
- - **Pacchetto CUDA errato.** PyTorch viene pubblicato con un singolo pacchetto per ogni versione di CUDA. Se scegli quello sbagliato, otterrai silenziosamente PyTorch solo per CPU e l'addestramento sarà incredibilmente lento. Utilizza lo strumento di selezione dei pacchetti disponibile all'indirizzo <https://pytorch.org/get-started/locally/> per il tuo driver. Esegui `nvidia-smi` per visualizzare la versione del driver/CUDA.
311
- - **Windows + esportazione GGUF.** L'opzione `[export]` crea `llama-cpp-python` dal codice sorgente, che richiede Visual Studio Build Tools (componente C++) e CMake.
319
+ - **Pacchetto CUDA errato.** PyTorch viene pubblicato con un singolo pacchetto per ogni versione di CUDA. Se selezioni quello sbagliato, otterrai silenziosamente solo PyTorch per CPU e l'addestramento sarà estremamente lento. Utilizza lo strumento di selezione dei pacchetti disponibile all'indirizzo <https://pytorch.org/get-started/locally/> per la tua scheda grafica. Esegui `nvidia-smi` per visualizzare la versione del driver / CUDA.
320
+ - **Windows + esportazione GGUF.** L'opzione extra `[export]` crea `llama-cpp-python` dal codice sorgente, il che richiede Visual Studio Build Tools (componente C++) e CMake.
312
321
 
313
- **macOS:** il supporto per CUDA non è disponibile (nessuna CUDA): un `trainer.train()` con CUDA genera `DEP_GPU_NOT_AVAILABLE` e puoi eseguire l'adattatore addestrato su un Mac tramite Ollama. **Novità nella versione 1.5:** un'implementazione sperimentale MLX (`--backend mlx`, `pip install 'backpropagate[mlx]'`) addestra un adattatore LoRA in modo nativo su Apple Silicon tramite `mlx_lm.lora`: solo LoRA SFT e testato, ma non ancora verificato su hardware reale (vedi [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15)). Per il percorso CUDA o per ORPO / fine-tuning completo / FP8 / esecuzioni multiple, utilizza una macchina Linux o Windows con CUDA.
322
+ **macOS:** la configurazione CUDA non è supportata (nessuna CUDA); l'esecuzione di `trainer.train()` con una configurazione CUDA genera un errore `DEP_GPU_NOT_AVAILABLE` ed è possibile eseguire l'adattatore addestrato su un Mac tramite Ollama. **Novità nella versione v1.5:** una configurazione MLX sperimentale (`--backend mlx`, `pip install 'backpropagate[mlx]'`) esegue nativamente l'addestramento di un adattatore LoRA su Apple Silicon tramite `mlx_lm.lora`: solo SFT LoRA, e compilato e testato, ma non ancora verificato in condizioni reali (vedi [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15)). Per il percorso CUDA o per ORPO / fine-tuning completo / FP8 / esecuzioni multiple, utilizza una macchina Linux o Windows con CUDA.
314
323
 
315
- Consulta la [pagina della guida alla risoluzione dei problemi](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) per la guida completa alla risoluzione dei problemi di installazione e la [pagina dedicata alla risoluzione dei problemi di CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/) per i problemi relativi al driver / VRAM / xformers / bf16 rispetto a fp16.
324
+ Consulta la [pagina della guida alla risoluzione dei problemi](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) per la guida completa alla risoluzione dei problemi di installazione e la [pagina dedicata alla risoluzione dei problemi CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/) per i problemi relativi al driver / VRAM / xformers / bf16 rispetto a fp16.
316
325
 
317
- ## CLI
326
+ ## CLI (riga di comando)
318
327
 
319
- Ogni API Python ha un equivalente nella CLI:
328
+ Ogni API Python ha un corrispondente nella riga di comando:
320
329
 
321
330
  ```bash
322
331
  backprop train --data my_data.jsonl --model Qwen/Qwen2.5-7B-Instruct --steps 100
@@ -333,7 +342,7 @@ backprop replay <run-id> # re-run with same config / dataset
333
342
  backprop export-runs --format jsonl # bulk export run history
334
343
  ```
335
344
 
336
- Riferimento completo nella [pagina della guida alla CLI](https://mcp-tool-shop-org.github.io/backpropagate/handbook/cli-reference/), oppure utilizza `backprop <sottocomando> --help`.
345
+ Riferimento completo disponibile nella [pagina della guida alla riga di comando](https://mcp-tool-shop-org.github.io/backpropagate/handbook/cli-reference/), oppure utilizza `backprop <sottocomando> --help`.
337
346
 
338
347
  ## Configurazione
339
348
 
@@ -342,71 +351,75 @@ Ogni impostazione può essere sovrascritta con una variabile d'ambiente utilizza
342
351
  | Variabile | Predefinito | Note |
343
352
  |---|---|---|
344
353
  | `BACKPROPAGATE_LOG_LEVEL` | `INFO` | `DEBUG` / `INFO` / `WARNING` / `ERROR` |
345
- | `BACKPROPAGATE_LOG_JSON` | auto | Forza i log in formato JSON o nella console |
354
+ | `BACKPROPAGATE_LOG_JSON` | auto | Forza l'utilizzo di log in formato JSON o nella console. |
346
355
  | `BACKPROPAGATE_MODEL__NAME` | `Qwen/Qwen2.5-7B-Instruct` | Modello predefinito |
347
356
  | `BACKPROPAGATE_TRAINING__LEARNING_RATE` | `2e-4` | Tasso di apprendimento |
348
- | `BACKPROPAGATE_LORA__R` | `256` | Rango LoRA (predefinito nella versione 1.3; utilizza `--lora-preset=fast` per il valore predefinito della versione 1.2.x, che è 16) |
357
+ | `BACKPROPAGATE_LORA__R` | `256` | Rango LoRA (predefinito v1.3; utilizza `--lora-preset=fast` per il valore predefinito della v1.2.x, ovvero 16) |
349
358
  | `BACKPROPAGATE_UI__OUTPUT_DIR` | `~/.backpropagate/ui-outputs` | Sandbox del file system dell'interfaccia utente |
350
359
 
351
- Le chiavi nidificate utilizzano il doppio sottolineatura (`MODEL__NAME`, non `MODEL_NAME`). Il riferimento completo è disponibile nella [pagina della guida alle variabili d'ambiente](https://mcp-tool-shop-org.github.io/backpropagate/handbook/env-vars/).
360
+ Le chiavi nidificate utilizzano il doppio underscore (`MODEL__NAME`, non `MODEL_NAME`). Il riferimento completo è disponibile nella [pagina della guida alle variabili d'ambiente](https://mcp-tool-shop-org.github.io/backpropagate/handbook/env-vars/).
352
361
 
353
362
  ## Preset dei modelli
354
363
 
355
364
  | Preset | VRAM | Licenza | Note |
356
365
  |---|---|---|---|
357
366
  | Qwen-3.5-4B | ~8 GB | Apache 2.0 | Predefinito consigliato per modelli inferiori a 5B. Migliore qualità per questa dimensione. |
358
- | Phi-4-mini-3.8B | ~8 GB | MIT | Ottimo per ragionamento / matematica / codice. Licenza rigorosa. |
359
- | SmolLM3-3B | ~6 GB | Apache 2.0 | Ricetta completamente aperta. Contesto nativo di 64K. |
367
+ | Phi-4-mini-3.8B | ~8 GB | MIT | Ottimo nelle attività di ragionamento, matematica e codice. Licenza completamente aperta. |
368
+ | SmolLM3-3B | ~6 GB | Apache 2.0 | Ricetta completamente open source. Contesto nativo di 64K. |
360
369
  | Qwen 2.5 7B | ~12 GB | Apache 2.0 | Predefinito esistente. Migliore qualità tra i preset 7B legacy. |
361
- | Qwen 2.5 3B | ~8 GB | Qwen-Research | ⚠ licenza di ricerca: consulta i termini di licenza di Qwen prima dell'uso commerciale. |
362
- | Llama 3.2 3B | ~8 GB | Llama Community | Solida alternativa a Qwen 3B con alcune limitazioni permissive. |
363
- | Llama 3.2 1B | ~6 GB | Llama Community | Per esperimenti rapidi su schede di piccole dimensioni. |
364
- | Mistral 7B | ~12 GB | Apache 2.0 | Confrontabile con Qwen 7B, template di chat diverso. |
370
+ | Qwen 2.5 3B | ~8 GB | Qwen-Research | ⚠ licenza di ricerca: consulta i termini della licenza Qwen prima dell'uso commerciale. |
371
+ | Llama 3.2 3B | ~8 GB | Comunità Llama | Un'alternativa valida a Qwen 3B con alcune limitazioni. |
372
+ | Llama 3.2 1B | ~6 GB | Comunità Llama | Per esperimenti rapidi su schede di piccole dimensioni. |
373
+ | Mistral 7B | ~12 GB | Apache 2.0 | Simile a Qwen 7B, con un modello di chat diverso. |
374
+ | Llama-3.1-8B | ~7-8 GB (QLoRA) | Llama-3.1-Community | 8B QLoRA, contesto nativo di 128K (la clausola >700M-MAU richiede una licenza Meta separata). |
375
+ | **Qwen2.5-14B** | ~8,5 GB (QLoRA) | Apache 2.0 | **Il punto ideale per l'utilizzo quotidiano con 32 GB** — rank/alpha 32, paged 8-bit AdamW, 4096 ctx. |
376
+ | Mistral-Small-24B | ~18 GB (QLoRA) | Apache 2.0 | 24B QLoRA su una scheda da 32 GB con margine di 4096 ctx. |
377
+ | **Qwen2.5-32B** | ~26 GB (QLoRA) | Apache 2.0 | **Limite massimo per 32 GB** — si adatta a malapena con `max_len 2048` + paged 8-bit AdamW. |
365
378
 
366
- Altri modelli spesso funzionano, ma solo questi otto sono fissati nei test CI. Utilizza `--lora-preset=quality` (predefinito) per i target con rango 256 / tutti i parametri lineari secondo Biderman 2024 + Thinking Machines 2025, oppure `--lora-preset=fast` per il target legacy con rango 16 / q+v se hai bisogno del footprint della versione 1.2.x.
379
+ Altri modelli spesso funzionano; le righe sopra riportate sono le configurazioni predefinite curate: la fascia da 14B a 32B è ottimizzata con QLoRA per una scheda da 32 GB (l'ambito misurato). Utilizzare `--lora-preset=quality` (impostazione predefinita) per i target rank-256 / all-linear secondo Biderman 2024 + Thinking Machines 2025, oppure `--lora-preset=fast` per il target legacy rank-16 / q+v se è necessario l'ingombro della versione 1.2.x.
367
380
 
368
381
  ## Risoluzione dei problemi
369
382
 
370
- Un breve elenco dei fallimenti più comuni durante la prima esecuzione. L'indice completo è disponibile nella [pagina della guida alla risoluzione dei problemi](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/). Per un'analisi approfondita del driver / VRAM / precisione mista, consulta la [pagina della guida alla risoluzione dei problemi di CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/).
383
+ Un breve elenco degli errori più comuni che si verificano durante la prima esecuzione. L'indice completo in ordine inverso è disponibile nella [pagina del manuale per la risoluzione dei problemi](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/). Per un'analisi approfondita di driver / VRAM / precisione mista, consultare la [pagina della risoluzione dei problemi CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/).
371
384
 
372
385
  | Sintomo | Codice di errore | Soluzione |
373
386
  |---|---|---|
374
- | La GPU esaurisce la memoria durante l'addestramento | `RUNTIME_GPU_OOM` | Automatico: la retropropagazione dimezza la dimensione del batch e riprova fino a 3 volte. Per disattivare: `Trainer(oom_recovery=False)`. Per forzare una dimensione inferiore: `--batch-size 1`. |
375
- | HuggingFace restituisce 401 / "modello non trovato". | `DEP_MODEL_LOAD_FAILED` | Eseguire `huggingface-cli login` e riprovare. In caso di errori di battitura, copiare l'ID esatto da <https://huggingface.co/models>. |
376
- | `register_with_ollama` connessione rifiutata. | `DEP_OLLAMA_REGISTRATION_FAILED` | Avviare il daemon: `ollama serve`. Installare da <https://ollama.com>. Riprovare. |
377
- | Disco pieno durante il salvataggio del checkpoint. | `STATE_CHECKPOINT_INVALID` | Le scritture atomiche lasciano una directory `.partial` in caso di errore: è sicuro eliminarla. Il checkpoint precedente valido è intatto. |
378
- | Addestramento in pausa a causa del surriscaldamento della GPU. | `RUNTIME_GPU_TEMPERATURE_CRITICAL` | Automatico: la retropropagazione si interrompe quando viene superata la soglia di temperatura e riprende quando la GPU si raffredda. Migliorare il flusso d'aria se il problema persiste. |
379
- | `backprop ui --share` rifiutato. | `RUNTIME_UI_AUTH_NOT_ENFORCED` | Passare `--auth user:password` oppure utilizzare il port-forwarding SSH (vedere [Web UI](#web-ui)). |
380
- | Esportazione GGUF fallita al primo tentativo. | `RUNTIME_GGUF_EXPORT_FAILED` | `pip install backpropagate[export]`; su Windows è necessario anche Visual C++ Build Tools + CMake. |
387
+ | La GPU esaurisce la memoria durante l'addestramento | `RUNTIME_GPU_OOM` | Automatico: Backpropagate dimezza le dimensioni del batch e riprova fino a 3 volte. Per disattivare questa funzione: `Trainer(oom_recovery=False)`. Per forzare una dimensione inferiore: `--batch-size 1`. |
388
+ | HuggingFace restituisce 401 / "modello non trovato" | `DEP_MODEL_LOAD_FAILED` | Eseguire `huggingface-cli login` e riprovare. In caso di errori di battitura, copiare l'ID esatto da <https://huggingface.co/models>. |
389
+ | La connessione a `register_with_ollama` viene rifiutata | `DEP_OLLAMA_REGISTRATION_FAILED` | Avviare il daemon: `ollama serve`. Installare da <https://ollama.com>. Riprovare. |
390
+ | Lo spazio su disco è insufficiente durante il salvataggio del checkpoint | `STATE_CHECKPOINT_INVALID` | Le scritture atomiche lasciano una directory `.partial` in caso di errore: è sicuro eliminarla. Il checkpoint precedente valido è intatto. |
391
+ | L'addestramento viene interrotto a causa del surriscaldamento della GPU | `RUNTIME_GPU_TEMPERATURE_CRITICAL` | Automatico: Backpropagate si interrompe quando viene superata la soglia di temperatura e riprende quando la GPU si raffredda. Migliorare il flusso d'aria se il problema persiste. |
392
+ | `backprop ui --share` rifiutato | `RUNTIME_UI_AUTH_NOT_ENFORCED` | Passare `--auth user:password`, oppure utilizzare invece il port-forwarding SSH (vedere [Interfaccia utente Web](#interfaccia-utente-web)). |
393
+ | Esportazione GGUF non riuscita al primo tentativo | `RUNTIME_GGUF_EXPORT_FAILED` | `pip install backpropagate[export]`; su Windows è necessario anche Visual C++ Build Tools + CMake. |
381
394
 
382
395
  ## Segnalazione di bug
383
396
 
384
- Quando qualcosa fallisce, Backpropagate stampa una riga all'avvio, ad esempio `run_started run_id=<uuid>`, e associa lo stesso ID a ogni riga del log, a ogni checkpoint e a ogni voce di Weights & Biases. **Includere il `run_id` in qualsiasi segnalazione di bug**, in modo che chi si occupa della manutenzione possa correlare tutto per quella specifica esecuzione.
397
+ Quando qualcosa fallisce, Backpropagate stampa una riga all'avvio simile a `run_started run_id=<uuid>` e associa lo stesso ID a ogni riga del log, a ogni checkpoint e a ogni voce di Weights & Biases. **Includere il `run_id` in qualsiasi segnalazione di bug**, in modo che chi si occupa della manutenzione possa correlare tutto per quella specifica esecuzione.
385
398
 
386
399
  Una buona segnalazione di bug include:
387
400
 
388
401
  1. **Il `run_id`**: l'UUID stampato all'avvio. Un singolo UUID consente a chi si occupa della manutenzione di correlare ogni riga del log, ogni checkpoint e ogni voce di Weights & Biases per quella specifica esecuzione.
389
402
  2. **Il codice di errore**: la riga `[CODE_NAME]: message` in stderr. Consultare [codici di errore](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) per il catalogo dei codici stabili.
390
- 3. **Il traceback modificato**. Stderr viene automaticamente modificato in modalità non verbose (i token Bearer, `sk-*`, `hf_*`, le chiavi AWS, le coppie `password=` / `token=` / `api_key=` vengono rimossi): è sicuro incollarlo. Per il traceback completo e non modificato, rieseguire con `BACKPROPAGATE_DEBUG=1` (o `--verbose`); rivedere prima di pubblicarlo.
391
- 4. **L'output di `backprop info`**. Un singolo comando stampa Python / PyTorch / CUDA / modello GPU / VRAM / sistema operativo / extra installati: tutto ciò di cui chi si occupa della manutenzione ha bisogno per analizzare una regressione specifica della piattaforma.
403
+ 3. **Il traceback modificato**. Stderr viene automaticamente modificato in modalità non verbose (i token Bearer, `sk-*`, `hf_*`, le chiavi AWS, le coppie `password=` / `token=` / `api_key=` vengono eliminate): è sicuro copiarlo e incollarlo. Per il traceback completo non modificato, rieseguire con `BACKPROPAGATE_DEBUG=1` (o `--verbose`); rivederlo prima di pubblicarlo.
404
+ 4. **L'output di `backprop info`**. Un singolo comando stampa Python / PyTorch / CUDA / modello GPU / VRAM / sistema operativo / extra installati: tutto ciò di cui chi si occupa della manutenzione ha bisogno per individuare una regressione specifica della piattaforma.
392
405
 
393
- Il [modello di segnalazione di bug](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) richiede esplicitamente ciascuno di questi elementi, in modo che la fase di triage avvenga rapidamente. Domande, idee o discussioni del tipo "è questo previsto?" devono essere pubblicate in [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). I problemi di sicurezza devono essere segnalati in privato tramite il modulo [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new): consultare [SECURITY.md](SECURITY.md) per le politiche e i tempi di risposta.
406
+ Il [modello di segnalazione di bug](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) richiede esplicitamente ciascuno di questi elementi in modo che la valutazione possa procedere rapidamente. Domande, idee o discussioni su "è questo previsto?" devono essere pubblicate in [Discussioni di GitHub](https://github.com/mcp-tool-shop-org/backpropagate/discussions). I problemi di sicurezza devono essere segnalati privatamente tramite il modulo [Avviso di sicurezza di GitHub](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new): consultare [SECURITY.md](SECURITY.md) per le politiche e i tempi di risposta.
394
407
 
395
408
  ## Privacy
396
409
 
397
- Tutto l'addestramento avviene localmente sulla GPU. Backpropagate non effettua richieste di rete, tranne per scaricare i modelli da HuggingFace (operazione che si avvia manualmente). Nessun telemetria, nessuna dipendenza dal cloud.
410
+ Tutto l'addestramento avviene localmente sulla GPU. Backpropagate non effettua richieste di rete, tranne per scaricare modelli da HuggingFace (che si avvia manualmente). Nessun telemetria, nessuna dipendenza dal cloud.
398
411
 
399
412
  ## Riferimenti
400
413
 
401
- Le impostazioni predefinite di Backpropagate e la modalità di addestramento multi-esecuzione si basano su ricerche recenti. Se sei interessato alle tecniche sottostanti:
414
+ Le impostazioni predefinite e la modalità di addestramento multi-esecuzione di Backpropagate sono basate su ricerche recenti. Se sei interessato alle tecniche sottostanti:
402
415
 
403
- - **Hu et al. 2021.** *LoRA: Low-Rank Adaptation of Large Language Models.* [arXiv:2106.09685](https://arxiv.org/abs/2106.09685) — il documento fondamentale che introduce LoRA, che è il metodo utilizzato da Backpropagate per addestrare gli adattatori in modo efficiente.
404
- - **Biderman et al. 2024.** *LoRA Learns Less and Forgets Less.* [arXiv:2405.09673](https://arxiv.org/abs/2405.09673) — evidenze empiriche che LoRA con rango 256 e obiettivi completamente lineari corrisponde alla qualità del fine-tuning completo nella maggior parte delle attività post-addestramento con il 67% della potenza di calcolo. Guida la configurazione LoRA predefinita di Backpropagate v1.3.
405
- - **Thinking Machines 2025.** *LoRA Without Regret.* [thinkingmachines.ai/blog/lora](https://thinkingmachines.ai/blog/lora/) — il seguito pratico che identifica la correzione 10× del tasso di apprendimento rispetto al fine-tuning completo necessaria con un rango LoRA elevato.
406
- - **Kirkpatrick et al. 2017.** *Overcoming catastrophic forgetting in neural networks.* [arXiv:1612.00796](https://arxiv.org/abs/1612.00796) — la caratterizzazione originale del motivo per cui le reti neurali "dimenticano" l'addestramento precedente quando si esegue il fine-tuning su nuovi dati (EWC — Elastic Weight Consolidation).
407
- - **Wang et al. 2023.** *Orthogonal Subspace Learning for Language Model Continual Learning.* [arXiv:2310.14152](https://arxiv.org/abs/2310.14152) — O-LoRA, un approccio precedente all'utilizzo di LoRA per l'apprendimento continuo, limitando i nuovi adattatori a sottospazi ortogonali.
408
- - **Yadav et al. 2023.** *TIES-Merging: Resolving Interference When Merging Models.* [arXiv:2306.01708](https://arxiv.org/abs/2306.01708) — una tecnica fondamentale per unire più modelli con fine-tuning senza interferenze.
409
- - **Qiao & Mahdavi 2025.** *Merge before Forget: A Single LoRA Continual Learning via Continual Merging.* [arXiv:2512.23017](https://arxiv.org/abs/2512.23017) — l'algoritmo specifico che l'unificatore multi-esecuzione di Backpropagate implementa. Un preprint di dicembre 2025; Backpropagate è il primo implementatore noto di questo algoritmo.
416
+ - **Hu et al. 2021.** *LoRA: Adattamento a basso rango di modelli linguistici di grandi dimensioni.* [arXiv:2106.09685](https://arxiv.org/abs/2106.09685) — l'articolo fondamentale che introduce LoRA, il metodo con cui Backpropagate addestra gli adattatori in modo efficiente.
417
+ - **Biderman et al. 2024.** *LoRA impara di meno e dimentica di meno.* [arXiv:2405.09673](https://arxiv.org/abs/2405.09673) — evidenze empiriche che LoRA con rango 256 e obiettivi completamente lineari raggiunge una qualità paragonabile al fine-tuning completo nella maggior parte delle attività post-addestramento, utilizzando il 67% della potenza di calcolo. Definisce la configurazione LoRA predefinita di Backpropagate v1.3.
418
+ - **Thinking Machines 2025.** *LoRA senza rimpianti.* [thinkingmachines.ai/blog/lora](https://thinkingmachines.ai/blog/lora/) — il seguito pratico che identifica la correzione del tasso di apprendimento (10 volte) rispetto al fine-tuning completo necessaria con un rango LoRA elevato.
419
+ - **Kirkpatrick et al. 2017.** *Superare l'oblio catastrofico nelle reti neurali.* [arXiv:1612.00796](https://arxiv.org/abs/1612.00796) — la prima descrizione del motivo per cui le reti neurali "dimenticano" gli addestramenti precedenti quando si esegue il fine-tuning su nuovi dati (EWC — Elastic Weight Consolidation).
420
+ - **Wang et al. 2023.** *Apprendimento di sottospazi ortogonali per l'apprendimento continuo di modelli linguistici.* [arXiv:2310.14152](https://arxiv.org/abs/2310.14152) — O-LoRA, un approccio precedente all'utilizzo di LoRA per l'apprendimento continuo, limitando i nuovi adattatori a sottospazi ortogonali.
421
+ - **Yadav et al. 2023.** *TIES-Merging: Risolvere le interferenze durante la fusione dei modelli.* [arXiv:2306.01708](https://arxiv.org/abs/2306.01708) — una tecnica fondamentale per fondere più modelli con fine-tuning senza interferenze.
422
+ - **Qiao & Mahdavi 2025.** *Unisci prima di dimenticare: un singolo apprendimento continuo LoRA tramite fusione continua.* [arXiv:2512.23017](https://arxiv.org/abs/2512.23017) — l'algoritmo specifico che il sistema di fusione multi-esecuzione di Backpropagate implementa. Un preprint di dicembre 2025; Backpropagate è il primo utilizzatore noto di questo articolo.
410
423
 
411
424
  ## Licenza
412
425