Docling ನ ಏಕೀಕೃತ ಬಹು-ಫಾರ್ಮ್ಯಾಟ್ parser ಬಳಸಿ ದಾಖಲೆಗಳನ್ನು ಹೊರತೆಗೆಯಿರಿ

ಪರಿಚಯ

ರಿಟ್ರೀವಲ್-ಆಗ್ಮೆಂಟೆಡ್ ಜನರೇಷನ್ (RAG) ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ತಂಡಗಳು ಮೊದಲ ದಿನವೇ ಒಂದೇ ಗೋಡೆಗೆ ಡಿಕ್ಕಿ ಹೊಡೆಯುತ್ತವೆ: ಪ್ರತಿಯೊಂದು ಇನ್‌ಪುಟ್ ಫಾರ್ಮ್ಯಾಟ್ — PDF, DOCX, HTML, PPTX, ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ ಚಿತ್ರಗಳು — ತನ್ನದೇ ಪಾರ್ಸರ್, ತನ್ನದೇ ವಿಚಿತ್ರ ನಡವಳಿಕೆಗಳು, ಮತ್ತು ತನ್ನದೇ ಬಗ್ ಮೇಲ್ಮೈಯನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು ಅವುಗಳ ಸುತ್ತಲಿನ ರ್ಯಾಪರ್‌ಗಳು ಔಟ್‌ಪುಟ್ ಸ್ಕೀಮಾದ ಬಗ್ಗೆ ಅಪರೂಪವಾಗಿ ಒಪ್ಪುತ್ತವೆ. Docling ಇದನ್ನೆಲ್ಲಾ ಒಂದೇ ಹೊರತೆಗೆಯುವ ಇಂಟರ್‌ಫೇಸ್‌ಗೆ ಕುಗ್ಗಿಸುತ್ತದೆ, ಅದು ಯಾವಾಗಲೂ ಏಕರೂಪದ ಆಕಾರದ ಟ್ರೀಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಪದರವನ್ನು ತಪ್ಪಾಗಿ ಮಾಡಿದರೆ ಪ್ರತಿಯೊಂದು ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಗ್ರಾಹಕ (ಚಂಕರ್, ಎಂಬೆಡರ್, ರಿಟ್ರೀವರ್, ಇವ್ಯಾಲ್ಯುಯೇಟರ್) ಆ ಅಸಂಗತತೆಯನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ, ಹಾಗಾಗಿ ಒಂದೇ ಕೆಟ್ಟ ಪಾರ್ಸರ್ ಸಂಪೂರ್ಣ RAG ಸ್ಟ್ಯಾಕ್‌ನ್ನು ಭ್ರಷ್ಟಗೊಳಿಸುತ್ತದೆ. ಈ ಪಾಠದ ಕೊನೆಯಲ್ಲಿ ನೀವು OCR ಮತ್ತು ಟೇಬಲ್ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯೊಂದಿಗೆ ಪ್ರೊಡಕ್ಷನ್-ದರ್ಜೆಯ PDF ಹೊರತೆಗೆಯುವಿಕೆಗಾಗಿ Docling ನ DocumentConverter ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು, ಪ್ರತ್ಯೇಕ ವೈಫಲ್ಯಗಳಲ್ಲಿ ನಿಲ್ಲಿಸದೆ ಮಿಶ್ರ-ಫಾರ್ಮ್ಯಾಟ್ ಬ್ಯಾಚ್‌ಗಳ ಮೇಲೆ ಅದನ್ನು ಚಲಾಯಿಸಲು, ಮತ್ತು ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಹಂತಗಳಿಗಾಗಿ ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್‌ಗಳು, ಟೇಬಲ್‌ಗಳು ಮತ್ತು ಮೂಲ (provenance) ಮೆಟಾಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯಲು ಫಲಿತಾಂಶದ DoclingDocument ಟ್ರೀಯಲ್ಲಿ ಸಂಚರಿಸಲು ಸಮರ್ಥರಾಗುತ್ತೀರಿ.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

