Mesmo nesta era digital, em que cada vez mais empresas estão a migrar para a nuvem e a utilizar a aprendizagem automática (ML) ou a tecnologia para melhorar os processos empresariais, ainda vemos um grande número de empresas contactarem-se e perguntarem sobre o processamento de documentos, especialmente documentos manuscritos. Vemos formulários de emprego, cartões de ponto e aplicações financeiras com tabelas e formulários que contêm escrita à mão, além de informações impressas. Para complicar as coisas, cada documento pode estar em vários formatos, e cada instituição dentro de qualquer setor pode ter vários formatos diferentes. As organizações procuram uma solução simples que possa processar documentos complexos com formatos variados, incluindo tabelas, formulários e dados tabulares.

A extração de dados desses documentos, especialmente quando você tem uma combinação de texto impresso e manuscrito, é propensa a erros, demorada, cara e não escalável. O texto incorporado em tabelas e formulários aumenta a complexidade de extração e processamento. amazontext é um serviço de IA da AWS que extrai automaticamente texto impresso, manuscrito e outros dados de documentos digitalizados que vão além do simples reconhecimento óptico de caracteres (OCR) para identificar, compreender e extrair dados de formulários e tabelas.

Após a extração dos dados, a etapa de pós-processamento em um fluxo de trabalho de gerenciamento de documentos envolve a revisão das entradas e a realização de alterações conforme exigido pelos aplicativos de processamento downstream. IA aumentada da Amazon (Amazon A2I) facilita a configuração de uma revisão humana em seu fluxo de trabalho de ML. Isso permite que você execute automaticamente uma etapa humana para revisar seu pipeline de ML se os resultados ficarem abaixo de um limite de confiança especificado, configurar fluxos de trabalho de revisão e auditoria e modificar os resultados de previsão conforme necessário.

Nesta postagem, mostramos como você pode usar o recurso Amazon Textract Handwriting para extrair dados tabulares de documentos e ter um ciclo de revisão humana usando o Tipo de tarefa personalizada Amazon A2I para garantir que as previsões sejam altamente precisas. Armazenamos os resultados em Amazon DynamoDB, que é um banco de dados de valores-chave e documentos que oferece desempenho de milissegundos de um dígito em qualquer escala, disponibilizando os dados para processamento downstream.

Orientamos você nas etapas a seguir usando um Caderno Jupyter:

1. Use o Amazon Textract para recuperar dados tabulares do documento e inspecionar a resposta.
2. Configure um loop humano Amazon A2I para revisar e modificar a resposta do Amazon Textract.
3. Avaliar a resposta do Amazon A2I e armazená-la no DynamoDB para processamento downstream.

Pré-requisitos

Antes de começar, vamos configurar o notebook Jupyter passo a passo usando um Formação da Nuvem AWS modelo e, em seguida, crie uma força de trabalho privada do Amazon A2I, que é necessária no notebook para configurar o fluxo de trabalho personalizado do Amazon A2I.

Configurando o notebook Jupyter

Implantamos um modelo CloudFormation que realiza grande parte do trabalho de configuração inicial para você, como criar um Gerenciamento de acesso e identidade da AWS (IAM) função para Amazon Sage Maker, criando uma instância de notebook SageMaker e clonando o repositório GitHub na instância de notebook.

1. Escolha Pilha de Lançamento para configurar o notebook na região Leste dos EUA (Norte da Virgínia):

2. Não faça alterações no nome ou nos parâmetros da pilha.
3. No Empresa seção, selecione Reconheço que o AWS CloudFormation pode criar recursos do IAM.
4. Escolha Criar pilha.

A captura de tela a seguir da página de detalhes da pilha mostra o status da pilha como CREATE_IN_PROGRESS. Pode levar até 20 minutos para que o status mude para CREATE_COMPLETE.

5. No console SageMaker, escolha Instâncias de Notebook.
6. Escolha Abra o Jupyter para o TextractA2INotebook caderno que você criou.
7. Abra textract-hand-written-a2i-forms.ipynb e acompanhe por lá.

Configurando uma força de trabalho privada Amazon A2I

