Superar los desafíos de las señales de recompensa: aprendizaje por refuerzo basado en recompensas verificable con GRPO en SageMaker AI

El entrenamiento de modelos de lenguaje grandes requiere señales de retroalimentación precisas, pero el aprendizaje por refuerzo (RL) tradicional a menudo tiene problemas con la confiabilidad de las señales de recompensa. La calidad de estas señales influye directamente en cómo los modelos aprenden y toman decisiones. Sin embargo, crear mecanismos de retroalimentación sólidos puede resultar complejo y propenso a errores. Los escenarios de capacitación del mundo real a menudo introducen sesgos ocultos, incentivos no deseados y criterios de éxito ambiguos que pueden descarrilar el proceso de aprendizaje, dando lugar a modelos que se comportan de manera impredecible o no cumplen con los objetivos deseados.

En esta publicación, aprenderá cómo implementar el aprendizaje por refuerzo con recompensas verificables (RLVR) para introducir verificación y transparencia en las señales de recompensa para mejorar el rendimiento del entrenamiento. Este enfoque funciona mejor cuando se puede verificar objetivamente la exactitud de los resultados, como en el razonamiento matemático, la generación de código o las tareas de manipulación simbólica. También aprenderá a superponer técnicas como la optimización de políticas relativas a grupos (GRPO) y ejemplos breves para mejorar aún más los resultados. Utilizará el conjunto de datos GSM8K (Grade School Math 8K: una colección de problemas matemáticos de la escuela primaria) para mejorar la precisión en la resolución de problemas matemáticos, pero las técnicas utilizadas aquí se pueden adaptar a una amplia variedad de otros casos de uso.

Descripción técnica

Antes de profundizar en la implementación, resulta útil comprender los conceptos de RL que sustentan este enfoque. RL aborda los desafíos en el entrenamiento de modelos estableciendo un sistema de retroalimentación estructurado a través de señales de recompensa. Este paradigma permite que los modelos aprendan a través de la interacción, recibiendo retroalimentación que los guía hacia un comportamiento óptimo. RL proporciona un marco para que los modelos mejoren iterativamente sus respuestas basándose en señales claramente definidas sobre la calidad de sus resultados, lo que lo hace muy eficaz para entrenar modelos que interactúan con los usuarios y deben adaptar su comportamiento en función de los resultados. La RL tradicional ha puesto de relieve una consideración importante: la calidad de la señal de recompensa es muy importante. Cuando las funciones de recompensa son imprecisas o incompletas, los modelos pueden participar en un "pirateo de recompensas", encontrando formas no deseadas de maximizar las puntuaciones sin lograr el comportamiento deseado. Reconocer esta limitación ha llevado al desarrollo de enfoques más rigurosos que se centran en crear funciones de recompensa confiables y bien definidas.

RLVR aborda la piratería de recompensas a través de comentarios basados ​​en reglas definidas por el sintonizador del modelo. Utiliza funciones de recompensa programáticas que califican automáticamente los resultados según criterios específicos, lo que permite una iteración rápida sin el cuello de botella de recopilar calificaciones humanas. Estas recompensas "verificables" provienen de reglas objetivas y reproducibles, lo que hace que RLVR sea ideal para requisitos en evolución porque aprende estrategias generales de optimización y se adapta rápidamente a nuevos escenarios. GRPO es un algoritmo de aprendizaje por refuerzo que mejora el aprendizaje del modelo de IA al comparar el rendimiento dentro de grupos en lugar de entre todos los datos a la vez. Organiza los datos de entrenamiento en grupos significativos y optimiza el rendimiento en relación con la línea de base de cada grupo, prestando la atención adecuada a cada categoría. Esta optimización con reconocimiento de grupo reduce la variación del entrenamiento, acelera la convergencia y puede producir modelos que funcionan de manera consistente en varias categorías. La combinación de RLVR con GRPO crea un marco en el que las recompensas automatizadas guían el aprendizaje, mientras que la optimización relativa al grupo ayuda a impulsar un rendimiento equilibrado.

