Même à l'ère du numérique, où de plus en plus d'entreprises se tournent vers le cloud et utilisent l'apprentissage automatique (ML) ou la technologie pour améliorer les processus commerciaux, nous voyons toujours un grand nombre d'entreprises se tourner vers le traitement des documents, en particulier les documents manuscrits. Nous voyons des formulaires d'emploi, des cartes de pointage et des applications financières avec des tableaux et des formulaires qui contiennent une écriture manuscrite en plus des informations imprimées. Pour compliquer les choses, chaque document peut être dans différents formats, et chaque institution dans un secteur donné peut avoir plusieurs formats différents. Les organisations recherchent une solution simple capable de traiter des documents complexes avec différents formats, y compris des tableaux, des formulaires et des données tabulaires.

L'extraction de données à partir de ces documents, en particulier lorsque vous avez une combinaison de texte imprimé et manuscrit, est source d'erreurs, prend du temps, coûte cher et n'est pas évolutive. Le texte intégré dans les tableaux et les formulaires ajoute à la complexité d'extraction et de traitement. Extrait d'Amazon est un service AWS AI qui extrait automatiquement le texte imprimé, l'écriture manuscrite et d'autres données des documents numérisés qui vont au-delà de la simple reconnaissance optique de caractères (OCR) pour identifier, comprendre et extraire des données de formulaires et de tableaux.

Une fois les données extraites, l'étape de post-traitement dans un flux de travail de gestion de documents consiste à examiner les entrées et à apporter les modifications requises par les applications de traitement en aval. IA augmentée d'Amazon (Amazon A2I) facilite la configuration d'une révision humaine dans votre flux de travail ML. Cela vous permet d'avoir automatiquement une étape humaine pour examiner votre pipeline ML si les résultats tombent en dessous d'un seuil de confiance spécifié, de configurer des flux de travail d'examen et d'audit et de modifier les résultats de prédiction si nécessaire.

Dans cet article, nous montrons comment vous pouvez utiliser la fonction manuscrite d'Amazon Textract pour extraire des données tabulaires à partir de documents et avoir une boucle de révision humaine à l'aide du Type de tâche personnalisée Amazon A2I pour vous assurer que les prédictions sont très précises. Nous stockons les résultats dans Amazon DynamoDB, qui est une base de données de valeurs-clés et de documents qui offre des performances à la milliseconde à un chiffre à n'importe quelle échelle, rendant les données disponibles pour le traitement en aval.

Nous vous guidons à travers les étapes suivantes à l'aide d'un Carnet Jupyter:

1. Utilisez Amazon Textract pour récupérer les données tabulaires du document et inspecter la réponse.
2. Configurez une boucle humaine Amazon A2I pour examiner et modifier la réponse Amazon Textract.
3. Évaluer la réponse Amazon A2I et la stocker dans DynamoDB pour un traitement en aval.

Pré-requis

Avant de commencer, configurons le bloc-notes Jupyter pas à pas à l'aide d'un AWS CloudFormation puis créez une main-d'œuvre privée Amazon A2I, qui est nécessaire dans le bloc-notes pour configurer le flux de travail Amazon A2I personnalisé.

Configuration du notebook Jupyter

Nous déployons un modèle CloudFormation qui effectue une grande partie du travail de configuration initiale pour vous, comme la création d'un Gestion des identités et des accès AWS (IAM) rôle pour Amazon Sage Maker, en créant une instance de notebook SageMaker et en clonant le référentiel GitHub dans l'instance de notebook.

1. Selectionnez Lancer la pile pour configurer le notebook dans la région USA Est (Virginie du Nord):

2. N'apportez aucune modification au nom ou aux paramètres de la pile.
3. Dans le Fonctionnalités section, sélectionnez Je reconnais qu'AWS CloudFormation peut créer des ressources IAM.
4. Selectionnez Créer une pile.