Para esta postagem, você cria uma equipe de trabalho privada e adiciona apenas um usuário (você) a ela. Para obter instruções, veja Crie uma força de trabalho privada (Amazon SageMaker Console). Quando o usuário (você) aceita o convite, você deve se adicionar à força de trabalho. Para obter instruções, consulte o Adicionar um trabalhador a uma equipe de trabalho seção em Gerenciar uma força de trabalho (Amazon SageMaker Console).

Depois de criar uma força de trabalho de rotulagem, copie o ARN da força de trabalho e insira-o na célula do notebook para configurar uma força de trabalho de revisão privada:

WORKTEAM_ARN= "<your workteam ARN>"

Nas seções a seguir, orientamos você nas etapas para usar este notebook.

Recuperando dados tabulares do documento e inspecionando a resposta

Nesta seção, percorremos as seguintes etapas usando o caderno passo a passo:

1. Revise os dados de amostra, que possuem conteúdo impresso e manuscrito.
2. Configure as funções auxiliares para analisar a resposta do Amazon Textract.
3. Inspecione e analise a resposta do Amazon Textract.

Revendo os dados de amostra

Revise os dados de amostra executando a seguinte célula do notebook:

# Document
documentName = "test_handwritten_document.png" display(Image(filename=documentName))

Usamos o documento de exemplo a seguir, que possui conteúdo impresso e manuscrito em tabelas.

Use a biblioteca Amazon Textract Parser para processar a resposta

Vamos agora importar o Analisador de resposta do Amazon Textract biblioteca para analisar e extrair o que precisamos da resposta do Amazon Textract. Existem duas funções principais aqui. Primeiro, extrairemos os dados do formulário (pares de valores-chave) que fazem parte da seção de cabeçalho do documento. Segundo, analisaremos a tabela e as células para criar um arquivo csv contendo os dados tabulares. Neste notebook, usaremos a API Sync do Amazon Textract para extração de documentos, Analisar Documento. Aceita arquivos de imagem (png ou jpeg) como entrada.

client = boto3.client( service_name='textract', region_name= 'us-east-1', endpoint_url='https://textract.us-east-1.amazonaws.com',
) with open(documentName, 'rb') as file: img_test = file.read() bytes_test = bytearray(img_test) print('Image loaded', documentName) # process using image bytes
response = client.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['TABLES','FORMS'])

Você pode usar a biblioteca Amazon Textract Response Parser para analisar facilmente o JSON retornado pelo Amazon Textract. A biblioteca analisa JSON e fornece construções específicas de linguagem de programação para trabalhar com diferentes partes do documento. Para mais detalhes, consulte o Biblioteca do analisador Amazon Textract

from trp import Document
# Parse JSON response from Textract
doc = Document(response) # Iterate over elements in the document
for page in doc.pages: # Print lines and words for line in page.lines: print("Line: {}".format(line.text)) for word in line.words: print("Word: {}".format(word.text)) # Print tables for table in page.tables: for r, row in enumerate(table.rows): for c, cell in enumerate(row.cells): print("Table[{}][{}] = {}".format(r, c, cell.text)) # Print fields for field in page.form.fields: print("Field: Key: {}, Value: {}".format(field.key.text, field.value.text))

Agora que temos o conteúdo necessário da imagem do documento, vamos criar um arquivo csv para armazená-lo e também usá-lo para configurar o loop humano Amazon A2I para revisão e modificação conforme necessário.

# Lets get the form data into a csv file
with open('test_handwritten_form.csv', 'w', newline='') as csvfile: formwriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL) for field in page.form.fields: formwriter.writerow([field.key.text+" "+field.value.text]) # Lets get the table data into a csv file
with open('test_handwritten_tab.csv', 'w', newline='') as csvfile: tabwriter = csv.writer(csvfile, delimiter=',') for r, row in enumerate(table.rows): csvrow = [] for c, cell in enumerate(row.cells): if cell.text: csvrow.append(cell.text.rstrip()) #csvrow += '{}'.format(cell.text.rstrip())+"," tabwriter.writerow(csvrow) 

