Enterprise Document OCR

Anda dapat menggunakan Enterprise Document OCR sebagai bagian dari Document AI untuk mendeteksi dan mengekstrak teks serta informasi tata letak dari berbagai dokumen. Dengan fitur yang dapat dikonfigurasi, Anda dapat menyesuaikan sistem untuk memenuhi persyaratan pemrosesan dokumen tertentu.

Ringkasan

Anda dapat menggunakan Enterprise Document OCR untuk tugas seperti entri data berdasarkan algoritma atau machine learning serta meningkatkan dan memverifikasi akurasi data. Anda juga dapat menggunakan Enterprise Document OCR untuk menangani tugas seperti berikut:

• Mendigitalkan teks: Mengekstrak data teks dan tata letak dari dokumen untuk penelusuran, pipeline pemrosesan dokumen berbasis aturan, atau pembuatan model kustom.
• Menggunakan aplikasi model bahasa besar: Gunakan pemahaman kontekstual LLM dan kemampuan ekstraksi teks dan tata letak OCR untuk mengotomatiskan pertanyaan dan jawaban. Dapatkan insight dari data, dan sederhanakan alur kerja.
• Pengarsipan: Mendigitalkan dokumen kertas menjadi teks yang dapat dibaca mesin untuk meningkatkan aksesibilitas dokumen.

Memilih OCR terbaik untuk kasus penggunaan Anda

Deteksi dan ekstraksi

Enterprise Document OCR dapat mendeteksi blok, paragraf, baris, kata, dan simbol dari PDF dan gambar, serta meluruskan dokumen untuk akurasi yang lebih baik.

Atribut deteksi dan ekstraksi tata letak yang didukung:

Fitur Enterprise Document OCR yang dapat dikonfigurasi meliputi:

• Mengekstrak teks native atau yang disematkan dari PDF digital: Fitur ini mengekstrak teks dan simbol persis seperti yang muncul dalam dokumen sumber, bahkan untuk teks yang diputar, ukuran atau gaya font yang ekstrem, dan teks yang sebagian tersembunyi.

• Koreksi rotasi: Gunakan Enterprise Document OCR untuk memproses awal gambar dokumen guna mengoreksi masalah rotasi yang dapat memengaruhi kualitas ekstraksi atau pemrosesan.

• Skor kualitas gambar: Menerima metrik kualitas yang dapat membantu perutean dokumen. Skor kualitas gambar memberikan metrik kualitas tingkat halaman dalam delapan dimensi, termasuk keburaman, keberadaan font yang lebih kecil dari biasanya, dan silau.

• Tentukan rentang halaman: Menentukan rentang halaman dalam dokumen input untuk OCR. Hal ini menghemat waktu pemrosesan dan pembelanjaan di halaman yang tidak diperlukan.

• Deteksi bahasa: Mendeteksi bahasa yang digunakan dalam teks yang diekstrak.

• Petunjuk bahasa dan tulisan tangan: Tingkatkan akurasi dengan memberikan petunjuk bahasa atau tulisan tangan kepada model OCR berdasarkan karakteristik yang diketahui dari set data Anda.

Untuk mempelajari cara mengaktifkan konfigurasi OCR, lihat Mengaktifkan konfigurasi OCR.

Add-on OCR

Enterprise Document OCR menawarkan kemampuan analisis opsional yang dapat diaktifkan pada setiap permintaan pemrosesan sesuai kebutuhan.

Kemampuan add-on berikut tersedia untuk versi Stabil pretrained-ocr-v2.0-2023-06-02 dan pretrained-ocr-v2.1-2024-08-07, serta versi Release Candidate pretrained-ocr-v2.1.1-2025-01-31.

