

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á.

# Criar um trabalho de avaliação de RAG de recuperação e geração
<a name="knowledge-base-evaluation-create-randg"></a>

Você pode criar um trabalho de avaliação do RAG usando o Console de gerenciamento da AWS, AWS CLI, ou um AWS SDK compatível.

Esse tipo de trabalho requer acesso a um modelo avaliador. Para ver uma lista de modelos avaliadores compatíveis, consulte [Modelos compatíveis](evaluation-kb.md#evaluation-kb-supported). 

Para criar um trabalho usando as instruções a seguir, você precisa de um conjunto de dados de prompts. Se você ainda não criou um, consulte [Criar conjuntos de dados de prompts para avaliação de RAG no Amazon Bedrock](knowledge-base-evaluation-prompt.md).

------
#### [ Console ]

1. Abra o [console do Amazon Bedrock](https://console.aws.amazon.com/bedrock/home).

1. No painel à esquerda, em **Inferência e avaliação**, selecione **Avaliações**.

1. No painel de **Avaliações de RAG**, escolha **Criar**.

1. Para inserir os detalhes da avaliação de RAG, faça o seguinte:

   1. No painel **Detalhes da avaliação**, em **Nome da avaliação**, insira um nome para seu trabalho de avaliação. O nome que você escolher deve ser exclusivo em seu Região da AWS.

   1. Opcionalmente, em **Descrição: *opcional***, insira uma descrição para o trabalho de avaliação.

   1. Em **Modelo de avaliador**, escolha **Selecionar modelo** e escolha o modelo avaliador que você deseja que realize sua avaliação.

1. Insira a fonte de inferência para o trabalho de avaliação. Com as avaliações do Amazon Bedrock RAG, você pode avaliar o desempenho das Bases de Conhecimento do Amazon Bedrock ou de outras fontes de RAG fornecendo seus próprios dados de resposta de inferência no [conjunto de dados de prompts](knowledge-base-evaluation-prompt.md). Para selecionar uma base de conhecimento do Amazon Bedrock, faça o seguinte:

   1. No painel **Fonte de inferência**, em **Selecionar origem**, escolha **Base de conhecimento do Bedrock**.

   1. Em **Escolha uma base de conhecimento**, selecione uma base de conhecimento usando a lista suspensa.

1. Para trazer seus próprios dados de resposta de inferência, faça o seguinte:

   1. No painel **Fonte de inferência**, em **Selecionar origem**, escolha **Trazer suas próprias respostas de inferência**.

   1. Em **Nome da origem**, insira um nome para a origem de RAG que você usou para criar os dados de resposta. O nome inserido deve corresponder ao parâmetro `knowledgeBaseIdentifier` no [conjunto de dados de prompts](knowledge-base-evaluation-prompt.md).

1. No painel **Fonte de inferência**, em **Tipo de avaliação**, selecione **Recuperação e geração de respostas**.

1. Selecione as métricas integradas que você deseja que o modelo avaliador use escolhendo-a no painel **Métricas**.

1. Defina os locais de entrada e saída para o conjunto de dados e os resultados fazendo o seguinte:

   1. No painel **Conjuntos de dados**, em **Escolha um conjunto de dados de prompts**, insira o URI do Amazon S3 para o conjunto de dados de prompts ou escolha **Procurar no S3** e selecione o arquivo. Para ver uma definição do formato de conjunto de dados de prompts necessário para um trabalho de avaliação somente de recuperação, consulte [Criar um conjunto de dados de prompts para trabalhos de avaliação de RAG somente de recuperação](knowledge-base-evaluation-prompt-retrieve.md).

   1. Em **Resultados da avaliação**, insira um local do Amazon S3 para que o Amazon Bedrock salve seus resultados ou escolha **Procurar no S3** para selecionar um local.

1. Em **Perfil do IAM do Amazon Bedrock: Permissões**, selecione **Criar e usar um novo perfil de serviço** para que o Amazon Bedrock crie um perfil do IAM para o trabalho de avaliação ou selecione **Usar um perfil de serviço existente** para escolher um perfil do IAM existente. Para ver uma lista das permissões necessárias para criar e executar um trabalho de avaliação, consulte [Pré-requisitos](knowledge-base-evaluation-create.md#knowledge-base-evaluation-create-prereqs).

1. (Opcional) para usar sua própria chave KMS para criptografar seus dados de avaliação, em **KMSKey - *Opcional*, marque **Personalizar configurações de criptografia (avançadas)** e selecione sua chave**. AWS KMS Por padrão, o Amazon Bedrock criptografa os dados do trabalho de avaliação com uma chave do Amazon Bedrock com uma chave do Amazon AWS Bedrock.

1. Selecione **Criar** para concluir a criação do trabalho de avaliação.

------
#### [ AWS CLI ]

**Criar um trabalho de avaliação de recuperação e geração para uma base de conhecimento do Amazon Bedrock**
+ Execute o AWS CLI comando a seguir usando o arquivo JSON de exemplo.

  ```
  aws bedrock create-evaluation-job --cli-input-json file://{{my_eval_job.json}}
  ```

  ```
  {
      "jobName": {{"my_rag_eval"}},
      "roleArn": {{"arn:aws:iam::111122223333:role/service-role/Amazon-Bedrock-IAM-Role-Amazon-Bedrock-IAM-Role-20250218T063974"}},
      "applicationType": "RagEvaluation",
      "evaluationConfig": {
          "automated": {
              "datasetMetricConfigs": [
                  {
                      "taskType": "General",
                      "dataset": {
                          "name": "text_dataset",
                          "datasetLocation": {
                              "s3Uri": "s3://amzn-s3-demo-bucket/input/retrieve-and-generate/rng-eval-byoir.jsonl"
                          }
                      },
                      "metricNames": [
                          "Builtin.Correctness",
                          "Builtin.Completeness",
                          "Builtin.Helpfulness",
                          "Builtin.LogicalCoherence",
                          "Builtin.Faithfulness",
                          "Builtin.Harmfulness",
                          "Builtin.Stereotyping",
                          "Builtin.Refusal",
                          "Builtin.CitationCoverage",
                          "Builtin.CitationPrecision"
                      ]
                  }
              ],
              "evaluatorModelConfig": {
                  "bedrockEvaluatorModels": [
                      {
                          "modelIdentifier": "us.meta.llama3-1-70b-instruct-v1:0"
                      }
                  ]
              }
          }
      },
     "inferenceConfig": {
          "ragConfigs": [
              {
                  "knowledgeBaseConfig": {
                      "retrieveAndGenerateConfig": {
                          "type": "KNOWLEDGE_BASE",
                          "knowledgeBaseConfiguration": {
                              "knowledgeBaseId": {{"≪Your Knowledge Base ID>"}},
                              "modelArn": "mistral.mistral-large-2402-v1:0",
                              "generationConfiguration": {
                                  "promptTemplate": {
                                      "textPromptTemplate": "$search_results$ hello world template"
                                  }
                              },
                              "orchestrationConfiguration": {
                                  "queryTransformationConfiguration": {
                                      "type": "QUERY_DECOMPOSITION"
                                  }
                               }
                          }
                      }
                  }
              }
          ]
      },
      "outputDataConfig": {
          "s3Uri": "s3://amzn-s3-demo-bucket/output/"
      }
  }
  ```

**Executar um trabalho de avaliação de recuperação e geração usando seus próprios dados de resposta de inferência**
+ Execute o AWS CLI comando a seguir usando o arquivo JSON de exemplo.

  ```
  aws bedrock create-evaluation-job --cli-input-json file://{{my_eval_job.json}}
  ```

  ```
  {
      "jobName": {{"my_rag_eval"}},
      "roleArn": {{"arn:aws:iam::111122223333:role/service-role/Amazon-Bedrock-IAM-Role-Amazon-Bedrock-IAM-Role-20250218T063974"}},
      "applicationType": "RagEvaluation",
      "evaluationConfig": {
          "automated": {
              "datasetMetricConfigs": [
                  {
                      "taskType": "General",
                      "dataset": {
                          "name": "text_dataset",
                          "datasetLocation": {
                              "s3Uri": "s3://amzn-s3-demo-bucket/input/retrieve-and-generate/rng-eval-byoir.jsonl"
                          }
                      },
                      "metricNames": [
                          "Builtin.Correctness",
                          "Builtin.Completeness",
                          "Builtin.Helpfulness",
                          "Builtin.LogicalCoherence",
                          "Builtin.Faithfulness",
                          "Builtin.Harmfulness",
                          "Builtin.Stereotyping",
                          "Builtin.Refusal",
                          "Builtin.CitationCoverage",
                          "Builtin.CitationPrecision"
                      ]
                  }
              ],
              "evaluatorModelConfig": {
                  "bedrockEvaluatorModels": [
                      {
                          "modelIdentifier": "us.meta.llama3-1-70b-instruct-v1:0"
                      }
                  ]
              }
          }
      },
      "inferenceConfig": {
          "ragConfigs": [
              {
                  "precomputedRagSourceConfig": {
                      "retrieveAndGenerateSourceConfig": {
                          "ragSourceIdentifier": {{"my_rag_source"}}
                      }
                  }
              }
          ]
      },
      "outputDataConfig": {
          "s3Uri": "s3://amzn-s3-demo-bucket/output/"
      }
  }
  ```

------
#### [ SDK for Python ]

O exemplo de Python a seguir demonstra como fazer uma solicitação de API *Recuperar e Gerar* do boto3.

```
import boto3
client = boto3.client('bedrock')

job_response = client.create_evaluation_job(
    jobName="my_evaluation_job",
    jobDescription="two different task types",
    roleArn="arn:aws:iam::111122223333:role/role-name",
    applicationType="RagEvaluation",
    inferenceConfig={
        "ragConfigs": [
            {
                "knowledgeBaseConfig": {
                    "retrieveAndGenerateConfig": {
                        "type": "KNOWLEDGE_BASE",
                        "knowledgeBaseConfiguration": {
                            "knowledgeBaseId": "73SPNQM4CI",
                            "modelArn": "anthropic.claude-3-sonnet-20240229-v1:0",
                            "generationConfiguration": {
                                "promptTemplate": {
                                    "textPromptTemplate": "$search_results$ hello world template"
                                }
                            },
                             "retrievalConfiguration": {
                                 "vectorSearchConfiguration": {
                                     "numberOfResults": 10,
                                     "overrideSearchType": "HYBRID"
                                }
                             }
                        }
                    }
                }
            }
        ]
    },
    outputDataConfig={
        "s3Uri":"s3://amzn-s3-demo-bucket-model-evaluations/outputs/"
    },
    evaluationConfig={
        "automated": {
            "datasetMetricConfigs": [
                {
                    "taskType": "Summarization",
                    "dataset": {
                        "name": "RagDataset",
                        "datasetLocation": {
                            "s3Uri": "s3://amzn-s3-demo-bucket-input-data/data_3_rng.jsonl"
                        }
                    },
                    "metricNames": [
                        "Builtin.Faithfulness"
                    ]
                }
            ],
            "evaluatorModelConfig":
                {
                    "bedrockEvaluatorModels": [{
                        "modelIdentifier": "meta.llama3-1-70b-instruct-v1:0"
                    }]
                }
        }
    }
)

print(job_response)
```

------