Alternativamente, se você quiser modificar este caderno para usar um arquivo PDF ou para processamento em lote de documentos, use o API StartDocumentAnalysis. StartDocumentAnalysis retorna um identificador de trabalho (JobId) que você usa para obter os resultados da operação. Quando a análise de texto é concluída, o Amazon Textract publica um status de conclusão no tópico Amazon Simple Notification Service (Amazon SNS) especificado em NotificationChannel. Para obter os resultados da operação de análise de texto, primeiro verifique se o valor do status publicado no tópico do Amazon SNS é BEM SUCEDIDO. Se sim, ligue GetDocumentAnalysise passe o identificador do trabalho (JobId) desde a chamada inicial até StartDocumentAnalysis.

Inspecionar e analisar a resposta do Amazon Textract

Agora carregamos os itens de linha do formulário em um DataFrame do Pandas e o limpamos para garantir que tenhamos as colunas e linhas relevantes que os aplicativos downstream precisam. Em seguida, enviamos para o Amazon A2I para revisão humana.

Execute a seguinte célula do notebook para inspecionar e analisar os dados de valor-chave da resposta do Amazon Textract:

# Load the csv file contents into a dataframe, strip out extra spaces, use comma as delimiter
df_form = pd.read_csv('test_handwritten_form.csv', header=None, quoting=csv.QUOTE_MINIMAL, sep=',')
# Rename column
df_form = df_form.rename(columns={df_form.columns[0]: 'FormHeader'})
# display the dataframe
df_form

A captura de tela a seguir mostra nossa saída.

Execute a seguinte célula do notebook para inspecionar e analisar os dados tabulares da resposta do Amazon Textract:

# Load the csv file contents into a dataframe, strip out extra spaces, use comma as delimiter
df_tab = pd.read_csv('test_handwritten_tab.csv', header=1, quoting=csv.QUOTE_MINIMAL, sep=',')
# display the dataframe
df_tab.head()

A captura de tela a seguir mostra nossa saída.

Podemos ver que o Amazon Textract detectou conteúdo impresso e manuscrito a partir dos dados tabulares.

Configurando um loop humano Amazon A2I

O Amazon A2I oferece suporte a dois tipos de tarefas integradas: Extração de pares de valores-chave do Amazon Textract e Moderação de imagens do Amazon Rekognitione um tipo de tarefa personalizada que você pode usar para integrar um ciclo de revisão humana em qualquer fluxo de trabalho de ML. Você pode usar um tipo de tarefa personalizado para integrar o Amazon A2I com outros serviços da AWS, como Amazon Comprehend, Amazon Transcribe e Amazon Tradutor, bem como seus próprios fluxos de trabalho de ML personalizados. Para saber mais, consulte Casos de uso e exemplos usando Amazon A2I.

Nesta seção, mostramos como usar o tipo de tarefa personalizada Amazon A2I para integração com tabelas e pares de valores-chave do Amazon Textract por meio do caderno passo a passo para pontuações de detecção de baixa confiança das respostas do Amazon Textract. Inclui as seguintes etapas:

1. Crie uma interface do usuário de tarefa manual.
2. Crie uma definição de fluxo de trabalho.
3. Envie previsões para loops humanos do Amazon A2I.
4. Faça login no portal do trabalhador e anote ou verifique os resultados do Amazon Textract.

Criando uma UI de Tarefa Humana

Você pode criar uma UI de tarefa para seus trabalhadores criando um modelo de tarefa do trabalhador. Um modelo de tarefa de trabalho é um arquivo HTML que você usa para exibir seus dados de entrada e instruções para ajudar os trabalhadores a concluir sua tarefa. Se estiver criando um fluxo de trabalho de revisão humana para um tipo de tarefa personalizada, você deverá criar um modelo de tarefa de trabalho personalizado usando código HTML. Para mais informações, veja Criar modelo de tarefa de trabalhador personalizado.

Para esta postagem, criamos um modelo HTML de UI personalizado para renderizar tabelas do Amazon Textract e pares de valores-chave no notebook. Você pode encontrar o modelo tabelas-keyvalue-sample.liquid.html em nosso repositório GitHub e personalize-o para seu caso de uso de documento específico.

Este modelo é usado sempre que um loop humano é necessário. Temos mais de 70 UIs pré-construídas disponíveis em GitHub. Opcionalmente, você pode criar esta definição de fluxo de trabalho na página Console do Amazon A2I. Para obter instruções, consulte Crie um fluxo de trabalho de revisão humana.