• OCR Matematika: Mengidentifikasi dan mengekstrak formula dari dokumen dalam format LaTeX.
• Ekstraksi kotak centang: Mendeteksi kotak centang dan mengekstrak statusnya (dicentang/tidak dicentang) dalam respons Enterprise Document OCR.
• Deteksi gaya font: Mengidentifikasi properti font tingkat kata, termasuk jenis font, gaya font, tulisan tangan, ketebalan, dan warna.

Untuk mempelajari cara mengaktifkan add-on yang tercantum, lihat Mengaktifkan add-on OCR.

Format file yang didukung

OCR Dokumen Perusahaan mendukung format file PDF, GIF, TIFF, JPEG, PNG, BMP, dan WebP. Untuk mengetahui informasi selengkapnya, lihat File yang didukung.

Enterprise Document OCR juga mendukung file DocX hingga 15 halaman dalam sinkron dan 30 halaman dalam asinkron. Dukungan DocX dalam pratinjau pribadi. Untuk meminta akses, kirimkan Formulir Permintaan Dukungan DocX .

Pembuatan versi lanjutan

Pembuatan versi lanjutan berada dalam Pratinjau. Upgrade pada model OCR AI/ML yang mendasarinya dapat menyebabkan perubahan pada perilaku OCR. Jika konsistensi ketat diperlukan, gunakan versi model yang di-freeze untuk menyematkan perilaku ke model OCR lama hingga 18 bulan. Tindakan ini memastikan hasil fungsi OCR ke gambar yang sama. Lihat tabel tentang versi pemroses.

Versi pemroses

Versi prosesor berikut kompatibel dengan fitur ini. Untuk mengetahui informasi selengkapnya, lihat Mengelola versi pemroses.

Menggunakan Enterprise Document OCR untuk memproses dokumen

Panduan memulai ini memperkenalkan Enterprise Document OCR. Bagian ini menunjukkan cara mengoptimalkan hasil OCR dokumen untuk alur kerja Anda dengan mengaktifkan atau menonaktifkan salah satu konfigurasi OCR yang tersedia.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Document AI API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Document AI API.

Enable the API

Membuat pemroses Enterprise Document OCR

Pertama, buat pemroses Enterprise Document OCR. Untuk mengetahui informasi selengkapnya, lihat membuat dan mengelola pemroses.

Konfigurasi OCR

Semua konfigurasi OCR dapat diaktifkan dengan menyetel kolom masing-masing di ProcessOptions.ocrConfig dalam ProcessDocumentRequest atau BatchProcessDocumentsRequest.

Untuk mengetahui informasi selengkapnya, lihat Mengirim permintaan pemrosesan.

Analisis kualitas gambar

Analisis kualitas dokumen cerdas menggunakan machine learning untuk melakukan penilaian kualitas dokumen berdasarkan keterbacaan kontennya. Penilaian kualitas ini ditampilkan sebagai skor kualitas [0, 1], dengan 1 berarti kualitas sempurna. Jika skor kualitas yang terdeteksi lebih rendah dari 0.5, daftar alasan kualitas negatif (diurutkan berdasarkan kemungkinan) juga akan ditampilkan. Kemungkinan lebih besar dari 0.5 dianggap sebagai deteksi positif.

Jika dokumen dianggap rusak, API akan menampilkan delapan jenis kerusakan dokumen berikut:

• quality/defect_blurry
• quality/defect_noisy
• quality/defect_dark
• quality/defect_faint
• quality/defect_text_too_small
• quality/defect_document_cutoff
• quality/defect_text_cutoff
• quality/defect_glare

Ada beberapa batasan pada analisis kualitas dokumen saat ini:

• Deteksi positif palsu dapat terjadi pada dokumen digital yang tidak memiliki kecacatan. Fitur ini paling baik digunakan pada dokumen yang dipindai atau difoto.

• Cacat silau bersifat lokal. Keberadaannya mungkin tidak menghalangi keterbacaan dokumen secara keseluruhan.

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.enableImageQualityScores ke true dalam permintaan pemrosesan. Fitur tambahan ini menambahkan latensi yang sebanding dengan pemrosesan OCR ke panggilan proses.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableImageQualityScores": true
      }
    }
  }