• DocumentConverter: Docling ನ ಏಕೈಕ ಪ್ರವೇಶ-ಬಿಂದು ಕ್ಲಾಸ್, ಇದು ಇನ್‌ಪುಟ್ ಫೈಲ್‌ಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್-ನಿರ್ದಿಷ್ಟ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗೆ ರವಾನಿಸುತ್ತದೆ ಮತ್ತು ಮೂಲ ಫಾರ್ಮ್ಯಾಟ್ ಯಾವುದಾದರೂ ಏಕರೂಪದ ಆಕಾರದ DoclingDocument ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• DoclingDocument: Docling ಹೊರಸೂಸುವ ಕಂಟೆಂಟ್ ಅಂಶಗಳ (TextItem, SectionHeaderItem, TableItem, PictureItem) ಟೈಪ್ ಮಾಡಲಾದ ಟ್ರೀ, ಪ್ರತಿಯೊಂದೂ ಗ್ರೌಂಡಿಂಗ್‌ಗಾಗಿ ಪುಟ ಸಂಖ್ಯೆ ಮತ್ತು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ ಹೊಂದಿರುವ prov ಮೆಟಾಡೇಟಾವನ್ನು ಹೊತ್ತಿರುತ್ತದೆ.
• TableFormer: Docling ನ ಟೇಬಲ್-ರಚನೆ ಗುರುತಿಸುವಿಕೆ ಮಾಡೆಲ್, ಟೇಬಲ್-ಭಾರವಾದ PDF ಗಳಲ್ಲಿ ವೇಗಕ್ಕಾಗಿ ಹೊರತೆಗೆಯುವ ನಿಖರತೆಯನ್ನು ವಿನಿಮಯ ಮಾಡಲು TableFormerMode (FAST ಅಥವಾ ACCURATE) ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು.
• PdfPipelineOptions: DocumentConverter ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನಲ್ಲಿ OCR, ಟೇಬಲ್-ರಚನೆ ಪತ್ತೆಹಚ್ಚುವಿಕೆ, ಚಿತ್ರ ಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ಇತರ PDF-ನಿರ್ದಿಷ್ಟ ಹೊರತೆಗೆಯುವ ನಡವಳಿಕೆಯನ್ನು ಟಾಗಲ್ ಮಾಡುವ ಪ್ರತಿ-ಫಾರ್ಮ್ಯಾಟ್ ಕಾನ್ಫಿಗರೇಷನ್ ಆಬ್ಜೆಕ್ಟ್.
• ConversionStatus: convert_all() ಹಿಂತಿರುಗಿಸುವ ಪ್ರತಿ-ದಾಖಲೆಯ ಫಲಿತಾಂಶ (SUCCESS, PARTIAL_SUCCESS, FAILURE), ಇದರಿಂದ ಬ್ಯಾಚ್ ಜಾಬ್‌ಗಳು ಒಂದೇ ಕೆಟ್ಟ ಇನ್‌ಪುಟ್‌ನಲ್ಲಿ ನಿಲ್ಲದೆ ಫಲಿತಾಂಶದ ಗುಣಮಟ್ಟದ ಮೇಲೆ ಕವಲೊಡೆಯಬಹುದು.

ಪರಿಕಲ್ಪನೆಗಳು

Docling ನ ಮೌಲ್ಯವೆಂದರೆ ಅದು ಫಾರ್ಮ್ಯಾಟ್-ನಿರ್ದಿಷ್ಟ ಪಾರ್ಸಿಂಗ್‌ನ್ನು ಒಂದೇ ಕನ್ವರ್ಟರ್ ಮತ್ತು ಒಂದೇ ಔಟ್‌ಪುಟ್ ಸ್ಕೀಮಾದ ಹಿಂದೆ ಮರೆಮಾಡುತ್ತದೆ, ಹಾಗಾಗಿ RAG ಪೈಪ್‌ಲೈನ್‌ನ ಉಳಿದ ಭಾಗವನ್ನು ಒಂದೇ ಟ್ರೀ ಆಕಾರದ ವಿರುದ್ಧ ಬರೆಯಬಹುದು. ಮೂರು ವಿಚಾರಗಳು ಈ ಪಾಠವನ್ನು ಮುನ್ನಡೆಸುತ್ತವೆ:

1. ಒಂದು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ಕನ್ವರ್ಟರ್, ಹಲವು ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು. ಒಂದು DocumentConverter ಅನ್ನು ಒಮ್ಮೆ format_options ಮ್ಯಾಪ್‌ನೊಂದಿಗೆ ಆರಂಭಿಸಲಾಗುತ್ತದೆ, ಇದು ಪ್ರತಿ InputFormat ಗೆ ಒಂದು ಪೈಪ್‌ಲೈನ್‌ನ್ನು (OCR ಸೆಟ್ಟಿಂಗ್‌ಗಳು, ಟೇಬಲ್-ರಚನೆ ಮೋಡ್, ಚಿತ್ರ ಸ್ಕೇಲ್) ಜೋಡಿಸುತ್ತದೆ. ಅದೇ ಇನ್‌ಸ್ಟೆನ್ಸ್ ನಂತರ ಕಾಲರ್ ಕೋಡ್‌ನಲ್ಲಿ ಪ್ರತಿ-ಕಾಲ್ ಕವಲೊಡೆಯುವಿಕೆ ಇಲ್ಲದೆ PDF, DOCX, HTML, PPTX ಮತ್ತು ಚಿತ್ರ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
2. ಪ್ರತ್ಯೇಕಿಸಲಾದ ವೈಫಲ್ಯಗಳೊಂದಿಗೆ ಬ್ಯಾಚ್ ಪ್ರೊಸೆಸಿಂಗ್. convert_all(..., raises_on_error=False) ಪ್ರತಿ ಇನ್‌ಪುಟ್‌ಗೆ ಒಂದು ConversionResult ನೀಡುತ್ತದೆ, ಇದರಿಂದ ವಿರೂಪಗೊಂಡ PDF ConversionStatus.FAILURE ಆಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಬ್ಯಾಚ್‌ನ ಉಳಿದ ಭಾಗ ಚಾಲನೆಯಲ್ಲಿರುತ್ತದೆ — ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ವೈವಿಧ್ಯಮಯ ದಾಖಲೆ ಕಾರ್ಪಸ್‌ಗಳನ್ನು ಸೇರಿಸಿಕೊಳ್ಳುವಾಗ ಇದು ಅತ್ಯಗತ್ಯ.
3. ಮೂಲ ಮಾಹಿತಿಯೊಂದಿಗೆ ಏಕರೂಪದ ಟ್ರೀ. ಪ್ರತಿಯೊಂದು ಯಶಸ್ವಿ ಹೊರತೆಗೆಯುವಿಕೆ ಒಂದು DoclingDocument ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಅದರ iterate_items() ನಡಿಗೆಯು prov ಮೆಟಾಡೇಟಾದೊಂದಿಗೆ ಟೈಪ್ ಮಾಡಲಾದ ನೋಡ್‌ಗಳನ್ನು (TextItem, SectionHeaderItem, TableItem, PictureItem) ನೀಡುತ್ತದೆ. ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಚಂಕರ್‌ಗಳು ಮತ್ತು ರಿಟ್ರೀವರ್‌ಗಳು ಒಂದೇ ಆಕಾರವನ್ನು ಬಳಸುತ್ತವೆ, ಮತ್ತು ಮೂಲ ಮಾಹಿತಿಯು ಉತ್ತರಗಳು ತಾವು ಬಂದ ನಿಖರ ಪುಟ ಮತ್ತು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ನ್ನು ಉಲ್ಲೇಖಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