Usted define funciones de recompensa para diferentes aspectos de la tarea y GRPO las trata como grupos distintos durante la capacitación, lo que facilita la mejora simultánea en todas las dimensiones. Esta combinación ofrece una adaptación rápida y un rendimiento sólido, ideal para entornos dinámicos que requieren una generalización más allá de la distribución del entrenamiento. Agregar aprendizaje en pocas oportunidades mejora este marco de tres maneras. En primer lugar, los ejemplos de pocas tomas proporcionan plantillas que muestran al modelo cómo son los buenos resultados, lo que reduce el espacio de búsqueda para la exploración. En segundo lugar, GRPO aprovecha estos ejemplos generando múltiples respuestas de candidatos por mensaje y aprendiendo de su desempeño relativo dentro de cada grupo. En tercer lugar, las recompensas verificables confirman inmediatamente qué enfoques tienen éxito. Esta combinación acelera el aprendizaje: el modelo comienza con ejemplos concretos del formato deseado, explora variaciones de manera eficiente mediante comparaciones grupales y recibe comentarios definitivos sobre la corrección.

Descripción general de la solución

En esta sección, explicará cómo ajustar un modelo Qwen2.5-0.5B en SageMaker AI utilizando los trabajos de capacitación de Amazon Amazon SageMaker. Los trabajos de capacitación de Amazon SageMaker admiten configuraciones distribuidas de múltiples GPU y múltiples nodos, por lo que puede activar clústeres de alto rendimiento a pedido, entrenar modelos de mil millones de parámetros más rápido y apagar automáticamente los recursos cuando finaliza el trabajo.

Nota: Si bien se seleccionó Qwen2.5-0.5B para este caso de uso, otros, como la generación de código, requerirán un modelo más grande (por ejemplo, Qwen2.5-Coder-7B) y, posteriormente, instancias de capacitación más grandes.

Requisitos previos

Para ejecutar el ejemplo de esta publicación en Amazon SageMaker AI, debe cumplir los siguientes requisitos previos:

Configuración del entorno

Puede utilizar su IDE preferido, como VS Code o PyCharm, pero asegúrese de que su entorno local esté configurado para funcionar con AWS, como se explica en los requisitos previos.

Para utilizar los espacios de SageMaker Studio JupyterLab, complete los siguientes pasos:

En la consola de Amazon SageMaker AI, elija Dominios en el panel de navegación y luego abra su dominio. En el panel de navegación, en Aplicaciones e IDE, elija Studio. En la pestaña Perfiles de usuario, busque su perfil de usuario y luego elija Iniciar y Studio. En Amazon SageMaker Studio, inicie una instancia de notebook ml.t3.medium JupyterLab con al menos 50 GB de almacenamiento.

No se requiere una instancia de notebook grande, porque el trabajo de ajuste se ejecutará en una instancia de entrenamiento efímera separada con aceleración de GPU.

Para comenzar a realizar ajustes, comience clonando el repositorio de GitHub y navegando al directorio 3_distributed_training/reinforcement-learning/grpo-with-verifiable-reward, luego inicie model-finetuning-grpo-rlvr.ipynb Notebook con un kernel Python 3.12 o una versión superior.

Prepare el conjunto de datos para realizar ajustes

Ejecutar GRPO con RLVR requiere que tengas la respuesta final a cada pregunta para calcular la recompensa. Primero, prepare los datos extrayendo la respuesta final para cada pregunta.

conjunto de datos = GSM8K(split="train", include_answer=False, include_reasoning=True, pocos_shot=True, num_shots=8, seed=None, cot=True).dataset.shuffle(seed=42) Conjunto de datos({ características: ['pregunta', 'respuesta', 'mensaje', 'respuesta_final'], num_rows: 7473 })

Además, este ejemplo utiliza ejemplos de pocos disparos (8 disparos) para mejorar el rendimiento del entrenamiento del modelo. Para obtener más información sobre ejemplos de pocas tomas en el aprendizaje por refuerzo, consulte el artículo "Aprendizaje por refuerzo para el razonamiento en modelos de lenguaje grandes con un ejemplo de entrenamiento". Si bien el artículo de investigación se centra en ejemplos de un solo disparo, esta publicación le mostrará el rendimiento tanto de un solo disparo como de múltiples disparos.

Cada entrada contendrá 8 ejemplos, seguidos del problema a resolver:

"Pregunta: Mark tiene $50 y compra un juguete que cuesta $35. ¿Cuánto dinero le queda? Solución: Pensemos paso a paso. Para saber cuánto dinero le queda a Mark, reste el costo del juguete de la cantidad total de dinero que tiene Mark. Entonces, $50 – $35 = $15. #### La respuesta final es 15 Pregunta: Emily tiene 3 veces más lápices que Alice. Si Alice tiene 15 lápices, ¿cuántos lápices tiene Emily Solución: Pensemos paso a paso para saber cuántos lápices tiene Emily, multiplicamos la cantidad de lápices que tiene Alice por 3. Alice tiene 15 lápices, entonces Emily tiene 15 * 3 = 45 lápices #### La respuesta final es 45 Pregunta: Jack ha recolectado 12 canicas más que Kevin, ¿cuántas canicas tiene Jack? canicas que tiene Jack, le sumamos 12 a la cantidad de canicas que tiene Kevin. Entonces, Jack tiene 27 + 12 = 39 canicas #### La respuesta final es 39 Pregunta: Hay 24 estudiantes en un salón de clases. Si cada grupo debe tener 4 estudiantes, ¿cuántos grupos se pueden formar? Entonces, pensemos paso a paso. Se pueden formar 6 grupos. #### La respuesta final es 6 Pregunta: Samantha horneó 40 galletas y quiere dividirlas en partes iguales, cada bolsa contendrá 5 galletas. ¿Cuántas bolsas necesitará Samantha? Pensemos paso a paso para encontrar la cantidad de galletas necesarias, divida la cantidad total de galletas por la cantidad de galletas por bolsa. Compra 7 paquetes, ¿cuánto gastarás en total? Solución: Pensemos paso a paso. El costo total se calcula multiplicando el costo por paquete por la cantidad de paquetes. Por lo tanto, gastas 7 * $4 = $28. Solución: Pensemos paso a paso. páginas por día, entonces dividimos el total de páginas por la cantidad de páginas que lee por día. Por lo tanto, le toma 240 / 20 = 12 días para terminar el libro. #### La respuesta final es 12 Pregunta: Un granjero tiene un total de 80 manzanas y naranjas, restamos la cantidad de manzanas. La cantidad total de frutas. Entonces, la cantidad de naranjas es 80 – 30 = 50.n #### La respuesta final es 50 Pregunta: Mimi recogió 2 docenas de conchas en la playa. Kyle encontró el doble de conchas que Mimi y las puso en su bolsillo.

Una vez preparados los datos, mantenga el 10 por ciento de los datos como conjunto de validación y envíe tanto el conjunto de entrenamiento como el de validación a S3.

La función de recompensa verificable

Esta implementación de GRPO para el razonamiento matemático emplea un sistema de recompensa dual que proporciona retroalimentación objetiva y verificable durante el entrenamiento. Este enfoque aprovecha la verificabilidad inherente de los problemas matemáticos para crear señales de entrenamiento confiables sin requerir anotaciones humanas o evaluación subjetiva. Implementará dos funciones de recompensa complementarias que funcionan juntas para guiar el modelo hacia el formato de respuesta correcto y la precisión matemática del resultado:

Función de recompensa de formato

Esta función ayuda a verificar que el modelo aprende a estructurar sus respuestas correctamente mediante:

Coincidencia de patrones: busca el formato específico #### La respuesta final es [número] Puntuación consistente: otorga 0,5 puntos por el formato adecuado, 0,0 por el formato incorrecto Señal de entrenamiento: alienta al modelo a seguir la estructura de respuesta esperada

#Format función de recompensa def format_reward_func_qa(compleciones, **kwargs): patrón = r"n#### La respuesta final es d+" complete_contents = [finalización para completar en finalizaciones] coincidencias = [re.search(pattern, content) para contenido en finalización_contents] return [0.5 si coincide, sino 0.0 para coincidencia en coincidencias]

Función de recompensa por corrección

Esta función proporciona la verificación matemática central mediante:

Extracción de respuestas: utiliza expresiones regulares para extraer respuestas numéricas de respuestas formateadas. Normalización: elimina caracteres de formato comunes (comas, símbolos de moneda, unidades). Comparación de precisión: utiliza una tolerancia de 1e-3 para manejar la precisión de punto flotante. Puntuación binaria: otorga 1,0 por las respuestas correctas y 0,0 por las incorrectas.

