Khaitan

Khaitan

1635843087

पायथन में टेक्स्ट का रंग कैसे बदलें

विभिन्न रंगों (जैसे लाल, हरा और नीला) के साथ रंगीन टेक्स्ट प्रिंट करने के लिए कलरमा लाइब्रेरी का उपयोग करना सीखें और पायथन में अग्रभूमि और चमक में।

फैंसी स्कैनिंग स्क्रिप्ट बनाने से लेकर आपके कार्यक्रमों में विभिन्न लॉग संदेश प्रकारों (डीबग, जानकारी, या महत्वपूर्ण, आदि) को अलग करने के लिए विभिन्न रंगों में कंसोल पर प्रिंट करना बहुत आसान और काफी व्यावहारिक है। इस ट्यूटोरियल में, आप सीखेंगे कि आप coloramaलाइब्रेरी का उपयोग करके पायथन में रंगीन टेक्स्ट कैसे प्रिंट कर सकते हैं ।

हम उपयोग करेंगे colorama, आइए पहले इसे स्थापित करें:

$ pip install colorama

इसके बाद, एक नई पायथन फ़ाइल खोलें, और निम्नलिखित लिखें:

from colorama import init, Fore, Back, Style

# essential for Windows environment
init()
# all available foreground colors
FORES = [ Fore.BLACK, Fore.RED, Fore.GREEN, Fore.YELLOW, Fore.BLUE, Fore.MAGENTA, Fore.CYAN, Fore.WHITE ]
# all available background colors
BACKS = [ Back.BLACK, Back.RED, Back.GREEN, Back.YELLOW, Back.BLUE, Back.MAGENTA, Back.CYAN, Back.WHITE ]
# brightness values
BRIGHTNESS = [ Style.DIM, Style.NORMAL, Style.BRIGHT ]

सबसे पहले, हम init()फ़ंक्शन को कॉल करते हैं, जो coloramaठीक से काम करने के लिए विंडोज वातावरण पर आवश्यक है, यह अन्य प्लेटफार्मों पर कुछ नहीं करता है, इसलिए आप इसे हटा सकते हैं।

दूसरा, हम FORESसूची में सभी उपलब्ध अग्रभूमि रंगों को परिभाषित करते हैं , और BACKSसूची में पृष्ठभूमि के रंग , हम BRIGHTNESSविभिन्न चमक सेटिंग के लिए सूची को भी परिभाषित करते हैं ।

अगला, आइए एक ऐसा फ़ंक्शन बनाएं जो नियमित पायथन के print()फ़ंक्शन को लपेटता है , लेकिन रंग और चमक सेट करने की क्षमता के साथ:

def print_with_color(s, color=Fore.WHITE, brightness=Style.NORMAL, **kwargs):
    """Utility function wrapping the regular `print()` function 
    but with colors and brightness"""
    print(f"{brightness}{color}{s}{Style.RESET_ALL}", **kwargs)

हम बस print()अंदर का उपयोग करते हैं, लेकिन चमक और रंग कोड के साथ पाठ को तैयार करते हैं, और Style.RESET_ALLअंत में हर बार जब हम फ़ंक्शन का उपयोग करते हैं तो डिफ़ॉल्ट रंग और चमक पर रीसेट करने के लिए जोड़ते हैं ।

हम पास भी करते हैं **kwargsताकि हम अन्य print()फ़ंक्शन के कीवर्ड तर्कों का उपयोग कर सकें , जैसे endऔर sep

अब जब हमारे पास अपना कार्य है, तो आइए सभी अग्रभूमि रंगों का उपयोग करें और एक ही टेक्स्ट को अलग-अलग रंगों और प्रत्येक को अलग-अलग चमक के साथ प्रिंट करें:

# printing all available foreground colors with different brightness
for fore in FORES:
    for brightness in BRIGHTNESS:
        print_with_color("Hello world!", color=fore, brightness=brightness)

यह निम्न छवि में जैसा दिखेगा:

पायथन में विभिन्न रंगों के साथ एक ही पाठ

काला दिखाई नहीं दे रहा है, क्योंकि टर्मिनल की पृष्ठभूमि का रंग भी काला है, यहाँ एक अलग पृष्ठभूमि रंग है:

पायथन में विभिन्न रंगों के साथ एक ही पाठ

आइए अब पृष्ठभूमि रंगों का उपयोग करें:

# printing all available foreground and background colors with different brightness
for fore in FORES:
    for back in BACKS:
        for brightness in BRIGHTNESS:
            print_with_color("A", color=back+fore, brightness=brightness, end=' ')
    print()

आप एक ही समय में पृष्ठभूमि और अग्रभूमि का रंग बदल सकते हैं, इसलिए हम अग्रभूमि रंगों पर भी पुनरावृति कर रहे हैं, यह कैसा दिखेगा:

पायथन में Colorama के साथ विभिन्न पृष्ठभूमि रंग

निष्कर्ष

इतना ही! अब आप सभी उपलब्ध अग्रभूमि और पृष्ठभूमि रंगों के साथ-साथ coloramaपायथन में पुस्तकालय में चमक मूल्यों को जानते हैं । मुझे आशा है कि यह आपके लिए अपनी परियोजनाओं के लिए जानकारी और कॉपी कोड को जल्दी से समझने में मददगार था।

#python 

What is GEEK

Buddha Community

पायथन में टेक्स्ट का रंग कैसे बदलें
Khaitan

Khaitan

1635843087

पायथन में टेक्स्ट का रंग कैसे बदलें

विभिन्न रंगों (जैसे लाल, हरा और नीला) के साथ रंगीन टेक्स्ट प्रिंट करने के लिए कलरमा लाइब्रेरी का उपयोग करना सीखें और पायथन में अग्रभूमि और चमक में।

फैंसी स्कैनिंग स्क्रिप्ट बनाने से लेकर आपके कार्यक्रमों में विभिन्न लॉग संदेश प्रकारों (डीबग, जानकारी, या महत्वपूर्ण, आदि) को अलग करने के लिए विभिन्न रंगों में कंसोल पर प्रिंट करना बहुत आसान और काफी व्यावहारिक है। इस ट्यूटोरियल में, आप सीखेंगे कि आप coloramaलाइब्रेरी का उपयोग करके पायथन में रंगीन टेक्स्ट कैसे प्रिंट कर सकते हैं ।

हम उपयोग करेंगे colorama, आइए पहले इसे स्थापित करें:

$ pip install colorama

इसके बाद, एक नई पायथन फ़ाइल खोलें, और निम्नलिखित लिखें:

from colorama import init, Fore, Back, Style

# essential for Windows environment
init()
# all available foreground colors
FORES = [ Fore.BLACK, Fore.RED, Fore.GREEN, Fore.YELLOW, Fore.BLUE, Fore.MAGENTA, Fore.CYAN, Fore.WHITE ]
# all available background colors
BACKS = [ Back.BLACK, Back.RED, Back.GREEN, Back.YELLOW, Back.BLUE, Back.MAGENTA, Back.CYAN, Back.WHITE ]
# brightness values
BRIGHTNESS = [ Style.DIM, Style.NORMAL, Style.BRIGHT ]

सबसे पहले, हम init()फ़ंक्शन को कॉल करते हैं, जो coloramaठीक से काम करने के लिए विंडोज वातावरण पर आवश्यक है, यह अन्य प्लेटफार्मों पर कुछ नहीं करता है, इसलिए आप इसे हटा सकते हैं।

दूसरा, हम FORESसूची में सभी उपलब्ध अग्रभूमि रंगों को परिभाषित करते हैं , और BACKSसूची में पृष्ठभूमि के रंग , हम BRIGHTNESSविभिन्न चमक सेटिंग के लिए सूची को भी परिभाषित करते हैं ।

अगला, आइए एक ऐसा फ़ंक्शन बनाएं जो नियमित पायथन के print()फ़ंक्शन को लपेटता है , लेकिन रंग और चमक सेट करने की क्षमता के साथ:

def print_with_color(s, color=Fore.WHITE, brightness=Style.NORMAL, **kwargs):
    """Utility function wrapping the regular `print()` function 
    but with colors and brightness"""
    print(f"{brightness}{color}{s}{Style.RESET_ALL}", **kwargs)

हम बस print()अंदर का उपयोग करते हैं, लेकिन चमक और रंग कोड के साथ पाठ को तैयार करते हैं, और Style.RESET_ALLअंत में हर बार जब हम फ़ंक्शन का उपयोग करते हैं तो डिफ़ॉल्ट रंग और चमक पर रीसेट करने के लिए जोड़ते हैं ।

हम पास भी करते हैं **kwargsताकि हम अन्य print()फ़ंक्शन के कीवर्ड तर्कों का उपयोग कर सकें , जैसे endऔर sep

अब जब हमारे पास अपना कार्य है, तो आइए सभी अग्रभूमि रंगों का उपयोग करें और एक ही टेक्स्ट को अलग-अलग रंगों और प्रत्येक को अलग-अलग चमक के साथ प्रिंट करें:

# printing all available foreground colors with different brightness
for fore in FORES:
    for brightness in BRIGHTNESS:
        print_with_color("Hello world!", color=fore, brightness=brightness)

यह निम्न छवि में जैसा दिखेगा:

पायथन में विभिन्न रंगों के साथ एक ही पाठ

काला दिखाई नहीं दे रहा है, क्योंकि टर्मिनल की पृष्ठभूमि का रंग भी काला है, यहाँ एक अलग पृष्ठभूमि रंग है:

पायथन में विभिन्न रंगों के साथ एक ही पाठ

आइए अब पृष्ठभूमि रंगों का उपयोग करें:

# printing all available foreground and background colors with different brightness
for fore in FORES:
    for back in BACKS:
        for brightness in BRIGHTNESS:
            print_with_color("A", color=back+fore, brightness=brightness, end=' ')
    print()

आप एक ही समय में पृष्ठभूमि और अग्रभूमि का रंग बदल सकते हैं, इसलिए हम अग्रभूमि रंगों पर भी पुनरावृति कर रहे हैं, यह कैसा दिखेगा:

पायथन में Colorama के साथ विभिन्न पृष्ठभूमि रंग

निष्कर्ष

इतना ही! अब आप सभी उपलब्ध अग्रभूमि और पृष्ठभूमि रंगों के साथ-साथ coloramaपायथन में पुस्तकालय में चमक मूल्यों को जानते हैं । मुझे आशा है कि यह आपके लिए अपनी परियोजनाओं के लिए जानकारी और कॉपी कोड को जल्दी से समझने में मददगार था।

#python 

Khaitan

Khaitan

1633944819

पायथन में पीडीएफ को इमेज में कैसे बदलें

पाइथन में प्रति पृष्ठ अलग-अलग छवियों में पीडीएफ फाइलों को परिवर्तित करने के लिए PyMuPDF लाइब्रेरी का उपयोग करना सीखें।