ಈ ವಾಕ್‌ಥ್ರೂ ಪೈಪ್‌ಲೈನ್‌ನ ಎರಡು ಹಂತಗಳನ್ನು ಒಂದರ ಹಿಂದೆ ಒಂದರಂತೆ ಒಳಗೊಳ್ಳುತ್ತದೆ. ಮೊದಲ ಹಂತವು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ DocumentConverter ಅನ್ನು ನಿರ್ಮಿಸಿ ಅದರ ಮೂಲಕ ಮಿಶ್ರ-ಫಾರ್ಮ್ಯಾಟ್ ಬ್ಯಾಚ್‌ನ್ನು ಚಲಾಯಿಸುತ್ತದೆ; ಎರಡನೇ ಹಂತವು ಫಲಿತಾಂಶದ DoclingDocument ಟ್ರೀಯಲ್ಲಿ ಸಂಚರಿಸಿ ಹೆಡಿಂಗ್ ಶ್ರೇಣಿಗಳನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ, ಇದರಿಂದ ಮೂಲ ಫಾರ್ಮ್ಯಾಟ್ ಯಾವುದಾದರೂ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಚಂಕರ್‌ಗಳು ಸ್ಥಿರವಾದ ರಚನೆಯನ್ನು ನೋಡುತ್ತವೆ.

ಕನ್ವರ್ಟರ್ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಮತ್ತು ಚಲಾಯಿಸುವುದು

ಕನ್ವರ್ಟರ್ OCR, ಟೇಬಲ್ ಪತ್ತೆಹಚ್ಚುವಿಕೆ ಮತ್ತು ಚಿತ್ರ ರೆಸಲ್ಯೂಷನ್‌ನ್ನು ನಿಯಂತ್ರಿಸುವ ಪ್ರತಿ-ಫಾರ್ಮ್ಯಾಟ್ ಪೈಪ್‌ಲೈನ್ ಆಯ್ಕೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನಂತರ ಬ್ಯಾಚ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ convert_all() ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕೆಳಗಿನ ಸ್ನಿಪ್ಪೆಟ್ ಡಿಜಿಟಲ್-ಜನಿತ ಮತ್ತು ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ ಇನ್‌ಪುಟ್‌ಗಳೆರಡಕ್ಕೂ PDF ಹೊರತೆಗೆಯುವಿಕೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ ಮತ್ತು PDF ಗಳ ಡೈರೆಕ್ಟರಿಯ ಮೇಲೆ ಅದನ್ನು ಚಲಾಯಿಸುತ್ತದೆ, ಬ್ಯಾಚ್‌ನ್ನು ನಿಲ್ಲಿಸದೆ ಪ್ರತ್ಯೇಕ ವೈಫಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:

Code snippetpython
1from pathlib import Path
2from docling.document_converter import DocumentConverter, PdfFormatOption
3from docling.datamodel.pipeline_options import (
4    PdfPipelineOptions,
5    EasyOcrOptions,
6    TableFormerMode,
7)
8from docling.datamodel.base_models import InputFormat, ConversionStatus
9
10ocr_options = EasyOcrOptions(
11    lang=["en"],
12    force_full_page_ocr=False,
13)
14
15pipeline_options = PdfPipelineOptions(
16    do_ocr=True,
17    ocr_options=ocr_options,
18    do_table_structure=True,
19    table_structure_options={"mode": TableFormerMode.ACCURATE},
20    images_scale=2.0,
21)
22
23converter = DocumentConverter(
24    format_options={
25        InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options),
26    }
27)
28
29pdf_files = list(Path("/data/incoming/").glob("**/*.pdf"))
30results = converter.convert_all(pdf_files, raises_on_error=False)
31
32for result in results:
33    if result.status == ConversionStatus.SUCCESS:
34        doc = result.document
35        markdown = doc.export_to_markdown()
36        print(f"Processed {result.input.file}: {len(doc.pages)} pages")
37    elif result.status == ConversionStatus.PARTIAL_SUCCESS:
38        print(f"Partial: {result.input.file} - {len(result.errors)} errors")
39    else:
40        print(f"Failed: {result.input.file} - {result.errors}")

