你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

使用文档智能模型

此内容适用于：v4.0（预览版） | 先前版本：v3.1 (GA)v3.0 (GA)v2.1 (GA)

本指南介绍如何将文档智能模型添加到应用程序和工作流中。 可以使用所选编程语言 SDK 或 REST API。

Azure AI 文档智能是一个基于云的 Azure AI 服务，它使用机器学习从文档中提取关键文本和结构元素。 我们建议你在学习该技术时使用免费服务。 请记住，每月的免费页数限于 500。

从以下文档智能模型中选择一种模型，分析并提取表单和文档中的数据和值：

• 预生成读取模型是所有文档智能模型的核心，可以检测行、字词、位置和语言。 布局、常规文档、预生成和自定义模型都使用 read 模型作为从文档中提取文本的基础。

• 预生成布局模型从文档和图像中提取文本和文本位置、表、选择标记和结构信息。 可以使用布局模型并启用可选的查询字符串参数 features=keyValuePairs 来提取键/值对。

• prebuilt-contract 模型从合同协议中提取关键信息。

• prebuilt-healthInsuranceCard.us 模型可从美国医疗保险卡中提取重要信息。

• 预生成税务文件模型模型提取美国税务表单上报告的信息。

• 预生成发票模型会从各种格式和质量的销售发票中提取关键字段和行项。 字段包括手机捕获的图像、扫描的文档和数字 PDF。

• 预生成收据模型提取印刷体和手写体销售收据中的关键信息。

• 预生成 idDocument 模型从美国驾驶执照、国际护照个人资料页、美国各州身份证、社会保障卡和永久居民卡中提取关键信息。

客户端库 | SDK 参考 | REST API 参考 | 包| 示例|支持的 REST API 版本

先决条件

• Azure 订阅 - 免费创建订阅。

• Visual Studio IDE。

• Azure AI 服务或文档智能资源。 创建“单一服务或多个服务。 可以使用免费定价层 (F0) 试用该服务，然后再升级到付费层进行生产。

• 从创建的资源获取密钥和终结点，以便将应用程序连接到文档智能服务。

  1. 部署资源后，选择“转到资源”。
  2. 在左侧导航菜单中，选择“密钥和终结点”。
  3. 复制其中一个密钥和终结点，稍后你将在本快速入门中使用它们。

  

• 在 URL 中的文档文件。 对于本项目，可以使用下表中为每项功能提供的示例表单：

  功能	modelID	document-url
  “读取”模型	prebuilt-read	示例手册
  布局模型	预生成布局	预订确认示例
  W-2 窗体模型	prebuilt-tax.us.w2	示例 W-2 表单
  发票模型	预生成的发票	示例发票
  收据模型	prebuilt-receipt	示例收据
  ID 文档模型	prebuilt-idDocument	示例身份证明文档

设置环境变量

若要与文档智能服务交互，需要创建 DocumentAnalysisClient 类的实例。 为此，请使用 Azure 门户中的 key 和 endpoint 实例化客户端。 对于此项目，使用环境变量来存储和访问凭据。

重要

如果使用 API 密钥，请将其安全地存储在某个其他位置，例如 Azure Key Vault 中。 请不要直接在代码中包含 API 密钥，并且切勿公开发布该密钥。

有关 Azure AI 服务安全性的详细信息，请参阅对 Azure AI 服务的请求进行身份验证。

若要为文档智能资源密钥设置环境变量，请打开控制台窗口，按照操作系统和开发环境的说明进行操作。 将 <yourKey> 和 <yourEndpoint> 替换为 Azure 门户中资源的值。

Windows

环境变量不区分大小写。 它们通常以大写形式声明，其中包含的单词以下划线联接。 请根据命令提示符运行以下命令：

1. 设置密钥变量：

   setx DI_KEY <yourKey>
   

2. 设置终结点变量

   setx DI_ENDPOINT <yourEndpoint>
   

3. 设置环境变量后关闭命令提示符窗口。 这些值将一直保留，直到你再次更改它们。

4. 重启任何读取环境变量的运行程序。 例如，如果正在使用 Visual Studio 或 Visual Studio Code 作为编辑器，请在运行示例代码之前重启它。

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
setx VARIABLE_NAME=	通过将环境变量值设置为空字符串来删除环境变量。	setx DI_KEY=
setx VARIABLE_NAME=value	设置或更改环境变量的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	显示特定环境变量的值。	set DI_KEY
set	显示所有环境变量。	set

