Fonctionnalités du module complémentaire Document Intelligence

Ce contenu s'applique à :v4.0 (GA) | Versions précédentes :v3.1 (GA) :::moniker-end

Capacités

Document Intelligence prend en charge des fonctionnalités d’analyse plus sophistiquées et modulaires. Utilisez les fonctionnalités de modules complémentaires pour étendre les résultats afin d’inclure d’autres fonctionnalités extraites de vos documents. Certaines fonctionnalités de modules complémentaires entraînent un coût supplémentaire. Ces fonctionnalités optionnelles peuvent être activées et désactivées selon le scénario d’extraction de documents. Pour activer une fonctionnalité, ajoutez le nom de fonctionnalité associé à la propriété features de la chaîne de requête. Vous pouvez activer plusieurs fonctionnalités du module complémentaire à la demande, en fournissant une liste séparée par des virgules de fonctionnalités. Les fonctionnalités du module complémentaire suivantes sont disponibles pour 2023-07-31 (GA) et les versions ultérieures.

• ocrHighResolution

• formulas

• styleFont

• barcodes

• languages

• Searchable PDF pris en charge

• queryFields

• keyValuePairs

Remarque

Tous les modèles ou types de fichiers Microsoft Office ne prennent pas en charge les fonctionnalités d’extension. Pour plus d’informations, consultezExtraction de données de modèle.

Disponibilité de la version

Fonctionnalité de module complémentaire	Module complémentaire/gratuit	2024-11-30 (GA)	2023-07-31 (GA)	2022-08-31 (GA)	v2.1 (GA)
Extraction de codes-barres	Gratuit	✔️	✔️	n/a	n/a
Détection de la langue	Gratuit	✔️	✔️	n/a	n/a
Paires clé-valeur	Gratuit	✔️	n/a	n/a	n/a
PDF pouvant être recherché	Gratuit	✔️	n/a	n/a	n/a
Extraction des propriétés de la police	Module complémentaire	✔️	✔️	n/a	n/a
Extraction de formules	Module complémentaire	✔️	✔️	n/a	n/a
Extraction à haute résolution	Module complémentaire	✔️	✔️	n/a	n/a
Champs de requête	Module complémentaire	✔️	n/a	n/a	n/a

✱ Module complémentaire : les champs de requête sont facturés différemment des autres fonctionnalités du module complémentaire. Pour en savoir plus, voir les tarifs.
** Module complémentaire - Un PDF pouvant faire l’objet d’une recherche est disponible uniquement avec le modèle de lecture en tant que fonctionnalité de module complémentaire.

Formats de fichiers pris en charge

• PDF

• Images : JPEG/JPG, PNG, BMP, TIFF, HEIF

✱ Les fichiers Microsoft Office ne sont pas pris en charge actuellement.

Extraction à haute résolution

La tâche de reconnaître de petits textes dans des documents de grande taille, comme les dessins d’ingénierie, est une difficulté. Le texte est parfois mélangé à d’autres éléments graphiques, avec des polices, tailles et orientations variables. De surcroît, le texte peut être scindé en parties distinctes ou relié à d’autres symboles. Document Intelligence prend désormais en charge l’extraction de contenu de ces types de documents avec la fonctionnalité ocr.highResolution. Vous obtenez une extraction de contenu de meilleure qualité à partir de documents A1/A2/A3 en activant cette fonctionnalité de module complémentaire.

REST API

{your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=ocrHighResolution

Exemple de code

# Analyze a document at a URL:
formUrl = "https://github.com/Azure-Samples/document-intelligence-code-samples/blob/main/Data/add-on/add-on-highres.png?raw=true"
poller = document_intelligence_client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=formUrl),
    features=[DocumentAnalysisFeature.OCR_HIGH_RESOLUTION],  # Specify which add-on capabilities to enable.
)
result: AnalyzeResult = poller.result()

# [START analyze_with_highres]
if result.styles and any([style.is_handwritten for style in result.styles]):
    print("Document contains handwritten content")
