Tutorial: Usar o Azure Functions e Python para processar documentos armazenados

Artigo
05/30/2024

O Document Intelligence pode ser usado como parte de um pipeline de processamento de dados automatizado criado com o Azure Functions. Este guia mostrará como usar o Azure Functions para processar documentos que são carregados em um contêiner de armazenamento de blob do Azure. Esse fluxo de trabalho extrai dados de tabela de documentos armazenados usando o modelo de layout de Inteligência Documental e salva os dados da tabela em um arquivo de .csv no Azure. Em seguida, você pode exibir os dados usando o Microsoft Power BI (não abordado aqui).

Captura de ecrã do diagrama de fluxo de trabalho do Serviço do Azure

Neste tutorial, irá aprender a:

Criar uma conta de Armazenamento do Azure.
Crie um projeto do Azure Functions.
Extraia dados de layout de formulários carregados.
Carregue dados de layout extraídos no Armazenamento do Azure.

Pré-requisitos

Subscrição - do Azure Crie uma gratuitamente
Um recurso de Document Intelligence. Depois de ter sua assinatura do Azure, crie um recurso de Inteligência Documental no portal do Azure para obter sua chave e ponto de extremidade. Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.
- Depois que o recurso for implantado, selecione Ir para o recurso. Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo à API de Document Intelligence. Você colará sua chave e ponto de extremidade no código abaixo mais adiante no tutorial:
Python 3.6.x, 3.7.x, 3.8.x ou 3.9.x (Python 3.10.x não é suportado para este projeto).
A versão mais recente do Visual Studio Code (VS Code) com as seguintes extensões instaladas:
- Extensão do Azure Functions. Depois de instalado, você verá o logotipo do Azure no painel de navegação esquerdo.
- Azure Functions Core Tools versão 3.x (a versão 4.x não é suportada para este projeto).
- Extensão Python para código do Visual Studio. Para obter mais informações, consulteIntrodução ao Python no VS Code
Azure Storage Explorer instalado.
Um documento PDF local para analisar. Você pode usar nosso exemplo de documento pdf para este projeto.

Criar uma conta de Armazenamento do Azure

Crie uma conta de Armazenamento do Azure v2 de uso geral no portal do Azure. Se você não souber como criar uma conta de armazenamento do Azure com um contêiner de armazenamento, siga estes inícios rápidos:
- Criar uma conta de armazenamento. Ao criar sua conta de armazenamento, selecione Desempenho padrão no campo Detalhes>da instância Desempenho.
- Crie um contêiner. Ao criar seu contêiner, defina Nível de acesso público como Contêiner (acesso de leitura anônimo para contêineres e arquivos) na janela Novo contêiner .
No painel esquerdo, selecione a guia Compartilhamento de recursos (CORS) e remova a política CORS existente, se existir.
Depois que sua conta de armazenamento for implantada, crie dois contêineres de armazenamento de blob vazios, chamados de entrada e saída.

Criar um projeto das Funções do Azure

Crie uma nova pasta chamada functions-app para conter o projeto e escolha Selecionar.
Abra o Visual Studio Code e abra a Paleta de Comandos (Ctrl+Shift+P). Procure e escolha Python:Select Interpreter → escolha um interpretador Python instalado que seja a versão 3.6.x, 3.7.x, 3.8.x ou 3.9.x. Esta seleção adicionará o caminho do interpretador Python que você selecionou ao seu projeto.
Selecione o logotipo do Azure no painel de navegação esquerdo.
- Você verá seus recursos existentes do Azure no modo de exibição Recursos.
- Selecione a assinatura do Azure que você está usando para este projeto e, abaixo, você verá o Aplicativo Azure Function.
Selecione a seção Espaço de trabalho (Local) localizada abaixo dos recursos listados. Selecione o símbolo de adição e escolha o botão Criar função .
Quando solicitado, escolha Criar novo projeto e navegue até o diretório function-app . Escolha Selecionar.
Ser-lhe-á pedido para definir várias definições:
- Selecione uma linguagem → escolha Python.
- Selecione um interpretador Python para criar um ambiente virtual → selecione o interpretador definido como padrão anteriormente.
- Selecione um modelo → escolha o gatilho de Armazenamento de Blob do Azure e dê um nome ao gatilho ou aceite o nome padrão. Pressione Enter para confirmar.
- Selecione a configuração → escolha ➕Criar nova configuração de aplicativo local no menu suspenso.
- Selecione assinatura → escolha sua assinatura do Azure com a conta de armazenamento que você criou → selecione sua conta de armazenamento → selecione o nome do contêiner de entrada de armazenamento (neste caso, input/{name}). Pressione Enter para confirmar.
- Selecione como você gostaria de abrir seu projeto → escolha Abrir o projeto na janela atual no menu suspenso.
Depois de concluir essas etapas, o VS Code adicionará um novo projeto do Azure Function com um script __init__.py Python. Esse script será acionado quando um arquivo for carregado no contêiner de armazenamento de entrada :

import logging

import azure.functions as func


def main(myblob: func.InputStream):
    logging.info(f"Python blob trigger function processed blob \n"
                 f"Name: {myblob.name}\n"
                 f"Blob Size: {myblob.length} bytes")

Testar a função

Pressione F5 para executar a função básica. O VS Code solicitará que você selecione uma conta de armazenamento com a qual interagir com ele.
Selecione a conta de armazenamento que criou e continue.
Abra o Gerenciador de Armazenamento do Azure e carregue o documento PDF de exemplo no contêiner de entrada . Em seguida, verifique o terminal VS Code. O script deve registrar que foi acionado pelo upload do PDF.
Pare o script antes de continuar.

Adicionar código de processamento de documentos

