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 différents documents. Grâce aux fonctionnalités configurables, vous pouvez adapter le système pour répondre à des 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, ainsi que pour améliorer et vérifier la précision des données. Vous pouvez également utiliser Enterprise Document OCR pour effectuer des tâches telles que les suivantes :

• Numérisation de texte : extrayez le texte et les données 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 capacité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 l'accessibilité des documents.

Choisir la meilleure solution OCR pour votre cas d'utilisation

Détection et extraction

Enterprise Document OCR peut détecter des blocs, des paragraphes, des lignes, des mots et des symboles dans les PDF et les images, et redresser les documents pour une meilleure précision.

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

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

• Extraire du texte intégré ou natif à partir de PDF numériques : cette fonctionnalité extrait le texte et les symboles exactement tels qu'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 l'orientation : utilisez Enterprise Document OCR pour prétraiter les images de documents afin de corriger les problèmes d'orientation qui peuvent affecter la qualité de l'extraction ou le traitement.

• Score de qualité d'image : recevez des métriques de qualité qui peuvent vous aider à acheminer les documents. Le score de qualité des images 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 l'éblouissement.

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

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

• Suggestions de langue et d'écriture manuscrite : améliorez la précision en fournissant au modèle OCR une suggestion 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 Activer les configurations OCR.

Modules complémentaires OCR

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

Les fonctionnalités complémentaires suivantes sont disponibles pour les versions pretrained-ocr-v2.0-2023-06-02 et pretrained-ocr-v2.1-2024-08-07 stables, ainsi que pour la version pretrained-ocr-v2.1.1-2025-01-31 Release Candidate.

• OCR mathématique : identifiez et extrayez des formules à partir de documents au format LaTeX.
• Extraction des cases à cocher : détectez les cases à cocher et extrayez leur état (coché/non coché) 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, le style, l'écriture manuscrite, l'épaisseur et la couleur de la police.

Pour savoir comment activer les modules complémentaires listés, consultez Activer les modules complémentaires de reconnaissance optique des caractères.

Formats de fichiers acceptés

La reconnaissance optique de caractères 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 Fichiers acceptés.

Enterprise Document OCR est également compatible avec les fichiers DocX de 15 pages maximum en mode synchrone et de 30 pages maximum en mode asynchrone. La compatibilité avec le format DocX est en version Preview privée. Pour demander l'accès, envoyez le formulaire de demande d'assistance DocX .

Gestion avancée des versions

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

Versions du processeur

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

Utiliser Enterprise Document OCR pour traiter des documents

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

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.

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

Go to project selector

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

Enable the Document AI API.

Enable the API

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

Go to project selector

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

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 Créer et gérer des processeurs.

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 demande 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 une qualité parfaite. Si le niveau de qualité détecté est inférieur à 0.5, une liste de raisons de mauvaise 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 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 de la qualité des documents présente certaines limites :

• Il peut renvoyer des faux positifs avec des documents numériques sans défauts. Cette fonctionnalité est plus efficace sur les documents numérisés ou photographiés.

• Les défauts d'éblouissement sont locaux. Leur présence n'empêche pas forcément la lisibilité globale du document.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.enableImageQualityScores sur true dans la demande 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 complets, consultez Exemple de sortie de processeur.

Indicateurs de langue

Le processeur de reconnaissance optique des caractères est compatible avec les indications de langue que vous définissez pour améliorer les performances du moteur de reconnaissance optique des caractères. L'application d'un indice de langue permet à la ROC d'être optimisée pour une langue sélectionnée au lieu d'une langue déduite.

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 complets, consultez Exemple de sortie de processeur.

Détection des symboles

Renseigne 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 demande 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 complets, consultez Exemple de sortie de processeur.

Analyse PDF intégrée

Extrayez le texte intégré des fichiers PDF numériques. Lorsqu'il est activé, le modèle PDF numérique intégré est automatiquement utilisé s'il existe du texte numérique. Si le texte n'est pas numérique, 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 demande de traitement.

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