Output

Hasil deteksi kerusakan akan muncul di Document.pages[].imageQualityScores[].

  {
    "pages": [
      {
        "imageQualityScores": {
          "qualityScore": 0.7811847,
          "detectedDefects": [
            {
              "type": "quality/defect_document_cutoff",
              "confidence": 1.0
            },
            {
              "type": "quality/defect_glare",
              "confidence": 0.97849524
            },
            {
              "type": "quality/defect_text_cutoff",
              "confidence": 0.5
            }
          ]
        }
      }
    ]
  }

Lihat Contoh output pemroses untuk contoh output lengkap.

Petunjuk bahasa

Prosesor OCR mendukung petunjuk bahasa yang Anda tentukan untuk meningkatkan performa mesin OCR. Dengan menerapkan petunjuk bahasa, OCR dapat mengoptimalkan bahasa yang dipilih, bukan bahasa yang disimpulkan.

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.hints[].languageHints[] dengan daftar kode bahasa BCP-47.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "hints": {
          "languageHints": ["en", "es"]
        }
      }
    }
  }

Lihat Contoh output pemroses untuk contoh output lengkap.

Deteksi simbol

Mengisi data di tingkat simbol (atau huruf individual) dalam respons dokumen.

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.enableSymbol ke true dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableSymbol": true
      }
    }
  }

Output

Jika fitur ini diaktifkan, kolom Document.pages[].symbols[] akan diisi.

Lihat Contoh output pemroses untuk contoh output lengkap.

Penguraian PDF bawaan

Mengekstrak teks tersemat dari file PDF digital. Jika diaktifkan, model PDF digital bawaan akan otomatis digunakan jika ada teks digital. Jika ada teks non-digital, model OCR optik akan digunakan secara otomatis. Pengguna menerima kedua hasil teks yang digabungkan.

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.enableNativePdfParsing ke true dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "enableNativePdfParsing": true
      }
    }
  }

Deteksi karakter dalam kotak

Secara default, Enterprise Document OCR mengaktifkan detektor untuk meningkatkan kualitas ekstraksi teks karakter yang berada dalam kotak. Berikut ini contohnya:



Jika Anda mengalami masalah kualitas OCR dengan karakter di dalam kotak, Anda dapat menonaktifkannya.

Input

Nonaktifkan dengan menyetel ProcessOptions.ocrConfig.disableCharacterBoxesDetection ke true dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
        "disableCharacterBoxesDetection": true
      }
    }
  }

Tata letak lama

Jika memerlukan algoritma deteksi tata letak heuristik, Anda dapat mengaktifkan tata letak lama, yang berfungsi sebagai alternatif untuk algoritma deteksi tata letak berbasis ML saat ini. Ini bukan konfigurasi yang direkomendasikan. Pelanggan dapat memilih algoritma tata letak yang paling sesuai berdasarkan alur kerja dokumen mereka.

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.advancedOcrOptions ke ["legacy_layout"] dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "advancedOcrOptions": ["legacy_layout"]
      }
    }
  }

Menentukan rentang halaman

Secara default, OCR mengekstrak informasi teks dan tata letak dari semua halaman dalam dokumen. Anda dapat memilih nomor halaman atau rentang halaman tertentu dan hanya mengekstrak teks dari halaman tersebut.

Ada tiga cara untuk mengonfigurasi ini di ProcessOptions:

• Untuk hanya memproses halaman kedua dan kelima:

  {
    "individualPageSelector": {"pages": [2, 5]}
  }

• Untuk hanya memproses tiga halaman pertama:

  {
    "fromStart": 3
  }

• Untuk memproses hanya empat halaman terakhir:

  {
    "fromEnd": 4
  }

Dalam respons, setiap Document.pages[].pageNumber sesuai dengan halaman yang sama yang ditentukan dalam permintaan.

