Docling ના unified multi-format parser નો ઉપયોગ કરીને documents extract કરો

પરિચય

રિટ્રીવલ-ઓગમેન્ટેડ જનરેશન પાઇપલાઇન બનાવતી ટીમો પહેલા દિવસે જ એક જ દીવાલ સાથે ટકરાય છે: દરેક ઇનપુટ ફોર્મેટ — PDF, DOCX, HTML, PPTX, સ્કેન કરેલી ઇમેજ — માટે તેનું પોતાનું પાર્સર, તેની પોતાની વિચિત્રતાઓ અને તેની પોતાની બગ સરફેસ જરૂરી હોય છે, અને તેમની આસપાસના રેપર્સ આઉટપુટ સ્કીમા પર ભાગ્યે જ સંમત થાય છે. Docling આ બધાને એક જ એક્સટ્રેક્શન ઇન્ટરફેસમાં સંકોચી દે છે જે હંમેશા એકસમાન આકારનું ટ્રી પરત કરે છે. આ લેયર ખોટું બને તો દરેક ડાઉનસ્ટ્રીમ કન્ઝ્યુમર (chunker, embedder, retriever, evaluator) એ અસંગતતા વારસામાં મેળવે છે, તેથી એક જ ખરાબ પાર્સર સંપૂર્ણ RAG સ્ટેકને ભ્રષ્ટ કરે છે. આ પાઠના અંત સુધીમાં તમે OCR અને ટેબલ ડિટેક્શન સાથે પ્રોડક્શન-ગ્રેડ PDF એક્સટ્રેક્શન માટે Docling ના DocumentConverter ને કન્ફિગર કરી શકશો, વ્યક્તિગત નિષ્ફળતાઓ પર અટક્યા વિના મિશ્ર-ફોર્મેટ બેચ પર તેને ચલાવી શકશો, અને ડાઉનસ્ટ્રીમ સ્ટેજ માટે કન્ટેન્ટ બ્લોક્સ, ટેબલ્સ અને પ્રોવેનન્સ મેટાડેટા બહાર કાઢવા માટે પરિણામી DoclingDocument ટ્રીમાં નેવિગેટ કરી શકશો.

મુખ્ય પરિભાષા

• DocumentConverter: Docling નો એકમાત્ર એન્ટ્રી-પોઇન્ટ ક્લાસ જે ઇનપુટ ફાઇલોને ફોર્મેટ-વિશિષ્ટ પાઇપલાઇન્સ તરફ મોકલે છે અને સ્રોત ફોર્મેટ ભલે કોઈ પણ હોય, એકસમાન આકારનું DoclingDocument પરત કરે છે.
• DoclingDocument: Docling દ્વારા ઉત્સર્જિત કન્ટેન્ટ એલિમેન્ટ્સ (TextItem, SectionHeaderItem, TableItem, PictureItem) નું ટાઇપ્ડ ટ્રી, જેમાં દરેક એલિમેન્ટ ગ્રાઉન્ડિંગ માટે પેજ નંબર અને બાઉન્ડિંગ બોક્સ સાથેનો prov મેટાડેટા ધરાવે છે.
• TableFormer: Docling નું ટેબલ-સ્ટ્રક્ચર રેકગ્નિશન મોડેલ, જે TableFormerMode (FAST અથવા ACCURATE) દ્વારા કન્ફિગર કરી શકાય છે, જેથી ટેબલ-ભારે PDF પર ઝડપ સામે એક્સટ્રેક્શન ફિડેલિટીનો સોદો કરી શકાય.
• 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) આપે છે. ડાઉનસ્ટ્રીમ chunkers અને retrievers એક જ આકાર વાપરે છે, અને પ્રોવેનન્સ જવાબોને તેઓ જે ચોક્કસ પેજ અને બાઉન્ડિંગ બોક્સમાંથી આવ્યા તેનો સંદર્ભ આપવા દે છે.

કોડ વોકથ્રૂ

