@mcptoolshop/backpropagate 1.5.0 → 1.6.0

package/README.es.md

@@ -145,7 +145,7 @@ Esto entrena un adaptador Qwen 2.5 de 7B con 5 conversaciones cortas en formato
 
 Los formatos Alpaca (`instruction` / `output`), OpenAI chat (`messages`) y texto sin formato también funcionan: Backpropagate detecta automáticamente el formato.
 
-### Ajuste de preferencias (ORPO)
+### Ajuste de preferencias (ORPO, SimPO, KTO)
 
 Novedad en la v1.5: entrene con preferencias en lugar de demostraciones simples. ORPO no requiere referencia y es de una sola etapa: integra la señal de preferencia en el paso de ajuste fino supervisado, por lo que no hay un modelo de recompensa o de referencia separado y la forma de 3 líneas se mantiene. Pase `--method orpo` (CLI) o `method="orpo"` (Python) y proporcione un conjunto de datos de filas `{prompt, chosen, rejected}` (o simplemente `{chosen, rejected}`):
 
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-La tasa de aprendizaje predeterminada se reduce automáticamente a `8e-6` para ORPO (la pérdida es más pronunciada que en SFT simple); ajuste `--orpo-beta` (valor predeterminado `0.1`) para ponderar la penalización de la razón de probabilidades. En v1.5, ORPO solo tiene `mode="lora"`. SimPO y KTO están planeados como desarrollos posteriores; para RL en línea (PPO/GRPO), consulte [Qué NO es la retropropagación](#what-backpropagate-is-not-for).
+La tasa de aprendizaje predeterminada se reduce automáticamente a `8e-6` para ORPO (la pérdida es más pronunciada que en el SFT simple); ajuste `--orpo-beta` (valor predeterminado: `0.1`) para ponderar la penalización de la razón de probabilidades. ORPO solo funciona con `mode="lora"`.
+
+**Novedad en la versión 1.6: SimPO y KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) no requiere referencia, utiliza una recompensa normalizada por longitud y toma los mismos datos emparejados `{prompt, chosen, rejected}` que ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) utiliza datos **no emparejados** `{prompt, completion, label}` — valoraciones positivas/negativas por ejemplo — para la gran clase de comentarios que no son pares A/B seleccionados; equilibra automáticamente los pesos deseables/indeseables de la pérdida a partir del recuento de etiquetas. Ambos solo funcionan con `mode="lora"` y se mantienen dentro del ámbito SFT de una sola GPU (sin un modelo de referencia separado). Consulte el [manual de ajuste de preferencias](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) para saber cuál utilizar. Para RL en línea (PPO/GRPO), consulte [Qué NO es Backpropagate](#what-backpropagate-is-not-for).
 
 ### SFT de trazado de razonamiento (destilación R1)
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 En v1.5, la vía MLX es **solo LoRA SFT**; no hay ORPO, no hay FP8, no hay `mode='full'`, no hay ejecución múltiple en MLX todavía (cada una se rechaza con `CONFIG_INVALID_SETTING`; use `backend='cuda'`/`'auto'` en un sistema NVIDIA para esas opciones). El adaptador resultante es un archivo safetensors simple y se exporta a Ollama a través de la misma ruta que la vía CUDA.
 
-> ⚠️ **Estado honesto:** la vía MLX se incluye en v1.5 **construida + probada con pruebas unitarias (simuladas)**, pero **todavía no se ha verificado en Apple Silicon real**; `mlx-lm` es exclusivo de Apple y no se pudo ejecutar en el sistema NVIDIA en el que se creó esto. Trátelo como experimental (el mismo enfoque que la vía FP8) y, por favor, [informe de las anomalías](#reporting-bugs) una vez que se ejecute en un Mac de la serie M. Forzar `--backend mlx` en un host que no sea de Apple genera un error con `CONFIG_INVALID_SETTING`; la falta del conjunto de herramientas `mlx_lm` en un Mac genera `DEP_MLX_UNAVAILABLE`.
+> ⚠️ **Estado actual:** la implementación MLX incluida en la versión 1.5 está **construida y probada unitariamente (simulada)**, pero **aún no se ha verificado con pruebas reales en hardware Apple Silicon**; `mlx-lm` solo funciona en dispositivos Apple y no se pudo ejecutar en el equipo NVIDIA donde se desarrolló este código. Trátelo como experimental, al igual que la ruta FP8 en la versión 1.5 (FP8 pasó a la fase de verificación con pruebas reales en Blackwell en la versión 1.6; MLX aún necesita esa fase en hardware real); por favor, [informe sobre cualquier anomalía](#reporting-bugs) una vez que se ejecute en un Mac de la serie M. Forzar `--backend mlx` en un host que no sea Apple genera el error `CONFIG_INVALID_SETTING`; la falta de las herramientas `mlx_lm` en un Mac genera el error `DEP_MLX_UNAVAILABLE`.
 
 Para obtener más flujos de trabajo de principio a fin (ajuste fino y carga en HF Hub, reanudación después de que se agota la memoria, SLAO de ejecución múltiple en una campaña larga, etc.), consulte la [página de recetas del manual](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
 
@@ -303,7 +305,7 @@ Las operaciones de escritura en el sistema de archivos desde la interfaz de usua
 
 **Requisitos:** Python 3.10+ · GPU CUDA (8 GB+ de VRAM) · PyTorch 2.0+
 
-Python 3.10 dejará de recibir soporte en octubre de 2026 y está programado para ser eliminado en la versión 1.5. Para nuevas instalaciones, prefiera Python 3.11 o 3.12; 3.11 es la versión más probada.
+Python 3.10 es compatible hasta al menos la versión 1.6; su soporte oficial finaliza en octubre de 2026 y está programado para ser eliminado en la primera versión posterior a esa fecha. Para nuevas instalaciones, prefiera Python 3.11 o 3.12; 3.11 es la versión más probada.
 
 Backpropagate gestiona las peculiaridades del tiempo de ejecución al entrenar en diferentes plataformas, pero no puede solucionar los problemas que surgen durante la instalación. Los dos más comunes son:
 

package/README.fr.md

@@ -145,7 +145,7 @@ Cela entraîne un adaptateur Qwen 2.5 7B sur 5 courtes conversations au format
 
 Les formats Alpaca (`instruction` / `output`), OpenAI chat (`messages`) et texte brut fonctionnent également — Backpropagate détecte automatiquement le format.
 
-### Affinage des préférences (ORPO)
+### Réglage des préférences (ORPO, SimPO, KTO)
 
 Nouveau dans la version 1.5 : entraînez-vous sur des préférences au lieu de simples démonstrations. ORPO est sans référence et en une seule étape — il intègre le signal de préférence dans l’étape d’affinage supervisé, il n’y a donc pas de modèle de récompense ou de référence distinct et la forme en 3 lignes reste la même. Passez `--method orpo` (CLI) ou `method="orpo"` (Python) et fournissez un ensemble de données de lignes `{prompt, chosen, rejected}` (ou simplement `{chosen, rejected}` :
 
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-Le taux d’apprentissage par défaut est automatiquement réduit à `8e-6` pour ORPO (la perte est plus marquée que pour SFT simple) ; ajustez `--orpo-beta` (par défaut `0.1`) pour pondérer la pénalité du rapport de cotes. Dans la version 1.5, ORPO est uniquement en mode `mode="lora"`. SimPO et KTO sont prévus comme prochaines étapes ; pour l’apprentissage par renforcement en ligne (PPO/GRPO), consultez [Ce que la rétropropagation n’est PAS](#what-backpropagate-is-not-for).
+Le taux d’apprentissage par défaut est automatiquement réduit à `8e-6` pour ORPO (la perte est plus marquée que dans le cas de SFT simple) ; réglez `--orpo-beta` (par défaut `0.1`) pour pondérer la pénalité du rapport de cotes. ORPO utilise uniquement `mode="lora"`.
+
+**Nouveauté dans la version 1.6 : SimPO et KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) ne nécessite pas de données de référence et utilise une récompense normalisée en fonction de la longueur, tout en utilisant les mêmes données appariées `{prompt, chosen, rejected}` qu’ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) utilise des données **non appariées** `{prompt, completion, label}` — évaluation positive/négative par exemple — pour la vaste catégorie de commentaires qui ne sont pas des paires A/B sélectionnées ; il équilibre automatiquement les poids de perte souhaitables/indésirables en fonction du nombre d’étiquettes. Les deux utilisent uniquement `mode="lora"` et restent dans l’enveloppe SFT sur une seule GPU (pas de modèle de référence distinct). Consultez le [guide de réglage des préférences](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) pour savoir lequel utiliser. Pour l’apprentissage par renforcement en ligne (PPO/GRPO), consultez [Ce que Backpropagate n’est PAS](#what-backpropagate-is-not-for).
 
 ### SFT avec suivi du raisonnement (distillation R1)
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 Dans la version 1.5, l’option MLX est **uniquement LoRA SFT** — pas d’ORPO, pas de FP8, pas de `mode='full'`, pas d’exécution multiple sur MLX pour le moment (chacune est rejetée avec `CONFIG_INVALID_SETTING` ; utilisez `backend='cuda'`/`'auto'` sur une machine NVIDIA pour ces options). L’adaptateur résultant est un simple fichier safetensors et est exporté vers Ollama via le même chemin que l’option CUDA.
 
-> ⚠️ **État honnête :** l’option MLX est incluse dans la version 1.5, **construite et testée avec des simulations**, mais **pas encore vérifiée sur du matériel Apple Silicon réel** — `mlx-lm` est uniquement pour Apple et n’a pas pu être exécutée sur la machine NVIDIA sur laquelle ce code a été écrit. Considérez-la comme expérimentale (même approche que l’option FP8) et veuillez [signaler les anomalies](#reporting-bugs) une fois qu’elle sera exécutée sur un Mac de la série M. Forcer `--backend mlx` sur un hôte non Apple génère une erreur `CONFIG_INVALID_SETTING` ; l’absence de la chaîne d’outils `mlx_lm` sur un Mac génère une erreur `DEP_MLX_UNAVAILABLE`.
+> ⚠️ **État actuel :** la version MLX incluse dans la v1.5 est **intégrée et testée (avec des simulations)**, mais **n’a pas encore été validée sur du matériel Apple Silicon réel**. `mlx-lm` est uniquement compatible avec Apple et n’a pas pu être exécuté sur le système NVIDIA utilisé pour sa création. Considérez-la comme expérimentale — la même approche a été utilisée pour le chemin FP8 dans la v1.5 (FP8 a ensuite été validé sur Blackwell dans la v1.6 ; MLX doit encore passer cette étape sur du matériel réel) — et veuillez [signaler les anomalies](#reporting-bugs) une fois qu’elle sera exécutée sur un Mac de la série M. Forcer `--backend mlx` sur un hôte non Apple génère l’erreur `CONFIG_INVALID_SETTING` ; l’absence de la chaîne d’outils `mlx_lm` sur un Mac provoque l’erreur `DEP_MLX_UNAVAILABLE`.
 
 Pour des flux de travail de bout en bout plus complets (affiner et pousser vers HF-Hub, reprendre après une erreur de mémoire, SLAO multi-exécution sur une longue campagne, etc.), consultez la [page des recettes du manuel](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
 
@@ -303,7 +305,7 @@ Les écritures dans le système de fichiers à partir de l’interface utilisate
 
 **Configuration requise :** Python 3.10+ ; GPU CUDA (8 Go ou plus de VRAM) ; PyTorch 2.0+
 
-La prise en charge de Python 3.10 sera interrompue en octobre 2026 et sa suppression est prévue dans la version 1.5. Pour les nouvelles installations, privilégiez Python 3.11 ou 3.12 ; la version 3.11 est la version la plus testée.
+Python 3.10 est pris en charge jusqu’à au moins la v1.6 ; sa prise en charge par le fournisseur initial prendra fin en octobre 2026 et il est prévu de le supprimer dans la première version après cette date. Pour les nouvelles installations, privilégiez Python 3.11 ou 3.12 — 3.11 est la version la plus testée.
 
 Backpropagate gère les particularités de l’exécution de l’entraînement sur différentes plateformes, mais il ne peut pas résoudre les problèmes survenant lors de l’installation. Les deux problèmes les plus courants sont les suivants :
 

package/README.hi.md

@@ -145,7 +145,7 @@ trainer.export('gguf', quantization='q4_k_m')
 
 अल्पाका (`instruction` / `output`), OpenAI चैट (`messages`), और कच्चे पाठ प्रारूप भी काम करते हैं — बैकप्रोपगेट प्रारूप का स्वचालित रूप से पता लगाता है।
 
-### प्राथमिकता ट्यूनिंग (ORPO)
+### वरीयता ट्यूनिंग (ओआरपीओ, सिम्पो, केटीओ)
 
 v1.5 में नया: सादे प्रदर्शनों के बजाय प्राथमिकताओं पर प्रशिक्षित करें। ORPO संदर्भ-मुक्त और सिंगल-स्टेज है — यह प्राथमिकता संकेत को SFT चरण में जोड़ता है, इसलिए कोई अलग इनाम या संदर्भ मॉडल नहीं है और 3-लाइन आकार अपरिवर्तित रहता है। `--method orpo` (CLI) या `method="orpo"` (Python) पास करें और `{prompt, chosen, rejected}` (या केवल `{chosen, rejected}`) पंक्तियों के एक डेटासेट को फीड करें:
 
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-डिफ़ॉल्ट लर्निंग दर स्वचालित रूप से ORPO के लिए `8e-6` तक कम हो जाती है (हानि, साधारण SFT की तुलना में अधिक तीव्र है); `--orpo-beta` को समायोजित करें (डिफ़ॉल्ट `0.1`) ताकि ऑड्स-अनुपात दंड को भार दिया जा सके। v1.5 में ORPO केवल `mode="lora"` है। SimPO और KTO नियोजित अनुवर्ती हैं; ऑनलाइन RL (PPO/GRPO) के लिए [What Backpropagate is NOT for](#what-backpropagate-is-not-for) देखें।
+ओआरपीओ के लिए डिफ़ॉल्ट लर्निंग दर स्वचालित रूप से घटकर `8e-6` हो जाती है (क्योंकि इसका नुकसान साधारण एसएफटी की तुलना में अधिक तीव्र होता है); ऑड्स-अनुपात दंड को भारित करने के लिए `--orpo-beta` (डिफ़ॉल्ट `0.1`) ट्यून करें। ओआरपीओ केवल `mode="lora"` पर ही काम करता है।
+
+**v1.6 में नया — सिम्पो और केटीओ।** `--method simpo` ([मेंग एट अल. 2024](https://arxiv.org/abs/2405.14734)) लंबाई-मानकीकृत इनाम के साथ संदर्भ-मुक्त है और ओआरपीओ के समान युग्मित `{prompt, chosen, rejected}` डेटा लेता है (`--simpo-beta`, `--simpo-gamma`)। `--method kto` ([एथयाराज एट अल. 2024](https://arxiv.org/abs/2402.01306)) **युग्मित नहीं** `{prompt, completion, label}` डेटा लेता है — प्रति उदाहरण थंब्स-अप/डाउन — प्रतिक्रिया के उस बड़े वर्ग के लिए जो क्यूरेटेड ए/बी युग्म नहीं हैं; यह आपके लेबल गणनाओं से वांछनीय/अवांछनीय नुकसान भार को स्वचालित रूप से संतुलित करता है। दोनों केवल `mode="lora"` पर ही काम करते हैं और सिंगल-जीपीयू एसएफटी लिफाफे में रहते हैं (कोई अलग संदर्भ मॉडल नहीं)। इसका उपयोग किस लिए करना है, इसके लिए [वरीयता-ट्यूनिंग हैंडबुक](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) देखें। ऑनलाइन आरएल (पीपीओ/जीआरपीओ) के लिए [बैकप्रोपगेट क्या नहीं है](#what-backpropagate-is-not-for) देखें।
 
 ### तर्क-आधारित SFT (R1 डिस्टिलेशन)
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 v1.5 में MLX रेल **केवल LoRA SFT है** — कोई ORPO नहीं, कोई FP8 नहीं, कोई `mode='full'` नहीं, अभी तक MLX पर कोई मल्टी-रन नहीं (प्रत्येक को `CONFIG_INVALID_SETTING` के साथ अस्वीकार कर दिया जाता है; उन कार्यों के लिए NVIDIA बॉक्स पर `backend='cuda'`/`'auto'` का उपयोग करें)। परिणामी एडाप्टर सादा सेफ़टेंसर है और उसी पथ के माध्यम से CUDA रेल की तरह Ollama में निर्यात होता है।
 
-> ⚠️ **ईमानदार स्थिति:** MLX रेल v1.5 में **बनाकर + यूनिट-परीक्षण (मॉक किया गया)** के साथ शिप की जाती है, लेकिन **अभी तक वास्तविक Apple सिलिकॉन पर डॉगफ़ूड-सत्यापित नहीं है** — `mlx-lm` केवल Apple के लिए है और इसे उस NVIDIA सेटअप पर नहीं चलाया जा सकता है जिस पर इसे बनाया गया था। इसे प्रयोगात्मक के रूप में मानें (FP8 पथ के समान ढांचा), और कृपया [विसंगतियों की रिपोर्ट करें](#reporting-bugs) जब यह M-श्रृंखला Mac पर चलता है। गैर-Apple होस्ट पर `--backend mlx` को जबरदस्ती करने पर `CONFIG_INVALID_SETTING` त्रुटि आती है; Mac पर लापता `mlx_lm` टूलचेन `DEP_MLX_UNAVAILABLE` उत्पन्न करता है।
+> ⚠️ **सटीक स्थिति:** एमएलएक्स रेल v1.5 में **निर्मित + यूनिट-परीक्षण (मॉक किया गया)** के साथ आता है, लेकिन अभी तक वास्तविक ऐप्पल सिलिकॉन पर **डॉगफूड-सत्यापित नहीं** है — `mlx-lm` केवल ऐप्पल के लिए है और इसे उस एनवीडिया रिग पर नहीं चलाया जा सकता था जिस पर यह बनाया गया था। इसे प्रयोगात्मक मानें — वही ढांचा जो v1.5 में एफपी8 पथ में था (एफपी8 को v1.6 में ब्लैकवेल पर डॉगफूड-सत्यापित किया गया; एमएलएक्स को अभी भी वास्तविक सिलिकॉन पर उस चरण से गुजरने की आवश्यकता है) — और कृपया एक बार जब यह एम-सीरीज़ मैक पर चलता है, तो [विसंगतियों की रिपोर्ट करें](#reporting-bugs)। गैर-एप्पल होस्ट पर `--backend mlx` को जबरदस्ती लागू करने पर `CONFIG_INVALID_SETTING` त्रुटि आती है; मैक पर लापता `mlx_lm` टूलचेन `DEP_MLX_UNAVAILABLE` उत्पन्न करता है।
 
 अधिक एंड-टू-एंड वर्कफ़्लो (फाइन-ट्यून-एंड-पुश-टू-HF-हब, OOM के बाद फिर से शुरू करें, लंबे अभियान में मल्टी-रन SLAO, आदि) के लिए [हैंडबुक रेसिपी पेज](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/) देखें।
 
@@ -303,7 +305,7 @@ UI से फ़ाइल सिस्टम में लिखी जाने
 
 **आवश्यकताएं:** Python 3.10+ · CUDA GPU (8GB+ VRAM) · PyTorch 2.0+
 
-Python 3.10 का समर्थन अक्टूबर 2026 में समाप्त हो जाएगा और इसे v1.5 में हटाने की योजना है। नए इंस्टॉलेशन के लिए, Python 3.11 या 3.12 को प्राथमिकता दें - 3.11 सबसे अधिक परीक्षण किया गया संस्करण है।
+पायथन 3.10 कम से कम v1.6 तक समर्थित है; इसकी अपस्ट्रीम जीवन अवधि अक्टूबर 2026 में समाप्त हो जाएगी और इसे उसके बाद के पहले संस्करण में हटाने की योजना बनाई गई है। नए इंस्टॉलेशन के लिए, पायथन 3.11 या 3.12 को प्राथमिकता दें — 3.11 सबसे अधिक परीक्षण किया गया संस्करण है।
 
 Backpropagate विभिन्न प्लेटफ़ॉर्म पर प्रशिक्षण के दौरान आने वाली रनटाइम संबंधी विशिष्टताओं को संभालता है, लेकिन यह इंस्टॉलेशन के समय आने वाली समस्याओं को ठीक नहीं कर सकता है। दो सबसे आम समस्याएं हैं:
 

package/README.it.md

@@ -17,7 +17,7 @@
 
 # Addestra un adattatore. Caricalo su Ollama. Passa oltre
 
-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.
+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` sul tuo modello affinato. Funziona perfettamente su Windows.
 
 ```python
 from backpropagate import Trainer
@@ -32,7 +32,7 @@ backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --oll
 ollama run my-model
 ```
 
-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.
+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.
 
 ## Installa
 
@@ -56,74 +56,74 @@ pipx install "backpropagate[full]"       # adds everything: unsloth, ui, monitor
 
 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`.
 
-## Dove si colloca Backpropagate
+## Dove si colloca Backpropagate nello spazio degli strumenti
 
-Esistono diverse buone librerie per l'affinamento di LLM. Ognuna di esse è ottima per cose diverse:
+Esistono diverse buone librerie per l'affinamento di LLM. Ognuna di esse è ottima in ambiti diversi:
 
-- **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)**: se ti piacciono le configurazioni YAML e desideri una community di ricette da cui copiare.
-- **[LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)**: se desideri DPO/PPO/RLHF e un'interfaccia utente web.
-- **[Unsloth](https://github.com/unslothai/unsloth)**: se hai bisogno dell'addestramento più rapido possibile e utilizzi una famiglia di modelli supportata.
-- **[torchtune](https://github.com/pytorch/torchtune)**: se desideri le ricette PyTorch native di Meta che puoi modificare.
+- **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)** — se ti piacciono le configurazioni YAML e desideri una community di ricette da cui copiare
+- **[LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)** — se vuoi DPO/PPO/RLHF e un'interfaccia utente web
+- **[Unsloth](https://github.com/unslothai/unsloth)** — se hai bisogno dell'addestramento più rapido possibile e utilizzi una famiglia di modelli supportata
+- **[torchtune](https://github.com/pytorch/torchtune)** — se desideri le ricette PyTorch native di Meta che puoi modificare
 
-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.
+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.
 
-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.
+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.
 
-## Cosa puoi affinare su una GPU di consumo da 16 GB
+## Cosa puoi affinare su una GPU consumer da 16 GB
 
 Ecco i limiti pratici su una scheda da 16 GB (RTX 4080 / 5080 / 4070 Ti Super):
 
 | Modello | Metodo | Stato |
 |---|---|---|
-| Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Buono. Lunghezza di sequenza completa, spazio sufficiente. |
-| 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. |
-| Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Standard. ~7-8 GB. Impostazioni predefinite di Backpropagate. |
+| Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Ottimo. Lunghezza di sequenza completa, con spazio a sufficienza. |
+| 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 piena precisione (bf16), senza 4 bit, senza adattatore; il checkpointing del gradiente e l'Adam a 8 bit con paging mantengono l'impronta entro i 16 GB. |
+| Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Standard. Circa 7-8 GB. Impostazioni predefinite di Backpropagate. |
 | Llama-3 13B | QLoRA + sample packing | Stretto, ma funziona. Utilizza sequenze più brevi. |
-| 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. |
+| Mixtral 8x7B (47 miliardi di parametri totali) | — | Fuori portata: la quantizzazione a 2 bit (AQLM / QuIP#) interrompe il contratto dell'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. |
 
-`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`.
+`mode="full"` consente modelli fino a **4 miliardi di parametri**. Le quattro impostazioni nella riga dell'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 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 un errore con `RUNTIME_FULL_FT_MODEL_TOO_LARGE`.
 
-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.
+La quantizzazione a 2 bit (AQLM / QuIP#) è **fuori portata**. È stata prevista per la v1.4, quindi abbandonata nella [breve descrizione della traiettoria v1.5](docs/V1_5_BRIEF.md): una base a 2 bit non può essere unificata in modo pulito con i pesi a piena precisione, il che interrompe il contratto dell'adattatore unificabile → GGUF → Ollama (il punto principale della pipeline). Le opzioni di ottimizzazione offerte da Backpropagate sono invece il percorso di calcolo FP8 v1.5 (`--fp8`, Blackwell/Hopper) e `mode="full"` per i modelli ≤4B: entrambi rimangono unificabili ed esportabili.
 
-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).
+Per i modelli da 3B o 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 della configurazione e il confronto sulla qualità con Biderman 2024 / Thinking Machines 2025. Per i modelli da 7B o superiori, l'affinamento completo richiede una GPU da 24 GB o superiore: valuta la possibilità di noleggiare un A100 nel cloud oppure attieniti a LoRA, che le ricerche più recenti dimostrano essere altrettanto efficace dell'affinamento completo nella maggior parte delle attività post-addestramento (consulta [la sezione "anti-pitch"](#what-backpropagate-is-not-for) per i riferimenti).
 
 ## Per cosa NON è adatto Backpropagate
 
-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:
+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:
 
-- **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.
-- **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)).
-- **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.
-- **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.
+- **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 + le configurazioni predefinite inferiori a 4B come soluzioni alternative). Nel complesso: 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 (seguimento delle istruzioni, adattamento al dominio, personalità/stile) con il 67% della potenza di calcolo. Quindi, per il lavoro che la maggior parte degli utenti desidera effettivamente, non si perde nulla utilizzando LoRA. `mode="full"` è disponibile per i casi in cui si è misurata una differenza di qualità e si è deciso di investire più risorse computazionali. 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.
+- **RL online — PPO / GRPO / RLVR** — Backpropagate esegue l'addestramento SFT in una sola fase 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, come PPO, GRPO o RLVR, che richiede un modello di ricompensa o un ciclo di generazione e valutazione in aggiunta alla fase di addestramento. Per questi casi, utilizzare direttamente TRL o LLaMA-Factory. (L'ottimizzazione delle preferenze senza riferimenti si adatta all'ambito della singola fase perché non è necessario mantenere un modello di riferimento separato in memoria; vedere la nota su ORPO sotto [Guida rapida](#guida-rapida)).
+- **Addestramento multi-nodo** — una sola GPU su una sola macchina. L'addestramento multi-GPU su una singola macchina funziona (tramite `accelerate launch`), ma non è ufficialmente supportato.
+- **Addestramento macOS con CUDA** — Apple Silicon non dispone di CUDA, quindi il percorso CUDA deve essere eseguito su un sistema 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 in modo nativo un adattatore LoRA su Apple Silicon; vedere [Apple Silicon (MLX)](#apple-silicon-mlx--sperimentale-v15). È disponibile solo l'addestramento LoRA-SFT ed è stato implementato, ma non ancora verificato su hardware reale. Pertanto, per qualsiasi operazione che vada oltre un addestramento LoRA SFT (ORPO, ottimizzazione completa, FP8, esecuzioni multiple), si consiglia di utilizzare il percorso CUDA.
 - **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.
 
-Se hai bisogno di una di queste cose, utilizza una delle librerie elencate sopra. Sono più adatte a questo scopo.
+Se si necessita di una qualsiasi di queste funzionalità, utilizzare una delle librerie elencate sopra. Sono più adatte a questo scopo.
 
 ## Cosa offre Backpropagate
 
-Quattro cose, in una singola installazione:
+Quattro elementi, in un'unica installazione:
 
-**1. Una vera API a 3 righe che funziona senza un file di configurazione.**
-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.
+**1. Una vera API di 3 righe che funziona senza un file di configurazione.**
+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.
 
 **2. Windows che funziona davvero.**
-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.
+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.
 
-**3. Progettato per esecuzioni non presidiate.**
+**3. Progettato per esecuzioni senza supervisione.**
 L'addestramento richiede ore. Non si vuole doverlo monitorare costantemente. Backpropagate è progettata per essere lasciata in esecuzione:
 
-- Se si esaurisce la memoria GPU, dimezza automaticamente la dimensione del batch e riprova, fino a tre volte. Nessuna regolazione manuale.
-- Se la GPU diventa troppo calda, si mette in pausa fino a quando le cose non si raffreddano e poi continua.
-- Ogni checkpoint viene scritto in modo atomico: se il laptop si blocca durante il salvataggio, il checkpoint precedente e valido rimane intatto.
+- 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.
+- Se la GPU diventa troppo calda, si mette in pausa finché non si raffredda e poi continua.
+- Ogni checkpoint viene scritto in modo atomico: se il laptop si blocca durante il salvataggio, il checkpoint precedente valido rimane intatto.
 - 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.
-- 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/).
+- 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/).
 
 **4. Un solo comando, dall'adattatore addestrato a `ollama run`.**
 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.
 
 ## Guida rapida
 
-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:
+Il repository include un piccolo set di dati di esempio, quindi lo snippet all'inizio di questo README funziona su una nuova installazione:
 
 ```bash
 pipx install "backpropagate[standard]"
@@ -136,18 +136,18 @@ trainer.export('gguf', quantization='q4_k_m')
 "
 ```
 
-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:
+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:
 
 ```jsonl
 {"conversations": [{"from": "human", "value": "What is Python?"}, {"from": "gpt", "value": "A programming language."}]}
 {"conversations": [{"from": "human", "value": "Explain recursion."}, {"from": "gpt", "value": "A function that calls itself."}]}
 ```
 
-I formati Alpaca (`instruction` / `output`), OpenAI chat (`messages`) e testo semplice funzionano anche: Backpropagate rileva automaticamente il formato.
+I formati Alpaca (`instruction` / `output`), OpenAI chat (`messages`) e testo semplice funzionano anche; Backpropagate rileva automaticamente il formato.
 
-### Ottimizzazione delle preferenze (ORPO)
+### Ottimizzazione delle preferenze (ORPO, SimPO, KTO)
 
-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}`):
+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}`):
 
 ```jsonl
 {"prompt": "What is Python?", "chosen": "A high-level programming language known for readability.", "rejected": "idk look it up"}
@@ -166,15 +166,17 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-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).
+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"`.
+
+**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).
 
 ### SFT con traccia del ragionamento (distillazione R1)
 
-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.
+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.
 
 ### Apple Silicon (MLX) — sperimentale, versione 1.5
 
-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.
+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.
 
 ```python
 from backpropagate import Trainer
@@ -188,26 +190,26 @@ trainer.train("examples/quickstart.jsonl", steps=100)
 backprop train --data my_data.jsonl --backend mlx --steps 100
 ```
 
-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.
+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.
 
-> ⚠️ **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`.
+> ⚠️ **Stato reale:** l'opzione MLX viene fornita nella versione 1.5 **costruita + testata con unità (simulata)** ma **NON ancora verificata su Apple Silicon reale** — `mlx-lm` è solo per Apple e non poteva essere eseguito sulla macchina NVIDIA su cui è stato creato questo progetto. Considerala sperimentale — lo stesso approccio che è stato utilizzato per il percorso FP8 nella versione 1.5 (FP8 è passato alla fase di verifica su Blackwell nella versione 1.6; MLX deve ancora superare questa fase su hardware reale) — e segnala eventuali anomalie [qui](#reporting-bugs) una volta che verrà eseguita su un Mac della serie M. Forzare `--backend mlx` su un host non Apple genera un errore `CONFIG_INVALID_SETTING`; la mancanza dello strumento `mlx_lm` su un Mac genera `DEP_MLX_UNAVAILABLE`.
 
-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/).
+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/).
 
 ### Interfaccia utente web (opzionale)
 
-Se preferisci fare clic invece di digitare Python, installa il componente aggiuntivo dell'interfaccia utente e avvia:
+Se preferisci fare clic invece di digitare in Python, installa il pacchetto aggiuntivo dell'interfaccia utente e avvia:
 
 ```bash
 pipx install "backpropagate[ui]"
 backprop ui --port 7862
 ```
 
-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`.
+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`.
 
 ## Addestramento multi-esecuzione
 
-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:
+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:
 
 ```python
 from backpropagate import Trainer
@@ -222,7 +224,7 @@ result = trainer.multi_run(
 )
 ```
 
-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.
+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.
 
 La versione CLI:
 
@@ -230,9 +232,9 @@ La versione CLI:
 backprop multi-run --data my_data.jsonl --runs 5 --steps 100 --samples 1000
 ```
 
-## Riprendi da un checkpoint
+## Ripresa da un checkpoint
 
-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:
+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:
 
 ```bash
 backprop resume <run-id>
@@ -240,11 +242,11 @@ backprop multi-run --data ... --resume <run-id>
 backprop train --data ... --resume <run-id>     # single-run resume
 ```
 
-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.
+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.
 
 ## Cronologia dell'addestramento
 
-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:
+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:
 
 ```bash
 backprop list-runs                         # last 20 runs
@@ -255,7 +257,7 @@ backprop show-run abcd1234                 # detail view (partial ID is fine)
 
 ## Monitoraggio degli esperimenti
 
-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.
+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.
 
 ```bash
 pip install backpropagate[monitoring]   # installs wandb + psutil
@@ -263,25 +265,25 @@ wandb login                             # one-time setup
 backprop train --data my_data.jsonl
 ```
 
-Sovrascrivi con `Trainer(report_to=["wandb"])`, `Trainer(report_to=["tensorboard"])` o `Trainer(report_to="none")` per disattivare.
+È possibile sovrascrivere le impostazioni con `Trainer(report_to=["wandb"])`, `Trainer(report_to=["tensorboard"])` o `Trainer(report_to="none")` per disattivare la funzionalità.
 
 ## Interfaccia utente web
 
-L'interfaccia web Reflex è un'opzione: installala con `pipx install "backpropagate[ui]"` e avviala:
+L'interfaccia web di Reflex è attivabile; installala con `pipx install "backpropagate[ui]"` e avviala:
 
 ```bash
 backprop ui --port 7862
 ```
 
-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.
+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.
 
-Per esporlo ad altri dispositivi (altre persone sulla tua rete, un URL pubblico, ecc.), devi associare `--share` (o `--host`) a `--auth`:
+Per renderla accessibile ad altri dispositivi (altre persone sulla tua rete, un URL pubblico, ecc.), devi combinare `--share` (o `--host`) con `--auth`:
 
 ```bash
 backprop ui --share --auth alice:hunter2
 ```
 
-`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:
+`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:
 
 ```bash
 # On the client:
@@ -291,32 +293,32 @@ backprop ui                             # no --share
 # Then open http://localhost:7860 in your local browser
 ```
 
-Consulta [handbook/security.md](https://mcp-tool-shop-org.github.io/backpropagate/handbook/security/) per il modello completo delle minacce.
+Consulta [handbook/security.md](https://mcp-tool-shop-org.github.io/backpropagate/handbook/security/) per la descrizione completa del modello di minaccia.
 
 Le operazioni di scrittura sul file system dall'interfaccia utente sono limitate a una singola directory:
 
 - Predefinito: `~/.backpropagate/ui-outputs`
 - Sovrascrittura: imposta `BACKPROPAGATE_UI__OUTPUT_DIR=/path/you/own`
-- 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.
+- 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.
 
 ## Note sulla piattaforma
 
-**Requisiti:** Python 3.10+ · GPU CUDA (8 GB+ di VRAM) · PyTorch 2.0+
+**Requisiti:** Python 3.10+ · GPU CUDA (8 GB o più di VRAM) · PyTorch 2.0+
 
-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.
+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.
 
-Backpropagate gestisce le peculiarità di runtime dell'addestramento su diverse piattaforme, ma non può risolvere i problemi di installazione. I due più comuni sono:
+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:
 
-- **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.
-- **Windows + esportazione GGUF.** L'opzione `[export]` crea `llama-cpp-python` dal codice sorgente, che richiede Visual Studio Build Tools (componente C++) e CMake.
+- **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.
+- **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.
 
-**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.
+**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.
 
-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.
+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.
 
-## CLI
+## CLI (riga di comando)
 
-Ogni API Python ha un equivalente nella CLI:
+Ogni API Python ha un corrispondente nella riga di comando:
 
 ```bash
 backprop train --data my_data.jsonl --model Qwen/Qwen2.5-7B-Instruct --steps 100
@@ -333,7 +335,7 @@ backprop replay <run-id>               # re-run with same config / dataset
 backprop export-runs --format jsonl    # bulk export run history
 ```
 
-Riferimento completo nella [pagina della guida alla CLI](https://mcp-tool-shop-org.github.io/backpropagate/handbook/cli-reference/), oppure utilizza `backprop <sottocomando> --help`.
+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`.
 
 ## Configurazione
 
@@ -342,71 +344,71 @@ Ogni impostazione può essere sovrascritta con una variabile d'ambiente utilizza
 | Variabile | Predefinito | Note |
 |---|---|---|
 | `BACKPROPAGATE_LOG_LEVEL` | `INFO` | `DEBUG` / `INFO` / `WARNING` / `ERROR` |
-| `BACKPROPAGATE_LOG_JSON` | auto | Forza i log in formato JSON o nella console |
+| `BACKPROPAGATE_LOG_JSON` | auto | Forza l'utilizzo di log in formato JSON o nella console. |
 | `BACKPROPAGATE_MODEL__NAME` | `Qwen/Qwen2.5-7B-Instruct` | Modello predefinito |
 | `BACKPROPAGATE_TRAINING__LEARNING_RATE` | `2e-4` | Tasso di apprendimento |
-| `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) |
+| `BACKPROPAGATE_LORA__R` | `256` | Rango LoRA (predefinito v1.3; utilizza `--lora-preset=fast` per il valore predefinito della v1.2.x, ovvero 16) |
 | `BACKPROPAGATE_UI__OUTPUT_DIR` | `~/.backpropagate/ui-outputs` | Sandbox del file system dell'interfaccia utente |
 
-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/).
+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/).
 
 ## Preset dei modelli
 
 | Preset | VRAM | Licenza | Note |
 |---|---|---|---|
 | Qwen-3.5-4B | ~8 GB | Apache 2.0 | Predefinito consigliato per modelli inferiori a 5B. Migliore qualità per questa dimensione. |
-| Phi-4-mini-3.8B | ~8 GB | MIT | Ottimo per ragionamento / matematica / codice. Licenza rigorosa. |
-| SmolLM3-3B | ~6 GB | Apache 2.0 | Ricetta completamente aperta. Contesto nativo di 64K. |
+| Phi-4-mini-3.8B | ~8 GB | MIT | Ottimo nelle attività di ragionamento, matematica e codice. Licenza completamente aperta. |
+| SmolLM3-3B | ~6 GB | Apache 2.0 | Ricetta completamente open source. Contesto nativo di 64K. |
 | Qwen 2.5 7B | ~12 GB | Apache 2.0 | Predefinito esistente. Migliore qualità tra i preset 7B legacy. |
-| Qwen 2.5 3B | ~8 GB | Qwen-Research | ⚠ licenza di ricerca: consulta i termini di licenza di Qwen prima dell'uso commerciale. |
-| Llama 3.2 3B | ~8 GB | Llama Community | Solida alternativa a Qwen 3B con alcune limitazioni permissive. |
-| Llama 3.2 1B | ~6 GB | Llama Community | Per esperimenti rapidi su schede di piccole dimensioni. |
-| Mistral 7B | ~12 GB | Apache 2.0 | Confrontabile con Qwen 7B, template di chat diverso. |
+| Qwen 2.5 3B | ~8 GB | Qwen-Research | ⚠ licenza di ricerca: consulta i termini della licenza Qwen prima dell'uso commerciale. |
+| Llama 3.2 3B | ~8 GB | Comunità Llama | Un'alternativa valida a Qwen 3B con alcune limitazioni. |
+| Llama 3.2 1B | ~6 GB | Comunità Llama | Per esperimenti rapidi su schede di piccole dimensioni. |
+| Mistral 7B | ~12 GB | Apache 2.0 | Simile a Qwen 7B, con un modello di chat diverso. |
 
-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.
+Altri modelli spesso funzionano, ma solo questi otto sono configurati in CI. Utilizzare `--lora-preset=quality` (impostazione predefinita) per obiettivi di rango 256 / completamente lineari secondo Biderman 2024 + Thinking Machines 2025, oppure `--lora-preset=fast` per l'obiettivo legacy di rango 16 / q+v se è necessario il footprint della versione 1.2.x.
 
 ## Risoluzione dei problemi
 
-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/).
+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/).
 
 | Sintomo | Codice di errore | Soluzione |
 |---|---|---|
-| 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`. |
-| 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>. |
-| `register_with_ollama` connessione rifiutata. | `DEP_OLLAMA_REGISTRATION_FAILED` | Avviare il daemon: `ollama serve`. Installare da <https://ollama.com>. Riprovare. |
-| 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. |
-| 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. |
-| `backprop ui --share` rifiutato. | `RUNTIME_UI_AUTH_NOT_ENFORCED` | Passare `--auth user:password` oppure utilizzare il port-forwarding SSH (vedere [Web UI](#web-ui)). |
-| Esportazione GGUF fallita al primo tentativo. | `RUNTIME_GGUF_EXPORT_FAILED` | `pip install backpropagate[export]`; su Windows è necessario anche Visual C++ Build Tools + CMake. |
+| 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`. |
+| 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>. |
+| La connessione a `register_with_ollama` viene rifiutata | `DEP_OLLAMA_REGISTRATION_FAILED` | Avviare il daemon: `ollama serve`. Installare da <https://ollama.com>. Riprovare. |
+| 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. |
+| 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. |
+| `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)). |
+| Esportazione GGUF non riuscita al primo tentativo | `RUNTIME_GGUF_EXPORT_FAILED` | `pip install backpropagate[export]`; su Windows è necessario anche Visual C++ Build Tools + CMake. |
 
 ## Segnalazione di bug
 
-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.
+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.
 
 Una buona segnalazione di bug include:
 
 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.
 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.
-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.
-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.
+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.
+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.
 
-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.
+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.
 
 ## Privacy
 
-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.
+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.
 
 ## Riferimenti
 
-Le impostazioni predefinite di Backpropagate e la modalità di addestramento multi-esecuzione si basano su ricerche recenti. Se sei interessato alle tecniche sottostanti:
+Le impostazioni predefinite e la modalità di addestramento multi-esecuzione di Backpropagate sono basate su ricerche recenti. Se sei interessato alle tecniche sottostanti:
 
-- **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.
-- **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.
-- **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.
-- **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).
-- **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.
-- **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.
-- **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.
+- **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.
+- **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.
+- **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.
+- **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).
+- **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.
+- **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.
+- **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.
 
 ## Licenza
 

package/README.ja.md

@@ -145,7 +145,7 @@ trainer.export('gguf', quantization='q4_k_m')
 
 Alpaca（`instruction` / `output`）、OpenAIチャット（`messages`）、および生のテキスト形式も機能します。Backpropagateは、形式を自動的に検出します。
 
-### 優先度調整（ORPO）
+### 嗜好性チューニング（ORPO、SimPO、KTO）
 
 v1.5の新機能：プレーンなデモンストレーションではなく、優先度に基づいてトレーニングします。ORPOは参照なしで、単一ステージです。優先度のシグナルをSFTステップに組み込むため、個別の報酬モデルや参照モデルはなく、3行の構造は変わりません。`--method orpo`（CLI）または`method="orpo"`（Python）を渡し、`{prompt, chosen, rejected}`（または`{chosen, rejected}`のみ）の行のデータセットを渡します。
 
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-デフォルトの学習率は、ORPO（損失が単純なSFTよりも鋭い）に対して自動的に `8e-6` に低下します。`--orpo-beta`（デフォルトは `0.1`）を調整して、オッズ比ペナルティの重みを調整します。v1.5では、ORPOは `mode="lora"` のみです。SimPOとKTOは今後の計画です。オンラインRL（PPO/GRPO）については、[What Backpropagate is NOT for](#what-backpropagate-is-not-for) を参照してください。
+デフォルトの学習率は、ORPOに対して自動的に`8e-6`まで低下します（損失は単純なSFTよりも急峻です）。オッズ比ペナルティの重みを調整するために、`--orpo-beta`（デフォルトは`0.1`）を調整してください。ORPOは`mode="lora"`でのみ使用できます。
+
+**v1.6の新機能 — SimPOとKTO。** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734))は、長さで正規化された報酬を使用し、参照を必要とせず、ORPOと同じペアの`{prompt, chosen, rejected}`データを受け取ります（`--simpo-beta`、`--simpo-gamma`）。`--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306))は、**ペアになっていない** `{prompt, completion, label}`データを受け取ります。これは、キュレーションされたA/Bペアではない大規模なフィードバックのクラスに対して、サンプルごとの肯定/否定の評価を行います。また、ラベル数に基づいて、望ましい/望ましくない損失の重みを自動的に調整します。どちらも`mode="lora"`でのみ使用でき、単一GPU SFT環境に留まります（個別の参照モデルは使用しません）。どの方法を使用するかについては、[嗜好性チューニングハンドブック](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/)を参照してください。オンラインRL（PPO/GRPO）については、[Backpropagateが適さない理由](#what-backpropagate-is-not-for)をご覧ください。
 
 ### 推論トレースSFT（R1蒸留）
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 v1.5では、MLXレールは **LoRA SFTのみ** です。ORPO、FP8、`mode='full'`、MLXでのマルチランはまだサポートされていません（それぞれ `CONFIG_INVALID_SETTING` で拒否されます。それらの機能を使用する場合は、NVIDIA環境で `backend='cuda'` / `'auto'` を使用してください）。結果として得られるアダプターは、プレーンなsafetensorsであり、CUDAレールと同じパスを通じてOllamaにエクスポートされます。
 
-> ⚠️ **正直な状況：** MLXレールはv1.5に **構築およびユニットテスト済み（モック）** として含まれていますが、**まだ実際のApple Siliconでドッグフード検証されていません**。`mlx-lm` はApple専用であり、このソフトウェアが作成されたNVIDIA環境では実行できません。実験的なものとして扱い（FP8パスと同じ）、MシリーズMacで実行した後に、[バグの報告](#reporting-bugs) をお願いします。Apple以外のホストで `--backend mlx` を強制すると、`CONFIG_INVALID_SETTING` エラーが発生します。Macに `mlx_lm` ツールチェーンがない場合、`DEP_MLX_UNAVAILABLE` が発生します。
+> ⚠️ **現状:** v1.5でMLXレールは**構築され、ユニットテストも完了（モックを使用）**していますが、**まだ実際のApple Siliconでの実証検証は行われていません** — `mlx-lm`はApple専用であり、このコードが作成されたNVIDIA環境では実行できません。実験的なものとして扱ってください。これは、v1.5でFP8パスが採用されたときと同じ考え方です（FP8はv1.6でBlackwell上で実証検証に合格しました。MLXはまだ実際のシリコンでの検証が必要です）。MシリーズのMacで実行したら、[不具合を報告してください](#reporting-bugs)。Apple以外のホストで`--backend mlx`を強制すると、`CONFIG_INVALID_SETTING`エラーが発生します。Macに`mlx_lm`ツールチェーンがない場合、`DEP_MLX_UNAVAILABLE`エラーが発生します。
 
 よりエンドツーエンドのワークフロー（ファインチューンとHF Hubへのプッシュ、OOM後の再開、長期間のキャンペーンにおけるマルチランSLAOなど）については、[ハンドブックのレシピページ](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/) を参照してください。
 
@@ -303,7 +305,7 @@ UIからのファイルシステムへの書き込みは、単一のディレク
 
 **要件：** Python 3.10+、CUDA GPU（8GB以上のVRAM）、PyTorch 2.0+
 
-Python 3.10は、2026年10月にサポートが終了し、v1.5で廃止される予定です。新しいインストールの場合、Python 3.11または3.12を推奨します。3.11は最もテストされたバージョンです。
+Python 3.10は少なくともv1.6までサポートされます。2026年10月にアップストリームのサポートが終了し、その後最初のリリースで削除される予定です。新しいインストールでは、Python 3.11または3.12を推奨します。3.11は最もテストされたバージョンです。
 
 Backpropagateは、さまざまなプラットフォームでのトレーニングにおける実行時の癖に対処しますが、インストール時の問題を修正することはできません。最も一般的な問題は次の2つです。
 

package/README.md

@@ -92,7 +92,7 @@ For models 3B and smaller, full fine-tuning (not just LoRA) is feasible on 16GB
 If your use case is below, you'll have a better time with a different library — Backpropagate is not the right pick and trying to make it work would cost more than just reaching for the right tool. Reading this section before you start saves the install-and-bounce cycle:
 
 - **Full-parameter fine-tuning of 7B+ models** — Backpropagate uses LoRA / QLoRA, which trains a small adapter rather than updating every weight. For models 7B and larger, full fine-tuning needs 24GB+ of GPU memory and doesn't fit on a 16GB consumer card. For models 3B and smaller, full fine-tuning IS feasible on 16GB and ships in v1.4 as `mode="full"` (pass `Trainer(..., mode="full")` or `--mode=full` on the CLI; a hard gate raises `RUNTIME_FULL_FT_MODEL_TOO_LARGE` for models > 4B and names LoRA + the sub-4B presets as recoveries). The bigger picture: recent research ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) shows that LoRA at correct configuration matches full fine-tuning quality on most post-training tasks (instruction-following, domain adaptation, persona/style) at 67% of the compute — so for the work most operators actually want, you don't lose anything by sticking with LoRA. `mode="full"` exists for the cases where you've measured a quality gap and decided to spend the extra compute. If you genuinely need full fine-tuning of a 7B+ model, use HuggingFace `transformers.Trainer` directly on a 24GB+ card.
-- **Online RL — PPO / GRPO / RLVR** — Backpropagate does single-stage SFT plus reference-free preference tuning (ORPO ships in v1.5; SimPO/KTO are planned). What it does *not* do is online reinforcement learning — PPO, GRPO, or RLVR — which needs a reward model or a generation-and-scoring loop on top of the training step. For those, use TRL directly or LLaMA-Factory. (Reference-free preference tuning fits the single-stage envelope because there's no separate reference model to hold in memory; see the ORPO note under [Quick Start](#quick-start).)
+- **Online RL — PPO / GRPO / RLVR** — Backpropagate does single-stage SFT plus reference-free preference tuning (ORPO in v1.5; SimPO + KTO in v1.6). What it does *not* do is online reinforcement learning — PPO, GRPO, or RLVR — which needs a reward model or a generation-and-scoring loop on top of the training step. For those, use TRL directly or LLaMA-Factory. (Reference-free preference tuning fits the single-stage envelope because there's no separate reference model to hold in memory; see the ORPO note under [Quick Start](#quick-start).)
 - **Multi-node training** — single GPU on one machine only. Multi-GPU on one machine works (via `accelerate launch`) but isn't officially supported.
 - **macOS training on the CUDA rail** — Apple Silicon doesn't have CUDA, so the CUDA path has to run on a Linux or Windows box with an NVIDIA GPU. You can still run the trained model on a Mac via Ollama. **New in v1.5:** an experimental MLX rail (`--backend mlx`) trains a LoRA adapter natively on Apple Silicon — see [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15). It is LoRA-SFT-only and built-but-not-yet-dogfood-verified on real silicon, so for anything beyond a LoRA SFT (ORPO, full fine-tune, FP8, multi-run) you still want the CUDA rail.
 - **Anything outside the tested model families** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Other models often work but aren't pinned in CI.
@@ -145,9 +145,9 @@ This trains a Qwen 2.5 7B adapter on 5 short ShareGPT-format conversations, then
 
 Alpaca (`instruction` / `output`), OpenAI chat (`messages`), and raw text formats also work — Backpropagate auto-detects the format.
 
-### Preference tuning (ORPO)
+### Preference tuning (ORPO, SimPO, KTO)
 
-New in v1.5: train on preferences instead of plain demonstrations. ORPO is reference-free and single-stage — it folds the preference signal into the SFT step, so there's no separate reward or reference model and the 3-line shape is unchanged. Pass `--method orpo` (CLI) or `method="orpo"` (Python) and feed it a dataset of `{prompt, chosen, rejected}` (or just `{chosen, rejected}`) rows:
+Train on preferences instead of plain demonstrations. ORPO is reference-free and single-stage — it folds the preference signal into the SFT step, so there's no separate reward or reference model and the 3-line shape is unchanged. Pass `--method orpo` (CLI) or `method="orpo"` (Python) and feed it a dataset of `{prompt, chosen, rejected}` (or just `{chosen, rejected}`) rows:
 
 ```jsonl
 {"prompt": "What is Python?", "chosen": "A high-level programming language known for readability.", "rejected": "idk look it up"}
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-The default learning rate auto-lowers to `8e-6` for ORPO (the loss is sharper than plain SFT); tune `--orpo-beta` (default `0.1`) to weight the odds-ratio penalty. In v1.5 ORPO is `mode="lora"` only. SimPO and KTO are planned follow-ons; for online RL (PPO/GRPO) see [What Backpropagate is NOT for](#what-backpropagate-is-not-for).
+The default learning rate auto-lowers to `8e-6` for ORPO (the loss is sharper than plain SFT); tune `--orpo-beta` (default `0.1`) to weight the odds-ratio penalty. ORPO is `mode="lora"` only.
+
+**New in v1.6 — SimPO and KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) is reference-free with a length-normalized reward and takes the same paired `{prompt, chosen, rejected}` data as ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) takes **unpaired** `{prompt, completion, label}` data — per-example thumbs-up/down — for the large class of feedback that isn't curated A/B pairs; it auto-balances the desirable/undesirable loss weights from your label counts. Both are `mode="lora"` only and stay in the single-GPU SFT envelope (no separate reference model). See the [preference-tuning handbook](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) for which to use. For online RL (PPO/GRPO) see [What Backpropagate is NOT for](#what-backpropagate-is-not-for).
 
 ### Reasoning-trace SFT (R1 distillation)
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 In v1.5 the MLX rail is **LoRA SFT only** — no ORPO, no FP8, no `mode='full'`, no multi-run on MLX yet (each is rejected with `CONFIG_INVALID_SETTING`; use `backend='cuda'`/`'auto'` on an NVIDIA box for those). The resulting adapter is plain safetensors and exports to Ollama through the same path as the CUDA rail.
 
-> ⚠️ **Honest status:** the MLX rail ships in v1.5 **built + unit-tested (mocked)** but **NOT yet dogfood-verified on real Apple Silicon** — `mlx-lm` is Apple-only and could not be run on the NVIDIA rig this was authored on. Treat it as experimental (same framing as the FP8 path), and please [report anomalies](#reporting-bugs) once it runs on an M-series Mac. Forcing `--backend mlx` on a non-Apple host errors with `CONFIG_INVALID_SETTING`; a missing `mlx_lm` toolchain on a Mac raises `DEP_MLX_UNAVAILABLE`.
+> ⚠️ **Honest status:** the MLX rail ships in v1.5 **built + unit-tested (mocked)** but **NOT yet dogfood-verified on real Apple Silicon** — `mlx-lm` is Apple-only and could not be run on the NVIDIA rig this was authored on. Treat it as experimental — the same framing the FP8 path had in v1.5 (FP8 graduated to dogfood-verified on Blackwell in v1.6; MLX still needs that pass on real silicon) — and please [report anomalies](#reporting-bugs) once it runs on an M-series Mac. Forcing `--backend mlx` on a non-Apple host errors with `CONFIG_INVALID_SETTING`; a missing `mlx_lm` toolchain on a Mac raises `DEP_MLX_UNAVAILABLE`.
 
 For more end-to-end workflows (fine-tune-and-push-to-HF-Hub, resume after OOM, multi-run SLAO across a long campaign, etc.) see the [handbook recipes page](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
 
@@ -303,7 +305,7 @@ Filesystem writes from the UI are sandboxed to a single directory:
 
 **Requirements:** Python 3.10+ · CUDA GPU (8GB+ VRAM) · PyTorch 2.0+
 
-Python 3.10 reaches upstream end-of-life in October 2026 and is scheduled for drop in v1.5. For new installs, prefer Python 3.11 or 3.12 — 3.11 is the most-tested floor.
+Python 3.10 is supported through at least v1.6; it reaches upstream end-of-life in October 2026 and is scheduled for removal in the first release after that. For new installs, prefer Python 3.11 or 3.12 — 3.11 is the most-tested floor.
 
 Backpropagate handles the runtime quirks of training on different platforms, but it can't fix install-time problems. The two most common are:
 

package/README.pt-BR.md

@@ -145,7 +145,7 @@ Isso treina um adaptador Qwen 2.5 7B em 5 conversas curtas no formato ShareGPT e
 
 Os formatos Alpaca (`instruction` / `output`), OpenAI chat (`messages`) e texto bruto também funcionam — Backpropagate detecta automaticamente o formato.
 
-### Ajuste de preferência (ORPO)
+### Ajuste de preferências (ORPO, SimPO, KTO)
 
 Novo na v1.5: treine com base em preferências em vez de demonstrações simples. ORPO não requer referência e é de estágio único — ele incorpora o sinal de preferência na etapa de ajuste fino SFT, portanto, não há um modelo de recompensa ou referência separado e a forma de 3 linhas permanece inalterada. Passe `--method orpo` (CLI) ou `method="orpo"` (Python) e forneça um conjunto de dados de linhas `{prompt, chosen, rejected}` (ou apenas `{chosen, rejected}`):
 
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-A taxa de aprendizado padrão é automaticamente reduzida para `8e-6` para ORPO (a perda é mais acentuada do que em SFT simples); ajuste `--orpo-beta` (padrão `0.1`) para ponderar a penalidade da razão de chances. Na v1.5, ORPO é apenas `mode="lora"`. SimPO e KTO são planejados como complementos; para RL online (PPO/GRPO), consulte [O que Backpropagate NÃO é](#what-backpropagate-is-not-for).
+A taxa de aprendizado padrão é automaticamente reduzida para `8e-6` para ORPO (a perda é mais acentuada do que no SFT simples); ajuste `--orpo-beta` (padrão `0.1`) para ponderar a penalidade da razão de chances. ORPO é apenas em `mode="lora"`.
+
+**Novo na v1.6 — SimPO e KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) não requer referência, utiliza uma recompensa normalizada pelo comprimento e usa os mesmos dados pareados `{prompt, chosen, rejected}` que o ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) usa dados **não pareados** `{prompt, completion, label}` — avaliações individuais de "gostei/não gostei" — para a grande classe de feedback que não é um conjunto curado de pares A/B; ele equilibra automaticamente os pesos desejáveis/indesejáveis da perda com base nas contagens dos seus rótulos. Ambos são apenas em `mode="lora"` e permanecem no ambiente SFT de GPU única (sem modelo de referência separado). Consulte o [manual de ajuste de preferências](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) para saber qual usar. Para RL online (PPO/GRPO), consulte [O que o Backpropagate NÃO é](#what-backpropagate-is-not-for).
 
 ### Rastreamento de raciocínio SFT (destilação R1)
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 Na v1.5, o caminho MLX é **apenas LoRA SFT** — sem ORPO, sem FP8, sem `mode='full'`, sem execução múltipla em MLX ainda (cada um é rejeitado com `CONFIG_INVALID_SETTING`; use `backend='cuda'`/`'auto'` em uma máquina NVIDIA para esses). O adaptador resultante é apenas safetensors e é exportado para o Ollama pelo mesmo caminho do caminho CUDA.
 
-> ⚠️ **Status honesto:** o caminho MLX é lançado na v1.5 **construído + testado em unidade (simulado)**, mas **AINDA NÃO verificado em Apple Silicon real** — `mlx-lm` é exclusivo da Apple e não pôde ser executado na máquina NVIDIA em que isso foi desenvolvido. Trate-o como experimental (o mesmo enquadramento do caminho FP8) e, por favor, [relate anomalias](#reporting-bugs) assim que for executado em um Mac da série M. Forçar `--backend mlx` em um host que não seja Apple gera um erro com `CONFIG_INVALID_SETTING`; a ausência do conjunto de ferramentas `mlx_lm` em um Mac gera `DEP_MLX_UNAVAILABLE`.
+> ⚠️ **Situação atual:** a versão MLX incluída na v1.5 foi **construída + testada em unidade (simulada)**, mas **ainda não foi verificada em testes reais com Apple Silicon** — `mlx-lm` é exclusivo para Apple e não pôde ser executado no sistema NVIDIA onde este código foi desenvolvido. Considere como experimental — a mesma abordagem que o caminho FP8 teve na v1.5 (FP8 passou para testes reais em Blackwell na v1.6; MLX ainda precisa passar por esse teste em silício real) — e, por favor, [relate anomalias](#reporting-bugs) assim que for executado em um Mac da série M. Forçar `--backend mlx` em um host não Apple gera o erro `CONFIG_INVALID_SETTING`; a ausência de uma ferramenta `mlx_lm` em um Mac gera `DEP_MLX_UNAVAILABLE`.
 
 Para fluxos de trabalho de ponta a ponta mais abrangentes (ajuste fino e envio para o HF-Hub, retomada após estouro de memória, SLAO de execução múltipla em uma campanha longa, etc.), consulte a [página de receitas do manual](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
 
@@ -303,7 +305,7 @@ As operações de escrita no sistema de arquivos a partir da interface do usuár
 
 **Requisitos:** Python 3.10+ · GPU CUDA (8 GB+ de VRAM) · PyTorch 2.0+
 
-O Python 3.10 atingirá o fim do ciclo de vida em outubro de 2026 e está programado para ser removido na versão 1.5. Para novas instalações, prefira o Python 3.11 ou 3.12 — o 3.11 é a versão mais testada.
+O Python 3.10 é suportado até, pelo menos, a v1.6; seu suporte oficial termina em outubro de 2026 e está programado para ser removido na primeira versão após essa data. Para novas instalações, prefira o Python 3.11 ou 3.12 — o 3.11 é a versão mais testada.
 
 O Backpropagate lida com as peculiaridades de tempo de execução do treinamento em diferentes plataformas, mas não pode corrigir problemas de tempo de instalação. Os dois mais comuns são:
 

package/README.zh.md

@@ -145,7 +145,7 @@ trainer.export('gguf', quantization='q4_k_m')
 
 Alpaca（`instruction` / `output`）、OpenAI 聊天（`messages`）和原始文本格式也可以工作——Backpropagate 会自动检测格式。
 
-### 偏好调整（ORPO）
+### 偏好调整（ORPO、SimPO、KTO）
 
 v1.5 版本的新功能：使用偏好而不是纯演示进行训练。ORPO 是无参考且单阶段的——它将偏好信号折叠到 SFT 步骤中，因此没有单独的奖励或参考模型，并且 3 行的结构保持不变。通过 `--method orpo`（CLI）或 `method="orpo"`（Python）传递，并提供一个包含 `{prompt, chosen, rejected}`（或仅 `{chosen, rejected}`）行的数据集：
 
@@ -166,7 +166,9 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-默认的学习率会自动降低到 `8e-6`，用于 ORPO（损失函数比普通的 SFT 更陡峭）；调整 `--orpo-beta`（默认值为 `0.1`）以调整优势比惩罚的权重。在 v1.5 中，ORPO 仅为 `mode="lora"`。SimPO 和 KTO 计划作为后续功能推出；对于在线 RL（PPO/GRPO），请参阅 [反向传播并非](#what-backpropagate-is-not-for)。
+对于 ORPO，默认学习率会自动降低到 `8e-6`（损失函数比普通的 SFT 更陡峭）；通过调整 `--orpo-beta`（默认为 `0.1`）来设置赔率比惩罚的权重。ORPO 仅适用于 `mode="lora"`。
+
+**v1.6 版本的新功能 — SimPO 和 KTO。** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) 不需要参考数据，使用长度归一化的奖励，并采用与 ORPO 相同的配对 `{prompt, chosen, rejected}` 数据（`--simpo-beta`、`--simpo-gamma`）。`--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) 使用**未配对的** `{prompt, completion, label}` 数据——每个示例的“好评/差评”——用于处理大量非人工筛选的 A/B 对反馈；它会自动平衡来自标签计数的理想/不理想损失权重。两者都仅适用于 `mode="lora"`，并且仍然在单个 GPU 的 SFT 范围内（没有单独的参考模型）。请参阅[偏好调整手册](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) 以了解应该使用哪一个。对于在线 RL（PPO/GRPO），请参见[Backpropagate 并非用于](#what-backpropagate-is-not-for)。
 
 ### 基于推理轨迹的 SFT（R1 蒸馏）
 
@@ -190,7 +192,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 在 v1.5 中，MLX 框架**仅支持 LoRA SFT**——不支持 ORPO、不支持 FP8、不支持 `mode='full'`，目前也不支持在 MLX 上进行多轮训练（每轮都会出现 `CONFIG_INVALID_SETTING` 错误；如果需要这些功能，请在 NVIDIA 机器上使用 `backend='cuda'`/`'auto'`）。生成的适配器是纯 safetensors 格式，并通过与 CUDA 框架相同的路径导出到 Ollama。
 
-> ⚠️ **诚实的状态：** MLX 框架在 v1.5 中以**已构建 + 单元测试（模拟）**的形式提供，但**尚未在真实的 Apple Silicon 上进行实际验证**——`mlx-lm` 仅适用于 Apple，并且无法在此处编写代码的 NVIDIA 机器上运行。将其视为实验性功能（与 FP8 路径具有相同的框架），并且请在它在 M 系列 Mac 上运行时[报告异常](#reporting-bugs)。在非 Apple 机器上强制使用 `--backend mlx` 会出现 `CONFIG_INVALID_SETTING` 错误；如果在 Mac 上缺少 `mlx_lm` 工具链，则会显示 `DEP_MLX_UNAVAILABLE`。
+> ⚠️ **当前状态：**v1.5 版本中包含的 MLX 框架已经过构建和单元测试（模拟），但**尚未在真实的 Apple Silicon 上进行实际验证**——`mlx-lm` 仅适用于 Apple 设备，无法在此处编写代码时运行在 NVIDIA 系统上。请将其视为实验性功能——与 v1.5 中 FP8 路径的初始状态相同（FP8 在 v1.6 中已升级到经过实际验证的状态；MLX 仍需要在真实的硬件上进行测试），并且请在它在一系列 M 型 Mac 上运行时[报告异常](#reporting-bugs)。如果在非 Apple 主机上强制使用 `--backend mlx`，则会出错并显示 `CONFIG_INVALID_SETTING`；如果 Mac 上缺少 `mlx_lm` 工具链，则会显示 `DEP_MLX_UNAVAILABLE`。
 
 有关更多端到端的流程（微调并推送到 HF Hub、在 OOM 之后恢复、在长时间的训练过程中进行多轮 SLAO 等），请参阅 [手册配方页面](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/)。
 
@@ -303,7 +305,7 @@ UI 中的文件系统写入操作被限制在一个目录中：
 
 **要求：** Python 3.10+ · CUDA GPU（8GB+ VRAM）· PyTorch 2.0+
 
-Python 3.10 将于 2026 年 10 月达到其生命周期终点，并且计划在 v1.5 中停止支持。对于新安装，建议使用 Python 3.11 或 3.12——3.11 是经过最多测试的最低版本。
+Python 3.10 至少支持到 v1.6 版本；它将在 2026 年 10 月达到上游生命周期结束，并且计划在之后发布的第一个版本中删除。对于新安装，建议使用 Python 3.11 或 3.12——3.11 是经过最多测试的版本。
 
 Backpropagate 处理不同平台上训练时出现的一些运行时问题，但它无法修复安装时出现的问题。最常见的问题有两个：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcptoolshop/backpropagate",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Deprecated npm distribution shim for backpropagate — prints install guidance for pipx/uv tool/pip. See https://github.com/mcp-tool-shop-org/backpropagate",
   "type": "commonjs",
   "license": "MIT",