문서 인텔리전스 모델 사용

이 콘텐츠의 적용 대상: v3.1(GA) | 최신 버전: v4.0(미리 보기) | 이전 버전: v3.0 v2.1

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

Azure AI 문서 인텔리전스는 기계 학습을 사용하여 문서에서 핵심 텍스트와 구조 요소를 추출하는 클라우드 기반 Azure AI 서비스입니다. 기술을 학습할 때 체험판 서비스를 이용하는 것이 좋습니다. 체험판 페이지는 한 달에 500페이지로 제한됩니다.

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

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

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

• prebuilt-contract 모델은 계약에서 주요 정보를 추출합니다.

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

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

• prebuilt-invoice 모델은 다양한 형식과 품질의 판매 청구서에서 주요 필드와 항목을 추출합니다. 필드에는 전화로 캡처한 이미지, 스캔한 문서 및 디지털 PDF가 포함됩니다.

• prebuilt-receipt 모델은 인쇄 및 필기 판매 영수증에서 주요 정보를 추출합니다.

• prebuilt-idDocument 모델은 미국 운전면허증, 국가별 여권 약력 페이지, 미국 주 ID, 사회 보장 카드 및 영주권 카드에서 주요 정보를 추출합니다.

• prebuilt-businessCard 모델은 명함 이미지에서 주요 정보와 연락처 세부 정보를 추출합니다.

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

필수 조건

• Azure 구독 – 체험 구독을 만듭니다.

• Visual Studio IDE

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

• 애플리케이션을 Azure 문서 인텔리전스 서비스에 연결하려면 만든 리소스의 키와 엔드포인트

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

  

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

  기능	modelID	document-url
  읽기 모델	prebuilt-read	샘플 브로셔
  레이아웃 모델	prebuilt-layout	샘플 예약 확인서
  W-2 양식 모델	prebuilt-tax.us.w2	샘플 W-2 양식
  청구서 모델	prebuilt-invoice	샘플 청구서
  영수증 모델	prebuilt-receipt	샘플 영수증
  ID 문서 모델	prebuilt-idDocument	샘플 ID 문서
  명함 모델	prebuilt-businessCard	샘플 명함

환경 변수 설정

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

Important

API 키를 사용하는 경우 Azure Key Vault와 같은 다른 위치에 안전하게 저장합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요.

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

문서 인텔리전스 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따르세요. <yourKey> 및 <yourEndpoint>를 Azure Portal 리소스의 값으로 바꿉니다.

Windows

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

1. 주요 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

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

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

1. 주요 변수를 설정합니다.

   export key=<yourKey>
   

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

   export endpoint=<yourEndpoint>
   

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

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

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

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

1. 주요 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

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

   export DI_ENDPOINT=<yourEndpoint>
   

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

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

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

프로그래밍 환경 설정

1. Visual Studio를 시작합니다.

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

   

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

   

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

   

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

   

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

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

   

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

   

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

애플리케이션 빌드

참고 항목

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

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

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

2. Console.Writeline("Hello World!") 줄을 포함하여 기존 코드를 삭제합니다.

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

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

4. 애플리케이션에 코드 샘플을 추가한 후에는 프로젝트 이름 옆에 있는 녹색 시작 단추를 선택하여 프로그램을 빌드하고 실행하거나 F5 키를 누릅니다.

   

읽기 모델 사용

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

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

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

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

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

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

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

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

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

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

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

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

Console.WriteLine("Detected languages:");

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

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

레이아웃 모델 사용

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

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

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

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

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

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

Console.WriteLine("Paragraphs:");

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

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

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

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

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

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

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

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

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

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

일반 문서 모델 사용

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

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

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

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

AnalyzeResult result = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

W-2 세금 모델 사용

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

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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


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

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

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

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

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

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

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

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

청구서 모델 사용

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

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

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

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

AnalyzeResult result = operation.Value;

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

    AnalyzedDocument document = result.Documents[i];

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

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

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

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

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

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

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

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

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

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

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

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

영수증 모델 사용

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

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

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

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

AnalyzeResult receipts = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

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

ID 문서 모델

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

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

// sample document document

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

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

AnalyzeResult identityDocuments = operation.Value;

AnalyzedDocument identityDocument = identityDocuments.Documents.Single();

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

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

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

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

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

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

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

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

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

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

명함 모델 사용

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

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

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

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

AnalyzeResult businessCards = operation.Value;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

필수 조건

• Azure 구독 – 체험 구독을 만듭니다.

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

  • Visual Studio Code는 Windows 및 macOS에 대한 Java용 코딩 팩을 제공합니다. 코딩 팩은 VS Code 번들, JDK(Java 개발 키트) 및 Microsoft에서 제안하는 확장 컬렉션입니다. 코딩 팩을 사용하여 기존 개발 환경을 수정할 수도 있습니다.
  • VS Code 및 Java용 코딩 팩을 사용하는 경우 Java용 Gradle 확장을 설치합니다.

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

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

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

  팁

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