La capture d'écran suivante de la page des détails de la pile montre l'état de la pile comme CREATE_IN_PROGRESS. Cela peut prendre jusqu'à 20 minutes pour que le statut passe à CREATE_COMPLETE.

5. Sur la console SageMaker, choisissez Instances de bloc-notes.
6. Selectionnez Ouvrez Jupyter pour le TextractA2INotebook cahier que vous avez créé.
7. Ouvert textract-hand-written-a2i-forms.ipynb et suivez-là.

Mettre en place une main-d'œuvre privée Amazon A2I

Pour cet article, vous créez une équipe de travail privée et n'y ajoutez qu'un seul utilisateur (vous). Pour obtenir des instructions, consultez Créer une force de travail privée (Amazon SageMaker Console). Lorsque l'utilisateur (vous) accepte l'invitation, vous devez vous ajouter à l'effectif. Pour obtenir des instructions, consultez le Ajouter un travailleur à une équipe de travail section Gérer une main-d'œuvre (Amazon SageMaker Console).

Après avoir créé un effectif d'étiquetage, copiez l'ARN de l'effectif et saisissez-le dans la cellule du bloc-notes pour configurer un effectif d'examen privé:

WORKTEAM_ARN= "<your workteam ARN>"

Dans les sections suivantes, nous vous expliquons comment utiliser ce bloc-notes.

Récupération des données tabulaires du document et inspection de la réponse

Dans cette section, nous passons par les étapes suivantes en utilisant le carnet pas à pas:

1. Examinez les exemples de données, dont le contenu est à la fois imprimé et manuscrit.
2. Configurez les fonctions d'assistance pour analyser la réponse Amazon Textract.
3. Inspectez et analysez la réponse Amazon Textract.

Examen des exemples de données

Examinez les exemples de données en exécutant la cellule de bloc-notes suivante:

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

Nous utilisons l'exemple de document suivant, dont le contenu est à la fois imprimé et manuscrit dans les tableaux.

Utilisez la bibliothèque d'analyseur Amazon Textract pour traiter la réponse

Nous allons maintenant importer le Analyseur de réponse Amazon Textract bibliothèque pour analyser et extraire ce dont nous avons besoin de la réponse d'Amazon Textract. Il y a deux fonctions principales ici. Premièrement, nous allons extraire la partie des données du formulaire (paires clé-valeur) de la section d'en-tête du document. Deuxièmement, nous analyserons le tableau et les cellules pour créer un fichier csv contenant les données tabulaires. Dans ce cahier, nous utiliserons l'API Sync d'Amazon Textract pour l'extraction de documents, AnalyserDocument. Cela accepte les fichiers image (png ou jpeg) comme entrée.

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'])

Vous pouvez utiliser la bibliothèque Amazon Textract Response Parser pour analyser facilement le JSON renvoyé par Amazon Textract. La bibliothèque analyse JSON et fournit des constructions spécifiques au langage de programmation pour travailler avec différentes parties du document. Pour plus de détails, veuillez consulter le Bibliothèque d'analyseur 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))

Maintenant que nous avons le contenu dont nous avons besoin à partir de l'image du document, créons un fichier csv pour le stocker et utilisons-le également pour configurer la boucle humaine Amazon A2I pour révision et modification si nécessaire.

# 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) 

Sinon, si vous souhaitez modifier ce bloc-notes pour utiliser un fichier PDF ou pour le traitement par lots de documents, utilisez le API StartDocumentAnalysis. StartDocumentAnalysis renvoie un identifiant de tâche (JobId) que vous utilisez pour obtenir les résultats de l'opération. Lorsque l'analyse de texte est terminée, Amazon Textract publie un statut d'achèvement dans la rubrique Amazon Simple Notification Service (Amazon SNS) que vous spécifiez dans NotificationChannel. Pour obtenir les résultats de l'opération d'analyse de texte, vérifiez d'abord que la valeur d'état publiée dans la rubrique Amazon SNS est RÉUSSIE. Si oui, appelez GetDocumentAnalysiset transmettez l'identifiant de la tâche (JobId) de l'appel initial à StartDocumentAnalysis.

