Crie e gerencie trabalhos de ajuste fino para modelos Amazon Nova - Amazon Bedrock
Pré-requisitosCrie seu trabalho de RFTMonitore seu trabalho de treinamento em RFTConfigurar inferência

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Crie e gerencie trabalhos de ajuste fino para modelos Amazon Nova

Você pode criar um trabalho de ajuste fino de reforço (RFT) usando o console ou a API do Amazon Bedrock. O trabalho de RFT pode levar algumas horas, dependendo do tamanho dos dados de treinamento, do número de épocas e da complexidade das funções de recompensa.

Pré-requisitos

  • Crie uma função de serviço do IAM com as permissões necessárias. Para obter informações abrangentes sobre segurança e permissões, incluindo permissões específicas de RFT, consulte. Acesso e segurança para modelos Amazon Nova

  • (Opcional) Criptografe dados de entrada e saída, seu trabalho de RFT ou solicitações de inferência feitas em modelos personalizados. Para obter mais informações, consulte Criptografia de modelos personalizados.

Crie seu trabalho de RFT

Escolha a guia correspondente ao método de sua preferência e siga as etapas:

Console

Para enviar uma tarefa de RFT no console, execute as seguintes etapas:

  1. Abra o console Amazon Bedrock e navegue até Modelos personalizados em Tune.

  2. Escolha Criar e, em seguida, Criar tarefa de ajuste fino de reforço.

  3. Na seção Detalhes do modelo, escolha Amazon Nova 2 Lite como seu modelo básico.

  4. Na seção Detalhes da personalização, insira o nome da personalização.

  5. Na seção Dados de treinamento, escolha sua fonte de dados. Selecione entre seus registros de invocação disponíveis armazenados no Amazon S3, selecione a localização do Amazon S3 do seu arquivo de conjunto de dados de treinamento ou carregue um arquivo diretamente do seu dispositivo.

    nota

    Seu conjunto de dados de treinamento deve estar no formato de dados de conclusão do OpenAI Chat. Se você fornecer registros de invocação no formato de invocação ou conversão do Amazon Bedrock, o Amazon Bedrock os converterá automaticamente para o formato de conclusão de bate-papo.

  6. Na seção Função de recompensa, configure seu mecanismo de recompensa:

    • Modelo como juiz (RLAIF) - Selecione um modelo base hospedado no Bedrock como juiz e configure as instruções para avaliação. Use isso para tarefas subjetivas, como moderação de conteúdo.

      nota

      A opção Model as judge do console converte automaticamente sua configuração em uma função Lambda durante o treinamento.

    • Código personalizado (RLVR) - Crie funções de recompensa personalizadas usando código Python executado por meio de funções Lambda. Use isso para tarefas objetivas, como geração de código.

    Para obter mais informações, consulte Configurando funções de recompensa para modelos Amazon Nova.

  7. (Opcional) Na seção Hiperparâmetros, ajuste os parâmetros de treinamento ou use valores padrão.

  8. Na seção Dados de saída, insira o local do Amazon S3 onde o Amazon Bedrock deve salvar as saídas do trabalho.

  9. Na seção Configuração da função, escolha uma função existente na lista suspensa ou insira um nome para a função de serviço a ser criada.

  10. (Opcional) Na seção Configuração adicional, configure os dados de validação apontando para um bucket do Amazon S3, configurações de criptografia KMS e tags de trabalho e modelo.

  11. Escolha Criar tarefa de ajuste fino de reforço para começar a tarefa.

API

Envie uma CreateModelCustomizationJob solicitação com customizationType set toREINFORCEMENT_FINE_TUNING.

Campos obrigatórios: roleArnbaseModelIdentifier,customModelName,jobName,,trainingDataConfig,outputDataConfig, rftConfig

Exemplo de solicitação:

{
    "roleArn": "arn:aws:iam::123456789012:role/BedrockRFTRole",
    "baseModelIdentifier": "amazon.nova-2.0",
    "customModelName": "my-rft-model",
    "jobName": "my-rft-job",
    "customizationType": "REINFORCEMENT_FINE_TUNING",
    "trainingDataConfig": {
        "s3Uri": "s3://my-bucket/training-data.jsonl"
    },
    "customizationConfig": {
        "rftConfig" : {
            "graderConfig": {
                "lambdaGrader": {
                    "lambdaArn": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
                }
            },
            "hyperParameters": {
                "batchSize": 64,
                "epochCount": 2,
                "evalInterval": 10,
                "inferenceMaxTokens": 8192,
                "learningRate": 0.00001,
                "maxPromptLength": 4096,
                "reasoningEffort": "high",
                "trainingSamplePerPrompt": 4
            }
        }
    },
    "outputDataConfig": {
        "s3Uri": "s3://my-bucket/rft-output/"
    }
}