Détection de personnages dans un cadre

Par défaut, Enterprise Document OCR est doté d'un détecteur qui améliore la qualité de l'extraction de texte des caractères situés dans un encadré. Voici un exemple :



Si vous rencontrez des problèmes de qualité de reconnaissance optique des caractères avec des caractères dans des cadres, vous pouvez désactiver cette option.

Entrée

Pour le désactiver, définissez ProcessOptions.ocrConfig.disableCharacterBoxesDetection sur true dans la demande de traitement.

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

Ancienne mise en page

Si vous avez besoin d'un algorithme heuristique de détection de la mise en page, vous pouvez activer l'ancienne mise en page, qui sert d'alternative à l'algorithme actuel de détection de la mise en page 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 mieux adapté à leur flux de travail de documents.

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.advancedOcrOptions sur ["legacy_layout"] dans la demande 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 le texte que de ces pages.

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

• Pour ne traiter que la deuxième et la cinquième page :

  {
    "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 que celles 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 les demandes de traitement individuelles selon les besoins.

Fonction OCR mathématique

La reconnaissance optique des caractères (OCR) 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

  

• Conversion au format LaTeX

  

Entrée

Pour l'activer, définissez ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr sur true dans la demande 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ématiques 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 le résultat JSON complet 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 tous 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 demande de traitement.

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

Sortie

Le résultat 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 le résultat JSON complet 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 meilleur post-traitement.

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 (RGBa)

• Couleur d'arrière-plan (RGBa)

Entrée

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

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

Sortie

La sortie font-style s'affiche dans 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 le résultat JSON complet 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 l'API Vision AI. Les utilisateurs peuvent ainsi comparer les réponses entre le processeur de reconnaissance optique des caractères (OCR) de documents et l'API Vision AI. Voici un exemple de code.

Voici les différences connues entre la réponse de l'API Vision AI et celle de l'API Document AI, ainsi que le convertisseur :

• La réponse de l'API Vision AI ne renseigne que vertices pour les requêtes d'images et normalized_vertices pour les requêtes de PDF. La réponse Document AI et le convertisseur remplissent vertices et normalized_vertices.
• La réponse de l'API Vision AI renseigne 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 remplit toujours les champs de symboles. Par défaut, la réponse Document AI ne renseigne pas les champs de symboles. Pour vous assurer que la réponse Document AI et le convertisseur remplissent les champs de symboles, définissez la fonctionnalité enable_symbol comme détaillé.

Exemples de code

Les exemples de code suivants montrent comment envoyer une requête de traitement permettant les configurations et les modules complémentaires OCR, puis comment 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 : booléen permettant de désactiver l'examen manuel (compatible uniquement avec les processeurs Human-in-the-Loop).
  • true : l'examen manuel est ignoré.
  • false : active l'examen manuel (valeur par défaut)
• MIME_TYPE^† : l'une des options de type MIME valides.
• IMAGE_CONTENT^† : contenu de document intégré valide, représenté sous forme de flux d'octets. Pour les représentations JSON, l'encodage en 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==
  Pour en savoir plus, consultez la section Encodage Base64.
• FIELD_MASK : spécifie les champs à inclure dans la sortie Document. Il s'agit d'une liste de noms de champs complets au format FieldMask.
  • Exemple : text,entities,pages.pageNumber
• Configurations de l'OCR
  • ENABLE_NATIVE_PDF_PARSING : (booléen) extrait le texte intégré des 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 cadres 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 des 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 la mise en page heuristique, qui sert d'alternative à l'algorithme de détection de la mise en page basé sur le ML actuel.
• 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) activez 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 au début ou à la fin du document.

† Ce contenu peut également être spécifié à l'aide de 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 renvoie 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
    )

Étapes suivantes

• Consultez la liste des outils de traitement.
• Séparez les documents en fragments lisibles avec l'analyseur de mise en page.
• Créez un classificateur personnalisé.