macOS

macOS 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此变量是临时的，仅在关闭终端会话之前有效： 打开终端并输入以下命令：

1. 设置密钥变量：

   export key=<yourKey>
   

2. 设置终结点变量：

   export endpoint=<yourEndpoint>
   

通过在 Bash ~/.bash_profile 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用你喜欢的文本编辑器打开 ~/.bash_profile 文件并添加以下命令，以创建永久环境变量：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   示例： export DI_KEY="<yourKey>"

2. 保存对 bash_profile 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bash-profile
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示特定环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

Linux

Linux 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此值是临时的，仅在关闭终端会话之前有效：

1. 设置密钥变量：

   export DI_KEY=<yourKey>
   

2. 设置终结点变量：

   export DI_ENDPOINT=<yourEndpoint>
   

通过在 Bash ~/.bashrc 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用文本编辑器打开 ~/.bashrc 文件并添加以下命令，以创建永久环境变量：

   export <VARIABLE>=<value>
   

   示例： export DI_KEY=<yourKey>

2. 保存对 .bashrc 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bashrc
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY=
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

设置编程环境

1. 启动 Visual Studio。

2. 在“开始”页上，选择“创建新项目”。

   

3. 在“创建新项目”页面上，在搜索框中输入“控制台”。 选择“控制台应用程序”模板，然后选择“下一步”。

   

4. 在“配置新项目”页的“项目名称”下，输入 docIntelligence_app。 然后，选择“下一步”。

   

5. 在“其他信息”页面中，选择“.NET 8.0 (长期支持)”，然后选择“创建”。

   

使用 NuGet 安装客户端库

1. 右键单击 docIntelligence_app 项目，然后选择“管理 NuGet 包...”。

   

2. 选择“浏览”选项卡，并输入 Azure.AI.FormRecognizer。

3. 选中 Include prerelease 复选框。

   

4. 从下拉菜单中选择一个版本，然后将包安装到项目中。

生成应用程序

注意

从 .NET 6 开始，使用 console 模板的新项目将生成与以前版本不同的新程序样式。 新的输出使用最新的 C# 功能，这些功能简化了你需要编写的代码。

使用较新版本时，只需编写 Main 方法的主体。 无需包括顶级语句、全局 using 指令或隐式 using 指令。 有关详细信息，请参阅 C# 控制台应用模板生成顶级语句。

1. 打开 Program.cs 文件。

2. 删除现有的代码，包括 Console.Writeline("Hello World!") 行。

3. 选择以下代码示例之一，然后将其复制并粘贴到应用程序的 Program.cs 文件中：

   • prebuilt-read
   • 预生成布局
   • prebuilt-tax.us.w2
   • 预生成的发票
   • prebuilt-receipt
   • prebuilt-idDocument

4. 将代码示例添加到应用程序后，选择项目名称旁边的绿色“开始”按钮以生成和运行程序，或按 F5 键。

   