इस ट्यूटोरियल का उद्देश्य पीडीएफ फाइलों को छवियों में बदलने के लिए पायथन में एक हल्का कमांड-लाइन टूल विकसित करना है।

हम PyMuPDF का उपयोग करेंगे , एक अत्यधिक बहुमुखी, अनुकूलन योग्य PDF, XPS, और eBook दुभाषिया समाधान जिसका उपयोग PDF रेंडरर, व्यूअर, या टूलकिट जैसे अनुप्रयोगों की एक विस्तृत श्रृंखला में किया जा सकता है।

सबसे पहले, आवश्यक पुस्तकालय स्थापित करें:

$ pip install PyMuPDF==1.18.9

पुस्तकालयों का आयात:

import fitz

from typing import Tuple
import os

आइए हमारे मुख्य उपयोगिता फ़ंक्शन को परिभाषित करें:

def convert_pdf2img(input_file: str, pages: Tuple = None):
    """Converts pdf to image and generates a file by page"""
    # Open the document
    pdfIn = fitz.open(input_file)
    output_files = []
    # Iterate throughout the pages
    for pg in range(pdfIn.pageCount):
        if str(pages) != str(None):
            if str(pg) not in str(pages):
                continue
        # Select a page
        page = pdfIn[pg]
        rotate = int(0)
        # PDF Page is converted into a whole picture 1056*816 and then for each picture a screenshot is taken.
        # zoom = 1.33333333 -----> Image size = 1056*816
        # zoom = 2 ---> 2 * Default Resolution (text is clear, image text is hard to read)    = filesize small / Image size = 1584*1224
        # zoom = 4 ---> 4 * Default Resolution (text is clear, image text is barely readable) = filesize large
        # zoom = 8 ---> 8 * Default Resolution (text is clear, image text is readable) = filesize large
        zoom_x = 2
        zoom_y = 2
        # The zoom factor is equal to 2 in order to make text clear
        # Pre-rotate is to rotate if needed.
        mat = fitz.Matrix(zoom_x, zoom_y).preRotate(rotate)
        pix = page.getPixmap(matrix=mat, alpha=False)
        output_file = f"{os.path.splitext(os.path.basename(input_file))[0]}_page{pg+1}.png"
        pix.writePNG(output_file)
        output_files.append(output_file)
    pdfIn.close()
    summary = {
        "File": input_file, "Pages": str(pages), "Output File(s)": str(output_files)
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return output_files

उपरोक्त फ़ंक्शन एक पीडीएफ फाइल को इमेज फाइलों की एक श्रृंखला में परिवर्तित करता है। यह चयनित पृष्ठों के माध्यम से पुनरावृति करता है (डिफ़ॉल्ट उनमें से सभी है), वर्तमान पृष्ठ का एक स्क्रीनशॉट लेता है, और writePNG()विधि का उपयोग करके एक छवि फ़ाइल बनाता है ।

आप ज़ूम फ़ैक्टर को बदलने zoom_xऔर zoom_yबदलने के लिए, rotateअपनी आवश्यकताओं के अनुरूप इन मापदंडों और चर को बदलने के लिए स्वतंत्र महसूस कर सकते हैं।

आइए अब इस फ़ंक्शन का उपयोग करें:

if __name__ == "__main__":
    import sys
    input_file = sys.argv[1]
    convert_pdf2img(input_file)

आइए एक बहु-पृष्ठ पीडीएफ फाइल पर स्क्रिप्ट का परीक्षण करें (इसे यहां प्राप्त करें ):

$ python convert_pdf2image.py bert-paper.pdf

आउटपुट निम्न के रूप में होगा:

## Summary ########################################################
File:bert-paper.pdf
Pages:None
Output File(s):['bert-paper_page1.png', 'bert-paper_page2.png', 'bert-paper_page3.png', 'bert-paper_page4.png', 'bert-paper_page5.png', 'bert-paper_page6.png', 'bert-paper_page7.png', 'bert-paper_page8.png', 'bert-paper_page9.png', 'bert-paper_page10.png', 'bert-paper_page11.png', 'bert-paper_page12.png', 'bert-paper_page13.png', 'bert-paper_page14.png', 'bert-paper_page15.png', 'bert-paper_page16.png']
###################################################################

और वास्तव में, छवियों को सफलतापूर्वक उत्पन्न किया गया था:

एक पीडीएफ फाइल को कई छवियों में बदलने का परिणामनिष्कर्ष

हम आशा करते हैं कि आपको यह ट्यूटोरियल आपकी आवश्यकताओं के लिए उपयोगी लगेगा

#python #pdf

Khaitan

Khaitan

1634545297

पायथन में पीडीएफ को डॉक्स में कैसे बदलें

जानें कि आप pdf2docx लाइब्रेरी का उपयोग कैसे कर सकते हैं ताकि आप पीडीएफ फाइलों को पायथन में docx वर्ड फाइल में बदल सकें

इस ट्यूटोरियल में, हम देखेंगे कि कैसे हम पीडीएफ फाइलों को docx एक्सटेंशन में बदलने के लिए pdf2docx लाइब्रेरी का उपयोग कर सकते हैं ।

इस ट्यूटोरियल का लक्ष्य एक फ़ोल्डर के भीतर स्थित पीडीएफ फाइलों के एक या संग्रह को परिवर्तित करने के लिए पाइथन पारिस्थितिकी तंत्र के बाहर बाहरी उपयोगिताओं पर भरोसा किए बिना पाइथन-आधारित मॉड्यूल के माध्यम से हल्के कमांड-लाइन-आधारित उपयोगिता विकसित करना है।

pdf2docx , PyMuPDF के साथ PDF से डेटा निकालने , नियमों के साथ लेआउट को पार्स करने और python-docx के साथ docx फ़ाइल जेनरेट करने के लिए एक पायथन लाइब्रेरी है । python-docx एक अन्य पुस्तकालय है जिसका उपयोग pdf2docx द्वारा Microsoft Word (.docx) फ़ाइलों को बनाने और अद्यतन करने के लिए किया जाता है ।

आवश्यकताओं में जा रहे हैं:

$ pip install pdf2docx==0.5.1

आइए मॉड्यूल आयात करके शुरू करें:

# Import Libraries
from pdf2docx import parse
from typing import Tuple

आइए पीडीएफ को डॉक्स में बदलने के लिए जिम्मेदार फ़ंक्शन को परिभाषित करें:

def convert_pdf2docx(input_file: str, output_file: str, pages: Tuple = None):
    """Converts pdf to docx"""
    if pages:
        pages = [int(i) for i in list(pages) if i.isnumeric()]
    result = parse(pdf_file=input_file,
                   docx_with_path=output_file, pages=pages)
    summary = {
        "File": input_file, "Pages": str(pages), "Output File": output_file
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return result

convert_pdf2docx()समारोह में यह एक Docx फ़ाइल में एक पीडीएफ फाइल में कनवर्ट करता है और अंत में रूपांतरण प्रक्रिया का सारांश प्रिंट, आप कन्वर्ट करने के लिए पृष्ठों की एक श्रेणी निर्दिष्ट करने की अनुमति देता है।

आइए अब इसका इस्तेमाल करें:

if __name__ == "__main__":
    import sys
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    convert_pdf2docx(input_file, output_file)

कमांड-लाइन तर्कों से इनपुट और आउटपुट फ़ाइल नाम प्राप्त करने के लिए हम केवल पायथन के अंतर्निहित sys मॉड्यूल का उपयोग करते हैं। आइए एक नमूना पीडीएफ फाइल को कन्वर्ट करने का प्रयास करें (इसे यहां प्राप्त करें ):

$ python convert_pdf2docx.py letter.pdf letter.docx

letter.docxवर्तमान निर्देशिका में एक नई फ़ाइल दिखाई देगी, और आउटपुट इस तरह होगा:

Parsing Page 1: 1/1...
Creating Page 1: 1/1...
--------------------------------------------------
Terminated in 0.10869679999999998s.
## Summary ########################################################
File:letter.pdf
Pages:None
Output File:letter.docx
###################################################################

आप convert_pdf2docx()फ़ंक्शन में इच्छित पृष्ठ भी निर्दिष्ट कर सकते हैं ।

मुझे आशा है कि आपको यह संक्षिप्त ट्यूटोरियल पसंद आया होगा और आपको यह कनवर्टर उपयोगी लगा होगा।

#python 

Khaitan

Khaitan

1635394893

पायथन में ट्रांसफॉर्मर का उपयोग करके BERT को प्रीट्रेन कैसे करें

जानें कि आप पाइथन में हगिंगफेस ट्रांसफॉर्मर्स लाइब्रेरी का उपयोग करके अपने कस्टम डेटासेट पर मास्क्ड लैंग्वेज मॉडलिंग (एमएलएम) कार्य पर बीईआरटी और अन्य ट्रांसफॉर्मर को कैसे दिखा सकते हैं।

एक पूर्व-प्रशिक्षित मॉडल एक ऐसा मॉडल है जिसे पहले बड़े डेटासेट पर प्रशिक्षित किया गया था और प्रत्यक्ष उपयोग या फ़ाइन-ट्यूनिंग के लिए सहेजा गया था । इस ट्यूटोरियल में, आप सीखेंगे कि आप पायथन में हगिंगफेस ट्रांसफॉर्मर लाइब्रेरी की मदद से अपने कस्टम टेक्स्ट डेटासेट पर BERT (या किसी अन्य ट्रांसफॉर्मर मॉडल) को कैसे प्रीट्रेन कर सकते हैं।

आरंभ करने के लिए, हमें 3 पुस्तकालय स्थापित करने की आवश्यकता है:

$ pip install datasets transformers==4.11.2 sentencepiece

यदि आप साथ चलना चाहते हैं, तो एक नई नोटबुक, या पायथन फ़ाइल खोलें और आवश्यक पुस्तकालयों को आयात करें:

from datasets import *
from transformers import *
from tokenizers import *
import os
import json

डेटासेट चुनना

यदि आप एक ट्रांसफॉर्मर को पूर्व-प्रशिक्षित करने के इच्छुक हैं, तो आपके पास एक कस्टम डेटासेट होने की सबसे अधिक संभावना है। लेकिन इस ट्यूटोरियल में प्रदर्शन उद्देश्यों के लिए, हम cc_newsडेटासेट का उपयोग करने जा रहे हैं , हम उसके लिए हगिंगफेस डेटासेट लाइब्रेरी का उपयोग करेंगे । परिणामस्वरूप, अपने कस्टम डेटासेट को लाइब्रेरी में लोड करने के लिए इस लिंक का अनुसरण करना सुनिश्चित करें ।

CC-News डेटासेट में दुनिया भर की समाचार साइटों के समाचार लेख होते हैं। इसमें जनवरी 2017 और दिसंबर 2019 के बीच प्रकाशित अंग्रेजी में 708,241 समाचार लेख शामिल हैं ।

डेटासेट डाउनलोड करना और तैयार करना:

# download and prepare cc_news dataset
dataset = load_dataset("cc_news", split="train")

डेटासेट में केवल एक विभाजन है, इसलिए हमें इसे प्रशिक्षण और परीक्षण सेट में विभाजित करने की आवश्यकता है:

# split the dataset into training (90%) and testing (10%)
d = dataset.train_test_split(test_size=0.1)
d["train"], d["test"]

आप seedपैरामीटर को train_test_split()विधि में भी पास कर सकते हैं ताकि यह कई बार चलने के बाद एक ही सेट हो।

आउटपुट:

(Dataset({
     features: ['title', 'text', 'domain', 'date', 'description', 'url', 'image_url'],
     num_rows: 637416
 }), Dataset({
     features: ['title', 'text', 'domain', 'date', 'description', 'url', 'image_url'],
     num_rows: 70825
 }))

आइए देखें कि यह कैसा दिखता है:

for t in d["train"]["text"][:3]:
  print(t)
  print("="*50)

आउटपुट (छीन):

Pretty sure women wish men did this better too!!
Q: A recent survey showed that 1/3 of men wish they did THIS better. What is...<STRIPPED>
==================================================
× GoDaddy boots neo-Nazi site after a derogatory story on the Charlottesville victim
The Daily Stormer, a white supremacist and neo-Nazi website,...<STRIPPED>
==================================================
French bank Natixis under investigation over subprime losses
PARIS, Feb 15 Natixis has been placed under formal investigation...<STRIPPED>

जैसा कि पहले उल्लेख किया गया है, यदि आपके पास अपना कस्टम डेटासेट है, तो आप या तो ऊपर के रूप में लोड करने के लिए अपने डेटासेट को सेट करने के लिंक का अनुसरण कर सकते हैं, या आप LineByLineTextDatasetकक्षा का उपयोग कर सकते हैं यदि आपका कस्टम डेटासेट एक टेक्स्ट फ़ाइल है जहां सभी वाक्य एक नए द्वारा अलग किए गए हैं रेखा।

हालांकि, उपयोग करने से बेहतर तरीका यह LineByLineTextDatasetहै कि आप अपने कस्टम डेटासेट को सेट करें, splitकमांड या किसी अन्य पायथन कोड का उपयोग करके अपनी टेक्स्ट फ़ाइल को कई चंक फाइलों में विभाजित करें , और load_dataset()जैसा कि हमने ऊपर किया था, वैसे ही लोड करें:

# if you have huge custom dataset separated into files
# load the splitted files
files = ["train1.txt", "train2.txt"] # train3.txt, etc.
dataset = load_dataset("text", data_files=files, split="train")

यदि आपके पास अपना कस्टम डेटा एक विशाल फ़ाइल के रूप में है, तो आपको फ़ंक्शन splitका उपयोग करके उन्हें लोड करने से पहले इसे मुट्ठी भर टेक्स्ट फ़ाइलों (जैसे कि लिनक्स या कोलाब पर कमांड का उपयोग करना) में विभाजित करना चाहिए load_dataset(), क्योंकि यदि यह मेमोरी से अधिक हो जाता है तो रनटाइम क्रैश हो जाएगा। .

टोकनिज़र का प्रशिक्षण

इसके बाद, हमें अपने टोकननाइज़र को प्रशिक्षित करने की आवश्यकता है। ऐसा करने के लिए, हमें अपने डेटासेट को टेक्स्ट फाइलों में लिखना होगा, क्योंकि टोकननाइज़र लाइब्रेरी को इनपुट की आवश्यकता होती है:

# if you want to train the tokenizer from scratch (especially if you have custom
# dataset loaded as datasets object), then run this cell to save it as files
# but if you already have your custom data as text files, there is no point using this
def dataset_to_text(dataset, output_filename="data.txt"):
  """Utility function to save dataset text to disk,
  useful for using the texts to train the tokenizer 
  (as the tokenizer accepts files)"""
  with open(output_filename, "w") as f:
    for t in dataset["text"]:
      print(t, file=f)

# save the training set to train.txt
dataset_to_text(d["train"], "train.txt")
# save the testing set to test.txt
dataset_to_text(d["test"], "test.txt")

उपरोक्त कोड सेल का मुख्य उद्देश्य डेटासेट ऑब्जेक्ट को टेक्स्ट फाइल के रूप में सहेजना है। यदि आपके पास पहले से ही टेक्स्ट फ़ाइल के रूप में आपका डेटासेट है, तो आपको इस चरण को छोड़ देना चाहिए। अगला, आइए कुछ मापदंडों को परिभाषित करें:

special_tokens = [
  "[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]", "<S>", "<T>"
]
# if you want to train the tokenizer on both sets
# files = ["train.txt", "test.txt"]
# training the tokenizer on the training set
files = ["train.txt"]
# 30,522 vocab is BERT's default vocab size, feel free to tweak
vocab_size = 30_522
# maximum sequence length, lowering will result to faster training (when increasing batch size)
max_length = 512
# whether to truncate
truncate_longer_samples = True

filesसूची प्रशिक्षण के लिए टोकननाइज़र को पास करने के लिए फ़ाइलों की सूची है। vocab_sizeटोकन का शब्दावली आकार है। max_lengthअधिकतम अनुक्रम लंबाई है। आइए अब टोकननाइज़र को प्रशिक्षित करें:

# initialize the WordPiece tokenizer
tokenizer = BertWordPieceTokenizer()
# train the tokenizer
tokenizer.train(files=files, vocab_size=vocab_size, special_tokens=special_tokens)
# enable truncation up to the maximum 512 tokens
tokenizer.enable_truncation(max_length=max_length)

चूंकि यह BERT है, डिफ़ॉल्ट टोकननाइज़र WordPiece है । नतीजतन, हम लाइब्रेरी BertWordPieceTokenizer()से टोकननाइज़र क्लास को इनिशियलाइज़ करते हैं tokenizersऔर train()इसे प्रशिक्षित करने के लिए विधि का उपयोग करते हैं । आइए इसे अभी सेव करें:

model_path = "pretrained-bert"
# make the directory if not already there
if not os.path.isdir(model_path):
  os.mkdir(model_path)
# save the tokenizer  
tokenizer.save_model(model_path)
# dumping some of the tokenizer config to config file, 
# including special tokens, whether to lower case and the maximum sequence length
with open(os.path.join(model_path, "config.json"), "w") as f:
  tokenizer_cfg = {
      "do_lower_case": True,
      "unk_token": "[UNK]",
      "sep_token": "[SEP]",
      "pad_token": "[PAD]",
      "cls_token": "[CLS]",
      "mask_token": "[MASK]",
      "model_max_length": max_length,
      "max_len": max_length,
  }
  json.dump(tokenizer_cfg, f)

tokenizer.save_model()विधि है कि रास्ते में शब्दावली फ़ाइल की बचत होती है, हम भी मैन्युअल रूप से इस तरह के विशेष टोकन के रूप में कुछ tokenizer विन्यास, बचाने:

  • unk_token: एक विशेष टोकन जो एक आउट-ऑफ-शब्दावली टोकन का प्रतिनिधित्व करता है, भले ही टोकननाइज़र एक वर्डपीस टोकननाइज़र है, unkटोकन असंभव नहीं हैं, लेकिन दुर्लभ हैं।
  • sep_token: एक विशेष टोकन जो एक ही इनपुट में दो अलग-अलग वाक्यों को अलग करता है।
  • pad_token: एक विशेष टोकन जिसका उपयोग वाक्यों को भरने के लिए किया जाता है जो अधिकतम अनुक्रम लंबाई तक नहीं पहुंचते हैं (क्योंकि टोकन की सरणियों का आकार समान होना चाहिए)।
  • cls_token: इनपुट के वर्ग का प्रतिनिधित्व करने वाला एक विशेष टोकन।
  • mask_token: यह वह मुखौटा टोकन है जिसका उपयोग हम नकाबपोश भाषा मॉडलिंग (एमएलएम) पूर्व-प्रशिक्षण कार्य के लिए करते हैं।

टोकननाइज़र का प्रशिक्षण पूरा होने के बाद (इसमें कई मिनट लगने चाहिए), आइए इसे अभी लोड करें:

# when the tokenizer is trained and configured, load it as BertTokenizerFast
tokenizer = BertTokenizerFast.from_pretrained(model_path)

डेटासेट को टोकन करना

अब जब हमारे पास टोकननाइज़र तैयार है, तो नीचे दिया गया कोड डेटासेट को टोकन करने के लिए ज़िम्मेदार है:

def encode_with_truncation(examples):
  """Mapping function to tokenize the sentences passed with truncation"""
  return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=max_length, return_special_tokens_mask=True)

def encode_without_truncation(examples):
  """Mapping function to tokenize the sentences passed without truncation"""
  return tokenizer(examples["text"], return_special_tokens_mask=True)

# the encode function will depend on the truncate_longer_samples variable
encode = encode_with_truncation if truncate_longer_samples else encode_without_truncation

# tokenizing the train dataset
train_dataset = d["train"].map(encode, batched=True)
# tokenizing the testing dataset
test_dataset = d["test"].map(encode, batched=True)
if truncate_longer_samples:
  # remove other columns and set input_ids and attention_mask as 
  train_dataset.set_format(type="torch", columns=["input_ids", "attention_mask"])
  test_dataset.set_format(type="torch", columns=["input_ids", "attention_mask"])
else:
  test_dataset.set_format(columns=["input_ids", "attention_mask", "special_tokens_mask"])
  train_dataset.set_format(columns=["input_ids", "attention_mask", "special_tokens_mask"])
train_dataset, test_dataset

encodeहमारे डेटासेट को टोकन करने के लिए हम जिस कॉलबैक का उपयोग करते हैं, वह truncate_longer_samplesबूलियन वैरिएबल पर निर्भर करता है । यदि सेट किया जाता है True, तो हम अधिकतम अनुक्रम लंबाई ( max_lengthपैरामीटर) से अधिक वाक्यों को काट देते हैं । अन्यथा, हम नहीं।

अगला, पर सेट truncate_longer_samplesकरने के मामले में False, हमें अपने असंबद्ध नमूनों को एक साथ जोड़ने और उन्हें निश्चित आकार के वैक्टर में काटने की आवश्यकता है क्योंकि मॉडल प्रशिक्षण के दौरान एक निश्चित आकार के अनुक्रम की अपेक्षा करता है:

# Main data processing function that will concatenate all texts from our dataset and generate chunks of
# max_seq_length.
def group_texts(examples):
    # Concatenate all texts.
    concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}
    total_length = len(concatenated_examples[list(examples.keys())[0]])
    # We drop the small remainder, we could add padding if the model supported it instead of this drop, you can
    # customize this part to your needs.
    if total_length >= max_length:
        total_length = (total_length // max_length) * max_length
    # Split by chunks of max_len.
    result = {
        k: [t[i : i + max_length] for i in range(0, total_length, max_length)]
        for k, t in concatenated_examples.items()
    }
    return result
# Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a
# remainder for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value
# might be slower to preprocess.
#
# To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
# https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
if not truncate_longer_samples:
  train_dataset = train_dataset.map(group_texts, batched=True, batch_size=2_000,
                                    desc=f"Grouping texts in chunks of {max_length}")
  test_dataset = test_dataset.map(group_texts, batched=True, batch_size=2_000,
                                  num_proc=4, desc=f"Grouping texts in chunks of {max_length}")

उपरोक्त अधिकांश कोड run_mlm.pyस्क्रिप्ट से हगिंगफेस ट्रांसफॉर्मर उदाहरणों से लाए गए थे , इसलिए यह वास्तव में पुस्तकालय द्वारा ही उपयोग किया जाता है।

यदि आप सभी पाठों को संयोजित नहीं करना चाहते हैं और फिर उन्हें 512 टोकन के टुकड़ों में विभाजित करना चाहते हैं, तो सुनिश्चित करें कि आपने पर सेट truncate_longer_samplesकिया है True, इसलिए यह प्रत्येक पंक्ति को उसकी लंबाई की परवाह किए बिना एक व्यक्तिगत नमूने के रूप में मानेगा। ध्यान दें कि यदि आप पर सेट truncate_longer_samplesकरते हैं True, तो उपरोक्त कोड सेल बिल्कुल भी निष्पादित नहीं किया जाएगा।

मॉडल लोड हो रहा है

इस ट्यूटोरियल के लिए, हम BERT को चुन रहे हैं, लेकिन हगिंगफेस ट्रांसफॉर्मर लाइब्रेरी द्वारा समर्थित किसी भी ट्रांसफॉर्मर मॉडल को चुनने के लिए स्वतंत्र महसूस करें, जैसे RobertaForMaskedLMया DistilBertForMaskedLM:

# initialize the model with the config
model_config = BertConfig(vocab_size=vocab_size, max_position_embeddings=max_length)
model = BertForMaskedLM(config=model_config)

हम मॉडल कॉन्फ़िगरेशन का उपयोग करके प्रारंभ करते हैं BertConfig, और शब्दावली आकार के साथ-साथ अधिकतम अनुक्रम लंबाई पास करते हैं। फिर हम BertForMaskedLMमॉडल को इनिशियलाइज़ करने के लिए कॉन्फिगरेशन पास करते हैं ।

पूर्व प्रशिक्षण

इससे पहले कि हम अपने मॉडल का ढोंग करना शुरू करें, हमें नकाबपोश भाषा मॉडल (एमएलएम) कार्य के लिए अपने डेटासेट में बेतरतीब ढंग से टोकन को मास्क करने का एक तरीका चाहिए। सौभाग्य से, पुस्तकालय केवल एक DataCollatorForLanguageModelingवस्तु का निर्माण करके हमारे लिए इसे आसान बनाता है :

# initialize the data collator, randomly masking 20% (default is 15%) of the tokens for the Masked Language
# Modeling (MLM) task
data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer, mlm=True, mlm_probability=0.2
)