Solicitação de amostra da API Python:

import boto3

bedrock = boto3.client(service_name='bedrock')
    
# Set parameters
customizationType = "REINFORCEMENT_FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-2-lite-v1:0:256k"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"

customizationConfig = {
    'rftConfig' : {
        'graderConfig': {
            'lambdaGrader': {
                'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:function-name'
            }
        },
        'hyperParameters': {
            'batchSize': 64,
            'epochCount': 2,
            'evalInterval': 10,
            'inferenceMaxTokens': 8192,
            'learningRate':0.00001,
            'maxPromptLength': 4096,
            'reasoningEffort': 'high',
            'trainingSamplePerPrompt':4
        }
    }
}

trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}

# Create job
response_ft = bedrock.create_model_customization_job(
    jobName=jobName, 
    customModelName=customModelName,
    roleArn=roleArn,
    baseModelIdentifier=baseModelIdentifier,
    customizationConfig=customizationConfig,
    trainingDataConfig=trainingDataConfig,
    outputDataConfig=outputDataConfig,
    customizationType=customizationType
)

jobArn = response_ft['jobArn']

Monitore seu trabalho de treinamento em RFT

O Amazon Bedrock fornece monitoramento em tempo real com gráficos e métricas visuais durante o treinamento de RFT. Essas métricas ajudam você a entender se o modelo converge adequadamente e se a função de recompensa orienta efetivamente o processo de aprendizado.

Rastreamento do status do trabalho

Você pode monitorar o status do seu trabalho de RFT por meio das fases de validação e treinamento no console do Amazon Bedrock.

Indicadores de conclusão:

  • O status do trabalho muda para Concluído quando o treinamento é concluído com êxito

  • O modelo ARN personalizado fica disponível para implantação

  • As métricas de treinamento atingem limites de convergência

Métricas de treinamento em tempo real

O Amazon Bedrock fornece monitoramento em tempo real durante o treinamento de RFT com gráficos visuais exibindo métricas de treinamento e validação.

Principais métricas de treinamento

  • Perda de treinamento - mede o quão bem o modelo está aprendendo com os dados de treinamento

  • Estatísticas de recompensa de treinamento - Mostra as pontuações de recompensa atribuídas por suas funções de recompensa

  • Margem de recompensa - mede a diferença entre recompensas de resposta boa e ruim

  • Precisão nos conjuntos de treinamento e validação - Mostra o desempenho do modelo nos dados de treinamento e retidos

Categorias métricas detalhadas

  • Métricas de recompensa — critic/rewards/meancritic/rewards/max,, critic/rewards/min (distribuição de recompensas) e val-score/rewards/mean@1 (recompensas de validação)

  • Comportamento do modelo — actor/entropy (variação da política; quanto maior, mais exploratório)

  • Saúde do treinamento — actor/pg_loss (perda do gradiente da política), actor/pg_clipfrac (frequência de atualizações recortadas) e actor/grad_norm (magnitude do gradiente)

  • Características de resposta —prompt_length/mean,prompt_length/max, prompt_length/min (estatísticas do token de entrada),response_length/mean,response_length/max, response_length/min (estatísticas do token de saída) e response/aborted_ratio (taxa de geração incompleta; 0 é igual a tudo concluído)

  • Desempenho — perf/throughput (produtividade do treinamento), perf/time_per_step (tempo por etapa do treinamento) e timing_per_token_ms/* (tempos de processamento por token)

  • Uso de recursos —perf/max_memory_allocated_gb, perf/max_memory_reserved_gb (memória da GPU) e perf/cpu_memory_used_gb (memória da CPU)

Visualização do progresso do treinamento

O console exibe gráficos interativos que são atualizados em tempo real à medida que seu trabalho de RFT progride. Essas visualizações podem ajudar você a:

  • Rastreie a convergência em direção ao desempenho ideal

  • Identifique possíveis problemas de treinamento com antecedência

  • Determine os pontos de parada ideais

  • Compare o desempenho em diferentes épocas

Configurar inferência

Após a conclusão do trabalho, implante o modelo RFT para inferência sob demanda ou use o Provisioned Throughput para obter um desempenho consistente. Para configurar a inferência, consulteConfigurar a inferência para um modelo personalizado.

Use Test in Playground para avaliar e comparar as respostas com o modelo básico. Para avaliar seu modelo RFT completo, consulte. Avalie seu modelo de RFT