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á. # Processando dados em um fluxo de trabalho de rotulagem personalizado com AWS Lambda Neste tópico, você pode aprender como implantar funções [AWS Lambda](https://aws.amazon.com/lambda/) opcionais ao criar um fluxo de trabalho de rotulagem personalizado. Você pode especificar dois tipos de funções do Lambda para usar com seu fluxo de trabalho de rotulagem personalizada. + *Lambda de pré-anotação*: essa função pré-processa cada objeto de dados enviado ao seu trabalho de rotulagem antes de enviá-lo aos operadores. + *Lambda de pós-anotação*: essa função processa os resultados quando os operadores enviam uma tarefa. Se você especificar vários operadores por objeto de dados, essa função poderá incluir lógica para consolidar anotações. Se você for um novo usuário do Lambda e do Ground Truth, recomendamos que você use as páginas desta seção da seguinte forma: 1. Primeiro, revise [Uso de funções do Lambda de pré-anotação e pós-anotaçãoUso de funções do Lambda](sms-custom-templates-step3-lambda-requirements.md). 1. Em seguida, use a página [Adicione as permissões necessárias para usar AWS Lambda com o Ground Truth](sms-custom-templates-step3-lambda-permissions.md) para aprender sobre os requisitos de segurança e permissão para usar suas funções do Lambda de pré-anotação e pós-anotação em um trabalho de rotulagem personalizado da Ground Truth. 1. Em seguida, você precisa visitar o console do Lambda ou usar o Lambda APIs para criar suas funções. Use a seção [Criar funções do Lambda usando modelos Ground Truth](sms-custom-templates-step3-lambda-create.md) para aprender a criar funções do Lambda. 1. Para saber como testar sua função do Lambda, consulte [Testar as funções do Lambda de pré-anotação e pós-anotação](sms-custom-templates-step3-lambda-test.md). 1. Depois de criar funções do Lambda de pré-processamento e pós-processamento, selecione-as na seção **Funções do Lambda** que vem depois do editor de código para seu HTML personalizado no console do Ground Truth. Para saber como usar essas funções em uma solicitação de API `CreateLabelingJob`, consulte [Criar um trabalho de rotulagem (API)](sms-create-labeling-job-api.md). Para um tutorial de fluxo de trabalho de rotulagem personalizado que inclui exemplos de funções do Lambda de pré-anotação e pós-anotação, consulte [Modelo de demonstração: anotação de imagens com `crowd-bounding-box`](sms-custom-templates-step2-demo1.md). **Topics** + [Uso de funções do Lambda de pré-anotação e pós-anotação](sms-custom-templates-step3-lambda-requirements.md) + [Adicione as permissões necessárias para usar AWS Lambda com o Ground Truth](sms-custom-templates-step3-lambda-permissions.md) + [Criar funções do Lambda usando modelos Ground Truth](sms-custom-templates-step3-lambda-create.md) + [Testar as funções do Lambda de pré-anotação e pós-anotação](sms-custom-templates-step3-lambda-test.md) # Uso de funções do Lambda de pré-anotação e pós-anotação Use estes tópicos para aprender sobre a sintaxe das solicitações enviadas para as funções do Lambda de pré-anotação e pós-anotação, e a sintaxe de resposta que o Ground Truth exige para executar um fluxo de trabalho de rotulagem personalizado. **Topics** + [Lambda de pré-anotação](#sms-custom-templates-step3-prelambda) + [Lambda de pós-anotação](#sms-custom-templates-step3-postlambda) ## Lambda de pré-anotação Antes de uma tarefa de rotulagem ser enviada ao operador, uma função do Lambda de pré-anotação pode ser invocada. O Ground Truth envia à sua função do Lambda uma solicitação em formato JSON para fornecer detalhes sobre o trabalho de rotulagem e o objeto de dados. Veja a seguir 2 exemplos de solicitações em formato JSON. ------ #### [ Data object identified with "source-ref" ] ``` { "version": "2018-10-16", "labelingJobArn": "dataObject" : { "source-ref": } } ``` ------ #### [ Data object identified with "source" ] ``` { "version": "2018-10-16", "labelingJobArn": "dataObject" : { "source": } } ``` ------ A lista a seguir contém os esquemas de solicitação de pré-anotação. Cada parâmetro é descrito abaixo. + `version` (string): esse é um número da versão usado internamente pela Ground Truth. + `labelingJobArn` (string): esse é o Nome de recurso da Amazon, ou ARN, do seu trabalho de rotulagem. Esse ARN pode ser usado para referenciar o trabalho de rotulagem ao usar operações de API Ground Truth, como `DescribeLabelingJob`. + O `dataObject` (objeto JSON): a chave contém uma única linha JSON, do seu arquivo manifesto de entrada ou enviada do Amazon SNS. Os objetos de linha JSON no seu manifesto podem ter até 100 kilobytes de tamanho e conter uma variedade de dados. Para um trabalho de anotação de imagem muito básico, o `dataObject` JSON pode conter apenas uma chave `source-ref`, identificando a imagem a ser anotada. Se o objeto de dados (por exemplo, uma linha de texto) for incluído diretamente no arquivo manifesto de entrada, o objeto de dados será identificado com `source`. Se você criar uma tarefa de verificação ou ajuste, essa linha poderá conter dados de etiqueta e metadados da trabalho de rotulagem anterior. Os exemplos de guias a seguir mostram exemplos de uma solicitação de pré-anotação. Cada parâmetro nesses exemplos de solicitações é explicado abaixo da tabela com guias. ------ #### [ Data object identified with "source-ref" ] ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker:us-west-2:111122223333:labeling-job/" "dataObject" : { "source-ref": "s3://input-data-bucket/data-object-file-name" } } ``` ------ #### [ Data object identified with "source" ] ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker::111122223333:labeling-job/" "dataObject" : { "source": "Sue purchased 10 shares of the stock on April 10th, 2020" } } ``` ------ Em troca, o Ground Truth exige uma resposta formatada da seguinte forma: **Example de dados de retorno esperados** ``` { "taskInput": , "isHumanAnnotationRequired": # Optional } ``` No exemplo anterior, o `` precisa conter *todos* os dados de que seu modelo de tarefas de operador personalizado precisará. Se você estiver realizando uma tarefa de caixa delimitadora em que as instruções permanecem as mesmas o tempo todo, pode ser apenas o recurso HTTP(S) ou Amazon S3 para o arquivo de imagem. \$1´Se é uma tarefa de análise de sentimento, e objetos diferentes podem ter opções diferentes, seria a referência do objeto como uma string e as opções como uma matriz de strings. **Implicações de `isHumanAnnotationRequired`** Este valor é opcional, pois será o padrão para `true`. O caso de uso principal para a definição explícita é quando você deseja excluir esse objeto de dados de ser rotulado por operadores humanos. Se você tiver uma mistura de objetos em seu manifesto, com alguns exigindo anotação por humano e alguns não precisando, você pode incluir um valor `isHumanAnnotationRequired` em cada objeto de dados. Você pode adicionar lógica à sua pré-anotação Lambda para determinar dinamicamente se um objeto requer anotação e definir esse valor booleano de acordo. ### Exemplos de funções do Lambda de pré-anotação A seguinte função do Lambda básica de pré-anotação acessa o objeto JSON em `dataObject` a partir da solicitação inicial e o retorna no parâmetro `taskInput`: ``` import json def lambda_handler(event, context): return { "taskInput": event['dataObject'] } ``` Supondo que o arquivo manifesto de entrada `"source-ref"` seja usado para identificar objetos de dados, o modelo de tarefas de operador usado no mesmo trabalho de rotulagem dessa pré-anotação Lambda deve incluir um elemento Liquid como o seguinte para ser ingerido `dataObject`: ``` {{ task.input.source-ref | grant_read_access }} ``` Se o arquivo manifesto de entrada for usado `source` para identificar o objeto de dados, o modelo de tarefa de trabalho poderá ser ingerido `dataObject` com o seguinte: ``` {{ task.input.source }} ``` O exemplo de pré-anotação do Lambda a seguir inclui lógica para identificar a chave usada no `dataObject` e apontar para esse objeto de dados usando `taskObject` na instrução de retorno do Lambda. ``` import json def lambda_handler(event, context): # Event received print("Received event: " + json.dumps(event, indent=2)) # Get source if specified source = event['dataObject']['source'] if "source" in event['dataObject'] else None # Get source-ref if specified source_ref = event['dataObject']['source-ref'] if "source-ref" in event['dataObject'] else None # if source field present, take that otherwise take source-ref task_object = source if source is not None else source_ref # Build response object output = { "taskInput": { "taskObject": task_object }, "humanAnnotationRequired": "true" } print(output) # If neither source nor source-ref specified, mark the annotation failed if task_object is None: print(" Failed to pre-process {} !".format(event["labelingJobArn"])) output["humanAnnotationRequired"] = "false" return output ``` ## Lambda de pós-anotação Quando todos os operadores tiverem anotado o objeto de dados ou quando o [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HumanLoopConfig.html#SageMaker-Type-HumanLoopConfig-TaskAvailabilityLifetimeInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HumanLoopConfig.html#SageMaker-Type-HumanLoopConfig-TaskAvailabilityLifetimeInSeconds) for atingido, o que ocorrer primeiro, o Ground Truth enviará essas anotações para seu Lambda de pós-anotação. Esse Lambda é geralmente usado para [Consolidação de anotações](sms-annotation-consolidation.md). **nota** [Para ver um exemplo de uma função Lambda pós-consolidação, consulte [annotation\$1consolidation\$1lambda.py](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe/blob/master/aws_sagemaker_ground_truth_sample_lambda/annotation_consolidation_lambda.py) no repositório -recipe. aws-sagemaker-ground-truth](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe) GitHub O bloco de código a seguir contém o esquema de solicitação pós-anotação. Cada parâmetro é descrito na seguinte lista com marcadores: ``` { "version": "2018-10-16", "labelingJobArn": , "labelCategories": [], "labelAttributeName": , "roleArn" : , "payload": { "s3Uri": } } ``` + `version` (string): esse é um número da versão usado internamente pela Ground Truth. + `labelingJobArn` (string): Esse é o nome de recurso da Amazon, ou ARN, do seu trabalho de rotulagem. Esse ARN pode ser usado para referenciar o trabalho de rotulagem ao usar operações de API Ground Truth, como `DescribeLabelingJob`. + `labelCategories` (lista de sequências de caracteres): inclui as categorias de rótulos e outros atributos que você especificou no console ou que você incluiu no arquivo de configuração da categoria de rótulo. + `labelAttributeName` (string): o nome do seu trabalho de rotulagem ou o nome de atributo do rótulo que você especifica ao criar o trabalho de rotulagem. + `roleArn` (string): o nome do recurso da Amazon (ARN) da função de execução do IAM que você especifica ao criar a tarefa de rotulagem. + `payload` (objeto JSON): um JSON que inclui uma chave `s3Uri`, que identifica a localização dos dados de anotação desse objeto de dados no Amazon S3. O segundo bloco de código abaixo mostra um exemplo desse arquivo de anotação. O bloco de código a seguir contém um exemplo de uma solicitação pós-anotação. Cada parâmetro nesses exemplos de solicitações é explicado abaixo da tabela com guias. **Example de uma solicitação Lambda de pós-anotação** ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker:us-west-2:111122223333:labeling-job/labeling-job-name", "labelCategories": ["Ex Category1","Ex Category2", "Ex Category3"], "labelAttributeName": "labeling-job-attribute-name", "roleArn" : "arn:aws:iam::111122223333:role/role-name", "payload": { "s3Uri": "s3://amzn-s3-demo-bucket/annotations.json" } } ``` **nota** Se nenhum operador trabalhar no objeto de dados e o `TaskAvailabilityLifetimeInSeconds` for atingido, o objeto de dados será marcado como falha e não será incluído como parte da invocação do Lambda de pós-anotação. O bloco de código a seguir contém o esquema de carga útil. Esse é o arquivo indicado pelo `s3Uri` parâmetro no objeto JSON de solicitação `payload` Lambda de pós-anotação. Por exemplo, se o bloco de código anterior for a solicitação Lambda pós-anotação, o arquivo de anotação a seguir está localizado em `s3://amzn-s3-demo-bucket/annotations.json`. Cada parâmetro é descrito na seguinte lista com marcadores: **Example de um arquivo de anotação** ``` [ { "datasetObjectId": , "dataObject": { "s3Uri": , "content": }, "annotations": [{ "workerId": , "annotationData": { "content": , "s3Uri": } }] } ] ``` + `datasetObjectId` (string): identifica uma ID exclusiva que a Ground Truth atribui a cada objeto de dados que você envia para o trabalho de rotulagem. + `dataObject` (objeto JSON): o objeto de dados que foi rotulado. Se o objeto de dados estiver incluído no arquivo manifesto de entrada e identificado usando a `source` chave (por exemplo, uma string), `dataObject` inclua uma `content` chave que identifica o objeto de dados. Caso contrário, a localização do objeto de dados (por exemplo, um link ou URI do S3) será identificada com `s3Uri`. + `annotations` (lista de objetos JSON): essa lista contém um único objeto JSON para cada anotação enviada pelos operadores para esse `dataObject`. Um único objeto JSON contém um único `workerId` que pode ser usado para identificar o operador que enviou essa anotação. A chave `annotationData` contém um dos seguintes valores: + `content` (string): contém os dados de anotação. + `s3Uri` (string): contém um URI do S3 que identifica a localização dos dados de anotação. A tabela a seguir contém exemplos do conteúdo que você pode encontrar no payload para diferentes tipos de anotação. ------ #### [ Named Entity Recognition Payload ] ``` [ { "datasetObjectId": "1", "dataObject": { "content": "Sift 3 cups of flour into the bowl." }, "annotations": [ { "workerId": "private.us-west-2.ef7294f850a3d9d1", "annotationData": { "content": "{\"crowd-entity-annotation\":{\"entities\":[{\"endOffset\":4,\"label\":\"verb\",\"startOffset\":0},{\"endOffset\":6,\"label\":\"number\",\"startOffset\":5},{\"endOffset\":20,\"label\":\"object\",\"startOffset\":15},{\"endOffset\":34,\"label\":\"object\",\"startOffset\":30}]}}" } } ] } ] ``` ------ #### [ Semantic Segmentation Payload ] ``` [ { "datasetObjectId": "2", "dataObject": { "s3Uri": "s3://amzn-s3-demo-bucket/gt-input-data/images/bird3.jpg" }, "annotations": [ { "workerId": "private.us-west-2.ab1234c5678a919d0", "annotationData": { "content": "{\"crowd-semantic-segmentation\":{\"inputImageProperties\":{\"height\":2000,\"width\":3020},\"labelMappings\":{\"Bird\":{\"color\":\"#2ca02c\"}},\"labeledImage\":{\"pngImageData\":\"iVBOR...\"}}}" } } ] } ] ``` ------ #### [ Bounding Box Payload ] ``` [ { "datasetObjectId": "0", "dataObject": { "s3Uri": "s3://amzn-s3-demo-bucket/gt-input-data/images/bird1.jpg" }, "annotations": [ { "workerId": "private.us-west-2.ab1234c5678a919d0", "annotationData": { "content": "{\"boundingBox\":{\"boundingBoxes\":[{\"height\":2052,\"label\":\"Bird\",\"left\":583,\"top\":302,\"width\":1375}],\"inputImageProperties\":{\"height\":2497,\"width\":3745}}}" } } ] } ] ``` ------ Sua função do Lambda de pós-anotação pode conter uma lógica semelhante à seguinte para percorrer e acessar todas as anotações contidas na solicitação: Para ver um exemplo completo, consulte [annotation\$1consolidation\$1lambda.py](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe/blob/master/aws_sagemaker_ground_truth_sample_lambda/annotation_consolidation_lambda.py) no GitHub repositório [aws-sagemaker-ground-truth-recipe](https://github.com/aws-samples/aws-sagemaker-ground-truth-recipe). Neste GitHub exemplo, você deve adicionar sua própria lógica de consolidação de anotações. ``` for i in range(len(annotations)): worker_id = annotations[i]["workerId"] annotation_content = annotations[i]['annotationData'].get('content') annotation_s3_uri = annotations[i]['annotationData'].get('s3uri') annotation = annotation_content if annotation_s3_uri is None else s3_client.get_object_from_s3( annotation_s3_uri) annotation_from_single_worker = json.loads(annotation) print("{} Received Annotations from worker [{}] is [{}]" .format(log_prefix, worker_id, annotation_from_single_worker)) ``` **dica** Ao executar algoritmos de consolidação nos dados, você pode usar um serviço de banco de dados do AWS para armazenar os resultados ou pode passar os resultados processados de volta para a Ground Truth. Os dados que você retorna ao Ground Truth são armazenados em manifestos de anotação consolidados no bucket do S3 especificado para saída durante a configuração do trabalho de rotulagem. Em troca, o Ground Truth exige uma resposta formatada da seguinte forma: **Example de dados de retorno esperados** ``` [ { "datasetObjectId": , "consolidatedAnnotation": { "content": { "": { # ... label content } } } }, { "datasetObjectId": , "consolidatedAnnotation": { "content": { "": { # ... label content } } } } . . . ] ``` Neste ponto, todos os dados que você está enviando para seu bucket S3, exceto o `datasetObjectId`, estão no objeto `content`. Quando você retorna anotações em `content`, isso resulta em uma entrada no manifesto de saída do seu trabalho, como a seguinte: **Example do formato do rótulo no manifesto de saída** ``` { "source-ref"/"source" : "", "": { # ... label content from you }, "-metadata": { # This will be added by Ground Truth "job_name": , "type": "groundTruth/custom", "human-annotated": "yes", "creation_date": # Timestamp of when received from Post-labeling Lambda } } ``` Por causa da natureza potencialmente complexa de um modelo personalizado e dos dados que ele coleta, o Ground Truth não oferece processamento adicional dos dados ou percepções sobre ele. # Adicione as permissões necessárias para usar AWS Lambda com o Ground Truth Talvez seja necessário configurar alguns ou todos os itens a seguir para criar e usar AWS Lambda com o Ground Truth. + Você precisa conceder permissão a uma função ou usuário do IAM (coletivamente, uma entidade do IAM) para criar as funções Lambda de pré-anotação e pós-anotação usando e escolhê-las ao criar o trabalho de AWS Lambda rotulagem. + A função de execução do IAM especificada quando o trabalho de rotulagem é configurado precisa de permissão para invocar as funções do Lambda de pré-anotação e pós-anotação. + As funções de pós-anotação do Lambda podem precisar de permissão para acessar o Amazon S3. Use as seções a seguir para aprender como criar as entidades do IAM e conceder as permissões descritas acima. **Topics** + [Conceder permissão para criar e selecionar uma AWS Lambda função](#sms-custom-templates-step3-postlambda-create-perms) + [Conceda permissão da função de execução do IAM para invocar AWS Lambda funções](#sms-custom-templates-step3-postlambda-execution-role-perms) + [Conceder permissões Lambda de pós-anotação para acessar a anotação](#sms-custom-templates-step3-postlambda-perms) ## Conceder permissão para criar e selecionar uma AWS Lambda função Se você não precisar de permissões granulares para desenvolver funções Lambda de pré-anotação e pós-anotação, poderá anexar a política gerenciada a um usuário ou função. AWS `AWSLambda_FullAccess` Essa política concede amplas permissões para usar todos os recursos do Lambda, bem como permissão para realizar ações em outros AWS serviços com os quais o Lambda interage. Para criar uma política mais granular para casos de uso sensíveis à segurança, consulte a documentação [Políticas de IAM baseadas em identidade para Lambda no Guia do Desenvolvedor para](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html) saber como criar uma política de IAM adequada ao seu caso de uso. AWS Lambda **Políticas para usar o console do Lambda** Se você quiser conceder permissão a uma entidade do IAM para usar o console Lambda, consulte Como [usar o console Lambda no Guia do](https://docs.aws.amazon.com/lambda/latest/dg/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-console) desenvolvedor. AWS Lambda Além disso, se você quiser que o usuário possa acessar e implantar as funções iniciais de pré-anotação e pós-anotação do Ground Truth usando o console Lambda, você deve especificar *``* onde deseja implantar as funções (essa deve ser a mesma AWS região usada para criar o trabalho de rotulagem) e adicionar a política a seguir à função do IAM. AWS Serverless Application Repository ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "serverlessrepo:ListApplicationVersions", "serverlessrepo:GetApplication", "serverlessrepo:CreateCloudFormationTemplate" ], "Resource": "arn:aws:serverlessrepo:us-east-1:838997950401:applications/aws-sagemaker-ground-truth-recipe" }, { "Sid": "VisualEditor1", "Effect": "Allow", "Action": "serverlessrepo:SearchApplications", "Resource": "*" } ] } ``` ------ **Políticas para ver as funções do Lambda no console Ground Truth** Para conceder permissão a uma entidade do IAM para visualizar as funções do Lambda no console do Ground Truth quando o usuário está criando um trabalho de rotulagem personalizado, a entidade deve ter as permissões descritas em [Conceda permissão ao IAM para usar o Amazon SageMaker Ground Truth Console](sms-security-permission-console-access.md), incluindo as permissões descritas na seção [Personalizar permissões de fluxo de trabalho de rotulagem](sms-security-permission-console-access.md#sms-security-permissions-custom-workflow). ## Conceda permissão da função de execução do IAM para invocar AWS Lambda funções Se você adicionar a política gerenciada do IAM [AmazonSageMakerGroundTruthExecution](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerGroundTruthExecution)à função de execução do IAM usada para criar o trabalho de rotulagem, essa função terá permissão para listar e invocar funções do Lambda com uma das seguintes sequências de caracteres no nome da função`GtRecipe`:`SageMaker`,,,`Sagemaker`, `sagemaker` ou. `LabelingFunction` Se os nomes da função do Lambda de pré-anotação ou pós-anotação não incluírem um dos termos do parágrafo anterior, ou se você precisar de mais permissões granulares do que as da política `AmazonSageMakerGroundTruthExecution` gerenciada, poderá adicionar uma política semelhante à seguinte para dar permissão ao perfil de execução para invocar funções de pré-anotação e pós-anotação: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": [ "arn:aws:lambda:us-east-1:111122223333:function:", "arn:aws:lambda:us-east-1:111122223333:function:" ] } ] } ``` ------ ## Conceder permissões Lambda de pós-anotação para acessar a anotação Conforme descrito em [Lambda de pós-anotação](sms-custom-templates-step3-lambda-requirements.md#sms-custom-templates-step3-postlambda), a solicitação Lambda pós-anotação inclui a localização dos dados de anotação no Amazon S3. Esse local é identificado pela string `s3Uri` no objeto `payload`. Para processar as anotações assim que elas chegam, mesmo para uma simples função de passagem direta, você precisa atribuir as permissões necessárias ao [perfil de execução pós-anotação do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) para ler arquivos do seu bucket do S3. Há várias maneiras de configurar o Lambda para acessar dados de anotação no Amazon S3. Duas formas comuns são: + Permita que a função de execução do Lambda assuma a função de execução da SageMaker IA identificada `roleArn` na solicitação Lambda pós-anotação. Essa função de execução de SageMaker IA é aquela usada para criar o trabalho de rotulagem e tem acesso ao bucket de saída do Amazon S3 onde os dados de anotação são armazenados. + Conceda permissão à função de execução do Lambda para acessar diretamente o bucket de saída do Amazon S3. Use as seguintes seções para aprender como configurar essas opções: **Conceda permissão à Lambda para assumir a função de execução de SageMaker IA** Para permitir que uma função Lambda assuma uma função de execução de SageMaker IA, você deve anexar uma política à função de execução da função Lambda e modificar a relação de confiança da função de execução de SageMaker IA para permitir que a Lambda a assuma. 1. [Anexe a seguinte política do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) à função de execução da sua função Lambda para assumir a função de execução da SageMaker IA identificada em. `Resource` Substitua `222222222222` pelo [ID da conta AWS](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html). Substitua `sm-execution-role` pelo nome do perfil de admissão. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::222222222222:role/sm-execution-role" } } ``` ------ 1. [Modifique a política de confiança](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy) da função de execução de SageMaker IA para incluir o seguinte`Statement`. Substitua `222222222222` pelo [ID da conta AWS](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html). Substitua `my-lambda-execution-role` pelo nome do perfil de admissão. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::222222222222:role/my-lambda-execution-role" }, "Action": "sts:AssumeRole" } ] } ``` ------ **Conceder permissão do perfil de execução do Lambda para acessar o S3** Você pode adicionar uma política semelhante à seguinte à função de execução da função do Lambda pós-anotação para dar a ela permissões de leitura do S3: *amzn-s3-demo-bucket*Substitua pelo nome do bucket de saída que você especifica ao criar um trabalho de etiquetagem. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*" } ] } ``` ------ Para adicionar permissões de leitura do S3 a uma função de execução do Lambda no console Lambda, use o procedimento a seguir. **Adicione permissões de leitura do S3 à pós-anotação Lambda:** 1. Abra a página [https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions) no console do Lambda. 1. Escolha o nome da função de pós-anotação. 1. Escolha **Configuração** e, em seguida, escolha **Permissões**. 1. Selecione o **nome da função** e a página de resumo dessa função será aberta no console do IAM em uma nova guia. 1. Selecione **Anexar políticas**. 1. Execute um destes procedimentos: + Pesquise e selecione **`AmazonS3ReadOnlyAccess`** para dar permissão à função para ler todos os buckets e objetos na conta. + Se você precisar de permissões mais granulares, selecione **Criar política** e use o exemplo de política na seção anterior para criar uma política. Observe que você deve voltar para a página de resumo da função de execução depois de criar a política. 1. Se você usou a política `AmazonS3ReadOnlyAccess` gerenciada, selecione **Anexar política**. Se você criou uma nova política, volte para a página de resumo da função de execução do Lambda e anexe a política que você acabou de criar. # Criar funções do Lambda usando modelos Ground Truth Você pode criar uma função Lambda usando o console Lambda AWS CLI, o ou um AWS SDK em uma linguagem de programação compatível de sua escolha. Use o Guia do AWS Lambda desenvolvedor para saber mais sobre cada uma dessas opções: + Para aprender como criar uma função do Lambda usando o console, consulte [Criar uma função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) com o console. + Para saber como criar uma função Lambda usando o AWS CLI, consulte Usando o [AWS Lambda com](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-awscli.html) a interface de linha de comando. AWS + Selecione a seção relevante no sumário para saber mais sobre como trabalhar com o Lambda no idioma de sua escolha. Por exemplo, selecione [Trabalhando com Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html) para saber mais sobre como usar o Lambda com o AWS SDK para Python (Boto3). *O Ground Truth fornece modelos de pré-anotação e pós-anotação por meio de uma receita (SAR). AWS Serverless Application Repository * Siga o procedimento a seguir para selecionar a fórmula do Ground Truth no console do Lambda. **Use a fórmula SAR do Ground Truth para criar funções do Lambda de pré-anotação e pós-anotação:** 1. Abra a página [https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions) no console do Lambda. 1. Selecione **Criar função**. 1. Selecione **Pesquisar repositório de aplicações sem servidor**. 1. Na caixa de texto de pesquisa, digite **aws-sagemaker-ground-truth-recipe** e selecione esse aplicativo. 1. Selecione **Implantar**. A aplicação pode levar alguns minutos para ser implantada. Depois que a aplicação é implantada, duas funções aparecem na seção **Funções** do console Lambda: `serverlessrepo-aws-sagema-GtRecipePreHumanTaskFunc-` e `serverlessrepo-aws-sagema-GtRecipeAnnotationConsol-`. 1. Selecione uma dessas funções e adicione sua lógica personalizada na seção **Código**. 1. Quando terminar de fazer alterações, selecione **Implantar** para implantá-las. # Testar as funções do Lambda de pré-anotação e pós-anotação Você pode testar suas funções do Lambda de pré-anotação e pós-anotação no console Lambda. Se você for um novo usuário do Lambda, poderá saber como testar ou *invocar* suas funções do Lambda no console usando o tutorial [Criar uma função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html#gettingstarted-zip-function) com o console no Guia do desenvolvedor AWS Lambda . Você pode usar as seções desta página para aprender como testar os modelos de pré-anotação e pós-anotação do Ground Truth fornecidos por meio de um (SAR). AWS Serverless Application Repository **Topics** + [Pré-requisitos](#sms-custom-templates-step3-lambda-test-pre) + [Sua função do Lambda de pré-anotação](#sms-custom-templates-step3-lambda-test-pre-annotation) + [Sua função do Lambda de pós-anotação](#sms-custom-templates-step3-lambda-test-post-annotation) ## Pré-requisitos Você deve fazer o seguinte para usar os testes descritos nesta página: + Você precisa acessar o console Lambda e precisa de permissão para criar e invocar funções do Lambda. Para saber como configurar essas permissões, consulte [Conceder permissão para criar e selecionar uma AWS Lambda função](sms-custom-templates-step3-lambda-permissions.md#sms-custom-templates-step3-postlambda-create-perms). + Se você não implantou a fórmula SAR do Ground Truth, use o procedimento em [Criar funções do Lambda usando modelos Ground Truth](sms-custom-templates-step3-lambda-create.md) para fazer isso. + Para testar a função do Lambda de pós-anotação, você deve ter um arquivo de dados no Amazon S3 com dados de anotação de amostra. Para um teste simples, você pode copiar e colar o código a seguir em um arquivo, salvá-lo como `sample-annotations.json` e [fazer o upload desse arquivo no Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html). Observe o URI do S3 desse arquivo. Você precisa dessas informações para configurar o teste Lambda pós-anotação. ``` [{"datasetObjectId":"0","dataObject":{"content":"To train a machine learning model, you need a large, high-quality, labeled dataset. Ground Truth helps you build high-quality training datasets for your machine learning models."},"annotations":[{"workerId":"private.us-west-2.0123456789","annotationData":{"content":"{\"crowd-entity-annotation\":{\"entities\":[{\"endOffset\":8,\"label\":\"verb\",\"startOffset\":3},{\"endOffset\":27,\"label\":\"adjective\",\"startOffset\":11},{\"endOffset\":33,\"label\":\"object\",\"startOffset\":28},{\"endOffset\":51,\"label\":\"adjective\",\"startOffset\":46},{\"endOffset\":65,\"label\":\"adjective\",\"startOffset\":53},{\"endOffset\":74,\"label\":\"adjective\",\"startOffset\":67},{\"endOffset\":82,\"label\":\"adjective\",\"startOffset\":75},{\"endOffset\":102,\"label\":\"verb\",\"startOffset\":97},{\"endOffset\":112,\"label\":\"verb\",\"startOffset\":107},{\"endOffset\":125,\"label\":\"adjective\",\"startOffset\":113},{\"endOffset\":134,\"label\":\"adjective\",\"startOffset\":126},{\"endOffset\":143,\"label\":\"object\",\"startOffset\":135},{\"endOffset\":169,\"label\":\"adjective\",\"startOffset\":153},{\"endOffset\":176,\"label\":\"object\",\"startOffset\":170}]}}"}}]},{"datasetObjectId":"1","dataObject":{"content":"Sift 3 cups of flour into the bowl."},"annotations":[{"workerId":"private.us-west-2.0123456789","annotationData":{"content":"{\"crowd-entity-annotation\":{\"entities\":[{\"endOffset\":4,\"label\":\"verb\",\"startOffset\":0},{\"endOffset\":6,\"label\":\"number\",\"startOffset\":5},{\"endOffset\":20,\"label\":\"object\",\"startOffset\":15},{\"endOffset\":34,\"label\":\"object\",\"startOffset\":30}]}}"}}]},{"datasetObjectId":"2","dataObject":{"content":"Jen purchased 10 shares of the stock on Janurary 1st, 2020."},"annotations":[{"workerId":"private.us-west-2.0123456789","annotationData":{"content":"{\"crowd-entity-annotation\":{\"entities\":[{\"endOffset\":3,\"label\":\"person\",\"startOffset\":0},{\"endOffset\":13,\"label\":\"verb\",\"startOffset\":4},{\"endOffset\":16,\"label\":\"number\",\"startOffset\":14},{\"endOffset\":58,\"label\":\"date\",\"startOffset\":40}]}}"}}]},{"datasetObjectId":"3","dataObject":{"content":"The narrative was interesting, however the character development was weak."},"annotations":[{"workerId":"private.us-west-2.0123456789","annotationData":{"content":"{\"crowd-entity-annotation\":{\"entities\":[{\"endOffset\":29,\"label\":\"adjective\",\"startOffset\":18},{\"endOffset\":73,\"label\":\"adjective\",\"startOffset\":69}]}}"}}]}] ``` + Você deve usar as instruções [Conceder permissões Lambda de pós-anotação para acessar a anotação](sms-custom-templates-step3-lambda-permissions.md#sms-custom-templates-step3-postlambda-perms) para dar permissão à função de execução da função Lambda de pós-anotação para assumir a função de execução de IA que você usa para criar SageMaker o trabalho de rotulagem. A função Lambda de pós-anotação usa a função de execução de IA para acessar SageMaker o arquivo de dados de anotação,, no S3. `sample-annotations.json` ## Sua função do Lambda de pré-anotação Use o procedimento a seguir para testar a função Lambda de pré-anotação criada quando você implantou a receita do AWS Serverless Application Repository Ground Truth (SAR). **Teste a função do Lambda de pré-anotação da fórmula Ground Truth SAR** 1. Abra a página [https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions) no console do Lambda. 1. Selecione a função de pré-anotação que foi implantada a partir da fórmula SAR do Ground Truth. O nome dessa função é semelhante a `serverlessrepo-aws-sagema-GtRecipePreHumanTaskFunc-`. 1. Na seção **Origem do código**, selecione a seta ao lado de **Testar**. 1. Selecione **Configurar evento de teste**. 1. Mantenha a opção **Criar novo evento de teste** selecionada. 1. Em **Modelo de evento**, selecione **SageMakerGround Truth PreHumanTask**. 1. Dê ao seu teste um **Nome do evento**. 1. Escolha **Criar**. 1. Selecione a seta ao lado de **Testar** novamente e você verá que o teste que você criou está selecionado, indicado com um ponto ao lado do nome do evento. Se não estiver selecionado, selecione-o. 1. Selecione **Testar** para executar o teste. Depois de executar o teste, você pode ver os **resultados da execução**. Em **Logs de função**, você deverá ver a seguinte resposta da função: ``` START RequestId: cd117d38-8365-4e1a-bffb-0dcd631a878f Version: $LATEST Received event: { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker:us-east-2:123456789012:labeling-job/example-job", "dataObject": { "source-ref": "s3://sagemakerexample/object_to_annotate.jpg" } } {'taskInput': {'taskObject': 's3://sagemakerexample/object_to_annotate.jpg'}, 'isHumanAnnotationRequired': 'true'} END RequestId: cd117d38-8365-4e1a-bffb-0dcd631a878f REPORT RequestId: cd117d38-8365-4e1a-bffb-0dcd631a878f Duration: 0.42 ms Billed Duration: 1 ms Memory Size: 128 MB Max Memory Used: 43 MB ``` Nessa resposta, podemos ver que a saída da função do Lambda corresponde à sintaxe de resposta de pré-anotação necessária: ``` {'taskInput': {'taskObject': 's3://sagemakerexample/object_to_annotate.jpg'}, 'isHumanAnnotationRequired': 'true'} ``` ## Sua função do Lambda de pós-anotação Use o procedimento a seguir para testar a função Lambda de pós-anotação criada quando você implantou a receita do AWS Serverless Application Repository Ground Truth (SAR). **Teste a fórmula de SAR de Ground Truth após a anotação Lambda** 1. Abra a página [https://console.aws.amazon.com/lambda/home#/functions](https://console.aws.amazon.com/lambda/home#/functions) no console do Lambda. 1. Selecione a função de pós-anotação que foi implantada a partir da fórmula SAR do Ground Truth. O nome dessa função é semelhante `serverlessrepo-aws-sagema-GtRecipeAnnotationConsol-` a. 1. Na seção **Origem do código**, selecione a seta ao lado de **Testar**. 1. Selecione **Configurar evento de teste**. 1. Mantenha a opção **Criar novo evento de teste** selecionada. 1. Em **Modelo de evento**, selecione **SageMakerGround Truth AnnotationConsolidation**. 1. Dê ao seu teste um **Nome do evento**. 1. Modifique o código do modelo de mapeamento da seguinte maneira: + Substitua o Amazon Resource Name (ARN) pelo ARN da função de execução de SageMaker IA que você usou para criar o trabalho de rotulagem. `roleArn` + Substitua o URI do S3 em `s3Uri` pelo URI do arquivo `sample-annotations.json` que você adicionou ao Amazon S3. Depois de fazer essas modificações, o teste deve ser semelhante ao seguinte: ``` { "version": "2018-10-16", "labelingJobArn": "arn:aws:sagemaker:us-east-2:123456789012:labeling-job/example-job", "labelAttributeName": "example-attribute", "roleArn": "arn:aws:iam::222222222222:role/sm-execution-role", "payload": { "s3Uri": "s3://your-bucket/sample-annotations.json" } } ``` 1. Escolha **Criar**. 1. Selecione a seta ao lado de **Testar** novamente e você verá que o teste que você criou está selecionado, indicado com um ponto ao lado do nome do evento. Se não estiver selecionado, selecione-o. 1. Selecione o **Testar** para executar o teste. Depois de executar o teste, você deve ver uma `-- Consolidated Output --` seção nos **logs de funções**, que contém uma lista de todas as anotações incluídas em `sample-annotations.json`.