@mcptoolshop/backpropagate 1.6.0 → 1.7.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. Continúa
+# Ajusta un modelo QLoRA de 32B o un modelo completo de 7B en una sola GPU. Luego, intégralo en Ollama
 
-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.
+Realiza el ajuste fino de modelos de lenguaje grandes en una **única** GPU, dimensionada según la tarjeta que realmente tienes. Tres líneas de código Python para ajustar un modelo QLoRA de 7B a 34B en una sola tarjeta de consumo de 32 GB (RTX 5090); una opción: `--full-ft-offload` — realiza el ajuste fino completo de un modelo de la clase 7B descargando el estado del optimizador a la RAM del host. Un comando más exporta a Ollama y, luego, `ollama run` ejecuta tu modelo ajustado. Se adapta fácilmente hasta los 16 GB. Funciona perfectamente en Windows.
 
 ```python
 from backpropagate import Trainer
@@ -69,33 +69,38 @@ Backpropagate es la opción que faltaba: **una API de Python de 3 líneas para u
 
 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 16 GB
+## Qué puedes ajustar en una sola GPU
 
-Aquí tienes el rango práctico en una tarjeta de 16 GB (RTX 4080 / 5080 / 4070 Ti Super):
+Backpropagate dimensiona la ejecución según tu tarjeta. Aquí tienes el rango práctico en una GPU de consumo de **32 GB** (RTX 5090) con 64 GB de RAM del host: este es el equipo en el que se realiza el ajuste:
 
-| Modelo | Método | Estado |
+| Tamaño del modelo | Método | Estado en una tarjeta de 32 GB |
 |---|---|---|
-| 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. |
+| 7B (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | QLoRA | Cómodo: ~7–8 GB. Longitud completa de la secuencia, mucho margen. |
+| **14B** (Qwen2.5-14B) | QLoRA | **El punto óptimo para el uso diario: ~8,5 GB**, según lo medido. rank/alpha 32, paged 8-bit AdamW, 4096 ctx. |
+| 24B (Mistral-Small-24B) | QLoRA | ~18 GB. Encaja con margen en 4096 ctx. |
+| **32B** (Qwen2.5-32B) | QLoRA | **Apenas encaja: ~26 GB** con `max_len 2048` + paged 8-bit AdamW. Límite máximo. |
+| ≤6B | `mode="full"` (ajuste fino completo) | Ajuste fino completo solo en GPU: pesos bf16, sin adaptador. El límite consciente de la tarjeta es de 6B en 32 GB. |
+| **Clase 7B** (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | `mode="full" --full-ft-offload` | **Ajuste fino completo mediante la descarga a la CPU FSDP2:** descarga los parámetros y el optimizador a 64 GB de RAM del host. Más lento (limitado por el ancho de banda); Linux/WSL2. |
 
-`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`.
+Dos cosas para las que la mayoría de las bibliotecas de una sola GPU te dirigen a otro lugar: **QLoRA de 24–34B** y **ajuste fino completo en una sola tarjeta de la clase 7B**. Backpropagate lo hace en una sola tarjeta de consumo y, luego, exporta el resultado directamente a Ollama.
 
-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.
+**El límite del ajuste fino completo es consciente de la tarjeta.** Se deriva de la aritmética de memoria de entrenamiento de 4 sumandos (pesos + gradientes + optimizador + activaciones) en relación con tu VRAM *detectada*: **16 GB → 4B, 24 GB → 5B, 32 GB → 6B** solo en GPU. `--full-ft-offload` lo amplía a la **clase 7B** descargando los parámetros y el estado del optimizador a la RAM del host mediante FSDP2 `fully_shard` + `CPUOffloadPolicy` (más lento, limitado por el ancho de banda PCIe/CPU; requiere ~64 GB de RAM del host y un backend NCCL, es decir, Linux/WSL2). Anula explícitamente el límite con `--full-ft-ceiling-billions`. Un modelo que supere incluso el límite de descarga finalizará con `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, indicando la solución (`--full-ft-offload` o LoRA/QLoRA). Consulta [la página completa del manual de ajuste fino](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) para ver las matemáticas de VRAM y la comparación de calidad de Biderman 2024 / Thinking Machines 2025.
 
