

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: analisando insights de avaliações de clientes com o Amazon Comprehend
<a name="tutorial-reviews"></a>

Este tutorial explica como usar o Amazon Comprehend [com o Amazon Simple](https://aws.amazon.com/s3/) Storage [AWS Glue](https://aws.amazon.com/glue/)Service [Amazon Athena](https://aws.amazon.com/athena/),, [e o Amazon](https://aws.amazon.com/quicksight/) Quick para obter informações valiosas sobre seus documentos. O Amazon Comprehend pode extrair sentimentos (o “clima” de um documento) e entidades (nomes de pessoas, organizações, eventos, datas, produtos, lugares, quantidades e títulos) a partir de textos não estruturados.

Por exemplo, você pode obter informações úteis a partir de avaliações de clientes. Neste tutorial, você analisa um conjunto de dados de amostras de avaliações de clientes sobre um livro. Você usa a análise de sentimentos do Amazon Comprehend para determinar se os clientes são positivos ou negativos em relação ao livro. Você também usa a análise de entidades do Amazon Comprehend para descobrir menções a entidades importantes, como livros ou autores relacionados. Depois de seguir este tutorial, você poderá descobrir que mais de 50% das avaliações são positivas. Você também pode descobrir que os clientes estão comparando autores e expressando interesse em outros livros clássicos.

Neste tutorial, você conseguirá fazer o seguinte:
+ Armazenar um conjunto de dados de amostras no [Amazon Simple Storage Service](https://aws.amazon.com/s3/) (Amazon S3). O Amazon Simple Storage Service é um serviço de armazenamento de objetos.
+ Use o [Amazon Comprehend](https://aws.amazon.com/comprehend/) para analisar o sentimento e as entidades nos documentos de revisão.
+ Use um [AWS Glue](https://aws.amazon.com/glue/)rastreador para armazenar os resultados da análise em um banco de dados. AWS Glue é um serviço de extração, transformação e carregamento (ETL) que permite catalogar e limpar seus dados para análise.
+ Execute [Amazon Athena](https://aws.amazon.com/athena/)consultas para limpar seus dados. Amazon Athena é um serviço de consulta interativo sem servidor.
+ Crie visualizações com seus dados no [Amazon Quick](https://aws.amazon.com/quicksight/). O Quick é uma ferramenta de business intelligence sem servidor para extrair insights de seus dados.

O diagrama mostra o fluxo de trabalho.

![\[Diagrama do fluxo de trabalho dos procedimentos do tutorial.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/tutorial-reviews-workflow.png)


**Tempo estimado para concluir este tutorial:** 1 hora

**Custo estimado:** algumas das ações deste tutorial geram cobranças na sua Conta da AWS. Para obter informações sobre as cobranças de cada um desses serviços, consulte as páginas de preços a seguir.
+ [Preços do Amazon S3](https://aws.amazon.com/s3/pricing/)
+ [Preços do Amazon Comprehend](https://aws.amazon.com/comprehend/pricing/)
+ [AWS Glue preços](https://aws.amazon.com/glue/pricing/)
+ [Definição de preços do Amazon Athena](https://aws.amazon.com/athena/pricing/)
+ [Preços rápidos](https://aws.amazon.com/quicksight/pricing/)

**Topics**
+ [Pré-requisitos](#tutorial-reviews-prereqs)
+ [Etapa 1: adicionando documentos ao Amazon S3](tutorial-reviews-add-docs.md)
+ [Etapa 2: (somente para CLI) criando um perfil do IAM para o Amazon Comprehend](tutorial-reviews-create-role.md)
+ [Etapa 3: executando trabalhos de análise em documentos no Amazon S3](tutorial-reviews-analysis.md)
+ [Etapa 4: preparar a saída do Amazon Comprehend para visualização de dados](tutorial-reviews-tables.md)
+ [Etapa 5: Visualizar a saída do Amazon Comprehend no Quick](tutorial-reviews-visualize.md)

## Pré-requisitos
<a name="tutorial-reviews-prereqs"></a>

Para concluir este tutorial, você precisará do seguinte:
+ Um Conta da AWS. Para obter informações sobre como configurar um Conta da AWS, consulte[Configurar](setting-up.md).
+ Uma entidade do IAM (usuário, grupo ou perfil). Para saber como configurar usuários e grupos para sua conta, consulte o tutorial de [Conceitos básicos](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html) no *Guia do usuário do IAM*.
+ As política de permissões a seguir a um usuário, grupo ou perfil. A política concede algumas das permissões necessárias para concluir este tutorial. O próximo pré-requisito descreve as permissões adicionais de que você precisa. 

------
#### [ JSON ]

****  

  ```
  {
    "Version":"2012-10-17",		 	 	 
    "Statement":
    [
      {
        "Sid": "VisualEditor0",
        "Effect": "Allow",
        "Action":
        [
          "comprehend:*",
          "ds:AuthorizeApplication",
          "ds:CheckAlias",
          "ds:CreateAlias",
          "ds:CreateIdentityPoolDirectory",
          "ds:DeleteDirectory",
          "ds:DescribeDirectories",
          "ds:DescribeTrusts",
          "ds:UnauthorizeApplication",
          "iam:AttachRolePolicy",
          "iam:CreatePolicy",
          "iam:CreatePolicyVersion",
          "iam:CreateRole",
          "iam:DeletePolicyVersion",
          "iam:DeleteRole",
          "iam:DetachRolePolicy",
          "iam:GetPolicy",
          "iam:GetPolicyVersion",
          "iam:GetRole",
          "iam:ListAccountAliases",
          "iam:ListAttachedRolePolicies",
          "iam:ListEntitiesForPolicy",
          "iam:ListPolicies",
          "iam:ListPolicyVersions",
          "iam:ListRoles",
          "quicksight:*",
          "s3:*",
          "tag:GetResources"
        ],
        "Resource": "*"
      },
      {
        "Action":
        [
          "iam:PassRole"
        ],
        "Effect": "Allow",
        "Resource":
        [
          "arn:aws:iam::*:role/*Comprehend*"
        ]
      }
    ]
  }
  ```

------

  Use a política anterior para criar uma política do IAM e a anexe ao grupo ou usuário. Para obter mais informações sobre como criar uma política do IAM, consulte [Criar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do usuário do IAM*. Para obter informações sobre como anexar a política do IAM, consulte [Adicionar e remover permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*.
+ Políticas gerenciadas anexadas a um grupo ou usuário do IAM. Além da política anterior, você também deve anexar as seguintes políticas AWS gerenciadas ao seu grupo ou usuário:
  + `AWSGlueConsoleFullAccess`
  + `AWSQuicksightAthenaAccess`

  Essas políticas gerenciadas dão permissão para usar AWS Glue Amazon Athena, e Quick. Para obter informações sobre como anexar a política do IAM, consulte [Adicionar e remover permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*.

# Etapa 1: adicionando documentos ao Amazon S3
<a name="tutorial-reviews-add-docs"></a>

Antes de iniciar os trabalhos de análise do Amazon Comprehend, você precisa armazenar um conjunto de dados de amostra de avaliações de clientes no Amazon Simple Storage Service (Amazon S3). O Amazon S3 hospeda seus dados em contêineres chamados buckets. O Amazon Comprehend pode analisar documentos armazenados em um bucket e enviar os resultados da análise para um bucket. Nesta etapa, você cria um bucket do S3, cria pastas de entrada e saída no bucket e carrega um conjunto de dados de amostra para o bucket.

**Topics**
+ [Pré-requisitos](#tutorial-reviews-add-docs-prereqs)
+ [Baixe os dados de amostra](#tutorial-reviews-add-docs-download)
+ [Crie um bucket do Amazon S3](#tutorial-reviews-add-docs-bucket)
+ [(Somente console) crie pastas](#tutorial-reviews-add-docs-folders)
+ [Carregue os dados de entrada](#tutorial-reviews-add-docs-upload)

## Pré-requisitos
<a name="tutorial-reviews-add-docs-prereqs"></a>

Antes de começar, revise o [Tutorial: analisando insights de avaliações de clientes com o Amazon Comprehend](tutorial-reviews.md) e conclua os pré-requisitos.

## Baixe os dados de amostra
<a name="tutorial-reviews-add-docs-download"></a>

O conjunto de dados de amostra a seguir contém avaliações da Amazon retiradas do conjunto de dados maior "Amazon reviews - Full", que foi publicado com o artigo "Character-level Convolutional Networks for Text Classification" (Xiang Zhang et al., 2015). Baixe o conjunto de dados para o computador.

**Obter os dados de amostra**

1. Baixe o arquivo zip [tutorial-reviews-data.zip](samples/tutorial-reviews-data.zip) para o seu computador.

1. Extraia o arquivo .zip em seu computador local. Há dois arquivos. O arquivo `THIRD_PARTY_LICENSES.txt` é a licença de código aberto para o conjunto de dados publicado por Xiang Zhang et al. O arquivo `amazon-reviews.csv` é o conjunto de dados que você analisa no tutorial.

## Crie um bucket do Amazon S3
<a name="tutorial-reviews-add-docs-bucket"></a>

Depois de baixar o conjunto de dados de amostra, crie um bucket do Amazon S3 para armazenar seus dados de entrada e saída. Você pode criar um bucket do S3 usando o console do Amazon S3 ou o AWS Command Line Interface (AWS CLI). 

### Crie um bucket do Amazon S3 (console)
<a name="tutorial-reviews-add-docs-bucket-console"></a>

No console do Amazon S3, você cria um bucket com um nome exclusivo em todos os AWS.

**Para criar um bucket do S3 (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Em **Buckets**, escolha **Criar bucket**.

1. Em **Nome do bucket**, insira um nome globalmente exclusivo que descreva a finalidade do bucket.

1. Em **Região**, escolha a AWS região em que você deseja criar o bucket. A região que você escolher deve oferecer suporte ao Amazon Comprehend. Para reduzir a latência, escolha a AWS região mais próxima da sua localização geográfica que seja suportada pelo Amazon Comprehend. Para obter uma lista das regiões que são compatíveis com o Amazon Comprehend, consulte a [Tabela de regiões](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) no *Guia global de infraestrutura*.

1. **Deixe as configurações padrão para **Propriedade do objeto**, **Configurações de bucket para bloquear acesso público**, **Versionamento de bucket** e Tags**.

1. Em **Criptografia padrão**, escolha **Desabilitar**. 
**dica**  
Embora este tutorial não use criptografia, talvez você queira usar criptografia ao analisar dados importantes. Para end-to-end criptografia, você pode criptografar seus dados em repouso no bucket e também ao executar trabalhos de análise. Para obter mais informações sobre criptografia com AWS, consulte [O que é AWS Key Management Service?](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) no *Guia do AWS Key Management Service desenvolvedor*.

1. Revise as configurações do bucket e escolha **Criar bucket**.

### Crie um bucket do Amazon S3 (AWS CLI)
<a name="tutorial-reviews-add-docs-bucket-cli"></a>

Depois de abrir o AWS CLI, você executa o `create-bucket` comando para criar um bucket que armazenará os dados de entrada e saída.

**Como criar um bucket do Amazon S3 (AWS CLI)**

1. Para criar seu bucket, execute o comando a seguir no AWS CLI. Substitua amzn-s3-demo-bucket por um nome para o bucket que seja exclusivo em todos os. AWS

   ```
   aws s3api create-bucket --bucket amzn-s3-demo-bucket
   ```

   Por padrão, o `create-bucket` comando cria um bucket na `us-east-1` AWS região. Para criar um bucket em uma Região da AWS diferente de `us-east-1`, adicione o parâmetro `LocationConstraint` para especificar sua Região. Por exemplo, o comando a seguir cria um bucket na Região `us-west-2`.

   ```
   aws s3api create-bucket --bucket amzn-s3-demo-bucket
   --region us-west-2 --create-bucket-configuration LocationConstraint=us-west-2
   ```

   Observe que somente algumas regiões oferecem suporte ao Amazon Comprehend. Para obter uma lista das regiões que são compatíveis com o Amazon Comprehend, consulte a [Tabela de regiões](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) no *Guia global de infraestrutura*.

1. Para garantir que o bucket foi criado com êxito, execute o comando a seguir. O comando lista todos os buckets do S3 associados à sua conta.

   ```
   aws s3 ls
   ```

## (Somente console) crie pastas
<a name="tutorial-reviews-add-docs-folders"></a>

Depois, crie duas pastas no seu bucket do S3. A primeira pasta é para seus dados de entrada. A segunda pasta é para onde o Amazon Comprehend envia os resultados da análise. Se você usa o console do Amazon S3, você precisa criar as pastas manualmente. Se você usar o AWS CLI, poderá criar pastas ao carregar o conjunto de dados de amostra ou executar um trabalho de análise. Por esse motivo, fornecemos um procedimento para criar pastas somente para usuários do console. Se você estiver usando o AWS CLI, você criará pastas dentro de [Carregue os dados de entrada](#tutorial-reviews-add-docs-upload) e dentro de [Etapa 3: executando trabalhos de análise em documentos no Amazon S3](tutorial-reviews-analysis.md).

**Para criar pastas em seu bucket do S3 (console)**

1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Em **Buckets**, escolha seu bucket na lista de buckets.

1. Na guia **Visão geral**, escolha **Criar pasta**.

1. Para o novo nome da pasta, insira `input`.

1. Para as configurações de criptografia, escolha **(Nenhuma (use as configurações do bucket)**.

1. Escolha **Salvar**.

1. Repita as etapas de 3 a 6 para criar outra pasta para a saída dos trabalhos de análise, mas na etapa 4, insira o `output` do nome da nova pasta.

## Carregue os dados de entrada
<a name="tutorial-reviews-add-docs-upload"></a>

Agora que você tem um bucket, carregue o conjunto de dados de amostra `amazon-reviews.csv`. Você pode carregar dados para buckets do S3 com o console Amazon S3 ou o AWS CLI. 

### Carregue documentos de amostra para um bucket (console)
<a name="tutorial-reviews-add-docs-upload-console"></a>

No console do Amazon S3, carregue o arquivo do conjunto de dados de amostra para a pasta de entrada.

**Par carregar os documentos de amostra (console)**

1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Em **Buckets**, escolha seu bucket na lista de buckets.

1. Escolha a pasta `input` e, em seguida, escolha **Upload**.

1. Escolha **Adicionar arquivos** e, em seguida, escolha o arquivo `amazon-reviews.csv` no seu computador.

1. Deixe as outras configurações nos valores padrão.

1. Escolha **Carregar**.

### Carregue os documentos de amostra em um bucket (AWS CLI)
<a name="tutorial-reviews-add-docs-upload-cli"></a>

Crie uma pasta de entrada em seu bucket do S3 e carregue o arquivo do conjunto de dados na nova pasta com o comando `cp`.

**Par carregar os documentos de amostra (AWS CLI)**

1. Para fazer o upload do `amazon-reviews.csv` arquivo em uma nova pasta no seu bucket, execute o AWS CLI comando a seguir. Substitua amzn-s3-demo-bucket pelo nome do seu bucket do . Ao adicionar o caminho do `/input/` no final, o Amazon S3 cria automaticamente uma nova pasta chamada `input` em seu bucket e carrega o arquivo do conjunto de dados nessa pasta.

   ```
   aws s3 cp amazon-reviews.csv s3://amzn-s3-demo-bucket/input/
   ```

1. Para garantir que o arquivo foi carregado com êxito, execute o comando a seguir. O comando lista o conteúdo da pasta `input` do seu bucket.

   ```
   aws s3 ls s3://amzn-s3-demo-bucket/input/
   ```

Agora, você tem um bucket do S3 com o arquivo `amazon-reviews.csv` em uma pasta chamada `input`. Se você usou o console, você também tem uma pasta `output` no bucket. Se você usou o AWS CLI, você criará a pasta de saída ao executar os trabalhos de análise do Amazon Comprehend.

# Etapa 2: (somente para CLI) criando um perfil do IAM para o Amazon Comprehend
<a name="tutorial-reviews-create-role"></a>

Essa etapa é necessária somente se você estiver usando o AWS Command Line Interface (AWS CLI) para concluir este tutorial. Se você estiver usando o console do Amazon Comprehend para executar os trabalhos de análise, vá para [Etapa 3: executando trabalhos de análise em documentos no Amazon S3](tutorial-reviews-analysis.md).

Para executar trabalhos de análise, o Amazon Comprehend exige acesso ao bucket do Amazon S3 que contém o conjunto de dados de amostra e conterá a saída dos trabalhos. As funções do IAM permitem que você controle as permissões de AWS serviços ou usuários. Nesta etapa, você criará um perfil do IAM para o Amazon Comprehend. Em seguida, você cria e anexa a esse perfil uma política baseada em recursos que concede ao Amazon Comprehend acesso ao seu bucket do S3. Ao final dessa etapa, o Amazon Comprehend terá as permissões necessárias para acessar seus dados de entrada, armazenar sua saída e executar trabalhos de análise de sentimentos e entidades.

Para obter mais informações sobre como usar o IAM com o Amazon Comprehend, consulte [Como o Amazon Comprehend funciona com o IAM](security_iam_service-with-iam.md).

**Topics**
+ [Pré-requisitos](#tutorial-reviews-create-role-prereqs)
+ [Criar um perfil do IAM](#tutorial-reviews-create-role-trust-policy)
+ [Anexe a política do IAM ao perfil do IAM.](#tutorial-reviews-create-role-policy)

## Pré-requisitos
<a name="tutorial-reviews-create-role-prereqs"></a>

Antes de começar, faça o seguinte:
+ Completa [Etapa 1: adicionando documentos ao Amazon S3](tutorial-reviews-add-docs.md).
+ Tenha um editor de código ou texto para salvar políticas JSON e acompanhar seus nomes de recursos da Amazon (ARNs).

## Criar um perfil do IAM
<a name="tutorial-reviews-create-role-trust-policy"></a>

Para acessar seu bucket do Amazon Simple Storage Service (Amazon S3), o Amazon Comprehend precisa assumir uma função (IAM). AWS Identity and Access Management O perfil do IAM declara o Amazon Comprehend como uma entidade confiável. Depois que o Amazon Comprehend assumir o perfil e se tornar uma entidade confiável, você poderá conceder ao bucket permissões de acesso ao Amazon Comprehend. Nesta etapa, você cria um perfil que rotula o Amazon Comprehend como uma entidade confiável. Você pode criar uma função com o console do Amazon Comprehend AWS CLI ou com o console do Amazon Comprehend. Para usar o console, vá para [Etapa 3: executando trabalhos de análise em documentos no Amazon S3](tutorial-reviews-analysis.md).

O console do Amazon Comprehend permite que você selecione perfis em que o nome do perfil contenha 'Comprehend' e em que a política de confiança inclua **comprehend.amazonaws.com**. Configure suas funções criadas pela CLI para atender a esses critérios se você quiser que o console as exiba.



**Para criar uma função do IAM para o Amazon Comprehend AWS (CLI)**

1. Salve a política de confiança a seguir como um documento JSON chamado `comprehend-trust-policy.json` em um editor de códigos ou texto em seu computador. Essa política de confiança declara o Amazon Comprehend como uma entidade confiável e permite que ele assuma um perfil do IAM.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "comprehend.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

1. Para criar a função do IAM, execute o AWS CLI comando a seguir. O comando cria um perfil do IAM chamado `AmazonComprehendServiceRole-access-role` e anexa a política de confiança a ele. Substitua `path/` pelo caminho do seu computador local até o documento JSON.

   ```
   aws iam create-role --role-name AmazonComprehendServiceRole-access-role
   --assume-role-policy-document file://path/comprehend-trust-policy.json
   ```
**dica**  
Se você receber uma mensagem de Erro ao analisar o parâmetro, o caminho para seu arquivo de política de confiança JSON provavelmente está incorreto. Forneça o caminho relativo para o arquivo com base no seu diretório inicial.

1. Copie o nome do recurso da Amazon (ARN) e salve-o em um editor de texto. O ARN tem um formato semelhante a `arn:aws:iam::123456789012:role/AmazonComprehendServiceRole-access-role`. Você precisa desse ARN para executar trabalhos de análise do Amazon Comprehend.

## Anexe a política do IAM ao perfil do IAM.
<a name="tutorial-reviews-create-role-policy"></a>

Para acessar seu bucket do Amazon S3, o Amazon Comprehend precisa de permissões para listar, ler e gravar. Para dar ao Amazon Comprehend as permissões necessárias, crie e anexe uma política do IAM para um perfil do IAM. A política do IAM permite que o Amazon Comprehend recupere os dados de entrada do seu bucket e grave os resultados da análise no bucket. Depois de criar a política, anexe-a ao seu perfil do IAM.

**Para criar uma política do IAM (AWS CLI)**

1. Salve a seguinte política localmente como um documento JSON chamado `comprehend-access-policy.json`. Ela concede ao Amazon Comprehend acesso ao bucket do S3 especificado.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": [
                   "arn:aws:s3:::amzn-s3-demo-bucket/*"
               ],
               "Effect": "Allow"
           },
           {
               "Action": [
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::amzn-s3-demo-bucket"
               ],
               "Effect": "Allow"
           },
           {
               "Action": [
                   "s3:PutObject"
               ],
               "Resource": [
                   "arn:aws:s3:::amzn-s3-demo-bucket/*"
               ],
               "Effect": "Allow"
           }
       ]
   }
   ```

------

1. Para criar a política de acesso ao bucket do S3, execute o AWS CLI comando a seguir. Substitua `path/` pelo caminho do seu computador local até o documento JSON.

   ```
   aws iam create-policy --policy-name comprehend-access-policy
   --policy-document file://path/comprehend-access-policy.json
   ```

1. Copie o ARN da política de acesso e salve-o em um editor de texto. O ARN tem um formato semelhante a `arn:aws:iam::123456789012:policy/comprehend-access-policy`. Você precisa desse ARN para vincular sua política de acesso ao seu perfil do IAM.

**Para anexar a política do IAM ao perfil do IAM (AWS CLI)**
+ Execute o comando a seguir. Substitua `policy-arn` pelo ARN da política de acesso que você copiou na etapa anterior.

  ```
  aws iam attach-role-policy --policy-arn policy-arn
  --role-name AmazonComprehendServiceRole-access-role
  ```

Agora você tem um perfil do IAM chamado `AmazonComprehendServiceRole-access-role` que tem uma política de confiança para o Amazon Comprehend e uma política de acesso que concede ao Amazon Comprehend acesso ao seu bucket do S3. O ARN do perfil do IAM também será copiado para um editor de texto.

# Etapa 3: executando trabalhos de análise em documentos no Amazon S3
<a name="tutorial-reviews-analysis"></a>

Depois de armazenar os dados no Amazon S3, você pode começar a executar trabalhos de análise no Amazon Comprehend. Um trabalho de análise de *sentimentos* determina o clima geral de um documento (positivo, negativo, neutro ou misto). Um trabalho de análise de *entidades* extrai os nomes de objetos do mundo real de um documento. Esses objetos incluem pessoas, lugares, títulos, eventos, datas, quantidades, produtos e organizações. Nesta etapa, você executa dois trabalhos de análise do Amazon Comprehend para extrair o sentimento e as entidades do conjunto de dados de amostra.

**Topics**
+ [Pré-requisitos](#tutorial-reviews-analysis-prereqs)
+ [Analise sentimentos e entidades](#tutorial-reviews-analysis-jobs)

## Pré-requisitos
<a name="tutorial-reviews-analysis-prereqs"></a>

Antes de começar, faça o seguinte:
+ Completa [Etapa 1: adicionando documentos ao Amazon S3](tutorial-reviews-add-docs.md).
+ (Opcional) Se você estiver usando o AWS CLI, preencha [Etapa 2: (somente para CLI) criando um perfil do IAM para o Amazon Comprehend](tutorial-reviews-create-role.md) e tenha seu ARN de função do IAM pronto.

## Analise sentimentos e entidades
<a name="tutorial-reviews-analysis-jobs"></a>

O primeiro trabalho que você executa analisa o sentimento de cada avaliação do cliente no conjunto de dados de amostra. O segundo trabalho extrai as entidades em cada avaliação do cliente. Você pode realizar trabalhos de análise do Amazon Comprehend usando o console do Amazon Comprehend ou o AWS CLI. 

**dica**  
Verifique se você está em uma AWS região que ofereça suporte ao Amazon Comprehend. Para obter mais informações, consulte a [Tabela de regiões](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) no *Guia Global de Infraestrutura*.

### Analise sentimentos e entidades (console)
<a name="tutorial-reviews-analysis-jobs-console"></a>

Ao usar o console do Amazon Comprehend, você cria um trabalho por vez. Você precisa repetir as etapas a seguir para executar um trabalho de análise de sentimentos e de entidades. Observe que, para o primeiro trabalho, você cria um perfil do IAM, mas para o segundo trabalho, você pode reutilizar o perfil do IAM do primeiro trabalho. Você pode reutilizar o perfil do IAM, desde que use o mesmo bucket e pastas do S3.

**Para executar trabalhos de análise de sentimentos e entidades (console)**

1. Certifique-se de que você esteja na mesma Região em que você criou o bucket do Amazon Simple Storage Service (Amazon S3). Se você estiver em outra região, na barra de navegação, escolha a AWS região em que você criou seu bucket do S3 no **seletor de regiões**.

1. Abra o console do Amazon Comprehend em [https://console.aws.amazon.com/comprehend/](https://console.aws.amazon.com/comprehend/)

1. Escolha **Executar o Amazon Comprehend)**.

1. No painel de navegação, escolha **Trabalhos de análise**.

1. Escolha **Criar trabalho**.

1. Na seção **Configurações de trabalho**, faça o seguinte:

   1. Em **Nome**, insira `reviews-sentiment-analysis`.

   1. Em **Tipo de análise**, escolha **Sentiment**.

   1. Em **Idioma**, escolha **Inglês**.

   1. Deixe a configuração de **Criptografia do trabalho** desabilitada.

1. Na seção **Dados de entrada**, faça o seguinte:

   1. Em **Fonte de dados**, escolha **Meus documentos**.

   1. Para a **Local do S3**, escolha **Procurar no S3** e, em seguida, escolha seu bucket na lista de buckets.

   1. Em seu bucket do S3, em **Objetos**, escolha sua pasta `input`.

   1. Na pasta `input`, escolha o conjunto de dados de amostra `amazon-reviews.csv` e, em seguida, **Escolher**.

   1. Em **Formato de entrada**, escolha **Um documento por linha**.

1. Na seção **Dados de saída**, faça o seguinte:

   1. Para a **Local do S3**, escolha **Procurar no S3** e, em seguida, escolha seu bucket na lista de buckets.

   1. Em seu bucket do S3, em **Objetos**, escolha a pasta `output` e, em seguida, **Escolher**.

   1. Deixe a **Criptografia** desabilitada.

1. Na seção **Permissões de acesso**, faça o seguinte:

   1. Em **Perfil do IAM)**, escolha **Criar um perfil do IAM)**.

   1. Em **Permissões para acessar**, escolha **Buckets do S3 de entrada e saída**.

   1. Em **Sufixo do nome**, insira `comprehend-access-role`. Esse perfil fornece acesso ao bucket do Amazon S3.

1. Escolha **Criar trabalho**.

1. Repita as etapas de 1 a 10 para criar um trabalho de análise de entidades. Faça as seguintes alterações em:

   1. Em **Configurações de trabalho**, em **Nome**, insira `reviews-entities-analysis`.

   1. Em **Configurações de trabalho**, em **Tipo de análise**, escolha **Entidades**.

   1. Em **Permissões de acesso**, escolha **Utilizar um perfil do IAM existente**. Em **Nome do perfil**, escolha `AmazonComprehendServiceRole-comprehend-access-role` (essa é a mesmo perfil que você criou para o trabalho de sentimento).

### Analise sentimentos e entidades (AWS CLI)
<a name="tutorial-reviews-analysis-jobs-cli"></a>

Você usa os `start-sentiment-detection-job` e os comandos `start-entities-detection-job` para executar trabalhos de análise de sentimentos e entidades. Depois de executar cada comando, ele AWS CLI mostra um objeto JSON com um `JobId` valor que permite acessar detalhes sobre o trabalho, incluindo a localização de saída do S3.

**Para executar trabalhos de análise de sentimentos e entidades (AWS CLI)**

1. Inicie um trabalho de análise de sentimentos executando o comando a seguir no AWS CLI. Substitua `arn:aws:iam::123456789012:role/comprehend-access-role` pelo ARN do perfil do IAM que você copiou anteriormente para um editor de texto. Se sua AWS CLI região padrão for diferente da região na qual você criou seu bucket do Amazon S3, inclua o `--region` parâmetro e `us-east-1` substitua pela região em que seu bucket reside.

   ```
   aws comprehend start-sentiment-detection-job 
   --input-data-config S3Uri=s3://amzn-s3-demo-bucket/input/
   --output-data-config S3Uri=s3://amzn-s3-demo-bucket/output/ 
   --data-access-role-arn arn:aws:iam::123456789012:role/comprehend-access-role
   --job-name reviews-sentiment-analysis
   --language-code en
   [--region us-east-1]
   ```

1. Depois de enviar o trabalho, copie o `JobId` e salve-o em um editor de texto. Você precisará do `JobId` para encontrar os arquivos de saída do trabalho de análise.

1. Inicie um trabalho de análise de entidades executando o comando a seguir.

   ```
   aws comprehend start-entities-detection-job 
   --input-data-config S3Uri=s3://amzn-s3-demo-bucket/input/
   --output-data-config S3Uri=s3://amzn-s3-demo-bucket/output/ 
   --data-access-role-arn arn:aws:iam::123456789012:role/comprehend-access-role
   --job-name reviews-entities-analysis
   --language-code en
   [--region us-east-1]
   ```

1. Depois de enviar o trabalho, copie o `JobId` e salve-o em um editor de texto.

1. Verifique o status dos seus trabalhos. Você pode ver o progresso de um trabalho acompanhando seu `JobId`.

   Para acompanhar o andamento do trabalho de análise de sentimentos, execute o comando a seguir. Substitua `sentiment-job-id` pelo `JobId` que você copiou depois de executar sua análise de sentimentos.

   ```
   aws comprehend describe-sentiment-detection-job
   --job-id sentiment-job-id
   ```

   Para monitorar seu trabalho de análise de entidades, execute o comando a seguir. Substitua `entities-job-id` pelo `JobId` que você copiou depois de executar sua análise de entidades.

   ```
   aws comprehend describe-entities-detection-job
   --job-id entities-job-id
   ```

   É preciso alguns minutos para que `JobStatus` seja exibido como `COMPLETED`.

Você concluiu trabalhos de análise de sentimentos e entidades. Ambos os trabalhos devem ser concluídos antes de você passar para a próxima etapa. A conclusão do trabalho pode demorar vários minutos.

# Etapa 4: preparar a saída do Amazon Comprehend para visualização de dados
<a name="tutorial-reviews-tables"></a>

Para preparar os resultados das tarefas de análise de sentimentos e entidades para criar visualizações de dados, você usa o AWS Glue e o Amazon Athena. Nesta etapa, você extrai os arquivos de resultados do Amazon Comprehend. Em seguida, você cria um *crawler* AWS Glue que explora seus dados e os cataloga automaticamente em tabelas no AWS Glue Data Catalog. Depois disso, você acessa e transforma essas tabelas usando Amazon Athena um serviço de consulta interativo e sem servidor. Quando você concluir essa etapa, seus resultados do Amazon Comprehend estarão limpos e prontos para visualização.

Para uma tarefa de detecção de entidades de PII, o arquivo de saída é um texto sem formatação, não um arquivo compactado. O nome do arquivo de saída é o mesmo do arquivo de entrada, com `.out` anexo no final. Não é necessária a etapa de extrair o arquivo de saída. Pule para [carregar os dados em um AWS Glue Data Catalog](#tutorial-reviews-tables-crawler).



**Topics**
+ [Pré-requisitos](#tutorial-reviews-tables-prereqs)
+ [Baixe a saída](#tutorial-reviews-tables-download)
+ [Extraia os arquivos de saída](#tutorial-reviews-tables-extract)
+ [Carregue os arquivos extraídos](#tutorial-reviews-tables-upload)
+ [Carregue os dados em um AWS Glue Data Catalog](#tutorial-reviews-tables-crawler)
+ [Prepare os dados para análise](#tutorial-reviews-tables-prep)

## Pré-requisitos
<a name="tutorial-reviews-tables-prereqs"></a>

Antes de começar, conclua [Etapa 3: executando trabalhos de análise em documentos no Amazon S3](tutorial-reviews-analysis.md).

## Baixe a saída
<a name="tutorial-reviews-tables-download"></a>

O Amazon Comprehend usa compressão Gzip para compactar arquivos de saída e salvá-los como um arquivo tar. A maneira mais simples de extrair os arquivos de saída é baixar esses arquivos `output.tar.gz` localmente. 

Nesta etapa, você baixará os arquivos de saída de sentimentos e entidades.

### Baixe os arquivos de saída (console)
<a name="tutorial-reviews-tables-download-console"></a>

Para encontrar os arquivos de saída para cada tarefa, retorne à tarefa de análise no console do Amazon Comprehend. A tarefa de análise fornece a localização do S3 para a saída, onde você pode baixar o arquivo de saída.

**Baixar os arquivos de saída (console)**

1. No console do [Amazon Comprehend](https://console.aws.amazon.com/comprehend/), no painel de navegação, retorne às **Tarefas de análise.**

1. Escolha sua tarefa de análise de sentimentos `reviews-sentiment-analysis`.

1. Em **Saída**, escolha o link exibido ao lado do **Local dos dados de saída**. Isso redireciona você para o arquivo de `output.tar.gz` em seu bucket do S3.

1. Na página **Visão geral** selecione **Fazer download**.

1. No seu computador, renomeie o arquivo como `sentiment-output.tar.gz`. Como todos os arquivos de saída têm o mesmo nome, isso ajuda você a acompanhar os arquivos de sentimentos e entidades.

1. Repita as etapas 1 a 4 para encontrar e baixar a saída da sua tarefa de `reviews-entities-analysis`. No seu computador, renomeie o arquivo como `entities-output.tar.gz`.

### Baixe os arquivos de saída (AWS CLI)
<a name="tutorial-reviews-tables-download-cli"></a>

Para encontrar os arquivos de saída de cada tarefa, use o `JobId` da tarefa de análise para encontrar a localização da saída no S3. Em seguida, use o comando `cp` para baixar o arquivo de saída no seu computador.

**Baixar os arquivos de saída (AWS CLI)**

1. Para listar detalhes sobre sua tarefa de análise de sentimentos, execute o comando a seguir. Substitua o `sentiment-job-id` pelo sentimento `JobId` que você salvou.

   ```
   aws comprehend describe-sentiment-detection-job --job-id sentiment-job-id
   ```

   Se perdeu o controle da sua `JobId`, execute o comando a seguir para listar todas as suas tarefas de sentimento e filtrá-las por nome.

   ```
   aws comprehend list-sentiment-detection-jobs 
   --filter JobName="reviews-sentiment-analysis"
   ```

1. No objeto de `OutputDataConfig`, encontre o valor `S3Uri`. O valor `S3Uri` deve ser semelhante ao seguinte formato: `s3://amzn-s3-demo-bucket/.../output/output.tar.gz`. Copie esse valor para um editor de texto. 

1. Para baixar o arquivo de saída de sentimentos no diretório local, execute o seguinte comando: Substitua o caminho do bucket do S3 pelo `S3Uri` copiado na etapa anterior. Substitua `path/` pelo caminho da pasta para seu diretório local. O nome do `sentiment-output.tar.gz` substitui o nome do arquivo original para ajudar você a acompanhar os arquivos de sentimentos e entidades.

   ```
   aws s3 cp s3://amzn-s3-demo-bucket/.../output/output.tar.gz 
   path/sentiment-output.tar.gz
   ```

1. Para listar detalhes sobre sua tarefa de análise de entidades, execute o comando a seguir.

   ```
   aws comprehend describe-entities-detection-job
   --job-id entities-job-id
   ```

   Se perdeu o controle da sua `JobId`, execute o comando a seguir para listar todas as suas tarefas de entidade e filtrá-las por nome.

   ```
   aws comprehend list-entities-detection-jobs
   --filter JobName="reviews-entities-analysis"
   ```

1. A partir do objeto de `OutputDataConfig` na descrição da tarefa de sua entidade, copie o valor do `S3Uri`.

1. Para baixar o arquivo de saída de entidades no diretório local, execute o seguinte comando. Substitua o caminho do bucket do S3 pelo `S3Uri` copiado na etapa anterior. Substitua `path/` pelo caminho da pasta para seu diretório local. O nome da `entities-output.tar.gz` substitui o nome do arquivo original.

   ```
   aws s3 cp s3://amzn-s3-demo-bucket/.../output/output.tar.gz 
   path/entities-output.tar.gz
   ```

## Extraia os arquivos de saída
<a name="tutorial-reviews-tables-extract"></a>

Antes de acessar os resultados do Amazon Comprehend, descompacte os arquivos de sentimentos e entidades. Use o sistema de arquivos local ou um terminal para descompactar os arquivos. 

### Extraia os arquivos de saída (sistema de arquivos GUI)
<a name="tutorial-reviews-tables-extract-gui"></a>

Se você usa o macOS, clique duas vezes no arquivo no sistema de arquivos GUI para extrair o arquivo de saída.

Se você usa o Windows, é possível utilizar uma ferramenta de terceiros, como 7-Zip, para extrair os arquivos de saída no sistema de arquivos GUI. No Windows, você deve executar duas etapas para acessar o arquivo de saída. Primeiro, descompacte o arquivo e, em seguida, extraia-o

Renomeie o arquivo de sentimentos como `sentiment-output` e o arquivo de entidades como `entities-output` para distinguir entre os arquivos de saída.

### Extraia os arquivos de saída (terminal)
<a name="tutorial-reviews-tables-extract-terminal"></a>

Se você usa Linux ou macOS, é possível utilizar seu terminal padrão. Se você usa o Windows, deve ter acesso a um ambiente no estilo UNIX, como o Cygwin, para executar comandos tar.

Para extrair o arquivo de saída de sentimentos do arquivo de sentimentos, execute o comando a seguir em seu terminal local.

```
tar -xvf sentiment-output.tar.gz --transform 's,^,sentiment-,'
```

Observe que o parâmetro `--transform` adiciona o prefixo `sentiment-` ao arquivo de saída dentro do arquivo, renomeando o arquivo como `sentiment-output`. Isso permite distinguir entre os arquivos de saída de sentimentos e entidades e evitar a substituição.

Para extrair o arquivo de saída de entidades do arquivo de entidades, execute o comando a seguir em seu terminal local.

```
tar -xvf entities-output.tar.gz --transform 's,^,entities-,'
```

O parâmetro `--transform` adiciona o prefixo `entities-` ao nome do arquivo de saída.

**dica**  
Para economizar custos de armazenamento no Amazon S3, compacte os arquivos novamente com o Gzip antes de carregá-los. É importante descompactar e descompactar os arquivos originais porque não é AWS Glue possível ler automaticamente os dados de um arquivo tar. No entanto, AWS Glue pode ler arquivos no formato Gzip.

## Carregue os arquivos extraídos
<a name="tutorial-reviews-tables-upload"></a>

Depois de extrair os arquivos, faça o upload deles no seu bucket. Você deve armazenar os arquivos de saída de sentimentos e entidades em pastas separadas AWS Glue para ler os dados corretamente. No seu bucket, crie uma pasta para os resultados dos sentimentos extraídos e uma segunda pasta para os resultados das entidades extraídas. É possível criar pastas com o console do Amazon S3 ou com o AWS CLI. 

### Faça upload de arquivos extraídos para o Amazon S3 (console)
<a name="tutorial-reviews-tables-upload-console"></a>

Em seu bucket do S3, crie uma pasta para o arquivo de resultados de sentimento extraído e uma pasta para o arquivo de resultados de entidades. Em seguida, faça o upload dos arquivos de resultados extraídos para suas respectivas pastas.

**Fazer o upload dos arquivos extraídos para o Amazon S3 (console)**

1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Em **Buckets**, escolha seu bucket e, em seguida, **Criar pasta**.

1. Para o novo nome da pasta, insira o `sentiment-results` e escolha **Salvar**. Essa pasta conterá o arquivo de saída do sentimento extraído.

1. Na guia **Visão geral** do seu bucket, na lista de conteúdos do bucket, escolha a nova pasta `sentiment-results`. Escolha **Carregar**.

1. Em **Adicionar arquivos**, escolha o arquivo de `sentiment-output` do seu computador local e selecione **Avançar**.

1. Deixe as opções de **Gerenciar usuários**, **Acesso para outros Conta da AWS** e **Gerenciar permissões públicas** como padrões. Escolha **Próximo**.

1. Em **Classe de armazenamento**, escolha **Padrão**. Deixe as opções de **Criptografia**, **Metadados** e **Tag** como padrões. Escolha **Próximo**.

1. Revise as opções de upload e escolha **Carregar**.

1. Repita as etapas 1 a 8 para criar uma pasta chamada `entities-results` e carregar o arquivo de `entities-output` nela.

### Faça o upload dos arquivos extraídos para o Amazon S3 (AWS CLI)
<a name="tutorial-reviews-tables-upload-cli"></a>

Crie uma pasta no seu bucket do S3 ao fazer o upload de um arquivo com o comando `cp`. 

**Fazer o upload dos arquivos extraídos no Amazon S3 (AWS CLI)**

1. Crie uma pasta de sentimentos e envie seu arquivo de sentimentos para ela executando o comando a seguir. Substitua `path/` pelo caminho local para o arquivo de saída de sentimento extraído.

   ```
   aws s3 cp path/sentiment-output s3://amzn-s3-demo-bucket/sentiment-results/
   ```

1. Crie uma pasta de saída de entidades e carregue seu arquivo de entidades nela executando o comando a seguir. Substitua `path/` pelo caminho local para o arquivo de saída de entidades extraído.

   ```
   aws s3 cp path/entities-output s3://amzn-s3-demo-bucket/entities-results/
   ```

## Carregue os dados em um AWS Glue Data Catalog
<a name="tutorial-reviews-tables-crawler"></a>

Para colocar os resultados em um banco de dados, você pode usar um AWS Glue *rastreador*. Um AWS Glue *rastreador* verifica arquivos e descobre o esquema dos dados. Em seguida, ele organiza os dados em tabelas em um AWS Glue Data Catalog (um banco de dados com tecnologia sem servidor). Você pode criar um rastreador com o AWS Glue console ou o. AWS CLI

### Carregue os dados em um AWS Glue Data Catalog (console)
<a name="tutorial-reviews-tables-crawler-console"></a>

Crie um AWS Glue rastreador que `sentiment-results` escaneie suas pastas e `entities-results` pastas separadamente. Um novo perfil de IAM para o AWS Glue concede permissão ao crawler para acessar seu bucket do S3. Esse perfil do IAM é criado ao configurar o crawler.

**Para carregar os dados em um AWS Glue Data Catalog (console)**

1. Certifique-se de que você esteja em uma região que ofereça suporte AWS Glue. Se estiver em outra região, na barra de navegação, escolha uma região compatível no **Seletor de regiões**. Para obter uma lista das regiões que oferecem suporte AWS Glue, consulte a [Tabela de regiões](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) no *Guia Global de Infraestrutura*.

1. Abra o AWS Glue console em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).

1. No painel de navegação, escolha **Crawlers** e **Adicionar crawler**.

1. Em **Nome do crawler**, digite `comprehend-analysis-crawler` e escolha **Próximo**.

1. Em **Tipo de fonte do crawler**, escolha **Armazenamentos de dados** e **Próximo**.

1. Em **Adicionar um armazenamento de dados**, faça o seguinte:

   1. Em **Escolher um armazenamento de dados**, escolha **S3**.

   1. Deixe **Conexão** em branco.

   1. Na opção **Rastrear dados em**, escolha **Caminho especificado em minha conta**.

   1. Em **Incluir caminho**, insira o caminho do S3 completo da pasta de saída de sentimentos: `s3://amzn-s3-demo-bucket/sentiment-results`.

   1. Escolha **Próximo**.

1. Em **Adicionar outro armazenamento de dados**, escolha **Sim** e **Próximo**. Repita a Etapa 6, mas insira o caminho do S3 completo da pasta de saída das entidades: `s3://amzn-s3-demo-bucket/entities-results`.

1. Em **Adicionar outro armazenamento de dados**, escolha **Não** e **Próximo**.

1. Em **Perfil do IAM**, siga um destes procedimentos:

   1. Escolha **Criar um perfil do IAM**.

   1. Para a **Perfil do IAM**, insira `glue-access-role` e **Próximo**.

1. Em **Criar uma programação para esse crawler**, escolha **Executar sob demanda** e **Próximo**.

1. Na página **Configurar a saída do crawler**, faça o seguinte:

   1. Em **Base de dados**, selecione **Adicionar banco de dados**.

   1. Em **Nome do banco de dados**, insira `comprehend-results`. Esse banco de dados armazenará suas tabelas de saída do Amazon Comprehend.

   1. Deixe as outras opções em suas configurações padrão e escolha **Próximo**.

1. Revise as informações do crawler e escolha **Concluir**.

1. No console Glue, em **Crawlers**, escolha `comprehend-analysis-crawler` e **Executar crawler**. A conclusão do crawler pode levar alguns minutos.

### Carregue os dados em um AWS Glue Data Catalog (AWS CLI)
<a name="tutorial-reviews-tables-crawler-cli"></a>

Crie uma função do IAM para AWS Glue que forneça permissão para acessar seu bucket do S3. Em seguida, crie um banco de dados no AWS Glue Data Catalog. Por fim, crie e execute um crawler que carrega seus dados em tabelas no banco de dados.

**Para carregar os dados em um AWS Glue Data Catalog (AWS CLI)**

1. Para criar uma função do IAM para AWS Glue, faça o seguinte:

   1. Salve a política de confiança a seguir como um documento JSON chamado `glue-trust-policy.json` em seu computador.

------
#### [ JSON ]

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Effect": "Allow",
            "Principal": {
              "Service": "glue.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. Para criar um perfil do IAM, execute o comando a seguir. Substitua `path/` pelo caminho do seu computador local até o documento JSON.

      ```
      aws iam create-role --role-name glue-access-role
      --assume-role-policy-document file://path/glue-trust-policy.json
      ```

   1. Quando AWS CLI listar o Amazon Resource Number (ARN) para a nova função, copie e salve-o em um editor de texto.

   1. Salve a seguinte política do IAM como um documento JSON chamado `glue-access-policy.json` em seu computador. A política concede AWS Glue permissão para rastrear suas pastas de resultados.

------
#### [ JSON ]

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "s3:GetObject",
                      "s3:PutObject"
                  ],
                  "Resource": [
                      "arn:aws:s3:::amzn-s3-demo-bucket/sentiment-results*",
                      "arn:aws:s3:::amzn-s3-demo-bucket/entities-results*"
                  ]
              }
          ]
      }
      ```

------

   1. Para criar uma política do IAM, execute o comando a seguir. Substitua `path/` pelo caminho do seu computador local até o documento JSON.

      ```
      aws iam create-policy --policy-name glue-access-policy
      --policy-document file://path/glue-access-policy.json
      ```

   1. Quando AWS CLI listar o ARN da política de acesso, copie e salve em um editor de texto.

   1. Anexe a nova política ao perfil do IAM executando o comando a seguir. Substitua `policy-arn` pelo ARN da política do IAM anotado na etapa anterior.

      ```
      aws iam attach-role-policy --policy-arn policy-arn
      --role-name glue-access-role
      ```

   1. Anexe a política AWS gerenciada `AWSGlueServiceRole` à sua função do IAM executando o comando a seguir.

      ```
      aws iam attach-role-policy --policy-arn
      arn:aws:iam::aws:policy/service-role/AWSGlueServiceRole
      --role-name glue-access-role
      ```

1. Crie um AWS Glue banco de dados executando o comando a seguir.

   ```
   aws glue create-database 
   --database-input Name="comprehend-results"
   ```

1. Crie um novo AWS Glue rastreador executando o comando a seguir. `glue-iam-role-arn`Substitua pelo ARN da sua AWS Glue função do IAM.

   ```
   aws glue create-crawler 
   --name comprehend-analysis-crawler
   --role glue-iam-role-arn 
   --targets S3Targets=[
   {Path="s3://amzn-s3-demo-bucket/sentiment-results"},
   {Path="s3://amzn-s3-demo-bucket/entities-results"}] 
   --database-name comprehend-results
   ```

1. Inicie o crawler executando o comando a seguir:

   ```
   aws glue start-crawler --name comprehend-analysis-crawler
   ```

   A conclusão do crawler pode levar alguns minutos.

## Prepare os dados para análise
<a name="tutorial-reviews-tables-prep"></a>

Agora você tem um banco de dados preenchido com os resultados do Amazon Comprehend. No entanto, os resultados estão aninhados. Para desaninhá-los, você executa algumas instruções SQL em Amazon Athena. Amazon Athena é um serviço de consulta interativo que facilita a análise de dados no Amazon S3 usando SQL padrão. O Athena não tem servidor, portanto, não há infraestrutura para gerenciar e tem um modelo de preços. pay-per-query Nesta etapa, você cria novas tabelas de dados limpos que podem ser usadas para análise e visualização. Você usa o console do Athena para prepará-los.

**Preparar os dados**

1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. No editor de consultas, escolha **Configurações** e escolha **Gerenciar**.

1. Em **Localização dos resultados da consulta**, insira `s3://amzn-s3-demo-bucket/query-results/`. Isso cria uma nova pasta chamada `query-results` em seu bucket que armazena a saída das Amazon Athena consultas que você executa. Escolha **Salvar**.

1. No editor de consultas, escolha **Editor**.

1. Em **Banco de dados**, escolha o AWS Glue banco de dados `comprehend-results` que você criou.

1. Na seção **Tabelas**, haverá duas tabelas chamadas `sentiment_results` e `entities_results`. Visualize as tabelas para garantir que o crawler tenha carregado os dados. Nas opções de cada tabela (os três pontos ao lado do nome da tabela), escolha **Visualizar tabela**. Uma consulta curta é executada automaticamente. Verifique o painel **Resultados** para garantir que as tabelas contenham dados.
**dica**  
Se as tabelas não tiverem dados, tente verificar as pastas em seu bucket do S3. Certifique-se de haver uma pasta para resultados de entidades e uma pasta para resultados de sentimentos. Em seguida, tente executar um novo AWS Glue rastreador.

1. Para desaninhar a tabela de `sentiment_results`, insira a seguinte consulta no **Editor de consultas** e escolha **Executar**.

   ```
   CREATE TABLE sentiment_results_final AS
   SELECT file, line, sentiment,
   sentimentscore.mixed AS mixed,
   sentimentscore.negative AS negative,
   sentimentscore.neutral AS neutral,
   sentimentscore.positive AS positive
   FROM sentiment_results
   ```

1. Para começar a desaninhar a tabela de entidades, insira a consulta a seguir no **Editor de consultas** e escolha **Executar**.

   ```
   CREATE TABLE entities_results_1 AS
   SELECT file, line, nested FROM entities_results
   CROSS JOIN UNNEST(entities) as t(nested)
   ```

1. Para concluir o desaninhamento da tabela de entidades, insira a consulta a seguir no **Editor de consultas** e escolha **Executar consulta**.

   ```
   CREATE TABLE entities_results_final AS
   SELECT file, line,
   nested.beginoffset AS beginoffset,
   nested.endoffset AS endoffset,
   nested.score AS score,
   nested.text AS entity,
   nested.type AS category
   FROM entities_results_1
   ```

Sua tabela de `sentiment_results_final` deve ter a aparência a seguir, com colunas denominadas **arquivo**, **linha**, **sentimento**, **mista**, **negativa**, **neutra** e **positiva**. A tabela deve ter um valor por célula. A coluna de **sentimentos** descreve o sentimento geral mais provável de uma avaliação específica. As colunas **mista**, **negativa**, **neutra** e **positiva** dão pontuações para cada tipo de sentimento.

![\[Captura de tela da tabela de saída de sentimentos no Athena.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/tutorial-reviews-sentiment-table.png)


Sua tabela de `entities_results_final` deve ter a aparência a seguir, com colunas chamadas **arquivo**, **linha**, **beginoffset, **endoffset****, **pontuação**, **entidade** e **categoria**. A tabela deve ter um valor por célula. A coluna de **pontuação** indica a confiança do Amazon Comprehend na **entidade** detectada. A **categoria** indica que tipo de entidade o Comprehend detectou.

![\[Exibição no console da tabela de saída de entidades no Athena.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/tutorial-reviews-entities-table.png)


Agora que tem os resultados do Amazon Comprehend carregados em tabelas, você pode visualizar e extrair insights significativos dos dados.

# Etapa 5: Visualizar a saída do Amazon Comprehend no Quick
<a name="tutorial-reviews-visualize"></a>

Depois de armazenar os resultados do Amazon Comprehend em tabelas, você pode se conectar e visualizar os dados com o Quick. O Quick é uma ferramenta AWS gerenciada de business intelligence (BI) para visualização de dados. O Quick facilita a conexão com sua fonte de dados e a criação de recursos visuais poderosos. Nesta etapa, você conecta o Quick aos seus dados, cria visualizações que extraem insights dos dados e publica um painel de visualizações.

**Topics**
+ [Pré-requisitos](#tutorial-reviews-visualize-prereqs)
+ [Dê acesso rápido](#tutorial-reviews-visualize-access)
+ [Importe os conjuntos de dados](#tutorial-reviews-visualize-import)
+ [Crie uma visualização de sentimentos](#tutorial-reviews-visualize-sentiment)
+ [Crie uma visualização de entidades](#tutorial-reviews-visualize-entities)
+ [Publique um painel](#tutorial-reviews-visualize-dashboard)
+ [Limpeza](#tutorial-reviews-visualize-clean)

## Pré-requisitos
<a name="tutorial-reviews-visualize-prereqs"></a>

Antes de começar, conclua [Etapa 4: preparar a saída do Amazon Comprehend para visualização de dados](tutorial-reviews-tables.md).

## Dê acesso rápido
<a name="tutorial-reviews-visualize-access"></a>

Para importar os dados, o Quick exige acesso ao bucket e às tabelas do Amazon Simple Storage Service (Amazon S3). Amazon Athena Para dar acesso rápido aos seus dados, você deve estar conectado como QuickSight administrador e ter acesso para editar as permissões do recurso. Se você não conseguir concluir as etapas a seguir, revise os pré-requisitos do IAM na página de visão geral [Tutorial: analisando insights de avaliações de clientes com o Amazon Comprehend](tutorial-reviews.md).

**Para dar acesso rápido aos seus dados**

1. Abra o [console Quick](https://quicksight.aws.amazon.com/sn/start).

1. Se for a primeira vez que você usa o Quick, o console solicitará que você crie um novo usuário administrador fornecendo um endereço de e-mail. Para **Endereço de E-mail**, insira o mesmo endereço de e-mail da sua Conta da AWS. Escolha **Continuar**.

1. Depois de entrar, escolha o nome do seu perfil na barra de navegação e escolha **Gerenciar QuickSight**. Você deve estar conectado como administrador para ver a QuickSight opção **Gerenciar**.

1. Escolha **Segurança e permissões**.

1. Para **QuickSight acessar os AWS serviços**, escolha **Adicionar ou remover**.

1. Escolha **Amazon S3**.

1. Em **Selecionar buckets do Amazon S3**, escolha seu bucket do S3 em **S3 Bucket** e **Permissão de gravação para o Athena Workgroup**.

1. Escolha **Terminar**.

1. Selecione **Atualizar**.

## Importe os conjuntos de dados
<a name="tutorial-reviews-visualize-import"></a>

Antes de criar visualizações, você deve adicionar os conjuntos de dados de sentimentos e entidades ao Quick. Você faz isso com o console rápido. Você importa suas tabelas de sentimentos e entidades não aninhadas do. Amazon Athena

**Para importar seus conjuntos de dados**

1. Abra o [console Quick](https://quicksight.aws.amazon.com/sn/start).

1. Na barra de navegação, em **Conjuntos de dados**, escolha **Novo conjunto de dados**.

1. Em **Criar um conjunto de dados**, escolha **Athena**.

1. Em**Nome da fonte de dados**, insira `reviews-sentiment-analysis` e escolha **Criar fonte de dados**.

1. Em **Banco de dados**, selecione o banco de dados `comprehend-results`.

1. Em **Tabelas**, escolha a tabela de sentimentos `sentiment_results_final` e, em seguida, escolha **Selecionar**.

1. Escolha **Importar para SPICE para acelerar a análise** e escolha **Visualizar**. O SPICE QuickSight é o mecanismo de cálculo na memória que fornece análises mais rápidas do que a consulta direta ao criar visualizações.

1. Retorne ao console rápido e escolha **Conjuntos de dados.** Repita as etapas de 1 a 7 para criar um conjunto de dados de entidades, mas faça as seguintes alterações:

   1. Para **Nome da fonte de dados**, insira `reviews-entities-analysis`.

   1. Em **Tabelas**, escolha a tabela de entidades `entities_results_final`.

## Crie uma visualização de sentimentos
<a name="tutorial-reviews-visualize-sentiment"></a>

Agora que você pode acessar seus dados no Quick, você pode começar a criar visualizações. Você cria um gráfico circular com os dados de sentimento do Amazon Comprehend. O gráfico circular mostra a proporção das avaliações positivas, neutras, mistas e negativas.

**Para visualizar dados de sentimentos**

1. No console Rápido, escolha **Análises** e, em seguida, escolha **Nova análise**.

1. Em **Seus conjuntos de dados**, escolha o conjunto de dados de sentimentos `sentiment_results_final` e, em seguida, escolha **Criar análise**.

1. No editor visual, na **Lista de campos**, escolha **sentimento**.
**nota**  
Os valores na **Lista de campos** dependem dos nomes das colunas usadas para criar as tabelas em Amazon Athena. Se você alterou os nomes das colunas fornecidos nas consultas SQL, os nomes da **Lista de campos** serão diferentes dos nomes usados nesses exemplos de visualização.

1. Para **Tipos de visuais**, escolha **Gráfico de pizza**.

Um gráfico circular semelhante ao seguinte, com seções positivas, neutras, mistas e negativas, é exibido. Para ver a contagem e a porcentagem de uma seção, passe o mouse sobre ela. 

![\[Exibição no console do gráfico circular de sentimentos com seções positivas, negativas, neutras e mistas.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/tutorial-reviews-pie.png)


## Crie uma visualização de entidades
<a name="tutorial-reviews-visualize-entities"></a>

Agora, crie uma segunda visualização com o conjunto de dados de entidades. Você cria um mapa de árvore das entidades distintas nos dados. Cada bloco no mapa de árvore representa uma entidade e o tamanho do bloco se correlaciona com o número de vezes que a entidade aparece no conjunto de dados.

**Para visualizar dados de entidades**

1. No painel de controle **Visualizar**, ao lado de **Conjunto de dados**, escolha o ícone **Adicionar, editar, substituir e remover conjuntos de dados**.

1. Escolha **Adicionar conjunto de dados**.

1. Em **Escolher conjunto de dados a ser adicionado**, escolha o conjunto de dados `entities_results_final` de suas entidades na lista de conjuntos de dados e escolha **Selecionar**.

1. No painel de controle **Visualizar**, escolha a lista suspensa **Conjunto de dados** e escolha o conjunto de dados de entidades `entities_results_final`.

1. Na **Lista de campos**, escolha **entidade**.

1. Para **Tipos de visuais**, escolha **Mapa de árvore**.

Um mapa de árvore semelhante ao seguinte é exibido ao lado do seu gráfico circular. Para ver a contagem de uma entidade específica, passe o mouse sobre um bloco.

![\[Exibição no console de um mapa de árvore com blocos para cada entidade exclusiva.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/tutorial-reviews-tree.png)


## Publique um painel
<a name="tutorial-reviews-visualize-dashboard"></a>

Depois de criar as visualizações, você pode publicá-las como um painel. Você pode realizar várias tarefas com um painel, como compartilhá-lo com os usuários do seu Conta da AWS, salvá-lo como PDF ou enviá-lo por e-mail como um relatório (limitado à edição Enterprise do Quick). Nesta etapa, você publica as visualizações como um painel na sua conta.

**Para publicar seu painel**

1. Na barra de navegação, escolha **Compartilhar**.

1. Escolha **Publicar painel**.

1. Escolha **Publicar novo painel como** e insira o nome `comprehend-analysis-reviews` para o painel.

1. Escolha **Publicar painel**.

1. Feche o painel **Compartilhar painel com os usuários** escolhendo o botão de fechar no canto superior direito.

1. No console rápido, no painel de navegação, escolha **Painéis**. Uma miniatura do seu novo painel `comprehend-analysis-reviews` deve aparecer em **Painéis**. Escolha o painel para visualizá-lo.

Agora você tem um painel com visualizações de sentimentos e entidades que se parece com o exemplo a seguir.

![\[Exibição no console de um QuickSight painel com um gráfico circular e um mapa de árvore.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/tutorial-reviews-dashboard.png)


**dica**  
 Se você quiser editar as visualizações em seu painel, volte para **Análises** e edite a visualização que você deseja atualizar. Em seguida, publique o painel novamente como um novo painel ou como um substituto do painel existente. 

## Limpeza
<a name="tutorial-reviews-visualize-clean"></a>

Depois de concluir este tutorial, talvez você queira limpar todos AWS os recursos que não deseja mais usar. Os AWS recursos ativos podem continuar gerando cobranças em sua conta.

As ações a seguir podem ajudar a evitar cobranças contínuas:
+ Cancele sua assinatura do Quick. O Quick é um serviço de assinatura mensal. Para cancelar sua assinatura, consulte [Cancelar sua assinatura](https://docs.aws.amazon.com/quicksight/latest/user/closing-account.html) no *Guia rápido do usuário*.
+ Exclua seu bucket do Amazon S3. O Amazon S3 cobra pelo armazenamento. Para limpar seus recursos do Amazon S3, exclua seu bucket. Para obter mais informações sobre como excluir um bucket, consulte [Como excluir um bucket do S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/delete-bucket.html) no *Guia do usuário do Amazon Simple Storage Service*. Certifique-se de que você salvou todos os seus arquivos importantes antes de excluir seu bucket.
+ Limpe seu AWS Glue Data Catalog. O armazenamento é AWS Glue Data Catalog cobrado mensalmente. Você pode excluir seus bancos de dados para evitar cobranças contínuas. Para obter informações sobre como gerenciar seus AWS Glue Data Catalog bancos de dados, consulte Como [trabalhar com bancos de dados no AWS Glue console](https://docs.aws.amazon.com/glue/latest/dg/console-databases.html) no *Guia do AWS Glue desenvolvedor*. Certifique-se de que você exportou seus dados antes de limpar qualquer banco de dados ou tabela.