else:
    print("Document does not contain handwritten content")

for page in result.pages:
    print(f"----Analyzing layout from page #{page.page_number}----")
    print(f"Page has width: {page.width} and height: {page.height}, measured with unit: {page.unit}")

    if page.lines:
        for line_idx, line in enumerate(page.lines):
            words = get_words(page, line)
            print(
                f"...Line # {line_idx} has word count {len(words)} and text '{line.content}' "
                f"within bounding polygon '{line.polygon}'"
            )

            for word in words:
                print(f"......Word '{word.content}' has a confidence of {word.confidence}")

    if page.selection_marks:
        for selection_mark in page.selection_marks:
            print(
                f"Selection mark is '{selection_mark.state}' within bounding polygon "
                f"'{selection_mark.polygon}' and has a confidence of {selection_mark.confidence}"
            )

if result.tables:
    for table_idx, table in enumerate(result.tables):
        print(f"Table # {table_idx} has {table.row_count} rows and " f"{table.column_count} columns")
        if table.bounding_regions:
            for region in table.bounding_regions:
                print(f"Table # {table_idx} location on page: {region.page_number} is {region.polygon}")
        for cell in table.cells:
            print(f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'")
            if cell.bounding_regions:
                for region in cell.bounding_regions:
                    print(f"...content on page {region.page_number} is within bounding polygon '{region.polygon}'")

Consultez des exemples sur GitHub.

Sortie

"styles": [true],
"pages": [
  {
    "page_number": 1,
    "width": 1000,
    "height": 800,
    "unit": "px",
    "lines": [
      {
        "line_idx": 1,
        "content": "This",
        "polygon": [10, 20, 30, 40],
        "words": [
          {
            "content": "This",
            "confidence": 0.98
          }
        ]
      }
    ],
    "selection_marks": [
      {
        "state": "selected",
        "polygon": [50, 60, 70, 80],
        "confidence": 0.91
      }
    ]
  }
],
"tables": [
  {
    "table_idx": 1,
    "row_count": 3,
    "column_count": 4,
    "bounding_regions": [
      {
        "page_number": 1,
        "polygon": [100, 200, 300, 400]
      }
    ],
    "cells": [
      {
        "row_index": 1,
        "column_index": 1,
        "content": "Content 1",
        "bounding_regions": [
          {
            "page_number": 1,
            "polygon": [110, 210, 310, 410]
          }
        ]
      }
    ]
  }
]

Extraction de formules

La fonctionnalité ocr.formula extrait toutes les formules identifiées, dont les équations mathématiques, dans la collection formulas comme objet de niveau supérieur sous content. Dans content, les formules détectées sont représentées comme :formula:. Chaque entrée de cette collection représente une formule qui inclut le type de formule en tant que inline ou display et sa représentation LaTeX comme value avec ses coordonnées polygon. Les formules apparaissent en premier lieu à la fin de chaque page.

Remarque

Le score confidence est codé en dur.

REST API

{your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=formulas

Exemple de code

# Analyze a document at a URL:
formUrl = "https://github.com/Azure-Samples/document-intelligence-code-samples/blob/main/Data/add-on/layout-formulas.png?raw=true"
poller = document_intelligence_client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=formUrl),
    features=[DocumentAnalysisFeature.FORMULAS],  # Specify which add-on capabilities to enable
)
result: AnalyzeResult = poller.result()

# [START analyze_formulas]
for page in result.pages:
    print(f"----Formulas detected from page #{page.page_number}----")
    if page.formulas:
        inline_formulas = [f for f in page.formulas if f.kind == "inline"]
        display_formulas = [f for f in page.formulas if f.kind == "display"]

        # To learn the detailed concept of "polygon" in the following content, visit: https://aka.ms/bounding-region
        print(f"Detected {len(inline_formulas)} inline formulas.")
        for formula_idx, formula in enumerate(inline_formulas):
            print(f"- Inline #{formula_idx}: {formula.value}")
            print(f"  Confidence: {formula.confidence}")
            print(f"  Bounding regions: {formula.polygon}")

        print(f"\nDetected {len(display_formulas)} display formulas.")
        for formula_idx, formula in enumerate(display_formulas):
            print(f"- Display #{formula_idx}: {formula.value}")
            print(f"  Confidence: {formula.confidence}")
            print(f"  Bounding regions: {formula.polygon}")