• 애플리케이션을 Azure 문서 인텔리전스 서비스에 연결하려면 만든 리소스의 키와 엔드포인트

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

  

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

  기능	modelID	document-url
  읽기 모델	prebuilt-read	샘플 브로셔
  레이아웃 모델	prebuilt-layout	샘플 예약 확인서
  W-2 양식 모델	prebuilt-tax.us.w2	샘플 W-2 양식
  청구서 모델	prebuilt-invoice	샘플 청구서
  영수증 모델	prebuilt-receipt	샘플 영수증
  ID 문서 모델	prebuilt-idDocument	샘플 ID 문서
  명함 모델	prebuilt-businessCard	샘플 명함

환경 변수 설정

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

Important

API 키를 사용하는 경우 Azure Key Vault와 같은 다른 위치에 안전하게 저장합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요.

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

문서 인텔리전스 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따르세요. <yourKey> 및 <yourEndpoint>를 Azure Portal 리소스의 값으로 바꿉니다.

Windows

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

1. 주요 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

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

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

1. 주요 변수를 설정합니다.

   export key=<yourKey>
   

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

   export endpoint=<yourEndpoint>
   

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

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

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

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

1. 주요 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

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

   export DI_ENDPOINT=<yourEndpoint>
   

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

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

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

프로그래밍 환경 설정

프로그래밍 환경을 설정하려면 Gradle 프로젝트를 만들고 클라이언트 라이브러리를 설치합니다.

Gradle 프로젝트 만들기

1. 콘솔 창에서 form-recognizer-app 앱에 대한 디렉터리를 만들고 해당 디렉터리로 이동합니다.

   mkdir form-recognizer-app
   cd form-recognizer-app
   

2. 작업 디렉터리에서 gradle init 명령을 실행합니다. 이 명령은 build.gradle.kts를 포함하여 런타임에 애플리케이션을 만들고 구성하는 데 사용되는 Gradle용 필수 빌드 파일을 만듭니다.

   gradle init --type basic
   

3. DSL을 선택하라는 메시지가 표시되면 Kotlin을 선택합니다.

4. Enter 키를 선택하여 기본 프로젝트 이름 form-recognizer-app을 적용합니다.

클라이언트 라이브러리 설치

이 문서에서는 Gradle 종속성 관리자를 사용합니다. 다른 종속성 관리자에 대한 클라이언트 라이브러리 및 정보는 Maven 중앙 리포지토리에서 찾을 수 있습니다.

1. IDE에서 프로젝트의 build.gradle.kts 파일을 엽니다. 필수 플러그 인 및 설정과 함께 클라이언트 라이브러리를 implementation 문으로 포함하도록 다음 코드를 복사하여 붙여넣습니다.

   plugins {
       java
       application
   }
   application {
       mainClass.set("FormRecognizer")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation(group = "com.azure", name = "azure-ai-formrecognizer", version = "4.0.0")
   }
   

Java 애플리케이션 만들기

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

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

   mkdir -p src/main/java
   

   다음 디렉터리 구조를 만듭니다.

   

2. java 디렉터리로 이동하여 FormRecognizer.java라는 파일을 만듭니다.

   팁

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

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

   • 사전 빌드된 읽기 모델은 모든 문서 인텔리전스 모델의 핵심이며 행, 단어, 위치 및 언어를 감지할 수 있습니다. 레이아웃, 일반 문서, 미리 빌드 및 사용자 지정 모델은 모두 read 모델을 문서에서 텍스트를 추출하기 위한 기반으로 사용합니다.
   • prebuilt-layout 모델은 문서와 이미지에서 텍스트와 텍스트 위치, 표, 선택 표시, 구조 정보를 추출합니다.
   • prebuilt-tax.us.w2 모델은 IRS(미국 국세청) 세금 양식에 보고된 정보를 추출합니다.
   • prebuilt-invoice 모델은 다양한 형식의 판매 청구서에서 주요 필드와 항목을 추출합니다.
   • prebuilt-receipt 모델은 인쇄 및 필기 판매 영수증에서 주요 정보를 추출합니다.
   • prebuilt-idDocument 모델은 미국 운전면허증, 국가별 여권 약력 페이지, 미국 주 ID, 사회 보장 카드 및 영주권 카드에서 주요 정보를 추출합니다.

4. 다음 명령을 입력합니다.

   gradle build
   gradle -PmainClass=FormRecognizer run
   

읽기 모델 사용

import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, documentUrl);

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

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

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

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

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

레이아웃 모델 사용

import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, layoutDocumentUrl);