हम पास करते हैं tokenizerऔर सेट mlmकरते हैं True, और प्रत्येक टोकन को 20% संभावना से यादृच्छिक रूप से बदलने के mlm_probabilityलिए 0.2 पर भी सेट करते हैं [MASK]

अगला, आइए हमारे प्रशिक्षण तर्कों को आरंभ करें:

training_args = TrainingArguments(
    output_dir=model_path,          # output directory to where save model checkpoint
    evaluation_strategy="steps",    # evaluate each `logging_steps` steps
    overwrite_output_dir=True,      
    num_train_epochs=10,            # number of training epochs, feel free to tweak
    per_device_train_batch_size=10, # the training batch size, put it as high as your GPU memory fits
    gradient_accumulation_steps=8,  # accumulating the gradients before updating the weights
    per_device_eval_batch_size=64,  # evaluation batch size
    logging_steps=500,             # evaluate, log and save model checkpoints every 1000 step
    save_steps=500,
    # load_best_model_at_end=True,  # whether to load the best model (in terms of loss) at the end of training
    # save_total_limit=3,           # whether you don't have much space so you let only 3 model weights saved in the disk
)

प्रत्येक तर्क टिप्पणी में समझाया गया है, का उल्लेख डॉक्स अधिक जानकारी के लिए। आइए अब अपना ट्रेनर बनाएं:TrainingArguments

