Introduzione a Riconoscimento modulo

Questo articolo si applica a:Riconoscimento modulo v3.0 checkmarkRiconoscimento modulo v3.0. Versione precedente:Riconoscimento modulo v2.1

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

Si è verificato un problema durante l'esecuzione dell'applicazione.

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.

Si è verificato un problema durante l'esecuzione dell'applicazione.

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

Si è verificato un problema con l'installazione della libreria client.

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

Aggiungere il codice di esempio seguente al 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(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 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, 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 URL. Per questa guida introduttiva è possibile usare il documento del modulo di esempio .
  • È stato aggiunto il valore formUrl dell'URL del file alla 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 l'esempio di codice seguente al index.js file. Assicurarsi di aggiornare le variabili chiave e endpoint con valori dall'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 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 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'URL del file alla invoiceUrl variabile nella parte superiore del file.
  • Per analizzare un determinato file in un URI, si userà il beginAnalyzeDocuments metodo e si passerà PrebuiltModels.Invoice come ID modello. Il valore restituito è un result oggetto contenente 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 .

 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 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 del modello di fattura predefinito

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

  • Python 3.7 o versione successiva

    • L'installazione di Python deve includere pip. È possibile verificare se è installato pip eseguendo pip --version nella riga di comando. Ottenere pip installando la versione più recente di Python.
  • Versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedereIntroduzione con Python in VS Code.

  • 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. 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

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 AzureKeyCredential con key il portale di Azure e un'istanza DocumentAnalysisClient con e il AzureKeyCredential Riconoscimento modulo endpoint.

  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 del modulo di esempio .
  • Per analizzare un determinato file in 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 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 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_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 è disponibile 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, 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 URL. Per questa guida introduttiva è possibile usare il documento del modulo di esempio .
  • È stato aggiunto il valore dell'URL del file alla formUrl variabile nella analyze_layout funzione.
  • Per analizzare un determinato file in 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 dati relativi al documento inviato.

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_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 è disponibile 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 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'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 il comando seguente relativo al sistema operativo:

    • 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 alla richiesta post:

  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 https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf
    Lettura precompilt-read https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
    Layout layout predefinito https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
    W-2 predefinita-tax.us.w2 https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
    Fatture fattura predefinita https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
    Receipts ricevuta predefinita https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
    Documenti ID predefinito-idDocument https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png
    Biglietti da visita predefinito-businessCard https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg

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 202 (Success) risposta che include un'intestazione Operation-location . Il valore di questa intestazione contiene un resultID oggetto su cui è possibile eseguire una query per ottenere lo stato dell'operazione asincrona:

{alt-text}

Ottenere i risultati dell'analisi (richiesta GET)

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

  1. Sostituire {POST response} l'intestazione Operation-location dalla risposta POST.

  2. Sostituire {key} con il valore della chiave dell'istanza di Riconoscimento modulo nel 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 sarà necessario chiamare di nuovo l'API manualmente o tramite uno script. Si consiglia di attendere almeno un secondo tra le chiamate.

Risposta di esempio per la fattura predefinita

{
    "status": "succeeded",
    "createdDateTime": "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 di documento supportati

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

È questo, complimenti!

In questa guida introduttiva è stato usato un modulo Riconoscimento modulo modello per analizzare vari moduli e documenti. Successivamente, esplorare la documentazione di Riconoscimento modulo Studio e di riferimento per informazioni approfondite sull'API Riconoscimento modulo.

Passaggi successivi

Questo articolo si applica a:Riconoscimento modulo v2.1 segno di spuntaRiconoscimento modulo v2.1. Versione successiva:Riconoscimento modulo v3.0

Introduzione ad Azure Riconoscimento modulo usando il linguaggio di programmazione preferito o l'API REST. Azure Riconoscimento modulo è un servizio di intelligenza artificiale applicato al cloud basato sul cloud che usa Machine Learning per estrarre coppie chiave-valore, testo e tabelle dai documenti. È possibile chiamare facilmente Riconoscimento modulo modelli integrando gli SDK della libreria client nei flussi di lavoro e nelle applicazioni. È consigliabile usare il servizio gratuito mentre si acquisisce familiarità con questa tecnologia. Tenere presente che il numero di pagine gratuite è limitato a 500 al mese.

Per altre informazioni sulle funzionalità di Riconoscimento modulo e sulle opzioni di sviluppo, visitare la pagina Panoramica.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (NuGet) | Esempi

In questa guida introduttiva si useranno le API seguenti per estrarre dati strutturati da moduli e documenti:

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.

  • Versione corrente dell'IDE di Visual Studio.

  • 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. Avviare Visual Studio 2019.

  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 della pagina Crea nuovo progetto di Visual Studio.

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

    Screenshot: finestra di dialogo Configura nuovo progetto in Visual Studio.

  5. Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 5.0 (Corrente) 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 che mostra la finestra seleziona pacchetto NuGet.

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

    Screenshot che mostra il menu a discesa seleziona Riconoscimento modulo pacchetto.

  3. Selezionare la versione 3.1.1 dal menu a discesa e selezionare Installa.

Compilare l'applicazione

Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della FormRecognizerClient classe . A tale scopo, si creerà un AzureKeyCredential oggetto con la chiave e un'istanza FormRecognizerClient con e il AzureKeyCredential Riconoscimento modulo endpoint.

Nota

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

  2. Includere le direttive using seguenti:

using Azure;
using Azure.AI.FormRecognizer;
using Azure.AI.FormRecognizer.Models;
using System.Threading.Tasks;
  1. Impostare le endpoint variabili di ambiente e key e creare l'istanza AzureKeyCredential e FormRecognizerClient :
private static readonly string endpoint = "your-form-recognizer-endpoint";
private static readonly string key = "your-api-key";
private static readonly AzureKeyCredential credential = new AzureKeyCredential(key);
  1. Eliminare la riga , Console.Writeline("Hello World!"); e aggiungere uno degli esempi di codice Try It al file Program.cs :

    Screenshot: aggiungere il codice di esempio al metodo Main.

  2. Selezionare un esempio di codice da copiare e incollare nel metodo Main 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, vedere l'articolo sulla sicurezza di Servizi cognitivi.

Prova: Modello di layout

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

  • Per questo esempio, è necessario un file di documento di modulo in corrispondenza di un URI. Per questa guida introduttiva, è possibile usare il documento di modulo di esempio .
  • È stato aggiunto il valore dell'URI del file alla formUri variabile .
  • Per estrarre il layout da un determinato file in corrispondenza di un URI, usare il StartRecognizeContentFromUriAsync metodo .

Aggiungere il codice seguente al file Program.cs dell'applicazione di layout:


FormRecognizerClient recognizerClient = AuthenticateClient();

Task recognizeContent = RecognizeContent(recognizerClient);
Task.WaitAll(recognizeContent);

private static FormRecognizerClient AuthenticateClient()
            {
                var credential = new AzureKeyCredential(key);
                var client = new FormRecognizerClient(new Uri(endpoint), credential);
                return client;
            }

            private static async Task RecognizeContent(FormRecognizerClient recognizerClient)
        {
            string formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
            FormPageCollection formPages = await recognizerClient
        .StartRecognizeContentFromUri(new Uri(formUrl))
        .WaitForCompletionAsync();

            foreach (FormPage page in formPages)
            {
                Console.WriteLine($"Form Page {page.PageNumber} has {page.Lines.Count} lines.");

                for (int i = 0; i < page.Lines.Count; i++)
                {
                    FormLine line = page.Lines[i];
                    Console.WriteLine($"    Line {i} has {line.Words.Count} word{(line.Words.Count > 1 ? "s" : "")}, and text: '{line.Text}'.");
                }

                for (int i = 0; i < page.Tables.Count; i++)
                {
                    FormTable table = page.Tables[i];
                    Console.WriteLine($"Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
                    foreach (FormTableCell cell in table.Cells)
                    {
                        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) contains text: '{cell.Text}'.");
                    }
                }
            }
        }
    }
}