આ વોકથ્રૂ પાઇપલાઇનના બે તબક્કાઓને એક પછી એક આવરી લે છે. પહેલો તબક્કો કન્ફિગર કરેલું DocumentConverter બનાવે છે અને તેના દ્વારા મિશ્ર-ફોર્મેટ બેચ ચલાવે છે; બીજો તબક્કો પરિણામી DoclingDocument ટ્રીમાં નેવિગેટ કરે છે અને હેડિંગ હાયરાર્કીને નોર્મલાઇઝ કરે છે, જેથી ડાઉનસ્ટ્રીમ chunkers સ્રોત ફોર્મેટ ભલે કોઈ પણ હોય, સુસંગત સ્ટ્રક્ચર જુએ.

કન્વર્ટરને કન્ફિગર કરવું અને ચલાવવું

કન્વર્ટર પ્રતિ-ફોર્મેટ પાઇપલાઇન વિકલ્પો લે છે જે 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 ઇનપુટ ફોર્મેટને ફોર્મેટ-વિશિષ્ટ પાઇપલાઇન્સ સાથે મેપ કરે છે. એ જ કન્વર્ટર ઇન્સ્ટન્સને અન્ય ઇનપુટ સુધી વિસ્તારવા માટે તેમના પોતાના વિકલ્પો સાથે InputFormat.DOCX અથવા InputFormat.HTML એન્ટ્રીઓ ઉમેરો.
• convert_all(..., raises_on_error=False) પ્રતિ-દસ્તાવેજ એક ConversionResult આપે છે અને નિષ્ફળતાઓને અલગ પાડે છે, જેથી એક ખોટી રીતે બનેલું PDF બેચને અટકાવે નહીં. સ્વચ્છ એક્સટ્રેક્શનને આંશિક એક્સટ્રેક્શનથી અલગ પાડવા માટે ConversionStatus.{SUCCESS, PARTIAL_SUCCESS} પર બ્રાન્ચ કરો, અને હેડિંગ લેવલ, ટેબલ ફોર્મેટિંગ અને ફિગર રેફરન્સ જાળવી રાખીને દસ્તાવેજ ટ્રીને સિરિયલાઇઝ કરવા માટે export_to_markdown() કોલ કરો.

આઉટપુટમાં નેવિગેટ કરવું અને ફોર્મેટ વચ્ચે નોર્મલાઇઝ કરવું

DoclingDocument ઓબ્જેક્ટ કન્ટેન્ટને ટાઇપ્ડ એલિમેન્ટ્સના ટ્રી તરીકે ખુલ્લું મૂકે છે. એ ટ્રી પર વોક કરવાથી તમને બ્લોક્સની એક સપાટ, ટાઇપ્ડ યાદી મળે છે જે તમે chunkers, embedders અથવા evaluators ને આપી શકો — અને એક વાર ટ્રી હાથમાં આવે, પછી તમે ફોર્મેટ વચ્ચે ઘૂસી આવતા સ્ટ્રક્ચરલ તફાવતો (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. chunkers અને embedders ને બ્લોક્સ મોકલતી વખતે item.prov (પેજ નંબર અને બાઉન્ડિંગ બોક્સ) જાળવી રાખો — ડાઉનસ્ટ્રીમ રિટ્રીવલ અને જવાબ-ગ્રાઉન્ડિંગ સાઇટેશન માટે તેના પર આધાર રાખે છે.

શું ન કરવું

1. કોલર કોડમાં પ્રતિ-ફોર્મેટ if pdf … elif docx … બ્રાન્ચ ન લખો — format_options માં ફોર્મેટ-વિશિષ્ટ PdfFormatOption / DocxFormatOption એન્ટ્રીઓ રજિસ્ટર કરો અને convert() ને પોલિમોર્ફિક રીતે કોલ કરો.
2. ડિફૉલ્ટ રૂપે images_scale ને 2–3 થી ઉપર ન વધારો; તે મેમરી અને પ્રતિ-પેજ સમયને અનેક ગણો વધારે છે, અને પહેલેથી વાંચી શકાય તેવા ટેક્સ્ટ પર OCR ફિડેલિટી ભાગ્યે જ સુધારે છે.
3. ConversionStatus.PARTIAL_SUCCESS પરિણામોને શાંતિથી છોડી ન દો — result.errors તપાસો અને દરેક પાઇપલાઇન માટે નક્કી કરો કે આંશિક કન્ટેન્ટ વાપરી શકાય તેવું છે કે તેને ક્વોરન્ટાઇન કરવું જોઈએ.