문서 인텔리전스 모델 사용

이 콘텐츠는 적용됩니다:v4.0 (GA) | 이전 버전:v3.1 (GA)v3.0 (GA)v2.1 (GA)

이 가이드에서는 애플리케이션 및 워크플로에 문서 인텔리전스 모델을 추가하는 방법을 알아봅니다. 선택한 프로그래밍 언어 SDK 또는 REST API를 사용합니다.

Azure AI Document Intelligence는 기계 학습을 사용하여 문서에서 키 텍스트 및 구조 요소를 추출하는 클라우드 기반 Azure AI 서비스입니다. 기술을 학습하는 동안 무료 서비스를 사용하는 것이 좋습니다. 체험판 페이지는 한 달에 500페이지로 제한됩니다.

다음 문서 인텔리전스 모델 중에서 선택하고 양식 및 문서에서 데이터 및 값을 분석 및 추출합니다.

• 미리 빌드된 읽기 모델은 모든 문서 인텔리전스 모델의 핵심이며 선, 단어, 위치 및 언어를 검색할 수 있습니다. 레이아웃, 일반 문서, 미리 빌드된 모델 및 사용자 지정 모델은 모두 문서에서 텍스트를 추출하기 위한 기초로 모델을 사용합니다 read .

• 미리 빌드된 레이아웃 모델은 문서 및 이미지에서 텍스트 및 텍스트 위치, 테이블, 선택 표시 및 구조 정보를 추출합니다. 선택적 쿼리 문자열 매개 변수 features=keyValuePairs 를 사용하도록 설정된 레이아웃 모델을 사용하여 키/값 쌍을 추출할 수 있습니다.

• 미리 빌드된 계약 모델은 계약 계약에서 주요 정보를 추출합니다.

• prebuilt-healthInsuranceCard.us 모델은 미국 건강 보험 카드에서 주요 정보를 추출합니다.

• 미리 빌드된 세금 문서 모델 모델은 미국 세금 양식에 보고된 정보를 추출합니다.

• 미리 빌드된 송장 모델은 다양한 형식과 품질로 판매 청구서에서 주요 필드 및 품목을 추출합니다. 필드에는 휴대폰 캡처 이미지, 스캔한 문서 및 디지털 PDF가 포함됩니다.

• 미리 빌드된 영수증 모델은 인쇄 및 필기 판매 영수증에서 주요 정보를 추출합니다.

• 미리 빌드된 idDocument 모델은 미국 운전 면허증, 국제 여권 전기 페이지, 미국 주 ID, 사회 보장 카드 및 영주권 카드에서 주요 정보를 추출합니다.

클라이언트 라이브러리 |REST API 참조 | 패키지| 샘플|지원되는 REST API 버전

필수 조건

• Azure 구독 – 무료로 만드세요.

• Visual Studio IDE입니다.

• Azure AI 서비스 또는 문서 인텔리전스 리소스입니다. 단일 서비스 또는 다중 서비스. 평가판 가격 책정 계층(F0)을 통해 서비스를 사용해보고, 나중에 프로덕션용 유료 계층으로 업그레이드할 수 있습니다.

• 애플리케이션을 Azure Document Intelligence 서비스에 연결하기 위해 만든 리소스의 키 및 엔드포인트입니다.

  1. 리소스를 배포한 후 리소스로 이동을 선택합니다.
  2. 왼쪽 창에서 키 및 엔드포인트를 선택합니다.
  3. 이 문서의 뒷부분에서 사용할 키와 엔드포인트 중 하나를 복사합니다.

  

• URL 위치에 있는 문서 파일입니다. 이 프로젝트의 경우 각 기능에 대해 다음 표에 제공된 샘플 양식을 사용할 수 있습니다.

  특징	modelID	문서 URL
  읽기 모델	사전 빌드 읽기	샘플 브로셔
  레이아웃 모델	미리 빌드된 레이아웃	샘플 예약 확인
  W-2 양식 모델	prebuilt-tax.us.w2 (사전 구축된 세금 소프트웨어 파일)	샘플 W-2 양식
  청구서 모델	미리 구성된 청구서	샘플 청구서
  영수증 모델	미리 빌드된 영수증	샘플 영수증
  ID 문서 모델	ID 문서 사전 구축	샘플 ID 문서

환경 변수 설정

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 key 및 endpoint을 사용하여 클라이언트를 인스턴스화하세요. 이 프로젝트의 경우 환경 변수를 사용하여 자격 증명을 저장하고 액세스합니다.

중요합니다

주의해서 API 키를 사용합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요. API 키를 사용하는 경우 Azure Key Vault에 안전하게 저장합니다. 앱에서 API 키를 안전하게 사용하는 방법에 대한 자세한 내용은 Azure Key Vault를 사용하여 API 키를 참조하세요.

AI 서비스 보안에 대한 자세한 내용은 Azure AI 서비스에 대한 요청 인증을 참조하세요.

Document Intelligence 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따릅니다. <yourKey>와 <yourEndpoint>를 Azure 포털에서 리소스의 값으로 교체하십시오.

Windows