Consultez des exemples sur GitHub.

Sortie

"content": ":formula:",
 "pages": [
   {
     "pageNumber": 1,
     "formulas": [
       {
         "kind": "inline",
         "value": "\\frac { \\partial a } { \\partial b }",
         "polygon": [...],
         "span": {...},
         "confidence": 0.99
       },
       {
         "kind": "display",
         "value": "y = a \\times b + a \\times c",
         "polygon": [...],
         "span": {...},
         "confidence": 0.99
       }
     ]
   }
 ]

Extraction des propriétés de la police

La fonctionnalité ocr.font extrait toutes les propriétés de police de caractère récupéré de la collection styles comme objet de niveau supérieur sous content. Chaque objet de style indique une propriété de police unique, l’étendue du texte à laquelle il s’applique et son score de confiance correspondant. La propriété de style existante est étendue avec d’autres propriétés de police, telles que similarFontFamily pour la police de caractère, fontStyle pour les styles comme italique et normal, fontWeight pour gras ou normal, color pour la couleur du texte et backgroundColor pour la couleur du cadre englobant le texte.

REST API

  {your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=styleFont

Exemple de code

# Analyze a document at a URL:
formUrl = "https://github.com/Azure-Samples/document-intelligence-code-samples/blob/main/Data/receipt/receipt-with-tips.png?raw=true"
poller = document_intelligence_client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=formUrl),
    features=[DocumentAnalysisFeature.STYLE_FONT]    # Specify which add-on capabilities to enable.
)
result: AnalyzeResult = poller.result()

# [START analyze_fonts]
# DocumentStyle has the following font related attributes:
similar_font_families = defaultdict(list)  # e.g., 'Arial, sans-serif
font_styles = defaultdict(list)  # e.g, 'italic'
font_weights = defaultdict(list)  # e.g., 'bold'
font_colors = defaultdict(list)  # in '#rrggbb' hexadecimal format
font_background_colors = defaultdict(list)  # in '#rrggbb' hexadecimal format

if result.styles and any([style.is_handwritten for style in result.styles]):
    print("Document contains handwritten content")
else:
    print("Document does not contain handwritten content")
    return

print("\n----Fonts styles detected in the document----")

# Iterate over the styles and group them by their font attributes.
for style in result.styles:
    if style.similar_font_family:
        similar_font_families[style.similar_font_family].append(style)
    if style.font_style:
        font_styles[style.font_style].append(style)
    if style.font_weight:
        font_weights[style.font_weight].append(style)
    if style.color:
        font_colors[style.color].append(style)
    if style.background_color:
        font_background_colors[style.background_color].append(style)

print(f"Detected {len(similar_font_families)} font families:")
for font_family, styles in similar_font_families.items():
    print(f"- Font family: '{font_family}'")
    print(f"  Text: '{get_styled_text(styles, result.content)}'")

print(f"\nDetected {len(font_styles)} font styles:")
for font_style, styles in font_styles.items():
    print(f"- Font style: '{font_style}'")
    print(f"  Text: '{get_styled_text(styles, result.content)}'")

print(f"\nDetected {len(font_weights)} font weights:")
for font_weight, styles in font_weights.items():
    print(f"- Font weight: '{font_weight}'")
    print(f"  Text: '{get_styled_text(styles, result.content)}'")

print(f"\nDetected {len(font_colors)} font colors:")
for font_color, styles in font_colors.items():
    print(f"- Font color: '{font_color}'")
    print(f"  Text: '{get_styled_text(styles, result.content)}'")

