Attività iniziali: Riconoscimento modulo C# SDK (beta)

Nota

Riconoscimento modulo versione beta è attualmente disponibile in anteprima pubblica. Alcune funzionalità potrebbero non essere supportate o avere funzionalità limitate.

Documentazione | di riferimento Codice | sorgente della libreriaPacchetti (NuGet) | Esempi

Attività iniziali con Azure Riconoscimento modulo usando il linguaggio di programmazione C#. 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 IDK 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.

In questa guida introduttiva si useranno le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e 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 segni di selezione come pulsanti di opzione e caselle di controllo nei documenti moduli, 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.

  • 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 di Servizi cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Solo per Riconoscimento modulo l'accesso, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare Azure Active Directory autenticazione.

  • 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: keys and endpoint location in the Azure portal.

Configurazione

  1. Avviare Visual Studio.

  2. Nella pagina iniziale scegliere Crea un nuovo progetto.

    Screenshot: Visual Studio start window.

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

    Screenshot: Visual Studio's create new project page.

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

    Screenshot: Visual Studio's configure new project dialog window.

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

    Screenshot: Visual Studio's additional information dialog window.

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: select-nuget-package.png

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

    Screenshot: select-form-recognizer-package.png

  3. Scegliere la casella di controllo Includi versione preliminare e selezionare la versione 4.0.0-beta.3* 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 con key dal portale di Azure e un'istanza DocumentAnalysisClientAzureKeyCredential con e il Riconoscimento modulo endpoint.AzureKeyCredential

Nota

  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 metodi sicuri per archiviare e accedere alle credenziali. Per altre informazioni, vedereSicurezza di Servizi cognitivi.

Modello di documento generale

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

  • Per questo esempio, è necessario un file di documento di modulo da 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 StartAnalyzeDocumentFromUri metodo . Il valore restituito è un AnalyzeResult oggetto contenente i dati relativi al documento inviato.
  • È stato aggiunto il valore dell'URI del file alla Uri fileUri variabile all'inizio dello script.
  • Per semplicità, tutti i campi di entità restituiti dal servizio non vengono visualizzati qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Generale del concetto di documento .

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

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.StartAnalyzeDocumentFromUriAsync("prebuilt-document", fileUri);

await operation.WaitForCompletionAsync();

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

Console.WriteLine("Detected entities:");

foreach (DocumentEntity entity in result.Entities)
{
    if (entity.SubCategory == null)
    {
        Console.WriteLine($"  Found entity '{entity.Content}' with category '{entity.Category}'.");
    }
    else
    {
        Console.WriteLine($"  Found entity '{entity.Content}' with category '{entity.Category}' and sub-category '{entity.SubCategory}'.");
    }
}

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.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[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.BoundingBox[0].X}, Y= {selectionMark.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingBox[1].X}, Y= {selectionMark.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingBox[2].X}, Y= {selectionMark.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingBox[3].X}, Y= {selectionMark.BoundingBox[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.Offset, 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: run your Visual Studio program.

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

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

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.StartAnalyzeDocumentFromUriAsync("prebuilt-layout", fileUri);

await operation.WaitForCompletionAsync();

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.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[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.BoundingBox[0].X}, Y= {selectionMark.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingBox[1].X}, Y= {selectionMark.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingBox[2].X}, Y= {selectionMark.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingBox[3].X}, Y= {selectionMark.BoundingBox[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.Offset, 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: run your Visual Studio program.

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 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'URI del file alla Uri fileUri variabile all'inizio 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 i valori dell'istanza di Riconoscimento modulo nell'portale di Azure:



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.StartAnalyzeDocumentFromUriAsync("prebuilt-invoice", invoiceUri);

await operation.WaitForCompletionAsync();

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.ValueType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

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

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

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

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

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

                    if (itemFields.TryGetValue("Amount", out DocumentField? itemAmountField))
                    {
                        if (itemAmountField.ValueType == DocumentFieldType.Double)
                        {
                            double itemAmount = itemAmountField.AsDouble();

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

    if (document.Fields.TryGetValue("SubTotal", out DocumentField? subTotalField))
    {
        if (subTotalField.ValueType == DocumentFieldType.Double)
        {
            double subTotal = subTotalField.AsDouble();
            Console.WriteLine($"Sub Total: '{subTotal}', with confidence {subTotalField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("TotalTax", out DocumentField? totalTaxField))
    {
        if (totalTaxField.ValueType == DocumentFieldType.Double)
        {
            double totalTax = totalTaxField.AsDouble();
            Console.WriteLine($"Total Tax: '{totalTax}', with confidence {totalTaxField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField? invoiceTotalField))
    {
        if (invoiceTotalField.ValueType == DocumentFieldType.Double)
        {
            double invoiceTotal = invoiceTotalField.AsDouble();
            Console.WriteLine($"Invoice Total: '{invoiceTotal}', 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: run your Visual Studio program.

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.

È così, congratulazioni!

In questa guida introduttiva è stato usato l'SDK C# di Riconoscimento modulo per analizzare vari moduli e documenti in modi diversi. Esplorare quindi la documentazione di riferimento per informazioni sull'API Riconoscimento modulo più approfondita.

Passaggio successivo