使用文件智慧服務模型

此內容適用於：v4.0 （預覽） | 舊版：v3.1 （GA）v3.0 （GA）v2.1 （GA）

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

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

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

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

• 預先建置的配置模型會從檔和影像中擷取文字和文字位置、數據表、選取標記和結構資訊。 您可以使用配置模型搭配啟用選擇性查詢字串參數 features=keyValuePairs 來擷取索引鍵/值組。

• 預先建置的合約模型會從合約合約擷取重要資訊。

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

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

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

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

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

必要條件

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

• Visual Studio IDE。

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

• 您建立的資源中的金鑰和端點，以將應用程式連線到 Azure Document Intelligence 服務。

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

  

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

  功能	modelID	document-url
  讀取模型	prebuilt-read	範例摺頁冊
  版面配置模型	prebuilt-layout	預約確認範例
  W-2 表體模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	預建發票	發票範例
  收據模型	prebuilt-receipt	範例收據
  標識碼檔模型	prebuilt-idDocument	範例標識碼檔
  名片模型	prebuilt-businessCard	範例名片

設定環境變數

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

重要

請勿將密鑰直接包含在程式碼中，且絕不公開發佈。 針對生產環境，請使用安全的方式來儲存和存取您的認證，例如 Azure 金鑰保存庫。 如需詳細資訊，請參閱 Azure AI 服務安全性。

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

Windows

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

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

macOS 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export key=<yourKey>
   

2. 設定您的端點變數：

   export endpoint=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bash_profile 啟動腳稿中放置匯出命令：

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

Linux 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定您的端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bashrc 啟動腳稿中放置匯出命令：

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

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

設定程式設計環境

1. 啟動 Visual Studio。

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

   

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

   

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

   

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

   

使用 NuGet 安裝客戶端連結庫

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

   

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

   

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

建置您的 應用程式

注意

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

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

1. 開啟 Program.cs 檔案。

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

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

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

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

   

使用讀取模型

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

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

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

AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-read", fileUri);
AnalyzeResult result = operation.Value;

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

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

        Console.WriteLine($"    Its bounding polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].Y}");
        }
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("Detected languages:");

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

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

使用版面配置模型

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

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

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

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

AnalyzeResult result = operation.Value;

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

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

        Console.WriteLine($"    Its bounding polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].Y}");
        }
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding polygon (points ordered clockwise):");

        for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
        }
    }
}

Console.WriteLine("Paragraphs:");