• EasyOcrOptions(force_full_page_ocr=False) ಹೊರತೆಗೆಯಬಹುದಾದ ಟೆಕ್ಸ್ಟ್ ಲೇಯರ್ ಇಲ್ಲದ ಪುಟಗಳಲ್ಲಿ ಮಾತ್ರ OCR ಚಲಾಯಿಸುತ್ತದೆ, ಹಾಗಾಗಿ ಡಿಜಿಟಲ್-ಜನಿತ PDF ಗಳು OCR ದಂಡವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪಿಸುತ್ತವೆ ಮತ್ತು ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ ಪುಟಗಳು ಇನ್ನೂ ಪ್ರೊಸೆಸ್ ಆಗುತ್ತವೆ.
• PdfPipelineOptions OCR, ನಿಖರ ಮೋಡ್‌ನಲ್ಲಿ TableFormer ಬಳಸಿ ಟೇಬಲ್-ರಚನೆ ಪತ್ತೆಹಚ್ಚುವಿಕೆ, ಮತ್ತು 2× ಚಿತ್ರ ರೆಸಲ್ಯೂಷನ್ ಸ್ಕೇಲಿಂಗ್‌ನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ images_scale ಮೌಲ್ಯಗಳು ಚಿಕ್ಕ ಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ OCR ನಿಖರತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತವೆ ಆದರೆ ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಪ್ರತಿ-ಪುಟ ಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ.
• format_options ಡಿಕ್ಟ್ ಇನ್‌ಪುಟ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್-ನಿರ್ದಿಷ್ಟ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. ಅದೇ ಕನ್ವರ್ಟರ್ ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನ್ನು ಇತರ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ ವಿಸ್ತರಿಸಲು ತಮ್ಮದೇ ಆಯ್ಕೆಗಳೊಂದಿಗೆ InputFormat.DOCX ಅಥವಾ InputFormat.HTML ನಮೂದುಗಳನ್ನು ಸೇರಿಸಿ.
• convert_all(..., raises_on_error=False) ಪ್ರತಿ ದಾಖಲೆಗೆ ಒಂದು ConversionResult ನೀಡುತ್ತದೆ ಮತ್ತು ವೈಫಲ್ಯಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ, ಇದರಿಂದ ಒಂದು ವಿರೂಪಗೊಂಡ PDF ಬ್ಯಾಚ್‌ನ್ನು ನಿಲ್ಲಿಸುವುದಿಲ್ಲ. ಶುದ್ಧ ಹೊರತೆಗೆಯುವಿಕೆಗಳನ್ನು ಆಂಶಿಕವಾದವುಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ConversionStatus.{SUCCESS, PARTIAL_SUCCESS} ಮೇಲೆ ಕವಲೊಡೆಯಿರಿ, ಮತ್ತು ಹೆಡಿಂಗ್ ಹಂತಗಳು, ಟೇಬಲ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಮತ್ತು ಚಿತ್ರ ಉಲ್ಲೇಖಗಳನ್ನು ಸಂರಕ್ಷಿಸಿ ದಾಖಲೆ ಟ್ರೀಯನ್ನು ಸೀರಿಯಲೈಸ್ ಮಾಡಲು export_to_markdown() ಅನ್ನು ಕರೆಯಿರಿ.

ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಸಂಚರಿಸುವುದು ಮತ್ತು ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಾದ್ಯಂತ ಸಾಮಾನ್ಯೀಕರಿಸುವುದು

