Enterprise Document OCR

Vous pouvez utiliser Enterprise Document OCR dans Document AI pour détecter et extraire du texte et des informations de mise en page à partir de divers documents. Grâce aux fonctionnalités configurables, vous pouvez adapter le système aux exigences spécifiques de traitement des documents.

Présentation

Vous pouvez utiliser Enterprise Document OCR pour des tâches telles que la saisie de données basée sur des algorithmes ou le machine learning, et pour améliorer et vérifier la justesse des données. Vous pouvez également utiliser Enterprise Document OCR pour effectuer les tâches suivantes:

  • Numérisation du texte:extrayez les données de texte et de mise en page des documents pour la recherche, les pipelines de traitement de documents basés sur des règles ou la création de modèles personnalisés.
  • Utiliser des applications de grands modèles de langage:utilisez la compréhension contextuelle des LLM et les fonctionnalités d'extraction de texte et de mise en page de l'OCR pour automatiser les questions et les réponses. Dégagez des insights à partir des données et simplifiez les workflows.
  • Archivage:numérisez les documents papier en texte lisible par machine pour améliorer leur accessibilité.

Choisir le meilleur OCR pour votre cas d'utilisation

Solution Produit Description Cas d'utilisation
Document AI Enterprise Document OCR Modèle spécialisé pour les cas d'utilisation des documents. Les fonctionnalités avancées incluent le score de qualité de l'image, les suggestions de langue et la correction de la rotation. Recommandé pour extraire du texte à partir de documents. Il peut s'agir de PDF, de documents scannés en tant qu'images ou de fichiers Microsoft DocX.
Document AI Modules complémentaires OCR Fonctionnalités premium pour des besoins spécifiques Compatible uniquement avec Enterprise Document OCR version 2.0 ou ultérieure. Vous devez détecter et reconnaître des formules mathématiques, recevoir des informations sur le style de police ou activer l'extraction de cases à cocher.
API Cloud Vision Détection de texte API REST disponible dans le monde entier, basée sur le modèle OCR standard de Google Cloud . Quota par défaut de 1 800 requêtes par minute. Cas d'utilisation généraux d'extraction de texte nécessitant une faible latence et une capacité élevée.
Cloud Vision OCR Google Distributed Cloud (obsolète) Application Google Cloud Marketplace pouvant être déployée en tant que conteneur sur n'importe quel cluster GKE à l'aide de GKE Enterprise. Pour respecter les exigences de résidence des données ou de conformité.

Détection et extraction

Enterprise Document OCR peut détecter des blocs, des paragraphes, des lignes, des mots et des symboles à partir de PDF et d'images, et redresser les documents pour plus de précision.

Attributs de détection et d'extraction de mise en page acceptés:

Texte imprimé Écriture manuscrite Paragraphe Bloquer Ligne Éléments textuels Au niveau du symbole Numéro de page
Par défaut Par défaut Par défaut Par défaut Par défaut Par défaut Configurable Par défaut

Les fonctionnalités configurables d'Enterprise Document OCR incluent les suivantes:

  • Extraire du texte intégré ou natif à partir de fichiers PDF numériques:cette fonctionnalité extrait le texte et les symboles exactement comme ils apparaissent dans les documents sources, même pour les textes pivotés, les tailles ou styles de police extrêmes, et le texte partiellement masqué.

  • Correction de la rotation:utilisez Enterprise Document OCR pour prétraiter les images de documents afin de corriger les problèmes de rotation pouvant affecter la qualité ou le traitement de l'extraction.

  • Score de qualité de l'image:recevez des métriques de qualité qui peuvent vous aider à acheminer les documents. Le score de qualité des images vous fournit des métriques de qualité au niveau de la page dans huit dimensions, y compris le flou, la présence de polices plus petites que d'habitude et les reflets.

  • Spécifier la plage de pages:spécifie la plage des pages d'un document d'entrée pour l'OCR. Cela permet de réduire les dépenses et le temps de traitement des pages inutiles.

  • Détection de la langue:détecte les langues utilisées dans les textes extraits.

  • Conseils sur la langue et l'écriture manuscrite:améliorez la précision en fournissant au modèle OCR un indice de langue ou d'écriture manuscrite en fonction des caractéristiques connues de votre ensemble de données.

