Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ajuste fino de refuerzos (RFT) para modelos Amazon Nova

Descripción general de

¿Qué es la RFT?

El ajuste preciso por refuerzo (RFT) mejora el rendimiento del modelo al entrenarse con las señales de retroalimentación (puntuaciones medibles o recompensas que indican el rendimiento del modelo) en lugar de con las respuestas exactas correctas. A diferencia de los ajustes supervisados, que aprenden de los pares de entradas y salidas, la RFT utiliza funciones de recompensa para evaluar las respuestas del modelo y lo optimiza de forma iterativa para maximizar estas recompensas. Este enfoque es excelente cuando es difícil definir el resultado exacto y correcto, pero se puede medir de forma fiable la calidad de la respuesta.

¿Cuándo usar la RFT

Utilice la RFT cuando pueda definir criterios de éxito claros y mensurables, pero tenga dificultades para proporcionar resultados exactos y correctos para la formación. Es ideal para:

Los mejores casos de uso

La RFT sobresale en ámbitos en los que la calidad de los resultados se puede medir objetivamente, pero las respuestas óptimas son difíciles de definir por adelantado:

Modelos compatibles

Amazon NovaLite 2.0

Formato de los datos

Los datos de entrenamiento de RFT deben seguir el formato OpenAI Reinforcement Fine-Tuning. Cada ejemplo de entrenamiento es un objeto JSON que contiene:

Ejemplo: problema matemático

{
  "id": "sample-001",
  "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"]
  }
}

El reference_answer campo 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 recompensa a evaluar la calidad.

Recomendaciones de tamaño del conjunto de datos

Punto de partida

Enfoque centrado en la evaluación

Antes de invertir en una formación de RFT a gran escala, evalúe el rendimiento básico de su modelo:

Empezar con un conjunto de datos pequeño te permite validar que tu función de recompensa está libre de errores, confirmar que la RFT es el enfoque adecuado para tu caso de uso, identificar y solucionar los problemas de forma temprana y probar el flujo de trabajo antes de ampliarlo.

Características de los datos de entrenamiento efectivos

Claridad y coherencia

Los buenos ejemplos de RFT requieren datos de entrada claros e inequívocos que permitan un cálculo preciso de las recompensas en los diferentes modelos de salida. Evite el ruido en los datos, como el formato incoherente, las etiquetas o instrucciones contradictorias, las indicaciones ambiguas y las respuestas de referencia contradictorias. Cualquier ambigüedad confundirá el proceso de formación y provocará que el modelo aprenda comportamientos no deseados.

Diversidad

Su conjunto de datos debe capturar toda la diversidad de casos de uso de producción para garantizar un rendimiento sólido en el mundo real. Incluye diferentes formatos de entrada y casos límite, mapea los patrones reales de uso de la producción a partir de registros y análisis de usuarios, toma muestras de distintos tipos de usuarios, regiones geográficas y variaciones estacionales, e incluye niveles de dificultad, desde problemas simples hasta problemas complejos.

Consideraciones sobre la función de recompensa

Diseñe su función de recompensa para un entrenamiento eficiente. Debería ejecutarse en cuestión de segundos (no minutos), paralelizarse de forma eficazAWS Lambda, obtener puntuaciones consistentes y fiables y gestionar los distintos tipos de resultados de los modelos con elegancia. Las funciones de recompensa rápidas y escalables permiten una iteración rápida y una experimentación rentable.

Propiedades adicionales

El formato de datos RFT admite campos personalizados que van más allá de los requisitos básicos del esquema (messagesyreference_answer). Esta flexibilidad le permite añadir cualquier dato adicional que su función de recompensas necesite para una evaluación adecuada.

Propiedades adicionales comunes

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.

Ejemplos con propiedades adicionales

Chemistry problem

{
  "id": "chem-001",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful chemistry assistant"
    },
    {
      "role": "user",
      "content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
    }
  ],
  "reference_answer": {
    "donor_bond_counts": 2,
    "acceptor_bond_counts": 4
  }
}

El reference_answer campo 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 recompensa a evaluar la calidad.

Math problem with metadata

{
  "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
}

Implementación de funciones de recompensa

Las funciones de recompensa se implementan como funciones Lambda que evalúan las respuestas del modelo y devuelven puntuaciones numéricas. La función Lambda recibe los mensajes y la verdad fundamental en el formato OpenAI y debe devolver las puntuaciones en forma de diccionario.

