Introduzione a Informazioni sui documenti

Importante

• Riconoscimento modulo di Servizi cognitivi di Azure ora si chiama Informazioni sui documenti di Azure AI.
• Alcune piattaforme sono ancora in attesa dell'aggiornamento della ridenominazione.
• Tutte le menzioni di Riconoscimento modulo o Informazioni sui documenti nella documentazione fanno riferimento allo stesso servizio di Azure.

Questo contenuto si applica a: v4.0 (anteprima) versioni precedenti: v3.1 (disponibilità generale) v3.0 (disponibilità generale)

• Introduzione all'anteprima più recente di Informazioni sui documenti di Azure AI (2024-07-31-preview).

• Informazioni sui documenti di Azure AI/Riconoscimento modulo è un servizio di intelligenza artificiale di Azure basato sul cloud che usa l'apprendimento automatico 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 questo avvio rapido, è consigliabile usare il servizio gratuito mentre si acquisisce familiarità con questa tecnologia. Tenere presente che il numero di pagine gratuite è limitato a 500 al mese.

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

Libreria client | Riferimento SDK | Riferimento API REST | Pacchetto| Esempi|Versione dell'API REST supportata

In questo avvio rapido si usano le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:

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

• Modello predefinito: consente di 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.

• Una risorsa Servizi di Azure AI o Informazioni sui documenti. Dopo aver creato la sottoscrizione di Azure, creare una risorsa a servizio singolo o multiservizio di Azure per intelligenza artificiale nel 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 Servizi di Azure AI se si prevede di accedere a più Servizi di Azure AI con un singolo endpoint/chiave. Solo per l'accesso a Informazioni sui documenti, creare una risorsa di Informazioni sui documenti. Si noti che sarà necessaria una risorsa di tipo servizio singolo se si intende usare l'autenticazione di Microsoft Entra.

• Dopo la distribuzione della risorsa selezionare Vai alla risorsa. La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Informazioni sui documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nell'avvio rapido:

  

Impostazione

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 selezionare 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 Altre informazioni selezionare .NET 8.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 selezionare Gestisci pacchetti NuGet....

   

2. Selezionare la scheda Esplora e digitare Azure.AI.FormRecognizer.

3. Selezionare la casella di controllo Include prerelease.

   

4. Scegliere una versione dal menu a discesa e installare il pacchetto nel progetto.

Compilare l'applicazione

Per interagire con il servizio Informazioni sui documenti, è necessario creare un'istanza della classe DocumentIntelligenceClient. A tale scopo, creare AzureKeyCredential con key dal portale di Azure e un'istanza di DocumentIntelligenceClient con AzureKeyCredential e endpoint di Informazioni sui documenti.

Nota

• A partire da .NET 6, i nuovi progetti che usano il modello console 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 d'uso globali o implicite.
• Per altre informazioni, vedere i nuovi modelli di 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 da copiare e incollare nel file Program.cs dell'applicazione:

   • Modello Layout

   • Modello predefinito

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, utilizzare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vederel'articolo sulla sicurezza di Servizi di Azure AI.

Modello di layout

Estrarre testo, indicatori 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. Per questa guida di avvio rapido, è possibile usare il documento di esempio di Microsoft.
• È stato aggiunto il valore dell'URI del file alla variabile Uri fileUri nella parte superiore dello script.
• Per estrarre il layout da un determinato file in un URI, usare il metodo StartAnalyzeDocumentFromUri e passare prebuilt-layout come ID modello. Il valore restituito è un oggetto AnalyzeResult contenente i dati del documento inviato.

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili della chiave e dell'endpoint con i valori dell'istanza di Informazioni sui documenti del 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");

AnalyzeDocumentContent content = new AnalyzeDocumentContent()
{
    UrlSource= fileUri
};

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

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 verde di avvio 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 prebuilt-invoice.

Suggerimento

Non si è limitati alle fatture: è possibile scegliere tra molti modelli predefiniti, ognuno dei quali ha un set specifico 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 prebuilt-invoice. Per questo avvio rapido, è possibile usare il documento di fattura di esempio.
• È stato aggiunto il valore dell'URI del file alla variabile Uri invoiceUri nella parte superiore del file Program.cs.
• Per analizzare un determinato file in un URI, si usa il metodo StartAnalyzeDocumentFromUri e si passa prebuilt-invoice come ID modello. Il valore restituito è un oggetto AnalyzeResult 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 dei tipi corrispondenti, vedere la pagina concettuale relativa alla Fattura.

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili della chiave e dell'endpoint con i valori dell'istanza di Informazioni sui documenti del 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");