Pour savoir comment activer les configurations OCR, consultez la section Activer les configurations OCR.

Modules complémentaires OCR

Enterprise Document OCR propose des fonctionnalités d'analyse facultatives qui peuvent être activées sur des demandes de traitement individuelles si nécessaire.

Les fonctionnalités de module complémentaire suivantes sont disponibles pour la version stable pretrained-ocr-v2.0-2023-06-02 et la version candidate pretrained-ocr-v2.1-2024-08-07:

  • OCR mathématique: identifiez et extrayez les formules à partir de documents au format LaTeX.
  • Extraction des cases à cocher: détectez les cases à cocher et extrayez leur état (cochée/non cochée) dans la réponse Enterprise Document OCR.
  • Détection du style de police: identifiez les propriétés de police au niveau des mots, y compris le type de police, le style de police, l'écriture manuscrite, l'épaisseur et la couleur.

Pour savoir comment activer les modules complémentaires listés, consultez la section Activer les modules complémentaires OCR.

Formats de fichiers acceptés

La fonctionnalité OCR pour les documents d'entreprise est compatible avec les formats de fichiers PDF, GIF, TIFF, JPEG, PNG, BMP et WebP. Pour en savoir plus, consultez la section Fichiers compatibles.

Enterprise Document OCR est également compatible avec les fichiers DocX jusqu'à 15 pages en mode synchronisé et 30 pages en mode asynchrone. La prise en charge de DocX est en version preview privée. Pour demander l'accès, envoyez le formulaire de demande d'assistance pour DocX .

Gestion des versions avancée

La gestion des versions avancée est disponible en version preview. Les mises à niveau des modèles OCR sous-jacents d'IA/ML peuvent entraîner des modifications du comportement de l'OCR. Si une cohérence stricte est requise, utilisez une version de modèle figée pour épingler le comportement à un ancien modèle OCR pendant une période maximale de 18 mois. Cela garantit le même résultat de la fonction OCR pour l'image. Consultez le tableau des versions de l'outil de traitement.

Versions du processeur

Les versions de processeur suivantes sont compatibles avec cette fonctionnalité. Pour en savoir plus, consultez la page Gérer les versions de l'outil de traitement.

ID de version Canal de publication Description
pretrained-ocr-v1.0-2020-09-23 Stable L'utilisation de cette fonctionnalité n'est pas recommandée. Elle sera abandonnée aux États-Unis (États-Unis) et dans l'Union européenne (UE) à partir du 30 avril 2025.
pretrained-ocr-v1.1-2022-09-12 Stable L'utilisation de cette fonctionnalité n'est pas recommandée. Elle sera abandonnée aux États-Unis (États-Unis) et dans l'Union européenne (UE) à partir du 30 avril 2025.
pretrained-ocr-v1.2-2022-11-10 Stable Version de modèle figée de la version 1.0: fichiers de modèle, configurations et binaires d'un instantané de version figés dans une image de conteneur pendant un maximum de 18 mois.
pretrained-ocr-v2.0-2023-06-02 Stable Modèle prêt à la production spécialisé pour les cas d'utilisation des documents. Inclut l'accès à tous les modules complémentaires OCR.
pretrained-ocr-v2.1-2024-08-07 Version candidate Les principaux axes d'amélioration de la version 2.1 sont les suivants: une meilleure reconnaissance du texte imprimé, une détection plus précise des cases à cocher et un ordre de lecture plus précis.

Utiliser Enterprise Document OCR pour traiter des documents