Windows의 환경 변수는 대/소문자를 구분하지 않습니다. 일반적으로 대문자로 선언되며 단어는 밑줄로 조인됩니다. 명령 프롬프트에서 다음 명령을 실행합니다.

1. 키 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

3. 환경 변수를 설정한 후 명령 프롬프트 창을 닫습니다. 값은 다시 변경할 때까지 유지됩니다.

4. 환경 변수를 읽는 실행 중인 프로그램을 다시 시작합니다. 예를 들어 Visual Studio 또는 Visual Studio Code를 편집기로 사용하는 경우 샘플 코드를 실행하기 전에 다시 시작합니다.

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
setx VARIABLE_NAME=	값을 빈 문자열로 설정하여 환경 변수를 삭제합니다.	setx DI_KEY=
setx VARIABLE_NAME=value	환경 변수의 값을 설정하거나 변경합니다.	setx DI_KEY=<yourKey>
set VARIABLE_NAME	특정 환경 변수의 값을 표시합니다.	set DI_KEY
set	모든 환경 변수를 표시합니다.	set

macOS

macOS의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다. 터미널을 열고 다음 명령을 입력합니다.

1. 키 변수를 설정합니다.

   export key=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export endpoint=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bash_profile 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bash_profile 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

2. 변경 내용을 bash_profile 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bash-profile
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	특정 환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

리눅스

Linux의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다.

1. 키 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export DI_ENDPOINT=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bashrc 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bashrc 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

2. 변경 내용을 .bashrc 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bashrc
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY=
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

프로그래밍 환경 설정

1. Visual Studio를 시작합니다.

2. 시작 페이지에서 새 프로젝트 만들기를 선택합니다.

   

3. 새 프로젝트 만들기 페이지에 가서 검색 상자에 콘솔을 입력합니다. 콘솔 애플리케이션 템플릿을 선택한 다음, 다음을 선택합니다.

   

4. 새 프로젝트 구성 페이지의 프로젝트 이름 아래에 docIntelligence_app 입력합니다. 그런 후 다음을 선택합니다.

   

5. 추가 정보 페이지에서 .NET 8.0(장기 지원)을 선택한 다음 만들기를 선택합니다.

   

NuGet을 사용하여 클라이언트 라이브러리 설치

1. docIntelligence_app 프로젝트를 마우스 오른쪽 단추로 클릭하고 NuGet 패키지 관리를 선택합니다.

   

2. 찾아보기 탭을 선택하고 Azure.AI.DocumentIntelligence를 입력 합니다.

3. 드롭다운 메뉴에서 버전을 선택하고 프로젝트에 패키지를 설치합니다.

애플리케이션 빌드

비고

.NET 6부터 console 템플릿을 사용하는 새 프로젝트는 이전 버전과 다른 새 프로그램 스타일을 생성합니다. 새 출력에서는 작성해야 하는 코드를 간소화하는 최신 C# 기능을 사용합니다.

최신 버전을 사용하는 경우 Main 메서드의 본문만 작성하면 됩니다. 최상위 문, 전역 using 지시문 또는 암시적 using 지시문을 포함할 필요가 없습니다. 자세한 내용은 최상위 문을 생성하는 C# 콘솔 앱 템플릿을 참조하세요.

1. Program.cs 파일을 엽니다.

2. 기존 코드와 Console.Writeline("Hello World!")줄을 삭제하십시오.

3. 다음 코드 샘플 중 하나를 선택하고 애플리케이션의 Program.cs 파일에 복사/붙여넣습니다.

   • prebuilt-read
   • 미리 빌드된 레이아웃
   • prebuilt-tax.us.w2 (프리빌트 세금 모듈)
   • prebuilt-invoice
   • 미리 빌드된 영수증
   • 프리빌트-ID문서

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.Polygon.Count; j++)
        {
            Console.WriteLine($"      Point {j} => X: {line.Polygon[j].X}, Y: {line.Polygon[j].Y}");
        }
    }
}

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

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

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

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

Console.WriteLine("Detected languages:");

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

GitHub의 Azure 샘플 리포지토리를 방문하여 모델 출력을read 확인합니다.

레이아웃 모델 사용

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

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

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

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

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

Console.WriteLine("Paragraphs:");

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 레이아웃 모델 출력을 확인합니다.

일반 문서 모델 사용

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 일반 문서 모델 출력을 확인합니다.

W-2 세금 모델 사용

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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


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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 W-2 세금 모델 출력을 확인합니다.

청구서 모델 사용

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 청구서 모델 출력을 확인합니다.

영수증 모델 사용

using Azure;
using Azure.AI.DocumentIntelligence;

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

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

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

AnalyzeResult receipts = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 영수증 모델 출력을 확인합니다.

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 문서 모델 출력을 확인합니다.

클라이언트 라이브러리 | REST API 참조 | 패키지(Maven) | 샘플 |지원되는 REST API 버전

필수 조건

• Azure 구독 – 무료로 만드세요.

