使用文件智慧服務模型

此內容適用於： v4.0 (預覽版) | 較舊版本： v3.1 (GA) v3.0 (GA) v2.1 (GA)

在本指南中，了解如何將文件智慧服務模型新增至您的應用程式和工作流程。 使用您選擇的程式設計語言 SDK 或 REST API。

Azure AI 文件智慧服務是雲端式 Azure AI 服務，而此服務使用機器學習以從文件中擷取重要文字和結構元素。 當您學習技術時，我們建議您使用免費的服務。 請記住，免費的頁數限制為每個月 500 頁。

選擇下列文件智慧服務模型，從表單和文件中分析及擷取資料和值：

• prebuilt-read 模型是所有文件智慧服務模型的核心，而且可以偵測行、字組、位置和語言。 版面配置、一般文件、預建和自訂模型全都使用 read 模型做為從文件擷取文字的基礎。

• prebuilt-layout 模型會從文件和映像中擷取文字和文字位置、資料表、選取標記和結構資訊。 您可以使用版面配置模型搭配啟用選擇性查詢字串參數 features=keyValuePairs 來擷取索引鍵/值組。

• prebuilt-contract 模型會從契約合約擷取重要資訊。

• prebuilt-healthInsuranceCard.us 模型會從美國醫療保健卡擷取重要資訊。

• prebuilt tax document models 模型會擷取美國稅務表格上報告的資訊。

• prebuilt-invoice 模型會以各種格式和品質從銷售發票擷取重要欄位和明細行項目。 欄位包括手機擷取的影像、掃描的文件和數位 PDF。

• prebuilt-receipt 模型會擷取印刷和手寫銷售收據的重要資訊。

• prebuilt-idDocument 模型會擷取美國駕照、國際護照個人資料頁、美國州別識別碼、社會安全卡和永久居民卡的重要資訊。

必要條件

• Azure 訂用帳戶 - 建立免費帳戶。

• Visual Studio IDE。

• Azure AI 服務或文件智慧服務資源。 建立 single-service 或 multi-service。 您可以使用免費定價層 (F0) 來試用服務，之後可升級至付費層以用於實際執行環境。

• 從您所建立資源的金鑰和端點，將應用程式連線至 Azure 文件智慧服務。

  1. 部署資源之後，請選取 [移至資源]。
  2. 在左側導覽功能表中，選取 [金鑰和端點]。
  3. 複製其中一個金鑰和 [端點]，以供稍後在本文中使用。

  

• URL 位置的文件檔案。 在本專案中，您可以使用下表中針對每個功能所提供的範例表單：

  功能	modelID	document-url
  Read 模型	prebuilt-read	範例手冊
  版面配置模型	prebuilt-layout	範例預約確認
  W-2 表單模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	prebuilt-invoice	發票範例
  收據模型	prebuilt-receipt	範例收據
  識別碼文件模型	prebuilt-idDocument	範例身分證明文件
  名片模型	prebuilt-businessCard	範例名片

設定環境變數

若要與此文件智慧服務互動，您必須建立 DocumentAnalysisClient 類別的執行個體。 若要這樣做，請使用 key 和 endpoint 以從 Azure 入口網站將用戶端具現化。 在此專案中，使用環境變數來儲存和存取認證。

重要

請不要在您的程式碼中直接包括金鑰，而且不要公開張貼金鑰。 在生產環境中，請使用安全方式來儲存和存取 Azure Key Vault 等認證。 如需詳細資訊，請參閱 Azure AI 服務安全性。

若要設定文件智慧服務資源金鑰的環境變數，請開啟主控台視窗，並遵循作業系統和開發環境的指示進行。 將 <yourKey> 和 <yourEndpoint> 取代為 Azure 入口網站中資源的值。

Windows

Windows 中的環境變數不區分大小寫。 這些變數通常會以大寫方式宣告，並加上底線聯結的字組。 在命令提示字元中，執行下列命令：

1. 設定金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

3. 設定環境變數之後，請關閉 [命令提示字元] 視窗。 值會維持不變，直到您再次變更這些值為止。

4. 重新啟動任何讀取環境變數的執行中程式。 例如，如果您使用 Visual Studio 或 Visual Studio Code 作為編輯器，則請在執行範例程式碼之前重新啟動。

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
setx VARIABLE_NAME=	將值設定為空字串，以刪除環境變數。	setx DI_KEY=
setx VARIABLE_NAME=value	設定或變更環境變數的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	顯示特定環境變數的值。	set DI_KEY
set	顯示所有環境變數。	set

macOS

macOS 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止。 開啟您的終端機，然後輸入下列命令：

1. 設定金鑰變數：

   export key=<yourKey>
   

2. 設定端點變數：

   export endpoint=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bash_profile 啟動指令碼中，以永久設定環境變數：

1. 使用文字編輯器來開啟 ~/.bash_profile 檔案，並新增下列命令來建立永久環境變數：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

2. 將變更儲存至 bash_profile 檔案。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bash-profile
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示特定環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

Linux

Linux 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止：

1. 設定金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bashrc 啟動指令碼中，以永久設定環境變數：

1. 使用您慣用的文字編輯器來開啟 ~/.bashrc 檔案，並新增下列命令來建立永久環境變數：

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

2. 儲存對 .bashrc 檔案所做的變更。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bashrc
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY=
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

設定程式設計環境

1. 啟動 Visual Studio。

2. 在開始頁面中，選擇 [建立新的專案]。

   

3. 在 [建立新的專案] 頁面的搜尋方塊中，輸入主控台。 選取 [主控台應用程式] 範本，然後選擇 [下一步]。

   

4. 在 [設定新專案] 頁面中，於 [專案名稱] 底下輸入 docIntelligence_app。 然後選取下一步。

   

5. 在 [其他資訊] 頁面中，選取 [.NET 8.0 (長期支援)]，然後選取 [建立]。

   

使用 NuGet 安裝用戶端程式庫

1. 以滑鼠右鍵按一下您的 docIntelligence_app 專案，然後選取 [管理 NuGet 套件...]。

   

2. 選取 [瀏覽] 索引標籤，然後輸入 [Azure.AI.FormRecognizer]。

   

3. 從下拉式功能表中選取版本，並在專案中安裝套件。

建置您的 應用程式

注意

從 .NET 6 開始，使用 console 範本的新專案會產生與舊版不同的新程式樣式。 新輸出會使用最新的 C# 功能，以簡化您需要撰寫的程式碼。

當您使用較新版本時，只需要撰寫 Main 方法的本文。 您不需要包含最上層陳述式、全域 Using 指示詞或隱含 Using 指示詞。 如需詳細資訊，請參閱 C# 主控台應用程式範本可產生最上層陳述式。

1. 開啟 Program.cs 檔案。

2. 刪除預先存在的程式碼，包含此行 Console.Writeline("Hello World!")。

3. 選取下列其中一個程式碼範例，然後複製並貼上您應用程式中的 Program.cs 檔案：

   • prebuilt-read
   • prebuilt-layout
   • prebuilt-tax.us.w2
   • prebuilt-invoice
   • prebuilt-receipt
   • prebuilt-idDocument

4. 將程式碼範例新增至應用程式之後，請選擇專案名稱旁的綠色 [開始] 按鈕來建置和執行程式，或按 F5。

   

使用讀取模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
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/rest-api/read.png");

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-read", 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}");
        }
    }
}

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("Detected languages:");

foreach (DocumentLanguage language in result.Languages)
{
    Console.WriteLine($"  Found language with locale'{language.Locale}' with confidence {language.Confidence}.");
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視read模型輸出。

使用版面配置模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

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

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

請造訪 GitHub 上的 Azure 範例存放庫，並檢視版面配置模型輸出。

請使用一般文件模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

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

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

AnalyzeResult result = operation.Value;

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

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

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding 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}");
        }
    }
}

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

請造訪 GitHub 上的 Azure 範例存放庫，並檢視一般文件模型輸出。

使用 W-2 稅務模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

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

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-tax.us.w2", w2Uri);

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("AdditionalInfo", out DocumentField? additionalInfoField))
    {
        if (additionalInfoField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField infoField in additionalInfoField.Value.AsList())
            {
                Console.WriteLine("AdditionalInfo:");

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

                    if (infoFields.TryGetValue("Amount", out DocumentField? amountField))
                    {
                        if (amountField.FieldType == DocumentFieldType.Double)
                        {
                            double amount = amountField.Value.AsDouble();

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

                    if (infoFields.TryGetValue("LetterCode", out DocumentField? letterCodeField))
                    {
                        if (letterCodeField.FieldType == DocumentFieldType.String)
                        {
                            string letterCode = letterCodeField.Value.AsString();

                            Console.WriteLine($"  LetterCode: '{letterCode}', with confidence {letterCodeField.Confidence}");
                        }
                    }
                }
            }
        }
    }


    if (document.Fields.TryGetValue("AllocatedTips", out DocumentField? allocatedTipsField))
    {
        if (allocatedTipsField.FieldType == DocumentFieldType.Double)
        {
            double allocatedTips = allocatedTipsField.Value.AsDouble();
            Console.WriteLine($"Allocated Tips: '{allocatedTips}', with confidence {allocatedTipsField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("Employer", out DocumentField? employerField))
    {
        if (employerField.FieldType == DocumentFieldType.Dictionary)
        {
            IReadOnlyDictionary<string, DocumentField> employerFields = employerField.Value.AsDictionary();

            if (employerFields.TryGetValue("Name", out DocumentField? employerNameField))
            {
                if (employerNameField.FieldType == DocumentFieldType.String)
                {
                    string name = employerNameField.Value.AsString();

                    Console.WriteLine($"Employer Name: '{name}', with confidence {employerNameField.Confidence}");
                }
            }

            if (employerFields.TryGetValue("IdNumber", out DocumentField? idNumberField))
            {
                if (idNumberField.FieldType == DocumentFieldType.String)
                {
                    string id = idNumberField.Value.AsString();

                    Console.WriteLine($"Employer ID Number: '{id}', with confidence {idNumberField.Confidence}");
                }
            }

            if (employerFields.TryGetValue("Address", out DocumentField? addressField))
            {
                if (addressField.FieldType == DocumentFieldType.Address)
                {
                    Console.WriteLine($"Employer Address: '{addressField.Content}', with confidence {addressField.Confidence}");
                }
            }
        }
    }
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視 W-2 稅務模型輸出。

使用發票模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

// sample document document
Uri invoiceUri = new Uri("https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/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}");
        }
    }
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視發票模型輸出。

使用收據模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

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

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

AnalyzeResult receipts = operation.Value;

foreach (AnalyzedDocument receipt in receipts.Documents)
{
    if (receipt.Fields.TryGetValue("MerchantName", out DocumentField merchantNameField))
    {
        if (merchantNameField.FieldType == DocumentFieldType.String)
        {
            string merchantName = merchantNameField.Value.AsString();

            Console.WriteLine($"Merchant Name: '{merchantName}', with confidence {merchantNameField.Confidence}");
        }
    }

    if (receipt.Fields.TryGetValue("TransactionDate", out DocumentField transactionDateField))
    {
        if (transactionDateField.FieldType == DocumentFieldType.Date)
        {
            DateTimeOffset transactionDate = transactionDateField.Value.AsDate();

            Console.WriteLine($"Transaction Date: '{transactionDate}', with confidence {transactionDateField.Confidence}");
        }
    }

    if (receipt.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("TotalPrice", out DocumentField itemTotalPriceField))
                    {
                        if (itemTotalPriceField.FieldType == DocumentFieldType.Double)
                        {
                            double itemTotalPrice = itemTotalPriceField.Value.AsDouble();

                            Console.WriteLine($"  Total Price: '{itemTotalPrice}', with confidence {itemTotalPriceField.Confidence}");
                        }
                    }
                }
            }
        }
    }

    if (receipt.Fields.TryGetValue("Total", out DocumentField totalField))
    {
        if (totalField.FieldType == DocumentFieldType.Double)
        {
            double total = totalField.Value.AsDouble();

            Console.WriteLine($"Total: '{total}', with confidence '{totalField.Confidence}'");
        }
    }
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視收據模型輸出。