AnalyzeResult analyzeLayoutResult = analyzeLayoutResultPoller.getFinalResult();

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

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

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

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

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

}

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

}

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

일반 문서 모델 사용

import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, generalDocumentUrl);

AnalyzeResult analyzeResult = analyzeDocumentPoller.getFinalResult();

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

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

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

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

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

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

}

}

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

W-2 세금 모델 사용

import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, w2Url);

AnalyzeResult analyzeTaxResult = analyzeW2Poller.getFinalResult();

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.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, invoiceUrl);

AnalyzeResult analyzeInvoiceResult = analyzeInvoicesPoller.getFinalResult();

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.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, receiptUrl);

AnalyzeResult receiptResults = analyzeReceiptPoller.getFinalResult();

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.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .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.beginAnalyzeDocumentFromUrl(modelId, licenseUrl);

AnalyzeResult identityDocumentResults = analyzeIdentityDocumentPoller.getFinalResult();

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

명함 모델 사용

import com.azure.ai.formrecognizer.*;

import com.azure.ai.formrecognizer.documentanalysis.models.*;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClient;
import com.azure.ai.formrecognizer.documentanalysis.DocumentAnalysisClientBuilder;

import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.util.polling.SyncPoller;

import java.io.IOException;
import java.util.List;
import java.util.Arrays;
import java.time.LocalDate;
import java.util.Map;
import java.util.stream.Collectors;