• 최신 버전의 Visual Studio Code 또는 선호하는 IDE Visual Studio Code에서 Java를 참조하세요.

  • Visual Studio Code는 Windows 및 macOS 용 Java용 코딩 팩 을 제공합니다. 코딩 팩은 VS 코드, JDK (Java Development Kit), 및 Microsoft에서 제안한 확장 모음으로 구성되어 있습니다. 코딩 팩을 사용하여 기존 개발 환경을 수정할 수도 있습니다.
  • Code 및 Java용 코딩 팩을 사용하는 VS 경우 Java용 Gradle 확장을 설치합니다.

  Visual Studio Code를 사용하지 않는 경우 개발 환경에 다음이 설치되어 있는지 확인합니다.

  • JDK(Java Development Kit), 버전 8 이상 자세한 내용은 OpenJDK의 Microsoft 빌드를 참조하세요.
  • Gradle, 버전 6.8 이상.

• Azure AI 서비스 또는 문서 인텔리전스 리소스입니다. 단일 서비스 또는 다중 서비스. 평가판 가격 책정 계층(F0)을 통해 서비스를 사용해보고, 나중에 프로덕션용 유료 계층으로 업그레이드할 수 있습니다.

  팁 (조언)

  단일 엔드포인트 및 키를 사용하여 여러 Azure AI 서비스에 액세스하려는 경우 Azure AI Foundry 리소스를 만듭니다. 문서 인텔리전스 액세스에 대해서만 문서 인텔리전스 리소스를 만듭니다. Microsoft Entra ID 인증을 사용하려는 경우 단일 서비스 리소스가 필요합니다.

• 애플리케이션을 Azure Document Intelligence 서비스에 연결하기 위해 만든 리소스의 키 및 엔드포인트입니다.

  1. 리소스를 배포한 후 리소스로 이동을 선택합니다.
  2. 왼쪽 창에서 키 및 엔드포인트를 선택합니다.
  3. 이 문서의 뒷부분에서 사용할 키와 엔드포인트 중 하나를 복사합니다.

  

• URL의 문서 파일입니다. 이 프로젝트의 경우 각 기능에 대해 다음 표에 제공된 샘플 양식을 사용할 수 있습니다.

  특징	modelID	document-url
  읽기 모델	사전 빌드 읽기	샘플 브로셔
  레이아웃 모델	미리 빌드된 레이아웃	샘플 예약 확인
  W-2 양식 모델	prebuilt-세금.us.w2	샘플 W-2 양식
  청구서 모델	미리 구성된 청구서	샘플 청구서
  영수증 모델	미리 빌드된 영수증	샘플 영수증
  ID 문서 모델	ID 문서 사전 구축	샘플 ID 문서

환경 변수 설정

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 key 및 endpoint을 사용하여 클라이언트를 인스턴스화하세요. 이 프로젝트의 경우 환경 변수를 사용하여 자격 증명을 저장하고 액세스합니다.

중요합니다

주의해서 API 키를 사용합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요. API 키를 사용하는 경우 Azure Key Vault에 안전하게 저장합니다. 앱에서 API 키를 안전하게 사용하는 방법에 대한 자세한 내용은 Azure Key Vault를 사용하여 API 키를 참조하세요.

AI 서비스 보안에 대한 자세한 내용은 Azure AI 서비스에 대한 요청 인증을 참조하세요.

Document Intelligence 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따릅니다. <yourKey>와 <yourEndpoint>를 Azure 포털에서 리소스의 값으로 교체하십시오.

Windows

Windows의 환경 변수는 대/소문자를 구분하지 않습니다. 일반적으로 대문자로 선언되며 단어는 밑줄로 조인됩니다. 명령 프롬프트에서 다음 명령을 실행합니다.

1. 키 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

3. 환경 변수를 설정한 후 명령 프롬프트 창을 닫습니다. 값은 다시 변경할 때까지 유지됩니다.

4. 환경 변수를 읽는 실행 중인 프로그램을 다시 시작합니다. 예를 들어 Visual Studio 또는 Visual Studio Code를 편집기로 사용하는 경우 샘플 코드를 실행하기 전에 다시 시작합니다.

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
setx VARIABLE_NAME=	값을 빈 문자열로 설정하여 환경 변수를 삭제합니다.	setx DI_KEY=
setx VARIABLE_NAME=value	환경 변수의 값을 설정하거나 변경합니다.	setx DI_KEY=<yourKey>
set VARIABLE_NAME	특정 환경 변수의 값을 표시합니다.	set DI_KEY
set	모든 환경 변수를 표시합니다.	set

macOS

macOS의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다. 터미널을 열고 다음 명령을 입력합니다.

1. 키 변수를 설정합니다.

   export key=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export endpoint=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bash_profile 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bash_profile 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

2. 변경 내용을 bash_profile 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bash-profile
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	특정 환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

리눅스

Linux의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 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 명령을 실행합니다. 이 명령은 build.gradle.kts를 포함하여 런타임에 애플리케이션을 만들고 구성하는 데 사용되는 Gradle용 필수 빌드 파일을 만듭니다.

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

Java 애플리케이션 만들기