Provare: modello predefinito

Questo esempio illustra come analizzare i dati da determinati tipi di documenti comuni con modelli pre-sottoposti a training, usando una fattura come esempio.

  • Per questo esempio, viene analizzato un documento di fattura usando un modello predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È stato aggiunto il valore dell'URI del file alla invoiceUri variabile nella parte superiore del metodo Main.
  • Per analizzare un determinato file in un URI, usare il StartRecognizeInvoicesFromUriAsync metodo .
  • Per semplicità, tutti i campi restituiti dal servizio non vengono visualizzati qui. Per visualizzare l'elenco di tutti i campi supportati e dei tipi corrispondenti, vedere la pagina Del concetto di fattura .

Scegliere un modello predefinito

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. Ecco i modelli predefiniti attualmente supportati dal servizio Riconoscimento modulo:

  • Fattura: estrae testo, contrassegni di selezione, tabelle, campi e informazioni chiave dalle fatture.
  • Ricevuta: estrae testo e informazioni chiave dalle ricevute.
  • Documento ID: estrae le informazioni di testo e chiave dalle licenze di conducente e dai passaporti internazionali.
  • Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.

Aggiungere il codice seguente al metodo di file Program.cs della fattura predefinita

FormRecognizerClient recognizerClient = AuthenticateClient();

  Task analyzeinvoice = AnalyzeInvoice(recognizerClient, invoiceUrl);
  Task.WaitAll(analyzeinvoice);

   private static FormRecognizerClient AuthenticateClient() {
     var credential = new AzureKeyCredential(key);
     var client = new FormRecognizerClient(new Uri(endpoint), credential);
     return client;
   }

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

   private static async Task AnalyzeInvoice(FormRecognizerClient recognizerClient, string invoiceUrl) {
     var options = new RecognizeInvoicesOptions() {
       Locale = "en-US"
     };
     RecognizedFormCollection invoices = await recognizerClient.StartRecognizeInvoicesFromUriAsync(new Uri(invoiceUrl), options).WaitForCompletionAsync();

     RecognizedForm invoice = invoices[0];

     FormField invoiceIdField;
     if (invoice.Fields.TryGetValue("InvoiceId", out invoiceIdField)) {
       if (invoiceIdField.Value.ValueType == FieldValueType.String) {
         string invoiceId = invoiceIdField.Value.AsString();
         Console.WriteLine($"    Invoice Id: '{invoiceId}', with confidence {invoiceIdField.Confidence}");
       }
     }

     FormField invoiceDateField;
     if (invoice.Fields.TryGetValue("InvoiceDate", out invoiceDateField)) {
       if (invoiceDateField.Value.ValueType == FieldValueType.Date) {
         DateTime invoiceDate = invoiceDateField.Value.AsDate();
         Console.WriteLine($"    Invoice Date: '{invoiceDate}', with confidence {invoiceDateField.Confidence}");
       }
     }

     FormField dueDateField;
     if (invoice.Fields.TryGetValue("DueDate", out dueDateField)) {
       if (dueDateField.Value.ValueType == FieldValueType.Date) {
         DateTime dueDate = dueDateField.Value.AsDate();
         Console.WriteLine($"    Due Date: '{dueDate}', with confidence {dueDateField.Confidence}");
       }
     }

     FormField vendorNameField;
     if (invoice.Fields.TryGetValue("VendorName", out vendorNameField)) {
       if (vendorNameField.Value.ValueType == FieldValueType.String) {
         string vendorName = vendorNameField.Value.AsString();
         Console.WriteLine($"    Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
       }
     }

     FormField vendorAddressField;
     if (invoice.Fields.TryGetValue("VendorAddress", out vendorAddressField)) {
       if (vendorAddressField.Value.ValueType == FieldValueType.String) {
         string vendorAddress = vendorAddressField.Value.AsString();
         Console.WriteLine($"    Vendor Address: '{vendorAddress}', with confidence {vendorAddressField.Confidence}");
       }
     }

     FormField customerNameField;
     if (invoice.Fields.TryGetValue("CustomerName", out customerNameField)) {
       if (customerNameField.Value.ValueType == FieldValueType.String) {
         string customerName = customerNameField.Value.AsString();
         Console.WriteLine($"    Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
       }
     }

     FormField customerAddressField;
     if (invoice.Fields.TryGetValue("CustomerAddress", out customerAddressField)) {
       if (customerAddressField.Value.ValueType == FieldValueType.String) {
         string customerAddress = customerAddressField.Value.AsString();
         Console.WriteLine($"    Customer Address: '{customerAddress}', with confidence {customerAddressField.Confidence}");
       }
     }

     FormField customerAddressRecipientField;
     if (invoice.Fields.TryGetValue("CustomerAddressRecipient", out customerAddressRecipientField)) {
       if (customerAddressRecipientField.Value.ValueType == FieldValueType.String) {
         string customerAddressRecipient = customerAddressRecipientField.Value.AsString();
         Console.WriteLine($"    Customer address recipient: '{customerAddressRecipient}', with confidence {customerAddressRecipientField.Confidence}");
       }
     }

     FormField invoiceTotalField;
     if (invoice.Fields.TryGetValue("InvoiceTotal", out invoiceTotalField)) {
       if (invoiceTotalField.Value.ValueType == FieldValueType.Float) {
         float invoiceTotal = invoiceTotalField.Value.AsFloat();
         Console.WriteLine($"    Invoice Total: '{invoiceTotal}', with confidence {invoiceTotalField.Confidence}");
       }
     }
   }
 }
}