Inspection et analyse de la réponse Amazon Textract

Nous chargeons maintenant les éléments de ligne du formulaire dans un Pandas DataFrame et le nettoyons pour nous assurer que nous disposons des colonnes et des lignes pertinentes dont les applications en aval ont besoin. Nous l'envoyons ensuite à Amazon A2I pour examen humain.

Exécutez la cellule de bloc-notes suivante pour inspecter et analyser les données de valeur-clé de la réponse 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

La capture d'écran suivante montre notre sortie.

Exécutez la cellule de bloc-notes suivante pour inspecter et analyser les données tabulaires de la réponse 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()

La capture d'écran suivante montre notre sortie.

Nous pouvons voir qu'Amazon Textract a détecté à la fois du contenu imprimé et manuscrit à partir des données tabulaires.

Configuration d'une boucle humaine Amazon A2I

Amazon A2I prend en charge deux types de tâches intégrés: Extraction de paires clé-valeur Amazon Textract et Modération d'image Amazon RekognitionEt un type de tâche personnalisé que vous pouvez utiliser pour intégrer une boucle de révision humaine dans n'importe quel flux de travail ML. Vous pouvez utiliser un type de tâche personnalisé pour intégrer Amazon A2I à d'autres services AWS tels que Amazon comprendre, Amazon Transcribeet Amazon Traduire, ainsi que vos propres flux de travail ML personnalisés. Pour en savoir plus, consultez Cas d'utilisation et exemples utilisant Amazon A2I.

Dans cette section, nous montrons comment utiliser le type de tâche personnalisée Amazon A2I pour l'intégrer aux tables Amazon Textract et aux paires clé-valeur via le carnet pas à pas pour les scores de détection à faible confiance des réponses Amazon Textract. Il comprend les étapes suivantes:

1. Créez une interface utilisateur de tâche manuelle.
2. Créez une définition de workflow.
3. Envoyez des prédictions aux boucles humaines Amazon A2I.
4. Connectez-vous au portail des employés et annotez ou vérifiez les résultats d'Amazon Textract.

Création d'une interface utilisateur de tâche manuelle

Vous pouvez créer une interface utilisateur de tâches pour vos collaborateurs en créant un modèle de tâche de travailleur. Un modèle de tâche de travail est un fichier HTML que vous utilisez pour afficher vos données d'entrée et des instructions pour aider les travailleurs à terminer votre tâche. Si vous créez un flux de travail de révision humaine pour un type de tâche personnalisé, vous devez créer un modèle de tâche de travail personnalisé à l'aide du code HTML. Pour plus d'informations, consultez Créer un modèle de tâche de travail personnalisé.

Pour cet article, nous avons créé un modèle HTML d'interface utilisateur personnalisé pour afficher les tables Amazon Textract et les paires clé-valeur dans le bloc-notes. Vous pouvez trouver le modèle tables-valeur-clé-échantillon.liquid.html dans notre dépôt GitHub et personnalisez-le pour votre cas d'utilisation de document spécifique.

Ce modèle est utilisé chaque fois qu'une boucle humaine est requise. Nous avons plus de 70 interfaces utilisateur prédéfinies disponibles sur GitHub. Si vous le souhaitez, vous pouvez créer cette définition de workflow sur le Console Amazon A2I. Pour obtenir des instructions, consultez Créer un workflow de révision humaine.

Après avoir créé ce modèle personnalisé à l'aide de HTML, vous devez utiliser ce modèle pour générer une interface utilisateur de tâche utilisateur Amazon A2I Amazon Resource Name (ARN). Cet ARN a le format suivant: arn:aws:sagemaker:<région-aws>:numéro-de-compte-aws>:human-task-uje/nom-modèle>. Cet ARN est associé à une ressource de modèle de tâche de travail que vous pouvez utiliser dans un ou plusieurs flux de travail de révision humaine (définitions de flux). Générer un ARN d'interface utilisateur de tâche manuelle à l'aide d'un modèle de tâche de travail à l'aide du CréerHumanTaskUi Opération de l'API en exécutant la cellule de bloc-notes suivante:

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)

