Avvio rapido: Riconoscimento modulo SDK | API REST v3.0

Introduzione alla versione più recente di Azure Riconoscimento modulo. Azure Riconoscimento modulo è un servizio di intelligenza artificiale applicato al cloud che usa Machine Learning per estrarre coppie chiave-valore, testo, tabelle e dati chiave dai documenti. È possibile integrare facilmente i modelli Riconoscimento modulo nei flussi di lavoro e nelle applicazioni usando un SDK nel linguaggio di programmazione preferito 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à e sulle opzioni di sviluppo Riconoscimento modulo, visitare la pagina Panoramica.

Informazioni di riferimento| su SDK Informazioni di riferimento | sulle API Pacchetto (NuGet) | Campioni | Versioni dell'API REST supportate

In questa guida introduttiva si useranno le funzionalità seguenti per analizzare ed estrarre i dati e i valori dai moduli e dai documenti:

  • Modello di documento generale: analizzare ed estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate.

  • Modello di layout: analizzare ed estrarre tabelle, righe, parole e contrassegni di selezione come pulsanti di opzione e caselle di controllo nei documenti, senza dover 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.

  • Risorsa Servizi cognitivi o Riconoscimento modulo. Dopo aver creato la sottoscrizione di Azure, creare una risorsa 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 Servizi cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Per accedere solo a Riconoscimento modulo, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione di Azure Active Directory.

  • 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 Riconoscimento modulo. Incollare la chiave e l'endpoint nel codice seguente più avanti nella guida di avvio rapido:

    Screenshot: chiavi e posizione dell'endpoint nella portale di Azure.

Configurazione

  1. Avviare Visual Studio.

  2. Nella pagina iniziale scegliere Crea un nuovo progetto.

    Screenshot: finestra iniziale di Visual Studio.

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

    Screenshot: pagina crea nuovo progetto di Visual Studio.

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

    Screenshot: finestra di dialogo configura nuovo progetto di Visual Studio.

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

    Screenshot: finestra di dialogo informazioni aggiuntive di Visual Studio.

Installare la libreria client con NuGet

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

    Screenshot della finestra del pacchetto NuGet in Visual Studio.

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

    Screenshot della selezione del pacchetto NuGet non rilasciato in Visual Studio.

  3. Selezionare la versione 4.0.0 dal menu a discesa e installare il pacchetto nel progetto.

Compilare l'applicazione

Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della DocumentAnalysisClient classe. A tale scopo, si creerà un oggetto AzureKeyCredential con key il portale di Azure e un'istanza DocumentAnalysisClient con e il AzureKeyCredential Riconoscimento modulo endpoint.

Nota

  • A partire da .NET 6, i nuovi progetti che usano il modello generano un nuovo stile di console programma diverso dalle versioni precedenti.
  • Il nuovo output usa funzionalità C# recenti che semplificano il codice da scrivere.
  • Quando si usa la versione più recente, è necessario scrivere solo il corpo del Main metodo. Non è necessario includere istruzioni di primo livello, direttive globali o direttive 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:

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedereSicurezza di Servizi cognitivi.

Modello di documento generale

Analizzare ed estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate.

  • Per questo esempio, è necessario un file di documento di modulo da un URI. Per questa guida introduttiva è possibile usare il documento del modulo di esempio .
  • Per analizzare un determinato file in un URI, si userà il StartAnalyzeDocumentFromUri metodo e si passerà prebuilt-document come ID modello. Il valore restituito è un AnalyzeResult oggetto contenente dati relativi al documento inviato.
  • È stato aggiunto il valore dell'URI del file alla Uri fileUri variabile nella parte superiore dello script.

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'istanza di portale di Azure Riconoscimento modulo:

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

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


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

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed,"prebuilt-document", fileUri);

AnalyzeResult result = operation.Value;

Console.WriteLine("Detected key-value pairs:");

foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
    if (kvp.Value == null)
    {
        Console.WriteLine($"  Found key with no value: '{kvp.Key.Content}'");
    }
    else
    {
        Console.WriteLine($"  Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
    }
}

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"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} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingPolygon[0].X}, Y= {line.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingPolygon[1].X}, Y= {line.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingPolygon[2].X}, Y= {line.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingPolygon[3].X}, Y= {line.BoundingPolygon[3].Y}");
    }

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

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingPolygon[0].X}, Y= {selectionMark.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingPolygon[1].X}, Y= {selectionMark.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingPolygon[2].X}, Y= {selectionMark.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingPolygon[3].X}, Y= {selectionMark.BoundingPolygon[3].Y}");
    }
}

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)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

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}) has kind '{cell.Kind}' and 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.