使用“读取”模型

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-read", fileUri);
AnalyzeResult result = operation.Value;

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

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

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

        for (int j = 0; j < line.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.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

        for (int j = 0; j < line.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.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

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

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

        for (int j = 0; j < line.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.DocumentIntelligence;

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

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

Operation<AnalyzeResult> operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, "prebuilt-tax.us.w2", w2Uri);

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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


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

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

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

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

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

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

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

请访问 GitHub 上的 Azure 示例存储库，并查看 W-2 税务模型输出。

使用发票模型

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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

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

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

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

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

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

请访问 GitHub 上的 Azure 示例存储库，并查看发票模型输出。

使用收据模型

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult receipts = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

请访问 GitHub 上的 Azure 示例存储库，并查看收据模型输出。

使用 ID 文档模型

using Azure;
using Azure.AI.DocumentIntelligence;

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

// sample document document

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

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

AnalyzeResult identityDocuments = operation.Value;

AnalyzedDocument identityDocument = identityDocuments.Documents.Single();

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

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

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

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

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

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

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

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

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

请访问 GitHub 上的 Azure 示例存储库，并查看 ID 文档模型输出。

客户端库 | SDK 参考 | REST API 参考 | 包 (Maven) | 示例 |支持的 REST API 版本

先决条件

• Azure 订阅 - 免费创建订阅。

• 最新版本的 Visual Studio Code 或者你首选的 IDE。 请参阅 Visual Studio Code 中的 Java。

  • Visual Studio Code 提供了适用于 Windows 和 macOS 的 Java 编码包。 该编码包是 VS Code、Java 开发工具包 (JDK) 和 Microsoft 建议扩展的集合。 编码包还可用于修复现有开发环境。
  • 如果使用的是 VS Code 和适用于 Java 的编码包，请安装 Gradle for Java 扩展。

  如果不使用 Visual Studio Code，请确保在开发环境中安装了以下内容：

  • Java 开发工具包 (JDK) 版本 8 或更高版本。 有关详细信息，请参阅 Microsoft Build of OpenJDK。
  • Gradle 版本 6.8 或更高版本。

• Azure AI 服务或文档智能资源。 创建“单一服务或多个服务。 可以使用免费定价层 (F0) 试用该服务，然后再升级到付费层进行生产。

  提示

  如果计划通过一个终结点和密钥访问多个 Azure AI 服务，请创建 Azure AI 服务资源。 请创建仅供文档智能访问的文档智能资源。 若要使用 Microsoft Entra 身份验证，则需要单服务资源。

• 从创建的资源获取密钥和终结点，以便将应用程序连接到文档智能服务。

  1. 部署资源后，选择“转到资源”。
  2. 在左侧导航菜单中，选择“密钥和终结点”。
  3. 复制其中一个密钥和终结点，稍后你将在本快速入门中使用它们。

  

• URL 中的文档文件。 对于本项目，可以使用下表中为每项功能提供的示例表单：

  功能	modelID	document-url
  “读取”模型	prebuilt-read	示例手册
  布局模型	预生成布局	预订确认示例
  W-2 窗体模型	prebuilt-tax.us.w2	示例 W-2 表单
  发票模型	预生成的发票	示例发票
  收据模型	prebuilt-receipt	示例收据
  ID 文档模型	prebuilt-idDocument	示例身份证明文档

设置环境变量

若要与文档智能服务交互，需要创建 DocumentAnalysisClient 类的实例。 为此，请使用 Azure 门户中的 key 和 endpoint 实例化客户端。 对于此项目，使用环境变量来存储和访问凭据。

重要

如果使用 API 密钥，请将其安全地存储在某个其他位置，例如 Azure Key Vault 中。 请不要直接在代码中包含 API 密钥，并且切勿公开发布该密钥。

有关 Azure AI 服务安全性的详细信息，请参阅对 Azure AI 服务的请求进行身份验证。

若要为文档智能资源密钥设置环境变量，请打开控制台窗口，按照操作系统和开发环境的说明进行操作。 将 <yourKey> 和 <yourEndpoint> 替换为 Azure 门户中资源的值。

Windows

环境变量不区分大小写。 它们通常以大写形式声明，其中包含的单词以下划线联接。 请根据命令提示符运行以下命令：

1. 设置密钥变量：

   setx DI_KEY <yourKey>
   

2. 设置终结点变量

   setx DI_ENDPOINT <yourEndpoint>
   

3. 设置环境变量后关闭命令提示符窗口。 这些值将一直保留，直到你再次更改它们。

4. 重启任何读取环境变量的运行程序。 例如，如果正在使用 Visual Studio 或 Visual Studio Code 作为编辑器，请在运行示例代码之前重启它。

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
setx VARIABLE_NAME=	通过将环境变量值设置为空字符串来删除环境变量。	setx DI_KEY=
setx VARIABLE_NAME=value	设置或更改环境变量的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	显示特定环境变量的值。	set DI_KEY
set	显示所有环境变量。	set

macOS

macOS 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此变量是临时的，仅在关闭终端会话之前有效： 打开终端并输入以下命令：

1. 设置密钥变量：

   export key=<yourKey>
   

2. 设置终结点变量：

   export endpoint=<yourEndpoint>
   

通过在 Bash ~/.bash_profile 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用你喜欢的文本编辑器打开 ~/.bash_profile 文件并添加以下命令，以创建永久环境变量：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   示例： export DI_KEY="<yourKey>"

2. 保存对 bash_profile 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bash-profile
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示特定环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

Linux

Linux 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此值是临时的，仅在关闭终端会话之前有效：

1. 设置密钥变量：

   export DI_KEY=<yourKey>
   

2. 设置终结点变量：

   export DI_ENDPOINT=<yourEndpoint>
   

通过在 Bash ~/.bashrc 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用文本编辑器打开 ~/.bashrc 文件并添加以下命令，以创建永久环境变量：

   export <VARIABLE>=<value>
   

   示例： export DI_KEY=<yourKey>

2. 保存对 .bashrc 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bashrc
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY=
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

设置编程环境

若要设置编程环境，请创建 Gradle 项目并安装客户端库。

创建新的 Gradle 项目

1. 在控制台窗口中，为你的应用（名为 doc-intelligence-app）创建一个新目录，然后导航到该目录。

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

2. 从工作目录运行 gradle init 命令。 此命令将创建 Gradle 的基本生成文件，其中包括 build.gradle.kts - 在运行时将使用该文件创建并配置应用程序。

   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.4'
   }
   

创建 Java 应用程序

若要与文档智能服务交互，需要创建 DocumentIntelligenceClient 类的实例。 为此，你要通过 Azure 门户使用 key 创建一个 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 文件，选择以下代码示例之一，然后将其复制/贴到你的应用程序中：

   • 预生成读取模型是所有文档智能模型的核心，可以检测行、字词、位置和语言。 布局、常规文档、预生成和自定义模型都使用 read 模型作为从文档中提取文本的基础。
   • 预生成布局模型从文档和图像中提取文本和文本位置、表、选择标记和结构信息。
   • 预生成 tax.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 示例存储库，并查看收据模型输出。

使用 ID 文档模型

import com.azure.ai.documentintelligence;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

请访问 GitHub 上的 Azure 示例存储库，并查看 ID 文档模型输出。

客户端库 | REST API 参考 | 包 (npm) | 示例 |支持的 REST API 版本

先决条件

• Azure 订阅 - 免费创建订阅。

• 最新版本的 Visual Studio Code 或者你首选的 IDE。 有关详细信息，请参阅 Visual Studio Code 中的 Node.js。

• Node.js 的最新 LTS 版本。

• Azure AI 服务或文档智能资源。 创建“单一服务或多个服务。 可以使用免费定价层 (F0) 试用该服务，然后再升级到付费层进行生产。

  提示

  如果计划通过一个终结点和密钥访问多个 Azure AI 服务，请创建 Azure AI 服务资源。 请创建仅供文档智能访问的文档智能资源。 若要使用 Microsoft Entra 身份验证，则需要单服务资源。

• 从创建的资源获取密钥和终结点，以便将应用程序连接到文档智能服务。

  1. 部署资源后，选择“转到资源”。
  2. 在左侧导航菜单中，选择“密钥和终结点”。
  3. 复制其中一个密钥和终结点，稍后你将在本快速入门中使用它们。

  

• URL 中的文档文件。 对于本项目，可以使用下表中为每项功能提供的示例表单：

  功能	modelID	document-url
  “读取”模型	prebuilt-read	示例手册
  布局模型	预生成布局	预订确认示例
  W-2 窗体模型	prebuilt-tax.us.w2	示例 W-2 表单
  发票模型	预生成的发票	示例发票
  收据模型	prebuilt-receipt	示例收据
  ID 文档模型	prebuilt-idDocument	示例身份证明文档

设置环境变量

若要与文档智能服务交互，需要创建 DocumentAnalysisClient 类的实例。 为此，请使用 Azure 门户中的 key 和 endpoint 实例化客户端。 对于此项目，使用环境变量来存储和访问凭据。

重要

如果使用 API 密钥，请将其安全地存储在某个其他位置，例如 Azure Key Vault 中。 请不要直接在代码中包含 API 密钥，并且切勿公开发布该密钥。

有关 Azure AI 服务安全性的详细信息，请参阅对 Azure AI 服务的请求进行身份验证。

若要为文档智能资源密钥设置环境变量，请打开控制台窗口，按照操作系统和开发环境的说明进行操作。 将 <yourKey> 和 <yourEndpoint> 替换为 Azure 门户中资源的值。

Windows

环境变量不区分大小写。 它们通常以大写形式声明，其中包含的单词以下划线联接。 请根据命令提示符运行以下命令：

1. 设置密钥变量：

   setx DI_KEY <yourKey>
   

2. 设置终结点变量

   setx DI_ENDPOINT <yourEndpoint>
   

3. 设置环境变量后关闭命令提示符窗口。 这些值将一直保留，直到你再次更改它们。

4. 重启任何读取环境变量的运行程序。 例如，如果正在使用 Visual Studio 或 Visual Studio Code 作为编辑器，请在运行示例代码之前重启它。

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
setx VARIABLE_NAME=	通过将环境变量值设置为空字符串来删除环境变量。	setx DI_KEY=
setx VARIABLE_NAME=value	设置或更改环境变量的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	显示特定环境变量的值。	set DI_KEY
set	显示所有环境变量。	set

macOS

macOS 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此变量是临时的，仅在关闭终端会话之前有效： 打开终端并输入以下命令：

1. 设置密钥变量：

   export key=<yourKey>
   

2. 设置终结点变量：

   export endpoint=<yourEndpoint>
   

通过在 Bash ~/.bash_profile 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用你喜欢的文本编辑器打开 ~/.bash_profile 文件并添加以下命令，以创建永久环境变量：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   示例： export DI_KEY="<yourKey>"

2. 保存对 bash_profile 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bash-profile
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示特定环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

Linux

Linux 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此值是临时的，仅在关闭终端会话之前有效：

1. 设置密钥变量：

   export DI_KEY=<yourKey>
   

2. 设置终结点变量：

   export DI_ENDPOINT=<yourEndpoint>
   

通过在 Bash ~/.bashrc 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用文本编辑器打开 ~/.bashrc 文件并添加以下命令，以创建永久环境变量：

   export <VARIABLE>=<value>
   

   示例： export DI_KEY=<yourKey>

2. 保存对 .bashrc 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bashrc
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY=
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

设置编程环境

创建 Node.js Express 应用程序。

1. 在控制台窗口中，为名为“doc-intel-app”的应用创建一个新目录，然后导航到该目录。

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

2. 运行 npm init 命令以初始化应用程序并为项目构建基架。

   npm init
   

3. 使用终端中提供的提示指定项目的属性。

   • 最重要的属性包括名称、版本号和入口点。
   • 建议保留 index.js 作为入口点名称。 描述、测试命令、GitHub 存储库、关键字、作者和许可证信息均为可选属性。 可在此项目中跳过它们。
   • 选择“Enter”以接受括号中的建议。

   完成提示后，命令会在 doc-intel-app 目录中创建一个 package.json 文件。

4. 安装 ai-document-intelligence 客户端库和 azure/identity npm 包：

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

应用的 package.json 文件将随依赖项进行更新。

1. 在应用程序目录中创建一个名为“index.js”的文件。

   提示

   可以使用 Powershell 创建新文件。 按住 Shift 键并右键单击文件夹，在项目目录中打开 PowerShell 窗口，然后输入以下命令：New-Item index.js。

生成应用程序

若要与文档智能服务交互，需要创建 DocumentIntelligenceClient 类的实例。 为此，你要通过 Azure 门户使用你的密钥创建一个 AzureKeyCredential，并使用 AzureKeyCredential 和文档智能终结点创建一个 DocumentIntelligenceClient 实例。

在 Visual Studio Code 或你喜爱的 IDE 中打开 index.js 文件，选择以下代码示例之一，然后将其复制/粘贴到你的应用程序中：

• 预生成读取模型是所有文档智能模型的核心，可以检测行、字词、位置和语言。 布局、常规文档、预生成和自定义模型都使用 read 模型作为从文档中提取文本的基础。
• 预生成布局模型从文档和图像中提取文本和文本位置、表、选择标记和结构信息。
• 预生成 tax.us.w2 模型提取美国国内税收署 (IRS) 纳税表单上报告的信息。
• prebuilt-invoice 模型会提取美国国内税收署纳税表单上报告的信息。
• 预生成收据模型提取印刷体和手写体销售收据中的关键信息。
• 预生成 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 示例存储库，并查看收据模型输出。

使用 ID 文档模型

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

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

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

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

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

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

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

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

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

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

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

请访问 GitHub 上的 Azure 示例存储库，并查看 ID 文档模型输出。

客户端库 |SDK 参考 | 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) 试用该服务，然后再升级到付费层进行生产。