#Función de recompensa por corrección def correctness_reward_func_qa(completions, final_answer, **kwargs): recompensas =[]para completar, ground_truth en zip(completions, final_answer): intente: match = re.search(r'####.*?([d,]+(?:.d+)?)', complete) if match: respuesta = match.group(1) for remove_char in [',', '$', '%', 'g']: respuesta = respuesta.replace(remove_char, '') if abs(float(respuesta)-float(ground_truth)) < 1e-3: recompensas.append(1.0) más: recompensas.append(0.0) más: recompensas.append(0.0) excepto ValueError: recompensas.append(0.0) devuelve recompensas

Integrando RLVR con GRPO

Las funciones de recompensa están integradas en el proceso de formación de GRPO a través de GRPOTrainer:

recompensas_funcs = [formato_reward_func_qa, corrección_reward_func_qa] entrenador = GRPOTrainer (modelo = modelo, args = formación_args, tren_dataset = tren_dataset, eval_dataset = prueba_dataset, procesamiento_clase = tokenizador, peft_config = peft_config, recompensa_funcs = recompensas_funcs,)

Durante el entrenamiento, GRPO utiliza estas funciones de recompensa para calcular los gradientes de políticas. Primero, el modelo genera múltiples terminaciones para cada problema matemático. A continuación, se calcula la recompensa por cada respuesta para ambas funciones de recompensa. La función de recompensa de formato otorgará hasta 0,5 por una estructura de respuesta adecuada, y la función de recompensa por corrección otorgará hasta 1,0 por la precisión matemática de la respuesta para una recompensa combinada máxima de 1,5 por finalización. Luego, GRPO compara las terminaciones dentro de los grupos para identificar las mejores respuestas. Finalmente, en el paso de actualización de la política, la función de pérdida utiliza diferencias de recompensa para actualizar los parámetros del modelo. Las terminaciones con recompensas más altas aumentan su probabilidad, mientras que las terminaciones con recompensas más bajas disminuyen su probabilidad. Esta clasificación relativa impulsa el proceso de optimización. El siguiente ejemplo demuestra cómo ajustar Qwen2.5-0.5B. La receta se proporciona en la carpeta de scripts, lo que le permite personalizarla o cambiar el modelo base. Aquí utilizará GRPO con recompensas verificables mediante la Adaptación cuantificada de bajo rango (QLoRA). QLoRA se utiliza aquí como una técnica para reducir los requisitos de recursos de capacitación y acelerar el proceso de capacitación, con una pequeña compensación en precisión.

# Argumentos del modelo model_name_or_path: Qwen/Qwen2.5-0.5B tokenizer_name_or_path: Qwen/Qwen2.5-0.5B model_revision: main torch_dtype: bfloat16 attn_implementation: flash_attention_2 bf16: true tf32: true output_dir: /opt/ml/model/Qwen2.5-0.5B-RL-VR-GRPO # Argumentos del conjunto de datos train_dataset_id_or_path: /opt/ml/input/data/train/dataset.json test_dataset_id_or_path: /opt/ml/input/data/val/dataset.json dataset_splits: 'train' max_seq_length: 2048 embalaje: verdadero # argumentos LoRA use_peft: true load_in_4bit: true lora_target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "up_proj", "down_proj", "gate_proj"] lora_modules_to_save: ["lm_head", "embed_tokens"] lora_r: 16 lora_alpha: 16 # Argumentos de entrenamiento num_train_epochs: 2 per_device_train_batch_size: 16 gradient_accumulation_steps: 2 gradient_checkpointing: true gradient_checkpointing_kwargs: use_reentrant: True learning_rate: 1.84e-4 lr_scheduler_type: coseno warmup_ratio: 0.1 # Argumentos de registro logging_strategy: pasos logging_steps: 5 report_to: – mlflow save_strategy: "no" semilla: 42

Resumen de recetas

Esta receta implementa la optimización de políticas relativas al grupo (GRPO) con recompensas verificables por ajustar el modelo Qwen2.5-0.5B en tareas de razonamiento matemático. La receta utiliza un sistema de doble recompensa que evalúa objetivamente tanto el formato de las respuestas como la corrección matemática sin requerir anotaciones humanas.

Hiperparámetros importantes:

learning_rate: 1.84e-4 – Tasa de aprendizaje optimizada para el entrenamiento GRPO num_train_epochs: 2 – Épocas de entrenamiento para evitar el sobreajuste per_device_train_batch_size: 16 con gradient_accumulation_steps: 2 – Tamaño de lote efectivo de 32 max_seq_length: 2048 – Ventana de contexto para indicaciones de 8 disparos lora_r: 16 y lora_alpha: 16 – Parámetros de rango y escala de LoRA warmup_ratio: 0.1 con programador de coseno – Programación de tasa de aprendizaje lora_target_modules – Atención de objetivos y capas de MLP para adaptación

Como siguiente paso, utilizará un trabajo de entrenamiento de IA de SageMaker para poner en marcha un grupo de entrenamiento y ejecutar el ajuste del modelo. El entrenador de modelos de IA de SageMaker. ModelTrainer ejecuta trabajos de capacitación en una infraestructura totalmente administrada; Manejar la configuración del entorno, el escalado y la gestión de artefactos. También le permite especificar scripts de entrenamiento, datos de entrada y recursos informáticos sin aprovisionar servidores manualmente. Las dependencias de la biblioteca se pueden administrar a través del archivo requisitos.txt en la carpeta de scripts. ModelTrainer detectará automáticamente este archivo e instalará las dependencias enumeradas en tiempo de ejecución.

Primero, configure su entorno. Aquí especificará el tipo de instancia y la cantidad de instancias para la capacitación y la ubicación del contenedor de capacitación.

de sagemaker.core importar image_uris de sagemaker.core.helper.session_helper importar sesión sagemaker_session = Session() nombre_de_bucket = sagemaker_session.default_bucket() default_prefix = sagemaker_session.default_bucket_prefix configs = load_sagemaker_config() instancia_tipo = "ml.g6.48xlarge" instancia_count = 1 config_filename = "Qwen2.5-0.5B.yaml" image_uri = image_uris.retrieve( framework="pytorch", región=sagemaker_session.boto_session.region_name, versión="2.7.1", tipo_instancia=tipo_instancia, image_scope="formación" )

A continuación, configure las variables de entorno, las ubicaciones de los códigos y las rutas de datos:

de sagemaker.train.configs import (CheckpointConfig, Compute, OutputDataConfig, SourceCode, StoppingCondition,) de sagemaker.train.distributed import Torchrun de sagemaker.train.model_trainer import ModelTrainer env = {} env["FI_PROVIDER"] = "efa" env["NCCL_PROTO"] = "simple" env["NCCL_SOCKET_IFNAME"] = "eth0" env["NCCL_IB_DISABLE"] = "1" env["NCCL_DEBUG"] = "WARN" env["HF_token"] = os.environ['hf_token'] env["CONFIG_PATH"] = f"recipes/{config_filename}" env["MLFLOW_EXPERIMENT_NAME"]= "grpo-rlvr" env["MLFLOW_TAGS"] = '{"source.job": "sm-training-jobs", "source.type": "grpo-rlvr", "source.framework": "pytorch"}' env["MLFLOW_TRACKING_URI"] = MLFLOW_TRACKING_SERVER_ARN # Definir el script que se ejecutará código_fuente = CódigoFuente( fuente_dir="./scripts", requisitos="requirements.txt", entrada_script="run_finetuning.sh", ) # Definir el cálculo Compute_configs = Compute( tipo_instancia=tipo_instancia, cuenta_instancia=cuenta_instancia, keep_alive_period_in_segundos=3600, ) # definir nombre del trabajo de capacitación nombre_trabajo = f"train-{config_filename.split('/')[-1].replace('.', '-').replace('yaml', 'rlvr')}" # define la ruta OutputDataConfigoutput_path = f"s3://{bucket_name}/{job_name}" # define el ModelTrainer model_trainer = ModelTrainer(training_image=image_uri, Environment=env, source_code=source_code, base_job_name=nombre_trabajo, compute=compute_configs, stop_condition=StoppingCondition(max_runtime_in_segundos=18000), output_data_config=OutputDataConfig(s3_output_path=output_path), checkpoint_config=CheckpointConfig( s3_uri=output_path + "/checkpoint", local_path="/opt/ml/checkpoints" ), )

Configure los canales para los datos de capacitación y validación:

de sagemaker.train.configs import InputData # Pasar los datos de entrada train_input = InputData(channel_name="train", data_source=train_dataset_s3_path, # Ruta S3 donde se almacenan los datos de entrenamiento) val_input = InputData(channel_name="val", data_source=val_dataset_s3_path, # Ruta S3 donde se almacenan los datos de entrenamiento) # Verificar los datos configurados de los canales de entrada = [train_input, val_input]