Ce guide de démarrage rapide vous présente la reconnaissance optique des caractères dans Enterprise Document OCR. Il vous explique comment optimiser les résultats de la reconnaissance optique des caractères pour votre workflow en activant ou en désactivant l'une des configurations OCR disponibles.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Document AI API.

    Enable the API

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Document AI API.

    Enable the API

Créer un processeur Enterprise Document OCR

Commencez par créer un processeur Enterprise Document OCR. Pour en savoir plus, consultez la section Créer et gérer des outils de traitement.

Configurations OCR

Toutes les configurations OCR peuvent être activées en définissant les champs correspondants dans ProcessOptions.ocrConfig dans ProcessDocumentRequest ou BatchProcessDocumentsRequest.

Pour en savoir plus, consultez Envoyer une requête de traitement.

Analyse de la qualité des images

L'analyse intelligente de la qualité des documents utilise le machine learning pour évaluer la qualité d'un document en fonction de la lisibilité de son contenu. Cette évaluation de la qualité est renvoyée sous la forme d'un niveau de qualité [0, 1], où 1 signifie "qualité parfaite". Si le niveau de qualité détecté est inférieur à 0.5, une liste de raisons de faible qualité (triées par probabilité) est également renvoyée. Une probabilité supérieure à 0.5 est considérée comme une détection positive.

Si le document est considéré comme défectueux, l'API renvoie les huit types de défauts de document suivants:

  • quality/defect_blurry
  • quality/defect_noisy
  • quality/defect_dark
  • quality/defect_faint
  • quality/defect_text_too_small
  • quality/defect_document_cutoff
  • quality/defect_text_cutoff
  • quality/defect_glare

L'analyse actuelle de la qualité des documents présente certaines limites:

  • Il peut renvoyer des détections de faux positifs pour des documents numériques sans défaut. Cette fonctionnalité est particulièrement adaptée aux documents scannés ou photographiés.
  • Les défauts de reflet sont locaux. Leur présence peut ne pas nuire à la lisibilité globale du document.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.enableImageQualityScores sur true dans la requête de traitement. Cette fonctionnalité supplémentaire ajoute une latence comparable au traitement OCR à l'appel du processus.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableImageQualityScores": true
      }
    }
  }

Sortie

Les résultats de la détection des défauts s'affichent dans Document.pages[].imageQualityScores[].

  {
    "pages": [
      {
        "imageQualityScores": {
          "qualityScore": 0.7811847,
          "detectedDefects": [
            {
              "type": "quality/defect_document_cutoff",
              "confidence": 1.0
            },
            {
              "type": "quality/defect_glare",
              "confidence": 0.97849524
            },
            {
              "type": "quality/defect_text_cutoff",
              "confidence": 0.5
            }
          ]
        }
      }
    ]
  }

Pour obtenir des exemples de sortie complète, consultez Exemple de sortie du processeur.

Indicateurs de langue

Le processeur OCR prend en charge les indices de langue que vous définissez pour améliorer les performances du moteur OCR. L'application d'un indice de langue permet à la ROC d'optimiser pour une langue sélectionnée plutôt que pour une langue inférée.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.hints[].languageHints[] avec une liste de codes de langue BCP-47.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "hints": {
          "languageHints": ["en", "es"]
        }
      }
    }
  }

Pour obtenir des exemples de sortie complète, consultez Exemple de sortie du processeur.

Détection de symboles

Renseignez les données au niveau du symbole (ou de la lettre individuelle) dans la réponse du document.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.enableSymbol sur true dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableSymbol": true
      }
    }
  }

Sortie

Si cette fonctionnalité est activée, le champ Document.pages[].symbols[] est renseigné.

Pour obtenir des exemples de sortie complète, consultez Exemple de sortie du processeur.

Analyse PDF intégrée

Extrayez le texte intégré à partir de fichiers PDF numériques. Lorsqu'il est activé, si du texte numérique est présent, le modèle PDF numérique intégré est automatiquement utilisé. Si du texte non numérique est présent, le modèle OCR optique est automatiquement utilisé. L'utilisateur reçoit les deux résultats textuels fusionnés.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.enableNativePdfParsing sur true dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableNativePdfParsing": true
      }
    }
  }