• 从创建的资源获取密钥和终结点，以便将应用程序连接到文档智能服务。

  1. 部署资源后，选择“转到资源”。
  2. 在左侧导航菜单中，选择“密钥和终结点”。
  3. 复制其中一个密钥和终结点，稍后你将在本快速入门中使用它们。

  

• URL 中的文档文件。 对于本项目，可以使用下表中为每项功能提供的示例表单：

  功能	modelID	document-url
  “读取”模型	prebuilt-read	示例手册
  布局模型	预生成布局	预订确认示例
  W-2 窗体模型	prebuilt-tax.us.w2	示例 W-2 表单
  发票模型	预生成的发票	示例发票
  收据模型	prebuilt-receipt	示例收据
  ID 文档模型	prebuilt-idDocument	示例身份证明文档

设置环境变量

若要与文档智能服务交互，需要创建 DocumentAnalysisClient 类的实例。 为此，请使用 Azure 门户中的 key 和 endpoint 实例化客户端。 对于此项目，使用环境变量来存储和访问凭据。

重要

如果使用 API 密钥，请将其安全地存储在某个其他位置，例如 Azure Key Vault 中。 请不要直接在代码中包含 API 密钥，并且切勿公开发布该密钥。

有关 Azure AI 服务安全性的详细信息，请参阅对 Azure AI 服务的请求进行身份验证。