Eseguire l'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.

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (Maven) | Esempi

In questa guida introduttiva si useranno le API seguenti per estrarre i dati strutturati dai moduli e dai documenti:

Prerequisiti

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

Creare un nuovo progetto Gradle

In una 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
  1. 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
    
  2. Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.

  3. Accettare il nome del progetto predefinito (form-recognizer-app)

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.

Nel file build.gradle.kts del progetto includere la libreria client come istruzione implementation, unitamente ai plug-in e alle impostazioni necessari.

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

Creare un file Java

Dalla directory di lavoro eseguire il comando seguente:

mkdir -p src/main/java

Si creerà la struttura di directory seguente:

Screenshot della struttura di directory Java dell'applicazione.

Passare alla directory Java e creare un file denominato FormRecognizer.java. Aprirlo nell'editor o nell'IDE preferito e aggiungere le istruzioni e import le dichiarazioni del pacchetto seguenti:

import com.azure.ai.formrecognizer.*;
import com.azure.ai.formrecognizer.models.*;

import java.util.concurrent.atomic.AtomicReference;
import java.util.List;
import java.util.Map;
import java.time.LocalDate;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.util.Context;
import com.azure.core.util.polling.SyncPoller;

Selezionare un esempio di codice per copiare e incollare nel metodo principale 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, vedere l'articolo sulla sicurezza di Servizi cognitivi.