# initialize the trainer and pass everything to it
trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    train_dataset=train_dataset,
    eval_dataset=test_dataset,
)

हम अपने प्रशिक्षण तर्कों को Trainer, साथ ही साथ मॉडल, डेटा कोलेटर और प्रशिक्षण सेट को पास करते हैं। हम train()प्रशिक्षण शुरू करने के लिए अभी कॉल करते हैं:

# train the model
trainer.train()
[10135/79670 18:53:08 < 129:35:53, 0.15 it/s, Epoch 1.27/10]
Step	Training Loss	Validation Loss
1000	6.904000	6.558231
2000	6.498800	6.401168
3000	6.362600	6.277831
4000	6.251000	6.172856
5000	6.155800	6.071129
6000	6.052800	5.942584
7000	5.834900	5.546123
8000	5.537200	5.248503
9000	5.272700	4.934949
10000	4.915900	4.549236

डेटासेट के आकार, प्रशिक्षण बैच के आकार (यानी इसे आपकी GPU मेमोरी के अनुसार बढ़ाएँ), और GPU की गति के आधार पर प्रशिक्षण में कई घंटे से लेकर कई दिनों तक का समय लगेगा।

जैसा कि आप आउटपुट में देख सकते हैं, मॉडल में अभी भी सुधार हो रहा है और सत्यापन हानि अभी भी कम हो रही है। सत्यापन हानि कम होने के बाद आपको आमतौर पर प्रशिक्षण रद्द करना होगा।

जब से हम की स्थापना की है logging_stepsऔर save_steps1000 के लिए है, तो ट्रेनर का मूल्यांकन करने और हर 1000 चरणों के बाद मॉडल की बचत होगी (यानी चरणों एक्स पर प्रशिक्षित gradient_accumulation_stepएक्स per_device_train_size=  1000x8x10 = 80,000 नमूने)। नतीजतन, मैंने लगभग 19 घंटे के प्रशिक्षण, या 10000 चरणों (यानी लगभग 1.27 युगों, या 800,000 नमूनों पर प्रशिक्षित ) के बाद प्रशिक्षण रद्द कर दिया है , और मॉडल का उपयोग करना शुरू कर दिया है। अगले भाग में, हम देखेंगे कि हम अनुमान के लिए मॉडल का उपयोग कैसे कर सकते हैं।

मॉडल का उपयोग करना

इससे पहले कि हम मॉडल का उपयोग, मान लेते हैं हमारे पास नहीं है जाने modelऔर tokenizerवर्तमान क्रम में चर। इसलिए, हमें उन्हें फिर से लोड करने की आवश्यकता है:

# load the model checkpoint
model = BertForMaskedLM.from_pretrained(os.path.join(model_path, "checkpoint-10000"))
# load the tokenizer
tokenizer = BertTokenizerFast.from_pretrained(model_path)

यदि आप Google Colab पर हैं, तो आपको बाद में उपयोग के लिए अपनी चौकियों को Google ड्राइव में सहेजना होगा, आप model_pathस्थानीय पथ के बजाय ड्राइव पथ पर सेट करके ऐसा कर सकते हैं जैसे हमने यहां किया था, बस सुनिश्चित करें कि आपके पास वहां पर्याप्त जगह है .

वैकल्पिक रूप से, आप अपने मॉडल और टोकननाइज़र को हगिंगफेस हब में धकेल सकते हैं, इसे करने के लिए इस उपयोगी मार्गदर्शिका की जाँच करें ।

आइए अब हमारे मॉडल का उपयोग करें:

fill_mask = pipeline("fill-mask", model=model, tokenizer=tokenizer)

हम साधारण पाइपलाइन एपीआई का उपयोग करते हैं , और दोनों को पास modelकरते हैं tokenizer। आइए कुछ उदाहरणों की भविष्यवाणी करें:

# perform predictions
examples = [
  "Today's most trending hashtags on [MASK] is Donald Trump",
  "The [MASK] was cloudy yesterday, but today it's rainy.",
]
for example in examples:
  for prediction in fill_mask(example):
    print(f"{prediction['sequence']}, confidence: {prediction['score']}")
  print("="*50)

आउटपुट:

today's most trending hashtags on twitter is donald trump, confidence: 0.1027069091796875
today's most trending hashtags on monday is donald trump, confidence: 0.09271949529647827
today's most trending hashtags on tuesday is donald trump, confidence: 0.08099588006734848
today's most trending hashtags on facebook is donald trump, confidence: 0.04266013577580452
today's most trending hashtags on wednesday is donald trump, confidence: 0.04120611026883125
==================================================
the weather was cloudy yesterday, but today it's rainy., confidence: 0.04445931687951088
the day was cloudy yesterday, but today it's rainy., confidence: 0.037249673157930374
the morning was cloudy yesterday, but today it's rainy., confidence: 0.023775646463036537
the weekend was cloudy yesterday, but today it's rainy., confidence: 0.022554103285074234
the storm was cloudy yesterday, but today it's rainy., confidence: 0.019406016916036606
==================================================

यह प्रभावशाली है, मैंने प्रशिक्षण रद्द कर दिया है और मॉडल अभी भी दिलचस्प परिणाम दे रहा है!

निष्कर्ष

और वहां आपके पास हगिंगफेस लाइब्रेरी का उपयोग करके बीईआरटी या अन्य ट्रांसफॉर्मर को पूर्व-प्रशिक्षित करने के लिए एक पूरा कोड है, नीचे कुछ सुझाव दिए गए हैं:

  • जैसा कि ऊपर उल्लेख किया गया है, प्रशिक्षण की गति GPU की गति, डेटासेट में नमूनों की संख्या और बैच आकार पर निर्भर करेगी। मैंने प्रशिक्षण बैच का आकार 10 पर सेट किया है, क्योंकि यह अधिकतम है जो कोलाब पर मेरी GPU मेमोरी को फिट कर सकता है। यदि आपके पास अधिक मेमोरी है, तो इसे बढ़ाना सुनिश्चित करें ताकि आप प्रशिक्षण की गति को काफी बढ़ा सकें।
  • प्रशिक्षण के दौरान, यदि आप देखते हैं कि सत्यापन हानि बढ़ने लगती है, तो उस चेकपॉइंट को याद रखना सुनिश्चित करें जहां सबसे कम सत्यापन हानि होती है ताकि आप उस चेकपॉइंट को बाद में उपयोग के लिए लोड कर सकें। आप यह भी सेट कर सकते हैं load_best_model_at_endकि Trueक्या आप नुकसान का ट्रैक नहीं रखना चाहते हैं, क्योंकि प्रशिक्षण समाप्त होने पर यह नुकसान के मामले में सबसे अच्छा भार लोड करेगा।
  • शब्दावली का आकार मूल बीईआरटी कॉन्फ़िगरेशन के आधार पर चुना गया था, क्योंकि इसका आकार 30,522 था , अगर आपको लगता है कि आपके डेटासेट की भाषा में एक बड़ी शब्दावली है, या आप इसके साथ प्रयोग कर सकते हैं, तो इसे बढ़ाने के लिए स्वतंत्र महसूस करें।
  • यदि आप पर सेट truncate_longer_samplesकरते हैं False, तो कोड मानता है कि आपके पास एक वाक्य (यानी पंक्ति) पर बड़ा टेक्स्ट है, आप देखेंगे कि इसे संसाधित करने में अधिक समय लगता है, खासकर यदि आप विधि batch_sizeपर एक बड़ा सेट करते हैं map()। यह प्रक्रिया घंटे का एक बहुत लेता है, तो आप या तो सेट कर सकते हैं truncate_longer_samplesकरने के लिए Trueताकि आप वाक्य है कि से अधिक काट-छांट max_lengthटोकन या आप उपयोग कर संसाधित करने के बाद डाटासेट बचा सकता है save_to_disk()विधि, ताकि आप इसे एक बार संसाधित करने और कई बार इसे लोड।