public class FormRecognizer {
  //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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
      DocumentAnalysisClient client = new DocumentAnalysisClientBuilder()
        .credential(new AzureKeyCredential(key))
        .endpoint(endpoint)
        .buildClient();

//sample document
String businessCardUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg";
String modelId = "prebuilt-businessCard";

SyncPoller < OperationResult, AnalyzeResult > analyzeBusinessCardPoller = client.beginAnalyzeDocumentFromUrl(modelId, businessCardUrl);

AnalyzeResult businessCardPageResults = analyzeBusinessCardPoller.getFinalResult();

for (int i = 0; i < businessCardPageResults.getDocuments().size(); i++) {
  System.out.printf("--------Analyzing business card %d -----------%n", i);
  AnalyzedDocument analyzedBusinessCard = businessCardPageResults.getDocuments().get(i);
  Map < String, DocumentField > businessCardFields = analyzedBusinessCard.getFields();
  DocumentField contactNamesDocumentField = businessCardFields.get("ContactNames");
  if (contactNamesDocumentField != null) {
    if (DocumentFieldType.LIST == contactNamesDocumentField.getType()) {
      List < DocumentField > contactNamesList = contactNamesDocumentField.getValueAsList();
      contactNamesList.stream()
        .filter(contactName -> DocumentFieldType.MAP == contactName.getType())
        .map(contactName -> {
          System.out.printf("Contact name: %s%n", contactName.getContent());
          return contactName.getValueAsMap();
        })
        .forEach(contactNamesMap -> contactNamesMap.forEach((key, contactName) -> {
          if ("FirstName".equals(key)) {
            if (DocumentFieldType.STRING == contactName.getType()) {
              String firstName = contactName.getValueAsString();
              System.out.printf("\tFirst Name: %s, confidence: %.2f%n",
                firstName, contactName.getConfidence());
            }
          }
          if ("LastName".equals(key)) {
            if (DocumentFieldType.STRING == contactName.getType()) {
              String lastName = contactName.getValueAsString();
              System.out.printf("\tLast Name: %s, confidence: %.2f%n",
                lastName, contactName.getConfidence());
            }
          }
        }));
    }
  }

  DocumentField jobTitles = businessCardFields.get("JobTitles");
  if (jobTitles != null) {
    if (DocumentFieldType.LIST == jobTitles.getType()) {
      List < DocumentField > jobTitlesItems = jobTitles.getValueAsList();
      jobTitlesItems.forEach(jobTitlesItem -> {
        if (DocumentFieldType.STRING == jobTitlesItem.getType()) {
          String jobTitle = jobTitlesItem.getValueAsString();
          System.out.printf("Job Title: %s, confidence: %.2f%n",
            jobTitle, jobTitlesItem.getConfidence());
        }
      });
    }
  }

  DocumentField departments = businessCardFields.get("Departments");
  if (departments != null) {
    if (DocumentFieldType.LIST == departments.getType()) {
      List < DocumentField > departmentsItems = departments.getValueAsList();
      departmentsItems.forEach(departmentsItem -> {
        if (DocumentFieldType.STRING == departmentsItem.getType()) {
          String department = departmentsItem.getValueAsString();
          System.out.printf("Department: %s, confidence: %.2f%n",
            department, departmentsItem.getConfidence());
        }
      });
    }
  }

  DocumentField emails = businessCardFields.get("Emails");
  if (emails != null) {
    if (DocumentFieldType.LIST == emails.getType()) {
      List < DocumentField > emailsItems = emails.getValueAsList();
      emailsItems.forEach(emailsItem -> {
        if (DocumentFieldType.STRING == emailsItem.getType()) {
          String email = emailsItem.getValueAsString();
          System.out.printf("Email: %s, confidence: %.2f%n", email, emailsItem.getConfidence());
        }
      });
    }
  }

  DocumentField websites = businessCardFields.get("Websites");
  if (websites != null) {
    if (DocumentFieldType.LIST == websites.getType()) {
      List < DocumentField > websitesItems = websites.getValueAsList();
      websitesItems.forEach(websitesItem -> {
        if (DocumentFieldType.STRING == websitesItem.getType()) {
          String website = websitesItem.getValueAsString();
          System.out.printf("Web site: %s, confidence: %.2f%n",
            website, websitesItem.getConfidence());
        }
      });
    }
  }

  DocumentField mobilePhones = businessCardFields.get("MobilePhones");
  if (mobilePhones != null) {
    if (DocumentFieldType.LIST == mobilePhones.getType()) {
      List < DocumentField > mobilePhonesItems = mobilePhones.getValueAsList();
      mobilePhonesItems.forEach(mobilePhonesItem -> {
        if (DocumentFieldType.PHONE_NUMBER == mobilePhonesItem.getType()) {
          String mobilePhoneNumber = mobilePhonesItem.getValueAsPhoneNumber();
          System.out.printf("Mobile phone number: %s, confidence: %.2f%n",
            mobilePhoneNumber, mobilePhonesItem.getConfidence());
        }
      });
    }
  }

  DocumentField otherPhones = businessCardFields.get("OtherPhones");
  if (otherPhones != null) {
    if (DocumentFieldType.LIST == otherPhones.getType()) {
      List < DocumentField > otherPhonesItems = otherPhones.getValueAsList();
      otherPhonesItems.forEach(otherPhonesItem -> {
        if (DocumentFieldType.PHONE_NUMBER == otherPhonesItem.getType()) {
          String otherPhoneNumber = otherPhonesItem.getValueAsPhoneNumber();
          System.out.printf("Other phone number: %s, confidence: %.2f%n",
            otherPhoneNumber, otherPhonesItem.getConfidence());
        }
      });
    }
  }

  DocumentField faxes = businessCardFields.get("Faxes");
  if (faxes != null) {
    if (DocumentFieldType.LIST == faxes.getType()) {
      List < DocumentField > faxesItems = faxes.getValueAsList();
      faxesItems.forEach(faxesItem -> {
        if (DocumentFieldType.PHONE_NUMBER == faxesItem.getType()) {
          String faxPhoneNumber = faxesItem.getValueAsPhoneNumber();
          System.out.printf("Fax phone number: %s, confidence: %.2f%n",
            faxPhoneNumber, faxesItem.getConfidence());
        }
      });
    }
  }

  DocumentField addresses = businessCardFields.get("Addresses");
  if (addresses != null) {
    if (DocumentFieldType.LIST == addresses.getType()) {
      List < DocumentField > addressesItems = addresses.getValueAsList();
      addressesItems.forEach(addressesItem -> {
        if (DocumentFieldType.STRING == addressesItem.getType()) {
          String address = addressesItem.getValueAsString();
          System.out
            .printf("Address: %s, confidence: %.2f%n", address, addressesItem.getConfidence());
        }
      });
    }
  }

  DocumentField companyName = businessCardFields.get("CompanyNames");
  if (companyName != null) {
    if (DocumentFieldType.LIST == companyName.getType()) {
      List < DocumentField > companyNameItems = companyName.getValueAsList();
      companyNameItems.forEach(companyNameItem -> {
        if (DocumentFieldType.STRING == companyNameItem.getType()) {
          String companyNameValue = companyNameItem.getValueAsString();
          System.out.printf("Company name: %s, confidence: %.2f%n", companyNameValue,
            companyNameItem.getConfidence());
        }
      });
    }
  }
}
}
}

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

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

필수 조건

• Azure 구독 – 체험 구독을 만듭니다.

• 최신 버전의 Visual Studio Code 또는 선호하는 IDE 자세한 내용은 Visual Studio Code의 Node.js를 참조하세요.

• Node.js의 최신 LTS 버전입니다.

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

  팁

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

• 애플리케이션을 Azure 문서 인텔리전스 서비스에 연결하려면 만든 리소스의 키와 엔드포인트

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

  

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

  기능	modelID	document-url
  읽기 모델	prebuilt-read	샘플 브로셔
  레이아웃 모델	prebuilt-layout	샘플 예약 확인서
  W-2 양식 모델	prebuilt-tax.us.w2	샘플 W-2 양식
  청구서 모델	prebuilt-invoice	샘플 청구서
  영수증 모델	prebuilt-receipt	샘플 영수증
  ID 문서 모델	prebuilt-idDocument	샘플 ID 문서
  명함 모델	prebuilt-businessCard	샘플 명함