DoclingDocument ಆಬ್ಜೆಕ್ಟ್ ಕಂಟೆಂಟ್‌ನ್ನು ಟೈಪ್ ಮಾಡಲಾದ ಅಂಶಗಳ ಟ್ರೀಯಾಗಿ ಒದಗಿಸುತ್ತದೆ. ಆ ಟ್ರೀಯಲ್ಲಿ ನಡೆದರೆ ನಿಮಗೆ ಚಂಕರ್‌ಗಳು, ಎಂಬೆಡರ್‌ಗಳು ಅಥವಾ ಇವ್ಯಾಲ್ಯುಯೇಟರ್‌ಗಳಿಗೆ ನೀಡಬಹುದಾದ ಚಪ್ಪಟೆಯಾದ, ಟೈಪ್ ಮಾಡಲಾದ ಬ್ಲಾಕ್‌ಗಳ ಪಟ್ಟಿ ಸಿಗುತ್ತದೆ — ಮತ್ತು ಟ್ರೀ ಕೈಯಲ್ಲಿದ್ದ ಮೇಲೆ, ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಾದ್ಯಂತ ನುಸುಳುವ ರಚನಾತ್ಮಕ ವ್ಯತ್ಯಾಸಗಳನ್ನು (PDF ಫಾಂಟ್-ಗಾತ್ರ ಹ್ಯೂರಿಸ್ಟಿಕ್‌ಗಳು, DOCX ಹೆಡಿಂಗ್ ಶೈಲಿಗಳು, <h2> ನಿಂದ ಆರಂಭವಾಗುವ HTML) ಕೂಡ ಸರಿಹೊಂದಿಸಬಹುದು:

Code snippetpython
1from docling.datamodel.document import DoclingDocument
2
3def extract_content_blocks(doc: DoclingDocument) -> list[dict]:
4    blocks = []
5    for item, level in doc.iterate_items():
6        block = {
7            "type": item.__class__.__name__,
8            "text": item.text if hasattr(item, "text") else "",
9            "level": level,
10            "page": item.prov[0].page_no if item.prov else None,
11            "bbox": item.prov[0].bbox.as_tuple() if item.prov else None,
12        }
13        if item.__class__.__name__ == "TableItem":
14            block["table_data"] = item.export_to_dataframe().to_dict()
15        blocks.append(block)
16    return blocks
17
18def normalize_heading_levels(doc: DoclingDocument) -> DoclingDocument:
19    """Shift headings so the document always starts at h1."""
20    heading_levels_seen = {
21        item.level
22        for item, _ in doc.iterate_items()
23        if item.__class__.__name__ == "SectionHeaderItem"
24    }
25    if heading_levels_seen and min(heading_levels_seen) > 1:
26        offset = min(heading_levels_seen) - 1
27        for item, _ in doc.iterate_items():
28            if item.__class__.__name__ == "SectionHeaderItem":
29                item.level = max(1, item.level - offset)
30    return doc

