Informazioni di base: Riconoscimento modulo JavaScript SDK (beta)
Nota
Riconoscimento modulo versione beta è attualmente disponibile in anteprima pubblica. Alcune funzionalità potrebbero non essere supportate o avere funzionalità limitate.
Documentazione di riferimento | Codice sorgente della libreria | Pacchetto (npm) | Esempi
Attività iniziali con Azure Riconoscimento modulo usando il linguaggio di programmazione JavaScript. Azure Riconoscimento modulo è un servizio di intelligenza artificiale applicato al cloud basato sul cloud che usa Machine Learning per estrarre coppie chiave-valore, testo e tabelle dai documenti. È possibile chiamare facilmente Riconoscimento modulo modelli integrando IDK della libreria client nei flussi di lavoro e nelle applicazioni. È consigliabile usare il servizio gratuito mentre si acquisisce familiarità con questa tecnologia. Tenere presente che il numero di pagine gratuite è limitato a 500 al mese.
Per altre informazioni sulle funzionalità di Riconoscimento modulo e sulle opzioni di sviluppo, visitare la pagina Panoramica.
In questa guida introduttiva si useranno le funzionalità seguenti per analizzare ed estrarre dati e valori da moduli e documenti:
🆕 Documento generale: analizzare ed estrarre campi comuni da tipi di documenti specifici usando un modello di fattura con training preliminare.
Layout: analizzare ed estrarre tabelle, righe, parole e segni di selezione, ad esempio pulsanti di opzione e caselle di controllo nei documenti moduli, senza dover eseguire il training di un modello.
Fattura predefinita: analizzare ed estrarre campi comuni da tipi di documenti specifici usando un modello con training preliminare.
Prerequisiti
Sottoscrizione di Azure: creare un account gratuito.
La versione più recente di Visual Studio Code o dell'IDE preferito. Per altre informazioni, vedereNode.js in Visual Studio Code
La versione LTS più recente di Node.js
Una risorsa Servizi cognitivi o Riconoscimento modulo. Dopo aver creato la sottoscrizione di Azure, creare una risorsa di Riconoscimento modulo a servizio singolo o multiservizio nel portale di Azure per ottenere la chiave e l'endpoint. È possibile usare il piano tariffario gratuito (
F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.Suggerimento
Creare una risorsa di Servizi cognitivi se si prevede di accedere a più servizi cognitivi con un singolo endpoint/chiave. Solo per Riconoscimento modulo l'accesso, creare una risorsa Riconoscimento modulo. Si noti che è necessaria una risorsa a servizio singolo se si intende usare Azure Active Directory autenticazione.
Dopo la distribuzione della risorsa, selezionare Vai alla risorsa. È necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API Riconoscimento modulo. La chiave e l'endpoint verranno incollati nel codice seguente più avanti nella guida introduttiva:
Configurazione
Creare una nuova applicazione Node.js Express: in una finestra della console ,ad esempio cmd, PowerShell o Bash, creare una nuova directory per l'app denominata
form-recognizer-appe passare a essa.mkdir form-recognizer-app && cd form-recognizer-appEseguire il
npm initcomando per inizializzare l'applicazione e eseguire lo scaffolding del progetto.npm initSpecificare 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.jsil nome del punto di ingresso. La descrizione, il comando di test, il repository GitHub, le parole chiave, l'autore e le informazioni sulla licenza sono attributi facoltativi, ma possono essere ignorati per questo progetto. - Accettare i suggerimenti tra parentesi selezionando Restituisci o Invio.
- Dopo aver completato le richieste, verrà creato un
package.jsonfile nella directory form-recognizer-app.
Installare la libreria client e
azure/identityiai-form-recognizerpacchetti npm:npm install @azure/ai-form-recognizer@4.0.0-beta.3 @azure/identity- Il file
package.jsondell'app viene aggiornato con le dipendenze.
- Il file
Creare un file denominato
index.jsnella directory dell'applicazione.Suggerimento
- È possibile creare un nuovo file usando PowerShell.
- Aprire una finestra di PowerShell nella directory del progetto tenendo premuto MAIUSC e facendo clic con il pulsante destro del mouse sulla cartella.
- Digitare il comando new-item seguente index.js.
Compilare l'applicazione
Per interagire con il servizio Riconoscimento modulo, è necessario creare un'istanza della DocumentAnalysisClient classe . A tale scopo, si creerà un oggetto con key dal portale di Azure e un'istanza DocumentAnalysisClientAzureKeyCredential con e il Riconoscimento modulo endpoint.AzureKeyCredential
Aprire il
index.jsfile in Visual Studio Code o nell'IDE preferito e selezionare uno degli esempi di codice seguenti per copiare e incollare nell'applicazione:
Importante
Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, usare metodi sicuri per archiviare e accedere alle credenziali. Per altre informazioni, vedere* Sicurezza di Servizi cognitivi.
Modello di documento generale
Estrarre testo, tabelle, struttura, coppie chiave-valore e entità denominate dai documenti.
- Per questo esempio, è necessario un file di documento di modulo da un URL. Per questa guida introduttiva, è possibile usare il documento di modulo di esempio .
- Per analizzare un determinato file da un URL, si userà il
beginAnalyzeDocumentsmetodo e si passeràprebuilt-documentcome ID modello. - È stato aggiunto il valore dell'URL del file alla
formUrlvariabile nella parte superiore del file. - Per visualizzare l'elenco di tutti i campi supportati e i tipi corrispondenti, vedere la pagina Generale del concetto di documento .
Aggiungere il codice di esempio seguente al index.js file . Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Riconoscimento modulo nel portale di Azure:
const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");
// set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
const key = "<your-endpoint>";
const endpoint = "<your-key>";
// 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() {
// create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));
const poller = await client.beginAnalyzeDocument("prebuilt-document", formUrl);
const {
keyValuePairs,
entities
} = await poller.pollUntilDone();
if (keyValuePairs.length <= 0) {
console.log("No key-value pairs were extracted from the document.");
} else {
console.log("Key-Value Pairs:");
for (const {
key,
value,
confidence
} of keyValuePairs) {
console.log("- Key :", `"${key.content}"`);
console.log(" Value:", `"${value?.content ?? "<undefined>"}" (${confidence})`);
}
}
if (entities.length <= 0) {
console.log("No entities were extracted from the document.");
} else {
console.log("Entities:");
for (const entity of entities) {
console.log(
`- "${entity.content}" ${entity.category} - ${entity.subCategory ?? "<none>"} (${
entity.confidence
})`
);
}
}
}
main().catch((error) => {
console.error("An error occurred:", error);
process.exit(1);
});
Eseguire l'applicazione
Dopo aver aggiunto un esempio di codice all'applicazione, eseguire il programma:
Passare alla cartella in cui si dispone dell'applicazione di riconoscimento modulo (form-recognizer-app).
Digitare il comando seguente nel terminale:
node index.js
Output generale del modello di documento
Ecco un frammento di output previsto:
Key-Value Pairs:
- Key : "For the Quarterly Period Ended"
Value: "March 31, 2020" (0.35)
- Key : "From"
Value: "1934" (0.119)
- Key : "to"
Value: "<undefined>" (0.317)
- Key : "Commission File Number"
Value: "001-37845" (0.87)
- Key : "(I.R.S. ID)"
Value: "91-1144442" (0.87)
- Key : "Class"
Value: "Common Stock, $0.00000625 par value per share" (0.748)
- Key : "Outstanding as of April 24, 2020"
Value: "7,583,440,247 shares" (0.838)
Entities:
- "$0.00000625" Quantity - Currency (0.8)
- "MSFT" Organization - <none> (0.99)
- "NASDAQ" Organization - StockExchange (0.99)
- "2.125%" Quantity - Percentage (0.8)
- "2021" DateTime - DateRange (0.8)
Per visualizzare l'intero output, visitare il repository degli esempi di Azure in GitHub per visualizzare l'output generale del modello di documento
Modello di layout
Estrarre testo, segni di selezione, stili di testo, strutture di tabella e coordinate dell'area di delimitazione dai documenti.
- Per questo esempio, è necessario un file di documento di modulo da un URL. Per questa guida introduttiva, è possibile usare il documento di modulo di esempio .
- È stato aggiunto il valore dell'URL del file alla
formUrlvariabile nella parte superiore del file. - Per analizzare un determinato file da un URL, si userà il
beginAnalyzeDocumentsmetodo e si passeràprebuilt-layoutcome ID modello.
Aggiungere il codice di esempio seguente al index.js file . Assicurarsi di aggiornare le variabili chiave ed endpoint con i valori dell'istanza di Riconoscimento modulo nel portale di Azure:
const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");
// set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
const key = "<your-endpoint>";
const endpoint = "<your-key>";
// 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.beginAnalyzeDocument("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 di riconoscimento modulo (form-recognizer-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 degli esempi di Azure in GitHub per visualizzare l'output del modello di layout
Modello predefinito
In questo esempio verrà analizzata una fattura usando il modello predefinito di fattura .
Suggerimento
Non è possibile limitare le fatture: sono disponibili diversi modelli predefiniti tra cui scegliere, ognuno dei quali ha un proprio set di campi supportati. Il modello da usare per l'operazione di analisi dipende dal tipo di documento da analizzare. Vedere Estrazione dei dati del modello.
- Analizzare una fattura usando il modello di fattura predefinito. È possibile usare il documento di fattura di esempio per questa guida introduttiva.
- È stato aggiunto il valore dell'URL del file alla
invoiceUrlvariabile nella parte superiore del file. - Per analizzare un determinato file in corrispondenza di un URI, si userà il
beginAnalyzeDocumentsmetodo e si passeràPrebuiltModels.Invoicecome ID modello. Il valore restituito è unresultoggetto 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 .
// using the PrebuiltModels object, rather than the raw model ID, adds strong typing to the model's output
const { PrebuiltModels } = require("@azure/ai-form-recognizer");
// set `<your-endpoint>` and `<your-key>` variables with the values from the Azure portal
const key = "<your-endpoint>";
const endpoint = "<your-key>";
// sample document
const invoiceUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";
async function main() {
const client = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));
const poller = await client.beginAnalyzeDocument(PrebuiltModels.Invoice, invoiceUrl);
const {
documents: [result]
} = await poller.pollUntilDone();
if (result) {
const invoice = result.fields;
console.log("Vendor Name:", invoice.vendorName?.value);
console.log("Customer Name:", invoice.customerName?.value);
console.log("Invoice Date:", invoice.invoiceDate?.value);
console.log("Due Date:", invoice.dueDate?.value);
console.log("Items:");
for (const {
properties: item
} of invoice.items?.values ?? []) {
console.log("-", item.productCode?.value ?? "<no product code>");
console.log(" Description:", item.description?.value);
console.log(" Quantity:", item.quantity?.value);
console.log(" Date:", item.date?.value);
console.log(" Unit:", item.unit?.value);
console.log(" Unit Price:", item.unitPrice?.value);
console.log(" Tax:", item.tax?.value);
console.log(" Amount:", item.amount?.value);
}
console.log("Subtotal:", invoice.subTotal?.value);
console.log("Previous Unpaid Balance:", invoice.previousUnpaidBalance?.value);
console.log("Tax:", invoice.totalTax?.value);
console.log("Amount Due:", invoice.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 di riconoscimento modulo (form-recognizer-app).
Digitare il comando seguente nel terminale:
node index.js
Output del modello predefinito
Ecco un frammento di output previsto:
Vendor Name: CONTOSO LTD.
Customer Name: MICROSOFT CORPORATION
Invoice Date: 2019-11-15T00:00:00.000Z
Due Date: 2019-12-15T00:00:00.000Z
Items:
- <no product code>
Description: Test for 23 fields
Quantity: 1
Date: undefined
Unit: undefined
Unit Price: 1
Tax: undefined
Amount: 100
Per visualizzare l'intero output, visitare il repository di esempi di Azure in GitHub per visualizzare l'output predefinito del modello di fattura
È questo, complimenti!
In questa guida introduttiva è stato usato il Riconoscimento modulo JavaScript SDK per analizzare i vari moduli in modi diversi. Esaminare quindi la documentazione di riferimento per informazioni su Riconoscimento modulo API v3.0.