यदि आप पाठ वर्गीकरण जैसे डाउनस्ट्रीम कार्य के लिए BERT को ठीक करने में रुचि रखते हैं, तो यह ट्यूटोरियल आपको इसके माध्यम से मार्गदर्शन करता है।

#python

Khaitan

Khaitan

1634551440

पायथन के साथ पीडीएफ फाइलों में छवियों से टेक्स्ट कैसे निकालें

पाइथन के साथ पीडीएफ फाइलों में छवियों से टेक्स्ट निकालने के लिए टेसरैक्ट, ओपनसीवी, पीईएमयूपीडीएफ और कई अन्य पुस्तकालयों का लाभ उठाने का तरीका जानें

आजकल, मध्यम और बड़े पैमाने की कंपनियों के पास दैनिक उपयोग में भारी मात्रा में मुद्रित दस्तावेज़ हैं। इनमें चालान, रसीदें, कॉर्पोरेट दस्तावेज़, रिपोर्ट और मीडिया रिलीज़ शामिल हैं।

उन कंपनियों के लिए, ओसीआर स्कैनर का उपयोग दक्षता और सटीकता में सुधार करते हुए काफी समय बचा सकता है। 

ऑप्टिकल कैरेक्टर रिकग्निशन (ओसीआर) एल्गोरिदम कंप्यूटर को मुद्रित या हस्तलिखित दस्तावेजों का स्वचालित रूप से विश्लेषण करने की अनुमति देता है और कंप्यूटर के लिए उन्हें कुशलतापूर्वक संसाधित करने के लिए संपादन योग्य प्रारूपों में टेक्स्ट डेटा तैयार करता है। OCR सिस्टम टेक्स्ट की एक द्वि-आयामी छवि को रूपांतरित करता है जिसमें मशीन-मुद्रित या हस्तलिखित पाठ हो सकता है, जो इसके छवि प्रतिनिधित्व से मशीन-पठनीय पाठ में हो सकता है।

आम तौर पर, एक ओसीआर इंजन में ऑप्टिकल कैरेक्टर रिकग्निशन की मदद से कुशल समस्या-समाधान के लिए मशीन लर्निंग एल्गोरिदम को प्रशिक्षित करने के लिए आवश्यक कई कदम शामिल होते हैं ।

निम्नलिखित चरण जो एक इंजन से दूसरे इंजन में भिन्न हो सकते हैं, स्वचालित चरित्र पहचान के लिए मोटे तौर पर आवश्यक हैं: इस ट्यूटोरियल के भीतर, मैं आपको निम्नलिखित दिखाने जा रहा हूं:ओसीआर इंजन वर्कफ़्लो

  • इमेज फाइल पर OCR स्कैनर कैसे चलाएं।
  • इमेज फाइल में किसी खास टेक्स्ट को कैसे रिडक्ट या हाईलाइट करें।
  • पीडीएफ फाइल या पीडीएफ फाइलों के संग्रह पर ओसीआर स्कैनर कैसे चलाएं।

आरंभ करने के लिए, हमें निम्नलिखित पुस्तकालयों का उपयोग करने की आवश्यकता है:

Tesseract OCR :  एक ओपन-सोर्स टेक्स्ट रिकग्निशन इंजन है जो Apache 2.0 लाइसेंस के तहत उपलब्ध है और इसका विकास 2006 से Google द्वारा प्रायोजित किया गया है। वर्ष 2006 में, Tesseract को सबसे सटीक ओपन-सोर्स OCR इंजनों में से एक माना जाता था। आप इसे सीधे उपयोग कर सकते हैं या छवियों से मुद्रित पाठ निकालने के लिए एपीआई का उपयोग कर सकते हैं। सबसे अच्छी बात यह है कि यह विभिन्न प्रकार की भाषाओं का समर्थन करता है। 

Tesseract इंजन को स्थापित करना इस लेख के दायरे से बाहर है। हालाँकि, आपको इसे अपने ऑपरेटिंग सिस्टम पर स्थापित करने के लिए Tesseract की आधिकारिक स्थापना मार्गदर्शिका का पालन ​​करने की आवश्यकता है।

Tesseract सेटअप को मान्य करने के लिए, कृपया निम्न कमांड चलाएँ और उत्पन्न आउटपुट की जाँच करें:

Tesseract स्थापना को मान्य करनाPython-tesseract : Google के Tesseract-OCR Engine के लिए एक Python आवरण है। यह टेसरैक्ट के लिए एक स्टैंड-अलोन इनवोकेशन स्क्रिप्ट के रूप में भी उपयोगी है, क्योंकि यह पिल्लो और लेप्टोनिका इमेजिंग लाइब्रेरी द्वारा समर्थित सभी छवि प्रकारों को पढ़ सकता है, जिसमें jpeg, png, gif, bmp, tiff, और अन्य शामिल हैं।

OpenCV : कंप्यूटर विज़न, मशीन लर्निंग और इमेज प्रोसेसिंग के लिए एक पायथन ओपन-सोर्स लाइब्रेरी है। ओपनसीवी विभिन्न प्रकार की प्रोग्रामिंग भाषाओं जैसे पायथन, सी ++, जावा, आदि का समर्थन करता है। यह वस्तुओं, चेहरों या यहां तक ​​कि मानव की लिखावट की पहचान करने के लिए छवियों और वीडियो को संसाधित कर सकता है। 

PyMuPDF : MuPDF एक अत्यधिक बहुमुखी, अनुकूलन योग्य PDF, XPS और eBook दुभाषिया समाधान है जिसका उपयोग PDF रेंडरर, व्यूअर या टूलकिट के रूप में अनुप्रयोगों की एक विस्तृत श्रृंखला में किया जा सकता है। PyMuPDF, MuPDF के लिए एक पायथन बाइंडिंग है। यह हल्का PDF और XPS व्यूअर है।

Numpy: एक सामान्य-उद्देश्य वाला सरणी-प्रसंस्करण पैकेज है। यह इन सरणियों के साथ काम करने के लिए एक उच्च-प्रदर्शन बहुआयामी सरणी वस्तु और उपकरण प्रदान करता है। यह पायथन के साथ वैज्ञानिक कंप्यूटिंग के लिए मौलिक पैकेज है। इसके अलावा, Numpy को जेनेरिक डेटा के एक कुशल बहु-आयामी कंटेनर के रूप में भी इस्तेमाल किया जा सकता है।

पिलो: पीआईएल (पायथन इमेज लाइब्रेरी) के ऊपर बनाया गया है। यह पायथन में इमेज प्रोसेसिंग के लिए एक आवश्यक मॉड्यूल है।

पांडा: एक खुला स्रोत, बीएसडी-लाइसेंस प्राप्त पायथन पुस्तकालय है जो पायथन प्रोग्रामिंग भाषा के लिए उच्च-प्रदर्शन, उपयोग में आसान डेटा संरचना और डेटा विश्लेषण उपकरण प्रदान करता है। 

Filetype: लघु और अनुमान फ़ाइल प्रकार और MIME प्रकार के लिए निर्भरता से मुक्त अजगर पैकेज।

इस ट्यूटोरियल का उद्देश्य एक छवि या स्कैन की गई पीडीएफ फाइल के भीतर या पीडीएफ फाइलों के संग्रह वाले फ़ोल्डर में शामिल टेक्स्ट को निकालने, संशोधित करने या हाइलाइट करने के लिए एक हल्की कमांड-लाइन-आधारित उपयोगिता विकसित करना है।

सेट अप

आरंभ करने के लिए, आइए आवश्यकताओं को स्थापित करें:

$ pip install Filetype==1.0.7 numpy==1.19.4 opencv-python==4.4.0.46 pandas==1.1.4 Pillow==8.0.1 PyMuPDF==1.18.9 pytesseract==0.3.7

आइए आवश्यक पुस्तकालयों को आयात करके शुरू करें:

import os
import re
import argparse
import pytesseract
from pytesseract import Output
import cv2
import numpy as np
import fitz
from io import BytesIO
from PIL import Image
import pandas as pd
import filetype

# Path Of The Tesseract OCR engine
TESSERACT_PATH = "C:\Program Files\Tesseract-OCR\tesseract.exe"
# Include tesseract executable
pytesseract.pytesseract.tesseract_cmd = TESSERACT_PATH

TESSERACT_PATHवह जगह है जहाँ Tesseract निष्पादन योग्य स्थित है। जाहिर है, आपको इसे अपने मामले के लिए बदलने की जरूरत है।

def pix2np(pix):
    """
    Converts a pixmap buffer into a numpy array
    """
    # pix.samples = sequence of bytes of the image pixels like RGBA
    #pix.h = height in pixels
    #pix.w = width in pixels
    # pix.n = number of components per pixel (depends on the colorspace and alpha)
    im = np.frombuffer(pix.samples, dtype=np.uint8).reshape(
        pix.h, pix.w, pix.n)
    try:
        im = np.ascontiguousarray(im[..., [2, 1, 0]])  # RGB To BGR
    except IndexError:
        # Convert Gray to RGB
        im = cv2.cvtColor(im, cv2.COLOR_GRAY2RGB)
        im = np.ascontiguousarray(im[..., [2, 1, 0]])  # RGB To BGR
    return im

यह फ़ंक्शन एक पिक्समैप बफर को एक NumPy सरणी में PyMuPDF लाइब्रेरी का उपयोग करके लिए गए स्क्रीनशॉट का प्रतिनिधित्व करता है ।

Tesseract सटीकता में सुधार करने के लिए, आइए OpenCV का उपयोग करके कुछ प्रीप्रोसेसिंग फ़ंक्शन को परिभाषित करें:

# Image Pre-Processing Functions to improve output accurracy
# Convert to grayscale
def grayscale(img):
    return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Remove noise