Screenshot: eseguire il programma Visual Studio.

Output generale del modello di documento

Ecco un frammento di output previsto:

  Detected key-value pairs:
  Found key with no value: '?'
  Found key-value pair: 'QUARTERLY REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' and ':selected:'
  Found key-value pair: 'For the Quarterly Period Ended March 31, 2020' and 'OR'
  Found key with no value: '?'
  Found key-value pair: 'TRANSITION REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' and ':unselected:'
  Found key with no value: 'For the Transition Period From'
  Found key-value pair: 'to Commission File Number' and '001-37845'

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output generale del modello di documento.

Modello di layout

Estrarre testo, contrassegni di selezione, stili di testo, strutture di tabella e coordinate dell'area di associazione da documenti.

  • Per questo esempio, è necessario un file di documento di modulo da un URI. Per questa guida introduttiva è possibile usare il documento del modulo di esempio .
  • È 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 dati dal documento inviato.

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'istanza di portale di Azure Riconoscimento modulo:

using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

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

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

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(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),");
    Console.WriteLine($"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} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingPolygon[0].X}, Y= {line.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingPolygon[1].X}, Y= {line.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingPolygon[2].X}, Y= {line.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingPolygon[3].X}, Y= {line.BoundingPolygon[3].Y}");
    }

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

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingPolygon[0].X}, Y= {selectionMark.BoundingPolygon[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingPolygon[1].X}, Y= {selectionMark.BoundingPolygon[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingPolygon[2].X}, Y= {selectionMark.BoundingPolygon[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingPolygon[3].X}, Y= {selectionMark.BoundingPolygon[3].Y}");
    }
}

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)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

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}) has kind '{cell.Kind}' and 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.

Screenshot: eseguire il programma Visual Studio.

Output del modello di layout

Ecco un frammento di output previsto:

  Document Page 1 has 69 line(s), 425 word(s), and 15 selection mark(s).
  Line 0 has content: 'UNITED STATES'.
    Its bounding box is:
      Upper left => X: 3.4915, Y= 0.6828
      Upper right => X: 5.0116, Y= 0.6828
      Lower right => X: 5.0116, Y= 0.8265
      Lower left => X: 3.4915, Y= 0.8265
  Line 1 has content: 'SECURITIES AND EXCHANGE COMMISSION'.
    Its bounding box is:
      Upper left => X: 2.1937, Y= 0.9061
      Upper right => X: 6.297, Y= 0.9061
      Lower right => X: 6.297, Y= 1.0498
      Lower left => X: 2.1937, Y= 1.0498

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output del modello di layout.

Modello predefinito

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

Suggerimento

Non è limitato alle fatture: sono disponibili diversi modelli predefiniti da scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Vedere estrazione dei dati del modello.

  • Analizzare una fattura usando il modello di fattura predefinita. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È 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 un URI, usare il StartAnalyzeDocumentFromUri metodo e passare prebuilt-invoice come ID modello. Il valore restituito è un AnalyzeResult oggetto contenente dati dal 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 Del concetto di fattura .

Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'istanza di portale di Azure Riconoscimento modulo:



using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;

