# Avaliar o modelo treinado do SageMaker AI O objetivo do processo de avaliação é avaliar o desempenho do modelo treinado em relação a referências ou conjuntos de dados personalizados. O processo de avaliação geralmente envolve etapas para criar uma fórmula de avaliação apontando para o modelo treinado, especificar conjuntos de dados e métricas de avaliação, enviar um trabalho separado para avaliação e avaliar com base em referências padrão ou dados personalizados. O processo de avaliação gerará métricas de desempenho armazenadas no bucket do Amazon S3. **nota** O processo de avaliação descrito neste tópico é um processo off-line. O modelo é testado em relação a referências fixas com respostas predefinidas, em vez de ser avaliado em tempo real ou por meio de interações ao vivo com o usuário. Para avaliação em tempo real, você pode testar o modelo depois de implantado no Amazon Bedrock chamando as APIs de runtime do [Amazon Bedrock](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html). **Topics** + [Pré-requisitos](#nova-model-evaluation-prerequisites) + [Tarefas de referência disponíveis](#nova-model-evaluation-benchmark) + [Configurações específicas de avaliação](#nova-model-evaluation-config) + [Executar tarefas de treinamento de avaliação](#nova-model-evaluation-notebook) + [Avaliar e analisar os resultados da avaliação](#nova-model-evaluation-assess) + [Práticas recomendadas e solução de problemas de avaliação](#nova-model-evaluation-best-practices) + [Subtarefas disponíveis](#nova-model-evaluation-subtasks) + [Treinamento iterativo](smtj-iterative-training.md) ## Pré-requisitos Antes de iniciar uma tarefa de treinamento de avaliação, observe o seguinte: + Um modelo do Amazon Nova treinado pelo SageMaker AI que você deseja avaliar o desempenho. + Fórmula básica do Amazon Nova para avaliação. Para obter mais informações, consulte [Obter fórmulas do Amazon Nova](nova-model-recipes.md#nova-model-get-recipes). ## Tarefas de referência disponíveis Um pacote de código de amostra está disponível para demonstrar como calcular métricas de referência usando o recurso de avaliação de modelo do SageMaker AI para o Amazon Nova. Para acessar os pacotes de código, consulte [sample-Nova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/). Veja aqui uma lista de referências padrão do setor disponíveis e compatíveis. É possível especificar as referências a seguir no parâmetro `eval_task`. **Referências disponíveis para avaliação de modelo** | Referência | Modalidade | Descrição | Métricas | Estratégia | Subtarefa disponível | | --- | --- | --- | --- | --- | --- | | mmlu | Texto | Compreensão de linguagem multitarefa: testa o conhecimento em 57 disciplinas. | accuracy | zs\$1cot | Sim | | mmlu\$1pro | Texto | MMLU (subconjunto profissional): concentra-se em domínios profissionais como direito, medicina, contabilidade e engenharia. | accuracy | zs\$1cot | Não | | bbh | Texto | Tarefas de raciocínio avançado: um conjunto de problemas desafiadores que testam habilidades cognitivas e de resolução de problemas de nível mais alto. | accuracy | fs\$1cot | Sim | | gpqa | Texto | Resposta a perguntas de física geral: avalia a compreensão de conceitos de física e habilidades relacionadas à resolução de problemas. | accuracy | zs\$1cot | Não | | math | Texto | Resolução de problemas matemáticos: mede o raciocínio matemático em vários tópicos, como álgebra, cálculo e problemas de palavras. | exact\$1match | zs\$1cot | Sim | | strong\$1reject | Texto | Tarefa de controle de qualidade: testa a capacidade do modelo de detectar e rejeitar conteúdo impróprio, prejudicial ou incorreto. | deflection | zs | Sim | | ifeval | Texto | Avaliação de seguimento de instruções: avalia com que precisão um modelo segue as instruções dadas e conclui as tarefas conforme as especificações. | accuracy | zs | Não | | gen\$1qa | Multimodal (imagem) | Avaliação personalizada do conjunto de dados: permite que você forneça seu próprio conjunto de dados para avaliação comparativa, comparando as saídas dos modelos para as respostas de referência com métricas como ROUGE e BLEU. `gen_qa` é compatível com a inferência de imagens para modelos baseados no Amazon Nova Lite e no Amazon Nova Pro. Também permite o uso de perfis do lambda para métricas personalizadas. (Para avaliação de RFT, use a fórmula de avaliação de RFT) | todas | gen\$1qa | Não | | mmmu | Multimodal | Massive Multidiscipline Multimodal Understanding (MMMU): avaliação comparativa de nível universitário que compreende perguntas abertas e de múltipla escolha de 30 disciplinas. | accuracy | zs\$1cot | Sim | | llm\$1judge | Texto | Comparação de preferências do LLM como avaliador: usa um modelo avaliador do Nova para determinar a preferência entre respostas emparelhadas (B em comparação com A) para os prompts, calculando a probabilidade de B ser preferida em relação a A. | todas | avaliador | Não | | mm\$1llm\$1judge | Multimodal (imagem) | Esta nova avaliação comparativa se comporta da mesma forma que o `llm_judge` baseado em texto acima. A única diferença é que ele é compatível com a inferência de imagens. | todas | avaliador | Não | | rubric\$1llm\$1judge | Texto | O Rubric Judge é um modelo aprimorado de avaliação LLM como avaliador criado no Nova 2.0 Lite. Ao contrário do [modelo original do avaliador](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/), que fornece apenas veredictos preferenciais, o Rubric Judge gera dinamicamente critérios de avaliação personalizados para cada prompt e atribui pontuações granulares em várias dimensões. | todas | avaliador | Não | | aime\$12024 | Texto | AIME 2024: problemas do American Invitational Mathematics Examination que testam raciocínio matemático avançado e resolução de problemas | exact\$1match | zs\$1cot | Não | | calendar\$1scheduling | Texto | Natural Plan: agendamento de calendário, tarefa de teste de habilidades de planejamento para marcar reuniões de vários dias e com várias pessoas | exact\$1match | fs | Não | | humaneval | Texto | HumanEval: um conjunto de dados de referência projetado para avaliar as capacidades de geração de código de grandes modelos de linguagem. | passar@1 | zs | Não | ## Configurações específicas de avaliação Abaixo é apresentado um detalhamento dos principais componentes na fórmula e orientações sobre como modificá-los para seus casos de uso. ### Informações sobre as fórmulas e sobre como modificá-las **Configuração geral de execução** ``` run: name: eval_job_name model_type: amazon.nova-lite-v1:0:300k model_name_or_path: nova-lite/prod # or s3://escrow_bucket/model_location replicas: 1 data_s3_path: "" mlflow_tracking_uri: "" mlflow_experiment_name : "" mlflow_run_name : "" ``` + `name`: um nome descritivo para sua tarefa de avaliação. + `model_type`: especifica a variante do modelo do Nova a ser usada. Não modifique manualmente esse campo. Entre as opções estão: + amazon.nova-micro-v1:0:128k + amazon.nova-lite-v1:0:300k + amazon.nova-pro-v1:0:300k + amazon.nova-2-lite-v1:0:256k (modelo Nova 2.0: consulte o [guia de personalização do Nova 2.0](https://docs.aws.amazon.com//nova/latest/nova2-userguide/nova-model.html)) + `model_name_or_path`: o caminho para o modelo de base ou caminho do S3 para o ponto de verificação pós-treinado. Entre as opções estão: + nova-micro/prod + nova-lite/prod + nova-pro/prod + nova-lite-2/prod (modelo Nova 2.0) + Caminho do S3 para o caminho do ponto de verificação pós-treinado (`s3:customer-escrow-111122223333-smtj-/`) **nota** **Avaliar modelo pós-treinado** Para avaliar um modelo pós-treinado após uma tarefa de treinamento de SFT do Nova, siga estas etapas após executar uma tarefa de treinamento bem-sucedida. No final dos logs de treinamento, você verá a mensagem de log “Training is complete”. Você também encontrará um arquivo `manifest.json` no bucket de saída que contém o local do ponto de verificação. Esse arquivo estará localizado dentro de um arquivo `output.tar.gz` no local de saída do S3. Para continuar com a avaliação, use esse ponto de verificação definindo-o como o valor para `run.model_name_or_path` na configuração da sua fórmula. + `replica`: o número de instâncias de computação a serem usadas para inferência distribuída (execução de inferência em vários nós). Defina `replica` > 1 para permitir a inferência de vários nós, o que acelera a avaliação. Se `instance_count` e `replica` forem especificados, `instance_count` terá precedência. Observe que várias réplicas só se aplicam às tarefas de treinamento do SageMaker AI. + `data_s3_path`: o caminho do Amazon S3 do conjunto de dados de entrada. Esse campo é obrigatório, mas sempre deve ser deixado em branco. + `mlflow_tracking_uri`: (opcional) a localização do servidor de rastreamento MLflow (necessário somente no SMHP) + `mlflow_experiment_name`: (opcional) nome do experimento para agrupar execuções de ML relacionadas + `mlflow_run_name`: (opcional) nome personalizado para um treinamento específico executado em um experimento **Configuração da avaliação** ``` evaluation: task: mmlu strategy: zs_cot subtask: abstract_algebra metric: accuracy ``` + `task`: especifica a referência ou tarefa de avaliação a ser usada. As tarefas permitidas incluem: + `mmlu` + `mmlu_pro` + `bbh` + `gpqa` + `math` + `strong_reject` + `gen_qa` + `ifeval` + `mmmu` + `llm_judge` + `mm_llm_judge` + `rubric_llm_judge` + `aime_2024` + `calendar_scheduling` + `humaneval` + `strategy`: define a abordagem de avaliação. + `zs_cot`: cadeia de pensamento zero shot, uma abordagem de utilização de prompts em grandes modelos de linguagem que incentiva o raciocínio passo a passo sem exigir exemplos explícitos. + `fs_cot`: cadeia de pensamento few shot, uma abordagem que fornece alguns exemplos de raciocínio passo a passo antes de pedir ao modelo que resolva um novo problema. + `zs`: zero shot, uma abordagem para resolver um problema sem nenhum exemplo de treinamento prévio. + `gen_qa`: estratégia específica para trazer seu próprio conjunto de dados. + `judge`: estratégia específica para LLM Nova como avaliador e `mm_llm_judge`. + `subtask`: opcional. Componentes específicos da tarefa de avaliação. Para ver uma lista completa de subtarefas disponíveis, consulte [Subtarefas disponíveis](#nova-model-evaluation-subtasks). + Verifique as subtarefas permitidas em “Tarefas de referência disponíveis”. + É necessário remover esse campo se não houver subtarefas de referência. + `metric`: a métrica de avaliação a ser usada. + `accuracy`: porcentagem de respostas corretas. + `exact_match`: para a referência math, exibe a taxa na qual as strings previstas de entrada correspondem exatamente às respectivas referências. + `deflection`: para a referência strong reject, exibe a deflexão relativa ao modelo base e as métricas de significância da diferença. + `all`: Para a referência `gen_qa`, traga seu próprio conjunto de dados, exibe as seguintes métricas: + `rouge1`: mede a sobreposição de unigramas (palavras únicas) entre o texto gerado e o texto de referência. + `rouge2`: mede a sobreposição de bigramas (duas palavras consecutivas) entre o texto gerado e o texto de referência. + `rougeL`: mede a maior subsequência comum entre textos, permitindo lacunas na correspondência. + `exact_match`: pontuação binária (0 ou 1) indicando se o texto gerado corresponde exatamente ao texto de referência, caractere por caractere. + `quasi_exact_match`: semelhante à correspondência exata, mas mais tolerante. Geralmente ignora diferenças de maiúsculas e minúsculas, pontuação e espaço em branco. + `f1_score`: média harmônica de precisão e recall. Mede a sobreposição de palavras entre as respostas previstas e de referência. + `f1_score_quasi`: semelhante ao f1\$1score, mas com uma correspondência mais branda. Usa a comparação de texto normalizada que ignora pequenas diferenças. + `bleu`: mede a precisão das correspondências de n-gramas entre o texto gerado e o texto de referência. É comumente usada em avaliação de tradução. Para `llm_judge` e `mm_llm_judge`, utilize seu próprio conjunto de dados de avaliação comparativa e obtenha as seguintes métricas: + `a_scores`: número de acertos da `response_A` em passagens de avaliação para frente e para trás. + `a_scores_stderr`: erro padrão de `response_A_scores` em avaliações de pares. + `b_scores`: mede o número de acertos da `response_B` em passes de avaliação para frente e para trás. + `a_scores_stderr`: erro padrão de `response_B_scores` em avaliações de pares. + `ties`: número de avaliações em que a `response_A` e a `response_B` são avaliadas como iguais. + `ties_stderr`: erro padrão de `ties` em avaliações de pares. + `inference_error`: contagem de avaliações que não puderam ser concluídas adequadamente. + `score`: pontuação agregada com base nos acertos dos passes para frente e para trás da `response_B`. + `score_stderr`: pontuação agregada com base nos acertos dos passes para frente e para trás da `response_B`. + `inference_error_stderr`: erro padrão da pontuação agregada em avaliações de pares. + `winrate`: a probabilidade de que a `response_B` será preferida em relação à `response_A` calculada por meio da probabilidade de Bradley-Terry. + `lower_rate`: limite inferior (2,5º percentil) da taxa de acerto estimada da amostragem de bootstrap. + `upper_rate`: limite inferior (97,5º percentil) da taxa de acerto estimada da amostragem de bootstrap. **Configuração de inferência (opcional)** ``` inference: max_new_tokens: 2048 top_k: -1 top_p: 1.0 temperature: 0 top_logprobs: 10 reasoning_effort: null # options: low/high to enable reasoning or null to disable reasoning ``` + `max_new_tokens`: número máximo de tokens a serem gerados. Deve ser um número inteiro. (Indisponível para LLM como avaliador.) + `top_k`: número de tokens de maior probabilidade a serem considerados. Deve ser um número inteiro. + `top_p`: limite de probabilidade cumulativa para a amostragem de tokens. Deve ser um número de ponto flutuante entre 1,0 e 0,0. + `temperature`: aleatoriedade na seleção de tokens (maior = mais aleatório). Mantenha 0 que o resultado seja determinístico. Tipo flutuante. O valor mínimo é 0. + `top_logprobs`: o número dos principais logprobs a serem retornados na resposta de inferência. O valor deve ser um número inteiro de 0 a 20. Os logprobs contêm os tokens de saída considerados e as probabilidades logarítmicas de cada token de saída retornado no conteúdo da mensagem. + `reasoning_effort`: controla o comportamento de raciocínio para modelos capazes de raciocinar. Defina `reasoning_effort` somente quando `model_type` especificar um modelo capaz de raciocínio (atualmente `amazon.nova-2-lite-v1:0:256k`). As opções disponíveis são null (valor padrão se não definido; desabilita o raciocínio), low ou high. ### Formato de saída da probabilidade logarítmica Quando `top_logprobs` está configurado em suas definições de inferência, o resultado da avaliação inclui probabilidades logarítmicas em nível de token nos arquivos parquet. Cada posição de token contém um dicionário dos principais tokens candidatos com suas probabilidades logarítmicas na seguinte estrutura: ``` { "Ġint": {"logprob_value": -17.8125, "decoded_value": " int"}, "Ġthe": {"logprob_value": -2.345, "decoded_value": " the"} } ``` Cada entrada de token contém: + `logprob_value`: o valor da probabilidade logarítmica para o token + `decoded_value`: a representação de string decodificada legível por humanos do token O token bruto do tokenizador é usado como a chave do dicionário para garantir a exclusividade, enquanto `decoded_value` fornece uma interpretação legível. ### Exemplos de fórmula de avaliação O Amazon Nova oferece quatro tipos diferentes de fórmula de avaliação. Todas as fórmulas estão disponíveis no [repositório de fórmulas do SageMaker HyperPod no GitHub](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection). **Topics** #### Fórmulas gerais de referência de texto Essas fórmulas permitem que você avalie as capacidades fundamentais dos modelos do Amazon Nova em um conjunto abrangente de referências somente de texto. Formato da fórmula: `xxx_general_text_benchmark_eval.yaml`. #### Fórmulas de referência de traga seu próprio conjunto de dados Essas fórmulas permitem que você traga seu próprio conjunto de dados para fins de avaliação comparativa e compare os resultados do modelo com as respostas de referência usando diferentes tipos de métrica. Formato da fórmula: `xxx_ bring_your_own_dataset_eval.yaml`. **Traga seus próprios requisitos de conjunto de dados** Formato do arquivo: + Um único arquivo `gen_qa.jsonl` contendo exemplos de avaliação. O nome do arquivo deve ser exatamente `gen_qa.jsonl`. + Você deve fazer o upload de seu conjunto de dados em um local do S3 que as tarefas de treinamento do SageMaker AI possam acessar. + O arquivo deve seguir o formato de esquema exigido para um conjunto de dados geral de perguntas e respostas. Exigências do formato do esquema: cada linha no arquivo `.jsonl` deve ser um objeto JSON com os campos a seguir. + Campos obrigatórios. `query`: string contendo a pergunta ou instrução que precisa de uma resposta. `response`: string contendo a saída esperada do modelo. + Campos opcionais. `system`: string contendo o prompt do sistema que define o comportamento, o perfil ou a personalidade do modelo de IA antes de processar a consulta. `images`: matriz contendo uma lista de objetos com atributos de dados (strings de imagens codificadas em Base64). `metadata`: string contendo metadados associados à entrada para fins de marcação. **Exemplo de entrada** ``` { "system":"You are an English major with top marks in class who likes to give minimal word responses: ", "query":"What is the symbol that ends the sentence as a question", "response":"?" }{ "system":"You are a pattern analysis specialist who provides succinct answers: ", "query":"What is the next number in this series? 1, 2, 4, 8, 16, ?", "response":"32" }{ "system":"You have great attention to detail and follow instructions accurately: ", "query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry", "response":"of dry" }{ "system": "Image inference: ", "query": "What is the number in the image? Please just use one English word to answer.", "response": "two", "images": [ { "data": "data:image/png;Base64,iVBORw0KGgoA ..." } ] } ``` Para usar seu conjunto de dados personalizado, modifique sua fórmula de avaliação adicionando os campos obrigatórios abaixo sem alterar a configuração existente: ``` evaluation: task: gen_qa strategy: gen_qa metric: all ``` **Limitações** + Somente um arquivo `.jsonl` é permitido por avaliação. + O arquivo deve seguir rigorosamente o esquema definido. ##### Trazer suas próprias métricas Você pode trazer suas próprias métricas para personalizar totalmente seu fluxo de trabalho de avaliação de modelos com recursos personalizados de pré-processamento, pós-processamento e métricas. O pré-processamento permite que você processe os dados de entrada antes de enviá-los ao servidor de inferência, e o pós-processamento permite que você personalize o cálculo das métricas e retorne métricas personalizadas com base nas suas necessidades. Siga estas etapas para criar suas próprias métricas com o SDK de avaliação personalizado. 1. Caso ainda não tenha feito isso, [crie uma função do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) na sua primeira Conta da AWS. 1. Faça o download do arquivo `nova-custom-eval-layer.zip` pré-criado do [repositório do GitHub](https://github.com/aws/nova-custom-eval-sdk/releases). Você pode usar esse SDK de avaliação personalizada de código aberto do Nova para validar as cargas úteis de entrada e saída de sua função personalizada e fornecer uma interface unificada para integração com a avaliação de traga suas próprias métricas do Nova durante o treinamento. 1. Faça o upload da camada do Lambda personalizada usando o seguinte comando: ``` aws lambda publish-layer-version \ --layer-name nova-custom-eval-layer \ --zip-file fileb://nova-custom-eval-layer.zip \ --compatible-runtimes python3.12 python3.11 python3.10 python3.9 ``` 1. Adicione essa camada como uma camada personalizada à sua função do Lambda, junto com a camada necessária da AWS: `AWSLambdaPowertoolsPythonV3-python312-arm64` (necessária para a dependência `pydantic`). 1. Atualize seu código do Lambda usando o exemplo fornecido, modificando o código conforme necessário. Esse código de exemplo cria uma função do Lambda para a avaliação personalizada do Nova com etapas de pré-processamento e pós-processamento para a avaliação de modelo. ``` from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler @preprocess def preprocessor(event: dict, context) -> dict: data = event.get('data', {}) return { "statusCode": 200, "body": { "system": data.get("system"), "prompt": data.get("prompt", ""), "gold": data.get("gold", "") } } @postprocess def postprocessor(event: dict, context) -> dict: # data is already validated and extracted from event data = event.get('data', []) inference_output = data.get('inference_output', '') gold = data.get('gold', '') metrics = [] inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0 metrics.append({ "metric": "inverted_accuracy_custom", "value": accuracy }) # Add more metrics here return { "statusCode": 200, "body": metrics } # Build Lambda handler lambda_handler = build_lambda_handler( preprocessor=preprocessor, postprocessor=postprocessor ) ``` 1. Conceda ao Lambda acesso à tarefa de avaliação. Certifique-se de que o perfil de execução especificado para a tarefa de avaliação inclua uma política para invocar sua função do Lambda. Veja a seguir um exemplo de política: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "LambdaAccess", "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction", "Condition": { "StringLike": { "aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN" } } }, { "Sid": "DenyNonAWSEventSourcesForLambda", "Effect": "Deny", "Action": [ "lambda:InvokeFunction" ], "Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction", "Condition": { "Null": { "lambda:EventSourceToken": false } } } ] } ``` ------ 1. Analise o esquema de carga útil do Lambda. A tabela a seguir lista o esquema de solicitação e resposta do Lambda. Você pode validar seu esquema usando o SDK de avaliação personalizada do Nova. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/nova/latest/userguide/nova-model-evaluation.html) 1. Modifique o arquivo da fórmula. Aqui está um exemplo. ``` processor: lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name lambda_type: "custom_metrics" preprocessing: enabled: true postprocessing: enabled: true aggregation: average ``` + `lambda-arn`: o nome do recurso da Amazon (ARN) para sua função do Lambda que lida com o pré-processamento e pós-processamento. + `lambda_type`: “custom\$1metrics” ou “rft”. + `preprocessing`: se as operações de pré-processamento personalizadas devem ser habilitadas. + `postprocessing`: se as operações de pós-processamento personalizadas devem ser habilitadas. + `aggregation`: função de agregação integrada (opções válidas: mínimo, máximo, média, soma). **Limitações** + Traga suas próprias métricas só se aplica a conjuntos de dados de entrada de texto. + Não há suporte para conjuntos de dados de entrada multimodais. + A etapa de pré-processamento não processa o campo de metadados. #### Fórmulas de referência de LLM como avaliador do Nova O LLM como avaliador do Nova é um recurso de avaliação de modelo que permite que você compare a qualidade das respostas de um modelo com a resposta de um modelo de referência em um conjunto de dados personalizado. Ele aceita um conjunto de dados contendo prompts, respostas de referência e respostas do contestador e usa um modelo avaliador do Nova para fornecer uma métrica de taxa de acertos com base na [probabilidade de Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) por meio de comparações de pares. Formato da fórmula: `xxx_llm_judge_eval.yaml`. **Requisitos do conjunto de dados do LLM do Nova** Formato do arquivo: + Um único arquivo `llm_judge.jsonl` contendo exemplos de avaliação. O nome do arquivo deve ser exatamente `llm_judge.jsonl`. + Você deve fazer o upload de seu conjunto de dados em um local do S3 que as tarefas de treinamento do SageMaker AI possam acessar. + O arquivo deve seguir o formato de esquema exigido para o conjunto de dados `llm_judge`. + O conjunto de dados de entrada deve garantir que todos os registros tenham menos de 12 mil de comprimento de contexto. Formato do esquema: cada linha no arquivo `.jsonl` deve ser um objeto JSON com os campos a seguir. + Campos obrigatórios. `prompt`: string contendo o prompt para a resposta gerada. `response_A`: string contendo a resposta de referência. `response_B`: string contendo a resposta alternativa a ser comparada com a resposta de referência. Exemplo de entrada ``` { "prompt": "What is the most effective way to combat climate change?", "response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.", "response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less." } { "prompt": "Explain how a computer's CPU works", "response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.", "response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations." } { "prompt": "How does photosynthesis work?", "response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.", "response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts." } ``` Para usar seu conjunto de dados personalizado, modifique a fórmula de avaliação com os campos obrigatórios a seguir. Não altere nenhum conteúdo. ``` evaluation: task: llm_judge strategy: judge metric: all ``` **Limitações** + Somente um arquivo `.jsonl` é permitido por avaliação. + O arquivo deve seguir rigorosamente o esquema definido. + Os modelos avaliadores do Nova são os mesmos nas especificações Micro/Lite/Pro. + No momento, não há compatibilidade para modelos avaliadores. ##### LLM como avaliador do Nova para fórmulas de avaliações comparativas multimodais (imagem) O LLM como avaliador do Nova para multimodais (imagem), ou simplesmente Nova MM\$1LLM Judge, é um recurso de avaliação de modelos que permite que você compare a qualidade das respostas de um modelo com as respostas de um modelo de linha de base usando um conjunto de dados personalizado. Ele aceita um conjunto de dados contendo prompts, respostas de linha de base, respostas do desafiante e imagens no formato de string codificada em Base64, e depois usa um modelo avaliador do Nova para fornecer uma métrica de taxa de acertos com base na probabilidade de [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) por meio de comparações de pares. Formato da fórmula: `xxx_mm_llm_judge_eval.yaml`. **Requisitos do conjunto de dados do LLM do Nova** Formato do arquivo: + Um único arquivo `mm_llm_judge.jsonl` contendo exemplos de avaliação. O nome do arquivo deve ser exatamente `llm_judge.jsonl`. + Você deve fazer o upload de seu conjunto de dados em um local do S3 que as tarefas de treinamento do SageMaker AI possam acessar. + O arquivo deve seguir o formato de esquema exigido para o conjunto de dados `mm_llm_judge`. + O conjunto de dados de entrada deve garantir que todos os registros estejam dentro do limite de 12 mil de contexto, excluindo o atributo da imagem. Formato do esquema: cada linha no arquivo `.jsonl` deve ser um objeto JSON com os campos a seguir. + Campos obrigatórios. `prompt`: string contendo o prompt para a resposta gerada. `images`: matriz contendo uma lista de objetos com atributos de dados (os valores são strings de imagens codificadas em Base64). `response_A`: string contendo a resposta de referência. `response_B`: string contendo a resposta alternativa a ser comparada com a resposta de referência. Exemplo de entrada Para facilitar a leitura, o exemplo a seguir inclui novas linhas e recuo, mas no conjunto de dados real, cada registro deve estar em uma única linha. ``` { "prompt": "What is in the image?", "images": [ { "data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..." } ], "response_A": "a dog.", "response_B": "a cat.", } { "prompt": "How many animals are in each of the images?", "images": [ { "data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..." }, { "data": "data:image/jpeg;Base64,/DKEafe3gihn..." } ], "response_A": "The first image contains one cat and the second image contains one dog", "response_B": "The first image has one aminal and the second has one animal" } ``` Para usar seu conjunto de dados personalizado, modifique a fórmula de avaliação com os campos obrigatórios a seguir. Não altere nenhum conteúdo. ``` evaluation: task: mm_llm_judge strategy: judge metric: all ``` **Limitações** + Somente um arquivo `.jsonl` é permitido por avaliação. + O arquivo deve seguir rigorosamente o esquema definido. + Os modelos Nova MM Judge são compatíveis apenas com a referência de imagem. + Os modelos Nova MM Judge são iguais nas especificações do Amazon Nova Micro, Amazon Nova Lite e Amazon Nova Pro. + No momento, não há compatibilidade para modelos avaliadores. + O URI de imagem do Amazon S3 não é compatível. + O conjunto de dados de entrada deve garantir que todos os registros estejam dentro do limite de 12 mil de contexto, excluindo o atributo de imagens. ## Executar tarefas de treinamento de avaliação Inicie uma tarefa de treinamento usando o exemplo de caderno a seguir. Consulte o caderno abaixo como exemplo para executar a tarefa de treinamento de avaliação. Para ter mais informações, consulte [Usar um estimador do SageMaker AI para executar uma tarefa de treinamento](https://docs.aws.amazon.com//sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html). ### Tabelas de referência Antes de executar o caderno, consulte as tabelas de referência a seguir para selecionar o URI da imagem e as configurações de instância. **Selecionar o URI da imagem** | Fórmula | URI da imagem | | --- | --- | | URI da imagem de avaliação | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest | **Selecionar o tipo e da contagem de instâncias** | Modelo | Tipo de trabalho | Tipo de instância | Contagem de instâncias recomendada | Contagem de instâncias permitidas | | --- | --- | --- | --- | --- | | Amazon Nova Micro | Avaliação (SFT/DPO) | g5.12xlarge | 1 | 1 a 16 | | Amazon Nova Lite | Avaliação (SFT/DPO) | g5.12xlarge | 1 | 1 a 16 | | Amazon Nova Pro | Avaliação (SFT/DPO) | p5.48xlarge | 1 | 1 a 16 | ### Exemplo de bloco de notas O exemplo de caderno a seguir demonstra como executar uma tarefa de treinamento de avaliação. ``` # install python SDK # Do not use sagemaker v3, as sagemaker v3 introduced breaking changes !pip install sagemaker==2.254.1 import os import sagemaker,boto3 from sagemaker.inputs import TrainingInput from sagemaker.pytorch import PyTorch sagemaker_session = sagemaker.Session() role = sagemaker.get_execution_role() # Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local # Assume the file name be `recipe.yaml` # Populate parameters # input_s3_uri = "s3:///input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location output_s3_uri= "s3:///output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location instance_type = "instance_type" # ml.g5.16xlarge as example instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation) job_name = "your job name" recipe_path = "recipe path" # ./recipe.yaml as example image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change output_kms_key = "" # optional, leave blank for Amazon managed encryption # (Optional) To bring your own dataset and LLM judge for evaluation # evalInput = TrainingInput( # s3_data=input_s3_uri, # distribution='FullyReplicated', # s3_data_type='S3Prefix' #) estimator = PyTorch( output_path=output_s3_uri, base_job_name=job_name, role=role, instance_type=instance_type, instance_count=instance_count, training_recipe=recipe_path, sagemaker_session=sagemaker_session, image_uri=image_uri, output_kms_key=output_kms_key ) estimator.fit() # If input dataset exist, pass in inputs # estimator.fit(inputs={"train": evalInput}) ``` ## Avaliar e analisar os resultados da avaliação Após a conclusão bem-sucedida do seu trabalho de avaliação, você poderá avaliar e analisar os resultados usando as etapas a seguir. **Para avaliar e analisar os resultados, siga as etapas abaixo.** 1. Entenda a estrutura do local de saída. Os resultados são armazenados no local de saída especificado do Amazon S3 como um arquivo compactado: ``` s3://your-bucket/output/benchmark-name/ └── job_name/ └── output/ └── output.tar.gz ``` 1. Baixe o arquivo `output.tar.gz` em seu bucket. Extraia o conteúdo a ser exibido. ``` run_name/ ├── eval_results/ | └── results_[timestamp].json │ └── inference_output.jsonl (only present for gen_qa) | └── details/ | └── model/ | └── / | └──details__#_.parquet └── tensorboard_results/ └── eval/ └── events.out.tfevents.[timestamp] ``` + `results_[timestamp].json`: arquivo JSON de métricas de saída. + `details__#_.parquet`: arquivo de saída de inferência (exceto para `strong_reject`). + `events.out.tfevents.[timestamp]`: arquivo de saída do TensorBoard. + `inference_output.jsonl`: arquivo de saída de inferência limpo (somente para tarefas de `gen_qa`). 1. Visualize os resultados no TensorBoard. Para visualizar suas métricas de avaliação: 1. Faça upload da pasta extraída em um bucket do S3. 1. Navegue até o TensorBoard no SageMaker AI 1. Selecione “Pastas do S3”. 1. Adicione o caminho da pasta do S3. 1. Aguarde a conclusão da sincronização. 1. Analise os resultados da inferência. Todas as tarefas de avaliação, exceto `llm_judge` e `strong_reject`, terão os campos a seguir para análise na saída da inferência. + `full_prompt`: o prompt completo do usuário enviado ao modelo usado para a tarefa de avaliação. + `gold`: o campo que contém as respostas corretas, conforme especificado pelo conjunto de dados. + `metrics`: o campo que contém as métricas avaliadas na inferência individual. Valores que exigem agregação não têm um valor nas saídas de inferência individuais. + `predictions`: o campo que contém uma lista da saída do modelo para o prompt fornecido. + `pred_logits`: o campo que contém os tokens de saída considerados e as probabilidades logarítmicas de cada token de saída retornado no conteúdo da mensagem. Ao examinar esses campos, você pode determinar a causa das diferenças métricas e entender o comportamento dos modelos personalizados. Para `llm_judge`, o arquivo de saída da inferência contém os campos a seguir no campo de métricas por par de avaliações. + `forward_output`: as preferências brutas do avaliador ao avaliar em ordem (response\$1A, response\$1B). + `backward_output`: as preferências brutas do avaliador ao avaliar na ordem inversa (response\$1B, response\$1A). + `Pairwise metrics`: métricas calculadas por par de avaliações diretas e inversas, incluindo `a_scores`, `b_scores`, `ties`, `inference-score` e `score`. **nota** Métricas agregadas, como `winrate`, estão disponíveis apenas nos arquivos de resultados resumidos, não por avaliação individual. Para `gen_qa`, o arquivo `inference_output.jsonl` contém os seguintes campos para cada objeto JSON: + prompt: o prompt final enviado ao modelo. + inferência: a saída bruta de inferência do modelo. + gold: a resposta esperada do conjunto de dados de entrada + metadata: a string de metadados do conjunto de dados de entrada, se fornecida ## Práticas recomendadas e solução de problemas de avaliação ### Práticas recomendadas A seguir estão listadas algumas das práticas recomendadas para o processo de avaliação. + Mantenha seus caminhos de saída organizados por modelo e tipo de referência. + Mantenha convenções de nomenclatura consistentes para facilitar o rastreamento. + Salve os resultados extraídos em um local seguro. + Monitore o status de sincronização do TensorBoard para garantir que os dados sejam carregados com êxito. ### Solução de problemas Você pode usar o grupo de logs `/aws/sagemaker/TrainingJobs` do CloudWatch para logs de erro de tarefa de treinamento. #### Falha do núcleo do mecanismo **Problema**: Se você estiver vendo: ``` RuntimeError: Engine core initialization failed. ``` **Causa**: Embora este seja um erro geral que pode ter várias causas, ele normalmente ocorre quando há uma incompatibilidade entre o ponto de verificação do modelo que você está tentando carregar e o tipo de modelo especificado. Por exemplo, você deseja avaliar um ponto de verificação do modelo Nova 2.0 Lite ajustado, mas o tipo de modelo fornecido é o tipo de modelo 1.0. Por exemplo, `amazon.nova-micro-v1:0:128k`. O mapeamento correto deve ser ``` model_type: amazon.nova-2-lite-v1:0:256k model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location ``` **Prevenção**: Verifique se `model_name_or_path` está mapeado ao `model_type` correto antes de enviar a tarefa de avaliação. ## Subtarefas disponíveis Confira abaixo as subtarefas disponíveis para avaliação de modelo em vários domínios, incluindo MMLU (Massive Multitask Language Understanding), BBH (Big Bench Hard), MATH e MMMU (Massive Multi-discipline Multimodal Understanding). Essas subtarefas permitem avaliar o desempenho do modelo em capacidades e áreas de conhecimento específicas. **MMLU** ``` MMLU_SUBTASKS = [ "abstract_algebra", "anatomy", "astronomy", "business_ethics", "clinical_knowledge", "college_biology", "college_chemistry", "college_computer_science", "college_mathematics", "college_medicine", "college_physics", "computer_security", "conceptual_physics", "econometrics", "electrical_engineering", "elementary_mathematics", "formal_logic", "global_facts", "high_school_biology", "high_school_chemistry", "high_school_computer_science", "high_school_european_history", "high_school_geography", "high_school_government_and_politics", "high_school_macroeconomics", "high_school_mathematics", "high_school_microeconomics", "high_school_physics", "high_school_psychology", "high_school_statistics", "high_school_us_history", "high_school_world_history", "human_aging", "human_sexuality", "international_law", "jurisprudence", "logical_fallacies", "machine_learning", "management", "marketing", "medical_genetics", "miscellaneous", "moral_disputes", "moral_scenarios", "nutrition", "philosophy", "prehistory", "professional_accounting", "professional_law", "professional_medicine", "professional_psychology", "public_relations", "security_studies", "sociology", "us_foreign_policy", "virology", "world_religions" ] ``` **BBH** ``` BBH_SUBTASKS = [ "boolean_expressions", "causal_judgement", "date_understanding", "disambiguation_qa", "dyck_languages", "formal_fallacies", "geometric_shapes", "hyperbaton", "logical_deduction_five_objects", "logical_deduction_seven_objects", "logical_deduction_three_objects", "movie_recommendation", "multistep_arithmetic_two", "navigate", "object_counting", "penguins_in_a_table", "reasoning_about_colored_objects", "ruin_names", "salient_translation_error_detection", "snarks", "sports_understanding", "temporal_sequences", "tracking_shuffled_objects_five_objects", "tracking_shuffled_objects_seven_objects", "tracking_shuffled_objects_three_objects", "web_of_lies", "word_sorting" ] ``` **Math** ``` MATH_SUBTASKS = [ "algebra", "counting_and_probability", "geometry", "intermediate_algebra", "number_theory", "prealgebra", "precalculus", ``` **MMMU** ``` MATH_SUBTASKS = [ "Accounting", "Agriculture", "Architecture_and_Engineering", "Art", "Art_Theory", "Basic_Medical_Science", "Biology", "Chemistry", "Clinical_Medicine", "Computer_Science", "Design", "Diagnostics_and_Laboratory_Medicine", "Economics", "Electronics", "Energy_and_Power", "Finance", "Geography", "History", "Literature", "Manage", "Marketing", "Materials", "Math", "Mechanical_Engineering", "Music", "Pharmacy", "Physics", "Psychology", "Public_Health", "Sociology", ``` Avalie seus modelos Nova personalizados usando vários métodos e métricas de avaliação. **Topics** + [Pré-requisitos](#nova-model-evaluation-prerequisites) + [Tarefas de referência disponíveis](#nova-model-evaluation-benchmark) + [Configurações específicas de avaliação](#nova-model-evaluation-config) + [Executar tarefas de treinamento de avaliação](#nova-model-evaluation-notebook) + [Avaliar e analisar os resultados da avaliação](#nova-model-evaluation-assess) + [Práticas recomendadas e solução de problemas de avaliação](#nova-model-evaluation-best-practices) + [Subtarefas disponíveis](#nova-model-evaluation-subtasks) + [Treinamento iterativo](smtj-iterative-training.md) # Treinamento iterativo O treinamento iterativo é uma abordagem sistemática para ajustar modelos por meio de vários ciclos de treinamento, em que cada rodada se baseia no ponto de verificação anterior, abordando pontos fracos específicos descobertos por meio da avaliação. Esse método permite melhorias direcionadas na performance do modelo, incorporando exemplos selecionados que abordam os modos de falha, adaptando-se às mudanças nos requisitos e validando os aprimoramentos de forma incremental, em vez de se comprometer com uma única execução de treinamento longo. O processo normalmente segue padrões como o SFT (ajuste fino supervisionado) seguido pelo RFT (ajuste fino baseado em recompensa), com pontos de verificação armazenados em buckets de depósito do S3 gerenciados pela AWS que podem ser referenciados para iterações de treinamento subsequentes, mantendo a consistência no tipo de modelo e na técnica de treinamento em todo o pipeline. Para obter mais detalhes, consulte [Treinamento iterativo](nova-iterative-training.md).