Depois de criar esse modelo personalizado usando HTML, você deve usar esse modelo para gerar um nome de recurso da Amazon (ARN) da UI de tarefa manual do Amazon A2I. Este ARN tem o seguinte formato: arn:aws:sagemaker:<região aws>:número da conta aws>:human-task-ueu/nome do modelo>. Esse ARN está associado a um recurso de modelo de tarefa de trabalho que pode ser usado em um ou mais fluxos de trabalho de revisão humana (definições de fluxo). Gere um ARN da UI de tarefa manual usando um modelo de tarefa de trabalho usando o CriarHumanTaskUi Operação da API executando a seguinte célula do notebook:

def create_task_ui(): ''' Creates a Human Task UI resource. Returns: struct: HumanTaskUiArn ''' response = sagemaker_client.create_human_task_ui( HumanTaskUiName=taskUIName, UiTemplate={'Content': template}) return response
# Create task UI
humanTaskUiResponse = create_task_ui()
humanTaskUiArn = humanTaskUiResponse['HumanTaskUiArn']
print(humanTaskUiArn)

O código anterior fornece um ARN como saída, que usaremos na configuração das definições de fluxo na próxima etapa:

arn:aws:sagemaker:us-east-1:<aws-account-nr>:human-task-ui/ui-hw-invoice-2021-02-10-16-27-23

Criação da definição de fluxo de trabalho

Nesta seção, criamos uma definição de fluxo. As definições de fluxo nos permitem especificar o seguinte:

• A força de trabalho para a qual suas tarefas são enviadas
• As instruções que sua força de trabalho recebe (modelo de tarefa de trabalho)
• Onde seus dados de saída são armazenados

Para esta postagem, usamos a API no seguinte código:

create_workflow_definition_response = sagemaker_client.create_flow_definition( FlowDefinitionName= flowDefinitionName, RoleArn= role, HumanLoopConfig= { "WorkteamArn": WORKTEAM_ARN, "HumanTaskUiArn": humanTaskUiArn, "TaskCount": 1, "TaskDescription": "Review the table contents and correct values as indicated", "TaskTitle": "Employment History Review" }, OutputConfig={ "S3OutputPath" : OUTPUT_PATH } )
flowDefinitionArn = create_workflow_definition_response['FlowDefinitionArn'] # let's save this ARN for future use

Opcionalmente, você pode criar esta definição de fluxo de trabalho no Console do Amazon A2I. Para obter instruções, consulte Crie um fluxo de trabalho de revisão humana.

Envio de previsões para loops humanos do Amazon A2I

Criamos uma lista de itens do Pandas DataFrame onde salvamos a saída do Amazon Textract. Execute a seguinte célula do notebook para criar uma lista de itens a serem enviados para revisão:

NUM_TO_REVIEW = len(df_tab) # number of line items to review
dfstart = df_tab['Start Date'].to_list()
dfend = df_tab['End Date'].to_list()
dfemp = df_tab['Employer Name'].to_list()
dfpos = df_tab['Position Held'].to_list()
dfres = df_tab['Reason for leaving'].to_list()
item_list = [{'row': "{}".format(x), 'startdate': dfstart[x], 'enddate': dfend[x], 'empname': dfemp[x], 'posheld': dfpos[x], 'resleave': dfres[x]} for x in range(NUM_TO_REVIEW)]
item_list

Você obtém uma saída de todas as linhas e colunas recebidas do Amazon Textract:

[{'row': '0', 'startdate': '1/15/2009 ', 'enddate': '6/30/2011 ', 'empname': 'Any Company ', 'posheld': 'Assistant baker ', 'resleave': 'relocated '}, {'row': '1', 'startdate': '7/1/2011 ', 'enddate': '8/10/2013 ', 'empname': 'Example Corp. ', 'posheld': 'Baker ', 'resleave': 'better opp. '}, {'row': '2', 'startdate': '8/15/2013 ', 'enddate': 'Present ', 'empname': 'AnyCompany ', 'posheld': 'head baker ', 'resleave': 'N/A current '}]