若要为文档智能资源密钥设置环境变量，请打开控制台窗口，按照操作系统和开发环境的说明进行操作。 将 <yourKey> 和 <yourEndpoint> 替换为 Azure 门户中资源的值。

Windows

环境变量不区分大小写。 它们通常以大写形式声明，其中包含的单词以下划线联接。 请根据命令提示符运行以下命令：

1. 设置密钥变量：

   setx DI_KEY <yourKey>
   

2. 设置终结点变量

   setx DI_ENDPOINT <yourEndpoint>
   

3. 设置环境变量后关闭命令提示符窗口。 这些值将一直保留，直到你再次更改它们。

4. 重启任何读取环境变量的运行程序。 例如，如果正在使用 Visual Studio 或 Visual Studio Code 作为编辑器，请在运行示例代码之前重启它。

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
setx VARIABLE_NAME=	通过将环境变量值设置为空字符串来删除环境变量。	setx DI_KEY=
setx VARIABLE_NAME=value	设置或更改环境变量的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	显示特定环境变量的值。	set DI_KEY
set	显示所有环境变量。	set

macOS

macOS 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此变量是临时的，仅在关闭终端会话之前有效： 打开终端并输入以下命令：

1. 设置密钥变量：

   export key=<yourKey>
   

2. 设置终结点变量：

   export endpoint=<yourEndpoint>
   

