使用文件智能模型

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

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

Azure AI 檔智慧是雲端式 Azure AI 服務，使用機器學習從檔中擷取主要文字和結構元素。 建議您在了解技術時使用免費服務。 請記住，免費的頁數限制為每個月 500 頁。

從下列檔智慧模型中選擇，並從表單和檔中分析及擷取資料和值：

• 預建的讀取 模型是所有文檔智能模型的核心，並且可以偵測行、文字、位置和語言。 版面配置、一般檔、預先建置和自定義模型全都使用 read 模型作為從檔擷取文字的基礎。

• prebuilt-layout 模型會從文件和影像中擷取文字和文字位置、表格、選取標記和結構資訊。 您可以使用布局模型並啟用可選的查詢字串參數 features=keyValuePairs 擷取索引鍵/值組。

• 預先設計的合約 模型會從合約中提取關鍵資訊。

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

• 預先建置的稅務檔模型 模型會擷取美國稅務表格上報告的資訊。

• 預設發票 模型會從各種格式和品質的銷售發票中擷取關鍵欄位和明細項目。 欄位包括手機擷取的影像、掃描的檔和數位 PDF。

• 預建收據 模型會從印刷和手寫的銷售收據中擷取重要資訊。

• 預建的idDocument 模型會從美國駕駛執照、國際護照傳記頁面、美國州標識碼、社會保障卡和永久居民卡中擷取重要資訊。

用戶端連結庫 |REST API 參考 | 套件| 範例|支援的 REST API 版本

先決條件

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

• Visual Studio IDE。

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

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

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

  

• 位於 URL 位置的文件檔案。 針對此專案，您可以使用下表中針對每項功能的範例表單：

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

設定環境變數

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

這很重要

請謹慎使用 API 金鑰。 請勿在程式碼中直接包含 API 金鑰，且切勿公開張貼金鑰。 如果您使用 API 金鑰，請安全地將其儲存在 Azure 金鑰保存庫。 如需在應用程式中安全地使用 API 金鑰的詳細資訊，請參閱搭配 Azure 金鑰保存庫 的 API 金鑰。

如需 AI 服務安全性的詳細資訊，請參閱驗證對 Azure AI 服務的要求。

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

Windows

Windows 中的環境變數不會區分大小寫。 它們通常會以大寫方式宣告，單字之間以底線連結。 在命令提示字元中，執行下列命令：

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

命令	動作	範例
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
   

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

命令	動作	範例
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
   

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

命令	動作	範例
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.DocumentIntelligence。

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

建置您的 應用程式

備註

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

當您使用較新版本時，只需要撰寫 Main 方法的主體。 您不需要包含最上層陳述式、全域 using 指示詞或隱含 using 指示詞。 如需詳細資訊，請參閱 C# 主控台應用程式範本會產生最上層陳述式 (部分內容可能是機器或 AI 翻譯)。

1. 開啟 Program.cs 檔案。

2. 刪除現有的程式代碼，包括行 Console.Writeline("Hello World!")。

3. 選取下列其中一個程式代碼範例，並將/貼到應用程式的 Program.cs 檔案中：

   • prebuilt-read
   • 預建佈局
   • prebuilt-tax.us.w2
   • 預建發票
   • prebuilt-receipt
   • prebuilt-idDocument

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

   

