Enterprise Document OCR

Anda dapat menggunakan Enterprise Document OCR sebagai bagian dari Document AI untuk mendeteksi dan mengekstrak informasi teks dan 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

Solusi	Produk	Deskripsi	Kasus penggunaan
Document AI	Enterprise Document OCR	Model khusus untuk kasus penggunaan dokumen. Fitur lanjutan mencakup skor kualitas gambar, petunjuk bahasa, dan koreksi rotasi.	Direkomendasikan saat mengekstrak teks dari dokumen. Kasus penggunaan mencakup PDF, dokumen yang dipindai sebagai gambar, atau file Microsoft DocX.
Document AI	Add-on OCR	Fitur premium untuk persyaratan tertentu. Hanya kompatibel dengan Enterprise Document OCR versi 2.0 dan yang lebih baru.	Perlu mendeteksi dan mengenali formula matematika, menerima informasi gaya font, atau mengaktifkan ekstraksi kotak centang.
Cloud Vision API	Deteksi teks	REST API yang tersedia secara global berdasarkan model OCR standar Google Cloud . Kuota default 1.800 permintaan per menit.	Kasus penggunaan ekstraksi teks umum yang memerlukan latensi rendah dan kapasitas tinggi.
Cloud Vision	OCR Google Distributed Cloud (Tidak digunakan lagi)	Aplikasi Google Cloud Marketplace yang dapat di-deploy sebagai container ke cluster GKE mana pun menggunakan GKE Enterprise.	Untuk memenuhi persyaratan kepatuhan atau residensi data.

Deteksi dan ekstraksi

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

Atribut deteksi dan ekstraksi tata letak yang didukung:

Teks cetak	Tulis tangan	Paragraf	Blokir	Baris	Word	Tingkat simbol	Nomor halaman
Default	Default	Default	Default	Default	Default	Dapat Dikonfigurasi	Default

Fitur Enterprise Document OCR yang dapat dikonfigurasi meliputi:

• Mengekstrak teks tersemat atau native 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 ekstrem, dan teks yang sebagian tersembunyi.

• Koreksi rotasi: Gunakan Enterprise Document OCR untuk memproses gambar dokumen secara pra-pemrosesan guna memperbaiki masalah rotasi yang dapat memengaruhi kualitas atau pemrosesan ekstraksi.

• Skor kualitas gambar: Menerima metrik kualitas yang dapat membantu pemilihan rute dokumen. Skor kualitas gambar memberi Anda metrik kualitas tingkat halaman dalam delapan dimensi, termasuk buram, adanya font yang lebih kecil dari biasanya, dan silau.

• Menentukan rentang halaman: Menentukan rentang halaman dalam dokumen input untuk OCR. Hal ini menghemat waktu pembelanjaan dan pemrosesan 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 ke model OCR berdasarkan karakteristik set data Anda yang diketahui.

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 pretrained-ocr-v2.0-2023-06-02 Stabil dan versi pretrained-ocr-v2.1-2024-08-07 Calon Rilis:

• OCR Matematika: Mengidentifikasi dan mengekstrak formula dari dokumen dalam format LaTeX.
• Ekstraksi kotak centang: Mendeteksi kotak centang dan mengekstrak statusnya (ditandai/tidak ditandai) 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 sinkronisasi dan 30 halaman dalam asinkron. Dukungan DocX dalam pratinjau pribadi. Untuk meminta akses, kirimkan Formulir Permintaan Dukungan DocX .

Pembuatan versi lanjutan

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

Versi prosesor

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

ID versi	Saluran rilis	Deskripsi
pretrained-ocr-v1.0-2020-09-23	Stabil	Tidak direkomendasikan untuk digunakan dan akan dihentikan di Amerika Serikat (AS) dan Uni Eropa (EU) mulai 30 April 2025.
pretrained-ocr-v1.1-2022-09-12	Stabil	Tidak direkomendasikan untuk digunakan dan akan dihentikan di Amerika Serikat (AS) dan Uni Eropa (EU) mulai 30 April 2025.
pretrained-ocr-v1.2-2022-11-10	Stabil	Versi model beku v1.0: File model, konfigurasi, dan biner snapshot versi yang dibekukan dalam image container hingga 18 bulan.
pretrained-ocr-v2.0-2023-06-02	Stabil	Model siap produksi yang dikhususkan untuk kasus penggunaan dokumen. Mencakup akses ke semua add-on OCR.
pretrained-ocr-v2.1-2024-08-07	Kandidat rilis	Area utama peningkatan untuk v2.1 adalah: pengenalan teks cetak yang lebih baik, deteksi kotak centang yang lebih presisi, dan urutan pembacaan yang lebih akurat.