환경 변수 설정

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

Important

API 키를 사용하는 경우 Azure Key Vault와 같은 다른 위치에 안전하게 저장합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요.

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

문서 인텔리전스 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따르세요. <yourKey> 및 <yourEndpoint>를 Azure Portal 리소스의 값으로 바꿉니다.

Windows

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

1. 주요 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

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

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

1. 주요 변수를 설정합니다.

   export key=<yourKey>
   

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

   export endpoint=<yourEndpoint>
   

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

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

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

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

1. 주요 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

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

   export DI_ENDPOINT=<yourEndpoint>
   

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

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

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

프로그래밍 환경 설정

Node.js Express 애플리케이션을 만듭니다.

1. 콘솔 창에서 form-recognizer-app 앱에 대한 새 디렉터리를 만들고 해당 디렉터리로 이동합니다.

   mkdir form-recognizer-app
   cd form-recognizer-app
   

2. npm init 명령을 실행하여 애플리케이션을 초기화하고 프로젝트를 스캐폴드합니다.

   npm init
   

3. 터미널에 표시되는 프롬프트를 사용하여 프로젝트 특성을 지정합니다.

   • 가장 중요한 특성은 이름, 버전 번호, 진입점입니다.
   • 진입점 이름으로 index.js를 유지하는 것이 좋습니다. 설명, 테스트 명령, GitHub 리포지토리, 키워드, 작성자, 라이선스 정보는 선택적 특성입니다. 이 프로젝트에서는 건너뛸 수 있습니다.
   • Enter 키를 선택하여 괄호 안의 제안을 수락합니다.

   프롬프트를 완료하면 이 명령은 form-recognizer-app 디렉터리에 package.json 파일을 만듭니다.

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

   npm i @azure/ai-form-recognizer @azure/identity
   

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

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

   팁

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

애플리케이션 빌드

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure Portal에서 키를 사용하여 AzureKeyCredential을 만들고, AzureKeyCredential 및 문서 인텔리전스 엔드포인트로 DocumentAnalysisClient 인스턴스를 만듭니다.

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

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

읽기 모델 사용

