Introduzione a Document Intelligence
Importante
- Servizi cognitivi di Azure Riconoscimento modulo è ora Intelligence sui documenti di Intelligenza artificiale di Azure.
- Alcune piattaforme sono ancora in attesa dell'aggiornamento della ridenominazione.
- Tutte le menzioni di Riconoscimento modulo o document intelligence nella documentazione fanno riferimento allo stesso servizio di Azure.
Questo contenuto si applica a:v4.0 (anteprima)Versioni precedenti:v3.1 (GA)v3.0 (GA)
- Introduzione all'anteprima più recente di Azure AI Document Intelligence (anteprima 2024-02-29-preview).
Questo contenuto si applica a:v3.1 (GA)Versioni precedenti:v3.0v2.1
- Introduzione ad Azure Riconoscimento modulo versione ga più recente (
2023-07-31
).
Questo contenuto si applica a:v3.0 (GA)Versione più recente:v3.1v2.1
- Introduzione ad Azure Riconoscimento modulo versione ga legacy (
2022-08-31
).
Azure AI Document Intelligence/Riconoscimento modulo è un servizio di intelligenza artificiale di Azure basato sul cloud che usa Machine Learning per estrarre coppie chiave-valore, testo, tabelle e dati chiave dai documenti.
È possibile integrare facilmente i modelli di elaborazione dei documenti nei flussi di lavoro e nelle applicazioni usando un SDK del linguaggio di programmazione o chiamando l'API REST.
Per questa guida introduttiva, è consigliabile usare il servizio gratuito durante l'apprendimento della tecnologia. Tenere presente che il numero di pagine gratuite è limitato a 500 al mese.
Per altre informazioni sulle funzionalità dell'API e sulle opzioni di sviluppo, visitare la pagina Panoramica .
Informazioni di riferimento | dell'SDK della libreria | client per l'API REST Samples Supported REST API version (Esempi di pacchetti di riferimento| | api|REST supportati)
Pacchetto di riferimento dell'API di riferimento | | dell'SDK della libreria | client (NuGet)Esempi | della versione dell'API | REST supportata
Informazioni di riferimento | dell'SDK della libreria | client per l'API REST Samples Supported REST API version (Esempi di pacchetti di riferimento | | api |REST supportati)
In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:
Modello di layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione come pulsanti di opzione e caselle di controllo nei documenti, senza la necessità di eseguire il training di un modello.
Modello predefinito: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito.
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
Versione corrente dell'IDE di Visual Studio.
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa multiservizio o a servizio singolo di Intelligenza artificiale di Azure, nella portale di Azure, per ottenere la chiave e l'endpoint.
È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Un servizio di intelligenza artificiale di Azure o una risorsa Riconoscimento modulo. Dopo aver creato la sottoscrizione di Azure, creare una risorsa multiservizio o a servizio singolo di Intelligenza artificiale di Azure, nella portale di Azure, per ottenere la chiave e l'endpoint.
È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. 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 Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint della risorsa creata per connettere l'applicazione all'API Riconoscimento modulo. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
Avviare Visual Studio.
Nella pagina iniziale scegliere Crea un nuovo progetto.
Nella pagina Crea un nuovo progetto immettere console nella casella di ricerca. Scegliere il modello Applicazione console, quindi scegliere Avanti.
- Nella finestra di dialogo Configura il nuovo progetto immettere
doc_intel_quickstart
nella casella Nome progetto. Scegliere quindi Avanti.
- Nella finestra di dialogo Configura il nuovo progetto immettere
form_recognizer_quickstart
nella casella Nome progetto. Scegliere quindi Avanti.
Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.
Installare la libreria client con NuGet
Fare clic con il pulsante destro del mouse sul progetto doc_intel_quickstart e scegliere Gestisci pacchetti NuGet... .
Selezionare la scheda Sfoglia e digitare Azure.AI.DocumentIntelligence. Scegliere la casella di controllo e selezionare la
Include prerelease
versione 1.0.0-beta.1 dal menu a discesa
Fare clic con il pulsante destro del mouse sul progetto form_recognizer_quickstart e scegliere Gestisci pacchetti NuGet... .
Selezionare la scheda Sfoglia e digitare Azure.AI.FormRecognizer. Selezionare la versione 4.1.0 dal menu a discesa
Fare clic con il pulsante destro del mouse sul progetto form_recognizer_quickstart e scegliere Gestisci pacchetti NuGet... .
Selezionare la scheda Sfoglia e digitare Azure.AI.FormRecognizer. Selezionare la versione 4.0.0 dal menu a discesa
Compilare l'applicazione
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con l'oggetto dal key
portale di Azure e un'istanza DocumentIntelligenceClient
AzureKeyCredential
con e document intelligence endpoint
.
Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della DocumentAnalysisClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con il portale di Azure key
e un'istanza DocumentAnalysisClient
AzureKeyCredential
con e il 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 metodo
Main
. Non è necessario includere istruzioni di primo livello, direttive using globali o direttive using implicite. - Per altre informazioni, vedereNuovi modelli C# generano istruzioni di primo livello.
Aprire il file Program.cs.
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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Modello di layout
Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.
- Per questo esempio, è necessario un file di documento da un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- È stato aggiunto il valore dell'URI del file alla
Uri fileUri
variabile nella parte superiore dello script. - Per estrarre il layout da un determinato file in un URI, usare il
StartAnalyzeDocumentFromUri
metodo e passareprebuilt-layout
come ID modello. Il valore restituito è unAnalyzeResult
oggetto contenente i dati del documento inviato.
Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
using Azure;
using Azure.AI.DocumentIntelligence;
//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(new Uri(endpoint), credential);
//sample document
Uri fileUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf");
AnalyzeDocumentContent content = new AnalyzeDocumentContent()
{
UrlSource= fileUri
};
Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-layout", content);
AnalyzeResult result = operation.Value;
foreach (DocumentPage page in result.Pages)
{
Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s)," +
$" and {page.SelectionMarks.Count} selection mark(s).");
for (int i = 0; i < page.Lines.Count; i++)
{
DocumentLine line = page.Lines[i];
Console.WriteLine($" Line {i}:");
Console.WriteLine($" Content: '{line.Content}'");
Console.Write(" Bounding polygon, with points ordered clockwise:");
for (int j = 0; j < line.Polygon.Count; j += 2)
{
Console.Write($" ({line.Polygon[j]}, {line.Polygon[j + 1]})");
}
Console.WriteLine();
}
for (int i = 0; i < page.SelectionMarks.Count; i++)
{
DocumentSelectionMark selectionMark = page.SelectionMarks[i];
Console.WriteLine($" Selection Mark {i} is {selectionMark.State}.");
Console.WriteLine($" State: {selectionMark.State}");
Console.Write(" Bounding polygon, with points ordered clockwise:");
for (int j = 0; j < selectionMark.Polygon.Count; j++)
{
Console.Write($" ({selectionMark.Polygon[j]}, {selectionMark.Polygon[j + 1]})");
}
Console.WriteLine();
}
}
for (int i = 0; i < result.Paragraphs.Count; i++)
{
DocumentParagraph paragraph = result.Paragraphs[i];
Console.WriteLine($"Paragraph {i}:");
Console.WriteLine($" Content: {paragraph.Content}");
if (paragraph.Role != null)
{
Console.WriteLine($" Role: {paragraph.Role}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
var handwrittenContent = result.Content.Substring(span.Offset, span.Length);
Console.WriteLine($" {handwrittenContent}");
}
}
}
for (int i = 0; i < result.Tables.Count; i++)
{
DocumentTable table = result.Tables[i];
Console.WriteLine($"Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");
foreach (DocumentTableCell cell in table.Cells)
{
Console.WriteLine($" Cell ({cell.RowIndex}, {cell.ColumnIndex}) is a '{cell.Kind}' with content: {cell.Content}");
}
}
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, scegliere il pulsante Start verde accanto a formRecognizer_quickstart per compilare ed eseguire il programma oppure premere F5.
Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'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.
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.
Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'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 polygon (points ordered clockwise):");
for (int j = 0; j < line.BoundingPolygon.Count; j++)
{
Console.WriteLine($" Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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 polygon (points ordered clockwise):");
for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
{
Console.WriteLine($" Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
}
}
}
Console.WriteLine("Paragraphs:");
foreach (DocumentParagraph paragraph in result.Paragraphs)
{
Console.WriteLine($" Paragraph content: {paragraph.Content}");
if (paragraph.Role != null)
{
Console.WriteLine($" Role: {paragraph.Role}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
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}'.");
}
}
Extract the layout of a document from a file stream
To extract the layout from a given file at a file stream, use the AnalyzeDocument method and pass prebuilt-layout as the model ID. The returned value is an AnalyzeResult object containing data about the submitted document.
string filePath = "<filePath>";
using var stream = new FileStream(filePath, FileMode.Open);
AnalyzeDocumentOperation operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-layout", stream);
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 polygon (points ordered clockwise):");
for (int j = 0; j < line.BoundingPolygon.Count; j++)
{
Console.WriteLine($" Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].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 polygon (points ordered clockwise):");
for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
{
Console.WriteLine($" Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
}
}
}
Console.WriteLine("Paragraphs:");
foreach (DocumentParagraph paragraph in result.Paragraphs)
{
Console.WriteLine($" Paragraph content: {paragraph.Content}");
if (paragraph.Role != null)
{
Console.WriteLine($" Role: {paragraph.Role}");
}
}
foreach (DocumentStyle style in result.Styles)
{
// Check the style and style confidence to see if text is handwritten.
// Note that value '0.8' is used as an example.
bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;
if (isHandwritten && style.Confidence > 0.8)
{
Console.WriteLine($"Handwritten content found:");
foreach (DocumentSpan span in style.Spans)
{
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.
Modello predefinito
Analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito. In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.
Suggerimento
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze
dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.
- Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È stato aggiunto il valore dell'URI del file alla
Uri invoiceUri
variabile nella parte superiore del file Program.cs. - Per analizzare un determinato file in corrispondenza di un URI, usare il
StartAnalyzeDocumentFromUri
metodo e passareprebuilt-invoice
come ID modello. Il valore restituito è unAnalyzeResult
oggetto contenente i dati del documento inviato. - Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .
Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
using Azure;
using Azure.AI.DocumentIntelligence;
//set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instance
string endpoint = "<your-endpoint>";
string key = "<your-key>";
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(new Uri(endpoint), credential);
//sample invoice document
Uri invoiceUri = new Uri ("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf");
AnalyzeDocumentContent content = new AnalyzeDocumentContent()
{
UrlSource = invoiceUri
};
Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", content);
AnalyzeResult result = operation.Value;
for (int i = 0; i < result.Documents.Count; i++)
{
Console.WriteLine($"Document {i}:");
AnalyzedDocument document = result.Documents[i];
if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField)
&& vendorNameField.Type == DocumentFieldType.String)
{
string vendorName = vendorNameField.ValueString;
Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
}
if (document.Fields.TryGetValue("CustomerName", out DocumentField customerNameField)
&& customerNameField.Type == DocumentFieldType.String)
{
string customerName = customerNameField.ValueString;
Console.WriteLine($"Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
}
if (document.Fields.TryGetValue("Items", out DocumentField itemsField)
&& itemsField.Type == DocumentFieldType.Array)
{
foreach (DocumentField itemField in itemsField.ValueArray)
{
Console.WriteLine("Item:");
if (itemField.Type == DocumentFieldType.Object)
{
IReadOnlyDictionary<string, DocumentField> itemFields = itemField.ValueObject;
if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField)
&& itemDescriptionField.Type == DocumentFieldType.String)
{
string itemDescription = itemDescriptionField.ValueString;
Console.WriteLine($" Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
}
if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField)
&& itemAmountField.Type == DocumentFieldType.Currency)
{
CurrencyValue itemAmount = itemAmountField.ValueCurrency;
Console.WriteLine($" Amount: '{itemAmount.CurrencySymbol}{itemAmount.Amount}', with confidence {itemAmountField.Confidence}");
}
}
}
}
if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField)
&& subTotalField.Type == DocumentFieldType.Currency)
{
CurrencyValue subTotal = subTotalField.ValueCurrency;
Console.WriteLine($"Sub Total: '{subTotal.CurrencySymbol}{subTotal.Amount}', with confidence {subTotalField.Confidence}");
}
if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField)
&& totalTaxField.Type == DocumentFieldType.Currency)
{
CurrencyValue totalTax = totalTaxField.ValueCurrency;
Console.WriteLine($"Total Tax: '{totalTax.CurrencySymbol}{totalTax.Amount}', with confidence {totalTaxField.Confidence}");
}
if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField)
&& invoiceTotalField.Type == DocumentFieldType.Currency)
{
CurrencyValue invoiceTotal = invoiceTotalField.ValueCurrency;
Console.WriteLine($"Invoice Total: '{invoiceTotal.CurrencySymbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
}
}
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, scegliere il pulsante Start verde accanto a formRecognizer_quickstart per compilare ed eseguire il programma oppure premere F5.
Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'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 `FormRecognizerClient` 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");
Operation operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);
AnalyzeResult result = operation.Value;
for (int i = 0; i < result.Documents.Count; i++)
{
Console.WriteLine($"Document {i}:");
AnalyzedDocument document = result.Documents[i];
if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
{
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.
Output predefinito del modello
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 predefinito del modello di fattura.
Aggiungere l'esempio di codice seguente al file Program.cs. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di 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 `FormRecognizerClient` 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.
Client library | SDK reference | REST API reference | Package (Maven)Samples Supported REST API version (Maven)Samples Supported REST API version (Maven) | Samples |Supported REST API version
Client library | SDK reference | REST API reference | Package (Maven)Samples Supported REST API version (Maven)Samples Supported REST API version (Maven) | Samples| Supported REST API version
Client library | SDK reference | REST API reference | Package (Maven)Samples Supported REST API version (Maven)Samples Supported REST API version (Maven) | Samples|Supported REST API version
In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:
Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione, ad esempio pulsanti di opzione e caselle di controllo nei documenti, senza la necessità di eseguire il training di un modello.
Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello con training preliminare.
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
Versione più recente di Visual Studio Code o dell'IDE preferito. VedereJava in Visual Studio Code.
Suggerimento
- Visual Studio Code offre un pacchetto di codifica per Java per Windows e macOS.Il pacchetto di codifica è un bundle di VS Code, Java Development Kit (JDK) e una raccolta di estensioni suggerite da Microsoft. Il pacchetto di codifica può essere usato anche per correggere un ambiente di sviluppo esistente.
- Se si usa VS Code e Coding Pack per Java, installare l'estensione Gradle per Java .
Se non si usa Visual Studio Code, assicurarsi di avere installato quanto segue nell'ambiente di sviluppo:
Java Development Kit (JDK) versione 8 o successiva. Per altre informazioni, vedereMicrosoft Build of OpenJDK.
Gradle, versione 6.8 o successiva.
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. Successivamente, incollare la chiave e l'endpoint nel codice:
Configurazione
Creare un nuovo progetto Gradle
Nella finestra della console ,ad esempio cmd, PowerShell o Bash, creare una nuova directory per l'app denominata doc-intel-app e passare a essa.
mkdir doc-intel-app && doc-intel-app
mkdir doc-intel-app; cd doc-intel-app
Eseguire il comando
gradle init
dalla directory di lavoro. Questo comando crea file di compilazione essenziali per Gradle, incluso build.gradle.kts, usato in fase di esecuzione per creare e configurare l'applicazione.gradle init --type basic
Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.
Accettare il nome del progetto predefinito (doc-intel-app) selezionando Restituisci o Invio.
Nella finestra della console ,ad esempio cmd, PowerShell o Bash, creare una nuova directory per l'app denominata form-recognize-app e passare a essa.
mkdir form-recognize-app && form-recognize-app
mkdir form-recognize-app; cd form-recognize-app
Eseguire il comando
gradle init
dalla directory di lavoro. Questo comando crea file di compilazione essenziali per Gradle, incluso build.gradle.kts, usato in fase di esecuzione per creare e configurare l'applicazione.gradle init --type basic
Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.
Accettare il nome del progetto predefinito (form-recognize-app) selezionando Restituisci o Immetti.
Installare la libreria client
Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.
Aprire il file build.gradle.kts del progetto nell'IDE. Copay e oltre il codice seguente per includere la libreria client come istruzione implementation
, insieme ai plug-in e alle impostazioni necessari.
plugins {
java
application
}
application {
mainClass.set("DocIntelligence")
}
repositories {
mavenCentral()
}
dependencies {
implementation group: 'com.azure', name: 'azure-ai-documentintelligence', version: '1.0.0-beta.2'
}
Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.
Aprire il file build.gradle.kts del progetto nell'IDE. Copay e oltre il codice seguente per includere la libreria client come istruzione implementation
, insieme ai plug-in e alle impostazioni necessari.
plugins {
java
application
}
application {
mainClass.set("FormRecognizer")
}
repositories {
mavenCentral()
}
dependencies {
implementation group: 'com.azure', name: 'azure-ai-formrecognizer', version: '4.1.0'
}
Questo argomento di avvio rapido usa l'utilità di gestione dipendenze Gradle. La libreria client e le informazioni per altre utilità di gestione dipendenze sono disponibili in Maven Central Repository.
Aprire il file build.gradle.kts del progetto nell'IDE. Copay e oltre il codice seguente per includere la libreria client come istruzione implementation
, insieme ai plug-in e alle impostazioni necessari.
plugins {
java
application
}
application {
mainClass.set("FormRecognizer")
}
repositories {
mavenCentral()
}
dependencies {
implementation group: 'com.azure', name: 'azure-ai-formrecognizer', version: '4.0.0'
}
Creare un'applicazione Java
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con l'oggetto dal key
portale di Azure e un'istanza DocumentIntelligenceClient
AzureKeyCredential
con e document intelligence endpoint
.
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentAnalysisClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con l'oggetto dal key
portale di Azure e un'istanza DocumentAnalysisClient
AzureKeyCredential
con e document intelligence endpoint
.
Dalla directory doc-intel-app eseguire il comando seguente:
mkdir -p src/main/java
Creare la struttura di directory seguente:
Passare alla
java
directory e creare un file denominatoDocIntelligence.java
.Suggerimento
- È possibile creare un nuovo file usando PowerShell.
- Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.
- Digitare il comando seguente DocIntelligence.java New-Item.
Apri il file
DocIntelligence.java
. Copiare e incollare uno degli esempi di codice seguenti nell'applicazione:
Passare alla
java
directory e creare un file denominatoFormRecognizer.java
.Suggerimento
- È possibile creare un nuovo file usando PowerShell.
- Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.
- Digitare il comando seguente FormRecognizer.java New-Item.
Apri il file
FormRecognizer.java
. Copiare e incollare uno degli esempi di codice seguenti nell'applicazione:
Importante
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Modello di layout
Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.
- Per questo esempio, è necessario un file di documento in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- Per analizzare un determinato file in un URI, si userà il
beginAnalyzeDocumentFromUrl
metodo e si passeràprebuilt-layout
come ID modello. Il valore restituito è unAnalyzeResult
oggetto contenente i dati relativi al documento inviato. - È stato aggiunto il valore dell'URI del file alla
documentUrl
variabile nel metodo main.
Aggiungere il codice di esempio seguente al DocIntelligence.java
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
import com.azure.ai.documentintelligence;
import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.DocumentTable;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;
import java.util.List;
public class DocIntelligence {
// set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
private static final String endpoint = "<your-endpoint>";
private static final String key = "<your-key>";
public static void main(String[] args) {
// create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
.credential(new AzureKeyCredential(key))
.endpoint(endpoint)
.buildClient();
// sample document
String modelId = "prebuilt-layout";
String documentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
SyncPoller <AnalyzeResultOperation, AnalyzeResultOperation> analyzeLayoutPoller =
client.beginAnalyzeDocument(modelId,
null,
null,
null,
null,
null,
null,
new AnalyzeDocumentRequest().setUrlSource(documentUrl));
AnalyzeResult analyzeLayoutResult = analyzeLayoutPoller.getFinalResult().getAnalyzeResult();
// pages
analyzeLayoutResult.getPages().forEach(documentPage -> {
System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
documentPage.getWidth(),
documentPage.getHeight(),
documentPage.getUnit());
// lines
documentPage.getLines().forEach(documentLine ->
System.out.printf("Line '%s' is within a bounding polygon %s.%n",
documentLine.getContent(),
documentLine.getPolygon()));
// words
documentPage.getWords().forEach(documentWord ->
System.out.printf("Word '%s' has a confidence score of %.2f.%n",
documentWord.getContent(),
documentWord.getConfidence()));
// selection marks
documentPage.getSelectionMarks().forEach(documentSelectionMark ->
System.out.printf("Selection mark is '%s' and is within a bounding polygon %s with confidence %.2f.%n",
documentSelectionMark.getState().toString(),
documentSelectionMark.getPolygon(),
documentSelectionMark.getConfidence()));
});
// tables
List < DocumentTable > tables = analyzeLayoutResult.getTables();
for (int i = 0; i < tables.size(); i++) {
DocumentTable documentTable = tables.get(i);
System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
documentTable.getColumnCount());
documentTable.getCells().forEach(documentTableCell -> {
System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
});
System.out.println();
}
// styles
analyzeLayoutResult.getStyles().forEach(documentStyle -
> System.out.printf("Document is handwritten %s.%n", documentStyle.isHandwritten()));
}
}
Compilare ed eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, tornare alla directory principale del progetto, ovvero doc-intel-app.
Compilare l'applicazione con il
build
comando :gradle build
Eseguire l'applicazione con il
run
comando :gradle run
Aggiungere il codice di esempio seguente al FormRecognizer.java
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
import com.azure.ai.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-recognize-app.
Compilare l'applicazione con il
build
comando :gradle build
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.
Aggiungere il codice di esempio seguente al FormRecognizer.java
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
import com.azure.ai.formrecognizer;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;
import com.azure.ai.formrecognizer.documentanalysis.models.AnalyzeResult;
import com.azure.ai.formrecognizer.documentanalysis.models.OperationResult;
import com.azure.ai.formrecognizer.documentanalysis.models.DocumentTable;
import com.azure.ai.formrecognizer.documentanalysis.models.Point;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;
import java.util.List;
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 > analyzeLayoutPoller =
client.beginAnalyzeDocumentFromUrl(modelId, documentUrl);
AnalyzeResult analyzeLayoutResult = analyzeLayoutPoller.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(),
getBoundingCoordinates(documentLine.getBoundingPolygon())));
// 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.getSelectionMarkState().toString(),
getBoundingCoordinates(documentSelectionMark.getBoundingPolygon()),
documentSelectionMark.getConfidence()));
});
// tables
List < DocumentTable > tables = analyzeLayoutResult.getTables();
for (int i = 0; i < tables.size(); i++) {
DocumentTable documentTable = tables.get(i);
System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
documentTable.getColumnCount());
documentTable.getCells().forEach(documentTableCell -> {
System.out.printf("Cell '%s', has row index %d and column index %d.%n", documentTableCell.getContent(),
documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
});
System.out.println();
}
// styles
analyzeLayoutResult.getStyles().forEach(documentStyle -
> System.out.printf("Document is handwritten %s.%n", documentStyle.isHandwritten()));
}
/**
* 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-recognize-app.
Compilare l'applicazione con il
build
comando :gradle build
Eseguire l'applicazione con il
run
comando :gradle run
Modello predefinito
Analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito. In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.
Suggerimento
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze
dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.
- Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È stato aggiunto il valore dell'URL del file alla
invoiceUrl
variabile nella parte superiore del file. - Per analizzare un determinato file in un URI, si userà il
beginAnalyzeDocuments
metodo e si passeràPrebuiltModels.Invoice
come ID modello. Il valore restituito è unresult
oggetto contenente i dati relativi al documento inviato. - Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .
Aggiungere il codice di esempio seguente al DocIntelligence.java
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
import com.azure.ai.documentintelligence;
import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;
import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;
public class DocIntelligence {
// set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
private static final String endpoint = "<your-endpoint>";
private static final String key = "<your-key>";
public static void main(String[] args) {
// sample document
String modelId = "prebuilt-invoice";
String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";
public static void main(final String[] args) throws IOException {
// Instantiate a client that will be used to call the service.
DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
.credential(new AzureKeyCredential(key))
.endpoint(endpoint)
.buildClient();
SyncPoller<AnalyzeResultOperation, AnalyzeResultOperation > analyzeInvoicesPoller =
client.beginAnalyzeDocument(modelId,
null,
null,
null,
null,
null,
null,
new AnalyzeDocumentRequest().setUrlSource(invoiceUrl));
AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult().getAnalyzeResult();
for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
Document analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
System.out.printf("----------- Analyzing invoice %d -----------%n", i);
DocumentField vendorNameField = invoiceFields.get("VendorName");
if (vendorNameField != null) {
if (DocumentFieldType.STRING == vendorNameField.getType()) {
String merchantName = vendorNameField.getValueString();
System.out.printf("Vendor Name: %s, confidence: %.2f%n",
merchantName, vendorNameField.getConfidence());
}
}
DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
if (vendorAddressField != null) {
if (DocumentFieldType.STRING == vendorAddressField.getType()) {
String merchantAddress = vendorAddressField.getValueString();
System.out.printf("Vendor address: %s, confidence: %.2f%n",
merchantAddress, vendorAddressField.getConfidence());
}
}
DocumentField customerNameField = invoiceFields.get("CustomerName");
if (customerNameField != null) {
if (DocumentFieldType.STRING == customerNameField.getType()) {
String merchantAddress = customerNameField.getValueString();
System.out.printf("Customer Name: %s, confidence: %.2f%n",
merchantAddress, customerNameField.getConfidence());
}
}
DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
if (customerAddressRecipientField != null) {
if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
String customerAddr = customerAddressRecipientField.getValueString();
System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
customerAddr, customerAddressRecipientField.getConfidence());
}
}
DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
if (invoiceIdField != null) {
if (DocumentFieldType.STRING == invoiceIdField.getType()) {
String invoiceId = invoiceIdField.getValueString();
System.out.printf("Invoice ID: %s, confidence: %.2f%n",
invoiceId, invoiceIdField.getConfidence());
}
}
DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
if (customerNameField != null) {
if (DocumentFieldType.DATE == invoiceDateField.getType()) {
LocalDate invoiceDate = invoiceDateField.getValueDate();
System.out.printf("Invoice Date: %s, confidence: %.2f%n",
invoiceDate, invoiceDateField.getConfidence());
}
}
DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
if (customerAddressRecipientField != null) {
if (DocumentFieldType.NUMBER == invoiceTotalField.getType()) {
Double invoiceTotal = invoiceTotalField.getValueNumber();
System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
invoiceTotal, invoiceTotalField.getConfidence());
}
}
DocumentField invoiceItemsField = invoiceFields.get("Items");
if (invoiceItemsField != null) {
System.out.printf("Invoice Items: %n");
if (DocumentFieldType.ARRAY == invoiceItemsField.getType()) {
List < DocumentField > invoiceItems = invoiceItemsField.getValueArray();
invoiceItems.stream()
.filter(invoiceItem -> DocumentFieldType.OBJECT == invoiceItem.getType())
.map(documentField -> documentField.getValueObject())
.forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
// See a full list of fields found on an invoice here:
// https://aka.ms/documentintelligence/invoicefields
if ("Description".equals(key)) {
if (DocumentFieldType.STRING == documentField.getType()) {
String name = documentField.getValueString();
System.out.printf("Description: %s, confidence: %.2fs%n",
name, documentField.getConfidence());
}
}
if ("Quantity".equals(key)) {
if (DocumentFieldType.NUMBER == documentField.getType()) {
Double quantity = documentField.getValueNumber();
System.out.printf("Quantity: %f, confidence: %.2f%n",
quantity, documentField.getConfidence());
}
}
if ("UnitPrice".equals(key)) {
if (DocumentFieldType.NUMBER == documentField.getType()) {
Double unitPrice = documentField.getValueNumber();
System.out.printf("Unit Price: %f, confidence: %.2f%n",
unitPrice, documentField.getConfidence());
}
}
if ("ProductCode".equals(key)) {
if (DocumentFieldType.NUMBER == documentField.getType()) {
Double productCode = documentField.getValueNumber();
System.out.printf("Product Code: %f, confidence: %.2f%n",
productCode, documentField.getConfidence());
}
}
}));
}
}
}
}
}
}
Compilare ed eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, tornare alla directory principale del progetto, ovvero doc-intel-app.
Compilare l'applicazione con il
build
comando :gradle build
Eseguire l'applicazione con il
run
comando :gradle run
Aggiungere il codice di esempio seguente al FormRecognizer.java
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
import com.azure.ai.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 < OperationResult, AnalyzeResult > analyzeInvoicePoller = client.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);
AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.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 doc-intel-app.
Compilare l'applicazione con il
build
comando :gradle build
Eseguire l'applicazione con il
run
comando :gradle run
Output predefinito del modello
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.
Aggiungere il codice di esempio seguente al FormRecognizer.java
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
import com.azure.ai.formrecognizer;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;
import com.azure.ai.formrecognizer.documentanalysis.models.AnalyzeResult;
import com.azure.ai.formrecognizer.documentanalysis.models.AnalyzedDocument;
import com.azure.ai.formrecognizer.documentanalysis.models.DocumentField;
import com.azure.ai.formrecognizer.documentanalysis.models.DocumentFieldType;
import com.azure.ai.formrecognizer.documentanalysis.models.OperationResult;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;
import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;
public class 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 modelId = "prebuilt-invoice";
String invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";
SyncPoller < OperationResult, AnalyzeResult > analyzeInvoicePoller = client.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);
AnalyzeResult analyzeInvoiceResult = analyzeInvoicePoller.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 doc-intel-app.
Compilare l'applicazione con il
build
comando :gradle build
Eseguire l'applicazione con il
run
comando :gradle run
Pacchetto di riferimento | dell'API REST della libreria | client (npm)Esempi versione dell'API | | REST supportata
| | Api REST reference | Package (npm)Samples Supported REST API version (npm) | Samples |Supported REST API version
| | Api REST reference | Package (npm)Samples Supported REST API version (npm) | Samples |Supported REST API version
In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:
Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione, ad esempio pulsanti di opzione e caselle di controllo nei documenti, senza la necessità di eseguire il training di un modello.
Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello di fattura con training preliminare.
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
Versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedereNode.js in Visual Studio Code.
Versione più recente
LTS
di Node.js.Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
Creare una nuova applicazione Node.js Express: in una finestra della console (ad esempio cmd, PowerShell o Bash) creare e passare a una nuova directory per l'app denominata
doc-intel-app
.mkdir doc-intel-app && cd doc-intel-app
Eseguire il
npm init
comando per inizializzare l'applicazione e eseguire lo scaffolding del progetto.npm init
Specificare gli attributi del progetto usando le richieste presentate nel terminale.
- Gli attributi più importanti sono nome, numero di versione e punto di ingresso.
- È consigliabile mantenere
index.js
il nome del punto di ingresso. La descrizione, il comando di test, il repository GitHub, le parole chiave, l'autore e le informazioni sulla licenza sono attributi facoltativi, ma possono essere ignorati per questo progetto. - Accettare i suggerimenti tra parentesi selezionando Invio o Invio.
- Dopo aver completato le richieste, nella directory doc-intel-app verrà creato un
package.json
file.
Installare la
ai-document-intelligence
libreria client eazure/identity
i pacchetti npm:npm i @azure-rest/ai-document-intelligence@1.0.0-beta.2 @azure/identity
Il file
package.json
dell'app viene aggiornato con le dipendenze.
Installare la
ai-form-recognizer
libreria client eazure/identity
i pacchetti npm:npm i @azure/ai-form-recognizer@5.0.0 @azure/identity
- Il file
package.json
dell'app viene aggiornato con le dipendenze.
- Il file
Installare la
ai-form-recognizer
libreria client eazure/identity
i pacchetti npm:npm i @azure/ai-form-recognizer@4.0.0 @azure/identity
Creare un file denominato
index.js
nella directory dell'applicazione.Suggerimento
- È possibile creare un nuovo file usando PowerShell.
- Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.
- Digitare il comando seguente index.js New-Item.
Compilare l'applicazione
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con l'oggetto dal key
portale di Azure e un'istanza DocumentIntelligenceClient
AzureKeyCredential
con e document intelligence endpoint
.
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentAnalysisClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con il portale di Azure key
e un'istanza DocumentAnalysisClient
AzureKeyCredential
con e il Riconoscimento modulo endpoint
.
Aprire il
index.js
file in Visual Studio Code o nell'IDE preferito. Copiare e incollare uno degli esempi di codice seguenti nell'applicazione:
Importante
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Modello di layout
Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.
- Per questo esempio, è necessario un file di documento da un URL. È possibile usare il documento di esempio per questa guida introduttiva.
- È stato aggiunto il valore dell'URL del file alla
formUrl
variabile nella parte superiore del file.- Per analizzare un determinato file da un URL, si userà il
beginAnalyzeDocuments
metodo e si passeràprebuilt-layout
come ID modello.
const DocumentIntelligenceClient = require("@azure-rest/ai-document-intelligence");
// set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
const key = "<your-key";
const endpoint = "<your-endpoint>";
// sample document
const formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"
async function main() {
const client = DocumentIntelligenceClient(endpoint, {key:key},);
const initialResponse = await client
.path("/documentModels/{modelId}:analyze", "prebuilt-layout")
.post({
contentType: "application/json",
body: {
urlSource: formUrl
},
});
const poller = await getLongRunningPoller(client, initialResponse);
const analyzeResult = (await poller.pollUntilDone()).body.analyzeResult;
const documents = analyzeResult?.documents;
const document = documents && documents[0];
if (!document) {
throw new Error("Expected at least one document in the result.");
}
console.log(
"Extracted document:",
document.docType,
`(confidence: ${document.confidence || "<undefined>"})`,
);
console.log("Fields:", document.fields);
}
main().catch((error) => {
console.error("An error occurred:", error);
process.exit(1);
});
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, eseguire il programma:
Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).
Digitare il comando seguente nel terminale:
node index.js
Aggiungere il codice di esempio seguente al index.js
file. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
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", formUrl);
const {
pages,
tables
} = await poller.pollUntilDone();
if (pages.length <= 0) {
console.log("No pages were extracted from the document.");
} else {
console.log("Pages:");
for (const page of pages) {
console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
console.log(` ${page.width}x${page.height}, angle: ${page.angle}`);
console.log(` ${page.lines.length} lines, ${page.words.length} words`);
}
}
if (tables.length <= 0) {
console.log("No tables were extracted from the document.");
} else {
console.log("Tables:");
for (const table of tables) {
console.log(
`- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
);
}
}
}
main().catch((error) => {
console.error("An error occurred:", error);
process.exit(1);
});
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, eseguire il programma:
Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).
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 viene analizzata una fattura usando il modello di fattura predefinita.
Suggerimento
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze
dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.
- Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È stato aggiunto il valore dell'URL del file alla
invoiceUrl
variabile nella parte superiore del file. - Per analizzare un determinato file in un URI, si userà il
beginAnalyzeDocuments
metodo e si passeràPrebuiltModels.Invoice
come ID modello. Il valore restituito è unresult
oggetto contenente i dati relativi al documento inviato. - Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .
const DocumentIntelligenceClient = require("@azure-rest/ai-document-intelligence");
// set `<your-key>` and `<your-endpoint>` variables with the values from the Azure portal.
const key = "<your-key>";
const endpoint = "<your-endpoint>";
// sample document
invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"
async function main() {
const client = DocumentIntelligenceClient(endpoint, {key: key},
);
const initialResponse = await client
.path("/documentModels/{modelId}:analyze", "prebuilt-invoice")
.post({
contentType: "application/json",
body: {
// The Document Intelligence service will access the URL to the invoice image and extract data from it
urlSource: invoiceUrl,
},
});
const poller = await getLongRunningPoller(client, initialResponse);
poller.onProgress((state) => console.log("Operation:", state.result, state.status));
const analyzeResult = (await poller.pollUntilDone()).body.analyzeResult;
const documents = analyzeResult?.documents;
const result = documents && documents[0];
if (result) {
console.log(result.fields);
} else {
throw new Error("Expected at least one invoice in the result.");
}
console.log(
"Extracted invoice:",
document.docType,
`(confidence: ${document.confidence || "<undefined>"})`,
);
console.log("Fields:", document.fields);
}
main().catch((error) => {
console.error("An error occurred:", error);
process.exit(1);
});
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, eseguire il programma:
Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).
Digitare il comando seguente nel terminale:
node index.js
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
invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"
async function main() {
const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));
const poller = await client.beginAnalyzeDocumentFromUrl("prebuilt-invoice", invoiceUrl);
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 (page.lines && page.lines.length > 0) {
console.log(" Lines:");
for (const line of page.lines) {
console.log(` - "${line.content}"`);
// The words of the line can also be iterated independently. The words are computed based on their
// corresponding spans.
for (const word of line.words()) {
console.log(` - "${word.content}"`);
}
}
}
}
}
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:
Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).
Digitare il comando seguente nel terminale:
node index.js
Output predefinito del modello
Ecco un frammento di output previsto:
Vendor Name: CONTOSO LTD.
Customer Name: MICROSOFT CORPORATION
Invoice Date: 2019-11-15T00:00:00.000Z
Due Date: 2019-12-15T00:00:00.000Z
Items:
- <no product code>
Description: Test for 23 fields
Quantity: 1
Date: undefined
Unit: undefined
Unit Price: 1
Tax: undefined
Amount: 100
Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output predefinito del modello di fattura.
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
invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"
async function main() {
const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));
const poller = await client.beginAnalyzeDocument("prebuilt-invoice", invoiceUrl);
const {
documents: [document],
} = await poller.pollUntilDone();
if (document) {
const {
vendorName,
customerName,
invoiceDate,
dueDate,
items,
subTotal,
previousUnpaidBalance,
totalTax,
amountDue,
} = document.fields;
// The invoice model has many fields. For details, *see* [Invoice model field extraction](../../concept-invoice.md#field-extraction)
console.log("Vendor Name:", vendorName && vendorName.value);
console.log("Customer Name:", customerName && customerName.value);
console.log("Invoice Date:", invoiceDate && invoiceDate.value);
console.log("Due Date:", dueDate && dueDate.value);
console.log("Items:");
for (const item of (items && items.values) || []) {
const { productCode, description, quantity, date, unit, unitPrice, tax, amount } =
item.properties;
console.log("-", (productCode && productCode.value) || "<no product code>");
console.log(" Description:", description && description.value);
console.log(" Quantity:", quantity && quantity.value);
console.log(" Date:", date && date.value);
console.log(" Unit:", unit && unit.value);
console.log(" Unit Price:", unitPrice && unitPrice.value);
console.log(" Tax:", tax && tax.value);
console.log(" Amount:", amount && amount.value);
}
console.log("Subtotal:", subTotal && subTotal.value);
console.log("Previous Unpaid Balance:", previousUnpaidBalance && previousUnpaidBalance.value);
console.log("Tax:", totalTax && totalTax.value);
console.log("Amount Due:", amountDue && amountDue.value);
} else {
throw new Error("Expected at least one receipt in the result.");
}
}
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:
Passare alla cartella in cui si dispone dell'applicazione Document Intelligence (doc-intel-app).
Digitare il comando seguente nel terminale:
node index.js
Versione dell'API REST di riferimento | | dell'SDK della libreria |client (PyPi)Samples Supported REST API version (Versione dell'API | | REST supportata)
Versione dell'API REST di riferimento | | dell'SDK della libreria |client (PyPi)Samples Supported REST API version (Versione dell'API | | REST supportata)
Versione dell'API REST di riferimento | | dell'SDK della libreria | client (PyPi)Samples Supported REST API version (Versione dell'API | | REST supportata)
In questa guida introduttiva usare le funzionalità seguenti per analizzare ed estrarre dati da moduli e documenti:
Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione come pulsanti di opzione e caselle di controllo e coppie chiave-valore, senza dover eseguire il training di un modello.
Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello con training preliminare.
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
Python 3.7 o versione successiva.
- L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo
pip --version
nella riga di comando. Ottenere pip installando la versione più recente di Python.
- L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo
Versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedereIntroduzione a Python in Visual Studio Code.
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
Aprire una finestra del terminale nell'ambiente locale e installare la libreria client di Intelligence per intelligenza artificiale di Azure per Python con pip:
pip install azure-ai-documentintelligence==1.0.0b2
pip install azure-ai-formrecognizer==3.3.0
pip install azure-ai-formrecognizer==3.2.0b6
Creare l'applicazione Python
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentIntelligenceClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con l'oggetto dal key
portale di Azure e un'istanza DocumentIntelligenceClient
AzureKeyCredential
con e document intelligence endpoint
.
Creare un nuovo file Python denominato doc_intel_quickstart.py nell'editor o nell'IDE preferito.
Aprire il file doc_intel_quickstart.py e selezionare uno degli esempi di codice seguenti per copiare e incollare nell'applicazione:
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della DocumentAnalysisClient
classe . A tale scopo, si crea un AzureKeyCredential
oggetto con l'oggetto dal key
portale di Azure e un'istanza DocumentAnalysisClient
AzureKeyCredential
con e document intelligence endpoint
.
Creare un nuovo file Python denominato form_recognizer_quickstart.py nell'editor o nell'IDE preferito.
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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Modello di layout
Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.
- Per questo esempio, è necessario un file di documento da un URL. È possibile usare il documento di esempio per questa guida introduttiva.
- È stato aggiunto il valore dell'URL del file alla
formUrl
variabile nellaanalyze_layout
funzione . - Per analizzare un determinato file in corrispondenza di un URL, si userà il
begin_analyze_document_from_url
metodo e si passeràprebuilt-layout
come ID modello. Il valore restituito è unresult
oggetto contenente i dati relativi al documento inviato.
Aggiungere l'esempio di codice seguente all'applicazione doc_intel_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest
# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"
# helper functions
def get_words(page, line):
result = []
for word in page.words:
if _in_span(word, line.spans):
result.append(word)
return result
def _in_span(word, spans):
for span in spans:
if word.span.offset >= span.offset and (
word.span.offset + word.span.length
) <= (span.offset + span.length):
return True
return False
def analyze_layout():
# sample document
formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf"
document_intelligence_client = DocumentIntelligenceClient(
endpoint=endpoint, credential=AzureKeyCredential(key)
)
poller = document_intelligence_client.begin_analyze_document(
"prebuilt-layout", AnalyzeDocumentRequest(url_source=formUrl
))
result: AnalyzeResult = poller.result()
if result.styles and any([style.is_handwritten for style in result.styles]):
print("Document contains handwritten content")
else:
print("Document does not contain handwritten content")
for page in result.pages:
print(f"----Analyzing layout from page #{page.page_number}----")
print(
f"Page has width: {page.width} and height: {page.height}, measured with unit: {page.unit}"
)
if page.lines:
for line_idx, line in enumerate(page.lines):
words = get_words(page, line)
print(
f"...Line # {line_idx} has word count {len(words)} and text '{line.content}' "
f"within bounding polygon '{line.polygon}'"
)
for word in words:
print(
f"......Word '{word.content}' has a confidence of {word.confidence}"
)
if page.selection_marks:
for selection_mark in page.selection_marks:
print(
f"Selection mark is '{selection_mark.state}' within bounding polygon "
f"'{selection_mark.polygon}' and has a confidence of {selection_mark.confidence}"
)
if result.tables:
for table_idx, table in enumerate(result.tables):
print(
f"Table # {table_idx} has {table.row_count} rows and "
f"{table.column_count} columns"
)
if table.bounding_regions:
for region in table.bounding_regions:
print(
f"Table # {table_idx} location on page: {region.page_number} is {region.polygon}"
)
for cell in table.cells:
print(
f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'"
)
if cell.bounding_regions:
for region in cell.bounding_regions:
print(
f"...content on page {region.page_number} is within bounding polygon '{region.polygon}'"
)
print("----------------------------------------")
if __name__ == "__main__":
analyze_layout()
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, compilare ed eseguire il programma:
Passare alla cartella in cui si dispone del file doc_intel_quickstart.py .
Digitare il comando seguente nel terminale:
python doc_intel_quickstart.py
Aggiungere l'esempio di codice seguente all'applicazione form_recognizer_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:
# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"
def format_polygon(polygon):
if not polygon:
return "N/A"
return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])
def analyze_layout():
# sample 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(
"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:
Passare alla cartella in cui si dispone del file form_recognizer_quickstart.py .
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.
Aggiungere l'esempio di codice seguente all'applicazione form_recognizer_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:
# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"
def analyze_layout():
# sample 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 polygon '{}'".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 polygon '{}' 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 polygon '{}'".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:
Passare alla cartella in cui si dispone del file form_recognizer_quickstart.py .
Digitare il comando seguente nel terminale:
python form_recognizer_quickstart.py
Modello predefinito
Analizzare ed estrarre campi comuni da tipi di documento specifici usando un modello predefinito. In questo esempio viene analizzata una fattura usando il modello di fattura predefinita.
Suggerimento
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione analyze
dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.
- Analizzare una fattura usando il modello di fattura predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È stato aggiunto il valore dell'URL del file alla
invoiceUrl
variabile nella parte superiore del file. - Per analizzare un determinato file in un URI, si userà il
begin_analyze_document_from_url
metodo e si passeràprebuilt-invoice
come ID modello. Il valore restituito è unresult
oggetto contenente i dati relativi al documento inviato. - Per semplicità, tutte le coppie chiave-valore restituite dal servizio non vengono visualizzate qui. Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Concetto di fattura .
Aggiungere l'esempio di codice seguente all'applicazione doc_intel_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Document Intelligence portale di Azure:
# import libraries
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest
# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"
def analyze_invoice():
# sample document
invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf"
document_intelligence_client = DocumentIntelligenceClient(
endpoint=endpoint, credential=AzureKeyCredential(key)
)
poller = document_intelligence_client.begin_analyze_document(
"prebuilt-invoice", AnalyzeDocumentRequest(url_source=invoiceUrl)
)
invoices = poller.result()
if invoices.documents:
for idx, invoice in enumerate(invoices.documents):
print(f"--------Analyzing invoice #{idx + 1}--------")
vendor_name = invoice.fields.get("VendorName")
if vendor_name:
print(
f"Vendor Name: {vendor_name.get('content')} has confidence: {vendor_name.get('confidence')}"
)
vendor_address = invoice.fields.get("VendorAddress")
if vendor_address:
print(
f"Vendor Address: {vendor_address.get('content')} has confidence: {vendor_address.get('confidence')}"
)
vendor_address_recipient = invoice.fields.get("VendorAddressRecipient")
if vendor_address_recipient:
print(
f"Vendor Address Recipient: {vendor_address_recipient.get('content')} has confidence: {vendor_address_recipient.get('confidence')}"
)
customer_name = invoice.fields.get("CustomerName")
if customer_name:
print(
f"Customer Name: {customer_name.get('content')} has confidence: {customer_name.get('confidence')}"
)
customer_id = invoice.fields.get("CustomerId")
if customer_id:
print(
f"Customer Id: {customer_id.get('content')} has confidence: {customer_id.get('confidence')}"
)
customer_address = invoice.fields.get("CustomerAddress")
if customer_address:
print(
f"Customer Address: {customer_address.get('content')} has confidence: {customer_address.get('confidence')}"
)
customer_address_recipient = invoice.fields.get("CustomerAddressRecipient")
if customer_address_recipient:
print(
f"Customer Address Recipient: {customer_address_recipient.get('content')} has confidence: {customer_address_recipient.get('confidence')}"
)
invoice_id = invoice.fields.get("InvoiceId")
if invoice_id:
print(
f"Invoice Id: {invoice_id.get('content')} has confidence: {invoice_id.get('confidence')}"
)
invoice_date = invoice.fields.get("InvoiceDate")
if invoice_date:
print(
f"Invoice Date: {invoice_date.get('content')} has confidence: {invoice_date.get('confidence')}"
)
invoice_total = invoice.fields.get("InvoiceTotal")
if invoice_total:
print(
f"Invoice Total: {invoice_total.get('content')} has confidence: {invoice_total.get('confidence')}"
)
due_date = invoice.fields.get("DueDate")
if due_date:
print(
f"Due Date: {due_date.get('content')} has confidence: {due_date.get('confidence')}"
)
purchase_order = invoice.fields.get("PurchaseOrder")
if purchase_order:
print(
f"Purchase Order: {purchase_order.get('content')} has confidence: {purchase_order.get('confidence')}"
)
billing_address = invoice.fields.get("BillingAddress")
if billing_address:
print(
f"Billing Address: {billing_address.get('content')} has confidence: {billing_address.get('confidence')}"
)
billing_address_recipient = invoice.fields.get("BillingAddressRecipient")
if billing_address_recipient:
print(
f"Billing Address Recipient: {billing_address_recipient.get('content')} has confidence: {billing_address_recipient.get('confidence')}"
)
shipping_address = invoice.fields.get("ShippingAddress")
if shipping_address:
print(
f"Shipping Address: {shipping_address.get('content')} has confidence: {shipping_address.get('confidence')}"
)
shipping_address_recipient = invoice.fields.get("ShippingAddressRecipient")
if shipping_address_recipient:
print(
f"Shipping Address Recipient: {shipping_address_recipient.get('content')} has confidence: {shipping_address_recipient.get('confidence')}"
)
print("Invoice items:")
for idx, item in enumerate(invoice.fields.get("Items").get("valueArray")):
print(f"...Item #{idx + 1}")
item_description = item.get("valueObject").get("Description")
if item_description:
print(
f"......Description: {item_description.get('content')} has confidence: {item_description.get('confidence')}"
)
item_quantity = item.get("valueObject").get("Quantity")
if item_quantity:
print(
f"......Quantity: {item_quantity.get('content')} has confidence: {item_quantity.get('confidence')}"
)
unit = item.get("valueObject").get("Unit")
if unit:
print(
f"......Unit: {unit.get('content')} has confidence: {unit.get('confidence')}"
)
unit_price = item.get("valueObject").get("UnitPrice")
if unit_price:
unit_price_code = (
unit_price.get("valueCurrency").get("currencyCode")
if unit_price.get("valueCurrency").get("currencyCode")
else ""
)
print(
f"......Unit Price: {unit_price.get('content')}{unit_price_code} has confidence: {unit_price.get('confidence')}"
)
product_code = item.get("valueObject").get("ProductCode")
if product_code:
print(
f"......Product Code: {product_code.get('content')} has confidence: {product_code.get('confidence')}"
)
item_date = item.get("valueObject").get("Date")
if item_date:
print(
f"......Date: {item_date.get('content')} has confidence: {item_date.get('confidence')}"
)
tax = item.get("valueObject").get("Tax")
if tax:
print(
f"......Tax: {tax.get('content')} has confidence: {tax.get('confidence')}"
)
amount = item.get("valueObject").get("Amount")
if amount:
print(
f"......Amount: {amount.get('content')} has confidence: {amount.get('confidence')}"
)
subtotal = invoice.fields.get("SubTotal")
if subtotal:
print(
f"Subtotal: {subtotal.get('content')} has confidence: {subtotal.get('confidence')}"
)
total_tax = invoice.fields.get("TotalTax")
if total_tax:
print(
f"Total Tax: {total_tax.get('content')} has confidence: {total_tax.get('confidence')}"
)
previous_unpaid_balance = invoice.fields.get("PreviousUnpaidBalance")
if previous_unpaid_balance:
print(
f"Previous Unpaid Balance: {previous_unpaid_balance.get('content')} has confidence: {previous_unpaid_balance.get('confidence')}"
)
amount_due = invoice.fields.get("AmountDue")
if amount_due:
print(
f"Amount Due: {amount_due.get('content')} has confidence: {amount_due.get('confidence')}"
)
service_start_date = invoice.fields.get("ServiceStartDate")
if service_start_date:
print(
f"Service Start Date: {service_start_date.get('content')} has confidence: {service_start_date.get('confidence')}"
)
service_end_date = invoice.fields.get("ServiceEndDate")
if service_end_date:
print(
f"Service End Date: {service_end_date.get('content')} has confidence: {service_end_date.get('confidence')}"
)
service_address = invoice.fields.get("ServiceAddress")
if service_address:
print(
f"Service Address: {service_address.get('content')} has confidence: {service_address.get('confidence')}"
)
service_address_recipient = invoice.fields.get("ServiceAddressRecipient")
if service_address_recipient:
print(
f"Service Address Recipient: {service_address_recipient.get('content')} has confidence: {service_address_recipient.get('confidence')}"
)
remittance_address = invoice.fields.get("RemittanceAddress")
if remittance_address:
print(
f"Remittance Address: {remittance_address.get('content')} has confidence: {remittance_address.get('confidence')}"
)
remittance_address_recipient = invoice.fields.get(
"RemittanceAddressRecipient"
)
if remittance_address_recipient:
print(
f"Remittance Address Recipient: {remittance_address_recipient.get('content')} has confidence: {remittance_address_recipient.get('confidence')}"
)
print("----------------------------------------")
if __name__ == "__main__":
analyze_invoice()
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, compilare ed eseguire il programma:
Passare alla cartella in cui si dispone del file doc_intel_quickstart.py .
Digitare il comando seguente nel terminale:
python doc_intel_quickstart.py
Aggiungere l'esempio di codice seguente all'applicazione form_recognizer_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:
# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"
def format_bounding_region(bounding_regions):
if not bounding_regions:
return "N/A"
return ", ".join(
"Page #{}: {}".format(region.page_number, format_polygon(region.polygon))
for region in bounding_regions
)
def format_polygon(polygon):
if not polygon:
return "N/A"
return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])
def analyze_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,
)
)
print("----------------------------------------")
if __name__ == "__main__":
analyze_invoice()
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, compilare ed eseguire il programma:
Passare alla cartella in cui si dispone del file form_recognizer_quickstart.py .
Digitare il comando seguente nel terminale:
python form_recognizer_quickstart.py
Output predefinito del modello
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 predefinito del modello di fattura.
Aggiungere l'esempio di codice seguente all'applicazione form_recognizer_quickstart.py. Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di portale di Azure Riconoscimento modulo:
# import libraries
import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential
# set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
endpoint = "<your-endpoint>"
key = "<your-key>"
def format_polygon(polygon):
if not polygon:
return "N/A"
return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])
def analyze_layout():
# sample 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 polygon '{}'".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 polygon '{}' 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 polygon '{}'".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:
Passare alla cartella in cui si dispone del file form_recognizer_quickstart.py .
Digitare il comando seguente nel terminale:
python form_recognizer_quickstart.py
In questa guida introduttiva si apprenderà come usare l'API REST di Document Intelligence per analizzare ed estrarre dati e valori dai documenti:
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito
Strumento da riga di comando curl installato.
PowerShell versione 7.*+ (o un'applicazione della 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
- Windows:
Una risorsa document intelligence (a servizio singolo) o servizi di intelligenza artificiale di Azure (multiservizio). Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio, nella portale di Azure, per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.
Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Analizzare i documenti e ottenere risultati
Una richiesta POST viene usata per analizzare i documenti con un modello predefinito o personalizzato. Una richiesta GET viene usata per recuperare il risultato di una chiamata di analisi dei documenti. Viene modelId
usato con POST e resultId
con le operazioni GET.
Analizzare il documento (richiesta POST)
Prima di eseguire il comando cURL, apportare le modifiche seguenti alla richiesta post:
Sostituire
{endpoint}
con il valore dell'endpoint dell'istanza di Document Intelligence portale di Azure.Sostituire
{key}
con il valore della chiave dell'istanza di Document Intelligence portale di Azure.Usando la tabella seguente come riferimento, sostituire
{modelID}
e{your-document-url}
con i valori desiderati.È necessario un file di documento in un URL. Per questa guida introduttiva, è possibile usare i moduli di esempio forniti nella tabella seguente per ogni funzionalità:
Documenti di esempio
Funzionalità | {modelID} | {your-document-url} |
---|---|---|
Lettura | precompilt-read | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png |
Layout | precompilt-layout | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png |
Scheda assicurazione sanitaria | prebuilt-healthInsuranceCard.us | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png |
W-2 | prebuilt-tax.us.w2 | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png |
Fattura | fattura predefinita | https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf |
Ricevuta | ricevuta predefinita | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png |
Documento di identità | prebuilt-idDocument | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png |
Documenti di esempio
Funzionalità | {modelID} | {your-document-url} |
---|---|---|
Documento generale | precompilt-document | 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 | precompilt-layout | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png |
Scheda assicurazione sanitaria | prebuilt-healthInsuranceCard.us | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/insurance-card.png |
W-2 | prebuilt-tax.us.w2 | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png |
Fattura | fattura predefinita | https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf |
Ricevuta | ricevuta predefinita | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png |
Documento di identità | prebuilt-idDocument | https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png |
Tessera business | precompilt-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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Richiesta POST
curl -v -i POST "{endpoint}/documentintelligence/documentModels/{modelId}:analyze?api-version=2024-02-29-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"
curl -v -i POST "{endpoint}/formrecognizer/documentModels/{modelID}:analyze?api-version=2023-07-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {key}" --data-ascii "{'urlSource': '{your-document-url}'}"
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 (resultID)
Si riceve una 202 (Success)
risposta che include un'intestazione Operation-Location di sola lettura. Il valore di questa intestazione contiene un oggetto resultID
su cui è possibile eseguire una query per ottenere lo stato dell'operazione asincrona e recuperare i risultati usando una richiesta GET con la stessa chiave di sottoscrizione della risorsa:
Ottenere i risultati dell'analisi (richiesta GET)
Dopo aver chiamato l'API, chiamare l'API Analyze document
Get analyze result per ottenere lo stato dell'operazione e i dati estratti. Prima di eseguire il comando, apportare queste modifiche:
Dopo aver chiamato l'API, chiamare l'API Analyze document
Get analyze result per ottenere lo stato dell'operazione e i dati estratti. Prima di eseguire il comando, apportare queste modifiche:
Dopo aver chiamato l'API, chiamare l'API Analyze document
Get analyze result per ottenere lo stato dell'operazione e i dati estratti. Prima di eseguire il comando, apportare queste modifiche:
Sostituire
{resultID}
l'intestazione Operation-Location dalla risposta POST.Sostituire
{key}
con il valore della chiave dell'istanza di Document Intelligence nel portale di Azure.
Richiesta GET
curl -v -X GET "{endpoint}/documentintelligence/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2024-02-29-preview" -H "Ocp-Apim-Subscription-Key: {key}"
curl -v -X GET "{endpoint}/formrecognizer/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2023-07-31" -H "Ocp-Apim-Subscription-Key: {key}"
curl -v -X GET "{endpoint}/formrecognizer/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2022-08-31" -H "Ocp-Apim-Subscription-Key: {key}"
Esaminare i risultati
Si riceve una 200 (Success)
risposta con output JSON. Il primo campo, "status"
, indica lo stato dell'operazione. Se l'operazione non è completa, il valore di "status"
è "running"
o "notStarted"
ed è necessario chiamare di nuovo l'API, manualmente o tramite uno script. Si consiglia di attendere almeno un secondo tra le chiamate.
Risposta di esempio per la fattura predefinita
{
"status": "succeeded",
"createdDateTime": "2024-03-25T19:31:37Z",
"lastUpdatedDateTime": "2024-03-25T19:31:43Z",
"analyzeResult": {
"apiVersion": "2024-02-29-preview",
"modelId": "prebuilt-invoice",
"stringIndexType": "textElements"...
..."pages": [
{
"pageNumber": 1,
"angle": 0,
"width": 8.5,
"height": 11,
"unit": "inch",
"words": [
{
"content": "CONTOSO",
"boundingBox": [
0.5911,
0.6857,
1.7451,
0.6857,
1.7451,
0.8664,
0.5911,
0.8664
],
"confidence": 1,
"span": {
"offset": 0,
"length": 7
}
}],
}]
}
}
{
"status": "succeeded",
"createdDateTime": "2023-08-25T19:31:37Z",
"lastUpdatedDateTime": "2023-08-25T19:31:43Z",
"analyzeResult": {
"apiVersion": "2023-07-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
}
}],
}]
}
}
{
"status": "succeeded",
"createdDateTime": "2022-09-25T19:31:37Z",
"lastUpdatedDateTime": "2022-09-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 documento supportati
I modelli predefiniti estraggono set predefiniti di campi documento. Vedere Estrazione dei dati del modello per i nomi, i tipi, le descrizioni e gli esempi di campi estratti.
Questo è, congratulazioni!
In questo argomento di avvio rapido è stato usato un modello di Intelligence per i documenti per analizzare vari moduli e documenti. Esplorare quindi la documentazione di Document Intelligence Studio e la documentazione di riferimento per ottenere informazioni approfondite sull'API di Intelligence sui documenti.
Passaggi successivi
Per un'esperienza avanzata e una qualità avanzata del modello, provare Document Intelligence Studio
Per la migrazione dalla versione 3.1 alla versione 4.0, vedere Guide alla migrazione del log delle modifiche.
Questo contenuto si applica a:v2.1 | Versione più recente:v4.0 (anteprima)
Introduzione ad Azure AI Document Intelligence usando il linguaggio di programmazione preferito o l'API REST. Document Intelligence è un servizio di intelligenza artificiale di Azure basato sul cloud che usa l'apprendimento automatico per estrarre coppie chiave-valore, testo e tabelle dai documenti. È 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 Document Intelligence e sulle opzioni di sviluppo, visitare la pagina Panoramica .
Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (NuGet) | Esempi
In questa guida introduttiva si usano 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.
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio nella portale di Azure per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
Avviare Visual Studio 2019.
Nella pagina iniziale scegliere Crea un nuovo progetto.
Nella pagina Crea un nuovo progetto immettere console nella casella di ricerca. Scegliere il modello Applicazione console, quindi scegliere Avanti.
Nella finestra di dialogo Configura il nuovo progetto immettere
formRecognizer_quickstart
nella casella Nome progetto. Scegliere quindi Avanti.Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 5.0 (Corrente) e quindi selezionare Crea.
Installare la libreria client con NuGet
Fare clic con il pulsante destro del mouse sul progetto formRecognizer_quickstart e scegliere Gestisci pacchetti NuGet... .
Selezionare la scheda Sfoglia e digitare Azure.AI.FormRecognizer.
Selezionare la versione 3.1.1 dal menu a discesa e selezionare Installa.
Compilare l'applicazione
Per interagire con il servizio Document Intelligence, è necessario creare un'istanza della FormRecognizerClient
classe . A tale scopo, creare un oggetto AzureKeyCredential
con la chiave e un'istanza FormRecognizerClient
AzureKeyCredential
con e Document Intelligence endpoint
.
Nota
- A partire da .NET 6, i nuovi progetti che usano il
console
modello generano un nuovo stile di programma diverso dalle versioni precedenti. - Il nuovo output usa le funzionalità C# recenti che semplificano il codice da scrivere.
- Quando si usa la versione più recente, è sufficiente scrivere il corpo del metodo
Main
. Non è necessario includere istruzioni di primo livello, direttive using globali o direttive using implicite. - Per altre informazioni, vedereNuovi modelli C# generano istruzioni di primo livello.
Aprire il file Program.cs.
Includere le direttive using seguenti:
using Azure;
using Azure.AI.FormRecognizer;
using Azure.AI.FormRecognizer.Models;
using System.Threading.Tasks;
- Impostare le
endpoint
variabili di ambiente ekey
e creare l'istanzaAzureKeyCredential
eFormRecognizerClient
:
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);
Eliminare la riga ,
Console.Writeline("Hello World!");
e aggiungere uno degli esempi di codice Try It al file Program.cs :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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere l'articolo sulla sicurezza dei servizi di intelligenza artificiale di Azure.
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 in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- È stato aggiunto il valore dell'URI del file alla
formUri
variabile. - Per estrarre il layout da un determinato file in un URI, usare il
StartRecognizeContentFromUriAsync
metodo .
Aggiungere il codice seguente al file di 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}'.");
}
}
}
}
}
}
Prova: modello predefinito
Questo esempio illustra come analizzare i dati da determinati tipi di documenti comuni con modelli con training preliminare, usando una fattura come esempio.
- Per questo esempio, si analizza un documento di fattura usando un modello predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È 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 i tipi corrispondenti, vedere la pagina Concetto di fattura .
Scegliere un modello predefinito
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Document Intelligence:
- Fattura: estrae testo, segni di selezione, tabelle, campi e informazioni chiave dalle fatture.
- Ricevuta: estrae testo e informazioni chiave dalle ricevute.
- Documento ID: estrae testo e informazioni sulla chiave dalle patenti di guida e dai passaporti internazionali.
- Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.
Aggiungere il codice seguente all'applicazione fattura predefinita Program.cs metodo di file
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.
Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (Maven) | Esempi
In questa guida introduttiva si usano le API seguenti per estrarre dati strutturati da moduli e documenti:
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
Java Development Kit (JDK) versione 8 o successiva. Per altre informazioni, vedereVersioni java supportate e pianificazione degli aggiornamenti.
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio nella portale di Azure per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
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
Eseguire il comando
gradle init
dalla directory di lavoro. Questo comando crea file di compilazione essenziali per Gradle, incluso build.gradle.kts, usato in fase di esecuzione per creare e configurare l'applicazione.gradle init --type basic
Quando viene chiesto di scegliere un linguaggio DSL, selezionare Kotlin.
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
Creare la struttura di directory seguente:
Passare alla directory Java e creare un file denominato FormRecognizer.java. Aprirlo nell'editor o nell'IDE preferito e aggiungere le istruzioni e la dichiarazione del import
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 da copiare e incollare nel metodo principale dell'applicazione:
Importante
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
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 in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- 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 Document Intelligence portale di Azure):
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 con training preliminare, usando una fattura come esempio.
- Per questo esempio, si analizza un documento di fattura usando un modello predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- 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 i tipi corrispondenti, vedere la pagina Concetto di fattura .
Scegliere un modello predefinito
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Document Intelligence:
- Fattura: estrae testo, segni di selezione, tabelle, campi e informazioni chiave dalle fatture.
- Ricevuta: estrae testo e informazioni chiave dalle ricevute.
- Documento ID: estrae testo e informazioni sulla chiave dalle patenti di guida 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 Document Intelligence portale di Azure):
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.
- Compilare l'applicazione con il
build
comando :
gradle build
- Eseguire l'applicazione con il
run
comando :
gradle run
Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (npm) | Esempi
In questa guida introduttiva si usano le API seguenti per estrarre dati strutturati da moduli e documenti:
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
Versione più recente di Visual Studio Code o dell'IDE preferito.
La versione LTS più recente di Node.js
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio nella portale di Azure per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
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
Eseguire il comando
npm init
per creare un'applicazione Node con un filepackage.json
.npm init
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.Creare un file denominato
index.js
, aprirlo e importare le librerie seguenti:const { FormRecognizerClient, AzureKeyCredential } = require("@azure/ai-form-recognizer");
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";
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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Prova: Modello di layout
- Per questo esempio, è necessario un file di documento in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- È 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 sotto la 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 con training preliminare, usando una fattura come esempio. Per un elenco completo dei campi della fattura, vedere la pagina del concetto predefinito
- Per questo esempio, si analizza un documento di fattura usando un modello predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È 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 i tipi corrispondenti, vedere la pagina Concetto di fattura .
Scegliere un modello predefinito
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Document Intelligence:
- Fattura: estrae testo, segni di selezione, tabelle, campi e informazioni chiave dalle fatture.
- Ricevuta: estrae testo e informazioni chiave dalle ricevute.
- Documento ID: estrae testo e informazioni sulla chiave dalle patenti di guida e dai passaporti internazionali.
- Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.
Aggiungere il codice seguente all'applicazione di 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 usano le API seguenti per estrarre dati strutturati da moduli e documenti:
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito
-
- L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo
pip --version
nella riga di comando. Ottenere pip installando la versione più recente di Python.
- L'installazione di Python deve includere pip. È possibile verificare se pip è installato eseguendo
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio nella portale di Azure per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
Configurazione
Aprire una finestra del terminale nell'ambiente locale e installare la libreria client di Intelligence per intelligenza artificiale di Azure per Python con pip:
pip install azure-ai-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 della risorsa 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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Prova: Modello di layout
- Per questo esempio, è necessario un file di documento in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- È 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 sotto la 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 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 con training preliminare, usando una fattura come esempio. Per un elenco completo dei campi della fattura, vedere la pagina del concetto predefinito
- Per questo esempio, si analizza un documento di fattura usando un modello predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
- È 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 i tipi corrispondenti, vedere la pagina Concetto di fattura .
Scegliere un modello predefinito
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Document Intelligence:
- Fattura: estrae testo, segni di selezione, tabelle, campi e informazioni chiave dalle fatture.
- Ricevuta: estrae testo e informazioni chiave dalle ricevute.
- Documento ID: estrae testo e informazioni sulla chiave dalle patenti di guida e dai passaporti internazionali.
- Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.
Aggiungere il codice seguente all'applicazione di 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
Passare alla cartella in cui si dispone del file form_recognizer_quickstart.py .
Digitare il comando seguente nel terminale:
python form_recognizer_quickstart.py
| Informazioni di riferimento sulle API REST dell'API | REST di Document Intelligence |
In questa guida introduttiva si usano le API seguenti per estrarre dati strutturati da moduli e documenti:
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito
cURL installato.
PowerShell versione 6.0+o un'applicazione della riga di comando simile.
Un servizio di intelligenza artificiale di Azure o una risorsa di Document Intelligence. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Document Intelligence a servizio singolo o multiservizio nella portale di Azure per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0
) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa dei servizi di intelligenza artificiale di Azure se si prevede di accedere a più servizi di intelligenza artificiale di Azure con un singolo endpoint/chiave. Solo per l'accesso a Document Intelligence, creare una risorsa di Document Intelligence. Si noti che è necessaria una risorsa a servizio singolo se si intende usare l'autenticazione Microsoft Entra.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API di Intelligence documenti. La chiave e l'endpoint verranno incollati nel codice più avanti nella guida introduttiva:
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 l'ambiente di produzione, usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault. Per altre informazioni, vedere Sicurezza dei servizi di intelligenza artificiale di Azure.
Prova: Modello di layout
- Per questo esempio, è necessario un file di documento in un URI. È possibile usare il documento di esempio per questa guida introduttiva.
- Sostituire
{endpoint}
con l'endpoint ottenuto con la sottoscrizione di Document Intelligence. - Sostituire
{key}
con la chiave copiata dal passaggio precedente. - Sostituire
\"{your-document-url}
con un URL del documento di esempio:
https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf
Richiedi
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 riceve una 202 (Success)
risposta che include un'intestazione Operation-Location . Il valore di questa intestazione contiene un ID risultato che è possibile usare per eseguire una 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:
- Sostituire
{endpoint}
con l'endpoint ottenuto con la sottoscrizione di Document Intelligence. - Sostituire
{key}
con la chiave copiata dal passaggio precedente. - Sostituire
{resultId}
con l'ID risultato del passaggio precedente.
Richiedi
curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/layout/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"
Esaminare i risultati
Si riceve una 200 (success)
risposta con 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 èselected
ounselected
. - La
"pageResults"
sezione include le tabelle estratte. Per ogni tabella, vengono estratti il testo, la riga e l'indice di colonna, la riga e la colonna che si estende, il rettangolo delimitatore e altro ancora.
Corpo della risposta
È possibile visualizzare l'output completo dell'esempio in GitHub.
Prova: modello predefinito
- Per questo esempio, si analizza un documento di fattura usando un modello predefinito. Per questa guida introduttiva è possibile usare il documento della fattura di esempio.
Scegliere un modello predefinito
Non si è limitati alle fatture. Esistono diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Ecco i modelli predefiniti attualmente supportati dal servizio Document Intelligence:
- Fattura: estrae testo, segni di selezione, tabelle, campi e informazioni chiave dalle fatture.
- Ricevuta: estrae testo e informazioni chiave dalle ricevute.
- Documento ID: estrae testo e informazioni sulla chiave dalle patenti di guida e dai passaporti internazionali.
- Biglietto da visita: estrae testo e informazioni chiave dai biglietti da visita.
Prima di eseguire il comando, apportare queste modifiche:
Sostituire
{endpoint}
con l'endpoint ottenuto con la sottoscrizione di Document Intelligence.Sostituire
{key}
con la chiave copiata dal passaggio precedente.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
Richiedi
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 riceve una 202 (Success)
risposta che include un'intestazione Operation-Location . Il valore di questa intestazione contiene un ID risultato che è possibile usare per eseguire una query sullo stato dell'operazione asincrona e ottenere i risultati:
https:// cognitiveservice/formrecognizer/v2.1/prebuilt/receipt/analyzeResults/{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:
- Sostituire
{endpoint}
con l'endpoint ottenuto con la chiave di Document Intelligence. È possibile trovarla nella scheda Panoramica delle risorse di Intelligence documenti. - Sostituire
{resultId}
con l'ID risultato del passaggio precedente. - Sostituire
{key}
con la chiave.
Richiedi
curl -v -X GET "https://{endpoint}/formrecognizer/v2.1/prebuilt/invoice/analyzeResults/{resultId}" -H "Ocp-Apim-Subscription-Key: {key}"
Esaminare i risultati
Si riceve una 200 (Success)
risposta con output JSON.
- Il
"readResults"
campo contiene tutte le righe di testo estratte 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.
È così, ben fatto!
Passaggi successivi
Per un'esperienza avanzata e una qualità avanzata del modello, provare Document Intelligence Studio.
Studio supporta qualsiasi modello sottoposto a training con dati etichettati v2.1.
I log delle modifiche forniscono informazioni dettagliate sulla migrazione dalla versione 3.1 alla versione 4.0.