Document Intelligence 서비스와 상호 작용하려면 클래스의 인스턴스를 만듭니다 DocumentIntelligenceClient . 이렇게 하려면 Azure Portal에서 AzureKeyCredential를 사용하여 key을 만들고, DocumentIntelligenceClient 및 문서 인텔리전스 AzureKeyCredential를 사용하여 endpoint 인스턴스를 만듭니다.

1. doc-intelligence-app 디렉터리에서 다음 명령을 실행합니다.

   mkdir -p src/main/java
   

이 명령은 다음 디렉터리 구조를 만듭니다.

1. 디렉터리로 이동하여 javaDocIntelligence.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.getPolygon().toString()));

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

GitHub의 Azure 샘플 리포지토리를 방문하여 모델 출력을read 확인합니다.

레이아웃 모델 사용

import com.azure.ai.documentintelligence;

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

}

GitHub의 Azure 샘플 리포지토리를 방문하여 레이아웃 모델 출력을 확인합니다.

일반 문서 모델 사용

import com.azure.ai.documentintelligence;

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

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

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

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

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

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

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

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

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

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

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

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

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

}

}

GitHub의 Azure 샘플 리포지토리를 방문하여 일반 문서 모델 출력을 확인합니다.

W-2 세금 모델 사용

import com.azure.ai.documentintelligence;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 W-2 세금 모델 출력을 확인합니다.

청구서 모델 사용

import com.azure.ai.documentintelligence;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 청구서 모델 출력을 확인합니다.

영수증 모델 사용

import com.azure.ai.documentintelligence;

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

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 영수증 모델 출력을 확인합니다.

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 참조하세요.

• LTS의 최신 버전입니다.

• Azure AI 서비스 또는 문서 인텔리전스 리소스입니다. 단일 서비스 또는 다중 서비스. 평가판 가격 책정 계층(F0)을 통해 서비스를 사용해보고, 나중에 프로덕션용 유료 계층으로 업그레이드할 수 있습니다.

  팁 (조언)

  단일 엔드포인트 및 키를 사용하여 여러 Azure AI 서비스에 액세스하려는 경우 Azure AI Foundry 리소스를 만듭니다. 문서 인텔리전스 액세스에 대해서만 문서 인텔리전스 리소스를 만듭니다. Microsoft Entra ID 인증을 사용하려는 경우 단일 서비스 리소스가 필요합니다.

• 애플리케이션을 Azure Document Intelligence 서비스에 연결하기 위해 만든 리소스의 키 및 엔드포인트입니다.

  1. 리소스를 배포한 후 리소스로 이동을 선택합니다.
  2. 왼쪽 창에서 키 및 엔드포인트를 선택합니다.
  3. 이 문서의 뒷부분에서 사용할 키와 엔드포인트 중 하나를 복사합니다.

  

• URL의 문서 파일입니다. 이 프로젝트의 경우 각 기능에 대해 다음 표에 제공된 샘플 양식을 사용할 수 있습니다.

  특징	modelID	document-url
  읽기 모델	사전 빌드 읽기	샘플 브로셔
  레이아웃 모델	미리 빌드된 레이아웃	샘플 예약 확인
  W-2 양식 모델	프리빌트-세금.us.w2	샘플 W-2 양식
  청구서 모델	미리 구성된 청구서	샘플 청구서
  영수증 모델	미리 빌드된 영수증	샘플 영수증
  ID 문서 모델	ID 문서 사전 구축	샘플 ID 문서

환경 변수 설정

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 key 및 endpoint을 사용하여 클라이언트를 인스턴스화하세요. 이 프로젝트의 경우 환경 변수를 사용하여 자격 증명을 저장하고 액세스합니다.

중요합니다

주의해서 API 키를 사용합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요. API 키를 사용하는 경우 Azure Key Vault에 안전하게 저장합니다. 앱에서 API 키를 안전하게 사용하는 방법에 대한 자세한 내용은 Azure Key Vault를 사용하여 API 키를 참조하세요.

AI 서비스 보안에 대한 자세한 내용은 Azure AI 서비스에 대한 요청 인증을 참조하세요.

Document Intelligence 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따릅니다. <yourKey>와 <yourEndpoint>를 Azure 포털에서 리소스의 값으로 교체하십시오.

Windows

Windows의 환경 변수는 대/소문자를 구분하지 않습니다. 일반적으로 대문자로 선언되며 단어는 밑줄로 조인됩니다. 명령 프롬프트에서 다음 명령을 실행합니다.

1. 키 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

3. 환경 변수를 설정한 후 명령 프롬프트 창을 닫습니다. 값은 다시 변경할 때까지 유지됩니다.

4. 환경 변수를 읽는 실행 중인 프로그램을 다시 시작합니다. 예를 들어 Visual Studio 또는 Visual Studio Code를 편집기로 사용하는 경우 샘플 코드를 실행하기 전에 다시 시작합니다.

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
setx VARIABLE_NAME=	값을 빈 문자열로 설정하여 환경 변수를 삭제합니다.	setx DI_KEY=
setx VARIABLE_NAME=value	환경 변수의 값을 설정하거나 변경합니다.	setx DI_KEY=<yourKey>
set VARIABLE_NAME	특정 환경 변수의 값을 표시합니다.	set DI_KEY
set	모든 환경 변수를 표시합니다.	set

