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

# Tutorial: Conceitos básicos da API do Amazon A2I
<a name="a2i-get-started-api"></a>

Este tutorial explica as operações de API que você pode usar para começar a usar o Amazon A2I. 

Para usar um Jupyter Notebook para executar essas operações, selecione um Jupyter Notebook [Casos de uso e exemplos usando o Amazon A2I](a2i-task-types-general.md) e use-o [Use a instância do SageMaker notebook com o Amazon A2I Jupyter Notebook](a2i-task-types-general.md#a2i-task-types-notebook-demo) para aprender a usá-lo em uma SageMaker instância de notebook AI.

Para saber mais sobre as operações de API que você pode usar com o Amazon A2I, consulte [Usar APIs no Amazon Augmented AI](a2i-api-references.md).

## Crie uma equipe de trabalho privada
<a name="a2i-get-started-api-create-work-team"></a>

Você pode criar uma equipe de trabalho privada e se adicionar como operador para poder visualizar o Amazon A2I. 

Se você não estiver familiarizado com o Amazon Cognito, recomendamos que você use o console de SageMaker IA para criar uma força de trabalho privada e se adicionar como trabalhador particular. Para instruções, consulte [Etapa 1: Criar uma equipe de trabalho](a2i-get-started-console.md#a2i-get-started-console-step-1).

Se você estiver familiarizado com o Amazon Cognito, poderá usar as instruções a seguir para criar uma equipe de trabalho privada usando a SageMaker API. Depois de criar uma equipe de trabalho, anote o ARN () `WorkteamArn` da equipe de trabalho.

Para saber mais sobre a força de trabalho privada e outras configurações disponíveis, consulte [Força de trabalho privada](sms-workforce-private.md).

**Criando uma força de trabalho privada**  
Se você não criou uma força de trabalho privada, pode fazer isso usando um grupo de usuários do [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html). Verifique se você se adicionou a esse grupo de usuários. Você pode criar uma equipe de trabalho privada usando a AWS SDK para Python (Boto3) `[create\_workforce](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_workforce)` função. Para outros idiomas específicos SDKs, consulte a lista em. [CreateWorkforce](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateWorkforce.html#API_CreateWorkforce_SeeAlso)

```
    
    response = client.create_workforce(
        CognitoConfig={
            "UserPool": "{{Pool_ID}}",
            "ClientId": "{{app-client-id}}"
        },
        WorkforceName="{{workforce-name}}"
    )
```

**Crie uma equipe de trabalho privada**  
Depois de criar uma força de trabalho privada na AWS região para configurar e iniciar seu ciclo humano, você pode criar uma equipe de trabalho privada usando a AWS SDK para Python (Boto3) `[create\_workteam](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_workteam)` função. Para outros idiomas específicos SDKs, consulte a lista em. `[CreateWorkteam](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateWorkteam.html#API_CreateWorkteam_SeeAlso)`

```
    response = client.create_workteam(
        WorkteamName="{{work-team-name}}",
        WorkforceName= "{{workforce-name}}",
        MemberDefinitions=[
            {
                "CognitoMemberDefinition": {
                    "UserPool": "{{<aws-region>_ID}}",
                    "UserGroup": "{{user-group}}",
                    "ClientId": "{{app-client-id}}"
                },
            }
        ]
    )
```

Acesse o ARN da sua equipe de trabalho da seguinte forma:

```
    workteamArn = response["WorkteamArn"]
```

**Liste equipes de trabalho privadas em sua conta**  
Se você já criou uma equipe de trabalho privada, você pode listar todas as equipes de trabalho em uma determinada AWS região em sua conta usando a AWS SDK para Python (Boto3) `[list\_workteams](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.list_workteams)` função. Para outros idiomas específicos SDKs, consulte a lista em. `[ListWorkteams](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListWorkteams.html#API_ListWorkteams_SeeAlso)` 

```
    response = client.list_workteams()
```

Se você tiver várias equipes de trabalho em sua conta, talvez queira usar `MaxResults`, `SortBy` e `NameContains` para filtrar seus resultados.

## Criar um fluxo de trabalho de análise humana
<a name="a2i-get-started-api-create-human-review-workflow"></a>

Você pode criar um fluxo de trabalho de revisão humana usando a operação `[CreateFlowDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html)` do Amazon A2I. Antes de criar seu fluxo de trabalho de revisão humana, você precisa criar uma UI de tarefa humana. Você pode fazer isso com a operação `[CreateHumanTaskUi](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateHumanTaskUi.html)`.

Se você estiver usando o Amazon A2I com as integrações Amazon Textract ou Amazon Rekognition, você pode especificar as condições de ativação usando um JSON. 

### Crie uma interface de usuário de tarefas humanas
<a name="a2i-get-started-api-worker-task-template"></a>

Se você estiver criando um fluxo de trabalho de revisão humana para ser usado com as integrações do Amazon Textract ou do Amazon Rekognition, precisará usar e modificar o modelo de tarefa de operador predefinido. Para todas as integrações personalizadas, você pode usar seu próprio modelo de tarefa de operador personalizado. Use a tabela a seguir para aprender como criar uma interface de usuário de tarefa humana usando um modelo de tarefa de trabalho para as duas integrações integradas. Substitua o modelo pelo seu para personalizar essa solicitação. 

------
#### [ Amazon Textract – Key-value pair extraction ]

Para saber mais sobre este modelo, consulte [Exemplo de modelo personalizado do Amazon Textract](a2i-custom-templates.md#a2i-custom-templates-textract-sample).

```
{{template}} = r"""
<script src="https://assets.crowd.aws/crowd-html-elements.js"></script>
{% capture s3_uri %}http://s3.amazonaws.com/{{ task.input.aiServiceRequest.document.s3Object.bucket }}/{{ task.input.aiServiceRequest.document.s3Object.name }}{% endcapture %}
<crowd-form>
  <crowd-textract-analyze-document 
      src="{{ s3_uri | grant_read_access }}" 
      initial-value="{{ task.input.selectedAiServiceResponse.blocks }}" 
      header="Review the key-value pairs listed on the right and correct them if they don"t match the following document." 
      no-key-edit="" 
      no-geometry-edit="" 
      keys="{{ task.input.humanLoopContext.importantFormKeys }}" 
      block-types='["KEY_VALUE_SET"]'>
    <short-instructions header="Instructions">
        <p>Click on a key-value block to highlight the corresponding key-value pair in the document.
        </p><p><br></p>
        <p>If it is a valid key-value pair, review the content for the value. If the content is incorrect, correct it.
        </p><p><br></p>
        <p>The text of the value is incorrect, correct it.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/correct-value-text.png">
        </p><p><br></p>
        <p>A wrong value is identified, correct it.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/correct-value.png">
        </p><p><br></p>
        <p>If it is not a valid key-value relationship, choose No.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/not-a-key-value-pair.png">
        </p><p><br></p>
        <p>If you can’t find the key in the document, choose Key not found.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/key-is-not-found.png">
        </p><p><br></p>
        <p>If the content of a field is empty, choose Value is blank.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/value-is-blank.png">
        </p><p><br></p>
        <p><strong>Examples</strong></p>
        <p>Key and value are often displayed next or below to each other.
        </p><p><br></p>
        <p>Key and value displayed in one line.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/sample-key-value-pair-1.png">
        </p><p><br></p>
        <p>Key and value displayed in two lines.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/sample-key-value-pair-2.png">
        </p><p><br></p>
        <p>If the content of the value has multiple lines, enter all the text without line break. 
        Include all value text even if it extends beyond the highlight box.</p>
        <p><img src="https://assets.crowd.aws/images/a2i-console/multiple-lines.png"></p>
    </short-instructions>
    <full-instructions header="Instructions"></full-instructions>
  </crowd-textract-analyze-document>
</crowd-form>
"""
```

------
#### [ Amazon Rekognition – Image moderation ]

Para saber mais sobre este modelo, consulte [Exemplo de modelo personalizado do Amazon Rekognition](a2i-custom-templates.md#a2i-custom-templates-rekognition-sample).

```
{{template}} = r"""
<script src="https://assets.crowd.aws/crowd-html-elements.js"></script>
{% capture s3_uri %}http://s3.amazonaws.com/{{ task.input.aiServiceRequest.image.s3Object.bucket }}/{{ task.input.aiServiceRequest.image.s3Object.name }}{% endcapture %}

<crowd-form>
  <crowd-rekognition-detect-moderation-labels
    categories='[
      {% for label in task.input.selectedAiServiceResponse.moderationLabels %}
        {
          name: "{{ label.name }}",
          parentName: "{{ label.parentName }}",
        },
      {% endfor %}
    ]'
    src="{{ s3_uri | grant_read_access }}"
    header="Review the image and choose all applicable categories."
  >
    <short-instructions header="Instructions">
      <style>
        .instructions {
          white-space: pre-wrap;
        }
      </style>
      <p class="instructions">Review the image and choose all applicable categories.
If no categories apply, choose None.

<b>Nudity</b>
Visuals depicting nude male or female person or persons

<b>Partial Nudity</b>
Visuals depicting covered up nudity, for example using hands or pose

<b>Revealing Clothes</b>
Visuals depicting revealing clothes and poses

<b>Physical Violence</b>
Visuals depicting violent physical assault, such as kicking or punching

<b>Weapon Violence</b>
Visuals depicting violence using weapons like firearms or blades, such as shooting

<b>Weapons</b>
Visuals depicting weapons like firearms and blades
    </short-instructions>

    <full-instructions header="Instructions"></full-instructions>
  </crowd-rekognition-detect-moderation-labels>
</crowd-form>"""
```

------
#### [ Custom Integration ]

Veja a seguir um exemplo de modelo que pode ser usado em uma integração personalizada. Esse modelo é usado neste [caderno](https://github.com/aws-samples/amazon-a2i-sample-jupyter-notebooks/blob/master/Amazon%20Augmented%20AI%20(A2I)%20and%20Comprehend%20DetectSentiment.ipynb), demonstrando uma integração personalizada com o Amazon Comprehend.

```
{{template}} = r"""
<script src="https://assets.crowd.aws/crowd-html-elements.js"></script>

<crowd-form>
    <crowd-classifier
      name="sentiment"
      categories='["Positive", "Negative", "Neutral", "Mixed"]'
      initial-value="{{ task.input.initialValue }}"
      header="What sentiment does this text convey?"
    >
      <classification-target>
        {{ task.input.taskObject }}
      </classification-target>
      
      <full-instructions header="Sentiment Analysis Instructions">
        <p><strong>Positive</strong> sentiment include: joy, excitement, delight</p>
        <p><strong>Negative</strong> sentiment include: anger, sarcasm, anxiety</p>
        <p><strong>Neutral</strong>: neither positive or negative, such as stating a fact</p>
        <p><strong>Mixed</strong>: when the sentiment is mixed</p>
      </full-instructions>

      <short-instructions>
       Choose the primary sentiment that is expressed by the text. 
      </short-instructions>
    </crowd-classifier>
</crowd-form>
"""
```

------

Usando o modelo especificado acima, você pode criar um modelo usando a AWS SDK para Python (Boto3) `[create\_human\_task\_ui](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_human_task_ui)` função. Para outros idiomas específicos SDKs, consulte a lista em. `[CreateHumanTaskUi](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateHumanTaskUi.html#API_CreateHumanTaskUi_SeeAlso)` 

```
    
    response = client.create_human_task_ui(
        HumanTaskUiName="{{human-task-ui-name}}",
        UiTemplate={
            "Content": {{template}}
        }
    )
```

Esse elemento de resposta contém o ARN da interface de usuário da tarefa humana. Salve isso da seguinte forma:

```
    humanTaskUiArn = response["HumanTaskUiArn"]
```

### Crie JSON para especificar as condições de ativação
<a name="a2i-get-started-api-activation-conditions"></a>

Para as integrações integradas do Amazon Textract e do Amazon Rekognition, você pode salvar as condições de ativação em um objeto JSON e usá-las em sua solicitação `CreateFlowDefinition`. 

Em seguida, selecione uma guia para ver exemplos de condições de ativação que você pode usar para essas integrações integradas. Para obter informações adicionais sobre as opções de condição de ativação, consulte [Esquema JSON para condições de ativação de loop humano no Amazon Augmented AI](a2i-human-fallback-conditions-json-schema.md).

------
#### [ Amazon Textract – Key-value pair extraction ]

Este exemplo especifica condições para chaves específicas (como `Mail address`) no documento. Se a confiança do Amazon Textract estiver fora dos limites definidos aqui, o documento será enviado a para análise humana, com as chaves específicas que iniciaram o ciclo humano enviadas ao operador.

```
      import json  

      humanLoopActivationConditions = json.dumps(
        {
            "Conditions": [
                {
                  "Or": [
                    
                    {
                        "ConditionType": "ImportantFormKeyConfidenceCheck",
                        "ConditionParameters": {
                            "ImportantFormKey": "Mail address",
                            "ImportantFormKeyAliases": ["Mail Address:","Mail address:", "Mailing Add:","Mailing Addresses"],
                            "KeyValueBlockConfidenceLessThan": 100,
                            "WordBlockConfidenceLessThan": 100
                        }
                    },
                    {
                        "ConditionType": "MissingImportantFormKey",
                        "ConditionParameters": {
                            "ImportantFormKey": "Mail address",
                            "ImportantFormKeyAliases": ["Mail Address:","Mail address:","Mailing Add:","Mailing Addresses"]
                        }
                    },
                    {
                        "ConditionType": "ImportantFormKeyConfidenceCheck",
                        "ConditionParameters": {
                            "ImportantFormKey": "Phone Number",
                            "ImportantFormKeyAliases": ["Phone number:", "Phone No.:", "Number:"],
                            "KeyValueBlockConfidenceLessThan": 100,
                            "WordBlockConfidenceLessThan": 100
                        }
                    },
                    {
                      "ConditionType": "ImportantFormKeyConfidenceCheck",
                      "ConditionParameters": {
                        "ImportantFormKey": "*",
                        "KeyValueBlockConfidenceLessThan": 100,
                        "WordBlockConfidenceLessThan": 100
                      }
                    },
                    {
                      "ConditionType": "ImportantFormKeyConfidenceCheck",
                      "ConditionParameters": {
                        "ImportantFormKey": "*",
                        "KeyValueBlockConfidenceGreaterThan": 0,
                        "WordBlockConfidenceGreaterThan": 0
                      }
                    }
            ]
        }
            ]
        }
    )
```

------
#### [ Amazon Rekognition – Image moderation ]

As condições de ativação do loop humano usadas aqui são adaptadas à moderação de conteúdo do Amazon Rekognition; elas se baseiam nos limites de confiança dos rótulos e dos rótulos de moderação `Suggestive` e `Female Swimwear Or Underwear`.

```
        import json  

        humanLoopActivationConditions = json.dumps(
        {
            "Conditions": [
                {
                  "Or": [
                    {
                        "ConditionType": "ModerationLabelConfidenceCheck",
                        "ConditionParameters": {
                            "ModerationLabelName": "Suggestive",
                            "ConfidenceLessThan": 98
                        }
                    },
                    {
                        "ConditionType": "ModerationLabelConfidenceCheck",
                        "ConditionParameters": {
                            "ModerationLabelName": "Female Swimwear Or Underwear",
                            "ConfidenceGreaterThan": 98
                        }
                    }
                  ]
               }
            ]
        }
    )
```

------

### Criar um fluxo de trabalho de análise humana
<a name="a2i-get-started-api-flow-definition"></a>

Esta seção fornece um exemplo da `CreateFlowDefinition` AWS SDK para Python (Boto3) solicitação usando os recursos criados nas seções anteriores. Para outros idiomas específicos SDKs, consulte a lista em. [CreateFlowDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFlowDefinition.html#API_CreateFlowDefinition_SeeAlso) Use as guias na tabela a seguir para ver as solicitações para criar um fluxo de trabalho de revisão humana para as integrações integradas do Amazon Textract e do Amazon Rekognition.

------
#### [ Amazon Textract – Key-value pair extraction ]

Se você usar a integração integrada com o Amazon Textract, deverá especificar `"AWS/Textract/AnalyzeDocument/Forms/V1"` para `"AwsManagedHumanLoopRequestSource"` em `HumanLoopRequestSource`. 

```
    response = client.create_flow_definition(
        FlowDefinitionName="{{human-review-workflow-name}}",
        HumanLoopRequestSource={
            "AwsManagedHumanLoopRequestSource": "AWS/Textract/AnalyzeDocument/Forms/V1"
        }, 
        HumanLoopActivationConfig={
            "HumanLoopActivationConditionsConfig": {
                "HumanLoopActivationConditions": {{humanLoopActivationConditions}}
            }
        },
        HumanLoopConfig={
            "WorkteamArn": {{workteamArn}},
            "HumanTaskUiArn": {{humanTaskUiArn}},
            "TaskTitle": "{{Document entry review}}",
            "TaskDescription": "{{Review the document and instructions. Complete the task}}",
            "TaskCount": {{1}},
            "TaskAvailabilityLifetimeInSeconds": {{43200}},
            "TaskTimeLimitInSeconds": {{3600}},
            "TaskKeywords": [
                "{{document review}}",
            ],
        },
        OutputConfig={
            "S3OutputPath": "{{s3://amzn-s3-demo-bucket/prefix/}}",
        },
        RoleArn="{{arn:aws:iam::<account-number>:role/<role-name>}}",
        Tags=[
            {
                "Key": "{{string}}",
                "Value": "{{string}}"
            },
        ]
    )
```

------
#### [ Amazon Rekognition – Image moderation ]

Se você usar a integração integrada com o Amazon Rekognition deverá especificar `"AWS/Rekognition/DetectModerationLabels/Image/V3"` para `"AwsManagedHumanLoopRequestSource"` em `HumanLoopRequestSource`.

```
    response = client.create_flow_definition(
        FlowDefinitionName="{{human-review-workflow-name}}",
        HumanLoopRequestSource={
            "AwsManagedHumanLoopRequestSource": "AWS/Rekognition/DetectModerationLabels/Image/V3"
        }, 
        HumanLoopActivationConfig={
            "HumanLoopActivationConditionsConfig": {
                "HumanLoopActivationConditions": {{humanLoopActivationConditions}}
            }
        },
        HumanLoopConfig={
            "WorkteamArn": {{workteamArn}},
            "HumanTaskUiArn": {{humanTaskUiArn}},
            "TaskTitle": "{{Image content moderation}}",
            "TaskDescription": "{{Review the image and instructions. Complete the task}}",
            "TaskCount": {{1}},
            "TaskAvailabilityLifetimeInSeconds": {{43200}},
            "TaskTimeLimitInSeconds": {{3600}},
            "TaskKeywords": [
                "{{content moderation}}",
            ],
        },
        OutputConfig={
            "S3OutputPath": "{{s3://amzn-s3-demo-bucket/prefix/}}",
        },
        RoleArn="{{arn:aws:iam::<account-number>:role/<role-name>}}",
        Tags=[
            {
                "Key": "{{string}}",
                "Value": "{{string}}"
            },
        ]
    )
```

------
#### [ Custom Integration ]

Se você usa uma integração personalizada, exclua os seguintes parâmetros: `HumanLoopRequestSource`, `HumanLoopActivationConfig`.

```
    response = client.create_flow_definition(
        FlowDefinitionName="{{human-review-workflow-name}}",
        HumanLoopConfig={
            "WorkteamArn": {{workteamArn}},
            "HumanTaskUiArn": {{humanTaskUiArn}},
            "TaskTitle": "{{Image content moderation}}",
            "TaskDescription": "{{Review the image and instructions. Complete the task}}",
            "TaskCount": {{1}},
            "TaskAvailabilityLifetimeInSeconds": {{43200}},
            "TaskTimeLimitInSeconds": {{3600}},
            "TaskKeywords": [
                "{{content moderation}}",
            ],
        },
        OutputConfig={
            "S3OutputPath": "{{s3://amzn-s3-demo-bucket/prefix/}}",
        },
        RoleArn="{{arn:aws:iam::<account-number>:role/<role-name>}}",
        Tags=[
            {
                "Key": "{{string}}",
                "Value": "{{string}}"
            },
        ]
    )
```

------

Depois de criar um fluxo de trabalho de revisão humana, você pode recuperar o ARN da definição do fluxo a partir da resposta:

```
    {{humanReviewWorkflowArn}} = response["FlowDefinitionArn"]    
```

## Criar um loop humano
<a name="a2i-get-started-api-create-human-loop"></a>

A operação de API que você usa para iniciar um loop humano depende da integração do Amazon A2I que você usa. 
+ Se você usa a integração integrada do Amazon Textract, você usa a [AnalyzeDocument](https://docs.aws.amazon.com/textract/latest/dg/API_AnalyzeDocument.html)operação.
+ Se você usa a integração integrada do Amazon Rekognition, você usa a operação. [DetectModerationLabels](https://docs.aws.amazon.com/rekognition/latest/dg/API_DetectModerationLabels.html)
+ Se você usa uma integração personalizada, usa a [StartHumanLoop](https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_StartHumanLoop.html)operação. 

Selecione seu tipo de tarefa na tabela a seguir para ver exemplos de solicitações para o Amazon Textract e o Amazon Rekognition usando o AWS SDK para Python (Boto3). 

------
#### [ Amazon Textract – Key-value pair extraction ]

O exemplo a seguir usa a chamada AWS SDK para Python (Boto3) to `analyze_document` em us-west-2. Substitua o texto vermelho em itálico por seus recursos. Inclua o parâmetro [https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_HumanLoopDataAttributes.html](https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_HumanLoopDataAttributes.html) se você estiver usando a força de trabalho do Amazon Mechanical Turk. Para obter mais informações, consulte a documentação [analyze\_document](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/textract.html#Textract.Client.analyze_document) na *Referência da API AWS SDK para Python (Boto) *.

```
   response = client.analyze_document(
         Document={"S3Object": {"Bucket": "{{amzn-s3-demo-bucket}}", "Name": "{{document-name.pdf}}"},
         HumanLoopConfig={
            "FlowDefinitionArn":"{{arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name}}",
            "HumanLoopName":"{{human-loop-name}}",
            "DataAttributes" : {ContentClassifiers:[{{"FreeOfPersonallyIdentifiableInformation"}}|{{"FreeOfAdultContent"}}]}
         }
         FeatureTypes=["FORMS"]
    )
```

Os loops humanos só são criados se a confiança do Amazon Textract na tarefa de análise de documentos atender às condições de ativação que você especificou em seu fluxo de trabalho de revisão humana. Você pode verificar o elemento `response` para determinar se um loop humano foi criado. Para ver tudo incluído nessa resposta, consulte [https://docs.aws.amazon.com/textract/latest/dg/API_HumanLoopActivationOutput.html](https://docs.aws.amazon.com/textract/latest/dg/API_HumanLoopActivationOutput.html).

```
    if "HumanLoopArn" in analyzeDocumentResponse["HumanLoopActivationOutput"]:
        # A human loop has been started!
        print(f"A human loop has been started with ARN: {analyzeDocumentResponse["HumanLoopActivationOutput"]["HumanLoopArn"]}"
```

------
#### [ Amazon Rekognition – Image moderation ]

O exemplo a seguir usa a chamada AWS SDK para Python (Boto3) to `detect_moderation_labels` em us-west-2. Substitua o texto vermelho em itálico por seus recursos. Inclua o parâmetro [https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_HumanLoopDataAttributes.html](https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_HumanLoopDataAttributes.html) se você estiver usando a força de trabalho do Amazon Mechanical Turk. Para obter mais informações, consulte a documentação [detect\_moderation\_labels](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rekognition.html#Rekognition.Client.detect_moderation_labels) na *Referência da API do AWS SDK para Python (Boto) *.

```
   response = client.detect_moderation_labels(
            Image={"S3Object":{"Bucket": "{{amzn-s3-demo-bucket}}", "Name": "{{image-name.png}}"}},
            HumanLoopConfig={
               "FlowDefinitionArn":"{{arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name}}",
               "HumanLoopName":"{{human-loop-name}}",
               "DataAttributes":{ContentClassifiers:[{{"FreeOfPersonallyIdentifiableInformation"}}|{{"FreeOfAdultContent"}}]}
             }
    )
```

Os loops humanos só são criados se a confiança do Amazon Rekognition em uma tarefa de moderação de imagens atender às condições de ativação que você especificou em seu fluxo de trabalho de revisão humana. Você pode verificar o elemento `response` para determinar se um loop humano foi criado. Para ver tudo incluído nessa resposta, consulte [https://docs.aws.amazon.com/rekognition/latest/dg/API_HumanLoopActivationOutput.html](https://docs.aws.amazon.com/rekognition/latest/dg/API_HumanLoopActivationOutput.html).

```
    if "HumanLoopArn" in response["HumanLoopActivationOutput"]:
        # A human loop has been started!
        print(f"A human loop has been started with ARN: {response["HumanLoopActivationOutput"]["HumanLoopArn"]}")
```

------
#### [ Custom Integration ]

O exemplo a seguir usa a chamada AWS SDK para Python (Boto3) to `start_human_loop` em us-west-2. Substitua o texto vermelho em itálico por seus recursos. Inclua o parâmetro [https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_HumanLoopDataAttributes.html](https://docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_HumanLoopDataAttributes.html) se você estiver usando a força de trabalho do Amazon Mechanical Turk. Para obter mais informações, consulte a documentação [start\_human\_loop](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-a2i-runtime.html#AugmentedAIRuntime.Client.start_human_loop) na *Referência da API do AWS SDK para Python (Boto) *.

```
   response = client.start_human_loop(
        HumanLoopName= "{{human-loop-name}}",
        FlowDefinitionArn= "{{arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name}}",
        HumanLoopInput={"InputContent": {{inputContentJson}}},
        DataAttributes={"ContentClassifiers":[{{"FreeOfPersonallyIdentifiableInformation"|"FreeOfAdultContent"}}]}
   )
```

Este exemplo armazena o conteúdo de entrada na variável {{`inputContentJson`}}. Suponha que o conteúdo de entrada contenha dois elementos: uma sinopse de texto e um sentimento (como `Positive`, `Negative` ou `Neutral`), e esteja formatado da seguinte forma:

```
    inputContent = {
        "initialValue": sentiment,
         "taskObject": blurb
     }
```

As teclas `initialValue` e `taskObject` devem corresponder às chaves usadas nos elementos líquidos do modelo de tarefa do operador. Consulte o modelo personalizado [Crie uma interface de usuário de tarefas humanas](#a2i-get-started-api-worker-task-template) para ver um exemplo. 

Para criar um `{{inputContentJson}}`, faça o seguinte: 

```
    import json
    
    inputContentJson = json.dumps(inputContent)
```

Um loop humano começa toda vez que você chama `start_human_loop`. Para verificar o status do seu loop humano, use [describe\_human\_loop](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-a2i-runtime.html#AugmentedAIRuntime.Client.describe_human_loop): 

```
    human_loop_info = a2i.describe_human_loop(HumanLoopName="{{human_loop_name}}")
    print(f"HumanLoop Status: {resp["HumanLoopStatus"]}")
    print(f"HumanLoop Output Destination: {resp["HumanLoopOutput"]}")
```

------