def remove_noise(img):
    return cv2.medianBlur(img, 5)

# Thresholding
def threshold(img):
    # return cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
    return cv2.threshold(img, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]

# dilation
def dilate(img):
    kernel = np.ones((5, 5), np.uint8)
    return cv2.dilate(img, kernel, iterations=1)

# erosion
def erode(img):
    kernel = np.ones((5, 5), np.uint8)
    return cv2.erode(img, kernel, iterations=1)

# opening -- erosion followed by a dilation
def opening(img):
    kernel = np.ones((5, 5), np.uint8)
    return cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

# canny edge detection
def canny(img):
    return cv2.Canny(img, 100, 200)

# skew correction
def deskew(img):
    coords = np.column_stack(np.where(img > 0))
    angle = cv2.minAreaRect(coords)[-1]
    if angle < -45:
        angle = -(90 + angle)
    else:
        angle = -angle
    (h, w) = img.shape[:2]
    center = (w//2, h//2)
    M = cv2.getRotationMatrix2D(center, angle, 1.0)
    rotated = cv2.warpAffine(
        img, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
    return rotated

# template matching
def match_template(img, template):
    return cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)

def convert_img2bin(img):
    """
    Pre-processes the image and generates a binary output
    """
    # Convert the image into a grayscale image
    output_img = grayscale(img)
    # Invert the grayscale image by flipping pixel values.
    # All pixels that are grater than 0 are set to 0 and all pixels that are = to 0 are set to 255
    output_img = cv2.bitwise_not(output_img)
    # Converting image to binary by Thresholding in order to show a clear separation between white and blacl pixels.
    output_img = threshold(output_img)
    return output_img

हमने कई प्रीप्रोसेसिंग कार्यों के लिए कार्यों को परिभाषित किया है, जिसमें छवियों को ग्रेस्केल में परिवर्तित करना, पिक्सेल मानों को फ़्लिप करना, सफेद और काले पिक्सेल को अलग करना, और बहुत कुछ शामिल है।

अगला, आइए एक छवि प्रदर्शित करने के लिए एक फ़ंक्शन को परिभाषित करें:

def display_img(title, img):
    """Displays an image on screen and maintains the output until the user presses a key"""
    cv2.namedWindow('img', cv2.WINDOW_NORMAL)
    cv2.setWindowTitle('img', title)
    cv2.resizeWindow('img', 1200, 900)
    # Display Image on screen
    cv2.imshow('img', img)
    # Mantain output until user presses a key
    cv2.waitKey(0)
    # Destroy windows when user presses a key
    cv2.destroyAllWindows()

display_img()ऑन-स्क्रीन समारोह को प्रदर्शित करता है एक छवि एक विंडो में करने के लिए एक शीर्षक सेट होने titleपैरामीटर और इस विंडो उपयोगकर्ता तक खुला रखता है कुंजीपटल पर एक कुंजी प्रेस।

def generate_ss_text(ss_details):
    """Loops through the captured text of an image and arranges this text line by line.
    This function depends on the image layout."""
    # Arrange the captured text after scanning the page
    parse_text = []
    word_list = []
    last_word = ''
    # Loop through the captured text of the entire page
    for word in ss_details['text']:
        # If the word captured is not empty
        if word != '':
            # Add it to the line word list
            word_list.append(word)
            last_word = word
        if (last_word != '' and word == '') or (word == ss_details['text'][-1]):
            parse_text.append(word_list)
            word_list = []
    return parse_text

उपरोक्त फ़ंक्शन किसी छवि के कैप्चर किए गए टेक्स्ट में पुनरावृति करता है और ग्रैब्ड टेक्स्ट लाइन को लाइन से व्यवस्थित करता है। यह छवि लेआउट पर निर्भर करता है और कुछ छवि प्रारूपों के लिए ट्विकिंग की आवश्यकता हो सकती है।

अगला, आइए रेगुलर एक्सप्रेशन का उपयोग करके टेक्स्ट खोजने के लिए एक फ़ंक्शन को परिभाषित करें :

def search_for_text(ss_details, search_str):
    """Search for the search string within the image content"""
    # Find all matches within one page
    results = re.findall(search_str, ss_details['text'], re.IGNORECASE)
    # In case multiple matches within one page
    for result in results:
        yield result

हम इस फ़ंक्शन का उपयोग किसी छवि की पकड़ी गई सामग्री के भीतर विशिष्ट पाठ खोजने के लिए करेंगे। यह पाए गए मैचों का जनरेटर देता है।

def save_page_content(pdfContent, page_id, page_data):
    """Appends the content of a scanned page, line by line, to a pandas DataFrame."""
    if page_data:
        for idx, line in enumerate(page_data, 1):
            line = ' '.join(line)
            pdfContent = pdfContent.append(
                {'page': page_id, 'line_id': idx, 'line': line}, ignore_index=True
            )
    return pdfContent

save_page_content()फ़ंक्शन pdfContentपांडा डेटाफ़्रेम पर स्कैन करने के बाद एक छवि लाइन की पकड़ी गई सामग्री को लाइन से जोड़ता है ।

अब परिणामी डेटाफ़्रेम को CSV फ़ाइल में सहेजने के लिए एक फ़ंक्शन बनाते हैं:

def save_file_content(pdfContent, input_file):
    """Outputs the content of the pandas DataFrame to a CSV file having the same path as the input_file
    but with different extension (.csv)"""
    content_file = os.path.join(os.path.dirname(input_file), os.path.splitext(
        os.path.basename(input_file))[0] + ".csv")
    pdfContent.to_csv(content_file, sep=',', index=False)
    return content_file

इसके बाद, एक फ़ंक्शन लिखते हैं जो स्कैन की गई छवि से लिए गए टेक्स्ट के कॉन्फिडेंस स्कोर की गणना करता है:

def calculate_ss_confidence(ss_details: dict):
    """Calculate the confidence score of the text grabbed from the scanned image."""
    # page_num  --> Page number of the detected text or item
    # block_num --> Block number of the detected text or item
    # par_num   --> Paragraph number of the detected text or item
    # line_num  --> Line number of the detected text or item
    # Convert the dict to dataFrame
    df = pd.DataFrame.from_dict(ss_details)
    # Convert the field conf (confidence) to numeric
    df['conf'] = pd.to_numeric(df['conf'], errors='coerce')
    # Elliminate records with negative confidence
    df = df[df.conf != -1]
    # Calculate the mean confidence by page
    conf = df.groupby(['page_num'])['conf'].mean().tolist()
    return conf[0]

मुख्य समारोह में जा रहे हैं: छवि को स्कैन करना:

def ocr_img(
        img: np.array, input_file: str, search_str: str, 
        highlight_readable_text: bool = False, action: str = 'Highlight', 
        show_comparison: bool = False, generate_output: bool = True):
    """Scans an image buffer or an image file.
    Pre-processes the image.
    Calls the Tesseract engine with pre-defined parameters.
    Calculates the confidence score of the image grabbed content.
    Draws a green rectangle around readable text items having a confidence score > 30.
    Searches for a specific text.
    Highlight or redact found matches of the searched text.
    Displays a window showing readable text fields or the highlighted or redacted text.
    Generates the text content of the image.
    Prints a summary to the console."""
    # If image source file is inputted as a parameter
    if input_file:
        # Reading image using opencv
        img = cv2.imread(input_file)
    # Preserve a copy of this image for comparison purposes
    initial_img = img.copy()
    highlighted_img = img.copy()
    # Convert image to binary
    bin_img = convert_img2bin(img)
    # Calling Tesseract
    # Tesseract Configuration parameters
    # oem --> OCR engine mode = 3 >> Legacy + LSTM mode only (LSTM neutral net mode works the best)
    # psm --> page segmentation mode = 6 >> Assume as single uniform block of text (How a page of text can be analyzed)
    config_param = r'--oem 3 --psm 6'
    # Feeding image to tesseract
    details = pytesseract.image_to_data(
        bin_img, output_type=Output.DICT, config=config_param, lang='eng')
    # The details dictionary contains the information of the input image
    # such as detected text, region, position, information, height, width, confidence score.
    ss_confidence = calculate_ss_confidence(details)
    boxed_img = None
    # Total readable items
    ss_readable_items = 0
    # Total matches found
    ss_matches = 0
    for seq in range(len(details['text'])):
        # Consider only text fields with confidence score > 30 (text is readable)
        if float(details['conf'][seq]) > 30.0:
            ss_readable_items += 1
            # Draws a green rectangle around readable text items having a confidence score > 30
            if highlight_readable_text:
                (x, y, w, h) = (details['left'][seq], details['top']
                                [seq], details['width'][seq], details['height'][seq])
                boxed_img = cv2.rectangle(
                    img, (x, y), (x+w, y+h), (0, 255, 0), 2)
            # Searches for the string
            if search_str:
                results = re.findall(
                    search_str, details['text'][seq], re.IGNORECASE)
                for result in results:
                    ss_matches += 1
                    if action:
                        # Draw a red rectangle around the searchable text
                        (x, y, w, h) = (details['left'][seq], details['top']
                                        [seq], details['width'][seq], details['height'][seq])
                        # Details of the rectangle
                        # Starting coordinate representing the top left corner of the rectangle
                        start_point = (x, y)
                        # Ending coordinate representing the botton right corner of the rectangle
                        end_point = (x + w, y + h)
                        #Color in BGR -- Blue, Green, Red
                        if action == "Highlight":
                            color = (0, 255, 255)  # Yellow
                        elif action == "Redact":
                            color = (0, 0, 0)  # Black
                        # Thickness in px (-1 will fill the entire shape)
                        thickness = -1
                        boxed_img = cv2.rectangle(
                            img, start_point, end_point, color, thickness)
                            
    if ss_readable_items > 0 and highlight_readable_text and not (ss_matches > 0 and action in ("Highlight", "Redact")):
        highlighted_img = boxed_img.copy()
    # Highlight found matches of the search string
    if ss_matches > 0 and action == "Highlight":
        cv2.addWeighted(boxed_img, 0.4, highlighted_img,
                        1 - 0.4, 0, highlighted_img)
    # Redact found matches of the search string
    elif ss_matches > 0 and action == "Redact":
        highlighted_img = boxed_img.copy()
        #cv2.addWeighted(boxed_img, 1, highlighted_img, 0, 0, highlighted_img)
    # save the image
    cv2.imwrite("highlighted-text-image.jpg", highlighted_img)  
    # Displays window showing readable text fields or the highlighted or redacted data
    if show_comparison and (highlight_readable_text or action):
        title = input_file if input_file else 'Compare'
        conc_img = cv2.hconcat([initial_img, highlighted_img])
        display_img(title, conc_img)
    # Generates the text content of the image
    output_data = None
    if generate_output and details:
        output_data = generate_ss_text(details)
    # Prints a summary to the console
    if input_file:
        summary = {
            "File": input_file, "Total readable words": ss_readable_items, "Total matches": ss_matches, "Confidence score": ss_confidence
        }
        # Printing Summary
        print("## Summary ########################################################")
        print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
        print("###################################################################")
    return highlighted_img, ss_readable_items, ss_matches, ss_confidence, output_data
    # pass image into pytesseract module
    # pytesseract is trained in many languages
    #config_param = r'--oem 3 --psm 6'
    #details = pytesseract.image_to_data(img,config=config_param,lang='eng')
    # print(details)
    # return details

उपरोक्त निम्नलिखित कार्य करता है:

  • एक छवि बफर या एक छवि फ़ाइल स्कैन करता है।
  • छवि को पूर्व-संसाधित करता है।
  • Tesseract इंजन को पूर्व-निर्धारित मापदंडों के साथ चलाता है।
  • छवि की पकड़ी गई सामग्री के विश्वास स्कोर की गणना करता है।
  • 30 से अधिक कॉन्फिडेंस स्कोर वाले पठनीय टेक्स्ट आइटम के चारों ओर एक हरे रंग का आयत बनाता है।
  • छवि हथियाने वाली सामग्री के भीतर एक विशिष्ट पाठ की खोज करता है।
  • खोजे गए पाठ के पाए गए मिलानों को हाइलाइट या संशोधित करता है।
  • पढ़ने योग्य टेक्स्ट फ़ील्ड या हाइलाइट किए गए टेक्स्ट या संशोधित टेक्स्ट दिखाने वाली विंडो प्रदर्शित करता है।
  • छवि की पाठ सामग्री उत्पन्न करता है।
  • कंसोल पर एक सारांश प्रिंट करता है।
def image_to_byte_array(image: Image):
    """
    Converts an image into a byte array
    """
    imgByteArr = BytesIO()
    image.save(imgByteArr, format=image.format if image.format else 'JPEG')
    imgByteArr = imgByteArr.getvalue()
    return imgByteArr

def ocr_file(**kwargs):
    """Opens the input PDF File.
    Opens a memory buffer for storing the output PDF file.
    Creates a DataFrame for storing pages statistics
    Iterates throughout the chosen pages of the input PDF file
    Grabs a screen-shot of the selected PDF page.
    Converts the screen-shot pix to a numpy array
    Scans the grabbed screen-shot.
    Collects the statistics of the screen-shot(page).
    Saves the content of the screen-shot(page).
    Adds the updated screen-shot (Highlighted, Redacted) to the output file.
    Saves the whole content of the PDF file.
    Saves the output PDF file if required.
    Prints a summary to the console."""
    input_file = kwargs.get('input_file')
    output_file = kwargs.get('output_file')
    search_str = kwargs.get('search_str')
    pages = kwargs.get('pages')
    highlight_readable_text = kwargs.get('highlight_readable_text')
    action = kwargs.get('action')
    show_comparison = kwargs.get('show_comparison')
    generate_output = kwargs.get('generate_output')
    # Opens the input PDF file
    pdfIn = fitz.open(input_file)
    # Opens a memory buffer for storing the output PDF file.
    pdfOut = fitz.open()
    # Creates an empty DataFrame for storing pages statistics
    dfResult = pd.DataFrame(
        columns=['page', 'page_readable_items', 'page_matches', 'page_total_confidence'])
    # Creates an empty DataFrame for storing file content
    if generate_output:
        pdfContent = pd.DataFrame(columns=['page', 'line_id', 'line'])
    # Iterate throughout the pages of the input file
    for pg in range(pdfIn.pageCount):
        if str(pages) != str(None):
            if str(pg) not in str(pages):
                continue
        # Select a page
        page = pdfIn[pg]
        # Rotation angle
        rotate = int(0)
        # PDF Page is converted into a whole picture 1056*816 and then for each picture a screenshot is taken.
        # zoom = 1.33333333 -----> Image size = 1056*816
        # zoom = 2 ---> 2 * Default Resolution (text is clear, image text is hard to read)    = filesize small / Image size = 1584*1224
        # zoom = 4 ---> 4 * Default Resolution (text is clear, image text is barely readable) = filesize large
        # zoom = 8 ---> 8 * Default Resolution (text is clear, image text is readable) = filesize large
        zoom_x = 2
        zoom_y = 2
        # The zoom factor is equal to 2 in order to make text clear
        # Pre-rotate is to rotate if needed.
        mat = fitz.Matrix(zoom_x, zoom_y).preRotate(rotate)
        # To captue a specific part of the PDF page
        # rect = page.rect #page size
        # mp = rect.tl + (rect.bl - (0.75)/zoom_x) #rectangular area 56 = 75/1.3333
        # clip = fitz.Rect(mp,rect.br) #The area to capture
        # pix = page.getPixmap(matrix=mat, alpha=False,clip=clip)
        # Get a screen-shot of the PDF page
        # Colorspace -> represents the color space of the pixmap (csRGB, csGRAY, csCMYK)
        # alpha -> Transparancy indicator
        pix = page.getPixmap(matrix=mat, alpha=False, colorspace="csGRAY")
        # convert the screen-shot pix to numpy array
        img = pix2np(pix)
        # Erode image to omit or thin the boundaries of the bright area of the image
        # We apply Erosion on binary images.
        #kernel = np.ones((2,2) , np.uint8)
        #img = cv2.erode(img,kernel,iterations=1)
        upd_np_array, pg_readable_items, pg_matches, pg_total_confidence, pg_output_data \
            = ocr_img(img=img, input_file=None, search_str=search_str, highlight_readable_text=highlight_readable_text  # False
                      , action=action  # 'Redact'
                      , show_comparison=show_comparison  # True
                      , generate_output=generate_output  # False
                      )
        # Collects the statistics of the page
        dfResult = dfResult.append({'page': (pg+1), 'page_readable_items': pg_readable_items,
                                   'page_matches': pg_matches, 'page_total_confidence': pg_total_confidence}, ignore_index=True)
        if generate_output:
            pdfContent = save_page_content(
                pdfContent=pdfContent, page_id=(pg+1), page_data=pg_output_data)
        # Convert the numpy array to image object with mode = RGB
        #upd_img = Image.fromarray(np.uint8(upd_np_array)).convert('RGB')
        upd_img = Image.fromarray(upd_np_array[..., ::-1])
        # Convert the image to byte array
        upd_array = image_to_byte_array(upd_img)
        # Get Page Size
        """
        #To check whether initial page is portrait or landscape
        if page.rect.width > page.rect.height:
            fmt = fitz.PaperRect("a4-1")
        else:
            fmt = fitz.PaperRect("a4")

        #pno = -1 -> Insert after last page
        pageo = pdfOut.newPage(pno = -1, width = fmt.width, height = fmt.height)
        """
        pageo = pdfOut.newPage(
            pno=-1, width=page.rect.width, height=page.rect.height)
        pageo.insertImage(page.rect, stream=upd_array)
        #pageo.insertImage(page.rect, stream=upd_img.tobytes())
        #pageo.showPDFpage(pageo.rect, pdfDoc, page.number)
    content_file = None
    if generate_output:
        content_file = save_file_content(
            pdfContent=pdfContent, input_file=input_file)
    summary = {
        "File": input_file, "Total pages": pdfIn.pageCount, 
        "Processed pages": dfResult['page'].count(), "Total readable words": dfResult['page_readable_items'].sum(), 
        "Total matches": dfResult['page_matches'].sum(), "Confidence score": dfResult['page_total_confidence'].mean(), 
        "Output file": output_file, "Content file": content_file
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("\nPages Statistics:")
    print(dfResult, sep='\n')
    print("###################################################################")
    pdfIn.close()
    if output_file:
        pdfOut.save(output_file)
    pdfOut.close()

image_to_byte_array()समारोह एक बाइट सरणी में एक छवि बदल देता है।

ocr_file()समारोह निम्नलिखित है:

  • इनपुट पीडीएफ फाइल को खोलता है।
  • आउटपुट पीडीएफ फाइल को स्टोर करने के लिए मेमोरी बफर खोलता है।
  • पृष्ठ के आँकड़ों को संग्रहीत करने के लिए एक पांडा डेटाफ़्रेम बनाता है।
  • इनपुट पीडीएफ फाइल के चुने हुए पृष्ठों के माध्यम से पुनरावृत्त करता है।
  • इनपुट पीडीएफ फाइल के चयनित पृष्ठ का एक स्क्रीनशॉट (छवि) लेता है।
  • स्क्रीनशॉट (पिक्स) को एक NumPy सरणी में कनवर्ट करता है।
  • पकड़े गए स्क्रीन-शॉट को स्कैन करता है।
  • स्क्रीन-शॉट (पेज) के आंकड़े एकत्र करता है।
  • स्क्रीनशॉट की सामग्री को सहेजता है।
  • अपडेट किए गए स्क्रीनशॉट को आउटपुट फ़ाइल में जोड़ता है।
  • इनपुट PDF फ़ाइल की संपूर्ण सामग्री को CSV फ़ाइल में सहेजता है।
  • यदि आवश्यक हो तो आउटपुट पीडीएफ फाइल को सेव करता है।
  • कंसोल पर एक सारांश प्रिंट करता है।

आइए एक फ़ोल्डर को संसाधित करने के लिए एक और फ़ंक्शन जोड़ें जिसमें एकाधिक पीडीएफ फाइलें हों:

def ocr_folder(**kwargs):
    """Scans all PDF Files within a specified path"""
    input_folder = kwargs.get('input_folder')
    # Run in recursive mode
    recursive = kwargs.get('recursive')
    search_str = kwargs.get('search_str')
    pages = kwargs.get('pages')
    action = kwargs.get('action')
    generate_output = kwargs.get('generate_output')
    # Loop though the files within the input folder.
    for foldername, dirs, filenames in os.walk(input_folder):
        for filename in filenames:
            # Check if pdf file
            if not filename.endswith('.pdf'):
                continue
            # PDF File found
            inp_pdf_file = os.path.join(foldername, filename)
            print("Processing file =", inp_pdf_file)
            output_file = None
            if search_str:
                # Generate an output file
                output_file = os.path.join(os.path.dirname(
                    inp_pdf_file), 'ocr_' + os.path.basename(inp_pdf_file))
            ocr_file(
                input_file=inp_pdf_file, output_file=output_file, search_str=search_str, pages=pages, highlight_readable_text=False, action=action, show_comparison=False, generate_output=generate_output
            )
        if not recursive:
            break

इस फ़ंक्शन का उद्देश्य एक विशिष्ट फ़ोल्डर में शामिल पीडीएफ फाइलों को स्कैन करना है। यह निर्दिष्ट फ़ोल्डर की फ़ाइलों में या तो पुनरावर्ती रूप से लूप करता है या नहीं, यह पैरामीटर पुनरावर्ती के मान पर निर्भर करता है और इन फ़ाइलों को एक-एक करके संसाधित करता है।

यह निम्नलिखित मापदंडों को स्वीकार करता है:

  • input_folder: प्रोसेस करने के लिए पीडीएफ फाइलों वाले फोल्डर का पाथ।
  • search_str: हेरफेर करने के लिए खोजने के लिए पाठ।
  • recursive: सबफ़ोल्डर में लूप करके इस प्रक्रिया को पुनरावर्ती रूप से चलाना है या नहीं।
  • action: निम्नलिखित में से करने के लिए क्रिया: हाइलाइट करें, सुधारें।
  • pages: विचार करने के लिए पृष्ठ।
  • generate_output: चुनें कि इनपुट पीडीएफ फाइल की सामग्री को CSV फाइल में सेव करना है या नहीं

समाप्त करने से पहले, आइए कमांड-लाइन तर्कों को पार्स करने के लिए उपयोगी कार्यों को परिभाषित करें:

def is_valid_path(path):
    """Validates the path inputted and checks whether it is a file path or a folder path"""
    if not path:
        raise ValueError(f"Invalid Path")
    if os.path.isfile(path):
        return path
    elif os.path.isdir(path):
        return path
    else:
        raise ValueError(f"Invalid Path {path}")


def parse_args():
    """Get user command line parameters"""
    parser = argparse.ArgumentParser(description="Available Options")
    parser.add_argument('-i', '--input-path', type=is_valid_path,
                        required=True, help="Enter the path of the file or the folder to process")
    parser.add_argument('-a', '--action', choices=[
                        'Highlight', 'Redact'], type=str, help="Choose to highlight or to redact")
    parser.add_argument('-s', '--search-str', dest='search_str',
                        type=str, help="Enter a valid search string")
    parser.add_argument('-p', '--pages', dest='pages', type=tuple,
                        help="Enter the pages to consider in the PDF file, e.g. (0,1)")
    parser.add_argument("-g", "--generate-output", action="store_true", help="Generate text content in a CSV file")
    path = parser.parse_known_args()[0].input_path
    if os.path.isfile(path):
        parser.add_argument('-o', '--output_file', dest='output_file',
                            type=str, help="Enter a valid output file")
        parser.add_argument("-t", "--highlight-readable-text", action="store_true", help="Highlight readable text in the generated image")
        parser.add_argument("-c", "--show-comparison", action="store_true", help="Show comparison between captured image and the generated image")
    if os.path.isdir(path):
        parser.add_argument("-r", "--recursive", action="store_true", help="Whether to process the directory recursively")
    # To Porse The Command Line Arguments
    args = vars(parser.parse_args())
    # To Display The Command Line Arguments
    print("## Command Arguments #################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in args.items()))
    print("######################################################################")
    return args

is_valid_path()समारोह एक रास्ता एक पैरामीटर और चेक यह एक फ़ाइल पथ है कि क्या है या एक निर्देशिका पथ के रूप में inputted सत्यापित करता है।

parse_args()समारोह परिभाषित करता है और सेट उचित बाधाओं उपयोगकर्ता के कमांड लाइन तर्क के लिए इस उपयोगिता सुनिश्चित करें।

नीचे सभी मापदंडों के लिए स्पष्टीकरण दिया गया है:

  • input_path: फ़ाइल या फ़ोल्डर को संसाधित करने के पथ को इनपुट करने के लिए एक आवश्यक पैरामीटर, यह पैरामीटर is_valid_path()पहले परिभाषित फ़ंक्शन से जुड़ा हुआ है।
  • action: किसी भी गलत चयन से बचने के लिए पूर्व-निर्धारित विकल्पों की सूची के बीच प्रदर्शन करने की क्रिया।
  • search_str: हेरफेर करने के लिए खोजने के लिए पाठ।
  • pages: PDF फ़ाइल को संसाधित करते समय विचार करने वाले पृष्ठ।
  • generate_content: निर्दिष्ट करता है कि इनपुट फ़ाइल की पकड़ी गई सामग्री को जनरेट करना है या नहीं, छवि या PDF CSV फ़ाइल के लिए है या नहीं।
  • output_file: आउटपुट फ़ाइल का पथ। इस तर्क को भरना एक फ़ाइल के इनपुट के रूप में चयन से बाधित है, निर्देशिका नहीं।
  • highlight_readable_text: 30 से अधिक कॉन्फिडेंस स्कोर वाले पठनीय टेक्स्ट फ़ील्ड के चारों ओर हरे रंग के आयत बनाने के लिए।
  • show_comparison: मूल छवि और संसाधित छवि के बीच तुलना दिखाते हुए एक विंडो प्रदर्शित करता है।
  • recursive: किसी फोल्डर को रिकर्सिवली प्रोसेस करना है या नहीं। इस तर्क को भरना एक निर्देशिका के चयन से विवश है।

अंत में, आइए मुख्य कोड लिखें जो पहले परिभाषित कार्यों का उपयोग करता है:

if __name__ == '__main__':
    # Parsing command line arguments entered by user
    args = parse_args()
    # If File Path
    if os.path.isfile(args['input_path']):
        # Process a file
        if filetype.is_image(args['input_path']):
            ocr_img(
                # if 'search_str' in (args.keys()) else None
                img=None, input_file=args['input_path'], search_str=args['search_str'], highlight_readable_text=args['highlight_readable_text'], action=args['action'], show_comparison=args['show_comparison'], generate_output=args['generate_output']
            )
        else:
            ocr_file(
                input_file=args['input_path'], output_file=args['output_file'], search_str=args['search_str'] if 'search_str' in (args.keys()) else None, pages=args['pages'], highlight_readable_text=args['highlight_readable_text'], action=args['action'], show_comparison=args['show_comparison'], generate_output=args['generate_output']
            )
    # If Folder Path
    elif os.path.isdir(args['input_path']):
        # Process a folder
        ocr_folder(
            input_folder=args['input_path'], recursive=args['recursive'], search_str=args['search_str'] if 'search_str' in (args.keys()) else None, pages=args['pages'], action=args['action'], generate_output=args['generate_output']
        )

आइए हमारे कार्यक्रम का परीक्षण करें:

$ python pdf_ocr.py

आउटपुट:

usage: pdf_ocr.py [-h] -i INPUT_PATH [-a {Highlight,Redact}] [-s SEARCH_STR] [-p PAGES] [-g GENERATE_OUTPUT]

Available Options

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT_PATH, --input_path INPUT_PATH
                        Enter the path of the file or the folder to process
  -a {Highlight,Redact}, --action {Highlight,Redact}
                        Choose to highlight or to redact
  -s SEARCH_STR, --search_str SEARCH_STR
                        Enter a valid search string
  -p PAGES, --pages PAGES
                        Enter the pages to consider e.g.: (0,1)
  -g GENERATE_OUTPUT, --generate_output GENERATE_OUTPUT
                        Generate content in a CSV file

हमारे परीक्षण परिदृश्यों की खोज करने से पहले, निम्नलिखित से सावधान रहें:

सबसे पहले, आइए एक छवि इनपुट करने का प्रयास करें ( यदि आप समान आउटपुट प्राप्त करना चाहते हैं तो आप इसे यहां प्राप्त कर सकते हैं ), बिना किसी पीडीएफ फाइल को शामिल किए:

$ python pdf_ocr.py -s "BERT" -a Highlight -i example-image-containing-text.jpg

निम्नलिखित आउटपुट होगा:

## Command Arguments #################################################
input_path:example-image-containing-text.jpg
action:Highlight
search_str:BERT
pages:None
generate_output:False
output_file:None
highlight_readable_text:False
show_comparison:False
######################################################################
## Summary ########################################################
File:example-image-containing-text.jpg
Total readable words:192
Total matches:3
Confidence score:89.89337547979804
###################################################################

और वर्तमान निर्देशिका में एक नई छवि दिखाई दी है:

ओसीआर पायथन का उपयोग करके छवि में पाठ को हाइलाइट करनाआप सभी खोजे गए टेक्स्ट को पास कर सकते हैं -tया --highlight-readable-textहाइलाइट कर सकते हैं (एक अलग प्रारूप के साथ, ताकि खोज स्ट्रिंग को दूसरों से अलग किया जा सके)।

आप मूल छवि और संपादित छवि को एक ही विंडो में पास -cया --show-comparisonप्रदर्शित करने के लिए भी कर सकते हैं।

अब यह छवियों के लिए काम कर रहा है, आइए पीडीएफ फाइलों के लिए प्रयास करें:

$ python pdf_ocr.py -s "BERT" -i image.pdf -o output.pdf --generate-output -a "Highlight"

image.pdfपिछले उदाहरण में छवि वाली एक साधारण पीडीएफ फाइल है (फिर से, आप इसे यहां प्राप्त कर सकते हैं )।

इस बार हमने -iतर्क के लिए एक पीडीएफ फाइल पास की है, और output.pdfपरिणामी पीडीएफ फाइल के रूप में (जहां सभी हाइलाइटिंग होती है)। उपरोक्त आदेश निम्न आउटपुट उत्पन्न करता है:

## Command Arguments #################################################
input_path:image.pdf
action:Highlight
search_str:BERT
pages:None
generate_output:True
output_file:output.pdf
highlight_readable_text:False
show_comparison:False
######################################################################
## Summary ########################################################
File:image.pdf
Total pages:1
Processed pages:1
Total readable words:192.0
Total matches:3.0
Confidence score:83.1775128855722
Output file:output.pdf
Content file:image.csv

Pages Statistics:
   page  page_readable_items  page_matches  page_total_confidence
0   1.0                192.0           3.0              83.177513
###################################################################

output.pdfफ़ाइल निष्पादन, जहां यह एक ही मूल PDF लेकिन प्रकाश डाला पाठ के साथ शामिल करने के बाद उत्पादन किया जाता है। इसके अतिरिक्त, अब हमारे पास हमारी पीडीएफ फाइल के बारे में आंकड़े हैं, जहां कुल 192 शब्दों का पता चला है, और लगभग 83.2% के विश्वास के साथ हमारी खोज का उपयोग करके 3 का मिलान किया गया था।

एक CSV फ़ाइल भी तैयार की जाती है जिसमें प्रत्येक पंक्ति पर छवि से पता लगाया गया पाठ शामिल होता है।

निष्कर्ष

ऐसे अन्य पैरामीटर हैं जिनका हमने अपने उदाहरणों में उपयोग नहीं किया है, उन्हें बेझिझक एक्सप्लोर करें। आप -iपीडीएफ फाइलों के संग्रह को स्कैन करने के लिए तर्क के लिए एक संपूर्ण फ़ोल्डर भी पास कर सकते हैं ।

Tesseract स्वच्छ और स्पष्ट दस्तावेजों को स्कैन करने के लिए एकदम सही है। खराब गुणवत्ता वाला स्कैन ओसीआर में खराब परिणाम दे सकता है। आम तौर पर, यह आंशिक रोड़ा, विकृत परिप्रेक्ष्य और जटिल पृष्ठभूमि सहित कलाकृतियों से प्रभावित छवियों के सटीक परिणाम नहीं देता है।

यहां पूरा कोड प्राप्त करें

#python