Docling-இன் ஒருங்கிணைந்த பல-வடிவ parser-ஐப் பயன்படுத்தி ஆவணங்களைப் பிரித்தெடுக்கவும்

அறிமுகம்

Retrieval-augmented generation பைப்லைன்களை உருவாக்கும் குழுக்கள் முதல் நாளிலேயே ஒரே சுவரில் மோதுகின்றன: ஒவ்வொரு உள்ளீட்டு வடிவமும் — PDF, DOCX, HTML, PPTX, ஸ்கேன் செய்யப்பட்ட படங்கள் — தனக்கே உரிய பார்சர், தனக்கே உரிய விசித்திரங்கள், தனக்கே உரிய பிழைப் பரப்பு என்று தேவைப்படுகிறது, மேலும் அவற்றைச் சுற்றியுள்ள ராப்பர்கள் வெளியீட்டு ஸ்கீமாவில் அரிதாகவே ஒத்துப்போகின்றன. Docling இதையெல்லாம் எப்போதும் ஒரே சீரான வடிவிலான மரத்தைத் திருப்பித் தரும் ஒரே பிரித்தெடுப்பு இடைமுகமாகச் சுருக்குகிறது. இந்த அடுக்கைத் தவறாகச் செய்தால், கீழ்நிலையில் உள்ள ஒவ்வொரு நுகர்வோரும் (chunker, embedder, retriever, evaluator) அந்த முரண்பாட்டை மரபுரிமையாகப் பெறுகிறார்கள்; அதனால் ஒரு மோசமான பார்சர் முழு RAG ஸ்டாக்கையும் சிதைக்கிறது. இந்தப் பாடத்தின் முடிவில், OCR மற்றும் அட்டவணை கண்டறிதலுடன் production-தர PDF பிரித்தெடுப்புக்காக Docling-இன் DocumentConverter-ஐ உள்ளமைக்கவும், தனிப்பட்ட தோல்விகளில் நிறுத்தாமல் கலப்பு-வடிவத் தொகுதிகளின் மீது அதை இயக்கவும், மேலும் கீழ்நிலைக் கட்டங்களுக்காக உள்ளடக்கத் தொகுதிகள், அட்டவணைகள் மற்றும் மூலத்தரவு (provenance) மெட்டாடேட்டாவைப் பிரித்தெடுக்க விளைவாகக் கிடைக்கும் DoclingDocument மரத்தில் உலாவவும் உங்களால் முடியும்.

முக்கிய சொற்கள்

• DocumentConverter: உள்ளீட்டுக் கோப்புகளை வடிவம்-சார்ந்த பைப்லைன்களுக்கு அனுப்பி, மூல வடிவம் எதுவாக இருந்தாலும் ஒரே சீரான வடிவிலான DoclingDocument-ஐத் திருப்பித் தரும் Docling-இன் ஒற்றை நுழைவுப்புள்ளி வகுப்பு.
• DoclingDocument: Docling வெளியிடும் உள்ளடக்க உறுப்புகளின் (TextItem, SectionHeaderItem, TableItem, PictureItem) வகைப்படுத்தப்பட்ட மரம்; ஒவ்வொன்றும் grounding-க்காகப் பக்க எண் மற்றும் bounding box கொண்ட prov மெட்டாடேட்டாவைச் சுமந்து செல்கிறது.
• TableFormer: Docling-இன் அட்டவணை-அமைப்பு அடையாளம் காணும் மாடல்; அட்டவணைகள் நிறைந்த PDF-களில் பிரித்தெடுப்புத் துல்லியத்தை வேகத்திற்காகப் பரிமாறிக்கொள்ள TableFormerMode (FAST அல்லது ACCURATE) மூலம் உள்ளமைக்கக்கூடியது.
• PdfPipelineOptions: ஒரு DocumentConverter நிகழ்வில் OCR, அட்டவணை-அமைப்பு கண்டறிதல், பட அளவுமாற்றம் மற்றும் பிற PDF-சார்ந்த பிரித்தெடுப்பு நடத்தைகளை இயக்க/நிறுத்தும் ஒவ்வொரு வடிவத்திற்குமான உள்ளமைவு ஆப்ஜெக்ட்.
• ConversionStatus: convert_all() திருப்பித் தரும் ஒவ்வொரு ஆவணத்திற்குமான முடிவு (SUCCESS, PARTIAL_SUCCESS, FAILURE); இதனால் தொகுதி வேலைகள் ஒரே ஒரு மோசமான உள்ளீட்டில் நிறுத்தாமல் முடிவின் தரத்தின் அடிப்படையில் கிளைபிரியலாம்.