識別碼文件模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

// sample document document

Uri idDocumentUri = new Uri("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png");

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

AnalyzeResult identityDocuments = operation.Value;

AnalyzedDocument identityDocument = identityDocuments.Documents.Single();

if (identityDocument.Fields.TryGetValue("Address", out DocumentField addressField))
{
    if (addressField.FieldType == DocumentFieldType.String)
    {
        string address = addressField.Value. AsString();
        Console.WriteLine($"Address: '{address}', with confidence {addressField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("CountryRegion", out DocumentField countryRegionField))
{
    if (countryRegionField.FieldType == DocumentFieldType.CountryRegion)
    {
        string countryRegion = countryRegionField.Value.AsCountryRegion();
        Console.WriteLine($"CountryRegion: '{countryRegion}', with confidence {countryRegionField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("DateOfBirth", out DocumentField dateOfBirthField))
{
    if (dateOfBirthField.FieldType == DocumentFieldType.Date)
    {
        DateTimeOffset dateOfBirth = dateOfBirthField.Value.AsDate();
        Console.WriteLine($"Date Of Birth: '{dateOfBirth}', with confidence {dateOfBirthField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("DateOfExpiration", out DocumentField dateOfExpirationField))
{
    if (dateOfExpirationField.FieldType == DocumentFieldType.Date)
    {
        DateTimeOffset dateOfExpiration = dateOfExpirationField.Value.AsDate();
        Console.WriteLine($"Date Of Expiration: '{dateOfExpiration}', with confidence {dateOfExpirationField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("DocumentNumber", out DocumentField documentNumberField))
{
    if (documentNumberField.FieldType == DocumentFieldType.String)
    {
        string documentNumber = documentNumberField.Value.AsString();
        Console.WriteLine($"Document Number: '{documentNumber}', with confidence {documentNumberField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("FirstName", out DocumentField firstNameField))
{
    if (firstNameField.FieldType == DocumentFieldType.String)
    {
        string firstName = firstNameField.Value.AsString();
        Console.WriteLine($"First Name: '{firstName}', with confidence {firstNameField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("LastName", out DocumentField lastNameField))
{
    if (lastNameField.FieldType == DocumentFieldType.String)
    {
        string lastName = lastNameField.Value.AsString();
        Console.WriteLine($"Last Name: '{lastName}', with confidence {lastNameField.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("Region", out DocumentField regionfield))
{
    if (regionfield.FieldType == DocumentFieldType.String)
    {
        string region = regionfield.Value.AsString();
        Console.WriteLine($"Region: '{region}', with confidence {regionfield.Confidence}");
    }
}

if (identityDocument.Fields.TryGetValue("Sex", out DocumentField sexfield))
{
    if (sexfield.FieldType == DocumentFieldType.String)
    {
        string sex = sexfield.Value.AsString();
        Console.WriteLine($"Sex: '{sex}', with confidence {sexfield.Confidence}");
    }
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視 id-document 模型輸出。

使用名片模型

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

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentAnalysisClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

// sample document document
Uri businessCardUri = new Uri("https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/business-card-english.jpg");

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

AnalyzeResult businessCards = operation.Value;

foreach (AnalyzedDocument businessCard in businessCards.Documents)
{
    if (businessCard.Fields.TryGetValue("ContactNames", out DocumentField ContactNamesField))
    {
        if (ContactNamesField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField contactNameField in ContactNamesField.Value.AsList())
            {
                Console.WriteLine("Contact Name: ");

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

                    if (contactNameFields.TryGetValue("FirstName", out DocumentField firstNameField))
                    {
                        if (firstNameField.FieldType == DocumentFieldType.String)
                        {
                            string firstName = firstNameField.Value.AsString();

                            Console.WriteLine($"  First Name: '{firstName}', with confidence {firstNameField.Confidence}");
                        }
                    }

                    if (contactNameFields.TryGetValue("LastName", out DocumentField lastNameField))
                    {
                        if (lastNameField.FieldType == DocumentFieldType.String)
                        {
                            string lastName = lastNameField.Value.AsString();

                            Console.WriteLine($"  Last Name: '{lastName}', with confidence {lastNameField.Confidence}");
                        }
                    }
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("JobTitles", out DocumentField jobTitlesFields))
    {
        if (jobTitlesFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField jobTitleField in jobTitlesFields.Value.AsList())
            {
                if (jobTitleField.FieldType == DocumentFieldType.String)
                {
                    string jobTitle = jobTitleField.Value.AsString();

                    Console.WriteLine($"Job Title: '{jobTitle}', with confidence {jobTitleField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("Departments", out DocumentField departmentFields))
    {
        if (departmentFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField departmentField in departmentFields.Value.AsList())
            {
                if (departmentField.FieldType == DocumentFieldType.String)
                {
                    string department = departmentField.Value.AsString();

                    Console.WriteLine($"Department: '{department}', with confidence {departmentField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("Emails", out DocumentField emailFields))
    {
        if (emailFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField emailField in emailFields.Value.AsList())
            {
                if (emailField.FieldType == DocumentFieldType.String)
                {
                    string email = emailField.Value.AsString();

                    Console.WriteLine($"Email: '{email}', with confidence {emailField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("Websites", out DocumentField websiteFields))
    {
        if (websiteFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField websiteField in websiteFields.Value.AsList())
            {
                if (websiteField.FieldType == DocumentFieldType.String)
                {
                    string website = websiteField.Value.AsString();

                    Console.WriteLine($"Website: '{website}', with confidence {websiteField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("MobilePhones", out DocumentField mobilePhonesFields))
    {
        if (mobilePhonesFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField mobilePhoneField in mobilePhonesFields.Value.AsList())
            {
                if (mobilePhoneField.FieldType == DocumentFieldType.PhoneNumber)
                {
                    string mobilePhone = mobilePhoneField.Value.AsPhoneNumber();

                    Console.WriteLine($"Mobile phone number: '{mobilePhone}', with confidence {mobilePhoneField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("WorkPhones", out DocumentField workPhonesFields))
    {
        if (workPhonesFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField workPhoneField in workPhonesFields.Value.AsList())
            {
                if (workPhoneField.FieldType == DocumentFieldType.PhoneNumber)
                {
                    string workPhone = workPhoneField.Value.AsPhoneNumber();

                    Console.WriteLine($"Work phone number: '{workPhone}', with confidence {workPhoneField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("Faxes", out DocumentField faxesFields))
    {
        if (faxesFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField faxField in faxesFields.Value.AsList())
            {
                if (faxField.FieldType == DocumentFieldType.PhoneNumber)
                {
                    string fax = faxField.Value.AsPhoneNumber();

                    Console.WriteLine($"Fax phone number: '{fax}', with confidence {faxField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("Addresses", out DocumentField addressesFields))
    {
        if (addressesFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField addressField in addressesFields.Value.AsList())
            {
                if (addressField.FieldType == DocumentFieldType.String)
                {
                    string address = addressField.Value.AsString();

                    Console.WriteLine($"Address: '{address}', with confidence {addressField.Confidence}");
                }
            }
        }
    }

    if (businessCard.Fields.TryGetValue("CompanyNames", out DocumentField companyNamesFields))
    {
        if (companyNamesFields.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField companyNameField in companyNamesFields.Value.AsList())
            {
                if (companyNameField.FieldType == DocumentFieldType.String)
                {
                    string companyName = companyNameField.Value.AsString();

                    Console.WriteLine($"Company name: '{companyName}', with confidence {companyNameField.Confidence}");
                }
            }
        }
    }
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視名片模型輸出。

用戶端程式庫 (英文) | SDK 參考 (英文) | REST API 參考 (部分機器翻譯) | 套件 (Maven) (英文) | 範例 (英文) |支援的 REST API 版本 (部分機器翻譯)

必要條件

• Azure 訂用帳戶 - 建立免費帳戶。

• 最新的 Visual Studio Code 版本或您慣用的 IDE。 請參閱 Visual Studio Code 中的 Java。

  • Visual Studio Code 提供適用於 Windows 和 macOS 的 Java 編碼套件。 編碼套件是一組 VS 程式碼、Java 開發工具套件 (JDK)，以及 Microsoft 建議的延伸模組集合。 編碼套件也可以用於修正現有的開發環境。
  • 如果您使用 VS Code 和 JAVA 編碼套件，請安裝適用於 JAVA 的 Gradle 延伸模組。

  如果您未使用 Visual Studio Code，請確保在開發環境中安裝下列項目：

  • Java 開發套件 (JDK) (部分機器翻譯) 第 8 版或更新版本。 如需詳細資訊，請參閱 Microsoft Build of OpenJDK。
  • Gradle，6.8 版或後續版本。

• Azure AI 服務或文件智慧服務資源。 建立 single-service 或 multi-service。 您可以使用免費定價層 (F0) 來試用服務，之後可升級至付費層以用於實際執行環境。

  提示

  如果您打算使用單一端點和金鑰存取多個 Azure AI 服務，請建立 Azure AI 服務資源。 若為僅限文件智慧服務存取，請建立文件智慧服務資源。 如果您想要使用 Microsoft Entra 驗證，則需要使用單一服務資源。

• 從您所建立資源的金鑰和端點，將應用程式連線至 Azure 文件智慧服務。

  1. 部署資源之後，請選取 [移至資源]。
  2. 在左側導覽功能表中，選取 [金鑰和端點]。
  3. 複製其中一個金鑰和 [端點]，以供稍後在本文中使用。

  

• URL 的文件檔案。 在本專案中，您可以使用下表中針對每個功能所提供的範例表單：

  功能	modelID	document-url
  Read 模型	prebuilt-read	範例手冊
  版面配置模型	prebuilt-layout	範例預約確認
  W-2 表單模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	prebuilt-invoice	發票範例
  收據模型	prebuilt-receipt	範例收據
  識別碼文件模型	prebuilt-idDocument	範例身分證明文件

設定環境變數

若要與此文件智慧服務互動，您必須建立 DocumentAnalysisClient 類別的執行個體。 若要這樣做，請使用 key 和 endpoint 以從 Azure 入口網站將用戶端具現化。 在此專案中，使用環境變數來儲存和存取認證。

重要

請不要在您的程式碼中直接包括金鑰，而且不要公開張貼金鑰。 在生產環境中，請使用安全方式來儲存和存取 Azure Key Vault 等認證。 如需詳細資訊，請參閱 Azure AI 服務安全性。

若要設定文件智慧服務資源金鑰的環境變數，請開啟主控台視窗，並遵循作業系統和開發環境的指示進行。 將 <yourKey> 和 <yourEndpoint> 取代為 Azure 入口網站中資源的值。

Windows

Windows 中的環境變數不區分大小寫。 這些變數通常會以大寫方式宣告，並加上底線聯結的字組。 在命令提示字元中，執行下列命令：

1. 設定金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

3. 設定環境變數之後，請關閉 [命令提示字元] 視窗。 值會維持不變，直到您再次變更這些值為止。

4. 重新啟動任何讀取環境變數的執行中程式。 例如，如果您使用 Visual Studio 或 Visual Studio Code 作為編輯器，則請在執行範例程式碼之前重新啟動。

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
setx VARIABLE_NAME=	將值設定為空字串，以刪除環境變數。	setx DI_KEY=
setx VARIABLE_NAME=value	設定或變更環境變數的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	顯示特定環境變數的值。	set DI_KEY
set	顯示所有環境變數。	set

macOS

macOS 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止。 開啟您的終端機，然後輸入下列命令：

1. 設定金鑰變數：

   export key=<yourKey>
   

2. 設定端點變數：

   export endpoint=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bash_profile 啟動指令碼中，以永久設定環境變數：

1. 使用文字編輯器來開啟 ~/.bash_profile 檔案，並新增下列命令來建立永久環境變數：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

2. 將變更儲存至 bash_profile 檔案。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bash-profile
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示特定環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

Linux

Linux 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止：

1. 設定金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bashrc 啟動指令碼中，以永久設定環境變數：

1. 使用您慣用的文字編輯器來開啟 ~/.bashrc 檔案，並新增下列命令來建立永久環境變數：

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

2. 儲存對 .bashrc 檔案所做的變更。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bashrc
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY=
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

設定程式設計環境

若要設定程式設計環境，請建立 Gradle 專案並安裝用戶端程式庫。

建立 Gradle 專案

1. 在主控台視窗中，為名為 doc-intelligence-app 的應用程式建立目錄，並瀏覽至該目錄。

   mkdir doc-intelligence-app
   cd doc-intelligence-app
   

2. 從您的工作目錄執行 gradle init 命令。 此命令會建立 Gradle 的基本組建檔案，包括 build.gradle.kts，將在執行階段使用 build.gradle.kts，來建立及設定應用程式。

   gradle init --type basic
   

3. 出現選擇 DSL 的提示時，請選取 [Kotlin]。

4. 選取 Enter 以接受預設專案名稱 doc-intelligence-app。

安裝用戶端程式庫

本文使用 Gradle 相依性管理員。 您可以在 Maven 中央存放庫中找到用戶端程式庫和其他相依性管理員的資訊。

1. 在 IDE 中開啟專案的 build.gradle.kts 檔案。 複製並貼上下列程式碼，以將用戶端程式庫做為 implementation 陳述式包含在內，並且加入必要的外掛程式和設定。

   plugins {
      java
      application
   }
   application {
       mainClass.set("DocIntelligence")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation group: 'com.azure', name: 'azure-ai-documentintelligence', version: '1.0.0-beta.2'
   }
   

建立 Java 應用程式

若要與此文件智慧服務互動，請建立 DocumentIntelligenceClient 類別的執行個體。 若要這樣做，請使用 key 從 Azure 入口網站建立 AzureKeyCredential，並使用 AzureKeyCredential 和文件智慧服務 endpoint 來建立 DocumentIntelligenceClient 執行個體。

1. 從 doc-intelligence-app 目錄執行下列命令：

   mkdir -p src/main/java
   

該命令會建立下列目錄結構：

1. 瀏覽至 java 目錄並建立名為 DocIntelligence.java 的檔案。

   提示

   您可以使用 PowerShell 建立新檔案。 按住 Shift 鍵並在資料夾上以滑鼠右鍵按一下，以開啟專案目錄中的 PowerShell 視窗，然後輸入下列命令：New-Item DocIntelligence.java。

2. 開啟 DocIntelligence.java 檔案，然後選取下列其中一個程式碼範例，並且複製/貼入您的應用程式：

   • prebuilt-read 模型是所有文件智慧服務模型的核心，而且可以偵測行、字組、位置和語言。 版面配置、一般文件、預建和自訂模型全都使用 read 模型做為從文件擷取文字的基礎。
   • prebuilt-layout 模型會從文件和映像中擷取文字和文字位置、資料表、選取標記和結構資訊。
   • prebuilt-tax.us.w2 模型會擷取美國內部營收服務 (IRS) 稅務表單上所報告的資訊。
   • prebuilt-invoice 模型會以各種格式從銷售發票擷取重要欄位和明細行項目。
   • prebuilt-receipt 模型會擷取印刷和手寫銷售收據的重要資訊。
   • prebuilt-idDocument 模型會擷取美國駕照、國際護照個人資料頁、美國州別識別碼、社會安全卡和永久居民卡的重要資訊。

3. 輸入下列命令：

   gradle build
   gradle run
   

使用讀取模型

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 {

  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .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/rest-api/read.png";

String modelId = "prebuilt-read";

SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
  client.beginAnalyzeDocument(modelId, invoiceUrl);;

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.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.getBoundingPolygon().toString()));

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

請造訪 GitHub 上的 Azure 範例存放庫，並檢視read模型輸出。

使用版面配置模型

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 {
  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

//sample document
String layoutDocumentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png";
String modelId = "prebuilt-layout";

SyncPoller < OperationResult, AnalyzeResult > analyzeLayoutResultPoller =
  client.beginAnalyzeDocument(modelId, layoutDocumentUrl);

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.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.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.getSelectionMarkState().toString(),
      getBoundingCoordinates(documentSelectionMark.getBoundingPolygon()),
      documentSelectionMark.getConfidence()));
});

// tables
List < DocumentTable > tables = analyzeLayoutResult.getTables();
for (int i = 0; i < tables.size(); i++) {
  DocumentTable documentTables = tables.get(i);
  System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTables.getRowCount(),
    documentTables.getColumnCount());
  documentTables.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(", "));
}

}

請造訪 GitHub 上的 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 {
  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

//sample document
String generalDocumentUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";
String modelId = "prebuilt-document";
SyncPoller < OperationResult, AnalyzeResult > analyzeDocumentPoller =
  client.beginAnalyzeDocument(modelId, generalDocumentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult().getAnalyzeResult();;

// pages
analyzeResult.getPages().forEach(documentPage -> {
  System.out.printf("Page has width: %.2f and height: %.2f, measured with unit: %s%n",
    documentPage.getWidth(),
    documentPage.getHeight(),
    documentPage.getUnit());

  // lines
  documentPage.getLines().forEach(documentLine ->
    System.out.printf("Line %s is within a bounding polygon %s.%n",
      documentLine.getContent(),
      documentLine.getBoundingPolygon().toString()));

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

// tables
List < DocumentTable > tab_les = analyzeResult.getTables();
for (int i = 0; i < tab_les.size(); i++) {
  DocumentTable documentTable = tab_les.get(i);
  System.out.printf("Table %d has %d rows and %d columns.%n", i, documentTable.getRowCount(),
    documentTable.getColumnCount());
  documentTable.getCells().forEach(documentTableCell -> {
    System.out.printf("Cell '%s', has row index %d and column index %d.%n",
      documentTableCell.getContent(),
      documentTableCell.getRowIndex(), documentTableCell.getColumnIndex());
  });
  System.out.println();
}

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

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

}

}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視一般文件模型輸出。

使用 W-2 稅務模型

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 {
  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

// sample document
String w2Url = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png";
String modelId = "prebuilt-tax.us.w2";

SyncPoller < OperationResult, AnalyzeResult > analyzeW2Poller =
  client.beginAnalyzeDocument(modelId, w2Url);

AnalyzeResult analyzeTaxResult = analyzeW2Poller.getFinalResult().getAnalyzeResult();

for (int i = 0; i < analyzeTaxResult.getDocuments().size(); i++) {
  AnalyzedDocument analyzedTaxDocument = analyzeTaxResult.getDocuments().get(i);
  Map < String, DocumentField > taxFields = analyzedTaxDocument.getFields();
  System.out.printf("----------- Analyzing Document  %d -----------%n", i);
  DocumentField w2FormVariantField = taxFields.get("W2FormVariant");
  if (w2FormVariantField != null) {
    if (DocumentFieldType.STRING == w2FormVariantField.getType()) {
      String merchantName = w2FormVariantField.getValueAsString();
      System.out.printf("Form variant: %s, confidence: %.2f%n",
        merchantName, w2FormVariantField.getConfidence());
    }
  }

  DocumentField employeeField = taxFields.get("Employee");
  if (employeeField != null) {
    System.out.println("Employee Data: ");
    if (DocumentFieldType.MAP == employeeField.getType()) {
      Map < String, DocumentField > employeeDataFieldMap = employeeField.getValueAsMap();
      DocumentField employeeName = employeeDataFieldMap.get("Name");
      if (employeeName != null) {
        if (DocumentFieldType.STRING == employeeName.getType()) {
          String employeesName = employeeName.getValueAsString();
          System.out.printf("Employee Name: %s, confidence: %.2f%n",
            employeesName, employeeName.getConfidence());
        }
      }
      DocumentField employeeAddrField = employeeDataFieldMap.get("Address");
      if (employeeAddrField != null) {
        if (DocumentFieldType.STRING == employeeAddrField.getType()) {
          String employeeAddress = employeeAddrField.getValueAsString();
          System.out.printf("Employee Address: %s, confidence: %.2f%n",
            employeeAddress, employeeAddrField.getConfidence());
        }
      }
    }
  }

  DocumentField employerField = taxFields.get("Employer");
  if (employerField != null) {
    System.out.println("Employer Data: ");
    if (DocumentFieldType.MAP == employerField.getType()) {
      Map < String, DocumentField > employerDataFieldMap = employerField.getValueAsMap();
      DocumentField employerNameField = employerDataFieldMap.get("Name");
      if (employerNameField != null) {
        if (DocumentFieldType.STRING == employerNameField.getType()) {
          String employerName = employerNameField.getValueAsString();
          System.out.printf("Employer Name: %s, confidence: %.2f%n",
            employerName, employerNameField.getConfidence());
        }
      }

      DocumentField employerIDNumberField = employerDataFieldMap.get("IdNumber");
      if (employerIDNumberField != null) {
        if (DocumentFieldType.STRING == employerIDNumberField.getType()) {
          String employerIdNumber = employerIDNumberField.getValueAsString();
          System.out.printf("Employee ID Number: %s, confidence: %.2f%n",
            employerIdNumber, employerIDNumberField.getConfidence());
        }
      }
    }
  }

  DocumentField taxYearField = taxFields.get("TaxYear");
  if (taxYearField != null) {
    if (DocumentFieldType.STRING == taxYearField.getType()) {
      String taxYear = taxYearField.getValueAsString();
      System.out.printf("Tax year: %s, confidence: %.2f%n",
        taxYear, taxYearField.getConfidence());
    }
  }

  DocumentField taxDateField = taxFields.get("TaxDate");
  if (taxDateField != null) {
    if (DocumentFieldType.DATE == taxDateField.getType()) {
      LocalDate taxDate = taxDateField.getValueAsDate();
      System.out.printf("Tax Date: %s, confidence: %.2f%n",
        taxDate, taxDateField.getConfidence());
    }
  }

  DocumentField socialSecurityTaxField = taxFields.get("SocialSecurityTaxWithheld");
  if (socialSecurityTaxField != null) {
    if (DocumentFieldType.DOUBLE == socialSecurityTaxField.getType()) {
      Double socialSecurityTax = socialSecurityTaxField.getValueAsDouble();
      System.out.printf("Social Security Tax withheld: %.2f, confidence: %.2f%n",
        socialSecurityTax, socialSecurityTaxField.getConfidence());
    }
  }
}
}
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視 W-2 稅務模型輸出。

使用發票模型

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 {
  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

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

SyncPoller < OperationResult, AnalyzeResult > analyzeInvoicesPoller =
  client.beginAnalyzeDocument(modelId, invoiceUrl);

AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult().getAnalyzeResult();

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) -> {
          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());
            }
          }
        }));
    }
  }
}
}
}

請造訪 GitHub 上的 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 {
  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

String receiptUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png";
String modelId = "prebuilt-receipt";

SyncPoller < OperationResult, AnalyzeResult > analyzeReceiptPoller =
  client.beginAnalyzeDocument(modelId, receiptUrl);

AnalyzeResult receiptResults = analyzeReceiptPoller.getFinalResult().getAnalyzeResult();

for (int i = 0; i < receiptResults.getDocuments().size(); i++) {
  AnalyzedDocument analyzedReceipt = receiptResults.getDocuments().get(i);
  Map < String, DocumentField > receiptFields = analyzedReceipt.getFields();
  System.out.printf("----------- Analyzing receipt info %d -----------%n", i);
  DocumentField merchantNameField = receiptFields.get("MerchantName");
  if (merchantNameField != null) {
    if (DocumentFieldType.STRING == merchantNameField.getType()) {
      String merchantName = merchantNameField.getValueAsString();
      System.out.printf("Merchant Name: %s, confidence: %.2f%n",
        merchantName, merchantNameField.getConfidence());
    }
  }

  DocumentField merchantPhoneNumberField = receiptFields.get("MerchantPhoneNumber");
  if (merchantPhoneNumberField != null) {
    if (DocumentFieldType.PHONE_NUMBER == merchantPhoneNumberField.getType()) {
      String merchantAddress = merchantPhoneNumberField.getValueAsPhoneNumber();
      System.out.printf("Merchant Phone number: %s, confidence: %.2f%n",
        merchantAddress, merchantPhoneNumberField.getConfidence());
    }
  }

  DocumentField merchantAddressField = receiptFields.get("MerchantAddress");
  if (merchantAddressField != null) {
    if (DocumentFieldType.STRING == merchantAddressField.getType()) {
      String merchantAddress = merchantAddressField.getValueAsString();
      System.out.printf("Merchant Address: %s, confidence: %.2f%n",
        merchantAddress, merchantAddressField.getConfidence());
    }
  }

  DocumentField transactionDateField = receiptFields.get("TransactionDate");
  if (transactionDateField != null) {
    if (DocumentFieldType.DATE == transactionDateField.getType()) {
      LocalDate transactionDate = transactionDateField.getValueAsDate();
      System.out.printf("Transaction Date: %s, confidence: %.2f%n",
        transactionDate, transactionDateField.getConfidence());
    }
  }

  DocumentField receiptItemsField = receiptFields.get("Items");
  if (receiptItemsField != null) {
    System.out.printf("Receipt Items: %n");
    if (DocumentFieldType.LIST == receiptItemsField.getType()) {
      List < DocumentField > receiptItems = receiptItemsField.getValueAsList();
      receiptItems.stream()
        .filter(receiptItem -> DocumentFieldType.MAP == receiptItem.getType())
        .map(documentField -> documentField.getValueAsMap())
        .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
          if ("Name".equals(key)) {
            if (DocumentFieldType.STRING == documentField.getType()) {
              String name = documentField.getValueAsString();
              System.out.printf("Name: %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 ("Price".equals(key)) {
            if (DocumentFieldType.DOUBLE == documentField.getType()) {
              Double price = documentField.getValueAsDouble();
              System.out.printf("Price: %f, confidence: %.2f%n",
                price, documentField.getConfidence());
            }
          }
          if ("TotalPrice".equals(key)) {
            if (DocumentFieldType.DOUBLE == documentField.getType()) {
              Double totalPrice = documentField.getValueAsDouble();
              System.out.printf("Total Price: %f, confidence: %.2f%n",
                totalPrice, documentField.getConfidence());
            }
          }
        }));
    }
  }
}
}
}

請造訪 GitHub 上的 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 {
  //use your `key` and `endpoint` environment variables
  private static final String key = System.getenv("FR_KEY");
  private static final String endpoint = System.getenv("FR_ENDPOINT");

  public static void main(final String[] args) {

      // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
      DocumentIntelligenceClient client = new DocumentIntelligenceClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

//sample document
String licenseUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png";
String modelId = "prebuilt-idDocument";

SyncPoller < OperationResult, AnalyzeResult > analyzeIdentityDocumentPoller = client.beginAnalyzeDocument(modelId, licenseUrl);

AnalyzeResult identityDocumentResults = analyzeIdentityDocumentPoller.getFinalResult().getAnalyzeResult();

for (int i = 0; i < identityDocumentResults.getDocuments().size(); i++) {
  AnalyzedDocument analyzedIDDocument = identityDocumentResults.getDocuments().get(i);
  Map < String, DocumentField > licenseFields = analyzedIDDocument.getFields();
  System.out.printf("----------- Analyzed license info for page %d -----------%n", i);
  DocumentField addressField = licenseFields.get("Address");
  if (addressField != null) {
    if (DocumentFieldType.STRING == addressField.getType()) {
      String address = addressField.getValueAsString();
      System.out.printf("Address: %s, confidence: %.2f%n",
        address, addressField.getConfidence());
    }
  }

  DocumentField countryRegionDocumentField = licenseFields.get("CountryRegion");
  if (countryRegionDocumentField != null) {
    if (DocumentFieldType.STRING == countryRegionDocumentField.getType()) {
      String countryRegion = countryRegionDocumentField.getValueAsCountry();
      System.out.printf("Country or region: %s, confidence: %.2f%n",
        countryRegion, countryRegionDocumentField.getConfidence());
    }
  }

  DocumentField dateOfBirthField = licenseFields.get("DateOfBirth");
  if (dateOfBirthField != null) {
    if (DocumentFieldType.DATE == dateOfBirthField.getType()) {
      LocalDate dateOfBirth = dateOfBirthField.getValueAsDate();
      System.out.printf("Date of Birth: %s, confidence: %.2f%n",
        dateOfBirth, dateOfBirthField.getConfidence());
    }
  }

  DocumentField dateOfExpirationField = licenseFields.get("DateOfExpiration");
  if (dateOfExpirationField != null) {
    if (DocumentFieldType.DATE == dateOfExpirationField.getType()) {
      LocalDate expirationDate = dateOfExpirationField.getValueAsDate();
      System.out.printf("Document date of expiration: %s, confidence: %.2f%n",
        expirationDate, dateOfExpirationField.getConfidence());
    }
  }

  DocumentField documentNumberField = licenseFields.get("DocumentNumber");
  if (documentNumberField != null) {
    if (DocumentFieldType.STRING == documentNumberField.getType()) {
      String documentNumber = documentNumberField.getValueAsString();
      System.out.printf("Document number: %s, confidence: %.2f%n",
        documentNumber, documentNumberField.getConfidence());
    }
  }

  DocumentField firstNameField = licenseFields.get("FirstName");
  if (firstNameField != null) {
    if (DocumentFieldType.STRING == firstNameField.getType()) {
      String firstName = firstNameField.getValueAsString();
      System.out.printf("First Name: %s, confidence: %.2f%n",
        firstName, documentNumberField.getConfidence());
    }
  }

  DocumentField lastNameField = licenseFields.get("LastName");
  if (lastNameField != null) {
    if (DocumentFieldType.STRING == lastNameField.getType()) {
      String lastName = lastNameField.getValueAsString();
      System.out.printf("Last name: %s, confidence: %.2f%n",
        lastName, lastNameField.getConfidence());
    }
  }

  DocumentField regionField = licenseFields.get("Region");
  if (regionField != null) {
    if (DocumentFieldType.STRING == regionField.getType()) {
      String region = regionField.getValueAsString();
      System.out.printf("Region: %s, confidence: %.2f%n",
        region, regionField.getConfidence());
    }
  }
}
}
}

請造訪 GitHub 上的 Azure 範例存放庫，並檢視 id-document 模型輸出。

用戶端程式庫 (英文) | REST API 參考 (部分機器翻譯) | 套件 (npm) (英文) | 範例 (英文) |支援的 REST API 版本 (部分機器翻譯)

必要條件

• Azure 訂用帳戶 - 建立免費帳戶。

• 最新的 Visual Studio Code 版本或您慣用的 IDE。 如需詳細資訊，請參閱 Visual Studio Code 中的 Node.js。

• 最新LTS版的 Node.js (英文)。

• Azure AI 服務或文件智慧服務資源。 建立 single-service 或 multi-service。 您可以使用免費定價層 (F0) 來試用服務，之後可升級至付費層以用於實際執行環境。

  提示

  如果您打算使用單一端點和金鑰存取多個 Azure AI 服務，請建立 Azure AI 服務資源。 若為僅限文件智慧服務存取，請建立文件智慧服務資源。 如果您想要使用 Microsoft Entra 驗證，則需要使用單一服務資源。

• 從您所建立資源的金鑰和端點，將應用程式連線至 Azure 文件智慧服務。

  1. 部署資源之後，請選取 [移至資源]。
  2. 在左側導覽功能表中，選取 [金鑰和端點]。
  3. 複製其中一個金鑰和 [端點]，以供稍後在本文中使用。

  

• URL 的文件檔案。 在本專案中，您可以使用下表中針對每個功能所提供的範例表單：

  功能	modelID	document-url
  Read 模型	prebuilt-read	範例手冊
  版面配置模型	prebuilt-layout	範例預約確認
  W-2 表單模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	prebuilt-invoice	發票範例
  收據模型	prebuilt-receipt	範例收據
  識別碼文件模型	prebuilt-idDocument	範例身分證明文件

設定環境變數

若要與此文件智慧服務互動，您必須建立 DocumentAnalysisClient 類別的執行個體。 若要這樣做，請使用 key 和 endpoint 以從 Azure 入口網站將用戶端具現化。 在此專案中，使用環境變數來儲存和存取認證。

重要

請不要在您的程式碼中直接包括金鑰，而且不要公開張貼金鑰。 在生產環境中，請使用安全方式來儲存和存取 Azure Key Vault 等認證。 如需詳細資訊，請參閱 Azure AI 服務安全性。

若要設定文件智慧服務資源金鑰的環境變數，請開啟主控台視窗，並遵循作業系統和開發環境的指示進行。 將 <yourKey> 和 <yourEndpoint> 取代為 Azure 入口網站中資源的值。

Windows

Windows 中的環境變數不區分大小寫。 這些變數通常會以大寫方式宣告，並加上底線聯結的字組。 在命令提示字元中，執行下列命令：

1. 設定金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

3. 設定環境變數之後，請關閉 [命令提示字元] 視窗。 值會維持不變，直到您再次變更這些值為止。

4. 重新啟動任何讀取環境變數的執行中程式。 例如，如果您使用 Visual Studio 或 Visual Studio Code 作為編輯器，則請在執行範例程式碼之前重新啟動。

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
setx VARIABLE_NAME=	將值設定為空字串，以刪除環境變數。	setx DI_KEY=
setx VARIABLE_NAME=value	設定或變更環境變數的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	顯示特定環境變數的值。	set DI_KEY
set	顯示所有環境變數。	set

macOS

macOS 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止。 開啟您的終端機，然後輸入下列命令：

1. 設定金鑰變數：

   export key=<yourKey>
   

2. 設定端點變數：

   export endpoint=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bash_profile 啟動指令碼中，以永久設定環境變數：

1. 使用文字編輯器來開啟 ~/.bash_profile 檔案，並新增下列命令來建立永久環境變數：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

2. 將變更儲存至 bash_profile 檔案。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bash-profile
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示特定環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

Linux

Linux 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止：

1. 設定金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bashrc 啟動指令碼中，以永久設定環境變數：

1. 使用您慣用的文字編輯器來開啟 ~/.bashrc 檔案，並新增下列命令來建立永久環境變數：

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

2. 儲存對 .bashrc 檔案所做的變更。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bashrc
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY=
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

設定程式設計環境

建立 Node.js Express 應用程式。

1. 在主控台視窗中，為您的應用程式建立名為 doc-intel-app 的新目錄，並瀏覽至該目錄。

   mkdir doc-intel-app
   cd doc-intel-app
   

2. 執行 npm init 命令來初始化應用程式，並建構您的專案。

   npm init
   

3. 使用終端機中顯示的提示來指定專案的屬性。

   • 名稱、版本號碼和進入點是最重要的屬性。
   • 建議為進入點名稱保留 index.js。 描述、測試命令、GitHub 存放庫、關鍵字、作者和授權資訊皆為選擇性屬性。 在此專案中可以跳過。
   • 選取 Enter 以接受括號中的建議。

   完成提示後，將會在 doc-intel-app 目錄中建立 package.json 檔案。

4. 安裝 ai-document-intelligence 用戶端程式庫和 azure/identity npm 套件：

   npm i @azure-rest/ai-document-intelligence@1.0.0-beta.2 @azure/identity
   

您應用程式的 package.json 檔案會隨著相依項目更新。

1. 在應用程式目錄中建立名為 index.js 的檔案。

   提示

   您可以使用 PowerShell 建立新檔案。 按住 Shift 鍵並在資料夾上以滑鼠右鍵按一下，以開啟專案目錄中的 PowerShell 視窗，然後輸入下列命令：New-Item index.js。

建置您的 應用程式

若要與此文件智慧服務互動，您必須建立 DocumentIntelligenceClient 類別的執行個體。 若要這樣做，請使用您的金鑰從 Azure 入口網站建立 AzureKeyCredential，並使用 AzureKeyCredential 和文件智慧服務端點來建立 DocumentIntelligenceClient 執行個體。

在 Visual Studio Code 或您偏好的 IDE 中開啟 index.js 檔案，然後選取下列其中一個程式碼範例，並複製/貼至您的應用程式：

• prebuilt-read 模型是所有文件智慧服務模型的核心，而且可以偵測行、字組、位置和語言。 版面配置、一般文件、預建和自訂模型全都使用 read 模型做為從文件擷取文字的基礎。
• prebuilt-layout 模型會從文件和映像中擷取文字和文字位置、資料表、選取標記和結構資訊。
• prebuilt-tax.us.w2 模型會擷取美國內部營收服務 (IRS) 稅務表單上所報告的資訊。
• prebuilt-invoice 模型會擷取美國國稅局 (IRS) 稅務表單上所報告的資訊。
• prebuilt-receipt 模型會擷取印刷和手寫銷售收據的重要資訊。
• prebuilt-idDocument 模型會擷取美國駕照、國際護照個人資料頁、美國州別識別碼、社會安全卡和永久居民卡的重要資訊。

使用讀取模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

// sample document
const documentUrlRead = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png"

// helper function
function* getTextOfSpans(content, spans) {
    for (const span of spans) {
        yield content.slice(span.offset, span.offset + span.length);
    }
}

async function main() {
    // create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
    const client = DocumentIntelligence(endpoint, new AzureKeyCredential(key));
    const poller = await client.beginAnalyzeDocument("prebuilt-read", documentUrlRead);

    const {
        content,
        pages,
        languages,
        styles
    } = 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.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 (languages.length <= 0) {
        console.log("No language spans were extracted from the document.");
    } else {
        console.log("Languages:");
        for (const languageEntry of languages) {
            console.log(
                `- Found language: ${languageEntry.languageCode} (confidence: ${languageEntry.confidence})`
            );
            for (const text of getTextOfSpans(content, languageEntry.spans)) {
                const escapedText = text.replace(/\r?\n/g, "\\n").replace(/"/g, '\\"');
                console.log(`  - "${escapedText}"`);
            }
        }
    }

    if (styles.length <= 0) {
        console.log("No text styles were extracted from the document.");
    } else {
        console.log("Styles:");
        for (const style of styles) {
            console.log(
                `- Handwritten: ${style.isHandwritten ? "yes" : "no"} (confidence=${style.confidence})`
            );

            for (const word of getTextOfSpans(content, style.spans)) {
                console.log(`  - "${word}"`);
            }
        }
    }
}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

請造訪 GitHub 上的 Azure 範例存放庫，並檢視read模型輸出。

使用版面配置模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

// sample document
const layoutUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png"

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

    const poller = await client.beginAnalyzeDocument(
      "prebuilt-layout", layoutUrl);

    // Layout extraction produces basic elements such as pages, words, lines, etc. as well as information about the
    // appearance (styles) of textual elements.
    const { pages, tables } = await poller.pollUntilDone();

    if (!pages || 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 && page.lines.length} lines, ${page.words && 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 || 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);
  });

請造訪 GitHub 上的 Azure 範例存放庫，並檢視版面配置模型輸出。

請使用一般文件模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

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

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

    const poller = await client.beginAnalyzeDocument("prebuilt-document", documentUrl);

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

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

}

main().catch((error) => {
    console.error("An error occurred:", error);
    process.exit(1);
});

請造訪 GitHub 上的 Azure 範例存放庫，並檢視一般文件模型輸出。

使用 W-2 稅務模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

const w2DocumentURL = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png"

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

 const poller = await client.beginAnalyzeDocument("prebuilt-tax.us.w2", w2DocumentURL);

 const {
   documents: [result]
 } = await poller.pollUntilDone();

  if (result) {
    const { Employee, Employer, ControlNumber, TaxYear, AdditionalInfo } = result.fields;

    if (Employee) {
      const { Name, Address, SocialSecurityNumber } = Employee.properties;
      console.log("Employee:");
      console.log("  Name:", Name && Name.content);
      console.log("  SSN/TIN:", SocialSecurityNumber && SocialSecurityNumber.content);
      if (Address && Address.value) {
        const { streetAddress, postalCode } = Address.value;
        console.log("  Address:");
        console.log("    Street Address:", streetAddress);
        console.log("    Postal Code:", postalCode);
      }
    } else {
      console.log("No employee information extracted.");
    }

    if (Employer) {
      const { Name, Address, IdNumber } = Employer.properties;
      console.log("Employer:");
      console.log("  Name:", Name && Name.content);
      console.log("  ID (EIN):", IdNumber && IdNumber.content);

      if (Address && Address.value) {
        const { streetAddress, postalCode } = Address.value;
        console.log("  Address:");
        console.log("    Street Address:", streetAddress);
        console.log("    Postal Code:", postalCode);
      }
    } else {
      console.log("No employer information extracted.");
    }

    console.log("Control Number:", ControlNumber && ControlNumber.content);
    console.log("Tax Year:", TaxYear && TaxYear.content);

    if (AdditionalInfo) {
      console.log("Additional Info:");

      for (const info of AdditionalInfo.values) {
        const { LetterCode, Amount } = info.properties;
        console.log(`- ${LetterCode && LetterCode.content}: ${Amount && Amount.content}`);
      }
    }
  } else {
    throw new Error("Expected at least one document in the result.");
  }
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

請造訪 GitHub 上的 Azure 範例存放庫，以檢視 W-2 稅務模型輸出。

使用發票模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

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

async function main() {

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

  const poller = await client.beginAnalyzeDocument("prebuilt-invoice", invoiceUrl);

  const {
      documents: [result]
  } = await poller.pollUntilDone();

  if (result) {
      const invoice = result.fields;

      console.log("Vendor Name:", invoice.VendorName?.content);
      console.log("Customer Name:", invoice.CustomerName?.content);
      console.log("Invoice Date:", invoice.InvoiceDate?.content);
      console.log("Due Date:", invoice.DueDate?.content);

      console.log("Items:");
      for (const {
              properties: item
          } of invoice.Items?.values ?? []) {
          console.log("-", item.ProductCode?.content ?? "<no product code>");
          console.log("  Description:", item.Description?.content);
          console.log("  Quantity:", item.Quantity?.content);
          console.log("  Date:", item.Date?.content);
          console.log("  Unit:", item.Unit?.content);
          console.log("  Unit Price:", item.UnitPrice?.content);
          console.log("  Tax:", item.Tax?.content);
          console.log("  Amount:", item.Amount?.content);
      }

      console.log("Subtotal:", invoice.SubTotal?.content);
      console.log("Previous Unpaid Balance:", invoice.PreviousUnpaidBalance?.content);
      console.log("Tax:", invoice.TotalTax?.content);
      console.log("Amount Due:", invoice.AmountDue?.content);
  } else {
      throw new Error("Expected at least one receipt in the result.");
  }
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

請造訪 GitHub 上的 Azure 範例存放庫，並檢視發票模型輸出。

使用收據模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

// sample url
const receiptUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png";

async function main() {

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

    const poller = await client.beginAnalyzeDocument("prebuilt-receipt", receiptUrl);

    const {
        documents: [result]
    } = await poller.pollUntilDone();

    if (result) {
        const {
            MerchantName,
            Items,
            Total
        } = result.fields;

        console.log("=== Receipt Information ===");
        console.log("Type:", result.docType);
        console.log("Merchant:", MerchantName && MerchantName.content);

        console.log("Items:");
        for (const item of (Items && Items.values) || []) {
            const {
                Description,
                TotalPrice
            } = item.properties;

            console.log("- Description:", Description && Description.content);
            console.log("  Total Price:", TotalPrice && TotalPrice.content);
        }

        console.log("Total:", Total && Total.content);
    } else {
        throw new Error("Expected at least one receipt in the result.");
    }

}

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

請造訪 GitHub 上的 Azure 範例存放庫，並檢視收據模型輸出。

使用身分證明文件模型

const { DocumentIntelligenceClient } = require("@azure-rest/ai-document-intelligence");
const  { AzureKeyCredential } = require("@azure/core-auth");

//use your `key` and `endpoint` environment variables
const key = process.env['DI_KEY'];
const endpoint = process.env['DI_ENDPOINT'];

// sample document
const idDocumentURL = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png"

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

 const poller = await client.beginAnalyzeDocument("prebuilt-idDocument", idDocumentURL);

 const {
   documents: [result]
 } = await poller.pollUntilDone();

  if (result) {
// The identity document model has multiple document types, so we need to know which document type was actually
    extracted.
    if (result.docType === "idDocument.driverLicense") {
      const { FirstName, LastName, DocumentNumber, DateOfBirth, DateOfExpiration, Height, Weight, EyeColor, Endorsements, Restrictions, VehicleClassifications} = result.fields;

// For the sake of the example, we'll only show a few of the fields that are produced.
      console.log("Extracted a Driver License:");
      console.log("  Name:", FirstName && FirstName.content, LastName && LastName.content);
      console.log("  License No.:", DocumentNumber && DocumentNumber.content);
      console.log("  Date of Birth:", DateOfBirth && DateOfBirth.content);
      console.log("  Expiration:", DateOfExpiration && DateOfExpiration.content);
      console.log("  Height:", Height && Height.content);
      console.log("  Weight:", Weight && Weight.content);
      console.log("  Eye color:", EyeColor && EyeColor.content);
      console.log("  Restrictions:", Restrictions && Restrictions.content);
      console.log("  Endorsements:", Endorsements && Endorsements.content);
      console.log("  Class:", VehicleClassifications && VehicleClassifications.content);
    } else if (result.docType === "idDocument.passport") {
// The passport document type extracts and parses the Passport's machine-readable zone
      if (!result.fields.machineReadableZone) {
        throw new Error("No Machine Readable Zone extracted from passport.");
      }

      const {
        FirstName,
        LastName,
        DateOfBirth,
        Nationality,
        DocumentNumber,
        CountryRegion,
        DateOfExpiration,
      } = result.fields.machineReadableZone.properties;

      console.log("Extracted a Passport:");
      console.log("  Name:", FirstName && FirstName.content, LastName && LastName.content);
      console.log("  Date of Birth:", DateOfBirth && DateOfBirth.content);
      console.log("  Nationality:", Nationality && Nationality.content);
      console.log("  Passport No.:", DocumentNumber && DocumentNumber.content);
      console.log("  Issuer:", CountryRegion && CountryRegion.content);
      console.log("  Expiration Date:", DateOfExpiration && DateOfExpiration.content);
    } else {
// The only reason this would happen is if the client library's schema for the prebuilt identity document model is
      out of date, and a new document type has been introduced.
      console.error("Unknown document type in result:", result);
    }
  } else {
    throw new Error("Expected at least one receipt in the result.");
  }
}

main().catch((error) => {
  console.error("An error occurred:", error);
  process.exit(1);
});

請造訪 GitHub 上的 Azure 範例存放庫，並檢視 id-document 模型輸出。

用戶端程式庫 (英文) |SDK 參考 (英文) | REST API 參考 (部分機器翻譯) | 套件 (PyPi) (英文) | 範例 (英文) | 支援的 REST API 版本 (部分機器翻譯)

必要條件

• Azure 訂用帳戶 - 建立免費帳戶。

• Python 3.7 或更新版本 (英文)。 您安裝的 Python 應包含 pip。 您可以在命令列上執行 pip --version 來檢查是否已安裝 pip。 安裝最新版本的 Python 以取得 pip。

• 最新的 Visual Studio Code 版本或您慣用的 IDE。 請參閱 Visual Studio Code 中的 Python 使用者入門。

• Azure AI 服務或文件智慧服務資源。 建立 single-service 或 multi-service。 您可以使用免費定價層 (F0) 來試用服務，之後可升級至付費層以用於實際執行環境。

• 從您所建立資源的金鑰和端點，將應用程式連線至 Azure 文件智慧服務。

  1. 部署資源之後，請選取 [移至資源]。
  2. 在左側導覽功能表中，選取 [金鑰和端點]。
  3. 複製其中一個金鑰和 [端點]，以供稍後在本文中使用。

  

• URL 的文件檔案。 在本專案中，您可以使用下表中針對每個功能所提供的範例表單：

  功能	modelID	document-url
  Read 模型	prebuilt-read	範例手冊
  版面配置模型	prebuilt-layout	範例預約確認
  W-2 表單模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	prebuilt-invoice	發票範例
  收據模型	prebuilt-receipt	範例收據
  識別碼文件模型	prebuilt-idDocument	範例身分證明文件

設定環境變數

若要與此文件智慧服務互動，您必須建立 DocumentAnalysisClient 類別的執行個體。 若要這樣做，請使用 key 和 endpoint 以從 Azure 入口網站將用戶端具現化。 在此專案中，使用環境變數來儲存和存取認證。

重要

請不要在您的程式碼中直接包括金鑰，而且不要公開張貼金鑰。 在生產環境中，請使用安全方式來儲存和存取 Azure Key Vault 等認證。 如需詳細資訊，請參閱 Azure AI 服務安全性。

若要設定文件智慧服務資源金鑰的環境變數，請開啟主控台視窗，並遵循作業系統和開發環境的指示進行。 將 <yourKey> 和 <yourEndpoint> 取代為 Azure 入口網站中資源的值。

Windows

Windows 中的環境變數不區分大小寫。 這些變數通常會以大寫方式宣告，並加上底線聯結的字組。 在命令提示字元中，執行下列命令：

1. 設定金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

3. 設定環境變數之後，請關閉 [命令提示字元] 視窗。 值會維持不變，直到您再次變更這些值為止。

4. 重新啟動任何讀取環境變數的執行中程式。 例如，如果您使用 Visual Studio 或 Visual Studio Code 作為編輯器，則請在執行範例程式碼之前重新啟動。

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
setx VARIABLE_NAME=	將值設定為空字串，以刪除環境變數。	setx DI_KEY=
setx VARIABLE_NAME=value	設定或變更環境變數的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	顯示特定環境變數的值。	set DI_KEY
set	顯示所有環境變數。	set

macOS

macOS 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止。 開啟您的終端機，然後輸入下列命令：

1. 設定金鑰變數：

   export key=<yourKey>
   

2. 設定端點變數：

   export endpoint=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bash_profile 啟動指令碼中，以永久設定環境變數：

1. 使用文字編輯器來開啟 ~/.bash_profile 檔案，並新增下列命令來建立永久環境變數：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

2. 將變更儲存至 bash_profile 檔案。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bash-profile
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示特定環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

Linux

Linux 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止：

1. 設定金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bashrc 啟動指令碼中，以永久設定環境變數：

1. 使用您慣用的文字編輯器來開啟 ~/.bashrc 檔案，並新增下列命令來建立永久環境變數：

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

2. 儲存對 .bashrc 檔案所做的變更。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bashrc
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY=
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

設定程式設計環境

在本機環境中開啟終端機主控台視窗，並使用 pip 安裝適用於 Python 的 Azure AI 文件智慧服務用戶端程式庫：

pip install azure-ai-documentintelligence==1.0.0b2

建立 Python 應用程式

若要與此文件智慧服務互動，您必須建立 DocumentIntelligenceClient 類別的執行個體。 若要這樣做，請使用您的金鑰從 Azure 入口網站建立 AzureKeyCredential，並使用 AzureKeyCredential 和文件智慧服務端點來建立 DocumentIntelligenceClient 執行個體。

1. 在編輯器或 IDE 中建立一個名為 form_recognizer_quickstart.py 的新 Python 檔案。

2. 開啟 form_recognizer_quickstart.py 檔案，然後選取下列其中一個程式碼範例，並複製/貼上您的應用程式：

   • prebuilt-read 模型是所有文件智慧服務模型的核心，而且可以偵測行、字組、位置和語言。 版面配置、一般文件、預建和自訂模型全都使用 read 模型做為從文件擷取文字的基礎。
   • prebuilt-layout 模型會從文件和映像中擷取文字和文字位置、資料表、選取標記和結構資訊。
   • prebuilt-tax.us.w2 模型會擷取美國內部營收服務 (IRS) 稅務表單上所報告的資訊。
   • prebuilt-invoice 模型會以各種格式從銷售發票擷取重要欄位和明細行項目。
   • prebuilt-receipt 模型會擷取印刷和手寫銷售收據的重要資訊。
   • prebuilt-idDocument 模型會擷取美國駕照、國際護照個人資料頁、美國州別識別碼、社會安全卡和永久居民卡的重要資訊。

3. 從命令提示字元執行 Python 程式碼。

   python form_recognizer_quickstart.py
   

使用讀取模型

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

# use your `key` and `endpoint` environment variables
key = os.environ.get('DI_KEY')
endpoint = os.environ.get('DI_ENDPOINT')

# 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_read():
    # sample document
    formUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png"

    client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = client.begin_analyze_document(
        "prebuilt-read", AnalyzeDocumentRequest(url_source=formUrl
    ))
    result: AnalyzeResult = poller.result()

    print("----Languages detected in the document----")
    if result.languages is not None:
        for language in result.languages:
            print(f"Language code: '{language.locale}' with confidence {language.confidence}")

    print("----Styles detected in the document----")
    if result.styles:
        for style in result.styles:
            if style.is_handwritten:
                print("Found the following handwritten content: ")
                print(",".join([result.content[span.offset : span.offset + span.length] for span in style.spans]))
            if style.font_style:
                print(f"The document contains '{style.font_style}' font style, applied to the following text: ")
                print(",".join([result.content[span.offset : span.offset + span.length] for span in style.spans]))

    for page in result.pages:
        print(f"----Analyzing document 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 {len(words)} words and text '{line.content}' 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.paragraphs:
        print(f"----Detected #{len(result.paragraphs)} paragraphs in the document----")
        for paragraph in result.paragraphs:
            print(f"Found paragraph with role: '{paragraph.role}' within {paragraph.bounding_regions} bounding region")
            print(f"...with content: '{paragraph.content}'")

        result.paragraphs.sort(key=lambda p: (p.spans.sort(key=lambda s: s.offset), p.spans[0].offset))
        print("-----Print sorted paragraphs-----")
        for idx, paragraph in enumerate(result.paragraphs):
            print(
                f"...paragraph:{idx} with offset: {paragraph.spans[0].offset} and length: {paragraph.spans[0].length}"
            )

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


if __name__ == "__main__":
    analyze_read()

檢視 GitHub 上的完整程式碼。其他範例

請造訪 GitHub 上的 Azure 範例存放庫，並檢視 read 模型輸出。

使用版面配置模型

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult


# use your `key` and `endpoint` environment variables
key = os.environ.get('DI_KEY')
endpoint = os.environ.get('DI_ENDPOINT')


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

    client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = 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()

檢視 GitHub 上的完整程式碼。其他範例

請造訪 GitHub 上的 Azure 範例存放庫，並檢視版面配置模型輸出。

使用 W-2 稅務模型

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

# use your `key` and `endpoint` environment variables
key = os.environ.get('DI_KEY')
endpoint = os.environ.get('DI_ENDPOINT')

# formatting function
def format_address_value(address_value):
    return f"\n......House/building number: {address_value.house_number}\n......Road: {address_value.road}\n......City: {address_value.city}\n......State: {address_value.state}\n......Postal code: {address_value.postal_code}"


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

    client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = client.begin_analyze_document(
        "prebuilt-tax.us.w2",  AnalyzeDocumentRequest(url_source=formUrl
    ))

    w2s: AnalyzeResult =  poller.result()

        if w2s.documents:
        for idx, w2 in enumerate(w2s.documents):
            print(f"--------Analyzing US Tax W-2 Form #{idx + 1}--------")
            if w2.fields:
                form_variant = w2.fields.get("W2FormVariant")
                if form_variant:
                    print(
                        f"Form variant: {form_variant.get('valueString')} has confidence: " f"{form_variant.confidence}"
                    )
                tax_year = w2.fields.get("TaxYear")
                if tax_year:
                    print(f"Tax year: {tax_year.get('valueString')} has confidence: {tax_year.confidence}")
                w2_copy = w2.fields.get("W2Copy")
                if w2_copy:
                    print(f"W-2 Copy: {w2_copy.get('valueString')} has confidence: {w2_copy.confidence}")
                employee = w2.fields.get("Employee")
                if employee:
                    print("Employee data:")
                    employee_name = employee.get("valueObject").get("Name")
                    if employee_name:
                        f"confidence: {fed_income_tax_withheld.confidence}"
                    )
                social_security_wages = w2.fields.get("SocialSecurityWages")
                if social_security_wages:
                    print(
                        f"Social Security wages: {social_security_wages.get('valueNumber')} has confidence: "
                        f"{social_security_wages.confidence}"
                    )
                social_security_tax_withheld = w2.fields.get("SocialSecurityTaxWithheld")
                if social_security_tax_withheld:
                    print(
                        f"Social Security tax withheld: {social_security_tax_withheld.get('valueNumber')} "
                        f"has confidence: {social_security_tax_withheld.confidence}"
                    )
                medicare_wages_tips = w2.fields.get("MedicareWagesAndTips")
                if medicare_wages_tips:
                    print(
                        f"Medicare wages and tips: {medicare_wages_tips.get('valueNumber')} has confidence: "
                        f"{medicare_wages_tips.confidence}"
                    )
                medicare_tax_withheld = w2.fields.get("MedicareTaxWithheld")
                if medicare_tax_withheld:
                    print(
                        f"Medicare tax withheld: {medicare_tax_withheld.get('valueNumber')} has confidence: "
                        f"{medicare_tax_withheld.confidence}"
                    )
                social_security_tips = w2.fields.get("SocialSecurityTips")
                if social_security_tips:
                    print(
                        f"Social Security tips: {social_security_tips.get('valueNumber')} has confidence: "
                        f"{social_security_tips.confidence}"
                    )
                allocated_tips = w2.fields.get("AllocatedTips")
                if allocated_tips:
                    print(
                        f"Allocated tips: {allocated_tips.get('valueNumber')} has confidence: {allocated_tips.confidence}"
                    )
                verification_code = w2.fields.get("VerificationCode")
                if verification_code:
                    print(
                        f"Verification code: {verification_code.get('valueNumber')} has confidence: {verification_code.confidence}"
                    )
                dependent_care_benefits = w2.fields.get("DependentCareBenefits")
                if dependent_care_benefits:
                    print(
                        f"Dependent care benefits: {dependent_care_benefits.get('valueNumber')} has confidence: {dependent_care_benefits.confidence}"
                    )
                non_qualified_plans = w2.fields.get("NonQualifiedPlans")
                if non_qualified_plans:
                    print(
                        f"Non-qualified plans: {non_qualified_plans.get('valueNumber')} has confidence: {non_qualified_plans.confidence}"
                    )
                additional_info = w2.fields.get("AdditionalInfo")
                if additional_info:
                    print("Additional information:")
                    for item in additional_info.get("valueArray"):
                        letter_code = item.get("valueObject").get("LetterCode")
                        if letter_code:
                            print(
                                f"...Letter code: {letter_code.get('valueString')} has confidence: {letter_code.confidence}"
                            )
                        amount = item.get("valueObject").get("Amount")
                        if amount:
                            print(f"...Amount: {amount.get('valueNumber')} has confidence: {amount.confidence}")
                is_statutory_employee = w2.fields.get("IsStatutoryEmployee")
                if is_statutory_employee:
                    print(
                        f"Is statutory employee: {is_statutory_employee.get('valueString')} has confidence: {is_statutory_employee.confidence}"
                    )
                is_retirement_plan = w2.fields.get("IsRetirementPlan")
                if is_retirement_plan:
                    print(
                        f"Is retirement plan: {is_retirement_plan.get('valueString')} has confidence: {is_retirement_plan.confidence}"
                    )
                third_party_sick_pay = w2.fields.get("IsThirdPartySickPay")
                if third_party_sick_pay:
                    print(
                        f"Is third party sick pay: {third_party_sick_pay.get('valueString')} has confidence: {third_party_sick_pay.confidence}"
                    )
                other_info = w2.fields.get("Other")
                if other_info:
                    print(f"Other information: {other_info.get('valueString')} has confidence: {other_info.confidence}")
                state_tax_info = w2.fields.get("StateTaxInfos")
                if state_tax_info:
                    print("State Tax info:")
                    for tax in state_tax_info.get("valueArray"):
                        state = tax.get("valueObject").get("State")
                        if state:
                            print(f"...State: {state.get('valueString')} has confidence: {state.confidence}")
                        employer_state_id_number = tax.get("valueObject").get("EmployerStateIdNumber")
                        if employer_state_id_number:
                            print(
                                f"...Employer state ID number: {employer_state_id_number.get('valueString')} has "
                                f"confidence: {employer_state_id_number.confidence}"
                            )
                        state_wages_tips = tax.get("valueObject").get("StateWagesTipsEtc")
                        if state_wages_tips:
                            print(
                                f"...State wages, tips, etc: {state_wages_tips.get('valueNumber')} has confidence: "
                                f"{state_wages_tips.confidence}"
                            )
                        state_income_tax = tax.get("valueObject").get("StateIncomeTax")
                        if state_income_tax:
                            print(
                                f"...State income tax: {state_income_tax.get('valueNumber')} has confidence: "
                                f"{state_income_tax.confidence}"
                            )
                local_tax_info = w2.fields.get("LocalTaxInfos")
                if local_tax_info:
                    print("Local Tax info:")
                    for tax in local_tax_info.get("valueArray"):
                        local_wages_tips = tax.get("valueObject").get("LocalWagesTipsEtc")
                        if local_wages_tips:
                            print(
                                f"...Local wages, tips, etc: {local_wages_tips.get('valueNumber')} has confidence: "
                                f"{local_wages_tips.confidence}"
                            )
                        local_income_tax = tax.get("valueObject").get("LocalIncomeTax")
                        if local_income_tax:
                            print(
                                f"...Local income tax: {local_income_tax.get('valueNumber')} has confidence: "
                                f"{local_income_tax.confidence}"
                            )
                        locality_name = tax.get("valueObject").get("LocalityName")
                        if locality_name:
                            print(
                                f"...Locality name: {locality_name.get('valueString')} has confidence: "
                                f"{locality_name.confidence}"
                            )


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


if __name__ == "__main__":
    analyze_tax_us_w2()

檢視 GitHub 上的完整程式碼。其他範例

請造訪 GitHub 上的 Azure 範例存放庫，以檢視 W-2 稅務模型輸出。

使用發票模型

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

# use your `key` and `endpoint` environment variables
key = os.environ.get('DI_KEY')
endpoint = os.environ.get('DI_ENDPOINT')

def analyze_invoice():

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

    client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = client.begin_analyze_document(
        "prebuilt-invoice", AnalyzeDocumentRequest(url_source=formUrl), locale="en-US")

    result: AnalyzeResult = poller.result()

    if invoices.documents:
        for idx, invoice in enumerate(invoices.documents):
            print(f"--------Analyzing invoice #{idx + 1}--------")
            if invoice.fields:
                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 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:")
                items = invoice.fields.get("Items")
                if items:
                    for idx, item in enumerate(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()

檢視 GitHub 上的完整程式碼。其他範例

請造訪 GitHub 上的 Azure 範例存放庫，並檢視發票模型輸出。

使用收據模型

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

# use your `key` and `endpoint` environment variables
key = os.environ.get('DI_KEY')
endpoint = os.environ.get('DI_ENDPOINT')

def analyze_receipts():
    # sample document
    receiptUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png"

   client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )
    poller = client.begin_analyze_document(
        "prebuilt-receipt", AnalyzeDocumentRequest(url_source=receiptUrl), locale="en-US"
    )
    receipts: AnalyzeResult = poller.result()

    if receipts.documents:
        for idx, receipt in enumerate(receipts.documents):
            print(f"--------Analysis of receipt #{idx + 1}--------")
            print(f"Receipt type: {receipt.doc_type if receipt.doc_type else 'N/A'}")
            if receipt.fields:
                merchant_name = receipt.fields.get("MerchantName")
                if merchant_name:
                    print(
                        f"Merchant Name: {merchant_name.get('valueString')} has confidence: "
                        f"{merchant_name.confidence}"
                    )
                transaction_date = receipt.fields.get("TransactionDate")
                if transaction_date:
                    print(
                        f"Transaction Date: {transaction_date.get('valueDate')} has confidence: "
                        f"{transaction_date.confidence}"
                    )
                items = receipt.fields.get("Items")
                if items:
                    print("Receipt items:")
                    for idx, item in enumerate(items.get("valueArray")):
                        print(f"...Item #{idx + 1}")
                        item_description = item.get("valueObject").get("Description")
                        if item_description:
                            print(
                                f"......Item Description: {item_description.get('valueString')} has confidence: "
                                f"{item_description.confidence}"
                            )
                        item_quantity = item.get("valueObject").get("Quantity")
                        if item_quantity:
                            print(
                                f"......Item Quantity: {item_quantity.get('valueString')} has confidence: "
                                f"{item_quantity.confidence}"
                            )
                        item_total_price = item.get("valueObject").get("TotalPrice")
                        if item_total_price:
                            print(
                                f"......Total Item Price: {format_price(item_total_price.get('valueCurrency'))} has confidence: "
                                f"{item_total_price.confidence}"
                            )
                subtotal = receipt.fields.get("Subtotal")
                if subtotal:
                    print(
                        f"Subtotal: {format_price(subtotal.get('valueCurrency'))} has confidence: {subtotal.confidence}"
                    )
                tax = receipt.fields.get("TotalTax")
                if tax:
                    print(f"Total tax: {format_price(tax.get('valueCurrency'))} has confidence: {tax.confidence}")
                tip = receipt.fields.get("Tip")
                if tip:
                    print(f"Tip: {format_price(tip.get('valueCurrency'))} has confidence: {tip.confidence}")
                total = receipt.fields.get("Total")
                if total:
                    print(f"Total: {format_price(total.get('valueCurrency'))} has confidence: {total.confidence}")
            print("--------------------------------------")



if __name__ == "__main__":
    analyze_receipts()

檢視 GitHub 上的完整程式碼。其他範例

請造訪 GitHub 上的 Azure 範例存放庫，並檢視收據模型輸出。

使用身分證明文件模型

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

# use your `key` and `endpoint` environment variables
key = os.environ.get('DI_KEY')
endpoint = os.environ.get('DI_ENDPOINT')

def analyze_identity_documents():
# sample document
    identityUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png"

   client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller =client.begin_analyze_document(
            "prebuilt-idDocument", AnalyzeDocumentRequest(url_source=identityUrl)
        )
     id_documents: AnalyzeResult = poller.result()

    if id_documents.documents:
        for idx, id_document in enumerate(id_documents.documents):
            print(f"--------Analyzing ID document #{idx + 1}--------")
            if id_document.fields:
                first_name = id_document.fields.get("FirstName")
                if first_name:
                    print(f"First Name: {first_name.get('valueString')} has confidence: {first_name.confidence}")
                last_name = id_document.fields.get("LastName")
                if last_name:
                    print(f"Last Name: {last_name.get('valueString')} has confidence: {last_name.confidence}")
                document_number = id_document.fields.get("DocumentNumber")
                if document_number:
                    print(
                        f"Document Number: {document_number.get('valueString')} has confidence: {document_number.confidence}"
                    )
                dob = id_document.fields.get("DateOfBirth")
                if dob:
                    print(f"Date of Birth: {dob.get('valueDate')} has confidence: {dob.confidence}")
                doe = id_document.fields.get("DateOfExpiration")
                if doe:
                    print(f"Date of Expiration: {doe.get('valueDate')} has confidence: {doe.confidence}")
                sex = id_document.fields.get("Sex")
                if sex:
                    print(f"Sex: {sex.get('valueString')} has confidence: {sex.confidence}")
                address = id_document.fields.get("Address")
                if address:
                    print(f"Address: {address.get('valueString')} has confidence: {address.confidence}")
                country_region = id_document.fields.get("CountryRegion")
                if country_region:
                    print(
                        f"Country/Region: {country_region.get('valueCountryRegion')} has confidence: {country_region.confidence}"
                    )
                region = id_document.fields.get("Region")
                if region:
                    print(f"Region: {region.get('valueString')} has confidence: {region.confidence}")


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

if __name__ == "__main__":
    analyze_identity_documents()

檢視 GitHub 上的完整程式碼。其他範例

請造訪 GitHub 上的 Azure 範例存放庫，並檢視識別碼文件模型輸出。

注意

此專案使用 cURL 命令列工具來執行 REST API 呼叫。

| 文件智慧服務 REST API (部分機器翻譯) | 支援的 Azure SDK (部分機器翻譯)

必要條件

• Azure 訂用帳戶 - 建立免費帳戶。

• 已安裝 cURL 命令列工具。 Windows 10 和 Windows 11 隨附 cURL 的複本。 在命令提示字元中，輸入下列 cURL 命令。 如果顯示說明選項，則會在您的 Windows 環境中安裝 cURL。

  curl -help
  

  如果未安裝 cURL，您可以在這裡取得：

  • Windows
  • Mac 或 Linux

• Azure AI 服務或文件智慧服務資源。 建立 single-service 或 multi-service。 您可以使用免費定價層 (F0) 來試用服務，之後可升級至付費層以用於實際執行環境。

• 從您所建立資源的金鑰和端點，將應用程式連線至 Azure 文件智慧服務。

  1. 部署資源之後，請選取 [移至資源]。
  2. 在左側導覽功能表中，選取 [金鑰和端點]。
  3. 複製其中一個金鑰和 [端點]，以供稍後在本文中使用。

  

設定環境變數

若要與此文件智慧服務互動，您必須建立 DocumentAnalysisClient 類別的執行個體。 若要這樣做，請使用 key 和 endpoint 以從 Azure 入口網站將用戶端具現化。 在此專案中，使用環境變數來儲存和存取認證。

重要

請不要在您的程式碼中直接包括金鑰，而且不要公開張貼金鑰。 在生產環境中，請使用安全方式來儲存和存取 Azure Key Vault 等認證。 如需詳細資訊，請參閱 Azure AI 服務安全性。

若要設定文件智慧服務資源金鑰的環境變數，請開啟主控台視窗，並遵循作業系統和開發環境的指示進行。 將 <yourKey> 和 <yourEndpoint> 取代為 Azure 入口網站中資源的值。

Windows

Windows 中的環境變數不區分大小寫。 這些變數通常會以大寫方式宣告，並加上底線聯結的字組。 在命令提示字元中，執行下列命令：

1. 設定金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

3. 設定環境變數之後，請關閉 [命令提示字元] 視窗。 值會維持不變，直到您再次變更這些值為止。

4. 重新啟動任何讀取環境變數的執行中程式。 例如，如果您使用 Visual Studio 或 Visual Studio Code 作為編輯器，則請在執行範例程式碼之前重新啟動。

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
setx VARIABLE_NAME=	將值設定為空字串，以刪除環境變數。	setx DI_KEY=
setx VARIABLE_NAME=value	設定或變更環境變數的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	顯示特定環境變數的值。	set DI_KEY
set	顯示所有環境變數。	set

macOS

macOS 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止。 開啟您的終端機，然後輸入下列命令：

1. 設定金鑰變數：

   export key=<yourKey>
   

2. 設定端點變數：

   export endpoint=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bash_profile 啟動指令碼中，以永久設定環境變數：

1. 使用文字編輯器來開啟 ~/.bash_profile 檔案，並新增下列命令來建立永久環境變數：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

2. 將變更儲存至 bash_profile 檔案。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bash-profile
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示特定環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

Linux

Linux 中的環境變數區分大小寫。 依慣例，系統會以大寫字母宣告變數名稱。

export 命令會設定變數，並將其匯出至全域環境，其可供其他程序使用。 不過，值只是暫時的，而且只會持續到您關閉終端機工作階段為止：

1. 設定金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要將匯出命令放在 Bash ~/.bashrc 啟動指令碼中，以永久設定環境變數：

1. 使用您慣用的文字編輯器來開啟 ~/.bashrc 檔案，並新增下列命令來建立永久環境變數：

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

2. 儲存對 .bashrc 檔案所做的變更。

3. 若要使變更生效，請從終端機視窗執行下列命令：

   source ~/.bashrc
   

以下是一些更實用的命令，可與環境變數搭配使用：

Command	動作	範例
unset VARIABLE_NAME	刪除環境變數。	unset DI_KEY=
export VARIABLE_NAME=value	設定或變更暫存環境變數的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	顯示環境變數的值。 使用 echo 指令，在變數前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	顯示所有環境變數。	printenv

分析文件並取得結果

POST 要求可用來以預建或自訂模型分析文件。 GET 要求可用來擷取文件分析呼叫的結果。 modelId 用於 POST 作業，resultId 則用於 GET 作業。

使用下表做為參考。 將 <modelId> 和 <document-url> 取代為您所需的值：

模型	modelId	description	document-url
Read 模型	prebuilt-read	範例手冊	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
版面配置模型	prebuilt-layout	範例預約確認	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
W-2 表單模型	prebuilt-tax.us.w2	範例 W-2 表單	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
發票模型	prebuilt-invoice	發票範例	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
收據模型	prebuilt-receipt	範例收據	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
識別碼文件模型	prebuilt-idDocument	範例身分證明文件	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

POST 要求

開啟主控台視窗，然後執行下列 cURL 命令: 在上述〈設定環境變數〉一節中所建立的端點和重要環境變數。 如果您的變數名稱不同，則請取代這些變數。 請記得取代 <modelId> 和 <document-url> 參數。

curl -i -X POST "%DI_ENDPOINT%/documentintelligence/documentModels/{modelId}:analyze?api-version=2024-02-29-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: %DI_KEY%" --data-ascii "{'urlSource': '<document-url>'}"

若要啟用附加元件功能，請使用 POST 要求中的 features 查詢參數。 2023-07-31 (GA) 版本和更新版本共提供四個附加元件功能：ocr.highResolution、ocr.formula、ocr.font 和 queryFields.premium。 若要一一了解這些功能，請參閱自訂模型。

您只能呼叫 Read 和 Layout 模型的 highResolution、公式和字型功能，以及一般文件模型的 queryFields 功能。 下列範例示範如何呼叫 Layout 模型的 highResolution、公式和字型功能。

curl -i -X POST "%DI_ENDPOINT%documentintelligence/documentModels/prebuilt-layout:analyze?features=ocr.highResolution,ocr.formula,ocr.font?api-version=2024-02-29-preview" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: %DI_KEY%" --data-ascii "{'urlSource': '<document-url>'}"

POST 回應

您收到 202 (Success) 回應，其中包含 Operation-location 標頭。 使用此標頭的值來擷取回應結果。

取得分析結果 (GET 要求)

呼叫 Analyze document API 之後，請呼叫 [Get analyze result}(/rest/api/aiservices/document-models/get-analyze-result?view=rest-aiservices-2024-02-29-preview&preserve-view=true&tabs=HTTP) API，以取得作業的狀態和擷取的資料。

cURL 命令列工具不會格式化包含 JSON 內容的 API 回應，而這樣會讓內容難以閱讀。 若要格式化 JSON 回應，請包含管道字元，後面接著具有 GET 要求的 JSON 格式設定工具。

Windows

使用 NodeJS「json 工具」作為 cURL 的 JSON 格式器。 如果您尚未安裝 Node.js，則請下載並安裝最新版本。

1. 開啟主控台視窗，並使用下列命令安裝 json 工具：

   npm install -g jsontool
   

2. 包括管道字元 | json 與 GET 要求，以最適當地列印 JSON 輸出

   curl -i -X GET "<endpoint>documentintelligence/documentModels/prebuilt-read/analyzeResults/0e49604a-2d8e-4b15-b6b8-bb456e5d3e0a?api-version=2024-02-29-preview"-H "Ocp-Apim-Subscription-Key: <subscription key>" | json
   

macOS

json_pp 命令工具隨附於 macOS，而且可以用作 cURL 的 JSON 格式器。

• 包括 | json_pp 與您的 GET 要求，以最適當地列印 JSON 輸出。

  curl -i -X GET "{endpoint}documentintelligence/documentModels/prebuilt-read/analyzeResults/0e49604a-2d8e-4b15-b6b8-bb456e5d3e0a?api-version=2024-02-29-preview"-H "Ocp-Apim-Subscription-Key: <subscription key>" | json_pp
  

Linux

json_pp 命令列工具已預先安裝於大部分的 Linux 散發套件中。 如果未包含此工具，則您可以使用散發的套件管理員來進行安裝。

• 包括 | json_pp 與您的 GET 要求，以最適當地列印 JSON 輸出。

  curl -i -X GET "<endpoint>documentintelligence/documentModels/prebuilt-read/analyzeResults/0e49604a-2d8e-4b15-b6b8-bb456e5d3e0a?api-version=2024-02-29-preview"-H "Ocp-Apim-Subscription-Key: <subscription key>" | json_pp
  

GET 要求

在執行下列命令前，請進行變更：

• 將 <POST 回應>取代為 POST 回應中的 Operation-location 標頭。
• 如果與程式碼中的名稱不同，請將 <DI_KEY 取代為您環境變數的變數。
• 將 *<json-tool> 取代為您的 JSON 格式工具。

curl -i -X GET "<POST response>" -H "Ocp-Apim-Subscription-Key: %DI_KEY%" | `<json-tool>`

檢查回應

您收到 200 (Success) 回應及 JSON 輸出。 第一個 status 欄位會指出作業的狀態。 如果工作未完成，則的值 status 為 running 或 notStarted。 手動或透過指令碼再次呼叫 API。 我們建議您在每個呼叫之前間隔一秒以上的時間。

請造訪 GitHub 上的 Azure 範例存放庫，以檢視每個文件智慧服務模型的 GET 回應：

模型	輸出 URL
Read 模型	讀取模型輸出
版面配置模型	版面配置模型輸出
W-2 稅務模型	W-2 稅務模型輸出
發票模型	發票模型輸出
收據模型	收據模型輸出
識別碼文件模型	識別碼文件模型輸出

下一步

恭喜！ 您了解如何使用文件智慧服務模型，以不同方式分析各種文件。 接下來，請探索文件智慧服務工作室和參考文件。

嘗試使用 Document Intelligence Studio探索文件智慧服務 REST API