Introduzione a Document Intelligence

Importante

• Servizi cognitivi di Azure Riconoscimento modulo è ora Intelligence sui documenti di Intelligenza artificiale di Azure.
• Alcune piattaforme sono ancora in attesa dell'aggiornamento della ridenominazione.
• Tutte le menzioni di Riconoscimento modulo o document intelligence nella documentazione fanno riferimento allo stesso servizio di Azure.

Questo contenuto si applica a:v4.0 (anteprima)Versioni precedenti:v3.1 (GA)v3.0 (GA)

• Introduzione all'anteprima più recente di Azure AI Document Intelligence (anteprima 2024-02-29-preview).

• Azure AI Document Intelligence/Riconoscimento modulo è un servizio di intelligenza artificiale di Azure basato sul cloud che usa Machine Learning per estrarre coppie chiave-valore, testo, tabelle e dati chiave dai documenti.

• È possibile integrare facilmente i modelli di elaborazione dei documenti nei flussi di lavoro e nelle applicazioni usando un SDK del linguaggio di programmazione o chiamando l'API REST.

• Per questa guida introduttiva, è consigliabile usare il servizio gratuito durante l'apprendimento della tecnologia. Tenere presente che il numero di pagine gratuite è limitato a 500 al mese.

Per altre informazioni sulle funzionalità dell'API e sulle opzioni di sviluppo, visitare la pagina Panoramica .

Informazioni di riferimento | dell'SDK della libreria | client per l'API REST Samples Supported REST API version (Esempi di pacchetti di riferimento| | api|REST supportati)

In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:

• Modello di layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione come pulsanti di opzione e caselle di controllo nei documenti, senza la necessità di eseguire il training di un modello.

• Modello predefinito: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito.

• Versione corrente dell'IDE di Visual Studio.

• Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa multiservizio o a servizio singolo di Intelligenza artificiale di Azure, nella portale di Azure, per ottenere la chiave e l'endpoint.

• È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Suggerimento

Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.

• Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:

  

Configurazione

1. Avviare Visual Studio.

2. Nella pagina iniziale scegliere Crea un nuovo progetto.

   

3. Nella pagina Crea un nuovo progetto immettere console nella casella di ricerca. Scegliere il modello Applicazione console, quindi scegliere Avanti.

   

4. Nella finestra di dialogo Configura il nuovo progetto immettere doc_intel_quickstart nella casella Nome progetto. Scegliere quindi Avanti.

5. Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.

   

Installare la libreria client con NuGet

1. Fare clic con il pulsante destro del mouse sul progetto doc_intel_quickstart e scegliere Gestisci pacchetti NuGet... .

   

2. Selezionare la scheda Sfoglia e digitare Azure.AI.DocumentIntelligence. Scegliere la casella di controllo e selezionare la Include prerelease versione 1.0.0-beta.1 dal menu a discesa

   

Compilare l'applicazione

Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient classe . A tale scopo, si crea un AzureKeyCredential oggetto con l'oggetto dal key portale di Azure e un'istanza DocumentIntelligenceClientAzureKeyCredential con e document intelligence endpoint.

Nota

• A partire da .NET 6, i nuovi progetti che usano il console modello generano un nuovo stile di programma diverso dalle versioni precedenti.
• Il nuovo output usa le funzionalità C# recenti che semplificano il codice da scrivere.
• Quando si usa la versione più recente, è sufficiente scrivere il corpo del metodo Main. Non è necessario includere istruzioni di primo livello, direttive using globali o direttive using implicite.
• Per altre informazioni, vedereNuovi modelli C# generano istruzioni di primo livello.

1. Aprire il file Program.cs.

2. Eliminare il codice preesistente, inclusa la riga Console.Writeline("Hello World!"), e selezionare uno degli esempi di codice seguenti per copiare e incollare nel file Program.cs dell'applicazione:

   • Modello di layout

   • Modello predefinito

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.

Modello di layout

Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.

• Per questo esempio, è necessario un file di documento da un URI. È possibile usare il documento di esempio per questa guida introduttiva.
• È stato aggiunto il valore dell'URI del file alla Uri fileUri variabile nella parte superiore dello script.
• Per estrarre il layout da un determinato file in un URI, usare il StartAnalyzeDocumentFromUri metodo e passare prebuilt-layout come ID modello. Il valore restituito è un AnalyzeResult oggetto contenente i dati del documento inviato.

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:

using Azure;
using Azure.AI.DocumentIntelligence;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(new Uri(endpoint), credential);

//sample document
Uri fileUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-layout", fileUri);

AnalyzeResult result = operation.Value;

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s)," +
        $" and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];

        Console.WriteLine($"  Line {i}:");
        Console.WriteLine($"    Content: '{line.Content}'");

        Console.Write("    Bounding polygon, with points ordered clockwise:");
        for (int j = 0; j < line.Polygon.Count; j += 2)
        {
            Console.Write($" ({line.Polygon[j]}, {line.Polygon[j + 1]})");
        }

        Console.WriteLine();
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    State: {selectionMark.State}");

        Console.Write("    Bounding polygon, with points ordered clockwise:");
        for (int j = 0; j < selectionMark.Polygon.Count; j++)
        {
            Console.Write($" ({selectionMark.Polygon[j]}, {selectionMark.Polygon[j + 1]})");
        }

        Console.WriteLine();
    }
}