Détection de caractères dans un cadre

Par défaut, Enterprise Document OCR est doté d'un détecteur activé pour améliorer la qualité d'extraction du texte des caractères situés dans un cadre. Voici un exemple :

enterprise-document-ocr-1

Si vous rencontrez des problèmes de qualité de l'OCR avec des caractères dans des cases, vous pouvez désactiver cette fonctionnalité.

Entrée

Désactivez-la en définissant ProcessOptions.ocrConfig.disableCharacterBoxesDetection sur true dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "disableCharacterBoxesDetection": true
      }
    }
  }

Ancienne mise en page

Si vous avez besoin d'un algorithme de détection de mise en page basé sur des heuristiques, vous pouvez activer l'ancienne mise en page, qui constitue une alternative à l'algorithme de détection de mise en page actuel basé sur le ML. Il ne s'agit pas de la configuration recommandée. Les clients peuvent choisir l'algorithme de mise en page le plus adapté en fonction de leur flux de travail de traitement des documents.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.advancedOcrOptions sur ["legacy_layout"] dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "advancedOcrOptions": ["legacy_layout"]
      }
    }
  }

Spécifier une plage de pages

Par défaut, la reconnaissance optique des caractères extrait le texte et les informations de mise en page de toutes les pages des documents. Vous pouvez sélectionner des numéros de page ou des plages de pages spécifiques et n'extraire que le texte de ces pages.

Il existe trois façons de configurer cela dans ProcessOptions:

  • Pour ne traiter que les pages 2 et 5:
  {
    "individualPageSelector": {"pages": [2, 5]}
  }
  • Pour ne traiter que les trois premières pages:
  {
    "fromStart": 3
  }
  • Pour ne traiter que les quatre dernières pages:
  {
    "fromEnd": 4
  }

Dans la réponse, chaque Document.pages[].pageNumber correspond aux mêmes pages spécifiées dans la requête.

Utilisations des modules complémentaires OCR

Ces fonctionnalités d'analyse facultatives d'Enterprise Document OCR peuvent être activées sur des demandes de traitement individuelles si nécessaire.

Fonction OCR mathématique

La reconnaissance optique des caractères mathématique détecte, reconnaît et extrait les formules, telles que les équations mathématiques représentées en LaTeX, ainsi que les coordonnées du cadre de délimitation.

Voici un exemple de représentation LaTeX:

  • Image détectée

    enterprise-document-ocr-2

  • Conversion en LaTeX

    enterprise-document-ocr-3

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr sur true dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableMathOcr": true
          }
      }
    }
  }

Sortie

Le résultat de la reconnaissance optique des caractères mathématique s'affiche dans Document.pages[].visualElements[] avec "type": "math_formula".

"visualElements": [
  {
    "layout": {
      "textAnchor": {
        "textSegments": [
          {
            "endIndex": "46"
          }
        ]
      },
      "confidence": 1,
      "boundingPoly": {
        "normalizedVertices": [
          {
            "x": 0.14662756,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.8027211
          },
          {
            "x": 0.14662756,
            "y": 0.8027211
          }
        ]
      },
      "orientation": "PAGE_UP"
    },
    "type": "math_formula"
  }
]

Vous pouvez consulter la sortie JSON complète de Document sur ce lien .

Extraction des marques de sélection

Si cette option est activée, le modèle tente d'extraire toutes les cases à cocher et les boutons radio du document, ainsi que les coordonnées du cadre de délimitation.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection sur true dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableSelectionMarkDetection": true
          }
      }
    }
  }

Sortie

La sortie de la case à cocher s'affiche dans Document.pages[].visualElements[] avec "type": "unfilled_checkbox" ou "type": "filled_checkbox".