Penggunaan add-on OCR

Kemampuan analisis opsional Enterprise Document OCR ini dapat diaktifkan pada setiap permintaan pemrosesan sesuai kebutuhan.

OCR Matematika

OCR Matematika mendeteksi, mengenali, dan mengekstrak formula, seperti persamaan matematika yang ditampilkan sebagai LaTeX beserta koordinat kotak pembatas.

Berikut adalah contoh representasi LaTeX:

• Gambar terdeteksi

  

• Konversi ke LaTeX

  

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.premiumFeatures.enableMathOcr ke true dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableMathOcr": true
          }
      }
    }
  }

Output

Output OCR Matematika muncul di Document.pages[].visualElements[] dengan "type": "math_formula".



"visualElements": [
  {
    "layout": {
      "textAnchor": {
        "textSegments": [
          {
            "endIndex": "46"
          }
        ]
      },
      "confidence": 1,
      "boundingPoly": {
        "normalizedVertices": [
          {
            "x": 0.14662756,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.27891156
          },
          {
            "x": 0.9032258,
            "y": 0.8027211
          },
          {
            "x": 0.14662756,
            "y": 0.8027211
          }
        ]
      },
      "orientation": "PAGE_UP"
    },
    "type": "math_formula"
  }
]

Anda dapat memeriksa output JSON Document lengkap di link ini .

Ekstraksi tanda pilihan

Jika diaktifkan, model akan mencoba mengekstrak semua kotak centang dan tombol pilihan dalam dokumen, beserta koordinat kotak pembatas.

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.premiumFeatures.enableSelectionMarkDetection ke true dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "enableSelectionMarkDetection": true
          }
      }
    }
  }

Output

Output kotak centang muncul di Document.pages[].visualElements[] dengan "type": "unfilled_checkbox" atau "type": "filled_checkbox".



"visualElements": [
  {
    "layout": {
      "confidence": 0.89363575,
      "boundingPoly": {
        "vertices": [
          {
            "x": 11,
            "y": 24
          },
          {
            "x": 37,
            "y": 24
          },
          {
            "x": 37,
            "y": 56
          },
          {
            "x": 11,
            "y": 56
          }
        ],
        "normalizedVertices": [
          {
            "x": 0.017488075,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.38709676
          },
          {
            "x": 0.05882353,
            "y": 0.9032258
          },
          {
            "x": 0.017488075,
            "y": 0.9032258
          }
        ]
      }
    },
    "type": "unfilled_checkbox"
  },
  {
    "layout": {
      "confidence": 0.9148201,
      "boundingPoly": ...
    },
    "type": "filled_checkbox"
  }
],

Anda dapat memeriksa output JSON Document lengkap di link ini .

Deteksi gaya font

Dengan mengaktifkan deteksi gaya font, Enterprise Document OCR mengekstrak atribut font, yang dapat digunakan untuk pasca-pemrosesan yang lebih baik.

Di tingkat token (kata), atribut berikut terdeteksi:

• Deteksi tulisan tangan
• Gaya font
• Ukuran font
• Jenis font
• Warna font
• Ketebalan font
• Penentuan spasi huruf
• Tebal
• Miring
• Digarisbawahi
• Warna teks (RGBa)

• Warna latar belakang (RGBa)

Input

Aktifkan dengan menyetel ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo ke true dalam permintaan pemrosesan.

  {
    "rawDocument": {
      "mimeType": "MIME_TYPE",
      "content": "IMAGE_CONTENT"
    },
    "processOptions": {
      "ocrConfig": {
          "premiumFeatures": {
            "computeStyleInfo": true
          }
      }
    }
  }

Output

Output font-style muncul di Document.pages[].tokens[].styleInfo dengan jenis StyleInfo.