macOS

macOS의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다. 터미널을 열고 다음 명령을 입력합니다.

1. 키 변수를 설정합니다.

   export key=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export endpoint=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bash_profile 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bash_profile 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

2. 변경 내용을 bash_profile 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bash-profile
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	특정 환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

리눅스

Linux의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 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 키를 선택하여 괄호 안의 제안을 수락합니다.

   프롬프트를 완료한 후 명령은 package.json 디렉터리에 파일을 만듭니다.

4. ai-document-intelligence 클라이언트 라이브러리와 azure/identity npm 패키지를 설치합니다.

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

종속성이 있는 앱의 package.json 파일이 업데이트됩니다.

1. 애플리케이션 디렉터리에 index.js 파일을 만듭니다.

   팁 (조언)

   PowerShell을 사용하여 새 파일을 만들 수 있습니다. Shift 키를 누 른 채 폴더를 마우스 오른쪽 단추로 클릭하여 프로젝트 디렉터리에서 PowerShell 창을 연 다음, New-Item index.js명령을 입력합니다.

애플리케이션 빌드

문서 인텔리전스 서비스와 상호 작용하려면 DocumentIntelligenceClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 키를 사용하여 AzureKeyCredential을 생성하고 DocumentIntelligenceClient 및 Document Intelligence 엔드포인트가 포함된 AzureKeyCredential 인스턴스를 만듭니다.

index.js Visual Studio Code 또는 즐겨 찾는 IDE에서 파일을 열고 다음 코드 샘플 중 하나를 선택하고 애플리케이션에 복사/붙여넣습니다.

• 미리 빌드된 읽기 모델은 모든 문서 인텔리전스 모델의 핵심이며 선, 단어, 위치 및 언어를 검색할 수 있습니다. 레이아웃, 일반 문서, 미리 빌드된 모델 및 사용자 지정 모델은 모두 문서에서 텍스트를 추출하기 위한 기초로 모델을 사용합니다 read .
• 미리 빌드된 레이아웃 모델은 문서 및 이미지에서 텍스트 및 텍스트 위치, 테이블, 선택 표시 및 구조 정보를 추출합니다.
• 미리 빌드된 tax.us.w2 모델은 미국 국세청(IRS) 세금 양식에 보고된 정보를 추출합니다.
• 미리 빌드된 송장 모델은 미국 국세청 세금 양식에 보고된 정보를 추출합니다.
• 미리 빌드된 영수증 모델은 인쇄 및 필기 판매 영수증에서 주요 정보를 추출합니다.
• 미리 빌드된 idDocument 모델은 미국 운전면허증, 국제 여권 전기 페이지, 미국 주 신분증, 사회 보장 카드, 그리고 영주권 카드에서 주요 정보를 추출합니다.

읽기 모델 사용

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 모델 출력을read 확인합니다.

레이아웃 모델 사용

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 레이아웃 모델 출력을 확인합니다.

일반 문서 모델 사용

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

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

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

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

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

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

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

}

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

GitHub의 Azure 샘플 리포지토리를 방문하여 일반 문서 모델 출력을 확인합니다.

W-2 세금 모델 사용

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 W-2 세금 모델 출력을 확인합니다.

청구서 모델 사용

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

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

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