for (int i = 0; i < result.Paragraphs.Count; i++)
{
    DocumentParagraph paragraph = result.Paragraphs[i];

    Console.WriteLine($"Paragraph {i}:");
    Console.WriteLine($"  Content: {paragraph.Content}");

    if (paragraph.Role != null)
    {
        Console.WriteLine($"  Role: {paragraph.Role}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            var handwrittenContent = result.Content.Substring(span.Offset, span.Length);
            Console.WriteLine($"  {handwrittenContent}");
        }
    }
}

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];

    Console.WriteLine($"Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"  Cell ({cell.RowIndex}, {cell.ColumnIndex}) is a '{cell.Kind}' with content: {cell.Content}");
    }
}

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, scegliere il pulsante Start verde accanto a formRecognizer_quickstart per compilare ed eseguire il programma oppure premere F5.

Modello predefinito

Analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito. In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.

Suggerimento

Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

• Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
• È stato aggiunto il valore dell'URI del file alla Uri invoiceUri variabile nella parte superiore del file Program.cs.
• Per analizzare un determinato file in corrispondenza di un URI, usare il StartAnalyzeDocumentFromUri metodo e passare prebuilt-invoice come ID modello. Il valore restituito è un AnalyzeResult oggetto contenente i dati del documento inviato.
• Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:

using Azure;
using Azure.AI.DocumentIntelligence;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(new Uri(endpoint), credential);

//sample invoice document

Uri invoiceUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);

AnalyzeResult result = operation.Value;

for (int i = 0; i < result.Documents.Count; i++)
{
    Console.WriteLine($"Document {i}:");

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField)
        && vendorNameField.Type == DocumentFieldType.String)
    {
        string vendorName = vendorNameField.ValueString;
        Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
    }

    if (document.Fields.TryGetValue("CustomerName", out DocumentField customerNameField)
        && customerNameField.Type == DocumentFieldType.String)
    {
        string customerName = customerNameField.ValueString;
        Console.WriteLine($"Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
    }

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField)
        && itemsField.Type == DocumentFieldType.Array)
    {
        foreach (DocumentField itemField in itemsField.ValueArray)
        {
            Console.WriteLine("Item:");

            if (itemField.Type == DocumentFieldType.Object)
            {
                IReadOnlyDictionary<string, DocumentField> itemFields = itemField.ValueObject;

                if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField)
                    && itemDescriptionField.Type == DocumentFieldType.String)
                {
                    string itemDescription = itemDescriptionField.ValueString;
                    Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                }

                if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField)
                    && itemAmountField.Type == DocumentFieldType.Currency)
                {
                    CurrencyValue itemAmount = itemAmountField.ValueCurrency;
                    Console.WriteLine($"  Amount: '{itemAmount.CurrencySymbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                }
            }
        }
    }

    if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField)
        && subTotalField.Type == DocumentFieldType.Currency)
    {
        CurrencyValue subTotal = subTotalField.ValueCurrency;
        Console.WriteLine($"Sub Total: '{subTotal.CurrencySymbol}{subTotal.Amount}', with confidence {subTotalField.Confidence}");
    }

    if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField)
        && totalTaxField.Type == DocumentFieldType.Currency)
    {
        CurrencyValue totalTax = totalTaxField.ValueCurrency;
        Console.WriteLine($"Total Tax: '{totalTax.CurrencySymbol}{totalTax.Amount}', with confidence {totalTaxField.Confidence}");
    }

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField)
        && invoiceTotalField.Type == DocumentFieldType.Currency)
    {
        CurrencyValue invoiceTotal = invoiceTotalField.ValueCurrency;
        Console.WriteLine($"Invoice Total: '{invoiceTotal.CurrencySymbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
    }
}

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, scegliere il pulsante Start verde accanto a formRecognizer_quickstart per compilare ed eseguire il programma oppure premere F5.

Client library | SDK reference | REST API reference | Package (Maven)Samples Supported REST API version (Maven)Samples Supported REST API version (Maven) | Samples |Supported REST API version

In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:

• Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione, ad esempio pulsanti di opzione e caselle di controllo nei documenti, senza la necessità di eseguire il training di un modello.

• Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello con training preliminare.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito.

• Versione più recente di Visual Studio Code o dell'IDE preferito. VedereJava in Visual Studio Code.

  Suggerimento

  • Visual Studio Code offre un pacchetto di codifica per Java per Windows e macOS.Il pacchetto di codifica è un bundle di VS Code, Java Development Kit (JDK) e una raccolta di estensioni suggerite da Microsoft. Il pacchetto di codifica può essere usato anche per correggere un ambiente di sviluppo esistente.
  • Se si usa VS Code e Coding Pack per Java, installare l'estensione Gradle per Java .

• Se non si usa Visual Studio Code, assicurarsi di avere installato quanto segue nell'ambiente di sviluppo:

  • Java Development Kit (JDK) versione 8 o successiva. Per altre informazioni, vedereMicrosoft Build of OpenJDK.

  • Gradle, versione 6.8 o successiva.

• Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

  Suggerimento

  Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.

• Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. Successivamente, incollare la chiave e l'endpoint nel codice:

  

Configurazione

Creare un nuovo progetto Gradle

1. Nella finestra della console ,ad esempio cmd, PowerShell o Bash, creare una nuova directory per l'app denominata doc-intel-app e passare a essa.

   mkdir doc-intel-app && doc-intel-app
   

   mkdir doc-intel-app; cd doc-intel-app
   

2. Eseguire il comando gradle init dalla directory di lavoro. Questo comando crea file di compilazione essenziali per Gradle, incluso build.gradle.kts, usato in fase di esecuzione per creare e configurare l'applicazione.

   gradle init --type basic
   

3. Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

4. Accettare il nome del progetto predefinito (doc-intel-app) selezionando Restituisci o Invio.

Installare la libreria client

Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.

Aprire il file build.gradle.kts del progetto nell'IDE. Copay e oltre il codice seguente per includere la libreria client come istruzione implementation , insieme ai plug-in e alle impostazioni necessari.

   plugins {
       java
       application
   }
   application {
       mainClass.set("DocIntelligence")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-documentintelligence', version: '1.0.0-beta.2'

   }

Creare un'applicazione Java

Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient classe . A tale scopo, si crea un AzureKeyCredential oggetto con l'oggetto dal key portale di Azure e un'istanza DocumentIntelligenceClientAzureKeyCredential con e document intelligence endpoint.

1. Dalla directory doc-intel-app eseguire il comando seguente:

   mkdir -p src/main/java
   

   Creare la struttura di directory seguente:

   

2. Passare alla java directory e creare un file denominato DocIntelligence.java.

   Suggerimento

   • È possibile creare un nuovo file usando PowerShell.
   • Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.
   • Digitare il comando seguente DocIntelligence.java New-Item.

3. Apri il file DocIntelligence.java. Copiare e incollare uno degli esempi di codice seguenti nell'applicazione:

   • Layout

   • Fattura predefinita

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.

Modello di layout

Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.

• Per questo esempio, è necessario un file di documento in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
• Per analizzare un determinato file in un URI, si userà il beginAnalyzeDocumentFromUrl metodo e si passerà prebuilt-layout come ID modello. Il valore restituito è un AnalyzeResult oggetto contenente i dati relativi al documento inviato.
• È stato aggiunto il valore dell'URI del file alla documentUrl variabile nel metodo main.

Aggiungere il codice di esempio seguente al DocIntelligence.java file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.DocumentTable;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.util.List;

public class DocIntelligence {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(String[] args) {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String documentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
    String modelId = "prebuilt-layout";

    SyncPoller <AnalyzeResultOperation, AnalyzeResultOperation> analyzeLayoutResultPoller =
      client.beginAnalyzeDocument(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutPoller.getFinalResult().getAnalyzeResult();

    // pages
    analyzeLayoutResult.getPages().forEach(documentPage -> {
      System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
        documentPage.getWidth(),
        documentPage.getHeight(),
        documentPage.getUnit());

      // lines
      documentPage.getLines().forEach(documentLine ->
        System.out.printf("Line '%s' is within a bounding polygon %s.%n",
          documentLine.getContent(),
          documentLine.getPolygon()));

      // words
      documentPage.getWords().forEach(documentWord ->
        System.out.printf("Word '%s' has a confidence score of %.2f.%n",
          documentWord.getContent(),
          documentWord.getConfidence()));

      // selection marks
      documentPage.getSelectionMarks().forEach(documentSelectionMark ->
        System.out.printf("Selection mark is '%s' and is within a bounding polygon %s with confidence %.2f.%n",
          documentSelectionMark.getState().toString(),
          documentSelectionMark.getPolygon(),
          documentSelectionMark.getConfidence()));
    });

    // tables
    List < DocumentTable > tables = analyzeLayoutResult.getTables();
    for (int i = 0; i < tables.size(); i++) {
      DocumentTable documentTable = tables.get(i);
      System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
        documentTable.getColumnCount());
      documentTable.getCells().forEach(documentTableCell -> {
        System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
          documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
      });
      System.out.println();
    }

    // styles
    analyzeLayoutResult.getStyles().forEach(documentStyle -
      > System.out.printf("Document is handwritten %s.%n", documentStyle.isHandwritten()));
  }
}

Compilare ed eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, tornare alla directory principale del progetto, ovvero doc-intel-app.

1. Compilare l'applicazione con il build comando :

   gradle build
   

2. Eseguire l'applicazione con il run comando :

   gradle run
   

Modello predefinito

Analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito. In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.

Suggerimento

Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

• Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
• È stato aggiunto il valore dell'URL del file alla invoiceUrl variabile nella parte superiore del file.
• Per analizzare un determinato file in un URI, si userà il beginAnalyzeDocuments metodo e si passerà PrebuiltModels.Invoice come ID modello. Il valore restituito è un result oggetto contenente i dati relativi al documento inviato.
• Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .

Aggiungere il codice di esempio seguente al DocIntelligence.java file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

public class DocIntelligence {

  // set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
  private static final String endpoint = "<your-endpoint>";
  private static final String key = "<your-key>";