கருத்துகள்

Docling-இன் மதிப்பு என்னவென்றால், அது வடிவம்-சார்ந்த பார்சிங்கை ஒரே கன்வெர்ட்டர் மற்றும் ஒரே வெளியீட்டு ஸ்கீமாவின் பின்னால் மறைக்கிறது; அதனால் RAG பைப்லைனின் மீதமுள்ள பகுதியை ஒரே மர வடிவத்திற்கு எதிராக எழுதலாம். மூன்று கருத்துகள் இந்தப் பாடத்தை இயக்குகின்றன:

1. ஒரே உள்ளமைக்கப்பட்ட கன்வெர்ட்டர், பல வடிவங்கள். ஒரு DocumentConverter, ஒவ்வொரு InputFormat-க்கும் ஒரு பைப்லைனை (OCR அமைப்புகள், அட்டவணை-அமைப்பு பயன்முறை, பட அளவு) இணைக்கும் format_options map-உடன் ஒரு முறை துவக்கப்படுகிறது. பின்னர் அதே நிகழ்வு, அழைப்பவரின் கோடில் ஒவ்வொரு அழைப்பிற்கும் கிளைபிரியாமல் PDF, DOCX, HTML, PPTX மற்றும் பட உள்ளீடுகளைக் கையாளுகிறது.
2. தனிமைப்படுத்தப்பட்ட தோல்விகளுடன் தொகுதிச் செயலாக்கம். convert_all(..., raises_on_error=False) ஒவ்வொரு உள்ளீட்டிற்கும் ஒரு ConversionResult-ஐத் தருகிறது; இதனால் தவறாக உருவாக்கப்பட்ட PDF ஒன்று ConversionStatus.FAILURE ஆக வெளிப்படும்போது, தொகுதியின் மீதமுள்ள பகுதி தொடர்ந்து இயங்குகிறது — பெரிய அளவில் பலவகை ஆவணத் தொகுப்புகளை உள்வாங்கும்போது இது இன்றியமையாதது.
3. மூலத்தரவுடன் கூடிய ஒரு சீரான மரம். ஒவ்வொரு வெற்றிகரமான பிரித்தெடுப்பும் ஒரு DoclingDocument-ஐ உருவாக்குகிறது; அதன் iterate_items() நடை prov மெட்டாடேட்டாவுடன் கூடிய வகைப்படுத்தப்பட்ட முனைகளை (TextItem, SectionHeaderItem, TableItem, PictureItem) தருகிறது. கீழ்நிலை chunker-களும் retriever-களும் ஒரே வடிவத்தை நுகர்கின்றன, மேலும் மூலத்தரவு பதில்களுக்கு அவை வந்த சரியான பக்கம் மற்றும் bounding box-ஐ மேற்கோள் காட்ட அனுமதிக்கிறது.

கோட் வழிநடத்தல்

இந்த வழிநடத்தல் பைப்லைனின் இரண்டு கட்டங்களை அடுத்தடுத்து உள்ளடக்குகிறது. முதல் கட்டம் உள்ளமைக்கப்பட்ட DocumentConverter-ஐ உருவாக்கி, அதன் வழியாக ஒரு கலப்பு-வடிவத் தொகுதியை இயக்குகிறது; இரண்டாம் கட்டம் விளைவாகக் கிடைக்கும் DoclingDocument மரத்தில் உலாவி, மூல வடிவம் எதுவாக இருந்தாலும் கீழ்நிலை chunker-கள் சீரான அமைப்பைக் காணும் வகையில் தலைப்புப் படிநிலைகளை இயல்பாக்குகிறது.

கன்வெர்ட்டரை உள்ளமைத்தல் மற்றும் இயக்குதல்