Menggunakan Enterprise Document OCR untuk memproses dokumen

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

1. 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.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. Enable the Document AI API.

   Enable the API

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

7. 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 menetapkan kolom masing-masing di ProcessOptions.ocrConfig di 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 yang 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:

• Model ini dapat menampilkan deteksi positif palsu dengan dokumen digital tanpa cacat. Fitur ini paling baik digunakan pada dokumen yang dipindai atau difoto.

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

Input

Aktifkan dengan menetapkan 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 cacat 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. Menerapkan petunjuk bahasa memungkinkan OCR mengoptimalkan bahasa yang dipilih, bukan bahasa yang disimpulkan.

Input

Aktifkan dengan menetapkan 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

Isi data di tingkat simbol (atau setiap huruf) dalam respons dokumen.

Input

Aktifkan dengan menetapkan 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.

Pemrosesan PDF bawaan

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

Input

Aktifkan dengan menetapkan 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 memiliki detektor yang diaktifkan untuk meningkatkan kualitas ekstraksi teks karakter yang berada dalam kotak. Berikut ini contohnya:

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

Catatan: Fitur ini hanya tersedia untuk prosesor versi 2.0 dan yang lebih baru.

Input

Nonaktifkan dengan menetapkan 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.

Catatan: Fitur ini dapat mengubah urutan teks di Document.text.

Input

Aktifkan dengan menetapkan 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.

Catatan: Fitur ini hanya didukung untuk permintaan pemrosesan online (sinkron).

Ada tiga cara untuk mengonfigurasinya di ProcessOptions:

• Untuk hanya memproses halaman kedua dan kelima:

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

Catatan: Halaman diindeks 1.

• Untuk hanya memproses tiga halaman pertama:

  {
    "fromStart": 3
  }

• Untuk hanya memproses 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 direpresentasikan sebagai LaTeX beserta koordinat kotak pembatas.

Berikut adalah contoh representasi LaTeX:

• Gambar terdeteksi

  

• Konversi ke LaTeX

  

Input

Aktifkan dengan menetapkan 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 di dokumen, beserta koordinat kotak pembatas.

Input

Aktifkan dengan menetapkan 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 .

Catatan: OCR Matematika dan deteksi tanda pilihan adalah add-on yang saling eksklusif. Keduanya tidak dapat diaktifkan secara bersamaan.

Deteksi gaya font

Dengan mengaktifkan deteksi gaya font, Enterprise Document OCR mengekstrak atribut font, yang dapat digunakan untuk pascapemrosesan 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 menetapkan ProcessOptions.ocrConfig.premiumFeatures.computeStyleInfo ke true dalam permintaan pemrosesan.

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

Output

Output gaya font 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 adalah 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 pengonversi mengisi vertices dan normalized_vertices.
• Respons Vision AI API mengisi detected_break pada simbol terakhir kata. Respons Document AI API dan pengonversi 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 kolom simbol pengonversi diisi, tetapkan fitur enable_symbol seperti yang dijelaskan.

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: project ID Google Cloud Anda.
• PROCESSOR_ID: ID pemroses kustom Anda.
• PROCESSOR_VERSION: ID versi prosesor. Lihat Memilih versi prosesor untuk mengetahui informasi selengkapnya. Misalnya:
  • pretrained-TYPE-vX.X-YYYY-MM-DD
  • stable
  • rc
• skipHumanReview: Boolean untuk menonaktifkan peninjauan manual (Hanya didukung oleh pemroses Human-in-the-Loop.)
  • 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 Mengenkode Base64 untuk informasi selengkapnya.
• FIELD_MASK: Menentukan kolom yang akan disertakan dalam output Document. Ini adalah daftar yang dipisahkan koma berisi nama kolom yang sepenuhnya memenuhi syarat dalam format FieldMask.
  • Contoh: text,entities,pages.pageNumber
• Konfigurasi OCR
  • ENABLE_NATIVE_PDF_PARSING: (Boolean) Mengekstrak teks tersemat 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) Menonaktifkan pendeteksi 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 lebih menyesuaikan perilaku OCR. Nilai yang 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) Mengaktifkan pendeteksi tanda pilihan di mesin OCR.
  • COMPUTE_STYLE_INFO (Boolean) Mengaktifkan model identifikasi font dan menampilkan informasi gaya font.
  • ENABLE_MATH_OCR: (Boolean) Aktifkan model yang dapat mengekstrak formula matematika LaTeX.
• INDIVIDUAL_PAGES: Daftar setiap halaman 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 yang dienkode 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

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login , atau dengan menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke gcloud CLI . Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

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

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login . Anda dapat memeriksa akun yang saat ini aktif dengan menjalankan gcloud auth list.

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, baca 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 selanjutnya

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