//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentAnalysisClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(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");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(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))
    {
        if (vendorNameField.FieldType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.Value.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

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

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField))
    {
        if (itemsField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField itemField in itemsField.Value.AsList())
            {
                Console.WriteLine("Item:");

                if (itemField.FieldType == DocumentFieldType.Dictionary)
                {
                    IReadOnlyDictionary<string, DocumentField> itemFields = itemField.Value.AsDictionary();

                    if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField))
                    {
                        if (itemDescriptionField.FieldType == DocumentFieldType.String)
                        {
                            string itemDescription = itemDescriptionField.Value.AsString();

                            Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                        }
                    }

                    if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
                    {
                        if (itemAmountField.FieldType == DocumentFieldType.Currency)
                        {
                            CurrencyValue itemAmount = itemAmountField.Value.AsCurrency();

                            Console.WriteLine($"  Amount: '{itemAmount.Symbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
                        }
                    }
                }
            }
        }
    }

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

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

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField))
    {
        if (invoiceTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue invoiceTotal = invoiceTotalField.Value.AsCurrency();
            Console.WriteLine($"Invoice Total: '{invoiceTotal.Symbol}{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.

Screenshot: eseguire il programma Visual Studio.

Output del modello predefinito

Ecco un frammento di output previsto:

  Document 0:
  Vendor Name: 'CONTOSO LTD.', with confidence 0.962
  Customer Name: 'MICROSOFT CORPORATION', with confidence 0.951
  Item:
    Description: 'Test for 23 fields', with confidence 0.899
    Amount: '100', with confidence 0.902
  Sub Total: '100', with confidence 0.979

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output del modello di fattura predefinito.

Informazioni di riferimento | su SDK Informazioni di riferimento | sulle API Pacchetto (Maven) | Campioni| Versioni dell'API REST supportate

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

  • Documento generale: analizzare ed estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate.

  • Layout: analizzare ed estrarre tabelle, righe, parole e contrassegni di selezione come 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 pre-sottoposto a training.

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 il Code Pack per Java, installare l'estensione Gradle per Java .
  • Se non si usa VS Code, assicurarsi di avere installato gli elementi seguenti nell'ambiente di sviluppo:

  • Risorsa Servizi cognitivi o Riconoscimento modulo. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Riconoscimento modulo 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 Servizi cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Per accedere solo a Riconoscimento modulo, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione di Azure Active Directory.

  • 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 Riconoscimento modulo. In seguito si incollare la chiave e l'endpoint nel codice seguente:

    Screenshot: chiavi e posizione dell'endpoint nella portale di Azure.

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 form-recognizer-app e passare a essa.

    mkdir form-recognizer-app && form-recognizer-app
    
    mkdir translator-text-app; cd translator-text-app
    
  2. Eseguire il comando gradle init dalla directory di lavoro. Questo comando creerà 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 (form-recognizer-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.

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

    plugins {
        java
        application
    }
    application {
        mainClass.set("FormRecognizer")
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        implementation(group = "com.azure", name = "azure-ai-formrecognizer", version = "4.0.0")
    }
    

Creare un'applicazione Java

Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della DocumentAnalysisClient classe. A tale scopo, si creerà un oggetto AzureKeyCredential con key il portale di Azure e un'istanza DocumentAnalysisClient con e il AzureKeyCredential Riconoscimento modulo endpoint.

  1. Dalla directory form-recognizer-app eseguire il comando seguente:

    mkdir -p src/main/java
    

    Si creerà la struttura di directory seguente:

    Screenshot: struttura della directory Java

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

    Suggerimento

    • È possibile creare un nuovo file usando PowerShell.
    • Aprire una finestra di PowerShell nella directory del progetto tenendo premuto il tasto Maiusc e facendo clic con il pulsante destro del mouse sulla cartella.
    • Digitare il comando seguente New-Item FormRecognizer.java.
  3. Aprire il FormRecognizer.java file e selezionare uno degli esempi di codice seguenti per copiare e incollare nell'applicazione:

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedereSicurezza di Servizi cognitivi.

Modello di documento generale

Estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate dai documenti.

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

Aggiungere l'esempio di codice seguente al FormRecognizer.java file. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'istanza di portale di Azure Riconoscimento modulo:


import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // 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
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .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-document";
    SyncPoller < OperationResult, AnalyzeResult > analyzeDocumentPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

    // pages
    analyzeResult.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.getBoundingPolygon().toString()));

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

    // tables
    List < DocumentTable > tables = analyzeResult.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();
    }

    // Key-value pairs
    analyzeResult.getKeyValuePairs().forEach(documentKeyValuePair -> {
      System.out.printf("Key content: %s%n", documentKeyValuePair.getKey().getContent());
      System.out.printf("Key content bounding region: %s%n",
        documentKeyValuePair.getKey().getBoundingRegions().toString());

      if (documentKeyValuePair.getValue() != null) {
        System.out.printf("Value content: %s%n", documentKeyValuePair.getValue().getContent());
        System.out.printf("Value content bounding region: %s%n", documentKeyValuePair.getValue().getBoundingRegions().toString());
      }
    });
  }
}

Compilare ed eseguire l'applicazione

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

  1. Compilare l'applicazione con il build comando:

    gradle build
    
  2. Eseguire l'applicazione con il run comando:

    gradle run
    

Output generale del modello di documento

Ecco un frammento di output previsto:

Key content: For the Transition Period From
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@14c053c6]
Key content: to Commission File Number
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@6c2d4cc6]
Value content: 001-37845
Value content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@30865a90]
Key content: (I.R.S. ID)
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@6134ac4a]
Value content: 91-1144442
Value content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@777c9dc9]
Key content: Securities registered pursuant to Section 12(g) of the Act:
Key content bounding region: [com.azure.ai.formrecognizer.models.BoundingRegion@71b1a49c]
Value content: NONE

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output generale del modello di documento.

Modello di layout

Estrarre testo, contrassegni di selezione, stili di testo, strutture di tabella e coordinate dell'area di associazione da documenti.

  • Per questo esempio è necessario un file di documento di modulo in un URI. Per questa guida introduttiva è possibile usare il documento del modulo di esempio .
  • 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 dati relativi al documento inviato.
  • È stato aggiunto il valore dell'URI del file alla documentUrl variabile nel metodo main.

Aggiungere l'esempio di codice seguente al FormRecognizer.java file. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'istanza di portale di Azure Riconoscimento modulo:


import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // 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
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .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 < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
      client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

    AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

    // 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.getBoundingPolygon().toString()));

      // 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.getBoundingPolygon().toString(),
          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();
    }
  }
  // Utility function to get the bounding polygon coordinates
  private static String getBoundingCoordinates(List < Point > boundingPolygon) {
    return boundingPolygon.stream().map(point -> String.format("[%.2f, %.2f]", point.getX(),
      point.getY())).collect(Collectors.joining(", "));
  }
}

Compilare ed eseguire l'applicazione

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

  1. Compilare l'applicazione con il build comando :

    gradle build
    
  2. Eseguire l'applicazione con il run comando :

    gradle run
    

Output del modello di layout

Ecco un frammento di output previsto:

  Table 0 has 5 rows and 3 columns.
  Cell 'Title of each class', has row index 0 and column index 0.
  Cell 'Trading Symbol', has row index 0 and column index 1.
  Cell 'Name of exchange on which registered', has row index 0 and column index 2.
  Cell 'Common stock, $0.00000625 par value per share', has row index 1 and column index 0.
  Cell 'MSFT', has row index 1 and column index 1.
  Cell 'NASDAQ', has row index 1 and column index 2.
  Cell '2.125% Notes due 2021', has row index 2 and column index 0.
  Cell 'MSFT', has row index 2 and column index 1.
  Cell 'NASDAQ', has row index 2 and column index 2.
  Cell '3.125% Notes due 2028', has row index 3 and column index 0.
  Cell 'MSFT', has row index 3 and column index 1.
  Cell 'NASDAQ', has row index 3 and column index 2.
  Cell '2.625% Notes due 2033', has row index 4 and column index 0.
  Cell 'MSFT', has row index 4 and column index 1.
  Cell 'NASDAQ', has row index 4 and column index 2.

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output del modello di layout.

Modello predefinito

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

Suggerimento

Non è possibile limitare le fatture: sono disponibili diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

  • Analizzare una fattura usando il modello di fattura predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È stato aggiunto il valore dell'URL del file alla invoiceUrl variabile nella parte superiore del file.
  • Per analizzare un determinato file in corrispondenza di 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 FormRecognizer.java file . Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:


import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {

  // 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(final String[] args) throws IOException {

    // create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
      .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";

    SyncPoller < DocumentOperationResult, AnalyzeResult > analyzeInvoicePoller = client.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);

    AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult();

    for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
      AnalyzedDocument 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.getValueAsString();
          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.getValueAsString();
          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.getValueAsString();
          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.getValueAsString();
          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.getValueAsString();
          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.getValueAsDate();
          System.out.printf("Invoice Date: %s, confidence: %.2f%n",
            invoiceDate, invoiceDateField.getConfidence());
        }
      }

      DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
      if (customerAddressRecipientField != null) {
        if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
          Double invoiceTotal = invoiceTotalField.getValueAsDouble();
          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.LIST == invoiceItemsField.getType()) {
          List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
          invoiceItems.stream()
            .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
            .map(documentField -> documentField.getValueAsMap())
            .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
              // See a full list of fields found on an invoice here:
              // https://aka.ms/formrecognizer/invoicefields
              if ("Description".equals(key)) {
                if (DocumentFieldType.STRING == documentField.getType()) {
                  String name = documentField.getValueAsString();
                  System.out.printf("Description: %s, confidence: %.2fs%n",
                    name, documentField.getConfidence());
                }
              }
              if ("Quantity".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double quantity = documentField.getValueAsDouble();
                  System.out.printf("Quantity: %f, confidence: %.2f%n",
                    quantity, documentField.getConfidence());
                }
              }
              if ("UnitPrice".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double unitPrice = documentField.getValueAsDouble();
                  System.out.printf("Unit Price: %f, confidence: %.2f%n",
                    unitPrice, documentField.getConfidence());
                }
              }
              if ("ProductCode".equals(key)) {
                if (DocumentFieldType.DOUBLE == documentField.getType()) {
                  Double productCode = documentField.getValueAsDouble();
                  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 form-recognizer-app.

  1. Compilare l'applicazione con il build comando :

    gradle build
    
  2. Eseguire l'applicazione con il run comando :

    gradle run
    

Output del modello predefinito

Ecco un frammento di output previsto:

  ----------- Analyzing invoice  0 -----------
  Analyzed document has doc type invoice with confidence : 1.00
  Vendor Name: CONTOSO LTD., confidence: 0.92
  Vendor address: 123 456th St New York, NY, 10001, confidence: 0.91
  Customer Name: MICROSOFT CORPORATION, confidence: 0.84
  Customer Address Recipient: Microsoft Corp, confidence: 0.92
  Invoice ID: INV-100, confidence: 0.97
  Invoice Date: 2019-11-15, confidence: 0.97

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output predefinito del modello di fattura

Informazioni di riferimento | su SDK Informazioni di riferimento | sulle API Pacchetto (npm) | Campioni |Versioni dell'API REST supportate

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

  • Documento generale: analizzare ed estrarre coppie chiave-valore, segni di selezione ed entità dai 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 documenti specifici usando un modello di fattura con training preliminare.

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.

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

  • La versione LTS più recente di Node.js

  • Una risorsa Servizi cognitivi o Riconoscimento modulo. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Riconoscimento modulo a 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 cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Per accedere solo a Riconoscimento modulo, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione di Azure Active Directory.

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

    Screenshot: chiavi e posizione dell'endpoint nel portale di Azure.

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 form-recognizer-app.

    mkdir form-recognizer-app && cd form-recognizer-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 Restituisci o Invio.
    • Dopo aver completato le richieste, verrà creato un package.json file nella directory form-recognizer-app.
  4. Installare la libreria client e azure/identity i ai-form-recognizer pacchetti npm:

    npm i @azure/ai-form-recognizer @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 new-item seguente index.js.

Compilare l'applicazione

Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della DocumentAnalysisClient classe . A tale scopo, si creerà un oggetto con key dal portale di Azure e un'istanza DocumentAnalysisClientAzureKeyCredential con e il Riconoscimento modulo endpoint.AzureKeyCredential

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

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedereSicurezza di Servizi cognitivi.

Modello di documento generale

Estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate dai documenti.

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

Aggiungere il codice di esempio seguente al index.js file . Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:


  const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

  // 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 = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-document", formUrl);

    const {keyValuePairs} = await poller.pollUntilDone();

    if (!keyValuePairs || keyValuePairs.length <= 0) {
        console.log("No key-value pairs were extracted from the document.");
    } else {
        console.log("Key-Value Pairs:");
        for (const {key, value, confidence} of keyValuePairs) {
            console.log("- Key  :", `"${key.content}"`);
            console.log("  Value:", `"${(value && value.content) || "<undefined>"}" (${confidence})`);
        }
    }

}

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 di riconoscimento modulo (form-recognizer-app).

  2. Digitare il comando seguente nel terminale:

    node index.js
    

Output generale del modello di documento

Ecco un frammento di output previsto:

Key-Value Pairs:
- Key  : "For the Quarterly Period Ended"
  Value: "March 31, 2020" (0.35)
- Key  : "From"
  Value: "1934" (0.119)
- Key  : "to"
  Value: "<undefined>" (0.317)
- Key  : "Commission File Number"
  Value: "001-37845" (0.87)
- Key  : "(I.R.S. ID)"
  Value: "91-1144442" (0.87)
- Key  : "Class"
  Value: "Common Stock, $0.00000625 par value per share" (0.748)
- Key  : "Outstanding as of April 24, 2020"
  Value: "7,583,440,247 shares" (0.838)
Entities:
- "$0.00000625" Quantity - Currency (0.8)
- "MSFT" Organization - <none> (0.99)
- "NASDAQ" Organization - StockExchange (0.99)
- "2.125%" Quantity - Percentage (0.8)
- "2021" DateTime - DateRange (0.8)

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output generale del modello di documento

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 di modulo da un URL. Per questa guida introduttiva, è possibile usare il documento di modulo di esempio .
  • È 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.

Aggiungere il codice di esempio seguente al index.js file . Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:


 const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

    // 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 = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-layout", formUrlLayout);

    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 di riconoscimento modulo (form-recognizer-app).

  2. Digitare il comando seguente nel terminale:

    node index.js
    

Output del modello di layout

Ecco un frammento di output previsto:

Pages:
- Page 1 (unit: inch)
  8.5x11, angle: 0
  69 lines, 425 words
Tables:
- Extracted table: 3 columns, 5 rows (15 cells)

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output del modello di layout

Modello predefinito

In questo esempio verrà analizzata una fattura usando il modello predefinito di fattura .

Suggerimento

Non è possibile limitare le fatture: sono disponibili diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

  • Analizzare una fattura usando il modello di fattura predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È stato aggiunto il valore dell'URL del file alla invoiceUrl variabile nella parte superiore del file.
  • Per analizzare un determinato file in corrispondenza di 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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

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


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

    const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-layout", formUrlLayout);

    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 di riconoscimento modulo (form-recognizer-app).

  2. Digitare il comando seguente nel terminale:

    node index.js
    

Output del modello predefinito

Ecco un frammento di output previsto:

  Vendor Name: CONTOSO LTD.
  Customer Name: MICROSOFT CORPORATION
  Invoice Date: 2019-11-15T00:00:00.000Z
  Due Date: 2019-12-15T00:00:00.000Z
  Items:
  - <no product code>
    Description: Test for 23 fields
    Quantity: 1
    Date: undefined
    Unit: undefined
    Unit Price: 1
    Tax: undefined
    Amount: 100

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output predefinito del modello di fattura

Informazioni di riferimento | su SDK Informazioni di riferimento | sulle API Pacchetto (PyPi) | Campioni | Versioni dell'API REST supportate

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

  • Documento generale: analizzare ed estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate.

  • 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 documenti 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.
  • La versione più recente di Visual Studio Code o l'IDE preferito. Per altre informazioni, vedereIntroduzione con Python in VS Code.

  • Una risorsa Servizi cognitivi o Riconoscimento modulo. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Riconoscimento modulo a 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 cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Per accedere solo a Riconoscimento modulo, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione di Azure Active Directory.

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

    Screenshot: chiavi e posizione dell'endpoint nel portale di Azure.

Configurazione

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

pip install azure-ai-formrecognizer==3.2.0

Creare l'applicazione Python

Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della DocumentAnalysisClient classe . A tale scopo, si creerà un oggetto con key dal portale di Azure e un'istanza DocumentAnalysisClientAzureKeyCredential con e il Riconoscimento modulo endpoint.AzureKeyCredential

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

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

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedereSicurezza di Servizi cognitivi.

Modello di documento generale

Estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate dai documenti.

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

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


# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join("Page #{}: {}".format(region.page_number, format_polygon(region.polygon)) for region in bounding_regions)

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


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

    # create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    document_analysis_client = DocumentAnalysisClient(endpoint=endpoint, credential=AzureKeyCredential(key))

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-document", docUrl)
    result = poller.result()

    for style in result.styles:
        if style.is_handwritten:
            print("Document contains handwritten content: ")
            print(",".join([result.content[span.offset:span.offset + span.length] for span in style.spans]))

    print("----Key-value pairs found in document----")
    for kv_pair in result.key_value_pairs:
        if kv_pair.key:
            print(
                    "Key '{}' found within '{}' bounding regions".format(
                        kv_pair.key.content,
                        format_bounding_region(kv_pair.key.bounding_regions),
                    )
                )
        if kv_pair.value:
            print(
                    "Value '{}' found within '{}' bounding regions\n".format(
                        kv_pair.value.content,
                        format_bounding_region(kv_pair.value.bounding_regions),
                    )
                )

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

        for line_idx, line in enumerate(page.lines):
            print(
                "...Line # {} has text content '{}' within bounding box '{}'".format(
                    line_idx,
                    line.content,
                    format_polygon(line.polygon),
                )
            )

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

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

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


if __name__ == "__main__":
    analyze_general_documents()

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 form_recognizer_quickstart.py .

  2. Digitare il comando seguente nel terminale:

    python form_recognizer_quickstart.py
    

Output generale del modello di documento

Ecco un frammento di output previsto:

  ----Key-value pairs found in document----
  Key '☒' found within 'Page #1: [0.6694, 1.7746], [0.7764, 1.7746], [0.7764, 1.8833], [0.6694, 1.8833]' bounding regions
  Key 'QUARTERLY REPORT PURSUANT TO SECTION 13 OR 15(d) OF THE SECURITIES EXCHANGE ACT OF 1934' found within 'Page #1: [0.996, 1.7804], [7.8449, 1.7804], [7.8449, 2.0559], [0.996, 2.0559]' bounding regions
  Value ':selected:' found within 'Page #1: [0.6694, 1.7746], [0.7764, 1.7746], [0.7764, 1.8833], [0.6694, 1.8833]' bounding regions

  Key 'For the Quarterly Period Ended March 31, 2020' found within 'Page #1: [0.9982, 2.1626], [3.4543, 2.1626], [3.4543, 2.2665], [0.9982, 2.2665]' bounding regions
  Value 'OR' found within 'Page #1: [4.1471, 2.2972], [4.3587, 2.2972], [4.3587, 2.4049], [4.1471, 2.4049]' bounding regions

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output generale del modello di documento

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 di modulo da un URL. Per questa guida introduttiva, è possibile usare il documento di modulo di esempio .
  • È 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 form_recognizer_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:


# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])

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

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-layout", formUrl)
    result = poller.result()

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )

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

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

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

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

    for table_idx, table in enumerate(result.tables):
        print(
            "Table # {} has {} rows and {} columns".format(
                table_idx, table.row_count, table.column_count
            )
        )
        for region in table.bounding_regions:
            print(
                "Table # {} location on page: {} is {}".format(
                    table_idx,
                    region.page_number,
                    format_polygon(region.polygon),
                )
            )
        for cell in table.cells:
            print(
                "...Cell[{}][{}] has content '{}'".format(
                    cell.row_index,
                    cell.column_index,
                    cell.content,
                )
            )
            for region in cell.bounding_regions:
                print(
                    "...content on page {} is within bounding box '{}'".format(
                        region.page_number,
                        format_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 form_recognizer_quickstart.py .

  2. Digitare il comando seguente nel terminale:

    python form_recognizer_quickstart.py
    

Output del modello di layout

Ecco un frammento di output previsto:

  ----Analyzing layout from page #1----
  Page has width: 8.5 and height: 11.0, measured with unit: inch
  ...Line # 0 has word count 2 and text 'UNITED STATES' within bounding box '[3.4915, 0.6828], [5.0116, 0.6828], [5.0116, 0.8265], [3.4915, 0.8265]'
  ......Word 'UNITED' has a confidence of 1.0
  ......Word 'STATES' has a confidence of 1.0
  ...Line # 1 has word count 4 and text 'SECURITIES AND EXCHANGE COMMISSION' within bounding box '[2.1937, 0.9061], [6.297, 0.9061], [6.297, 1.0498], [2.1937, 1.0498]'
  ......Word 'SECURITIES' has a confidence of 1.0
  ......Word 'AND' has a confidence of 1.0
  ......Word 'EXCHANGE' has a confidence of 1.0
  ......Word 'COMMISSION' has a confidence of 1.0
  ...Line # 2 has word count 3 and text 'Washington, D.C. 20549' within bounding box '[3.4629, 1.1179], [5.031, 1.1179], [5.031, 1.2483], [3.4629, 1.2483]'
  ......Word 'Washington,' has a confidence of 1.0
  ......Word 'D.C.' has a confidence of 1.0

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output del modello di layout


Modello predefinito

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

Suggerimento

Non è possibile limitare le fatture: sono disponibili diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.

  • Analizzare una fattura usando il modello di fattura predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È 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 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 Del concetto di fattura .

Aggiungere l'esempio di codice seguente all'applicazione form_recognizer_quickstart.py. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'istanza di portale di Azure Riconoscimento modulo:

# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join("Page #{}: {}".format(region.page_number, format_polygon(region.polygon)) for region in bounding_regions)

def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


def analyze_invoice():

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

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-invoice", invoiceUrl)
    invoices = poller.result()

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

if __name__ == "__main__":
    analyze_invoice()

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

Eseguire l'applicazione

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

  1. Passare alla cartella in cui è disponibile il file form_recognizer_quickstart.py .

  2. Digitare il comando seguente nel terminale:

    python form_recognizer_quickstart.py
    

Output del modello predefinito

Ecco un frammento di output previsto:

  --------Recognizing invoice #1--------
  Vendor Name: CONTOSO LTD. has confidence: 0.919
  Vendor Address: 123 456th St New York, NY, 10001 has confidence: 0.907
  Vendor Address Recipient: Contoso Headquarters has confidence: 0.919
  Customer Name: MICROSOFT CORPORATION has confidence: 0.84
  Customer Id: CID-12345 has confidence: 0.956
  Customer Address: 123 Other St, Redmond WA, 98052 has confidence: 0.909
  Customer Address Recipient: Microsoft Corp has confidence: 0.917
  Invoice Id: INV-100 has confidence: 0.972
  Invoice Date: 2019-11-15 has confidence: 0.971
  Invoice Total: CurrencyValue(amount=110.0, symbol=$) has confidence: 0.97
  Due Date: 2019-12-15 has confidence: 0.973

Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output del modello di fattura predefinito

| RICONOSCIMENTO MODULO SDK DELL'API | RESTsupportati dagli SDK di | Azure

In questa guida introduttiva si userà l'API REST di Riconoscimento modulo per analizzare ed estrarre dati e valori da moduli e documenti:

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito

  • strumento della riga di comando curl installato.

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

  • Per controllare la versione di PowerShell, digitare quanto segue:

    • Windows: Get-Host | Select-Object Version
    • macOS o Linux: $PSVersionTable
  • Risorsa Riconoscimento modulo (servizio singolo) o Servizi cognitivi (multiservizio). Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Riconoscimento modulo 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 Servizi cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Per accedere solo a Riconoscimento modulo, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione di Azure Active Directory.

  • 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 Riconoscimento modulo. Incollare la chiave e l'endpoint nel codice seguente più avanti nella guida di avvio rapido:

    Screenshot: chiavi e posizione dell'endpoint nella portale di Azure.

Analizzare 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 operazioni GET.

Analizzare il documento (richiesta POST)

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

  1. Sostituire {endpoint} con il valore dell'endpoint dall'istanza di portale di Azure Riconoscimento modulo.

  2. Sostituire {key} con il valore della chiave dall'istanza di portale di Azure Riconoscimento modulo.

  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}
    Documento generale predefinito-documento Documento di esempio
    Lettura precompilt-read Documento di esempio
    Layout layout predefinito Documento di esempio
    W-2 predefinita-tax.us.w2 Esempio W-2
    Fatture fattura predefinita Esempio di fattura
    Receipts ricevuta predefinita Ricevuta di esempio
    Documenti ID predefinito-idDocument Documento ID di esempio
    Biglietti da visita predefinito-businessCard Carta da visita di esempio

Importante

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedereSicurezza di Servizi cognitivi.

Richiesta POST

curl -v -i POST "{endpoint}/formrecognizer/documentModels/{modelID}:analyze?api-version=2022-08-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"

Risposta POST

Si riceverà una risposta che include un'intestazione 202 (Success)Del percorso operazione . Il valore di questa intestazione contiene un resultID oggetto che può essere sottoposto a query per ottenere lo stato dell'operazione asincrona:

{alt-text}

Ottenere i risultati di analisi (richiesta GET)

Dopo aver chiamato l'API Analizza documento , chiamare l'API Recupera risultato per ottenere lo stato dell'operazione e i dati estratti. Prima di eseguire il comando, apportare queste modifiche:

  1. Sostituire {POST response} l'intestazione del percorso dell'operazione dalla risposta POST.

  2. Sostituire {key} con il valore della chiave dall'istanza di Riconoscimento modulo nell'portale di Azure.

Richiesta GET

curl -v -X GET "{POST response}" -H "Ocp-Apim-Subscription-Key: {key}"

Esaminare i risultati

Si riceverà una risposta 200 (Success) con un output JSON. Il primo campo, "status", indica lo stato dell'operazione. Se l'operazione non è completa, il valore di "status" sarà "running" o "notStarted", e si dovrebbe 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": "2022-03-25T19:31:37Z",
    "lastUpdatedDateTime": "2022-03-25T19:31:43Z",
    "analyzeResult": {
        "apiVersion": "2022-08-31",
        "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 del documento supportati

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

È così, congratulazioni!

In questa guida introduttiva è stato usato un modello di modulo Riconoscimento modulo per analizzare vari moduli e documenti. Esplorare quindi la documentazione di Riconoscimento modulo Studio e di riferimento per informazioni dettagliate sull'API Riconoscimento modulo.

Passaggi successivi