"tokens": [
  {
    "styleInfo": {
      "fontSize": 3,
      "pixelFontSize": 13,
      "fontType": "SANS_SERIF",
      "bold": true,
      "fontWeight": 564,
      "textColor": {
        "red": 0.16862746,
        "green": 0.16862746,
        "blue": 0.16862746
      },
      "backgroundColor": {
        "red": 0.98039216,
        "green": 0.9882353,
        "blue": 0.99215686
      }
    }
  },
  ...
]

Anda dapat memeriksa output JSON Document lengkap di link ini .

Mengonversi objek dokumen ke format Vision AI API

Toolbox Document AI menyertakan alat yang mengonversi format Document Document AI API ke format AnnotateFileResponse Vision AI, sehingga pengguna dapat membandingkan respons antara pemroses OCR dokumen dan Vision AI API. Berikut beberapa contoh kode.

Perbedaan yang diketahui antara respons Vision AI API dan respons serta pengonversi Document AI API:

• Respons Vision AI API hanya mengisi vertices untuk permintaan gambar, dan hanya mengisi normalized_vertices untuk permintaan PDF. Respons Document AI dan konverter mengisi vertices dan normalized_vertices.
• Respons Vision AI API mengisi detected_break dalam simbol terakhir kata. Respons Document AI API dan konverter mengisi detected_break dalam kata dan simbol terakhir kata.
• Respons Vision AI API selalu mengisi kolom simbol. Secara default, respons Document AI tidak mengisi kolom simbol. Untuk memastikan respons Document AI dan konverter mengisi kolom simbol, tetapkan fitur enable_symbol sebagai mendetail.

Contoh kode

Contoh kode berikut menunjukkan cara mengirim permintaan pemrosesan yang mengaktifkan konfigurasi dan add-on OCR, lalu membaca dan mencetak kolom ke terminal:

REST

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

• LOCATION: lokasi pemroses Anda, misalnya:
  • us - Amerika Serikat
  • eu - Uni Eropa
• PROJECT_ID: ID project Google Cloud Anda.
• PROCESSOR_ID: ID pemroses kustom Anda.
• PROCESSOR_VERSION: ID versi prosesor. Lihat Memilih versi prosesor untuk mengetahui informasi selengkapnya. Contoh:
  • pretrained-TYPE-vX.X-YYYY-MM-DD
  • stable
  • rc
• skipHumanReview: Nilai boolean untuk menonaktifkan peninjauan manual (Hanya didukung oleh pemroses yang memerlukan interaksi manusia.)
  • true - melewati peninjauan manual
  • false - mengaktifkan peninjauan manual (default)
• MIME_TYPE^†: Salah satu opsi jenis MIME yang valid.
• IMAGE_CONTENT^†: Salah satu Konten dokumen inline yang valid, direpresentasikan sebagai aliran byte. Untuk representasi JSON, encoding base64 (string ASCII) dari data gambar biner Anda. String ini akan terlihat seperti string berikut:
  • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
  Kunjungi topik Encoding Base64 untuk mengetahui informasi selengkapnya.
• FIELD_MASK: Menentukan kolom mana yang akan disertakan dalam output Document. Ini adalah daftar nama kolom yang sepenuhnya memenuhi syarat dalam format FieldMask yang dipisahkan koma.
  • Contoh: text,entities,pages.pageNumber
• Konfigurasi OCR
  • ENABLE_NATIVE_PDF_PARSING: (Boolean) Mengekstrak teks yang disematkan dari PDF, jika tersedia.
  • ENABLE_IMAGE_QUALITY_SCORES: (Boolean) Mengaktifkan skor kualitas dokumen cerdas.
  • ENABLE_SYMBOL: (Boolean) Menyertakan informasi OCR simbol (huruf).
  • DISABLE_CHARACTER_BOXES_DETECTION: (Boolean) Nonaktifkan detektor kotak karakter di mesin OCR.
  • LANGUAGE_HINTS: Daftar kode bahasa BCP-47 yang akan digunakan untuk OCR.
  • ADVANCED_OCR_OPTIONS: Daftar opsi OCR lanjutan untuk menyetel lebih lanjut perilaku OCR. Nilai valid saat ini adalah:
    • legacy_layout: algoritma deteksi tata letak heuristik, yang berfungsi sebagai alternatif untuk algoritma deteksi tata letak berbasis ML saat ini.
