Coherence: Measures the organization and structure of a generated text. - Thumbs up/down\nAccuracy: Indicates the accuracy of a generated text. - Choice buttons
\nThe evaluation creator should use this space to write detailed descriptions for every rating method so your evaluators know how to properly rate the responses with the buttons on their screen.
\nIf using Likert scale - individual, define the 1 and 5 of the 5 point Likert scale for each metric so your evaluators know if 1 or 5 means favorable/acceptable/preferable.\nIf using Likert scale - comparison, describe what the evaluator is looking for to determine their preference between two responses.\nIf using Choice buttons, describe what is preferred according to your metric and its description.\nIf using Ordinal ranking, define what should receive a #1 ranking according to your metric and its description.\nIf using Thumbs up/down, define what makes an acceptable response according to your metric and its description.
\nDescribe the purpose of your ground truth responses that will be shown on screen next to each model response. Note that the ground truth responses you provide are not rated/scored by the evaluators - they are meant to be a reference standard for comparison against the model responses.
" } } }, "inferenceConfig": { "models": [ { "precomputedInferenceSource": { "inferenceSourceIdentifier": "llama-3-1-80b" } }, { "precomputedInferenceSource": { "inferenceSourceIdentifier": "my_other_model" } } ] }, "outputDataConfig": { "s3Uri": "s3://amzn-s3-demo-bucket/output/" } } ``` ------ #### [ SDK for Python ] Veja os exemplos de como criar um trabalho de avaliação de modelo com a participação de operadores humanos por meio do SDK para Python. ``` import boto3 client = boto3.client('bedrock') job_request = client.create_evaluation_job( jobName="111122223333-job-01", jobDescription="two different task types", roleArn="arn:aws:iam::111122223333:role/example-human-eval-api-role", inferenceConfig={ ## You must specify and array of models "models": [ { "bedrockModel": { "modelIdentifier":"arn:aws:bedrock:us-west-2::foundation-model/amazon.titan-text-lite-v1", "inferenceParams":"{\"inferenceConfig\":{\"maxTokens\": 512,\"temperature\":0.7,\"topP\":0.9}}" } }, { "bedrockModel": { "modelIdentifier": "anthropic.claude-v2", "inferenceParams": "{\"inferenceConfig\":{\"maxTokens\":512,\"temperature\":1,\"topP\":0.999,\"stopSequences\":[\"stop\"]},\"additionalModelRequestFields\":{\"top_k\": 128}}" } } ] }, outputDataConfig={ "s3Uri":"s3://job-bucket/outputs/" }, evaluationConfig={ "human": { "humanWorkflowConfig": { "flowDefinitionArn": "arn:aws:sagemaker:us-west-2:111122223333:flow-definition/example-workflow-arn", "instructions": "some human eval instruction" }, "customMetrics": [ { "name": "IndividualLikertScale", "description": "testing", "ratingMethod": "IndividualLikertScale" } ], "datasetMetricConfigs": [ { "taskType": "Summarization", "dataset": { "name": "Custom_Dataset1", "datasetLocation": { "s3Uri": "s3://job-bucket/custom-datasets/custom-trex.jsonl" } }, "metricNames": [ "IndividualLikertScale" ] } ] } } ) print(job_request) ``` ------ # Listar trabalhos de avaliação de modelo que usam trabalhadores humanos no Amazon Bedrock É possível listar seus trabalhos atuais de avaliação de modelo que utilizam trabalhadores humanos usando a AWS CLI ou um SDK da AWS compatível. No console do Amazon Bedrock, também é possível visualizar uma tabela contendo seus trabalhos atuais de avaliação de modelo. Os exemplos a seguir mostram como encontrar os trabalhos de avaliação de modelo usando o Console de gerenciamento da AWS, a AWS CLI e o SDK para Python. ------ #### [ Amazon Bedrock console ] 1. Abra o console do Amazon Bedrock: [https://console.aws.amazon.com/bedrock/home](https://console.aws.amazon.com/bedrock/home) 1. No painel de navegação, escolha **Avaliação de modelo**. 1. No cartão **Trabalhos de avaliação de modelo**, é possível encontrar uma tabela que lista os trabalhos de avaliação de modelo que você já criou. ------ #### [ AWS CLI ] Na AWS CLI, é possível usar o comando `help` para ver os parâmetros necessários e quais são opcionais ao usar `list-evaluation-jobs`. ``` aws bedrock list-evaluation-jobs help ``` Veja a seguir um exemplo de como usar `list-evaluation-jobs` e especificar que no máximo cinco trabalhos sejam mostrados. Por padrão, os trabalhos são mostrados em ordem decrescente a partir do momento em que foram iniciados. ``` aws bedrock list-evaluation-jobs --max-items 5 ``` ------ #### [ SDK for Python ] Os exemplos a seguir mostram como usar o AWS SDK para Python para encontrar um trabalho de avaliação de modelo criado anteriormente. ``` import boto3 client = boto3.client('bedrock') job_request = client.list_evaluation_jobs(maxResults=20) print (job_request) ``` ------ # Interromper um trabalho de avaliação de modelo no Amazon Bedrock É possível interromper um trabalho de avaliação de modelo que está sendo processado usando o Console de gerenciamento da AWS, a AWS CLI ou um SDK da AWS compatível. Os exemplos a seguir mostram como interromper o trabalho de avaliação de modelo usando o Console de gerenciamento da AWS, a AWS CLI e o SDK para Python. ------ #### [ Amazon Bedrock console ] Os exemplos a seguir mostram como interromper o trabalho de avaliação de modelo usando a Console de gerenciamento da AWS. 1. Abra o console do Amazon Bedrock: [https://console.aws.amazon.com/bedrock/home](https://console.aws.amazon.com/bedrock/home) 1. No painel de navegação, escolha **Avaliação de modelo**. 1. No cartão **Trabalhos de avaliação de modelo**, é possível encontrar uma tabela que lista os trabalhos de avaliação de modelo que você já criou. 1. Selecione o botão de opção ao lado do nome do trabalho. 1. Escolha **Interromper avaliação**. ------ #### [ SDK for Python ] Os exemplos a seguir mostram como interromper um trabalho de avaliação de modelo usando o SDK para Python. ``` import boto3 client = boto3.client('bedrock') response = client.stop_evaluation_job( ## The ARN of the model evaluation job you want to stop. jobIdentifier='arn:aws:bedrock:us-west-2:444455556666:evaluation-job/fxaqujhttcza' ) print(response) ``` ------ #### [ AWS CLI ] Na AWS CLI, é possível usar o comando `help` para ver quais parâmetros são necessários e quais são opcionais ao especificar `add-something` na AWS CLI. ``` aws bedrock create-evaluation-job help ``` Os exemplos a seguir mostram como interromper o trabalho de avaliação de modelo usando a AWS CLI. ``` aws bedrock stop-evaluation-job --job-identifier arn:aws:bedrock:us-west-2:444455556666:evaluation-job/fxaqujhttcza ``` ------ # Excluir um trabalho de avaliação de modelo no Amazon Bedrock É possível excluir um trabalho de avaliação de modelo usando o console Amazon Bedrock ou usando a operação [BatchDeleteEvaluationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_BatchDeleteEvaluationJob.html) com a AWS CLI ou um SDK da AWS compatível. Antes de excluir um trabalho de avaliação de modelo, o status do trabalho deve ser `FAILED`, `COMPLETED` ou `STOPPED`. É possível obter o status atual de um trabalho no console Amazon Bedrock ou chamando o [ListEvaluationJobs](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListEvaluationJobs.html). Para obter mais informações, consulte [Listar trabalhos automáticos de avaliação de modelo no Amazon BedrockListar trabalhos de avaliação de modelo que usam trabalhadores humanos no Amazon Bedrock](model-evaluation-jobs-management-list.md). É possível excluir até 25 trabalhos de avaliação de modelo por vez com o console e com a operação `BatchDeleteEvaluationJob`. Se for necessário excluir mais trabalhos, repita o procedimento do console ou chamada de `BatchDeleteEvaluationJob`. Se você excluir um trabalho de avaliação de modelo com a operação `BatchDeleteEvaluationJob`, precisará dos nomes dos recursos da Amazon (ARNs) dos modelos que deseja excluir. Para obter mais informações sobre como obter o ARN de um modelo, consulte [Listar trabalhos automáticos de avaliação de modelo no Amazon BedrockListar trabalhos de avaliação de modelo que usam trabalhadores humanos no Amazon Bedrock](model-evaluation-jobs-management-list.md). Ao excluir um trabalho de avaliação de modelo, todos os recursos no Amazon Bedrock e no Amazon SageMaker AI são removidos. Qualquer trabalho de avaliação de modelo salvo nos buckets do Amazon S3 são deixados inalterados. Além disso, para trabalhos de avaliação de modelo que usam trabalhadores humanos, a exclusão de um trabalho de avaliação de modelo não excluirá a força de trabalho ou a equipe de trabalho que você configurou no Amazon Cognito ou no SageMaker AI. Use as seções a seguir para obter exemplos de como excluir um trabalho de avaliação de modelo. ------ #### [ Amazon Bedrock console ] Use o procedimento a seguir para criar um trabalho de avaliação de modelo no console do Amazon Bedrock. Para concluir esse procedimento com êxito, verifique se o usuário, o grupo ou o perfil do IAM tem permissões suficientes para acessar o console. Para saber mais, consulte [Permissões do console necessárias para criar um trabalho de avaliação de modelo realizado por humanos](model-evaluation-type-human.md#more-for-human). **Para excluir trabalhos de avaliação de modelo de vários trabalhos.** 1. Abra o console do Amazon Bedrock: [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock/). 1. No painel de navegação, escolha **Avaliação de modelo**. 1. No cartão **Trabalhos de avaliação de modelo**, use a tabela para encontrar os trabalhos de avaliação de modelo que você deseja excluir e selecione-os usando a caixa de seleção ao lado do nome do trabalho. É possível selecionar até 25 trabalhos. 1. Escolha **Excluir** para excluir os trabalhos de avaliação de modelo. 1. Se for necessário excluir mais trabalhos de avaliação de modelo, repita as etapas 3 e 4. ------ #### [ AWS CLI ] Na AWS CLI, é possível usar o comando `help` para ver os parâmetros necessários e quais são opcionais ao usar `batch-delete-evaluation-job`. ``` aws bedrock batch-delete-evaluation-job help ``` Veja a seguir um exemplo de como usar `batch-delete-evaluation-job` e especificar que dois trabalhos de avaliação de modelo sejam excluídos. Use o parâmetro `job-identifiers` para especificar uma lista de ARNs para trabalhos de avaliação de modelo que deseja excluir. É possível excluir até 25 trabalhos de avaliação de modelo em uma única chamada a `batch-delete-evaluation-job`. Se for necessário excluir mais trabalhos, faça mais chamadas a `batch-delete-evaluation-job`. ``` aws bedrock batch-delete-evaluation-job \ --job-identifiers arn:aws:bedrock:us-east-1:111122223333:evaluation-job/rmqp8zg80rvg arn:aws:bedrock:us-east-1:111122223333:evaluation-job/xmfp9zg204fdk ``` Depois de enviar, você receberá a resposta a seguir. ``` { "evaluationJobs": [ { "jobIdentifier": "rmqp8zg80rvg", "jobStatus": "Deleting" }, { "jobIdentifier": "xmfp9zg204fdk", "jobStatus": "Deleting" } ], "errors": [] } ``` ------ #### [ SDK for Python ] Os exemplos a seguir mostram como usar o AWS SDK para Python para excluir um trabalho de avaliação de modelo. Use o parâmetro `jobIdentifiers` para especificar uma lista de ARNs para trabalhos de avaliação de modelo que deseja excluir. É possível excluir até 25 trabalhos de avaliação de modelo em uma única chamada a `BatchDeleteEvaluationJob`. Se for necessário excluir mais trabalhos, faça mais chamadas a `BatchDeleteEvaluationJob`. ``` import boto3 client = boto3.client('bedrock') job_request = client.batch_delete_model_evaluation_job(jobIdentifiers=["arn:aws:bedrock:us-east-1:111122223333:evaluation-job/rmqp8zg80rvg", "arn:aws:bedrock:us-east-1:111122223333:evaluation-job/xmfp9zg204fdk"]) print (job_request) ``` ------ # Gerenciar uma equipe de trabalho de avaliações humanas de modelos no Amazon Bedrock Em trabalhos de avaliação com a participação de operadores humanos, é necessário ter uma equipe de trabalho. Uma equipe de trabalho é um grupo de operadores que *você* escolhe. Podem ser funcionários da empresa ou um grupo de especialistas no assunto do setor. **Notificações para operadores no Amazon Bedrock** Ao criar um trabalho de avaliação no Amazon Bedrock, os operadores são notificados sobre o trabalho atribuído *somente* quando você os adiciona pela primeira vez a uma equipe de trabalho. Se você excluir um operador de uma equipe de trabalho durante a criação do trabalho de avaliação, o operador também perderá o acesso a *todos* os trabalhos de avaliação atribuídos a ele. Para qualquer novo trabalho de avaliação de modelo que você atribuir a um operador humano existente, será necessário notificá-lo diretamente e fornecer o URL do portal de operadores. Os operadores devem usar suas credenciais de login criadas anteriormente para o portal de operadores. Esse portal do trabalhador é o mesmo para todos os trabalhos de avaliação em sua AWS conta por região. Você pode criar uma equipe de trabalho humana ou gerenciar uma existente enquanto configura uma equipe de trabalho de avaliação para uma *força de trabalho privada* gerenciada pela Amazon SageMaker Ground Truth. O Amazon SageMaker Ground Truth oferece suporte a recursos mais avançados de gerenciamento da força de trabalho. Para saber mais sobre como gerenciar sua força de trabalho no Amazon SageMaker Ground Truth, consulte [Criar e gerenciar forças de trabalho](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-management.html). É possível excluir operadores de uma equipe de trabalho configurando um novo trabalho de avaliação. Caso contrário, você deve usar o console do Amazon Cognito ou o console do Amazon SageMaker Ground Truth para gerenciar as equipes de trabalho que você criou no Amazon Bedrock. Se o usuário, grupo ou função do IAM tiver as permissões necessárias, você verá as forças de trabalho e equipes de trabalho privadas existentes que você criou no Amazon Cognito, no Amazon Ground SageMaker Truth ou no Amazon Augmented AI visíveis ao criar um trabalho de avaliação que usa trabalhadores humanos. O Amazon Bedrock comporta até cinquenta operadores por equipe de trabalho. No campo de endereços de e-mail, é possível inserir até 50 endereços de e-mail. Para adicionar mais operadores a um trabalho de avaliação, use o console do Amazon Cognito ou o console do Ground Truth. Os endereços devem ser separados por uma vírgula. Você deve incluir seu próprio endereço de e-mail para fazer parte da força de trabalho e poder ver as tarefas de rotulagem. ## Crie instruções para os operadores humanos Criar boas instruções para os trabalhos de avaliação de modelo melhora a precisão do operador na conclusão de suas tarefas. É possível modificar as instruções padrão fornecidas no console ao criar um trabalho de avaliação de modelo. Essas instruções são mostradas para o operador na página da interface do usuário em que eles concluem sua tarefa de rotulagem. Para ajudar os operadores a concluírem as tarefas atribuídas, é possível fornecer instruções em dois locais. **Fornecer uma boa descrição para cada método de avaliação e classificação** As descrições devem oferece uma explicação sucinta das métricas selecionadas. A descrição deve se aprofundar na métrica e deixar claro como você deseja que os operadores avaliem o método de classificação selecionado. **Fornecer instruções gerais de avaliação para os operadores** Essas instruções são mostradas na mesma página da web na qual os operadores concluem uma tarefa. É possível usar esse espaço para fornecer orientação de alto nível para o trabalho de avaliação de modelo e para descrever as respostas reais, caso as tenha incluído no conjunto de dados de prompts. # Avaliar o desempenho do modelo usando outro LLM como avaliador Com um trabalho de avaliação de modelo que usa um modelo como avaliador, o Amazon Bedrock utiliza um LLM para classificar as respostas de outro modelo e fornecer uma explicação de como ele atribuiu uma pontuação a cada par de prompt-resposta. As pontuações e explicações estão disponíveis no console do Amazon Bedrock por meio da página [Avaliações](https://console.aws.amazon.com/bedrock/home#/eval/evaluation). Esse tipo de avaliação de modelo requer dois modelos diferentes, um *modelo gerador* e um *modelo avaliador*. Você define prompts para o modelo gerador em um conjunto de dados, e o modelo avaliador classifica as respostas a esses prompts com base nas métricas selecionadas. O cartão de resumo de métricas no console exibe um histograma que mostra o número de vezes que as respostas receberam determinada pontuação e explicações sobre a pontuação dos cinco primeiros prompts encontrados no conjunto de dados. O relatório do trabalho de avaliação completo está disponível no bucket do Amazon S3 que você especificou ao criar o trabalho de avaliação de modelo. Ao criar o trabalho de avaliação de modelo, você pode selecionar um modelo do Amazon Bedrock como gerador ou avaliar um modelo que não seja do Amazon Bedrock fornecendo seus próprios dados de resposta de inferência no conjunto de dados de prompts. Se você fornecer seus próprios dados de resposta, o Amazon Bedrock ignorará a etapa de invocação do modelo e avaliará diretamente os dados fornecidos. Para avaliar as respostas dos modelos geradores, o Amazon Bedrock fornece um conjunto de métricas integradas que você pode selecionar. Cada métrica usa um prompt diferente para o modelo avaliador. Também é possível definir suas métricas personalizadas para seu caso de negócios específico. Para saber mais, consulte [Usar métricas para entender o desempenho do modelo](model-evaluation-metrics.md). ## Modelos compatíveis ### Modelos avaliadores compatíveis (métricas integradas) Para criar um trabalho de avaliação que usa um LLM como avaliador com as métricas integradas do Amazon Bedrock, é necessário acessar pelo menos um dos modelos avaliadores na lista a seguir. Para saber mais sobre como obter acesso aos modelos e regiões disponíveis, consulte [Acessar modelos de base do Amazon Bedrock](model-access.md). + Amazon Nova Pro – `amazon.nova-pro-v1:0` + Claude 3.5 Sonnet v1 da Anthropic: `anthropic.claude-3-5-sonnet-20240620-v1:0` + Claude 3.5 Sonnet v2 da Anthropic: `anthropic.claude-3-5-sonnet-20241022-v2:0` + Anthropic Claude 3.7 Sonnet – `anthropic.claude-3-7-sonnet-20250219-v1:0` + Anthropic Claude 3 Haiku – `anthropic.claude-3-haiku-20240307-v1:0` + Anthropic Claude 3.5 Haiku – `anthropic.claude-3-5-haiku-20241022-v1:0` + Meta Llama 3.1 70B Instruct – `meta.llama3-1-70b-instruct-v1:0` + Mistral Large – `mistral.mistral-large-2402-v1:0` É possível usar perfis de [inferência entre regiões](cross-region-inference.md) com os modelos listados. Para saber mais, consulte [Perfis de inferência entre regiões permitidos](inference-profiles-support.md#inference-profiles-support-system). ### Modelos avaliadores compatíveis (métricas personalizadas) Para criar um trabalho de avaliação que usa um LLM como avaliador com métricas personalizadas, é necessário acessar pelo menos um dos modelos avaliadores na lista a seguir. + Mistral Large 24.02: `mistral.mistral-large-2402-v1:0` + Mistral Large 24.07: `mistral.mistral-large-2407-v1:0` + Claude 3.5 Sonnet v1 da Anthropic: `anthropic.claude-3-5-sonnet-20240620-v1:0` + Claude 3.5 Sonnet v2 da Anthropic: `anthropic.claude-3-5-sonnet-20241022-v2:0` + Anthropic Claude 3.7 Sonnet – `anthropic.claude-3-7-sonnet-20250219-v1:0` + Claude 3 Haiku 3 da Anthropic: `anthropic.claude-3-haiku-20240307-v1:0` + Claude 3 Haiku 3.5 da Anthropic: `anthropic.claude-3-5-haiku-20241022-v1:0` + Meta Llama 3.1 70B Instruct – `meta.llama3-1-70b-instruct-v1:0` + Meta Llama 3.3 70B Instruct – `meta.llama3-3-70b-instruct-v1:0` + Amazon Nova Pro – `amazon.nova-pro-v1:0` É possível usar perfis de [inferência entre regiões](cross-region-inference.md) com os modelos listados. Para saber mais, consulte [Perfis de inferência entre regiões permitidos](inference-profiles-support.md#inference-profiles-support-system). ### Modelos geradores compatíveis É possível usar os tipos de modelo a seguir no Amazon Bedrock como modelo gerador em um trabalho de avaliação. Também é possível trazer seus próprios dados de respostas de inferência de modelos do Amazon Bedrock. + Modelos de base: [Informações sobre modelos de base do Amazon Bedrock](foundation-models-reference.md) + Modelos do Amazon Bedrock Marketplace: [Amazon Bedrock Marketplace](amazon-bedrock-marketplace.md) + Modelos de base personalizados: [Personalizar o modelo para melhorar a performance para o caso de uso](custom-models.md) + Modelos de base importados: [Usar a importação de modelo personalizado para importar um modelo de código aberto personalizado para o Amazon Bedrock](model-customization-import-model.md) + Roteadores de prompts: [Conceitos básicos sobre o Roteamento inteligente de prompts do Amazon Bedrock](prompt-routing.md) + Modelos para os quais você comprou throughput provisionado: [Aumentar a capacidade de invocação do modelo com throughput provisionado no Amazon Bedrock](prov-throughput.md) # Criar um conjunto de dados de prompts para um trabalho de avaliação de modelo que utilizam um modelo como avaliador Para criar um trabalho de avaliação de modelo que utiliza um modelo como avaliador, você deve especificar um conjunto de dados de prompts. Esse conjunto de dados de prompts usa o mesmo formato dos trabalhos de avaliação de modelo automática e é usado durante a inferência com os modelos que você seleciona para avaliação. Se quiser avaliar modelos que não são do Amazon Bedrock usando respostas que você já gerou, inclua-os no conjunto de dados de prompts, conforme descrito em [Preparar um conjunto de dados para um trabalho de avaliação usando seus próprios dados de resposta de inferência](#model-evaluation-prompt-datasets-judge-byoir). Quando você fornece seus próprios dados de resposta de inferência, o Amazon Bedrock ignora a etapa de invocação do modelo e executa o trabalho de avaliação com os dados que você fornece. Os conjuntos de dados de prompts personalizados devem ser armazenados no Amazon S3 e usar o formato de linha JSON e a extensão de arquivo `.jsonl`. Cada linha também deve ser um objeto JSON válido. Um conjunto de dados pode ter até mil prompts por trabalho de avaliação. Para trabalhos criados usando o console, atualize a configuração de compartilhamento de recursos de origem cruzada (CORS) no bucket do S3. Para saber mais sobre as permissões de CORS necessárias, consulte [Permissões de compartilhamento de recursos de origem cruzada (CORS) necessárias em buckets do S3](model-evaluation-security-cors.md). ## Preparar um conjunto de dados para um trabalho de avaliação em que o Amazon Bedrock invoca modelos para você Para executar um trabalho de avaliação em que o Amazon Bedrock invoque os modelos para você, crie um conjunto de dados de prompts que contenha os seguintes pares de chave-valor: + `prompt`: o prompt ao qual você deseja que os modelos respondam. + `referenceResponse`: (opcional) a resposta baseada em verdades de referência. + `category`: (opcional) gera pontuações de avaliação relatadas para cada categoria. **nota** Se você optar por fornecer uma resposta baseada em verdades de referência (`referenceResponse)`, o Amazon Bedrock usará esse parâmetro ao calcular as métricas de **completude** (`Builtin.Completeness`) e **exatidão** (`Builtin.Correctness`). Também é possível usar essas métricas sem fornecer uma resposta baseada em verdades de referência. Para ver os prompts do avaliador para esses dois cenários, consulte a seção em [Prompts do avaliador de métricas integradas para trabalhos de avaliação do tipo modelo como avaliador](model-evaluation-type-judge-prompt.md) referente ao modelo avaliador que você escolheu. Veja a seguir um exemplo de conjunto de dados personalizado que contém seis entradas e usa o formato de linha JSON. ``` {"prompt":"Provide the prompt you want the model to use during inference","category":"(Optional) Specify an optional category","referenceResponse":"(Optional) Specify a ground truth response."} {"prompt":"Provide the prompt you want the model to use during inference","category":"(Optional) Specify an optional category","referenceResponse":"(Optional) Specify a ground truth response."} {"prompt":"Provide the prompt you want the model to use during inference","category":"(Optional) Specify an optional category","referenceResponse":"(Optional) Specify a ground truth response."} {"prompt":"Provide the prompt you want the model to use during inference","category":"(Optional) Specify an optional category","referenceResponse":"(Optional) Specify a ground truth response."} {"prompt":"Provide the prompt you want the model to use during inference","category":"(Optional) Specify an optional category","referenceResponse":"(Optional) Specify a ground truth response."} {"prompt":"Provide the prompt you want the model to use during inference","category":"(Optional) Specify an optional category","referenceResponse":"(Optional) Specify a ground truth response."} ``` O exemplo a seguir é uma única entrada única expandida para aumentar a clareza. Em seu conjunto de dados de prompts real, cada linha deve ser um objeto JSON válido. ``` { "prompt": "What is high intensity interval training?", "category": "Fitness", "referenceResponse": "High-Intensity Interval Training (HIIT) is a cardiovascular exercise approach that involves short, intense bursts of exercise followed by brief recovery or rest periods." } ``` ## Preparar um conjunto de dados para um trabalho de avaliação usando seus próprios dados de resposta de inferência Para executar um trabalho de avaliação usando respostas que você já gerou, crie um conjunto de dados de prompts que contenha os seguintes pares de chave-valor: + `prompt`: o prompt que seus modelos usaram para gerar as respostas. + `referenceResponse`: (opcional) a resposta baseada em verdades de referência. + `category`: (opcional) gera pontuações de avaliação relatadas para cada categoria. + `modelResponses`: a resposta de sua própria inferência que você deseja que o Amazon Bedrock avalie. Os trabalhos de avaliação que usam um modelo como avaliador permitem apenas uma resposta de modelo para cada prompt, definida usando as seguintes chaves: + `response`: uma string contendo a resposta da inferência do modelo. + `modelIdentifier`: uma string identificando o modelo que gerou a resposta. Você pode usar somente um `modelIdentifier` em um trabalho de avaliação, e cada prompt no conjunto de dados deve usar esse identificador. **nota** Se você optar por fornecer uma resposta baseada em verdades de referência (`referenceResponse)`, o Amazon Bedrock usará esse parâmetro ao calcular as métricas de **completude** (`Builtin.Completeness`) e **exatidão** (`Builtin.Correctness`). Também é possível usar essas métricas sem fornecer uma resposta baseada em verdades de referência. Para ver os prompts do avaliador para esses dois cenários, consulte a seção em [Prompts do avaliador de métricas integradas para trabalhos de avaliação do tipo modelo como avaliador](model-evaluation-type-judge-prompt.md) referente ao modelo avaliador que você escolheu. Veja a seguir um exemplo de conjunto de dados personalizado com seis entradas no formato de linha JSON. ``` {"prompt":"The prompt you used to generate the model response","referenceResponse":"(Optional) a ground truth response","category":"(Optional) a category for the prompt","modelResponses":[{"response":"The response your model generated","modelIdentifier":"A string identifying your model"}]} {"prompt":"The prompt you used to generate the model response","referenceResponse":"(Optional) a ground truth response","category":"(Optional) a category for the prompt","modelResponses":[{"response":"The response your model generated","modelIdentifier":"A string identifying your model"}]} {"prompt":"The prompt you used to generate the model response","referenceResponse":"(Optional) a ground truth response","category":"(Optional) a category for the prompt","modelResponses":[{"response":"The response your model generated","modelIdentifier":"A string identifying your model"}]} {"prompt":"The prompt you used to generate the model response","referenceResponse":"(Optional) a ground truth response","category":"(Optional) a category for the prompt","modelResponses":[{"response":"The response your model generated","modelIdentifier":"A string identifying your model"}]} {"prompt":"The prompt you used to generate the model response","referenceResponse":"(Optional) a ground truth response","category":"(Optional) a category for the prompt","modelResponses":[{"response":"The response your model generated","modelIdentifier":"A string identifying your model"}]} {"prompt":"The prompt you used to generate the model response","referenceResponse":"(Optional) a ground truth response","category":"(Optional) a category for the prompt","modelResponses":[{"response":"The response your model generated","modelIdentifier":"A string identifying your model"}]} ``` O exemplo a seguir mostra um única entrada expandida em conjunto de dados de prompts para aumentar a clareza. ``` { "prompt": "What is high intensity interval training?", "referenceResponse": "High-Intensity Interval Training (HIIT) is a cardiovascular exercise approach that involves short, intense bursts of exercise followed by brief recovery or rest periods.", "category": "Fitness", "modelResponses": [ { "response": "High intensity interval training (HIIT) is a workout strategy that alternates between short bursts of intense, maximum-effort exercise and brief recovery periods, designed to maximize calorie burn and improve cardiovascular fitness.", "modelIdentifier": "my_model" } ] } ``` # Usar métricas para entender o desempenho do modelo Quando você executa um trabalho de avaliação de modelo, o modelo avaliador selecionado usa um conjunto de métricas para caracterizar o desempenho dos modelos que estão sendo avaliados. O Amazon Bedrock oferece inúmeras opções de métricas integradas ou você pode definir métricas personalizadas. A tabela a seguir lista as métricas integradas disponíveis no Amazon Bedrock para trabalhos de avaliação que usam um LLM como avaliador. Para saber como usar métricas personalizadas, consulte [Criar um prompt para uma métrica personalizada](model-evaluation-custom-metrics-prompt-formats.md) e [Criar um trabalho de avaliação de modelo usando métricas personalizadas](model-evaluation-custom-metrics-create-job.md). | Métrica | Descrição | | --- | --- | | Exatidão (Builtin.Correctness) | Mede se a resposta do modelo ao prompt está correta. Observe que, se você fornecer uma resposta baseada em referências (verdade de referência) como parte do seu [conjunto de dados de prompts](model-evaluation-prompt-datasets-judge.md), o modelo avaliador a considerará ao atribuir uma pontuação à resposta. | | Completude (Builtin.Completeness) | Mede até que ponto a resposta do modelo responde a cada pergunta no prompt. Observe que, se você fornecer uma resposta baseada em referências (verdade de referência) como parte do seu [conjunto de dados de prompts](model-evaluation-prompt-datasets-judge.md), o modelo avaliador a considerará ao atribuir uma pontuação à resposta. | | Fidelidade (Builtin.Faithfulness) | Identifica se a resposta contém informações não encontradas no prompt para medir a fidelidade da resposta ao contexto disponível. | | Utilidade (Builtin.Helpfulness) | Mede a utilidade da resposta do modelo. A avaliação usa fatores que incluem se a resposta segue as instruções fornecidas, se a resposta é sensata e coerente e se a resposta prevê necessidades e expectativas implícitas. | | Coerência lógica (Builtin.Coherence) | Mede a coerência da resposta identificando disparidades lógicas, inconsistências e contradições na resposta de um modelo a um prompt. | | Relevância (Builtin.Relevance) | Mede a relevância da resposta para o prompt. | | Adesão às instruções (Builtin.FollowingInstructions) | Mede até que ponto a resposta do modelo respeita as instruções exatas encontradas no prompt. | | Estilo e tom profissionais (Builtin.ProfessionalStyleAndTone) | Mede a adequação do estilo, da formatação e do tom da resposta para um ambiente profissional. | | Nocividade (Builtin.Harmfulness) | Avalia se a resposta contém conteúdo nocivo. | | Estereotipagem (Builtin.Stereotyping) | Avalia se o conteúdo da resposta contém qualquer tipo de estereótipo (positivos ou negativos). | | Recusa (Builtin.Refusal) | Determina se a resposta se recusa diretamente a responder ao prompt ou rejeita a solicitação fornecendo os motivos. | # Prompts do avaliador de métricas integradas para trabalhos de avaliação do tipo modelo como avaliador Quando você executa um trabalho de avaliação de modelo baseado em avaliador, o *modelo avaliador* classifica as respostas do *modelo gerador* de acordo com um conjunto de métricas definidas por você. O Amazon Bedrock oferece inúmeras métricas integradas, ou você pode definir [métricas personalizadas](model-evaluation-custom-metrics-prompt-formats.md). Consulte as seções a seguir para ver os prompts usados pelos modelos avaliadores disponíveis para as métricas integradas do Amazon Bedrock. **Topics** + [Amazon Nova Pro](model-evaluation-type-judge-prompt-nova.md) + [Anthropic Claude 3.5 Sonnet](model-evaluation-type-judge-prompt-claude-sonnet.md) + [Claude 3.5 Sonnet v2 da Anthropic](model-evaluation-type-judge-prompt-claude-sonnet35v2.md) + [Anthropic Claude 3.7 Sonnet](model-evaluation-type-judge-prompt-claude-sonnet37.md) + [Anthropic Claude 3 Haiku](model-evaluation-type-judge-prompt-haiku.md) + [Anthropic Claude 3.5 Haiku](model-evaluation-type-judge-prompt-haiku35.md) + [Meta Llama 3.1 70B Instruct](model-evaluation-type-judge-prompt-llama.md) + [Mistral Large](model-evaluation-type-judge-prompt-mistral.md) # Amazon Nova Pro Prompts usados com o Amazon Nova Pro. ## Coerência lógica *Coerência lógica*: procura disparidades lógicas, inconsistências e contradições nas respostas de um modelo a um prompt. As respostas são classificadas em uma escala Likert de cinco pontos e, em seguida, normalizadas na saída e no boletim do trabalho. O `{{prompt}}` conterá a solicitação enviada ao gerador a partir do seu conjunto de dados e `{{prediction}}` são as respostas do modelo gerador. ``` You are a helpful agent that can assess LLM response according to the given rubrics. You are given a question and a response from LLM. Your task is to check if the arguments presented in the response follow logically from one another. When evaluating the logical cohesion of the response, consider the following rubrics: 1. Check for self-contradictions: - Does the response contradict its own previous statements? - If chat history is provided, does the response contradict statements from previous turns without explicitly correcting itself? 2. Identify any logic gaps or errors in reasoning: - Does the response draw false conclusions from the available information? - Does it make "logical leaps" by skipping steps in an argument? - Are there instances where you think, "this does not follow from that" or "these two things cannot be true at the same time"? 3. Evaluate the soundness of the reasoning, not the soundness of the claims: - If the question asks that a question be answered based on a particular set of assumptions, take those assumptions as the basis for argument, even if they are not true. - Evaluate the logical cohesion of the response as if the premises were true. 4. Distinguish between logical cohesion and correctness: - Logical cohesion focuses on how the response arrives at the answer, not whether the answer itself is correct. - A correct answer reached through flawed reasoning should still be penalized for logical cohesion. 5. Relevance of Logical Reasoning: - If the response doesn't require argumentation or inference-making, and simply presents facts without attempting to draw conclusions, it can be considered logically cohesive by default. - In such cases, automatically rate the logical cohesion as 'Yes', as there's no logic gaps. Please rate the logical cohesion of the response based on the following scale: - Not at all: The response contains too many errors of reasoning to be usable, such as contradicting itself, major gaps in reasoning, or failing to present any reasoning where it is required. - Not generally: The response contains a few instances of coherent reasoning, but errors reduce the quality and usability. - Neutral/Mixed: It's unclear whether the reasoning is correct or not, as different users may disagree. The output is neither particularly good nor particularly bad in terms of logical cohesion. - Generally yes: The response contains small issues with reasoning, but the main point is supported and reasonably well-argued. - Yes: There are no issues with logical cohesion at all. The output does not contradict itself, and all reasoning is sound. Here is the actual task: Question: {{prompt}} Response: {{prediction}} The output should be a well-formatted JSON instance that conforms to the JSON schema below. As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]} the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted. Here is the output JSON schema: ``` {"properties": {"reasoning": {"description": "step by step reasoning to derive the final answer", "title": "Reasoning", "type": "string"}, "answer": {"description": "answer should be one of `Not at all`, `Not generally`, `Neutral/Mixed`, `Generally yes`, `Yes`", "enum": ["Not at all", "Not generally", "Neutral/Mixed", "Generally yes", "Yes"], "title": "Answer", "type": "string"}}, "required": ["reasoning", "answer"]} ``` Do not return any preamble or explanations, return only a pure JSON string surrounded by triple backticks (```). ``` ### Mapeamento de pontuação + **Nem um pouco**: `0.0` + **Geralmente não**: `1.0` + **Neutro/misto**: `2.0` + **Geralmente sim**: `3.0` + **Sim**: `4.0` ## Fidelidade *Fidelidade*: verifica se a resposta contém informações não encontradas no prompt, que não podem ser facilmente inferidas do prompt. As respostas são classificadas em uma escala Likert de cinco pontos e, em seguida, normalizadas na saída e no boletim do trabalho. O `{{prompt}}` conterá a solicitação enviada ao gerador a partir do seu conjunto de dados e `{{prediction}}` são as respostas do modelo gerador. ``` You are given a task in some context (Input), and a candidate answer. Is the candidate answer faithful to the task description and context? If the model gives an evasive response without any information, the candidate answer is faithful by default. A response is unfaithful only when (1) it clearly contradicts the context, or (2) the task implies that the response must be based on the context, like in a summarization task. If the task does not ask to respond based on the context, the model is allowed to use its own knowledge to provide a response, even if its claims are not verifiable. Task: {{prompt}} Candidate Response: {{prediction}} Evaluate how much of the information in the answer is faithful to the available context. Label an evasive response as faithful. The output should be formatted as a XML file. 1. Output should conform to the tags below. 2. Remember to always open and close all the tags. 3. Do not invent new tags. As an example, for the tags ["foo", "bar", "baz"]: 1. String ""answerContent": {
"evaluationResults": {
"thumbsUpDown": [{
"metricName": "Relevance",
"modelResponseId": "0",
"result": false
}]
}
} | Uma lista de objetos JSON que contêm respostas de operadores em `answerContent`. |
| `humanLoopName` | String | system-generated-hash | Uma string hexadecimal de 40 caracteres gerada pelo sistema. |
| inputRecord | Objeto JSON | "inputRecord": {
"prompt": "What does vitamin C serum do for skin?",
"category": "Skincare",
"referenceResponse": "Vitamin C serum offers a range of benefits for the skin. Firstly, it acts....
} | Um objeto JSON que contém um prompt de entrada do conjunto de dados de entrada. |
| modelResponses | Lista de objetos JSON | "modelResponses": [{
"modelIdentifier": "arn:aws:bedrock:us-west-2::foundation-model/model-id",
"response": "the-models-response-to-the-prompt"
}] | As respostas individuais dos modelos. |
| inputContent | Objeto | {
"additionalDataS3Uri":"s3://user-specified-S3-URI-path/datasets/dataset-name/records/record-number/human-loop-additional-data.json",
"evaluationMetrics":[
{
"description":"testing",
"metricName":"IndividualLikertScale",
"ratingMethod":"IndividualLikertScale"
}
],
"instructions":"example instructions"
} | O conteúdo de entrada do grupo humano necessário para iniciar o grupo humano no bucket do S3. |
| modelResponseIdMap | Objeto | {
"0":"arn:aws:bedrock:us-west-2::foundation-model/model-id"
} | `humanAnswers.answerContent.evaluationResults` contém `modelResponseId`s. O `modelResponseIdMap` conecta o `modelResponseId` ao nome do modelo. |
Veja a seguir um exemplo de dados de saída de um trabalho de avaliação de modelo.
```
{
"humanEvaluationResult": [{
"flowDefinitionArn": "arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name",
"humanAnswers": [{
"acceptanceTime": "2023-11-09T19:17:43.107Z",
"answerContent": {
"evaluationResults": {
"thumbsUpDown": [{
"metricName": "Coherence",
"modelResponseId": "0",
"result": false
}, {
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
}],
"individualLikertScale": [{
"metricName": "Toxicity",
"modelResponseId": "0",
"result": 1
}]
}
},
"submissionTime": "2023-11-09T19:17:52.101Z",
"timeSpentInSeconds": 8.994,
"workerId": "444455556666",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.Região da AWS.amazonaws.com/Região da AWS_111222",
"sub": "c6aa8eb7-9944-42e9-a6b9-"
}
}
}],
...Additional response have been truncated for clarity...
}],
"humanLoopName": "b3b1c64a2166e001e094123456789012",
"inputContent":{
"additionalDataS3Uri":"s3://user-specified-S3-output-path/datasets/dataset-name/records/record-number/human-loop-additional-data.json",
"evaluationMetrics":[
{
"description":"testing",
"metricName":"IndividualLikertScale",
"ratingMethod":"IndividualLikertScale"
}
],
"instructions":"some dummy instructions"
},
"modelResponseIdMap":{
"0":"arn:aws:bedrock:Região da AWS::foundation-model/model-id"
}
},
"inputRecord": {
"category": "Fitness",
"prompt": "Human: What is High-Intensity Interval Training ? \\n\\nAssistant:",
"referenceResponse": "High-Intensity Interval Training (HIIT) is a cardiovascular exercise approach that involves short, intense bursts of exercise followed by brief recovery or rest periods. In HIIT, you perform exercises at near-maximum effort during the high-intensity intervals, which can include activities like sprinting, cycling, jumping, or body weight exercises such as burpees or push-ups. These intense intervals are interspersed with short recovery periods to lower your heart rate before the next high-intensity bout. HIIT workouts usually consist of multiple cycles of these intervals, and the number of cycles and the length of intervals can vary. HIIT is known for its time efficiency, making it an excellent choice for those with busy schedules. It offers both aerobic and anaerobic benefits, improving cardiovascular fitness, burning calories, and promoting fat loss, all while boosting metabolism for continued calorie burning post-workout."
},
"modelResponses": [{
"modelIdentifier": "arn:aws:bedrock:Região da AWS::foundation-model/model-id",
"response": " High-intensity interval training (HIIT) is a form of exercise that involves short bursts of intense activity alternated with recovery periods. Here are some key features of HIIT:\n\n- Alternates short periods of intense anaerobic exercise with less intense recovery periods. The high-intensity periods are typically done at 80-95% of maximum heart rate.\n\n- The duration of the intense periods can range from 5 seconds to 8 minutes, but typically are in the range of 30 seconds to 4 minutes.\n\n- The total HIIT session typically lasts between 10-30 minutes, including warm-up, recovery periods, and cool down. \n\n- Uses exercises like sprints, cycling, rowing, jumping rope, stair climbing, swimming, etc. Movements that get your heart rate up quickly.\n\n- The short, intense intervals help improve cardiovascular fitness by increasing heart rate and oxygen consumption.\n\n- HIIT burns more calories and fat than steady-state cardio in a shorter time period. It also helps build muscle strength and endurance.\n\n- Considered an efficient and effective form of exercise for fat loss and improving aerobic power. But it requires motivation to push yourself during the intense intervals.\n\n- Not suitable for beginners due to the high-intensity. Start with steady-state cardio and build up endurance before trying HIIT.\n\nIn summary, HIIT intersperses intense bursts of"
}]
}
}
```
A tabela a seguir explica como o **Método de classificação** que você selecionou para cada métrica no console do Amazon Bedrock é retornado no bucket do Amazon S3. A primeira chave filha em `evaluationResults` é a forma como o **Método de classificação** é retornado.
**Como os métodos de classificação selecionados no console do Amazon Bedrock são salvos no Amazon S3**
| Método de classificação selecionado | Salvo no Amazon S3 |
| --- | --- |
| Escala Likert: individual | IndividualLikertScale |
| Escala Likert: comparação | ComparisonLikertScale |
| Botões de escolha | ComparisonChoice |
| Classificação ordinal | ComparisonRank |
| Polegar para cima/para baixo | ThumbsUpDown |
# Gerenciamento e criptografia de dados no trabalho de avaliação do Amazon Bedrock
Durante o trabalho de avaliação do modelo, o Amazon Bedrock faz uma cópia temporária dos seus dados e os armazena em um bucket AWS próprio do Amazon S3. O Amazon Bedrock exclui esses dados após a conclusão do trabalho. O Amazon Bedrock criptografa esses dados usando uma AWS KMS chave. Você pode escolher especificar sua própria AWS KMS chave ou usar uma chave de propriedade da Amazon Bedrock para criptografar os dados.
Ao criar um trabalho de avaliação de modelo usando o Console de gerenciamento da AWS,, ou um AWS SDK compatível AWS CLI, você pode optar por usar uma chave KMS de propriedade da Amazon Bedrock ou sua própria chave gerenciada pelo cliente. Se nenhuma chave gerenciada pelo cliente for especificada, uma chave de propriedade do Amazon Bedrock será usada por padrão.
Para usar uma chave gerenciada pelo cliente, adicione as ações e os recursos necessários à política do perfil de serviço do IAM. Você também deve adicionar os AWS KMS principais elementos de política necessários.
**Topics**
+ [Principais elementos de política necessários para criptografar seu trabalho de avaliação de modelo usando AWS KMS](model-evaluation-security-kms.md)
+ [AWS Key Management Service suporte em trabalhos de avaliação de modelos](model-evaluation-security-data.md)
+ [Criptografia de dados para trabalhos de avaliação de base de conhecimento](rag-evaluation-security-data.md)
# Principais elementos de política necessários para criptografar seu trabalho de avaliação de modelo usando AWS KMS
Cada AWS KMS chave deve ter exatamente uma política de chaves. As declarações na política de chaves determinam quem tem permissão para usar a AWS KMS chave e como eles podem usá-la. Você também pode usar políticas e concessões do IAM para controlar o acesso à AWS KMS chave, mas cada AWS KMS chave deve ter uma política de chaves.
**AWS KMS Principais elementos de política necessários no Amazon Bedrock**
+ `kms:Decrypt`: para arquivos que você criptografou com a sua chave do AWS Key Management Service , fornece ao Amazon Bedrock permissões para acessar e descriptografar esses arquivos.
+ `kms:GenerateDataKey`: controla a permissão para usar a chave do AWS Key Management Service para gerar chaves de dados. O Amazon Bedrock usa `GenerateDataKey` para criptografar os dados temporários que armazena para o trabalho de avaliação.
+ `kms:DescribeKey`: fornece informações detalhadas sobre uma chave do KMS.
Você deve adicionar a seguinte declaração à sua política de AWS KMS chaves existente. Ele fornece ao Amazon Bedrock permissões para armazenar temporariamente seus dados em um bucket de serviço do Amazon Bedrock especificado por você usando o AWS KMS .
```
{
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"kms:DescribeKey"
],
"Resource": "*",
"Condition": {
"StringLike": {
"kms:EncryptionContext:evaluationJobArn": "arn:aws:bedrock:{{region}}:{{accountId}}:evaluation-job/*",
"aws:SourceArn": "arn:aws:bedrock:{{region}}:{{accountId}}:evaluation-job/*"
}
}
}
```
Veja a seguir um exemplo de uma AWS KMS política completa.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "key-consolepolicy-3",
"Statement": [
{
"Sid": "EnableIAMUserPermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "BedrockDataKeyAndDecrypt",
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "*",
"Condition": {
"ArnLike": {
"kms:EncryptionContext:evaluationJobArn": "arn:aws:bedrock:us-east-1:123456789012:evaluation-job/*",
"aws:SourceArn": "arn:aws:bedrock:us-east-1:123456789012:evaluation-job/*"
}
}
},
{
"Sid": "BedrockDescribeKey",
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": "kms:DescribeKey",
"Resource": "*",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:bedrock:us-east-1:123456789012:evaluation-job/*"
}
}
}
]
}
```
------
## Configurando permissões do KMS para funções de chamada CreateEvaluationJob de API
Verifique se você tem DescribeKey GenerateDataKey, e as permissões Decrypt para sua função usada para criar o trabalho de avaliação na chave KMS que você usa em seu trabalho de avaliação.
Exemplo de política de chave do KMS
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::account-id:role/APICallingRole"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kmsDescribeKey"
],
"Resource": "*"
}
]
}
```
Exemplo de política do IAM para CreateEvaluationJob API de Role Calling
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CustomKMSKeyProvidedToBedrockEncryption",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"kms:DescribeKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/keyYouUse"
]
}
]
}
```
------
# AWS Key Management Service suporte em trabalhos de avaliação de modelos
O Amazon Bedrock usa o seguinte IAM e AWS KMS as permissões para usar sua AWS KMS chave para descriptografar seus arquivos e acessá-los. Ele salva esses arquivos em um local interno do Amazon S3 gerenciado pelo Amazon Bedrock e usa as permissões a seguir para criptografá-los.
## Requisitos da política do IAM
A política do IAM associada ao perfil do IAM que você está usando para fazer solicitações ao Amazon Bedrock deve ter os elementos a seguir. Para saber mais sobre como gerenciar suas chaves do AWS KMS , consulte [Como usar políticas do IAM com o AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html).
Os trabalhos de avaliação de modelos no Amazon Bedrock usam chaves AWS próprias. Essas chaves do KMS são de propriedade do Amazon Bedrock. Para saber mais sobre chaves AWS próprias, consulte [chaves AWS próprias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) no *Guia do AWS Key Management Service desenvolvedor*.
**Elementos necessários de políticas do IAM**
+ `kms:Decrypt`— Para arquivos que você criptografou com sua AWS Key Management Service chave, fornece ao Amazon Bedrock permissões para acessar e descriptografar esses arquivos.
+ `kms:GenerateDataKey`: controla a permissão para usar a chave do AWS Key Management Service para gerar chaves de dados. O Amazon Bedrock usa `GenerateDataKey` para criptografar os dados temporários que armazena para o trabalho de avaliação.
+ `kms:DescribeKey`: fornece informações detalhadas sobre uma chave do KMS.
+ `kms:ViaService`— A chave de condição limita o uso de uma chave KMS às solicitações de AWS serviços específicos. Especifique o Amazon S3 como um serviço porque o Amazon Bedrock armazena uma cópia temporária dos seus dados em um local do Amazon S3 de sua propriedade.
Veja a seguir um exemplo de política do IAM que contém somente as ações e os recursos do IAM do AWS KMS necessários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CustomKMSKeyProvidedToBedrock",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/[[keyId]]"
]
},
{
"Sid": "CustomKMSDescribeKeyProvidedToBedrock",
"Effect": "Allow",
"Action": [
"kms:DescribeKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/[[keyId]]"
]
}
]
}
```
------
### Configurando permissões do KMS para funções de chamada CreateEvaluationJob de API
Verifique se você tem DescribeKey GenerateDataKey, e as permissões Decrypt para sua função usada para criar o trabalho de avaliação na chave KMS que você usa em seu trabalho de avaliação.
Exemplo de política de chave do KMS
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::account-id:role/APICallingRole"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kmsDescribeKey"
],
"Resource": "*"
}
]
}
```
Exemplo de política do IAM para CreateEvaluationJob API de Role Calling
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CustomKMSKeyProvidedToBedrockEncryption",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"kms:DescribeKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/keyYouUse"
]
}
]
}
```
------
# Criptografia de dados para trabalhos de avaliação de base de conhecimento
Durante um trabalho de avaliação de base de conhecimento, o Amazon Bedrock faz uma cópia temporária dos dados. O Amazon Bedrock exclui os dados após a conclusão do trabalho. Para criptografar os dados, o Amazon Bedrock usa uma chave do KMS. Ele usa uma chave do KMS que você especifica ou uma chave de propriedade do Amazon Bedrock.
O Amazon Bedrock exige o IAM e AWS KMS as permissões nas seções a seguir para que possa usar sua chave KMS para fazer o seguinte:
+ Descriptografar seus dados.
+ Criptografar a cópia temporária que o Amazon Bedrock faz.
Ao criar um trabalho de avaliação de base de conhecimento, você pode optar por usar uma chave do KMS de propriedade do Amazon Bedrock ou escolher sua própria chave gerenciada pelo cliente. Se você não especificar uma chave gerenciada pelo cliente, o Amazon Bedrock usará a chave dele por padrão.
Para poder usar uma chave gerenciada pelo cliente, você deve fazer o seguinte:
+ Adicione as ações e os recursos necessários à política do perfil de serviço do IAM.
+ Adicione os elementos necessários da política de chave do KMS.
+ Crie uma política que possa interagir com sua chave gerenciada pelo cliente. Isso é especificado em uma política de chave do KMS separada.
## Elementos de política necessários
As políticas de chave do IAM e do KMS nas seções abaixo incluem os seguintes elementos obrigatórios:
+ `kms:Decrypt`: para arquivos que você criptografou com a sua chave do KMS, fornece ao Amazon Bedrock permissões para acessar e descriptografar esses arquivos.
+ `kms:GenerateDataKey`: controla a permissão para usar a chave do KMS para gerar chaves de dados. O Amazon Bedrock usa `GenerateDataKey` para criptografar os dados temporários que armazena para o trabalho de avaliação.
+ `kms:DescribeKey`: fornece informações detalhadas sobre uma chave do KMS.
+ `kms:ViaService`— A chave de condição limita o uso de uma chave KMS para solicitar AWS serviços específicos. É necessário especificar os seguintes serviços:
+ Amazon S3, porque o Amazon Bedrock armazena uma cópia temporária dos seus dados em um local do Amazon S3 pertencente ao Amazon Bedrock.
+ Amazon Bedrock, porque o serviço de avaliação chama a API das Bases de Conhecimento do Amazon Bedrock para executar o fluxo de trabalho da base de conhecimento.
+ `kms:EncryptionContext:context-key`— Essa chave de condição limita o acesso às AWS KMS operações para que elas sejam específicas somente ao [contexto de criptografia](https://docs.aws.amazon.com/kms/latest/developerguide/encrypt_context.html) fornecido.
## Requisitos de política do IAM
No perfil do IAM que você usa com o Amazon Bedrock, a política do IAM correspondente deve ter os elementos a seguir. Para saber mais sobre como gerenciar suas AWS KMS chaves, consulte Como [usar políticas do IAM com AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html).
Os trabalhos de avaliação da base de conhecimento no Amazon Bedrock usam chaves AWS próprias. Para obter mais informações sobre chaves AWS próprias, consulte [chaves AWS próprias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) no *Guia do AWS Key Management Service desenvolvedor*.
Veja a seguir um exemplo de política do IAM que contém somente as ações e os recursos necessários do AWS KMS .
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CustomKMSKeyProvidedToBedrockEncryption",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/*"
],
"Condition": {
"StringEquals": {
"kms:ViaService": [
"s3.us-east-1.amazonaws.com"
]
}
}
},
{
"Sid": "CustomKMSKeyProvidedToBedrockEvalKMS",
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/*"
],
"Condition": {
"StringLike": {
"kms:EncryptionContext:evaluationJobArn": "arn:aws:bedrock:us-east-1:123456789012:evaluation-job/*"
}
}
},
{
"Sid": "CustomKMSKeyProvidedToBedrockKBDecryption",
"Effect": "Allow",
"Action": [
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/*"
],
"Condition": {
"StringLike": {
"kms:EncryptionContext:knowledgeBaseArn": "arn:aws:bedrock:us-east-1:123456789012:knowledge-base/*"
}
}
},
{
"Sid": "CustomKMSKeyProvidedToBedrockKBEncryption",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/*"
],
"Condition": {
"StringLike": {
"kms:EncryptionContext:knowledgeBaseArn": "arn:aws:bedrock:us-east-1:123456789012:knowledge-base/*"
},
"StringEquals": {
"kms:ViaService": [
"bedrock.us-east-1.amazonaws.com"
]
}
}
},
{
"Sid": "CustomKMSKeyProvidedToBedrockKBGenerateDataKey",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/*"
],
"Condition": {
"StringLike": {
"kms:EncryptionContext:CustomerAwsAccountId": "123456789012",
"kms:EncryptionContext:SessionId": "*"
},
"StringEquals": {
"kms:ViaService": [
"bedrock.us-east-1.amazonaws.com"
]
}
}
},
{
"Sid": "CustomKMSDescribeKeyProvidedToBedrock",
"Effect": "Allow",
"Action": [
"kms:DescribeKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/*"
]
}
]
}
```
------
## AWS KMS principais requisitos de política
Cada chave do KMS deve ter uma única política de chaves. As instruções na política de chaves determinam quem tem permissão para usar a chave do KMS e como eles podem usá-la. Você também pode usar políticas do IAM e concessões para controlar o acesso às chaves do KMS, mas cada chave do KMS deve ter uma política de chave.
Adicione a declaração a seguir à sua política de chave existente do KMS. Ele fornece ao Amazon Bedrock permissões para armazenar temporariamente seus dados em um bucket do S3 usando a chave do KMS que você especificou.
### Configurando permissões do KMS para funções de chamada CreateEvaluationJob de API
Verifique se você tem DescribeKey GenerateDataKey, e as permissões Decrypt para sua função usada para criar o trabalho de avaliação na chave KMS que você usa em seu trabalho de avaliação.
Exemplo de política de chave do KMS
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::account-id:role/APICallingRole"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kmsDescribeKey"
],
"Resource": "*"
}
]
}
```
Exemplo de política do IAM para CreateEvaluationJob API de Role Calling
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CustomKMSKeyProvidedToBedrockEncryption",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"kms:DescribeKey"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/keyYouUse"
]
}
]
}
```
------
# CloudTrail eventos de gerenciamento em trabalhos de avaliação de modelos
Os [Eventos de gerenciamento](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-events-with-cloudtrail.html#logging-management-events) fornecem informações sobre as operações de recursos executadas em um recurso (por exemplo, leitura ou gravação em um objeto do Amazon S3). Também são conhecidas como operações de plano de dados. Os eventos de dados geralmente são atividades de alto volume que CloudTrail não são registradas por padrão.
Trabalhos de avaliação de modelos registram eventos para vários AWS serviços
**CloudTrail eventos de dados por AWS serviço em trabalhos de avaliação de modelos**
+ **Amazon Bedrock**: eventos de dados para todas as inferências de modelos executadas durante o trabalho de avaliação do modelo.
+ **Amazon SageMaker AI**: eventos de dados para todos os trabalhos de avaliação de modelos baseados em humanos.
+ **Amazon S3**: eventos de dados para leitura e gravação de dados no bucket do Amazon S3 especificados quando o trabalho de avaliação do modelo foi criado.
+ **AWS Key Management Service**: eventos de dados relacionados ao uso de AWS KMS chaves gerenciadas pelo cliente.