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á.
# Classificação personalizada
Use a *classificação personalizada* para organizar seus documentos em categorias (classes) definidas por você. A classificação personalizada é um processo em duas etapas. Primeiro, você treina um modelo de classificação personalizado (também chamado de classificador) para reconhecer as classes que são do seu interesse. Em seguida, você usa seu modelo para classificar qualquer número de conjuntos de documentos.
Por exemplo, você pode categorizar o conteúdo das solicitações de suporte a fim de poder encaminhar a solicitação para a equipe de suporte adequada. Ou você pode categorizar os e-mails recebidos dos clientes para fornecer orientação com base no tipo de solicitação do cliente. Você pode combinar o Amazon Comprehend com o Amazon Transcribe para converter fala em texto e depois classificar as solicitações provenientes de chamadas telefônicas de suporte.
Você pode executar a classificação personalizada em um único documento de forma síncrona (em tempo real) ou iniciar uma tarefa assíncrona para classificar um conjunto de documentos. Você pode ter vários classificadores personalizados em sua conta, cada um treinado usando dados diferentes. A classificação personalizada é compatível com uma variedade de tipos de documentos de entrada, como texto sem formatação, PDF, Word e imagens.
Ao enviar uma tarefa de classificação, você escolhe o modelo de classificador a ser usado, com base no tipo de documentos que precisa analisar. Por exemplo, para analisar documentos de texto sem formatação, você obtém os resultados mais precisos usando um modelo treinado com documentos de texto sem formatação. Para analisar documentos semiestruturados (como PDF, Word, imagens, saída do Amazon Textract ou arquivos digitalizados), você obtém os resultados mais precisos usando um modelo treinado com documentos originais.
**Topics**
+ [Preparar dados de treinamento do classificador](prep-classifier-data.md)
+ [Modelos de classificação de treinamento](training-classifier-model.md)
+ [Executar análises em tempo real](running-class-sync.md)
+ [Executar tarefas assíncronas](running-classifiers.md)
# Preparar dados de treinamento do classificador
Para classificação personalizada, você treina o modelo no modo multiclasse ou no modo multirrótulos. O modo multiclasse associa uma única classe a cada documento. O modo multirrótulos associa uma ou mais classes a cada documento. Os formatos de arquivo de entrada são diferentes para cada modo, então escolha o modo a ser usado antes de criar os dados de treinamento.
**nota**
O console do Amazon Comprehend se refere ao modo multiclasse como modo de rótulo único.
A classificação personalizada é compatível com modelos que você treina com documentos sem formatação e modelos treinados com documentos originais (como PDF, Word ou imagens). Para mais informações sobre modelos de classificadores e seus tipos de documentos compatíveis, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
Preparar dados para treinar um modelo de classificador personalizado:
1. Identifique as classes que você deseja que esse classificador analise. Decida qual modo usar (multiclasse ou multirrótulo).
1. Decida o tipo de modelo do classificador, com base no modelo ter o fim de analisar documentos de texto simples ou documentos semiestruturados.
1. Reúna exemplos de documentos para cada uma das classes. Para obter os requisitos mínimos de treinamento, consulte[Cotas gerais para classificação de documentos](guidelines-and-limits.md#limits-class-general).
1. Para um modelo de texto sem formatação, escolha o formato de arquivo de treinamento a ser usado (arquivo CSV ou arquivo de manifesto aumentado). Para treinar um modelo de documento nativo, você sempre usa um arquivo CSV.
**Topics**
+ [Formatos de arquivo de treinamento do classificador](prep-class-data-format.md)
+ [Modo multiclasse](prep-classifier-data-multi-class.md)
+ [Modo multirrótulo](prep-classifier-data-multi-label.md)
# Formatos de arquivo de treinamento do classificador
Para um modelo de texto sem formatação, você pode fornecer dados de treinamento do classificador como um arquivo CSV ou como um arquivo de manifesto aumentado que você cria usando o AI Ground Truth. SageMaker O arquivo CSV ou arquivo de manifesto aumentado inclui o texto de cada documento de treinamento e seus rótulos associados.
Para um modelo de documento nativo, você fornece dados do classificador de treinamento como um arquivo CSV. O arquivo CSV inclui o nome do arquivo de cada documento de treinamento e seus rótulos associados. Você inclui os documentos de treinamento na pasta de entrada do Amazon S3 para a tarefa de treinamento.
## Arquivos CSV
Você fornece dados de treinamento rotulados como texto codificado em UTF-8 em um arquivo CSV. Não inclua uma linha de cabeçalho. Adicionar uma linha de cabeçalho em seu arquivo pode causar erros runtime.
Para cada linha no arquivo CSV, a primeira coluna contém um ou mais rótulos de classe. Um rótulo de classe pode ser qualquer string UTF-8 válida. Recomendamos usar nomes de classe claros que não se sobreponham em significado. O nome pode incluir espaço em branco e consistir em várias palavras conectadas por sublinhados ou hífens.
Não deixe nenhum caractere de espaço antes ou depois das vírgulas que separam os valores em uma linha.
O conteúdo exato do arquivo CSV depende do modo classificador e do tipo de dados de treinamento. Para mais detalhes, consulte as seções em [Modo multiclasse](prep-classifier-data-multi-class.md) e [Modo multirrótulo](prep-classifier-data-multi-label.md).
## Arquivo de manifesto aumentado
Um arquivo de manifesto aumentado é um conjunto de dados rotulado que você cria usando o AI Ground SageMaker Truth. O Ground Truth é um serviço de rotulagem de dados que ajuda você ou seus funcionários a criar conjuntos de dados de treinamento para modelos de machine learning.
Para obter mais informações sobre o Ground Truth e os resultados que ele produz, consulte [Use o SageMaker AI Ground Truth to Label Data](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html) no *Amazon SageMaker AI Developer Guide*.
Os arquivos de manifesto aumentado estão no formato de linhas JSON. Nesses arquivos, cada linha é um objeto JSON completo que contém um documento de treinamento e seus rótulos associados. O conteúdo exato de cada linha depende do modo classificador. Para mais detalhes, consulte as seções em [Modo multiclasse](prep-classifier-data-multi-class.md) e [Modo multirrótulo](prep-classifier-data-multi-label.md).
Ao fornecer seus dados de treinamento ao Amazon Comprehend, você especifica um ou mais nomes de atributos do rótulo. A quantidade de nomes de atributos que você especifica depende se seu arquivo de manifesto aumentado é a saída de uma única tarefa de rotulagem ou de uma tarefa de rotulagem em cadeia.
Se seu arquivo for a saída de uma tarefa de rotulagem única, especifique o nome do atributo de rótulo único da tarefa do Ground Truth.
Se seu arquivo for a saída de um trabalho de rotulagem em cadeia, especifique o nome de atributo de rótulo etiqueta para um ou mais trabalhos na cadeia. Cada nome de atributo de rótulo fornece as anotações de uma tarefa individual. Você pode especificar até 5 desses atributos para arquivos de manifesto aumentados a partir de tarefas de rotulagem encadeadas.
Para obter mais informações sobre trabalhos de etiquetagem em cadeia e para obter exemplos dos resultados que eles produzem, consulte [Encadeamento de trabalhos de etiquetagem](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-reusing-data.html) no Amazon SageMaker AI Developer Guide.
# Modo multiclasse
No modo multiclasse, a classificação atribui uma classe para cada documento. As classes individuais são mutuamente exclusivas. Por exemplo, você pode classificar um filme como comédia ou ficção científica, mas não ambos.
**nota**
O console do Amazon Comprehend se refere ao modo multiclasse como modo de rótulo único.
**Topics**
+ [Modelos de texto sem formatação](#prep-multi-class-plaintext)
+ [Modelos de documento originais](#prep-multi-class-structured)
## Modelos de texto sem formatação
Para treinar um modelo de texto simples, você pode fornecer dados de treinamento rotulados como um arquivo CSV ou como um arquivo de manifesto aumentado do AI Ground Truth. SageMaker
### Arquivo CSV
Para informações gerais sobre como usar arquivos CSV para classificadores de treinamento, consulte [Arquivos CSV](prep-class-data-format.md#prep-data-csv).
Forneça os dados de treinamento como um arquivo CSV de duas colunas. Para cada linha, a primeira coluna contém o valor do rótulo da classe. A segunda coluna contém um exemplo de documento de texto para essa classe. Cada linha deve terminar com caracteres \$1n ou \$1r\$1n.
O exemplo a seguir mostra um arquivo CSV contendo três documentos.
```
CLASS,Text of document 1
CLASS,Text of document 2
CLASS,Text of document 3
```
O exemplo a seguir mostra uma linha de um arquivo CSV que treina um classificador personalizado para detectar se uma mensagem de e-mail é spam:
```
SPAM,"Paulo, your $1000 award is waiting for you! Claim it while you still can at http://example.com."
```
### Arquivo de manifesto aumentado
Para informações gerais sobre o uso de arquivos de manifesto aumentados para treinar classificadores, consulte [Arquivo de manifesto aumentado](prep-class-data-format.md#prep-data-annotations).
Para documentos de texto sem formatação, cada linha do arquivo de manifesto aumentado é um objeto JSON completo contendo um documento de treinamento, um único nome de classe e outros metadados do Ground Truth. O exemplo a seguir é um arquivo de manifesto aumentado para treinar um classificador personalizado a fim de reconhecer mensagens de e-mail de spam:
```
{"source":"Document 1 text", "MultiClassJob":0, "MultiClassJob-metadata":{"confidence":0.62, "job-name":"labeling-job/multiclassjob", "class-name":"not_spam", "human-annotated":"yes", "creation-date":"2020-05-21T17:36:45.814354", "type":"groundtruth/text-classification"}}
{"source":"Document 2 text", "MultiClassJob":1, "MultiClassJob-metadata":{"confidence":0.81, "job-name":"labeling-job/multiclassjob", "class-name":"spam", "human-annotated":"yes", "creation-date":"2020-05-21T17:37:51.970530", "type":"groundtruth/text-classification"}}
{"source":"Document 3 text", "MultiClassJob":1, "MultiClassJob-metadata":{"confidence":0.81, "job-name":"labeling-job/multiclassjob", "class-name":"spam", "human-annotated":"yes", "creation-date":"2020-05-21T17:37:51.970566", "type":"groundtruth/text-classification"}}
```
O exemplo a seguir mostra um objeto JSON do arquivo de manifesto aumentado, formatado para facilitar a leitura:
```
{
"source": "Paulo, your $1000 award is waiting for you! Claim it while you still can at http://example.com.",
"MultiClassJob": 0,
"MultiClassJob-metadata": {
"confidence": 0.98,
"job-name": "labeling-job/multiclassjob",
"class-name": "spam",
"human-annotated": "yes",
"creation-date": "2020-05-21T17:36:45.814354",
"type": "groundtruth/text-classification"
}
}
```
Neste exemplo, o atributo `source` fornece o texto do documento de treinamento e o atributo `MultiClassJob` atribui o índice de uma classe de uma lista de classificação. O atributo `job-name` é o nome que você definiu para a tarefa de rotulagem no Ground Truth.
Ao iniciar a tarefa de treinamento de classificadores no Amazon Comprehend, você especifica o mesmo nome da tarefa de rotulagem.
## Modelos de documento originais
Um modelo de documento nativo é um modelo que você treina com documentos nativos (como PDF, DOCX e imagens). Você fornece os dados de treinamento como um arquivo CSV.
### Arquivo CSV
Para informações gerais sobre como usar arquivos CSV para classificadores de treinamento, consulte [Arquivos CSV](prep-class-data-format.md#prep-data-csv).
Forneça os dados de treinamento como um arquivo CSV de três colunas. Para cada linha, a primeira coluna contém o valor do rótulo da classe. A segunda coluna contém o nome do arquivo de um documento de exemplo para essa classe. A terceira coluna contém o número da página. O número da página é opcional se o documento de exemplo for uma imagem.
O exemplo a seguir mostra um arquivo CSV que faz referência a três documentos de entrada.
```
CLASS,input-doc-1.pdf,3
CLASS,input-doc-2.docx,1
CLASS,input-doc-3.png
```
O exemplo a seguir mostra uma linha de um arquivo CSV que treina um classificador personalizado para detectar se uma mensagem de e-mail é spam. A página 2 do arquivo PDF contém o exemplo de spam.
```
SPAM,email-content-3.pdf,2
```
# Modo multirrótulo
No modo multirrótulo, as classes individuais representam categorias diferentes que não são mutuamente exclusivas. A classificação multirrótulo atribui uma ou mais classes a cada documento. Por exemplo, você pode classificar um filme como documentário e outro filme como ficção científica, ação e comédia.
Para treinamento, o modo multirrótulo suporta até 1 milhão de exemplos contendo até 100 classes exclusivas.
**Topics**
+ [Modelos de texto sem formatação](#prep-multi-label-plaintext)
+ [Modelos de documento originais](#prep-multi-label-structured)
## Modelos de texto sem formatação
Para treinar um modelo de texto simples, você pode fornecer dados de treinamento rotulados como um arquivo CSV ou como um arquivo de manifesto aumentado do AI Ground Truth. SageMaker
### Arquivo CSV
Para informações gerais sobre como usar arquivos CSV para classificadores de treinamento, consulte [Arquivos CSV](prep-class-data-format.md#prep-data-csv).
Forneça os dados de treinamento como um arquivo CSV de duas colunas. Para cada linha, a primeira coluna contém os valores do rótulo da classe e a segunda coluna contém um exemplo de documento de texto para essas classes. Para inserir mais de uma classe na primeira coluna, use um delimitador (como \$1) entre cada classe.
```
CLASS,Text of document 1
CLASS,Text of document 2
CLASS|CLASS|CLASS,Text of document 3
```
O exemplo a seguir mostra uma linha de um arquivo CSV que treina um classificador personalizado para detectar gêneros em resumos de filmes:
```
COMEDY|MYSTERY|SCIENCE_FICTION|TEEN,"A band of misfit teens become unlikely detectives when they discover troubling clues about their high school English teacher. Could the strange Mrs. Doe be an alien from outer space?"
```
O delimitador padrão entre os nomes das classes é uma barra vertical, também chamada de pipe (\$1). No entanto, é possível usar um caractere diferente como um delimitador. O delimitador deve ser diferente de todos os caracteres nos nomes de suas classes. Por exemplo, se suas classes são CLASSE\$11, CLASSE\$12 e CLASSE\$13, o sublinhado (**\$1**) faz parte do nome da classe. Portanto, não use um sublinhado como delimitador para separar os nomes das classes.
### Arquivo de manifesto aumentado
Para informações gerais sobre o uso de arquivos de manifesto aumentados para treinar classificadores, consulte [Arquivo de manifesto aumentado](prep-class-data-format.md#prep-data-annotations).
Para documentos de texto sem formatação, cada linha do arquivo de manifesto aumentado é um objeto JSON completo. Ele contém um documento de treinamento, nomes de classes e outros metadados do Ground Truth. O exemplo a seguir é um arquivo de manifesto aumentado para treinar um classificador personalizado a fim de detectar gêneros em resumos de filmes:
```
{"source":"Document 1 text", "MultiLabelJob":[0,4], "MultiLabelJob-metadata":{"job-name":"labeling-job/multilabeljob", "class-map":{"0":"action", "4":"drama"}, "human-annotated":"yes", "creation-date":"2020-05-21T19:02:21.521882", "confidence-map":{"0":0.66}, "type":"groundtruth/text-classification-multilabel"}}
{"source":"Document 2 text", "MultiLabelJob":[3,6], "MultiLabelJob-metadata":{"job-name":"labeling-job/multilabeljob", "class-map":{"3":"comedy", "6":"horror"}, "human-annotated":"yes", "creation-date":"2020-05-21T19:00:01.291202", "confidence-map":{"1":0.61,"0":0.61}, "type":"groundtruth/text-classification-multilabel"}}
{"source":"Document 3 text", "MultiLabelJob":[1], "MultiLabelJob-metadata":{"job-name":"labeling-job/multilabeljob", "class-map":{"1":"action"}, "human-annotated":"yes", "creation-date":"2020-05-21T18:58:51.662050", "confidence-map":{"1":0.68}, "type":"groundtruth/text-classification-multilabel"}}
```
O exemplo a seguir mostra um objeto JSON do arquivo de manifesto aumentado, formatado para facilitar a leitura:
```
{
"source": "A band of misfit teens become unlikely detectives when
they discover troubling clues about their high school English teacher.
Could the strange Mrs. Doe be an alien from outer space?",
"MultiLabelJob": [
3,
8,
10,
11
],
"MultiLabelJob-metadata": {
"job-name": "labeling-job/multilabeljob",
"class-map": {
"3": "comedy",
"8": "mystery",
"10": "science_fiction",
"11": "teen"
},
"human-annotated": "yes",
"creation-date": "2020-05-21T19:00:01.291202",
"confidence-map": {
"3": 0.95,
"8": 0.77,
"10": 0.83,
"11": 0.92
},
"type": "groundtruth/text-classification-multilabel"
}
}
```
Neste exemplo, o atributo `source` fornece o texto do documento de treinamento e o atributo `MultiLabelJob` atribui os índices de várias classes de uma lista de classificação. O nome da tarefa nos metadados do `MultiLabelJob` é o nome que você definiu para a tarefa de rotulagem no Ground Truth.
## Modelos de documento originais
Um modelo de documento nativo é um modelo que você treina com documentos nativos (como PDF, DOCX e arquivos de imagem). Você fornece dados de treinamento rotulados como um arquivo CSV.
### Arquivo CSV
Para informações gerais sobre como usar arquivos CSV para classificadores de treinamento, consulte [Arquivos CSV](prep-class-data-format.md#prep-data-csv).
Forneça os dados de treinamento como um arquivo CSV de três colunas. Para cada linha, a primeira coluna contém os valores do rótulo da classe. A segunda coluna contém o nome do arquivo de um documento de exemplo para essas classes. A terceira coluna contém o número da página. O número da página é opcional se o documento de exemplo for uma imagem.
Para inserir mais de uma classe na primeira coluna, use um delimitador (como \$1) entre cada classe.
```
CLASS,input-doc-1.pdf,3
CLASS,input-doc-2.docx,1
CLASS|CLASS|CLASS,input-doc-3.png,2
```
O exemplo a seguir mostra uma linha de um arquivo CSV que treina um classificador personalizado para detectar gêneros em resumos de filmes. A página 2 do arquivo PDF contém o exemplo de um comedy/teen filme.
```
COMEDY|TEEN,movie-summary-1.pdf,2
```
O delimitador padrão entre os nomes das classes é uma barra vertical, também chamada de pipe (\$1). No entanto, é possível usar um caractere diferente como um delimitador. O delimitador deve ser diferente de todos os caracteres nos nomes de suas classes. Por exemplo, se suas classes são CLASSE\$11, CLASSE\$12 e CLASSE\$13, o sublinhado (**\$1**) faz parte do nome da classe. Portanto, não use um sublinhado como delimitador para separar os nomes das classes.
# Modelos de classificação de treinamento
Para treinar um modelo para classificação personalizada, você define as categorias e fornece documentos de exemplo para treinar o modelo personalizado. Você treina o modelo no modo multiclasse ou multirrótulo. O modo multiclasse associa uma única classe a cada documento. O modo multirrótulos associa uma ou mais classes a cada documento.
A classificação personalizada é compatível com dois tipos de modelos de classificadores: modelos de texto sem formatação e modelos de documentos nativos. Um modelo de texto sem formatação classifica documentos com base em seu conteúdo de texto. Um modelo de documento nativo também classifica documentos com base no conteúdo do texto. Um modelo de documento nativo também pode usar sinais adicionais, como do layout do documento. Você treina um modelo de documento nativo com documentos nativos para que o modelo aprenda as informações do layout.
Os modelos de texto sem formatação têm as seguintes características:
+ Você treina o modelo usando documentos de texto codificados em UTF-8.
+ Você pode treinar o modelo usando documentos em um dos seguintes idiomas: inglês, espanhol, alemão, italiano, francês ou português.
+ Todos os documentos de treinamento de um determinado classificador devem usar o mesmo idioma.
+ Os documentos de treinamento são em texto sem formatação, portanto, não há custos adicionais pela extração de texto.
Os modelos de documentos nativos têm as seguintes características:
+ Você treina o modelo usando documentos semiestruturados, que incluem os seguintes tipos de documentos:
+ Documentos PDF digitais e digitalizados.
+ Documentos do Word (DOCX).
+ Imagens: arquivos JPG, arquivos PNG e arquivos TIFF de página única.
+ Arquivos de saída JSON da API Textract.
+ Você treina o modelo usando documentos em inglês.
+ Documentos de treinamento incluindo arquivos de documentos digitalizados implicam em cobranças adicionais pela extração de texto. Consulte a página de [Valores do Amazon Comprehend](https://aws.amazon.com/comprehend/pricing) para detalhes.
Você pode classificar qualquer um dos tipos de documentos compatíveis usando qualquer tipo de modelo. No entanto, para obter resultados mais precisos, recomendamos o uso de um modelo de texto sem formatação para classificar documentos de texto sem formatação e um modelo de documento nativo para classificar documentos semiestruturados.
**Topics**
+ [Treine classificadores personalizados (console)](create-custom-classifier-console.md)
+ [Treine classificadores personalizados (API)](train-custom-classifier-api.md)
+ [Teste os dados de treinamento](testing-the-model.md)
+ [Saída do treinamento do classificador](train-classifier-output.md)
+ [Métricas de classificador personalizados](cer-doc-class.md)
# Treine classificadores personalizados (console)
Você pode criar e treinar um classificador personalizado usando o console e, em seguida, usar o classificador personalizado para analisar seus documentos.
Para treinar um classificador personalizado, você precisa de um conjunto de documentos de treinamento. Você rotula esses documentos com as categorias que deseja que o classificador de documentos reconheça. Para informações sobre como preparar seus documentos de treinamento, consulte [Preparar dados de treinamento do classificador](prep-classifier-data.md).
**Criar e treinar um modelo de classificador de documentos**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Comprehend em [https://console.aws.amazon.com/comprehend/](https://console.aws.amazon.com/comprehend/)
1. No menu à esquerda, escolha **Personalização** e, em seguida, **Classificação personalizada**.
1. Escolha **Criar novo modelo**.
1. Em **Configurações do modelo**, insira um nome de modelo para o classificador. O nome deve ser exclusivo na sua conta e na sua região atual.
(Opcional) Insira um nome de versão. O nome deve ser exclusivo na sua conta e na sua região atual.
1. Selecione o idioma dos documentos de treinamento. Para ver os idiomas com os quais os classificadores são compatíveis, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
1. (Opcional) Se você quiser criptografar os dados no volume de armazenamento enquanto o Amazon Comprehend processa sua tarefa de treinamento, escolha **Criptografia classificadora**. Em seguida, selecione se deseja usar uma chave KMS associada à sua conta atual ou uma de outra conta.
+ Se estiver usando uma chave associada à conta atual, escolha o ID da chave para o **ID da chave KMS**.
+ Se estiver usando uma chave associada a uma conta diferente, insira o ARN do ID da chave em **ARN da chave KMS**.
**nota**
Para mais informações sobre como criar e usar chaves KMS e a criptografia associada, consulte o [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
1. Em **Especificações de dados**, escolha o **Tipo de modelo de treinamento** a ser usado.
+ **Documentos de texto sem formatação:** escolha essa opção para criar um modelo de texto sem formatação. Treine o modelo usando documentos de texto sem formatação.
+ **Documentos nativos:** escolha essa opção para criar um modelo de documento nativo. Treine o modelo usando documentos nativos (PDF, Word, imagens).
1. Escolha o **Formato de dados** dos seus dados de treinamento. Para mais informações sobre o formato, consulte [Formatos de arquivo de treinamento do classificador](prep-class-data-format.md).
+ **Arquivo CSV:** escolha essa opção se seus dados de treinamento usarem o formato de arquivo CSV.
+ **Manifesto aumentado:** escolha essa opção se você usou o Ground Truth para criar arquivos de manifesto aumentados para seus dados de treinamento. Esse formato estará disponível se você escolher **Documentos de texto sem formatação** como o tipo de modelo de treinamento.
1. Escolha o **Modo classificador** a ser usado.
+ **Modo de rótulo único:** escolha esse modo se as categorias que você está atribuindo aos documentos forem mutuamente exclusivas e você estiver treinando seu classificador para atribuir um rótulo a cada documento. Na API da Amazon Comprehend, o modo de rótulo único é conhecido como modo multiclasse.
+ **Modo multirrótulo:** escolha esse modo se várias categorias puderem ser aplicadas a um documento ao mesmo tempo e você estiver treinando seu classificador para atribuir um ou mais rótulos a cada documento.
1. Se você escolher o **Modo multirrótulo**, poderá selecionar o **Delimitador para rótulos**. Use esse caractere delimitador para separar rótulos quando houver várias classes para um documento de treinamento. O delimitador padrão é o caractere pipe.
1. (Opcional) Se escolher **Manifesto aumentado** como formato de dados, poderá inserir até cinco arquivos de manifesto aumentados. Cada arquivo de manifesto aumentado contém um conjunto de dados de treinamento ou um conjunto de dados de teste. Você deve fornecer pelo menos um conjunto de dados de treinamento. Os conjuntos de dados de teste são opcionais. Use as seguintes etapas para configurar os arquivos de manifesto aumentados:
1. Em **Conjunto de dados de treinamento e teste**, expanda o painel **Localização de entrada**.
1. Em **Tipo de conjunto de dados**, escolha **Dados de treinamento** ou **Dados de teste**.
1. **Para a **localização S3 do arquivo de manifesto aumentado do SageMaker AI Ground Truth**, insira a localização do bucket Amazon S3 que contém o arquivo de manifesto ou navegue até ele escolhendo Browse S3.** O perfil do IAM que você está usando para obter permissões a fim de acessar a tarefa de treinamento deve ter permissões para leitura no bucket do S3.
1. Para os **Nomes dos atributos**, insira o nome do atributo que contém suas anotações. Se o arquivo contiver anotações de várias tarefas de rotulagem em cadeia, adicione um atributo para cada tarefa.
1. Para adicionar outro local de entrada, escolha **Adicionar local de entrada** e configure o próximo local.
1. (Opcional) Se escolheu o **Arquivo CSV** como formato de dados, use as etapas a seguir para configurar o conjunto de dados de treinamento e o conjunto de dados de teste opcional:
1. Em **Conjunto de dados de treinamento**, insira a localização do bucket do Amazon S3 que contém seu arquivo CSV de dados de treinamento ou navegue até ele escolhendo **Procurar no S3**. O perfil do IAM que você está usando para obter permissões a fim de acessar a tarefa de treinamento deve ter permissões para leitura no bucket do S3.
(Opcional) Se escolheu **Documentos nativos** como o tipo de modelo de treinamento, você também fornecerá a URL da pasta do Amazon S3 contendo os arquivos de exemplo de treinamento.
1. Em **Testar conjunto de dados**, selecione se você está fornecendo dados extras para o Amazon Comprehend testar o modelo treinado.
+ **Divisão automática**: a divisão automática seleciona automaticamente 10% dos seus dados de treinamento a fim de reservar para uso como dados de teste.
+ (Opcional) **Fornecido pelo cliente**: insira a URL do arquivo CSV de dados de teste no Amazon S3. Você também pode navegar até localização do arquivo no Amazon S3 e escolher **Selecionar pasta**.
(Opcional) Se escolher **Documentos nativos** como o tipo de modelo de treinamento, você também fornecerá a URL da pasta do Amazon S3 contendo os arquivos de teste.
1. (Opcional) Para **Modo de leitura do documento**, você pode substituir as ações padrão de extração de texto. Essa opção não é necessária para modelos de texto sem formatação, já que se aplica à extração de texto para documentos digitalizados. Para obter mais informações, consulte [Configurar opções de extração de texto](idp-set-textract-options.md).
1. (Opcional para modelos de texto sem formatação) Para **Dados de saída**, insira a localização de um bucket do Amazon S3 para salvar os dados de saída do treinamento, como a matriz de confusão. Para obter mais informações, consulte [Matriz de confusão](train-classifier-output.md#conf-matrix).
(Opcional) Se criptografar o resultado de saída da sua tarefa de treinamento, escolha **Criptografia**. Em seguida, escolha se deseja usar uma chave KMS associada à conta atual ou uma de outra conta.
+ Se estiver usando uma chave associada à conta atual, escolha o alias da chave para o **ID da chave KMS**.
+ Se você estiver usando uma chave associada a uma conta diferente, insira o ARN do alias ou ID da chave em **ID da chave KMS**.
1. Para o **Perfil do IAM**, selecione **Escolher um perfil do IAM existente** e, em seguida, escolha um perfil do IAM existente com permissões de leitura para o bucket do S3 contendo seus documentos de treinamento. O perfil deve ter uma política de confiança que comece com `comprehend.amazonaws.com` para ser válida.
Se ainda não tem um perfil do IAM com essas permissões, escolha **Criar um perfil do IAM**. Escolha as permissões de acesso para conceder esse perfil e, depois, escolha um sufixo de nome para diferenciar o perfil dos perfis do IAM em sua conta.
**nota**
Para documentos de entrada criptografados, o perfil do IAM usada também deve ter uma permissão do `kms:Decrypt`. Para obter mais informações, consulte [Permissões necessárias para usar a criptografia KMS](security_iam_id-based-policy-examples.md#auth-kms-permissions).
1. (Opcional) Para lançar seus recursos no Amazon Comprehend a partir de uma VPC, insira o ID da VPC em **VPC** ou escolha o ID na lista suspensa.
1. Escolha a sub-rede em **Sub-redes**. Depois de selecionar a primeira sub-rede, é possível escolher outras adicionais.
1. Em **Grupo(s) de segurança**, escolha o grupo de segurança a ser usado se tiver especificado um. Depois de selecionar o primeiro grupo de segurança, é possível escolher outros.
**nota**
Quando você usa uma VPC com sua tarefa de classificação, os `DataAccessRole` usados para as operações Create and Start devem ter permissões para a VPC que acessa os documentos de entrada e o bucket de saída.
1. (Opcional) Para adicionar uma tag ao classificador personalizado, insira um par de valores-chave em **Tags**. Escolha **Adicionar Tag**. Para remover esse par antes de criar o classificador, escolha **Remover tag**. Para obter mais informações, consulte [Marcando seus Recursos](tagging.md).
1. Escolha **Criar**.
O console exibe a página **Classificadores**. O novo classificador aparece na tabela, mostrando `Submitted` como seu status. Quando o classificador começa a processar os documentos de treinamento, o status muda para `Training`. Quando um classificador está pronto para uso, o status muda para `Trained` ou `Trained with warnings`. Se o status for `TRAINED_WITH_WARNINGS`, revise a pasta de arquivos ignorados no [Saída do treinamento do classificador](train-classifier-output.md).
Se o Amazon Comprehend encontrar erros durante a criação ou o treinamento, o status mudará para `In error`. Escolha uma tarefa classificadora na tabela para obter mais informações sobre o classificador, incluindo mensagens de erro.
![\[A lista de classificadores personalizados.\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/class-list.png)
# Treine classificadores personalizados (API)
Para criar e treinar um classificador personalizado, use a [CreateDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_CreateDocumentClassifier.html)operação.
Você pode monitorar o progresso da solicitação usando a [DescribeDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassifier.html)operação. Após a transição do campo `Status` para `TRAINED`, você pode usar o classificador para classificar documentos. Se o status for `TRAINED_WITH_WARNINGS`, revise a pasta de arquivos ignorados no [Saída do treinamento do classificador](train-classifier-output.md) para a operação `CreateDocumentClassifier`.
**Topics**
+ [Classificação personalizada de treinamento usando o AWS Command Line Interface](#get-started-api-customclass-cli)
+ [Usando o AWS SDK para Java ou SDK para Python](#get-started-api-customclass-java)
## Classificação personalizada de treinamento usando o AWS Command Line Interface
Os exemplos a seguir mostram como usar a `CreateDocumentClassifier` operação, a `DescribeDocumentClassificationJob` operação e outro classificador personalizado APIs com o. AWS CLI
O exemplo está formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
Crie um classificador personalizado de texto sem formatação usando a operação `create-document-classifier`.
```
aws comprehend create-document-classifier \
--region region \
--document-classifier-name testDelete \
--language-code en \
--input-data-config S3Uri=s3://S3Bucket/docclass/file name \
--data-access-role-arn arn:aws:iam::account number:role/testFlywheelDataAccess
```
Para criar um classificador personalizado nativo, forneça os seguintes parâmetros adicionais na solicitação para `create-document-classifier`.
1. DocumentType: defina o valor como SEMI\$1STRUCTURED\$1DOCUMENT.
1. Documents: a localização do S3 para os documentos de treinamento (e, opcionalmente, os documentos de teste).
1. OutputDataConfig: forneça a localização do S3 para os documentos de saída (e uma chave KMS opcional).
1. DocumentReaderConfig: campo opcional para configurações de extração de texto.
```
aws comprehend create-document-classifier \
--region region \
--document-classifier-name testDelete \
--language-code en \
--input-data-config
S3Uri=s3://S3Bucket/docclass/file name \
DocumentType \
Documents \
--output-data-config S3Uri=s3://S3Bucket/docclass/file name \
--data-access-role-arn arn:aws:iam::account number:role/testFlywheelDataAccess
```
Obtenha informações sobre um classificador personalizado com o classificador de documentos ARN usando a operação `DescribeDocumentClassifier`.
```
aws comprehend describe-document-classifier \
--region region \
--document-classifier-arn arn:aws:comprehend:region:account number:document-classifier/file name
```
Exclua um classificador personalizado usando a operação `DeleteDocumentClassifier`.
```
aws comprehend delete-document-classifier \
--region region \
--document-classifier-arn arn:aws:comprehend:region:account number:document-classifier/testDelete
```
Liste todos os classificadores personalizados na conta usando a operação `ListDocumentClassifiers`.
```
aws comprehend list-document-classifiers
--region region
```
## Usando o AWS SDK para Java ou SDK para Python
Para exemplos de SDK sobre como criar e treinar um classificador personalizado, consulte [Use `CreateDocumentClassifier` com um AWS SDK ou CLI](example_comprehend_CreateDocumentClassifier_section.md).
# Teste os dados de treinamento
Depois de treinar o modelo, o Amazon Comprehend testa o modelo de classificador personalizado. Se você não fornecer um conjunto de dados de teste, o Amazon Comprehend treina o modelo com 90% dos dados de treinamento. Ele reserva 10% dos dados de treinamento para usar nos testes. Se você fornecer um conjunto de dados de teste, os dados de teste devem incluir pelo menos um exemplo para cada rótulo único no conjunto de dados de treinamento.
O teste do modelo fornece métricas que podem ser usadas para estimar a precisão do modelo. O console exibe as métricas na seção **Desempenho do classificador** da página de **Detalhes do classificador** no console. Eles também são `Metrics` retornados nos campos retornados pela [DescribeDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassifier.html)operação.
No exemplo de dados de treinamento a seguir, há cinco rótulos: DOCUMENTÁRIO, DOCUMENTÁRIO, FICÇÃO\$1CIENTÍFICA, DOCUMENTÁRIO, COMÉDIA\$1ROMÂNTICA. Existem três classes únicas: DOCUMENTÁRIO, FICÇÃO\$1CIENTÍFICA, COMÉDIA\$1ROMÂNTICA.
| Coluna 1 | Coluna 2 |
| --- | --- |
| DOCUMENTÁRIO | texto do documento 1 |
| DOCUMENTÁRIO | texto do documento 2 |
| FICÇÃO\$1CIENTÍFICA | texto do documento 3 |
| DOCUMENTÁRIO | texto do documento 4 |
| COMÉDIA\$1ROMÂNTICA | texto do documento 5 |
Para a divisão automática (em que o Amazon Comprehend reserva 10% dos dados de treinamento para uso em testes), se os dados de treinamento contiverem exemplos limitados de um rótulo específico, o conjunto de dados de teste poderá conter zero exemplos desse rótulo. Por exemplo, se o conjunto de dados de treinamento contiver 1.000 instâncias da classe DOCUMENTÁRIO, 900 instâncias de FICÇÃO\$1CIENTÍFICA e uma única instância da classe COMÉDIA\$1ROMÂNTICA, o conjunto de dados de teste poderá conter 100 ocorrências de DOCUMENTÁRIO e 90 de FICÇÃO\$1CIENTÍFICA, mas nenhuma instância de COMÉDIA\$1ROMÂNTICA, pois há um único exemplo disponível.
Depois de terminar de treinar seu modelo, as métricas de treinamento fornecem informações que podem ser usadas para decidir se o modelo é preciso o suficiente para suas necessidades.
# Saída do treinamento do classificador
Depois que o Amazon Comprehend conclui o treinamento do modelo de classificador personalizado, ele cria arquivos de saída no local de saída do Amazon S3 que você especificou na solicitação de API ou [CreateDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_CreateDocumentClassifier.html)na solicitação de console equivalente.
O Amazon Comprehend cria uma matriz de confusão quando você treina um modelo de texto sem formatação ou um modelo de documento nativo. Ele pode criar arquivos de saída adicionais quando você treina um modelo de documento nativo.
**Topics**
+ [Matriz de confusão](#conf-matrix)
+ [Saídas adicionais para modelos de documentos nativos](#train-class-output-native)
## Matriz de confusão
Quando você treina um modelo de classificador personalizado, o Amazon Comprehend cria uma matriz de confusão que fornece métricas sobre o desempenho do modelo no treinamento. Essa matriz mostra uma matriz de rótulos que o modelo previu, em comparação com os rótulos reais do documento. O Amazon Comprehend usa uma parte dos dados de treinamento para criar a matriz de confusão.
Uma matriz de confusão fornece uma indicação de quais classes poderiam usar mais dados para melhorar o desempenho do modelo. Uma classe com uma alta fração de previsões corretas tem o maior número de resultados ao longo da diagonal da matriz. Se o número na diagonal for menor, a classe terá uma fração menor de previsões corretas. Você pode adicionar mais exemplos de treinamento para essa classe e treinar o modelo novamente. Por exemplo, se 40% das amostras do rótulo A forem classificadas como rótulo D, adicionar mais amostras para o rótulo A e o rótulo D aumentará o desempenho do classificador.
Depois que o Amazon Comprehend cria o modelo classificador, a matriz de confusão fica disponível no arquivo `confusion_matrix.json` no local de saída do S3.
O formato da matriz de confusão varia, dependendo se você treinou seu classificador usando o modo multiclasse ou o multirrótulo.
**Topics**
+ [Matriz de confusão para o modo multiclasse](#m-c-matrix)
+ [Matriz de confusão para o modo multirrótulo](#m-l-matrix)
### Matriz de confusão para o modo multiclasse
No modo multiclasse, as classes individuais são mutuamente exclusivas, então a classificação atribui um rótulo a cada documento. Por exemplo, um animal pode ser um cachorro ou um gato, mas não os dois ao mesmo tempo.
Considere o exemplo a seguir de uma matriz de confusão para um classificador treinado em várias classes:
```
A B X Y <-(predicted label)
A 1 2 0 4
B 0 3 0 1
X 0 0 1 0
Y 1 1 1 1
^
|
(actual label)
```
Nesse caso, o modelo previu o seguinte:
+ Um rótulo “A” foi previsto com precisão, dois rótulos “A” foram previstos incorretamente como rótulos “B” e quatro rótulos “A” foram previstos incorretamente como rótulos “Y”.
+ Três rótulos “B” foram previstos com precisão e um rótulo “B” foi previsto incorretamente como um rótulo “Y”.
+ Um “X” foi previsto com precisão.
+ Um rótulo “Y” foi previsto com precisão, um foi previsto incorretamente como rótulo “A”, um foi previsto incorretamente como rótulo “B” e um foi previsto incorretamente como rótulo “X”.
A linha diagonal na matriz (A:A, B:B, X:X e Y:Y) mostra as previsões precisas. Os erros de predição são os valores fora da diagonal. Nesse caso, a matriz mostra as seguintes taxas de erro de predição:
+ Rótulos A: 86%
+ Rótulos B: 25%
+ Rótulos X: 0%
+ Rótulos Y: 75%
O classificador retorna a matriz de confusão como um arquivo no formato JSON. O arquivo JSON a seguir representa a matriz do exemplo anterior.
```
{
"type": "multi_class",
"confusion_matrix": [
[1, 2, 0,4],
[0, 3, 0, 1],
[0, 0, 1, 0],
[1, 1, 1, 1]],
"labels": ["A", "B", "X", "Y"],
"all_labels": ["A", "B", "X", "Y"]
}
```
### Matriz de confusão para o modo multirrótulo
No modo multirrótulo, a classificação pode atribuir uma ou mais classes a um documento. Considere o exemplo a seguir de uma matriz de confusão para um classificador treinado em várias classes.
Neste exemplo, há três rótulos possíveis: `Comedy`, `Action` e `Drama`. A matriz de confusão de vários rótulos cria uma matriz 2x2 para cada rótulo.
```
Comedy Action Drama
No Yes No Yes No Yes <-(predicted label)
No 2 1 No 1 1 No 3 0
Yes 0 2 Yes 2 1 Yes 1 1
^ ^ ^
| | |
|-----------(was this label actually used)--------|
```
Nesse caso, o modelo retornou o seguinte para o rótulo de `Comedy`:
+ Dois casos em que foi prevista a presença de um rótulo de `Comedy` com precisão. True positive (TP — verdadeiro positivo ).
+ Duas instâncias em que se previu com precisão a ausência de um rótulo de `Comedy`. True negative (TN — falso verdadeiro)
+ Zero instâncias em que a presença de um rótulo de `Comedy` foi prevista incorretamente. False positive (FP — falso positivo)
+ Uma instância em que foi prevista incorretamente a ausência de um rótulo de `Comedy`. False negative (FN — falso negativo)
Assim como em uma matriz de confusão multiclasse, a linha diagonal em cada matriz mostra as previsões precisas.
Nesse caso, o modelo previu rótulos de `Comedy` com precisão em 80% das vezes (TP mais TN) e os previu incorretamente em 20% das vezes (FP mais FN).
O classificador retorna a matriz de confusão como um arquivo no formato JSON. O arquivo JSON a seguir representa a matriz do exemplo anterior.
```
{
"type": "multi_label",
"confusion_matrix": [
[[2, 1],
[0, 2]],
[[1, 1],
[2, 1]],
[[3, 0],
[1, 1]]
],
"labels": ["Comedy", "Action", "Drama"]
"all_labels": ["Comedy", "Action", "Drama"]
}
```
## Saídas adicionais para modelos de documentos nativos
O Amazon Comprehend pode criar arquivos de saída adicionais quando você treina um modelo de documento nativo.
### Saída do Amazon Textract
Se o Amazon Comprehend invocou o Amazon Textract APIs para extrair texto para qualquer um dos documentos de treinamento, ele salvará os arquivos de saída do Amazon Textract no local de saída do S3. Ele usa a seguinte estrutura de diretórios:
+ **Documentos de treinamento:**
`amazon-textract-output/train///textract_output.json`
+ **Documentos de teste:**
`amazon-textract-output/test///textract_output.json`
O Amazon Comprehend preenche a pasta de teste se você tiver fornecido documentos de teste na solicitação da API.
### Falhas de anotação de documento
O Amazon Comprehend cria os seguintes arquivos no local de saída do Amazon S3 (na pasta **documentos\$1ignorados/**) se houver alguma falha na anotação:
+ failed\$1annotations\$1train.jsonl
O arquivo existe se alguma anotação falhar nos dados de treinamento.
+ failed\$1annotations\$1test.jsonl
O arquivo existe se a solicitação incluiu dados de teste e qualquer anotação falhou nos dados de teste.
Os arquivos de anotação com falha são arquivos JSONL com o seguinte formato:
```
{
"File": "String", "Page": Number, "ErrorCode": "...", "ErrorMessage": "..."}
{"File": "String", "Page": Number, "ErrorCode": "...", "ErrorMessage": "..."
}
```
# Métricas de classificador personalizados
O Amazon Comprehend fornece métricas para ajudar você a estimar o desempenho de um classificador personalizado. O Amazon Comprehend calcula as métricas usando os dados de teste da tarefa de treinamento do classificador. As métricas representam com precisão o desempenho do modelo durante o treinamento, portanto, elas se aproximam do desempenho do modelo para classificação de dados semelhantes.
Use operações de API, como [DescribeDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassifier.html)recuperar as métricas de um classificador personalizado.
**nota**
Consulte [Métricas: Precisão, recall e FScore](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_fscore_support.html) para uma compreensão das métricas subjacentes de Precisão, Recall e pontuação F1. Essas métricas são definidas em nível de classe. O Amazon Comprehend usa a média **macro** para combinar essas métricas no conjunto de testes P, R e F1, conforme discutido a seguir.
**Topics**
+ [Metrics](#cer-doc-class-metrics)
+ [Melhorar o desempenho do seu classificador personalizado](#improving-metrics-doc)
## Metrics
O Amazon Comprehend é compatível com as seguintes métricas:
**Topics**
+ [Precisão](#class-accuracy-metric)
+ [Precisão (precisão macro)](#class-macroprecision-metric)
+ [Recall (recall macro)](#class-macrorecall-metric)
+ [Pontuação F1 (macro pontuação F1)](#class-macrof1score-metric)
+ [Perda de Hamming](#class-hammingloss-metric)
+ [Micro precisão](#class-microprecision-metric)
+ [Micro recall](#class-microrecall-metric)
+ [Pontuação Micro F1](#class-microf1score-metric)
Para visualizar as métricas de um classificador, abra a página **Detalhes do classificador** no console.
![\[Métricas de classificador personalizados\]](http://docs.aws.amazon.com/pt_br/comprehend/latest/dg/images/classifierperformance.png)
### Precisão
A precisão indica a porcentagem de rótulos dos dados de teste que o modelo previu com precisão. Para calcular a precisão, divida o número de rótulos previstos com precisão nos documentos de teste pelo número total de rótulos nos documentos de teste.
Por exemplo
| Rótulo real | Rótulo previsto | Preciso/Incorreto |
| --- | --- | --- |
| 1 | 1 | Preciso |
| 0 | 1 | Incorreto |
| 2 | 3 | Incorreto |
| 3 | 3 | Preciso |
| 2 | 2 | Preciso |
| 1 | 1 | Preciso |
| 3 | 3 | Preciso |
A precisão consiste no número de previsões precisas dividido pelo número geral de amostras de teste = 5/7 = 0,714 ou 71,4%
### Precisão (precisão macro)
A precisão é uma medida da utilidade dos resultados do classificador nos dados do teste. É definido como o número de documentos classificados com precisão, dividido pelo número total de classificações da turma. Alta precisão significa que o classificador retornou resultados significativamente mais relevantes do que resultados irrelevantes.
A métrica de `Precision` também é conhecida como *Precisão macro*.
O exemplo a seguir mostra resultados de precisão para um conjunto de testes.
| Rótulo | Tamanho da amostra | Precisão do rótulo |
| --- | --- | --- |
| Rótulo\$11 | 400 | 0.75 |
| Rótulo\$12 | 300 | 0,80 |
| Rótulo\$13 | 30000 | 0.90 |
| Rótulo\$14 | 20 | 0.50 |
| Rótulo\$15 | 10 | 0,40 |
A métrica de precisão (Precisão macro) para o modelo é, portanto:
```
Macro Precision = (0.75 + 0.80 + 0.90 + 0.50 + 0.40)/5 = 0.67
```
### Recall (recall macro)
Isso indica a porcentagem de categorias corretas em seu texto que o modelo pode prever. Essa métrica vem da média das pontuações de recall de todos os rótulos disponíveis. O recall é uma medida do quanto os resultados do classificador estão completos para os dados do teste.
Um alto recall significa que o classificador retornou a maioria dos resultados relevantes.
A métrica de `Recall` também é conhecida como *Recall macro*.
O exemplo a seguir mostra resultados de recall para um conjunto de testes.
| Rótulo | Tamanho da amostra | Recall de rótulo |
| --- | --- | --- |
| Rótulo\$11 | 400 | 0,70 |
| Rótulo\$12 | 300 | 0,70 |
| Rótulo\$13 | 30000 | 0,98 |
| Rótulo\$14 | 20 | 0,80 |
| Rótulo\$15 | 10 | 0.10 |
A métrica recall (Recall macro) para o modelo é, portanto:
```
Macro Recall = (0.70 + 0.70 + 0.98 + 0.80 + 0.10)/5 = 0.656
```
### Pontuação F1 (macro pontuação F1)
A pontuação F1 é derivada dos valores de `Precision` e de `Recall`. Ele mede a precisão geral do classificador. A pontuação mais alta é 1 e a mais baixa é 0.
*O Amazon Comprehend calcula a Macro pontuação F1*. É a média não ponderada das pontuações F1 dos rótulos. Utilizar o seguinte conjunto de testes como exemplo:
| Rótulo | Tamanho da amostra | Pontuação F1 do rótulo |
| --- | --- | --- |
| Rótulo\$11 | 400 | 0,724 |
| Rótulo\$12 | 300 | 0,824 |
| Rótulo\$13 | 30000 | 0,94 |
| Rótulo\$14 | 20 | 0,62 |
| Rótulo\$15 | 10 | 0,16 |
A Macro F1 Score (macro pontuação F1) para o modelo é calculada da seguinte forma:
```
Macro F1 Score = (0.724 + 0.824 + 0.94 + 0.62 + 0.16)/5 = 0.6536
```
### Perda de Hamming
A fração de rótulos previstos incorretamente. Também é visto como a fração de rótulos incorretos em comparação com o número total de rótulos. Pontuações próximas a zero são melhores.
### Micro precisão
Original:
Semelhante à métrica de precisão, exceto que a micro precisão é baseada na pontuação geral de todas as pontuações de precisão somadas.
### Micro recall
Semelhante à métrica de recall, exceto que o micro recall é baseado na pontuação geral de todas as pontuações de recall somadas.
### Pontuação Micro F1
A Pontuação Micro F1 é uma combinação das métricas de micro precisão e micro recall.
## Melhorar o desempenho do seu classificador personalizado
As métricas fornecem uma visão sobre o desempenho do seu classificador personalizado durante uma tarefa de classificação. Se as métricas forem baixas, o modelo de classificação pode não ser eficaz para seu caso de uso. Você tem várias opções para melhorar o desempenho do classificador:
1. Em seus dados de treinamento, dê exemplos concretos que definam uma separação clara das categorias. Por exemplo, forneça documentos que usem exclusivos words/sentences para representar a categoria.
1. Adicione mais dados para rótulos pouco representados em seus dados de treinamento.
1. Tente reduzir a distorção nas categorias. Se o maior rótulo em seus dados tiver mais de 10 vezes os documentos no menor rótulo, tente aumentar o número de documentos para o menor rótulo. Reduza a taxa de inclinação para no máximo 10:1 entre classes altamente representadas e menos representadas. Você também pode remover documentos de entrada das classes altamente representadas.
# Executar análises em tempo real
Depois de treinar um classificador personalizado, você pode classificar documentos usando análise em tempo real. A análise em tempo real usa um único documento como entrada e retorna os resultados de forma síncrona. A classificação personalizada aceita uma variedade de tipos de documentos como entradas para análise em tempo real. Para obter detalhes, consulte [Entradas para análise personalizada em tempo real](idp-inputs-sync.md).
Se você planeja analisar arquivos de imagem ou documentos PDF digitalizados, sua política do IAM deve conceder permissões para usar dois métodos da API Amazon Textract DetectDocumentText ( AnalyzeDocumente). O Amazon Comprehend invoca esses métodos durante a extração de texto. Para visualizar um exemplo de política, consulte [Permissões necessárias para executar ações de análise de documentos](security_iam_id-based-policy-examples.md#security-iam-based-policy-perform-cmp-actions).
Você deve criar um endpoint para executar análises em tempo real usando um modelo de classificação personalizado.
**Topics**
+ [Análise em tempo real para classificação personalizada (console)](custom-sync.md)
+ [Análise em tempo real para classificação personalizada (API)](class-sync-api.md)
+ [Saídas para análise em tempo real](outputs-class-sync.md)
# Análise em tempo real para classificação personalizada (console)
Use o console do Amazon Comprehend para executar análises em tempo real usando um modelo de classificação personalizado.
Você cria um endpoint para executar a análise em tempo real. Um endpoint inclui recursos gerenciados que disponibilizam seu modelo personalizado para inferência em tempo real.
Para informações sobre o fornecimento do throughput do endpoint e os custos associados, consulte [Utilizar endpoints do Amazon Comprehend](using-endpoints.md).
**Topics**
+ [Criar um endpoint para classificação personalizada](#create-endpoint)
+ [Executar classificação personalizada em tempo real](#cc-real-time-analysis)
## Criar um endpoint para classificação personalizada
**Criar um endpoint (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Comprehend em [https://console.aws.amazon.com/comprehend/](https://console.aws.amazon.com/comprehend/)
1. No menu à esquerda, escolha **Endpoints** e, depois, o botão **Criar endpoint**. A tela **Criar endpoint** é aberta.
1. Dê um nome ao endpoint. O nome deve ser exclusivo na sua conta e região atual.
1. Escolha um modelo personalizado ao qual você deseja anexar o novo endpoint. No menu suspenso, pesquise pelo nome do modelo.
**nota**
Crie um modelo antes de poder anexar um endpoint a ele. Se ainda não tiver um modelo, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
1. (Opcional) para adicionar uma tag ao endpoint, insira um par de valores-chave em **Tags** e escolha **Adicionar tag**. Para remover esse par antes de criar o endpoint, escolha **Remover tag**
1. Insira o número de unidades de inferência (IUs) a serem atribuídas ao ponto final. Cada IU representa um throughput de 100 caracteres por segundo para até dois documentos por segundo. Para mais informações sobre o throughput do endpoint, consulte [Utilizar endpoints do Amazon Comprehend](using-endpoints.md).
1. (Opcional) Se você estiver criando um novo endpoint, terá a opção de usar o estimador de IU. Dependendo do throughput ou do número de caracteres que deseja analisar por segundo, pode ser difícil saber quantas IUs você precisa. Essa etapa opcional pode ajudá-lo a determinar o número de solicitações IUs a serem solicitadas.
1. Em **Resumo da compra**, analise seu custo estimado de endpoint por hora, dia e mês.
1. Marque a caixa de seleção se você está ciente de que sua conta incorre em cobranças pelo endpoint desde o momento em que ele é iniciado até que você o exclua.
1. Escolha **Criar endpoint**
## Executar classificação personalizada em tempo real
Após criar um endpoint, você poderá executar análises em tempo real usando seu modelo personalizado. Há duas maneiras de executar análises em tempo real a partir do console. Você pode inserir texto ou fazer upload de um arquivo, conforme mostrado a seguir.
**Executar análises em tempo real usando um modelo personalizado (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Comprehend em [https://console.aws.amazon.com/comprehend/](https://console.aws.amazon.com/comprehend/)
1. No menu à esquerda, escolha **Análise em tempo real**.
1. Em **Tipo de entrada**, escolha **Personalizado** para o **Tipo de análise**.
1. Em **Tipo de modelo personalizado**, escolha **Classificação personalizada**.
1. Em **Endpoint**, escolha o endpoint que deseja usar. Esse endpoint está vinculado a um modelo personalizado específico.
1. Para especificar os dados de entrada para análise, insira um texto ou carregue um arquivo.
+ Inserir texto:
1. Escolha **Texto de entrada**.
1. Insira o texto que deseja analisar.
+ Como carregar um arquivo:
1. Escolha **Fazer upload de arquivo** e insira o nome do arquivo para fazer o upload.
1. (Opcional) Em **Ações de leitura avançadas**, você pode substituir as ações padrão para extração de texto. Para obter detalhes, consulte [Configurar opções de extração de texto](idp-set-textract-options.md)
Para melhores resultados, combine o tipo de entrada com o tipo de modelo do classificador. O console exibirá um aviso se você enviar um documento nativo para um modelo de texto sem formatação ou texto sem formatação para um modelo de documento nativo. Para obter mais informações, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
1. Escolha **Analisar**. O Amazon Comprehend analisa os dados de entrada usando seu modelo personalizado. O Amazon Comprehend exibe as classes descobertas, junto com uma avaliação de confiança para cada classe.
# Análise em tempo real para classificação personalizada (API)
Você pode usar a API do Amazon Comprehend para executar a classificação em tempo real com um modelo personalizado. Primeiro, crie um endpoint para executar a análise em tempo real. Depois de criá-lo, execute a classificação em tempo real.
Os exemplos nesta seção usam formatos de comando para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
Para informações sobre o fornecimento do throughput do endpoint e os custos associados, consulte [Utilizar endpoints do Amazon Comprehend](using-endpoints.md).
**Topics**
+ [Criar um endpoint para classificação personalizada](#create-endpoint-api)
+ [Executar classificação personalizada em tempo real](#cc-real-time-analysis-api)
## Criar um endpoint para classificação personalizada
O exemplo a seguir mostra a operação da [CreateEndpoint](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_CreateEndpoint.html)API usando AWS CLI o.
```
aws comprehend create-endpoint \
--desired-inference-units number of inference units \
--endpoint-name endpoint name \
--model-arn arn:aws:comprehend:region:account-id:model/example \
--tags Key=My1stTag,Value=Value1
```
O Amazon Comprehend responde com o seguinte:
```
{
"EndpointArn": "Arn"
}
```
## Executar classificação personalizada em tempo real
Depois de criar um endpoint para seu modelo de classificação personalizado, você usa o endpoint para executar a operação da [ClassifyDocument](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ClassifyDocument.html)API. Você pode fornecer entrada de texto usando os parâmetros`text` ou `bytes`. Insira os outros tipos de entrada usando o parâmetro `bytes`.
Para arquivos de imagem e arquivos PDF, você pode usar o parâmetro `DocumentReaderConfig` para substituir as ações padrão de extração de texto. Para obter detalhes, consulte [Configurar opções de extração de texto](idp-set-textract-options.md)
Para melhores resultados, combine o tipo de entrada com o tipo de modelo do classificador. A resposta da API inclui um aviso se você enviar um documento nativo para um modelo de texto sem formatação ou um arquivo de texto sem formatação para um modelo de documento nativo. Para obter mais informações, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
### Usando o AWS Command Line Interface
Os exemplos a seguir demonstram como usar o comando CLI *classify-document*.
#### Classifique o texto usando o AWS CLI
O exemplo a seguir executa a classificação em tempo real em um bloco de texto.
```
aws comprehend classify-document \
--endpoint-arn arn:aws:comprehend:region:account-id:endpoint/endpoint name \
--text 'From the Tuesday, April 16th, 1912 edition of The Guardian newspaper: The maiden voyage of the White Star liner Titanic,
the largest ship ever launched ended in disaster. The Titanic started her trip from Southampton for New York on Wednesday. Late
on Sunday night she struck an iceberg off the Grand Banks of Newfoundland. By wireless telegraphy she sent out signals of distress,
and several liners were near enough to catch and respond to the call.'
```
O Amazon Comprehend responde com o seguinte:
```
{
"Classes": [
{
"Name": "string",
"Score": 0.9793661236763
}
]
}
```
#### Classifique um documento semiestruturado usando o AWS CLI
Para analisar a classificação personalizada de um arquivo PDF, Word ou de imagem, execute o comando `classify-document` com o arquivo de entrada no parâmetro `bytes`.
O exemplo a seguir usa uma imagem como arquivo de entrada. Ele usa a opção `fileb` para codificar em base 64 os bytes do arquivo de imagem. Para obter mais informações, consulte [Objetos binários grandes](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-types.html#parameter-type-blob) no Guia AWS Command Line Interface do usuário.
Esse exemplo também passa um arquivo JSON chamado `config.json` para definir as opções de extração de texto.
```
$ aws comprehend classify-document \
> --endpoint-arn arn \
> --language-code en \
> --bytes fileb://image1.jpg \
> --document-reader-config file://config.json
```
O arquivo **config.json** contém o conteúdo a seguir.
```
{
"DocumentReadMode": "FORCE_DOCUMENT_READ_ACTION",
"DocumentReadAction": "TEXTRACT_DETECT_DOCUMENT_TEXT"
}
```
O Amazon Comprehend responde com o seguinte:
```
{
"Classes": [
{
"Name": "string",
"Score": 0.9793661236763
}
]
}
```
Para obter mais informações, consulte a [ClassifyDocument](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ClassifyDocument.html)Referência da *API Amazon Comprehend*.
# Saídas para análise em tempo real
## Saídas para entradas de texto
Para entradas de texto, a saída inclui a lista de classes ou rótulos identificados pela análise do classificador. O exemplo a seguir mostra uma lista com duas classes.
```
"Classes": [
{
"Name": "abc",
"Score": 0.2757999897003174,
"Page": 1
},
{
"Name": "xyz",
"Score": 0.2721000015735626,
"Page": 1
}
]
```
## Saídas para entradas semiestruturadas
Para um documento de entrada semiestruturado ou um arquivo de texto, a saída pode incluir os seguintes campos adicionais:
+ DocumentMetadata — Extração de informações sobre o documento. Os metadados incluem uma lista de páginas no documento, com o número de caracteres extraídos de cada página. Esse campo estará presente na resposta se a solicitação incluir o parâmetro `Byte`.
+ DocumentType — O tipo de documento para cada página no documento de entrada. Esse campo estará presente na resposta se a solicitação incluir o parâmetro `Byte`.
+ Erros: erros no nível da página que o sistema detectou ao processar o documento de entrada. O campo estará vazio se o sistema não encontrar erros.
+ Avisos: avisos detectados durante o processamento do documento de entrada. A resposta inclui um aviso se houver uma incompatibilidade entre o tipo de documento de entrada e o tipo de modelo associado ao endpoint que você especificou. O campo ficará vazio se o sistema não tiver gerado nenhum aviso.
Para obter mais detalhes sobre esses campos de saída, consulte a [ClassifyDocument](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ClassifyDocument.html)Referência da *API Amazon Comprehend*.
O exemplo a seguir mostra a saída para um documento de entrada PDF nativo de uma página.
```
{
"Classes": [
{
"Name": "123",
"Score": 0.39570000767707825,
"Page": 1
},
{
"Name": "abc",
"Score": 0.2757999897003174,
"Page": 1
},
{
"Name": "xyz",
"Score": 0.2721000015735626,
"Page": 1
}
],
"DocumentMetadata": {
"Pages": 1,
"ExtractedCharacters": [
{
"Page": 1,
"Count": 2013
}
]
},
"DocumentType": [
{
"Page": 1,
"Type": "NATIVE_PDF"
}
]
}
```
# Executar tarefas assíncronas
Depois de treinar um classificador personalizado, use tarefas assíncronas para analisar documentos grandes ou vários documentos em um lote.
A classificação personalizada aceita uma variedade de tipos de documentos de entrada. Para obter detalhes, consulte [Entradas para análise personalizada assíncrona](idp-inputs-async.md).
Se você planeja analisar arquivos de imagem ou documentos PDF digitalizados, sua política do IAM deve conceder permissões para usar dois métodos da API Amazon Textract DetectDocumentText ( AnalyzeDocumente). O Amazon Comprehend invoca esses métodos durante a extração de texto. Para visualizar um exemplo de política, consulte [Permissões necessárias para executar ações de análise de documentos](security_iam_id-based-policy-examples.md#security-iam-based-policy-perform-cmp-actions).
Para classificação de documentos semiestruturados (arquivos de imagem, PDF ou Docx) usando um modelo de texto sem formatação, use o formato de entrada `one document per file`. Além disso, inclua o `DocumentReaderConfig` parâmetro em sua [StartDocumentClassificationJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StartDocumentClassificationJob.html)solicitação.
**Topics**
+ [Formatos de arquivo para análise assíncrona](class-inputs-async.md)
+ [Tarefas de análise para classificação personalizada (console)](analysis-jobs-custom-classifier.md)
+ [Tarefas de análise para classificação personalizada (API)](analysis-jobs-custom-class-api.md)
+ [Saídas para trabalhos de análise assíncrona](outputs-class-async.md)
# Formatos de arquivo para análise assíncrona
Ao executar a análise assíncrona com seu modelo, você tem uma escolha de formatos para documentos de entrada: `One document per line` ou `one document per file`. O formato usado depende do tipo de documento que deseja analisar, conforme descrito na tabela a seguir.
| Description | Formato |
| --- | --- |
| A entrada contém vários arquivos. Cada arquivo contém um documento de entrada. Esse formato é ideal para coleções de documentos grandes, como artigos de jornal ou artigos científicos. Além disso, use esse formato para documentos semiestruturados (arquivos de imagem, PDF ou Docx) usando um classificador de documentos nativo. | Um documento por arquivo |
| A entrada é um ou mais arquivos. Cada linha no arquivo é um documento de entrada separado. Esse formato é ideal para documentos curtos, como mensagens de texto ou publicações em redes sociais. | Um documento por linha |
**Um documento por arquivo**
Com o formato `one document per file`, cada arquivo representa um documento de entrada.
**Um documento por linha**
Com o formato `One document per line`, cada documento é colocado em uma linha separada e nenhum cabeçalho é usado. O rótulo não está incluído em cada linha (já que você ainda não conhece o rótulo do documento). Cada linha do arquivo (o final do documento individual) deve terminar com uma alimentação de linha (LF,\$1n), uma devolução de carro (CR,\$1 r) ou ambas (CRLF, \$1r\$1n). Não use o separador de linha UTF-8 (u\$12028) para finalizar uma linha.
O exemplo a seguir mostra o formato do arquivo de entrada.
```
Text of document 1 \n
Text of document 2 \n
Text of document 3 \n
Text of document 4 \n
```
Para qualquer formato, use a codificação UTF-8 para arquivos de texto. Depois de preparar os arquivos, coloque-os no bucket do S3 que está usando para os dados de entrada.
Ao iniciar uma tarefa de classificação, você especifica esse local do Amazon S3 para seus dados de entrada. O URI deve estar na mesma região que a API do endpoint que você está chamando. O URI pode apontar para um único arquivo (como ao usar o método “um documento por linha”) ou pode ser o prefixo de uma coleção de arquivos de dados.
Por exemplo, se você usar o URI `S3://bucketName/prefix`, se o prefixo for um único arquivo, o Amazon Comprehend usará esse arquivo como entrada. Se mais de um arquivo começar com o prefixo, o Amazon Comprehend usará todos eles como entrada.
Conceda ao Amazon Comprehend acesso ao bucket do S3 contendo sua coleção de documentos e arquivos de saída. Para obter mais informações, consulte [Permissões baseadas em perfis necessárias para operações assíncronas](security_iam_id-based-policy-examples.md#auth-role-permissions).
# Tarefas de análise para classificação personalizada (console)
Depois de criar e treinar um [classificador de documentos personalizado](), use o console para executar tarefas de classificação personalizadas com o modelo.
**Criar uma tarefa de classificação personalizada (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Comprehend em [https://console.aws.amazon.com/comprehend/](https://console.aws.amazon.com/comprehend/)
1. No menu à esquerda, escolha **Tarefas de análise** e, em seguida, **Criar tarefa**.
1. Dê um nome ao trabalho de classificação. O nome deve ser exclusivo na sua conta e na sua região atual.
1. Em **Tipo de análise**, escolha **Classificação personalizada**.
1. Em **Selecionar classificador**, escolha o classificador personalizado a ser usado.
1. (Opcional) Se você optar por criptografar os dados que o Amazon Comprehend usa ao processar sua tarefa, escolha **Criptografia de tarefas**. Em seguida, escolha se deseja usar uma chave KMS associada à conta atual ou uma de outra conta.
+ Se estiver usando uma chave associada à conta atual, escolha o ID da chave para o **ID da chave KMS**.
+ Se estiver usando uma chave associada a uma conta diferente, insira o ARN do ID da chave em **ARN da chave KMS**.
**nota**
Para obter mais informações sobre como criar e usar chaves KMS e a criptografia associada, consulte [Serviço de gerenciamento de chaves (KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
1. Em **Dados de entrada**, insira a localização do bucket do Amazon S3 contendo seus documentos de entrada ou navegue até ele escolhendo **Procurar no S3**. Esse bucket deve estar na mesma região da API que você está chamando. O perfil do IAM que você está usando para obter permissões de acesso à tarefa de classificação deve ter permissões de leitura para o bucket do S3.
Para alcançar o mais alto nível de precisão no treinamento de um modelo, combine o tipo de entrada com o tipo de modelo do classificador. A tarefa classificadora retornará um aviso se você enviar documentos nativos para um modelo de texto sem formatação ou documentos de texto sem formatação para um modelo de documento nativo. Para obter mais informações, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
1. (Opcional) Em **Formato de entrada**, escolha o formato dos documentos de entrada. O formato pode ser um documento por arquivo ou um documento por linha em um único arquivo. Um documento por linha se aplica somente a documentos de texto.
1. (Opcional) Para **Modo de leitura do documento**, você pode substituir as ações padrão de extração de texto. Para obter mais informações, consulte [Configurar opções de extração de texto](idp-set-textract-options.md).
1. Em **Dados de saída**, insira a localização do bucket do Amazon S3 em que o Amazon Comprehend deve gravar os dados de saída da tarefa ou navegar até elas escolhendo **Procurar no S3** Esse bucket deve estar na mesma região da API que você está chamando. O perfil do IAM que você está usando para obter permissões de acesso à tarefa de classificação deve ter permissões de gravação para o bucket do S3.
1. (Opcional) Se optar por criptografar o resultado de saída da sua tarefa, escolha **Criptografia**. Em seguida, escolha se deseja usar uma chave KMS associada à conta atual ou uma de outra conta.
+ Se você estiver usando uma chave associada à conta atual, escolha o alias ou ID da chave para o **ID da chave KMS**.
+ Se você estiver usando uma chave associada a uma conta diferente, insira o ARN do alias ou ID da chave em **ID da chave KMS**.
1. (Opcional) Para lançar seus recursos no Amazon Comprehend a partir de uma VPC, insira o ID da VPC em **VPC** ou escolha o ID na lista suspensa.
1. Escolha a sub-rede em **Sub-rede(s)**. Depois de selecionar a primeira sub-rede, é possível escolher outras adicionais.
1. Em **Grupo(s) de segurança**, escolha o grupo de segurança a ser usado se tiver especificado um. Depois de selecionar o primeiro grupo de segurança, é possível escolher outros.
**nota**
Quando você usa uma VPC com sua tarefa de classificação, o `DataAccessRole` usado para as operações Create and Start deve conceder permissões à VPC que acessa o bucket de saída.
1. Escolha **Criar tarefa** para criar a tarefa de classificação de documentos.
# Tarefas de análise para classificação personalizada (API)
Depois de [criar e treinar](train-custom-classifier-api.md) um classificador de documentos personalizado, use o classificador para executar tarefas de análise.
Use a [StartDocumentClassificationJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StartDocumentClassificationJob.html)operação para começar a classificar documentos sem rótulos. Você especifica o bucket do S3 que contém os documentos de entrada, o bucket do S3 para os documentos de saída e o classificador a ser usado.
Para alcançar o mais alto nível de precisão no treinamento de um modelo, combine o tipo de entrada com o tipo de modelo do classificador. A tarefa classificadora retornará um aviso se você enviar documentos nativos para um modelo de texto sem formatação ou documentos de texto sem formatação para um modelo de documento nativo. Para obter mais informações, consulte [Modelos de classificação de treinamento](training-classifier-model.md).
[StartDocumentClassificationJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_StartDocumentClassificationJob.html)é assíncrono. Depois de iniciar o trabalho, use a [DescribeDocumentClassificationJob](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassificationJob.html)operação para monitorar seu progresso. Quando o campo `Status` na resposta exibir `COMPLETED`, você poderá acessar a saída no local especificado.
**Topics**
+ [Usando o AWS Command Line Interface](#get-started-api-customclass-cli)
+ [Usando o AWS SDK para Java ou SDK para Python](#get-started-api-customclass-java)
## Usando o AWS Command Line Interface
Os exemplos a seguir são a `StartDocumentClassificationJob` operação e outro classificador personalizado APIs com o. AWS CLI
Os exemplos a seguir usam o formato de comando para Unix, Linux e macOS. Para Windows, substitua o caractere de continuação Unix de barra invertida (\$1) no final de cada linha por um circunflexo (^).
Execute uma tarefa de classificação personalizada usando a operação `StartDocumentClassificationJob`.
```
aws comprehend start-document-classification-job \
--region region \
--document-classifier-arn arn:aws:comprehend:region:account number:document-classifier/testDelete \
--input-data-config S3Uri=s3://S3Bucket/docclass/file name,InputFormat=ONE_DOC_PER_LINE \
--output-data-config S3Uri=s3://S3Bucket/output \
--data-access-role-arn arn:aws:iam::account number:role/resource name
```
Obtenha informações sobre um classificador personalizado com o ID da tarefa usando a operação `DescribeDocumentClassificationJob`.
```
aws comprehend describe-document-classification-job \
--region region \
--job-id job id
```
Liste todas as tarefas de classificação personalizada em sua conta usando a operação `ListDocumentClassificationJobs`.
```
aws comprehend list-document-classification-jobs
--region region
```
## Usando o AWS SDK para Java ou SDK para Python
Para exemplos de SDK sobre como iniciar um classificador personalizado, consulte [Use `StartDocumentClassificationJob` com um AWS SDK ou CLI](example_comprehend_StartDocumentClassificationJob_section.md).
# Saídas para trabalhos de análise assíncrona
Depois que uma tarefa de análise é concluída, ela armazena os resultados no bucket do S3 que você especificou na solicitação.
## Saídas para entradas de texto
Para qualquer formato de documentos de entrada de texto (com várias classes ou com vários rótulos), a saída da tarefa consiste em um único arquivo chamado `output.tar.gz`. É um arquivo compactado contendo um arquivo de texto com a saída.
**Saída multiclasse**
Quando você usa um classificador treinado no modo multiclasse, seus resultados exibem as `classes`. Cada uma dessas `classes` é a classe usada para criar o conjunto de categorias ao treinar seu classificador.
Para obter mais detalhes sobre esses campos de saída, consulte a [ClassifyDocument](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ClassifyDocument.html)Referência da *API Amazon Comprehend*.
Os exemplos a seguir usam as seguintes classes mutuamente exclusivas.
```
DOCUMENTARY
SCIENCE_FICTION
ROMANTIC_COMEDY
SERIOUS_DRAMA
OTHER
```
Se o formato dos dados de entrada for um documento por linha, o arquivo de saída conterá uma linha para cada linha na entrada. Cada linha inclui o nome do arquivo, o número da linha com base em zero da linha de entrada e a classe ou classes encontradas no documento. Termina com a confiança que o Amazon Comprehend tem de que a instância individual foi classificada corretamente.
Por exemplo:
```
{"File": "file1.txt", "Line": "0", "Classes": [{"Name": "Documentary", "Score": 0.8642}, {"Name": "Other", "Score": 0.0381}, {"Name": "Serious_Drama", "Score": 0.0372}]}
{"File": "file1.txt", "Line": "1", "Classes": [{"Name": "Science_Fiction", "Score": 0.5}, {"Name": "Science_Fiction", "Score": 0.0381}, {"Name": "Science_Fiction", "Score": 0.0372}]}
{"File": "file2.txt", "Line": "2", "Classes": [{"Name": "Documentary", "Score": 0.1}, {"Name": "Documentary", "Score": 0.0381}, {"Name": "Documentary", "Score": 0.0372}]}
{"File": "file2.txt", "Line": "3", "Classes": [{"Name": "Serious_Drama", "Score": 0.3141}, {"Name": "Other", "Score": 0.0381}, {"Name": "Other", "Score": 0.0372}]}
```
Se o formato dos dados de entrada for um documento por arquivo, o arquivo de saída conterá uma linha para cada documento. Cada linha tem o nome do arquivo e a classe ou classes encontradas no documento. Termina com a confiança de que o Amazon Comprehend classificou a instância individual com precisão.
Por exemplo:
```
{"File": "file0.txt", "Classes": [{"Name": "Documentary", "Score": 0.8642}, {"Name": "Other", "Score": 0.0381}, {"Name": "Serious_Drama", "Score": 0.0372}]}
{"File": "file1.txt", "Classes": [{"Name": "Science_Fiction", "Score": 0.5}, {"Name": "Science_Fiction", "Score": 0.0381}, {"Name": "Science_Fiction", "Score": 0.0372}]}
{"File": "file2.txt", "Classes": [{"Name": "Documentary", "Score": 0.1}, {"Name": "Documentary", "Score": 0.0381}, {"Name": "Domentary", "Score": 0.0372}]}
{"File": "file3.txt", "Classes": [{"Name": "Serious_Drama", "Score": 0.3141}, {"Name": "Other", "Score": 0.0381}, {"Name": "Other", "Score": 0.0372}]}
```
**Saída multirrótulo**
Quando você usa um classificador treinado no modo multirrótulo, seus resultados exibem os `labels`. Cada um desses `labels` é o rótulo usado para criar o conjunto de categorias ao treinar seu classificador.
Os exemplos a seguir usam esses rótulos exclusivos.
```
SCIENCE_FICTION
ACTION
DRAMA
COMEDY
ROMANCE
```
Se o formato dos dados de entrada for um documento por linha, o arquivo de saída conterá uma linha para cada linha na entrada. Cada linha inclui o nome do arquivo, o número da linha com base em zero da linha de entrada e a classe ou classes encontradas no documento. Termina com a confiança que o Amazon Comprehend tem de que a instância individual foi classificada corretamente.
Por exemplo:
```
{"File": "file1.txt", "Line": "0", "Labels": [{"Name": "Action", "Score": 0.8642}, {"Name": "Drama", "Score": 0.650}, {"Name": "Science Fiction", "Score": 0.0372}]}
{"File": "file1.txt", "Line": "1", "Labels": [{"Name": "Comedy", "Score": 0.5}, {"Name": "Action", "Score": 0.0381}, {"Name": "Drama", "Score": 0.0372}]}
{"File": "file1.txt", "Line": "2", "Labels": [{"Name": "Action", "Score": 0.9934}, {"Name": "Drama", "Score": 0.0381}, {"Name": "Action", "Score": 0.0372}]}
{"File": "file1.txt", "Line": "3", "Labels": [{"Name": "Romance", "Score": 0.9845}, {"Name": "Comedy", "Score": 0.8756}, {"Name": "Drama", "Score": 0.7723}, {"Name": "Science_Fiction", "Score": 0.6157}]}
```
Se o formato dos dados de entrada for um documento por arquivo, o arquivo de saída conterá uma linha para cada documento. Cada linha tem o nome do arquivo e a classe ou classes encontradas no documento. Termina com a confiança de que o Amazon Comprehend classificou a instância individual com precisão.
Por exemplo:
```
{"File": "file0.txt", "Labels": [{"Name": "Action", "Score": 0.8642}, {"Name": "Drama", "Score": 0.650}, {"Name": "Science Fiction", "Score": 0.0372}]}
{"File": "file1.txt", "Labels": [{"Name": "Comedy", "Score": 0.5}, {"Name": "Action", "Score": 0.0381}, {"Name": "Drama", "Score": 0.0372}]}
{"File": "file2.txt", "Labels": [{"Name": "Action", "Score": 0.9934}, {"Name": "Drama", "Score": 0.0381}, {"Name": "Action", "Score": 0.0372}]}
{"File": "file3.txt”, "Labels": [{"Name": "Romance", "Score": 0.9845}, {"Name": "Comedy", "Score": 0.8756}, {"Name": "Drama", "Score": 0.7723}, {"Name": "Science_Fiction", "Score": 0.6157}]}
```
## Saídas para documentos de entrada semiestruturados
Para documentos de entrada semiestruturados, a saída pode incluir os seguintes campos adicionais:
+ DocumentMetadata — Extração de informações sobre o documento. Os metadados incluem uma lista de páginas no documento, com o número de caracteres extraídos de cada página. Esse campo estará presente na resposta se a solicitação incluir o parâmetro `Byte`.
+ DocumentType — O tipo de documento para cada página no documento de entrada. Esse campo estará presente na resposta se a solicitação incluir o parâmetro `Byte`.
+ Erros: erros no nível da página que o sistema detectou ao processar o documento de entrada. O campo estará vazio se o sistema não encontrar erros.
Para obter mais detalhes sobre esses campos de saída, consulte a [ClassifyDocument](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_ClassifyDocument.html)Referência da *API Amazon Comprehend*.
O exemplo a seguir mostra a saída de um arquivo PDF digitalizado de duas páginas.
```
[{ #First page output
"Classes": [
{
"Name": "__label__2 ",
"Score": 0.9993996620178223
},
{
"Name": "__label__3 ",
"Score": 0.0004330444789957255
}
],
"DocumentMetadata": {
"PageNumber": 1,
"Pages": 2
},
"DocumentType": "ScannedPDF",
"File": "file.pdf",
"Version": "VERSION_NUMBER"
},
#Second page output
{
"Classes": [
{
"Name": "__label__2 ",
"Score": 0.9993996620178223
},
{
"Name": "__label__3 ",
"Score": 0.0004330444789957255
}
],
"DocumentMetadata": {
"PageNumber": 2,
"Pages": 2
},
"DocumentType": "ScannedPDF",
"File": "file.pdf",
"Version": "VERSION_NUMBER"
}]
```