• Add-on OCR Premium
  • ENABLE_SELECTION_MARK_DETECTION: (Boolean) Aktifkan detektor tanda pilihan di mesin OCR.
  • COMPUTE_STYLE_INFO (Boolean) Aktifkan model identifikasi font dan tampilkan informasi gaya font.
  • ENABLE_MATH_OCR: (Boolean) Aktifkan model yang dapat mengekstrak formula matematika LaTeX.
• INDIVIDUAL_PAGES: Daftar halaman individual yang akan diproses.
  • Atau, berikan kolom fromStart atau fromEnd untuk memproses jumlah halaman tertentu dari awal atau akhir dokumen.

† Konten ini juga dapat ditentukan menggunakan konten berenkode base64 dalam objek inlineDocument.

Metode HTTP dan URL:

POST https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process

Isi JSON permintaan:

{
  "skipHumanReview": skipHumanReview,
  "rawDocument": {
    "mimeType": "MIME_TYPE",
    "content": "IMAGE_CONTENT"
  },
  "fieldMask": "FIELD_MASK",
  "processOptions": {
    "ocrConfig": {
      "enableNativePdfParsing": ENABLE_NATIVE_PDF_PARSING,
      "enableImageQualityScores": ENABLE_IMAGE_QUALITY_SCORES,
      "enableSymbol": ENABLE_SYMBOL,
      "disableCharacterBoxesDetection": DISABLE_CHARACTER_BOXES_DETECTION,
      "hints": {
        "languageHints": [
          "LANGUAGE_HINTS"
        ]
      },
      "advancedOcrOptions": ["ADVANCED_OCR_OPTIONS"],
      "premiumFeatures": {
        "enableSelectionMarkDetection": ENABLE_SELECTION_MARK_DETECTION,
        "computeStyleInfo": COMPUTE_STYLE_INFO,
        "enableMathOcr": ENABLE_MATH_OCR,
      }
    },
    "individualPageSelector" {
      "pages": [INDIVIDUAL_PAGES]
    }
  }
}

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process"

PowerShell

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-documentai.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/processors/PROCESSOR_ID/processorVersions/PROCESSOR_VERSION:process" | Select-Object -Expand Content

Jika permintaan berhasil, server akan menampilkan kode status HTTP 200 OK dan respons dalam format JSON. Isi respons berisi instance Document.

Python

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Python Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

from typing import Optional, Sequence

from google.api_core.client_options import ClientOptions
from google.cloud import documentai

# TODO(developer): Uncomment these variables before running the sample.
# project_id = "YOUR_PROJECT_ID"
# location = "YOUR_PROCESSOR_LOCATION" # Format is "us" or "eu"
# processor_id = "YOUR_PROCESSOR_ID" # Create processor before running sample
# processor_version = "rc" # Refer to https://cloud.google.com/document-ai/docs/manage-processor-versions for more information
# file_path = "/path/to/local/pdf"
# mime_type = "application/pdf" # Refer to https://cloud.google.com/document-ai/docs/file-types for supported file types


