@mcptoolshop/backpropagate 1.3.0 → 1.5.0

package/README.es.md

@@ -15,9 +15,9 @@
   <a href="https://mcp-tool-shop-org.github.io/backpropagate/"><img src="https://img.shields.io/badge/Landing_Page-live-blue" alt="Landing Page"></a>
 </p>
 
-# Entrena un adaptador. Envíalo a Ollama. ¡Listo!
+# Entrena un adaptador. Envíalo a Ollama. Continúa
 
-Backpropagate es una biblioteca de Python para el ajuste fino de modelos de lenguaje grandes en una sola GPU. Tres líneas de código entrenan un modelo de 7B en una tarjeta de 16GB. Un comando más lo exporta a Ollama para que puedas ejecutar tu ajuste fino con `ollama run`. Funciona perfectamente en Windows.
+Backpropagate es una biblioteca de Python para el ajuste fino de modelos de lenguaje grandes en una sola GPU. Tres líneas de código entrenan un modelo de 7B en una tarjeta de 16 GB. Un comando más lo exporta a Ollama para que puedas ejecutar tu modelo ajustado con `ollama run`. Funciona de manera óptima en Windows.
 
 ```python
 from backpropagate import Trainer
@@ -28,13 +28,13 @@ 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
 ```
 
-Eso es todo. No hay un archivo de configuración YAML. No hay una "ceremonia" de `accelerate launch`. No hay un tutorial separado para "convertirlo a GGUF". Si tienes una GPU con CUDA y un archivo JSONL con tus datos de entrenamiento, estás a solo tres líneas de tener un ajuste fino funcional.
+Eso es todo. No hay un archivo de configuración YAML. No hay una "ceremonia" de `accelerate launch`. No hay un tutorial separado de "ahora conviértelo a GGUF". Si tienes una GPU CUDA y un archivo JSONL con tus datos de entrenamiento, estás a solo tres líneas de distancia de un modelo ajustado funcional.
 
-## Instalación
+## Instala
 
 ```bash
 # Recommended: isolated Python install (no conflicts with system Python or other projects)
@@ -47,78 +47,83 @@ uv tool install backpropagate
 pip install backpropagate
 ```
 
-Si quieres las funciones opcionales, reemplaza la instalación con una de estas:
+Si deseas las funciones opcionales, reemplaza la instalación por una de estas:
 
 ```bash
 pipx install "backpropagate[standard]"   # adds Unsloth (2x faster training) + the web UI
 pipx install "backpropagate[full]"       # adds everything: unsloth, ui, monitoring, export, etc.
 ```
 
-¿Prefieres Docker? `docker pull ghcr.io/mcp-tool-shop-org/backpropagate:latest` también funciona. Las imágenes están disponibles para `linux/amd64` y `linux/arm64`, por lo que los usuarios de Apple Silicon y ARM Linux obtienen una imagen nativa. Un archivo `compose.yaml` canónico para "UI en un contenedor" se encuentra en la raíz del repositorio; `docker compose up` inicia la interfaz web en `http://localhost:7860` con un volumen persistente `~/.backpropagate` montado.
+¿Prefieres Docker? `docker pull ghcr.io/mcp-tool-shop-org/backpropagate:latest` también funciona. Se proporcionan imágenes para `linux/amd64` y `linux/arm64`, por lo que los usuarios de Apple Silicon y ARM Linux obtienen una imagen nativa. Un archivo `compose.yaml` canónico para "UI en un contenedor" se encuentra en la raíz del repositorio; `docker compose up` activa la interfaz de usuario web en `http://localhost:7860` con un volumen persistente `~/.backpropagate`.
 
-## Dónde encaja Backpropagate
+## Dónde se ubica Backpropagate
 
-Existen varias bibliotecas excelentes para el ajuste fino de LLM. Cada una es excelente para diferentes cosas:
+Existen varias bibliotecas buenas para el ajuste fino de LLM. Cada una es excelente para diferentes cosas:
 