通过在 Bash ~/.bash_profile 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用你喜欢的文本编辑器打开 ~/.bash_profile 文件并添加以下命令，以创建永久环境变量：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   示例： export DI_KEY="<yourKey>"

2. 保存对 bash_profile 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bash-profile
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示特定环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

Linux

Linux 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此值是临时的，仅在关闭终端会话之前有效：

1. 设置密钥变量：

   export DI_KEY=<yourKey>
   

2. 设置终结点变量：

   export DI_ENDPOINT=<yourEndpoint>
   

通过在 Bash ~/.bashrc 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用文本编辑器打开 ~/.bashrc 文件并添加以下命令，以创建永久环境变量：

   export <VARIABLE>=<value>
   

   示例： export DI_KEY=<yourKey>

2. 保存对 .bashrc 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bashrc
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY=
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

设置编程环境

在本地环境中打开一个控制台窗口，并使用 pip 安装适用于 Python 的 Azure AI 文档智能客户端库：

pip install azure-ai-documentintelligence==1.0.0b4

创建 Python 应用程序

若要与文档智能服务交互，需要创建 DocumentIntelligenceClient 类的实例。 为此，你要通过 Azure 门户使用你的密钥创建一个 AzureKeyCredential，并使用 AzureKeyCredential 和文档智能终结点创建一个 DocumentIntelligenceClient 实例。

1. 在编辑器或 IDE 中创建一个名为 form_recognizer_quickstart.py 的新 Python 文件。

2. 打开 form_recognizer_quickstart.py 文件，选择以下代码示例之一，然后将其复制/粘贴到你的应用程序中：

   • 预生成读取模型是所有文档智能模型的核心，可以检测行、字词、位置和语言。 布局、常规文档、预生成和自定义模型都使用 read 模型作为从文档中提取文本的基础。
   • 预生成布局模型从文档和图像中提取文本和文本位置、表、选择标记和结构信息。
   • 预生成 tax.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')

# helper functions
def get_words(page, line):
    result = []
    for word in page.words:
        if _in_span(word, line.spans):
            result.append(word)
    return result