foreach (DocumentParagraph paragraph in result.Paragraphs)
{
    Console.WriteLine($"  Paragraph content: {paragraph.Content}");

    if (paragraph.Role != null)
    {
        Console.WriteLine($"    Role: {paragraph.Role}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

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

使用一般檔模型

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

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

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

        Console.WriteLine($"    Its bounding polygon (points ordered clockwise):");

        for (int j = 0; j < line.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.BoundingPolygon[j].X}, Y: {line.BoundingPolygon[j].Y}");
        }
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding polygon (points ordered clockwise):");

        for (int j = 0; j < selectionMark.BoundingPolygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {selectionMark.BoundingPolygon[j].X}, Y: {selectionMark.BoundingPolygon[j].Y}");
        }
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Index, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 一般檔模型輸出。

使用 W-2 稅金模型

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

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("AdditionalInfo", out DocumentField? additionalInfoField))
    {
        if (additionalInfoField.FieldType == DocumentFieldType.List)
        {
            foreach (DocumentField infoField in additionalInfoField.Value.AsList())
            {
                Console.WriteLine("AdditionalInfo:");

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

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

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

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

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


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

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

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

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

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

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

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

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

使用發票模型

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

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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

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

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

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

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

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

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

使用收據模型

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

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

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

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

AnalyzeResult receipts = operation.Value;

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

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

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

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

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

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

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

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

                    if (itemFields.TryGetValue("TotalPrice", out DocumentField itemTotalPriceField))
                    {
                        if (itemTotalPriceField.FieldType == DocumentFieldType.Double)
                        {
                            double itemTotalPrice = itemTotalPriceField.Value.AsDouble();

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

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

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

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

身分證明文件模型

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

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

// sample document document

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

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

AnalyzeResult identityDocuments = operation.Value;

AnalyzedDocument identityDocument = identityDocuments.Documents.Single();

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

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

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

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

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

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

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

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

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

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 標識碼檔模型輸出。

使用名片模型

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

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

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

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

AnalyzeResult businessCards = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

必要條件

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

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

  • Visual Studio Code 提供 適用於 Windows 和 macOS 的 Java 程式代碼撰寫套件。 程式代碼套件是 Code 套件組合 VS 、Java 開發工具套件 （JDK），以及 Microsoft 建議的延伸模組集合。 程式代碼撰寫套件也可用來修正現有的開發環境。
  • 如果您使用 VS Code 和 Code Pack For 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 Document Intelligence 服務。

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

  

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

  功能	modelID	document-url
  讀取模型	prebuilt-read	範例摺頁冊
  版面配置模型	prebuilt-layout	預約確認範例
  W-2 表體模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	預建發票	發票範例
  收據模型	prebuilt-receipt	範例收據
  標識碼檔模型	prebuilt-idDocument	範例標識碼檔

設定環境變數

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

重要

請勿將密鑰直接包含在程式碼中，且絕不公開發佈。 針對生產環境，請使用安全的方式來儲存和存取您的認證，例如 Azure 金鑰保存庫。 如需詳細資訊，請參閱 Azure AI 服務安全性。

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

Windows

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

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

macOS 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export key=<yourKey>
   

2. 設定您的端點變數：

   export endpoint=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bash_profile 啟動腳稿中放置匯出命令：

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

Linux 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定您的端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bashrc 啟動腳稿中放置匯出命令：

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

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

設定程式設計環境

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

建立 Gradle 專案

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

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

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

   gradle init --type basic
   

3. 當系統提示您選擇 DSL 時，請選取 [Kotlin]。

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

安裝用戶端程式庫

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

1. 在 IDE 中開啟專案的 build.gradle.kts 檔案。 複製並貼上下列程序代碼，以包含用戶端連結庫做為 implementation 語句，以及必要的外掛程式和設定。

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

建立 Java 應用程式

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

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

   mkdir -p src/main/java
   

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

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

   提示

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

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

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

3. 輸入下列命令：

   gradle build
   gradle run
   

使用讀取模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;


public class DocIntelligence {

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

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

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

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

String modelId = "prebuilt-read";

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

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult().getAnalyzeResult();

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

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

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

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

使用版面配置模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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

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

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

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

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

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult().getAnalyzeResult();

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

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

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

  // selection marks
  documentPage.getSelectionMarks().forEach(documentSelectionMark ->
    System.out.printf("Selection mark is '%s' and is within a bounding polygon %s with confidence %.2f.%n",
      documentSelectionMark.getSelectionMarkState().toString(),
      getBoundingCoordinates(documentSelectionMark.getBoundingPolygon()),
      documentSelectionMark.getConfidence()));
});

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

}

// Utility function to get the bounding polygon coordinates.
private static String getBoundingCoordinates(List < Point > boundingPolygon) {
  return boundingPolygon.stream().map(point -> String.format("[%.2f, %.2f]", point.getX(),
    point.getY())).collect(Collectors.joining(", "));
}

}

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

使用一般檔模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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

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

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

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

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

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

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

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

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

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

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

}

}

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 一般檔模型輸出。

使用 W-2 稅金模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

使用發票模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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

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

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

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

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

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

for (int i = 0; i < analyzeInvoiceResult.getDocuments().size(); i++) {
  AnalyzedDocument analyzedInvoice = analyzeInvoiceResult.getDocuments().get(i);
  Map < String, DocumentField > invoiceFields = analyzedInvoice.getFields();
  System.out.printf("----------- Analyzing invoice  %d -----------%n", i);
  DocumentField vendorNameField = invoiceFields.get("VendorName");
  if (vendorNameField != null) {
    if (DocumentFieldType.STRING == vendorNameField.getType()) {
      String merchantName = vendorNameField.getValueAsString();
      System.out.printf("Vendor Name: %s, confidence: %.2f%n",
        merchantName, vendorNameField.getConfidence());
    }
  }

  DocumentField vendorAddressField = invoiceFields.get("VendorAddress");
  if (vendorAddressField != null) {
    if (DocumentFieldType.STRING == vendorAddressField.getType()) {
      String merchantAddress = vendorAddressField.getValueAsString();
      System.out.printf("Vendor address: %s, confidence: %.2f%n",
        merchantAddress, vendorAddressField.getConfidence());
    }
  }

  DocumentField customerNameField = invoiceFields.get("CustomerName");
  if (customerNameField != null) {
    if (DocumentFieldType.STRING == customerNameField.getType()) {
      String merchantAddress = customerNameField.getValueAsString();
      System.out.printf("Customer Name: %s, confidence: %.2f%n",
        merchantAddress, customerNameField.getConfidence());
    }
  }

  DocumentField customerAddressRecipientField = invoiceFields.get("CustomerAddressRecipient");
  if (customerAddressRecipientField != null) {
    if (DocumentFieldType.STRING == customerAddressRecipientField.getType()) {
      String customerAddr = customerAddressRecipientField.getValueAsString();
      System.out.printf("Customer Address Recipient: %s, confidence: %.2f%n",
        customerAddr, customerAddressRecipientField.getConfidence());
    }
  }

  DocumentField invoiceIdField = invoiceFields.get("InvoiceId");
  if (invoiceIdField != null) {
    if (DocumentFieldType.STRING == invoiceIdField.getType()) {
      String invoiceId = invoiceIdField.getValueAsString();
      System.out.printf("Invoice ID: %s, confidence: %.2f%n",
        invoiceId, invoiceIdField.getConfidence());
    }
  }

  DocumentField invoiceDateField = invoiceFields.get("InvoiceDate");
  if (customerNameField != null) {
    if (DocumentFieldType.DATE == invoiceDateField.getType()) {
      LocalDate invoiceDate = invoiceDateField.getValueAsDate();
      System.out.printf("Invoice Date: %s, confidence: %.2f%n",
        invoiceDate, invoiceDateField.getConfidence());
    }
  }

  DocumentField invoiceTotalField = invoiceFields.get("InvoiceTotal");
  if (customerAddressRecipientField != null) {
    if (DocumentFieldType.DOUBLE == invoiceTotalField.getType()) {
      Double invoiceTotal = invoiceTotalField.getValueAsDouble();
      System.out.printf("Invoice Total: %.2f, confidence: %.2f%n",
        invoiceTotal, invoiceTotalField.getConfidence());
    }
  }

  DocumentField invoiceItemsField = invoiceFields.get("Items");
  if (invoiceItemsField != null) {
    System.out.printf("Invoice Items: %n");
    if (DocumentFieldType.LIST == invoiceItemsField.getType()) {
      List < DocumentField > invoiceItems = invoiceItemsField.getValueAsList();
      invoiceItems.stream()
        .filter(invoiceItem -> DocumentFieldType.MAP == invoiceItem.getType())
        .map(documentField -> documentField.getValueAsMap())
        .forEach(documentFieldMap -> documentFieldMap.forEach((key, documentField) -> {
          if ("Description".equals(key)) {
            if (DocumentFieldType.STRING == documentField.getType()) {
              String name = documentField.getValueAsString();
              System.out.printf("Description: %s, confidence: %.2fs%n",
                name, documentField.getConfidence());
            }
          }
          if ("Quantity".equals(key)) {
            if (DocumentFieldType.DOUBLE == documentField.getType()) {
              Double quantity = documentField.getValueAsDouble();
              System.out.printf("Quantity: %f, confidence: %.2f%n",
                quantity, documentField.getConfidence());
            }
          }
          if ("UnitPrice".equals(key)) {
            if (DocumentFieldType.DOUBLE == documentField.getType()) {
              Double unitPrice = documentField.getValueAsDouble();
              System.out.printf("Unit Price: %f, confidence: %.2f%n",
                unitPrice, documentField.getConfidence());
            }
          }
          if ("ProductCode".equals(key)) {
            if (DocumentFieldType.DOUBLE == documentField.getType()) {
              Double productCode = documentField.getValueAsDouble();
              System.out.printf("Product Code: %f, confidence: %.2f%n",
                productCode, documentField.getConfidence());
            }
          }
        }));
    }
  }
}
}
}

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