Le code précédent vous donne un ARN en sortie, que nous utilisons pour configurer les définitions de flux à l'étape suivante:

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

Création de la définition de workflow

Dans cette section, nous créons une définition de flux. Les définitions de flux nous permettent de spécifier les éléments suivants:

• La main-d'œuvre à laquelle vos tâches sont envoyées
• Les instructions que votre personnel reçoit (modèle de tâche de travailleur)
• Où vos données de sortie sont stockées

Pour cet article, nous utilisons l'API dans le code suivant:

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

Si vous le souhaitez, vous pouvez créer cette définition de workflow sur le Console Amazon A2I. Pour obtenir des instructions, consultez Créer un workflow de révision humaine.

Envoi de prédictions aux boucles humaines Amazon A2I

Nous créons une liste d'articles à partir du Pandas DataFrame où nous avons la sortie Amazon Textract enregistrée. Exécutez la cellule de bloc-notes suivante pour créer une liste d'éléments à envoyer pour examen:

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

Vous obtenez une sortie de toutes les lignes et colonnes reçues d'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 '}]

Exécutez la cellule de bloc-notes suivante pour obtenir une liste de paires clé-valeur:

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

Exécutez le code suivant pour créer une réponse JSON pour la boucle Amazon A2I en combinant la valeur-clé et la liste de table des cellules précédentes:

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

Démarrez la boucle humaine en exécutant la cellule de bloc-notes suivante:

# 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) } )

Vérifiez l'état de la boucle humaine avec le code suivant:

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)

Vous obtenez la sortie suivante, qui montre l'état de la boucle humaine et du compartiment S3 de destination de sortie:

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'}

Annoter les résultats via le portail des travailleurs

Exécutez les étapes du bloc-notes pour vérifier l'état de la boucle humaine. Vous pouvez utiliser l'accompagnement Cahier SageMaker Jupyter pour suivre les étapes de cet article.

1. Exécutez la cellule de bloc-notes suivante pour obtenir un lien de connexion pour accéder au portail de la main-d'œuvre privée:

   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. Choisissez le lien de connexion au portail du travailleur privé.
3. Sélectionnez le travail de révision humaine.
4. Selectionnez Commencer à travailler.

Vous êtes redirigé vers la console Amazon A2I, où vous trouvez le document d'origine affiché, votre paire clé-valeur, les réponses textuelles détectées à partir d'Amazon Textract et les réponses de votre table.

Faites défiler vers le bas pour trouver le formulaire de correction des paires clé-valeur et du texte, dans lequel vous pouvez vérifier les résultats et comparer la réponse Amazon Textract au document d'origine. Vous trouverez également l'interface utilisateur pour modifier le contenu tabulaire manuscrit et imprimé.

Vous pouvez modifier chaque cellule en fonction de la réponse d'image d'origine, saisir à nouveau les valeurs correctes et soumettre votre réponse. Le workflow d'étiquetage est terminé lorsque vous soumettez vos réponses.

Évaluer les résultats

Lorsque le travail d'étiquetage est terminé, vos résultats doivent être disponibles dans le chemin de sortie S3 spécifié dans la définition du flux de travail de révision humaine. Les réponses humaines sont renvoyées et enregistrées dans le fichier JSON. Exécutez la cellule notebook pour obtenir les résultats d'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')

Le code suivant montre un extrait du fichier JSON de sortie d'annotation 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}}

Stockage des résultats annotés Amazon A2I dans DynamoDB

