Recursos de complemento do Document Intelligence

Esse conteúdo se aplica a: v4.0 (GA) | Versões anteriores: v3.1 (GA):::moniker-end

Funcionalidades

A Informação de Documentos agora dá suporte a recursos de análise mais sofisticados e modulares. Use os recursos de complemento para estender os resultados para incluir mais recursos extraídos de seus documentos. Alguns recursos de complemento incorrem em um custo extra. Esses recursos opcionais podem ser habilitados e desabilitados dependendo do cenário de extração de documentos. Para habilitar um recurso, adicione o nome do recurso associado à propriedade features da cadeia de caracteres da consulta. Você pode habilitar mais de um recurso complementar em uma solicitação ao fornecer uma lista de recursos separada por vírgulas. Os seguintes recursos complementares estão disponíveis para a versão 2023-07-31 (GA) e posteriores.

• ocrHighResolution

• formulas

• styleFont

• barcodes

• languages

• Searchable PDF suporte

• queryFields

• keyValuePairs

Observação

• Nem todas as funcionalidades complementares têm suporte para todos os modelos. Para obter mais informações, confira extração de dados do modelo.

• Atualmente, não há suporte para recursos de complemento dos tipos de arquivo do Microsoft Office.

Disponibilidade de versão

Capacidade de complemento	Complemento/gratuito	2024-11-30 (GA)	2023-07-31 (GA)	2022-08-31 (GA)	v2.1 (GA)
Extração de código de barras	Grátis	✔️	✔️	N/D	N/D
Detecção de idioma	Grátis	✔️	✔️	N/D	N/D
Pares chave-valor	Grátis	✔️	N/D	N/D	N/D
PDF pesquisável	Gratuita	✔️	N/D	N/D	N/D
Extração de propriedade de fonte	Complemento	✔️	✔️	N/D	N/D
Extração de fórmulas	Complemento	✔️	✔️	N/D	N/D
Extração de alta resolução	Complemento	✔️	✔️	N/D	N/D
Campos de consulta	Complemento	✔️	N/D	N/D	N/D

✱ Complemento: os campos de consulta têm um preço diferente dos outros recursos complementares. Para obter detalhes, confira os preços.
** Complemento – PDF pesquisável só está disponível com o modelo de leitura como um recurso de complemento.

Formatos de arquivo com suporte

• PDF

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

✱ Atualmente, não há suporte para arquivos do Microsoft Office.

Extração de alta resolução

A tarefa de reconhecer textos pequenos de documentos de grande porte, como desenhos de engenharia, é um desafio. Geralmente, o texto é misturado com outros elementos gráficos e tem fontes, tamanhos e orientações variados. Além disso, o texto pode ser dividido em partes separadas ou conectado a outros símbolos. A Informação de Documentos agora dá suporte à extração de conteúdo desses tipos de documentos com a funcionalidade ocr.highResolution. Você obtém uma qualidade aprimorada da extração de conteúdo de documentos A1/A2/A3 habilitando essa funcionalidade de complemento.

REST API

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

Código de exemplo

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

Exibir exemplos no GitHub.

Saída

"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]
          }
        ]
      }
    ]
  }
]

Extração de fórmulas

A funcionalidade ocr.formula extrai todas as fórmulas identificadas, como equações matemáticas, na coleção formulas como um objeto de nível superior em content. Dentro de content, as fórmulas detectadas são representadas como :formula:. Cada entrada nesta coleção representa uma fórmula que inclui o tipo de fórmula como inline ou display, e sua representação LaTeX como value junto com suas coordenadas polygon. Inicialmente, fórmulas aparecem no final de cada página.

Observação

A pontuação confidence é codificada.

REST API

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

Código de exemplo

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

Exibir exemplos no GitHub.

Saída

"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
       }
     ]
   }
 ]

Extração de propriedade de fonte

A funcionalidade ocr.font extrai todas as propriedades de fonte do texto extraído na coleção styles como um objeto de nível superior em content. Cada objeto de estilo especifica uma única propriedade de fonte, o intervalo de texto ao qual ele se aplica e sua pontuação de confiança correspondente. A propriedade de estilo existente é estendida com mais propriedades de fonte, como similarFontFamily para a fonte do texto, fontStyle para estilos como itálico e normal, fontWeight para negrito ou normal, color para cor do texto e backgroundColor para a cor da caixa delimitadora de texto.

REST API

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

Código de exemplo

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

Exibir exemplos no GitHub.

Saída

"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
   }
 ]

Extração de propriedade de código de barras

O recurso ocr.barcode extrai todos os códigos de barras identificados na coleção barcodes como um objeto de nível superior em content. Dentro do content, os códigos de barras detectados são representados como :barcode:. Cada entrada nesta coleção representa um código de barras e inclui o tipo de código de barras como kind e o conteúdo do código de barras inserido como value, juntamente com suas coordenadas polygon. Inicialmente, os códigos de barras aparecem no final de cada página. O confidence é codificado como 1.

Tipos de código de barras com suporte

Tipo de código de barras	Exemplo
QR Code
Code 39
Code 93
Code 128
UPC (UPC-A & UPC-E)
PDF417
EAN-8
EAN-13
Codabar
Databar
Databar Expandido
ITF
Data Matrix