-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).
+### Se adapta a 16 GB
+
+El rango de 16 GB (RTX 4080 / 5080 / 4070 Ti Super) sigue siendo excelente: QLoRA de 7B en ~7–8 GB y un verdadero ajuste fino completo de un modelo genuino de ~3B (SmolLM3-3B, Qwen2.5-3B, Llama-3.2-3B/1B) dentro de 16 GB mediante `mode="full"` (pesos bf16 + checkpointing de gradiente + paged 8-bit AdamW). El mismo código selecciona el tamaño del lote y el límite de ajuste fino completo que se ajustan a la tarjeta que detecta; no hay opciones para cambiar entre equipos.
+
+La cuantización de 2 bits (AQLM / QuIP#) queda **fuera del alcance**: una base de 2 bits no se puede fusionar limpiamente con los pesos de precisión completa, lo que interrumpe el contrato de adaptador fusionable → GGUF → Ollama (el objetivo principal de la canalización). En su lugar, Backpropagate ofrece las opciones: QLoRA, `mode="full"`, `--full-ft-offload` y la ruta de cálculo FP8 (`--fp8`, Blackwell/Hopper); todas ellas siguen siendo fusionables y exportables.
 
 ## Para lo que NO sirve Backpropagate
 
 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 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.
+- **Ajuste fino con todos los parámetros más allá del límite de descarga (≈13B+)** — Propague hacia atrás ajustes finos completos hasta **~6B en GPU pura y ~7B mediante `--full-ft-offload`** en una tarjeta de 32 GB (vea [el rango](#qué-puede-ajustar-en-una-sola-GPU)). Un ajuste fino *verdaderamente completo* de un modelo de 13B+ va más allá de eso; requiere FSDP multi-GPU o una tarjeta más grande (utilice `transformers.Trainer` en varias GPU, o alquile una A100/H100). Sin embargo, antes de invertir esos recursos computacionales: 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 aproximadamente el 67% de los recursos computacionales; por lo tanto, QLoRA hasta 34B, que Backpropagate realiza en una sola tarjeta, no pierde nada para el trabajo que la mayoría de los usuarios realmente desean.
+- **RL en línea: PPO / GRPO / RLVR** — Backpropagate realiza un ajuste fino SFT de una sola etapa más un ajuste de preferencias sin referencia (ORPO en v1.5; SimPO + KTO en v1.6). Lo que *no* hace es el aprendizaje por refuerzo en línea: PPO, GRPO o RLVR, lo cual requiere un modelo de recompensa o un ciclo de generación y puntuación además del paso de entrenamiento. Para estos casos, utilice TRL directamente o LLaMA-Factory. (El ajuste de preferencias sin referencia se ajusta al rango de una sola etapa porque no hay un modelo de referencia separado que mantener en la memoria; vea la nota sobre ORPO en [Inicio rápido](#inicio-rápido)).
+- **Entrenamiento multi-nodo** — solo GPU única en una máquina. El uso de varias GPU en una misma máquina funciona (mediante `accelerate launch`), pero no está oficialmente soportado.
+- **Entrenamiento en macOS con CUDA** — Apple Silicon no tiene CUDA, por lo que la ruta de CUDA se ejecuta en un equipo Linux o Windows con una GPU NVIDIA. Aún puede ejecutar el modelo entrenado en un Mac a través de Ollama. Una ruta MLX **experimental y sin verificar** (`--backend mlx`) entrena un adaptador LoRA de forma nativa en Apple Silicon; vea [Apple Silicon (MLX)](#apple-silicon-mlx--vista-previa-sin-verificar). Solo es para LoRA-SFT y **no ha sido verificado en hardware real** (sin soporte), por lo que, para cualquier cosa más allá de un LoRA SFT (ORPO, ajuste fino completo, FP8, ejecución múltiple), utilice la ruta CUDA.
+- **Cualquier modelo fuera de las familias 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 de CI.
 
 Si necesita alguna de estas cosas, utilice una de las bibliotecas enumeradas anteriormente. Son mejores para ello.
 
@@ -174,7 +179,9 @@ La tasa de aprendizaje predeterminada se reduce automáticamente a `8e-6` para O
 
 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
+### Apple Silicon (MLX) — vista previa sin verificar
+
+> ⚠️ **Vista previa sin verificar: no forma parte del conjunto de funciones compatibles.** La ruta MLX se construye y se prueba a nivel de unidad, pero **no** ha sido verificada en hardware Apple Silicon real (`mlx-lm` solo es para Apple y no puede ejecutarse en los equipos NVIDIA en los que se desarrolla Backpropagate). Considere todo lo siguiente como experimental, úselo bajo su propio riesgo y [informe sobre cualquier anomalía](#informar-sobre-errores) si lo ejecuta en un Mac de la serie M.
 
 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.
 
@@ -192,7 +199,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 En v1.5, la vía MLX es **solo LoRA SFT**; no hay ORPO, no hay FP8, no hay `mode='full'`, no hay ejecución múltiple en MLX todavía (cada una se rechaza con `CONFIG_INVALID_SETTING`; use `backend='cuda'`/`'auto'` en un sistema NVIDIA para esas opciones). El adaptador resultante es un archivo safetensors simple y se exporta a Ollama a través de la misma ruta que la vía CUDA.
 
-> ⚠️ **Estado actual:** la implementación MLX incluida en la versión 1.5 está **construida y probada unitariamente (simulada)**, pero **aún no se ha verificado con pruebas reales en hardware Apple Silicon**; `mlx-lm` solo funciona en dispositivos Apple y no se pudo ejecutar en el equipo NVIDIA donde se desarrolló este código. Trátelo como experimental, al igual que la ruta FP8 en la versión 1.5 (FP8 pasó a la fase de verificación con pruebas reales en Blackwell en la versión 1.6; MLX aún necesita esa fase en hardware real); por favor, [informe sobre cualquier anomalía](#reporting-bugs) una vez que se ejecute en un Mac de la serie M. Forzar `--backend mlx` en un host que no sea Apple genera el error `CONFIG_INVALID_SETTING`; la falta de las herramientas `mlx_lm` en un Mac genera el error `DEP_MLX_UNAVAILABLE`.
+> Forzar `--backend mlx` en un host que no sea Apple genera el error `CONFIG_INVALID_SETTING`; la falta de una cadena 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/).
 
@@ -364,8 +371,12 @@ Las claves anidadas utilizan doble guion bajo (`MODEL__NAME`, no `MODEL_NAME`).
 | 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. |
+| Llama-3.1-8B | ~7-8 GB (QLoRA) | Llama-3.1-Community | 8B QLoRA, 128K de contexto nativo (la cláusula de >700M de usuarios activos mensuales requiere una licencia Meta separada). |
+| **Qwen2.5-14B** | ~8.5 GB (QLoRA) | Apache 2.0 | **El punto óptimo para el uso diario con 32 GB** — rango/alfa 32, AdamW de 8 bits paginado, 4096 ctx. |
+| Mistral-Small-24B | ~18 GB (QLoRA) | Apache 2.0 | 24B QLoRA en una tarjeta de 32 GB con margen de 4096 ctx. |
+| **Qwen2.5-32B** | ~26 GB (QLoRA) | Apache 2.0 | **Límite superior del rango de 32 GB** — apenas cabe con `max_len 2048` + AdamW de 8 bits paginado. |
 
-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.
+Otros modelos a menudo funcionan; las filas anteriores son los ajustes preestablecidos seleccionados: el nivel de 14B–32B está ajustado con QLoRA para una tarjeta de 32 GB (el rango medido). Utilice `--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 de rango 16 / q+v heredado si necesita la huella de v1.2.x.
 
 ## Solución de problemas
 

package/README.fr.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>
 
-# Entraînez un adaptateur. Envoyez-le à Ollama. Passez à autre chose
+# Ajustez finement un modèle QLoRA de 32 milliards de paramètres ou un modèle complet de 7 milliards de paramètres sur une seule carte graphique (GPU). Déployez-le sur Ollama
 
-Backpropagate est une bibliothèque Python pour affiner les grands modèles de langage sur une seule GPU. Trois lignes de code suffisent pour entraîner un modèle de 7 milliards de paramètres sur une carte de 16 Go. Une commande supplémentaire l'exporte vers Ollama afin que vous puissiez exécuter votre modèle affiné avec `ollama run`. Fonctionne parfaitement sous Windows.
+Effectuez une rétropropagation pour ajuster finement les grands modèles de langage sur une **seule** carte graphique, dimensionnée en fonction de la carte dont vous disposez réellement. Trois lignes de code Python pour un modèle QLoRA de 7 à 34 milliards de paramètres sur une seule carte grand public de 32 Go (RTX 5090) ; un seul indicateur — `--full-ft-offload` — permet d’effectuer un ajustement fin complet d’un modèle de classe 7B en déplaçant l’état de l’optimiseur vers la mémoire vive de l’hôte. Une commande supplémentaire exporte les données vers Ollama, puis `ollama run` lance votre modèle affiné. L’opération est facilement adaptable pour fonctionner avec une carte de 16 Go. Performances optimales sous Windows.
 
 ```python
 from backpropagate import Trainer
@@ -69,33 +69,38 @@ Backpropagate est l'option manquante : une API Python en 3 lignes pour les uti
 
 Si vous avez essayé l'une des bibliothèques ci-dessus et que vous avez été rebuté par la complexité de la configuration, ou que vous avez rencontré un problème de compatibilité avec une famille de modèles, ou que vous souhaitiez des paramètres par défaut optimisés pour Windows, Backpropagate est fait pour vous.
 
-## Ce que vous pouvez affiner sur une GPU grand public de 16 Go
+## Ce que vous pouvez ajuster finement sur une seule carte graphique
 
-Voici les limites pratiques sur une carte de 16 Go (RTX 4080 / 5080 / 4070 Ti Super) :
+La rétropropagation adapte l’exécution à votre carte. Voici les limites pratiques sur une carte graphique grand public de **32 Go** (RTX 5090) avec 64 Go de mémoire vive : c’est la configuration sur laquelle elle est optimisée :
 
-| Modèle | Méthode | État |
+| Taille du modèle | Méthode | État sur une carte de 32 Go |
 |---|---|---|
-| Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | Facile. Longueur de séquence complète, beaucoup de marge. |
-| SmolLM3-3B / Qwen2.5-3B / Llama-3.2-3B / Llama-3.2-1B | `mode="full"` (affinement complet) | v1.4 : passez `--mode=full` dans `backprop train` ou `Trainer(..., mode="full")`. Charge les poids en pleine précision (bf16) ; pas de 4 bits, pas d'adaptateur ; le contrôle de gradient et l'Adam paginé à 8 bits permettent de maintenir l'empreinte dans les 16 Go. |
-| Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | Standard. Environ 7 à 8 Go. Paramètres par défaut de Backpropagate. |
-| Llama-3 13B | QLoRA + échantillonnage par lots | Difficile, mais fonctionne. Utilisez des séquences plus courtes. |
-| Mixtral 8x7B (47 milliards de paramètres au total) | — | Hors de portée : la quantification à 2 bits (AQLM / QuIP#) rompt le contrat d'adaptateur fusionnable + exportation GGUF, elle a donc été abandonnée dans le [bref aperçu de la trajectoire v1.5](docs/V1_5_BRIEF.md). Sur une carte de 16 Go, utilisez une base ≤8 milliards de paramètres. |
+| 7B (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | QLoRA | Facile — environ 7 à 8 Go. Longueur de séquence complète, beaucoup de marge. |
+| **14B** (Qwen2.5-14B) | QLoRA | **La configuration idéale pour une utilisation quotidienne — environ 8,5 Go**, mesuré. Rang/alpha 32, paged 8-bit AdamW, 4096 ctx. |
+| 24B (Mistral-Small-24B) | QLoRA | Environ 18 Go. S’adapte avec une marge à 4096 ctx. |
+| **32B** (Qwen2.5-32B) | QLoRA | **S’adapte tout juste — environ 26 Go** avec `max_len 2048` + paged 8-bit AdamW. Limite supérieure. |
+| ≤6B | `mode="full"` (affinement complet) | Ajustement fin complet sur GPU uniquement — poids bf16, pas d’adaptateur. La limite tenant compte de la carte est de 6 milliards de paramètres sur une carte de 32 Go. |
+| **Modèle de classe 7B** (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | `mode="full" --full-ft-offload` | **Ajustement fin complet via FSDP2 avec déchargement sur le CPU** — les paramètres et l’optimiseur sont transférés vers la mémoire vive de l’hôte (64 Go). Plus lent (limité par la bande passante) ; Linux/WSL2. |
 
-`mode="full"` prend en charge les modèles jusqu'à **4 milliards de paramètres**. Les quatre préréglages de la ligne d'affinement complet ci-dessus sont authentiques (nombre réel de paramètres de 3,08 à 3,24 milliards) et s'adaptent à une carte de 16 Go. La classe de 3,8 à 4 milliards de paramètres (Phi-4-mini-3.8B, Qwen-3.5-4B) est également acceptée, mais nécessite une carte de **24 Go ou plus** pour un affinement complet : les poids et les gradients seuls atteignent presque 16 Go avant l'optimiseur et les activations, de sorte qu'une carte de 16 Go doit utiliser `mode="lora"` pour ces modèles (ils se trouvent dans la ligne LoRA). Les modèles >4 milliards de paramètres quittent le programme avec `RUNTIME_FULL_FT_MODEL_TOO_LARGE`.
+Deux opérations pour lesquelles la plupart des bibliothèques à carte graphique unique vous renvoient vers d’autres solutions — **QLoRA de 24 à 34 milliards de paramètres** et **ajustement fin complet sur une seule carte de modèle de classe 7B** — Backpropagate effectue ces opérations sur une seule carte grand public, puis exporte le résultat directement vers Ollama.
 
-La quantification à 2 bits (AQLM / QuIP#) est **hors de portée**. Elle a été envisagée pour la version 1.4, puis abandonnée dans le [bref aperçu de la trajectoire v1.5](docs/V1_5_BRIEF.md) : une base à 2 bits ne peut pas être proprement réintégrée dans des poids en pleine précision, ce qui rompt le contrat d'adaptateur fusionnable → GGUF → Ollama (le but de la chaîne de traitement). Les leviers de marge que Backpropagate propose sont le **chemin de calcul FP8** (v1.5, `--fp8`, Blackwell/Hopper) et `mode="full"` pour les modèles ≤4 milliards de paramètres : les deux restent fusionnables et exportables.
+**La limite pour l’ajustement fin complet tient compte de la carte.** Elle est dérivée du calcul de la mémoire d’entraînement à quatre termes (poids + gradients + optimiseur + activations) par rapport à votre VRAM *détectée* : **16 Go → 4 milliards, 24 Go → 5 milliards, 32 Go → 6 milliards** sur GPU uniquement. `--full-ft-offload` augmente cette limite à **modèle de classe 7B** en déplaçant les paramètres et l’état de l’optimiseur vers la mémoire vive via FSDP2 `fully_shard` + `CPUOffloadPolicy` (plus lent, limité par la bande passante PCIe/CPU ; nécessite environ 64 Go de mémoire vive et une implémentation NCCL, c’est-à-dire Linux/WSL2). Définissez explicitement la limite avec `--full-ft-ceiling-billions`. Un modèle dépassant même la limite du déchargement se termine par `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, en indiquant la solution ( `--full-ft-offload` ou LoRA/QLoRA). Consultez [la page complète sur l’ajustement fin](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) pour les calculs de la VRAM et la comparaison de qualité Biderman 2024 / Thinking Machines 2025.
 
-Pour les modèles de 3 milliards de paramètres et moins, l'affinement complet (et non seulement LoRA) est possible sur 16 Go et est désormais disponible dans la version 1.4 sous la forme `mode="full"`. Passez `Trainer(..., mode="full")` ou `backprop train --mode=full --model phi-4-mini-3.8b` pour l'activer. Une barrière stricte refuse le mode pour les modèles > 4 milliards de paramètres avec `RUNTIME_FULL_FT_MODEL_TOO_LARGE`, en indiquant LoRA + les préréglages inférieurs à 4 milliards de paramètres comme options de secours. Consultez [la page du guide complet sur l'affinement](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) pour les calculs de configuration et la comparaison de la qualité de Biderman 2024 / Thinking Machines 2025. Pour les modèles de 7 milliards de paramètres et plus, l'affinement complet nécessite une GPU de 24 Go ou plus : envisagez de louer une A100 dans le cloud, ou utilisez LoRA, ce qui, selon les recherches récentes, correspond à la qualité de l'affinement complet pour la plupart des tâches post-entraînement (voir [la section anti-argumentaire](#what-backpropagate-is-not-for) pour les références).
+### S’adapte à une carte de 16 Go
+
+La limite d’une carte de 16 Go (RTX 4080 / 5080 / 4070 Ti Super) reste optimale : QLoRA de 7B à environ 7–8 Go, et véritable ajustement fin complet d’un modèle authentique d’environ 3 milliards de paramètres (SmolLM3-3B, Qwen2.5-3B, Llama-3.2-3B/1B) dans les 16 Go via `mode="full"` (poids bf16 + contrôle des gradients + paged 8-bit AdamW). Le même code sélectionne la taille du lot et la limite de l’ajustement fin complet qui s’adaptent à la carte détectée, sans indicateurs à modifier entre les configurations.
+
+La quantification sur 2 bits (AQLM / QuIP#) est **hors de portée** — une base quantifiée sur 2 bits ne peut pas être fusionnée proprement avec des poids en pleine précision, ce qui rompt le contrat d’adaptateur fusionnable → GGUF → Ollama (le but principal du processus). Les leviers que Backpropagate propose à la place — QLoRA, `mode="full"`, `--full-ft-offload` et le chemin de calcul FP8 (`--fp8`, Blackwell/Hopper) — restent fusionnables et exportables.
 
 ## Ce que Backpropagate NE permet PAS
 
 Si votre cas d'utilisation est l'un des suivants, vous obtiendrez de meilleurs résultats avec une autre bibliothèque : Backpropagate n'est pas le bon choix et essayer de le faire fonctionner coûterait plus cher que de simplement utiliser l'outil approprié. La lecture de cette section avant de commencer vous évitera de devoir installer et abandonner :
 
-- **Affinage complet des paramètres des modèles 7B+** — Backpropagate utilise LoRA/QLoRA, ce qui entraîne un petit adaptateur plutôt que de mettre à jour tous les poids. Pour les modèles 7B et plus, l’affinage complet nécessite 24 Go ou plus de mémoire GPU et ne peut pas être effectué sur une carte grand public de 16 Go. Pour les modèles 3B et moins, l’affinage complet est possible avec 16 Go et est disponible dans la version 1.4 sous la forme `mode="full"` (passez `Trainer(..., mode="full")` ou `--mode=full` dans l’interface en ligne de commande ; une restriction stricte déclenche `RUNTIME_FULL_FT_MODEL_TOO_LARGE` pour les modèles > 4B et nomme LoRA + les préréglages inférieurs à 4B comme solutions de repli). 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, correspond à la qualité de l’affinage complet pour la plupart des tâches post-entraînement (suivi des instructions, adaptation au domaine, personnalité/style) avec 67 % de la puissance de calcul. Ainsi, pour le travail que la plupart des utilisateurs souhaitent effectuer, vous ne perdez rien en vous en tenant à LoRA. `mode="full"` existe pour les cas où vous avez mesuré une différence de qualité et décidé d’investir davantage de puissance de calcul. Si vous avez réellement besoin d’un affinage complet d’un modèle 7B+, utilisez directement HuggingFace `transformers.Trainer` sur une carte de 24 Go ou plus.
-- **Apprentissage par renforcement en ligne — PPO / GRPO / RLVR** — Backpropagate effectue un affinage supervisé en une seule étape, plus un affinage des préférences sans référence (ORPO est disponible dans la version 1.5 ; SimPO/KTO sont prévus). Ce que Backpropagate ne fait *pas*, c’est l’apprentissage par renforcement en ligne — PPO, GRPO ou RLVR — qui nécessite un modèle de récompense ou une boucle de génération et d’évaluation en plus de l’étape d’entraînement. Pour ces derniers, utilisez TRL ou LLaMA-Factory directement. (L’affinage des préférences sans référence s’intègre dans l’enveloppe d’une seule étape, car il n’y a pas de modèle de référence distinct à conserver en mémoire ; voir la note sur ORPO dans [Démarrage rapide](#quick-start).)
-- **Entraînement multi-nœuds** — 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 macOS sur le système CUDA** — Apple Silicon n’a pas CUDA, donc le chemin CUDA doit s’exécuter 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. **Nouveau dans la version 1.5 :** un système MLX expérimental (`--backend mlx`) entraîne un adaptateur LoRA de manière native sur Apple Silicon — voir [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15). Il est limité à LoRA-SFT et a été mis en œuvre, mais pas encore validé sur du matériel réel. Par conséquent, pour tout ce qui dépasse un LoRA SFT (ORPO, affinage complet, FP8, exécution multiple), vous devriez toujours utiliser le système CUDA.
-- **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 pris en charge dans les tests d’intégration continue.
+- **Affinement complet des paramètres au-delà du seuil de déchargement (≈13B+)** — Effectuer une rétropropagation d’un affinement complet jusqu’à **~6 Go de GPU pur et ~7 Go via `--full-ft-offload`** sur une carte de 32 Go (voir [l’enveloppe](#what-you-can-fine-tune-on-one-gpu)). Un affinement *véritablement complet* d’un modèle de 13B+ dépasse cette limite : il nécessite un FSDP multi-GPU ou une carte plus grande (utiliser `transformers.Trainer` sur plusieurs GPU, ou louer une A100/H100). Avant de dépenser ces ressources de calcul, cependant : 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 correcte, offre une qualité d’affinement comparable à celle de l’affinement complet pour la plupart des tâches post-entraînement (suivi des instructions, adaptation au domaine, personnalité/style) en utilisant environ 67 % des ressources de calcul. Ainsi, QLoRA jusqu’à 34B, ce que Backpropagate effectue sur une seule carte, ne présente aucun inconvénient pour les tâches que la plupart des utilisateurs souhaitent effectuer.
+- **Apprentissage par renforcement en ligne — PPO / GRPO / RLVR** — Backpropagate effectue un affinement SFT en une seule étape, ainsi qu’un ajustement de préférence sans référence (ORPO dans v1.5 ; SimPO + KTO dans v1.6). Ce que cela ne fait *pas*, c’est l’apprentissage par renforcement en ligne — PPO, GRPO ou RLVR —, qui nécessite un modèle de récompense ou une boucle de génération et d’évaluation en plus de l’étape d’entraînement. Pour ces cas, utilisez TRL directement ou LLaMA-Factory. (L’ajustement de préférence sans référence correspond à l’enveloppe d’une seule étape car il n’y a pas de modèle de référence distinct à conserver en mémoire ; voir la note sur ORPO dans [Quick Start](#quick-start).)
+- **Entraînement multi-nœuds** — un seul 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 macOS avec CUDA** — Apple Silicon ne dispose pas de CUDA, donc le chemin CUDA s’exécute sur une machine Linux ou Windows dotée d’un GPU NVIDIA. Vous pouvez toujours exécuter le modèle entraîné sur un Mac via Ollama. Un rail MLX **expérimental et non vérifié** (`--backend mlx`) entraîne un adaptateur LoRA de manière native sur Apple Silicon — voir [Apple Silicon (MLX)](#apple-silicon-mlx--unverified-preview). Il n’effectue qu’un affinement SFT avec LoRA et **n’a pas été vérifié en conditions réelles** (pas de prise en charge), donc pour tout ce qui dépasse un affinement SFT avec LoRA (ORPO, affinement complet, FP8, exécution multiple), vous devez utiliser le rail CUDA.
+- **Tout modèle autre que ceux testés** — 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 CI.
 
 Si vous avez besoin de l’une de ces fonctionnalités, utilisez l’une des bibliothèques répertoriées ci-dessus. Elles sont plus performantes dans ce domaine.
 
@@ -145,7 +150,7 @@ Cela entraîne un adaptateur Qwen 2.5 7B sur 5 courtes conversations au format
 
 Les formats Alpaca (`instruction` / `output`), OpenAI chat (`messages`) et texte brut fonctionnent également — Backpropagate détecte automatiquement le format.
 
-### Réglage des préférences (ORPO, SimPO, KTO)
+### Ajustement de préférence (ORPO, SimPO, KTO)
 
 Nouveau dans la version 1.5 : entraînez-vous sur des préférences au lieu de simples démonstrations. ORPO est sans référence et en une seule étape — il intègre le signal de préférence dans l’étape d’affinage supervisé, il n’y a donc pas de modèle de récompense ou de référence distinct et la forme en 3 lignes reste la même. Passez `--method orpo` (CLI) ou `method="orpo"` (Python) et fournissez un ensemble de données de lignes `{prompt, chosen, rejected}` (ou simplement `{chosen, rejected}` :
 
@@ -166,15 +171,17 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-Le taux d’apprentissage par défaut est automatiquement réduit à `8e-6` pour ORPO (la perte est plus marquée que dans le cas de SFT simple) ; réglez `--orpo-beta` (par défaut `0.1`) pour pondérer la pénalité du rapport de cotes. ORPO utilise uniquement `mode="lora"`.
+Le taux d’apprentissage par défaut diminue automatiquement à `8e-6` pour ORPO (la perte est plus marquée que pour un simple SFT) ; ajustez `--orpo-beta` (par défaut `0.1`) pour pondérer la pénalité du rapport de cotes. ORPO utilise uniquement le mode `"lora"`.
 
-**Nouveauté dans la version 1.6 : SimPO et KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) ne nécessite pas de données de référence et utilise une récompense normalisée en fonction de la longueur, tout en utilisant les mêmes données appariées `{prompt, chosen, rejected}` qu’ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) utilise des données **non appariées** `{prompt, completion, label}` — évaluation positive/négative par exemple — pour la vaste catégorie de commentaires qui ne sont pas des paires A/B sélectionnées ; il équilibre automatiquement les poids de perte souhaitables/indésirables en fonction du nombre d’étiquettes. Les deux utilisent uniquement `mode="lora"` et restent dans l’enveloppe SFT sur une seule GPU (pas de modèle de référence distinct). Consultez le [guide de réglage des préférences](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) pour savoir lequel utiliser. Pour l’apprentissage par renforcement en ligne (PPO/GRPO), consultez [Ce que Backpropagate n’est PAS](#what-backpropagate-is-not-for).
+**Nouveauté dans v1.6 — SimPO et KTO.** `--method simpo` ([Meng et al. 2024](https://arxiv.org/abs/2405.14734)) est sans référence, avec une récompense normalisée en fonction de la longueur, et utilise les mêmes données appariées `{prompt, chosen, rejected}` que ORPO (`--simpo-beta`, `--simpo-gamma`). `--method kto` ([Ethayarajh et al. 2024](https://arxiv.org/abs/2402.01306)) utilise des données **non appariées** `{prompt, completion, label}` — évaluations positives/négatives par exemple — pour la vaste classe de commentaires qui ne sont pas des paires A/B organisées ; il équilibre automatiquement les pondérations de perte souhaitables/indésirables en fonction du nombre d’étiquettes. Les deux utilisent uniquement le mode `"lora"` et restent dans l’enveloppe SFT avec un seul GPU (pas de modèle de référence distinct). Consultez le [manuel sur l’ajustement de préférence](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) pour savoir lequel utiliser. Pour l’apprentissage par renforcement en ligne (PPO/GRPO), consultez [Ce que Backpropagate ne permet PAS](#what-backpropagate-is-not-for).
 
 ### SFT avec suivi du raisonnement (distillation R1)
 
 Nouveau dans la version 1.5 : distillez un modèle de raisonnement de manière simple. Utilisez `--reasoning-trace` (CLI) ou `Trainer(..., reasoning_trace=True)` (Python) et fournissez-lui des données qui conservent une chaîne de pensée `<think>...</think>` dans les interactions de l’assistant — la moitié SFT pure de la distillation de [DeepSeek-R1](https://arxiv.org/abs/2501.12948), sans apprentissage par renforcement requis. La rétropropagation conserve `<think>` dans l’objectif d’entraînement, supprime les données vides ou trop longues (filtrage de la longueur des données) et augmente la valeur par défaut de `max_seq_length` à 8192 pour la chaîne de pensée plus longue. Il est essentiel que `<think>` reste du **texte brut** — aucun jeton spécial, aucun redimensionnement de l’intégration — de sorte que le GGUF fusionné puisse toujours être exporté vers Ollama comme tout autre modèle affiné. Uniquement SFT. Consultez la [recette reasoning-trace](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/#reasoning-trace-sft-r1-distillation) pour la forme de l’ensemble de données et les jetons ajustables.
 
-### Apple Silicon (MLX) — expérimental, version 1.5
+### Apple Silicon (MLX) — aperçu non vérifié
+
+> ⚠️ **Aperçu non vérifié — ne fait pas partie de l’ensemble des fonctionnalités prises en charge.** Le rail MLX est construit et testé avec des tests unitaires, mais n’a **pas** été vérifié en conditions réelles sur Apple Silicon (mlx-lm est spécifique à Apple et ne peut pas s’exécuter sur les machines NVIDIA sur lesquelles Backpropagate est développé). Considérez tout ce qui suit comme expérimental, utilisez-le à vos propres risques et [signalez les anomalies](#reporting-bugs) si vous l’exécutez sur un Mac de la série M.
 
 Nouveau dans la version 1.5 : **une API, deux options.** CUDA reste le backend canonique et vérifié ; MLX est une deuxième option qui entraîne sur un Mac de la série M via la chaîne d’outils [`mlx_lm.lora`](https://github.com/ml-explore/mlx-lm) d’Apple (mémoire unifiée, pas de CUDA). La même structure en 3 lignes sélectionne l’option en fonction du matériel — `backend='auto'` (par défaut) redirige vers CUDA sur NVIDIA et vers MLX sur Apple Silicon, de sorte que les configurations CUDA existantes sont identiques au niveau des octets.
 
@@ -192,7 +199,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 Dans la version 1.5, l’option MLX est **uniquement LoRA SFT** — pas d’ORPO, pas de FP8, pas de `mode='full'`, pas d’exécution multiple sur MLX pour le moment (chacune est rejetée avec `CONFIG_INVALID_SETTING` ; utilisez `backend='cuda'`/`'auto'` sur une machine NVIDIA pour ces options). L’adaptateur résultant est un simple fichier safetensors et est exporté vers Ollama via le même chemin que l’option CUDA.
 
-> ⚠️ **État actuel :** la version MLX incluse dans la v1.5 est **intégrée et testée (avec des simulations)**, mais **n’a pas encore été validée sur du matériel Apple Silicon réel**. `mlx-lm` est uniquement compatible avec Apple et n’a pas pu être exécuté sur le système NVIDIA utilisé pour sa création. Considérez-la comme expérimentale — la même approche a été utilisée pour le chemin FP8 dans la v1.5 (FP8 a ensuite été validé sur Blackwell dans la v1.6 ; MLX doit encore passer cette étape sur du matériel réel) — et veuillez [signaler les anomalies](#reporting-bugs) une fois qu’elle sera exécutée sur un Mac de la série M. Forcer `--backend mlx` sur un hôte non Apple génère l’erreur `CONFIG_INVALID_SETTING` ; l’absence de la chaîne d’outils `mlx_lm` sur un Mac provoque l’erreur `DEP_MLX_UNAVAILABLE`.
+> Forcer `--backend mlx` sur un hôte non Apple génère une erreur `CONFIG_INVALID_SETTING` ; l’absence d’une chaîne d’outils `mlx_lm` sur un Mac déclenche `DEP_MLX_UNAVAILABLE`.
 
 Pour des flux de travail de bout en bout plus complets (affiner et pousser vers HF-Hub, reprendre après une erreur de mémoire, SLAO multi-exécution sur une longue campagne, etc.), consultez la [page des recettes du manuel](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/).
 
@@ -305,7 +312,7 @@ Les écritures dans le système de fichiers à partir de l’interface utilisate
 
 **Configuration requise :** Python 3.10+ ; GPU CUDA (8 Go ou plus de VRAM) ; PyTorch 2.0+
 
-Python 3.10 est pris en charge jusqu’à au moins la v1.6 ; sa prise en charge par le fournisseur initial prendra fin en octobre 2026 et il est prévu de le supprimer dans la première version après cette date. Pour les nouvelles installations, privilégiez Python 3.11 ou 3.12 — 3.11 est la version la plus testée.
+Python 3.10 est pris en charge jusqu’à au moins la version 1.6 ; il atteindra sa fin de vie en octobre 2026 et sera supprimé dans la première version après cette date. Pour les nouvelles installations, préférez Python 3.11 ou 3.12 — 3.11 est la version la plus testée.
 
 Backpropagate gère les particularités de l’exécution de l’entraînement sur différentes plateformes, mais il ne peut pas résoudre les problèmes survenant lors de l’installation. Les deux problèmes les plus courants sont les suivants :
 
@@ -364,8 +371,12 @@ Les clés imbriquées utilisent un double soulignement (`MODEL__NAME`, et non `M
 | Llama 3.2 3B | ~8 Go | Llama Community | Alternative solide à Qwen 3B avec des réserves permissives. |
 | Llama 3.2 1B | ~6 Go | Llama Community | Pour des expériences rapides sur des cartes de petite taille. |
 | Mistral 7B | ~12 Go | Apache 2.0 | Comparable à Qwen 7B, modèle de chat différent. |
+| Llama-3.1-8B | ~7 à 8 Go (QLoRA) | Llama-3.1-Community | 8B QLoRA, contexte natif de 128 k (la clause des >700 millions d’utilisateurs actifs mensuels nécessite une licence Meta distincte). |
+| **Qwen2.5-14B** | ~8,5 Go (QLoRA) | Apache 2.0 | **Le point idéal pour un usage quotidien avec 32 Go** — rang/alpha 32, AdamW à 8 bits paginé, 4096 ctx. |
+| Mistral-Small-24B | ~18 Go (QLoRA) | Apache 2.0 | 24B QLoRA sur une carte de 32 Go avec une marge de 4096 ctx. |
+| **Qwen2.5-32B** | ~26 Go (QLoRA) | Apache 2.0 | **Au sommet de l’enveloppe des 32 Go** — s’adapte tout juste à `max_len 2048` + AdamW à 8 bits paginé. |
 
-D’autres modèles fonctionnent souvent, mais seuls ces huit sont pris en charge dans les tests CI. Utilisez l’option `--lora-preset=quality` (valeur par défaut) pour les cibles de rang 256 / entièrement linéaires selon Biderman 2024 + Thinking Machines 2025, ou l’option `--lora-preset=fast` pour la cible héritée de rang 16 / q+v si vous avez besoin de l’empreinte de la version 1.2.x.
+D’autres modèles fonctionnent souvent ; les lignes ci-dessus sont les préréglages organisés — la couche de 14B à 32B est affinée avec QLoRA pour une carte de 32 Go (l’enveloppe mesurée). Utilisez `--lora-preset=quality` (par défaut) pour les cibles de rang 256 / toutes linéaires, comme indiqué dans Biderman 2024 + Thinking Machines 2025, ou `--lora-preset=fast` pour la cible héritée de rang 16 / q+v si vous avez besoin de l’empreinte de v1.2.x.
 
 ## Résolution des problèmes
 

package/README.hi.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>
 
-# एक एडाप्टर को प्रशिक्षित करें। इसे ओलामा में भेजें। आगे बढ़ें।
+# 32B QLoRA या 7B एंड-टू-एंड मॉडल को एक GPU पर फाइन-ट्यून करें। इसे ओलामा में भेजें।
 
-बैकप्रोपैगेट एक पायथन लाइब्रेरी है जिसका उपयोग एकल जीपीयू पर बड़े भाषा मॉडल को ठीक करने के लिए किया जाता है। तीन पंक्तियों के कोड से 16GB कार्ड पर 7B मॉडल को प्रशिक्षित किया जा सकता है। एक और कमांड इसे ओलामा में निर्यात करता है ताकि आप अपने फाइनट्यून को `ollama run` के साथ चला सकें। यह विंडोज पर बेहतरीन तरीके से काम करता है।
+एकल GPU पर बड़े भाषा मॉडलों का फाइन-ट्यूनिंग बैकप्रोपेगेट करें, जो आपके पास मौजूद कार्ड के आकार के अनुसार हो। तीन पंक्तियों वाला पायथन QLoRA एक 7B–34B मॉडल को एक 32 GB उपभोक्ता कार्ड (RTX 5090) पर चलाता है; एक फ़्लैग — `--full-ft-offload` — 7B-क्लास मॉडल का पूर्ण फाइन-ट्यूनिंग करता है, जिसके लिए ऑप्टिमाइज़र स्टेट को होस्ट RAM में भेजा जाता है। एक और कमांड ओलामा में निर्यात करता है, फिर `ollama run` के साथ आपका फाइन-ट्यून चलाता है। यह आसानी से 16 GB तक स्केल हो सकता है। विंडोज पर उत्कृष्ट प्रदर्शन।
 
 ```python
 from backpropagate import Trainer
@@ -69,33 +69,38 @@ LLM को ठीक करने के लिए कई अच्छी ला
 
 यदि आपने ऊपर दी गई लाइब्रेरी में से किसी एक को आज़माया और कॉन्फ़िगरेशन-फ़ाइल समारोह से निराश हो गए, या मॉडल-परिवार की कमी का सामना किया, या विंडोज-प्रथम डिफ़ॉल्ट्स चाहते थे - तो बैकप्रोपैगेट आपके लिए है।
 
-## आप 16GB उपभोक्ता GPU पर क्या ठीक कर सकते हैं
+## आप एक GPU पर क्या फाइन-ट्यून कर सकते हैं।
 
-यहां 16GB कार्ड (RTX 4080 / 5080 / 4070 Ti Super) पर व्यावहारिक सीमा दी गई है:
+बैकप्रोपेगेट आपके कार्ड के अनुसार रन का आकार निर्धारित करता है। यहां 32 GB उपभोक्ता GPU (RTX 5090) और 64 GB होस्ट RAM पर व्यावहारिक सीमा दी गई है — जिस डिवाइस पर इसे ट्यून किया गया है:
 
-| मॉडल | विधि | स्थिति |
+| मॉडल का आकार | विधि | 32 GB कार्ड पर स्थिति |
 |---|---|---|
-| Qwen-3.5-4B / Phi-4-mini-3.8B / SmolLM3-3B | LoRA / QLoRA / DoRA | आरामदायक। पूरी अनुक्रम लंबाई, अतिरिक्त जगह। |
-| SmolLM3-3B / Qwen2.5-3B / Llama-3.2-3B / Llama-3.2-1B | `mode="full"` (पूर्ण फाइन-ट्यूनिंग) | v1.4 - `backprop train` या `Trainer(..., mode="full")` पर `--mode=full` पास करें। पूर्ण-सटीक (bf16) भार लोड करता है - कोई 4-बिट नहीं, कोई एडाप्टर नहीं; ग्रेडिएंट चेकपॉइंटिंग + पेज्ड 8-बिट एडम इसे 16GB के भीतर रखता है। |
-| Qwen-2.5-7B / Llama-3.1-8B / Mistral-7B | QLoRA | मानक। ~7-8 GB। बैकप्रोपैगेट के डिफ़ॉल्ट प्रीसेट। |
-| Llama-3 13B | QLoRA + नमूना पैकिंग | तंग लेकिन काम करता है। कम अनुक्रमों का उपयोग करें। |
-| Mixtral 8x7B (कुल 47B पैरामीटर) | — | दायरे से बाहर - 2-बिट (AQLM / QuIP#) मर्ज करने योग्य-एडाप्टर + GGUF-निर्यात अनुबंध को तोड़ता है, इसलिए इसे [v1.5 प्रक्षेपवक्र संक्षिप्त](docs/V1_5_BRIEF.md) में वापस ले लिया गया। 16GB कार्ड पर, ≤8B बेस का उपयोग करें। |
+| 7B (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | QLoRA | आरामदायक — ~7–8 GB। पूर्ण अनुक्रम लंबाई, बहुत अधिक जगह। |
+| **14B** (Qwen2.5-14B) | QLoRA | **दैनिक उपयोग के लिए सबसे अच्छा — ~8.5 GB**, मापा गया। रैंक/अल्फा 32, पेज किया हुआ 8-बिट AdamW, 4096 ctx। |
+| 24B (Mistral-Small-24B) | QLoRA | ~18 GB। 4096 ctx पर पर्याप्त जगह के साथ फिट बैठता है। |
+| **32B** (Qwen2.5-32B) | QLoRA | **बस फिट बैठता है — ~26 GB**, `max_len 2048` + पेज किया हुआ 8-बिट AdamW पर। सीमा का शीर्ष। |
+| ≤6B | `mode="full"` (पूर्ण फाइन-ट्यूनिंग) | शुद्ध-GPU पूर्ण FT — bf16 वजन, कोई एडाप्टर नहीं। कार्ड-जागरूक सीमा 32 GB पर 6B है। |
+| **7B-क्लास** (Qwen 2.5 7B / Llama-3.1-8B / Mistral 7B) | `mode="full" --full-ft-offload` | **FSDP2 CPU-ऑफलोड के माध्यम से पूर्ण फाइन-ट्यूनिंग** — पैरामीटर + ऑप्टिमाइज़र को 64 GB होस्ट RAM में भेजता है। धीमा (बैंडविड्थ-बाउंड); लिनक्स/WSL2। |
 
-`mode="full"` 4B तक के मॉडल को स्वीकार करता है। ऊपर दी गई पूर्ण-एफटी पंक्ति में चार प्रीसेट वास्तविक ~3B (सत्य पैरामीटर गणना 3.08-3.24B) हैं और 16GB कार्ड पर फिट होते हैं। 3.8-4B वर्ग (Phi-4-mini-3.8B, Qwen-3.5-4B) भी सीमा द्वारा स्वीकार किया जाता है, लेकिन पूर्ण FT के लिए 24GB+ कार्ड की आवश्यकता होती है - भार + ग्रेडिएंट अकेले 16GB तक पहुंचते हैं, इससे पहले कि ऑप्टिमाइज़र और सक्रियण - इसलिए 16GB कार्ड पर उन पर `mode="lora"` का उपयोग करें (वे LoRA पंक्ति में हैं)। 4B से अधिक मॉडल `RUNTIME_FULL_FT_MODEL_TOO_LARGE` के साथ बाहर निकल जाते हैं।
+दो चीजें जिनके लिए अधिकांश एकल-GPU लाइब्रेरी आपको कहीं और भेजती हैं — **24–34B QLoRA** और **एकल-कार्ड 7B-क्लास पूर्ण फाइन-ट्यूनिंग** — बैकप्रोपेगेट इसे एक उपभोक्ता कार्ड पर करता है, फिर परिणाम को सीधे ओलामा में निर्यात करता है।
 
-2-बिट परिमाणीकरण (AQLM / QuIP#) **दायरे से बाहर है।** इसे v1.4 के लिए निर्धारित किया गया था, फिर [v1.5 प्रक्षेपवक्र संक्षिप्त](docs/V1_5_BRIEF.md) में वापस ले लिया गया: 2-बिट बेस को पूर्ण-सटीक भार में साफ-सुथरा तरीके से वापस मर्ज नहीं किया जा सकता है, जो बैकप्रोपैगेट के मर्ज करने योग्य-एडाप्टर → GGUF → ओलामा निर्यात अनुबंध को तोड़ता है (पाइपलाइन का पूरा बिंदु)। इसके बजाय बैकप्रोपैगेट द्वारा भेजे जाने वाले हेडरूम लीवर v1.5 **FP8 कंप्यूट पथ** (`--fp8`, ब्लैकवेल/हॉपर) और ≤4B मॉडल के लिए `mode="full"` हैं - दोनों मर्ज करने योग्य और निर्यात करने योग्य बने रहते हैं।
+**पूर्ण-FT सीमा कार्ड-जागरूक है।** यह आपके *पता लगाए गए* VRAM के विरुद्ध 4-एडेंड प्रशिक्षण-मेमोरी अंकगणित (वजन + ग्रेडिएंट + ऑप्टिमाइज़र + सक्रियण) से प्राप्त होती है: **16 GB → 4B, 24 GB → 5B, 32 GB → 6B** शुद्ध-GPU। `--full-ft-offload` इसे FSDP2 `fully_shard` + `CPUOffloadPolicy` के माध्यम से पैरामीटर + ऑप्टिमाइज़र स्टेट को होस्ट RAM में भेजकर **7B-क्लास** तक बढ़ाता है (धीमा, PCIe/CPU-बैंडविड्थ-बाउंड; लगभग 64 GB होस्ट RAM और एक NCCL बैकएंड की आवश्यकता होती है, यानी लिनक्स/WSL2)। `--full-ft-ceiling-billions` के साथ स्पष्ट रूप से सीमा को ओवरराइड करें। यहां तक कि ऑफलोड सीमा से आगे का मॉडल भी `RUNTIME_FULL_FT_MODEL_TOO_LARGE` के साथ बाहर निकल जाता है, जो रिकवरी (`--full-ft-offload`, या LoRA/QLoRA`) का नाम बताता है। VRAM गणित + बिडरमैन 2024 / थिंकिंग मशीन्स 2025 गुणवत्ता तुलना के लिए [पूर्ण फाइन-ट्यूनिंग हैंडबुक पृष्ठ](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) देखें।
 
-3B और उससे छोटे मॉडल के लिए, 16GB पर पूर्ण फाइन-ट्यूनिंग (केवल LoRA नहीं) संभव है और अब v1.4 में `mode="full"` के रूप में उपलब्ध है। इसे सक्षम करने के लिए `Trainer(..., mode="full")` या `backprop train --mode=full --model phi-4-mini-3.8b` पास करें। एक कठोर गेट > 4B मॉडल के लिए मोड को `RUNTIME_FULL_FT_MODEL_TOO_LARGE` के साथ अस्वीकार करता है, LoRA + 4B से कम प्रीसेट को रिकवरी विकल्पों के रूप में नामित करता है। कॉन्फ़िगरेशन गणित + बिडरमैन 2024 / थिंकिंग मशीन 2025 गुणवत्ता तुलना के लिए [पूर्ण फाइन-ट्यूनिंग हैंडबुक पृष्ठ](https://mcp-tool-shop-org.github.io/backpropagate/handbook/full-fine-tuning/) देखें। 7B+ मॉडल के लिए, पूर्ण फाइन-ट्यूनिंग के लिए 24GB+ GPU की आवश्यकता होती है - A100 क्लाउड रेंटल पर विचार करें, या LoRA के साथ बने रहें, जो हालिया शोध से पता चलता है कि अधिकांश पोस्ट-ट्रेनिंग कार्यों पर पूर्ण फाइन-ट्यूनिंग गुणवत्ता से मेल खाता है (संदर्भ के लिए [एंटी-पिच अनुभाग](#what-backpropagate-is-not-for) देखें)।
+### 16 GB तक स्केल होता है
+
+16 GB सीमा (RTX 4080 / 5080 / 4070 Ti Super) अभी भी उत्कृष्ट है: ~7–8 GB पर 7B QLoRA, और `mode="full"` के माध्यम से 16 GB के भीतर एक वास्तविक ~3B (SmolLM3-3B, Qwen2.5-3B, Llama-3.2-3B/1B) का सच्चा पूर्ण फाइन-ट्यूनिंग (bf16 वजन + ग्रेडिएंट चेकपॉइंटिंग + पेज किया हुआ 8-बिट AdamW)। समान कोड बैच आकार और पूर्ण-FT सीमा को चुनता है जो भी कार्ड फिट बैठता है — डिवाइसों के बीच बदलने के लिए कोई फ़्लैग नहीं।
+
+2-बिट क्वांटाइजेशन (AQLM / QuIP#) **दायरे से बाहर** रहता है — 2-बिट बेस को पूर्ण-सटीक वजन में वापस मर्ज नहीं किया जा सकता है, जिससे मर्ज करने योग्य एडाप्टर → GGUF → ओलामा निर्यात अनुबंध टूट जाता है (पाइपलाइन का पूरा बिंदु)। बैकप्रोपेगेट के पास अन्य सुविधाएँ हैं — QLoRA, `mode="full"`, `--full-ft-offload`, और FP8 कंप्यूट पथ (`--fp8`, ब्लैकवेल/हॉपर`) — ये सभी मर्ज करने योग्य और निर्यात करने योग्य रहते हैं।
 
 ## बैकप्रोपैगेट किसके लिए नहीं है
 
 यदि आपका उपयोग मामला नीचे दिया गया है, तो आपको किसी अन्य लाइब्रेरी के साथ बेहतर अनुभव होगा - बैकप्रोपैगेट सही विकल्प नहीं है और इसे काम करने की कोशिश करने से सही उपकरण तक पहुंचने से अधिक खर्च आएगा। शुरू करने से पहले इस अनुभाग को पढ़ने से इंस्टॉलेशन-और-वापस जाने के चक्र से बचा जा सकता है:
 
-- **7B+ मॉडल का पूर्ण-पैरामीटर फाइन-ट्यूनिंग** — बैकप्रोपगेट LoRA / QLoRA का उपयोग करता है, जो हर वेट को अपडेट करने के बजाय एक छोटे एडाप्टर को प्रशिक्षित करता है। 7B और उससे बड़े मॉडल के लिए, पूर्ण फाइन-ट्यूनिंग के लिए 24GB+ GPU मेमोरी की आवश्यकता होती है और यह 16GB उपभोक्ता कार्ड पर फिट नहीं होता है। 3B और उससे छोटे मॉडल के लिए, पूर्ण फाइन-ट्यूनिंग 16GB पर संभव है और v1.4 में `mode="full"` के रूप में उपलब्ध है (CLI पर `Trainer(..., mode="full")` या `--mode=full` पास करें; एक हार्ड गेट 4B से बड़े मॉडल के लिए `RUNTIME_FULL_FT_MODEL_TOO_LARGE` उत्पन्न करता है और 4B से छोटे मॉडल के लिए LoRA + प्रीसेट को रिकवरी के रूप में नामित करता है)। मुख्य बात: हालिया शोध ([बिडरमैन 2024](https://arxiv.org/abs/2405.09673), [थिंकिंग मशीन्स 2025](https://thinkingmachines.ai/blog/lora/)) दर्शाता है कि सही कॉन्फ़िगरेशन पर LoRA, अधिकांश पोस्ट-ट्रेनिंग कार्यों (निर्देश-अनुपालन, डोमेन अनुकूलन, व्यक्तित्व/शैली) पर पूर्ण फाइन-ट्यूनिंग गुणवत्ता से मेल खाता है, जो 67% कंप्यूट शक्ति का उपयोग करता है — इसलिए, अधिकांश ऑपरेटरों द्वारा वास्तव में वांछित कार्य के लिए, LoRA का उपयोग करने से कोई नुकसान नहीं होता है। `mode="full"` उन मामलों के लिए मौजूद है जहां आपने गुणवत्ता में अंतर मापा है और अतिरिक्त कंप्यूट शक्ति खर्च करने का निर्णय लिया है। यदि आपको वास्तव में 7B+ मॉडल के पूर्ण फाइन-ट्यूनिंग की आवश्यकता है, तो HuggingFace `transformers.Trainer` को सीधे 24GB+ कार्ड पर उपयोग करें।
-- **ऑनलाइन RL — PPO / GRPO / RLVR** — बैकप्रोपगेट सिंगल-स्टेज SFT प्लस संदर्भ-मुक्त प्राथमिकता ट्यूनिंग करता है (ORPO v1.5 में उपलब्ध है; SimPO/KTO की योजना बनाई जा रही है)। यह जो *नहीं* करता है, वह है ऑनलाइन रीइन्फोर्समेंट लर्निंग — PPO, GRPO, या RLVR — जिसके लिए एक इनाम मॉडल या प्रशिक्षण चरण के शीर्ष पर एक पीढ़ी-और-स्कोरिंग लूप की आवश्यकता होती है। उन कार्यों के लिए, TRL या LLaMA-Factory का सीधे उपयोग करें। (संदर्भ-मुक्त प्राथमिकता ट्यूनिंग सिंगल-स्टेज एनवेलप में फिट बैठता है क्योंकि मेमोरी में रखने के लिए कोई अलग संदर्भ मॉडल नहीं है; [क्विक स्टार्ट](#quick-start) के तहत ORPO नोट देखें)।
-- **मल्टी-नोड प्रशिक्षण** — केवल एक मशीन पर एक GPU। एक मशीन पर मल्टी-GPU काम करता है ( `accelerate launch` के माध्यम से) लेकिन आधिकारिक तौर पर समर्थित नहीं है।
-- **CUDA रेल पर macOS प्रशिक्षण** — Apple Silicon में CUDA नहीं है, इसलिए CUDA पथ को NVIDIA GPU वाले Linux या Windows बॉक्स पर चलाना होगा। आप अभी भी प्रशिक्षित मॉडल को Ollama के माध्यम से Mac पर चला सकते हैं। **v1.5 में नया:** एक प्रायोगिक MLX रेल (`--backend mlx`) Apple Silicon पर मूल रूप से LoRA एडाप्टर को प्रशिक्षित करता है — [Apple Silicon (MLX)](#apple-silicon-mlx--experimental-v15) देखें। यह केवल LoRA-SFT है और वास्तविक सिलिकॉन पर बनाया गया है, लेकिन अभी तक पूरी तरह से सत्यापित नहीं है, इसलिए LoRA SFT (ORPO, पूर्ण फाइन-ट्यून, FP8, मल्टी-रन) से परे किसी भी चीज़ के लिए, आप अभी भी CUDA रेल का उपयोग करना चाहेंगे।
-- **परीक्षण किए गए मॉडल परिवारों के बाहर कुछ भी** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B। अन्य मॉडल अक्सर काम करते हैं लेकिन CI में पिन नहीं किए गए हैं।
+- **पूर्ण-पैरामीटर फाइन-ट्यूनिंग, ऑफलोड सीमा से आगे (≈13B+)** — पूर्ण-फाइन-ट्यून को अधिकतम ~6B शुद्ध-GPU और ~7B-क्लास तक `--full-ft-offload` के माध्यम से 32 GB कार्ड पर बैकप्रोपगेट करें (देखें [द एनवेलप](#what-you-can-fine-tune-on-one-gpu))। 13B+ मॉडल का *वास्तविक पूर्ण* फाइन-ट्यून इससे आगे है - इसके लिए मल्टी-GPU FSDP या एक बड़ा कार्ड चाहिए (कई GPU पर `transformers.Trainer` का उपयोग करें, या A100/H100 किराए पर लें)। उस कंप्यूटिंग शक्ति को खर्च करने से पहले: हालिया शोध ([बिडरमैन 2024](https://arxiv.org/abs/2405.09673), [थिंकिंग मशीन्स 2025](https://thinkingmachines.ai/blog/lora/)) दर्शाता है कि सही कॉन्फ़िगरेशन पर LoRA अधिकांश पोस्ट-ट्रेनिंग कार्यों (निर्देश-अनुपालन, डोमेन अनुकूलन, व्यक्तित्व/शैली) पर पूर्ण फाइन-ट्यूनिंग गुणवत्ता से मेल खाता है - लगभग 67% कंप्यूटिंग शक्ति के साथ - इसलिए QLoRA को अधिकतम 34B तक उपयोग करें, जिसे बैकप्रोपगेट एक कार्ड पर करता है, और इससे अधिकांश ऑपरेटरों द्वारा किए जाने वाले कार्यों में कोई कमी नहीं होगी।
+- **ऑनलाइन RL — PPO / GRPO / RLVR** — बैकप्रोपगेट सिंगल-स्टेज SFT प्लस संदर्भ-मुक्त प्राथमिकता ट्यूनिंग (v1.5 में ORPO; v1.6 में SimPO + KTO) करता है। यह जो *नहीं* करता है, वह ऑनलाइन सुदृढीकरण सीखना है - PPO, GRPO या RLVR - जिसके लिए एक इनाम मॉडल या प्रशिक्षण चरण के शीर्ष पर पीढ़ी-और-स्कोरिंग लूप की आवश्यकता होती है। उनके लिए, सीधे TRL या LLaMA-फ़ैक्टरी का उपयोग करें। (संदर्भ-मुक्त प्राथमिकता ट्यूनिंग सिंगल-स्टेज एनवेलप में फिट बैठता है क्योंकि मेमोरी में रखने के लिए कोई अलग संदर्भ मॉडल नहीं है; [क्विक स्टार्ट](#quick-start) के तहत ORPO नोट देखें)।
+- **मल्टी-नोड प्रशिक्षण** — केवल एक मशीन पर एक GPU। एक मशीन पर मल्टी-GPU काम करता है ( `accelerate launch` के माध्यम से), लेकिन आधिकारिक तौर पर समर्थित नहीं है।
+- **CUDA रेल पर macOS प्रशिक्षण** — Apple सिलिकॉन में CUDA नहीं है, इसलिए CUDA पथ NVIDIA GPU वाले Linux या Windows बॉक्स पर चलता है। आप अभी भी प्रशिक्षित मॉडल को Ollama के माध्यम से Mac पर चला सकते हैं। एक **प्रायोगिक, अप्रमाणित-पूर्वावलोकन** MLX रेल (`--backend mlx`) Apple सिलिकॉन पर मूल रूप से LoRA एडाप्टर को प्रशिक्षित करता है - [Apple सिलिकॉन (MLX)](#apple-silicon-mlx--unverified-preview) देखें। यह केवल LoRA-SFT है और **वास्तविक सिलिकॉन पर डॉगफूड-प्रमाणित नहीं** है (कोई समर्थन नहीं), इसलिए LoRA SFT (ORPO, पूर्ण फाइन-ट्यून, FP8, मल्टी-रन) से परे किसी भी चीज़ के लिए आप CUDA रेल चाहते हैं।
+- **परीक्षित मॉडल परिवारों के बाहर कुछ भी** — Qwen 2.5 / 3.5 (7B / 4B), Phi-4-mini-3.8B, SmolLM3-3B, Llama 3.2 (3B / 1B), Mistral 7B। अन्य मॉडल अक्सर काम करते हैं लेकिन CI में पिन नहीं किए जाते हैं।
 
 यदि आपको इनमें से किसी भी चीज़ की आवश्यकता है, तो ऊपर सूचीबद्ध पुस्तकालयों में से किसी एक का उपयोग करें। वे इसमें बेहतर हैं।
 
@@ -145,7 +150,7 @@ trainer.export('gguf', quantization='q4_k_m')
 
 अल्पाका (`instruction` / `output`), OpenAI चैट (`messages`), और कच्चे पाठ प्रारूप भी काम करते हैं — बैकप्रोपगेट प्रारूप का स्वचालित रूप से पता लगाता है।
 
-### वरीयता ट्यूनिंग (ओआरपीओ, सिम्पो, केटीओ)
+### प्राथमिकता ट्यूनिंग (ORPO, SimPO, KTO)
 
 v1.5 में नया: सादे प्रदर्शनों के बजाय प्राथमिकताओं पर प्रशिक्षित करें। ORPO संदर्भ-मुक्त और सिंगल-स्टेज है — यह प्राथमिकता संकेत को SFT चरण में जोड़ता है, इसलिए कोई अलग इनाम या संदर्भ मॉडल नहीं है और 3-लाइन आकार अपरिवर्तित रहता है। `--method orpo` (CLI) या `method="orpo"` (Python) पास करें और `{prompt, chosen, rejected}` (या केवल `{chosen, rejected}`) पंक्तियों के एक डेटासेट को फीड करें:
 
@@ -166,15 +171,17 @@ trainer.export("gguf", quantization="q4_k_m")
 backprop train --data preferences.jsonl --method orpo --steps 100
 ```
 
-ओआरपीओ के लिए डिफ़ॉल्ट लर्निंग दर स्वचालित रूप से घटकर `8e-6` हो जाती है (क्योंकि इसका नुकसान साधारण एसएफटी की तुलना में अधिक तीव्र होता है); ऑड्स-अनुपात दंड को भारित करने के लिए `--orpo-beta` (डिफ़ॉल्ट `0.1`) ट्यून करें। ओआरपीओ केवल `mode="lora"` पर ही काम करता है।
+डिफ़ॉल्ट शिक्षण दर स्वचालित रूप से ORPO के लिए `8e-6` तक कम हो जाती है (हानि साधारण SFT की तुलना में अधिक तीव्र होती है); `--orpo-beta` को ट्यून करें (डिफ़ॉल्ट `0.1`) ताकि ऑड्स-अनुपात दंड को भार दिया जा सके। ORPO केवल `mode="lora"` है।
 
-**v1.6 में नया — सिम्पो और केटीओ।** `--method simpo` ([मेंग एट अल. 2024](https://arxiv.org/abs/2405.14734)) लंबाई-मानकीकृत इनाम के साथ संदर्भ-मुक्त है और ओआरपीओ के समान युग्मित `{prompt, chosen, rejected}` डेटा लेता है (`--simpo-beta`, `--simpo-gamma`)। `--method kto` ([एथयाराज एट अल. 2024](https://arxiv.org/abs/2402.01306)) **युग्मित नहीं** `{prompt, completion, label}` डेटा लेता है — प्रति उदाहरण थंब्स-अप/डाउन — प्रतिक्रिया के उस बड़े वर्ग के लिए जो क्यूरेटेड ए/बी युग्म नहीं हैं; यह आपके लेबल गणनाओं से वांछनीय/अवांछनीय नुकसान भार को स्वचालित रूप से संतुलित करता है। दोनों केवल `mode="lora"` पर ही काम करते हैं और सिंगल-जीपीयू एसएफटी लिफाफे में रहते हैं (कोई अलग संदर्भ मॉडल नहीं)। इसका उपयोग किस लिए करना है, इसके लिए [वरीयता-ट्यूनिंग हैंडबुक](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) देखें। ऑनलाइन आरएल (पीपीओ/जीआरपीओ) के लिए [बैकप्रोपगेट क्या नहीं है](#what-backpropagate-is-not-for) देखें।
+**v1.6 में नया — SimPO और KTO।** `--method simpo` ([मेंग एट अल. 2024](https://arxiv.org/abs/2405.14734)) संदर्भ-मुक्त है, जिसमें लंबाई-मानकीकृत इनाम होता है और यह ORPO के समान युग्मित `{prompt, chosen, rejected}` डेटा लेता है (`--simpo-beta`, `--simpo-gamma`)। `--method kto` ([एथयाराज एट अल. 2024](https://arxiv.org/abs/2402.01306)) **युग्मित नहीं** `{prompt, completion, label}` डेटा लेता है - प्रति-उदाहरण थम्स-अप/डाउन - प्रतिक्रिया के उस बड़े वर्ग के लिए जो क्यूरेटेड A/B जोड़े नहीं हैं; यह आपके लेबल गणना से वांछनीय/अवांछनीय हानि भार को स्वचालित रूप से संतुलित करता है। दोनों केवल `mode="lora"` हैं और सिंगल-GPU SFT एनवेलप में रहते हैं (कोई अलग संदर्भ मॉडल नहीं)। [प्राथमिकता-ट्यूनिंग हैंडबुक](https://mcp-tool-shop-org.github.io/backpropagate/handbook/preference-tuning/) देखें कि किसका उपयोग करना है। ऑनलाइन RL (PPO/GRPO) के लिए, [बैकप्रोपगेट क्या नहीं है](#what-backpropagate-is-not-for) देखें।
 
 ### तर्क-आधारित SFT (R1 डिस्टिलेशन)
 
 v1.5 में नया: तर्क मॉडल को आसानी से डिस्टिल करें। `--reasoning-trace` (CLI) या `Trainer(..., reasoning_trace=True)` (Python) पास करें और ऐसे ट्रेस प्रदान करें जो सहायक के टर्न के अंदर `<think>...</think>` श्रृंखला-आधारित विचार को बनाए रखें — यह [DeepSeek-R1](https://arxiv.org/abs/2501.12948) डिस्टिलेशन का शुद्ध-SFT आधा हिस्सा है, RL की आवश्यकता नहीं है। बैकप्रोपैगेट प्रशिक्षण लक्ष्य में `<think>` को बनाए रखता है, खाली/अत्यधिक लंबे ट्रेस को हटा देता है (ट्रेस-लंबाई फ़िल्टरिंग), और लंबे CoT के लिए डिफ़ॉल्ट `max_seq_length` को 8192 तक बढ़ाता है। महत्वपूर्ण रूप से, `<think>` **सादा पाठ** रहता है — कोई विशेष टोकन नहीं, कोई एम्बेडिंग आकार परिवर्तन नहीं — इसलिए मर्ज किया गया GGUF अभी भी किसी अन्य फाइन-ट्यून की तरह Ollama में निर्यात होता है। केवल SFT। डेटासेट आकार और समायोज्य टोकन बैंड के लिए [reasoning-trace recipe](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/#reasoning-trace-sft-r1-distillation) देखें।
 
-### एप्पल सिलिकॉन (MLX) — प्रयोगात्मक, v1.5
+### Apple सिलिकॉन (MLX) — अप्रमाणित पूर्वावलोकन
+
+> ⚠️ **अप्रमाणित पूर्वावलोकन - समर्थित सुविधा सेट का हिस्सा नहीं।** MLX रेल को बनाया और यूनिट-परीक्षण किया गया है, लेकिन इसे वास्तविक Apple सिलिकॉन पर डॉगफूड-प्रमाणित नहीं किया गया है (`mlx-lm` केवल Apple के लिए है और बैकप्रोपगेट जिस पर विकसित किया गया है, NVIDIA रिग्स पर नहीं चल सकता)। नीचे दी गई हर चीज को प्रयोगात्मक मानें, अपने जोखिम पर उपयोग करें, और यदि आप इसे M-श्रृंखला Mac पर चलाते हैं तो [विसंगतियों की रिपोर्ट करें](#reporting-bugs)।
 
 v1.5 में नया: **एक API, दो रेल।** CUDA डिफ़ॉल्ट, सत्यापित बैकएंड बना रहता है; MLX एक दूसरी रेल है जो Apple के [`mlx_lm.lora`](https://github.com/ml-explore/mlx-lm) टूलचेन के माध्यम से M-श्रृंखला Mac पर प्रशिक्षित होती है (एकीकृत मेमोरी, कोई CUDA नहीं)। समान 3-पंक्ति आकार हार्डवेयर द्वारा रेल का चयन करता है — `backend='auto'` (डिफ़ॉल्ट) NVIDIA पर CUDA और Apple सिलिकॉन पर MLX पर रूट करता है, इसलिए मौजूदा CUDA सेटअप बाइट-दर-बाइट समान हैं:
 
@@ -192,7 +199,7 @@ backprop train --data my_data.jsonl --backend mlx --steps 100
 
 v1.5 में MLX रेल **केवल LoRA SFT है** — कोई ORPO नहीं, कोई FP8 नहीं, कोई `mode='full'` नहीं, अभी तक MLX पर कोई मल्टी-रन नहीं (प्रत्येक को `CONFIG_INVALID_SETTING` के साथ अस्वीकार कर दिया जाता है; उन कार्यों के लिए NVIDIA बॉक्स पर `backend='cuda'`/`'auto'` का उपयोग करें)। परिणामी एडाप्टर सादा सेफ़टेंसर है और उसी पथ के माध्यम से CUDA रेल की तरह Ollama में निर्यात होता है।
 
-> ⚠️ **सटीक स्थिति:** एमएलएक्स रेल v1.5 में **निर्मित + यूनिट-परीक्षण (मॉक किया गया)** के साथ आता है, लेकिन अभी तक वास्तविक ऐप्पल सिलिकॉन पर **डॉगफूड-सत्यापित नहीं** है — `mlx-lm` केवल ऐप्पल के लिए है और इसे उस एनवीडिया रिग पर नहीं चलाया जा सकता था जिस पर यह बनाया गया था। इसे प्रयोगात्मक मानें — वही ढांचा जो v1.5 में एफपी8 पथ में था (एफपी8 को v1.6 में ब्लैकवेल पर डॉगफूड-सत्यापित किया गया; एमएलएक्स को अभी भी वास्तविक सिलिकॉन पर उस चरण से गुजरने की आवश्यकता है) — और कृपया एक बार जब यह एम-सीरीज़ मैक पर चलता है, तो [विसंगतियों की रिपोर्ट करें](#reporting-bugs)। गैर-एप्पल होस्ट पर `--backend mlx` को जबरदस्ती लागू करने पर `CONFIG_INVALID_SETTING` त्रुटि आती है; मैक पर लापता `mlx_lm` टूलचेन `DEP_MLX_UNAVAILABLE` उत्पन्न करता है।
+> गैर-Apple होस्ट पर `--backend mlx` को जबरदस्ती लागू करने से `CONFIG_INVALID_SETTING` त्रुटि आती है; Mac पर लापता `mlx_lm` टूलचेन से `DEP_MLX_UNAVAILABLE` उत्पन्न होता है।
 
 अधिक एंड-टू-एंड वर्कफ़्लो (फाइन-ट्यून-एंड-पुश-टू-HF-हब, OOM के बाद फिर से शुरू करें, लंबे अभियान में मल्टी-रन SLAO, आदि) के लिए [हैंडबुक रेसिपी पेज](https://mcp-tool-shop-org.github.io/backpropagate/handbook/recipes/) देखें।
 
@@ -305,7 +312,7 @@ UI से फ़ाइल सिस्टम में लिखी जाने
 
 **आवश्यकताएं:** Python 3.10+ · CUDA GPU (8GB+ VRAM) · PyTorch 2.0+
 
-पायथन 3.10 कम से कम v1.6 तक समर्थित है; इसकी अपस्ट्रीम जीवन अवधि अक्टूबर 2026 में समाप्त हो जाएगी और इसे उसके बाद के पहले संस्करण में हटाने की योजना बनाई गई है। नए इंस्टॉलेशन के लिए, पायथन 3.11 या 3.12 को प्राथमिकता दें — 3.11 सबसे अधिक परीक्षण किया गया संस्करण है।
+Python 3.10 को कम से कम v1.6 तक समर्थित किया गया है; यह अक्टूबर 2026 में अपस्ट्रीम जीवन के अंत तक पहुंचता है और इसके बाद पहले रिलीज में इसे हटाने की योजना बनाई गई है। नए इंस्टॉलेशन के लिए, Python 3.11 या 3.12 को प्राथमिकता दें - 3.11 सबसे अधिक परीक्षण किया गया न्यूनतम संस्करण है।
 
 Backpropagate विभिन्न प्लेटफ़ॉर्म पर प्रशिक्षण के दौरान आने वाली रनटाइम संबंधी विशिष्टताओं को संभालता है, लेकिन यह इंस्टॉलेशन के समय आने वाली समस्याओं को ठीक नहीं कर सकता है। दो सबसे आम समस्याएं हैं:
 
@@ -364,8 +371,12 @@ backprop export-runs --format jsonl    # bulk export run history
 | Llama 3.2 3B | ~8GB | Llama Community | अनुमति देने वाली शर्तों के साथ Qwen 3B का एक ठोस विकल्प। |
 | Llama 3.2 1B | ~6GB | Llama Community | छोटे कार्ड पर त्वरित प्रयोगों के लिए। |
 | Mistral 7B | ~12GB | Apache 2.0 | Qwen 7B के समान, अलग चैट टेम्पलेट। |
+| Llama-3.1-8B | ~7-8GB (QLoRA) | Llama-3.1-Community | 8B QLoRA, 128K मूल संदर्भ ( >700M-MAU खंड के लिए एक अलग मेटा लाइसेंस की आवश्यकता है)। |
+| **Qwen2.5-14B** | ~8.5GB (QLoRA) | Apache 2.0 | **32 GB दैनिक-ड्राइवर स्वीट स्पॉट** — रैंक/अल्फा 32, पेज्ड 8-बिट AdamW, 4096 ctx। |
+| Mistral-Small-24B | ~18GB (QLoRA) | Apache 2.0 | 4096-ctx हेडरूम के साथ 32 GB कार्ड पर 24B QLoRA। |
+| **Qwen2.5-32B** | ~26GB (QLoRA) | Apache 2.0 | **32 GB एनवेलप का शीर्ष** — यह `max_len 2048` + पेज्ड 8-बिट AdamW पर बस फिट बैठता है। |
 
-अन्य मॉडल अक्सर काम करते हैं, लेकिन केवल ये आठ CI में पिन किए गए हैं। Biderman 2024 + Thinking Machines 2025 के अनुसार रैंक-256 / सभी-रैखिक लक्ष्यों के लिए `--lora-preset=quality` (डिफ़ॉल्ट) पास करें, या यदि आपको v1.2.x फ़ुटप्रिंट की आवश्यकता है तो पुराने रैंक-16 / q+v लक्ष्य के लिए `--lora-preset=fast` पास करें।
+अन्य मॉडल अक्सर काम करते हैं; ऊपर दी गई पंक्तियाँ क्यूरेटेड प्रीसेट हैं - 14B–32B टियर को 32 GB कार्ड के लिए QLoRA-ट्यून किया गया है (मापा एनवेलप)। Biderman 2024 + Thinking Machines 2025 के अनुसार रैंक-256 / सभी-रैखिक लक्ष्यों के लिए `--lora-preset=quality` (डिफ़ॉल्ट) पास करें, या यदि आपको v1.2.x फ़ुटप्रिंट की आवश्यकता है तो विरासत रैंक-16 / q+v लक्ष्य के लिए `--lora-preset=fast`।
 
 ## समस्या निवारण