-- **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)**: si te gustan las configuraciones YAML y quieres una comunidad de recetas para copiar.
-- **[LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)**: si quieres una GUI web y soporte integrado para DPO/PPO/RLHF.
-- **[Unsloth](https://github.com/unslothai/unsloth)**: si necesitas el entrenamiento más rápido posible y estás utilizando una familia de modelos compatible.
-- **[torchtune](https://github.com/pytorch/torchtune)**: si quieres las recetas nativas de PyTorch de Meta que puedes editar.
+- **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)**: si te gustan las configuraciones YAML y deseas una comunidad de recetas de las que puedas copiar.
+- **[LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)**: si deseas DPO/PPO/RLHF y una GUI web.
+- **[Unsloth](https://github.com/unslothai/unsloth)**: si necesitas el entrenamiento más rápido posible y utilizas una familia de modelos compatible.
+- **[torchtune](https://github.com/pytorch/torchtune)**: si deseas las recetas nativas de PyTorch de Meta que puedes editar.
 
-Backpropagate es la opción que falta: **una API de Python de 3 líneas para usuarios individuales en una sola GPU de consumo que desean entrenar un adaptador y enviarlo.** Sin YAML, sin GUI, sin DPO/PPO, sin nodos múltiples. Solo el bucle que realmente necesita todo el mundo y el paso de exportación que dificulta las cosas.
+Backpropagate es la opción que faltaba: **una API de Python de 3 líneas para usuarios individuales en una sola GPU de consumo que desean entrenar un adaptador y enviarlo.** Sin YAML, sin GUI, sin RL en línea (PPO/GRPO), sin multi-nodo. Solo el ciclo que realmente necesita todo el mundo y el paso de exportación que dificulta las cosas.
 
-Si has probado alguna de las bibliotecas anteriores y te has sentido frustrado por la "ceremonia" del archivo de configuración, o has encontrado una limitación en la familia de modelos, o querías configuraciones predeterminadas para Windows: Backpropagate es para ti.
+Si probaste una de las bibliotecas anteriores y te frustraste con la "ceremonia" del archivo de configuración, o te encontraste con una limitación de la familia de modelos, o querías opciones predeterminadas para Windows, Backpropagate es para ti.
 
-## Lo que puedes ajustar en una GPU de consumo de 16GB
+## Lo que puedes ajustar en una GPU de consumo de 16 GB
 
-Aquí tienes un rango práctico en una tarjeta de 16GB (RTX 4080 / 5080 / 4070 Ti Super):
+Aquí tienes el rango práctico en una tarjeta de 16 GB (RTX 4080 / 5080 / 4070 Ti Super):
 
 | 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. |
-| 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. |
+| Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Cómodo. Longitud de secuencia completa, espacio disponible. |
+| SmolLM3-3B / Qwen2.5-3B / Llama-3.2-3B / Llama-3.2-1B | `mode="full"` (ajuste fino completo) | v1.4: pasa `--mode=full` en `backprop train` o `Trainer(..., mode="full")`. Carga pesos de precisión completa (bf16); no hay 4 bits, no hay adaptador; el checkpointing de gradiente + Adam de 8 bits paginado mantienen la huella dentro de los 16 GB. |
+| Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Estándar. ~7-8 GB. Los ajustes predeterminados de Backpropagate. |
+| Llama-3 13B | QLoRA + empaquetamiento de muestras | Apretado, pero funciona. Utiliza secuencias más cortas. |
+| Mixtral 8x7B (47B de parámetros totales) | — | Fuera del alcance: 2 bits (AQLM / QuIP#) rompe el contrato de adaptador fusionable + exportación a GGUF, por lo que se eliminó en el [resumen de la trayectoria v1.5](docs/V1_5_BRIEF.md). En una tarjeta de 16 GB, utiliza una base de ≤8B. |
+
+`mode="full"` admite modelos de hasta **4B de parámetros**. Los cuatro ajustes preestablecidos en la fila de ajuste fino completo anterior son genuinos de ~3B (el recuento real de parámetros es de 3.08 a 3.24B) y caben en una tarjeta de 16 GB. La clase de 3.8 a 4B (Phi-4-mini-3.8B, Qwen-3.5-4B) también es aceptada por el límite, pero necesita una tarjeta de **24 GB o más** para un ajuste fino completo; solo los pesos y los gradientes se acercan a los 16 GB antes del optimizador y las activaciones, por lo que en una tarjeta de 16 GB, utiliza `mode="lora"` para esos (están en la fila de LoRA). Los modelos >4B se cierran con `RUNTIME_FULL_FT_MODEL_TOO_LARGE`.
+
+La cuantificación de 2 bits (AQLM / QuIP#) está **fuera del alcance**. Se incluyó en v1.4 y luego se eliminó en el [resumen de la trayectoria v1.5](docs/V1_5_BRIEF.md): una base de 2 bits no se puede fusionar limpiamente con los pesos de precisión completa, lo que rompe el contrato de adaptador fusionable → GGUF → Ollama (el objetivo principal de la canalización). Los mecanismos de ajuste que ofrece Backpropagate son la ruta de computación FP8 de v1.5 (`--fp8`, Blackwell/Hopper) y `mode="full"` para modelos de ≤4B; ambos se mantienen fusionables y exportables.
 
-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 y más pequeños, el ajuste fino completo (no solo LoRA) es factible en 16 GB y ahora se incluye en v1.4 como `mode="full"`. Pasa `Trainer(..., mode="full")` o `backprop train --mode=full --model phi-4-mini-3.8b` para habilitarlo. Una puerta de enlace impide el modo para modelos >4B con `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, y nombra a LoRA + los ajustes preestablecidos de menos de 4B como las opciones de recuperación. Consulta [la página del manual de ajuste fino completo](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) para ver las matemáticas de 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 necesita una GPU de 24 GB o más; considera alquilar una A100 en la nube o quédate con LoRA, que las investigaciones recientes muestran que coincide con la calidad del ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento (consulta [la sección "antiventa"](#what-backpropagate-is-not-for) para ver las citas).
 
-## Lo que Backpropagate NO es
+## Para lo que NO sirve Backpropagate
 
-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 tu caso de uso es el siguiente, te irá mejor con una biblioteca diferente; Backpropagate no es la opción correcta e intentar que funcione costaría más que simplemente utilizar la herramienta adecuada. Leer esta sección antes de comenzar te ahorrará el ciclo de instalación y abandono:
 
-- **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 parámetros completos de modelos de 7B+** — Backpropagate utiliza LoRA/QLoRA, que entrena un pequeño adaptador en lugar de actualizar todos los pesos. Para modelos de 7B y superiores, el ajuste fino completo requiere 24 GB o más de memoria de GPU y no cabe en una tarjeta de consumidor de 16 GB. Para modelos de 3B o inferiores, el ajuste fino completo es factible con 16 GB y se incluye en la v1.4 como `mode="full"` (pasar `Trainer(..., mode="full")` o `--mode=full` en la CLI; una restricción estricta genera `RUNTIME_FULL_FT_MODEL_TOO_LARGE` para modelos > 4B y nombra LoRA + los ajustes preestablecidos de sub-4B como opciones de recuperación). 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 seguir utilizando LoRA. `mode="full"` existe para los casos en los que se ha medido una diferencia de calidad y se ha decidido invertir en más capacidad de cómputo. Si realmente necesita un ajuste fino completo de un modelo de 7B+, utilice HuggingFace `transformers.Trainer` directamente en una tarjeta de 24 GB o más.
+- **RL en línea: PPO / GRPO / RLVR** — Backpropagate realiza un ajuste fino supervisado (SFT) de una sola etapa más un ajuste de preferencias sin referencia (ORPO se incluye en la v1.5; SimPO/KTO están planificados). Lo que *no* hace es el aprendizaje por refuerzo en línea: PPO, GRPO o RLVR, que requiere un modelo de recompensa o un bucle de generación y puntuación además del paso de entrenamiento. Para estos, utilice TRL o LLaMA-Factory directamente. (El ajuste de preferencias sin referencia se ajusta al ámbito de una sola etapa porque no hay un modelo de referencia separado que mantener en la memoria; consulte la nota de ORPO en [Guía de inicio rápido](#quick-start)).
+- **Entrenamiento en varios nodos** — solo una GPU en una máquina. El uso de varias GPU en una máquina funciona (a través de `accelerate launch`), pero no está oficialmente admitido.
+- **Entrenamiento en macOS con CUDA** — Apple Silicon no tiene CUDA, por lo que la ruta de CUDA debe ejecutarse en una máquina Linux o Windows con una GPU NVIDIA. Aún puede ejecutar el modelo entrenado en un Mac a través de Ollama. **Novedad en la v1.5:** una ruta MLX experimental (`--backend mlx`) entrena un adaptador LoRA de forma nativa en Apple Silicon; consulte [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15). Solo es para LoRA-SFT y se ha creado, pero aún no se ha verificado en hardware real, por lo que, para cualquier cosa que vaya más allá de un LoRA SFT (ORPO, ajuste fino completo, FP8, ejecución múltiple), seguirá necesitando la ruta de CUDA.
+- **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 definidos en CI.
 
-Si necesita alguna de estas funciones, utilice una de las bibliotecas mencionadas anteriormente. Son mejores en eso.
+Si necesita alguna de estas cosas, utilice una de las bibliotecas enumeradas anteriormente. Son mejores para ello.
 
-## Lo que Backpropagate le ofrece:
+## Lo que ofrece Backpropagate
 
 Cuatro cosas, en una sola instalación:
 
-**1. Una API real de 3 líneas que funciona sin un archivo de configuración.**
-El fragmento de código que se encuentra al principio de este archivo README se ejecuta de principio a fin. No requiere `accelerate config`, ni YAML, ni anulaciones de Hydra. Simplemente `Trainer(model).train(data)` y tendrá un modelo ajustado.
+**1. Una API real de 3 líneas que se ejecuta sin un archivo de configuración.**
+El fragmento de código que aparece al principio de este archivo README se ejecuta de principio a fin. No hay `accelerate config`, ni YAML, ni reemplazos de Hydra. Simplemente `Trainer(model).train(data)` y ya tiene un ajuste fino.
 
-**2. Funcionalidad que realmente funciona en Windows.**
-La mayoría de las bibliotecas de aprendizaje automático tratan a Windows como una opción secundaria. Backpropagate se prueba exhaustivamente en Windows + RTX 5080. La biblioteca se encarga de las peculiaridades del entorno de ejecución: sabe cómo pre-tokenizar sus datos para que el procesamiento multiproceso de Windows no se bloquee, desactiva automáticamente xformers en las tarjetas RTX 40/50 donde podría fallar, y selecciona la configuración del cargador de datos que no causa problemas. No tiene que saber nada de esto. Simplemente funciona.
+**2. Windows que realmente funciona.**
+La mayoría de las bibliotecas de aprendizaje automático tratan a Windows como algo secundario. Backpropagate se prueba de forma nativa en Windows + RTX 5080. La biblioteca gestiona las peculiaridades del tiempo de ejecución por usted: sabe cómo pre-tokenizar sus datos para que el procesamiento en paralelo de Windows no falle, desactiva automáticamente xformers en las tarjetas RTX 40/50 donde esto provocaría un error y elige la configuración del cargador de datos que no causa problemas. No tiene que saber nada de esto. Simplemente funciona.
 
-**3. Diseñado para ejecuciones no supervisadas.**
-El entrenamiento lleva horas. No quiere tener que vigilarlo constantemente. Backpropagate está diseñado para que se pueda dejar funcionando:
+**3. Diseñado para ejecuciones sin supervisión.**
+El entrenamiento lleva horas. No quiere tener que vigilarlo. Backpropagate está diseñado para que se pueda dejar funcionando:
 
-- Si se queda sin memoria de GPU, reduce automáticamente el tamaño del lote e intenta de nuevo, hasta tres veces. No requiere ajuste manual.
-- Si la GPU se calienta demasiado, se pausa hasta que se enfría y luego continúa.
-- Cada punto de control se guarda de forma atómica: si su computadora portátil se bloquea durante el guardado, el punto de control anterior y válido sigue intacto.
-- Cada ejecución de entrenamiento recibe un ID único que se imprime en cada línea de registro, cada punto de control y cada entrada de Weights & Biases. Si algo sale mal, un solo ID permite a un desarrollador correlacionar todo.
+- Si se queda sin memoria de GPU, reduce automáticamente a la mitad el tamaño del lote y lo vuelve a intentar, hasta tres veces. No requiere ajustes manuales.
+- Si su GPU se calienta demasiado, se detiene hasta que las cosas se enfríen y luego continúa.
+- Cada punto de control se escribe de forma atómica: si su portátil se bloquea en medio del guardado, el punto de control anterior y válido sigue intacto.
+- Cada ejecución de entrenamiento obtiene un ID único que se estampa en cada línea del registro, en cada punto de control y en cada entrada de Weights & Biases. Si algo sale mal, un solo ID permite a un mantenedor correlacionar todo.
 - Los errores vienen con códigos estables (`RUNTIME_GPU_OOM`, `DEP_OLLAMA_REGISTRATION_FAILED`, etc.) para que pueda buscar en sus registros y en la [guía de solución de problemas](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) para encontrar la solución. Los fallos específicos de CUDA tienen una [página de solución de problemas de CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/) dedicada.
 
-**4. Un solo comando para pasar del adaptador entrenado a `ollama run`.**
-Muchas bibliotecas entrenan un modelo. Pocas de ellas le permiten continuar una vez que realmente quiere usarlo. Backpropagate exporta a GGUF (el formato que utiliza Ollama) y registra un modelo de Ollama con un solo comando. Pasa de "entrenamiento completado" a "puedo chatear con mi modelo ajustado" en aproximadamente 30 segundos.
+**4. Un solo comando, desde el adaptador entrenado hasta `ollama run`.**
+Muchas bibliotecas entrenan un modelo. Pocas le facilitan el uso real. Backpropagate exporta a GGUF (el formato que utiliza Ollama) y registra un modelo de Ollama en un solo comando. Pasa de "entrenamiento completado" a "puedo chatear con mi modelo ajustado" en unos 30 segundos.
 
-## Cómo empezar
+## Guía de inicio rápido
 
-El repositorio incluye un conjunto de datos de ejemplo pequeño para que el fragmento de código que se muestra al principio de este archivo README se ejecute correctamente en una instalación limpia:
+El repositorio incluye un pequeño conjunto de datos de ejemplo para que el fragmento de código que aparece al principio de este archivo README se ejecute en una instalación limpia:
 
 ```bash
 pipx install "backpropagate[standard]"
@@ -131,31 +136,78 @@ trainer.export('gguf', quantization='q4_k_m')
 "
 ```
 
-Esto entrena un adaptador Qwen 2.5 de 7B con 5 conversaciones cortas en formato ShareGPT, y luego exporta el resultado a GGUF. Para sus propios datos, formatee su archivo JSONL con un ejemplo por línea:
+Esto entrena un adaptador Qwen 2.5 de 7B con 5 conversaciones cortas en formato ShareGPT y, a continuación, exporta el resultado a GGUF. Para sus propios datos, formatee su JSONL con un ejemplo por línea:
 
 ```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."}]}
 ```
 
-También funcionan los formatos de Alpaca (`instruction` / `output`), OpenAI chat (`messages`) y texto sin formato; Backpropagate detecta automáticamente el formato.
+Los formatos Alpaca (`instruction` / `output`), OpenAI chat (`messages`) y texto sin formato también funcionan: Backpropagate detecta automáticamente el formato.
 
-Para flujos de trabajo más completos (ajuste fino y publicación en Hugging Face Hub, reanudación después de errores de memoria, ejecuciones múltiples de SLAO durante una campaña larga, etc.), consulte la [página de recetas del manual](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
+### Ajuste de preferencias (ORPO)
 
-### Interfaz web (opcional)
+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}`):
 
-Si prefiere hacer clic en lugar de escribir código Python, instale el paquete de la interfaz de usuario y ejecútelo:
+```jsonl
+{"prompt": "What is Python?", "chosen": "A high-level programming language known for readability.", "rejected": "idk look it up"}
+{"prompt": "Explain recursion.", "chosen": "A function that calls itself with a smaller input until a base case.", "rejected": "when something repeats"}
+```
+
+```python
+from backpropagate import Trainer
+
+trainer = Trainer("Qwen/Qwen2.5-7B-Instruct", method="orpo")
+trainer.train("preferences.jsonl", steps=100)
+trainer.export("gguf", quantization="q4_k_m")
+```
+
+```bash
+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).
+
+### SFT de trazado de razonamiento (destilación R1)
+
+Nuevo en v1.5: destile un modelo de razonamiento de forma sencilla. Pase `--reasoning-trace` (CLI) o `Trainer(..., reasoning_trace=True)` (Python) y proporcione trazas que mantengan una cadena de pensamiento `<think>...</think>` dentro del turno del asistente; la mitad de SFT puro de la destilación de [DeepSeek-R1](https://arxiv.org/abs/2501.12948), no se requiere RL. La retropropagación mantiene `<think>` en el objetivo de entrenamiento, elimina las trazas vacías o demasiado largas (filtrado de la longitud de la traza) y aumenta el valor predeterminado de `max_seq_length` a 8192 para la cadena de pensamiento más larga. Lo más importante es que `<think>` permanece como **texto sin formato**; no hay tokens especiales, no se cambia el tamaño del embedding; por lo tanto, el GGUF combinado aún se exporta a Ollama como cualquier otro ajuste fino. Solo SFT. Consulte la [receta de trazado de razonamiento](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/#reasoning-trace-sft-r1-distillation) para conocer el formato del conjunto de datos y el rango de tokens ajustable.
+
+### Apple Silicon (MLX) — experimental, v1.5
+
+Nuevo en v1.5: **una API, dos vías**. CUDA sigue siendo el backend canónico y verificado; MLX es una segunda vía que se entrena en un Mac de la serie M a través del conjunto de herramientas [`mlx_lm.lora`](https://github.com/ml-explore/mlx-lm) de Apple (memoria unificada, sin CUDA). La misma estructura de 3 líneas selecciona la vía según el hardware: `backend='auto'` (el valor predeterminado) dirige el flujo a CUDA en NVIDIA y a MLX en Apple Silicon, por lo que los sistemas CUDA existentes son idénticos a nivel de bytes.
+
+```python
+from backpropagate import Trainer
+
+# On an M-series Mac with `pip install 'backpropagate[mlx]'`:
+trainer = Trainer("mlx-community/Qwen2.5-0.5B-Instruct-4bit", backend="mlx")
+trainer.train("examples/quickstart.jsonl", steps=100)
+```
+
+```bash
+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`.
+
+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/).
+
+### Interfaz de usuario web (opcional)
+
+Si prefiere hacer clic en lugar de escribir en Python, instale el paquete adicional de la interfaz de usuario y ejecute:
 
 ```bash
 pipx install "backpropagate[ui]"
 backprop ui --port 7862
 ```
 
-Se abre una interfaz web local en `http://localhost:7862`, donde puede seleccionar un conjunto de datos, elegir un modelo, entrenar y exportar. La interfaz de usuario solo funciona localmente de forma predeterminada. Para permitir el acceso desde otros dispositivos, consulte la sección [Interfaz web](#web-ui) a continuación para obtener información sobre el contrato de seguridad `--share` + `--auth`.
+Se abre una interfaz web local en `http://localhost:7862` para explorar conjuntos de datos, validar formatos y ensamblar una configuración de entrenamiento visualmente. El entrenamiento en sí se ejecuta a través de `backprop train` (el entrenamiento impulsado por la interfaz de usuario está en la hoja de ruta; el botón Iniciar actualmente muestra esa nota). La interfaz de usuario es solo local de forma predeterminada. Para exponerla a otros dispositivos, consulte [Interfaz de usuario web](#web-ui) a continuación para conocer el contrato de seguridad `--share` + `--auth`.
 
-## Entrenamiento con múltiples ejecuciones
+## Entrenamiento de ejecución múltiple
 
-Si desea realizar un ajuste fino incremental en varios conjuntos de datos, por ejemplo, si recibe nuevos datos de entrenamiento cada semana y desea agregarlos sin olvidar lo que aprendió antes, el modo `multi_run` de Backpropagate es para usted:
+Si desea realizar un ajuste fino de forma incremental en varios conjuntos de datos (por ejemplo, si obtiene nuevos datos de entrenamiento cada semana y desea agregarlos sin olvidar lo que aprendió antes), el modo `multi_run` de Backpropagate es para usted:
 
 ```python
 from backpropagate import Trainer
@@ -170,7 +222,7 @@ result = trainer.multi_run(
 )
 ```
 
-Esto realiza cinco pasadas de entrenamiento, fusionando el adaptador entre cada ejecución de una manera que preserva el conocimiento previo al tiempo que incorpora nuevos ejemplos. Esta técnica se basa en investigaciones recientes sobre aprendizaje continuo; consulte la sección [Referencias](#references) al final de este archivo README.
+Esto ejecuta cinco pases de entrenamiento, fusionando el adaptador entre ejecuciones de una manera que preserva el conocimiento anterior al tiempo que incorpora nuevos ejemplos. La técnica se basa en investigaciones recientes sobre el aprendizaje continuo; consulte [Referencias](#references) al final de este archivo README.
 
 La versión de la línea de comandos:
 
@@ -180,7 +232,7 @@ backprop multi-run --data my_data.jsonl --runs 5 --steps 100 --samples 1000
 
 ## Reanudar desde un punto de control
 
-Una ejecución de entrenamiento de 5 pasadas que se interrumpe en la pasada 4 se puede recuperar. Cada sesión de entrenamiento con múltiples ejecuciones escribe su ID de ejecución en el historial y el manifiesto del punto de control almacenados en el disco, por lo que para reanudar desde donde lo dejó, solo necesita un comando:
+Un entrenamiento de 5 ejecuciones que falla en la ejecución 4 se puede recuperar. Cada sesión de ejecución múltiple escribe su ID de ejecución en el historial y el manifiesto de puntos de control en el disco, por lo que reanudar donde lo dejó es un solo comando:
 
 ```bash
 backprop resume <run-id>
@@ -188,11 +240,11 @@ backprop multi-run --data ... --resume <run-id>
 backprop train --data ... --resume <run-id>     # single-run resume
 ```
 
-El comportamiento predeterminado de `backprop multi-run` (sin `--resume`) detecta automáticamente una ejecución en curso en el mismo directorio de salida y la continúa. Para forzar un inicio limpio, especifique un directorio de salida nuevo.
+El comportamiento predeterminado de `backprop multi-run` (sin `--resume`) detecta automáticamente una entrada en curso en el mismo directorio de salida y la continúa. Para forzar un inicio limpio, apunte a un directorio de salida nuevo.
 
 ## Historial de entrenamiento
 
-Cada invocación de `backprop train` y `backprop multi-run` registra una fila en `<output>/run_history.json`, que incluye el modelo utilizado, el conjunto de datos, los hiperparámetros, el estado, la pérdida final y el historial de pérdidas. Puede enumerar e inspeccionar ejecuciones anteriores:
+Cada invocación de `backprop train` y `backprop multi-run` registra una fila en `<output>/run_history.json`: modelo utilizado, conjunto de datos, hiperparámetros, estado, pérdida final, historial de pérdidas. Puede enumerar e inspeccionar ejecuciones anteriores:
 
 ```bash
 backprop list-runs                         # last 20 runs
@@ -203,7 +255,7 @@ backprop show-run abcd1234                 # detail view (partial ID is fine)
 
 ## Seguimiento de experimentos
 
-Backpropagate detecta automáticamente los sistemas de seguimiento de experimentos instalados (Weights & Biases, TensorBoard, MLflow) y los integra. Si `wandb` está instalado y ha iniciado sesión, cada ejecución se registra automáticamente en W&B con un nombre de ejecución que coincide con el ID de ejecución almacenado en el disco, lo que le permite buscar en W&B, sus registros y `run_history.json` utilizando un único identificador.
+Backpropagate detecta automáticamente los rastreadores de experimentos instalados (Weights & Biases, TensorBoard, MLflow) y los conecta. Si `wandb` está instalado y ha iniciado sesión, cada ejecución registra automáticamente en W&B con un nombre de ejecución que coincide con el ID de ejecución en el disco, por lo que puede buscar en W&B, sus registros y `run_history.json` utilizando un identificador.
 
 ```bash
 pip install backpropagate[monitoring]   # installs wandb + psutil
@@ -211,23 +263,25 @@ wandb login                             # one-time setup
 backprop train --data my_data.jsonl
 ```
 
-Puede anular este comportamiento con `Trainer(report_to=["wandb"])`, `Trainer(report_to=["tensorboard"])` o `Trainer(report_to="none")` para desactivarlo.
+Anule la configuración con `Trainer(report_to=["wandb"])`, `Trainer(report_to=["tensorboard"])` o `Trainer(report_to="none")` para optar por no participar.
 
-## Interfaz web
+## Interfaz de usuario web
 
-La interfaz web de Reflex es opcional; instálela con `pipx install "backpropagate[ui]"` y ejecútela:
+La interfaz web de Reflex es opcional; instálela con `pipx install "backpropagate[ui]"` y ejecute:
 
 ```bash
 backprop ui --port 7862
 ```
 
-La interfaz de usuario se ejecuta localmente en `http://localhost:7862`. Para permitir el acceso desde otros dispositivos (otras personas en su red, una URL pública, etc.), debe combinar `--share` (o `--host`) con `--auth`:
+La interfaz de usuario se ejecuta localmente en `http://localhost:7862`. Hoy cubre la mitad de **explorar / validar / configurar** del flujo de trabajo: apunte a un conjunto de datos, verifique el formato y las estadísticas detectados automáticamente, elija un modelo y cree una configuración de ejecución. **El lanzamiento de la ejecución se realiza desde la línea de comandos** (`backprop train` / `backprop multi-run`); el botón Iniciar en la interfaz de usuario muestra una nota que indica esto. El entrenamiento impulsado por la interfaz de usuario es un desarrollo futuro; hasta entonces, la interfaz de usuario es el punto de entrada y la línea de comandos es el disparador.
+
+Para exponerlo a otros dispositivos (otras personas en su red, una URL pública, etc.), debe combinar `--share` (o `--host`) con `--auth`:
 
 ```bash
 backprop ui --share --auth alice:hunter2
 ```
 
-`backprop ui --share` sin `--auth` genera un error. La razón es que `--share` publica una URL a la que cualquier persona en Internet puede acceder, y sin autenticación, eso significa que cualquier persona puede controlar su canal de entrenamiento y leer su token de Hugging Face. No hay forma de desactivar esta función; si no desea establecer credenciales, utilice el reenvío de puertos SSH en su lugar:
+`backprop ui --share` sin `--auth` finaliza con un error. La razón: `--share` publica una URL a la que puede acceder cualquier persona en Internet, y sin autenticación, esto significa que cualquiera puede ejecutar su proceso de entrenamiento y leer su token de HuggingFace. No hay opción para desactivar esto; si no desea configurar credenciales, utilice en su lugar el reenvío de puertos SSH:
 
 ```bash
 # On the client:
@@ -237,32 +291,32 @@ backprop ui                             # no --share
 # Then open http://localhost:7860 in your local browser
 ```
 
-Consulte [handbook/security.md](https://mcp-tool-shop-org.github.io/backpropagate/handbook/security/) para obtener información detallada sobre el modelo de amenazas.
+Consulte [handbook/security.md](https://mcp-tool-shop-org.github.io/backpropagate/handbook/security/) para obtener el modelo completo de amenazas.
 
-Las escrituras en el sistema de archivos desde la interfaz de usuario están restringidas a un solo directorio:
+Las operaciones de escritura en el sistema de archivos desde la interfaz de usuario se limitan a un único directorio:
 
 - Predeterminado: `~/.backpropagate/ui-outputs`
-- Para sobrescribir: establezca `BACKPROPAGATE_UI__OUTPUT_DIR=/ruta/propia`
-- La sobrescritura se valida mediante una lista de denegación; se rechazan las rutas del sistema o de credenciales (`/etc`, `~/.ssh`, `~/.aws`, `C:\Windows\System32`, etc.).
+- Anulación: establezca `BACKPROPAGATE_UI__OUTPUT_DIR=/ruta/que/desea`
+- La anulación se valida mediante una lista de denegación: se rechazan las rutas del sistema o de credenciales (`/etc`, `~/.ssh`, `~/.aws`, `C:\Windows\System32`, etc.)
 
-## Notas sobre la plataforma
+## Notas de la plataforma
 
-**Requisitos:** Python 3.10+ · GPU con CUDA (8GB+ de VRAM) · PyTorch 2.0+
+**Requisitos:** Python 3.10+ · GPU CUDA (8 GB+ de VRAM) · PyTorch 2.0+
 
-Python 3.10 llegará al final de su vida útil en octubre de 2026, y Backpropagate planea eliminar el soporte para 3.10 en la versión 1.4. Para nuevas instalaciones, prefiera Python 3.11 o 3.12; 3.11 es la versión más probada.
+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.
 
-Backpropagate gestiona las peculiaridades del entorno de ejecución al entrenar en diferentes plataformas, pero no puede solucionar problemas de instalación. Los dos problemas más comunes son:
+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:
 
-- **Controlador CUDA incorrecto.** PyTorch se publica con un binario por cada versión de CUDA. Si elige el incorrecto, obtendrá una versión de PyTorch solo para CPU, y el entrenamiento será extremadamente lento. Utilice el selector de controladores en <https://pytorch.org/get-started/locally/> para su controlador. Ejecute `nvidia-smi` para ver la versión de su controlador/CUDA.
-- **Windows + exportación GGUF.** La opción `[export]` compila `llama-cpp-python` desde el código fuente, lo que requiere Visual Studio Build Tools (componente C++) y CMake.
+- **Paquete CUDA incorrecto.** PyTorch se publica con un binario por cada versión de CUDA. Si elige el incorrecto, obtendrá silenciosamente PyTorch solo para CPU y el entrenamiento será increíblemente lento. Utilice el selector de paquetes en <https://pytorch.org/get-started/locally/> para su controlador. Ejecute `nvidia-smi` para ver su versión de controlador/CUDA.
+- **Windows + exportación GGUF.** La opción `[export]` construye `llama-cpp-python` a partir del código fuente, lo que requiere las herramientas de compilación de Visual Studio (componente C++) y CMake.
 
-**macOS:** El entrenamiento con GPU no está soportado (no hay CUDA). Puede ejecutar el adaptador entrenado en un Mac a través de Ollama, pero `trainer.train()` genera un error `DEP_GPU_NOT_AVAILABLE`. Utilice una máquina con Linux o Windows con CUDA para el entrenamiento.
+**macOS:** la compatibilidad con CUDA no está habilitada (no hay CUDA); un `trainer.train()` con CUDA genera `DEP_GPU_NOT_AVAILABLE`, y puede ejecutar el adaptador entrenado en un Mac a través de Ollama. **Nuevo en la versión 1.5:** una compatibilidad experimental con MLX (`--backend mlx`, `pip install 'backpropagate[mlx]'`) entrena un adaptador LoRA de forma nativa en Apple Silicon a través de `mlx_lm.lora`; solo SFT LoRA, y compilado y probado, pero aún no verificado en hardware real (consulte [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15)). Para la ruta CUDA o para ORPO/ajuste completo/FP8/ejecuciones múltiples, utilice una máquina Linux o Windows con CUDA.
 
-Consulte la [página del manual de solución de problemas](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) para obtener una guía completa sobre la solución de problemas de instalación, y la [página de solución de problemas de CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/) dedicada para problemas de controlador/VRAM/xformers/bf16-vs-fp16.
+Consulte la [página de solución de problemas del manual](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/) para obtener una guía completa de solución de problemas de instalación, y la [página dedicada de solución de problemas de CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/) para obtener información sobre problemas de controladores/VRAM/xformers/bf16 frente a fp16.
 
-## Interfaz de línea de comandos
+## CLI
 
-Cada API de Python tiene un equivalente de línea de comandos (CLI):
+Cada API de Python tiene un equivalente en la CLI:
 
 ```bash
 backprop train --data my_data.jsonl --model Qwen/Qwen2.5-7B-Instruct --steps 100
@@ -279,80 +333,80 @@ backprop replay <run-id>               # re-run with same config / dataset
 backprop export-runs --format jsonl    # bulk export run history
 ```
 
-Consulte la referencia completa en [la página de referencia del CLI](https://mcp-tool-shop-org.github.io/backpropagate/handbook/cli-reference/), o `backprop <subcomando> --help`.
+Referencia completa en [la página del manual de la CLI](https://mcp-tool-shop-org.github.io/backpropagate/handbook/cli-reference/), o `backprop <subcomando> --help`.
 
 ## Configuración
 
-Cada configuración se puede sobrescribir con una variable de entorno utilizando el prefijo `BACKPROPAGATE_`:
+Se puede anular cada configuración con una variable de entorno utilizando el prefijo `BACKPROPAGATE_`:
 
-| Variable | Valor predeterminado | Notas |
+| Variable | Predeterminado | Notas |
 |---|---|---|
 | `BACKPROPAGATE_LOG_LEVEL` | `INFO` | `DEBUG` / `INFO` / `WARNING` / `ERROR` |
-| `BACKPROPAGATE_LOG_JSON` | automático | Forzar registros JSON o de consola |
+| `BACKPROPAGATE_LOG_JSON` | automático | Forzar registros en JSON o en la consola |
 | `BACKPROPAGATE_MODEL__NAME` | `Qwen/Qwen2.5-7B-Instruct` | Modelo predeterminado |
 | `BACKPROPAGATE_TRAINING__LEARNING_RATE` | `2e-4` | Tasa de aprendizaje |
-| `BACKPROPAGATE_LORA__R` | `256` | Rango LoRA (valor predeterminado de la versión 1.3; use `--lora-preset=fast` para el valor predeterminado de la versión 1.2.x, que es 16) |
-| `BACKPROPAGATE_UI__OUTPUT_DIR` | `~/.backpropagate/ui-outputs` | Sistema de archivos de la interfaz de usuario (sandbox) |
+| `BACKPROPAGATE_LORA__R` | `256` | Rango LoRA (predeterminado en v1.3; pase `--lora-preset=fast` para el valor predeterminado de v1.2.x de 16) |
+| `BACKPROPAGATE_UI__OUTPUT_DIR` | `~/.backpropagate/ui-outputs` | Sandbox del sistema de archivos de la interfaz de usuario |
 
-Las claves anidadas utilizan doble guion bajo (`MODEL__NAME`, no `MODEL_NAME`). La referencia completa se encuentra en [la página del manual de variables de entorno](https://mcp-tool-shop-org.github.io/backpropagate/handbook/env-vars/).
+Las claves anidadas utilizan doble guion bajo (`MODEL__NAME`, no `MODEL_NAME`). La referencia completa está en [la página del manual de las variables de entorno](https://mcp-tool-shop-org.github.io/backpropagate/handbook/env-vars/).
 
-## Preajustes de modelos
+## Presets de modelo
 
-| Preajuste | VRAM | Licencia | Notas |
+| Preset | VRAM | Licencia | Notas |
 |---|---|---|---|
-| Qwen-3.5-4B | ~8GB | Apache 2.0 | Valor predeterminado recomendado para modelos de menos de 5B. La mejor calidad para este tamaño. |
-| Phi-4-mini-3.8B | ~8GB | MIT | Excelente para razonamiento, matemáticas y código. Licencia limpia. |
-| SmolLM3-3B | ~6GB | Apache 2.0 | Receta completamente abierta. Contexto nativo de 64K. |
-| Qwen 2.5 7B | ~12GB | Apache 2.0 | Valor predeterminado existente. La mejor calidad de los modelos heredados de 7B. |
-| Qwen 2.5 3B | ~8GB | Qwen-Research | ⚠ licencia de investigación; consulte los términos de la licencia de Qwen antes de usarlo comercialmente. |
-| Llama 3.2 3B | ~8GB | Llama Community | Una alternativa sólida a Qwen 3B con algunas restricciones. |
-| Llama 3.2 1B | ~6GB | Llama Community | Ideal para experimentos rápidos en tarjetas pequeñas. |
-| Mistral 7B | ~12GB | Apache 2.0 | Comparable a Qwen 7B, pero con una plantilla de chat diferente. |
+| Qwen-3.5-4B | ~8 GB | Apache 2.0 | Predeterminado recomendado para modelos de menos de 5B. La mejor calidad para este tamaño. |
+| Phi-4-mini-3.8B | ~8 GB | MIT | Fuerte en razonamiento/matemáticas/código. Licencia estrictamente limpia. |
+| SmolLM3-3B | ~6 GB | Apache 2.0 | Receta totalmente abierta. Contexto nativo de 64K. |
+| Qwen 2.5 7B | ~12 GB | Apache 2.0 | Predeterminado existente. La mejor calidad de los presets de 7B heredados. |
+| Qwen 2.5 3B | ~8 GB | Qwen-Research | ⚠ licencia de investigación: consulte los términos de la licencia de Qwen antes de su uso comercial. |
+| Llama 3.2 3B | ~8 GB | Llama Community | Una alternativa sólida a Qwen 3B con advertencias permisivas. |
+| Llama 3.2 1B | ~6 GB | Llama Community | Para experimentos rápidos en tarjetas pequeñas. |
+| Mistral 7B | ~12 GB | Apache 2.0 | Comparable a Qwen 7B, plantilla de chat diferente. |
 
-Otros modelos pueden funcionar, pero solo estos ocho están incluidos en las pruebas automatizadas (CI). Utilice `--lora-preset=quality` (predeterminado) para obtener un rango de 256 / objetivos de línea recta, según Biderman 2024 + Thinking Machines 2025, o `--lora-preset=fast` para obtener el rango de 16 / objetivo q+v de la versión 1.2.x si necesita la huella de la versión 1.2.x.
+Otros modelos a menudo funcionan, pero solo estos ocho están fijados en CI. Pase `--lora-preset=quality` (predeterminado) para objetivos de rango 256/todos los lineales según Biderman 2024 + Thinking Machines 2025, o `--lora-preset=fast` para el objetivo heredado de rango 16/q+v si necesita la huella de v1.2.x.
 
-## Resolución de problemas
+## Solución de problemas
 
-Un índice breve de los fallos más comunes al ejecutarlo por primera vez. El índice inverso completo se encuentra en [la página del manual de solución de problemas](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/). Para obtener información detallada sobre el controlador/VRAM/precisión mixta, consulte la [página de solución de problemas de CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/).
+Un breve índice de los fallos más comunes en la primera ejecución. El índice inverso completo está en [la página del manual de solución de problemas](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting/). Para obtener información detallada sobre el controlador/VRAM/precisión mixta, consulte la [página de solución de problemas de CUDA](https://mcp-tool-shop-org.github.io/backpropagate/handbook/troubleshooting-cuda/).
 
 | Síntoma | Código de error | Solución |
 |---|---|---|
-| La GPU se queda sin memoria durante el entrenamiento. | `RUNTIME_GPU_OOM` | Automatic — Backpropagate reduce la mitad del tamaño del lote e intenta hasta 3 veces. Para desactivar esta función: `Trainer(oom_recovery=False)`. Para forzar un tamaño de lote más pequeño: `--batch-size 1`. |
-| HuggingFace devuelve 401 / "modelo no encontrado" | `DEP_MODEL_LOAD_FAILED` | Ejecute `huggingface-cli login` e inténtelo de nuevo. Si hay errores tipográficos, copie el ID exacto de <https://huggingface.co/models>. |
-| `register_with_ollama` rechaza la conexión. | `DEP_OLLAMA_REGISTRATION_FAILED` | Inicie el demonio: `ollama serve`. Instálelo desde <https://ollama.com>. Se puede volver a intentar. |
-| El disco se llena durante el guardado del punto de control. | `STATE_CHECKPOINT_INVALID` | Las escrituras atómicas dejan un directorio `.partial` en caso de fallo; es seguro eliminarlo. El punto de control anterior y válido está intacto. |
-| Entrenamiento pausado debido a sobrecalentamiento de la GPU. | `RUNTIME_GPU_TEMPERATURE_CRITICAL` | Automatic — Backpropagate pausa cuando se alcanza el umbral de temperatura y reanuda cuando la GPU se enfría. Mejore el flujo de aire si esto ocurre con frecuencia. |
-| `backprop ui --share` es rechazado. | `INPUT_AUTH_REQUIRED` | Utilice `--auth user:password` o, en su lugar, use el reenvío de puertos SSH (consulte [Interfaz de usuario web](#web-ui)). |
-| La exportación a GGUF falló en el primer intento. | `RUNTIME_GGUF_EXPORT_FAILED` | `pip install backpropagate[export]`; en Windows, también necesita Visual C++ Build Tools + CMake. |
+| La GPU se queda sin memoria a mitad del entrenamiento | `RUNTIME_GPU_OOM` | Automático: la retropropagación reduce a la mitad el tamaño del lote y reintenta hasta 3 veces. Para desactivar: `Trainer(oom_recovery=False)`. Para forzar un tamaño menor: `--batch-size 1`. |
+| HuggingFace devuelve 401 / "modelo no encontrado". | `DEP_MODEL_LOAD_FAILED` | Ejecute `huggingface-cli login` y vuelva a intentarlo. Para errores tipográficos, copie el ID exacto de <https://huggingface.co/models>. |
+| `register_with_ollama` conexión rechazada. | `DEP_OLLAMA_REGISTRATION_FAILED` | Inicie el demonio: `ollama serve`. Instale desde <https://ollama.com>. Se puede reintentar. |
+| Disco lleno durante el guardado del punto de control. | `STATE_CHECKPOINT_INVALID` | Las escrituras atómicas dejan un directorio `.partial` en caso de fallo; es seguro eliminarlo. El punto de control anterior y correcto está intacto. |
+| Entrenamiento pausado debido al sobrecalentamiento de la GPU. | `RUNTIME_GPU_TEMPERATURE_CRITICAL` | Automático: la retropropagación se pausa al alcanzar el umbral de temperatura y se reanuda a medida que la GPU se enfría. Mejore el flujo de aire si esto sigue ocurriendo. |
+| `backprop ui --share` rechazado. | `RUNTIME_UI_AUTH_NOT_ENFORCED` | Pase `--auth user:password` o utilice el reenvío de puertos SSH en su lugar (consulte [Interfaz de usuario web](#web-ui)). |
+| La exportación a GGUF falló en el primer intento. | `RUNTIME_GGUF_EXPORT_FAILED` | `pip install backpropagate[export]`; en Windows, también necesita las herramientas de compilación de Visual C++ y CMake. |
 
-## Informar de errores
+## Informar sobre errores
 
-Cuando algo falla, Backpropagate imprime una línea al inicio, como `run_started run_id=<uuid>`, y asocia el mismo ID a cada línea de registro, a cada punto de control y a cada entrada de Weights & Biases. **Incluya el `run_id` en cualquier informe de error**; esto permite al responsable del mantenimiento correlacionar todo para esa ejecución específica.
+Cuando algo falla, Backpropagate imprime una línea al inicio, como `run_started run_id=<uuid>`, y vincula el mismo ID a cada línea del registro, a cada punto de control y a cada entrada de Weights & Biases. **Incluya el `run_id` en cualquier informe de errores**, ya que esto permite al responsable correlacionar todo para esa ejecución específica.
 
-Un buen informe de error incluye:
+Un buen informe de errores 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 impreso al inicio. Un UUID permite al responsable correlacionar cada línea del 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 `[CODE_NAME]: message` en stderr. Consulte [códigos de error](https://mcp-tool-shop-org.github.io/backpropagate/handbook/error-codes/) para obtener el catálogo de códigos estables.
+3. **El rastreo de pila redactado**. Stderr se redacta automáticamente en el modo no detallado (los tokens de Bearer, `sk-*`, `hf_*`, las claves de AWS y los pares `password=` / `token=` / `api_key=` se eliminan; es seguro pegarlos). Para obtener el rastreo de pila completo y no redactado, vuelva a ejecutar con `BACKPROPAGATE_DEBUG=1` (o `--verbose`); revíselo antes de publicarlo.
+4. **La salida de `backprop info`**. Un comando imprime Python / PyTorch / CUDA / modelo de GPU / VRAM / SO / extras instalados: todo lo que el responsable necesita para analizar 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 de informe de errores](https://github.com/mcp-tool-shop-org/backpropagate/issues/new?template=bug_report.yml) solicita explícitamente cada uno de estos elementos para que la evaluación inicial se realice rápidamente. Las preguntas, ideas o consultas sobre si algo es "esperado" deben dirigirse a [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 conocer la política y los plazos de respuesta.
 
 ## Privacidad
 
-Todo el entrenamiento se realiza localmente en su GPU. Backpropagate no realiza solicitudes de red excepto para descargar modelos de HuggingFace (lo cual usted inicia). No hay telemetría, ni dependencia de la nube.
+Todo el entrenamiento se realiza localmente en su GPU. Backpropagate no realiza ninguna solicitud de red, excepto para descargar modelos de HuggingFace (lo que usted inicia). No hay telemetría ni dependencia de la nube.
 
 ## Referencias
 
-Los valores predeterminados de Backpropagate y el modo de entrenamiento con múltiples ejecuciones se basan en investigaciones recientes. Si está interesado en las técnicas subyacentes:
+Los valores predeterminados de Backpropagate y el modo de entrenamiento multi-ejecución se basan en investigaciones recientes. Si está interesado en las técnicas subyacentes:
 
-- **Hu et al. 2021.** *LoRA: Low-Rank Adaptation of Large Language Models.* [arXiv:2106.09685](https://arxiv.org/abs/2106.09685) — el artículo fundamental que introduce LoRA, que es la forma en que Backpropagate entrena adaptadores de manera eficiente.
-- **Biderman et al. 2024.** *LoRA Learns Less and Forgets Less.* [arXiv:2405.09673](https://arxiv.org/abs/2405.09673) — evidencia empírica de que LoRA con un rango de 256 y objetivos totalmente lineales coincide con la calidad del ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento, utilizando el 67% de la capacidad de cómputo. Define la configuración predeterminada de LoRA de la versión 1.3 de Backpropagate.
-- **Thinking Machines 2025.** *LoRA Without Regret.* [thinkingmachines.ai/blog/lora](https://thinkingmachines.ai/blog/lora/) — el seguimiento práctico que identifica la corrección de 10 veces la tasa de aprendizaje con respecto al ajuste fino completo necesaria para rangos LoRA altos.
-- **Kirkpatrick et al. 2017.** *Overcoming catastrophic forgetting in neural networks.* [arXiv:1612.00796](https://arxiv.org/abs/1612.00796) — la caracterización original de por qué las redes neuronales "olvidan" el entrenamiento anterior cuando se ajustan a nuevos datos (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 enfoque anterior para usar LoRA para el aprendizaje continuo, restringiendo los nuevos adaptadores a subespacios ortogonales.
-- **Yadav et al. 2023.** *TIES-Merging: Resolving Interference When Merging Models.* [arXiv:2306.01708](https://arxiv.org/abs/2306.01708) — una técnica fundamental para fusionar múltiples modelos ajustados sin interferencia.
-- **Qiao & Mahdavi 2025.** *Merge before Forget: A Single LoRA Continual Learning via Continual Merging.* [arXiv:2512.23017](https://arxiv.org/abs/2512.23017) — el algoritmo específico que implementa el fusionador de múltiples ejecuciones de Backpropagate. Un preprint de diciembre de 2025; Backpropagate es el primer adoptador conocido en un entorno de producción.
+- **Hu et al. 2021.** *LoRA: Low-Rank Adaptation of Large Language Models.* [arXiv:2106.09685](https://arxiv.org/abs/2106.09685) — el documento fundamental que presenta LoRA, que es la forma en que Backpropagate entrena los adaptadores de manera eficiente.
+- **Biderman et al. 2024.** *LoRA Learns Less and Forgets Less.* [arXiv:2405.09673](https://arxiv.org/abs/2405.09673) — evidencia empírica de que LoRA con rango 256 y objetivos totalmente lineales coincide con la calidad del ajuste fino completo en la mayoría de las tareas posteriores al entrenamiento con el 67% de la capacidad de cómputo. Esto impulsa la configuración predeterminada de LoRA v1.3 de Backpropagate.
+- **Thinking Machines 2025.** *LoRA Without Regret.* [thinkingmachines.ai/blog/lora](https://thinkingmachines.ai/blog/lora) — la continuación práctica que identifica la corrección de 10× en la tasa de aprendizaje frente al ajuste fino completo necesaria con un rango LoRA alto.
+- **Kirkpatrick et al. 2017.** *Overcoming catastrophic forgetting in neural networks.* [arXiv:1612.00796](https://arxiv.org/abs/1612.00796) — la caracterización original de por qué las redes neuronales "olvidan" el entrenamiento anterior cuando se realiza un ajuste fino con nuevos datos (EWC: consolidación elástica del peso).
+- **Wang et al. 2023.** *Orthogonal Subspace Learning for Language Model Continual Learning.* [arXiv:2310.14152](https://arxiv.org/abs/2310.14152) — O-LoRA, un enfoque anterior para utilizar LoRA para el aprendizaje continuo restringiendo los nuevos adaptadores a subespacios ortogonales.
+- **Yadav et al. 2023.** *TIES-Merging: Resolving Interference When Merging Models.* [arXiv:2306.01708](https://arxiv.org/abs/2306.01708) — una técnica fundamental para fusionar varios modelos ajustados sin interferencias.
+- **Qiao & Mahdavi 2025.** *Merge before Forget: A Single LoRA Continual Learning via Continual Merging.* [arXiv:2512.23017](https://arxiv.org/abs/2512.23017) — el algoritmo específico que el fusionador multi-ejecución de Backpropagate implementa. Un preprint de diciembre de 2025; Backpropagate es el primer usuario conocido de este documento.
 
 ## Licencia