print(f"\nDetected {len(font_background_colors)} font background colors:")
for font_background_color, styles in font_background_colors.items():
    print(f"- Font background color: '{font_background_color}'")
    print(f"  Text: '{get_styled_text(styles, result.content)}'")

Consultez des exemples sur GitHub.

Sortie

"content": "Foo bar",
"styles": [
   {
     "similarFontFamily": "Arial, sans-serif",
     "spans": [ { "offset": 0, "length": 3 } ],
     "confidence": 0.98
   },
   {
     "similarFontFamily": "Times New Roman, serif",
     "spans": [ { "offset": 4, "length": 3 } ],
     "confidence": 0.98
   },
   {
     "fontStyle": "italic",
     "spans": [ { "offset": 1, "length": 2 } ],
     "confidence": 0.98
   },
   {
     "fontWeight": "bold",
     "spans": [ { "offset": 2, "length": 3 } ],
     "confidence": 0.98
   },
   {
     "color": "#FF0000",
     "spans": [ { "offset": 4, "length": 2 } ],
     "confidence": 0.98
   },
   {
     "backgroundColor": "#00FF00",
     "spans": [ { "offset": 5, "length": 2 } ],
     "confidence": 0.98
   }
 ]

Extraction des propriétés des code-barres

La fonctionnalité ocr.barcode extrait tous les code-barres identifiés dans la collection barcodes en tant qu’objet de niveau supérieur sous content. Dans content, les code-barres détectés sont représentés sous la forme :barcode:. Chaque entrée de cette collection représente un code-barres et inclut le type de code-barres comme kind et le contenu du code-barres incorporé comme value, ainsi que ses coordonnées polygon. Les code-barres apparaissent en premier lieu à la fin de chaque page. Le confidence est codé en dur pour 1.

Types de code-barres pris en charge

Type de code-barres	Exemple
QR Code
Code 39
Code 93
Code 128
UPC (UPC-A & UPC-E)
PDF417
EAN-8
EAN-13
Codabar
Databar
Databar Développée
ITF
Data Matrix

REST API

{your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=barcodes

Exemple de code

# Analyze a document at a URL:
formUrl = "https://github.com/Azure-Samples/document-intelligence-code-samples/blob/main/Data/add-on/add-on-barcodes.jpg?raw=true"
poller = document_intelligence_client.begin_analyze_document(
    "prebuilt-read",
    AnalyzeDocumentRequest(url_source=formUrl),
    features=[DocumentAnalysisFeature.BARCODES]    # Specify which add-on capabilities to enable.
)
result: AnalyzeResult = poller.result()

# [START analyze_barcodes]
# Iterate over extracted barcodes on each page.
for page in result.pages:
    print(f"----Barcodes detected from page #{page.page_number}----")
    if page.barcodes:
        print(f"Detected {len(page.barcodes)} barcodes:")
        for barcode_idx, barcode in enumerate(page.barcodes):
            print(f"- Barcode #{barcode_idx}: {barcode.value}")
            print(f"  Kind: {barcode.kind}")
            print(f"  Confidence: {barcode.confidence}")
            print(f"  Bounding regions: {barcode.polygon}")

Consultez des exemples sur GitHub.

Sortie

----Barcodes detected from page #1----
Detected 2 barcodes:
- Barcode #0: 123456
  Kind: QRCode
  Confidence: 0.95
  Bounding regions: [10.5, 20.5, 30.5, 40.5]
- Barcode #1: 789012
  Kind: QRCode
  Confidence: 0.98
  Bounding regions: [50.5, 60.5, 70.5, 80.5]

Détection de la langue

L’ajout de la fonctionnalité languages à la requête analyzeResult prédit le langage primaire détecté pour chaque ligne de texte, ainsi que la confidence dans la collection languages sous analyzeResult.

REST API

{your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=languages

Exemple de code

# Analyze a document at a URL:
formUrl = "https://github.com/Azure-Samples/document-intelligence-code-samples/blob/main/Data/add-on/add-on-fonts_and_languages.png?raw=true"
poller = document_intelligence_client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=formUrl),
    features=[DocumentAnalysisFeature.LANGUAGES]     # Specify which add-on capabilities to enable.
)
result: AnalyzeResult = poller.result()