கன்வெர்ட்டர் 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, accurate பயன்முறையில் TableFormer-ஐப் பயன்படுத்தும் அட்டவணை-அமைப்பு கண்டறிதல், மற்றும் 2× படத் தெளிவுத்திறன் அளவுமாற்றத்தை இயக்குகிறது. அதிக images_scale மதிப்புகள் சிறிய உரையில் OCR துல்லியத்தை மேம்படுத்துகின்றன, ஆனால் நினைவக நுகர்வையும் ஒவ்வொரு பக்கத்திற்குமான செயலாக்க நேரத்தையும் அதிகரிக்கின்றன.
• format_options dict உள்ளீட்டு வடிவங்களை வடிவம்-சார்ந்த பைப்லைன்களுக்கு map செய்கிறது. அதே கன்வெர்ட்டர் நிகழ்வை மற்ற உள்ளீடுகளுக்கும் விரிவுபடுத்த, InputFormat.DOCX அல்லது InputFormat.HTML உள்ளீடுகளை அவற்றின் சொந்த விருப்பங்களுடன் சேர்க்கவும்.
• convert_all(..., raises_on_error=False) ஒவ்வொரு ஆவணத்திற்கும் ஒரு ConversionResult-ஐத் தந்து, தோல்விகளைத் தனிமைப்படுத்துகிறது; அதனால் தவறாக உருவாக்கப்பட்ட ஒரு PDF தொகுதியை நிறுத்தாது. சுத்தமான பிரித்தெடுப்புகளைப் பகுதியளவு பிரித்தெடுப்புகளிலிருந்து வேறுபடுத்த ConversionStatus.{SUCCESS, PARTIAL_SUCCESS}-இன் அடிப்படையில் கிளைபிரியவும், மேலும் தலைப்பு நிலைகள், அட்டவணை வடிவமைப்பு மற்றும் படக் குறிப்புகள் பாதுகாக்கப்பட்ட நிலையில் ஆவண மரத்தைச் சீரியலைஸ் செய்ய export_to_markdown()-ஐ அழைக்கவும்.

வெளியீட்டில் உலாவுதல் மற்றும் வடிவங்களுக்கு இடையே இயல்பாக்குதல்