"visualElements": [
  {
    "layout": {
      "confidence": 0.89363575,
      "boundingPoly": {
        "vertices": [
          {
            "x": 11,
            "y": 24
          },
          {
            "x": 37,
            "y": 24
          },
          {
            "x": 37,
            "y": 56
          },
          {
            "x": 11,
            "y": 56
          }
        ],
        "normalizedVertices": [
          {
            "x": 0.017488075,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.9032258
          },
          {
            "x": 0.017488075,
            "y": 0.9032258
          }
        ]
      }
    },
    "type": "unfilled_checkbox"
  },
  {
    "layout": {
      "confidence": 0.9148201,
      "boundingPoly": ...
    },
    "type": "filled_checkbox"
  }
],

Vous pouvez consulter la sortie JSON complète de Document sur ce lien .

Détection du style de police

Lorsque la détection du style de police est activée, Enterprise Document OCR extrait les attributs de police, qui peuvent être utilisés pour un post-traitement plus efficace.

Au niveau du jeton (mot), les attributs suivants sont détectés:

  • Détection de l'écriture manuscrite
  • Style de police
  • Taille de police
  • Type de police
  • Couleur de la police
  • Épaisseur de la police
  • L'espacement entre les lettres
  • Gras
  • Italique
  • Souligné
  • Couleur du texte (RVBA)
  • Couleur d'arrière-plan (RVBA)

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo sur true dans la requête de traitement.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "computeStyleInfo": true
          }
      }
    }
  }

Sortie

La sortie du style de police s'affiche en Document.pages[].tokens[].styleInfo avec le type StyleInfo.

"tokens": [
  {
    "styleInfo": {
      "fontSize": 3,
      "pixelFontSize": 13,
      "fontType": "SANS_SERIF",
      "bold": true,
      "fontWeight": 564,
      "textColor": {
        "red": 0.16862746,
        "green": 0.16862746,
        "blue": 0.16862746
      },
      "backgroundColor": {
        "red": 0.98039216,
        "green": 0.9882353,
        "blue": 0.99215686
      }
    }
  },
  ...
]

Vous pouvez consulter la sortie JSON complète de Document sur ce lien .

Convertir des objets de document au format de l'API Vision AI

La boîte à outils Document AI inclut un outil qui convertit le format Document de l'API Document AI au format AnnotateFileResponse de Vision AI, ce qui permet aux utilisateurs de comparer les réponses entre le processeur de reconnaissance optique des caractères dans les documents et l'API Vision AI. Voici un exemple de code.

Différences connues entre la réponse de l'API Vision AI et la réponse et le convertisseur de l'API Document AI:

  • La réponse de l'API Vision AI ne renseigne que vertices pour les requêtes d'image et normalized_vertices pour les requêtes PDF. La réponse Document AI et le convertisseur renseignent à la fois vertices et normalized_vertices.
  • La réponse de l'API Vision AI renseigne le detected_break dans le dernier symbole du mot. La réponse de l'API Document AI et le convertisseur renseignent detected_break dans le mot et le dernier symbole du mot.
  • La réponse de l'API Vision AI renseigne toujours les champs de symboles. Par défaut, la réponse de Document AI ne renseigne pas les champs de symboles. Pour vous assurer que la réponse Document AI et les champs de symboles du convertisseur sont renseignés, définissez la fonctionnalité enable_symbol comme indiqué.

Exemples de code