使用收據模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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

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

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

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

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

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

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

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

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

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

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

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

使用標識碼檔模型

import com.azure.ai.documentintelligence;

import com.azure.ai.documentintelligence.models.AnalyzeDocumentRequest;
import com.azure.ai.documentintelligence.models.AnalyzeResult;
import com.azure.ai.documentintelligence.models.AnalyzeResultOperation;
import com.azure.ai.documentintelligence.models.Document;
import com.azure.ai.documentintelligence.models.DocumentField;
import com.azure.ai.documentintelligence.models.DocumentFieldType;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 標識碼檔模型輸出。

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

必要條件

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

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

• 最新版本 LTS 的 Node.js。

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

  提示

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

• 您建立的資源中的金鑰和端點，以將應用程式連線到 Azure Document Intelligence 服務。

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

  

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

  功能	modelID	document-url
  讀取模型	prebuilt-read	範例摺頁冊
  版面配置模型	prebuilt-layout	預約確認範例
  W-2 表體模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	預建發票	發票範例
  收據模型	prebuilt-receipt	範例收據
  標識碼檔模型	prebuilt-idDocument	範例標識碼檔

設定環境變數

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

重要

請勿將密鑰直接包含在程式碼中，且絕不公開發佈。 針對生產環境，請使用安全的方式來儲存和存取您的認證，例如 Azure 金鑰保存庫。 如需詳細資訊，請參閱 Azure AI 服務安全性。

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

Windows

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

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

macOS 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export key=<yourKey>
   

2. 設定您的端點變數：

   export endpoint=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bash_profile 啟動腳稿中放置匯出命令：

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

Linux 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定您的端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bashrc 啟動腳稿中放置匯出命令：

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

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

設定程式設計環境

建立 Node.js Express 應用程式。

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

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

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

   npm init
   

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

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

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

4. 安裝客戶端連結 ai-document-intelligence 庫與 azure/identity npm 套件：

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

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

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

   提示

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

建置您的 應用程式

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

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

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

使用讀取模型

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

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

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

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

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

    const {
        content,
        pages,
        languages,
        styles
    } = await poller.pollUntilDone();

    if (pages.length <= 0) {
        console.log("No pages were extracted from the document.");
    } else {
        console.log("Pages:");
        for (const page of pages) {
            console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
            console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
            console.log(`  ${page.lines.length} lines, ${page.words.length} words`);

            if (page.lines.length > 0) {
                console.log("  Lines:");

                for (const line of page.lines) {
                    console.log(`  - "${line.content}"`);

                    // The words of the line can also be iterated independently. The words are computed based on their
                    // corresponding spans.
                    for (const word of line.words()) {
                        console.log(`    - "${word.content}"`);
                    }
                }
            }
        }
    }

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

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

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

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

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

使用版面配置模型

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

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

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

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

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

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

    if (!pages || pages.length <= 0) {
      console.log("No pages were extracted from the document.");
    } else {
      console.log("Pages:");
      for (const page of pages) {
        console.log("- Page", page.pageNumber, `(unit: ${page.unit})`);
        console.log(`  ${page.width}x${page.height}, angle: ${page.angle}`);
        console.log(
          `  ${page.lines && page.lines.length} lines, ${page.words && page.words.length} words`
        );

        if (page.lines && page.lines.length > 0) {
          console.log("  Lines:");

          for (const line of page.lines) {
            console.log(`  - "${line.content}"`);

            // The words of the line can also be iterated independently. The words are computed based on their
            // corresponding spans.
            for (const word of line.words()) {
              console.log(`    - "${word.content}"`);
            }
          }
        }
      }
    }

    if (!tables || tables.length <= 0) {
      console.log("No tables were extracted from the document.");
    } else {
      console.log("Tables:");
      for (const table of tables) {
        console.log(
          `- Extracted table: ${table.columnCount} columns, ${table.rowCount} rows (${table.cells.length} cells)`
        );
      }
    }
  }

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

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

使用一般檔模型

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

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

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

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

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

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

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

}

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

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 一般檔模型輸出。

使用 W-2 稅金模型

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

使用發票模型

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

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

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