# [START analyze_languages]
print("----Languages detected in the document----")
if result.languages:
    print(f"Detected {len(result.languages)} languages:")
    for lang_idx, lang in enumerate(result.languages):
        print(f"- Language #{lang_idx}: locale '{lang.locale}'")
        print(f"  Confidence: {lang.confidence}")
        print(
            f"  Text: '{','.join([result.content[span.offset : span.offset + span.length] for span in lang.spans])}'"
        )

Consultez des exemples sur GitHub.

Sortie

"languages": [
    {
        "spans": [
            {
                "offset": 0,
                "length": 131
            }
        ],
        "locale": "en",
        "confidence": 0.7
    },
]

PDF pouvant être recherché

La fonctionnalité PDF pouvant faire l’objet d’une recherche vous permet de convertir un fichier PDF analogique, tel que des fichiers PDF d’images numérisées, en PDF avec du texte incorporé. Le texte incorporé permet une recherche en texte profond dans le contenu extrait du PDF en superposant les entités de texte détectées au-dessus des fichiers image.

Important

• Actuellement, seul le modèle prebuilt-read de lecture prend en charge la fonctionnalité PDF pouvant faire l’objet d’une recherche. Lorsque vous utilisez cette fonctionnalité, définissez modelId comme prebuilt-read.
• Le PDF interrogeable est inclus dans le modèle 2024-11-30 (GA) prebuilt-read sans coût d'utilisation pour la consommation générale de PDF.

Utiliser un PDF pouvant faire l’objet d’une recherche

Pour utiliser un fichier PDF pouvant faire l’objet d’une recherche, effectuez une requête POST à l’aide de l’opération Analyze et spécifiez le format de sortie comme pdf :

POST /documentModels/prebuilt-read:analyze?output=pdf
{...}
202

Une fois l’opération Analyze terminée, effectuez une demande GET pour récupérer les résultats de l’opération Analyze.

Une fois l’opération terminée, le fichier PDF peut être récupéré et téléchargé en tant que application/pdf. Cette opération permet le téléchargement direct de la forme de texte incorporée au format PDF au lieu de JSON encodé en Base64.

// Monitor the operation until completion.
GET /documentModels/prebuilt-read/analyzeResults/{resultId}
200
{...}

// Upon successful completion, retrieve the PDF as application/pdf.
GET /documentModels/prebuilt-read/analyzeResults/{resultId}/pdf
200 OK
Content-Type: application/pdf

Paires clé-valeur

Dans les versions antérieures de l’API, le modèle prebuilt-document extrayait des paires clé-valeur à partir de formulaires et de documents. Avec l’ajout de la fonctionnalité keyValuePairs à la disposition prédéfinie, le modèle de disposition produit désormais les mêmes résultats.

Les paires clé-valeur sont des portions spécifiques dans le document qui identifient une étiquette ou une clé, ainsi que la réponse ou la valeur associée. Dans un formulaire structuré, ces paires pourraient être l’étiquette et la valeur saisie par l’utilisateur pour ce champ. Dans un document non structuré, il pourrait s’agir de la date d’exécution d’un contrat en fonction du texte d’un paragraphe. Le modèle d’IA est formé à l’extraction des clés et des valeurs identifiables à partir d’une grande variété de types, de formats et de structures de documents.

Les clés peuvent également exister de manière isolée lorsque le modèle détecte qu’une clé existe sans valeur associée ou lors du traitement de champs facultatifs. Par exemple, le champ du second prénom peut être laissé vide sur un formulaire dans certains cas. Les paires clé-valeur sont des étendues de texte contenues dans le document. Si, dans certains documents, la même valeur est décrite de plusieurs manières, par exemple client/utilisateur, la clé associée est soit client, soit utilisateur (en fonction du contexte).