Execute a seguinte célula do notebook para obter uma lista de pares de valores-chave:

dforighdr = df_form['FormHeader'].to_list()
hdr_list = [{'hdrrow': "{}".format(x), 'orighdr': dforighdr[x]} for x in range(len(df_form))]
hdr_list

Execute o código a seguir para criar uma resposta JSON para o loop Amazon A2I combinando o valor-chave e a lista de tabelas das células anteriores:

ip_content = {"Header": hdr_list, 'Pairs': item_list, 'image1': s3_img_url }

Inicie o loop humano executando a seguinte célula do notebook:

# Activate human loops
import json
humanLoopName = str(uuid.uuid4()) start_loop_response = a2i.start_human_loop( HumanLoopName=humanLoopName, FlowDefinitionArn=flowDefinitionArn, HumanLoopInput={ "InputContent": json.dumps(ip_content) } )

Verifique o status do loop humano com o seguinte código:

completed_human_loops = []
resp = a2i.describe_human_loop(HumanLoopName=humanLoopName)
print(f'HumanLoop Name: {humanLoopName}')
print(f'HumanLoop Status: {resp["HumanLoopStatus"]}')
print(f'HumanLoop Output Destination: {resp["HumanLoopOutput"]}')
print('n') if resp["HumanLoopStatus"] == "Completed": completed_human_loops.append(resp)

Você obtém a seguinte saída, que mostra o status do loop humano e o bucket S3 de destino de saída:

HumanLoop Name: f69bb14e-3acd-4301-81c0-e272b3c77df0
HumanLoop Status: InProgress
HumanLoop Output Destination: {'OutputS3Uri': 's3://sagemaker-us-east-1-<aws-account-nr>/textract-a2i-handwritten/a2i-results/fd-hw-forms-2021-01-11-16-54-31/2021/01/11/16/58/13/f69bb14e-3acd-4301-81c0-e272b3c77df0/output.json'}

Anotando os resultados por meio do portal do trabalhador

Execute as etapas no notebook para verificar o status do loop humano. Você pode usar o acompanhamento Caderno SageMaker Jupyter para seguir as etapas nesta postagem.

1. Execute a seguinte célula do notebook para obter um link de login para navegar até o portal privado de força de trabalho:

   workteamName = WORKTEAM_ARN[WORKTEAM_ARN.rfind('/') + 1:]
   print("Navigate to the private worker portal and do the tasks. Make sure you've invited yourself to your workteam!")
   print('https://' + sagemaker_client.describe_workteam(WorkteamName=workteamName)['Workteam']['SubDomain'])

2. Escolha o link de login para o portal do trabalhador privado.
3. Selecione o trabalho de revisão humana.
4. Escolha Comece a trabalhar.

Você é redirecionado para o console do Amazon A2I, onde encontra o documento original exibido, seu par de valores-chave, as respostas de texto detectadas no Amazon Textract e as respostas da sua tabela.

Role para baixo para encontrar o formulário de correção para pares de valores-chave e texto, onde você pode verificar os resultados e comparar a resposta do Amazon Textract com o documento original. Você também encontrará a IU para modificar o conteúdo tabular manuscrito e impresso.

Você pode modificar cada célula com base na resposta da imagem original, inserir novamente os valores corretos e enviar sua resposta. O fluxo de trabalho de rotulagem é concluído quando você envia suas respostas.

Avaliando os resultados

Quando o trabalho de rotulagem for concluído, seus resultados deverão estar disponíveis no caminho de saída do S3 especificado na definição do fluxo de trabalho de revisão humana. As respostas humanas são retornadas e salvas no arquivo JSON. Execute a célula do notebook para obter os resultados do Amazon S3:

import re
import pprint pp = pprint.PrettyPrinter(indent=4) for resp in completed_human_loops: splitted_string = re.split('s3://' + 'a2i-experiments' + '/', resp['HumanLoopOutput']['OutputS3Uri']) output_bucket_key = splitted_string[1] response = s3.get_object(Bucket='a2i-experiments', Key=output_bucket_key) content = response["Body"].read() json_output = json.loads(content) pp.pprint(json_output) print('n')