REST API

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

Código de exemplo

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

Exibir exemplos no GitHub.

Saída

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

Detecção de idioma

Adicionar o recurso languages à solicitação analyzeResult prevê o idioma principal detectado para cada linha de texto junto com a confidence na coleção de languages em analyzeResult.

REST API

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

Código de exemplo

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

Exibir exemplos no GitHub.

Saída

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

PDF Pesquisável

A funcionalidade do PDF pesquisável permite que você converta um PDF analógico, como arquivos PDF de imagem digitalizada, em um PDF com texto inserido. O texto inserido habilita a pesquisa de texto profundo no conteúdo extraído do PDF sobrepondo as entidades de texto detectadas sobre os arquivos de imagem.

Importante

• Atualmente, a funcionalidade do PDF pesquisável só tem suporte pelo modelo OCR de Leitura prebuilt-read. Ao usar esse recurso, especifique a modelId como prebuilt-read.
• O PDF pesquisável está incluído no modelo 2024-11-30 (GA) prebuilt-read sem custo de uso para o consumo geral do PDF.

Usar o PDF pesquisável

Para usar o PDF pesquisável, faça uma solicitação POST usando a operação Analyze e especifique o formato de saída como pdf:

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

Depois que a operação de Analyze for concluída, faça uma solicitação GET para recuperar os resultados da operação Analyze.

Após a conclusão bem-sucedida, o PDF pode ser recuperado e baixado como application/pdf. Essa operação permite o download direto do formulário de texto inserido do PDF em vez de do JSON codificado em 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

Pares de chave-valor

Em versões anteriores da API, o modelo prebuilt-document extraía pares chave-valor de formulários e documentos. Com o acréscimo do recurso keyValuePairs ao layout predefinido, o modelo de layout agora produz os mesmos resultados.

Pares de chave-valor são spans específicos dentro do documento que identificam um rótulo ou chave e sua resposta ou valor associado. Em um formulário estruturado, esses pares poderiam ser o rótulo e o valor que o usuário inseriu no campo. Em um documento não estruturado, poderiam ser a data em que um contrato foi executado com base no texto em um parágrafo. O modelo de AI é treinado para extrair chaves e valores identificáveis com base em uma ampla variedade de tipos de documento, formatos e estruturas.

As chaves também podem existir isoladamente quando o modelo detecta que existe uma chave, sem valor associado ou ao processar campos opcionais. Por exemplo, um campo de nome do meio pode ser deixado em branco em um formulário em algumas instâncias. Pares de chave-valor são intervalos de texto contidos no documento. Para documentos em que o mesmo valor é descrito de maneiras diferentes, por exemplo, cliente/usuário, a chave associada é cliente ou usuário (com base no contexto).

API REST

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

Campos de consulta

Os campos de consulta são um recurso complementar destinado a ampliar o esquema extraído de qualquer modelo predefinido ou definir um nome de chave específico quando o nome da chave for variável. Para usar campos de consulta, defina os recursos para queryFields e forneça uma lista separada por vírgulas de nomes de campo na propriedade queryFields.

• A Informação de Documentos agora dá suporte ás extrações de campo de consulta. Com a extração de campo de consulta, é possível adicionar campos ao processo de extração usando uma solicitação de consulta sem a necessidade de treinamento adicional.

• Use os campos de consulta quando precisar estender o esquema de um modelo predefinido ou personalizado ou precisar extrair alguns campos com a saída do layout.

• Os campos de consulta são uma funcionalidade de complemento premium. Para obter melhores resultados, defina os campos que deseja extrair usando nomes de campo em letras maiúsculas ou minúsculas para nomes de campo com várias palavras.

• Os campos de consulta dão suporte a um máximo de 20 campos por solicitação. Se o documento contiver um valor para o campo, o campo e o valor serão retornados.

• Esta versão tem uma nova implementação da funcionalidade de campos de consulta que tem um preço menor que a implementação anterior e deve ser validada.

Observação

A extração de campo do Document Intelligence Studio está disponível atualmente com os modelos Layout e Predefinidos 2024-11-30 (GA) API with the exception of the modelos fiscais dos EUA (modelos W2, 1098s e 1099s).

Extração de campo de consulta

Para realizar a extração de campo de consulta, especifique os campos que deseja extrair e a Informação de Documentos analisará o documento adequadamente. Veja um exemplo:

• Se você estiver processando um contrato no Estúdio da Informação de Documentos, use a versão 2024-11-30 (GA):

  

• Você pode passar uma lista de rótulos de campo como Party1, Party2, TermsOfUse, PaymentTerms, PaymentDate e TermEndDate como parte da solicitação de analyze document.

  

• A Informação de Documentos pode analisar e extrair os dados de campo e retornar os valores em uma saída JSON estruturada.

• Além dos campos de consulta, a resposta inclui texto, tabelas, marcas de seleção e outros dados relevantes.

REST API

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

Código de exemplo

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

Exibir exemplos no GitHub.

Saída

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

Próximas etapas

Saiba mais: Ler modelo Modelo de layout

Exemplos de SDK: Python

Confira mais exemplos: Recursos de complemento