使用 Read 模型

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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.Polygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.Polygon[j].X}, Y: {line.Polygon[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 模型輸出。

使用 Layout 模型

using Azure;
using Azure.AI.DocumentIntelligence;

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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.Polygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.Polygon[j].X}, Y: {line.Polygon[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.Polygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.Polygon[j].X}, Y: {selectionMark.Polygon[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.DocumentIntelligence;

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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.Polygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.Polygon[j].X}, Y: {line.Polygon[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.Polygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.Polygon[j].X}, Y: {selectionMark.Polygon[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.DocumentIntelligence;

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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.DocumentIntelligence;

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);

AnalyzeResult result = operation.Value;

for (int i = 0; i < result.Documents.Count; i++)
{
    Console.WriteLine($"Document {i}:");

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
    {
        if (vendorNameField.FieldType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.Value.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

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

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

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

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

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

                    if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
                    {
                        if (itemAmountField.FieldType == DocumentFieldType.Currency)
                        {
                            CurrencyValue itemAmount = itemAmountField.Value.AsCurrency();

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

    if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField))
    {
        if (subTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue subTotal = subTotalField.Value.AsCurrency();
            Console.WriteLine($"Sub Total: '{subTotal.Symbol}{subTotal.Amount}', with confidence {subTotalField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField))
    {
        if (totalTaxField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue totalTax = totalTaxField.Value.AsCurrency();
            Console.WriteLine($"Total Tax: '{totalTax.Symbol}{totalTax.Amount}', with confidence {totalTaxField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField))
    {
        if (invoiceTotalField.FieldType == DocumentFieldType.Currency)
        {
            CurrencyValue invoiceTotal = invoiceTotalField.Value.AsCurrency();
            Console.WriteLine($"Invoice Total: '{invoiceTotal.Symbol}{invoiceTotal.Amount}', with confidence {invoiceTotalField.Confidence}");
        }
    }
}

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

使用收據模型

using Azure;
using Azure.AI.DocumentIntelligence;

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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.DocumentIntelligence;

//use your `key` and `endpoint` environment variables to create your `AzureKeyCredential` and `DocumentIntelligenceClient` instances
string key = Environment.GetEnvironmentVariable("DI_KEY");
string endpoint = Environment.GetEnvironmentVariable("DI_ENDPOINT");
AzureKeyCredential credential = new AzureKeyCredential(key);
DocumentIntelligenceClient client = new DocumentIntelligenceClient(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");

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(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 範例存放庫，並檢視 識別碼檔案模型輸出。

用戶端連結庫 | REST API 參考 | 套件 （Maven） | 範例 |支援的 REST API 版本

先決條件

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

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

  • Visual Studio Code 為適用於 Windows 和 macOS 的 Java 提供 程式代碼套件。 程式代碼撰寫套件是一組 VS Code、Java Development Kit （JDK），以及Microsoft所建議延伸模組的集合。 編碼套件也可以用於修正現有的開發環境。
  • 如果您使用 VS Code 和適用於 Java 的編碼套件，請安裝適用於 Java 的 Gradle 擴充功能。

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

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

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

  小提示

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

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

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

  

• URL 的文件檔案。 針對此專案，您可以使用下表中針對每項功能的範例表單：

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

設定環境變數

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

這很重要

請謹慎使用 API 金鑰。 請勿在程式碼中直接包含 API 金鑰，且切勿公開張貼金鑰。 如果您使用 API 金鑰，請安全地將其儲存在 Azure 金鑰保存庫。 如需在應用程式中安全地使用 API 金鑰的詳細資訊，請參閱搭配 Azure 金鑰保存庫 的 API 金鑰。

如需 AI 服務安全性的詳細資訊，請參閱驗證對 Azure AI 服務的要求。

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

Windows

Windows 中的環境變數不會區分大小寫。 它們通常會以大寫方式宣告，單字之間以底線連結。 在命令提示字元中，執行下列命令：

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

命令	動作	範例
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
   

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

命令	動作	範例
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
   

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

命令	動作	範例
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. 選擇 ，然後輸入 以接受預設項目名稱 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'
   }
   

建立 Java 應用程式

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

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

   mkdir -p src/main/java
   

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

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

   小提示

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

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

   • 預建的讀取 模型是所有文檔智能模型的核心，並且可以偵測行、文字、位置和語言。 版面配置、一般檔、預先建置和自定義模型全都使用 read 模型作為從檔擷取文字的基礎。
   • prebuilt-layout 模型會從文件和影像中擷取文字和文字位置、表格、選取標記和結構資訊。
   • prebuilt-tax.us.w2 模型會擷取美國國稅局 (IRS) 稅務表單上所報告的資訊。
   • 預設發票 模型會從各種格式的銷售發票中擷取關鍵欄位和明細項目。
   • 預建收據 模型會從印刷和手寫的銷售收據中擷取重要資訊。
   • 預建的 idDocument 模型會從美國駕駛執照、國際護照傳記頁面、美國州身份證、社會保障卡和永久居民卡中擷取重要資訊。

3. 輸入下列命令：

   gradle build
   gradle run
   

使用 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 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.getPolygon().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 模型輸出。

使用 Layout 模型

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.getPolygon().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.getPolygon()),
      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 > Polygon) {
  return Polygon.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.getPolygon().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 範例存放庫，並檢視 識別碼檔案模型輸出。

用戶端程式庫 | REST API 參考 | 套件 (npm) | 範例 |支援的 REST API 版本

先決條件

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

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

• LTS 的最新 版本。

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

  小提示

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

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

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

  

• URL 的文件檔案。 針對此專案，您可以使用下表中針對每項功能的範例表單：

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

設定環境變數

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

這很重要

請謹慎使用 API 金鑰。 請勿在程式碼中直接包含 API 金鑰，且切勿公開張貼金鑰。 如果您使用 API 金鑰，請安全地將其儲存在 Azure 金鑰保存庫。 如需在應用程式中安全地使用 API 金鑰的詳細資訊，請參閱搭配 Azure 金鑰保存庫 的 API 金鑰。

如需 AI 服務安全性的詳細資訊，請參閱驗證對 Azure AI 服務的要求。

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

Windows

Windows 中的環境變數不會區分大小寫。 它們通常會以大寫方式宣告，單字之間以底線連結。 在命令提示字元中，執行下列命令：

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

命令	動作	範例
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
   

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

命令	動作	範例
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
   

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

命令	動作	範例
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 存放庫、關鍵詞、作者和授權資訊都是選擇性屬性。 在此專案中可以跳過它們。
   • 選取 [輸入 以接受括弧中的建議。

   完成提示之後，命令會在 package.json 目錄中建立 檔案。

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

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

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

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

   小提示

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

建置您的 應用程式

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

在 Visual Studio Code 或您慣用的 IDE 中開啟 index.js 檔案，然後選取下列其中一個程式代碼範例，然後將/貼到您的應用程式：

• 預建的讀取 模型是所有文檔智能模型的核心，並且可以偵測行、文字、位置和語言。 版面配置、一般檔、預先建置和自定義模型全都使用 read 模型作為從檔擷取文字的基礎。
• prebuilt-layout 模型會從文件和影像中擷取文字和文字位置、表格、選取標記和結構資訊。
• prebuilt-tax.us.w2 模型會擷取美國國稅局 (IRS) 稅務表單上所報告的資訊。
• 預建發票 模型會擷取美國國稅服務稅單上報告的資訊。
• 預建收據 模型會從印刷和手寫的銷售收據中擷取重要資訊。
• 預建的 idDocument 模型會從美國駕駛執照、國際護照傳記頁面、美國州身份證、社會保障卡和永久居民卡中擷取重要資訊。

使用 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 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 模型輸出。

使用 Layout 模型

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 範例存放庫，並檢視 識別碼檔案模型輸出。

用戶端連結庫 | 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 服務或文件智慧服務資源。 建立 單一服務 或 多服務。 您可以使用免費定價層 (F0) 來試用服務，之後可升級至付費層以用於實際執行環境。

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

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

  

• URL 的文件檔案。 針對此專案，您可以使用下表中針對每項功能的範例表單：

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

設定環境變數

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

這很重要

請謹慎使用 API 金鑰。 請勿在程式碼中直接包含 API 金鑰，且切勿公開張貼金鑰。 如果您使用 API 金鑰，請安全地將其儲存在 Azure 金鑰保存庫。 如需在應用程式中安全地使用 API 金鑰的詳細資訊，請參閱搭配 Azure 金鑰保存庫 的 API 金鑰。

如需 AI 服務安全性的詳細資訊，請參閱驗證對 Azure AI 服務的要求。

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

Windows

Windows 中的環境變數不會區分大小寫。 它們通常會以大寫方式宣告，單字之間以底線連結。 在命令提示字元中，執行下列命令：

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

命令	動作	範例
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
   

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

命令	動作	範例
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
   

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

命令	動作	範例
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 Document Intelligence 用戶端連結庫：

pip install azure-ai-documentintelligence==1.0.0b4

建立 Python 應用程式

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

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

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

   • 預建的讀取 模型是所有文檔智能模型的核心，並且可以偵測行、文字、位置和語言。 版面配置、一般檔、預先建置和自定義模型全都使用 read 模型作為從檔擷取文字的基礎。
   • prebuilt-layout 模型會從文件和影像中擷取文字和文字位置、表格、選取標記和結構資訊。
   • prebuilt-tax.us.w2 模型會擷取美國國稅局 (IRS) 稅務表單上所報告的資訊。
   • 預設發票 模型會從各種格式的銷售發票中擷取關鍵欄位和明細項目。
   • 預建收據 模型會從印刷和手寫的銷售收據中擷取重要資訊。
   • 預建的 idDocument 模型會從美國駕駛執照、國際護照傳記頁面、美國州身份證、社會保障卡和永久居民卡中擷取重要資訊。

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

   python form_recognizer_quickstart.py
   

使用 Read 模型

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

# 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 模型輸出。

使用 Layout 模型

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


# 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

# 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

# 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

# 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

# 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 (部分內容可能是機器或 AI 翻譯) | 支援的 Azure SDK (部分內容可能是機器或 AI 翻譯)

先決條件

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

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

  curl -help
  

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

  • Windows
  • Mac 或 Linux

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

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

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

  

設定環境變數

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

這很重要

請謹慎使用 API 金鑰。 請勿在程式碼中直接包含 API 金鑰，且切勿公開張貼金鑰。 如果您使用 API 金鑰，請安全地將其儲存在 Azure 金鑰保存庫。 如需在應用程式中安全地使用 API 金鑰的詳細資訊，請參閱搭配 Azure 金鑰保存庫 的 API 金鑰。

如需 AI 服務安全性的詳細資訊，請參閱驗證對 Azure AI 服務的要求。

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

Windows

Windows 中的環境變數不會區分大小寫。 它們通常會以大寫方式宣告，單字之間以底線連結。 在命令提示字元中，執行下列命令：

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

命令	動作	範例
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
   

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

命令	動作	範例
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
   

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

命令	動作	範例
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	說明	document-url
Read 模型	prebuilt-read	樣本手冊	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
版面配置模型	預設佈局	預約確認範例	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 要求

開啟bash視窗並執行下列 cURL 命令。 這些命令包含先前在設定環境變數區段中建立的端點和主要環境變數。 如果您的變數名稱不同，請取代這些變數。 請記得取代 <modelId> 和 <document-url> 參數。

curl -i -X POST "POST {endpoint}/documentintelligence/documentModels/{modelId}:analyze?_overload=analyzeDocument&api-version=2024-11-30" -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 "{endpoint}/documentintelligence/documentModels/prebuilt-layout:analyze?features=ocr.highResolution,ocr.formula,ocr.font?api-version=2024-11-30" -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 結果 API，以取得作業的狀態和擷取的數據。

cURL 命令行工具不會格式化包含 JSON 內容的 API 回應，這會使內容難以讀取。 若要設定 JSON 回應的格式，請包括直立線符號字元，後面接著具有 GET 要求的 JSON 格式設定工具。

Windows

使用 Node.js json 工具 作為 cURL 的 JSON 格式器。 如果您沒有安裝 Node.js，請下載並安裝最新版本。

1. 開啟 bash 視窗，並使用下列命令安裝 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-11-30"-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/{modelId}/analyzeResults/{resultId}?api-version=2024-11-30"-H "Ocp-Apim-Subscription-Key: <subscription key>" | json_pp
  

Linux

json_pp 命令行工具已預安裝於大部分的Linux發行版中。 如果它未被包括，您可以使用您的發行版的套件管理員來安裝它。

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

  curl -i -X GET "{endpoint}/documentintelligence/documentModels/{modelId}/analyzeResults/{resultId}?api-version=2024-11-30"-H "Ocp-Apim-Subscription-Key: <subscription key>" | json_pp
  

GET 要求

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

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

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

檢查回應

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

請瀏覽 GitHub 上的 Azure 範例存放庫，以檢視每個檔案智慧模型的 GET 回應：

型號	輸出 URL
Read 模型	Read 模型輸出 (英文)
版面配置模型	Layout 模型輸出 (英文)
W-2 稅制模型	W-2 稅務模型輸出 (英文)
發票模型	發票模型輸出 (英文)
收據模型	收據模型輸出
識別碼文件模型	身分證明文件模型輸出 (英文)

後續步驟

祝賀！ 您已瞭解如何使用文件智慧模型，以不同方式分析各種檔。 接下來，探索 Document Intelligence Studio 和參考文件。

試用 Document Intelligence Studio探索文件智慧 REST API