async function main() {

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

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

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

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

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

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

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

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

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

使用收據模型

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

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

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

async function main() {

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

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

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

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

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

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

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

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

}

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

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

使用標識碼檔模型

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

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

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

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

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

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

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

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

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

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

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

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 標識碼檔模型輸出。

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

必要條件

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

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

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

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

• 您建立的資源中的金鑰和端點，以將應用程式連線到 Azure Document Intelligence 服務。

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

  

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

  功能	modelID	document-url
  讀取模型	prebuilt-read	範例摺頁冊
  版面配置模型	prebuilt-layout	預約確認範例
  W-2 表體模型	prebuilt-tax.us.w2	範例 W-2 表單
  發票模型	預建發票	發票範例
  收據模型	prebuilt-receipt	範例收據
  標識碼檔模型	prebuilt-idDocument	範例標識碼檔

設定環境變數

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

重要

請勿將密鑰直接包含在程式碼中，且絕不公開發佈。 針對生產環境，請使用安全的方式來儲存和存取您的認證，例如 Azure 金鑰保存庫。 如需詳細資訊，請參閱 Azure AI 服務安全性。

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

Windows

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

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

macOS 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export key=<yourKey>
   

2. 設定您的端點變數：

   export endpoint=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bash_profile 啟動腳稿中放置匯出命令：

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

Linux 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定您的端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bashrc 啟動腳稿中放置匯出命令：

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

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

設定程式設計環境

在本機環境中開啟控制台視窗，並使用 pip 安裝適用於 Python 的 Azure AI Document Intelligence 用戶端連結庫：

pip install azure-ai-documentintelligence==1.0.0b2

建立 Python 應用程式

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

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

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

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

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

   python form_recognizer_quickstart.py
   

使用讀取模型

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

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

# formatting function
def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


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", formUrl
    )
    result = poller.result()

    print("Document contains content: ", result.content)

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )

    for page in result.pages:
        print("----Analyzing Read from page #{}----".format(page.page_number))
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                page.width, page.height, page.unit
            )
        )

        for line_idx, line in enumerate(page.lines):
            print(
                "...Line # {} has text content '{}' within bounding box '{}'".format(
                    line_idx,
                    line.content,
                    format_polygon(line.polygon),
                )
            )

        for word in page.words:
            print(
                "...Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

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


if __name__ == "__main__":
    analyze_read()

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

使用版面配置模型

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


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

# formatting function
def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


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

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

    poller = client.begin_analyze_document(
        "prebuilt-layout", formUrl
    )
    result = poller.result()

    for idx, style in enumerate(result.styles):
        print(
            "Document contains {} content".format(
                "handwritten" if style.is_handwritten else "no handwritten"
            )
        )

    for page in result.pages:
        print("----Analyzing layout from page #{}----".format(page.page_number))
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                page.width, page.height, page.unit
            )
        )

        for line_idx, line in enumerate(page.lines):
            words = line.get_words()
            print(
                "...Line # {} has word count {} and text '{}' within bounding box '{}'".format(
                    line_idx,
                    len(words),
                    line.content,
                    format_polygon(line.polygon),
                )
            )

            for word in words:
                print(
                    "......Word '{}' has a confidence of {}".format(
                        word.content, word.confidence
                    )
                )

        for selection_mark in page.selection_marks:
            print(
                "...Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(selection_mark.polygon),
                    selection_mark.confidence,
                )
            )

    for table_idx, table in enumerate(result.tables):
        print(
            "Table # {} has {} rows and {} columns".format(
                table_idx, table.row_count, table.column_count
            )
        )
        for region in table.bounding_regions:
            print(
                "Table # {} location on page: {} is {}".format(
                    table_idx,
                    region.page_number,
                    format_polygon(region.polygon),
                )
            )
        for cell in table.cells:
            print(
                "...Cell[{}][{}] has content '{}'".format(
                    cell.row_index,
                    cell.column_index,
                    cell.content,
                )
            )
            for region in cell.bounding_regions:
                print(
                    "...content on page {} is within bounding box '{}'".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )

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


if __name__ == "__main__":
    analyze_layout()

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

使用一般檔模型

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

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

# formatting function
def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join("Page #{}: {}".format(region.page_number, format_polygon(region.polygon)) for region in bounding_regions)

