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á. # Fluxos de trabalho de rotulagem personalizados Esses tópicos ajudam você a configurar um trabalho de rotulagem do Ground Truth que usa um modelo de rotulagem personalizado. Um modelo de rotulagem personalizado permite que você crie uma interface de usuário personalizada do portal do operador que os operadores usarão para rotular os dados. O modelo pode ser criado usando HTML, CSS JavaScript, [linguagem de modelo Liquid](https://shopify.github.io/liquid/) e [elementos HTML do Crowd](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-ui-template-reference.html). ## Visão geral do Se esta é a primeira vez que você cria um fluxo de trabalho de rotulagem personalizado no Ground Truth, a lista a seguir é um resumo de alto nível das etapas necessárias. 1. *Configure sua força de trabalho*: Para criar um fluxo de trabalho de rotulagem personalizado, você precisa de uma força de trabalho. Este tópico ensina sobre como configurar uma força de trabalho. 1. *Criação de um modelo personalizado*: Para criar um modelo personalizado, você deve mapear os dados do arquivo de manifesto de entrada corretamente para as variáveis do seu modelo. 1. *Usando funções do Lambda de processamento opcional*: Para controlar como os dados do seu manifesto de entrada são adicionados ao seu modelo de operador e como as anotações do operador são registradas no arquivo de saída do seu trabalho. Este tópico também tem três end-to-end demonstrações para ajudar você a entender melhor como usar modelos de etiquetagem personalizados. **nota** Todos os exemplos nos links abaixo incluem funções do Lambda de pré-anotação e pós-anotação. Essas funções do Lambda são opcionais. + [Modelo de demonstração: anotação de imagens com `crowd-bounding-box`](sms-custom-templates-step2-demo1.md) + [Modelo de demonstração: intenções de rotulagem com `crowd-classifier`](sms-custom-templates-step2-demo2.md) + [Crie um fluxo de trabalho personalizado de rotulagem de dados com o Amazon SageMaker Ground Truth](https://aws.amazon.com/blogs/machine-learning/build-a-custom-data-labeling-workflow-with-amazon-sagemaker-ground-truth/) **Topics** + [ ## Visão geral do ](#sms-custom-templates-overview) + [ # Configurar a força de trabalho ](sms-custom-templates-step1.md) + [ # Um modelo de tarefas do operador personalizado. ](sms-custom-templates-step2.md) + [ # Adicionar automação com o Liquid ](sms-custom-templates-step2-automate.md) + [ # Processando dados em um fluxo de trabalho de rotulagem personalizado com AWS Lambda ](sms-custom-templates-step3.md) + [ # Modelo de demonstração: anotação de imagens com `crowd-bounding-box` ](sms-custom-templates-step2-demo1.md) + [ # Modelo de demonstração: intenções de rotulagem com `crowd-classifier` ](sms-custom-templates-step2-demo2.md) + [ # Crie um fluxo de trabalho personalizado usando a API ](sms-custom-templates-step4.md) # Configurar a força de trabalho Nesta etapa, use o console para estabelecer qual tipo de operador usar e fazer as sub-seleções necessárias para esse tipo de operador. Ele assume que você já tenha concluído as etapas até este ponto na seção [Introdução: crie um trabalho de rotulagem de caixa delimitadora com o Ground Truth](sms-getting-started.md) e tenha escolhido a opção **Tarefa de rotulagem personalizada** como o **Tipo de tarefa**. **Para configurar sua força de trabalho.** 1. Primeiro, escolha uma opção em **Tipos de operadores**. No momento, existem três tipos disponíveis: + **Público** usa uma força de trabalho sob demanda de prestadores de serviços independentes, desenvolvido por Amazon Mechanical Turk. Eles são pagos por tarefa. + **Privado** usa seus funcionários ou prestadores de serviços para lidar com dados que precisam permanecer na sua organização. + O **fornecedor** usa fornecedores terceirizados especializados no fornecimento de serviços de rotulagem de dados, disponíveis por meio do Marketplace. AWS 1. Se você escolher a opção **Público**, será solicitado que você defina o **número de operadores por objeto de conjunto de dados**. Ter mais de um operador executando a mesma tarefa no mesmo objeto pode ajudar a aumentar a precisão dos seus resultados. O padrão é três. Você pode aumentar ou diminuir isso dependendo da precisão necessária. Também será solicitado que você defina um **preço por tarefa** usando o menu suspenso. O menu recomenda pontos de preço com base em quanto tempo levará para concluir a tarefa. O método recomendado para determinar isso é primeiramente executar um pequeno teste da sua tarefa com uma força de trabalho **privada**. O teste fornece uma estimativa realista de quanto tempo a tarefa leva para ser concluída. Você pode então selecionar o intervalo da sua estimativa no menu **Preço por tarefa**. Se seu tempo médio for superior a 5 minutos, considere dividir sua tarefa em unidades menores. ## Próximo [Um modelo de tarefas do operador personalizado.](sms-custom-templates-step2.md) # Um modelo de tarefas do operador personalizado. Para criar um trabalho de rotulagem personalizado, você precisa atualizar o modelo de tarefa do operador, mapear os dados de entrada do seu arquivo de manifesto para as variáveis usadas no modelo e mapear os dados de saída para o Amazon S3. Para saber mais sobre os atributos avançados que usam a automação do Liquid, consulte [Adicionar automação com o Liquid](sms-custom-templates-step2-automate.md). As seções a seguir descrevem as etapas necessárias. ## Modelo de tarefa do operador Um *modelo de tarefa do operador* é um arquivo usado pelo Ground Truth para personalizar a interface de usuário (UI) do operador. Você pode criar um modelo de tarefa de trabalho usando HTML, CSS JavaScript, [linguagem de modelo Liquid](https://shopify.github.io/liquid/) e [elementos HTML do Crowd](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-ui-template-reference.html). O Liquid é usado para automatizar o modelo. Os elementos HTML do Crow são usados para incluir ferramentas comuns de anotação e fornecer a lógica para enviar para o Ground Truth. Use os tópicos a seguir para saber como criar um modelo de tarefa do operador. Você pode ver um repositório de exemplos de modelos de tarefas para trabalhadores da Ground Truth em [GitHub](https://github.com/aws-samples/amazon-sagemaker-ground-truth-task-uis). ### Usando o modelo básico de tarefas do trabalhador no console de SageMaker IA Você pode usar um editor de modelos no console Ground Truth para começar a criar um modelo. Esse editor inclui vários modelos básicos predefinidos. Ele é compatível com preenchimento automático para o código HTML e Elementos HTML do Crowd. **Para acessar o editor de modelos personalizados Ground Truth:** 1. Siga as instruções em [Criar um trabalho de rotulagem (console)](sms-create-labeling-job-console.md). 1. Em seguida, selecione **Personalizado** para o **tipo de tarefa** do trabalho de rotulagem. 1. Ao selecionar **Avançar**, você poderá acessar o editor de modelos e os modelos base na seção **Configuração de tarefas de rotulagem personalizadas**. 1. (Opcional) Selecione um modelo básico no menu suspenso em **Modelos**. Se você preferir criar um modelo do zero, escolha **Personalizado** no menu suspenso para obter um esqueleto mínimo do modelo. Use a seção a seguir para aprender a visualizar localmente um modelo desenvolvido no console. #### Visualizando os modelos de tarefas de trabalho localmente Você deve usar o console para testar como o modelo processa os dados recebidos. Para testar a aparência e funcionamento do HTML e dos elementos personalizados do modelo, você pode usar seu navegador. **nota** As variáveis não serão analisadas. Talvez seja necessário substituí-los por conteúdo de amostra enquanto visualiza o conteúdo localmente. O exemplo de trecho de código a seguir carrega o código necessário para renderizar os elementos HTML personalizados. Use isso caso deseje desenvolver a aparência do seu modelo no editor de sua escolha, e não no console. **Example** ``` ``` ### Como criar uma amostra simples de tarefa em HTML Agora que você tem o modelo de tarefa base do operador, você pode usar este tópico para criar um modelo de tarefa simples baseado em HTML. Veja a seguir um exemplo de entrada de um arquivo de manifesto de entrada. ``` { "source": "This train is really late.", "labels": [ "angry" , "sad", "happy" , "inconclusive" ], "header": "What emotion is the speaker feeling?" } ``` No modelo de tarefa HTML, precisamos mapear as variáveis do arquivo de manifesto de entrada para o modelo. A variável do exemplo de manifesto de entrada seria mapeada usando a seguinte sintaxe **task.input.source**, **task.input.labels** e **task.input.header**: Veja a seguir uma amostra simples de modelo de tarefa de trabalho em HTML para análise de tweets. Todas as tarefas começam e terminam com os elementos ` `. Como os elementos HTML padrão de `
`, todo o seu código de formulário deve estar entre eles. O Ground Truth gera as tarefas dos operadores diretamente do contexto especificado no modelo, a menos que você implemente uma pré-anotação Lambda. O objeto `taskInput` retornado pelo Ground Truth ou [Lambda de pré-anotação](sms-custom-templates-step3-lambda-requirements.md#sms-custom-templates-step3-prelambda) é o objeto `task.input` nos modelos. Para uma tarefa simples de análise de tweets, use o elemento ``. Ela requer os seguintes atributos: + *nome*: o nome da sua variável de saída. As anotações do operador são salvas nesse nome de variável no manifesto de saída. + *categories* - uma matriz em formato JSON das possíveis respostas. + *header* - um título para a ferramenta de anotação O elemento `` requer pelo menos os três elementos filhos a seguir. + **: o texto que o operador classificará com base nas opções especificadas no atributo `categories` acima. + **: instruções que estão disponíveis no link "Visualizar instruções completas" na ferramenta. Elas podem ser deixadas em branco, mas é recomendável que você forneça boas instruções para obter melhores resultados. + **: uma descrição mais breve da tarefa que aparece na barra lateral da ferramenta. Elas podem ser deixadas em branco, mas é recomendável que você forneça boas instruções para obter melhores resultados. Uma versão simples dessa ferramenta ficaria assim. A variável **\$1\$1 task.input.source \$1\$1** é o que especifica os dados de origem do seu arquivo de manifesto de entrada. A **\$1\$1 task.input.labels \$1 to\$1json \$1\$1** é um exemplo de um filtro variável para transformar a matriz em uma representação JSON. O atributo `categories` deve ser JSON. **Example de usar `crowd-classifier` com a amostra de manifesto de entrada json** ``` {{ task.input.source }} Try to determine the sentiment the author of the tweet is trying to express. If none seem to match, choose "cannot determine." Pick the term that best describes the sentiment of the tweet. ``` Você pode copiar e colar o código no editor no fluxo de trabalho de criação de tarefas de rotulagem do Ground Truth para visualizar a ferramenta ou experimentar uma [demonstração desse código no CodePen.](https://codepen.io/MTGT/full/OqBvJw) [https://codepen.io/MTGT/full/OqBvJw](https://codepen.io/MTGT/full/OqBvJw) ## Dados de entrada, ativos externos e o modelo de tarefa As seções a seguir descrevem o uso de ativos externos, os requisitos de formato de dados de entrada e quando considerar o uso de funções do Lambda de pré-anotação. ### Requisitos de formato de dados de entrada Ao criar um arquivo de manifesto de entrada para usar em seu trabalho de rotulagem personalizado do Ground Truth, você deve armazenar os dados no Amazon S3. Os arquivos de manifesto de entrada também devem ser salvos no mesmo local Região da AWS em que seu trabalho de rotulagem personalizado do Ground Truth deve ser executado. Além disso, ele pode ser armazenado em qualquer bucket do Amazon S3 que seja acessível ao perfil de serviço IAM que você usa para executar o trabalho de rotulagem personalizado no Ground Truth. Os arquivos de manifesto de entrada devem usar o formato de linhas JSON ou JSON delimitado por nova linha. Cada linha é delimitada por uma quebra de linha padrão, **\$1n** ou **\$1r\$1n**. Cada linha também deve ser um objeto JSON válido. Cada objeto JSON no arquivo manifesto deve conter uma das seguintes chaves: `source-ref` ou `source`. O valor das chaves é interpretado da seguinte forma: + `source-ref`: a origem do objeto é o objeto do Amazon S3 especificado no valor. Use esse valor quando o objeto for um objeto binário, como uma imagem. + `source`: a origem do objeto é o valor. Use esse valor quando o objeto for um valor de texto. Para saber mais sobre como formatar seus arquivos de manifesto de entrada, consulte [Arquivos de manifesto de entrada](sms-input-data-input-manifest.md). ### Sua função do Lambda de pré-anotação Opcionalmente, você pode especificar uma função do Lambda* de pré-anotação* para gerenciar como os dados do arquivo de manifesto de entrada são tratados antes da rotulagem. Se você especificou o par de valores-chave `isHumanAnnotationRequired`, deverá usar uma função do Lambda de pré-anotação. Quando a Ground Truth envia à função do Lambda de pré-anotação uma solicitação formatada em JSON, ela usa os seguintes esquemas: **Example objeto de dados identificado com o par de valores-chave `source-ref`** ``` { "version": "2018-10-16", "labelingJobArn": arn:aws:lambda:us-west-2:555555555555:function:my-function "dataObject" : { "source-ref": s3://input-data-bucket/data-object-file-name } } ``` **Example objeto de dados identificado com o par de valores-chave `source`** ``` { "version": "2018-10-16", "labelingJobArn" : arn:aws:lambda:us-west-2:555555555555:function:my-function "dataObject" : { "source": Sue purchased 10 shares of the stock on April 10th, 2020 } } ``` A seguir está a resposta esperada da função do Lambda quando `isHumanAnnotationRequired` é usado. ``` { "taskInput": { "source": "This train is really late.", "labels": [ "angry" , "sad" , "happy" , "inconclusive" ], "header": "What emotion is the speaker feeling?" }, "isHumanAnnotationRequired": False } ``` ### Uso de ativos externos Os modelos personalizados SageMaker do Amazon Ground Truth permitem que scripts externos e folhas de estilo sejam incorporados. Por exemplo, o bloco de código a seguir demonstra como você adicionaria uma folha de estilos localizada em `https://www.example.com/my-enhancement-styles.css` ao seu modelo. **Example** ``` ``` Se encontrar erros, verifique se o servidor de origem está enviando o tipo MIME e os cabeçalhos de codificação corretos com os ativos. Por exemplo, os tipos MIME e de codificação para scripts remotos são: `application/javascript;CHARSET=UTF-8`. O MIME e o tipo de codificação das folhas de estilo remotas são: `text/css;CHARSET=UTF-8`. ## Dados de saída e seu modelo de tarefa As seções a seguir descrevem os dados de saída de um trabalho de rotulagem personalizado e quando considerar o uso de uma função do Lambda pós-anotação. ### Dados de saída Quando seu trabalho de rotulagem personalizado é concluído, os dados são salvos no bucket do Amazon S3 especificado quando o trabalho de rotulagem foi criado. Os dados são salvos em um arquivo `output.manifest`. **nota** *labelAttributeName*é uma variável de espaço reservado. Na saída, é o nome do seu trabalho de rotulagem ou o nome de atributo do rótulo que você especifica ao criar o trabalho de rotulagem. + `source` ou `source-ref`: Foi solicitado que os operadores rotulassem a string ou um URI do S3. + `labelAttributeName`: um dicionário contendo conteúdo consolidado de rótulos da [função do Lambda de pós-anotação](sms-custom-templates-step3-lambda-requirements.md#sms-custom-templates-step3-postlambda). Se uma função do Lambda de pós-anotação não for especificada, esse dicionário ficará vazio. + `labelAttributeName-metadata`: Metadados do seu trabalho de rotulagem personalizada adicionados pelo Ground Truth. + `worker-response-ref`: O URI do S3 do bucket em que os dados são salvos. Se uma função do Lambda de pós-anotação for especificada, esse par de valores-chave não estará presente. Neste exemplo, o objeto JSON é formatado para legibilidade, no arquivo de saída real, e o objeto JSON está em uma única linha. ``` { "source" : "This train is really late.", "labelAttributeName" : {}, "labelAttributeName-metadata": { # These key values pairs are added by Ground Truth "job_name": "test-labeling-job", "type": "groundTruth/custom", "human-annotated": "yes", "creation_date": "2021-03-08T23:06:49.111000", "worker-response-ref": "s3://amzn-s3-demo-bucket/test-labeling-job/annotations/worker-response/iteration-1/0/2021-03-08_23:06:49.json" } } ``` ### Usando uma pós-anotação Lambda para consolidar os resultados de seus operadores Por padrão, o Ground Truth salva as respostas dos operadores não processadas no Amazon S3. Para ter um controle mais refinado sobre como as respostas são tratadas, você pode especificar uma *função do Lambda pós-anotação*. Por exemplo, uma função do Lambda pós-anotação pode ser usada para consolidar a anotação se vários operadores tiverem rotulado o mesmo objeto de dados. Para saber mais sobre como criar funções do Lambda de pós-anotação, consulte [Lambda de pós-anotação](sms-custom-templates-step3-lambda-requirements.md#sms-custom-templates-step3-postlambda). Se você quiser usar uma função do Lambda de pós-anotação, ela deverá ser especificada como parte da [https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_AnnotationConsolidationConfig.html](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_AnnotationConsolidationConfig.html) em uma solicitação `CreateLabelingJob`. Para saber mais sobre como a consolidação de anotações funciona, consulte [Consolidação de anotações](sms-annotation-consolidation.md). # Adicionar automação com o Liquid Nosso sistema de modelo personalizado usa o [Liquid](https://shopify.github.io/liquid/) para automação. Trata-se de uma linguagem de marcação de código aberto em linha. No Liquid, o texto entre chaves simples e símbolos de percentagem é uma instrução ou *tag* que realiza uma operação, como controle de fluxo ou iteração. O texto entre chaves duplas é uma variável ou um *objeto* que gera seu valor. O uso mais comum do Liquid será para analisar os dados provenientes do arquivo de manifesto de entrada e extrair as variáveis relevantes para criar a tarefa. O Ground Truth gera automaticamente as tarefas, a menos que uma pré-anotação Lambda seja especificada. O objeto `taskInput` retornado pelo Ground Truth ou o [Lambda de pré-anotação](sms-custom-templates-step3-lambda-requirements.md#sms-custom-templates-step3-prelambda) é o objeto `task.input` nos modelos. As propriedades no manifesto de entrada são passadas para o template como `event.dataObject`. **Example objeto de dados do manifesto** ``` { "source": "This is a sample text for classification", "labels": [ "angry" , "sad" , "happy" , "inconclusive" ], "header": "What emotion is the speaker feeling?" } ``` **Example amostra de HTML usando variáveis** ``` {{ task.input.source }} ``` Observe a adição de ` | to_json` à propriedade `labels` acima. Esse é um filtro que transforma a matriz do manifesto de entrada em uma representação JSON da matriz. Os filtros de variáveis são explicados na próxima seção. A lista a seguir inclui dois tipos de tags líquidas que podem ser úteis para automatizar o processamento de dados de entrada em modelos. Se você selecionar um dos seguintes tipos de tags, será redirecionado para a documentação do Liquid: + [Fluxo de controle](https://shopify.github.io/liquid/tags/control-flow/): inclui operadores lógicos de programação como `if/else`, `unless` e `case/when`. + [Iteração](https://shopify.github.io/liquid/tags/iteration/): permite que você execute blocos de código repetidamente usando instruções como for loops. Para ver um exemplo de um modelo HTML que usa elementos Liquid para criar um loop for, consulte [translation-review-and-correction.liquid.html](https://github.com/aws-samples/amazon-sagemaker-ground-truth-task-uis/blob/8ae02533ea5a91087561b1daecd0bc22a37ca393/text/translation-review-and-correction.liquid.html) em. GitHub Para obter mais informações e acessar a documentação, visite a página inicial [Liquid](https://shopify.github.io/liquid/). ## Filtros de variáveis Além dos[ filtros e ações padrão do Liquid](https://shopify.github.io/liquid/filters/abs/), o Ground Truth oferece alguns filtros adicionais. Os filtros são aplicados colocando um caractere de barra vertical (`|`) após o nome da variável e, em seguida, especificando um nome do filtro. Os filtros podem ser encadeados na forma de: **Example** ``` {{ | | }} ``` ### Escape automático e escape explícito Por padrão, as entradas terão escape HTML para evitar confusão entre o texto da variável e o HTML. Você pode adicionar explicitamente o filtro `escape` para tornar mais óbvio para alguém que esteja lendo a origem do seu modelo que o escape está sendo feito. ### escape\$1once `escape_once` garante que, se você já tiver escapado seu código, ele não será reexibido além disso. Por exemplo, para que & não se torne &. ### skip\$1autoescape `skip_autoescape` é útil quando seu conteúdo deve ser usado como HTML. Por exemplo, você pode ter alguns parágrafos de texto e algumas imagens nas instruções completas de uma caixa delimitadora. **Use `skip_autoescape` com moderação** A prática recomendada em modelos é evitar transmitir código da função ou marcação com `skip_autoescape`, a menos que você tenha absoluta certeza de que tem o controle rígido sobre o que está sendo transmitido. Se você estiver transmitindo a entrada do usuário, poderá expor seus funcionários a um ataque de Cross Site Scripting. ### to\$1json `to_json`codificará o que você envia para JSON (JavaScript Object Notation). Se você alimentar um objeto, ele será serializado. ### grant\$1read\$1access `grant_read_access` usa um URI do S3 e o codifica em um URL HTTPS com um token de acesso de curta duração para esse recurso. Isso possibilita exibir aos operadores fotos, áudio ou vídeo de objetos armazenados em buckets do S3 que de outra forma não são acessíveis publicamente. ### s3\$1presign O filtro `s3_presign` funciona da mesma forma que o filtro `grant_read_access`. `s3_presign` usa um URI do Amazon S3 e o codifica em um URL HTTPS com um token de acesso de curta duração para esse recurso. Isso possibilita exibir objetos de fotografia, áudio ou vídeo armazenados em buckets do S3 que, de outra forma, não são acessíveis publicamente para operadores. **Example dos filtros de variáveis** Input ``` auto-escape: {{ "Have you read 'James & the Giant Peach'?" }} explicit escape: {{ "Have you read 'James & the Giant Peach'?" | escape }} explicit escape_once: {{ "Have you read 'James & the Giant Peach'?" | escape_once }} skip_autoescape: {{ "Have you read 'James & the Giant Peach'?" | skip_autoescape }} to_json: {{ jsObject | to_json }} grant_read_access: {{ "s3://amzn-s3-demo-bucket/myphoto.png" | grant_read_access }} s3_presign: {{ "s3://amzn-s3-demo-bucket/myphoto.png" | s3_presign }} ``` **Example** Output ``` auto-escape: Have you read 'James & the Giant Peach'? explicit escape: Have you read 'James & the Giant Peach'? explicit escape_once: Have you read 'James & the Giant Peach'? skip_autoescape: Have you read 'James & the Giant Peach'? to_json: { "point_number": 8, "coords": [ 59, 76 ] } grant_read_access: https://s3.amazonaws.com/amzn-s3-demo-bucket/myphoto.png? s3_presign: https://s3.amazonaws.com/amzn-s3-demo-bucket/myphoto.png? ``` **Example de um modelo de classificação automatizado.** Para automatizar a amostra de classificação de texto simples, substitua o texto do tweet por uma variável. O modelo de classificação de texto está abaixo com automação adicionada. Eles changes/additions estão destacados em negrito. ``` {{ task.input.source }} Try to determine the feeling the author of the tweet is trying to express. If none seem to match, choose "other." Pick the term best describing the sentiment of the tweet. ``` O texto do tweet que estava no exemplo anterior foi substituído por um objeto. O objeto `entry.taskInput` usa `source` (ou outro nome que você especificar no seu Lambda de pré-anotação) como o nome da propriedade para o texto, e ele é inserido diretamente no HTML por estar entre chaves duplas. # 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`. # Modelo de demonstração: anotação de imagens com `crowd-bounding-box` Ao escolher usar um modelo personalizado como seu tipo de tarefa no console do Amazon SageMaker Ground Truth, você acessa o **painel de tarefas de rotulagem personalizada**. Ali, você pode escolher entre vários modelos básicos. Os modelos representam algumas das tarefas mais comuns e fornecem uma amostra a partir da qual você cria o modelo da tarefa de rotulagem personalizado. Se você não estiver usando o console ou como um recurso adicional, consulte [Amazon SageMaker AI Ground Truth Sample Task UIs ](https://github.com/aws-samples/amazon-sagemaker-ground-truth-task-uis) para obter um repositório de modelos de demonstração para uma variedade de tipos de tarefas de rotulagem. Essa demonstração funciona com o **BoundingBox**modelo. A demonstração também funciona com as AWS Lambda funções necessárias para processar seus dados antes e depois da tarefa. No repositório do Github acima, para encontrar modelos que funcionem com AWS Lambda funções, procure `{{ task.input. }}` no modelo. **Topics** + [ ## Modelo personalizado de caixa delimitadora inicial ](#sms-custom-templates-step2-demo1-base-template) + [ ## Seu próprio modelo personalizado de caixa delimitadora ](#sms-custom-templates-step2-demo1-your-own-template) + [ ## Seu arquivo de manifesto ](#sms-custom-templates-step2-demo1-manifest) + [ ## Sua função do Lambda de pré-anotação ](#sms-custom-templates-step2-demo1-pre-annotation) + [ ## Sua função do Lambda de pós-anotação ](#sms-custom-templates-step2-demo1-post-annotation) + [ ## A saída do seu trabalho de rotulagem ](#sms-custom-templates-step2-demo1-job-output) ## Modelo personalizado de caixa delimitadora inicial Este é o modelo de caixa delimitadora inicial fornecido. ```

Use the bounding box tool to draw boxes around the requested target of interest:

  1. Draw a rectangle using your mouse over each instance of the target.
  2. Make sure the box does not cut into the target, leave a 2 - 3 pixel margin
  3. When targets are overlapping, draw a box around each object, include all contiguous parts of the target in the box. Do not include parts that are completely overlapped by another object.
  4. Do not include parts of the target that cannot be seen, even though you think you can interpolate the whole shape of the target.
  5. Avoid shadows, they're not considered as a part of the target.
  6. If the target goes off the screen, label up to the edge of the image.
 Use the bounding box tool to draw boxes around the requested target of interest. ``` Os modelos personalizados usam a [Linguagem de modelo Liquid](https://shopify.github.io/liquid/), e cada um dos itens entre chaves duplas é uma variável. A AWS Lambda função de pré-anotação deve fornecer um objeto chamado `taskInput` e as propriedades desse objeto podem ser acessadas como `{{ task.input. }}` em seu modelo. ## Seu próprio modelo personalizado de caixa delimitadora Por exemplo, suponha que você tenha uma grande coleção de fotos de animais em que você conhece o tipo de animais na imagem por meio de um trabalho anterior de classificação de imagem. Agora você quer ter uma caixa delimitadora desenhada em torno dela. Na amostra inicial, existem três variáveis: `taskObject`, `header` e `labels`. Cada um deles seria representado em diferentes partes da caixa delimitadora. + `taskObject` é um URL HTTP(S) ou URI do S3 para a foto a ser anotada. O `| grant_read_access` adicionado é um filtro que converterá um URI do S3 em um HTTPS URL com acesso de curta duração a esse recurso. Se você estiver usando um URL HTTP(S), ele não será necessário. + `header` é o texto acima da foto a ser rotulado, algo como "Desenhe uma caixa ao redor do pássaro na foto". + `labels` é uma matriz, representada como `['item1', 'item2', ...]`. Esses são rótulos que podem ser atribuídos pelo operador às diferentes caixas que eles desenham. Você pode ter um ou muitos. Cada um dos nomes de variáveis vem do objeto JSON na resposta do seu Lambda de pré-anotação. Os nomes acima são meramente sugeridos. Use qualquer nome de variável que faça sentido para você e favoreça a legibilidade do código na sua equipe. **Use apenas variáveis quando necessário** Se um campo não for alterado, você poderá remover essa variável do modelo e substituí-la por esse texto. Caso contrário, será necessário repetir esse texto como um valor em cada objeto no manifesto ou codificá-lo na função do Lambda de pré-anotação. **Example : Modelo final de caixa delimitadora personalizada** Para manter as coisas simples, esse modelo terá uma variável, um rótulo e instruções muito básicas. Supondo que seu manifesto tenha uma propriedade "animal" em cada objeto de dados, esse valor pode ser reutilizado em duas partes do modelo. ```

Draw a bounding box around the {{ task.input.animal }} in the image. If there is more than one {{ task.input.animal }} per image, draw a bounding box around the largest one.

The box should be tight around the {{ task.input.animal }} with no more than a couple of pixels of buffer around the edges.

If the image does not contain a {{ task.input.animal }}, check the Nothing to label box.

Draw a bounding box around the {{ task.input.animal }} in each image. If there is more than one {{ task.input.animal }} per image, draw a bounding box around the largest one.

 ``` Observe a reutilização de `{{ task.input.animal }}` em todo o modelo. Se o seu manifesto tivesse todos os nomes de animais começando com letra maiúscula, você poderia usar `{{ task.input.animal | downcase }}`, incorporando um dos filtros integrados do Liquid em frases que precisavam ser apresentadas em minúsculas. ## Seu arquivo de manifesto Seu arquivo de manifesto deve fornecer os valores das variáveis que você está usando em seu modelo. Você pode fazer uma certa transformação dos seus dados de manifesto no seu Lambda de pré-anotação, mas, se não precisar, mantenha um menor risco de erros e seu Lambda será executado mais rapidamente. Veja a seguir um exemplo de arquivo de manifesto para o modelo. ``` {"source-ref": "", "animal": "horse"} {"source-ref": "", "animal" : "bird"} {"source-ref": "", "animal" : "dog"} {"source-ref": "", "animal" : "cat"} ``` ## Sua função do Lambda de pré-anotação Como parte da configuração do trabalho, forneça o ARN de uma AWS Lambda função que pode ser chamada para processar suas entradas de manifesto e passá-las para o mecanismo de modelos. **Redação de sua função do Lambda** A melhor prática ao nomear sua função é usar um das quatro strings a seguir como parte do nome da função: `SageMaker`, `Sagemaker`, `sagemaker`, ou `LabelingFunction`. Isso se aplica às funções de pré-anotação e pós-anotação. Ao usar o console, se você tiver funções do AWS Lambda pertencentes à sua conta, uma lista suspensa de funções que atendem aos requisitos de nomenclatura será fornecida para escolher uma. Neste exemplo muito básico, você está apenas passando as informações do manifesto sem fazer nenhum processamento adicional nele. Esta função de pré-anotação de amostra é escrita para o Python 3.7. ``` import json def lambda_handler(event, context): return { "taskInput": event['dataObject'] } ``` O objeto JSON do seu manifesto será fornecido como filho do objeto `event`. As propriedades dentro do objeto `taskInput` estarão disponíveis como variáveis para o seu modelo, portanto, basta configurar o valor de `taskInput` para `event['dataObject']` para passar todos os valores do seu objeto do manifesto para o seu modelo sem precisar copiá-los individualmente. Se você quiser enviar mais valores para o modelo, você pode adicioná-los ao objeto `taskInput`. ## Sua função do Lambda de pós-anotação Como parte da configuração do trabalho, forneça o ARN de uma AWS Lambda função que pode ser chamada para processar os dados do formulário quando um trabalhador conclui uma tarefa. Isso pode ser tão simples ou complexo quanto você quiser. Se você quiser fazer a consolidação e a pontuação das respostas à medida que elas chegarem, você pode aplicar os algoritmos de and/or consolidação de pontuação de sua escolha. Se quiser armazenar os dados brutos para processamento offline, essa é uma opção. **Fornecer permissões ao seu Lambda de pós-anotação** Os dados de anotação estarão em um arquivo designado pela string `s3Uri` no objeto `payload`. Para processar as anotações assim que elas chegarem, mesmo para uma simples função de repasse, você precisa atribuir ao `S3ReadOnly` acesso ao seu Lambda para que ele possa ler os arquivos de anotação. Na página Console para a criação do seu Lambda, role até o painel **Perfil de execução**. Selecione **Criar uma nova função a partir de um ou mais modelos**. Dê um nome à função. Na lista suspensa **Modelos de política**, escolha **Permissões somente leitura do objeto Amazon S3**. Salve o Lambda, e a função será salva e selecionada. O exemplo a seguir está em Python 2.7. ``` import json import boto3 from urlparse import urlparse def lambda_handler(event, context): consolidated_labels = [] parsed_url = urlparse(event['payload']['s3Uri']); s3 = boto3.client('s3') textFile = s3.get_object(Bucket = parsed_url.netloc, Key = parsed_url.path[1:]) filecont = textFile['Body'].read() annotations = json.loads(filecont); for dataset in annotations: for annotation in dataset['annotations']: new_annotation = json.loads(annotation['annotationData']['content']) label = { 'datasetObjectId': dataset['datasetObjectId'], 'consolidatedAnnotation' : { 'content': { event['labelAttributeName']: { 'workerId': annotation['workerId'], 'boxesInfo': new_annotation, 'imageSource': dataset['dataObject'] } } } } consolidated_labels.append(label) return consolidated_labels ``` O Lambda de pós-anotação geralmente recebe lotes de resultados de tarefas no objeto de evento. Esse lote será o objeto `payload` que o Lambda deve percorrer. O que você retornará será um objeto que atende ao [contrato de API](sms-custom-templates-step3.md). ## A saída do seu trabalho de rotulagem Você encontrará a saída da tarefa em uma pasta com o nome da sua tarefa de rotulagem no bucket do S3 de destino especificado. Ele estará em uma subpasta chamada `manifests`. Para uma tarefa de caixa delimitadora, a saída que você encontrará no manifesto de saída será um pouco parecida com a demonstração abaixo. O exemplo foi limpo para impressão. A saída real será uma única linha por registro. **Example : JSON no manifesto de saída** ``` { "source-ref":"", "