AnalyzeDocumentContent content = new AnalyzeDocumentContent()
{
    UrlSource = invoiceUri
};

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

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 verde di avvio accanto a formRecognizer_quickstart per compilare ed eseguire il programma oppure premere F5.

Libreria client | Riferimento SDK | Riferimento API REST | Pacchetto (Maven) | Esempi |Versione dell'API REST supportata

In questo avvio rapido si usano le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:

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

• Fattura predefinita: consente di analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello già sottoposto a training.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito.

• La versione più recente di Visual Studio Code o dell'IDE preferito. Vedere Java in Visual Studio Code.

  Suggerimento

  • Visual Studio Code offre un Coding Pack per Java per Windows e macOS. Il Coding Pack è un bundle di VS Code, Java Development Kit (JDK) e una raccolta di estensioni suggerite da Microsoft. Il Coding Pack può essere usato anche per correggere un ambiente di sviluppo esistente.
  • Se si usano 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:

  • Un Java Development Kit (JDK) versione 8 o successiva. Per altre informazioni, vedere Microsoft Build di OpenJDK.

  • Gradle, versione 6.8 o successiva.

• Una risorsa Servizi di Azure AI o Informazioni sui documenti. Dopo aver creato la sottoscrizione di Azure, creare una risorsa Informazioni sui documenti di tipo servizio singolo o multiservizio nel 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 Servizi di Azure AI se si prevede di accedere a più Servizi di Azure AI con un singolo endpoint/chiave. Solo per l'accesso a Informazioni sui documenti, creare una risorsa di Informazioni sui documenti. Si noti che sarà necessaria una risorsa di tipo servizio singolo se si intende usare l'autenticazione di Microsoft Entra.

• Dopo la distribuzione della risorsa selezionare Vai alla risorsa. La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Informazioni sui documenti. Successivamente, incollare la chiave e l'endpoint nel codice:

  

Impostazione

Creare un nuovo progetto Gradle

1. 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 && doc-intel-app
   

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

2. Eseguire il comando gradle init dalla directory di lavoro. Questo comando crea i file di compilazione essenziali per Gradle, tra cui build.gradle.kts, che viene 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 Ritorno 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. Copiare e incollare il codice seguente per includere la libreria client come istruzione implementation, insieme alle impostazioni e ai plug-in necessari.

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

   }

Creare un'applicazione Java

Per interagire con il servizio Informazioni sui documenti, è necessario creare un'istanza della classe DocumentIntelligenceClient. A tale scopo, creare AzureKeyCredential con key dal portale di Azure e un'istanza di DocumentIntelligenceClient con AzureKeyCredential e endpoint di Informazioni sui documenti.

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

   mkdir -p src/main/java
   

   Si crea la struttura di directory seguente:

   

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

   Suggerimento

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

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 la produzione, utilizzare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vederel'articolo sulla sicurezza di Servizi di Azure AI.

Modello di layout

Estrarre testo, indicatori 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. Per questa guida di avvio rapido, è possibile usare il documento di esempio di Microsoft.
• Per analizzare un determinato file in un URI, si userà il metodo beginAnalyzeDocumentFromUrl e si passerà prebuilt-layout come ID modello. Il valore restituito è un oggetto AnalyzeResult contenente i dati relativi al documento inviato.
• È stato aggiunto il valore dell'URI del file alla variabile documentUrl nel metodo main.