  public static void main(String[] args) {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

    // sample document
    String modelId = "prebuilt-invoice";
    String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

    public static void main(final String[] args) throws IOException {
      // Instantiate a client that will be used to call the service.
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential("{key}"))
        .endpoint("https://{endpoint}.cognitiveservices.azure.com/")
        .buildClient();

      SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
        client.beginAnalyzeDocument(modelId, invoiceUrl);

      AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult().getAnalyzeResult();

      for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
        Document analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
        Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
        System.out.printf("----------- Analyzing invoice  %d -----------%n", i);
        DocumentField vendorNameField = invoiceFields.get("VendorName");
        if (vendorNameField != null) {
          if (DocumentFieldType.STRING == vendorNameField.getType()) {
            String merchantName = vendorNameField.getValueString();
            System.out.printf("Vendor Name: %s, confidence: %.2f%n",
              merchantName, vendorNameField.getConfidence());
          }
        }

        DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
        if (vendorAddressField != null) {
          if (DocumentFieldType.STRING == vendorAddressField.getType()) {
            String merchantAddress = vendorAddressField.getValueString();
            System.out.printf("Vendor address: %s, confidence: %.2f%n",
              merchantAddress, vendorAddressField.getConfidence());
          }
        }

        DocumentField customerNameField = invoiceFields.get("CustomerName");
        if (customerNameField != null) {
          if (DocumentFieldType.STRING == customerNameField.getType()) {
            String merchantAddress = customerNameField.getValueString();
            System.out.printf("Customer Name: %s, confidence: %.2f%n",
              merchantAddress, customerNameField.getConfidence());
          }
        }

        DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
        if (customerAddressRecipientField != null) {
          if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
            String customerAddr = customerAddressRecipientField.getValueString();
            System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
              customerAddr, customerAddressRecipientField.getConfidence());
          }
        }

        DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
        if (invoiceIdField != null) {
          if (DocumentFieldType.STRING == invoiceIdField.getType()) {
            String invoiceId = invoiceIdField.getValueString();
            System.out.printf("Invoice ID: %s, confidence: %.2f%n",
              invoiceId, invoiceIdField.getConfidence());
          }
        }

        DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
        if (customerNameField != null) {
          if (DocumentFieldType.DATE == invoiceDateField.getType()) {
            LocalDate invoiceDate = invoiceDateField.getValueDate();
            System.out.printf("Invoice Date: %s, confidence: %.2f%n",
              invoiceDate, invoiceDateField.getConfidence());
          }
        }

        DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
        if (customerAddressRecipientField != null) {
          if (DocumentFieldType.NUMBER == invoiceTotalField.getType()) {
            Double invoiceTotal = invoiceTotalField.getValueNumber();
            System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
              invoiceTotal, invoiceTotalField.getConfidence());
          }
        }

        DocumentField invoiceItemsField = invoiceFields.get("Items");
        if (invoiceItemsField != null) {
          System.out.printf("Invoice Items: %n");
          if (DocumentFieldType.ARRAY == invoiceItemsField.getType()) {
            List < DocumentField > invoiceItems = invoiceItemsField.getValueArray();
            invoiceItems.stream()
              .filter(invoiceItem -> DocumentFieldType.OBJECT == invoiceItem.getType())
              .map(documentField -> documentField.getValueObject())
              .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {

                // See a full list of fields found on an invoice here:
                // https://aka.ms/documentintelligence/invoicefields

                if ("Description".equals(key)) {
                  if (DocumentFieldType.STRING == documentField.getType()) {
                    String name = documentField.getValueString();
                    System.out.printf("Description: %s, confidence: %.2fs%n",
                      name, documentField.getConfidence());
                  }
                }
                if ("Quantity".equals(key)) {
                  if (DocumentFieldType.NUMBER == documentField.getType()) {
                    Double quantity = documentField.getValueNumber();
                    System.out.printf("Quantity: %f, confidence: %.2f%n",
                      quantity, documentField.getConfidence());
                  }
                }
                if ("UnitPrice".equals(key)) {
                  if (DocumentFieldType.NUMBER == documentField.getType()) {
                    Double unitPrice = documentField.getValueNumber();
                    System.out.printf("Unit Price: %f, confidence: %.2f%n",
                      unitPrice, documentField.getConfidence());
                  }
                }
                if ("ProductCode".equals(key)) {
                  if (DocumentFieldType.NUMBER == documentField.getType()) {
                    Double productCode = documentField.getValueNumber();
                    System.out.printf("Product Code: %f, confidence: %.2f%n",
                      productCode, documentField.getConfidence());
                  }
                }
              }));
          }
        }
      }
    }
  }
}

Compilare ed eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, tornare alla directory principale del progetto, ovvero doc-intel-app.

1. Compilare l'applicazione con il build comando :

   gradle build
   

2. Eseguire l'applicazione con il run comando :

   gradle run
   

Pacchetto di riferimento | dell'API REST della libreria | client (npm)Esempi versione dell'API | | REST supportata

In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:

• Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione, ad esempio pulsanti di opzione e caselle di controllo nei documenti, senza la necessità di eseguire il training di un modello.

• Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello di fattura con training preliminare.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito.

• Versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedereNode.js in Visual Studio Code.

• Versione più recente LTS di Node.js.

• Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

  Suggerimento

  Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.

• Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:

  

Configurazione

1. Creare una nuova applicazione Node.js Express: in una finestra della console (ad esempio cmd, PowerShell o Bash) creare e passare a una nuova directory per l'app denominata doc-intel-app.

   mkdir doc-intel-app && cd doc-intel-app
   

2. Eseguire il npm init comando per inizializzare l'applicazione e eseguire lo scaffolding del progetto.

   npm init
   

3. Specificare gli attributi del progetto usando le richieste presentate nel terminale.

   • Gli attributi più importanti sono nome, numero di versione e punto di ingresso.
   • È consigliabile mantenere index.js il nome del punto di ingresso. La descrizione, il comando di test, il repository GitHub, le parole chiave, l'autore e le informazioni sulla licenza sono attributi facoltativi, ma possono essere ignorati per questo progetto.
   • Accettare i suggerimenti tra parentesi selezionando Invio o Invio.
   • Dopo aver completato le richieste, nella directory doc-intel-app verrà creato un package.json file.

4. Installare la ai-document-intelligence libreria client e azure/identity i pacchetti npm:

   npm i @azure-rest/ai-document-intelligence@1.0.0-beta.2 @azure/identity
   
   

   Il file package.json dell'app viene aggiornato con le dipendenze.

5. Creare un file denominato index.js nella directory dell'applicazione.

   Suggerimento

   • È possibile creare un nuovo file usando PowerShell.
   • Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.
   • Digitare il comando seguente index.js New-Item.

Compilare l'applicazione

Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient classe . A tale scopo, si crea un AzureKeyCredential oggetto con l'oggetto dal key portale di Azure e un'istanza DocumentIntelligenceClientAzureKeyCredential con e document intelligence endpoint.

1. Aprire il index.js file in Visual Studio Code o nell'IDE preferito. Copiare e incollare uno degli esempi di codice seguenti nell'applicazione:

   • Layout

   • Fattura predefinita

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.

Modello di layout

Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.

• Per questo esempio, è necessario un file di documento da un URL. È possibile usare il documento di esempio per questa guida introduttiva.
• È stato aggiunto il valore dell'URL del file alla formUrl variabile nella parte superiore del file.
• Per analizzare un determinato file da un URL, si userà il beginAnalyzeDocuments metodo e si passerà prebuilt-layout come ID modello.

    const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
    const  { AzureKeyCredential } = require("@azure/core-auth");

    // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
    const key = "<your-key";
    const endpoint = "<your-endpoint>";

    // sample document
  const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

