La creación de funciones de recompensa eficaces puede ayudarle a personalizar los modelos de Amazon Nova según sus necesidades específicas, y AWS Lambda proporciona la base escalable y rentable. La arquitectura sin servidor de Lambda le permite centrarse en definir criterios de calidad mientras maneja la infraestructura computacional.
Amazon Nova ofrece múltiples enfoques de personalización, destacando el ajuste fino de refuerzo (RFT) por su capacidad para enseñar a los modelos los comportamientos deseados a través de comentarios iterativos. A diferencia del ajuste fino supervisado (SFT), que requiere miles de ejemplos etiquetados con rutas de razonamiento anotadas, RFT aprende de las señales de evaluación en los resultados finales. En el corazón de RFT se encuentra la función de recompensa: un mecanismo de puntuación que guía al modelo hacia mejores respuestas.
Esta publicación demuestra cómo Lambda permite funciones de recompensa escalables y rentables para la personalización de Amazon Nova. Aprenderá a elegir entre aprendizaje por refuerzo mediante recompensas verificables (RLVR) para tareas objetivamente verificables y aprendizaje por refuerzo mediante retroalimentación de IA (RLAIF) para una evaluación subjetiva, diseñará sistemas de recompensas multidimensionales que lo ayudarán a prevenir la piratería de recompensas, optimizará las funciones de Lambda para escalar el entrenamiento y monitoreará las distribuciones de recompensas con Amazon CloudWatch. Se incluyen ejemplos de código de trabajo y orientación de implementación para ayudarle a comenzar a experimentar.
Creación de recompensas basadas en código con AWS Lambda
Tiene múltiples caminos para personalizar los modelos de base, cada uno de ellos adecuado para diferentes escenarios. SFT sobresale cuando tiene ejemplos claros de entrada y salida y desea enseñar patrones de respuesta específicos; es particularmente efectivo para tareas como clasificación, reconocimiento de entidades nombradas o adaptación de modelos a terminología y convenciones de formato específicas de un dominio. SFT funciona bien cuando el comportamiento deseado se puede demostrar a través de ejemplos, lo que lo hace ideal para enseñar un estilo, una estructura o una transferencia de conocimientos factuales consistentes. Sin embargo, algunos desafíos de personalización requieren un enfoque diferente. Cuando las aplicaciones necesitan modelos para equilibrar múltiples dimensiones de calidad simultáneamente (como respuestas de servicio al cliente que deben ser precisas, empáticas, concisas y alineadas con la marca simultáneamente) o cuando la creación de miles de rutas de razonamiento anotadas resulta poco práctica, los métodos basados en refuerzo ofrecen una mejor alternativa. RFT aborda estos escenarios aprendiendo de las señales de evaluación en lugar de requerir demostraciones exhaustivas y etiquetadas de los procesos de razonamiento correctos.
Las funciones de recompensa basadas en AWS Lambda simplifican esto mediante el aprendizaje basado en comentarios. En lugar de mostrarle al modelo miles de ejemplos efectivos, usted proporciona indicaciones y define una lógica de evaluación que califica las respuestas; luego, el modelo aprende a mejorar a través de comentarios iterativos. Este enfoque requiere menos ejemplos etiquetados y al mismo tiempo le brinda un control preciso sobre los comportamientos deseados. La puntuación multidimensional captura criterios de calidad matizados que impiden que los modelos aprovechen los atajos, mientras que la arquitectura sin servidor de Lambda maneja cargas de trabajo de capacitación variables sin administración de infraestructura. El resultado es una personalización de Nova que es accesible para desarrolladores sin experiencia profunda en aprendizaje automático, pero lo suficientemente flexible para casos de uso de producción sofisticados.
Cómo funcionan las recompensas basadas en AWS Lambda
La arquitectura RFT utiliza AWS Lambda como evaluador de recompensas sin servidor que se integra con el canal de capacitación de Amazon Nova, creando un circuito de retroalimentación que guía el aprendizaje del modelo. El proceso comienza cuando su trabajo de capacitación genera respuestas de los candidatos del modelo Nova para cada mensaje de capacitación. Estas respuestas fluyen a su función Lambda, que evalúa su calidad en dimensiones como corrección, seguridad, formato y concisión. Luego, la función devuelve puntuaciones numéricas escalares, normalmente en el rango de -1 a 1 como práctica recomendada. Las puntuaciones más altas guían al modelo para reforzar las conductas que las produjeron, mientras que las puntuaciones más bajas lo alejan de los patrones que condujeron a respuestas deficientes. Este ciclo se repite miles de veces a lo largo del entrenamiento, moldeando progresivamente el modelo hacia respuestas que consistentemente obtienen mayores recompensas.
La arquitectura reúne varios servicios de AWS en una solución de personalización coherente. Lambda ejecuta su lógica de evaluación de recompensas con escalamiento automático que maneja demandas de capacitación variables sin necesidad de aprovisionar o administrar infraestructura. Amazon Bedrock proporciona la experiencia RFT totalmente administrada con soporte Lambda integrado y ofrece modelos de evaluación de IA para implementaciones de RLAIF a través de una sencilla interfaz de programación de aplicaciones (API). Para los equipos que necesitan un control de capacitación avanzado, Amazon SageMaker AI ofrece opciones a través de Amazon SageMaker AI Training Jobs y Amazon SageMaker AI HyperPod, ambos compatibles con las mismas funciones de recompensa basadas en Lambda. Amazon CloudWatch monitorea el rendimiento de Lambda en tiempo real, registra información de depuración detallada sobre las distribuciones de recompensas y el progreso de la capacitación, y activa alertas cuando surgen problemas. En la base se encuentra el propio Amazon Nova: modelos con recetas de personalización optimizadas en una amplia variedad de casos de uso que responden de manera efectiva a las señales de retroalimentación que brindan sus funciones de recompensa.
Este enfoque sin servidor hace que la personalización de Nova sea rentable. Lambda escala automáticamente desde el manejo de 10 evaluaciones simultáneas por segundo durante la experimentación inicial hasta más de 400 evaluaciones durante la capacitación en producción, sin ajuste de infraestructura ni planificación de capacidad. Su única función Lambda puede evaluar múltiples criterios de calidad simultáneamente, proporcionando retroalimentación matizada y multidimensional que evita que los modelos exploten atajos de puntuación simplistas. La arquitectura admite tanto la verificación objetiva a través de RLVR (ejecutar código contra casos de prueba o validar resultados estructurados) como el juicio subjetivo a través de RLAIF, donde los modelos de IA evalúan cualidades como el tono y la utilidad. Solo paga por el tiempo de cálculo real durante la evaluación con granularidad de facturación de milisegundos, lo que hace que la experimentación sea asequible y al mismo tiempo mantiene los costos de producción proporcionales a la intensidad del entrenamiento. Quizás lo más valioso para el desarrollo iterativo es que las funciones Lambda se guardan como activos de "Evaluador" reutilizables en Amazon SageMaker AI Studio, lo que le permite mantener una medición de calidad consistente a medida que perfecciona su estrategia de personalización en múltiples ejecuciones de capacitación.
Elegir el mecanismo de recompensas adecuado
La base de un RFT exitoso es elegir el mecanismo de retroalimentación adecuado. Dos enfoques complementarios sirven para diferentes casos de uso: RLVR y RLAIF son dos técnicas que se utilizan para ajustar modelos de lenguajes grandes (LLM) después de su entrenamiento inicial. Su principal diferencia radica en cómo proporcionan retroalimentación al modelo.
RLVR (Aprendizaje por refuerzo mediante recompensas verificables)
RLVR utiliza un código determinista para verificar la corrección objetiva. RLVR está diseñado para dominios donde una respuesta "correcta" se puede verificar matemática o lógicamente, por ejemplo, resolviendo un problema matemático. RLVR utiliza funciones deterministas para calificar los resultados en lugar de un modelo de recompensa aprendido. RLVR falla en tareas como la escritura creativa o la voz de la marca donde no existe una verdad absoluta.
Ideal para: generación de código, razonamiento matemático, tareas de salida estructuradas. Ejemplo: ejecutar código generado en casos de prueba, validar respuestas de API, verificar la precisión de los cálculos. Ventaja: puntuación determinista, confiable y auditable.
Las funciones RLVR verifican mediante programación la exactitud con respecto a la verdad básica. Aquí en este ejemplo se hace un análisis de sentimiento.
desde escribir import Lista importar json importar aleatorio desde clases de datos importar asdict, importar clase de datos re desde escribir importar Opcional def extract_answer_nova(solution_str: str) -> Opcional[str]: """Extraer polaridad de sentimiento de la respuesta con formato Nova para chABSA.""" # Primero intente extraer del bloque de solución solución_match = re.search(r'<|begin_of_solution|>(.*?)<|end_of_solution|>', solucion_str, re.DOTALL) if solución_match: solución_content = solución_match.group(1) # Buscar formato en caja en el bloque de solución boxed_matches = re.findall(r'\boxed{([^}]+)}', solución_content) if boxed_matches: return boxed_matches[-1].strip() # Alternativa: buscar formato en caja en cualquier lugar boxed_matches = re.findall(r'\boxed{([^}]+)}', solución_str) if boxed_matches: devolver boxed_matches[-1].strip() # Último recurso: buscar palabras clave de opinión solución_lower = solución_str.lower() para la opinión en ['positive', 'negative', 'neutral']: si sentimiento en solución_inferior: devolver sentimiento devolver Ninguno def normalize_answer(respuesta: str) -> str: """Normalizar respuesta para comparación.""" return respuesta.strip().lower() def Compute_score( solución_str: str, ground_truth: str, format_score: float = 0.0, puntuación: float = 1.0, data_source: str="chabsa", extra_info: Opcional[dict] = Ninguno) -> float: """función de puntuación chABSA con firma compatible con VeRL.""" respuesta = extract_answer_nova(solución_str) si la respuesta es Ninguna: devolver 0.0 # Analizar ground_truth JSON para obtener la respuesta gt_answer = ground_truth.get("answer", ground_truth) clean_answer = normalize_answer(answer) clean_ground_truth = normalize_answer(gt_answer) return puntuación si clean_answer == clean_ground_truth else format_score @dataclass clase RewardOutput: """Servicio de recompensa.""" id: str agregado_reward_score: float def lambda_handler(evento, contexto): puntuaciones: Lista[RewardOutput] =[]muestras = evento para muestra en muestras: # Extrae la clave de verdad fundamental. En el conjunto de datos actual, su respuesta es print("Muestra: ", json.dumps(muestra, sangría=2)) ground_truth = muestra["reference_answer"] idx = "no id" # print(muestra) si no es "id" en la muestra: print(f"ID es Ninguno/vacío para la muestra: {muestra}") else: idx = muestra["id"] ro = RewardOutput(id=idx, agregado_reward_score=0.0) si no es "mensajes" en la muestra: print(f"Mensajes es Ninguno/vacío para id: {idx}") puntuaciones.append(RewardOutput(id="0", agregado_reward_score=0.0)) continuar # Extraer respuesta del dictado de verdad sobre el terreno si tierra_verdad es Ninguno: print(f"No se encontró respuesta en verdad sobre el terreno para id: {idx}") puntuaciones.append(RewardOutput(id="0", agregado_reward_score=0.0)) continuar # Obtener finalización del último mensaje (mensaje del asistente) last_message = sample["messages"][-1] complete_text = last_message["content"] if last_message["role"] no está en ["assistant", "nova_assistant"]: print(f"El último mensaje no es del asistente para id: {idx}") puntuaciones.append(RewardOutput(id="0", agregado_reward_score=0.0)) continuar si no es "contenido" en el último_mensaje: print(f"El texto de finalización está vacío para id: {idx}") puntuaciones.append(RewardOutput(id="0", agregado_reward_score=0.0)) continuar puntuación_aleatoria = Compute_score(solution_str=completion_text, ground_truth=ground_truth) ro = RewardOutput(id=idx, agregado_reward_score=random_score) print(f"Respuesta para id: {idx} es {ro}") puntuaciones.append(ro) return [asdict(score) para puntuación en puntuaciones]
Su función RLVR debe incorporar tres elementos de diseño críticos para una capacitación eficaz. En primer lugar, cree un panorama de recompensas fluido otorgando crédito parcial; por ejemplo, proporcionando puntos format_score por una estructura de respuesta adecuada incluso cuando la respuesta final sea incorrecta. Esto evita acantilados de puntuación binaria que dificultan el aprendizaje. En segundo lugar, implemente una buena lógica de extracción con múltiples estrategias de análisis que manejen varios formatos de respuesta con elegancia. En tercer lugar, valide las entradas en cada paso utilizando prácticas de codificación defensiva que eviten fallos debidos a entradas con formato incorrecto.
RLAIF (Aprendizaje por refuerzo mediante retroalimentación de IA)
RLAIF utiliza modelos de IA como jueces para la evaluación subjetiva. RLAIF logra un rendimiento comparable al RLHF (aprendizaje por refuerzo mediante retroalimentación humana) y al mismo tiempo es significativamente más rápido y menos costoso. A continuación se muestra un ejemplo de código de función lambda RLVR para la clasificación de sentimientos.
Ideal para: Escritura creativa, resúmenes, alineación de la voz de la marca, utilidad Ejemplo: evaluar el tono de respuesta, evaluar la calidad del contenido, juzgar la alineación de la intención del usuario Ventaja: juicio escalable similar al de un humano sin costos de etiquetado manual
Las funciones de RLAIF delegan el juicio a modelos de IA capaces, como se muestra en este código de muestra a continuación.
import json import re import time import boto3 escribiendo import List, Dict, Any, Opcional bedrock_runtime = boto3.client('bedrock-runtime', region_name="us-east-1") JUDGE_MODEL_ID = "" #Reemplazar con el ID del modelo de juez de su interés SYSTEM_PROMPT = "Debe generar SOLO un número entre 0.0 y 1.0. Sin explicaciones, sin texto, solo el número." JUDGE_PROMPT_TEMPLATE = """Compare las siguientes dos respuestas y califique qué tan similares son en una escala de 0,0 a 1,0, donde: – 1,0 significa que las respuestas son semánticamente equivalentes (mismo significado, incluso si están redactadas de manera diferente) – 0,5 significa que las respuestas son parcialmente similares – 0,0 significa que las respuestas son completamente diferentes o contradictorias Respuesta A: {response_a} Respuesta B: {response_b} Genera SÓLO un número entre 0.0 y 1.0. Sin explicaciones.""" def extract_solution_nova(solution_str: str, método: str = "strict") -> Opcional[str]: """Extraer solución de la respuesta con formato Nova.""" método de afirmación en ["estricto", "flexible"] if método == "estricto": boxed_matches = re.findall(r'\boxed{([^}]+)}', solución_str) si boxed_matches: final_answer = boxed_matches[-1].replace(",", "").replace("$", "") return respuesta_final return Ninguno elif método == "flexible": boxed_matches = re.findall(r'\boxed{([^}]+)}', solución_str) if boxed_matches: números = re.findall(r"(\-?[0-9\.\,]+)", boxed_matches[-1]) if números: devuelve números[-1].replace(",", "").replace("$", "") respuesta = re.findall(r"(\-?[0-9\.\,]+)", solución_str) if len(respuesta) == 0: devuelve Ninguno else: invalid_str = ["", "."] para final_answer en reversa(respuesta): si final_answer no está en invalid_str: break return final_answer def lambda_graded(id: str, respuesta_a: str, respuesta_b: str, max_retries: int = 50) -> float: """Llame a Bedrock para comparar respuestas y devolver puntuación de similitud.""" solicitud = JUDGE_PROMPT_TEMPLATE.format(response_a=response_a, respuesta_b=response_b) para intento en el rango(max_retries): intente: respuesta = bedrock_runtime.converse( modelId=JUDGE_MODEL_ID, mensajes=[{"role": "usuario", "contenido": [{"text": solicitud}]}], sistema=[{"text": SYSTEM_PROMPT}], inferenceConfig={"temperatura": 0.0, "maxTokens": 10} ) salida = respuesta['salida']['mensaje']['contenido'][0]['text'].strip() puntuación = float(salida) devuelve max(0.0, min(1.0, puntuación)) excepto Excepción como e: si "ThrottlingException" en str(e) e intento < max_retries – 1: time.sleep(2 ** intento) else: devuelve 0.0 devuelve 0.0 def Compute_score(id: str, solucion_str: str, ground_truth: str) -> float: """Puntuación de cálculo para el formato train.jsonl.""" respuesta = extract_solution_nova(solution_str=solution_str, método="flexible") si la respuesta es Ninguna: devolver 0.0 clean_answer = str(answer) clean_ground_truth = str(ground_truth) puntuación = lambda_graded(id, respuesta_a=clean_answer, respuesta_b=clean_ground_truth) devolver puntuación def lambda_grader(muestras: List[Dict[str, Any]]) -> List[Dict[str, Any]]: """ Procesa muestras del formato train.jsonl y devuelve puntuaciones. Args: muestras: Lista de diccionarios con mensajes y metadatos Devuelve: Lista de diccionarios con puntuaciones de recompensa """ resultados =[]para muestra en muestras: sample_id = sample.get("id", "unknown") # Extraer respuesta de referencia de metadatos o metadatos de nivel superior = sample.get("metadata", {}) reference_answer = metadata.get("reference_answer", sample.get("reference_answer", {})) if isinstance(reference_answer, dict): ground_truth = reference_answer.get("answer", "") else: ground_truth = str(reference_answer) # Obtener respuesta del asistente de mensajes mensajes = sample.get("mensajes",[]) Assistant_response = "" para mensaje en reverso (mensajes): if message.get("role") in ["assistant", "nova_assistant"]: asistente_response = message.get("content", "") break si no asistente_respuesta o no ground_truth: results.append({ "id": sample_id, "aggregate_reward_score": 0.0 }) continuar # Calcular puntuación = Compute_score( id=sample_id, solución_str=assistant_response, ground_truth=ground_truth ) results.append({ "id": sample_id, "aggregate_reward_score": puntuación, "metrics_list": [ { "name": "semantic_similarity", "value": puntuación, "type": "Reward" } ] }) devuelve resultados def lambda_handler(evento, contexto): return lambda_grader(evento)
Al implementar la función RLAIF, considere la inicialización del cliente con variables globales para reducir la latencia general de las invocaciones. Maneje las excepciones de limitación con elegancia para evitar interrupciones en el entrenamiento. Utilice la temperatura 0,0 para puntuaciones deterministas de los jueces; ayuda a la coherencia del modelo. Y proporciona una rúbrica clara, ayuda a los jueces a proporcionar puntuaciones calibradas.
Consideraciones para escribir buenas funciones de recompensa
Para escribir buenas funciones de recompensa para RFT, comience de manera simple, cree un panorama de recompensas fluido (no acantilados binarios), asegúrese de que las recompensas se alineen con el verdadero objetivo (evite la piratería), use recompensas densas/con forma para tareas complejas, proporcione señales claras y hágalas verificables y consistentes.
Defina el objetivo con claridad: sepa exactamente cómo se ve el éxito para su modelo. Panorama de recompensas fluido: en lugar de un simple aprobado/reprobado (0 o 1), utilice un panorama suave y denso.
señales de recompensa que otorgan crédito parcial por estar “en el camino correcto”. Esta retroalimentación granular ayuda al modelo a aprender de mejoras incrementales en lugar de esperar una respuesta perfecta. Para tareas complejas de varios pasos, proporcione recompensas por el progreso intermedio (dar forma) en lugar de solo por el resultado final (escaso).
Hacer que las recompensas sean multidimensionales: una única recompensa escalar se piratea con demasiada facilidad. El
La recompensa debe evaluar el rendimiento del modelo desde múltiples dimensiones: por ejemplo, corrección, fidelidad a los datos aportados, alineación de seguridad/políticas, formato y concisión, etc.
Prevención de piratería de recompensas: asegúrese de que el modelo no pueda obtener recompensas elevadas mediante atajos
(por ejemplo, conjeturas afortunadas, acciones repetitivas); Haga que la tarea sea a prueba de conjeturas.
Utilice rúbricas verificables: para tareas objetivas como generación de código o matemáticas, utilice herramientas automatizadas.
Calificadores que ejecutan el código o analizan etiquetas de respuesta específicas (por ejemplo,) para verificar la corrección sin un ser humano en el circuito.
Implementar jueces LLM para tareas subjetivas: cuando el código programático no puede juzgar
la respuesta (p. ej., resumen), utilice un modelo capaz e independiente como “juez LLM”. Primero debes evaluar a este juez para asegurarte de que sus calificaciones sean estables y estén alineadas con las preferencias humanas.
Optimizar la ejecución de su función de recompensa dentro del ciclo de entrenamiento
Una vez que su función de recompensa funcione correctamente, la optimización le ayudará a entrenar más rápido mientras controla los costos. Esta sección cubre técnicas a considerar para sus cargas de trabajo. Las técnicas de optimización aumentan su impacto: una función Lambda bien configurada con un tamaño de lote adecuado, configuraciones de concurrencia, mitigación de arranque en frío y manejo de errores puede evaluar las respuestas diez veces más rápido que una implementación ingenua, al mismo tiempo que cuesta significativamente menos y proporciona una mejor confiabilidad de la capacitación. La inversión en optimización en las primeras etapas del proceso de personalización rinde frutos a lo largo de la capacitación al reducir el tiempo de iteración, disminuir los costos de computación y detectar problemas antes de que requieran una costosa recapacitación.
Asegúrese de que los permisos de IAM estén configurados correctamente antes de comenzar a entrenar
Gestión de dependencias y permisos
Cómo agregar dependencias: puede agruparlas directamente con su código en un paquete de implementación (archivo .zip) o usar capas Lambda para administrar las dependencias por separado de su lógica central. Creación de un paquete de implementación .zip (consulte las instrucciones aquí) Uso de capas Lambda (consulte las instrucciones aquí) Acceso a Amazon Bedrock para RLAIF: el rol de ejecución de la función Lambda debe tener acceso a Amazon Bedrock para la llamada API de LLM.
Utilice capas para dependencias compartidas entre múltiples funciones. Utilice paquetes de implementación para lógica específica de funciones. Adjunte permisos de AWS Identity and Access Management (IAM) al rol de ejecución de Lambda para implementaciones de RLAIF. Siguiendo el principio de privilegio mínimo, limite el ARN del recurso al modelo básico específico que está utilizando como juez en lugar de utilizar un comodín.
Comprender las diferencias de plataforma y qué plataforma podría ser más adecuada para sus necesidades
La optimización de las funciones de recompensa basadas en Lambda requiere comprender cómo interactúan los diferentes entornos de capacitación con la evaluación sin servidor y cómo las opciones arquitectónicas afectan el rendimiento, la latencia y el costo. El panorama de optimización difiere sustancialmente entre los modelos de procesamiento sincrónico y asincrónico, lo que hace que el ajuste específico del entorno sea esencial para la personalización a escala de producción.
Los trabajos de capacitación de IA de Amazon SageMaker emplean un procesamiento sincrónico que genera implementaciones primero antes de evaluarlas en lotes paralelos. Esta arquitectura crea distintas oportunidades de optimización en torno al tamaño de lotes y la gestión de concurrencia. El parámetro lambda_batch_size, cuyo valor predeterminado es 64, determina cuántas muestras evalúa Lambda en una sola invocación; ajuste esto más alto para funciones de recompensa rápidas que se completan en milisegundos, pero bájelo para evaluaciones complejas que se acercan a los umbrales de tiempo de espera. El parámetro lambda_concurrency controla la ejecución paralela; el valor predeterminado de 12 invocaciones simultáneas suele resultar conservador para cargas de trabajo de producción. Las funciones de recompensa rápida se benefician de una simultaneidad significativamente mayor, que a veces alcanza 50 o más ejecuciones simultáneas, aunque debe monitorear los límites de simultaneidad de Lambda a nivel de cuenta que limitan el total de ejecuciones simultáneas en todas sus funciones en una región.
Amazon SageMaker AI HyperPod adopta un enfoque fundamentalmente diferente mediante el procesamiento asincrónico que genera y evalúa muestras individualmente en lugar de en lotes grandes. Esta arquitectura muestra por muestra admite naturalmente un mayor rendimiento, con configuraciones predeterminadas que manejan 400 transacciones por segundo a través de Lambda sin ajustes especiales. Escalar más allá de esta línea base requiere un ajuste coordinado de los parámetros de la receta HyperPod, específicamente proc_num y rollout_worker_replicas que controlan el paralelismo de los trabajadores. Al escalar a los trabajadores de manera agresiva, considere aumentar las réplicas de generación proporcionalmente para evitar que la generación se convierta en el cuello de botella mientras la capacidad de evaluación permanece inactiva.
Optimización de la función de recompensa mediante la concurrencia de Lambda
La configuración Lambda impacta directamente en la velocidad y confiabilidad del entrenamiento:
Configuración de tiempo de espera: establezca el tiempo de espera en 60 segundos (el valor predeterminado es solo 3 segundos), esto proporciona margen para llamadas de jueces RLAIF o lógica RLVR compleja. Asignación de memoria: configure la memoria en 512 MB (el valor predeterminado es 128 MB), la CPU acelerada mejora el rendimiento del tiempo de respuesta Mitigación de arranque en frío
La mitigación del arranque en frío evita picos de latencia que pueden ralentizar el entrenamiento y aumentar los costos. Mantenga los paquetes de implementación por debajo de 50 MB para minimizar el tiempo de inicialización; esto a menudo significa excluir dependencias innecesarias y usar capas Lambda para bibliotecas compartidas grandes. Reutilice las conexiones entre invocaciones inicializando clientes como el cliente de tiempo de ejecución de Amazon Bedrock en un ámbito global en lugar de dentro de la función del controlador, lo que permite que el entorno de ejecución de Lambda mantenga estas conexiones entre invocaciones. Perfile su función utilizando Lambda Insights para identificar cuellos de botella en el rendimiento. Almacene en caché los datos a los que se accede con frecuencia, como rúbricas de evaluación, reglas de validación o parámetros de configuración en el ámbito global, de modo que Lambda los cargue una vez por contenedor en lugar de en cada invocación. Este patrón de inicialización global con ejecución a nivel de controlador resulta particularmente efectivo para funciones Lambda que manejan miles de evaluaciones durante el entrenamiento.
Optimización de los modelos de jueces RLAIF
Para las implementaciones de RLAIF que utilizan modelos de Amazon Bedrock como jueces, hay una importante compensación a considerar. Los modelos más grandes proporcionan juicios más confiables pero tienen un rendimiento menor, mientras que los modelos más pequeños ofrecen un mejor rendimiento pero pueden ser menos capaces; elija el modelo de juez más pequeño que sea suficiente para que su tarea maximice el rendimiento. Perfile la coherencia del juez antes de escalar al entrenamiento completo.
Gestión del rendimiento:
Supervise los límites de limitación de Amazon Bedrock a nivel regional. Considere los puntos finales de IA de Amazon SageMaker para los modelos de evaluación. Ofrece un mayor rendimiento, pero actualmente está limitado a modelos de peso abierto y Nova. Realiza múltiples evaluaciones por lotes por llamada API cuando sea posible. Cuenta para trabajos de capacitación simultáneos que comparten la cuota de Amazon Bedrock. Garantiza que su función de recompensa Lambda sea tolerante a errores y correctiva.
Los sistemas del mundo real encuentran fallas: problemas en la red, indisponibilidad temporal del servicio o tiempos de espera de Lambda ocasionales. En lugar de permitir que una sola falla descarrile todo su trabajo de capacitación, hemos creado mecanismos de reintento sólidos que manejan automáticamente los tiempos de espera, las fallas de Lambda y los errores transitorios. El sistema reintenta de forma inteligente los cálculos de recompensa fallidos con un retroceso exponencial, lo que da tiempo a los problemas temporales para resolverse. Si una llamada falla incluso después de tres intentos, recibirá un mensaje de error claro y procesable que señalará el problema específico, ya sea un tiempo de espera, un problema de permisos o un error en su lógica de recompensa. Esta transparencia le permite identificar y solucionar problemas rápidamente sin tener que examinar registros crípticos.
Depuración iterativa de CloudWatch y detección temprana de cualquier signo de error
La visibilidad de su proceso de capacitación es esencial tanto para monitorear el progreso como para solucionar problemas. Registramos automáticamente información completa en CloudWatch para cada etapa del proceso de capacitación: las métricas de cada paso de capacitación, incluidas puntuaciones de recompensa de capacitación por pasos y seguimientos de ejecución detallados para cada componente del proceso. Este registro granular facilita el seguimiento del progreso del entrenamiento en tiempo real, verifica que su función de recompensa esté calificando las respuestas como se esperaba y diagnostica rápidamente los problemas cuando surgen. Por ejemplo, si nota que el entrenamiento no mejora, puede examinar las distribuciones de recompensas en CloudWatch para ver si su función devuelve principalmente ceros o si no hay señal suficiente.
CloudWatch proporciona visibilidad integral del desempeño de la función de recompensa. A continuación se muestran algunas consultas útiles de Amazon CloudWatch Insights para la solución.
Conclusión
Las funciones de recompensa basadas en Lambda desbloquean la personalización de Amazon Nova para organizaciones que necesitan un control de comportamiento preciso sin conjuntos de datos etiquetados masivos ni un razonamiento mejorado. Este enfoque ofrece ventajas significativas a través de flexibilidad, escalabilidad y rentabilidad que agilizan el proceso de personalización de su modelo. La arquitectura permite que RLVR maneje tareas de verificación objetiva, mientras que RLAIF ayuda con juicios subjetivos para evaluaciones de calidad matizadas. Las organizaciones pueden usarlos individualmente o combinarlos para una evaluación integral que capture tanto la precisión de los hechos como las preferencias estilísticas. La escalabilidad surge naturalmente de la base sin servidor, manejando automáticamente cargas de trabajo de capacitación variables desde la experimentación temprana hasta la personalización a escala de producción. La rentabilidad surge directamente de este diseño: las organizaciones pagan solo por la computación de evaluación real, y los trabajos de capacitación se completan más rápido debido a la simultaneidad de Lambda optimizada y al cálculo eficiente de recompensas. La combinación de los modelos básicos de Amazon Nova, la escalabilidad sin servidor de Lambda y la infraestructura de personalización administrada de Amazon Bedrock hace que el ajuste de refuerzo sea más accesible independientemente de la escala organizacional. Comience a experimentar con el código de muestra de este blog y comience a personalizar los modelos de Amazon Nova que ofrecen exactamente los comportamientos que sus aplicaciones necesitan.
Expresiones de gratitud
Un agradecimiento especial a Eric Grudzien y Anupam Dewan por su revisión y contribuciones a esta publicación.
Acerca de los autores
Bharata Balaji
Bharathan Balaji es científico aplicado senior en Amazon Web Services y trabaja en aprendizaje por refuerzo y servicios de modelos básicos. Su trabajo se centra en desarrollar capacidades de IA que ayuden a los clientes a transformar sus negocios.
Manoj Gupta
Manoj Gupta es arquitecto senior de soluciones en AWS, con sede en San Francisco. Con más de 4 años de experiencia en AWS, trabaja en estrecha colaboración con los clientes para crear soluciones optimizadas impulsadas por AI/ML e infraestructura en la nube. Sus principales áreas de enfoque son datos, IA/ML y seguridad, ayudando a las organizaciones a modernizar sus pilas de tecnología. Fuera del trabajo, le gustan las actividades al aire libre y viajar con la familia.
Brian Hu
Brian Hu es científico aplicado senior en AWS y se especializa en ajustes supervisados y de refuerzo y sus aplicaciones en varios dominios. Trabaja en estrecha colaboración con los clientes para personalizar modelos de lenguaje grandes (LLM) para mejorar el rendimiento y la optimización específica del dominio.
Sarthak Khanna
Sarthak Khanna es ingeniero de desarrollo de software en Amazon AGI y se especializa en sistemas de IA agentes y de ajuste de refuerzo. Su trabajo se centra en crear canales de capacitación escalables para modelos de lenguaje grandes, aprovechando el aprendizaje por refuerzo para permitir el razonamiento de múltiples turnos, el uso de herramientas y la toma de decisiones autónoma.