Aggiungere il seguente codice di esempio al file DocIntelligence.java. Assicurarsi di aggiornare le variabili della chiave e dell'endpoint con i valori dell'istanza di Informazioni sui documenti del portale di Azure:

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 `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
    DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
      .credential(new AzureKeyCredential(key))
      .endpoint(endpoint)
      .buildClient();

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

    SyncPoller <AnalyzeResultOperation, AnalyzeResultOperation> analyzeLayoutPoller =
      client.beginAnalyzeDocument(modelId,
          null,
          null,
          null,
          null,
          null,
          null,
          new AnalyzeDocumentRequest().setUrlSource(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, doc-intel-app.

1. Compilare l'applicazione con il comando build:

   gradle build
   

2. Eseguire l'applicazione con il comando run:

   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 prebuilt-invoice.

Suggerimento

Non si è limitati alle fatture: è possibile scegliere tra molti modelli predefiniti, ognuno dei quali ha un set specifico 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 prebuilt-invoice. Per questo avvio rapido, è possibile usare il documento di fattura di esempio.
• Il valore dell'URL del file è stato aggiunto alla variabile invoiceUrl nella parte iniziale del file.
• Per analizzare un determinato file in un URI, si userà il metodo beginAnalyzeDocuments e si passerà PrebuiltModels.Invoice come ID modello. Il valore restituito è un oggetto result 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 dei tipi corrispondenti, vedere la pagina concettuale relativa alla Fattura.

Aggiungere il seguente codice di esempio al file DocIntelligence.java. Assicurarsi di aggiornare le variabili della chiave e dell'endpoint con i valori dell'istanza di Informazioni sui documenti del portale di Azure:

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) {

    // 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(endpoint)
        .buildClient();

      SyncPoller<AnalyzeResultOperation, AnalyzeResultOperation > analyzeInvoicesPoller =
        client.beginAnalyzeDocument(modelId, 
            null,
            null,
            null,
            null,
            null,
            null,
            new AnalyzeDocumentRequest().setUrlSource(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, doc-intel-app.

1. Compilare l'applicazione con il comando build:

   gradle build
   

2. Eseguire l'applicazione con il comando run:

   gradle run
   

Libreria client | Riferimento API REST | Pacchetto (npm) | Esmpi |Versione dell'API REST supportata

In questo avvio rapido si usano le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:

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

• Fattura predefinita: consente di analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello di fattura già sottoposto a training.

Prerequisiti

• Sottoscrizione di Azure: creare un account gratuito.

• La versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedere Node.js in Visual Studio Code.

• La versione LTS più recente di Node.js.

• Una risorsa Servizi di Azure AI o Informazioni sui documenti. Dopo aver creato la sottoscrizione di Azure, creare una risorsa Informazioni sui documenti di tipo servizio singolo o multiservizio nel 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 Servizi di Azure AI se si prevede di accedere a più Servizi di Azure AI con un singolo endpoint/chiave. Solo per l'accesso a Informazioni sui documenti, creare una risorsa di Informazioni sui documenti. Si noti che sarà necessaria una risorsa di tipo servizio singolo se si intende usare l'autenticazione di Microsoft Entra.

• Dopo la distribuzione della risorsa selezionare Vai alla risorsa. La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Informazioni sui documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nell'avvio rapido:

  

Impostazione

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

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

2. Eseguire il comando npm init per inizializzare l'applicazione ed 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 per 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 Torna o Invio.
   • Dopo aver completato le richieste, nella directory doc-intel-app verrà creato un file package.json.

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

   npm i @azure-rest/ai-document-intelligence@1.0.0-beta.3 @azure/core-auth
   

   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 New-Item index.js.

Compilare l'applicazione

Per interagire con il servizio Informazioni sui documenti, è necessario creare un'istanza della classe DocumentIntelligenceClient. A tale scopo, creare AzureKeyCredential con key dal portale di Azure e un'istanza di DocumentIntelligenceClient con AzureKeyCredential e endpoint di Informazioni sui documenti.

1. Aprire il file index.js 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 la produzione, utilizzare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vederel'articolo sulla sicurezza di Servizi di Azure AI.

Modello di layout

Estrarre testo, indicatori 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. Per questa guida di avvio rapido, è possibile usare il documento di esempio di Microsoft.
• Il valore dell'URL del file è stato aggiunto alla variabile formUrl nella parte iniziale del file.
• Per analizzare un determinato file da un URL, si userà il metodo beginAnalyzeDocuments e si passerà prebuilt-layout come ID modello.

    const DocumentIntelligence = require("@azure-rest/ai-document-intelligence").default,
  { getLongRunningPoller, isUnexpected } = 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 = DocumentIntelligence(endpoint, new AzureKeyCredential(key));


    const initialResponse = await client
      .path("/documentModels/{modelId}:analyze", "prebuilt-layout")
      .post({
        contentType: "application/json",
        body: {
          urlSource: formUrl
        },
       });

       if (isUnexpected(initialResponse)) {
       throw initialResponse.body.error;
     }

    const poller = await getLongRunningPoller(client, initialResponse);
    const analyzeResult = (await poller.pollUntilDone()).body.analyzeResult;

    const documents = analyzeResult?.documents;

    const document = documents && documents[0];
    if (!document) {
    throw new Error("Expected at least one document in the result.");
    }

    console.log(
    "Extracted document:",
    document.docType,
    `(confidence: ${document.confidence || "<undefined>"})`,
    );
    console.log("Fields:", document.fields);
}

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 Informazioni sui documenti (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 prebuilt-invoice.

Suggerimento

Non si è limitati alle fatture: è possibile scegliere tra molti modelli predefiniti, ognuno dei quali ha un set specifico 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 prebuilt-invoice. Per questo avvio rapido, è possibile usare il documento di fattura di esempio.
• Il valore dell'URL del file è stato aggiunto alla variabile invoiceUrl nella parte iniziale del file.
• Per analizzare un determinato file in un URI, si userà il metodo beginAnalyzeDocuments e si passerà PrebuiltModels.Invoice come ID modello. Il valore restituito è un oggetto result 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 dei tipi corrispondenti, vedere la pagina concettuale relativa alla fattura.

const DocumentIntelligence = require("@azure-rest/ai-document-intelligence").default,
  { getLongRunningPoller, isUnexpected } = 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 invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"

async function main() {

    const client = DocumentIntelligence(endpoint, new AzureKeyCredential(key));

    const initialResponse = await client
    .path("/documentModels/{modelId}:analyze", "prebuilt-invoice")
    .post({
      contentType: "application/json",
      body: {
        // The Document Intelligence service will access the URL to the invoice image and extract data from it
        urlSource: invoiceUrl,
      },
    });

    if (isUnexpected(initialResponse)) {
       throw initialResponse.body.error;
     }

    const poller = await getLongRunningPoller(client, initialResponse);

    poller.onProgress((state) => console.log("Operation:", state.result, state.status));
    const analyzeResult = (await poller.pollUntilDone()).body.analyzeResult;

    const documents = analyzeResult?.documents;

    const result = documents && documents[0];
    if (result) {
      console.log(result.fields);
    } else {
      throw new Error("Expected at least one invoice in the result.");
    }

console.log(
    "Extracted invoice:",
    document.docType,
    `(confidence: ${document.confidence || "<undefined>"})`,
  );
  console.log("Fields:", document.fields);
}


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 Informazioni sui documenti (doc-intel-app).

2. Digitare il comando seguente nel terminale:

   node index.js
   

Libreria client |Riferimento SDK | Riferimento API REST | Pacchetto (PyPi) | Esempi | Versione dell'API REST supportata

In questo avvio rapido si usano le funzionalità seguenti per analizzare ed estrarre dati da moduli e documenti:

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

• Fattura predefinita: consente di analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello già sottoposto a training.

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. Per ottenere pip, installare la versione più recente di Python.

• La versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedere Introduzione a Python in Visual Studio Code.

• Una risorsa Servizi di Azure AI o Informazioni sui documenti. Dopo aver creato la sottoscrizione di Azure, creare una risorsa Informazioni sui documenti di tipo servizio singolo o multiservizio nel 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 Servizi di Azure AI se si prevede di accedere a più Servizi di Azure AI con un singolo endpoint/chiave. Solo per l'accesso a Informazioni sui documenti, creare una risorsa di Informazioni sui documenti. Si noti che sarà necessaria una risorsa di tipo servizio singolo se si intende usare l'autenticazione di Microsoft Entra.

• Dopo la distribuzione della risorsa selezionare Vai alla risorsa. La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Informazioni sui documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nell'avvio rapido:

  

Impostazione

Aprire una finestra del terminale nell'ambiente locale e installare la libreria client di Informazioni sui documenti di Azure AI per Python con pip:

pip install azure-ai-documentintelligence==1.0.0b4

Creare l'applicazione Python

Per interagire con il servizio Informazioni sui documenti, è necessario creare un'istanza della classe DocumentIntelligenceClient. A tale scopo, creare AzureKeyCredential con key dal portale di Azure e un'istanza di DocumentIntelligenceClient con AzureKeyCredential e endpoint di Informazioni sui documenti.

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 da copiare e incollare nell'applicazione:

   • Layout

   • Fattura predefinita

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, utilizzare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vederel'articolo sulla sicurezza di Servizi di Azure AI.

Modello di layout

Estrarre testo, indicatori 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. Per questa guida di avvio rapido, è possibile usare il documento di esempio di Microsoft.
• Il valore dell'URL del file è stato aggiunto alla variabile formUrl nella funzione analyze_layout.

Aggiungere l'esempio di codice seguente all'applicazione doc_intel_quickstart.py. Assicurarsi di aggiornare le variabili della chiave e dell'endpoint con i valori dell'istanza di Informazioni sui documenti del 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

# 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", 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 è presente il 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 prebuilt-invoice.

Suggerimento

Non si è limitati alle fatture: è possibile scegliere tra molti modelli predefiniti, ognuno dei quali ha un set specifico 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 prebuilt-invoice. Per questo avvio rapido, è possibile usare il documento di fattura di esempio.
• Il valore dell'URL del file è stato aggiunto alla variabile invoiceUrl nella parte iniziale del file.
• Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e dei tipi corrispondenti, vedere la pagina concettuale relativa alla fattura.

Aggiungere l'esempio di codice seguente all'applicazione doc_intel_quickstart.py. Assicurarsi di aggiornare le variabili della chiave e dell'endpoint con i valori dell'istanza di Informazioni sui documenti del 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest



# 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", AnalyzeDocumentRequest(url_source=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 è presente il file doc_intel_quickstart.py.

2. Digitare il comando seguente nel terminale:

   python doc_intel_quickstart.py
   

| API REST di Informazioni sui documenti | SDK di Azure supportati

In questa guida introduttiva si apprenderà come usare l'API REST di Informazioni sui documenti 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 Informazioni sui documenti (a servizio singolo) o Servizi di Azure AI (multiservizio). Dopo aver creato la sottoscrizione di Azure, creare una risorsa Informazioni sui documenti di tipo servizio singolo o multiservizio nel 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 Servizi di Azure AI se si prevede di accedere a più Servizi di Azure AI con un singolo endpoint/chiave. Solo per l'accesso a Informazioni sui documenti, creare una risorsa di Informazioni sui documenti. Si noti che sarà necessaria una risorsa di tipo servizio singolo se si intende usare l'autenticazione di Microsoft Entra.

• Dopo la distribuzione della risorsa selezionare Vai alla risorsa. La chiave e l'endpoint della risorsa creata saranno necessari per connettere l'applicazione all'API Informazioni sui documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nell'avvio rapido:

  

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. modelId viene usato con operazioni POST e resultId con 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 Informazioni sui documenti del portale di Azure.

2. Sostituire {key} con il valore della chiave dell'istanza di Informazioni sui documenti del 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 questo avvio rapido è possibile usare i moduli di esempio forniti nella tabella seguente per ogni funzionalità:

Documenti di esempio

Funzionalità	{modelID}	{your-document-url}
Lettura	prebuilt-read	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
Layout	prebuilt-layout	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
Tessera 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	prebuilt-invoice	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
Ricevuta	prebuilt-receipt	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 la produzione, utilizzare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vederel'articolo sulla sicurezza di Servizi di Azure AI.

Richiesta POST

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

Risposta POST (resultID)

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

Ottenere i risultati dell'analisi (richiesta GET)

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

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

2. Sostituire {key} con il valore della chiave dell'istanza di Informazioni sui documenti del portale di Azure.

Richiesta GET

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

Esaminare i risultati

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

Risposta di esempio per prebuilt-invoice

{
    "status": "succeeded",
    "createdDateTime": "2024-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2024-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2024-07-31-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 di documento supportati

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

Sono state completate tutte le operazioni necessarie.

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

Passaggi successivi

• Per un'esperienza avanzata e una qualità avanzata del modello, provare Studio di Informazioni sui documenti

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

• Trovare altri esempi in GitHub.