Provare: Modello di layout

Estrarre testo, contrassegni di selezione, stili di testo e strutture di tabella, insieme alle coordinate dell'area delimitante 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 beginRecognizeContentFromUrl metodo .
  • È stato aggiunto il valore dell'URI del file alla formUrl variabile nel metodo main.

Aggiornare la classe FormRecognizer dell'applicazione, con il codice seguente (aggiornare le variabili chiave ed endpoint con valori dell'istanza di portale di Azure Riconoscimento modulo):


static final String key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
static final String endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

public static void main(String[] args) {FormRecognizerClient recognizerClient = new FormRecognizerClientBuilder()
                .credential(new AzureKeyCredential(key)).endpoint(endpoint).buildClient();

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

    System.out.println("Get form content...");
        GetContent(recognizerClient, formUrl);
  }
    private static void GetContent(FormRecognizerClient recognizerClient, String invoiceUri) {
        String analyzeFilePath = invoiceUri;
        SyncPoller<FormRecognizerOperationResult, List<FormPage>> recognizeContentPoller = recognizerClient
                .beginRecognizeContentFromUrl(analyzeFilePath);

        List<FormPage> contentResult = recognizeContentPoller.getFinalResult();
        // </snippet_getcontent_call>
        // <snippet_getcontent_print>
        contentResult.forEach(formPage -> {
            // Table information
            System.out.println("----Recognizing content ----");
            System.out.printf("Has width: %f and height: %f, measured with unit: %s.%n", formPage.getWidth(),
                    formPage.getHeight(), formPage.getUnit());
            formPage.getTables().forEach(formTable -> {
                System.out.printf("Table has %d rows and %d columns.%n", formTable.getRowCount(),
                        formTable.getColumnCount());
                formTable.getCells().forEach(formTableCell -> {
                    System.out.printf("Cell has text %s.%n", formTableCell.getText());
                });
                System.out.println();
            });
        });
    }

Prova: modello predefinito

Questo esempio illustra come analizzare i dati da determinati tipi di documenti comuni con modelli pre-sottoposti a training, usando una fattura come esempio.

  • Per questo esempio, viene analizzato un documento di fattura usando un modello predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • Per analizzare un determinato file in un URI, si userà .beginRecognizeInvoicesFromUrl
  • È stato aggiunto il valore dell'URI del file alla invoiceUrl variabile nel metodo main.
  • Per semplicità, tutti i campi restituiti dal servizio non vengono visualizzati qui. Per visualizzare l'elenco di tutti i campi supportati e dei tipi corrispondenti, vedere la pagina Del concetto di fattura .

Scegliere un modello predefinito

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. Ecco i modelli predefiniti attualmente supportati dal servizio Riconoscimento modulo:

  • Fattura: estrae testo, contrassegni di selezione, tabelle, campi e informazioni chiave dalle fatture.
  • Ricevuta: estrae testo e informazioni chiave dalle ricevute.
  • Documento ID: estrae le informazioni di testo e chiave dalle licenze di conducente e dai passaporti internazionali.
  • Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.

Aggiornare la classe FormRecognizer dell'applicazione, con il codice seguente (aggiornare le variabili chiave ed endpoint con valori dell'istanza di portale di Azure Riconoscimento modulo):


static final String key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
static final String endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";