# formatting function
def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


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

    # create your `DocumentIntelligenceClient` instance and `AzureKeyCredential` variable
   client = DocumentIntelligenceClient(endpoint=endpoint, credential=AzureKeyCredential(key))

    poller = client.begin_analyze_document(
            "prebuilt-document", docUrl)
    result = poller.result()

    for style in result.styles:
        if style.is_handwritten:
            print("Document contains handwritten content: ")
            print(",".join([result.content[span.offset:span.offset + span.length] for span in style.spans]))

    print("----Key-value pairs found in document----")
    for kv_pair in result.key_value_pairs:
        if kv_pair.key:
            print(
                    "Key '{}' found within '{}' bounding regions".format(
                        kv_pair.key.content,
                        format_bounding_region(kv_pair.key.bounding_regions),
                    )
                )
        if kv_pair.value:
            print(
                    "Value '{}' found within '{}' bounding regions\n".format(
                        kv_pair.value.content,
                        format_bounding_region(kv_pair.value.bounding_regions),
                    )
                )

    for page in result.pages:
        print("----Analyzing document from page #{}----".format(page.page_number))
        print(
            "Page has width: {} and height: {}, measured with unit: {}".format(
                page.width, page.height, page.unit
            )
        )

        for line_idx, line in enumerate(page.lines):
            print(
                "...Line # {} has text content '{}' within bounding box '{}'".format(
                    line_idx,
                    line.content,
                    format_polygon(line.polygon),
                )
            )

        for word in page.words:
            print(
                "...Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

        for selection_mark in page.selection_marks:
            print(
                "...Selection mark is '{}' within bounding box '{}' and has a confidence of {}".format(
                    selection_mark.state,
                    format_polygon(selection_mark.polygon),
                    selection_mark.confidence,
                )
            )

    for table_idx, table in enumerate(result.tables):
        print(
            "Table # {} has {} rows and {} columns".format(
                table_idx, table.row_count, table.column_count
            )
        )
        for region in table.bounding_regions:
            print(
                "Table # {} location on page: {} is {}".format(
                    table_idx,
                    region.page_number,
                    format_polygon(region.polygon),
                )
            )
        for cell in table.cells:
            print(
                "...Cell[{}][{}] has content '{}'".format(
                    cell.row_index,
                    cell.column_index,
                    cell.content,
                )
            )
            for region in cell.bounding_regions:
                print(
                    "...content on page {} is within bounding box '{}'\n".format(
                        region.page_number,
                        format_polygon(region.polygon),
                    )
                )
    print("----------------------------------------")


if __name__ == "__main__":
    analyze_general_documents()

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 一般檔模型輸出。

使用 W-2 稅金模型

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

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

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


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

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

    poller = client.begin_analyze_document(
        "prebuilt-tax.us.w2", formUrl
    )
    w2s = poller.result()

    for idx, w2 in enumerate(w2s.documents):
         print("--------Analyzing US Tax W-2 Form #{}--------".format(idx   1))
        form_variant = w2.fields.get("W2FormVariant")
        if form_variant:
            print(
                "Form variant: {} has confidence: {}".format(
                    form_variant.value, form_variant.confidence
                )
            )
        tax_year = w2.fields.get("TaxYear")
        if tax_year:
            print(
                "Tax year: {} has confidence: {}".format(
                    tax_year.value, tax_year.confidence
                )
            )
        w2_copy = w2.fields.get("W2Copy")
        if w2_copy:
            print(
                "W-2 Copy: {} has confidence: {}".format(
                    w2_copy.value,
                    w2_copy.confidence,
                )
            )
        employee = w2.fields.get("Employee")
        if employee:
            print("Employee data:")
            employee_name = employee.value.get("Name")
            if employee_name:
                print(
                    "...Name: {} has confidence: {}".format(
                        employee_name.value, employee_name.confidence
                    )
                )
            employee_ssn = employee.value.get("SocialSecurityNumber")
            if employee_ssn:
                print(
                    "...SSN: {} has confidence: {}".format(
                        employee_ssn.value, employee_ssn.confidence
                    )
                )
            employee_address = employee.value.get("Address")
            if employee_address:
                print(
                    "...Address: {}\n......has confidence: {}".format(
                        format_address_value(employee_address.value),
                        employee_address.confidence,
                    )
                )
            employee_zipcode = employee.value.get("ZipCode")
            if employee_zipcode:
                print(
                    "...Zipcode: {} has confidence: {}".format(
                        employee_zipcode.value, employee_zipcode.confidence
                    )
                )
        control_number = w2.fields.get("ControlNumber")
        if control_number:
            print(
                "Control Number: {} has confidence: {}".format(
                    control_number.value, control_number.confidence
                )
            )
        employer = w2.fields.get("Employer")
        if employer:
            print("Employer data:")
            employer_name = employer.value.get("Name")
            if employer_name:
                print(
                    "...Name: {} has confidence: {}".format(
                        employer_name.value, employer_name.confidence
                    )
                )
            employer_id = employer.value.get("IdNumber")
            if employer_id:
                print(
                    "...ID Number: {} has confidence: {}".format(
                        employer_id.value, employer_id.confidence
                    )
                )
            employer_address = employer.value.get("Address")
            if employer_address:
                print(
                    "...Address: {}\n......has confidence: {}".format(
                        format_address_value(employer_address.value),
                        employer_address.confidence,
                    )
                )
            employer_zipcode = employer.value.get("ZipCode")
            if employer_zipcode:
                print(
                    "...Zipcode: {} has confidence: {}".format(
                        employer_zipcode.value, employer_zipcode.confidence
                    )
                )
        wages_tips = w2.fields.get("WagesTipsAndOtherCompensation")
        if wages_tips:
            print(
                "Wages, tips, and other compensation: {} has confidence: {}".format(
                    wages_tips.value,
                    wages_tips.confidence,
                )
            )
        fed_income_tax_withheld = w2.fields.get("FederalIncomeTaxWithheld")
        if fed_income_tax_withheld:
            print(
                "Federal income tax withheld: {} has confidence: {}".format(
                    fed_income_tax_withheld.value, fed_income_tax_withheld.confidence
                )
            )
        social_security_wages = w2.fields.get("SocialSecurityWages")
        if social_security_wages:
            print(
                "Social Security wages: {} has confidence: {}".format(
                    social_security_wages.value, social_security_wages.confidence
                )
            )
        social_security_tax_withheld = w2.fields.get("SocialSecurityTaxWithheld")
        if social_security_tax_withheld:
            print(
                "Social Security tax withheld: {} has confidence: {}".format(
                    social_security_tax_withheld.value,
                    social_security_tax_withheld.confidence,
                )
            )
        medicare_wages_tips = w2.fields.get("MedicareWagesAndTips")
        if medicare_wages_tips:
            print(
                "Medicare wages and tips: {} has confidence: {}".format(
                    medicare_wages_tips.value, medicare_wages_tips.confidence
                )
            )
        medicare_tax_withheld = w2.fields.get("MedicareTaxWithheld")
        if medicare_tax_withheld:
            print(
                "Medicare tax withheld: {} has confidence: {}".format(
                    medicare_tax_withheld.value, medicare_tax_withheld.confidence
                )
            )
        social_security_tips = w2.fields.get("SocialSecurityTips")
        if social_security_tips:
            print(
                "Social Security tips: {} has confidence: {}".format(
                    social_security_tips.value, social_security_tips.confidence
                )
            )
        allocated_tips = w2.fields.get("AllocatedTips")
        if allocated_tips:
            print(
                "Allocated tips: {} has confidence: {}".format(
                    allocated_tips.value,
                    allocated_tips.confidence,
                )
            )
        verification_code = w2.fields.get("VerificationCode")
        if verification_code:
            print(
                "Verification code: {} has confidence: {}".format(
                    verification_code.value, verification_code.confidence
                )
            )
        dependent_care_benefits = w2.fields.get("DependentCareBenefits")
        if dependent_care_benefits:
            print(
                "Dependent care benefits: {} has confidence: {}".format(
                    dependent_care_benefits.value,
                    dependent_care_benefits.confidence,
                )
            )
        non_qualified_plans = w2.fields.get("NonQualifiedPlans")
        if non_qualified_plans:
            print(
                "Non-qualified plans: {} has confidence: {}".format(
                    non_qualified_plans.value,
                    non_qualified_plans.confidence,
                )
            )
        additional_info = w2.fields.get("AdditionalInfo")
        if additional_info:
            print("Additional information:")
            for item in additional_info.value:
                letter_code = item.value.get("LetterCode")
                if letter_code:
                    print(
                        "...Letter code: {} has confidence: {}".format(
                            letter_code.value, letter_code.confidence
                        )
                    )
                amount = item.value.get("Amount")
                if amount:
                    print(
                        "...Amount: {} has confidence: {}".format(
                            amount.value, amount.confidence
                        )
                    )
        is_statutory_employee = w2.fields.get("IsStatutoryEmployee")
        if is_statutory_employee:
            print(
                "Is statutory employee: {} has confidence: {}".format(
                    is_statutory_employee.value, is_statutory_employee.confidence
                )
            )
        is_retirement_plan = w2.fields.get("IsRetirementPlan")
        if is_retirement_plan:
            print(
                "Is retirement plan: {} has confidence: {}".format(
                    is_retirement_plan.value, is_retirement_plan.confidence
                )
            )
        third_party_sick_pay = w2.fields.get("IsThirdPartySickPay")
        if third_party_sick_pay:
            print(
                "Is third party sick pay: {} has confidence: {}".format(
                    third_party_sick_pay.value, third_party_sick_pay.confidence
                )
            )
        other_info = w2.fields.get("Other")
        if other_info:
            print(
                "Other information: {} has confidence: {}".format(
                    other_info.value,
                    other_info.confidence,
                )
            )
        state_tax_info = w2.fields.get("StateTaxInfos")
        if state_tax_info:
            print("State Tax info:")
            for tax in state_tax_info.value:
                state = tax.value.get("State")
                if state:
                    print(
                        "...State: {} has confidence: {}".format(
                            state.value, state.confidence
                        )
                    )
                employer_state_id_number = tax.value.get("EmployerStateIdNumber")
                if employer_state_id_number:
                    print(
                        "...Employer state ID number: {} has confidence: {}".format(
                            employer_state_id_number.value,
                            employer_state_id_number.confidence,
                        )
                    )
                state_wages_tips = tax.value.get("StateWagesTipsEtc")
                if state_wages_tips:
                    print(
                        "...State wages, tips, etc: {} has confidence: {}".format(
                            state_wages_tips.value, state_wages_tips.confidence
                        )
                    )
                state_income_tax = tax.value.get("StateIncomeTax")
                if state_income_tax:
                    print(
                        "...State income tax: {} has confidence: {}".format(
                            state_income_tax.value, 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.value:
                local_wages_tips = tax.value.get("LocalWagesTipsEtc")
                if local_wages_tips:
                    print(
                        "...Local wages, tips, etc: {} has confidence: {}".format(
                            local_wages_tips.value, local_wages_tips.confidence
                        )
                    )
                local_income_tax = tax.value.get("LocalIncomeTax")
                if local_income_tax:
                    print(
                        "...Local income tax: {} has confidence: {}".format(
                            local_income_tax.value, local_income_tax.confidence
                        )
                    )
                locality_name = tax.value.get("LocalityName")
                if locality_name:
                    print(
                        "...Locality name: {} has confidence: {}".format(
                            locality_name.value, locality_name.confidence
                        )
                    )

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


if __name__ == "__main__":
    analyze_tax_us_w2()

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

使用發票模型

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

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

# formatting function
def format_bounding_region(bounding_regions):
    if not bounding_regions:
        return "N/A"
    return ", ".join("Page #{}: {}".format(region.page_number, format_polygon(region.polygon)) for region in bounding_regions)

# formatting function
def format_polygon(polygon):
    if not polygon:
        return "N/A"
    return ", ".join(["[{}, {}]".format(p.x, p.y) for p in polygon])


def analyze_invoice():

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

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

    poller = client.begin_analyze_document(
            "prebuilt-invoice", invoiceUrl)
    invoices = poller.result()

    for idx, invoice in enumerate(invoices.documents):
        print("--------Recognizing invoice #{}--------".format(idx + 1))
        vendor_name = invoice.fields.get("VendorName")
        if vendor_name:
            print(
                "Vendor Name: {} has confidence: {}".format(
                    vendor_name.value, vendor_name.confidence
                )
            )
        vendor_address = invoice.fields.get("VendorAddress")
        if vendor_address:
            print(
                "Vendor Address: {} has confidence: {}".format(
                    vendor_address.value, vendor_address.confidence
                )
            )
        vendor_address_recipient = invoice.fields.get("VendorAddressRecipient")
        if vendor_address_recipient:
            print(
                "Vendor Address Recipient: {} has confidence: {}".format(
                    vendor_address_recipient.value, vendor_address_recipient.confidence
                )
            )
        customer_name = invoice.fields.get("CustomerName")
        if customer_name:
            print(
                "Customer Name: {} has confidence: {}".format(
                    customer_name.value, customer_name.confidence
                )
            )
        customer_id = invoice.fields.get("CustomerId")
        if customer_id:
            print(
                "Customer Id: {} has confidence: {}".format(
                    customer_id.value, customer_id.confidence
                )
            )
        customer_address = invoice.fields.get("CustomerAddress")
        if customer_address:
            print(
                "Customer Address: {} has confidence: {}".format(
                    customer_address.value, customer_address.confidence
                )
            )
        customer_address_recipient = invoice.fields.get("CustomerAddressRecipient")
        if customer_address_recipient:
            print(
                "Customer Address Recipient: {} has confidence: {}".format(
                    customer_address_recipient.value,
                    customer_address_recipient.confidence,
                )
            )
        invoice_id = invoice.fields.get("InvoiceId")
        if invoice_id:
            print(
                "Invoice Id: {} has confidence: {}".format(
                    invoice_id.value, invoice_id.confidence
                )
            )
        invoice_date = invoice.fields.get("InvoiceDate")
        if invoice_date:
            print(
                "Invoice Date: {} has confidence: {}".format(
                    invoice_date.value, invoice_date.confidence
                )
            )
        invoice_total = invoice.fields.get("InvoiceTotal")
        if invoice_total:
            print(
                "Invoice Total: {} has confidence: {}".format(
                    invoice_total.value, invoice_total.confidence
                )
            )
        due_date = invoice.fields.get("DueDate")
        if due_date:
            print(
                "Due Date: {} has confidence: {}".format(
                    due_date.value, due_date.confidence
                )
            )
        purchase_order = invoice.fields.get("PurchaseOrder")
        if purchase_order:
            print(
                "Purchase Order: {} has confidence: {}".format(
                    purchase_order.value, purchase_order.confidence
                )
            )
        billing_address = invoice.fields.get("BillingAddress")
        if billing_address:
            print(
                "Billing Address: {} has confidence: {}".format(
                    billing_address.value, billing_address.confidence
                )
            )
        billing_address_recipient = invoice.fields.get("BillingAddressRecipient")
        if billing_address_recipient:
            print(
                "Billing Address Recipient: {} has confidence: {}".format(
                    billing_address_recipient.value,
                    billing_address_recipient.confidence,
                )
            )
        shipping_address = invoice.fields.get("ShippingAddress")
        if shipping_address:
            print(
                "Shipping Address: {} has confidence: {}".format(
                    shipping_address.value, shipping_address.confidence
                )
            )
        shipping_address_recipient = invoice.fields.get("ShippingAddressRecipient")
        if shipping_address_recipient:
            print(
                "Shipping Address Recipient: {} has confidence: {}".format(
                    shipping_address_recipient.value,
                    shipping_address_recipient.confidence,
                )
            )
        print("Invoice items:")
        for idx, item in enumerate(invoice.fields.get("Items").value):
            print("...Item #{}".format(idx + 1))
            item_description = item.value.get("Description")
            if item_description:
                print(
                    "......Description: {} has confidence: {}".format(
                        item_description.value, item_description.confidence
                    )
                )
            item_quantity = item.value.get("Quantity")
            if item_quantity:
                print(
                    "......Quantity: {} has confidence: {}".format(
                        item_quantity.value, item_quantity.confidence
                    )
                )
            unit = item.value.get("Unit")
            if unit:
                print(
                    "......Unit: {} has confidence: {}".format(
                        unit.value, unit.confidence
                    )
                )
            unit_price = item.value.get("UnitPrice")
            if unit_price:
                print(
                    "......Unit Price: {} has confidence: {}".format(
                        unit_price.value, unit_price.confidence
                    )
                )
            product_code = item.value.get("ProductCode")
            if product_code:
                print(
                    "......Product Code: {} has confidence: {}".format(
                        product_code.value, product_code.confidence
                    )
                )
            item_date = item.value.get("Date")
            if item_date:
                print(
                    "......Date: {} has confidence: {}".format(
                        item_date.value, item_date.confidence
                    )
                )
            tax = item.value.get("Tax")
            if tax:
                print(
                    "......Tax: {} has confidence: {}".format(tax.value, tax.confidence)
                )
            amount = item.value.get("Amount")
            if amount:
                print(
                    "......Amount: {} has confidence: {}".format(
                        amount.value, amount.confidence
                    )
                )
        subtotal = invoice.fields.get("SubTotal")
        if subtotal:
            print(
                "Subtotal: {} has confidence: {}".format(
                    subtotal.value, subtotal.confidence
                )
            )
        total_tax = invoice.fields.get("TotalTax")
        if total_tax:
            print(
                "Total Tax: {} has confidence: {}".format(
                    total_tax.value, total_tax.confidence
                )
            )
        previous_unpaid_balance = invoice.fields.get("PreviousUnpaidBalance")
        if previous_unpaid_balance:
            print(
                "Previous Unpaid Balance: {} has confidence: {}".format(
                    previous_unpaid_balance.value, previous_unpaid_balance.confidence
                )
            )
        amount_due = invoice.fields.get("AmountDue")
        if amount_due:
            print(
                "Amount Due: {} has confidence: {}".format(
                    amount_due.value, amount_due.confidence
                )
            )
        service_start_date = invoice.fields.get("ServiceStartDate")
        if service_start_date:
            print(
                "Service Start Date: {} has confidence: {}".format(
                    service_start_date.value, service_start_date.confidence
                )
            )
        service_end_date = invoice.fields.get("ServiceEndDate")
        if service_end_date:
            print(
                "Service End Date: {} has confidence: {}".format(
                    service_end_date.value, service_end_date.confidence
                )
            )
        service_address = invoice.fields.get("ServiceAddress")
        if service_address:
            print(
                "Service Address: {} has confidence: {}".format(
                    service_address.value, service_address.confidence
                )
            )
        service_address_recipient = invoice.fields.get("ServiceAddressRecipient")
        if service_address_recipient:
            print(
                "Service Address Recipient: {} has confidence: {}".format(
                    service_address_recipient.value,
                    service_address_recipient.confidence,
                )
            )
        remittance_address = invoice.fields.get("RemittanceAddress")
        if remittance_address:
            print(
                "Remittance Address: {} has confidence: {}".format(
                    remittance_address.value, remittance_address.confidence
                )
            )
        remittance_address_recipient = invoice.fields.get("RemittanceAddressRecipient")
        if remittance_address_recipient:
            print(
                "Remittance Address Recipient: {} has confidence: {}".format(
                    remittance_address_recipient.value,
                    remittance_address_recipient.confidence,
                )
            )

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

if __name__ == "__main__":
    analyze_invoice()

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

使用收據模型

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

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

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

   client = DocumentIntelligenceClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )
    poller = client.begin_analyze_document(
        "prebuilt-receipt", receiptUrl, locale="en-US"
    )
    receipts = poller.result()
    for idx, receipt in enumerate(receipts.documents):
         print("--------Analysis of receipt #{}--------".format(idx   1))
        print("Receipt type: {}".format(receipt.doc_type or "N/A"))
        merchant_name = receipt.fields.get("MerchantName")
        if merchant_name:
            print(
                "Merchant Name: {} has confidence: {}".format(
                    merchant_name.value, merchant_name.confidence
                )
            )
        transaction_date = receipt.fields.get("TransactionDate")
        if transaction_date:
            print(
                "Transaction Date: {} has confidence: {}".format(
                    transaction_date.value, transaction_date.confidence
                )
            )
        if receipt.fields.get("Items"):
            print("Receipt items:")
            for idx, item in enumerate(receipt.fields.get("Items").value):
                 print("...Item #{}".format(idx   1))
                item_description = item.value.get("Description")
                if item_description:
                    print(
                        "......Item Description: {} has confidence: {}".format(
                            item_description.value, item_description.confidence
                        )
                    )
                item_quantity = item.value.get("Quantity")
                if item_quantity:
                    print(
                        "......Item Quantity: {} has confidence: {}".format(
                            item_quantity.value, item_quantity.confidence
                        )
                    )
                item_price = item.value.get("Price")
                if item_price:
                    print(
                        "......Individual Item Price: {} has confidence: {}".format(
                            item_price.value, item_price.confidence
                        )
                    )
                item_total_price = item.value.get("TotalPrice")
                if item_total_price:
                    print(
                        "......Total Item Price: {} has confidence: {}".format(
                            item_total_price.value, item_total_price.confidence
                        )
                    )
        subtotal = receipt.fields.get("Subtotal")
        if subtotal:
            print(
                "Subtotal: {} has confidence: {}".format(
                    subtotal.value, subtotal.confidence
                )
            )
        tax = receipt.fields.get("TotalTax")
        if tax:
            print("Total tax: {} has confidence: {}".format(tax.value, tax.confidence))
        tip = receipt.fields.get("Tip")
        if tip:
            print("Tip: {} has confidence: {}".format(tip.value, tip.confidence))
        total = receipt.fields.get("Total")
        if total:
            print("Total: {} has confidence: {}".format(total.value, total.confidence))
        print("--------------------------------------")


if __name__ == "__main__":
    analyze_receipts()

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

使用標識碼檔模型

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

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

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

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

    poller =client.begin_analyze_document(
            "prebuilt-idDocument", identityUrl
        )
    id_documents = poller.result()

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

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

if __name__ == "__main__":
    analyze_identity_documents()

請流覽 GitHub 上的 Azure 範例存放庫，並檢視 標識碼檔模型輸出。

注意

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

| 檔智慧 REST API | 支援的 Azure SDK

必要條件

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

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

  curl -help
  

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

  • Windows
  • Mac 或 Linux

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

• 您建立的資源中的金鑰和端點，以將應用程式連線到 Azure Document Intelligence 服務。

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

  

設定環境變數

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

重要

請勿將密鑰直接包含在程式碼中，且絕不公開發佈。 針對生產環境，請使用安全的方式來儲存和存取您的認證，例如 Azure 金鑰保存庫。 如需詳細資訊，請參閱 Azure AI 服務安全性。

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

Windows

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

1. 設定您的金鑰變數：

   setx DI_KEY <yourKey>
   

2. 設定您的端點變數

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

macOS 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export key=<yourKey>
   

2. 設定您的端點變數：

   export endpoint=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bash_profile 啟動腳稿中放置匯出命令：

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   範例: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

Linux 中的環境變數會區分大小寫。 傳統上，變數名稱是以大寫字母宣告。

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

1. 設定您的金鑰變數：

   export DI_KEY=<yourKey>
   

2. 設定您的端點變數：

   export DI_ENDPOINT=<yourEndpoint>
   

若要永久設定環境變數，請在Bash ~/.bashrc 啟動腳稿中放置匯出命令：

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

   export <VARIABLE>=<value>
   

   範例: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

分析檔並取得結果

POST 要求可用來使用預先建置或自定義模型來分析檔。 GET 要求可用來擷取檔分析呼叫的結果。 modelId與 POST 和 resultId GET 作業搭配使用。

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

模型	modelId	description	document-url
讀取模型	prebuilt-read	範例摺頁冊	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
版面配置模型	prebuilt-layout	預約確認範例	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
W-2 表體模型	prebuilt-tax.us.w2	範例 W-2 表單	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
發票模型	預建發票	發票範例	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
收據模型	prebuilt-receipt	範例收據	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
標識碼檔模型	prebuilt-idDocument	範例標識碼檔	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

POST 要求

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

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

若要啟用附加元件功能，請使用 POST 要求中的 features 查詢參數。 有四個附加元件功能可供 （GA） 和更新版本使用：ocr.highResolution、ocr.formula、ocr.font 和 queryFields.premium2023-07-31。 若要深入瞭解每個功能，請參閱 自定義模型。

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

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

POST 回應

您會收到 202 (Success) 包含標頭的 Operation-location 回應。 使用這個標頭的值來擷取響應結果。

取得分析結果 （GET 要求）

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

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

Windows

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

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

   npm install -g jsontool
   

2. 藉由包含管線字元 | json 與 GET 要求，以美化 JSON 輸出。

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

macOS

json_pp命令工具隨附 macOS，並可作為 cURL 的 JSON 格式器。

• 藉由包含 | json_pp GET 要求，以列印 JSON 輸出。

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

Linux

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

• 藉由包含 | json_pp 您的 GET 要求，以列印 JSON 輸出。

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

GET 要求

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

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

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

檢查回應

您收到 200 (Success) 回應及 JSON 輸出。 第一個字段 status表示作業的狀態。 如果工作未完成，則的值 status 為 running 或 notStarted。 手動或透過腳本再次呼叫 API。 我們建議在呼叫之間間隔一秒以上。

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

模型	輸出 URL
讀取模型	讀取模型輸出
版面配置模型	版面配置模型輸出
W-2 稅金模型	W-2 稅務模型輸出
發票模型	發票模型輸出
收據模型	收據模型輸出
標識碼檔模型	標識碼檔模型輸出

下一步

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

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