@mcptoolshop/backpropagate 1.3.0 → 1.4.0

package/README.es.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ Aquí tienes un rango práctico en una tarjeta de 16GB (RTX 4080 / 5080 / 4070 T
 | Modelo | Método | Estado |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Cómodo. Longitud de secuencia completa, con espacio de sobra. |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (límite de 3B de parámetros) | `mode="full"` (ajuste fino completo) | v1.4: Use el parámetro `--mode=full` en `backprop train` o `Trainer(..., mode="full")`. El checkpointing de gradientes y el Adam de 8 bits con paginación mantienen la memoria de activación en sqrt(L). |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Estándar. ~7-8 GB. Configuraciones predeterminadas de Backpropagate. |
 | Llama-3 13B | QLoRA + empaquetado de muestras | Apretado pero funciona. Usa secuencias más cortas. |
-| Mixtral 8x7B (47B de parámetros totales) | AQLM de 2 bits + LoRA | Experimental en v1.4. El modelo más grande que puedes usar en una tarjeta de 16GB. |
+| Mixtral 8x7B (47B de parámetros totales) | AQLM de 2 bits + LoRA | Planificado para v1.5: Consulte el documento V1_5_BRIEF cuando se publique. |
+
+La cuantización AQLM de 2 bits (`quant_method="aqlm"`, opción experimental para Mixtral-8x7B en 16GB) estaba prevista para v1.4 y ahora está planificada para v1.5. La biblioteca `aqlm` está madura; en la versión 1.4, se priorizó el soporte para el ajuste fino completo de modelos de hasta 3B (`mode="full"`) en lugar de agregar un nuevo backend de cuantización. Consulte el documento V1_5_BRIEF cuando se publique para ver el plan de implementación de la versión 1.5.
 
-Para modelos de 3B y menos, el ajuste fino completo (no solo LoRA) es factible en 16GB y está planeado como una opción `mode="full"` para v1.4. Para modelos de 7B o más, el ajuste fino completo requiere una GPU de 24GB o más: considera alquilar una instancia de A100 en la nube, o quédate con LoRA, que la investigación reciente muestra que coincide con la calidad del ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento (consulta la sección "lo que Backpropagate no es" para obtener citas).
+Para modelos de 3B o menos, el ajuste fino completo (no solo LoRA) es posible en 16GB y ahora está disponible en la versión 1.4 como `mode="full"`. Utilice `Trainer(..., mode="full")` o `backprop train --mode=full --model phi-4-mini-3.8b` para habilitarlo. Un mecanismo de seguridad impide el uso de este modo para modelos mayores de 3B, mostrando el error `RUNTIME_FULL_FT_MODEL_TOO_LARGE` y sugiriendo LoRA y las configuraciones preestablecidas para modelos de menos de 3B como alternativas. Consulte la [página completa del manual de ajuste fino](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) para obtener información sobre la configuración y la comparación de calidad de Biderman 2024 / Thinking Machines 2025. Para modelos de 7B o más, el ajuste fino completo requiere una GPU de 24GB o más; considere alquilar una GPU A100 en la nube, o utilice LoRA, que, según investigaciones recientes, ofrece una calidad comparable al ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento (consulte la [sección de advertencias](#what-backpropagate-is-not-for) para obtener referencias).
 
 ## Lo que Backpropagate NO es
 
-La honestidad ayuda a todos. Backpropagate no hace estas cosas, e intentar que lo haga sería una experiencia peor que buscar la herramienta adecuada:
+Si su caso de uso es diferente a los siguientes, obtendrá mejores resultados con otra biblioteca. Backpropagate no es la opción adecuada, e intentar que funcione le costará más que simplemente utilizar la herramienta correcta. Leer esta sección antes de comenzar le ahorrará el ciclo de instalación y prueba:
 
-- **Ajuste fino completo de parámetros para modelos de 7B+** — Backpropagate utiliza LoRA/QLoRA, que entrena un adaptador pequeño en lugar de actualizar cada peso. Para modelos de 7B y superiores, el ajuste fino completo requiere 24 GB+ de memoria de GPU y no cabe en una tarjeta de consumo de 16 GB. Para modelos de 3B y menos, el ajuste fino completo SÍ es posible con 16 GB; se planea una opción `mode="full"` para la versión 1.4. En resumen: investigaciones recientes ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) muestran que LoRA, con la configuración correcta, iguala la calidad del ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento (seguimiento de instrucciones, adaptación de dominio, personalidad/estilo) con el 67% de la capacidad de cómputo; por lo tanto, para el trabajo que la mayoría de los usuarios realmente desean, no se pierde nada al usar LoRA. Si realmente necesita el ajuste fino completo de un modelo de 7B+, utilice `transformers.Trainer` de HuggingFace directamente en una tarjeta de 24 GB+.
-- **DPO / PPO / GRPO / ajuste de preferencias** — Backpropagate solo realiza un ajuste fino supervisado en una sola etapa. Para el aprendizaje por preferencias, utilice TRL directamente o LLaMA-Factory.
-- **Entrenamiento en múltiples nodos** — solo una GPU en una sola máquina. El uso de múltiples GPU en una sola máquina funciona (a través de `accelerate launch`), pero no está oficialmente soportado.
-- **Entrenamiento en macOS** — Apple Silicon no tiene CUDA, por lo que el entrenamiento debe ejecutarse en una máquina con Linux o Windows con una GPU NVIDIA. Aún puede ejecutar el modelo entrenado en una Mac a través de Ollama.
-- **Cualquier cosa fuera de las familias de modelos probadas** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Otros modelos a menudo funcionan, pero no están incluidos en las pruebas automatizadas.
+- **Ajuste fino de todos los parámetros de modelos de 7B o más:** Backpropagate utiliza LoRA / QLoRA, que entrena un adaptador pequeño en lugar de actualizar cada peso. Para modelos de 7B o más, el ajuste fino completo requiere 24GB o más de memoria de GPU y no cabe en una tarjeta de consumo de 16GB. Para modelos de 3B o menos, el ajuste fino completo SÍ es posible en 16GB y está disponible en la versión 1.4 como `mode="full"` (utilice `Trainer(..., mode="full")` o `--mode=full` en la línea de comandos; un mecanismo de seguridad genera el error `RUNTIME_FULL_FT_MODEL_TOO_LARGE` para modelos mayores de 3B y sugiere LoRA y las configuraciones preestablecidas para modelos de menos de 3B como alternativas). En resumen: investigaciones recientes ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) demuestran que LoRA, con la configuración correcta, ofrece una calidad comparable al ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento (seguimiento de instrucciones, adaptación de dominio, personalidad/estilo) con un 67% menos de recursos computacionales; por lo tanto, para el trabajo que la mayoría de los usuarios desean realizar, no se pierde nada al utilizar LoRA. `mode="full"` existe para los casos en los que ha detectado una diferencia de calidad y ha decidido invertir recursos computacionales adicionales. Si realmente necesita realizar un ajuste fino completo de un modelo de 7B o más, utilice directamente el `Trainer` de HuggingFace `transformers` en una tarjeta de 24GB o más.
+- **DPO / PPO / GRPO / ajuste de preferencias:** Backpropagate solo realiza un ajuste fino supervisado de una sola etapa. Para el aprendizaje por preferencias, utilice TRL directamente o LLaMA-Factory.
+- **Entrenamiento en múltiples nodos:** Solo se admite una GPU en una sola máquina. El entrenamiento con varias GPU en una sola máquina funciona (a través de `accelerate launch`), pero no está oficialmente soportado.
+- **Entrenamiento en macOS:** Apple Silicon no tiene CUDA, por lo que el entrenamiento debe ejecutarse en un sistema Linux o Windows con una GPU NVIDIA. Aún puede ejecutar el modelo entrenado en un Mac a través de Ollama.
+- **Cualquier modelo que no pertenezca a las familias de modelos probadas:** Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Otros modelos a menudo funcionan, pero no están incluidos en las pruebas automatizadas.
 
 Si necesita alguna de estas funciones, utilice una de las bibliotecas mencionadas anteriormente. Son mejores en eso.
 
@@ -331,12 +334,12 @@ Cuando algo falla, Backpropagate imprime una línea al inicio, como `run_started
 
 Un buen informe de error incluye:
 
-1. **El `run_id`**: el UUID que se imprime al inicio.
-2. **El código de error**: la línea `[CODE_NAME]: message` en stderr. Consulte [códigos de error](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) para ver el catálogo.
-3. **La línea de comandos con información sensible eliminada**. El stderr se elimina automáticamente (los tokens Bearer, `sk-*`, `hf_*`, las claves de AWS, los pares `password=` / `token=` se eliminan), por lo que es seguro pegarlo. Para obtener el rastreo completo y sin eliminar información, vuelva a ejecutar con `--verbose`, pero revise antes de publicarlo.
-4. **Versiones de Python / PyTorch, modelo de GPU, sistema operativo**. `backprop info` imprime todo esto de una vez.
+1. **El `run_id`**: El UUID que se muestra al inicio. Un UUID permite al responsable del sistema correlacionar cada línea de registro, cada punto de control y cada entrada de Weights & Biases para esa ejecución específica.
+2. **El código de error**: La línea `[NOMBRE_DEL_CÓDIGO]: mensaje` que aparece en stderr. Consulte [códigos de error](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) para ver el catálogo de códigos estables.
+3. **El rastreo de errores (traceback) con información sensible eliminada.** En el modo no detallado, stderr se elimina automáticamente (los tokens Bearer, `sk-*`, `hf_*`, las claves de AWS, y las parejas `password=` / `token=` / `api_key=` se eliminan) — es seguro copiarlo. Para ver el rastreo de errores completo y sin información sensible eliminada, ejecute de nuevo con `BACKPROPAGATE_DEBUG=1` (o `--verbose`); revise antes de publicarlo.
+4. **La salida de `backprop info`**. Un comando imprime información sobre Python / PyTorch / CUDA / el modelo de la GPU / VRAM / el sistema operativo / los complementos instalados: todo lo que el responsable del sistema necesita para identificar la causa de una regresión específica de la plataforma.
 
-Las preguntas, ideas o discusiones sobre si algo es "esperado" deben realizarse en [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Los problemas de seguridad deben informarse de forma privada a través del formulario [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new); consulte [SECURITY.md](SECURITY.md) para ver la política.
+La [plantilla para informes de errores](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) solicita explícitamente cada uno de estos elementos, lo que permite una resolución rápida de los problemas. Las preguntas, ideas o discusiones sobre si un comportamiento es esperado deben realizarse en [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Los problemas de seguridad deben informarse de forma privada a través del formulario de [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new); consulte el archivo [SECURITY.md](SECURITY.md) para conocer la política y los plazos de respuesta.
 
 ## Privacidad
 

package/README.fr.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ Voici les limites pratiques sur une carte de 16 Go (RTX 4080 / 5080 / 4070 Ti Su
 | Modèle | Méthode | Statut |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Confortable. Longueur de séquence complète, avec de la marge. |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (limite de 3 milliards de paramètres) | `mode="full"` (ajustement fin complet) | v1.4 — Utilisez l'option `--mode=full` avec `backprop train` ou `Trainer(..., mode="full")`. Le checkpointing des gradients et l'optimiseur Adam en 8 bits avec pagination maintiennent la mémoire d'activation à sqrt(L). |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Standard. Environ 7-8 Go. Les paramètres par défaut de Backpropagate. |
 | Llama-3 13B | QLoRA + échantillonnage | Juste limite, mais fonctionne. Utilisez des séquences plus courtes. |
-| Mixtral 8x7B (47 milliards de paramètres au total) | AQLM 2 bits + LoRA | Expérimental en v1.4. Le plus grand modèle que vous puissiez utiliser sur une carte de 16 Go. |
+| Mixtral 8x7B (47 milliards de paramètres au total) | AQLM 2 bits + LoRA | Prévu pour v1.5 — Consultez le document V1_5_BRIEF lorsqu'il sera publié. |
+
+La quantification AQLM 2 bits (`quant_method="aqlm"`, option expérimentale pour Mixtral-8x7B sur 16 Go) était prévue pour v1.4 et est maintenant prévue pour v1.5. La bibliothèque `aqlm` est mature ; la feuille de route de v1.4 a donné la priorité au support de l'ajustement fin complet pour les modèles ≤ 3 milliards de paramètres (`mode="full"`) plutôt qu'à l'ajout d'un nouveau backend de quantification. Consultez le document V1_5_BRIEF lorsqu'il sera publié pour connaître le plan de mise en œuvre de v1.5.
 
-Pour les modèles de 3 milliards de paramètres et moins, un ajustement fin complet (et non seulement LoRA) est possible sur 16 Go et est prévu comme une option `mode="full"` pour la version 1.4. Pour les modèles de 7 milliards de paramètres et plus, un ajustement fin complet nécessite un GPU de 24 Go ou plus. Envisagez de louer un A100 dans le cloud, ou utilisez LoRA, qui, selon les recherches récentes, offre une qualité équivalente à l'ajustement fin complet pour la plupart des tâches post-entraînement (voir la section "ce que Backpropagate n'est pas" pour les références).
+Pour les modèles de 3 milliards de paramètres et moins, l'ajustement fin complet (et non pas seulement LoRA) est possible sur 16 Go et est désormais disponible dans v1.4 avec l'option `mode="full"`. Utilisez `Trainer(..., mode="full")` ou `backprop train --mode=full --model phi-4-mini-3.8b` pour l'activer. Un mécanisme de protection empêche l'utilisation de ce mode pour les modèles > 3 milliards de paramètres, en proposant LoRA et les configurations pré-établies pour les modèles < 3 milliards de paramètres comme solutions de contournement. Consultez [la page complète sur l'ajustement fin](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) pour les détails de configuration et la comparaison de qualité entre Biderman 2024 et Thinking Machines 2025. Pour les modèles de 7 milliards de paramètres et plus, l'ajustement fin complet nécessite une GPU de 24 Go ou plus ; envisagez une location de GPU A100 dans le cloud, ou utilisez LoRA, qui, selon des recherches récentes, offre une qualité équivalente à l'ajustement fin complet pour la plupart des tâches après l'entraînement (voir [la section "Ce que Backpropagate n'est pas"](#what-backpropagate-is-not) pour les références).
 
 ## Ce que Backpropagate N'EST PAS
 
-Une description honnête aide tout le monde. Backpropagate ne fait pas ces choses, et essayer de le faire le ferait vivre une expérience pire que celle de chercher l'outil approprié :
+Si votre cas d'utilisation correspond à l'un des éléments suivants, vous obtiendrez de meilleurs résultats avec une autre bibliothèque. Backpropagate n'est pas le choix idéal, et essayer de le faire fonctionner coûterait plus cher que d'utiliser l'outil approprié. Lire cette section avant de commencer vous évitera de devoir installer et désinstaller à plusieurs reprises :
 
-- **Affinage précis des modèles de plus de 7 milliards de paramètres** — Backpropagate utilise LoRA/QLoRA, qui entraîne un petit adaptateur au lieu de mettre à jour chaque poids. Pour les modèles de 7 milliards de paramètres et plus, l'affinage complet nécessite 24 Go de mémoire GPU et ne tient pas sur une carte grand public de 16 Go. Pour les modèles de 3 milliards de paramètres et moins, l'affinage complet est possible avec 16 Go ; une option `mode="full"` est prévue pour la version 1.4. L'essentiel : des recherches récentes ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) montrent que LoRA, avec une configuration appropriée, offre une qualité d'affinage comparable à l'affinage complet pour la plupart des tâches post-entraînement (suivi d'instructions, adaptation au domaine, personnalité/style), tout en utilisant 67 % moins de ressources de calcul. Ainsi, pour la plupart des tâches que les utilisateurs souhaitent réellement effectuer, vous ne perdez rien en utilisant LoRA. Si vous avez réellement besoin d'un affinage complet d'un modèle de plus de 7 milliards de paramètres, utilisez directement le module `transformers.Trainer` de HuggingFace sur une carte de 24 Go ou plus.
-- **DPO / PPO / GRPO / affinage par préférences** — Backpropagate effectue uniquement un affinage supervisé en une seule étape. Pour l'apprentissage par préférences, utilisez directement TRL ou LLaMA-Factory.
-- **Entraînement multi-nœuds** — uniquement un GPU sur une seule machine. L'utilisation de plusieurs GPU sur une seule machine est possible (via `accelerate launch`), mais n'est pas officiellement prise en charge.
-- **Entraînement sur macOS** — Apple Silicon ne dispose pas de CUDA, l'entraînement doit donc être effectué sur une machine Linux ou Windows avec un GPU NVIDIA. Vous pouvez toujours exécuter le modèle entraîné sur un Mac via Ollama.
-- **Tout ce qui se trouve en dehors des familles de modèles testées** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. D'autres modèles fonctionnent souvent, mais ne sont pas inclus dans les tests d'intégration continue.
+- **Ajustement fin complet des paramètres des modèles de 7 milliards de paramètres et plus** — Backpropagate utilise LoRA / QLoRA, qui entraîne un petit adaptateur au lieu de mettre à jour chaque poids. Pour les modèles de 7 milliards de paramètres et plus, l'ajustement fin complet nécessite 24 Go de mémoire GPU et ne peut pas être exécuté sur une carte grand public de 16 Go. Pour les modèles de 3 milliards de paramètres et moins, l'ajustement fin complet est possible sur 16 Go et est disponible dans v1.4 avec l'option `mode="full"` (utilisez `Trainer(..., mode="full")` ou `--mode=full` dans l'interface de ligne de commande ; un mécanisme de protection empêche l'utilisation de ce mode pour les modèles > 3 milliards de paramètres et propose LoRA et les configurations pré-établies pour les modèles < 3 milliards de paramètres comme solutions de contournement). Pour résumer : des recherches récentes ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) montrent que LoRA, avec une configuration appropriée, offre une qualité équivalente à l'ajustement fin complet pour la plupart des tâches après l'entraînement (suivi d'instructions, adaptation à un domaine spécifique, personnalisation/style) avec seulement 67 % de la puissance de calcul. Ainsi, pour la plupart des tâches que les utilisateurs souhaitent effectuer, vous ne perdez rien à utiliser LoRA. L'option `mode="full"` est disponible pour les cas où vous avez constaté un écart de qualité et que vous avez décidé de consacrer une puissance de calcul supplémentaire. Si vous avez réellement besoin d'un ajustement fin complet d'un modèle de 7 milliards de paramètres ou plus, utilisez directement le module `transformers.Trainer` de HuggingFace sur une carte de 24 Go ou plus.
+- **DPO / PPO / GRPO / ajustement des préférences** — Backpropagate ne prend en charge que l'ajustement fin supervisé en une seule étape. Pour l'apprentissage par préférences, utilisez directement TRL ou LLaMA-Factory.
+- **Entraînement multi-nœuds** — Fonctionne uniquement avec une seule GPU sur une seule machine. L'utilisation de plusieurs GPU sur une seule machine est possible (via `accelerate launch`) mais n'est pas officiellement prise en charge.
+- **Entraînement sur macOS** — Apple Silicon ne dispose pas de CUDA, l'entraînement doit donc être effectué sur une machine Linux ou Windows avec une GPU NVIDIA. Vous pouvez toujours exécuter le modèle entraîné sur un Mac via Ollama.
+- **Tout ce qui se trouve en dehors des familles de modèles testées** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. D'autres modèles peuvent fonctionner, mais ne sont pas inclus dans les tests automatisés.
 
 Si vous avez besoin de ces fonctionnalités, utilisez l'une des bibliothèques mentionnées ci-dessus. Elles sont plus adaptées à cela.
 
@@ -331,12 +334,12 @@ Lorsqu'une erreur se produit, Backpropagate affiche une ligne au démarrage, com
 
 Un bon rapport de bogue comprend :
 
-1. **L'ID de la session (`run_id`)** : l'UUID affiché au démarrage.
-2. **Le code d'erreur** : la ligne `[CODE_NAME]: message` dans la sortie d'erreur standard (stderr). Consultez [la liste des codes d'erreur](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) pour plus d'informations.
-3. **La ligne de commande masquée.** La sortie d'erreur standard est automatiquement masquée (les jetons Bearer, les chaînes commençant par `sk-*`, `hf_*`, les clés AWS, les paires `password=` / `token=` sont supprimées) ; vous pouvez la copier sans problème. Pour obtenir la trace complète et non masquée, relancez l'exécution avec l'option `--verbose`, mais examinez-la avant de la publier.
-4. **Versions de Python / PyTorch, modèle du GPU, système d'exploitation.** La commande `backprop info` affiche toutes ces informations en une seule fois.
+1. **L'identifiant de session (`run_id`)** : L'UUID affiché au démarrage. Un UUID permet à un responsable de corréler chaque ligne de journal, chaque point de contrôle et chaque entrée Weights & Biases pour cette session spécifique.
+2. **Le code d'erreur** : La ligne `[NOM_DU_CODE]: message` dans la sortie d'erreur standard (stderr). Consultez [la liste des codes d'erreur](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) pour connaître les codes stables.
+3. **La trace de la pile masquée.** La sortie d'erreur standard est automatiquement masquée en mode non verbeux (les jetons d'authentification, les clés commençant par `sk-*`, `hf_*`, les clés AWS, les paires `password=` / `token=` / `api_key=` sont supprimées) ; vous pouvez la copier sans risque. Pour afficher la trace de la pile complète et non masquée, relancez le programme avec `BACKPROPAGATE_DEBUG=1` (ou `--verbose`) ; examinez-la attentivement avant de la publier.
+4. **La sortie de la commande `backprop info`**. Une seule commande affiche les informations sur Python, PyTorch, CUDA, le modèle GPU, la VRAM, le système d'exploitation et les modules complémentaires installés : toutes les informations dont un responsable a besoin pour identifier une régression spécifique à une plateforme.
 
-Les questions, les suggestions ou les discussions sur le fait de savoir si un comportement est normal doivent être posées sur [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Les problèmes de sécurité doivent être signalés de manière privée via le formulaire [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) ; consultez le fichier [SECURITY.md](SECURITY.md) pour connaître la politique.
+Le [modèle de rapport de bug](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) vous demande explicitement de fournir ces informations, ce qui accélère le processus de triage. Les questions, les idées ou les discussions sur le type de comportement attendu doivent être posées dans [les discussions GitHub](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Les problèmes de sécurité doivent être signalés de manière privée via le formulaire [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) ; consultez le fichier [SECURITY.md](SECURITY.md) pour connaître la politique et les délais de réponse.
 
 ## Confidentialité
 

package/README.hi.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ pipx install "backpropagate[full]"       # adds everything: unsloth, ui, monitor
 | मॉडल | विधि | स्थिति |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | आरामदायक। पूर्ण सीक्वेंस लंबाई, अतिरिक्त जगह। |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (≤3B पैरामीटर की सीमा) | `mode="full"` (पूर्ण फाइन-ट्यूनिंग) | v1.4 — `backprop train` पर `--mode=full` या `Trainer(..., mode="full")` का उपयोग करें। ग्रेडिएंट चेकपॉइंटिंग + पेज्ड 8-बिट एडम, एक्टिवेशन मेमोरी को sqrt(L) पर बनाए रखता है। |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | मानक। लगभग 7-8 जीबी। बैकप्रोपैगेट की डिफ़ॉल्ट सेटिंग्स। |
 | Llama-3 13B | QLoRA + सैंपल पैकिंग | कठिन लेकिन काम करता है। छोटे सीक्वेंस का उपयोग करें। |
-| Mixtral 8x7B (कुल 47 बिलियन पैरामीटर) | AQLM 2-बिट + LoRA | v1.4 में प्रायोगिक। 16 जीबी के कार्ड पर आप जिस सबसे बड़े मॉडल को चला सकते हैं। |
+| Mixtral 8x7B (कुल 47 बिलियन पैरामीटर) | AQLM 2-बिट + LoRA | v1.5 के लिए योजनाबद्ध — जब पोस्ट किया जाए तो V1_5_BRIEF देखें। |
+
+AQLM 2-बिट क्वांटाइजेशन (`quant_method="aqlm"`), जो Mixtral-8x7B के लिए 16GB पर एक प्रायोगिक विकल्प है, v1.4 के लिए निर्धारित था और अब v1.5 के लिए योजनाबद्ध है। `aqlm` लाइब्रेरी परिपक्व है; v1.4 में, पूर्ण फाइन-ट्यूनिंग के समर्थन को प्राथमिकता दी गई (≤3B मॉडलों के लिए `mode="full"`), एक नए क्वांटाइजेशन बैकएंड को जोड़ने की तुलना में। v1.5 के कार्यान्वयन योजना के लिए V1_5_BRIEF देखें जब वह पोस्ट किया जाए।
 
-3 बिलियन और उससे छोटे मॉडलों के लिए, 16 जीबी पर पूर्ण फाइन-ट्यूनिंग (केवल LoRA नहीं) संभव है, और इसे v1.4 के लिए `mode="full"` विकल्प के रूप में योजनाबद्ध किया गया है। 7 बिलियन या उससे बड़े मॉडलों के लिए, पूर्ण फाइन-ट्यूनिंग के लिए 24 जीबी या उससे अधिक जीपीयू की आवश्यकता होती है - एक A100 क्लाउड रेंटल पर विचार करें, या LoRA का उपयोग करें, जो हाल के शोध से पता चलता है कि यह अधिकांश पोस्ट-ट्रेनिंग कार्यों पर पूर्ण फाइन-ट्यूनिंग की गुणवत्ता से मेल खाता है (अधिक उद्धरणों के लिए [इस अनुभाग](#what-backpropagate-is-not-for) देखें)।
+3B और उससे छोटे मॉडलों के लिए, 16GB पर पूर्ण फाइन-ट्यूनिंग (सिर्फ LoRA नहीं) संभव है और अब v1.4 में `mode="full"` के रूप में उपलब्ध है। इसे सक्षम करने के लिए `Trainer(..., mode="full")` या `backprop train --mode=full --model phi-4-mini-3.8b` का उपयोग करें। 3B से बड़े मॉडलों के लिए, यह मोड `RUNTIME_FULL_FT_MODEL_TOO_LARGE` त्रुटि के साथ अस्वीकार कर दिया जाता है, और LoRA और 3B से छोटे मॉडलों को रिकवरी विकल्प के रूप में सूचीबद्ध किया जाता है। कॉन्फ़िगरेशन गणित और Biderman 2024 / Thinking Machines 2025 द्वारा किए गए गुणवत्ता तुलना के लिए [पूर्ण फाइन-ट्यूनिंग हैंडबुक पृष्ठ](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) देखें। 7B+ मॉडलों के लिए, पूर्ण फाइन-ट्यूनिंग के लिए 24GB+ GPU की आवश्यकता होती है — एक A100 क्लाउड रेंटल पर विचार करें, या LoRA का उपयोग करें, जो हाल के शोध से पता चलता है कि अधिकांश पोस्ट-ट्रेनिंग कार्यों पर पूर्ण फाइन-ट्यूनिंग की गुणवत्ता से मेल खाता है (संदर्भों के लिए [एंटी-पिच अनुभाग](#what-backpropagate-is-not-for) देखें)।
 
 ## बैकप्रोपैगेट किसके लिए नहीं है
 
-ईमानदार स्कोप हर किसी की मदद करता है। बैकप्रोपैगेट इन चीजों को नहीं करता है, और इसे ऐसा करने की कोशिश करना सही उपकरण का उपयोग करने से भी बदतर अनुभव होगा:
+यदि आपका उपयोग-मामला नीचे दिए गए में से है, तो आपको किसी अन्य लाइब्रेरी के साथ बेहतर अनुभव होगा — Backpropagate सही विकल्प नहीं है, और इसे काम करने के लिए मजबूर करने से सही उपकरण का उपयोग करने की तुलना में अधिक लागत आएगी। इस अनुभाग को शुरू करने से पहले पढ़ना, इंस्टॉलेशन और परीक्षण चक्र को बचाता है:
 
-- **7B+ मॉडलों का पूर्ण-पैरामीटर फाइन-ट्यूनिंग:** बैकप्रोपगेट LoRA/QLoRA का उपयोग करता है, जो प्रत्येक वेट को अपडेट करने के बजाय एक छोटे एडाप्टर को प्रशिक्षित करता है। 7B और उससे बड़े मॉडलों के लिए, पूर्ण फाइन-ट्यूनिंग के लिए 24GB+ GPU मेमोरी की आवश्यकता होती है और यह 16GB के उपभोक्ता कार्ड पर फिट नहीं होता है। 3B और उससे छोटे मॉडलों के लिए, 16GB पर पूर्ण फाइन-ट्यूनिंग संभव है; v1.4 के लिए `mode="full"` विकल्प की योजना है। बड़ी तस्वीर: हाल के शोध (Biderman 2024, Thinking Machines 2025) से पता चलता है कि LoRA सही कॉन्फ़िगरेशन के साथ अधिकांश पोस्ट-ट्रेनिंग कार्यों (निर्देशों का पालन, डोमेन अनुकूलन, व्यक्तित्व/शैली) में पूर्ण फाइन-ट्यूनिंग की गुणवत्ता से मेल खाता है, और यह 67% कम कंप्यूटिंग संसाधनों का उपयोग करता है। इसलिए, अधिकांश ऑपरेटरों के लिए जो काम वे वास्तव में करना चाहते हैं, LoRA का उपयोग करने से उन्हें कोई नुकसान नहीं होता है। यदि आपको वास्तव में 7B+ मॉडल की पूर्ण फाइन-ट्यूनिंग की आवश्यकता है, तो HuggingFace `transformers.Trainer` को सीधे 24GB+ कार्ड पर उपयोग करें।
-- **DPO/PPO/GRPO/पसंद ट्यूनिंग:** बैकप्रोपगेट केवल सिंगल-स्टेज सुपरवाइज्ड फाइन-ट्यूनिंग करता है। पसंद सीखने के लिए, सीधे TRL या LLaMA-Factory का उपयोग करें।
-- **मल्टी-नोड प्रशिक्षण:** केवल एक मशीन पर एक GPU। एक मशीन पर मल्टी-GPU काम करता है (accelerate launch के माध्यम से), लेकिन यह आधिकारिक तौर पर समर्थित नहीं है।
-- **macOS पर प्रशिक्षण:** Apple Silicon में CUDA नहीं है, इसलिए प्रशिक्षण को Linux या Windows बॉक्स पर NVIDIA GPU के साथ चलाना होगा। आप प्रशिक्षित मॉडल को Ollama के माध्यम से Mac पर चला सकते हैं।
-- **परीक्षण किए गए मॉडल परिवारों के बाहर की कोई भी चीज़:** Qwen 2.5/3.5 (7B/4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B/1B), Mistral 7B। अन्य मॉडल अक्सर काम करते हैं लेकिन CI में पिन नहीं किए गए हैं।
+- **7B+ मॉडलों का पूर्ण-पैरामीटर फाइन-ट्यूनिंग** — Backpropagate LoRA / QLoRA का उपयोग करता है, जो प्रत्येक वजन को अपडेट करने के बजाय एक छोटे एडाप्टर को प्रशिक्षित करता है। 7B और उससे बड़े मॉडलों के लिए, पूर्ण फाइन-ट्यूनिंग के लिए 24GB+ GPU मेमोरी की आवश्यकता होती है और यह 16GB के उपभोक्ता कार्ड पर फिट नहीं होता है। 3B और उससे छोटे मॉडलों के लिए, पूर्ण फाइन-ट्यूनिंग 16GB पर संभव है और v1.4 में `mode="full"` के रूप में उपलब्ध है ( `Trainer(..., mode="full")` या `--mode=full` का उपयोग करके CLI पर; 3B से बड़े मॉडलों के लिए `RUNTIME_FULL_FT_MODEL_TOO_LARGE` त्रुटि उत्पन्न होती है और LoRA और 3B से छोटे मॉडल को रिकवरी विकल्प के रूप में सूचीबद्ध किया जाता है)। बड़ी तस्वीर: हाल के शोध ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) से पता चलता है कि LoRA, सही कॉन्फ़िगरेशन के साथ, अधिकांश पोस्ट-ट्रेनिंग कार्यों (निर्देश-अनुसरण, डोमेन अनुकूलन, व्यक्तित्व/शैली) पर पूर्ण फाइन-ट्यूनिंग की गुणवत्ता से मेल खाता है, और यह 67% कम कंप्यूट संसाधनों का उपयोग करता है — इसलिए, अधिकांश ऑपरेटरों द्वारा किए जाने वाले कार्यों के लिए, LoRA का उपयोग करने से आपको कुछ भी नहीं खोना पड़ता। `mode="full"` उन मामलों के लिए मौजूद है जहां आपने गुणवत्ता में अंतर को मापा है और अतिरिक्त कंप्यूट संसाधनों का उपयोग करने का निर्णय लिया है। यदि आपको वास्तव में 7B+ मॉडल का पूर्ण फाइन-ट्यूनिंग करने की आवश्यकता है, तो HuggingFace `transformers.Trainer` का उपयोग सीधे 24GB+ कार्ड पर करें।
+- **DPO / PPO / GRPO / प्राथमिकता ट्यूनिंग** — Backpropagate केवल सिंगल-स्टेज सुपरवाइज्ड फाइन-ट्यूनिंग करता है। प्राथमिकता सीखने के लिए, सीधे TRL या LLaMA-Factory का उपयोग करें।
+- **मल्टी-नोड प्रशिक्षण** — केवल एक मशीन पर सिंगल GPU। एक मशीन पर मल्टी-GPU काम करता है ( `accelerate launch` के माध्यम से), लेकिन आधिकारिक तौर पर समर्थित नहीं है।
+- **macOS प्रशिक्षण** — Apple Silicon में CUDA नहीं है, इसलिए प्रशिक्षण को Linux या Windows बॉक्स पर NVIDIA GPU के साथ चलाना होगा। आप प्रशिक्षित मॉडल को Ollama के माध्यम से Mac पर चला सकते हैं।
+- **परीक्षण किए गए मॉडल परिवारों के बाहर की कोई भी चीज़** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B। अन्य मॉडल अक्सर काम करते हैं लेकिन CI में पिन नहीं किए गए हैं।
 
 यदि आपको इनमें से किसी भी चीज़ की आवश्यकता है, तो ऊपर सूचीबद्ध पुस्तकालयों में से किसी एक का उपयोग करें। वे इसमें बेहतर हैं।
 
@@ -331,12 +334,12 @@ backprop export-runs --format jsonl    # bulk export run history
 
 एक अच्छी बग रिपोर्ट में शामिल हैं:
 
-1. **`run_id`** — स्टार्टअप पर प्रिंट किया गया यूयूआईडी।
-2. **त्रुटि कोड** — stderr में `[कोड_नाम]: संदेश` पंक्ति। त्रुटि कोड की सूची के लिए [त्रुटि कोड](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) देखें।
-3. **संपादित कमांड लाइन।** stderr स्वचालित रूप से संपादित किया जाता है (बेरर टोकन, `sk-*`, `hf_*`, AWS कुंजियाँ, `password=` / `token=` जोड़े हटा दिए जाते हैं) — इसे सुरक्षित रूप से पेस्ट किया जा सकता है। पूर्ण, संपादित न किए गए ट्रेसबैक के लिए, `--verbose` के साथ पुनः चलाएं, लेकिन पोस्ट करने से पहले इसकी समीक्षा करें।
-4. **पायथन / पायटॉर्च संस्करण, जीपीयू मॉडल, ऑपरेटिंग सिस्टम।** `backprop info` यह सब एक साथ प्रिंट करता है।
+1. **`run_id`**: यह UUID (यूनिवर्सल यूनिक आइडेंटिफायर) है जो स्टार्टअप के समय प्रदर्शित होता है। एक UUID एक रखरखावकर्ता को उस विशेष रन के लिए प्रत्येक लॉग लाइन, प्रत्येक चेकपॉइंट और प्रत्येक वेट्स एंड बायसेस प्रविष्टि को जोड़ने में मदद करता है।
+2. **त्रुटि कोड**: यह `stderr` में `[कोड_नाम]: संदेश` के रूप में दिखाई देने वाली लाइन है। स्थिर कोडों की सूची के लिए, [त्रुटि कोड](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) देखें।
+3. **संशोधित ट्रेसबैक (Traceback)।** गैर-विस्तृत मोड में `stderr` स्वचालित रूप से संशोधित किया जाता है (Bearer टोकन, `sk-*`, `hf_*`, AWS कुंजियाँ, `password=` / `token=` / `api_key=` जोड़े हटा दिए जाते हैं) - इसे सुरक्षित रूप से पेस्ट किया जा सकता है। पूर्ण, बिना संशोधित ट्रेसबैक के लिए, `BACKPROPAGATE_DEBUG=1` (या `--verbose`) के साथ पुनः चलाएं; पोस्ट करने से पहले इसकी समीक्षा करें।
+4. **`backprop info` आउटपुट।** एक कमांड Python / PyTorch / CUDA / GPU मॉडल / VRAM / ऑपरेटिंग सिस्टम / स्थापित अतिरिक्त सुविधाओं के बारे में जानकारी प्रदर्शित करता है - यह सब कुछ एक रखरखावकर्ता को किसी प्लेटफ़ॉर्म-विशिष्ट समस्या का पता लगाने के लिए आवश्यक होता है।
 
-प्रश्न, विचार, या "क्या यह अपेक्षित है" संबंधी चर्चाएं [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions) में होनी चाहिए। सुरक्षा संबंधी मुद्दों की रिपोर्ट [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) फॉर्म के माध्यम से निजी तौर पर की जानी चाहिए — नीति के लिए [SECURITY.md](SECURITY.md) देखें।
+[बग रिपोर्ट टेम्पलेट](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) इन सभी चीजों के लिए स्पष्ट रूप से जानकारी मांगता है, इसलिए समस्या निवारण प्रक्रिया तेजी से होती है। प्रश्न, विचार, या "क्या यह अपेक्षित है?" जैसे विषय [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions) पर पोस्ट किए जाने चाहिए। सुरक्षा संबंधी मुद्दों की रिपोर्ट [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) फॉर्म के माध्यम से निजी तौर पर की जानी चाहिए - नीति और प्रतिक्रिया समय-सीमा के लिए [SECURITY.md](SECURITY.md) देखें।
 
 ## गोपनीयता
 

package/README.it.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ 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 | Comodo. Lunghezza della sequenza completa, con spazio extra. |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (limite massimo di 3 miliardi di parametri) | `mode="full"` (affinamento completo) | v1.4 — utilizzare l'opzione `--mode=full` con `backprop train` oppure `Trainer(..., mode="full")`. Il checkpointing del gradiente e l'utilizzo di Adam a 8 bit con paginazione mantengono la memoria delle attivazioni a sqrt(L). |
 | 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 | Limitato ma funzionante. Utilizza sequenze più corte. |
-| Mixtral 8x7B (47 miliardi di parametri totali) | AQLM 2-bit + LoRA | Sperimentale nella versione 1.4. Il modello più grande che puoi utilizzare su una scheda da 16 GB. |
+| Mixtral 8x7B (47 miliardi di parametri totali) | AQLM 2-bit + LoRA | Previsto per la v1.5 — consultare il documento V1_5_BRIEF quando sarà disponibile. |
+
+La quantizzazione AQLM a 2 bit (`quant_method="aqlm"`, opzione sperimentale per Mixtral-8x7B su 16GB) era prevista per la v1.4 ed è ora pianificata per la v1.5. La libreria `aqlm` è matura; nella versione 1.4, la priorità è stata data al supporto per l'affinamento completo per modelli con un massimo di 3 miliardi di parametri (`mode="full"`) piuttosto che all'aggiunta di un nuovo backend di quantizzazione. Consultare il documento V1_5_BRIEF quando sarà disponibile per il piano di implementazione della v1.5.
 
-Per i modelli da 3 miliardi di parametri e inferiori, l'affinamento completo (non solo LoRA) è possibile su 16 GB ed è previsto come opzione `mode="full"` nella versione 1.4. Per i modelli da 7 miliardi di parametri o superiori, l'affinamento completo richiede una GPU da 24 GB o superiore: considera un'istanza cloud A100 oppure utilizza LoRA, che, secondo recenti ricerche, offre una qualità equivalente all'affinamento completo nella maggior parte delle attività di post-addestramento (vedi la sezione "cosa Backpropagate non è" per le citazioni).
+Per i modelli da 3 miliardi di parametri in giù, l'affinamento completo (e non solo LoRA) è possibile su 16GB ed è ora disponibile nella v1.4 con `mode="full"`. Per abilitarlo, utilizzare `Trainer(..., mode="full")` oppure `backprop train --mode=full --model phi-4-mini-3.8b`. Un meccanismo di controllo impedisce l'utilizzo di questa modalità per modelli superiori a 3 miliardi di parametri, suggerendo LoRA e le configurazioni predefinite inferiori a 3 miliardi come alternative. Consultare la [pagina completa del manuale sull'affinamento completo](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) per i dettagli sulla configurazione e per il confronto della qualità tra Biderman 2024 e Thinking Machines 2025. Per i modelli da 7 miliardi di parametri in su, l'affinamento completo richiede una GPU da 24GB o superiore; si consiglia di utilizzare un servizio di cloud con una GPU A100 oppure di utilizzare LoRA, che, secondo recenti ricerche, offre una qualità equivalente all'affinamento completo nella maggior parte delle attività successive all'addestramento (vedere la [sezione "cosa Backpropagate non è"](#what-backpropagate-is-not-for) per le citazioni).
 
 ## Cosa Backpropagate NON è
 
-Essere onesti aiuta tutti. Backpropagate non fa queste cose, e cercare di farlo sarebbe un'esperienza peggiore rispetto a utilizzare lo strumento giusto:
+Se il vostro caso d'uso rientra nelle categorie seguenti, otterrete risultati migliori con un'altra libreria. Backpropagate non è la scelta giusta e cercare di farlo funzionare costerebbe più che utilizzare lo strumento appropriato. Leggere questa sezione prima di iniziare vi farà risparmiare tempo e tentativi.
 
-- **Ottimizzazione completa dei parametri per modelli da 7B+** — Backpropagate utilizza LoRA / QLoRA, che addestra un piccolo adattatore invece di aggiornare ogni peso. Per i modelli da 7B e superiori, l'ottimizzazione completa richiede 24GB+ di memoria GPU e non è possibile eseguirla su una scheda consumer da 16GB. Per i modelli da 3B e inferiori, l'ottimizzazione completa è fattibile su 16GB; un'opzione `mode="full"` è prevista per la versione 1.4. In sintesi: 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, raggiunge una qualità simile all'ottimizzazione completa nella maggior parte delle attività di post-addestramento (seguimento delle istruzioni, adattamento al dominio, personalità/stile) utilizzando il 67% delle risorse di calcolo; quindi, per il tipo di lavoro che la maggior parte degli utenti desidera, non si perde nulla utilizzando LoRA. Se è realmente necessario eseguire un'ottimizzazione completa di un modello da 7B+, utilizzare direttamente `transformers.Trainer` di HuggingFace su una scheda da 24GB+.
-- **DPO / PPO / GRPO / ottimizzazione delle preferenze** — Backpropagate esegue solo l'ottimizzazione supervisionata in una singola fase. Per l'apprendimento basato sulle preferenze, utilizzare direttamente TRL o LLaMA-Factory.
-- **Addestramento multi-nodo** — solo una GPU su una singola macchina. L'utilizzo di più GPU su una singola macchina è possibile (tramite `accelerate launch`), ma non è ufficialmente supportato.
+- **Affinamento completo dei parametri per modelli da 7 miliardi di parametri in su** — Backpropagate utilizza LoRA / QLoRA, che addestra un piccolo adattatore invece di aggiornare tutti i pesi. Per i modelli da 7 miliardi di parametri in su, l'affinamento completo richiede 24GB+ di memoria GPU e non è possibile su una scheda consumer da 16GB. Per i modelli da 3 miliardi di parametri in giù, l'affinamento completo è possibile su 16GB ed è disponibile nella v1.4 con `mode="full"` (utilizzare `Trainer(..., mode="full")` oppure `--mode=full` dalla riga di comando; un meccanismo di controllo impedisce l'utilizzo di questa modalità per modelli superiori a 3 miliardi di parametri, suggerendo LoRA e le configurazioni predefinite inferiori a 3 miliardi come alternative). In sintesi: recenti ricerche ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) dimostrano che LoRA, con la configurazione corretta, offre una qualità equivalente all'affinamento completo nella maggior parte delle attività successive all'addestramento (istruzioni, adattamento al dominio, personalità/stile) con il 67% della potenza di calcolo; quindi, per il lavoro che la maggior parte degli operatori desidera svolgere, non si perde nulla utilizzando LoRA. `mode="full"` è disponibile per i casi in cui si è riscontrata una differenza di qualità e si è deciso di utilizzare una maggiore potenza di calcolo. Se è necessario affinare completamente un modello da 7 miliardi di parametri, utilizzare direttamente il modulo `transformers.Trainer` di HuggingFace su una scheda da 24GB o superiore.
+- **DPO / PPO / GRPO / ottimizzazione delle preferenze** — Backpropagate esegue solo l'affinamento supervisionato in una singola fase. Per l'apprendimento delle preferenze, utilizzare direttamente TRL o LLaMA-Factory.
+- **Addestramento multi-nodo** — supporta solo una GPU su una singola macchina. L'utilizzo di più GPU su una singola macchina è possibile (tramite `accelerate launch`) ma non è ufficialmente supportato.
 - **Addestramento su macOS** — Apple Silicon non dispone di CUDA, quindi l'addestramento deve essere eseguito su una macchina Linux o Windows con una GPU NVIDIA. È comunque possibile eseguire il modello addestrato su un Mac tramite Ollama.
-- **Qualsiasi modello al di fuori delle famiglie di modelli supportate** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Altri modelli potrebbero funzionare, ma non sono inclusi nei test automatizzati.
+- **Qualsiasi modello al di fuori delle famiglie di modelli testate** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Altri modelli potrebbero funzionare, ma non sono inclusi nei test automatizzati.
 
 Se avete bisogno di queste funzionalità, utilizzate una delle librerie elencate sopra. Sono più adatte per questo scopo.
 
@@ -331,12 +334,12 @@ Quando si verifica un errore, Backpropagate stampa una riga all'avvio, simile a
 
 Una segnalazione di bug efficace include:
 
-1. **Il `run_id`**: l'UUID stampato all'avvio.
-2. **Il codice di errore**: la riga `[CODE_NAME]: message` presente nell'output di errore standard (stderr). Consultare [codici di errore](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) per l'elenco completo.
-3. **La riga di comando mascherata.** L'output di errore standard viene automaticamente mascherato (i token di autorizzazione, le stringhe `sk-*`, `hf_*`, le chiavi AWS, le coppie `password=` / `token=` vengono eliminate) e può essere tranquillamente incollata. Per visualizzare la traccia completa e non mascherata, eseguire nuovamente il comando con l'opzione `--verbose`, ma esaminarla prima di pubblicarla.
-4. **Versioni di Python / PyTorch, modello della GPU, sistema operativo.** `backprop info` stampa tutte queste informazioni in un'unica volta.
+1. **L'ID di esecuzione (`run_id`)**: l'UUID visualizzato all'avvio. Un singolo UUID consente a un amministratore di correlare ogni riga del log, ogni punto di controllo e ogni voce di Weights & Biases relativa a quella specifica esecuzione.
+2. **Il codice di errore**: la riga `[NOME_CODICE]: messaggio` presente nello standard error (stderr). Consultare [codici di errore](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) per l'elenco dei codici stabili.
+3. **La traccia dello stack (traceback) oscurata.** Lo standard error viene automaticamente oscurato in modalità non dettagliata (i token di autorizzazione, le stringhe `sk-*`, `hf_*`, le chiavi AWS, le coppie `password=` / `token=` / `api_key=` vengono eliminate) – è sicuro copiarla. Per visualizzare la traccia dello stack completa e non oscurata, eseguire nuovamente il comando con `BACKPROPAGATE_DEBUG=1` (o `--verbose`); esaminarla prima di pubblicarla.
+4. **L'output di `backprop info`**. Un singolo comando stampa informazioni su Python / PyTorch / CUDA / modello GPU / VRAM / sistema operativo / moduli aggiuntivi installati: tutto ciò di cui un amministratore ha bisogno per identificare una regressione specifica della piattaforma.
 
-Domande, suggerimenti o discussioni su "se questo è un comportamento previsto" devono essere poste nella sezione [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Le segnalazioni di problemi di sicurezza devono essere inviate privatamente tramite il modulo [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) e consultare il file [SECURITY.md](SECURITY.md) per le relative policy.
+Il [modello per la segnalazione di bug](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) richiede esplicitamente queste informazioni, quindi la gestione delle segnalazioni è rapida. Domande, suggerimenti o discussioni del tipo "è un comportamento previsto?" devono essere pubblicate nelle [discussioni di GitHub](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Le problematiche di sicurezza devono essere segnalate privatamente tramite il modulo [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) – consultare il file [SECURITY.md](SECURITY.md) per le linee guida e i tempi di risposta.
 
 ## Privacy
 

package/README.ja.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ Backpropagateは、これらのライブラリとは異なるアプローチを
 | モデル | 方法 | 状態 |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | 快適。最大シーケンス長で動作し、余裕があります。 |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (パラメータ数が30億以下) | `mode="full"` (フルファインチューニング) | v1.4 — `backprop train` コマンドで `--mode=full` オプションを付与するか、`Trainer(..., mode="full")` を指定します。勾配チェックポイントとPaged 8-bit Adamを使用することで、活性化メモリをsqrt(L)に抑えます。 |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | 標準的。約7〜8GBのメモリを使用。Backpropagateのデフォルト設定。 |
 | Llama-3 13B | QLoRA + サンプルパッキング | ギリギリだが動作する。短いシーケンスを使用してください。 |
-| Mixtral 8x7B (合計470億パラメータ) | AQLM 2-bit + LoRA | v1.4での実験機能。16GBのカードで動作する最大のモデルです。 |
+| Mixtral 8x7B (合計470億パラメータ) | AQLM 2-bit + LoRA | v1.5では以下の機能が予定されています。詳細は、公開されたV1_5_BRIEFをご確認ください。 |
+
+AQLM 2-bit量子化 (`quant_method="aqlm"`) は、Mixtral-8x7Bを16GBのメモリで動作させるための実験的なオプションとしてv1.4で検討されていましたが、現在はv1.5での実装が予定されています。`aqlm` ライブラリは成熟していますが、v1.4では、フルファインチューニングのサポート（パラメータ数が30億以下のモデルに対して `mode="full"` を設定）を優先し、新しい量子化バックエンドの追加は見送られました。v1.5の実装計画については、公開されたV1_5_BRIEFをご確認ください。
 
-3B以下のモデルでは、LoRAだけでなく、フルファインチューニングも16GBで実行可能です。v1.4では`mode="full"`オプションとして実装予定です。7B以上のモデルでは、フルファインチューニングには24GB以上のGPUが必要になります。クラウドのA100インスタンスを検討するか、LoRAを使用することをお勧めします。最近の研究によると、LoRAはほとんどのトレーニング後のタスクで、フルファインチューニングと同等の品質が得られることがわかっています（詳細については、[このセクション](#what-backpropagate-is-not-for)を参照）。
+30億パラメータ以下のモデルでは、フルファインチューニング（LoRAだけでなく）が16GBのメモリでも可能であり、v1.4では `mode="full"` として提供されています。`Trainer(..., mode="full")` を指定するか、`backprop train --mode=full --model phi-4-mini-3.8b` コマンドを実行することで有効にできます。30億パラメータを超えるモデルに対しては、`RUNTIME_FULL_FT_MODEL_TOO_LARGE` エラーが発生し、フルファインチューニングは利用できません。この場合、LoRAや30億パラメータ以下のモデルのプリセットを使用できます。設定の詳細や、Biderman 2024 / Thinking Machines 2025による品質比較については、[フルファインチューニングに関する詳細なドキュメント](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) を参照してください。70億パラメータ以上のモデルでは、フルファインチューニングには24GB以上のGPUメモリが必要です。A100クラウドの利用を検討するか、LoRAを使用することをお勧めします。最近の研究では、LoRAが多くの後処理タスクにおいて、フルファインチューニングと同等の品質を達成できることが示されています（詳細は、[この機能ではないものに関するセクション](#what-backpropagate-is-not-for) を参照）。
 
 ## Backpropagateが適さないケース
 
-正直な情報を提供することで、ユーザーの皆様に最適な選択肢を提供します。Backpropagateは、これらの機能を提供していません。これらの機能を実装しようとしても、適切なツールを使用するよりも手間がかかる可能性があります。
+もし、以下の用途で使用する場合は、別のライブラリを使用することをお勧めします。Backpropagateは適切な選択肢ではなく、無理に使うと、適切なツールを使用するよりも手間と時間がかかります。このセクションを読んでから始めることで、インストールと設定の繰り返しを避けることができます。
 
-- **70億パラメータ以上のモデルのフルパラメータファインチューニング** — BackpropagateはLoRA/QLoRAを使用しており、すべての重みを更新するのではなく、小さなアダプターを学習します。70億パラメータ以上のモデルの場合、フルファインチューニングには24GB以上のGPUメモリが必要であり、16GBの一般的なグラフィックボードでは動作しません。30億パラメータ以下のモデルでは、16GBのメモリでフルファインチューニングが可能です。v1.4では、`mode="full"`オプションが予定されています。全体として、最近の研究（[Biderman 2024](https://arxiv.org/abs/2405.09673)、[Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)）によると、正しく設定されたLoRAは、ほとんどの追加学習タスク（指示に従う、ドメイン適応、ペルソナ/スタイル）において、フルファインチューニングと同等の品質を、計算量の67%で実現できます。したがって、ほとんどのユーザーが実際に必要とするタスクにおいては、LoRAを使用しても何も失うことはありません。もし、70億パラメータ以上のモデルのフルファインチューニングが必要な場合は、HuggingFaceの`transformers.Trainer`を直接、24GB以上のGPUでご使用ください。
-- **DPO/PPO/GRPO/好みの学習** — Backpropagateは、シングルステージの教師ありファインチューニングのみをサポートしています。好みの学習については、TRLまたはLLaMA-Factoryを直接ご使用ください。
-- **マルチノードトレーニング** — シングルGPUのみをサポートします。シングルマシンのマルチGPU構成は動作しますが（`accelerate launch`を使用）、公式にはサポートされていません。
-- **macOSでのトレーニング** — Apple SiliconにはCUDAがないため、トレーニングはNVIDIA GPUを搭載したLinuxまたはWindowsの環境で行う必要があります。学習済みのモデルは、Ollamaを通じてMacでも実行できます。
-- **テスト対象外のモデルファミリー** — Qwen 2.5 / 3.5 (7B / 4B)、Phi-4-mini-3.8B、SmolLM3-3B、Llama 3.2 (3B / 1B)、Mistral 7B。他のモデルも動作する場合がありますが、CI環境では検証されていません。
+- **70億パラメータ以上のモデルのフルパラメータファインチューニング** — BackpropagateはLoRA/QLoRAを使用しており、すべてのパラメータを更新するのではなく、小さなアダプターを学習します。70億パラメータ以上のモデルでは、フルファインチューニングには24GB以上のGPUメモリが必要であり、16GBの一般的なGPUでは動作しません。30億パラメータ以下のモデルでは、フルファインチューニングは16GBのメモリでも可能であり、v1.4では `mode="full"` として提供されています（`Trainer(..., mode="full")` を指定するか、`--mode=full` オプションをCLIで指定します。30億パラメータを超えるモデルに対しては、`RUNTIME_FULL_FT_MODEL_TOO_LARGE` エラーが発生し、LoRAや30億パラメータ以下のモデルのプリセットを使用できます）。補足として、最近の研究（[Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)）によると、適切な設定のLoRAは、ほとんどの後処理タスク（指示に従う、ドメイン適応、ペルソナ/スタイル）において、フルファインチューニングと同等の品質を67%の計算量で達成できます。したがって、ほとんどのユーザーが求めるタスクでは、LoRAを使用しても何も失うことはありません。`mode="full"` は、品質の差を測定し、追加の計算リソースを使用する必要がある場合に利用できます。70億パラメータ以上のモデルをフルファインチューニングする必要がある場合は、HuggingFaceの `transformers.Trainer` を直接、24GB以上のGPUで実行してください。
+- **DPO / PPO / GRPO / 嗜好学習** — Backpropagateは、シングルステージの教師ありファインチューニングのみをサポートしています。嗜好学習の場合は、TRLまたはLLaMA-Factoryを直接使用してください。
+- **マルチノードトレーニング** — シングルGPUのみをサポートしています。シングルマシン上でのマルチGPU構成は可能ですが（`accelerate launch` を使用）、公式にはサポートされていません。
+- **macOSでのトレーニング** — Apple SiliconにはCUDAがないため、トレーニングはLinuxまたはWindowsのNVIDIA GPU搭載マシンで行う必要があります。トレーニング済みのモデルは、Ollamaを使用してMac上で実行できます。
+- **サポートされていないモデルファミリー** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B。他のモデルでも動作する場合がありますが、CI環境でのテストは行われていません。
 
 上記のような機能が必要な場合は、上記に記載されているライブラリをご利用ください。それらは、それらの機能に特化しています。
 
@@ -331,12 +334,12 @@ Backpropagateがエラーを検出した場合、起動時に`run_started run_id
 
 良いバグレポートには、以下の情報が含まれている必要があります。
 
-1. **`run_id`**: 起動時に表示されるUUID。
-2. **エラーコード**: `stderr`に出力される`[コード名]: メッセージ`という形式のエラーメッセージ。エラーコードの一覧は、[エラーコード](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/)を参照してください。
-3. **編集されたコマンドライン**: `stderr`は自動的に編集されます（Bearerトークン、`sk-*`、`hf_*`、AWSキー、`password=`/`token=`の組み合わせは削除されます）。安心して貼り付けてください。完全な未編集のトレースバックを表示するには、`--verbose`オプションをつけて再度実行してください。ただし、投稿する前に内容を確認してください。
-4. **Python/PyTorchのバージョン、GPUモデル、OS**: `backprop info`コマンドを実行すると、これらすべての情報が一度に表示されます。
+1. **`run_id`**: 起動時に表示されるUUID。このUUIDを使用することで、管理者は特定の実行に関するすべてのログ行、チェックポイント、およびWeights & Biasesのエントリを関連付けることができます。
+2. **エラーコード**: `stderr`に出力される`[コード名]: メッセージ`という形式の文字列。安定したコードの一覧は、[エラーコード](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/)を参照してください。
+3. **追跡情報のマスキング**: `stderr`は、詳細表示モードでない場合、自動的にマスキングされます（Bearerトークン、`sk-*`、`hf_*`、AWSキー、`password=` / `token=` / `api_key=`のペアなどが削除されます）。貼り付けても安全です。完全な追跡情報を確認するには、`BACKPROPAGATE_DEBUG=1`（または`--verbose`）を指定して再度実行し、投稿前に内容を確認してください。
+4. **`backprop info`の出力**: このコマンドは、Python、PyTorch、CUDA、GPUモデル、VRAM、OS、インストールされている追加機能など、管理者がプラットフォーム固有の問題を特定するために必要なすべての情報を表示します。
 
-質問、アイデア、または「これは想定通りですか？」といった内容については、[GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions) のページにお寄せください。セキュリティに関する問題は、[GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) のフォームを通じて、非公開でご報告ください。詳細は、[SECURITY.md](SECURITY.md) をご確認ください。
+[バグレポートテンプレート](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml)では、これらの情報をすべて明示的に入力するように促しており、そのため問題の切り分けが迅速に進みます。質問、アイデア、または「これは想定される動作ですか？」といった議論は、[GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions)で行ってください。セキュリティに関する問題は、[GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new)のフォームを通じて、非公開で報告してください。ポリシーと対応のタイムラインについては、[SECURITY.md](SECURITY.md)を参照してください。
 
 ## プライバシー
 

package/README.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,17 +76,20 @@ Here's the practical envelope on a 16GB card (RTX 4080 / 5080 / 4070 Ti Super):
 | Model | Method | Status |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Comfortable. Full sequence length, room to spare. |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (≤3B parameter ceiling) | `mode="full"` (full fine-tuning) | v1.4 — pass `--mode=full` on `backprop train` or `Trainer(..., mode="full")`. Gradient checkpointing + paged 8-bit Adam keep the activation memory at sqrt(L). |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Standard. ~7-8 GB. Backpropagate's default presets. |
 | Llama-3 13B | QLoRA + sample packing | Tight but works. Use shorter sequences. |
-| Mixtral 8x7B (47B total parameters) | AQLM 2-bit + LoRA | Experimental in v1.4. The largest model you can touch on a 16GB card. |
+| Mixtral 8x7B (47B total parameters) | AQLM 2-bit + LoRA | Planned for v1.5 — see V1_5_BRIEF when posted. |
+
+AQLM 2-bit quantization (`quant_method="aqlm"` experimental opt-in for Mixtral-8x7B on 16GB) was scoped for v1.4 and is now planned for v1.5. The `aqlm` library is mature; the v1.4 wave-budget prioritized full fine-tuning support for ≤3B models (`mode="full"`) over adding a new quantization backend. See V1_5_BRIEF when posted for the v1.5 implementation plan.
 
-For models 3B and smaller, full fine-tuning (not just LoRA) is feasible on 16GB and is planned as a `mode="full"` option for v1.4. For 7B+ models, full fine-tuning needs a 24GB+ GPU — consider an A100 cloud rental, or stick with LoRA, which recent research shows matches full fine-tuning quality on most post-training tasks anyway (see [the anti-pitch section](#what-backpropagate-is-not-for) for citations).
+For models 3B and smaller, full fine-tuning (not just LoRA) is feasible on 16GB and now ships in v1.4 as `mode="full"`. Pass `Trainer(..., mode="full")` or `backprop train --mode=full --model phi-4-mini-3.8b` to enable it. A hard gate refuses the mode for models > 3B with `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, naming LoRA + the three sub-3B presets as the recovery options. See [the full fine-tuning handbook page](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) for the configuration math + Biderman 2024 / Thinking Machines 2025 quality comparison. For 7B+ models, full fine-tuning needs a 24GB+ GPU — consider an A100 cloud rental, or stick with LoRA, which recent research shows matches full fine-tuning quality on most post-training tasks anyway (see [the anti-pitch section](#what-backpropagate-is-not-for) for citations).
 
 ## What Backpropagate is NOT for
 
-Honest scope helps everyone. Backpropagate doesn't do these things, and trying to make it do them would be a worse experience than reaching for the right tool:
+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; a `mode="full"` option is planned for v1.4. 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. If you genuinely need full fine-tuning of a 7B+ model, use HuggingFace `transformers.Trainer` directly on a 24GB+ card.
+- **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 > 3B and names LoRA + the sub-3B 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.
 - **DPO / PPO / GRPO / preference tuning** — Backpropagate does single-stage supervised fine-tuning only. For preference learning, use TRL directly or LLaMA-Factory.
 - **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** — Apple Silicon doesn't have CUDA, so training 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.
@@ -331,12 +334,12 @@ When something fails, Backpropagate prints a line at startup like `run_started r
 
 A good bug report includes:
 
-1. **The `run_id`** — the UUID printed at startup.
-2. **The error code** — the `[CODE_NAME]: message` line in stderr. See [error codes](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) for the catalog.
-3. **The redacted command line.** Stderr is automatically redacted (Bearer tokens, `sk-*`, `hf_*`, AWS keys, `password=` / `token=` pairs are scrubbed) — safe to paste. For the full unredacted traceback, re-run with `--verbose`, but review before posting.
-4. **Python / PyTorch versions, GPU model, OS.** `backprop info` prints all of this in one go.
+1. **The `run_id`** — the UUID printed at startup. One UUID lets a maintainer correlate every log line, every checkpoint, and every Weights & Biases entry for that exact run.
+2. **The error code** — the `[CODE_NAME]: message` line in stderr. See [error codes](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) for the catalog of stable codes.
+3. **The redacted traceback.** Stderr is automatically redacted in non-verbose mode (Bearer tokens, `sk-*`, `hf_*`, AWS keys, `password=` / `token=` / `api_key=` pairs are scrubbed) — safe to paste. For the full unredacted traceback, re-run with `BACKPROPAGATE_DEBUG=1` (or `--verbose`); review before posting.
+4. **The `backprop info` output.** One command prints Python / PyTorch / CUDA / GPU model / VRAM / OS / installed extras — everything the maintainer needs to bisect a platform-specific regression.
 
-Questions, ideas, or "is this expected" threads belong in [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Security issues should be reported privately via the [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) form — see [SECURITY.md](SECURITY.md) for the policy.
+The [bug report template](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) prompts for each of these explicitly so triage moves fast. Questions, ideas, or "is this expected?" threads belong in [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Security issues should be reported privately via the [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) form — see [SECURITY.md](SECURITY.md) for the policy and response timelines.
 
 ## Privacy
 

package/README.pt-BR.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ Aqui está a faixa prática em uma placa de 16 GB (RTX 4080 / 5080 / 4070 Ti Sup
 | Modelo | Método | Status |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Confortável. Comprimento total da sequência, espaço extra. |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (limite máximo de 3 bilhões de parâmetros) | `mode="full"` (ajuste fino completo) | v1.4 — Utilize a opção `--mode=full` no comando `backprop train` ou `Trainer(..., mode="full")`. O checkpointing do gradiente e o Adam de 8 bits com paginação mantêm a memória de ativação em sqrt(L). |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Padrão. ~7-8 GB. Configurações padrão do Backpropagate. |
 | Llama-3 13B | QLoRA + empacotamento de amostras | Apertado, mas funciona. Use sequências mais curtas. |
-| Mixtral 8x7B (47 bilhões de parâmetros no total) | AQLM 2-bit + LoRA | Experimental na v1.4. O maior modelo que você pode usar em uma placa de 16 GB. |
+| Mixtral 8x7B (47 bilhões de parâmetros no total) | AQLM 2-bit + LoRA | Planejado para v1.5 — Consulte o documento V1_5_BRIEF quando for publicado. |
+
+A quantização AQLM de 2 bits (`quant_method="aqlm"`, opção experimental para Mixtral-8x7B em 16GB) foi planejada para v1.4 e agora está prevista para v1.5. A biblioteca `aqlm` está madura; a prioridade para a versão 1.4 foi oferecer suporte completo para ajuste fino de modelos com até 3 bilhões de parâmetros (`mode="full"`), em vez de adicionar um novo backend de quantização. Consulte o documento V1_5_BRIEF quando for publicado para o plano de implementação da versão 1.5.
 
-Para modelos de 3 bilhões de parâmetros ou menores, o ajuste fino completo (não apenas LoRA) é viável em 16 GB e está planejado como uma opção `mode="full"` para a v1.4. Para modelos de 7 bilhões de parâmetros ou mais, o ajuste fino completo requer uma GPU de 24 GB ou mais — considere alugar uma GPU A100 na nuvem, ou use LoRA, que pesquisas recentes mostram que corresponde à qualidade do ajuste fino completo na maioria das tarefas de pós-treinamento (veja a seção "o que Backpropagate não é" para citações).
+Para modelos com 3 bilhões de parâmetros ou menores, o ajuste fino completo (e não apenas LoRA) é viável em 16GB e está disponível na versão 1.4 como `mode="full"`. Utilize `Trainer(..., mode="full")` ou `backprop train --mode=full --model phi-4-mini-3.8b` para habilitá-lo. Um mecanismo impede o uso desse modo para modelos maiores que 3 bilhões de parâmetros, oferecendo LoRA e as configurações predefinidas para modelos menores que 3 bilhões como alternativas. Consulte a página completa do manual de ajuste fino ([https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/)) para a configuração e a comparação de qualidade entre Biderman 2024 e Thinking Machines 2025. Para modelos com 7 bilhões de parâmetros ou mais, o ajuste fino completo requer uma GPU com 24GB ou mais — considere alugar uma GPU A100 na nuvem ou utilize LoRA, que, segundo pesquisas recentes, oferece qualidade comparável ao ajuste fino completo na maioria das tarefas de pós-treinamento (consulte a seção "o que Backpropagate não é" para referências).
 
 ## O que Backpropagate NÃO é
 
-Uma descrição honesta ajuda a todos. Backpropagate não faz essas coisas, e tentar fazer com que faça seria uma experiência pior do que usar a ferramenta certa:
+Se o seu caso de uso se enquadra nas opções abaixo, você terá melhores resultados com outra biblioteca — Backpropagate não é a escolha certa, e tentar fazê-lo funcionar custará mais do que simplesmente usar a ferramenta adequada. Ler esta seção antes de começar economiza o tempo gasto na instalação e na tentativa de fazer funcionar:
 
-- **Ajuste fino completo de parâmetros para modelos com mais de 7 bilhões de parâmetros** — O Backpropagate usa LoRA/QLoRA, que treina um adaptador pequeno em vez de atualizar todos os pesos. Para modelos com 7 bilhões de parâmetros ou mais, o ajuste fino completo requer 24 GB ou mais de memória da GPU e não cabe em uma placa de consumo de 16 GB. Para modelos com 3 bilhões de parâmetros ou menos, o ajuste fino completo é viável em 16 GB; uma opção `mode="full"` está planejada para a versão 1.4. Em resumo: pesquisas recentes ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) mostram que o LoRA, com a configuração correta, atinge a mesma qualidade do ajuste fino completo na maioria das tarefas de pós-treinamento (seguir instruções, adaptação de domínio, personalidade/estilo), utilizando 67% menos recursos computacionais. Portanto, para a maioria das tarefas que os usuários desejam realizar, você não perde nada ao usar o LoRA. Se você realmente precisa do ajuste fino completo de um modelo com mais de 7 bilhões de parâmetros, use o `transformers.Trainer` da HuggingFace diretamente em uma placa com 24 GB ou mais.
-- **DPO / PPO / GRPO / ajuste de preferências** — O Backpropagate realiza apenas o ajuste fino supervisionado em uma única etapa. Para o aprendizado por preferências, use o TRL diretamente ou o LLaMA-Factory.
-- **Treinamento em vários nós** — Apenas uma GPU em uma única máquina. O uso de várias GPUs em uma única máquina funciona (via `accelerate launch`), mas não é oficialmente suportado.
-- **Treinamento no macOS** — O Apple Silicon não possui CUDA, portanto, o treinamento deve ser executado em uma máquina Linux ou Windows com uma GPU NVIDIA. Você ainda pode executar o modelo treinado em um Mac usando o Ollama.
-- **Qualquer modelo fora das famílias de modelos testados** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Outros modelos geralmente funcionam, mas não são testados nos testes de integração contínua (CI).
+- **Ajuste fino de todos os parâmetros de modelos com 7 bilhões de parâmetros ou mais** — Backpropagate utiliza LoRA / QLoRA, que treina um adaptador pequeno em vez de atualizar todos os pesos. Para modelos com 7 bilhões de parâmetros ou mais, o ajuste fino completo requer 24GB ou mais de memória da GPU e não cabe em uma placa de consumidor com 16GB. Para modelos com 3 bilhões de parâmetros ou menos, o ajuste fino completo é viável em 16GB e está disponível na versão 1.4 como `mode="full"` (utilize `Trainer(..., mode="full")` ou `--mode=full` na linha de comando; um mecanismo impede o uso desse modo para modelos maiores que 3 bilhões de parâmetros, oferecendo LoRA e as configurações predefinidas para modelos menores que 3 bilhões como alternativas). Em resumo: pesquisas recentes ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) mostram que o LoRA, com a configuração correta, oferece qualidade comparável ao ajuste fino completo na maioria das tarefas de pós-treinamento (seguir instruções, adaptação de domínio, personalidade/estilo) com 67% do poder computacional — portanto, para o trabalho que a maioria dos usuários realmente deseja realizar, você não perde nada ao usar LoRA. `mode="full"` existe para os casos em que você mediu uma diferença de qualidade e decidiu gastar mais poder computacional. Se você realmente precisa de um ajuste fino completo de um modelo com 7 bilhões de parâmetros ou mais, utilize diretamente o `transformers.Trainer` da HuggingFace em uma placa com 24GB ou mais.
+- **DPO / PPO / GRPO / ajuste de preferências** — Backpropagate realiza apenas o ajuste fino supervisionado em uma única etapa. Para o aprendizado por preferências, utilize diretamente o TRL ou o LLaMA-Factory.
+- **Treinamento em vários nós** — apenas uma GPU em uma única máquina. O uso de várias GPUs em uma única máquina funciona (via `accelerate launch`), mas não é oficialmente suportado.
+- **Treinamento no macOS** — o Apple Silicon não possui CUDA, portanto, o treinamento deve ser executado em uma máquina Linux ou Windows com uma GPU NVIDIA. Você ainda pode executar o modelo treinado em um Mac via Ollama.
+- **Qualquer modelo fora das famílias de modelos testados** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B. Outros modelos podem funcionar, mas não são testados nos testes automatizados.
 
 Se você precisar de alguma dessas funcionalidades, utilize uma das bibliotecas listadas acima. Elas são mais adequadas para isso.
 
@@ -331,12 +334,12 @@ Quando algo falha, o Backpropagate imprime uma linha no início, como `run_start
 
 Um bom relatório de bug inclui:
 
-1. **O `run_id`** — o UUID impresso no início.
-2. **O código de erro** — a linha `[CODE_NAME]: message` no stderr. Consulte [códigos de erro](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) para a lista completa.
-3. **O comando de linha de comando, com informações sensíveis removidas.** O stderr é automaticamente anonimizado (tokens Bearer, `sk-*`, `hf_*`, chaves AWS, pares `password=` / `token=` são removidos) — é seguro colar. Para obter o rastreamento completo e não anonimizado, execute novamente com `--verbose`, mas revise antes de publicar.
-4. **Versões do Python / PyTorch, modelo da GPU, sistema operacional.** `backprop info` imprime tudo isso de uma vez.
+1. **O `run_id`** — o UUID (identificador único universal) exibido na inicialização. Um único UUID permite que um administrador correlacione cada linha de log, cada ponto de verificação e cada entrada do Weights & Biases para aquela execução específica.
+2. **O código de erro** — a linha `[NOME_DO_CÓDIGO]: mensagem` no stderr. Consulte [códigos de erro](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) para o catálogo de códigos estáveis.
+3. **O rastreamento de erro (traceback) com informações removidas.** O stderr é automaticamente editado (com informações sensíveis removidas) no modo não detalhado (tokens Bearer, `sk-*`, `hf_*`, chaves da AWS, pares `password=` / `token=` / `api_key=` são removidos) — é seguro colar. Para o rastreamento de erro completo e sem informações removidas, execute novamente com `BACKPROPAGATE_DEBUG=1` (ou `--verbose`); revise antes de publicar.
+4. **A saída de `backprop info`.** Um único comando imprime informações sobre Python / PyTorch / CUDA / modelo da GPU / VRAM / sistema operacional / complementos instalados — tudo o que o administrador precisa para identificar a causa de uma regressão específica da plataforma.
 
-Perguntas, ideias ou discussões sobre se algo é esperado devem ser feitas em [Discussões do GitHub](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Problemas de segurança devem ser relatados de forma privada através do formulário [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) — consulte [SECURITY.md](SECURITY.md) para a política.
+O [modelo de relatório de erro](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) solicita explicitamente cada um desses itens, o que agiliza o processo de triagem. Perguntas, ideias ou discussões sobre "é isso esperado?" devem ser feitas nos [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions). Problemas de segurança devem ser relatados de forma privada através do formulário [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) — consulte o arquivo [SECURITY.md](SECURITY.md) para obter a política e os prazos de resposta.
 
 ## Privacidade
 

package/README.zh.md

@@ -28,7 +28,7 @@ trainer.export("gguf", quantization="q4_k_m")
 ```
 
 ```bash
-backprop ollama register ./output/lora --name my-model
+backprop export ./output/lora --format gguf --quantization q4_k_m --ollama --ollama-name my-model
 ollama run my-model
 ```
 
@@ -76,21 +76,24 @@ Backpropagate 是一个缺失的选项：**一个用于单个消费级 GPU 的
 | 模型 | 方法 | 状态 |
 |---|---|---|
 | Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | 良好。完整的序列长度，还有剩余空间。 |
+| Phi-4-mini-3.8B / Qwen-3.5-4B / SmolLM3-3B (参数上限≤3B) | `mode="full"` (全量微调) | v1.4 — 在 `backprop train` 命令中使用 `--mode=full` 参数，或者在 `Trainer` 类中设置 `mode="full"`。梯度检查点 + Paged 8-bit Adam 算法可以使激活内存保持在 sqrt(L) 的水平。 |
 | Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | 标准。约 7-8 GB。Backpropagate 的默认设置。 |
 | Llama-3 13B | QLoRA + 采样压缩 | 勉强可用。使用较短的序列。 |
-| Mixtral 8x7B (总参数 47B) | AQLM 2-bit + LoRA | v1.4 中的实验性功能。您可以在 16GB 显卡上运行的最大模型。 |
+| Mixtral 8x7B (总参数 47B) | AQLM 2-bit + LoRA | 计划在 v1.5 版本中实现 — 详情请参考 V1_5_BRIEF（发布后查看）。 |
+
+AQLM 2-bit 量化 (`quant_method="aqlm"`) 是一种实验性功能，适用于 16GB 内存上的 Mixtral-8x7B 模型。该功能最初计划在 v1.4 版本中实现，但现在计划在 v1.5 版本中实现。`aqlm` 库已经比较成熟；在 v1.4 版本的开发中，我们优先支持 ≤3B 模型的全量微调 (`mode="full"`)，而不是添加新的量化后端。请在 V1_5_BRIEF 发布后查看 v1.5 的具体实现计划。
 
-对于 3B 及更小的模型，可以在 16GB 的显卡上进行完整的微调（而不仅仅是 LoRA），并且计划在 v1.4 中提供一个 `mode="full"` 选项。对于 7B+ 的模型，需要 24GB+ 的 GPU 才能进行完整的微调。您可以考虑租用 A100 云服务器，或者坚持使用 LoRA，因为最近的研究表明，在大多数微调后的任务中，LoRA 的质量可以与完整的微调相媲美（请参阅 [“不适合使用的场景”](#what-backpropagate-is-not-for) 部分以获取引用）。
+对于 3B 及以下的模型，全量微调（而不仅仅是 LoRA）可以在 16GB 内存上实现，并且现在已在 v1.4 版本中以 `mode="full"` 的形式提供。使用 `Trainer(..., mode="full")` 或 `backprop train --mode=full --model phi-4-mini-3.8b` 命令启用此功能。对于大于 3B 的模型，系统会强制阻止使用此模式，并会显示 `RUNTIME_FULL_FT_MODEL_TOO_LARGE` 错误，同时建议使用 LoRA 以及其他适用于小于 3B 的预设模型作为替代方案。请参考 [完整的微调指南页面](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/)，了解配置细节以及 Biderman 2024 / Thinking Machines 2025 的质量比较。对于 7B 及以上的模型，全量微调需要 24GB 或更大的 GPU 内存 — 考虑租用 A100 云服务器，或者继续使用 LoRA，因为最近的研究表明，在大多数后续训练任务中，LoRA 的质量可以与全量微调相媲美（请参阅 [“不适用场景”部分](#what-backpropagate-is-not-for) 中的引用）。
 
 ## Backpropagate 不适合的场景
 
-坦诚的说明有助于每个人。Backpropagate 不适用于以下场景，并且尝试使其执行这些操作会比使用正确的工具更糟糕：
+如果您的使用场景符合以下情况，您可能更适合使用其他库 — Backpropagate 并非最佳选择，尝试使其工作可能会花费更多，不如直接选择合适的工具。在开始之前阅读此部分可以避免安装和卸载的循环：
 
-- **70亿参数以上模型的全面微调** — Backpropagate 使用 LoRA/QLoRA，它训练一个小的适配器，而不是更新每个权重。对于 70 亿参数及以上的模型，全面微调需要 24GB+ 的 GPU 内存，无法在 16GB 的消费级显卡上运行。对于 30 亿参数及以下的模型，全面微调可以在 16GB 的显卡上运行；v1.4 计划提供 `mode="full"` 选项。更重要的是，最近的研究（[Biderman 2024](https://arxiv.org/abs/2405.09673)，[Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)）表明，在正确的配置下，LoRA 在大多数微调任务（指令遵循、领域适应、角色/风格）中，其质量可以与全面微调相媲美，但计算量仅为 67%。因此，对于大多数用户实际需要的任务，使用 LoRA 不会带来任何损失。如果您确实需要对 70 亿参数以上的模型进行全面微调，请直接使用 HuggingFace 的 `transformers.Trainer`，并在 24GB+ 的显卡上运行。
-- **DPO/PPO/GRPO/偏好学习** — Backpropagate 仅支持单阶段的监督微调。对于偏好学习，请直接使用 TRL 或 LLaMA-Factory。
-- **多节点训练** — 仅支持单个机器上的单个 GPU。单个机器上的多 GPU 可以运行（通过 `accelerate launch`），但未正式支持。
-- **macOS 训练** — Apple Silicon 没有 CUDA，因此训练需要在运行 Linux 或 Windows 的机器上，该机器需要配备 NVIDIA GPU。您仍然可以在 Mac 上通过 Ollama 运行训练好的模型。
-- **任何不在测试模型系列中的模型** — Qwen 2.5 / 3.5 (70亿 / 40亿参数)，Phi-4-mini-3.8B，SmolLM3-3B，Llama 3.2 (30亿 / 10亿参数)，Mistral 7B。其他模型通常可以运行，但未在 CI 中进行测试。
+- **7B+ 模型的全参数微调** — Backpropagate 使用 LoRA / QLoRA，它训练一个小的适配器，而不是更新每个权重。对于 7B 及更大的模型，全量微调需要 24GB 或更多的 GPU 内存，无法在 16GB 的消费级显卡上运行。对于 3B 及以下的模型，全量微调可以在 16GB 内存上运行，并且已在 v1.4 版本中以 `mode="full"` 的形式提供（使用 `Trainer(..., mode="full")` 或 `--mode=full` 命令；对于大于 3B 的模型，系统会强制阻止此模式，并会显示 `RUNTIME_FULL_FT_MODEL_TOO_LARGE` 错误，同时建议使用 LoRA 以及其他适用于小于 3B 的预设模型作为替代方案）。总的来说：最近的研究 ([Biderman 2024](https://arxiv.org/abs/2405.09673), [Thinking Machines 2025](https://thinkingmachines.ai/blog/lora/)) 表明，在正确的配置下，LoRA 可以在大多数后续训练任务（指令遵循、领域适应、角色/风格）中达到与全量微调相当的质量，并且只需要 67% 的计算资源 — 因此，对于大多数用户来说，坚持使用 LoRA 并不会带来任何损失。`mode="full"` 适用于那些已经测量到质量差距，并且愿意为此付出额外计算成本的情况。如果确实需要对 7B+ 的模型进行全量微调，请直接使用 HuggingFace `transformers.Trainer`，并在 24GB 或更大的显卡上运行。
+- **DPO / PPO / GRPO / 偏好学习** — Backpropagate 仅支持单阶段的监督微调。对于偏好学习，请直接使用 TRL 或 LLaMA-Factory。
+- **多节点训练** — 仅支持单个 GPU，且只能在一台机器上运行。支持在一台机器上使用多个 GPU（通过 `accelerate launch`），但未正式支持。
+- **macOS 训练** — Apple Silicon 芯片不支持 CUDA，因此训练需要在运行 Linux 或 Windows 的机器上，并使用 NVIDIA GPU。您仍然可以在 Mac 上通过 Ollama 运行训练好的模型。
+- **任何不在测试模型系列中的模型** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B。其他模型通常可以工作，但未在 CI 测试中进行验证。
 
 如果您需要这些功能，请使用上面列出的库。它们在这方面做得更好。
 
@@ -331,12 +334,12 @@ backprop export-runs --format jsonl    # bulk export run history
 
 一个好的错误报告应包含：
 
-1. **`run_id`** — 启动时打印的 UUID。
-2. **错误代码** — `stderr` 中的 `[CODE_NAME]: message` 行。请参阅 [错误代码](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) 目录。
-3. **已屏蔽的命令行。** `stderr` 会自动进行屏蔽（Bearer 令牌、`sk-*`、`hf_*`、AWS 密钥、`password=` / `token=` 对等信息会被删除）——可以安全地粘贴。要查看完整的未屏蔽的堆栈跟踪，请使用 `--verbose` 重新运行，但在发布之前请仔细检查。
-4. **Python / PyTorch 版本、GPU 型号、操作系统。** `backprop info` 可以一次性打印所有这些信息。
+1. **`run_id`**：启动时打印的 UUID。一个 UUID 允许维护人员将每一行日志、每一个检查点以及 Weights & Biases 中的每一条记录与该特定运行关联起来。
+2. **错误代码**：`stderr` 中出现的 `[代码名称]: 消息` 格式的行。请参考[错误代码目录](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/)，了解稳定代码的详细信息。
+3. **已屏蔽的堆栈跟踪信息。** 在非详细模式下，`stderr` 会自动进行屏蔽（Bearer 令牌、`sk-*`、`hf_*`、AWS 密钥以及 `password=` / `token=` / `api_key=` 组合会被删除），因此可以安全地复制粘贴。要查看完整的、未屏蔽的堆栈跟踪信息，请重新运行程序，并设置 `BACKPROPAGATE_DEBUG=1`（或使用 `--verbose` 参数）；在发布之前，请仔细审查。
+4. **`backprop info` 的输出结果。** 该命令会打印 Python / PyTorch / CUDA / GPU 模型 / VRAM / 操作系统 / 已安装的扩展模块等信息——维护人员需要的所有信息，以便分析特定平台的回归问题。
 
-问题、想法或“这是预期的吗”的讨论应在 [GitHub Discussions](https://github.com/mcp-tool-shop-org/backpropagate/discussions) 中提出。安全问题应通过 [GitHub Security Advisory](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new) 表单私下报告 — 请参阅 [SECURITY.md](SECURITY.md) 了解相关政策。
+[错误报告模板](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) 会明确提示您提供以上所有信息，因此问题可以快速得到处理。任何问题、想法或“这是预期的吗？”的讨论，都应该在[GitHub 讨论区](https://github.com/mcp-tool-shop-org/backpropagate/discussions)中进行。安全问题应通过[GitHub 安全建议](https://github.com/mcp-tool-shop-org/backpropagate/security/advisories/new)表单私下报告，请参阅[SECURITY.md](SECURITY.md) 了解相关政策和响应时间。
 
 ## 隐私
 

package/bin/backpropagate.js

@@ -23,15 +23,33 @@
 // supported channels. The migration is complete in v1.3.
 // ---------------------------------------------------------------------------
 
+// BRIDGE-B (Stage C humanization): the shim's WHOLE job is the friendly-error
+// path. Three rules the message has to satisfy:
+//   1. Name the next step (every error names the next step).
+//   2. Make the install commands copy-paste-runnable on the operator's host
+//      (no shell quoting that fails on cmd.exe, no `sudo` prefix that
+//      misleads on Windows).
+//   3. Stay calibrated — the v1.2 PyInstaller-bin build failed 3 times so
+//      v1.3 redirected operators to PyPI / pipx / uv; the message names the
+//      channels in preference order (isolated > shared > root-installable).
 process.stderr.write(
-  "npm distribution of backpropagate is deprecated.\n" +
+  "npm distribution of backpropagate is deprecated as of v1.3.\n" +
   "\n" +
-  "Install via one of the supported channels:\n" +
-  "  pipx install backpropagate   (recommended — isolated venv)\n" +
-  "  uv tool install backpropagate\n" +
-  "  pip install backpropagate\n" +
+  "Next step — install from PyPI via one of these channels (pick one):\n" +
+  "  pipx install backpropagate         # recommended on macOS/Linux (isolated venv, on PATH)\n" +
+  "  uv tool install backpropagate      # recommended on Windows (uv handles venv + PATH)\n" +
+  "  pip install backpropagate          # plain pip (use inside a venv)\n" +
   "\n" +
-  "Optional extras (UI / GGUF export / monitoring) are documented at:\n" +
-  "  https://github.com/mcp-tool-shop-org/backpropagate#installation\n"
+  "Verify the install:  backprop --version\n" +
+  "\n" +
+  "Optional extras (Reflex UI, GGUF export, monitoring) — pick one bundle:\n" +
+  "  pipx install 'backpropagate[standard]'    # unsloth + ui (recommended)\n" +
+  "  pipx install 'backpropagate[full]'        # everything\n" +
+  "  pipx install 'backpropagate[ui]'          # just the Reflex web UI\n" +
+  "\n" +
+  "Getting started + extras documentation:\n" +
+  "  https://mcp-tool-shop-org.github.io/backpropagate/handbook/getting-started/\n" +
+  "Source + issues:\n" +
+  "  https://github.com/mcp-tool-shop-org/backpropagate\n"
 );
 process.exit(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcptoolshop/backpropagate",
-  "version": "1.3.0",
+  "version": "1.4.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",