public static void main(String[] args) {
    FormRecognizerClient recognizerClient = new FormRecognizerClientBuilder().credential(new AzureKeyCredential(key)).endpoint(endpoint).buildClient();

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

    System.out.println("Analyze invoice...");
        AnalyzeInvoice(recognizerClient, invoiceUrl);
  }
    private static void AnalyzeInvoice(FormRecognizerClient recognizerClient, String invoiceUrl) {
      SyncPoller < FormRecognizerOperationResult,
        List < RecognizedForm >> recognizeInvoicesPoller = recognizerClient.beginRecognizeInvoicesFromUrl(invoiceUrl);
      List < RecognizedForm > recognizedInvoices = recognizeInvoicesPoller.getFinalResult();

      for (int i = 0; i < recognizedInvoices.size(); i++) {
        RecognizedForm recognizedInvoice = recognizedInvoices.get(i);
        Map < String,
        FormField > recognizedFields = recognizedInvoice.getFields();
        System.out.printf("----------- Recognized invoice info for page %d -----------%n", i);
        FormField vendorNameField = recognizedFields.get("VendorName");
        if (vendorNameField != null) {
            if (FieldValueType.STRING == vendorNameField.getValue().getValueType()) {
                String merchantName = vendorNameField.getValue().asString();
                System.out.printf("Vendor Name: %s, confidence: %.2f%n", merchantName, vendorNameField.getConfidence());
            }
        }

        FormField vendorAddressField = recognizedFields.get("VendorAddress");
        if (vendorAddressField != null) {
            if (FieldValueType.STRING == vendorAddressField.getValue().getValueType()) {
                String merchantAddress = vendorAddressField.getValue().asString();
                System.out.printf("Vendor address: %s, confidence: %.2f%n", merchantAddress, vendorAddressField.getConfidence());
            }
        }

        FormField customerNameField = recognizedFields.get("CustomerName");
        if (customerNameField != null) {
            if (FieldValueType.STRING == customerNameField.getValue().getValueType()) {
                String merchantAddress = customerNameField.getValue().asString();
                System.out.printf("Customer Name: %s, confidence: %.2f%n", merchantAddress, customerNameField.getConfidence());
            }
        }

        FormField customerAddressRecipientField = recognizedFields.get("CustomerAddressRecipient");
        if (customerAddressRecipientField != null) {
            if (FieldValueType.STRING == customerAddressRecipientField.getValue().getValueType()) {
                String customerAddr = customerAddressRecipientField.getValue().asString();
                System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n", customerAddr, customerAddressRecipientField.getConfidence());
            }
        }

        FormField invoiceIdField = recognizedFields.get("InvoiceId");
        if (invoiceIdField != null) {
            if (FieldValueType.STRING == invoiceIdField.getValue().getValueType()) {
                String invoiceId = invoiceIdField.getValue().asString();
                System.out.printf("Invoice Id: %s, confidence: %.2f%n", invoiceId, invoiceIdField.getConfidence());
            }
        }

        FormField invoiceDateField = recognizedFields.get("InvoiceDate");
        if (customerNameField != null) {
            if (FieldValueType.DATE == invoiceDateField.getValue().getValueType()) {
                LocalDate invoiceDate = invoiceDateField.getValue().asDate();
                System.out.printf("Invoice Date: %s, confidence: %.2f%n", invoiceDate, invoiceDateField.getConfidence());
            }
        }

        FormField invoiceTotalField = recognizedFields.get("InvoiceTotal");
        if (customerAddressRecipientField != null) {
            if (FieldValueType.FLOAT == invoiceTotalField.getValue().getValueType()) {
                Float invoiceTotal = invoiceTotalField.getValue().asFloat();
                System.out.printf("Invoice Total: %.2f, confidence: %.2f%n", invoiceTotal, invoiceTotalField.getConfidence());
            }
        }
    }
}

Compilare ed eseguire l'applicazione

Tornare alla directory principale del progetto: form-recognizer-app.

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

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (npm) | Esempi

In questa guida introduttiva si useranno le API seguenti per estrarre i dati strutturati dai moduli e dai documenti:

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito.

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

  • Versione LTS più recente di Node.js

  • 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 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. Creare una nuova applicazione Node.js. In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

    mkdir form-recognizer-app && cd form-recognizer-app
    
  2. Eseguire il comando npm init per creare un'applicazione Node con un file package.json.

    npm init
    
  3. Installare il pacchetto npm della ai-form-recognizer libreria client:

    npm install @azure/ai-form-recognizer
    

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

  4. Creare un file denominato index.js, aprirlo e importare le librerie seguenti:

    const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");
    
  5. Creare variabili per l'endpoint e la chiave di Azure della risorsa:

    const key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
    const endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";
    
  6. A questo punto, l'applicazione JavaScript deve contenere le righe di codice seguenti:

    
    const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");
    
    const endpoint = "PASTE_YOUR_FORM_RECOGNIZER_ENDPOINT_HERE";
    const key = "PASTE_YOUR_FORM_RECOGNIZER_KEY_HERE";
    

Selezionare un esempio di codice da 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, vedere l'articolo sulla sicurezza di Servizi cognitivi.

Provare: Modello di layout

  • 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 .
  • È stato aggiunto il valore dell'URI del file alla formUrl variabile nella parte superiore del file.
  • Per analizzare un determinato file in un URI, si userà il beginRecognizeContent metodo .

Aggiungere il codice seguente all'applicazione di layout nella riga seguente della key variabile

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

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

async function recognizeContent() {
    const client = new FormRecognizerClient(endpoint, new AzureKeyCredential(key));
    const poller = await client.beginRecognizeContentFromUrl(formUrl);
    const pages = await poller.pollUntilDone();

    if (!pages || pages.length === 0) {
        throw new Error("Expecting non-empty list of pages!");
    }

    for (const page of pages) {
        console.log(
            `Page ${page.pageNumber}: width ${page.width} and height ${page.height} with unit ${page.unit}`
        );
        for (const table of page.tables) {
            for (const cell of table.cells) {
                console.log(`cell [${cell.rowIndex},${cell.columnIndex}] has text ${cell.text}`);
            }
        }
    }
}