async function main() {

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

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

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

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

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

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

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

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

GitHub의 Azure 샘플 리포지토리를 방문하여 청구서 모델 출력을 확인합니다.

영수증 모델 사용

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

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

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

async function main() {

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

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

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

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

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

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

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

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

}

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

GitHub의 Azure 샘플 리포지토리를 방문하여 영수증 모델 출력을 확인합니다.

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 문서 모델 출력을 확인합니다.

클라이언트 라이브러리 | REST API 참조 | 패키지(PyPi) | 샘플 | 지원되는 REST API 버전

필수 조건

• Azure 구독 – 무료로 만드세요.

• Python 3.7 이상. Python 설치에 pip가 포함되어야 합니다. 명령줄에서 실행 pip --version 하여 pip가 설치되어 있는지 확인할 수 있습니다. 최신 버전의 Python을 설치하여 pip를 받으세요.

• 최신 버전의 Visual Studio Code 또는 선호하는 IDE Visual Studio Code에서 Python 시작 참조

• Azure AI 서비스 또는 문서 인텔리전스 리소스입니다. 단일 서비스 또는 다중 서비스. 평가판 가격 책정 계층(F0)을 통해 서비스를 사용해보고, 나중에 프로덕션용 유료 계층으로 업그레이드할 수 있습니다.

• 애플리케이션을 Azure Document Intelligence 서비스에 연결하기 위해 만든 리소스의 키 및 엔드포인트입니다.

  1. 리소스를 배포한 후 리소스로 이동을 선택합니다.
  2. 왼쪽 창에서 키 및 엔드포인트를 선택합니다.
  3. 이 문서의 뒷부분에서 사용할 키와 엔드포인트 중 하나를 복사합니다.

  

• URL의 문서 파일입니다. 이 프로젝트의 경우 각 기능에 대해 다음 표에 제공된 샘플 양식을 사용할 수 있습니다.

  특징	modelID	document-url
  읽기 모델	사전 빌드 읽기	샘플 브로셔
  레이아웃 모델	미리 빌드된 레이아웃	샘플 예약 확인
  W-2 양식 모델	prebuilt-tax.us.w2	샘플 W-2 양식
  청구서 모델	미리 구성된 청구서	샘플 청구서
  영수증 모델	미리 빌드된 영수증	샘플 영수증
  ID 문서 모델	ID 문서 사전 구축	샘플 ID 문서

환경 변수 설정

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 key 및 endpoint을 사용하여 클라이언트를 인스턴스화하세요. 이 프로젝트의 경우 환경 변수를 사용하여 자격 증명을 저장하고 액세스합니다.

중요합니다

주의해서 API 키를 사용합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요. API 키를 사용하는 경우 Azure Key Vault에 안전하게 저장합니다. 앱에서 API 키를 안전하게 사용하는 방법에 대한 자세한 내용은 Azure Key Vault를 사용하여 API 키를 참조하세요.

AI 서비스 보안에 대한 자세한 내용은 Azure AI 서비스에 대한 요청 인증을 참조하세요.

Document Intelligence 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따릅니다. <yourKey>와 <yourEndpoint>를 Azure 포털에서 리소스의 값으로 교체하십시오.

Windows

Windows의 환경 변수는 대/소문자를 구분하지 않습니다. 일반적으로 대문자로 선언되며 단어는 밑줄로 조인됩니다. 명령 프롬프트에서 다음 명령을 실행합니다.

1. 키 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

3. 환경 변수를 설정한 후 명령 프롬프트 창을 닫습니다. 값은 다시 변경할 때까지 유지됩니다.

4. 환경 변수를 읽는 실행 중인 프로그램을 다시 시작합니다. 예를 들어 Visual Studio 또는 Visual Studio Code를 편집기로 사용하는 경우 샘플 코드를 실행하기 전에 다시 시작합니다.

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
setx VARIABLE_NAME=	값을 빈 문자열로 설정하여 환경 변수를 삭제합니다.	setx DI_KEY=
setx VARIABLE_NAME=value	환경 변수의 값을 설정하거나 변경합니다.	setx DI_KEY=<yourKey>
set VARIABLE_NAME	특정 환경 변수의 값을 표시합니다.	set DI_KEY
set	모든 환경 변수를 표시합니다.	set

macOS

macOS의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다. 터미널을 열고 다음 명령을 입력합니다.

1. 키 변수를 설정합니다.

   export key=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export endpoint=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bash_profile 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bash_profile 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

2. 변경 내용을 bash_profile 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bash-profile
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	특정 환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

리눅스

Linux의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다.

1. 키 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export DI_ENDPOINT=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bashrc 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bashrc 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

2. 변경 내용을 .bashrc 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bashrc
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY=
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

프로그래밍 환경 설정

로컬 환경에서 콘솔 창을 열고 pip를 사용하여 Python용 Azure AI Document Intelligence 클라이언트 라이브러리를 설치합니다.

pip install azure-ai-documentintelligence==1.0.0b4

Python 애플리케이션 만들기

문서 인텔리전스 서비스와 상호 작용하려면 DocumentIntelligenceClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 키를 사용하여 AzureKeyCredential을 생성하고 DocumentIntelligenceClient 및 Document Intelligence 엔드포인트가 포함된 AzureKeyCredential 인스턴스를 만듭니다.

1. 편집기 또는 IDE에서 form_recognizer_quickstart.py 이라는 새 Python 파일을 만듭니다.

2. form_recognizer_quickstart.py 파일을 열고 다음 코드 샘플 중 하나를 선택하고 애플리케이션에 복사/붙여넣습니다.

   • 미리 빌드된 읽기 모델은 모든 문서 인텔리전스 모델의 핵심이며 선, 단어, 위치 및 언어를 검색할 수 있습니다. 레이아웃, 일반 문서, 미리 빌드된 모델 및 사용자 지정 모델은 모두 문서에서 텍스트를 추출하기 위한 기초로 모델을 사용합니다 read .
   • 미리 빌드된 레이아웃 모델은 문서 및 이미지에서 텍스트 및 텍스트 위치, 테이블, 선택 표시 및 구조 정보를 추출합니다.
   • 미리 빌드된 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
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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


if __name__ == "__main__":
    analyze_read()

GitHub에서 전체 코드를 봅니다.추가 샘플

GitHub의 Azure 샘플 리포지토리를 방문하여 모델 출력을read 확인합니다.

레이아웃 모델 사용

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


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


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

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

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

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

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

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

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

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

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

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



if __name__ == "__main__":
    analyze_layout()

GitHub에서 전체 코드를 봅니다.추가 샘플

GitHub의 Azure 샘플 리포지토리를 방문하여 레이아웃 모델 출력을 확인합니다.

W-2 세금 모델 사용

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

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

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


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

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

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

    w2s: AnalyzeResult =  poller.result()

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


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


if __name__ == "__main__":
    analyze_tax_us_w2()

GitHub에서 전체 코드를 봅니다.추가 샘플

GitHub의 Azure 샘플 리포지토리를 방문하여 W-2 세금 모델 출력을 확인합니다.

청구서 모델 사용

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

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

def analyze_invoice():

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

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

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

    result: AnalyzeResult = poller.result()

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


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

if __name__ == "__main__":
    analyze_invoice()

GitHub에서 전체 코드를 봅니다.추가 샘플

GitHub의 Azure 샘플 리포지토리를 방문하여 청구서 모델 출력을 확인합니다.

영수증 모델 사용

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

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

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

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

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



if __name__ == "__main__":
    analyze_receipts()

GitHub에서 전체 코드를 봅니다.추가 샘플

GitHub의 Azure 샘플 리포지토리를 방문하여 영수증 모델 출력을 확인합니다.

ID 문서 모델 사용

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

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

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

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

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

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


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

if __name__ == "__main__":
    analyze_identity_documents()

GitHub에서 전체 코드를 봅니다.추가 샘플

GitHub의 Azure 샘플 리포지토리를 방문하여 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)을 통해 서비스를 사용해보고, 나중에 프로덕션용 유료 계층으로 업그레이드할 수 있습니다.