def _in_span(word, spans):
    for span in spans:
        if word.span.offset >= span.offset and (word.span.offset + word.span.length) <= (span.offset + span.length):
            return True
    return False


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

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

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

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

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

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

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

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

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

    if result.paragraphs:
        print(f"----Detected #{len(result.paragraphs)} paragraphs in the document----")
        for paragraph in result.paragraphs:
            print(f"Found paragraph with role: '{paragraph.role}' within {paragraph.bounding_regions} bounding region")
            print(f"...with content: '{paragraph.content}'")

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

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


if __name__ == "__main__":
    analyze_read()

在 GitHub 上查看完整代码。更多示例

请访问 GitHub 上的 Azure 示例存储库，并查看 read 模型输出。

使用布局模型

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


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


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

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

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

    if result.styles and any([style.is_handwritten for style in result.styles]):
        print("Document contains handwritten content")
    else:
        print("Document does not contain handwritten content")

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

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

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

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

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

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



if __name__ == "__main__":
    analyze_layout()

在 GitHub 上查看完整代码。更多示例

请访问 GitHub 上的 Azure 示例存储库，并查看布局模型输出。

使用 W-2 税务模型

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

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

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


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

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

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

    w2s: AnalyzeResult =  poller.result()

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


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


if __name__ == "__main__":
    analyze_tax_us_w2()

在 GitHub 上查看完整代码。更多示例

请访问 GitHub 上的 Azure 示例存储库，并查看 W-2 税务模型输出。

使用发票模型

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

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

def analyze_invoice():

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

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

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

    result: AnalyzeResult = poller.result()

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


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

if __name__ == "__main__":
    analyze_invoice()

在 GitHub 上查看完整代码。更多示例

请访问 GitHub 上的 Azure 示例存储库，并查看发票模型输出。

使用收据模型

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

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

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

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

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



if __name__ == "__main__":
    analyze_receipts()

在 GitHub 上查看完整代码。更多示例

请访问 GitHub 上的 Azure 示例存储库，并查看收据模型输出。

使用 ID 文档模型

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

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

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

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

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

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


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

if __name__ == "__main__":
    analyze_identity_documents()

在 GitHub 上查看完整代码。更多示例

请访问 GitHub 上的 Azure 示例存储库，并查看 ID 文档模型输出。

注意

此项目使用 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) 试用该服务，然后再升级到付费层进行生产。

• 从创建的资源获取密钥和终结点，以便将应用程序连接到文档智能服务。

  1. 部署资源后，选择“转到资源”。
  2. 在左侧导航菜单中，选择“密钥和终结点”。
  3. 复制其中一个密钥和终结点，稍后你将在本快速入门中使用它们。

  

设置环境变量

若要与文档智能服务交互，需要创建 DocumentAnalysisClient 类的实例。 为此，请使用 Azure 门户中的 key 和 endpoint 实例化客户端。 对于此项目，使用环境变量来存储和访问凭据。

重要

如果使用 API 密钥，请将其安全地存储在某个其他位置，例如 Azure Key Vault 中。 请不要直接在代码中包含 API 密钥，并且切勿公开发布该密钥。

有关 Azure AI 服务安全性的详细信息，请参阅对 Azure AI 服务的请求进行身份验证。

若要为文档智能资源密钥设置环境变量，请打开控制台窗口，按照操作系统和开发环境的说明进行操作。 将 <yourKey> 和 <yourEndpoint> 替换为 Azure 门户中资源的值。

Windows

环境变量不区分大小写。 它们通常以大写形式声明，其中包含的单词以下划线联接。 请根据命令提示符运行以下命令：

1. 设置密钥变量：

   setx DI_KEY <yourKey>
   

2. 设置终结点变量

   setx DI_ENDPOINT <yourEndpoint>
   

3. 设置环境变量后关闭命令提示符窗口。 这些值将一直保留，直到你再次更改它们。

4. 重启任何读取环境变量的运行程序。 例如，如果正在使用 Visual Studio 或 Visual Studio Code 作为编辑器，请在运行示例代码之前重启它。

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
setx VARIABLE_NAME=	通过将环境变量值设置为空字符串来删除环境变量。	setx DI_KEY=
setx VARIABLE_NAME=value	设置或更改环境变量的值。	setx DI_KEY=<yourKey>
set VARIABLE_NAME	显示特定环境变量的值。	set DI_KEY
set	显示所有环境变量。	set

macOS

macOS 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此变量是临时的，仅在关闭终端会话之前有效： 打开终端并输入以下命令：

1. 设置密钥变量：

   export key=<yourKey>
   

2. 设置终结点变量：

   export endpoint=<yourEndpoint>
   