Les exemples de code suivants montrent comment envoyer une requête de traitement permettant d'activer les configurations et les modules complémentaires OCR, puis lire et imprimer les champs dans le terminal:

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION: emplacement de votre processeur, par exemple :
    • us : États-Unis
    • eu : Union européenne
  • PROJECT_ID : ID de votre projet Google Cloud .
  • PROCESSOR_ID: ID de votre processeur personnalisé.
  • PROCESSOR_VERSION: identifiant de la version du processeur. Pour en savoir plus, consultez Sélectionner une version de l'outil de traitement. Par exemple :
      .
    • pretrained-TYPE-vX.X-YYYY-MM-DD
    • stable
    • rc
  • skipHumanReview: valeur booléenne permettant de désactiver l'examen manuel (compatible avec les outils de traitement Human-in-the-Loop uniquement).
    • true : ignore l'examen manuel
    • false : active l'examen manuel (valeur par défaut)
  • MIME_TYPE: l'une des options Type MIME valides.
  • IMAGE_CONTENT: l'un des contenus de document intégrés valides, représenté sous forme de flux d'octets. Pour les représentations JSON, l'encodage base64 (chaîne ASCII) de vos données d'image binaires. Cette chaîne doit ressembler à la chaîne suivante :
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Consultez la section encodage en base64 pour en savoir plus.
  • FIELD_MASK: spécifie les champs à inclure dans la sortie Document. Il s'agit d'une liste de noms de champs complets séparés par une virgule au format FieldMask.
    • Exemple : text,entities,pages.pageNumber
  • Configurations OCR
    • ENABLE_NATIVE_PDF_PARSING (booléen) : extrait le texte intégré des fichiers PDF, le cas échéant.
    • ENABLE_IMAGE_QUALITY_SCORES: (valeur booléenne) active les évaluations intelligentes de la qualité des documents.
    • ENABLE_SYMBOL (booléen) : inclut les informations OCR sur les symboles (lettres).
    • DISABLE_CHARACTER_BOXES_DETECTION: (booléen) Désactive le détecteur de zone de caractères dans le moteur OCR.
    • LANGUAGE_HINTS: liste des codes de langue BCP-47 à utiliser pour la reconnaissance optique de caractères.
    • ADVANCED_OCR_OPTIONS: liste d'options OCR avancées permettant d'affiner le comportement de l'OCR. Les valeurs valides actuelles sont les suivantes :
      • legacy_layout: algorithme de détection de mise en page basé sur des heuristiques, qui constitue une alternative à l'algorithme de détection de mise en page actuel basé sur le ML.
  • Modules complémentaires OCR Premium
    • ENABLE_SELECTION_MARK_DETECTION: (booléen) Active le détecteur de marques de sélection dans le moteur OCR.
    • COMPUTE_STYLE_INFO (booléen) Active le modèle d'identification de police et renvoie les informations sur le style de police.
    • ENABLE_MATH_OCR: (booléen) Active le modèle pouvant extraire les formules mathématiques LaTeX.
  • INDIVIDUAL_PAGES: liste des pages individuelles à traiter.
    • Vous pouvez également fournir le champ fromStart ou fromEnd pour traiter un nombre spécifique de pages à partir du début ou de la fin du document.

† Ce contenu peut également être spécifié à l'aide d'un contenu encodé en base64 dans l'objet inlineDocument.

Méthode HTTP et URL :

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process

Corps JSON de la requête :