DoclingDocument ஆப்ஜெக்ட் உள்ளடக்கத்தை வகைப்படுத்தப்பட்ட உறுப்புகளின் மரமாக வெளிப்படுத்துகிறது. அந்த மரத்தில் நடப்பது, chunker-கள், embedder-கள் அல்லது evaluator-களுக்கு ஊட்டக்கூடிய தட்டையான, வகைப்படுத்தப்பட்ட தொகுதிகளின் பட்டியலைத் தருகிறது — மேலும் மரம் கையில் கிடைத்தவுடன், வடிவங்களுக்கு இடையே ஊடுருவும் அமைப்பு வேறுபாடுகளையும் (PDF எழுத்துரு-அளவு heuristics, DOCX தலைப்பு styles, <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 (படங்கள்) அடங்கும். ஒவ்வொரு உறுப்பும் பக்க எண், bounding box மற்றும் நம்பகத்தன்மை கொண்ட prov (மூலத்தரவு) மெட்டாடேட்டாவைச் சுமந்து செல்கிறது — மேற்கோள்கள், retrieval மற்றும் grounding-க்கு இது இன்றியமையாதது.
• அட்டவணைகள் சிறப்புக் கவனம் பெறுகின்றன: export_to_dataframe() Docling-இன் உள் அட்டவணைப் பிரதிநிதித்துவத்தை pandas DataFrame ஆக உருவாக்குகிறது; அதை நீங்கள் கீழ்நிலை நுகர்வோருக்காக JSON, CSV அல்லது Parquet ஆகச் சீரியலைஸ் செய்யலாம்.
• normalize_heading_levels பயன்படுத்தப்பட்ட குறைந்தபட்சத் தலைப்பு நிலையைக் கண்டறிய மரத்தை ஸ்கேன் செய்து, ஆவணம் h1-இல் தொடங்கும் வகையில் ஒவ்வொரு தலைப்பையும் கீழே நகர்த்துகிறது. இது அமைப்பு-உணர்வுள்ள chunking-ஐ வடிவங்களுக்கு இடையே நிர்ணயமானதாக ஆக்குகிறது — இது இல்லாமல், <h2>-இல் தொடங்கும் HTML பக்கமும் h1-இல் தொடங்கும் PDF-ம் நுட்பமாக வேறுபட்ட chunk எல்லைகளை உருவாக்குகின்றன.

convert_all() குறைந்தது ஒரு ConversionStatus.SUCCESS முடிவைத் திருப்பித் தரும்போது, extract_content_blocks(doc) நிரப்பப்பட்ட page மற்றும் bbox புலங்களுடன் TextItem மற்றும் SectionHeaderItem உள்ளீடுகளைக் கொண்ட காலியில்லாத பட்டியலைத் திருப்பித் தரும்போது, மேலும் normalize_heading_levels(doc) மூல வடிவம் எதுவாக இருந்தாலும் முதல் தலைப்பு நிலை 1 ஆக இருக்கும் ஆவணத்தை உருவாக்கும்போது, இது வேலை செய்கிறது என்பதை நீங்கள் அறிவீர்கள்.

துறைசார் பயன்பாடு

செய்ய வேண்டியவை மற்றும் செய்யக்கூடாதவை

இப்போது நீங்கள் செயல்படுத்தலை முழுமையாகக் கடந்து வந்திருப்பதால், கீழே உள்ள நடைமுறைகள் நீடித்த அணுகுமுறையை உடையக்கூடிய அணுகுமுறையிலிருந்து பிரித்துக் காட்டுகின்றன.

செய்ய வேண்டியவை

1. ஒவ்வொரு worker செயல்முறைக்கும் ஒரு DocumentConverter-ஐ துவக்கி, ஆவணங்களுக்கு இடையே அதை மீண்டும் பயன்படுத்தவும் — TableFormer மற்றும் OCR மாடல் ஏற்றுதல் முதல்-அழைப்பு தாமதத்தில் பெரும்பங்கு வகிக்கிறது; அதனால் ஒவ்வொரு அழைப்பிற்கும் உருவாக்குவது தொகுதி வேலைகளைப் பல மடங்கு மெதுவாக்குகிறது.
2. convert_all()-க்கு raises_on_error=False-ஐ அனுப்பி, ConversionStatus.{SUCCESS, PARTIAL_SUCCESS, FAILURE}-இன் அடிப்படையில் வெளிப்படையாகக் கிளைபிரியவும்; இதனால் சிதைந்த ஒரு PDF ஆயிரக்கணக்கான ஆவணங்களின் உள்வாங்கலை நிறுத்தாது.
3. chunker-கள் மற்றும் embedder-களுக்குத் தொகுதிகளை வெளியிடும்போது item.prov-ஐ (பக்க எண் மற்றும் bounding box) பாதுகாக்கவும் — கீழ்நிலை retrieval மற்றும் பதில்-grounding மேற்கோள்களுக்காக இதையே நம்பியுள்ளன.

செய்யக்கூடாதவை

1. அழைப்பவரின் கோடில் ஒவ்வொரு வடிவத்திற்கும் if pdf … elif docx … கிளைகளை எழுத வேண்டாம் — format_options-இல் வடிவம்-சார்ந்த PdfFormatOption / DocxFormatOption உள்ளீடுகளைப் பதிவு செய்து, convert()-ஐ polymorphic ஆக அழைக்கவும்.
2. இயல்பாக images_scale-ஐ 2–3-க்கு மேல் உயர்த்த வேண்டாம்; இது நினைவகத்தையும் ஒவ்வொரு பக்கத்திற்குமான நேரத்தையும் பெருக்குகிறது, மேலும் ஏற்கனவே படிக்கக்கூடிய உரையில் OCR துல்லியத்தை அரிதாகவே மேம்படுத்துகிறது.
3. ConversionStatus.PARTIAL_SUCCESS முடிவுகளை அமைதியாகக் கைவிட வேண்டாம் — result.errors-ஐ ஆய்வு செய்து, பகுதியளவு உள்ளடக்கம் பயன்படுத்தக்கூடியதா அல்லது தனிமைப்படுத்த வேண்டுமா என்பதை ஒவ்வொரு பைப்லைனுக்கும் தனியாக முடிவு செய்யவும்.