• iterate_items() ಪ್ರತಿಯೊಂದು ಕಂಟೆಂಟ್ ಅಂಶವನ್ನು ದಾಖಲೆ ಶ್ರೇಣಿಯಲ್ಲಿನ ಅದರ ಆಳದ ಹಂತದೊಂದಿಗೆ ನೀಡುತ್ತದೆ. ಅಂಶ ಪ್ರಕಾರಗಳಲ್ಲಿ TextItem (ಪ್ಯಾರಾಗ್ರಾಫ್‌ಗಳು), SectionHeaderItem (ಹೆಡಿಂಗ್‌ಗಳು), TableItem (ಟೇಬಲ್‌ಗಳು), ಮತ್ತು PictureItem (ಚಿತ್ರಗಳು) ಸೇರಿವೆ. ಪ್ರತಿಯೊಂದು ಅಂಶವೂ ಪುಟ ಸಂಖ್ಯೆ, ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯೊಂದಿಗೆ prov (ಮೂಲ ಮಾಹಿತಿ) ಮೆಟಾಡೇಟಾವನ್ನು ಹೊತ್ತಿರುತ್ತದೆ — ಉಲ್ಲೇಖಗಳು, ರಿಟ್ರೀವಲ್ ಮತ್ತು ಗ್ರೌಂಡಿಂಗ್‌ಗೆ ಅತ್ಯಗತ್ಯ.
• ಟೇಬಲ್‌ಗಳಿಗೆ ವಿಶೇಷ ನಿರ್ವಹಣೆ ಸಿಗುತ್ತದೆ: export_to_dataframe() Docling ನ ಆಂತರಿಕ ಟೇಬಲ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು pandas DataFrame ಆಗಿ ರೂಪಿಸುತ್ತದೆ, ಇದನ್ನು ನೀವು ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಗ್ರಾಹಕರಿಗಾಗಿ JSON, CSV ಅಥವಾ Parquet ಗೆ ಸೀರಿಯಲೈಸ್ ಮಾಡಬಹುದು.
• normalize_heading_levels ಬಳಸಲಾದ ಕನಿಷ್ಠ ಹೆಡಿಂಗ್ ಹಂತಕ್ಕಾಗಿ ಟ್ರೀಯನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ದಾಖಲೆ h1 ನಿಂದ ಆರಂಭವಾಗುವಂತೆ ಪ್ರತಿಯೊಂದು ಹೆಡಿಂಗ್‌ನ್ನು ಕೆಳಕ್ಕೆ ಸರಿಸುತ್ತದೆ. ಇದು ರಚನೆ-ಅರಿವಿನ ಚಂಕಿಂಗ್‌ನ್ನು ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಾದ್ಯಂತ ನಿರ್ಣಾಯಕವಾಗಿಸುತ್ತದೆ — ಇದಿಲ್ಲದೆ, <h2> ನಿಂದ ಆರಂಭವಾಗುವ HTML ಪುಟ ಮತ್ತು h1 ನಿಂದ ಆರಂಭವಾಗುವ PDF ಸೂಕ್ಷ್ಮವಾಗಿ ಭಿನ್ನವಾದ ಚಂಕ್ ಗಡಿಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ.

convert_all() ಕನಿಷ್ಠ ಒಂದು ConversionStatus.SUCCESS ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿದಾಗ, extract_content_blocks(doc) ತುಂಬಿದ page ಮತ್ತು bbox ಫೀಲ್ಡ್‌ಗಳೊಂದಿಗೆ TextItem ಮತ್ತು SectionHeaderItem ನಮೂದುಗಳನ್ನು ಹೊಂದಿರುವ ಖಾಲಿಯಲ್ಲದ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸಿದಾಗ, ಮತ್ತು normalize_heading_levels(doc) ಮೂಲ ಫಾರ್ಮ್ಯಾಟ್ ಯಾವುದಾದರೂ ಮೊದಲ ಹೆಡಿಂಗ್ ಹಂತ 1 ಆಗಿರುವ ದಾಖಲೆಯನ್ನು ಉತ್ಪಾದಿಸಿದಾಗ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ.

ವಿಭಾಗೀಯ ಅನ್ವಯ

ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು

ನೀವು ಈಗ ಅನುಷ್ಠಾನದ ಮೂಲಕ ಹಾದುಹೋಗಿದ್ದೀರಿ, ಕೆಳಗಿನ ಅಭ್ಯಾಸಗಳು ಬಾಳಿಕೆ ಬರುವ ವಿಧಾನವನ್ನು ದುರ್ಬಲವಾದದರಿಂದ ಪ್ರತ್ಯೇಕಿಸುತ್ತವೆ.

ಮಾಡಬೇಕಾದವು