通过在 Bash ~/.bash_profile 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用你喜欢的文本编辑器打开 ~/.bash_profile 文件并添加以下命令，以创建永久环境变量：

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   示例： export DI_KEY="<yourKey>"

2. 保存对 bash_profile 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bash-profile
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示特定环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

Linux

Linux 中的环境变量区分大小写。 通常，变量名称采用大写字母来声明。

export 命令可设置变量并将其导出到全局环境（可用于其他进程）。 但是，此值是临时的，仅在关闭终端会话之前有效：

1. 设置密钥变量：

   export DI_KEY=<yourKey>
   

2. 设置终结点变量：

   export DI_ENDPOINT=<yourEndpoint>
   

通过在 Bash ~/.bashrc 启动脚本中放置导出命令，可以永久设置环境变量：

1. 使用文本编辑器打开 ~/.bashrc 文件并添加以下命令，以创建永久环境变量：

   export <VARIABLE>=<value>
   

   示例： export DI_KEY=<yourKey>

2. 保存对 .bashrc 文件的更改。

3. 若要使更改生效，请从终端窗口中运行以下命令：

   source ~/.bashrc
   

下面是其他一些可与环境变量一起使用的有用命令：

命令	操作	示例
unset VARIABLE_NAME	删除环境变量。	unset DI_KEY=
export VARIABLE_NAME=value	设置或更改临时环境变量的值。	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	显示环境变量的值。 使用 echo 命令，在变量前面加上 $。	printenv DI_KEY echo $DI_KEY
printenv	显示所有环境变量。	printenv

分析文档并获取结果

POST 请求用于通过预生成或自定义模型分析文档。 GET 请求用于检索文档分析调用的结果。 modelId 与 POST 一起使用，resultId 与 GET 操作一起使用。

使用下表作为指南。 将 <modelId> 和 <document-url> 替换为所需的值：

型号	modelId	description	document-url
“读取”模型	prebuilt-read	示例手册	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
布局模型	预生成布局	预订确认示例	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
W-2 窗体模型	prebuilt-tax.us.w2	示例 W-2 表单	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
发票模型	预生成的发票	示例发票	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
ID 文档模型	prebuilt-idDocument	示例身份证明文档	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

POST 请求

打开控制台窗口并运行以下 cURL 命令。 该命令包含之前在“设置环境变量”部分中创建的终结点和关键环境变量。 如果变量名称不同，请替换这些变量。 请记得替换 <modelId> 和 <document-url> 参数。

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

若要启用附加功能，请在 POST 请求中使用 features 查询参数。 2023-07-31 (GA) 及更高版本提供了四项附加功能：ocr.highResolution、ocr.formula、ocr.font 和 queryFields.premium。 若要详细了解每项功能，请参阅自定义模型。

只能调用读取和布局模型的 highResolution、公式和字体功能，以及常规文档模型的 queryFields 功能。 以下示例演示如何调用布局模型的 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. 通过在 GET 请求中添加竖线 | json，打印易读的 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 格式化程序。

• 通过在 GET 请求中添加 | json_pp，打印易读的 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

大多数 Linux 分发版中预安装了 json_pp 命令行工具。 如果未包含它，可以使用分发版的包管理器进行安装。

• 通过在 GET 请求中添加 | json_pp，打印易读的 JSON 输出。

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

GET 请求

在运行以下命令之前，请进行以下更改：

• 将 <POST 响应>替换为 POST 响应的标头“Operation-location”。
• 如果 <DI_KEY 不同于代码中的名称，请将其替换为你的环境变量的变量。
• 将 *<json-tool> 替换为 JSON 格式设置工具。

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

检查响应

你将收到包含 JSON 输出的 200 (Success) 响应。 第一个字段 status 指示操作的状态。 如果操作未完成，则 status 的值为 running 或 notStarted。 再次手动或通过脚本调用 API。 我们建议两次调用间隔一秒或更长时间。

请访问 GitHub 上的 Azure 示例存储库，查看每个文档智能模型的 GET 响应：

型号	输出 URL
“读取”模型	读取模型输出
布局模型	布局模型输出
W-2 税务模型	W-2 税务模型输出
发票模型	发票模型输出
收据模型	收据模型输出
ID 文档模型	ID 文档模型输出

后续步骤

祝贺你！ 你已了解如何使用文档智能模型以不同方式分析各种文档。 接下来，请探索文档智能工作室和参考文档。

试用文档智能工作室浏览文档智能 REST API