const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    const client = new DocumentAnalysisClient(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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl(
      "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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 = new DocumentAnalysisClient(endpoint, new AzureKeyCredential(key));

    const poller = await client.beginAnalyzeDocumentFromUrl("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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 = new DocumentAnalysisClient(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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 = new DocumentAnalysisClient(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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 = new DocumentAnalysisClient(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 { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

//use your `key` and `endpoint` environment variables
const key = process.env['FR_KEY'];
const endpoint = process.env['FR_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 = new DocumentAnalysisClient(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 && natiNationalityonality.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 문서 모델 출력을 확인합니다.

명함 모델 사용

const { AzureKeyCredential, DocumentAnalysisClient } = require("@azure/ai-form-recognizer");

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

// sample document
const businessCardURL = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg"

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

    const poller = await client.beginAnalyzeDocument("prebuilt-businessCard", businessCardURL);

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

    if (result) {
        const businessCard = result.fields;
        console.log("=== Business Card Information ===");

        // There are more fields than just these few, and the model allows for multiple contact & company names as well as
        // phone numbers, though we'll only show the first extracted values here.
        const name = businessCard.ContactNames && businessCard.ContactNames.values[0];
        if (name) {
            const {
                FirstName,
                LastName
            } = name.properties;
            console.log("Name:", FirstName && FirstName.content, LastName && LastName.content);
        }

        const company = businessCard.CompanyNames && businessCard.CompanyNames.values[0];
        if (company) {
            console.log("Company:", company.content);
        }

        const address = businessCard.Addresses && businessCard.Addresses.values[0];
        if (address) {
            console.log("Address:", address.content);
        }
        const jobTitle = businessCard.JobTitles && businessCard.JobTitles.values[0];
        if (jobTitle) {
            console.log("Job title:", jobTitle.content);
        }
        const department = businessCard.Departments && businessCard.Departments.values[0];
        if (department) {
            console.log("Department:", department.content);
        }
        const email = businessCard.Emails && businessCard.Emails.values[0];
        if (email) {
            console.log("Email:", email.content);
        }
        const workPhone = businessCard.WorkPhones && businessCard.WorkPhones.values[0];
        if (workPhone) {
            console.log("Work phone:", workPhone.content);
        }
        const website = businessCard.Websites && businessCard.Websites.values[0];
        if (website) {
            console.log("Website:", website.content);
        }
    } else {
        throw new Error("Expected at least one business card in the result.");
    }
}

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

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

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

필수 조건

• Azure 구독 – 체험 구독을 만듭니다.

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

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

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

• 애플리케이션을 Azure 문서 인텔리전스 서비스에 연결하려면 만든 리소스의 키와 엔드포인트

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

  

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

  기능	modelID	document-url
  읽기 모델	prebuilt-read	샘플 브로셔
  레이아웃 모델	prebuilt-layout	샘플 예약 확인서
  W-2 양식 모델	prebuilt-tax.us.w2	샘플 W-2 양식
  청구서 모델	prebuilt-invoice	샘플 청구서
  영수증 모델	prebuilt-receipt	샘플 영수증
  ID 문서 모델	prebuilt-idDocument	샘플 ID 문서
  명함 모델	prebuilt-businessCard	샘플 명함

환경 변수 설정

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

Important

API 키를 사용하는 경우 Azure Key Vault와 같은 다른 위치에 안전하게 저장합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요.

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

문서 인텔리전스 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따르세요. <yourKey> 및 <yourEndpoint>를 Azure Portal 리소스의 값으로 바꿉니다.

Windows

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

1. 주요 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

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

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

1. 주요 변수를 설정합니다.

   export key=<yourKey>
   

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

   export endpoint=<yourEndpoint>
   

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

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

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

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

1. 주요 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

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

   export DI_ENDPOINT=<yourEndpoint>
   

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

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

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

프로그래밍 환경 설정

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

pip install azure-ai-formrecognizer==3.2.0

Python 애플리케이션 만들기

문서 인텔리전스 서비스와 상호 작용하려면 DocumentAnalysisClient 클래스의 인스턴스를 만들어야 합니다. 이렇게 하려면 Azure Portal에서 키를 사용하여 AzureKeyCredential을 만들고, AzureKeyCredential 및 문서 인텔리전스 엔드포인트로 DocumentAnalysisClient 인스턴스를 만듭니다.

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

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

   • 사전 빌드된 읽기 모델은 모든 문서 인텔리전스 모델의 핵심이며 행, 단어, 위치 및 언어를 감지할 수 있습니다. 레이아웃, 일반 문서, 미리 빌드 및 사용자 지정 모델은 모두 read 모델을 문서에서 텍스트를 추출하기 위한 기반으로 사용합니다.
   • prebuilt-layout 모델은 문서와 이미지에서 텍스트와 텍스트 위치, 표, 선택 표시, 구조 정보를 추출합니다.
   • prebuilt-tax.us.w2 모델은 IRS(미국 국세청) 세금 양식에 보고된 정보를 추출합니다.
   • prebuilt-invoice 모델은 다양한 형식의 판매 청구서에서 주요 필드와 항목을 추출합니다.
   • prebuilt-receipt 모델은 인쇄 및 필기 판매 영수증에서 주요 정보를 추출합니다.
   • prebuilt-idDocument 모델은 미국 운전면허증, 국가별 여권 약력 페이지, 미국 주 ID, 사회 보장 카드 및 영주권 카드에서 주요 정보를 추출합니다.

3. 명령 프롬프트에서 Python 코드를 실행합니다.

   python form_recognizer_quickstart.py
   

읽기 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

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


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

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-read", formUrl
    )
    result = poller.result()

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

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

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

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

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

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


if __name__ == "__main__":
    analyze_read()

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

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

레이아웃 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

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


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

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-layout", formUrl
    )
    result = poller.result()

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

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

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

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

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

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

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


if __name__ == "__main__":
    analyze_layout()

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

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

일반 문서 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

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

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


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

    # create your `DocumentAnalysisClient` instance and `AzureKeyCredential` variable
    document_analysis_client = DocumentAnalysisClient(endpoint=endpoint, credential=AzureKeyCredential(key))

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-document", docUrl)
    result = poller.result()

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

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

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

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

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

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

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


if __name__ == "__main__":
    analyze_general_documents()

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

W-2 세금 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# use your `key` and `endpoint` environment variables
key = os.environ.get('FR_KEY')
endpoint = os.environ.get('FR_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"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
        "prebuilt-tax.us.w2", formUrl
    )
    w2s = poller.result()

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

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


if __name__ == "__main__":
    analyze_tax_us_w2()

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

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

청구서 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

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

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


def analyze_invoice():

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

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-invoice", invoiceUrl)
    invoices = poller.result()

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

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

if __name__ == "__main__":
    analyze_invoice()

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

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

영수증 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# use your `key` and `endpoint` environment variables
key = os.environ.get('FR_KEY')
endpoint = os.environ.get('FR_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"

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


if __name__ == "__main__":
    analyze_receipts()

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

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

ID 문서 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

# use your `key` and `endpoint` environment variables
key = os.environ.get('FR_KEY')
endpoint = os.environ.get('FR_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"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-idDocument", identityUrl
        )
    id_documents = poller.result()

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

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

if __name__ == "__main__":
    analyze_identity_documents()

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

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

명함 모델 사용

import os
from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

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

def analyze_business_card():
      # sample document
    businessCardUrl = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/de5e0d8982ab754823c54de47a47e8e499351523/curl/form-recognizer/rest-api/business_card.jpg"

    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, credential=AzureKeyCredential(key)
    )

    poller = document_analysis_client.begin_analyze_document_from_url(
            "prebuilt-businessCard", businessCardUrl, locale="en-US"
        )
    business_cards = poller.result()

    for idx, business_card in enumerate(business_cards.documents):
        print("--------Analyzing business card #{}--------".format(idx + 1))
        contact_names = business_card.fields.get("ContactNames")
        if contact_names:
            for contact_name in contact_names.value:
                print(
                    "Contact First Name: {} has confidence: {}".format(
                        contact_name.value["FirstName"].value,
                        contact_name.value[
                            "FirstName"
                        ].confidence,
                    )
                )
                print(
                    "Contact Last Name: {} has confidence: {}".format(
                        contact_name.value["LastName"].value,
                        contact_name.value[
                            "LastName"
                        ].confidence,
                    )
                )
        company_names = business_card.fields.get("CompanyNames")
        if company_names:
            for company_name in company_names.value:
                print(
                    "Company Name: {} has confidence: {}".format(
                        company_name.value, company_name.confidence
                    )
                )
        departments = business_card.fields.get("Departments")
        if departments:
            for department in departments.value:
                print(
                    "Department: {} has confidence: {}".format(
                        department.value, department.confidence
                    )
                )
        job_titles = business_card.fields.get("JobTitles")
        if job_titles:
            for job_title in job_titles.value:
                print(
                    "Job Title: {} has confidence: {}".format(
                        job_title.value, job_title.confidence
                    )
                )
        emails = business_card.fields.get("Emails")
        if emails:
            for email in emails.value:
                print(
                    "Email: {} has confidence: {}".format(email.value, email.confidence)
                )
        websites = business_card.fields.get("Websites")
        if websites:
            for website in websites.value:
                print(
                    "Website: {} has confidence: {}".format(
                        website.value, website.confidence
                    )
                )
        addresses = business_card.fields.get("Addresses")
        if addresses:
            for address in addresses.value:
                print(
                    "Address: {} has confidence: {}".format(
                        address.value, address.confidence
                    )
                )
        mobile_phones = business_card.fields.get("MobilePhones")
        if mobile_phones:
            for phone in mobile_phones.value:
                print(
                    "Mobile phone number: {} has confidence: {}".format(
                        phone.content, phone.confidence
                    )
                )
        faxes = business_card.fields.get("Faxes")
        if faxes:
            for fax in faxes.value:
                print(
                    "Fax number: {} has confidence: {}".format(
                        fax.content, fax.confidence
                    )
                )
        work_phones = business_card.fields.get("WorkPhones")
        if work_phones:
            for work_phone in work_phones.value:
                print(
                    "Work phone number: {} has confidence: {}".format(
                        work_phone.content, work_phone.confidence
                    )
                )
        other_phones = business_card.fields.get("OtherPhones")
        if other_phones:
            for other_phone in other_phones.value:
                print(
                    "Other phone number: {} has confidence: {}".format(
                        other_phone.value, other_phone.confidence
                    )
                )

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

if __name__ == "__main__":
    analyze_business_card()

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

| 문서 인텔리전스 REST API | 지원되는 Azure SDKS |

참고 항목

이 프로젝트는 cURL 명령줄 도구를 사용하여 REST API 호출을 실행합니다.

필수 조건

• Azure 구독 – 체험 구독을 만듭니다.

• cURL 명령줄 도구가 설치되었습니다. Windows 10 및 Windows 11은 cURL 복사본과 함께 제공됩니다. 명령 프롬프트에서 다음 cURL 명령을 입력합니다. 도움말 옵션이 표시되면 Windows 환경에 cURL이 설치된 것입니다.

  curl -help
  

  cURL이 설치되지 않은 경우 여기에서 가져올 수 있습니다.

  • Windows
  • Mac 또는 Linux

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

• 애플리케이션을 Azure 문서 인텔리전스 서비스에 연결하려면 만든 리소스의 키와 엔드포인트

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

  

환경 변수 설정

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

Important

API 키를 사용하는 경우 Azure Key Vault와 같은 다른 위치에 안전하게 저장합니다. API 키를 코드에 직접 포함하지 말고, 공개적으로 게시하지 마세요.

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

문서 인텔리전스 리소스 키에 대한 환경 변수를 설정하려면 콘솔 창을 열고 운영 체제 및 개발 환경에 대한 지침을 따르세요. <yourKey> 및 <yourEndpoint>를 Azure Portal 리소스의 값으로 바꿉니다.

Windows

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

1. 주요 변수를 설정합니다.

   setx DI_KEY <yourKey>
   

2. 엔드포인트 변수 설정

   setx DI_ENDPOINT <yourEndpoint>
   

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

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

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

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

macOS

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

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

1. 주요 변수를 설정합니다.

   export key=<yourKey>
   

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

   export endpoint=<yourEndpoint>
   

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

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

   export DI_KEY=<yourKey> DI_ENDPOINT=<yourEndpoint>
   

   예: export DI_KEY="<yourKey>"

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

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

   source ~/.bash-profile
   

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

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

Linux

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

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

1. 주요 변수를 설정합니다.

   export DI_KEY=<yourKey>
   

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

   export DI_ENDPOINT=<yourEndpoint>
   

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

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

   export <VARIABLE>=<value>
   

   예: export DI_KEY=<yourKey>

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

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

   source ~/.bashrc
   

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

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

문서 분석 및 결과 가져오기

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

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

모델	modelId	description	document-url
읽기 모델	prebuilt-read	샘플 브로셔	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/read.png
레이아웃 모델	prebuilt-layout	샘플 예약 확인서	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/layout.png
W-2 양식 모델	prebuilt-tax.us.w2	샘플 W-2 양식	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/w2.png
청구서 모델	prebuilt-invoice	샘플 청구서	https://github.com/Azure-Samples/cognitive-services-REST-api-samples/raw/master/curl/form-recognizer/rest-api/invoice.pdf
영수증 모델	prebuilt-receipt	샘플 영수증	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/receipt.png
ID 문서 모델	prebuilt-idDocument	샘플 ID 문서	https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/rest-api/identity_documents.png

POST 요청

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

curl -i -X POST "%FR_ENDPOINT%formrecognizer/documentModels/<modelId>:analyze?api-version=2023-07-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: %FR_KEY%" --data-ascii "{'urlSource': '<document-url>'}"

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

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

curl -i -X POST "%FR_ENDPOINT%formrecognizer/documentModels/prebuilt-layout:analyze?features=ocr.highResolution,ocr.formula,ocr.font?api-version=2023-07-31" -H "Content-Type: application/json" -H "Ocp-Apim-Subscription-Key: %FR_KEY%" --data-ascii "{'urlSource': '<document-url>'}"

POST 응답

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

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

Analyze document API를 호출한 후 [Get analyze result}(/rest/api/aiservices/document-models/get-analyze-result?view=rest-aiservices-2023-07-31&preserve-view=true&tabs=HTTP) API를 호출하여 작업 상태와 추출된 데이터를 가져옵니다.

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

Windows

cURL용 JSON 포맷터로 NodeJS json 도구를 사용합니다. Node.js가 설치되어 있지 않으면 최신 버전을 다운로드하여 설치합니다.

1. 콘솔 창을 열고 다음 명령을 사용하여 json 도구를 설치합니다.

   npm install -g jsontool
   

2. GET 요청에 파이프 문자 | json을 포함하여 JSON 출력을 예쁘게 인쇄합니다.

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

macOS

json_pp 명령 도구는 macOS와 함께 제공되며 cURL용 JSON 포맷터로 사용할 수 있습니다.

• GET 요청에 | json_pp를 포함하여 JSON 출력을 예쁘게 인쇄합니다.

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

Linux

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

• GET 요청에 | json_pp를 포함하여 JSON 출력을 예쁘게 인쇄합니다.

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

GET 요청

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

• <POST 응답>을 POST 응답의 Operation-location 헤더로 바꿉니다.
• <FR_KEY가 코드의 이름과 다른 경우 환경 변수에 대한 변수로 바꿉니다.
• *<json-tool>을 JSON 서식 지정 도구로 바꿉니다.

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

응답 검사

JSON 출력으로 200 (Success) 응답을 받습니다. 작업의 상태를 나타내는 첫 번째 필드, status입니다. 작업이 완료되지 않은 경우 값 status는 running 또는 notStarted입니다. 수동으로 또는 스크립트를 통해 API를 다시 호출합니다. 호출 간에 1초 이상의 간격을 사용하는 것이 좋습니다.

각 문서 인텔리전스 모델에 대한 GET 응답을 보려면 GitHub의 Azure 샘플 리포지토리를 방문하세요.

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

다음 단계

축하합니다! 문서 인텔리전스 모델을 사용하여 다양한 문서를 다양한 방식으로 분석하는 방법을 배웠습니다. 다음으로 문서 인텔리전스 Studio 및 참조 문서를 살펴보세요.

문서 인텔리전스 스튜디오 사용해 보기 문서 인텔리전스 REST API 살펴보기