def process_document_ocr_sample(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
) -> None:
    # Optional: Additional configurations for Document OCR Processor.
    # For more information: https://cloud.google.com/document-ai/docs/enterprise-document-ocr
    process_options = documentai.ProcessOptions(
        ocr_config=documentai.OcrConfig(
            enable_native_pdf_parsing=True,
            enable_image_quality_scores=True,
            enable_symbol=True,
            # OCR Add Ons https://cloud.google.com/document-ai/docs/ocr-add-ons
            premium_features=documentai.OcrConfig.PremiumFeatures(
                compute_style_info=True,
                enable_math_ocr=False,  # Enable to use Math OCR Model
                enable_selection_mark_detection=True,
            ),
        )
    )
    # Online processing request to Document AI
    document = process_document(
        project_id,
        location,
        processor_id,
        processor_version,
        file_path,
        mime_type,
        process_options=process_options,
    )

    text = document.text
    print(f"Full document text: {text}\n")
    print(f"There are {len(document.pages)} page(s) in this document.\n")

    for page in document.pages:
        print(f"Page {page.page_number}:")
        print_page_dimensions(page.dimension)
        print_detected_languages(page.detected_languages)

        print_blocks(page.blocks, text)
        print_paragraphs(page.paragraphs, text)
        print_lines(page.lines, text)
        print_tokens(page.tokens, text)

        if page.symbols:
            print_symbols(page.symbols, text)

        if page.image_quality_scores:
            print_image_quality_scores(page.image_quality_scores)

        if page.visual_elements:
            print_visual_elements(page.visual_elements, text)


def print_page_dimensions(dimension: documentai.Document.Page.Dimension) -> None:
    print(f"    Width: {str(dimension.width)}")
    print(f"    Height: {str(dimension.height)}")


def print_detected_languages(
    detected_languages: Sequence[documentai.Document.Page.DetectedLanguage],
) -> None:
    print("    Detected languages:")
    for lang in detected_languages:
        print(f"        {lang.language_code} ({lang.confidence:.1%} confidence)")


def print_blocks(blocks: Sequence[documentai.Document.Page.Block], text: str) -> None:
    print(f"    {len(blocks)} blocks detected:")
    first_block_text = layout_to_text(blocks[0].layout, text)
    print(f"        First text block: {repr(first_block_text)}")
    last_block_text = layout_to_text(blocks[-1].layout, text)
    print(f"        Last text block: {repr(last_block_text)}")


def print_paragraphs(
    paragraphs: Sequence[documentai.Document.Page.Paragraph], text: str
) -> None:
    print(f"    {len(paragraphs)} paragraphs detected:")
    first_paragraph_text = layout_to_text(paragraphs[0].layout, text)
    print(f"        First paragraph text: {repr(first_paragraph_text)}")
    last_paragraph_text = layout_to_text(paragraphs[-1].layout, text)
    print(f"        Last paragraph text: {repr(last_paragraph_text)}")


def print_lines(lines: Sequence[documentai.Document.Page.Line], text: str) -> None:
    print(f"    {len(lines)} lines detected:")
    first_line_text = layout_to_text(lines[0].layout, text)
    print(f"        First line text: {repr(first_line_text)}")
    last_line_text = layout_to_text(lines[-1].layout, text)
    print(f"        Last line text: {repr(last_line_text)}")


def print_tokens(tokens: Sequence[documentai.Document.Page.Token], text: str) -> None:
    print(f"    {len(tokens)} tokens detected:")
    first_token_text = layout_to_text(tokens[0].layout, text)
    first_token_break_type = tokens[0].detected_break.type_.name
    print(f"        First token text: {repr(first_token_text)}")
    print(f"        First token break type: {repr(first_token_break_type)}")
    if tokens[0].style_info:
        print_style_info(tokens[0].style_info)

    last_token_text = layout_to_text(tokens[-1].layout, text)
    last_token_break_type = tokens[-1].detected_break.type_.name
    print(f"        Last token text: {repr(last_token_text)}")
    print(f"        Last token break type: {repr(last_token_break_type)}")
    if tokens[-1].style_info:
        print_style_info(tokens[-1].style_info)


def print_symbols(
    symbols: Sequence[documentai.Document.Page.Symbol], text: str
) -> None:
    print(f"    {len(symbols)} symbols detected:")
    first_symbol_text = layout_to_text(symbols[0].layout, text)
    print(f"        First symbol text: {repr(first_symbol_text)}")
    last_symbol_text = layout_to_text(symbols[-1].layout, text)
    print(f"        Last symbol text: {repr(last_symbol_text)}")