recognizeContent().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Prova: modello predefinito

Questo esempio illustra come analizzare i dati da determinati tipi di documenti comuni con modelli pre-sottoposti a training, usando una fattura come esempio. Per un elenco completo dei campi della fattura, vedere la pagina del concetto predefinito

  • Per questo esempio, viene analizzato un documento di fattura usando un modello predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È stato aggiunto il valore dell'URI del file alla invoiceUrl variabile nella parte superiore del file.
  • Per analizzare un determinato file in un URI, si userà il beginRecognizeInvoices metodo .
  • Per semplicità, tutti i campi restituiti dal servizio non vengono visualizzati qui. Per visualizzare l'elenco di tutti i campi supportati e dei tipi corrispondenti, vedere la pagina Del concetto di fattura .

Scegliere un modello predefinito

Non si è limitati alle fatture: sono disponibili diversi modelli predefiniti da scegliere, ognuno dei quali dispone di un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Riconoscimento modulo:

  • Fattura: estrae testo, contrassegni di selezione, tabelle, campi e informazioni chiave dalle fatture.
  • Ricevuta: estrae testo e informazioni chiave dalle ricevute.
  • Documento ID: estrae le informazioni di testo e chiave dalle licenze di conducente e dai passaporti internazionali.
  • Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.

Aggiungere il codice seguente all'applicazione fattura predefinita sotto la key variabile


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

async function recognizeInvoices() {

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

    const poller = await client.beginRecognizeInvoicesFromUrl(invoiceUrl);
    const [invoice] = await poller.pollUntilDone();

    if (invoice === undefined) {
        throw new Error("Failed to extract data from at least one invoice.");
    }

    /**
     * This is a helper function for printing a simple field with an elemental type.
     */
    function fieldToString(field) {
        const {
            name,
            valueType,
            value,
            confidence
        } = field;
        return `${name} (${valueType}): '${value}' with confidence ${confidence}'`;
    }

    console.log("Invoice fields:");

    /**
     * Invoices contain a lot of optional fields, but they are all of elemental types
     * such as strings, numbers, and dates, so we will just enumerate them all.
     */
    for (const [name, field] of Object.entries(invoice.fields)) {
        if (field.valueType !== "array" && field.valueType !== "object") {
            console.log(`- ${name} ${fieldToString(field)}`);
        }
    }

    // Invoices also support nested line items, so we can iterate over them.
    let idx = 0;

    console.log("- Items:");

    const items = invoice.fields["Items"]?.value;
    for (const item of items ?? []) {
        const value = item.value;

        // Each item has several subfields that are nested within the item. We'll
        // map over this list of the subfields and filter out any fields that
        // weren't found. Not all fields will be returned every time, only those
        // that the service identified for the particular document in question.

        const subFields = [
                "Description",
                "Quantity",
                "Unit",
                "UnitPrice",
                "ProductCode",
                "Date",
                "Tax",
                "Amount"
            ]
            .map((fieldName) => value[fieldName])
            .filter((field) => field !== undefined);

        console.log(
            [
                `  - Item #${idx}`,
                // Now we will convert those fields into strings to display
                ...subFields.map((field) => `    - ${fieldToString(field)}`)
            ].join("\n")
        );
    }
}

recognizeInvoices().catch((err) => {
    console.error("The sample encountered an error:", err);
});

Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (PyPi) | Esempi

In questa guida introduttiva si useranno le API seguenti per estrarre i dati strutturati dai moduli e dai documenti:

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito

  • Python 3.x

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

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

Creare una nuova applicazione Python

Creare una nuova applicazione Python denominata form_recognizer_quickstart.py nell'editor o nell'IDE preferito. Importare quindi le librerie seguenti:

import os
from azure.ai.formrecognizer import FormRecognizerClient
from azure.core.credentials import AzureKeyCredential

Creare variabili per l'endpoint e la chiave delle risorse di Azure

endpoint = "YOUR_FORM_RECOGNIZER_ENDPOINT"
key = "YOUR_FORM_RECOGNIZER_KEY"

A questo punto, l'applicazione Python deve contenere le righe di codice seguenti:

import os
from azure.core.exceptions import ResourceNotFoundError
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

endpoint = "YOUR_FORM_RECOGNIZER_ENDPOINT"
key = "YOUR_FORM_RECOGNIZER_KEY"

Selezionare un esempio di codice da 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, vedere l'articolo sulla sicurezza di Servizi cognitivi.