Luego comience el entrenamiento:model_trainer.train(input_data_config=data)La siguiente es la estructura de directorios para el código fuente de este ejemplo:

scripts/ ├── acelerar_configs/ # Archivos de configuración de Acelerar ├── run_finetuning.sh # Iniciar script para capacitación distribuida con Accelerate en trabajos de capacitación de SageMaker ├── run_grpo.py # Script de capacitación principal para GRPO ├── utilidades/ # utilidades para cargar datos y crear indicaciones ├── recetas/ # Recetas de configuración de entrenamiento predefinidas (YAML) └── requisitos.txt # Dependencias de Python instaladas en tiempo de ejecución

Para realizar ajustes en varias GPU, el script de entrenamiento de ejemplo utiliza Huggingface Accelerate y DeepSpeed ​​ZeRO-3, que trabajan juntos para entrenar modelos grandes de manera más eficiente. Huggingface Accelerate simplifica el inicio de la capacitación distribuida al manejar automáticamente la ubicación del dispositivo, la gestión de procesos y configuraciones de precisión mixtas. DeepSpeed ​​ZeRO-3 reduce el uso de memoria al dividir los estados, gradientes y parámetros del optimizador en las GPU, lo que permite que los modelos de mil millones de parámetros se ajusten y entrenen más rápido. Puede ejecutar su script de entrenamiento GRPO con Huggingface Accelerate usando un comando simple como el siguiente:

NUM_GPUS=$(nvidia-smi –list-gpus | wc -l) echo "Se detectaron ${NUM_GPUS} GPU en la máquina" # Inicie el ajuste fino con Accelerate + DeepSpeed ​​(Zero3) acelere el lanzamiento –config_file acelere_configs/deepspeed_zero3.yaml –num_processes ${NUM_GPUS} run_grpo.py –config $CONFIG_PATH

Resultados

Después de evaluar los modelos en 100 muestras de prueba, el modelo entrenado con GRPO de 8 disparos logró una precisión del 41 % en comparación con el 11 % del modelo base, lo que demuestra una mejora de 3,7 veces en el razonamiento matemático de la cadena de pensamiento.

El siguiente cuadro muestra un umbral distinto relacionado con la longitud del contexto, lo que revela un rango óptimo de muestras para la activación del razonamiento. Si bien las configuraciones de 0 disparos (6%) y 2 disparos (3%) tuvieron un desempeño deficiente (incluso peor que el modelo base), el rendimiento mejoró dramáticamente en el contexto de 4 disparos (33%), luego alcanzó su punto máximo en el contexto de 8 disparos (41%). Este patrón de escala no lineal sugiere que el entrenamiento GRPO crea patrones de razonamiento que requieren una cierta cantidad de ejemplos para activarse de manera efectiva. El modelo parece haber aprendido a aprovechar las comparaciones de grupos a partir de múltiples ejemplos, en consonancia con el enfoque de optimización de políticas basado en grupos de GRPO, donde el modelo aprende a comparar y seleccionar rutas de razonamiento óptimas a partir de múltiples soluciones generadas.

Extendiendo RLVR a otros dominios

Si bien esta publicación se centró en el razonamiento matemático con GSM8K, el enfoque RLVR se generaliza a dominios con resultados objetivamente verificables. Dos direcciones prometedoras demuestran esta versatilidad:

Generación de código con recompensas basadas en la ejecución

La generación de código proporciona verificación natural mediante la ejecución. Se pueden otorgar recompensas parciales cuando el código se compila y ejecuta sin errores, mientras que se logran recompensas completas cuando los resultados pasan pruebas unitarias integrales. Los expertos en el dominio especifican los requisitos mediante indicaciones en lenguaje natural, mientras que el modelo de recompensa evalúa automáticamente la corrección mediante la ejecución de código, lo que alivia la evaluación humana subjetiva.

Generación de texto de dominio específico con validación semántica

