Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Reinforcement fine-tuning (RFT) per i modelli Amazon Nova

Panoramica di

Che cos'è RFT?

Il Reinforcement Fine-Tuning (RFT) migliora le prestazioni del modello addestrandosi sui segnali di feedback (punteggi misurabili o premi che indicano le prestazioni del modello) anziché sulle risposte esatte e corrette. A differenza della messa a punto supervisionata che apprende dalle coppie input-output, RFT utilizza le funzioni di ricompensa per valutare le risposte del modello e ottimizza iterativamente il modello per massimizzare tali ricompense. Questo approccio eccelle quando è difficile definire l'output esatto e corretto, ma è possibile misurare in modo affidabile la qualità della risposta.

Quando usare RFT

Usa RFT quando puoi definire criteri di successo chiari e misurabili ma hai difficoltà a fornire risultati esatti e corretti per la formazione. È ideale per:

I migliori casi d'uso

RFT eccelle nei settori in cui la qualità dell'output può essere misurata oggettivamente, ma le risposte ottimali sono difficili da definire in anticipo:

Modelli supportati

Amazon NovaLite 2.0

Formato dei dati

I dati di addestramento RFT devono seguire il formato OpenAI Reinforcement Fine-Tuning. Ogni esempio di addestramento è un oggetto JSON contenente:

Esempio: problema matematico

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

Il reference_answer campo contiene l'output previsto o i criteri di valutazione utilizzati dalla funzione di ricompensa per assegnare un punteggio alla risposta del modello. Non si limita agli output strutturati, ma può contenere qualsiasi formato che aiuti la funzione di ricompensa a valutare la qualità.

Consigli sulle dimensioni dei set di dati

Punto di partenza

Approccio basato sulla valutazione

Prima di investire nella formazione RFT su larga scala, valuta le prestazioni di base del tuo modello:

Partire da un set di dati di piccole dimensioni consente di verificare che la funzione di ricompensa sia priva di bug, confermare che RFT sia l'approccio giusto per il caso d'uso, identificare e risolvere tempestivamente i problemi e testare il flusso di lavoro prima di procedere con l'espansione.

Caratteristiche dei dati di addestramento efficaci

Chiarezza e coerenza

I buoni esempi RFT richiedono dati di input chiari e inequivocabili che consentano un calcolo accurato della ricompensa tra i diversi output del modello. Evita il rumore nei dati, ad esempio formattazione incoerente, etichette o istruzioni contraddittorie, istruzioni ambigue e risposte di riferimento contrastanti. Qualsiasi ambiguità condurrà in errore il processo di formazione e indurrà il modello ad apprendere comportamenti non intenzionali.

Diversità

Il tuo set di dati dovrebbe catturare l'intera diversità dei casi d'uso di produzione per garantire solide prestazioni nel mondo reale. Includi diversi formati di input e casi limite, mappa i modelli di utilizzo effettivo della produzione mediante log e analisi degli utenti, campiona diversi tipi di utenti, aree geografiche e variazioni stagionali e includi livelli di difficoltà, da problemi semplici a complessi.

Considerazioni sulla funzione di ricompensa

Progetta la tua funzione di ricompensa per un allenamento efficiente. Dovrebbe essere eseguita in pochi secondi (non minuti), parallelizzarsi efficacemente con il modelloAWS Lambda, restituire punteggi coerenti e affidabili e gestire con eleganza diversi tipi di output del modello. Le funzioni di ricompensa veloci e scalabili consentono un'iterazione rapida e una sperimentazione conveniente.

Proprietà aggiuntive

Il formato di dati RFT supporta campi personalizzati oltre ai requisiti di base dello schema (e). messages reference_answer Questa flessibilità consente di aggiungere tutti i dati aggiuntivi necessari alla funzione di ricompensa per una corretta valutazione.

Proprietà aggiuntive comuni

Questi campi aggiuntivi vengono trasferiti alla funzione di ricompensa durante la valutazione, abilitando una sofisticata logica di punteggio personalizzata in base al caso d'uso specifico.

Esempi con proprietà aggiuntive

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

Il reference_answer campo contiene l'output previsto o i criteri di valutazione utilizzati dalla funzione di ricompensa per assegnare un punteggio alla risposta del modello. Non si limita agli output strutturati, ma può contenere qualsiasi formato che aiuti la funzione di ricompensa a valutare la qualità.

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
}

Implementazione delle funzioni di

Le funzioni di ricompensa sono implementate come funzioni Lambda che valutano le risposte del modello e restituiscono punteggi numerici. La funzione Lambda riceve messaggi e informazioni di base nel formato OpenAI e deve restituire punteggi come dizionario.

autorizzazioni IAM

Assicurati che il tuo ruolo di esecuzione dell' SageMaker IA disponga InvokeFunction delle autorizzazioni per la funzione Lambda.

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

Linee guida di progettazione

Quando scrivi funzioni di ricompensa, procedi come segue:

Formato dell'interfaccia

La tua funzione di ricompensa deve accettare e restituire dati nel seguente formato.

Struttura di input

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

Struttura di output

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

Esempio di funzione 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)

Configurazione di addestramento

Usa il modello di taccuino SageMaker AI Training Job per iniziare un lavoro di formazione. Per ulteriori informazioni, consulta Creare un lavoro di formazione.

Contenitore di formazione

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

Requisiti delle ist

Il contenitore supporta sia la formazione Full Rank che quella LoRa:

Selezione della modalità di ragionamento

Modalità disponibili

Quando usare ciascuna modalità

Usa high il ragionamento per attività analitiche complesse, risoluzione di problemi matematici, deduzione logica in più fasi e attività in cui il pensiero aggiunge valore. step-by-step

Usa none (omettireasoning_effort) o low ragiona per semplici domande fattuali, classificazioni dirette, ottimizzazione della velocità e dei costi e risposte dirette alle domande.

Compromessi in termini di costi e prestazioni

Le modalità di ragionamento più avanzate aumentano i tempi e i costi di formazione, la latenza e i costi dell'inferenza e la capacità di modellazione per attività di ragionamento complesse.

Monitoraggio della formazione

I registri di formazione includono metriche complete per ogni fase. Le categorie di metriche chiave includono quanto segue:

Utilizzo di modelli ottimizzati

Al termine dell'addestramento, il checkpoint finale del modello viene salvato nella posizione di output specificata. Il percorso del checkpoint è disponibile nei log di formazione e nel manifest.json file nella posizione di output di Amazon S3 (output_s3_uridefinita nel notebook).

Limitazioni e best practice

Limitazioni

Best practice