Em seguida, você adicionará seu próprio código ao script Python para chamar o serviço Document Intelligence e analisar os documentos carregados usando o modelo de layout Document Intelligence.

No VS Code, navegue até o arquivo requirements.txt da função. Esse arquivo define as dependências para seu script. Adicione os seguintes pacotes Python ao arquivo:
```
cryptography
azure-functions
azure-storage-blob
azure-identity
requests
pandas
numpy
```

Em seguida, abra o script __init__.py . Adicione as seguintes instruções import:

import logging
from azure.storage.blob import BlobServiceClient
import azure.functions as func
import json
import time
from requests import get, post
import os
import requests
from collections import OrderedDict
import numpy as np
import pandas as pd

Você pode deixar a função gerada main como está. Você adicionará seu código personalizado dentro desta função.

# This part is automatically generated
def main(myblob: func.InputStream):
    logging.info(f"Python blob trigger function processed blob \n"
    f"Name: {myblob.name}\n"
    f"Blob Size: {myblob.length} bytes")

O bloco de código a seguir chama a API Document Intelligence Analyze Layout no documento carregado. Preencha os valores do ponto final e da chave.
```
# This is the call to the Document Intelligence endpoint
    endpoint = r"Your Document Intelligence Endpoint"
    apim_key = "Your Document Intelligence Key"
    post_url = endpoint + "/formrecognizer/v2.1/layout/analyze"
    source = myblob.read()

    headers = {
    # Request headers
    'Content-Type': 'application/pdf',
    'Ocp-Apim-Subscription-Key': apim_key,
        }

    text1=os.path.basename(myblob.name)
```
Importante

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, consulte Segurança dos serviços de IA do Azure.

Em seguida, adicione código para consultar o serviço e obter os dados retornados.

resp = requests.post(url=post_url, data=source, headers=headers)

if resp.status_code != 202:
    print("POST analyze failed:\n%s" % resp.text)
    quit()
print("POST analyze succeeded:\n%s" % resp.headers)
get_url = resp.headers["operation-location"]

wait_sec = 25

time.sleep(wait_sec)
# The layout API is async therefore the wait statement

resp = requests.get(url=get_url, headers={"Ocp-Apim-Subscription-Key": apim_key})

resp_json = json.loads(resp.text)

status = resp_json["status"]

if status == "succeeded":
    print("POST Layout Analysis succeeded:\n%s")
    results = resp_json
else:
    print("GET Layout results failed:\n%s")
    quit()

results = resp_json

Adicione o seguinte código para se conectar ao contêiner de saída do Armazenamento do Azure. Preencha seus próprios valores para o nome e a chave da conta de armazenamento. Você pode obter a chave na guia Chaves de acesso do seu recurso de armazenamento no portal do Azure.

# This is the connection to the blob storage, with the Azure Python SDK
    blob_service_client = BlobServiceClient.from_connection_string("DefaultEndpointsProtocol=https;AccountName="Storage Account Name";AccountKey="storage account key";EndpointSuffix=core.windows.net")
    container_client=blob_service_client.get_container_client("output")

O código a seguir analisa a resposta retornada do Document Intelligence, constrói um arquivo .csv e o carrega no contêiner de saída .

Importante

Você provavelmente precisará editar esse código para corresponder à estrutura de seus próprios documentos.

    # The code below extracts the json format into tabular data.
    # Please note that you need to adjust the code below to your form structure.
    # It probably won't work out-of-the-box for your specific form.
    pages = results["analyzeResult"]["pageResults"]

    def make_page(p):
        res=[]
        res_table=[]
        y=0
        page = pages[p]
        for tab in page["tables"]:
            for cell in tab["cells"]:
                res.append(cell)
                res_table.append(y)
            y=y+1

        res_table=pd.DataFrame(res_table)
        res=pd.DataFrame(res)
        res["table_num"]=res_table[0]
        h=res.drop(columns=["boundingBox","elements"])
        h.loc[:,"rownum"]=range(0,len(h))
        num_table=max(h["table_num"])
        return h, num_table, p

    h, num_table, p= make_page(0)

    for k in range(num_table+1):
        new_table=h[h.table_num==k]
        new_table.loc[:,"rownum"]=range(0,len(new_table))
        row_table=pages[p]["tables"][k]["rows"]
        col_table=pages[p]["tables"][k]["columns"]
        b=np.zeros((row_table,col_table))
        b=pd.DataFrame(b)
        s=0
        for i,j in zip(new_table["rowIndex"],new_table["columnIndex"]):
            b.loc[i,j]=new_table.loc[new_table.loc[s,"rownum"],"text"]
            s=s+1

Finalmente, o último bloco de código carrega a tabela extraída e os dados de texto para o elemento de armazenamento de blob.

    # Here is the upload to the blob storage
    tab1_csv=b.to_csv(header=False,index=False,mode='w')
    name1=(os.path.splitext(text1)[0]) +'.csv'
    container_client.upload_blob(name=name1,data=tab1_csv)

Executar a função

Pressione F5 para executar a função novamente.
Use o Gerenciador de Armazenamento do Azure para carregar um formulário PDF de exemplo no contêiner de armazenamento de entrada . Essa ação deve acionar o script para ser executado e, em seguida, você deve ver o arquivo de .csv resultante (exibido como uma tabela) no contêiner de saída .

Você pode conectar esse contêiner ao Power BI para criar visualizações avançadas dos dados que ele contém.

Próximos passos

Neste tutorial, você aprendeu como usar uma Função do Azure escrita em Python para processar automaticamente documentos PDF carregados e produzir seu conteúdo em um formato mais amigável para dados. Em seguida, saiba como usar o Power BI para exibir os dados.

Microsoft Power BI

O que é Document Intelligence?
Saiba mais sobre o modelo de layout

Partilhar via