{
  "skipHumanReview": skipHumanReview,
  "rawDocument": {
    "mimeType": "MIME_TYPE",
    "content": "IMAGE_CONTENT"
  },
  "fieldMask": "FIELD_MASK",
  "processOptions": {
    "ocrConfig": {
      "enableNativePdfParsing": ENABLE_NATIVE_PDF_PARSING,
      "enableImageQualityScores": ENABLE_IMAGE_QUALITY_SCORES,
      "enableSymbol": ENABLE_SYMBOL,
      "disableCharacterBoxesDetection": DISABLE_CHARACTER_BOXES_DETECTION,
      "hints": {
        "languageHints": [
          "LANGUAGE_HINTS"
        ]
      },
      "advancedOcrOptions": ["ADVANCED_OCR_OPTIONS"],
      "premiumFeatures": {
        "enableSelectionMarkDetection": ENABLE_SELECTION_MARK_DETECTION,
        "computeStyleInfo": COMPUTE_STYLE_INFO,
        "enableMathOcr": ENABLE_MATH_OCR,
      }
    },
    "individualPageSelector" {
      "pages": [INDIVIDUAL_PAGES]
    }
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process" | Select-Object -Expand Content

Si la requête aboutit, le serveur affiche un code d'état HTTP 200 OK et la réponse au format JSON. Le corps de la réponse contient une instance de Document.

Python

Pour en savoir plus, consultez la documentation de référence de l'API Document AI Python.

Pour vous authentifier auprès de Document AI, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


from typing import Optional, Sequence

from google.api_core.client_options import ClientOptions
from google.cloud import documentai

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu"
# processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample
# processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information
# file_path = "/path/to/local/pdf"
# mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types


def process_document_ocr_sample(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
) -> None:
    # Optional: Additional configurations for Document OCR Processor.
    # For more information: https://cloud.google.com/document-ai/docs/enterprise-document-ocr
    process_options = documentai.ProcessOptions(
        ocr_config=documentai.OcrConfig(
            enable_native_pdf_parsing=True,
            enable_image_quality_scores=True,
            enable_symbol=True,
            # OCR Add Ons https://cloud.google.com/document-ai/docs/ocr-add-ons
            premium_features=documentai.OcrConfig.PremiumFeatures(
                compute_style_info=True,
                enable_math_ocr=False,  # Enable to use Math OCR Model
                enable_selection_mark_detection=True,
            ),
        )
    )
    # Online processing request to Document AI
    document = process_document(
        project_id,
        location,
        processor_id,
        processor_version,
        file_path,
        mime_type,
        process_options=process_options,
    )

    text = document.text
    print(f"Full document text: {text}\n")
    print(f"There are {len(document.pages)} page(s) in this document.\n")

    for page in document.pages:
        print(f"Page {page.page_number}:")
        print_page_dimensions(page.dimension)
        print_detected_languages(page.detected_languages)

        print_blocks(page.blocks, text)
        print_paragraphs(page.paragraphs, text)
        print_lines(page.lines, text)
        print_tokens(page.tokens, text)

        if page.symbols:
            print_symbols(page.symbols, text)

        if page.image_quality_scores:
            print_image_quality_scores(page.image_quality_scores)

        if page.visual_elements:
            print_visual_elements(page.visual_elements, text)


def print_page_dimensions(dimension: documentai.Document.Page.Dimension) -> None:
    print(f"    Width: {str(dimension.width)}")
    print(f"    Height: {str(dimension.height)}")


def print_detected_languages(
    detected_languages: Sequence[documentai.Document.Page.DetectedLanguage],
) -> None:
    print("    Detected languages:")
    for lang in detected_languages:
        print(f"        {lang.language_code} ({lang.confidence:.1%} confidence)")


def print_blocks(blocks: Sequence[documentai.Document.Page.Block], text: str) -> None:
    print(f"    {len(blocks)} blocks detected:")
    first_block_text = layout_to_text(blocks[0].layout, text)
    print(f"        First text block: {repr(first_block_text)}")
    last_block_text = layout_to_text(blocks[-1].layout, text)
    print(f"        Last text block: {repr(last_block_text)}")


def print_paragraphs(
    paragraphs: Sequence[documentai.Document.Page.Paragraph], text: str
) -> None:
    print(f"    {len(paragraphs)} paragraphs detected:")
    first_paragraph_text = layout_to_text(paragraphs[0].layout, text)
    print(f"        First paragraph text: {repr(first_paragraph_text)}")
    last_paragraph_text = layout_to_text(paragraphs[-1].layout, text)
    print(f"        Last paragraph text: {repr(last_paragraph_text)}")


def print_lines(lines: Sequence[documentai.Document.Page.Line], text: str) -> None:
    print(f"    {len(lines)} lines detected:")
    first_line_text = layout_to_text(lines[0].layout, text)
    print(f"        First line text: {repr(first_line_text)}")
    last_line_text = layout_to_text(lines[-1].layout, text)
    print(f"        Last line text: {repr(last_line_text)}")


def print_tokens(tokens: Sequence[documentai.Document.Page.Token], text: str) -> None:
    print(f"    {len(tokens)} tokens detected:")
    first_token_text = layout_to_text(tokens[0].layout, text)
    first_token_break_type = tokens[0].detected_break.type_.name
    print(f"        First token text: {repr(first_token_text)}")
    print(f"        First token break type: {repr(first_token_break_type)}")
    if tokens[0].style_info:
        print_style_info(tokens[0].style_info)

    last_token_text = layout_to_text(tokens[-1].layout, text)
    last_token_break_type = tokens[-1].detected_break.type_.name
    print(f"        Last token text: {repr(last_token_text)}")
    print(f"        Last token break type: {repr(last_token_break_type)}")
    if tokens[-1].style_info:
        print_style_info(tokens[-1].style_info)


def print_symbols(
    symbols: Sequence[documentai.Document.Page.Symbol], text: str
) -> None:
    print(f"    {len(symbols)} symbols detected:")
    first_symbol_text = layout_to_text(symbols[0].layout, text)
    print(f"        First symbol text: {repr(first_symbol_text)}")
    last_symbol_text = layout_to_text(symbols[-1].layout, text)
    print(f"        Last symbol text: {repr(last_symbol_text)}")


def print_image_quality_scores(
    image_quality_scores: documentai.Document.Page.ImageQualityScores,
) -> None:
    print(f"    Quality score: {image_quality_scores.quality_score:.1%}")
    print("    Detected defects:")

    for detected_defect in image_quality_scores.detected_defects:
        print(f"        {detected_defect.type_}: {detected_defect.confidence:.1%}")


def print_style_info(style_info: documentai.Document.Page.Token.StyleInfo) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    print(f"           Font Size: {style_info.font_size}pt")
    print(f"           Font Type: {style_info.font_type}")
    print(f"           Bold: {style_info.bold}")
    print(f"           Italic: {style_info.italic}")
    print(f"           Underlined: {style_info.underlined}")
    print(f"           Handwritten: {style_info.handwritten}")
    print(
        f"           Text Color (RGBa): {style_info.text_color.red}, {style_info.text_color.green}, {style_info.text_color.blue}, {style_info.text_color.alpha}"
    )


def print_visual_elements(
    visual_elements: Sequence[documentai.Document.Page.VisualElement], text: str
) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    checkboxes = [x for x in visual_elements if "checkbox" in x.type]
    math_symbols = [x for x in visual_elements if x.type == "math_formula"]

    if checkboxes:
        print(f"    {len(checkboxes)} checkboxes detected:")
        print(f"        First checkbox: {repr(checkboxes[0].type)}")
        print(f"        Last checkbox: {repr(checkboxes[-1].type)}")

    if math_symbols:
        print(f"    {len(math_symbols)} math symbols detected:")
        first_math_symbol_text = layout_to_text(math_symbols[0].layout, text)
        print(f"        First math symbol: {repr(first_math_symbol_text)}")




def process_document(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
    process_options: Optional[documentai.ProcessOptions] = None,
) -> documentai.Document:
    # You must set the `api_endpoint` if you use a location other than "us".
    client = documentai.DocumentProcessorServiceClient(
        client_options=ClientOptions(
            api_endpoint=f"{location}-documentai.googleapis.com"
        )
    )

    # The full resource name of the processor version, e.g.:
    # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`
    # You must create a processor before running this sample.
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version
    )

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

    # Configure the process request
    request = documentai.ProcessRequest(
        name=name,
        raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),
        # Only supported for Document OCR processor
        process_options=process_options,
    )

    result = client.process_document(request=request)

    # For a full list of `Document` object attributes, reference this page:
    # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document
    return result.document




def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:
    """
    Document AI identifies text in different parts of the document by their
    offsets in the entirety of the document"s text. This function converts
    offsets to a string.
    """
    # If a text segment spans several lines, it will
    # be stored in different text segments.
    return "".join(
        text[int(segment.start_index) : int(segment.end_index)]
        for segment in layout.text_anchor.text_segments
    )

Étape suivante