API REST

{your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=keyValuePairs

Champs de requête

Les champs de requête sont une capacité du module complémentaire permettant d’étendre le schéma extrait de n’importe quel modèle prédéfini ou de définir un nom de clé spécifique lorsque le nom de la clé est variable. Pour utiliser des champs de requête, définissez les fonctionnalités sur queryFields et fournissez une liste (séparée par des virgules) des noms de champs dans la propriété queryFields.

• Document Intelligence prend désormais en charge les extractions de champs de requête. Avec l’extraction de champ de requête, vous pouvez ajouter des champs au processus d’extraction au moyen d’une requête sans besoin de formation supplémentaire.

• Utilisez des champs de requête lorsque vous devez étendre le schéma d’un modèle prédéfini ou personnalisé ou extraire quelques champs avec la sortie de la disposition.

• Les champs de requête sont une fonctionnalité de module complémentaire Premium. Pour de meilleurs résultats, définissez les champs que vous souhaitez extraire en utilisant des noms de champs en casse mixte (camel) ou Pascal pour les noms de champs à plusieurs mots.

• Les champs de requêtes prennent en charge un maximum de 20 champs par requête. Si le document contient une valeur pour le champ, le champ et la valeur sont retournés.

• Cette version comporte une nouvelle implémentation de la capacité des champs de requête, dont le prix est inférieur à celui de l’implémentation précédente et qui doit être validée.

Remarque

L'extraction des champs de requête dans Document Intelligence Studio est actuellement disponible avec l'API des modèles préconstruits (GA), à l'exception des modèles de déclaration fiscale américains 2024-11-30 W2, 1098 et 1099.

Extraction du champ de requête

Pour l’extraction de champ de requête, indiquez les champs à extraire et Document Intelligence analyse le document en conséquence. Voici un exemple :

• Si vous traitez un contrat dans Document Intelligence Studio, utilisez la version 2024-11-30 (GA) :

  

• Vous pouvez transmettre une liste d’étiquettes de champ comme Party1, Party2, TermsOfUse, PaymentTerms, PaymentDate et TermEndDate dans le cadre de la requête analyze document.

  

• Document Intelligence est en mesure d’analyser et d’extraire les données de champ et de retourner les valeurs dans une sortie JSON structurée.

• Outre les champs de requête, la réponse inclut du texte, des tableaux, des marques de sélection et d’autres données pertinentes.

REST API

{your-resource-endpoint}.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=2024-11-30&features=queryFields&queryFields=TERMS

Exemple de code

# Analyze a document at a URL:
formUrl = "https://github.com/Azure-Samples/document-intelligence-code-samples/blob/main/Data/invoice/simple-invoice.png?raw=true"
poller = document_intelligence_client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=formUrl),
    features=[DocumentAnalysisFeature.QUERY_FIELDS],    # Specify which add-on capabilities to enable.
    query_fields=["Address", "InvoiceNumber"],  # Set the features and provide a comma-separated list of field names.
)
result: AnalyzeResult = poller.result()
print("Here are extra fields in result:\n")
if result.documents:
    for doc in result.documents:
        if doc.fields and doc.fields["Address"]:
            print(f"Address: {doc.fields['Address'].value_string}")
        if doc.fields and doc.fields["InvoiceNumber"]:
            print(f"Invoice number: {doc.fields['InvoiceNumber'].value_string}")

Consultez des exemples sur GitHub.

Sortie

Address: 1 Redmond way Suite 6000 Redmond, WA Sunnayvale, 99243
Invoice number: 34278587

Étapes suivantes

En savoir plus : Modèle LectureModèle Disposition.

Exemples de kits SDK : python

Trouver d’autres exemples : Fonctionnalités de module complémentaire