• 애플리케이션을 Azure Document Intelligence 서비스에 연결하기 위해 만든 리소스의 키 및 엔드포인트입니다.

  1. 리소스를 배포한 후 리소스로 이동을 선택합니다.
  2. 왼쪽 창에서 키 및 엔드포인트를 선택합니다.
  3. 이 문서의 뒷부분에서 사용할 키와 엔드포인트 중 하나를 복사합니다.

  

환경 변수 설정

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure 포털에서 key 및 endpoint을 사용하여 클라이언트를 인스턴스화하세요. 이 프로젝트의 경우 환경 변수를 사용하여 자격 증명을 저장하고 액세스합니다.

중요합니다

주의해서 API 키를 사용합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요. API 키를 사용하는 경우 Azure Key Vault에 안전하게 저장합니다. 앱에서 API 키를 안전하게 사용하는 방법에 대한 자세한 내용은 Azure Key Vault를 사용하여 API 키를 참조하세요.

AI 서비스 보안에 대한 자세한 내용은 Azure AI 서비스에 대한 요청 인증을 참조하세요.

Document Intelligence 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따릅니다. <yourKey>와 <yourEndpoint>를 Azure 포털에서 리소스의 값으로 교체하십시오.

Windows

Windows의 환경 변수는 대/소문자를 구분하지 않습니다. 일반적으로 대문자로 선언되며 단어는 밑줄로 조인됩니다. 명령 프롬프트에서 다음 명령을 실행합니다.

1. 키 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

3. 환경 변수를 설정한 후 명령 프롬프트 창을 닫습니다. 값은 다시 변경할 때까지 유지됩니다.

4. 환경 변수를 읽는 실행 중인 프로그램을 다시 시작합니다. 예를 들어 Visual Studio 또는 Visual Studio Code를 편집기로 사용하는 경우 샘플 코드를 실행하기 전에 다시 시작합니다.

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
setx VARIABLE_NAME=	값을 빈 문자열로 설정하여 환경 변수를 삭제합니다.	setx DI_KEY=
setx VARIABLE_NAME=value	환경 변수의 값을 설정하거나 변경합니다.	setx DI_KEY=<yourKey>
set VARIABLE_NAME	특정 환경 변수의 값을 표시합니다.	set DI_KEY
set	모든 환경 변수를 표시합니다.	set

macOS

macOS의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다. 터미널을 열고 다음 명령을 입력합니다.

1. 키 변수를 설정합니다.

   export key=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export endpoint=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bash_profile 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bash_profile 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

2. 변경 내용을 bash_profile 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bash-profile
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY=<yourKey>
printenv VARIABLE_NAME echo $VARIABLE_NAME	특정 환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

리눅스

Linux의 환경 변수는 대/소문자를 구분합니다. 일반적으로 변수 이름은 대문자로 선언됩니다.

이 export 명령은 변수를 설정하고 다른 프로세스에서 사용할 수 있는 전역 환경으로 내보냅니다. 그러나 이 값은 일시적이고 터미널 세션을 닫을 때까지만 지속됩니다.

1. 키 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

2. 엔드포인트 변수를 설정합니다.

   export DI_ENDPOINT=<yourEndpoint>
   

환경 변수를 영구적으로 설정하려면 Bash ~/.bashrc 시작 스크립트에 내보내기 명령을 배치합니다.

1. 텍스트 편집기를 사용하여 ~/.bashrc 파일을 열고 다음 명령을 추가하여 영구 환경 변수를 만듭니다.

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

2. 변경 내용을 .bashrc 파일에 저장합니다.

3. 변경 내용을 적용하려면 터미널 창에서 다음 명령을 실행합니다.

   source ~/.bashrc
   

다음은 환경 변수와 함께 사용할 수 있는 몇 가지 유용한 명령입니다.