Provare: Modello di layout

  • 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 .
  • È stato aggiunto il valore dell'URI del file alla formUrl variabile nella parte superiore del file.
  • Per analizzare un determinato file in un URI, si userà il begin_recognize_content_from_url metodo .

Aggiungere il codice seguente all'applicazione di layout nella riga seguente della key variabile


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

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

    form_recognizer_client = FormRecognizerClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = form_recognizer_client.begin_recognize_content_from_url(formUrl)
    form_pages = poller.result()

    for idx, content in enumerate(form_pages):
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                content.width, content.height, content.unit
            )
        )
        for table_idx, table in enumerate(content.tables):
            print(
                "Table # {} has {} rows and {} columns".format(
                    table_idx, table.row_count, table.column_count
                )
            )
            print(
                "Table # {} location on page: {}".format(
                    table_idx, format_bounding_box(table.bounding_box)
                )
            )
            for cell in table.cells:
                print(
                    "...Cell[{}][{}] has text '{}' within bounding box '{}'".format(
                        cell.row_index,
                        cell.column_index,
                        cell.text,
                        format_bounding_box(cell.bounding_box),
                    )
                )

        for line_idx, line in enumerate(content.lines):
            print(
                "Line # {} has word count '{}' and text '{}' within bounding box '{}'".format(
                    line_idx,
                    len(line.words),
                    line.text,
                    format_bounding_box(line.bounding_box),
                )
            )
            if line.appearance:
                if (
                    line.appearance.style_name == "handwriting"
                    and line.appearance.style_confidence > 0.8
                ):
                    print(
                        "Text line '{}' is handwritten and might be a signature.".format(
                            line.text
                        )
                    )
            for word in line.words:
                print(
                    "...Word '{}' has a confidence of {}".format(
                        word.text, word.confidence
                    )
                )

        for selection_mark in content.selection_marks:
            print(
                "Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_bounding_box(selection_mark.bounding_box),
                    selection_mark.confidence,
                )
            )
        print("----------------------------------------")


if __name__ == "__main__":
    recognize_content()

Prova: modello predefinito

Questo esempio illustra come analizzare i dati da determinati tipi di documenti comuni con modelli pre-sottoposti a training, usando una fattura come esempio. Per un elenco completo dei campi della fattura, vedere la pagina del concetto predefinito

  • Per questo esempio, viene analizzato un documento di fattura usando un modello predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
  • È stato aggiunto il valore dell'URI del file alla variabile ''formUrl' nella parte superiore del file.
  • Per analizzare un determinato file in un URI, si userà il metodo ''begin_recognize_invoices_from_url'.
  • Per semplicità, tutti i campi restituiti dal servizio non vengono visualizzati qui. Per visualizzare l'elenco di tutti i campi supportati e dei tipi corrispondenti, vedere la pagina Del concetto di fattura .

Scegliere un modello predefinito

Non si è limitati alle fatture: sono disponibili diversi modelli predefiniti da scegliere, ognuno dei quali dispone di un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Riconoscimento modulo:

  • Fattura: estrae testo, contrassegni di selezione, tabelle, campi e informazioni chiave dalle fatture.
  • Ricevuta: estrae testo e informazioni chiave dalle ricevute.
  • Documento ID: estrae le informazioni di testo e chiave dalle licenze di conducente e dai passaporti internazionali.
  • Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.

Aggiungere il codice seguente all'applicazione fattura predefinita sotto la key variabile


def recognize_invoice():

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

    form_recognizer_client = FormRecognizerClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = form_recognizer_client.begin_recognize_invoices_from_url(
        invoiceUrl, locale="en-US"
    )
    invoices = poller.result()

    for idx, invoice in enumerate(invoices):
        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):
            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__":
    recognize_invoice()

Eseguire l'applicazione

  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

| informazioni di riferimento sulle API | REST di Azure Riconoscimento modulo |

In questa guida introduttiva si useranno le API seguenti per estrarre i dati strutturati dai moduli e dai documenti:

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito

  • cURL installato.

  • PowerShell versione 6.0+o un'applicazione da riga di comando simile.

  • 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 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.

Selezionare un esempio di codice da 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, vedere l'articolo sulla sicurezza di Servizi cognitivi.

Provare: Modello di layout

  • 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 .
  1. Sostituire {endpoint} con l'endpoint ottenuto con la sottoscrizione di riconoscimento modulo.
  2. Sostituire {key} con la chiave copiata dal passaggio precedente.
  3. Sostituire \"{your-document-url} con un URL del modulo di esempio:
https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf

Richiesta

curl -v -i POST "https://{endpoint}/formrecognizer/v2.1/layout/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{​​​​​​​'urlSource': '{your-document-url}'}​​​​​​​​"

Operation-Location

Si riceverà una risposta 202 (Success) che include un'intestazione Operation-Location. Il valore di questa intestazione contiene un ID risultato che è possibile usare per eseguire query sullo stato dell'operazione asincrona e ottenere i risultati:

https:// cognitiveservice/formrecognizer/v2.1/layout/analyzeResults/{resultId}.

Nell'esempio seguente, come parte dell'URL, la stringa dopo analyzeResults/ è l'ID risultato.

https://cognitiveservice/formrecognizer/v2/layout/analyzeResults/54f0b076-4e38-43e5-81bd-b85b8835fdfb

Ottenere i risultati del layout

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

  1. Sostituire {endpoint} con l'endpoint ottenuto con la sottoscrizione di riconoscimento modulo.
  2. Sostituire {key} con la chiave copiata dal passaggio precedente.
  3. Sostituire {resultId} con l'ID risultato del passaggio precedente.

Richiesta

curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/layout/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"

Esaminare i risultati

Si riceverà una risposta 200 (success) con il contenuto JSON.

Vedere l'immagine di fattura seguente e il corrispondente output JSON.

  • Il nodo "readResults" contiene ogni riga di testo con il rispettivo posizionamento del rettangolo di selezione nella pagina.
  • Il selectionMarks nodo mostra ogni segno di selezione (casella di controllo, segno di opzione) e se lo stato è "selezionato" o "non selezionato".
  • La "pageResults" sezione include le tabelle estratte. Per ogni tabella, il testo, la riga e l'indice di colonna, la riga e la colonna che si estende, la casella di selezione e altro ancora vengono estratti.

Documento di rendiconto su un progetto Contoso con una tabella.

Corpo della risposta

È possibile visualizzare l'output completo dell'esempio in GitHub.

Prova: modello predefinito

  • Per questo esempio, viene analizzato un documento di fattura usando un modello predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.

Scegliere un modello predefinito

Non si è limitati alle fatture: sono disponibili diversi modelli predefiniti da scegliere, ognuno dei quali dispone di un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Riconoscimento modulo:

  • Fattura: estrae testo, contrassegni di selezione, tabelle, campi e informazioni chiave dalle fatture.
  • Ricevuta: estrae testo e informazioni chiave dalle ricevute.
  • Documento ID: estrae le informazioni di testo e chiave dalle licenze di conducente e dai passaporti internazionali.
  • Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.

Prima di eseguire il comando, apportare queste modifiche:

  1. Sostituire {endpoint} con l'endpoint ottenuto con la sottoscrizione di riconoscimento modulo.

  2. Sostituire {key} con la chiave copiata dal passaggio precedente.

  3. Sostituire \"{your-document-url} con un URL di fattura di esempio:

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

Richiesta

curl -v -i POST https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyze" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key:  {key}" --data-ascii "{​​​​​​​'urlSource': '{your invoice URL}'}​​​​​​​​"

Operation-Location

Si riceverà una risposta 202 (Success) che include un'intestazione Operation-Location. Il valore di questa intestazione contiene un ID risultato che è possibile usare per eseguire query sullo stato dell'operazione asincrona e ottenere i risultati:

https:// cognitiveservice/formrecognizer/v2.1/prebuilt/receipt/analysisResults/{resultId}

Nell'esempio seguente, come parte dell'URL, la stringa dopo analyzeResults/ è l'ID risultato:

https://cognitiveservice/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/54f0b076-4e38-43e5-81bd-b85b8835fdfb

Ottenere i risultati delle fatture

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

  1. Sostituire {endpoint} con l'endpoint ottenuto con la chiave di Riconoscimento modulo. disponibile nella scheda Overview (Panoramica) della risorsa di riconoscimento modulo.
  2. Sostituire {resultId} con l'ID risultato del passaggio precedente.
  3. Sostituire {key} con la chiave.

Richiesta

curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"

Esaminare i risultati

Si riceverà una risposta 200 (Success) con un output JSON.

  • Il "readResults" campo contiene ogni riga di testo estratta dalla fattura.
  • "pageResults" Include le tabelle e i segni di selezione estratti dalla fattura.
  • Il "documentResults" campo contiene informazioni chiave/valore per le parti più rilevanti della fattura.

Vedere il documento della fattura di esempio .

Corpo della risposta

Vedere l'output completo dell'esempio in GitHub.

È questo, complimenti! In questa guida introduttiva sono stati usati Riconoscimento modulo modelli per analizzare diversi moduli in modi diversi.

Passaggi successivi

  • Per un'esperienza avanzata e una qualità avanzata del modello, provare Riconoscimento modulo v3.0 Studio .

  • V3.0 Studio supporta qualsiasi modello sottoposto a training con dati con etichetta v2.1.

  • Per informazioni dettagliate sulla migrazione dalla versione 2.1 alla versione 3.0, vedere la guida alla migrazione delle API.

  • Per iniziare a usare la versione 3.0, vedere le guide introduttive sull'API REST o C#, Java, JavaScript o Python SDK.