# Refinamiento por refuerzo (RFT) con modelos de Amazon Nova ## Descripción general **¿Qué es el RFT?** El refinamiento por refuerzo (RFT) mejora el rendimiento del modelo al entrenarlo con señales de comentarios (puntuaciones medibles o recompensas que indican el rendimiento del modelo) en lugar de con respuestas exactas correctas. A diferencia del refinamiento supervisado, que aprende de los pares de entradas y salidas, el RFT utiliza funciones de recompensas para evaluar las respuestas del modelo y lo optimiza de forma iterativa para maximizar estas recompensas. Este enfoque destaca al definir el resultado exacto correcto, pero le permite medir de forma fiable la calidad de la respuesta. **Cuándo se debe usar el RFT** Utilice el RFT cuando pueda definir criterios de éxito claros y medibles, pero tenga dificultades para proporcionar resultados exactos y correctos para el entrenamiento. Es ideal para: + Tareas en las que la calidad es subjetiva o multifacética (escritura creativa, optimización del código, razonamiento complejo) + Escenarios con múltiples soluciones válidas en los que algunas son claramente mejores que otras + Aplicaciones que requieran mejoras iterativas, personalización o el cumplimiento de reglas empresariales complejas + Casos en los que recopilar ejemplos etiquetados de alta calidad es caro o poco práctico **Los mejores casos de uso** El RFT sobresale en dominios en los que la calidad de los resultados se puede medir objetivamente, pero las respuestas óptimas son difíciles de definir por adelantado: + Resolución de problemas matemáticos y generación de código + Razonamiento científico y análisis de datos estructurados + Tareas que requieren razonamiento paso a paso o resolución de problemas de varios turnos + Aplicaciones que equilibran varios objetivos (precisión, eficiencia, estilo) + Escenarios en los que el éxito se puede verificar mediante programación con resultados de ejecución o métricas de rendimiento **Modelos compatibles** Nova Lite 2.0 ## Información general sobre el formato de datos Los datos de entrenamiento RFT deben seguir el [formato](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input) de refinamiento por refuerzo de OpenAI. Cada ejemplo de entrenamiento es un objeto JSON que contiene lo siguiente: + Una matriz `messages` con turnos conversacionales con los roles `system` y `user` + Un campo `reference_answer` que contiene el resultado esperado o los criterios de evaluación para el cálculo de recompensas **Limitaciones actuales** + Solo texto ### Ejemplos de formato de datos Cada ejemplo debe estar en una sola línea del archivo JSONL, con un objeto JSON por línea. ------ #### [ Chemistry problem ] ``` { "id": "chem-01", "messages": [ { "role": "system", "content": "You are a helpful chemistry assistant" }, { "role": "user", "content": "Calculate the molecular weight of caffeine (C8H10N4O2)" } ], "reference_answer": { "molecular_weight": 194.19, "unit": "g/mol", "calculation": "8(12.01) + 10(1.008) + 4(14.01) + 2(16.00) = 194.19" } } ``` ------ #### [ Math problem ] ``` { "id": "sample-001", // Optional "messages": [ { "role": "system", "content": "You are a math tutor" }, { "role": "user", "content": "Solve: 2x + 5 = 13" } ], "reference_answer": { "solution": "x = 4", "steps": ["2x = 13 - 5", "2x = 8", "x = 4"] } } ``` ------ #### [ Code problem ] ``` { "id": "code-002", "messages": [ { "role": "system", "content": "You are a helpful programming assistant" }, { "role": "user", "content": "Write a Python function that reverses a string without using built-in reverse methods" } ], "reference_answer": { "code": "def reverse_string(s): \n result = '' \n for i in range(len(s) - 1, -1, -1): \n result += s[i] \n return result", "test_cases": [ { "input": "hello", "expected_output": "olleh" }, { "input": "", "expected_output": "" }, { "input": "a", "expected_output": "a" }, { "input": "Python123", "expected_output": "321nohtyP" } ], "all_tests_pass": true } } ``` ------ El campo `reference_answer` contiene el resultado esperado o los criterios de evaluación que la función de recompensa utiliza para puntuar la respuesta del modelo. No se limita a resultados estructurados, sino que puede contener cualquier formato que ayude a la función de recompensas a evaluar la calidad. ## Recomendaciones de tamaño de conjunto de datos **Punto de partida** + Mínimo 100 ejemplos de entrenamiento + Mínimo 100 ejemplos de evaluación **Enfoque de priorización de la evaluación** Antes de invertir en un entrenamiento RFT a gran escala, evalúe el rendimiento de línea de base del modelo: + **Alto rendimiento (recompensa superior al 95 %)**: el RFT puede no ser necesario, el modelo ya funciona bien. + **Rendimiento muy bajo (recompensa del 0 %)**: cambie primero al SFT para establecer las capacidades básicas. + **Rendimiento moderado**: es probable que el RFT sea adecuado. Comenzar con un conjunto de datos pequeño le permite: + Validar que la función de recompensas no contenga errores + Confirmar que el RFT sea el enfoque adecuado para su caso de uso + Identificar y solucionar problemas con antelación + Probar el flujo de trabajo antes de escalar verticalmente Una vez validado, puede ampliarlo a conjuntos de datos más grandes para mejorar aún más el rendimiento. ## Características de los datos de entrenamiento eficaces **Claridad y coherencia** Los buenos ejemplos del RFT requieren datos de entrada claros e inequívocos que permitan un cálculo preciso de las recompensas en las diferentes salidas del modelo. Evite el ruido en los datos, lo que incluye lo siguiente: + Formato incoherente + Etiquetas o instrucciones contradictorias + Peticiones ambiguas + Conflictos en las respuestas de referencia Cualquier ambigüedad inducirá a error durante el proceso de entrenamiento y provocará que el modelo aprenda comportamientos no deseados. **Diversidad** El conjunto de datos debe capturar toda la diversidad de casos de uso de producción para garantizar un rendimiento real sólido. Incluya: + Diferentes formatos de entrada y casos extremos + Asignación de patrones reales de uso de producción a partir de registros y análisis de usuarios + Muestras de distintos tipos de usuarios, regiones geográficas y variaciones estacionales + Inclusión de niveles de dificultad, desde problemas simples hasta problemas complejos **Consideraciones sobre la función de recompensas** Diseñe la función de recompensas para un entrenamiento eficiente: + Ejecución en segundos (no minutos) + Paralelización eficaz con Lambda + Devolución de puntuaciones coherentes y fiables + Gestión de diferentes tipos de salidas del modelo sin problemas Las funciones de recompensas rápidas y escalables permiten una iteración rápida y una experimentación rentable. ## Propiedades adicionales El formato de datos del RFT admite campos personalizados que van más allá de los requisitos básicos del esquema (`messages` y `reference_answer`). Esta flexibilidad le permite agregar cualquier dato adicional que su función de recompensas necesite para una evaluación adecuada. **nota** No tiene que configurarlo en su fórmula: el formato de datos admite campos adicionales de forma inherente. Solo tiene que incluirlos en el JSON de los datos de entrenamiento para que se transiferan a la de recompensas en el campo `metadata`. **Propiedades adicionales comunes** Campos de metadatos de ejemplo: + `task_id`: identificador único de seguimiento + `difficulty_level`: indicador de la complejidad del problema + `domain`: categoría o área del asunto + `expected_reasoning_steps`: número de pasos de la solución **Ejemplo con propiedades adicionales** ``` { "messages": [ { "role": "system", "content": "You are a math tutor" }, { "role": "user", "content": "Solve: 2x + 5 = 13" } ], "reference_answer": { "solution": "x = 4", "steps": ["2x = 13 - 5", "2x = 8", "x = 4"] }, "task_id": "algebra_001", "difficulty_level": "easy", "domain": "algebra", "expected_reasoning_steps": 3 } ``` Estos campos adicionales se transfieren a la función de recompensas durante la evaluación, lo que permite aplicar una lógica de puntuación sofisticada adaptada a su caso de uso específico. ## Configuración de entrenamiento **Fórmula de muestra** ``` # Note: # This recipe can run on p5.48xlarge and p5en.48xlarge instance types. run: name: "my-rft-run" # Unique run name (appears in logs/artifacts). model_type: amazon.nova-2-lite-v1:0:256k model_name_or_path: nova-lite-2/prod data_s3_path: s3:/// # Training dataset in JSONL; replicas: 4 reward_lambda_arn: arn:aws:lambda:::function: ## MLFlow configs mlflow_tracking_uri: "" # Required for MLFlow mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty ## SMTJ GRPO Training specific configs training_config: max_length: 8192 # Context window (tokens) for inputs+prompt; global_batch_size: 16 # Total samples per optimizer step across all replicas (16/32/64/128/256). reasoning_effort: high # Enables reasoning mode high / low / or null for non-reasoning rollout: # How responses are generated for GRPO/advantage calc. advantage_strategy: number_generation: 2 # N samples per prompt to estimate advantages (variance vs cost). generator: max_new_tokens: 6000 # Cap on tokens generated per sample set_random_seed: true # Seed generation for reproducibility across runs. temperature: 1 # Softmax temperature; top_k: 1 # Sample only from top-K logits rewards: preset_reward_function: null # Usage of preset reward functions [exact_match] api_endpoint: lambda_arn: arn:aws:lambda:::function: lambda_concurrency_limit: 12 # Max concurrent Lambda invocations (throughput vs. throttling). trainer: max_steps: 2 # Steps to train for. One Step = global_batch_size save_steps: 5 test_steps: 1 # RL parameters ent_coeff: 0.0 # A bonus added to the policy loss that rewards higher-output entropy. kl_loss_coef: 0.001 # Weight on the KL penalty between the actor (trainable policy) and a frozen reference model optim_config: # Optimizer settings lr: 5e-5 # Learning rate weight_decay: 0.0 # L2 regularization strength (0.0–1.0) adam_beta1: 0.9 adam_beta2: 0.95 peft: # Parameter-efficient fine-tuning (LoRA) peft_scheme: "lora" # Enable LoRA for PEFT lora_tuning: alpha: 32 lora_plus_lr_ratio: 64.0 # LoRA+ learning rate scaling factor (0.0–100.0) ``` ## Entrenamiento RFT con LLM como juez ### Descripción general Los modelos de lenguaje de gran tamaño (LLM) se utilizan cada vez más como jueces en los flujos de trabajo de refinamiento por refuerzo (RFT), ya que proporcionan señales de recompensas automatizadas que guían la optimización de los modelos. Con este enfoque, el LLM evalúa las salidas del modelo en función de criterios específicos (ya sea la corrección, la calidad, la adherencia al estilo o la equivalencia semántica) y asigna recompensas que impulsan el proceso de aprendizaje por refuerzo. Esto es particularmente valioso para tareas en las que las funciones de recompensas tradicionales son difíciles de definir mediante programación, como determinar si diferentes representaciones (como “1/3”, “0,333” y “un tercio”) son semánticamente equivalentes, o evaluar cualidades matizadas como la coherencia y la relevancia. Al utilizar jueces basados en LLM como funciones de recompensas, puede escalar el RFT a dominios complejos sin necesidad de una amplia anotación humana, lo que permite una iteración rápida y una mejora continua de los modelos en varios casos de uso, más allá de los problemas de alineación tradicionales. ### Selección del modo de razonamiento **Modos disponibles** + ninguno: sin razonamiento (omita el campo reasoning\$1effort) + bajo: sobrecarga de razonamiento mínima + alto: capacidad de razonamiento máxima (opción predeterminada cuando se especifica reasoning\$1effort) **nota** No hay una opción media para el RFT. Si el campo reasoning\$1effort no está en la configuración, el razonamiento está desactivado. Cuando el razonamiento está habilitado, debe configurar `max_new_tokens` en 32 768 para dar cabida a las salidas de razonamiento extendido. **Cuándo se debe usar cada modo** Utilice el razonamiento alto para: + Tareas analíticas complejas + Resolución de problemas matemáticos + Deducción lógica de varios pasos + Tareas en las que pensar paso a paso agrega valor Utilice ninguno (omita reasoning\$1effort) o un razonamiento bajo para: + Consultas de hechos sencillas + Clasificaciones directas + Optimización de velocidad y costo + Preguntas y respuestas directas **Compensaciones de costo y rendimiento** Los modos de razonamiento alto aumentan lo siguiente: + Tiempo y costo del entrenamiento + Latencia y costo de la inferencia + Capacidad del modelo para tareas de razonamiento complejas ### Validación del juez de LLM Antes de implementar un LLM como juez en producción, compruebe que las evaluaciones del modelo del juez se ajusten al juicio humano. Esto implica: + Medir las tasas de acuerdo entre el juez de LLM y los evaluadores humanos sobre muestras representativas de la tarea + Garantizar que el acuerdo del LLM con las personas cumpla o supere las tasas de acuerdo interhumano + Identificar posibles sesgos en el modelo del juez + Crear la confianza de que la señal de recompensas guíe al modelo en la dirección deseada Este paso de validación ayuda a garantizar que el proceso de evaluación automatizada produzca modelos que cumplan con los criterios de calidad de producción. ### Configuración de Lambda para juez de LLM El uso de un LLM como juez es una extensión del uso de las funciones de Lambda para el aprendizaje por refuerzo con recompensas verificables (RLVR). Dentro de la función de Lambda, puede hacer una llamada a uno de los modelos alojados en Amazon Bedrock. **Requisitos de configuración importantes:** | Configuración | Requisito | Details | | --- | --- | --- | | Rendimiento de Amazon Bedrock | Cuota suficiente | Asegúrese de que la cuota de rendimiento para el modelo de Amazon Bedrock utilizado sea suficiente para la carga de trabajo de entrenamiento. | | Tiempo de espera de Lambda | Tiempo de espera ampliado | Configure el tiempo de espera de la función de Lambda en hasta un máximo de 15 minutos. La configuración predeterminada es de 3 segundos, lo que no es suficiente para las respuestas del modelo de Amazon Bedrock. | | Simultaneidad de Lambda | Mayor simultaneidad | La función de Lambda se invoca en paralelo durante el entrenamiento. Aumente la simultaneidad para maximizar el rendimiento disponible. | | Configuración de fórmulas | Coincidencia de la configuración de Lambda | El límite de simultaneidad debe estar configurado en la fórmula. | ## Creación y ejecución de trabajos **Inicio de un trabajo de entrenamiento** Utilice la plantilla de cuaderno de trabajos de entrenamiento de SageMaker: [https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook). **Requisitos de instancias** El contenedor admite tanto el entrenamiento de rango completo como el de LoRA: + **Entrenamiento de LoRA**: 2/4/6/8 × instancias p5.48xlarge o p5en.48xlarge + **Entrenamiento de rango completo**: 2/4/6/8 × instancias p5.48xlarge (obligatorias) ## Supervisión del entrenamiento Los registros de entrenamiento incluyen métricas completas en cada paso. Categorías de métricas clave: **Métricas de recompensas** + `critic/rewards/mean`, `critic/rewards/max`, `critic/rewards/min`: distribución de recompensas + `val-score/rewards/mean@1`: recompensas de validación **Comportamiento del modelo** + `actor/entropy`: variación de la política (mayor = más exploratoria) **Estado del entrenamiento** + `actor/pg_loss`: pérdida de gradiente de la política + `actor/pg_clipfrac`: frecuencia de las actualizaciones recortadas + `actor/grad_norm`: magnitud del gradiente **Características de la respuesta** + `prompt_length/mean`, `prompt_length/max`, `prompt_length/min`: estadísticas del token de entrada + `response_length/mean`, `response_length/max`, `response_length/min`: estadísticas del token de salida + `response/aborted_ratio`: porcentaje de generación incompleta (0 = todo completado) **Desempeño** + `perf/throughput`: rendimiento del entrenamiento + `perf/time_per_step`: tiempo por paso del entrenamiento + `timing_per_token_ms/*`: tiempo de procesamiento por token **Uso de recursos** + `perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb`: memoria de la GPU + `perf/cpu_memory_used_gb`: memoria de la CPU ## Uso de modelos de ajuste fino Después de finalizar el entrenamiento, el punto de control final del modelo se guarda en la ubicación de salida especificada. La ruta del punto de control está disponible en: + Registros de entrenamiento + Archivo `manifest.json` en la ubicación de salida de Amazon S3 (definida por `output_s3_uri` en el cuaderno) ## Limitaciones y prácticas recomendadas **Limitaciones** + **Tiempo de espera de Lambda**: las funciones de recompensas deben completarse en 15 minutos (evita procesos fuera de control y administra los costos). + **Solo turno único**: no se admiten conversaciones de varios turnos. + **Requisitos de datos**: necesita una diversidad suficiente, ya que tiene dificultades para obtener recompensas escasas (menos del 5 % de ejemplos positivos). + **Costo computacional**: es más caro que el refinamiento supervisado. + **Sin datos multimodales**: solo se admite el tipo de datos de texto. **Prácticas recomendadas** **Empezar poco a poco** + Comience con entre 100 y 200 ejemplos. + Valide la corrección de la función de recompensas. + Escale de forma gradual en función de los resultados. **Evaluación del entrenamiento previo** + Pruebe el rendimiento del modelo de línea de base antes del RFT. + Si las recompensas son del 0 % de forma constante, utilice antes el SFT para establecer las capacidades básicas + Si las recompensas son superiores al 95 %, es posible que el RFT no sea necesario. **Supervisión del entrenamiento** + Haga un seguimiento del promedio de las puntuaciones y la distribución de las recompensas + Observe si hay sobreajuste (aumento de recompensas de entrenamiento con disminución de recompensas de validación). + Busque patrones preocupantes: + Recompensas que se estancan por debajo de 0,15 + Aumento de la variación de las recompensas a lo largo del tiempo + Reducción del rendimiento de validación **Optimización de las funciones de recompensas** + Ejecución en segundos (no minutos) + Minimice las llamadas a la API externa. + Use algoritmos eficientes. + Implemente una gestión de errores adecuada. + Aproveche el escalado paralelo de Lambda. **Estrategia de iteración** Si las recompensas no mejoran: + Ajuste el diseño de la función de recompensas. + Aumente la diversidad de los conjuntos de datos. + Agregue más ejemplos representativos. + Verifique que las señales de recompensas sean claras y coherentes. ## Capacidades avanzadas: Nova Forge Para los usuarios que requieren capacidades avanzadas más allá de las limitaciones del RFT estándar, Nova Forge está disponible como un servicio de suscripción de pago que ofrece: + Soporte para conversación de varios turnos + Funciones de recompensas con un tiempo de ejecución superior a 15 minutos + Algoritmos y opciones de ajuste adicionales + Modificaciones de fórmulas de entrenamiento personalizadas + Técnicas de IA de vanguardia Nova Forge se ejecuta en SageMaker HyperPod y se ha diseñado para ayudar a los clientes empresariales a crear sus propios modelos de frontera. ## Comandos y consejos útiles Hay disponible una colección de [scripts de observabilidad](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring) para ayudar a supervisar el estado y el progreso de los trabajos de entrenamiento. Los scripts disponibles le permiten: + Habilitar las notificaciones de correo electrónico para actualizar el estado de los trabajos de entrenamiento + Obtener estimaciones del tiempo de entrenamiento en función de las configuraciones de los trabajos + Obtener aproximaciones del tiempo que se espera que dure el entrenamiento para los trabajos en curso **Instalación** **nota** Asegúrese de actualizar las credenciales de AWS antes de utilizar cualquiera de los siguientes scripts. ``` pip install boto3 git clone https://github.com/aws-samples/amazon-nova-samples.git cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/ ``` **Uso básico** ``` # Enabling email notifications for training job status updates python enable_sagemaker_job_notifs.py --email test@amazon.com test2@gmail.com --region us-east-1 --platform SMTJ Creating resources........ Please check your email for a subscription confirmation email, and click 'Confirm subscription' to start receiving job status email notifications! You'll receive the confirmation email within a few minutes. ``` ``` # Obtaining training time estimates based on job configurations python get_training_time_estimate.py ``` ``` # Obtaining approximations for how long training is expected to take for in-progress jobs python get-training-job-progress.py --region us-east-1 --job-name my-training-job --num-dataset-samples 1000 ``` Consulte [en esta página](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md) los detalles y ejemplos adicionales.