Instalar e executar contêineres do Reconhecimento de Formulários v2.1

Este artigo se aplica a:Reconhecimento de Formulários v2.1.

O Reconhecimento de Formulários do Azure é um Serviço de IA Aplicada do Azure que permite criar software de processamento de dados automatizado usando tecnologia de aprendizado de máquina. O Reconhecimento de Formulários do Azure permite que você identifique e extraia texto, pares chave-valor, marcas de seleção, dados de tabela e muito mais dos documentos de formulário. Em seguida, os resultados são gerados em dados estruturados que incluem as relações no arquivo original.

Neste artigo, você aprenderá a baixar, instalar e executar contêineres do Reconhecimento de Formulários do Azure. Os contêineres permitem executar o Reconhecimento de Formulários do Azure em seu próprio ambiente. Contêineres são excelentes para especificar requisitos de segurança e governança de dados. Os recursos do Reconhecimento de Formulários do Azure são suportados por seis contêineres de recursos do Reconhecimento de Formulários do Azure: Layout, Cartão de visita, Documento de identificação, Recibo, Fatura e Personalizado (para contêineres de Recibo, Cartão de visita e Documento de identificação você também precisará do contêiner de Leitor de OCR).

Importante

• Para usar contêineres de Reconhecimento de Formulários, será necessário enviar uma solicitação online para aprovação. Para obter mais informações, consulte Solicitar aprovação para executar o contêiner abaixo.

Pré-requisitos

Para começar, você precisará de uma conta do Azure. Se você não tem uma, crie uma conta gratuita.

Você também precisará do seguinte para usar contêineres do Reconhecimento de Formulários do Azure:

Obrigatório	Finalidade
Familiaridade com o Docker	É necessário ter uma compreensão básica de conceitos do Docker, como registros, repositórios, contêineres e imagens de contêiner, bem como conhecimento básico de dockerterminologia e comandos.
Mecanismo do Docker instalado	É necessário ter o Mecanismo Docker instalado em um computador host. O Docker fornece pacotes que configuram o ambiente do Docker no macOS, no Windows e no Linux. Para instruções sobre conceitos básicos do Docker e de contêiner, consulte a visão geral do Docker. O Docker deve ser configurado para permitir que os contêineres conectem-se e enviem dados de cobrança para o Azure. No Windows, o Docker também deve ser configurado para dar suporte a contêineres do Linux.
Recurso do Reconhecimento de Formulários	Um recurso de serviço único do Reconhecimento de Formulários do Azure ou vários de serviços múltiplos do Serviços Cognitivos no portal do Azure. Para usar os contêineres, você deve ter a chave associada e o URI do ponto de extremidade. Ambos os valores estão disponíveis na página Chaves e ponto de extremidade do Reconhecimento de Formulários, no portal do Azure: {FORM_RECOGNIZER_KEY} : uma das duas chaves de recursos disponíveis. {FORM_RECOGNIZER_ENDPOINT_URI} : o ponto de extremidade para o recurso usado para rastrear informações de cobrança.
Recurso da API de Pesquisa Visual Computacional	Para processar cartões de visita, documentos de identificação ou recibos, você precisará de um recurso do Pesquisa Visual Computacional. Acesse o recurso de Reconhecimento de Texto como um recurso do Azure (API REST ou SDK) ou como um contêiner do cognitive-services-recognize-text. Os valores de cobrança normais se aplicam. Se você usa o contêiner cognitive-services-recognize-text, certifique-se de que sua chave de Pesquisa Visual Computacional do contêiner do Reconhecimento de Formulários do Azure seja a chave especificada no Pesquisa Visual Computacional docker runoudocker compose o comando para o contêiner cognitive-services-recognize-text e de que o ponto de extremidade de cobrança seja o ponto de extremidade do contêiner (por exemplo, http://localhost:5000). Se você usar os contêineres da Pesquisa Visual Computacional e do Reconhecimento de Formulários juntos no mesmo host, eles não poderão ser iniciados com a porta padrão 5000. Passe a chave e do ponto de extremidade para a nuvem do Azure da Pesquisa Visual Computacional ou ao contêiner dos Serviços Cognitivos: {COMPUTER_VISION_KEY} : uma das duas chaves de recursos disponíveis. {COMPUTER_VISION_ENDPOINT_URI} : o ponto de extremidade para o recurso usado para rastrear informações de cobrança.

Opcional	Finalidade
CLI do Azure (Interface de linha de comando do Azure)	O CLI do Azure permite que você use um conjunto de comandos online para criar e gerenciar recursos do Azure. Ela está disponível para instalação em ambientes Windows, macOS e Linux e pode ser executada em um contêiner do Docker e no Azure Cloud Shell.

Solicitar aprovação para executar o contêiner

Conclua e envie a Solicitação de Serviços Cognitivos do Azure para Serviços Restritos para solicitar acesso ao contêiner.

O formulário solicita informações sobre você, sua empresa e o cenário do usuário para o qual você usará o contêiner. Depois que você enviar o formulário, a equipe dos Serviços Cognitivos do Azure o analisará e enviará uma decisão por email a você em até dez dias úteis.

Importante

• No formulário, você precisa usar um endereço de email associado a uma ID da assinatura do Azure.
• O recurso do Azure usado para executar o contêiner precisa ter sido criado com a ID da assinatura do Azure aprovada.
• Verifique seu email ( tanto na caixa de entrada e quanto nas pastas de lixo eletrônico) para obter atualizações sobre o status do seu aplicativo da Microsoft.

Após sua aprovação, você poderá executar o contêiner depois de baixá-lo do MCR (Microsoft Container Registry), o que será descrito mais adiante no artigo.

Você não poderá executar o contêiner se a sua assinatura do Azure não for aprovada.

Requisitos do computador host

O host é um computador baseado em x64 que executa o contêiner do Docker. Ele pode ser um computador local ou um serviço de hospedagem do Docker no Azure, como:

• Serviço de Kubernetes do Azure.
• Instâncias de Contêiner do Azure.
• Um cluster do Kubernetes implantado no Azure Stack. Para obter mais informações, consulte Implantar Kubernetes no Azure Stack.

Recomendações e requisitos do contêiner

Contêineres de suporte são necessários

A tabela a seguir lista os contêineres de suporte para cada Reconhecimento de Formulários do Azure que você baixar. Para saber mais, confira a seção Cobrança.

Contêiner de recursos	Contêiner(es) de suporte
Layout	Nenhum
Cartão de visita	Leitura da Pesquisa Visual Computacional
Documento de identificação	Leitura da Pesquisa Visual Computacional
Fatura	Layout
Receipt	Leitura da Pesquisa Visual Computacional
Personalizado	API personalizada,Supervisionado personalizado, Layout

Memória e núcleos de CPU recomendados

Observação

Os valores mínimos e recomendados se baseiam nos limites do Docker e não nos recursos do computador host.

Contêineres de leitura, layout e pré-construídos

Contêiner	Mínimo	Recomendadas
Leitura 3.2	8 núcleos, 16 GB de memória	8 núcleos, 24 GB de memória
Layout 2.1	8 núcleos, 16 GB de memória	8 núcleos, 24 GB de memória
Business Card 2.1	2 núcleos, 4 GB de memória	4 núcleos, 4 GB de memória
ID Document 2.1	1 núcleo, 2 GB de memória	2 núcleos, 2 GB de memória
Invoice 2.1	4 núcleos, 8 GB de memória	8 núcleos, 8 GB de memória
Receipt 2.1	4 núcleos, 8 GB de memória	8 núcleos, 8 GB de memória

Contêineres personalizados

Os requisitos de máquina host a seguir são aplicáveis a solicitações de treinamento e análise:

Contêiner	Mínimo	Recomendadas
API personalizada	0,5 núcleos, 0,5 GB de memória	1 núcleo, 1 GB de memória
Supervisionado personalizado	4 núcleos, 2 GB de memória	8 núcleos, 4 GB de memória

• Cada núcleo precisa ser de pelo menos 2,6 GHz (gigahertz) ou mais rápido.
• Memória e núcleo correspondem às configurações --cpus e --memory, que são usadas como parte do comando docker compose ou docker run.

Dica

Você pode usar o comando imagens do estivador para listar as imagens do contêiner transferidas por download. Por exemplo, o comando a seguir lista o ID, o repositório e a tag de cada imagem do contêiner transferida por download, formatada como uma tabela:

docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

IMAGE ID         REPOSITORY                TAG
<image-id>       <repository-path/name>    <tag-name>

Execute o contêiner com o comando docker-compose up

• Substitua os valores {ENDPOINT_URI} e {API_KEY} pelo URI do ponto de extremidade do recurso e pela chave da página de recursos do Azure.

  

• Verifique se o valor dos termos de licença está definido como "accept".

• Os valores EULA, Billing e Key devem ser especificados; caso contrário, o contêiner não será iniciado.

Importante

As chaves são usadas para acessar o recurso de Reconhecimento de Formulários do Azure. Não compartilhe suas chaves. Armazene-as com segurança, por exemplo, usando o Azure Key Vault. Recomendamos a regeneração regular dessas chaves. Apenas uma chave é necessária para fazer uma chamada à API. Ao regenerar a primeira chave, você pode usar a segunda chave para obter acesso contínuo ao serviço.

Layout

O exemplo de código a seguir é um docker compose independente para executar o contêiner de layout do Reconhecimento de Formulários. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores de {FORM_RECOGNIZER_ENDPOINT_URI} e {{FORM_RECOGNIZER_KEY} para sua instância de contêiner de layout.

version: "3.9"
services:
  azure-cognitive-service-layout:
    container_name: azure-cognitive-service-layout
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
    ports:
      - "5000"
    networks:
      - ocrvnet
networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Cartão de visita

O exemplo de código a seguir é um docker compose independente para executar os contêineres de Leitura e Cartão de visita do Reconhecimento de Formulários. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores de {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para sua instância de contêiner de cartão de visita. Insira {COMPUTER_VISION_ENDPOINT_URI} e {COMPUTER_VISION_KEY} para seu contêiner de leitura do Pesquisa Visual Computacional.

version: "3.9"
services:
  azure-cognitive-service-businesscard:
    container_name: azure-cognitive-service-businesscard
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/businesscard
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
      - AzureCognitiveServiceReadHost=http://azure-cognitive-service-read:5000
    ports:
      - "5000:5050"
    networks:
      - ocrvnet
  azure-cognitive-service-read:
    container_name: azure-cognitive-service-read
    image: mcr.microsoft.com/azure-cognitive-services/vision/read:3.2-model-2021-04-12
    environment:
      - EULA=accept
      - billing={COMPUTER_VISION_ENDPOINT_URI}
      - apiKey={COMPUTER_VISION_KEY}
    networks:
      - ocrvnet

networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Documento de identificação

O exemplo de código a seguir é um docker compose independente para executar os contêineres de Leitura e Documento de Identidade do Reconhecimento de Formulários. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores de {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para sua instância de contêiner de documento de identificação. Insira os valores de {COMPUTER_VISION_ENDPOINT_URI} e {COMPUTER_VISION_KEY} para seu contêiner de leitura do Pesquisa Visual Computacional.

version: "3.9"
services:
  azure-cognitive-service-id:
    container_name: azure-cognitive-service-id
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/id-document
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
      - AzureCognitiveServiceReadHost=http://azure-cognitive-service-read:5000
    ports:
      - "5000:5050"
    networks:
      - ocrvnet
  azure-cognitive-service-read:
    container_name: azure-cognitive-service-read
    image: mcr.microsoft.com/azure-cognitive-services/vision/read:3.2-model-2021-04-12
    environment:
      - EULA=accept
      - billing={COMPUTER_VISION_ENDPOINT_URI}
      - apiKey={COMPUTER_VISION_KEY}
    networks:
      - ocrvnet

networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Fatura

O exemplo de código a seguir é um docker compose independente para executar os contêineres de Layout e Fatura do Reconhecimento de Formulários. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores de {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para sua instância de contêiner de fatura e de layout.

version: "3.9"
services:
  azure-cognitive-service-invoice:
    container_name: azure-cognitive-service-invoice
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/invoice
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
      - AzureCognitiveServiceLayoutHost=http://azure-cognitive-service-layout:5000
    ports:
      - "5000:5050"
    networks:
      - ocrvnet
  azure-cognitive-service-layout:
    container_name: azure-cognitive-service-layout
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
    networks:
      - ocrvnet

networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Receipt

O exemplo de código a seguir é um docker compose independente para executar os contêineres de Leitura e Recibo do Reconhecimento de Formulários. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up. Insira os valores de {FORM_RECOGNIZER_ENDPOINT_URI} e {FORM_RECOGNIZER_KEY} para sua instância de contêiner de recibo. Insira os valores de {COMPUTER_VISION_ENDPOINT_URI} e {COMPUTER_VISION_KEY} para seu contêiner de leitura do Pesquisa Visual Computacional.

version: "3.9"
services:
  azure-cognitive-service-receipt:
    container_name: azure-cognitive-service-receipt
    image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/receipt
    environment:
      - EULA=accept
      - billing={FORM_RECOGNIZER_ENDPOINT_URI}
      - apiKey={FORM_RECOGNIZER_KEY}
      - AzureCognitiveServiceReadHost=http://azure-cognitive-service-read:5000
    ports:
      - "5000:5050"
    networks:
      - ocrvnet
  azure-cognitive-service-read:
    container_name: azure-cognitive-service-read
    image: mcr.microsoft.com/azure-cognitive-services/vision/read:3.2-model-2021-04-12
    environment:
      - EULA=accept
      - billing={COMPUTER_VISION_ENDPOINT_URI}
      - apiKey={COMPUTER_VISION_KEY}
    networks:
      - ocrvnet

networks:
  ocrvnet:
    driver: bridge

Agora, você pode iniciar o serviço com o comando docker compose:

docker-compose up

Custom

Além dos pré-requisitos, será necessário fazer o seguinte para processar um documento personalizado:

• Crie uma pasta para armazenar os seguintes arquivos:

1. .env
2. nginx.conf
3. docker-compose.yml

• Crie uma pasta para armazenar os dados de entrada.

1. Nomeie esta pasta como compartilhada.
2. Referenciaremos o caminho do arquivo para esta pasta como {SHARED_MOUNT_PATH}.
3. Copie o caminho do arquivo para um local conveniente, como o bloco de notas da Microsoft. Você precisará adicioná-lo ao arquivo .env.

• Crie uma pasta para armazenar os logs gravados pelo serviço de Reconhecimento de Formulários do Azure no computador local.

1. Nomeie esta pasta como saída.
2. Referenciaremos o caminho do arquivo para esta pasta como {OUTPUT_MOUNT_PATH}.
3. Copie o caminho do arquivo para um local conveniente, como o bloco de notas da Microsoft. Você precisará adicioná-lo ao arquivo .env.

• Crie um arquivo de ambiente.

1. Nomeie este arquivo .env.

2. Declare estas variáveis de ambiente:

SHARED_MOUNT_PATH="<file-path-to-shared-folder>"
OUTPUT_MOUNT_PATH="<file -path-to-output-folder>"
FORM_RECOGNIZER_ENDPOINT_URI="<your-form-recognizer-endpoint>"
FORM_RECOGNIZER_KEY="<your-form-recognizer-key>"
RABBITMQ_HOSTNAME="rabbitmq"
RABBITMQ_PORT=5672
NGINX_CONF_FILE="<file-path>"

• Criar um arquivo nginx

1. Nomeie esse arquivo nginx.conf.

2. Use a seguinte configuração:

worker_processes 1;

events { worker_connections 1024; }

http {

    sendfile on;
    client_max_body_size 90M;
    upstream docker-api {
        server azure-cognitive-service-custom-api:5000;
    }

    upstream docker-layout {
        server  azure-cognitive-service-layout:5000;
    }

    server {
        listen 5000;

        location = / {
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $scheme://$host:$server_port;
            proxy_pass http://docker-api/;

        }

        location /status {
            proxy_pass http://docker-api/status;

        }

        location /ready {
            proxy_pass http://docker-api/ready;

        }

        location /swagger {
            proxy_pass http://docker-api/swagger;

        }

        location /formrecognizer/v2.1/custom/ {
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $scheme://$host:$server_port;
            proxy_pass http://docker-api/formrecognizer/v2.1/custom/;

        }

        location /formrecognizer/v2.1/layout/ {
            proxy_set_header Host $host:$server_port;
            proxy_set_header Referer $scheme://$host:$server_port;
            proxy_pass http://docker-layout/formrecognizer/v2.1/layout/;

        }
    }
}

• Um conjunto com pelo menos seis formulários do mesmo tipo. Você usará esses dados para treinar o modelo e testar um formulário. Você usar um conjunto de dados de exemplo (baixar e extrair sample_data.zip). Baixe os arquivos de treinamento para a pasta compartilhada que você criou.

• Se você quiser rotular seus dados, baixe a ferramenta de Rotulagem de Amostra do Reconhecimento de Formulários do Azure para Windows. O download importará o arquivo .exe da ferramenta de rotulagem que você usará para rotular os dados presentes no sistema de arquivos local. Você pode ignorar quaisquer avisos que ocorram durante o processo de download.

Criar um novo projeto de ferramenta de Rotulagem de Amostra

• Abra a ferramenta de rotulagem clicando duas vezes no arquivo .exe da ferramenta de Rotulagem de Amostra.
• No painel esquerdo da ferramenta, selecione a guia conexões.
• Selecione para criar um novo projeto e dê a ele um nome e uma descrição.
• Para o provedor, escolha a opção sistema de arquivos local. Para a pasta local, insira o caminho para a pasta em que você armazenou os arquivos de dados de exemplo.
• Navegue de volta para a guia página principal e selecione a “opção Usar personalizado para treinar um modelo com rótulos e pares chave-valor”.
• Selecione o botão treinar no painel esquerdo para treinar o modelo rotulado.
• Salve essa conexão e use-a para rotular suas solicitações.
• Você pode optar por analisar o arquivo de sua escolha em relação ao modelo treinado.

• Crie um arquivo do docker compose.

1. Nomeie esse arquivo como docker-compose.yml

2. O exemplo de código a seguir é um docker composeindependente para executar os contêineres de Layout, Ferramenta de Rótulo, API Personalizada e Supervisionado Personalizado do Reconhecimento de Formulários ao mesmo tempo. Com docker compose, um arquivo YAML é usado para configurar os serviços do aplicativo. Em seguida, você cria e inicia todos os serviços com base na sua configuração com o comando docker-compose up.

version: '3.3'
services:
 nginx:
  image: nginx:alpine
  container_name: reverseproxy
  volumes:
    - ${NGINX_CONF_FILE}:/etc/nginx/nginx.conf
  ports:
    - "5000:5000"
 rabbitmq:
  container_name: ${RABBITMQ_HOSTNAME}
  image: rabbitmq:3
  expose:
    - "5672"
 layout:
  container_name: azure-cognitive-service-layout
  image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/layout
  depends_on:
    - rabbitmq
  environment:
    eula: accept
    key: ${FORM_RECOGNIZER_KEY}
    billing: ${FORM_RECOGNIZER_ENDPOINT_URI}
    Queue:RabbitMQ:HostName: ${RABBITMQ_HOSTNAME}
    Queue:RabbitMQ:Port: ${RABBITMQ_PORT}
    Logging:Console:LogLevel:Default: Information
    SharedRootFolder: /shared
    Mounts:Shared: /shared
    Mounts:Output: /logs
  volumes:
    - type: bind
      source: ${SHARED_MOUNT_PATH}
      target: /shared
    - type: bind
      source: ${OUTPUT_MOUNT_PATH}
      target: /logs
  expose:
    - "5000"

 custom-api:
  container_name: azure-cognitive-service-custom-api
  image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/custom-api
  restart: always
  depends_on:
    - rabbitmq
  environment:
    eula: accept
    key: ${FORM_RECOGNIZER_KEY}
    billing: ${FORM_RECOGNIZER_ENDPOINT_URI}
    Logging:Console:LogLevel:Default: Information
    Queue:RabbitMQ:HostName: ${RABBITMQ_HOSTNAME}
    Queue:RabbitMQ:Port: ${RABBITMQ_PORT}
    SharedRootFolder: /shared
    Mounts:Shared: /shared
    Mounts:Output: /logs
  volumes:
    - type: bind
      source: ${SHARED_MOUNT_PATH}
      target: /shared
    - type: bind
      source: ${OUTPUT_MOUNT_PATH}
      target: /logs
  expose:
    - "5000"

 custom-supervised:
  container_name: azure-cognitive-service-custom-supervised
  image: mcr.microsoft.com/azure-cognitive-services/form-recognizer/custom-supervised
  restart: always
  depends_on:
    - rabbitmq
  environment:
    eula: accept
    key: ${FORM_RECOGNIZER_KEY}
    billing: ${FORM_RECOGNIZER_ENDPOINT_URI}
    CustomFormRecognizer:ContainerPhase: All
    CustomFormRecognizer:LayoutAnalyzeUri: http://azure-cognitive-service-layout:5000/formrecognizer/v2.1/layout/analyze
    Logging:Console:LogLevel:Default: Information
    Queue:RabbitMQ:HostName: ${RABBITMQ_HOSTNAME}
    Queue:RabbitMQ:Port: ${RABBITMQ_PORT}
    SharedRootFolder: /shared
    Mounts:Shared: /shared
    Mounts:Output: /logs
  volumes:
    - type: bind
      source: ${SHARED_MOUNT_PATH}
      target: /shared
    - type: bind
      source: ${OUTPUT_MOUNT_PATH}
      target: /logs

Certifique-se que o serviço esteja em execução

Para garantir que o serviço está em execução. Execute esses comandos em um shell do Ubuntu.

$cd <folder containing the docker-compose file>

$source .env

$docker-compose up

Crie uma nova conexão

• No painel esquerdo da ferramenta, selecione a guia conexões.
• Selecione criar um novo projeto e dê a ele um nome e uma descrição.
• Para o provedor, escolha a opção sistema de arquivos local. Para a pasta local, certifique-se de inserir o caminho para a pasta em que você armazenou os arquivos de dados de exemplo.
• Navegue de volta para a guia página principal e selecione Usar personalizado para treinar um modelo com rótulos e pares chave-valor.
• Selecione o botão treinar no painel esquerdo para treinar o modelo rotulado.
• Salve essa conexão e use-a para rotular suas solicitações.
• Você pode optar por analisar o arquivo de sua escolha em relação ao modelo treinado.

A ferramenta de Rotulagem de Exemplo e as ACIs (Instâncias de Contêiner do Azure)

Para saber como usar a ferramenta Rotulagem de Exemplo com uma Instância de Contêiner do Azure, confiraImplantar a ferramenta de Rotulagem de Exemplo.

Confirme se o servidor está em execução

Há várias maneiras de validar se um contêiner está em execução:

• O contêiner fornece uma home page em \ como uma validação visual de que o contêiner está em execução.

• Você pode abrir seu navegador da Web favorito e navegar até o endereço IP externo e a porta exposta do contêiner em questão. Use as URLs de solicitação listadas para validar se o contêiner está em execução. As URLs de solicitação de exemplo listadas são http://localhost:5000, mas o seu contêiner específico pode variar. Lembre-se de que você está navegando para o endereço IP externo e porta exposta do contêiner.

  URL de Solicitação	Finalidade
  http://localhost:5000/	O contêiner fornece uma home page.
  http://localhost:5000/ready	Solicitado com GET, essa solicitação fornece uma verificação de que o contêiner está pronto para aceitar uma consulta em relação ao modelo. Essa solicitação pode ser usada para testes de preparação e de execução do Kubernetes.
  http://localhost:5000/status	Solicitado com GET, essa solicitação verifica se a chave API usada para iniciar o contêiner é válida sem causar uma consulta de terminal. Essa solicitação pode ser usada para testes de preparação e de execução do Kubernetes.
  http://localhost:5000/swagger	O contêiner fornece um conjunto completo de documentação para os pontos de extremidade e um recurso Experimentar. Com esse recurso, é possível inserir suas configurações em um formulário HTML baseado na Web e realizar a consulta sem precisar escrever nenhum código. Após a consulta ser retornada, um exemplo de comando CURL será fornecido para demonstrar o formato do corpo e dos cabeçalhos HTTP exigidos.

Parar os contêineres

Para parar o contêiner, use o seguinte comando:

docker-compose down

Cobrança

Os contêineres do Reconhecimento de Formulários enviam informações de cobrança para o Azure usando um recurso do Reconhecimento de Formulários em sua conta do Azure.

Consultas ao contêiner são cobradas pelo tipo de preço do recurso do Azure usado para Key. Você será cobrado por cada instância de contêiner usada para processar seus documentos e imagens. Portanto, se você usar o recurso de cartão de visita, será cobrado pelo Reconhecimento de Formulários do Azure BusinessCard e pelas instâncias de contêiner Computer Vision Read. Para o recurso da fatura, você será cobrado pelo Reconhecimento de Formulários do Azure Invoice e pelas instâncias de contêiner Layout. Consulte os preços para Reconhecimento de Formulários do Azure e contêiner de recurso de leitura do Pesquisa Visual Computacional.

Os contêineres dos Serviços Cognitivos do Azure não estão licenciados para execução sem estarem conectados com o ponto de extremidade de medição/cobrança. Os contêineres devem ser habilitados para sempre comunicar informações de cobrança com o ponto de extremidade de cobrança. Os contêineres dos Serviços Cognitivos não enviam dados do cliente, como imagem ou texto que está sendo analisado, para a Microsoft.

Conectar-se ao Azure

O contêiner precisa dos valores de argumento de cobrança para ser executado. Esses valores permitem que o contêiner se conecte ao ponto de extremidade de cobrança. O contêiner relata o uso a cada 10 a 15 minutos. Se o contêiner não se conectar ao Azure dentro da janela de tempo permitida, ele continuará sendo executado, mas não atenderá a consultas até que o ponto de extremidade de cobrança seja restaurado. Serão realizadas 10 tentativas de conexão no mesmo intervalo de tempo de 10 a 15 minutos. Se não for possível conectar-se ao ponto de extremidade de cobrança dentro das 10 tentativas, o contêiner interromperá as solicitações de serviço. Veja as Perguntas frequentes do contêiner de Serviços Cognitivos para obter um exemplo das informações enviadas à Microsoft para cobrança.

Argumentos de cobrança

O comando docker-compose up iniciará o contêiner quando todas as três opções a seguir forem fornecidas com valores válidos:

Opção	Descrição
Key	A chave do recurso dos Serviços Cognitivos que serve para rastrear informações de cobrança. O valor dessa opção deve ser definido como uma chave para o recurso provisionado especificado em Billing.
Billing	O ponto de extremidade do recurso dos Serviços Cognitivos usado para rastrear informações de cobrança. O valor dessa opção deve ser definido como o URI do ponto de extremidade de um recurso do Azure provisionado.
Eula	Indica que você aceitou a licença do contêiner. O valor dessa opção deve ser definido como aceitar.

Para obter mais informações sobre essas opções, consulte Configurar contêineres.

Resumo

É isso! Neste artigo, você aprendeu conceitos e o fluxo de trabalho para baixar, instalar e executar contêineres do Reconhecimento de Formulários do Azure. Em resumo:

• O Reconhecimento de Formulários do Azure fornece sete contêineres do Linux para o Docker.
• As imagens de contêiner são baixadas do mcr.
• Imagens de contêiner são executadas no Docker.
• A informações de cobrança devem ser especificadas quando você instanciar um contêiner.

Importante

Os contêineres dos Serviços Cognitivos não estão licenciados para execução sem estarem conectados ao Azure para medição. Os clientes precisam ativar os contêineres para comunicar informações de cobrança com o serviço de medição em todos os momentos. Os contêineres de Serviços Cognitivos não enviam dados do cliente (por exemplo, a imagem ou o texto que está sendo analisado) para a Microsoft.

Próximas etapas

• Definições de configuração de contêiner do Reconhecimento de Formulários do Azure

• Receita da instância de contêiner do Azure