Nous stockons maintenant le formulaire avec le contenu mis à jour dans une table DynamoDB afin que les applications en aval puissent l'utiliser. Pour automatiser le processus, configurez simplement un AWS Lambda déclenchez avec DynamoDB pour extraire et envoyer automatiquement des informations à vos points de terminaison ou applications d'API. Pour plus d'informations, consultez Flux DynamoDB et déclencheurs AWS Lambda.

Pour stocker vos résultats, procédez comme suit:

1. Obtenez les réponses humaines pour les valeurs-clés et le texte dans un DataFrame en exécution de la cellule de bloc-notes suivante:

   #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. Obtenez les réponses examinées par l'homme pour les données tabulaires dans un DataFrame en exécutant la cellule suivante:

   #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. Combinez les DataFrames en un DataFrame à enregistrer dans la table 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

Création de la table DynamoDB

Créez votre table DynamoDB avec le code suivant:

# 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))

Vous obtenez la sortie suivante:

Table successfully created. Item count is: 0

Téléchargement du contenu du DataFrame dans une table DynamoDB

Téléchargez le contenu de votre DataFrame dans votre table DynamoDB avec le code suivant:

Remarque: Lors de l'ajout du contenu de plusieurs documents dans votre table DynamoDB, assurez-vous d'ajouter un numéro de document comme attribut pour différencier les documents. Dans l'exemple ci-dessous, nous utilisons simplement l'index comme line_nr car nous travaillons avec un seul document.

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']) } )

Pour vérifier si les éléments ont été mis à jour, exécutez le code suivant pour récupérer la valeur de la table DynamoDB:

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

Vous pouvez également consulter le tableau sur la console DynamoDB, comme dans la capture d'écran suivante.

Conclusion

Cet article a démontré à quel point il est facile d'utiliser des services dans la couche AI ​​de la pile AWS AI / ML, tels qu'Amazon Textract et Amazon A2I, pour lire et traiter des données tabulaires à partir de formulaires manuscrits et les stocker dans une table DynamoDB pour les applications en aval utiliser. Vous pouvez également envoyer les données de formulaire augmentées d'Amazon A2I à un compartiment S3 pour qu'elles soient consommées par vos applications d'analyse AWS.

Pour des présentations vidéo, des exemples de blocs-notes Jupyter ou plus d'informations sur des cas d'utilisation tels que le traitement de documents, la modération de contenu, l'analyse des sentiments, la traduction de texte, etc., consultez Ressources d'IA augmentées d'Amazon. Si cet article vous aide ou vous inspire pour résoudre un problème, nous serions ravis d'en entendre parler! Le code de cette solution est disponible sur le GitHub repo pour que vous puissiez utiliser et étendre. Les contributions sont toujours les bienvenues!

À propos des auteurs

Prém Ranga est un architecte de solutions d'entreprise basé à Atlanta, en Géorgie. Il fait partie de la communauté technique du Machine Learning et adore travailler avec les clients sur leur parcours ML et IA. Prem est passionné de robotique, est un chercheur de véhicules autonomes et a également construit les Beer Pours contrôlés par Alexa à Houston et dans d'autres endroits.

Ici ici est un architecte de solutions spécialisé en IA / ML basé à Arlington, en Virginie. Elle travaille avec l'équipe du secteur public mondial et aide les clients à adopter l'apprentissage automatique à grande échelle. Elle est passionnée par les domaines d'explicabilité de la PNL et du ML en AI / ML.

Sriharsha MS est un architecte de solutions spécialisé AI / ML au sein de l'équipe de spécialistes stratégiques d'Amazon Web Services. Il travaille avec des clients AWS stratégiques qui tirent parti de l'IA / ML pour résoudre des problèmes commerciaux complexes. Il fournit des conseils techniques et des conseils de conception pour mettre en œuvre des applications AI / ML à grande échelle. Son expertise couvre l'architecture des applications, le Big Data, l'analyse et l'apprentissage automatique.

Source : https://aws.amazon.com/blogs/machine-learning/process-documents-cipient-handwritten-tabular-content-using-amazon-texttract-and-amazon-a2i/