def print_image_quality_scores(
    image_quality_scores: documentai.Document.Page.ImageQualityScores,
) -> None:
    print(f"    Quality score: {image_quality_scores.quality_score:.1%}")
    print("    Detected defects:")

    for detected_defect in image_quality_scores.detected_defects:
        print(f"        {detected_defect.type_}: {detected_defect.confidence:.1%}")


def print_style_info(style_info: documentai.Document.Page.Token.StyleInfo) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    print(f"           Font Size: {style_info.font_size}pt")
    print(f"           Font Type: {style_info.font_type}")
    print(f"           Bold: {style_info.bold}")
    print(f"           Italic: {style_info.italic}")
    print(f"           Underlined: {style_info.underlined}")
    print(f"           Handwritten: {style_info.handwritten}")
    print(
        f"           Text Color (RGBa): {style_info.text_color.red}, {style_info.text_color.green}, {style_info.text_color.blue}, {style_info.text_color.alpha}"
    )


def print_visual_elements(
    visual_elements: Sequence[documentai.Document.Page.VisualElement], text: str
) -> None:
    """
    Only supported in version `pretrained-ocr-v2.0-2023-06-02`
    """
    checkboxes = [x for x in visual_elements if "checkbox" in x.type]
    math_symbols = [x for x in visual_elements if x.type == "math_formula"]

    if checkboxes:
        print(f"    {len(checkboxes)} checkboxes detected:")
        print(f"        First checkbox: {repr(checkboxes[0].type)}")
        print(f"        Last checkbox: {repr(checkboxes[-1].type)}")

    if math_symbols:
        print(f"    {len(math_symbols)} math symbols detected:")
        first_math_symbol_text = layout_to_text(math_symbols[0].layout, text)
        print(f"        First math symbol: {repr(first_math_symbol_text)}")




def process_document(
    project_id: str,
    location: str,
    processor_id: str,
    processor_version: str,
    file_path: str,
    mime_type: str,
    process_options: Optional[documentai.ProcessOptions] = None,
) -> documentai.Document:
    # You must set the `api_endpoint` if you use a location other than "us".
    client = documentai.DocumentProcessorServiceClient(
        client_options=ClientOptions(
            api_endpoint=f"{location}-documentai.googleapis.com"
        )
    )

    # The full resource name of the processor version, e.g.:
    # `projects/{project_id}/locations/{location}/processors/{processor_id}/processorVersions/{processor_version_id}`
    # You must create a processor before running this sample.
    name = client.processor_version_path(
        project_id, location, processor_id, processor_version
    )

    # Read the file into memory
    with open(file_path, "rb") as image:
        image_content = image.read()

    # Configure the process request
    request = documentai.ProcessRequest(
        name=name,
        raw_document=documentai.RawDocument(content=image_content, mime_type=mime_type),
        # Only supported for Document OCR processor
        process_options=process_options,
    )

    result = client.process_document(request=request)

    # For a full list of `Document` object attributes, reference this page:
    # https://cloud.google.com/document-ai/docs/reference/rest/v1/Document
    return result.document




def layout_to_text(layout: documentai.Document.Page.Layout, text: str) -> str:
    """
    Document AI identifies text in different parts of the document by their
    offsets in the entirety of the document"s text. This function converts
    offsets to a string.
    """
    # If a text segment spans several lines, it will
    # be stored in different text segments.
    return "".join(
        text[int(segment.start_index) : int(segment.end_index)]
        for segment in layout.text_anchor.text_segments
    )

Langkah berikutnya

• Tinjau daftar pemroses.
• Pisahkan dokumen menjadi bagian-bagian yang mudah dibaca dengan Layout Parser.
• Buat pengklasifikasi kustom.