Para dominios especializados como redacción médica o técnica, las recompensas basadas en palabras clave pueden guiar a los modelos hacia la terminología adecuada. Las recompensas parciales fomentan la inclusión de términos requeridos, mientras que las recompensas completas requieren conjuntos completos de palabras clave en contextos semánticamente apropiados. Por ejemplo, la generación de textos médicos puede recompensar resultados que combinen palabras clave de diagnóstico (“síntomas”, “diagnóstico”) con palabras clave de tratamiento (“terapia”, “medicación”) en patrones clínicamente válidos, enseñando vocabulario de dominio a través de objetivos mensurables. Estos ejemplos ilustran cómo las recompensas verificables se extienden más allá del razonamiento matemático a tareas donde la corrección puede validarse mediante programación, sentando las bases para aplicaciones más amplias de este enfoque de capacitación.

Limpiar

Para limpiar sus recursos y evitar incurrir en más cargos, siga estos pasos:

Elimine todos los recursos de SageMaker Studio no utilizados. Opcionalmente, elimine el dominio de SageMaker Studio. Elimine los depósitos de S3 creados. ¡Verifique que su trabajo de capacitación ya no se esté ejecutando! Para hacerlo, en su consola SageMaker, elija Capacitación y marque Trabajos de capacitación.

Para obtener más información sobre cómo limpiar los recursos aprovisionados, consulte Limpiar.

Conclusión

En este ejemplo, entrenó un modelo Qwen2.5-0.5B utilizando GRPO (optimización de políticas relativas de grupo) en GSM8K: un conjunto de datos de 8500 problemas matemáticos planteados en la escuela primaria que requieren razonamiento aritmético de varios pasos y comprensión del lenguaje natural. Cada problema incluye una pregunta como "Los patos de Janet ponen 16 huevos por día…" con soluciones paso a paso que terminan en respuestas numéricas, lo que lo hace ideal para un entrenamiento de recompensa verificable.

Esta implementación demuestra la eficacia del aprendizaje por refuerzo con recompensas verificables (RLVR) para tareas de razonamiento matemático. El modelo Qwen2.5-0.5B entrenado por GRPO logró una mejora de 3,7 veces con respecto al modelo base, alcanzando una precisión del 41 % en GSM8K en comparación con el 11 % de referencia. Los resultados de la evaluación validan el RLVR como un enfoque prometedor para dominios con resultados objetivamente verificables, que ofrece una alternativa a los métodos de entrenamiento basados ​​en preferencias. El comportamiento del umbral sugiere que GRPO aprende a aprovechar las comparaciones de grupos a partir de múltiples ejemplos, de forma coherente con su enfoque de optimización basado en grupos. Este trabajo establece una base para aplicar sistemas de recompensa verificables a otros dominios que requieren rigor lógico y precisión matemática.

Para obtener más información sobre la capacitación totalmente administrada de Amazon SageMaker AI, consulte la sección de capacitación de la documentación de SageMaker AI. El código de soporte para esta publicación se puede encontrar en GitHub.

Sobre los autores

Surya Kari es científico senior de datos de IA generativa en AWS y se especializa en el desarrollo de soluciones que aprovechan modelos básicos de última generación. Tiene una amplia experiencia trabajando con modelos de lenguaje avanzados, incluidos DeepSeek-R1, la familia Llama y Qwen, centrándose en su ajuste y optimización para aplicaciones científicas específicas. Su experiencia se extiende a la implementación de canales de capacitación eficientes y estrategias de implementación utilizando AWS SageMaker, lo que permite escalar modelos básicos desde el desarrollo hasta la producción. Colabora con los clientes para diseñar e implementar soluciones de IA generativa, ayudándolos a navegar por la selección de modelos, afinar enfoques y estrategias de implementación para lograr un rendimiento óptimo para sus casos de uso específicos.

Giuseppe Zappia es arquitecto principal de soluciones especializado en IA/ML en AWS y se centra en ayudar a grandes empresas a diseñar e implementar soluciones de ML en AWS. Tiene más de 20 años de experiencia como ingeniero de software completo y ha pasado los últimos 6 años en AWS centrado en el campo del aprendizaje automático.

Amin Dashti es un científico de datos sénior e investigador en AWS que une un profundo conocimiento teórico con experiencia práctica en aprendizaje automático. Con experiencia en física teórica y más de siete años de experiencia, ha diseñado e implementado modelos escalables en todos los dominios, desde análisis predictivos e inferencia estadística en sistemas financieros hasta aplicaciones de vanguardia en visión por computadora (CV) y procesamiento del lenguaje natural (NLP).