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á. # Personalize um modelo com ajuste fino de reforço no Amazon Bedrock O ajuste fino por reforço é uma técnica de personalização de modelos no Amazon Bedrock que melhora o desempenho do modelo básico ao ensinar aos modelos o que constitui uma resposta “boa” por meio de sinais de feedback chamados recompensas. Ao contrário dos métodos tradicionais de ajuste fino que dependem de conjuntos de dados rotulados, o ajuste fino por reforço usa uma abordagem orientada por feedback que otimiza iterativamente o modelo para maximizar essas recompensas. ## Aplicativos e cenários de ajuste fino de reforço Use o ajuste fino de reforço quando puder definir critérios de sucesso claros e mensuráveis para avaliar a qualidade da resposta. O ajuste fino do reforço é excelente em domínios em que a qualidade da saída pode ser medida objetivamente, especialmente quando existem várias respostas válidas ou quando as respostas ideais são difíceis de definir antecipadamente. É ideal para: + Resolução de problemas matemáticos e geração de código (usando avaliadores baseados em regras para avaliação objetiva) + Raciocínio científico e análise estruturada de dados + Tarefas subjetivas, como acompanhamento de instruções, moderação de conteúdo e redação criativa (usando juízes baseados em IA) + Tarefas que exigem step-by-step raciocínio ou solução de problemas em vários turnos + Cenários com várias soluções válidas em que algumas são claramente melhores do que outras + Aplicações que equilibram vários objetivos (precisão, eficiência, estilo) + Aplicativos que exigem aprimoramento iterativo, personalização ou adesão a regras de negócios complexas + Cenários em que o sucesso pode ser verificado programaticamente por meio de resultados de execução ou métricas de desempenho + Casos em que coletar exemplos rotulados de alta qualidade é caro ou impraticável ## Benefícios do ajuste fino do reforço + **Melhor desempenho do modelo** — O ajuste fino do reforço melhora a precisão do modelo em até 66%, em média, em comparação com os modelos básicos. Isso permite a otimização de preço e desempenho por meio do ajuste fino de variantes de modelos menores, mais rápidas e mais eficientes. + **Facilidade de uso** — O Amazon Bedrock automatiza a complexidade do ajuste fino do reforço, tornando-o acessível aos desenvolvedores que criam aplicativos de IA. Você pode ajustar os modelos usando seus conjuntos de dados enviados ou registros de invocação de API existentes. Você pode definir funções de recompensa que classificam as saídas do modelo com código personalizado usando o Lambda model-as-a-judge ou o grader, com modelos integrados que ajudam na configuração rápida. + **Segurança e conformidade** — Seus dados proprietários nunca saem AWS do ambiente seguro e controlado durante o processo de personalização. ## Modelos compatíveis para ajuste fino do reforço A tabela a seguir mostra os modelos de base que você pode personalizar com o ajuste fino do reforço: **Modelos compatíveis para ajuste fino do reforço** | Fornecedor | Modelo | ID do modelo | Nome da região | Região | | --- | --- | --- | --- | --- | | Amazon | Nova 2 Lite | amazon.nova-2-lite-v1:0:256k | Leste dos EUA (Norte da Virgínia) | us-east-1 | | OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | Oeste dos EUA (Oregon) | us-west-2 | | Qwen | Qwen3 32B | qwen.qwen3-32b | Oeste dos EUA (Oregon) | us-west-2 | ## Como funciona o ajuste fino do reforço O Amazon Bedrock automatiza totalmente o fluxo de trabalho de ajuste fino de reforço. O modelo recebe solicitações do seu conjunto de dados de treinamento e gera várias respostas por solicitação. Essas respostas são então pontuadas por uma função de recompensa. O Amazon Bedrock usa os pares de resposta rápida com pontuações para treinar o modelo por meio do aprendizado baseado em políticas usando a Otimização de Política Relativa de Grupo (GRPO). O ciclo de treinamento continua até chegar ao final de seus dados de treinamento ou até você interromper o trabalho em um ponto de verificação escolhido, produzindo um modelo otimizado para a métrica que é importante para você. ## Reforço e ajuste fino das melhores práticas + **Comece pequeno** — comece com 100-200 exemplos, valide a exatidão da função de recompensa e escale gradualmente com base nos resultados + **Avaliação de pré-ajuste fino** — Teste o desempenho do modelo básico antes do ajuste fino do reforço. Se as recompensas forem consistentemente de 0%, use primeiro o ajuste fino supervisionado para estabelecer as capacidades básicas. Se as recompensas forem maiores que 95 por cento, o ajuste fino do reforço pode ser desnecessário + **Monitore o treinamento** — Acompanhe as pontuações médias e a distribuição das recompensas. Cuidado com o ajuste excessivo (as recompensas de treinamento aumentam enquanto as recompensas de validação diminuem). Procure padrões preocupantes, como estabilização das recompensas abaixo de 0,15, aumento da variação da recompensa ao longo do tempo e diminuição do desempenho de validação + **Otimize as funções de recompensa** — execute em segundos (não em minutos), minimize as chamadas externas de API, use algoritmos eficientes, implemente o tratamento adequado de erros e aproveite o escalonamento paralelo do Lambda + **Estratégia de iteração** — Se as recompensas não estiverem melhorando, ajuste o design da função de recompensa, aumente a diversidade do conjunto de dados, adicione exemplos mais representativos e verifique se os sinais de recompensa são claros e consistentes **Topics** + [Aplicativos e cenários de ajuste fino de reforço](#reinforcement-fine-tuning-when) + [Benefícios do ajuste fino do reforço](#reinforcement-fine-tuning-benefits) + [Modelos compatíveis para ajuste fino do reforço](#rft-supported-models) + [Como funciona o ajuste fino do reforço](#rft-how-it-works) + [Reforço e ajuste fino das melhores práticas](#rft-best-practices) + [Ajuste os modelos Amazon Nova com ajuste fino de reforço](rft-nova-models.md) + [Ajuste modelos de peso aberto usando -compatible OpenAI APIs](fine-tuning-openai-apis.md) + [Avalie seu modelo de RFT](rft-evaluate-model.md) # Ajuste os modelos Amazon Nova com ajuste fino de reforço Antes de fazer o ajuste fino, certifique-se de ter os pré-requisitos, pois o Amazon Bedrock precisa de permissões específicas para criar e gerenciar o processo de ajuste fino. Para obter informações abrangentes sobre segurança e permissões, consulte[Acesso e segurança para modelos Amazon Nova](rft-access-security.md). Execute o ajuste fino de reforço para os modelos Amazon Nova em 5 etapas: 1. **Forneça o conjunto de dados de treinamento** — faça o upload de solicitações no formato necessário (por exemplo, JSONL) como conjunto de dados de treinamento de ajuste fino de reforço. Para obter mais informações, consulte [Prepare dados para os modelos Amazon Nova](rft-prepare-data.md). 1. **Configurar a função de recompensa (avaliador)** — Defina um avaliador para pontuar as respostas do modelo com base na exatidão, estrutura, tom ou outros objetivos. A função de recompensa pode ser executada usando o Lambda para calcular as pontuações objetivas. Você também pode escolher um modelo como juiz (via console) e avaliar as respostas com base nos critérios e princípios que você configura (o console os converte em funções Lambda automaticamente). Para obter mais informações, consulte [Configurando funções de recompensa para modelos Amazon Nova](reward-functions.md). 1. **Envie o trabalho de ajuste fino do reforço — Inicie o trabalho** de ajuste fino do reforço especificando o modelo base, o conjunto de dados, a função de recompensa e outras configurações opcionais, como hiperparâmetros. Para obter mais informações, consulte [Crie e gerencie trabalhos de ajuste fino para modelos Amazon Nova](rft-submit-job.md). 1. **Monitore o treinamento** — acompanhe o status do trabalho, as métricas de recompensa e o progresso do treinamento até a conclusão. Para obter mais informações, consulte [Monitore seu trabalho de treinamento em RFT](rft-submit-job.md#rft-monitor-job). 1. **Use um modelo ajustado** — após a conclusão do trabalho, implante o modelo RFT resultante com um clique para inferência sob demanda. Você também pode usar o Provisioned Throughput para cargas de trabalho de missão crítica que exigem desempenho consistente. Consulte [Configurar a inferência para um modelo personalizado](model-customization-use.md). Use **Test in Playground** para avaliar e comparar as respostas com o modelo básico. **Importante** Você pode fornecer no máximo 20 mil solicitações ao Amazon Bedrock para reforçar o ajuste fino do modelo. ## Modelos Nova compatíveis A tabela a seguir mostra os modelos do Amazon Nova que você pode personalizar com o ajuste fino do reforço: **nota** Para obter informações sobre modelos adicionais compatíveis, incluindo modelos de peso aberto, consulte[Ajuste modelos de peso aberto usando -compatible OpenAI APIs](fine-tuning-openai-apis.md). **Modelos compatíveis para ajuste fino do reforço** | Fornecedor | Modelo | ID do modelo | Suporte ao modelo de região única | | --- | --- | --- | --- | | Amazon | Nova 2 Lite | amazon.nova-2-lite-v1:0:256k | us-east-1 | # Acesso e segurança para modelos Amazon Nova Antes de começar o ajuste fino do reforço, certifique-se de entender que tipo de acesso o Amazon Bedrock precisa para operações específicas de RFT. O RFT requer permissões adicionais além do ajuste fino padrão devido aos seus recursos de execução da função de recompensa. Para a configuração básica de segurança da personalização do modelo, incluindo relações de confiança, permissões do Amazon S3 e criptografia KMS, consulte. [Criar um perfil de serviço do IAM para a personalização de modelo](custom-model-job-access-security.md#custom-model-job-service-role) ## Pré-requisitos Antes de adicionar permissões do IAM específicas do RFT, você deve adicionar as seguintes funções de serviço do IAM: + [Relação de confiança](custom-model-job-access-security.md#custom-model-job-service-role-trust-relationship) + [Permissões para acessar arquivos de treinamento e de validação e gravar os arquivos de saída no S3](custom-model-job-access-security.md#custom-model-job-service-role-s3-permissions) ## Permissões do IAM específicas do RFT Adicione essas permissões à sua função de serviço de personalização de modelo existente para a funcionalidade RFT. ### Permissões do Lambda para funções de recompensa Você deve adicionar permissões de invocação do Lambda. Veja a seguir um exemplo de política que você pode usar: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:reward-function-name" ] } ] } ``` ### Acesso ao registro de invocação Para usar os registros de invocação do modelo Amazon Bedrock existentes como dados de treinamento, adicione permissões para acessar seu bucket do Amazon S3 onde os registros de invocação são armazenados. Você precisa fornecer permissões de acesso ao bucket do Amazon S3 para o bucket de entrada. Veja a seguir um exemplo de política que você pode usar: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::s3-invocation-logs-bucket", "arn:aws:s3:::s3-invocation-logs-bucket/*" ] } ] } ``` Para configuração de segurança, incluindo funções básicas do IAM, permissões do Amazon S3 e criptografia, consulte. [Criar um perfil de serviço do IAM para a personalização de modelo](custom-model-job-access-security.md#custom-model-job-service-role) ## Permissões da função Grader Lambda para RLAIF Se você criar sua própria função Lambda para Aprendizado por Reforço a partir de funções de recompensa de Feedback de IA (RLAIF), precisará adicionar permissões específicas à função de execução do Lambda. ### Permissões fundamentais para juízes de LLM Para funções de LLM-as-Judge recompensa (RLAIF), adicione permissões para invocar modelos básicos. Veja a seguir um exemplo de política que você pode usar para sua função de execução do Lambda. **nota** Adicione essas permissões à sua função de execução do Lambda somente se você criar sua própria função do Lambda. O console lida com isso automaticamente ao criar funções Lambda por meio do console. A seguir está um exemplo de LLM básico como invocação de juiz usando modelos básicos: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "bedrock:InvokeModel" ], "Resource": [ "arn:aws:bedrock:*:*:foundation-model/*" ] } ] } ``` A seguir está um exemplo de LLM básico como invocação de juiz usando perfil de inferência: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "bedrock:InvokeModel" ], "Resource": [ "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-premier-v1:0", "arn:aws:bedrock:us-east-2::foundation-model/amazon.nova-premier-v1:0", "arn:aws:bedrock:us-west-2::foundation-model/amazon.nova-premier-v1:0" ], "Condition": { "StringLike": { "bedrock:InferenceProfileArn": "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0" } } }, { "Effect": "Allow", "Action": [ "bedrock:InvokeModel" ], "Resource": [ "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0" ] } ] } ``` Para obter informações sobre os pré-requisitos do perfil de inferência, consulte [Pré-requisitos](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html) para perfis de inferência. # Prepare dados para os modelos Amazon Nova Ao ajustar um modelo do Amazon Nova com ajuste fino de reforço, você pode trazer seus próprios prompts ou usar os registros de invocação da API Amazon Bedrock existentes como dados de treinamento. ## Requisitos e fontes de dados de treinamento Você pode fornecer dados de treinamento por meio de uma das seguintes opções: **nota** Só oferecemos suporte ao formato de conclusão de bate-papo do OpenAI. ### Opção 1: forneça suas próprias instruções Colete seus prompts e armazene-os no formato de arquivo `.jsonl`. Você pode fazer upload de conjuntos de dados personalizados no formato JSONL ou selecionar conjuntos de dados existentes do Amazon S3. Cada registro no JSONL deve usar o formato de conclusão de bate-papo do OpenAI na seguinte estrutura: + `messages`: nesse campo, inclua a função de usuário, sistema ou assistente contendo o prompt de entrada fornecido ao modelo. + `reference_answer`: nesse campo, ele deve conter o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade. + [Opcional] Você pode adicionar campos usados pelo avaliador Lambda para avaliação. **Requisitos:** + Formato JSONL com prompts no formato de conclusão de chat OpenAI (um prompt por linha) + Um mínimo de 100 registros no conjunto de dados de treinamento + O Amazon Bedrock valida automaticamente o formato do conjunto de dados de treinamento ------ #### [ Example: General question-answering ] ``` { "messages": [ { "role": "system", "content": "You are a helpful assistant" }, { role": "user", "content": "What is machine learning?"} ], "reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed." } ``` ------ #### [ Example: Math problem ] ``` { "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"] } } ``` ------ ### Opção 2: usar registros de invocação Ao criar um trabalho de ajuste fino de reforço, você pode fazer com que o Amazon Bedrock use os registros de invocação existentes do seu bucket do S3 como dados de treinamento. Para o Amazon Bedrock, um log de invocação é um registro detalhado das invocações do modelo. Você pode usar registros de invocação de Invoke/Converse API armazenados no lado do cliente do Amazon S3 para treinamento. **Requisitos:** + O registro de API deve estar habilitado para seu uso do Amazon Bedrock + Os registros devem estar em um formato compatível (Amazon Bedrock Invoke/Converse API) + Um mínimo de 100 exemplos de solicitações Para usar registros de invocação para reforçar o ajuste fino, configure o login de invocação do modelo, use uma das operações de invocação do modelo e certifique-se de ter configurado um bucket do Amazon S3 como destino para os registros. Para obter mais informações sobre como configurar os registros de invocação, consulte [Monitorar a invocação do modelo usando o Logs e o CloudWatch Amazon](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) S3. Antes de iniciar o trabalho de ajuste fino de reforço com registros de invocação de um bucket do S3 como entrada, você deve fornecer permissões ao Amazon Bedrock para acessar os registros de um bucket do S3. Para obter mais informações, consulte [Acesso e segurança na personalização de modelos](custom-model-job-access-security.md). Opcionalmente, você pode adicionar metadados de solicitação aos pares de prompt-resposta no log de invocação usando uma das operações de invocação do modelo e depois usá-los para filtrar os logs. O Amazon Bedrock pode usar os registros filtrados para ajustar o modelo. #### Adicione metadados de solicitação às solicitações e respostas em seus registros de invocação Com os registros de invocação, você pode identificar as solicitações do conjunto de dados de treinamento que você deseja que o Amazon Bedrock use para reforçar o ajuste fino usando metadados de solicitação anexados aos registros de invocação. Veja a seguir um exemplo de um registro de invocação de uma `InvokeModel` chamada com o: `requestMetadata` ``` { "schemaType": "ModelInvocationLog", "schemaVersion": "1.0", "timestamp": "2024-09-11T17:16:18Z", "accountId": "XXXXX", "identity": { "arn": "arn:aws:sts::XXXXXXX:assumed-role/Admin/XXXXXX" }, "region": "us-east-1", "requestId": "7ee514f3-9eff-467c-af75-8fd564ce58e5", "operation": "InvokeModel", "modelId": "meta.llama3-1-405b-instruct-v1:0", "input": { "inputContentType": "application/json", "inputBodyJson": { "prompt": "story of two dogs", "max_tokens_to_sample": 300 }, "inputTokenCount": 13 }, "output": { "outputContentType": "application/json", "outputBodyJson": { "type": "completion", "completion": " Here is a story about two dogs:\n\nRex and Charlie were best friends who lived next door to each other. Every morning, their owners would let them out into the backyard to play. Rex was a golden retriever with long, shaggy fur. He loved to run and chase sticks. Charlie was a corgi with short legs and a big smile. He was happy just sniffing the grass and rolling around. \n\nThe two dogs spent every day playing together. Rex would grab a stick and bring it over to Charlie, wagging his tail excitedly. Charlie would take the other end of the stick in his mouth and they'd have a friendly game of tug-of-war. After tiring themselves out, they'd flop down in the warm sunshine for a nap. \n\nAt lunchtime, their owners would call them in for food. Rex would gobble up his kibble hungrily while Charlie ate his at a more leisurely pace. After lunch, it was right back outside for more playtime. The afternoon sunbeams would light up their fur as they chased each other around the yard. \n\nWhen it started getting late, their owners called them in for the night. Rex and Charlie would head inside, tired but happy after another fun day of play. After slurping up fresh water from their bowls, they'd curl up on their beds, Rex's fluffy golden tail tucked over his nose and little", "stop_reason": "max_tokens", "stop": null }, "outputTokenCount": 300 }, "requestMetadata": { "project": "CustomerService", "intent": "ComplaintResolution", "priority": "High" } } ``` Você pode especificar o registro de invocação como sua fonte de dados de entrada ao iniciar um trabalho de ajuste fino de reforço. Você pode iniciar um trabalho de ajuste fino de reforço por meio do console Amazon Bedrock, usando a API ou o SDK. AWS CLI ##### Requisitos para fornecer metadados de solicitação Os metadados solicitados devem cumprir os seguintes requisitos: + Fornecido no formato JSON `key:value`. + O par de chave-valor deve ser uma string de no máximo 256 caracteres. + Forneça no máximo de 16 pares de chave-valor. ##### Usar filtros de metadados de solicitação Depois que os registros de invocação com metadados de solicitação estiverem disponíveis, você poderá aplicar filtros com base nos metadados da solicitação para escolher seletivamente quais solicitações incluir para ajustar o modelo. Por exemplo, talvez você queira incluir somente aqueles com metadados `"project": "CustomerService"` e `"priority": "High"` solicitados. Para filtrar os registros usando vários metadados de solicitação, use um único operador `AND` booleano ou. `OR` Você não pode combinar esses operadores. Para filtragem de metadados de solicitação única, use o operador `Equals` ou`Not Equals`. ## Características dos dados de treinamento efetivos Dados eficazes de treinamento de RFT requerem três características principais: + **Clareza e consistência** — use instruções claras e inequívocas com formatação consistente. Evite rótulos contraditórios, instruções ambíguas ou respostas de referência conflitantes que enganem o treinamento. + **Diversidade** — inclua formatos de entrada variados, casos extremos e níveis de dificuldade que refletem os padrões de uso da produção em diferentes tipos e cenários de usuários. + **Funções de recompensa eficientes** — Crie funções que sejam executadas rapidamente (segundos, não minutos), que se paralelizem e retornem pontuações consistentes para um treinamento econômico. AWS Lambda ## Propriedades adicionais O formato de dados RFT oferece suporte a campos personalizados além dos requisitos principais do esquema (`messages`e`reference_answer`). Essa flexibilidade permite que você adicione quaisquer dados adicionais que sua função de recompensa precise para uma avaliação adequada. **nota** Você não precisa configurar isso em sua receita. O formato de dados suporta inerentemente campos adicionais. Basta incluí-los em seus dados de treinamento JSON e eles serão passados para sua função de recompensa em `metadata` campo. **Propriedades adicionais comuns** + `task_id`— Identificador exclusivo para rastreamento + `difficulty_level`— Indicador de complexidade do problema + `domain`— Área temática ou categoria + `expected_reasoning_steps`— Número de etapas na solução Esses campos adicionais são passados para sua função de recompensa durante a avaliação, permitindo uma lógica de pontuação sofisticada adaptada ao seu caso de uso específico. **Exemplos com propriedades adicionais** ------ #### [ 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 } } ``` O `reference_answer` campo contém o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade. ------ #### [ 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 } ``` ------ # Configurando funções de recompensa para modelos Amazon Nova As funções de recompensa avaliam a qualidade da resposta e fornecem sinais de feedback para o treinamento do modelo. Você pode configurar funções de recompensa usando funções personalizadas do Lambda ou modelos de fundação hospedados no Amazon Bedrock como juízes. Modelos guiados estão disponíveis para simplificar a criação de funções de recompensa para tarefas comuns, como acompanhamento de instruções e validação de formato. Escolha a abordagem que corresponda aos requisitos da sua tarefa. ## Aprendizagem por reforço por meio de recompensas verificáveis (RLVR) O RLVR otimiza modelos para tarefas objetivas, como geração de código ou raciocínio matemático, usando avaliadores ou modelos baseados em regras verificáveis. ready-to-use Você tem duas opções para RLVR (Código Personalizado): ### Opção 1: usar modelos fornecidos pelo console O console Amazon Bedrock fornece exemplos de modelos para as funções do nivelador Lambda: + Raciocínio matemático com verificação da verdade básica + Validação de formato e verificação de restrições + Modelo Lambda de avaliador genérico com código padronizado Siga as instruções no modelo fornecido na página de **trabalho Create RFT** no console [Amazon Bedrock](https://console.aws.amazon.com/bedrock). ### Opção 2: Traga sua própria função Lambda Crie funções de recompensa personalizadas usando seu próprio ARN do Lambda para cálculos lógicos complexos APIs, externos e de várias etapas ou combinando vários critérios de avaliação. **nota** Se você trouxer sua própria função Lambda, tenha em mente o seguinte: Aumente o tempo limite do Lambda do padrão de 3 segundos para o máximo 15 minutos para avaliações complexas. A função de execução do Lambda precisa de permissões para invocar modelos, conforme descrito em. [Acesso e segurança para modelos Amazon Nova](rft-access-security.md) ## Aprendizagem por reforço por meio de feedback de IA (RLAIF) O RLAIF otimiza modelos para tarefas subjetivas, como acompanhamento de instruções ou interações de chatbots, usando juízes baseados em IA com modelos. ready-to-use **Para RLAIF (modelo como juiz):** + Selecione um modelo base hospedado no Amazon Bedrock como juiz + Configurar instruções para avaliação + Definir critérios de avaliação e diretrizes de pontuação Modelos de LLM-as-Judge prompt disponíveis no console Amazon Bedrock: + Instrução seguinte (treinamento do modelo Judge) + Sumarização (caixas de diálogo com várias voltas) + Avaliação do raciocínio (CoT para domínios especializados) + Fidelidade ao RAG (perguntas e respostas baseadas no contexto) **nota** A opção **Model as Judge** do console converte automaticamente sua configuração em uma função Lambda durante o treinamento. ## Detalhes da implementação da função Lambda Ao implementar funções personalizadas de recompensa do Lambda, sua função deve aceitar e retornar dados no formato a seguir. ------ #### [ Input structure ] ``` [{ "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" } }] ``` ------ #### [ Output structure ] ``` [{ "id": "123", "aggregate_reward_score": 0.85, "metrics_list": [ { "name": "accuracy", "value": 0.9, "type": "Reward" }, { "name": "policy_compliance", "value": 0.8, "type": "Metric" } ] }] ``` ------ **Diretrizes de design** + **Classifique as respostas** — Dê à melhor resposta uma pontuação claramente mais alta + **Use verificações consistentes** — Avalie a conclusão da tarefa, a aderência ao formato, a segurança e a duração razoável + **Mantenha o escalonamento estável** — mantenha as pontuações normalizadas e não exploráveis # 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](rft-access-security.md) + (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](https://docs.aws.amazon.com/bedrock/latest/userguide/encryption-custom-job.html). ## 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**. 1. Escolha **Criar** e, em seguida, **Criar tarefa de ajuste fino de reforço**. 1. Na seção **Detalhes do modelo**, escolha **Amazon Nova 2 Lite** como seu modelo básico. 1. Na seção **Detalhes da personalização**, insira o nome da personalização. 1. 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. 1. 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](reward-functions.md). 1. (Opcional) Na seção **Hiperparâmetros**, ajuste os parâmetros de treinamento ou use valores padrão. 1. Na seção **Dados de saída**, insira o local do Amazon S3 onde o Amazon Bedrock deve salvar as saídas do trabalho. 1. 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. 1. (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. 1. Escolha **Criar tarefa de ajuste fino de reforço para começar a tarefa**. ------ #### [ API ] Envie uma CreateModelCustomizationJob solicitação com `customizationType` set to`REINFORCEMENT_FINE_TUNING`. **Campos obrigatórios:** `roleArn``baseModelIdentifier`,`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/mean``critic/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, consulte[Configurar a inferência para um modelo personalizado](model-customization-use.md). 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](rft-evaluate-model.md) # Ajuste modelos de peso aberto usando -compatible OpenAI APIs O Amazon Bedrock fornece endpoints de API OpenAI compatíveis para ajustar os modelos básicos. Esses endpoints permitem que você use ferramentas familiares para criar, monitorar OpenAI SDKs e gerenciar trabalhos de ajuste fino com os modelos Amazon Bedrock. Esta página destaca o uso deles APIs para o ajuste fino do reforço. ## Capacidades gerais + **Carregar arquivos de treinamento** — Use a API Files para carregar e gerenciar dados de treinamento para trabalhos de ajuste fino + **Crie tarefas de ajuste fino — Comece a ajustar tarefas** com dados de treinamento personalizados e funções de recompensa + **Listar e recuperar trabalhos** — Visualize todos os trabalhos de ajuste fino e obtenha informações detalhadas sobre trabalhos específicos + **Monitore eventos de trabalho** — acompanhe o progresso do ajuste fino por meio de registros de eventos detalhados + **Pontos de verificação de acesso — Recupere pontos** de verificação do modelo intermediário criados durante o treinamento + **Inferência imediata — Após a conclusão do ajuste fino, use o modelo ajustado resultante para inferência** sob demanda por meio do OpenAI compatível com o Amazon Bedrock (API de respostas/preenchimentos de bate-papo) sem etapas adicionais de implantação APIs + **Fácil migração** — Compatível com as bases de código OpenAI SDK existentes ## Fluxo de trabalho de reforço e ajuste fino para modelos de peso aberto Antes de fazer o ajuste fino, certifique-se de ter os pré-requisitos, pois o Amazon Bedrock precisa de permissões específicas para criar e gerenciar o processo de ajuste fino. Para obter informações abrangentes sobre segurança e permissões, consulte[Acesso e segurança para modelos de peso aberto](rft-open-weight-access-security.md). Execute o ajuste fino do reforço para modelos de peso aberto em 5 etapas: 1. **Carregar conjunto de dados de treinamento** — Use a API de arquivos para fazer upload de solicitações no formato necessário (por exemplo, JSONL) com o objetivo de “ajuste fino” como reforço e ajuste fino do conjunto de dados de treinamento. Para obter mais informações, consulte [Prepare dados para modelos de peso aberto](rft-prepare-data-open-weight.md). 1. **Configurar a função de recompensa** — defina um avaliador para pontuar as respostas do modelo com base na exatidão, estrutura, tom ou outros objetivos usando as funções Lambda. Para obter mais informações, consulte [Configurando funções de recompensa para modelos de peso aberto](reward-functions-open-weight.md). 1. **Crie um trabalho de ajuste fino — Inicie o trabalho** de ajuste fino de reforço usando a API OpenAI compatível especificando o modelo básico, o conjunto de dados, a função de recompensa e outras configurações opcionais, como hiperparâmetros. Para obter mais informações, consulte [Crie um trabalho de ajuste fino](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job). 1. **Monitore o progresso do treinamento** — Acompanhe o status do trabalho, os eventos e as métricas de treinamento usando os trabalhos de ajuste fino. APIs Para obter mais informações, consulte [Listar eventos de ajuste fino](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Acesse os pontos de verificação do modelo intermediário para avaliar o desempenho em diferentes estágios de treinamento, consulte[Listar pontos de verificação de ajuste fino](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints). 1. **Execute inferência** — Use o ID do modelo ajustado diretamente para inferência por meio de respostas ou conclusões de bate-papo compatíveis com o Amazon Bedrock. OpenAI APIs Para obter mais informações, consulte [Execute inferência com um modelo ajustado](fine-tuning-openai-job-create.md#fine-tuning-openai-inference). ## Regiões e endpoints compatíveis A tabela a seguir mostra os modelos básicos e as regiões que oferecem suporte a ajustes APIs finos OpenAI compatíveis: **Modelos e regiões OpenAI compatíveis para ajustes finos compatíveis APIs** | Fornecedor | Modelo | ID do modelo | Nome da região | Região | Endpoint | | --- | --- | --- | --- | --- | --- | | OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | Oeste dos EUA (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws | | Qwen | Qwen3 32B | qwen.qwen3-32b | Oeste dos EUA (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws | # Acesso e segurança para modelos de peso aberto Antes de começar o ajuste fino de reforço (RFT), certifique-se de entender que tipo de acesso o Amazon Bedrock precisa para operações específicas de RFT. O RFT requer permissões adicionais além do ajuste fino padrão devido aos seus recursos de execução da função de recompensa. ## Pré-requisitos Antes de usar o ajuste fino OpenAI compatível com o Amazon Bedrock APIs, certifique-se de ter o seguinte: 1. Uma AWS conta com permissões apropriadas para acessar o Amazon Bedrock 1. **Autenticação** — Você pode se autenticar usando: + Chave de API Amazon Bedrock (necessária para o OpenAI SDK e disponível para solicitações HTTP) + AWS credenciais (com suporte para solicitações HTTP) **nota** [Se você estiver usando chaves de API de curto e longo prazo do Amazon Bedrock, certifique-se de que sua função tenha acesso às seguintes permissões de política do IAM: e Role. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions) 1. **OpenAISDK (opcional)** — Instale o SDK do OpenAI Python se estiver usando solicitações baseadas em SDK. 1. **Variáveis de ambiente** — Defina as seguintes variáveis de ambiente: + `OPENAI_API_KEY`— Defina sua chave de API Amazon Bedrock + `OPENAI_BASE_URL`— Defina como o endpoint Amazon Bedrock da sua região (por exemplo,) `https://bedrock-mantle.us-west-2.api.aws/v1` Para obter mais informações, consulte [API de respostas](bedrock-mantle.md#bedrock-mantle-responses). 1. **Dados de treinamento** formatados como arquivos JSONL com a finalidade. `fine-tune` Para obter mais informações, consulte [Prepare dados para modelos de peso aberto](rft-prepare-data-open-weight.md). ## Permissões do Lambda para funções de recompensa Você deve adicionar permissões de invocação do Lambda. Veja a seguir um exemplo de política que você pode usar: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:reward-function-name" ] } ] } ``` Você também pode usar modelos hospedados pelo Amazon Bedrock como juízes para configurar funções de recompensa. Você precisará adicionar permissões específicas para invocar modelos básicos na função de execução do Lambda. Em sua função lambda, você pode configurar essas políticas gerenciadas LLMs para avaliação. Consulte [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html). Veja a seguir um exemplo para invocar os modelos da fundação Amazon Bedrock como juiz usando a API Invoke: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "bedrock:InvokeModel" ], "Resource": [ "arn:aws:bedrock:*:*:foundation-model/*" ] } ] } ``` # Prepare dados para modelos de peso aberto Ao ajustar modelos de peso aberto com ajuste fino de reforço usando compatibilidade com OpenAI, forneça dados de treinamento trazendo seus próprios APIs prompts no formato JSONL com essa finalidade. `fine-tune` ## Formato e requisitos dos dados de treinamento Os dados de treinamento devem seguir o formato de conclusão de bate-papo do OpenAI com exemplos de 100 a 20 mil. Cada exemplo de treinamento contém: + `messages`: nesse campo, inclua a função de usuário, sistema ou assistente contendo o prompt de entrada fornecido ao modelo. + `reference_answer`: nesse campo, ele deve conter o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade. + [Opcional] Você pode adicionar campos usados pelo avaliador Lambda para avaliação. **Requisitos:** + Formato JSONL com prompts no formato de conclusão de chat OpenAI (um prompt por linha) + O objetivo deve ser definido como `fine-tune` + Um mínimo de 100 registros no conjunto de dados de treinamento + O Amazon Bedrock valida automaticamente o formato do conjunto de dados de treinamento ------ #### [ Example: General question-answering ] ``` { "messages": [ { "role": "system", "content": "You are a helpful assistant" }, { role": "user", "content": "What is machine learning?"} ], "reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed." } ``` ------ #### [ Example: Math problem ] ``` { "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"] } } ``` ------ ## API de arquivos Você pode usar a API de arquivos compatível com OpenAI para carregar seus dados de treinamento para trabalhos de ajuste fino. Os arquivos são armazenados com segurança no Amazon Bedrock e usados na criação de trabalhos de ajuste fino. Para obter detalhes completos da API, consulte a [documentação de OpenAI Arquivos](https://platform.openai.com/docs/api-reference/files). ### Carregar arquivo de treinamento Para fazer o upload de um arquivo de treinamento, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Upload training file with open(TRAINING_FILE_PATH, 'rb') as f: file_response = client.files.create( file=f, purpose='fine-tune' ) # Store file ID for next steps training_file_id = file_response.id print(f"✅ Training file uploaded successfully: {training_file_id}") ``` ------ #### [ HTTP request ] Faça uma solicitação POST para`/v1/files`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/files \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -F purpose="fine-tune" \ -F file="@training_data.jsonl" ``` ------ ### Recuperar detalhes do arquivo Para recuperar detalhes sobre um arquivo específico, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Retrieve file details file_details = client.files.retrieve(training_file_id) # Print raw response print(json.dumps(file_details.model_dump(), indent=2)) ``` ------ #### [ HTTP request ] Faça uma solicitação GET para`/v1/files/{file_id}`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \ -H "Authorization: Bearer $OPENAI_API_KEY" ``` ------ ### Listar arquivos Para listar os arquivos enviados, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # List files files_response = client.files.list(purpose='fine-tune') # Print raw response print(json.dumps(files_response.model_dump(), indent=2)) ``` ------ #### [ HTTP request ] Faça uma solicitação GET para`/v1/files`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \ -H "Authorization: Bearer $OPENAI_API_KEY" ``` ------ ### Excluir arquivo Para excluir um arquivo, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Delete file delete_response = client.files.delete(training_file_id) ``` ------ #### [ HTTP request ] Faça uma solicitação DELETE para`/v1/files/{file_id}`: ``` curl -X DELETE https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \ -H "Authorization: Bearer $OPENAI_API_KEY" ``` ------ ## Características dos dados de treinamento efetivos Dados efetivos de treinamento de RFT requerem três características principais: + **Clareza e consistência** — use instruções claras e inequívocas com formatação consistente. Evite rótulos contraditórios, instruções ambíguas ou respostas de referência conflitantes que enganem o treinamento. + **Diversidade** — inclua formatos de entrada variados, casos extremos e níveis de dificuldade que refletem os padrões de uso da produção em diferentes tipos e cenários de usuários. + **Funções de recompensa eficientes** — Crie funções que sejam executadas rapidamente (segundos, não minutos), que se paralelizem e retornem pontuações consistentes para um treinamento econômico. AWS Lambda ## Propriedades adicionais O formato de dados RFT oferece suporte a campos personalizados além dos requisitos principais do esquema (`messages`e`reference_answer`). Essa flexibilidade permite que você adicione quaisquer dados adicionais que sua função de recompensa precise para uma avaliação adequada. **nota** Você não precisa configurar isso em sua receita. O formato de dados suporta inerentemente campos adicionais. Basta incluí-los em seus dados de treinamento JSON e eles serão passados para sua função de recompensa em `metadata` campo. **Propriedades adicionais comuns** + `task_id`— Identificador exclusivo para rastreamento + `difficulty_level`— Indicador de complexidade do problema + `domain`— Área temática ou categoria + `expected_reasoning_steps`— Número de etapas na solução Esses campos adicionais são passados para sua função de recompensa durante a avaliação, permitindo uma lógica de pontuação sofisticada adaptada ao seu caso de uso específico. **Exemplos com propriedades adicionais** ------ #### [ 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 } } ``` O `reference_answer` campo contém o resultado esperado ou os critérios de avaliação que sua função de recompensa usa para pontuar a resposta do modelo. Ela não se limita a resultados estruturados — ela pode conter qualquer formato que ajude sua função de recompensa a avaliar a qualidade. ------ #### [ 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 } ``` ------ # Configurando funções de recompensa para modelos de peso aberto As funções de recompensa avaliam a qualidade da resposta e fornecem sinais de feedback para o treinamento do modelo. Você pode configurar funções de recompensa usando funções personalizadas do Lambda. Escolha a abordagem que corresponda aos requisitos da sua tarefa. ## Funções personalizadas do Lambda para avaliação de recompensas Você pode configurar funções de recompensa usando funções personalizadas do Lambda. Em sua função Lambda, você tem flexibilidade na forma como implementa a lógica de avaliação: + **Tarefas objetivas** — Para tarefas objetivas, como geração de código ou raciocínio matemático, use avaliadores baseados em regras verificáveis que verifiquem a exatidão em relação a padrões ou casos de teste conhecidos. + Tarefas **subjetivas — Para tarefas** subjetivas, como acompanhamento de instruções ou interações com chatbots, chame os modelos da Amazon Bedrock Foundation como juízes em sua função Lambda para avaliar a qualidade da resposta com base em seus critérios. Sua função Lambda pode implementar lógica complexa, integrar componentes externos APIs, realizar cálculos em várias etapas ou combinar vários critérios de avaliação, dependendo dos requisitos de sua tarefa. **nota** Ao usar funções personalizadas do Lambda: Aumente o tempo limite do Lambda do padrão de 3 segundos para o máximo 15 minutos para avaliações complexas. A função de execução do Lambda precisa de permissões para invocar a função Lambda, conforme descrito em. [Permissões do Lambda para funções de recompensa](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions) ## Detalhes da implementação da função Lambda Ao implementar funções personalizadas de recompensa do Lambda, sua função deve aceitar e retornar dados no formato a seguir. ------ #### [ Input structure ] ``` [{ "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" } }] ``` ------ #### [ Output structure ] ``` [{ "id": "123", "aggregate_reward_score": 0.85, "metrics_list": [ { "name": "accuracy", "value": 0.9, "type": "Reward" }, { "name": "policy_compliance", "value": 0.8, "type": "Metric" } ] }] ``` ------ **Diretrizes de design** + **Classifique as respostas** — Dê à melhor resposta uma pontuação claramente mais alta + **Use verificações consistentes** — Avalie a conclusão da tarefa, a aderência ao formato, a segurança e a duração razoável + **Mantenha o escalonamento estável** — mantenha as pontuações normalizadas e não exploráveis # Crie e gerencie trabalhos de ajuste fino para modelos de peso aberto usando o OpenAI APIs O trabalho de ajuste fino compatível com OpenAI APIs permite que você crie, monitore e gerencie trabalhos de ajuste fino. Esta página destaca o uso deles APIs para o ajuste fino do reforço. Para obter detalhes completos da API, consulte a documentação [OpenAIde ajuste fino](https://platform.openai.com/docs/api-reference/fine-tuning). ## Crie um trabalho de ajuste fino Cria um trabalho de ajuste fino que inicia o processo de criação de um novo modelo a partir de um determinado conjunto de dados. Para obter detalhes completos da API, consulte a documentação sobre como [OpenAIcriar trabalhos de ajuste fino](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create). ### Exemplos Para criar um trabalho de ajuste fino com o método RFT, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Create fine-tuning job with RFT method job_response = client.fine_tuning.jobs.create( model=MODEL_ID, training_file=training_file_id, # Suffix field is not supported so commenting for now. # suffix="rft-example", # Optional: suffix for fine-tuned model name extra_body={ "method": { "type": "reinforcement", "reinforcement": { "grader": { "type": "lambda", "lambda": { "function": "arn:aws:lambda:us-west-2:123456789012:function:my-reward-function" # Replace with your Lambda ARN } }, "hyperparameters": { "n_epochs": 1, # Number of training epochs "batch_size": 4, # Batch size "learning_rate_multiplier": 1.0 # Learning rate multiplier } } } } ) # Store job ID for next steps job_id = job_response.id print({job_id}) ``` ------ #### [ HTTP request ] Faça uma solicitação POST para`/v1/fine_tuning/jobs`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "training_file": "file-abc123", "model": "gpt-4o-mini", "method": { "type": "reinforcement", "reinforcement": { "grader": { "type": "lambda", "lambda": { "function": "arn:aws:lambda:us-west-2:123456789012:function:my-grader" } }, "hyperparameters": { "n_epochs": 1, "batch_size": 4, "learning_rate_multiplier": 1.0 } } } }' ``` ------ ## Listar eventos de ajuste fino Lista eventos para um trabalho de ajuste fino. Eventos de ajuste fino fornecem informações detalhadas sobre o progresso do seu trabalho, incluindo métricas de treinamento, criação de pontos de verificação e mensagens de erro. Para obter detalhes completos da API, consulte a documentação da [OpenAILista de eventos de ajuste fino](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events). ### Exemplos Para listar eventos de ajuste fino, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # List fine-tuning events events = client.fine_tuning.jobs.list_events( fine_tuning_job_id="ftjob-abc123", limit=50 ) for event in events.data: print(f"[{event.created_at}] {event.level}: {event.message}") if event.data: print(f" Metrics: {event.data}") ``` ------ #### [ HTTP request ] Faça uma solicitação GET para`/v1/fine_tuning/jobs/{fine_tuning_job_id}/events`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=50 ``` ------ Os eventos incluem informações como: + Mensagens iniciadas e concluídas do treinamento + Notificações de criação de pontos de verificação + Métricas de treinamento (perda, precisão) em cada etapa + Mensagens de erro se o trabalho falhar Para paginar todos os eventos, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Paginate through all events all_events = [] after = None while True: events = client.fine_tuning.jobs.list_events( fine_tuning_job_id="ftjob-abc123", limit=100, after=after ) all_events.extend(events.data) if not events.has_more: break after = events.data[-1].id ``` ------ #### [ HTTP request ] Faça várias solicitações GET com o `after` parâmetro: ``` # First request curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100 # Subsequent requests with 'after' parameter curl "https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100&after=ft-event-abc123" ``` ------ ## Recupere o trabalho de ajuste fino Obtenha informações detalhadas sobre um trabalho de ajuste fino. Para obter detalhes completos da API, consulte a documentação do trabalho de [ajuste fino do OpenAI Retrieve](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve). ### Exemplos Para recuperar detalhes específicos do trabalho, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Retrieve specific job details job_details = client.fine_tuning.jobs.retrieve(job_id) # Print raw response print(json.dumps(job_details.model_dump(), indent=2)) ``` ------ #### [ HTTP request ] Faça uma solicitação GET para`/v1/fine_tuning/jobs/{fine_tuning_job_id}`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123 \ -H "Authorization: Bearer $OPENAI_API_KEY" ``` ------ ## Listar trabalhos de ajuste fino Lista os trabalhos de ajuste fino da sua organização com suporte à paginação. Para obter detalhes completos da API, consulte a documentação da [OpenAILista de trabalhos de ajuste fino](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list). ### Exemplos Para listar trabalhos de ajuste fino com limite e paginação, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # List fine-tuning jobs with limit and pagination response = client.fine_tuning.jobs.list( limit=20 # Maximum number of jobs to return ) # Print raw response print(json.dumps(response.model_dump(), indent=2)) ``` ------ #### [ HTTP request ] Faça uma solicitação GET para`/v1/fine_tuning/jobs`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs?limit=20 \ -H "Authorization: Bearer $OPENAI_API_KEY" ``` ------ ## Cancelar o trabalho de ajuste fino Cancela um trabalho de ajuste fino que está em andamento. Depois de cancelado, o trabalho não pode ser retomado. Para obter detalhes completos da API, consulte a documentação do [trabalho de ajuste fino do OpenAI Cancelamento](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel). ### Exemplos Para cancelar um trabalho de ajuste fino, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Cancel fine-tuning job cancel_response = client.fine_tuning.jobs.cancel("ftjob-abc123") print(f"Job ID: {cancel_response.id}") print(f"Status: {cancel_response.status}") # Should be "cancelled" ``` ------ #### [ HTTP request ] Faça uma solicitação POST para`/v1/fine_tuning/jobs/{fine_tuning_job_id}/cancel`: ``` curl -X POST https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/cancel \ -H "Authorization: Bearer $OPENAI_API_KEY" ``` ------ ## Listar pontos de verificação de ajuste fino Lista os pontos de verificação para um trabalho de ajuste fino. Os pontos de verificação são instantâneos de modelos intermediários criados durante o ajuste fino que podem ser usados para inferência para avaliar o desempenho em diferentes estágios de treinamento. Para obter mais informações, consulte a documentação de [OpenAIList fine-tuning checkpoints](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list). ### Exemplos Para listar os pontos de verificação de um trabalho de ajuste fino, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # List checkpoints for a fine-tuning job checkpoints = client.fine_tuning.jobs.checkpoints.list( fine_tuning_job_id="ftjob-abc123", limit=10 ) for checkpoint in checkpoints.data: print(f"Checkpoint ID: {checkpoint.id}") print(f"Step: {checkpoint.step_number}") print(f"Model: {checkpoint.fine_tuned_model_checkpoint}") print(f"Metrics: {checkpoint.metrics}") print("---") ``` ------ #### [ HTTP request ] Faça uma solicitação GET para`/v1/fine_tuning/jobs/{fine_tuning_job_id}/checkpoints`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/checkpoints?limit=10 ``` ------ Cada ponto de verificação inclui: + **ID do ponto de verificação** — Identificador exclusivo do ponto de verificação + **Número da etapa** — Etapa de treinamento na qual o ponto de verificação foi criado + **Ponto de verificação do** modelo — identificador do modelo que pode ser usado para inferência + **Métricas** — perda de validação e precisão neste ponto de verificação Para usar um modelo de ponto de verificação para inferência, escolha a guia do seu método preferido e siga as etapas: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Test inference with a checkpoint response = client.chat.completions.create( model=checkpoint.fine_tuned_model_checkpoint, messages=[{"role": "user", "content": "What is AI?"}], max_tokens=100 ) print(response.choices[0].message.content) ``` ------ #### [ HTTP request ] Faça uma solicitação POST para`/v1/chat/completions`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "ft:gpt-4o-mini:openai:custom:7p4lURel:ckpt-step-1000", "messages": [{"role": "user", "content": "What is AI?"}], "max_tokens": 100 }' ``` ------ ## Execute inferência com um modelo ajustado Depois que seu trabalho de ajuste estiver concluído, você poderá usar o modelo ajustado para inferência por meio da API de respostas ou da API de conclusão de bate-papo. Para obter detalhes completos da API, consulte[Gere respostas usando OpenAI APIs](bedrock-mantle.md). ### API de respostas Use a API de respostas para gerar texto em um único turno com seu modelo ajustado: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Get the fine-tuned model ID job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123") if job_details.status == 'succeeded' and job_details.fine_tuned_model: fine_tuned_model = job_details.fine_tuned_model print(f"Using fine-tuned model: {fine_tuned_model}") # Run inference with Responses API response = client.completions.create( model=fine_tuned_model, prompt="What is the capital of France?", max_tokens=100, temperature=0.7 ) print(f"Response: {response.choices[0].text}") else: print(f"Job status: {job_details.status}") print("Job must be in 'succeeded' status to run inference") ``` ------ #### [ HTTP request ] Faça uma solicitação POST para`/v1/completions`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel", "prompt": "What is the capital of France?", "max_tokens": 100, "temperature": 0.7 }' ``` ------ ### API de conclusão de bate-papo Use a API Chat Completions para interações conversacionais com seu modelo ajustado: ------ #### [ OpenAI SDK (Python) ] ``` # Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables from openai import OpenAI client = OpenAI() # Get the fine-tuned model ID job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123") if job_details.status == 'succeeded' and job_details.fine_tuned_model: fine_tuned_model = job_details.fine_tuned_model print(f"Using fine-tuned model: {fine_tuned_model}") # Run inference inference_response = client.chat.completions.create( model=fine_tuned_model, messages=[ {"role": "user", "content": "What is the capital of France?"} ], max_tokens=100 ) print(f"Response: {inference_response.choices[0].message.content}") else: print(f"Job status: {job_details.status}") print("Job must be in 'succeeded' status to run inference") ``` ------ #### [ HTTP request ] Faça uma solicitação POST para`/v1/chat/completions`: ``` curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel", "messages": [ {"role": "user", "content": "What is the capital of France?"} ], "max_tokens": 100 }' ``` ------ # Avalie seu modelo de RFT Depois que seu trabalho de ajuste fino de reforço for concluído com êxito, você poderá avaliar o desempenho do seu modelo personalizado usando vários métodos de avaliação. O Amazon Bedrock fornece ferramentas de avaliação integradas para ajudar você a comparar seu modelo RFT com o modelo básico e validar melhorias. **Topics** + [Métodos de avaliação](#rft-evaluation-methods) + [Configurando a inferência para avaliação](#rft-setup-inference-evaluation) + [Melhores práticas de avaliação](#rft-evaluation-best-practices) ## Métodos de avaliação O Amazon Bedrock oferece várias maneiras de avaliar o desempenho do seu modelo RFT. ### Métricas de validação Se você fizer o upload de um conjunto de dados de validação, verá dois gráficos adicionais nas métricas de treinamento. + **Recompensas de validação** - Mostra o quão bem seu modelo é generalizado além dos exemplos de treinamento. Pontuações mais baixas do que as recompensas de treinamento são normais e esperadas. + **Duração do episódio de validação** - Duração média da resposta em dados de validação não vistos. Mostra a eficiência com que seu modelo responde às novas entradas em comparação com os exemplos de treinamento. ### Teste no Playground Use o recurso Testar no Playground para avaliações rápidas e ad-hoc. Para usar o recurso Testar no Playground, a inferência precisa ser configurada. Para obter mais informações, consulte [Configurando a inferência para avaliação](#rft-setup-inference-evaluation). Essa ferramenta interativa permite que você: + Teste os prompts diretamente com seu modelo RFT + Compare as respostas side-by-side entre seu modelo personalizado e o modelo básico + Avalie as melhorias na qualidade da resposta em tempo real + Experimente com diferentes instruções para avaliar as capacidades do modelo ### Avaliação do modelo Bedrock Use a avaliação de modelo do Amazon Bedrock para avaliar seu modelo RFT usando seus próprios conjuntos de dados. Isso fornece uma análise abrangente de desempenho com métricas e benchmarks padronizados. Aqui estão alguns exemplos dos benefícios do Amazon Bedrock Model Evaluation. + Avaliação sistemática usando conjuntos de dados de teste personalizados + Comparações quantitativas de desempenho + Métricas padronizadas para avaliação consistente + Integração com fluxos de trabalho de avaliação existentes do Amazon Bedrock ## Configurando a inferência para avaliação Antes de avaliar seu modelo de RFT, configure a inferência usando uma das seguintes opções: ### Inferência sob demanda Crie um modelo personalizado de implantação sob demanda para pay-per-use avaliação flexível. Essa opção inclui preços baseados em tokens que são cobrados com base no número de tokens processados durante a inferência. ## Melhores práticas de avaliação + **Compare sistematicamente** - Sempre avalie seu modelo RFT em relação ao modelo básico usando as mesmas instruções de teste e critérios de avaliação. + **Use diversos casos de teste** - inclua vários tipos de solicitações e cenários que representem seus casos de uso no mundo real. + **Valide o alinhamento da recompensa** - Garanta que as melhorias do seu modelo estejam alinhadas com as funções de recompensa usadas durante o treinamento. + **Teste casos extremos** - Avalie o comportamento do modelo em entradas desafiadoras ou incomuns para avaliar a robustez. + **Monitore a consistência da resposta** - Verifique se seu modelo fornece qualidade consistente em várias execuções com solicitações semelhantes.