As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criar um fluxo de trabalho de análise humana
Use um *fluxo de trabalho de análise humana* do Amazon Augmented AI (Amazon A2I) ou uma *definição de fluxo* para especificar o seguinte:
+ Para os tipos de tarefa incorporadas do Amazon Textract e do Amazon Rekognition, as condições sob as quais o loop humano será chamado.
+ A força de trabalho para a qual suas tarefas são enviadas
+ As instruções que a força de trabalho receberá, que são chamadas de *modelo de tarefa de operador*.
+ A configuração de suas tarefas de trabalho, incluindo o número de operadores que recebem uma tarefa e os limites de tempo para concluir as tarefas.
+ Local em que seus dados de saída estão armazenados.
Você pode criar um fluxo de trabalho de revisão humana no console de SageMaker IA ou usando a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html)operação de SageMaker IA. É possível criar um modelo de tarefa de operador usando o console para tipos de tarefa do Amazon Textract e do Amazon Rekognition ao criar sua definição de fluxo.
**Importante**
As condições de ativação do loop humano, que iniciam o loop humano, como os limiares de confiança, não estão disponíveis para tipos de tarefas personalizados no Amazon A2I. Ao usar o console para criar uma definição de fluxo para um tipo de tarefa personalizado, não é possível especificar condições de ativação. Ao usar a API do Amazon A2I para criar uma definição de fluxo para um tipo de tarefa personalizado, você não pode definir o atributo `HumanLoopActivationConditions` do parâmetro `HumanLoopActivationConditionsConfig`. Para controlar quando as revisões humanas são iniciadas, especifique as condições nas quais `StartHumanLoop` é chamado no seu aplicativo personalizado. Neste caso, cada chamada de `StartHumanLoop` resulta em uma análise humana. Para obter mais informações, consulte [Usar o Amazon Augmented AI com tipos de tarefas personalizadas](a2i-task-types-custom.md).
**Pré-requisitos**
Para criar uma definição de fluxo de análise humana, você deve ter concluído os pré-requisitos descritos em [Pré-requisitos para usar a IA Augmented](a2i-getting-started-prerequisites.md).
Se você usar a API para criar uma definição de fluxo para qualquer tipo de tarefa ou se usar um tipo de tarefa personalizado ao criar uma definição de fluxo no console, primeiro criar um modelo de tarefa de operador. Para obter mais informações, consulte [Criar e gerenciar modelos de tarefas de operadores](a2i-instructions-overview.md).
Para visualizar o modelo de tarefa de operador ao criar uma definição de fluxo para um tipo de tarefa incorporado no console, conceda à função usada para criar a definição de fluxo permissão para acessar o bucket do Amazon S3 que contém os artefatos do modelo usando uma política como a descrita em [Habilitar visualizações do modelo de tarefa de operador](a2i-permissions-security.md#permissions-for-worker-task-templates-augmented-ai).
**Topics**
+ [Criar um fluxo de trabalho de análise humana (console)](#a2i-create-human-review-console)
+ [Criar um fluxo de trabalho de análise humana (API)](#a2i-create-human-review-api)
+ [Esquema JSON para condições de ativação de loop humano no Amazon Augmented AI](a2i-human-fallback-conditions-json-schema.md)
## Criar um fluxo de trabalho de análise humana (console)
Use esse procedimento para criar um fluxo de trabalho de revisão humana do Amazon Augmented AI (Amazon A2I) usando SageMaker o console de IA. Se você não estiver familiarizado com o Amazon A2I, é recomendável criar uma equipe de trabalho privada, usando pessoas de sua organização e usar o ARN dessa equipe de trabalho ao criar sua definição de fluxo. Para saber como configurar uma força de trabalho privada e criar uma equipe de trabalho, consulte [Crie uma força de trabalho privada (Amazon SageMaker AI Console)](sms-workforce-create-private-console.md). Se você já configurou uma força de trabalho privada, consulte [Crie uma equipe de trabalho usando o console de SageMaker IA](sms-workforce-management-private-console.md#create-workteam-sm-console) para saber como adicionar uma equipe de trabalho a essa força de trabalho.
Se você estiver usando o Amazon A2I com um dos tipos de tarefa integrados, pode criar instruções para os operadores usando um modelo de tarefa padrão fornecido pela Augmented AI durante a criação de um fluxo de trabalho de análise humana no console. Para ver exemplos dos modelos padrão fornecidos pelo Augmented AI, consulte os tipos de tarefa incorporados em [Casos de uso e exemplos usando o Amazon A2I](a2i-task-types-general.md).
**Como criar uma definição de fluxo (console)**
1. Abra o console de SageMaker IA em[https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, na seção **Augmented AI**, escolha **Human review workflows (Fluxos de trabalho de análise humana) ** e escolha **Create human review workflow (Criar fluxo de trabalho de análise humana)**.
1. Em **Overview (Visão geral)**, faça o seguinte:
1. Em **Name (Nome)**, insira um nome exclusivo para o fluxo de trabalho. O nome deve estar em minúsculas, exclusivo na AWS região da sua conta e pode ter até 63 caracteres. Os caracteres válidos incluem: a-z, 0-9 e - (hífen).
1. Em **S3 location for output (Local do S3 para a saída)**, insira o bucket do S3 onde você deseja armazenar os resultados da análise humana. O bucket deve estar localizado na mesma AWS região do fluxo de trabalho.
1. Para o **Perfil do IAM**, escolha um perfil que tenha as permissões necessárias. Se você escolher um tipo de tarefa incorporada e desejar visualizar o modelo do operador no console, forneça uma função com o tipo de política descrito no [Habilitar visualizações do modelo de tarefa de operador](a2i-permissions-security.md#permissions-for-worker-task-templates-augmented-ai) anexado.
1. Em **Task type (Tipo de tarefa)**, escolha o tipo de tarefa que deseja que o operador humano execute.
1. Se você escolher o tipo de tarefa do Amazon Rekognition ou do Amazon Textract, especifique as condições que invocarão a análise humana.
+ Para tarefas de moderação do Amazon Rekognition Image, escolha um intervalo de limiar de pontuação de confiança na inferência que inicie a análise humana.
+ Para tarefas do Amazon Textract, é possível iniciar uma análise humana quando chaves de formulário específicas estão ausentes ou quando a confiança na detecção de chaves de formulário é baixa. Você também pode iniciar uma análise humana se, após avaliar todas as chaves de formulário no texto, a confiança for menor do que o limiar necessário para qualquer chave de formulário. Você verá duas variáveis que podem ser usadas para especificar seus limites de confiança: **Confiança de identificação** e **Confiança de qualificação**. Para saber mais sobre essas variáveis, consulte [Use o Amazon Augmented AI com o Amazon Textract](a2i-textract-task-type.md).
+ Para os dois tipos de tarefa, você pode enviar aleatoriamente uma porcentagem de objetos de dados (imagens ou formulários) e seus rótulos a humanos para análise.
1. Configure e especifique seu modelo de tarefa de operador:
1. Se você estiver usando o Amazon Rekognition ou o Amazon Textract, digite:
1. Na seção **Create template (Criar modelo)**:
+ Para criar instruções para seus operadores usando o modelo padrão do Amazon A2I para os tipos de tarefa do Amazon Rekognition e do Amazon Textract, escolha **Criar com base em um modelo padrão**.
+ Se você selecionar **Build from a default template (Criar usando um modelo padrão)**, crie as instruções em **Worker task design (Design de tarefa de operador)**.
+ Forneça um **nome de modelo** que seja exclusivo na AWS região em que você está.
+ Na seção **Instructions (Instruções)**, forneça instruções detalhadas sobre como concluir a tarefa. Para ajudar os operadores a obter maior precisão, forneça exemplos bons e ruins.
+ (Opcional) Em **Additional instructions (Instruções adicionais)**, forneça aos operadores informações e instruções adicionais.
Para obter informações sobre como criar instruções eficientes, consulte [Criar instruções para o bom operador](a2i-creating-good-instructions-guide.md).
+ Para selecionar um modelo personalizado criado por você, escolha-o no menu **Template (Modelo)** e forneça uma **Task description (Descrição de tarefa)** para descrever brevemente a tarefa para os operadores. Para saber como criar um modelo personalizado, consulte [Criar um modelo de tarefa de trabalho](a2i-worker-template-console.md#a2i-create-worker-template-console).
1. Se você estiver usando o tipo de tarefa personalizado:
1. Na seção **Modelo de tarefa do operador**, selecione o modelo na lista. Todos os modelos que você criou no console de SageMaker IA aparecem nessa lista. Para saber como criar um modelo para tipos de tarefa personalizados, consulte [Criar e gerenciar modelos de tarefas de operadores](a2i-instructions-overview.md).
1. (Opcional) Visualize seu modelo de operador:
Para tipos de tarefa do Amazon Rekognition e do Amazon Textract, você tem a opção de escolher **Ver uma tarefa de operador de exemplo** para visualizar a interface do usuário de tarefa de operador.
Se estiver criando uma definição de fluxo para um tipo de tarefa personalizado, você poderá visualizar a interface do usuário de tarefa de operador usando a operação `RenderUiTemplate`. Para obter mais informações, consulte [Visualizar um modelo de tarefa de operador](a2i-custom-templates.md#a2i-preview-your-custom-template).
1. Em **Workers (Operadores)**, escolha um tipo de força de trabalho.
1. Escolha **Criar**.
### Próximas etapas
Depois de criar um fluxo de trabalho de análise humana, ele aparece no console em **Human review workflows (Fluxos de trabalho de análise humana)**. Para ver o nome de recurso da Amazon (ARN) da definição do fluxo e os detalhes da configuração, escolha o fluxo de trabalho selecionando seu nome.
Se você estiver usando um tipo de tarefa incorporado, poderá usar o ARN de definição de fluxo para iniciar um loop humano usando a API desse AWS serviço (por exemplo, a API Amazon Textract). Para tipos de tarefa personalizados, você pode usar o ARN para iniciar um loop humano usando a API de runtime da Amazon Augmented AI. Para saber mais sobre as duas opções, consulte [Criar e iniciar um loop humano](a2i-start-human-loop.md).
## Criar um fluxo de trabalho de análise humana (API)
Para criar uma definição de fluxo usando a SageMaker API, você usa a `CreateFlowDefinition` operação. Depois de concluir o [Pré-requisitos para usar a IA Augmented](a2i-getting-started-prerequisites.md), use o procedimento a seguir para aprender a usar essa operação de API.
Para obter uma visão geral da operação `CreateFlowDefinition` e detalhes sobre cada parâmetro, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html).
**Como criar uma definição de fluxo (API)**
1. Em `FlowDefinitionName`, insira um nome exclusivo. O nome deve ser exclusivo na AWS região da sua conta e pode ter até 63 caracteres. Os caracteres válidos incluem: a-z, 0-9 e - (hífen).
1. Em `RoleArn`, insira o ARN da função que você configurou para conceder acesso às suas fontes de dados.
1. Em `HumanLoopConfig`, insira informações sobre os operadores e o que eles devem ver. Para obter informações sobre cada parâmetro em`HumanLoopConfig`, consulte [HumanLoopConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html#sagemaker-CreateFlowDefinition-request-HumanLoopActivationConfig).
1. (Opcional) Se estiver usando um tipo de tarefa integrada, forneça condições que iniciem um loop humano em `HumanLoopActivationConfig`. Para saber como criar a entrada necessária para o parâmetro `HumanLoopActivationConfig`, consulte [Esquema JSON para condições de ativação de loop humano no Amazon Augmented AI](a2i-human-fallback-conditions-json-schema.md). Se você não especificar condições aqui, ao fornecer uma definição de fluxo para o AWS serviço associado a um tipo de tarefa incorporado (por exemplo, Amazon Textract ou Amazon Rekognition), esse serviço enviará todas as tarefas a um funcionário humano para análise.
Se você estiver usando um tipo de tarefa personalizado, `HumanLoopActivationConfig` estará desativado. Para saber como controlar quando as tarefas são enviadas a operadores humanos usando um tipo de tarefa personalizado, consulte [Usar o Amazon Augmented AI com tipos de tarefas personalizadas](a2i-task-types-custom.md).
1. (Opcional) Se você estiver usando um tipo de tarefa incorporado, especifique a fonte de integração (por exemplo, Amazon Rekognition ou Amazon Textract) no parâmetro. [HumanLoopRequestSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HumanLoopRequestSource.html)
1. Para `OutputConfig`, indique em que lugar do Amazon Simple Storage Service (Amazon S3) deve ser armazenada a saída do loop humano.
1. (Opcional) Use `Tags` para inserir pares chave-valor para ajudá-lo a categorizar e organizar uma definição de fluxo. Cada tag consiste em uma chave e um valor, ambos definidos por você.
------
#### [ Amazon Textract – Key-value pair extraction ]
Veja a seguir um exemplo de uma solicitação para criar um fluxo de trabalho de análise humana do Amazon Textract (definição de fluxo) usando o AWS SDK para Python (Boto3). Você deve usar `'AWS/Textract/AnalyzeDocument/Forms/V1'` para criar um loop humano do Amazon Textract. Inclua somente `PublicWorkforceTaskPrice` se você estiver usando a força de trabalho da Mechanical Turk.
```
sagemaker_client = boto3.client('sagemaker', aws_region)
response = sagemaker_client.create_flow_definition(
FlowDefinitionName='ExampleFlowDefinition',
HumanLoopRequestSource={
'AwsManagedHumanLoopRequestSource': 'AWS/Textract/AnalyzeDocument/Forms/V1'
},
HumanLoopActivationConfig={
'HumanLoopActivationConditionsConfig': {
'HumanLoopActivationConditions': '{...}'
}
},
HumanLoopConfig={
'WorkteamArn': 'arn:aws:sagemaker:aws_region:aws_account_number:workteam/private-crowd/workteam_name',
'HumanTaskUiArn': 'arn:aws:sagemaker:aws_region:aws_account_number:human-task-ui/template_name',
'TaskTitle': 'Example task title',
'TaskDescription': 'Example task description.',
'TaskCount': 123,
'TaskAvailabilityLifetimeInSeconds': 123,
'TaskTimeLimitInSeconds': 123,
'TaskKeywords': [
'Keyword1','Keyword2'
],
'PublicWorkforceTaskPrice': {
'AmountInUsd': {
'Dollars': 123,
'Cents': 123,
'TenthFractionsOfACent': 123
}
}
},
OutputConfig={
'S3OutputPath': 's3://bucket/path/',
'KmsKeyId': '1234abcd-12ab-34cd-56ef-1234567890ab'
},
RoleArn='arn:aws:iam::aws_account_number:role/role_name',
Tags=[
{
'Key': 'KeyName',
'Value': 'ValueName'
},
]
)
```
------
#### [ Amazon Rekognition – Image moderation ]
O seguinte é um exemplo de uma solicitação para criar um fluxo de trabalho de análise humana do Amazon Rekognition (definição de fluxo) usando o AWS SDK para Python (Boto3). Você deve usar `'AWS/Rekognition/DetectModerationLabels/Image/V3'` para criar uma definição de fluxo do Amazon Rekognition. Inclua somente `PublicWorkforceTaskPrice` se você estiver usando a força de trabalho da Mechanical Turk.
```
sagemaker_client = boto3.client('sagemaker', aws_region)
response = sagemaker_client.create_flow_definition(
FlowDefinitionName='ExampleFlowDefinition',
HumanLoopRequestSource={
'AwsManagedHumanLoopRequestSource': 'AWS/Rekognition/DetectModerationLabels/Image/V3'
},
HumanLoopActivationConfig={
'HumanLoopActivationConditionsConfig': {
'HumanLoopActivationConditions': '{...}'
}
},
HumanLoopConfig={
'WorkteamArn': 'arn:aws:sagemaker:aws_region:aws_account_number:workteam/private-crowd/workteam_name',
'HumanTaskUiArn': 'arn:aws:sagemaker:aws_region:aws_account_number:human-task-ui/template_name',
'TaskTitle': 'Example task title',
'TaskDescription': 'Example task description.',
'TaskCount': 123,
'TaskAvailabilityLifetimeInSeconds': 123,
'TaskTimeLimitInSeconds': 123,
'TaskKeywords': [
'Keyword1','Keyword2'
],
'PublicWorkforceTaskPrice': {
'AmountInUsd': {
'Dollars': 123,
'Cents': 123,
'TenthFractionsOfACent': 123
}
}
},
OutputConfig={
'S3OutputPath': 's3://bucket/path/',
'KmsKeyId': '1234abcd-12ab-34cd-56ef-1234567890ab'
},
RoleArn='arn:aws:iam::aws_account_number:role/role_name',
Tags=[
{
'Key': 'KeyName',
'Value': 'ValueName'
},
]
)
```
------
#### [ Custom Workflow ]
O seguinte é um exemplo de uma solicitação para criar um fluxo de trabalho de análise humana (definição de fluxo) para uma integração personalizada. Para criar esse tipo de fluxo de trabalho de análise humana, omita o `HumanLoopRequestSource` da solicitação de definição de fluxo. Você só precisa incluir o `PublicWorkforceTaskPrice` se estiver usando a força de trabalho do Mechanical Turk.
```
sagemaker_client = boto3.client('sagemaker', aws_region)
response = sagemaker_client.create_flow_definition(
FlowDefinitionName='ExampleFlowDefinition',
HumanLoopActivationConfig={
'HumanLoopActivationConditionsConfig': {
'HumanLoopActivationConditions': '{...}'
}
},
HumanLoopConfig={
'WorkteamArn': 'arn:aws:sagemaker:aws_region:aws_account_number:workteam/private-crowd/workteam_name',
'HumanTaskUiArn': 'arn:aws:sagemaker:aws_region:aws_acount_number:human-task-ui/template_name',
'TaskTitle': 'Example task title',
'TaskDescription': 'Example task description.',
'TaskCount': 123,
'TaskAvailabilityLifetimeInSeconds': 123,
'TaskTimeLimitInSeconds': 123,
'TaskKeywords': [
'Keyword1','Keyword2'
],
'PublicWorkforceTaskPrice': {
'AmountInUsd': {
'Dollars': 123,
'Cents': 123,
'TenthFractionsOfACent': 123
}
}
},
OutputConfig={
'S3OutputPath': 's3://bucket/path/',
'KmsKeyId': '1234abcd-12ab-34cd-56ef-1234567890ab'
},
RoleArn='arn:aws:iam::account_number:role/role_name',
Tags=[
{
'Key': 'KeyName',
'Value': 'ValueName'
},
]
)
```
------
### Próximas etapas
O valor de retorno de uma chamada bem-sucedida da operação da API `CreateFlowDefinition` é um nome de recurso da Amazon (ARN) da definição de fluxo.
Se você estiver usando um tipo de tarefa incorporado, poderá usar o ARN de definição de fluxo para iniciar um loop humano usando a API desse AWS serviço (ou seja, a API Amazon Textract). Para tipos de tarefa personalizados, você pode usar o ARN para iniciar um loop humano usando a API de runtime da Amazon Augmented AI. Para saber mais sobre essas opções, consulte [Criar e iniciar um loop humano](a2i-start-human-loop.md).
# Esquema JSON para condições de ativação de loop humano no Amazon Augmented AI
O `HumanLoopActivationConditions` é um parâmetro de entrada da API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html). Esse parâmetro é uma string no formato JSON. O JSON modela as condições sob as quais um loop humano é criado, quando essas condições forem avaliadas em relação à resposta de uma API de serviço de IA integrante (como `Rekognition.DetectModerationLabels` ou `Textract.AnalyzeDocument`). Essa resposta é referenciada como uma *inferência*. Por exemplo, o Amazon Rekognition envia uma inferência de um rótulo de moderação com uma pontuação de confiança associada. Neste exemplo, a inferência é a melhor estimativa do modelo do rótulo apropriado para uma imagem. Para o Amazon Textract, a inferência é feita sobre a associação entre blocos de texto (*pares de chave-valor*), como a associação entre `Name:` e `Sue` em um formulário, bem como o conteúdo dentro de um bloco de texto ou um *bloco de palavras*, como “Nome”.
O seguinte é o esquema para o JSON. No nível superior, o `HumanLoopActivationConditions` tem uma matriz JSON, `Conditions`. Cada membro dessa matriz é uma condição independente que, se avaliada como `true`, resultará na criação de um loop humano pelo Amazon A2I. Cada condição independente pode ser uma condição simples ou uma condição complexa. Uma condição simples tem os seguintes atributos:
+ `ConditionType`: esse atributo identifica o tipo de condição. Cada API de serviço de IA da AWS que se integra ao Amazon A2I define seu próprio conjunto de `ConditionTypes` permitido.
+ `DetectModerationLabels` do Rekognition – Esta API oferece suporte para os valores `ModerationLabelConfidenceCheck` e `Sampling` `ConditionType`.
+ `AnalyzeDocument` do Textract – Esta API oferece suporte aos valores `ImportantFormKeyConfidenceCheck`, `MissingImportantFormKey` e `Sampling` `ConditionType`.
+ `ConditionParameters` – Este é um objeto JSON que parametriza a condição. O conjunto de atributos permitido desse objeto depende do valor de `ConditionType`. Cada `ConditionType` define seu próprio conjunto de `ConditionParameters`.
Um membro da matriz `Conditions` pode modelar uma condição complexa. Isso é feito conectando logicamente condições simples usando os operadores lógicos `And` e `Or` e aninhando as condições simples subjacentes. Há suporte para até dois níveis de aninhamento.
```
{
"$schema": "http://json-schema.org/draft-07/schema#",
"definitions": {
"Condition": {
"type": "object",
"properties": {
"ConditionType": {
"type": "string"
},
"ConditionParameters": {
"type": "object"
}
},
"required": [
"ConditionType"
]
},
"OrConditionArray": {
"type": "object",
"properties": {
"Or": {
"type": "array",
"minItems": 2,
"items": {
"$ref": "#/definitions/ComplexCondition"
}
}
}
},
"AndConditionArray": {
"type": "object",
"properties": {
"And": {
"type": "array",
"minItems": 2,
"items": {
"$ref": "#/definitions/ComplexCondition"
}
}
}
},
"ComplexCondition": {
"anyOf": [
{
"$ref": "#/definitions/Condition"
},
{
"$ref": "#/definitions/OrConditionArray"
},
{
"$ref": "#/definitions/AndConditionArray"
}
]
}
},
"type": "object",
"properties": {
"Conditions": {
"type": "array",
"items": {
"$ref": "#/definitions/ComplexCondition"
}
}
}
}
```
**nota**
As condições de ativação do loop humano não estão disponíveis para fluxos de trabalho de análise humana integrados a tipos de tarefa personalizados. O parâmetro `HumanLoopActivationConditions` está desativado para tipos de tarefa personalizados.
**Topics**
+ [Uso do esquema JSON de condições de ativação de loop humano com o Amazon Textract](a2i-json-humantaskactivationconditions-textract-example.md)
+ [Uso do esquema JSON de condições de ativação de loop humano com o Amazon Rekognition](a2i-json-humantaskactivationconditions-rekognition-example.md)
# Uso do esquema JSON de condições de ativação de loop humano com o Amazon Textract
Quando usada com o Amazon A2I, a operação `AnalyzeDocument` oferece suporte para as seguintes entradas no parâmetro `ConditionType`:
+ `ImportantFormKeyConfidenceCheck` – use esta condição para criar um loop humano quando a confiança da inferência estiver dentro de um intervalo especificado para chaves de formulário de documento e blocos de palavras. Uma *chave de formulário* é qualquer palavra em um documento que esteja associada a uma entrada. A entrada é chamada de *valor*. Juntos, as chaves de formulário e os valores são referenciados como *pares chave-valor*. Um *bloco de palavras* refere-se às palavras que o Amazon Textract reconhece dentro de um bloco de texto detectado. Para saber mais sobre os blocos de documento do Amazon Textract; consulte [Documentos e objetos de blocos](https://docs.aws.amazon.com/textract/latest/dg/how-it-works-document-layout.html) no *Guias do desenvolvedor do Amazon Textract*.
+ `MissingImportantFormKey` – Use esta condição para criar um loop humano quando o Amazon Textract não tiver identificado a chave ou seus aliases associados dentro do documento.
+ `Sampling` – use esta condição para especificar uma porcentagem de formulários a serem enviados para humanos para análise, independentemente das pontuações de confiança da inferência. Use essa condição para fazer o seguinte:
+ Auditar seu modelo de ML amostrando aleatoriamente todos os formulários analisados pelo seu modelo e enviando uma porcentagem especificada para humanos para revisão.
+ Usando a condição `ImportantFormKeyConfidenceCheck`, faça uma amostragem aleatória de uma porcentagem das inferências que atenderam às condições especificadas em `ImportantFormKeyConfidenceCheck` para iniciar um loop humano e enviar apenas a porcentagem especificada a humanos para análise.
**nota**
Se você enviar a mesma solicitação para `AnalyzeDocument` várias vezes, o resultado da `Sampling` não será alterado para a inferência dessa entrada. Por exemplo, se você fizer uma solicitação `AnalyzeDocument` uma vez e `Sampling` não acionar um loop humano, as solicitações subsequentes para `AnalyzeDocument` com a mesma configuração não iniciarão um loop humano.
## Entradas e resultados de `ImportantFormKeyConfidenceCheck`
O `ImportantFormKeyConfidenceCheck` `ConditionType` oferece suporte aos seguintes `ConditionParameters`:
+ `ImportantFormKey` – Uma string que representa uma chave em um par de valores-chave detectada pelo Amazon Textract que precisa ser revisada por operadores humanos. Se o valor desse parâmetro for o valor especial genérico (\$1), todas as chaves serão consideradas como correspondentes à condição. Você pode usar isso para modelar o caso em que qualquer par chave-valor que atenda a determinados limites de confiança precisa de análise humana.
+ `ImportantFormKeyAliases` – Uma matriz que representa ortografias alternativas ou equivalentes lógicos para a chave de formulário importante.
+ `KeyValueBlockConfidenceEquals`
+ `KeyValueBlockConfidenceLessThan`
+ `KeyValueBlockConfidenceLessThanEquals`
+ `KeyValueBlockConfidenceGreaterThan`
+ `KeyValueBlockConfidenceGreaterThanEquals`
+ `WordBlockConfidenceEquals`
+ `WordBlockConfidenceLessThan`
+ `WordBlockConfidenceLessThanEquals`
+ `WordBlockConfidenceGreaterThan`
+ `WordBlockConfidenceGreaterThanEquals`
Quando você usa o `ImportantFormKeyConfidenceCheck` `ConditionType`, o Amazon A2I envia as inferências de bloco de chave-valor e de bloco de palavras dos blocos de chave-valor e os aliases associados especificados em `ImportantFormKey` e `ImportantFormKeyAliases` para análise humana.
Ao criar uma definição de fluxo, se você usar o modelo de tarefa padrão do trabalhador fornecido na seção **Fluxos de trabalho de revisão humana** do console Amazon SageMaker AI, as inferências de chave-valor e bloco enviadas para análise humana por essa condição de ativação serão incluídas na interface do usuário do trabalhador. Se você usar um modelo de tarefa de operador personalizado, será necessário incluir o elemento `{{ task.input.selectedAiServiceResponse.blocks }}` para incluir dados de entrada de valor inicial (inferências) do Amazon Textract. Para obter um exemplo de modelo personalizado que usa esse elemento de entrada, consulte [Exemplo de modelo personalizado do Amazon Textract](a2i-custom-templates.md#a2i-custom-templates-textract-sample).
## Entradas e resultados de `MissingImportantFormKey`
O `MissingImportantFormKey` `ConditionType` oferece suporte aos seguintes `ConditionParameters`:
+ `ImportantFormKey` – Uma string que representa uma chave em um par de valores-chave detectada pelo Amazon Textract que precisa ser revisada por operadores humanos.
+ `ImportantFormKeyAliases` – Uma matriz que representa ortografias alternativas ou equivalentes lógicos para a chave de formulário importante.
Quando você usa o `ConditionType` `MissingImportantFormKey`, se a chave em `ImportantFormKey` ou aliases em `ImportantFormKeyAliases` não estiverem incluídos na inferência do Amazon Textract, esse formulário será enviado ao humano para análise e nenhum par de valores–chave previsto será incluído. Por exemplo, se o Amazon Textract tiver identificado apenas o `Address` e o `Phone` em um formulário, mas estiver faltando o `ImportantFormKey` de `Name` (no tipo de condição `MissingImportantFormKey`), esse formulário será enviado aos humanos para análise sem nenhuma das chaves de formulário detectadas (`Address` e `Phone`).
Se você usar o modelo de tarefa de trabalho padrão fornecido no console de SageMaker IA, uma tarefa será criada solicitando que os trabalhadores identifiquem a chave `ImportantFormKey` e o valor associado. Se você usar um modelo de tarefa de operador personalizado, será necessário incluir o elemento HTML `` personalizado para configurar essa tarefa.
## Amostrar entradas e resultados
O `Sampling` `ConditionType` oferece suporte para `RandomSamplingPercentage` `ConditionParameters`. A entrada de `RandomSamplingPercentage` deve ser um número real entre 0,01 e 100. Esse número representa a porcentagem de dados qualificados para uma análise humana e que será enviado para humanos para análise. Se você usar a condição `Sampling` sem qualquer outra condição, esse número representará a porcentagem de todas as inferências resultantes feitas pela operação `AnalyzeDocument` em uma única solicitação que será enviada para humanos para análise.
Se você especificar a condição `Sampling` sem qualquer outro tipo de condição, todas as inferências de chave-valor e bloco serão enviadas aos operadores para revisão.
Ao criar uma definição de fluxo, se você usar o modelo de tarefa padrão do trabalhador fornecido na seção **Fluxos de trabalho de revisão humana** do console de SageMaker IA, todas as inferências de valores-chave e blocos enviadas para análise humana por essa condição de ativação serão incluídas na interface do usuário do trabalhador. Se você usar um modelo de tarefa de operador personalizado, será necessário incluir o elemento `{{ task.input.selectedAiServiceResponse.blocks }}` para incluir dados de entrada de valor inicial (inferências) do Amazon Textract. Para obter um exemplo de modelo personalizado que usa esse elemento de entrada, consulte [Exemplo de modelo personalizado do Amazon Textract](a2i-custom-templates.md#a2i-custom-templates-textract-sample).
## Exemplos
Embora apenas uma condição precise ser avaliada como `true` para acionar um loop humano, o Amazon A2I avaliará todas as condições para cada objeto analisado pelo Amazon Textract. Os revisores humanos precisarão revisar as chaves de formulário importantes para todas as condições que foram avaliadas como `true`.
**Exemplo 1: Detectar chaves de formulário importantes com pontuações de confiança em um intervalo especificado que iniciam um loop humano**
Veja a seguir um exemplo de um JSON `HumanLoopActivationConditions` que iniciará um loop humano se qualquer uma das seguintes três condições for atendida:
+ A API `AnalyzeDocument` do Amazon Textract retorna um par de valores-chave cuja chave é `Employee Name`, `Name` ou `EmployeeName`, com a confiança do bloco chave-valor sendo menor que 60 e as confianças de cada um dos blocos de palavras que compõem a chave e o valor sendo menor que 85.
+ A API `AnalyzeDocument` do Amazon Textract retorna um par de valores-chave cuja chave é `Pay Date`, `PayDate`, `DateOfPay` ou `pay-date`, com a confiança do bloco chave-valor sendo menor que 65 e as confianças de cada um dos blocos de palavras que compõem a chave e o valor sendo menor que 85.
+ A API `AnalyzeDocument` do Amazon Textract retorna um par de valores-chave cuja chave é `Gross Pay`, `GrossPay` ou `GrossAmount`, com a confiança do bloco chave-valor sendo menor que 60 e as confianças de cada um dos blocos de palavras que compõem a chave e o valor sendo menor que 85.
```
{
"Conditions": [
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Employee Name",
"ImportantFormKeyAliases": [
"Name",
"EmployeeName"
],
"KeyValueBlockConfidenceLessThan": 60,
"WordBlockConfidenceLessThan": 85
}
},
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Pay Date",
"ImportantFormKeyAliases": [
"PayDate",
"DateOfPay",
"pay-date"
],
"KeyValueBlockConfidenceLessThan": 65,
"WordBlockConfidenceLessThan": 85
}
},
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Gross Pay",
"ImportantFormKeyAliases": [
"GrossPay",
"GrossAmount"
],
"KeyValueBlockConfidenceLessThan": 60,
"WordBlockConfidenceLessThan": 85
}
}
]
}
```
**Exemplo 2: Uso do `ImportantFormKeyConfidenceCheck`**
No exemplo a seguir, se o Amazon Textract detectar um par de valores-chave cuja confiança no bloco chave-valor for menor que 60 e menor que 90 para qualquer bloco de palavras subjacente, ele criará um loop humano. Os revisores humanos são solicitados a revisar todos os pares de chave-valor de formulário que corresponderam às comparações de valor de confiança.
```
{
"Conditions": [
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "*",
"KeyValueBlockConfidenceLessThan": 60,
"WordBlockConfidenceLessThan": 90
}
}
]
}
```
**Exemplo 3: Usar amostragem**
No exemplo a seguir, 5% das inferências resultantes de uma solicitação de `AnalyzeDocument` do Amazon Textract serão enviadas para operadores humanos para análise. Todos os pares de valores-chave detectados retornados pelo Amazon Textract são enviados aos operadores para análise.
```
{
"Conditions": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
}
]
}
```
**Exemplo 4: Uso do `MissingImportantFormKey`**
No exemplo a seguir, se o `Mailing Address` ou seu alias, `Mailing Address:`, estiver sem as chaves detectadas pelo Amazon Textract, uma análise humana será iniciada. Ao usar o modelo de tarefa de operador padrão, a interface do usuário do operador solicitará que os operadores identifiquem a chave `Mailing Address` ou `Mailing Address:` e seu valor associado.
```
{
"ConditionType": "MissingImportantFormKey",
"ConditionParameters": {
"ImportantFormKey": "Mailing Address",
"ImportantFormKeyAliases": ["Mailing Address:"]
}
}
```
**Exemplo 5: Uso da amostragem e `ImportantFormKeyConfidenceCheck` com o operador `And`**
Neste exemplo, 5% dos pares de valores-chave detectados pelo Amazon Textract cuja chave é `Pay Date`, `PayDate`, `DateOfPay` ou `pay-date`, com a confiança do bloco de chave-valor menor que 65 e com as confianças de cada um dos blocos de palavras que compõem a chave e o valor inferiores a 85, são enviados a operadores para análise.
```
{
"Conditions": [
{
"And": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
},
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Pay Date",
"ImportantFormKeyAliases": [
"PayDate",
"DateOfPay",
"pay-date"
],
"KeyValueBlockConfidenceLessThan": 65,
"WordBlockConfidenceLessThan": 85
}
}
]
}
]
}
```
**Exemplo 6: Uso da amostragem e `ImportantFormKeyConfidenceCheck` com o operador `And`**
Use este exemplo para configurar seu fluxo de trabalho de análise humana para sempre enviar inferências de baixa confiança de um par chave-valor especificado para análise humana e amostrar a inferência de alta confiança de um par chave-valor a uma taxa especificada.
No exemplo a seguir, uma análise humana é iniciada de uma das seguintes maneiras:
+ Pares de valores-chave detectados cuja chave é `Pay Date`, `PayDate`, `DateOfPay` ou `pay-date`, com confianças de chave-valor e bloco de palavras inferiores a 60, serão enviados para análise humana. Somente a chave de formulário `Pay Date` (e seus aliases) e os valores associados são enviados aos operadores para análise.
+ 5% dos pares de chave-valor detectados cuja chave é `Pay Date`, `PayDate`, `DateOfPay` ou `pay-date`, com confianças de chave-valor e bloco de palavras maiores que 90, serão enviados para análise humana. Somente a chave de formulário `Pay Date` (e seus aliases) e os valores associados são enviados aos operadores para análise.
```
{
"Conditions": [
{
"Or": [
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Pay Date",
"ImportantFormKeyAliases": [
"PayDate",
"DateOfPay",
"pay-date"
],
"KeyValueBlockConfidenceLessThan": 60,
"WordBlockConfidenceLessThan": 60
}
},
{
"And": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
},
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Pay Date",
"ImportantFormKeyAliases": [
"PayDate",
"DateOfPay",
"pay-date"
],
"KeyValueBlockConfidenceLessThan": 90
"WordBlockConfidenceGreaterThan": 90
}
}
]
}
]
}
]
}
```
**Exemplo 7: Uso da amostragem e `ImportantFormKeyConfidenceCheck` com o operador `Or`**
No exemplo a seguir, a operação `AnalyzeDocument` do Amazon Textract retorna um par de valores-chave cuja chave é `Pay Date`, `PayDate`, `DateOfPay` ou `pay-date`, com a confiança do bloco de chave-valor inferior a 65 e as confianças de cada um dos blocos de palavras que compõem a chave e o valor inferiores a 85. Além disso, 5% de todos os outros formulários iniciam um loop humano. Para cada formulário escolhido aleatoriamente, todos os pares de chave-valor detectados para esse formulário serão enviados para humanos para análise.
```
{
"Conditions": [
{
"Or": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
},
{
"ConditionType": "ImportantFormKeyConfidenceCheck",
"ConditionParameters": {
"ImportantFormKey": "Pay Date",
"ImportantFormKeyAliases": [
"PayDate",
"DateOfPay",
"pay-date"
],
"KeyValueBlockConfidenceLessThan": 65,
"WordBlockConfidenceLessThan": 85
}
}
}
]
}
]
}
```
# Uso do esquema JSON de condições de ativação de loop humano com o Amazon Rekognition
Quando usada com o Amazon A2I, a operação `DetectModerationLabels` do Amazon Rekognition oferece suporte para as seguintes entradas nos parâmetros `ConditionType`:
+ `ModerationLabelConfidenceCheck` – use este tipo de condição para criar um loop humano quando a confiança de inferência for baixa para um ou mais rótulos especificados.
+ `Sampling` – use esta condição para especificar uma porcentagem de todas as inferências a serem enviadas para humanos para análise. Use essa condição para fazer o seguinte:
+ Auditar seu modelo de ML amostrando aleatoriamente todas as inferências do seu modelo e enviando uma porcentagem especificada para humanos para análise.
+ Usando a condição `ModerationLabelConfidenceCheck`, faça uma amostragem aleatória de uma porcentagem das inferências que atenderam às condições especificadas em `ModerationLabelConfidenceCheck` para iniciar um loop humano e enviar apenas a porcentagem especificada a humanos para análise.
**nota**
Se você enviar a mesma solicitação para `DetectModerationLabels` várias vezes, o resultado da `Sampling` não será alterado para a inferência dessa entrada. Por exemplo, se você fizer uma solicitação `DetectModerationLabels` uma vez, e a `Sampling` não iniciar um loop humano, as solicitações subsequentes para `DetectModerationLabels` com a mesma configuração não iniciarão um loop humano.
Ao criar uma definição de fluxo, se você usar o modelo padrão de tarefa do trabalhador fornecido na seção **Fluxos de trabalho de revisão humana** do console da Amazon SageMaker AI, as inferências enviadas para análise humana por essas condições de ativação serão incluídas na interface do usuário do trabalhador quando um trabalhador abrir sua tarefa. Se você usar um modelo de tarefa de operador personalizado, será necessário incluir o elemento HTML `` personalizado para acessar essas inferências. Para obter um exemplo de um modelo personalizado que usa esse elemento HTML, consulte [Exemplo de modelo personalizado do Amazon Rekognition](a2i-custom-templates.md#a2i-custom-templates-rekognition-sample).
## Entradas de `ModerationLabelConfidenceCheck`
Para o `ModerationLabelConfidenceCheck` `ConditionType`, os seguintes `ConditionParameters` são compatíveis:
+ `ModerationLabelName`— O nome exato (com distinção entre maiúsculas e minúsculas) de um [ModerationLabel](https://docs.aws.amazon.com/rekognition/latest/dg/API_ModerationLabel.html)detectado pela operação do Amazon Rekognition. `DetectModerationLabels` É possível especificar o valor especial genérico (\$1) para indicar qualquer rótulo de moderação.
+ `ConfidenceEquals`
+ `ConfidenceLessThan`
+ `ConfidenceLessThanEquals`
+ `ConfidenceGreaterThan`
+ `ConfidenceGreaterThanEquals`
Quando você usa o `ModerationLabelConfidenceCheck` `ConditionType`, o Amazon A2I envia inferências de rótulo para os rótulos especificados por você em `ModerationLabelName` para análise humana.
## Entradas de amostragem
O `Sampling` `ConditionType` oferece suporte para `RandomSamplingPercentage` `ConditionParameters`. A entrada para o parâmetro `RandomSamplingPercentage` deve ser um número real entre 0,01 e 100. Esse número representa a porcentagem de inferências qualificadas para uma análise humana que são enviadas para humanos para análise. Se você usar a condição `Sampling` sem qualquer outra condição, esse número representará a porcentagem de todas as inferências que resultam de uma única solicitação `DetectModerationLabel` enviadas para humanos para análise.
## Exemplos
**Exemplo 1: Use `ModerationLabelConfidenceCheck` com o operador `And`**
O exemplo a seguir de uma condição `HumanLoopActivationConditions` inicia um loop humano quando uma ou mais das seguintes condições forem atendidas:
+ O Amazon Rekognition detecta o rótulo de moderação `Graphic Male Nudity` com uma confiança entre 90 e 99.
+ O Amazon Rekognition detecta o rótulo de moderação `Graphic Female Nudity` com uma confiança entre 80 e 99.
Observe o uso dos operadores lógicos `Or` e `And` para modelar essa lógica.
Embora qualquer uma das duas condições sob o operador `Or` precise ser avaliada como `true` para que um loop humano seja criado, o Amazon Augmented AI avalia todas as condições. Os revisores humanos precisarão revisar os rótulos de moderação de todas as condições que foram avaliadas como `true`.
```
{
"Conditions": [{
"Or": [{
"And": [{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Male Nudity",
"ConfidenceLessThanEquals": 99
}
},
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Male Nudity",
"ConfidenceGreaterThanEquals": 90
}
}
]
},
{
"And": [{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Female Nudity",
"ConfidenceLessThanEquals": 99
}
},
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Female Nudity",
"ConfidenceGreaterThanEquals": 80
}
}
]
}
]
}]
}
```
**Exemplo 2: Use `ModerationLabelConfidenceCheck` com o valor genérico (\$1) **
No exemplo a seguir, se qualquer rótulo de moderação for detectado com uma confiança maior ou igual a 75, será iniciado um loop humano. Os analisadores humanos devem analisar todos os rótulos de moderação com pontuações de confiança maiores ou iguais a 75.
```
{
"Conditions": [
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "*",
"ConfidenceGreaterThanEquals": 75
}
}
]
}
```
**Exemplo 3: Usar amostragem**
No exemplo a seguir, 5% das inferências do Amazon Rekognition de uma solicitação de `DetectModerationLabels` serão enviadas a operadores humanos. Ao usar o modelo de tarefa de trabalho padrão fornecido no console de SageMaker IA, todos os rótulos de moderação retornados pelo Amazon Rekognition são enviados aos trabalhadores para análise.
```
{
"Conditions": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
}
]
}
```
**Exemplo 4: Uso da amostragem e `ModerationLabelConfidenceCheck` com o operador `And`**
Neste exemplo, 5% das inferências do Amazon Rekognition do rótulo de moderação `Graphic Male Nudity` com uma confiança superior a 50 serão enviados para operadores para análise. Ao usar o modelo de tarefa de trabalho padrão fornecido no console de SageMaker IA, somente as inferências do `Graphic Male Nudity` rótulo são enviadas aos trabalhadores para análise.
```
{
"Conditions": [
{
"And": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
},
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Male Nudity",
"ConfidenceGreaterThan": 50
}
}
]
}
]
}
```
**Exemplo 5: Uso da amostragem e `ModerationLabelConfidenceCheck` com o operador `And`**
Use este exemplo para configurar seu fluxo de trabalho de análise humana para sempre enviar inferências de baixa confiança de um rótulo especificado para análise humana e inferências de alta confiança de um rótulo a uma taxa especificada.
No exemplo a seguir, uma análise humana é iniciada de uma das seguintes maneiras:
+ As inferências para o rótulo de moderação `Graphic Male Nudity` com confianças inferiores a 60 são sempre enviadas para análise humana. Somente o rótulo `Graphic Male Nudity` é enviado aos operadores para análise.
+ 5% de todas as inferências do rótulo de moderação `Graphic Male Nudity` com pontuações de confiança superiores a 90 serão enviadas para análise humana. Somente o rótulo `Graphic Male Nudity` é enviado aos operadores para análise.
```
{
"Conditions": [
{
"Or": [
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Male Nudity",
"ConfidenceLessThan": 60
}
},
{
"And": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
},
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Male Nudity",
"ConfidenceGreaterThan": 90
}
}
]
}
]
}
]
}
```
**Exemplo 6: Uso da amostragem e `ModerationLabelConfidenceCheck` com o operador `Or`**
No exemplo a seguir, um loop humano será criado se a resposta de inferência do Amazon Rekognition contiver o rótulo “Graphic Male Nudity” (Nudez masculina gráfica) com confiança de inferência maior que 50. Além disso, 5% de todas as outras inferências iniciam um loop humano.
```
{
"Conditions": [
{
"Or": [
{
"ConditionType": "Sampling",
"ConditionParameters": {
"RandomSamplingPercentage": 5
}
},
{
"ConditionType": "ModerationLabelConfidenceCheck",
"ConditionParameters": {
"ModerationLabelName": "Graphic Male Nudity",
"ConfidenceGreaterThan": 50
}
}
]
}
]
}
```