명령어	조치	예시
unset VARIABLE_NAME	환경 변수를 삭제합니다.	unset DI_KEY=
export VARIABLE_NAME=value	임시 환경 변수의 값을 설정하거나 변경합니다.	export DI_KEY={yourKey}
printenv VARIABLE_NAME echo $VARIABLE_NAME	환경 변수의 값을 표시합니다. echo 명령어로 $를 사용하여 변수를 앞에 추가합니다.	printenv DI_KEY echo $DI_KEY
printenv	모든 환경 변수를 표시합니다.	printenv

문서 분석 및 결과 가져오기

POST 요청은 미리 빌드된 또는 사용자 지정 모델로 문서를 분석하는 데 사용됩니다. GET 요청은 문서 분석 호출의 결과를 검색하는 데 사용됩니다. modelId는 POST 작업과 함께 사용되고 resultId는 GET 작업과 함께 사용됩니다.

다음 표를 참조로 사용합니다. modelId< 및 document-url을 원하는 값으로 바꿉>다.<>

모델	modelId	설명	document-url
읽기 모델	사전 빌드 읽기	샘플 브로셔	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
영수증 모델	미리 빌드된 영수증	샘플 영수증	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
ID 문서 모델	ID 문서 사전 구축	샘플 ID 문서	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

POST 요청

bash 창을 열고 다음 cURL 명령을 실행합니다. 명령에는 이전에 설정된 환경 변수 섹션에서 만든 엔드포인트 및 키 환경 변수가 포함됩니다. 변수 이름이 다른 경우 해당 변수를 대체합니다. modelId< 및 document-url 매개 변수를> 바꿔야 합니다.<>

curl -i -X POST "POST {endpoint}/documentintelligence/documentModels/{modelId}:analyze?_overload=analyzeDocument&api-version=2024-11-30" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: {DI_KEY}" --data-ascii "{'urlSource': '<document-url>'}"

추가 기능 기능을 사용하도록 설정하려면 POST 요청에서 features 쿼리 매개 변수를 사용합니다. (GA) 및 이후의 릴리스에서는 2023-07-31와 함께 사용할 수 있는 네 가지 추가 기능이 있습니다: ocr.highResolution, ocr.formula, ocr.font, 및 queryFields.premium. 각 기능에 대한 자세한 내용은 사용자 지정 모델을 참조하세요.

읽기 및 레이아웃 모델에 대한 highResolution, 수식 및 글꼴 기능과 일반 문서 모델에 대한 queryFields 기능만 호출할 수 있습니다. 다음 예제에서는 레이아웃 모델에 대한 highResolution, 수식 및 글꼴 기능을 호출하는 방법을 보여줍니다.

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

POST 응답

헤더가 포함된 202 (Success) 응답을 받습니다 Operation-location. 이 헤더의 값을 사용하여 응답 결과를 검색합니다.

분석 결과 가져오기(GET 요청)

API를 호출한 Analyze document 후 결과 API를 호출 Get analyze 하여 작업 상태 및 추출된 데이터를 가져옵니다.

cURL 명령줄 도구는 JSON 콘텐츠가 포함된 API 응답의 형식을 지정하지 않으므로 콘텐츠를 읽기 어려울 수 있습니다. JSON 응답의 형식을 지정하려면 파이프 문자 뒤에 GET 요청이 포함된 JSON 서식 지정 도구를 포함합니다.

Windows

Node.js json 도구를 cURL용 JSON 포맷터로 사용합니다. Node.js 설치되지 않은 경우 최신 버전을 다운로드하여 설치합니다.

1. bash 창을 열고 다음 명령을 사용하여 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-11-30"-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/{modelId}/analyzeResults/{resultId}?api-version=2024-11-30"-H "Ocp-Apim-Subscription-Key: <subscription key>" | json_pp
  

리눅스

json_pp 명령줄 도구는 대부분의 Linux 배포판에 미리 설치되어 있습니다. 포함되지 않은 경우 배포판의 패키지 관리자를 사용하여 설치할 수 있습니다.

• 요청을 통해 | json_ppGET JSON 출력을 보기 좋게 출력합니다.

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

GET 요청

다음 명령을 실행하기 전에 다음을 변경합니다.

• < 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를 다시 호출합니다. 호출 간에 1초 이상의 간격을 사용하는 것이 좋습니다.

GitHub의 Azure 샘플 리포지토리를 방문하여 각 문서 인텔리전스 모델에 대한 GET응답을 확인합니다.

모델	출력 URL
읽기 모델	모델 출력 읽기
레이아웃 모델	레이아웃 모델 출력
W-2 세금 모델	W-2 세금 모델 출력
청구서 모델	청구서 모델 출력
영수증 모델	영수증 모델 출력
ID 문서 모델	ID 문서 모델 출력

다음 단계

축하합니다! 문서 인텔리전스 모델을 사용하여 다양한 방식으로 다양한 문서를 분석하는 방법을 배웠습니다. 다음으로 Document Intelligence Studio 및 참조 설명서를 탐색합니다.

Document Intelligence Studio에서 문서 인텔리전스 REST API 살펴보기