async function main() {
    const client = DocumentIntelligenceClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocument("prebuilt-layout", formUrl);

const {
        pages,
        tables
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, eseguire il programma:

1. Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).

2. Digitare il comando seguente nel terminale:

   node index.js
   

Modello predefinito

In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.

Suggerimento

Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

• Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
• È stato aggiunto il valore dell'URL del file alla invoiceUrl variabile nella parte superiore del file.
• Per analizzare un determinato file in un URI, si userà il beginAnalyzeDocuments metodo e si passerà PrebuiltModels.Invoice come ID modello. Il valore restituito è un result oggetto contenente i dati relativi al documento inviato.
• Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

    // set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
    const key = "<your-key>";
    const endpoint = "<your-endpoint>";

    // sample document
    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

async function main() {
    const client = DocumentIntelligenceClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocument("prebuilt-invoice", invoiceUrl);
if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);
        }
    }

    if (tables.length <= 0) {
        console.log("No tables were extracted from the document.");
    } else {
        console.log("Tables:");
        for (const table of tables) {
            console.log(
                `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
            );
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, eseguire il programma:

1. Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).

2. Digitare il comando seguente nel terminale:

   node index.js
   

Versione dell'API REST di riferimento | | dell'SDK della libreria |client (PyPi)Samples Supported REST API version (Versione dell'API | | REST supportata)

In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati da moduli e documenti:

• Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione come pulsanti di opzione e caselle di controllo e coppie chiave-valore, senza dover eseguire il training di un modello.

• Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello con training preliminare.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito.

• Python 3.7 o versione successiva.

  • L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo pip --version nella riga di comando. Ottenere pip installando la versione più recente di Python.

• Versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedereIntroduzione a Python in Visual Studio Code.

• Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Suggerimento

Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.

• Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:

  

Configurazione

Aprire una finestra del terminale nell'ambiente locale e installare la libreria client di Intelligence per intelligenza artificiale di Azure per Python con pip:

pip install azure-ai-documentintelligence==1.0.0b2

Creare l'applicazione Python

Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient classe . A tale scopo, si crea un AzureKeyCredential oggetto con l'oggetto dal key portale di Azure e un'istanza DocumentIntelligenceClientAzureKeyCredential con e document intelligence endpoint.

1. Creare un nuovo file Python denominato doc_intel_quickstart.py nell'editor o nell'IDE preferito.

2. Aprire il file doc_intel_quickstart.py e selezionare uno degli esempi di codice seguenti per copiare e incollare nell'applicazione:

   • Layout

   • Fattura predefinita

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.

Modello di layout

Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.

• Per questo esempio, è necessario un file di documento da un URL. È possibile usare il documento di esempio per questa guida introduttiva.
• È stato aggiunto il valore dell'URL del file alla formUrl variabile nella analyze_layout funzione .
• Per analizzare un determinato file in corrispondenza di un URL, si userà il begin_analyze_document_from_url metodo e si passerà prebuilt-layout come ID modello. Il valore restituito è un result oggetto contenente i dati relativi al documento inviato.

Aggiungere l'esempio di codice seguente all'applicazione doc_intel_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:

# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"

# helper functions

def get_words(page, line):
    result = []
    for word in page.words:
        if _in_span(word, line.spans):
            result.append(word)
    return result


def _in_span(word, spans):
    for span in spans:
        if word.span.offset >= span.offset and (
            word.span.offset + word.span.length
        ) <= (span.offset + span.length):
            return True
    return False


def analyze_layout():
    # sample document
    formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"

    document_intelligence_client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-layout", formUrl
    )

    analyze_request = AnalyzeDocumentRequest(
        url_source=formUrl
    )

    result: AnalyzeResult = poller.result()

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

    print("----------------------------------------")


if __name__ == "__main__":
    analyze_layout()

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, compilare ed eseguire il programma:

1. Passare alla cartella in cui si dispone del file doc_intel_quickstart.py .

2. Digitare il comando seguente nel terminale:

   python doc_intel_quickstart.py
   

---

Modello predefinito

Analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito. In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.

Suggerimento

Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

• Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
• È stato aggiunto il valore dell'URL del file alla invoiceUrl variabile nella parte superiore del file.
• Per analizzare un determinato file in un URI, si userà il begin_analyze_document_from_url metodo e si passerà prebuilt-invoice come ID modello. Il valore restituito è un result oggetto contenente i dati relativi al documento inviato.
• Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .

Aggiungere l'esempio di codice seguente all'applicazione doc_intel_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:

# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient


# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"

def analyze_invoice():
    # sample document

    invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

    document_intelligence_client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-invoice", invoiceUrl
    )
    invoices = poller.result()

    if invoices.documents:
        for idx, invoice in enumerate(invoices.documents):
            print(f"--------Analyzing invoice #{idx + 1}--------")
            vendor_name = invoice.fields.get("VendorName")
            if vendor_name:
                print(
                    f"Vendor Name: {vendor_name.get('content')} has confidence: {vendor_name.get('confidence')}"
                )
            vendor_address = invoice.fields.get("VendorAddress")
            if vendor_address:
                print(
                    f"Vendor Address: {vendor_address.get('content')} has confidence: {vendor_address.get('confidence')}"
                )
            vendor_address_recipient = invoice.fields.get("VendorAddressRecipient")
            if vendor_address_recipient:
                print(
                    f"Vendor Address Recipient: {vendor_address_recipient.get('content')} has confidence: {vendor_address_recipient.get('confidence')}"
                )
            customer_name = invoice.fields.get("CustomerName")
            if customer_name:
                print(
                    f"Customer Name: {customer_name.get('content')} has confidence: {customer_name.get('confidence')}"
                )
            customer_id = invoice.fields.get("CustomerId")
            if customer_id:
                print(
                    f"Customer Id: {customer_id.get('content')} has confidence: {customer_id.get('confidence')}"
                )
            customer_address = invoice.fields.get("CustomerAddress")
            if customer_address:
                print(
                    f"Customer Address: {customer_address.get('content')} has confidence: {customer_address.get('confidence')}"
                )
            customer_address_recipient = invoice.fields.get("CustomerAddressRecipient")
            if customer_address_recipient:
                print(
                    f"Customer Address Recipient: {customer_address_recipient.get('content')} has confidence: {customer_address_recipient.get('confidence')}"
                )
            invoice_id = invoice.fields.get("InvoiceId")
            if invoice_id:
                print(
                    f"Invoice Id: {invoice_id.get('content')} has confidence: {invoice_id.get('confidence')}"
                )
            invoice_date = invoice.fields.get("InvoiceDate")
            if invoice_date:
                print(
                    f"Invoice Date: {invoice_date.get('content')} has confidence: {invoice_date.get('confidence')}"
                )
            invoice_total = invoice.fields.get("InvoiceTotal")
            if invoice_total:
                print(
                    f"Invoice Total: {invoice_total.get('content')} has confidence: {invoice_total.get('confidence')}"
                )
            due_date = invoice.fields.get("DueDate")
            if due_date:
                print(
                    f"Due Date: {due_date.get('content')} has confidence: {due_date.get('confidence')}"
                )
            purchase_order = invoice.fields.get("PurchaseOrder")
            if purchase_order:
                print(
                    f"Purchase Order: {purchase_order.get('content')} has confidence: {purchase_order.get('confidence')}"
                )
            billing_address = invoice.fields.get("BillingAddress")
            if billing_address:
                print(
                    f"Billing Address: {billing_address.get('content')} has confidence: {billing_address.get('confidence')}"
                )
            billing_address_recipient = invoice.fields.get("BillingAddressRecipient")
            if billing_address_recipient:
                print(
                    f"Billing Address Recipient: {billing_address_recipient.get('content')} has confidence: {billing_address_recipient.get('confidence')}"
                )
            shipping_address = invoice.fields.get("ShippingAddress")
            if shipping_address:
                print(
                    f"Shipping Address: {shipping_address.get('content')} has confidence: {shipping_address.get('confidence')}"
                )
            shipping_address_recipient = invoice.fields.get("ShippingAddressRecipient")
            if shipping_address_recipient:
                print(
                    f"Shipping Address Recipient: {shipping_address_recipient.get('content')} has confidence: {shipping_address_recipient.get('confidence')}"
                )
            print("Invoice items:")
            for idx, item in enumerate(invoice.fields.get("Items").get("valueArray")):
                print(f"...Item #{idx + 1}")
                item_description = item.get("valueObject").get("Description")
                if item_description:
                    print(
                        f"......Description: {item_description.get('content')} has confidence: {item_description.get('confidence')}"
                    )
                item_quantity = item.get("valueObject").get("Quantity")
                if item_quantity:
                    print(
                        f"......Quantity: {item_quantity.get('content')} has confidence: {item_quantity.get('confidence')}"
                    )
                unit = item.get("valueObject").get("Unit")
                if unit:
                    print(
                        f"......Unit: {unit.get('content')} has confidence: {unit.get('confidence')}"
                    )
                unit_price = item.get("valueObject").get("UnitPrice")
                if unit_price:
                    unit_price_code = (
                        unit_price.get("valueCurrency").get("currencyCode")
                        if unit_price.get("valueCurrency").get("currencyCode")
                        else ""
                    )
                    print(
                        f"......Unit Price: {unit_price.get('content')}{unit_price_code} has confidence: {unit_price.get('confidence')}"
                    )
                product_code = item.get("valueObject").get("ProductCode")
                if product_code:
                    print(
                        f"......Product Code: {product_code.get('content')} has confidence: {product_code.get('confidence')}"
                    )
                item_date = item.get("valueObject").get("Date")
                if item_date:
                    print(
                        f"......Date: {item_date.get('content')} has confidence: {item_date.get('confidence')}"
                    )
                tax = item.get("valueObject").get("Tax")
                if tax:
                    print(
                        f"......Tax: {tax.get('content')} has confidence: {tax.get('confidence')}"
                    )
                amount = item.get("valueObject").get("Amount")
                if amount:
                    print(
                        f"......Amount: {amount.get('content')} has confidence: {amount.get('confidence')}"
                    )
            subtotal = invoice.fields.get("SubTotal")
            if subtotal:
                print(
                    f"Subtotal: {subtotal.get('content')} has confidence: {subtotal.get('confidence')}"
                )
            total_tax = invoice.fields.get("TotalTax")
            if total_tax:
                print(
                    f"Total Tax: {total_tax.get('content')} has confidence: {total_tax.get('confidence')}"
                )
            previous_unpaid_balance = invoice.fields.get("PreviousUnpaidBalance")
            if previous_unpaid_balance:
                print(
                    f"Previous Unpaid Balance: {previous_unpaid_balance.get('content')} has confidence: {previous_unpaid_balance.get('confidence')}"
                )
            amount_due = invoice.fields.get("AmountDue")
            if amount_due:
                print(
                    f"Amount Due: {amount_due.get('content')} has confidence: {amount_due.get('confidence')}"
                )
            service_start_date = invoice.fields.get("ServiceStartDate")
            if service_start_date:
                print(
                    f"Service Start Date: {service_start_date.get('content')} has confidence: {service_start_date.get('confidence')}"
                )
            service_end_date = invoice.fields.get("ServiceEndDate")
            if service_end_date:
                print(
                    f"Service End Date: {service_end_date.get('content')} has confidence: {service_end_date.get('confidence')}"
                )
            service_address = invoice.fields.get("ServiceAddress")
            if service_address:
                print(
                    f"Service Address: {service_address.get('content')} has confidence: {service_address.get('confidence')}"
                )
            service_address_recipient = invoice.fields.get("ServiceAddressRecipient")
            if service_address_recipient:
                print(
                    f"Service Address Recipient: {service_address_recipient.get('content')} has confidence: {service_address_recipient.get('confidence')}"
                )
            remittance_address = invoice.fields.get("RemittanceAddress")
            if remittance_address:
                print(
                    f"Remittance Address: {remittance_address.get('content')} has confidence: {remittance_address.get('confidence')}"
                )
            remittance_address_recipient = invoice.fields.get(
                "RemittanceAddressRecipient"
            )
            if remittance_address_recipient:
                print(
                    f"Remittance Address Recipient: {remittance_address_recipient.get('content')} has confidence: {remittance_address_recipient.get('confidence')}"
                )


          print("----------------------------------------")


if __name__ == "__main__":
    analyze_invoice()

Eseguire l'applicazione

Dopo aver aggiunto un esempio di codice all'applicazione, compilare ed eseguire il programma:

1. Passare alla cartella in cui si dispone del file doc_intel_quickstart.py .

2. Digitare il comando seguente nel terminale:

   python doc_intel_quickstart.py
   

| API | REST di Intelligence per documenti supportata da Azure SDKS

In questa guida introduttiva si apprenderà come usare l'API REST di Document Intelligence per analizzare ed estrarre dati e valori dai documenti:

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito

• Strumento da riga di comando curl installato.

  • Windows
  • Mac o Linux

• PowerShell versione 7.*+ (o un'applicazione della riga di comando simile).

  • Windows
  • macOS
  • Linux

• Per controllare la versione di PowerShell, digitare il comando seguente relativo al sistema operativo:

  • Windows: Get-Host | Select-Object Version
  • macOS o Linux: $PSVersionTable

• Una risorsa document intelligence (a servizio singolo) o servizi di intelligenza artificiale di Azure (multiservizio). Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Suggerimento

Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.

• Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:

  

Analizzare i documenti e ottenere risultati

Una richiesta POST viene usata per analizzare i documenti con un modello predefinito o personalizzato. Una richiesta GET viene usata per recuperare il risultato di una chiamata di analisi dei documenti. Viene modelId usato con POST e resultId con le operazioni GET.

Analizzare il documento (richiesta POST)

Prima di eseguire il comando cURL, apportare le modifiche seguenti alla richiesta post:

1. Sostituire {endpoint} con il valore dell'endpoint dell'istanza di Document Intelligence portale di Azure.

2. Sostituire {key} con il valore della chiave dell'istanza di Document Intelligence portale di Azure.

3. Usando la tabella seguente come riferimento, sostituire {modelID} e {your-document-url} con i valori desiderati.

4. È necessario un file di documento in un URL. Per questa guida introduttiva, è possibile usare i moduli di esempio forniti nella tabella seguente per ogni funzionalità:

Documenti di esempio

Funzionalità	{modelID}	{your-document-url}
Lettura	precompilt-read	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Layout	precompilt-layout	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
Scheda assicurazione sanitaria	prebuilt-healthInsuranceCard.us	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png
W-2	prebuilt-tax.us.w2	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
Fattura	fattura predefinita	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Ricevuta	ricevuta predefinita	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
Documento di identità	prebuilt-idDocument	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.

Richiesta POST

curl -v -i POST "{endpoint}/documentintelligence/documentModels/{modelId}:analyze?api-version=2024-02-29-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Risposta POST (resultID)

Si riceve una 202 (Success) risposta che include un'intestazione Operation-Location di sola lettura. Il valore di questa intestazione contiene un oggetto resultID su cui è possibile eseguire una query per ottenere lo stato dell'operazione asincrona e recuperare i risultati usando una richiesta GET con la stessa chiave di sottoscrizione della risorsa:

Ottenere i risultati dell'analisi (richiesta GET)

Dopo aver chiamato l'API, chiamare l'API Analyze documentGet analyze result per ottenere lo stato dell'operazione e i dati estratti. Prima di eseguire il comando, apportare queste modifiche:

1. Sostituire {resultID} l'intestazione Operation-Location dalla risposta POST.

2. Sostituire {key} con il valore della chiave dell'istanza di Document Intelligence nel portale di Azure.

Richiesta GET

curl -v -X GET "{endpoint}/documentintelligence/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2024-02-29-preview" -H "Ocp-Apim-Subscription-Key: {key}"

Esaminare i risultati

Si riceve una 200 (Success) risposta con output JSON. Il primo campo, "status", indica lo stato dell'operazione. Se l'operazione non è completa, il valore di "status" è "running" o "notStarted"ed è necessario chiamare di nuovo l'API, manualmente o tramite uno script. Si consiglia di attendere almeno un secondo tra le chiamate.

Risposta di esempio per la fattura predefinita

{
    "status": "succeeded",
    "createdDateTime": "2024-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2024-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2024-02-29-preview",
        "modelId": "prebuilt-invoice",
        "stringIndexType": "textElements"...
    ..."pages": [
            {
                "pageNumber": 1,
                "angle": 0,
                "width": 8.5,
                "height": 11,
                "unit": "inch",
                "words": [
                    {
                        "content": "CONTOSO",
                        "boundingBox": [
                            0.5911,
                            0.6857,
                            1.7451,
                            0.6857,
                            1.7451,
                            0.8664,
                            0.5911,
                            0.8664
                        ],
                        "confidence": 1,
                        "span": {
                            "offset": 0,
                            "length": 7
                                }
                      }],
              }]
      }
}

Campi documento supportati

I modelli predefiniti estraggono set predefiniti di campi documento. Vedere Estrazione dei dati del modello per i nomi, i tipi, le descrizioni e gli esempi di campi estratti.

Questo è, congratulazioni!

In questo argomento di avvio rapido è stato usato un modello di Intelligence per i documenti per analizzare vari moduli e documenti. Esplorare quindi la documentazione di Document Intelligence Studio e la documentazione di riferimento per ottenere informazioni approfondite sull'API di Intelligence sui documenti.

Passaggi successivi

• Per un'esperienza avanzata e una qualità avanzata del modello, provare Document Intelligence Studio

• Per la migrazione dalla versione 3.1 alla versione 4.0, vedere Guide alla migrazione del log delle modifiche.