1. ಪ್ರತಿ ವರ್ಕರ್ ಪ್ರೊಸೆಸ್‌ಗೆ ಒಂದು DocumentConverter ಅನ್ನು ಆರಂಭಿಸಿ ಮತ್ತು ದಾಖಲೆಗಳಾದ್ಯಂತ ಅದನ್ನು ಮರುಬಳಕೆ ಮಾಡಿ — TableFormer ಮತ್ತು OCR ಮಾಡೆಲ್ ಲೋಡಿಂಗ್ ಮೊದಲ-ಕಾಲ್ ಲೇಟೆನ್ಸಿಯಲ್ಲಿ ಪ್ರಧಾನವಾಗಿರುತ್ತದೆ, ಹಾಗಾಗಿ ಪ್ರತಿ-ಕಾಲ್ ನಿರ್ಮಾಣವು ಬ್ಯಾಚ್ ಜಾಬ್‌ಗಳನ್ನು ಹಲವು ಪಟ್ಟು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ.
2. convert_all() ಗೆ raises_on_error=False ಅನ್ನು ರವಾನಿಸಿ ಮತ್ತು ConversionStatus.{SUCCESS, PARTIAL_SUCCESS, FAILURE} ಮೇಲೆ ಸ್ಪಷ್ಟವಾಗಿ ಕವಲೊಡೆಯಿರಿ, ಇದರಿಂದ ಒಂದು ಭ್ರಷ್ಟ PDF ಸಾವಿರಾರು ದಾಖಲೆಗಳ ಇಂಜೆಸ್ಟ್‌ನ್ನು ನಿಲ್ಲಿಸುವುದಿಲ್ಲ.
3. ಚಂಕರ್‌ಗಳು ಮತ್ತು ಎಂಬೆಡರ್‌ಗಳಿಗೆ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಹೊರಸೂಸುವಾಗ item.prov (ಪುಟ ಸಂಖ್ಯೆ ಮತ್ತು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್) ಅನ್ನು ಸಂರಕ್ಷಿಸಿ — ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ರಿಟ್ರೀವಲ್ ಮತ್ತು ಉತ್ತರ-ಗ್ರೌಂಡಿಂಗ್ ಉಲ್ಲೇಖಗಳಿಗಾಗಿ ಅದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿವೆ.

ಮಾಡಬಾರದವು

1. ಕಾಲರ್ ಕೋಡ್‌ನಲ್ಲಿ ಪ್ರತಿ-ಫಾರ್ಮ್ಯಾಟ್ if pdf … elif docx … ಕವಲುಗಳನ್ನು ಬರೆಯಬೇಡಿ — format_options ನಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್-ನಿರ್ದಿಷ್ಟ PdfFormatOption / DocxFormatOption ನಮೂದುಗಳನ್ನು ನೋಂದಾಯಿಸಿ ಮತ್ತು convert() ಅನ್ನು ಪಾಲಿಮಾರ್ಫಿಕ್ ಆಗಿ ಕರೆಯಿರಿ.
2. ಡೀಫಾಲ್ಟ್ ಆಗಿ images_scale ಅನ್ನು 2–3 ಕ್ಕಿಂತ ಮೇಲೆ ಏರಿಸಬೇಡಿ; ಇದು ಮೆಮೊರಿ ಮತ್ತು ಪ್ರತಿ-ಪುಟ ಸಮಯವನ್ನು ಹಲವು ಪಟ್ಟು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಮತ್ತು ಈಗಾಗಲೇ ಓದಬಹುದಾದ ಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ OCR ನಿಖರತೆಯನ್ನು ಅಪರೂಪವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ.
3. ConversionStatus.PARTIAL_SUCCESS ಫಲಿತಾಂಶಗಳನ್ನು ಮೌನವಾಗಿ ಕೈಬಿಡಬೇಡಿ — result.errors ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಆಂಶಿಕ ಕಂಟೆಂಟ್ ಬಳಸಬಹುದೇ ಅಥವಾ ಕ್ವಾರಂಟೈನ್ ಮಾಡಬೇಕೇ ಎಂದು ಪ್ರತಿ ಪೈಪ್‌ಲೈನ್‌ಗೆ ನಿರ್ಧರಿಸಿ.