Permisos de IAM

Asegúrese de que su función de ejecución de SageMaker IA tenga InvokeFunction permisos para la función Lambda.

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-reward-function-lambda"
    }
  ]
}

Directrices de diseño

Al escribir las funciones de recompensa, haga lo siguiente:

Formato de interfaz

Tu función de recompensas debe aceptar y devolver datos en el siguiente formato.

Estructura de entrada

[{
  "id": "123",
  "messages": [
    {
      "role": "user",
      "content": "Do you have a dedicated security team?"
    },
    {
      "role": "assistant",
      "content": "As an AI developed by Amazon, I don not have a dedicated security team..."
    }
  ],
  "metadata": {
    "reference_answer": {
      "compliant": "No",
      "explanation": "As an AI developed by Company, I do not have a traditional security team..."
    },
    "my_key": "sample-001"
  }
}]

Estructura de salida

[{
  "id": "123",
  "aggregate_reward_score": 0.85,
  "metrics_list": [
    {
      "name": "accuracy",
      "value": 0.9,
      "type": "Reward"
    },
    {
      "name": "policy_compliance",
      "value": 0.8,
      "type": "Metric"
    }
  ]
}]

Ejemplo de función Lambda

from typing import List
import json
from dataclasses import asdict, dataclass

@dataclass
class RewardOutput:
    """Reward service output."""
    id: str
    aggregate_reward_score: float

def lambda_handler(event, context):
    """Main lambda handler"""
    return lambda_grader(event)

def lambda_grader(samples: list[dict]) -> list[dict]:
    """Core grader function"""
    scores: List[RewardOutput] = []
    for sample in samples:
        idx = sample["id"]
        ground_truth = sample.get("metadata", {}).get("reference_answer")
        
        if "messages" not in sample:
            print(f"Messages is None/empty for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        if ground_truth is None:
            print(f"No answer found in ground truth for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        # Get model's response (last turn is assistant turn)
        last_message = sample["messages"][-1]
        assert last_message["role"] == "assistant", "Last message must be from assistant"
        model_text = last_message["content"]
        
        ground_truth_text = _extract_ground_truth_text(ground_truth)
        
        if model_text.lower() == ground_truth_text.lower():
            score = 1.0
        else:
            score = 0.0
        
        ro = RewardOutput(id=idx, aggregate_reward_score=score)
        scores.append(ro)
    
    return [asdict(score) for score in scores]

def _extract_ground_truth_text(ground_truth) -> str:
    """Turn the ground_truth field into a plain string."""
    if isinstance(ground_truth, str):
        return ground_truth
    
    if isinstance(ground_truth, dict):
        if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str):
            return ground_truth["explanation"]
        if "answer" in ground_truth and isinstance(ground_truth["answer"], str):
            return ground_truth["answer"]
        return json.dumps(ground_truth, ensure_ascii=False)
    
    return str(ground_truth)

Configuración de entrenamiento

Usa la plantilla de cuaderno de trabajo de formación de SageMaker IA para iniciar un trabajo de formación. Para obtener más información, consulte Crear un trabajo de formación.

Contenedor de formación

708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-RFT-latest

Requisitos de instancia

El contenedor admite tanto el entrenamiento de rango completo como el de LoRa:

Selección del modo de razonamiento

Modos disponibles

Cuándo usar cada modo

Utilice el high razonamiento para tareas analíticas complejas, para la resolución de problemas matemáticos, para la deducción lógica en varios pasos y para tareas en las que step-by-step pensar aporta valor.

Utilice none (omitareasoning_effort) o low razone para consultas fácticas sencillas, clasificaciones directas, optimización de la velocidad y los costes y respuestas sencillas a las preguntas.

Compensaciones entre coste y rendimiento

Los modos de razonamiento superior aumentan el tiempo y el coste del entrenamiento, la latencia y el coste de las inferencias y la capacidad de modelar tareas de razonamiento complejas.

Supervisar la formación

Los registros de formación incluyen métricas completas en cada paso. Entre las categorías de métricas clave se incluyen las siguientes:

Uso de modelos ajustados

Una vez finalizado 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 los registros de entrenamiento y el manifest.json archivo en la ubicación de salida de Amazon S3 (definida output_s3_uri en su bloc de notas).

Limitaciones y mejores prácticas

Limitaciones

Prácticas recomendadas