O código a seguir mostra um snippet do arquivo JSON de saída da anotação Amazon A2I:

{ 'flowDefinitionArn': 'arn:aws:sagemaker:us-east-1:<aws-account-nr>:flow-definition/fd-hw-invoice-2021-02-22-23-07-53', 'humanAnswers': [ { 'acceptanceTime': '2021-02-22T23:08:38.875Z', 'answerContent': { 'TrueHdr3': 'Full Name: Jane ' 'Smith', 'predicted1': 'relocated', 'predicted2': 'better opp.', 'predicted3': 'N/A, current', 'predictedhdr1': 'Phone ' 'Number: ' '555-0100', 'predictedhdr2': 'Mailing ' 'Address: ' 'same as ' 'above', 'predictedhdr3': 'Full Name: ' 'Jane Doe', 'predictedhdr4': 'Home ' 'Address: ' '123 Any ' 'Street, Any ' 'Town. USA', 'rating1': { 'agree': True, 'disagree': False}, 'rating2': { 'agree': True, 'disagree': False}, 'rating3': { 'agree': False, 'disagree': True}, 'rating4': { 'agree': True, 'disagree': False}, 'ratingline1': { 'agree': True, 'disagree': False}, 'ratingline2': { 'agree': True, 'disagree': False}, 'ratingline3': { 'agree': True, 'disagree': False}}

Armazenar os resultados anotados do Amazon A2I no DynamoDB

Agora armazenamos o formulário com o conteúdo atualizado em uma tabela do DynamoDB para que aplicativos downstream possam usá-lo. Para automatizar o processo, basta configurar um AWS Lambda acione com o DynamoDB para extrair e enviar automaticamente informações para seus endpoints ou aplicativos de API. Para mais informações, veja Fluxos do DynamoDB e gatilhos do AWS Lambda.

Para armazenar seus resultados, execute as seguintes etapas:

1. Obtenha as respostas humanas para os valores-chave e o texto em um DataFrame, executando a seguinte célula do notebook:

   #updated array values to be strings for dataframe assignment
   for i in json_output['humanAnswers']: x = i['answerContent'] for j in range(0, len(df_form)): df_form.at[j, 'TrueHeader'] = str(x.get('TrueHdr'+str(j+1))) df_form.at[j, 'Comments'] = str(x.get('Comments'+str(j+1))) df_form = df_form.where(df_form.notnull(), None)
   

2. Obtenha as respostas revisadas por humanos para dados tabulares em um DataFrame executando a seguinte célula:

   #updated array values to be strings for dataframe assignment
   for i in json_output['humanAnswers']: x = i['answerContent'] for j in range(0, len(df_tab)): df_tab.at[j, 'TrueStartDate'] = str(x.get('TrueStartDate'+str(j+1))) df_tab.at[j, 'TrueEndDate'] = str(x.get('TrueEndDate'+str(j+1))) df_tab.at[j, 'TrueEmpName'] = str(x.get('TrueEmpName'+str(j+1))) df_tab.at[j, 'TruePosHeld'] = str(x.get('TruePosHeld'+str(j+1))) df_tab.at[j, 'TrueResLeave'] = str(x.get('TrueResLeave'+str(j+1))) df_tab.at[j, 'ChangeComments'] = str(x.get('Change Reason'+str(j+1))) df_tab = df_tab.where(df_tab.notnull(), None)You will get below output:

3. Combine os DataFrames em um DataFrame para salvar na tabela DynamoDB:

   # Join both the dataframes to prep for insert into DynamoDB
   df_doc = df_form.join(df_tab, how='outer')
   df_doc = df_doc.where(df_doc.notnull(), None)
   df_doc

Criando a tabela DynamoDB

Crie sua tabela DynamoDB com o seguinte código:

# Get the service resource.
dynamodb = boto3.resource('dynamodb')
tablename = "emp_history-"+str(uuid.uuid4()) # Create the DynamoDB table.
table = dynamodb.create_table(
TableName=tablename,
KeySchema=[
{ 'AttributeName': 'line_nr', 'KeyType': 'HASH'
}
],
AttributeDefinitions=[
{ 'AttributeName': 'line_nr', 'AttributeType': 'N'
},
],
ProvisionedThroughput={ 'ReadCapacityUnits': 5, 'WriteCapacityUnits': 5
}
)
# Wait until the table exists.
table.meta.client.get_waiter('table_exists').wait(TableName=tablename)
# Print out some data about the table.
print("Table successfully created. Item count is: " + str(table.item_count))

Você obtém a seguinte saída:

Table successfully created. Item count is: 0

Fazendo upload do conteúdo do DataFrame para uma tabela do DynamoDB

Faça upload do conteúdo do seu DataFrame para a tabela do DynamoDB com o seguinte código:

Observação: Ao adicionar conteúdo de vários documentos em sua tabela do DynamoDB, certifique-se de adicionar um número de documento como um atributo para diferenciar os documentos. No exemplo abaixo usamos apenas o índice como line_nr porque estamos trabalhando com um único documento.

for idx, row in df_doc.iterrows(): table.put_item( Item={ 'line_nr': idx, 'orig_hdr': str(row['FormHeader']) , 'true_hdr': str(row['TrueHeader']), 'comments': str(row['Comments']), 'start_date': str(row['Start Date ']), 'end_date': str(row['End Date ']), 'emp_name': str(row['Employer Name ']), 'position_held': str(row['Position Held ']), 'reason_for_leaving': str(row['Reason for leaving']), 'true_start_date': str(row['TrueStartDate']), 'true_end_date': str(row['TrueEndDate']), 'true_emp_name': str(row['TrueEmpName']), 'true_position_held': str(row['TruePosHeld']), 'true_reason_for_leaving': str(row['TrueResLeave']), 'change_comments': str(row['ChangeComments']) } )

Para verificar se os itens foram atualizados, execute o código a seguir para recuperar o valor da tabela do DynamoDB:

response = table.get_item(
Key={ 'line_nr': 2
}
)
item = response['Item']
print(item)

Como alternativa, você pode verificar a tabela no console do DynamoDB, como na captura de tela a seguir.

Conclusão

Esta postagem demonstrou como é fácil usar serviços na camada de IA da pilha AWS AI/ML, como Amazon Textract e Amazon A2I, para ler e processar dados tabulares de formulários manuscritos e armazená-los em uma tabela DynamoDB para aplicativos downstream usar. Você também pode enviar os dados de formulário aumentados do Amazon A2I para um bucket S3 para serem consumidos por seus aplicativos analíticos da AWS.

Para apresentações em vídeo, experimente blocos de anotações Jupyter ou mais informações sobre casos de uso, como processamento de documentos, moderação de conteúdo, análise de sentimentos, tradução de texto e muito mais, consulte Recursos de IA aumentada da Amazon. Se esta postagem ajuda ou inspira você a resolver um problema, adoraríamos saber mais sobre isso! O código desta solução está disponível no site GitHub repo para você usar e estender. Contribuições são sempre bem vindas!

Sobre os autores

Prem Ranga é arquiteto de soluções corporativas baseado em Atlanta, GA. Ele faz parte da comunidade técnica de aprendizado de máquina e adora trabalhar com clientes em sua jornada de ML e IA. Prem é apaixonado por robótica, é pesquisador de veículos autônomos e também construiu o Beer Pours, controlado pelo Alexa, em Houston e outros locais.

Mona Mona é arquiteto de soluções especialista em AI / ML baseado em Arlington, VA. Ela trabalha com a equipe do Setor Público Mundial e ajuda os clientes a adotar o aprendizado de máquina em grande escala. Ela é apaixonada pelas áreas de explicabilidade da PNL e ML em AI / ML.

Sriharsha MS é arquiteto de soluções especializado em IA/ML na equipe de especialistas estratégicos da Amazon Web Services. Ele trabalha com clientes estratégicos da AWS que estão aproveitando IA/ML para resolver problemas de negócios complexos. Ele fornece orientação técnica e consultoria de design para implementar aplicações de IA/ML em escala. Sua experiência abrange arquitetura de aplicativos, big data, análises e aprendizado de máquina.

Fonte: https://aws.amazon.com/blogs/machine-learning/process-documents-containing-handwriting-tabular-content-using-amazon-texttract-and-amazon-a2i/