चैटजीपीटी, गूगल क्लाउड और पायथन के साथ एक दस्तावेज़ विश्लेषक बनाएं

जब OpenAI ने चैटजीपीटी को आम जनता के लिए जारी किया, तो OpenAI के अधिकारियों सहित कुछ ही लोग, आम जनता द्वारा इसे अपनाने की गति का अनुमान लगा सकते थे। तब से, ChatGPT ने 100 मिलियन उपयोगकर्ताओं तक पहुंचने वाले सबसे तेज़ ऐप के रूप में टिकटॉक को पीछे छोड़ दिया है। जीवन के सभी क्षेत्रों के लोगों ने अपनी दक्षता में सुधार करने के लिए ChatGPT का उपयोग करने के तरीके ढूंढ लिए हैं, और कंपनियों ने इसके उपयोग पर दिशानिर्देश विकसित करने के लिए प्रयास किया है। कई शैक्षणिक संस्थानों सहित कुछ संगठन, इसके उपयोग के बारे में ज्यादातर संशय में रहे हैं, जबकि प्रौद्योगिकी कंपनियों जैसे अन्य संगठनों ने बहुत अधिक उदार नीति अपनाई है, यहां तक कि चैटजीपीटी एपीआई के आसपास एप्लिकेशन भी बना रहे हैं। आज, हम एक ऐसे एप्लिकेशन के निर्माण के बारे में जानेंगे।

लक्षित दर्शक

यह आलेख तीन भागों में विभाजित है: 1) एप्लिकेशन में अंतर्निहित प्रौद्योगिकियों की व्याख्या, 2) एप्लिकेशन का बैक-एंड, और 3) एप्लिकेशन का फ्रंट-एंड। यदि आप कुछ बुनियादी पायथन कोड पढ़ सकते हैं, तो आप पहले दो खंडों का आसानी से पालन करने में सक्षम होंगे, और यदि आपके पास React.js के साथ कुछ बुनियादी अनुभव है, तो आप बिना किसी समस्या के तीसरे खंड का पालन कर सकते हैं।

आवेदन पत्र

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

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

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

यदि आप अभी ऐप बनाना चाहते हैं, तो बेझिझक अगला भाग छोड़ दें। हालाँकि, यदि आप इस लेख में हमारे द्वारा उपयोग की जाने वाली विभिन्न तकनीकों की बेहतर समझ प्राप्त करना चाहते हैं, तो अगला भाग आपको थोड़ी पृष्ठभूमि देगा।

अंतर्निहित प्रौद्योगिकियाँ

पहली तकनीक जो हम उपयोग करेंगे वह ओसीआर, या ऑप्टिकल कैरेक्टर रिकॉग्निशन है, जो आम जनता के लिए उपलब्ध होने वाले शुरुआती व्यावसायिक मशीन लर्निंग अनुप्रयोगों में से एक है। ओसीआर मॉडल और एप्लिकेशन का लक्ष्य एक तस्वीर या छवि लेना है और फिर छवि से पाठ्य जानकारी को पहचानना और निकालना है। पहली बार में यह एक आसान काम लग सकता है, लेकिन वास्तव में समस्या काफी जटिल है। उदाहरण के लिए, अक्षर थोड़े धुंधले हो सकते हैं, जिससे सकारात्मक पहचान करना मुश्किल हो जाता है। पत्र को एक असामान्य अभिविन्यास में भी व्यवस्थित किया जा सकता है, जिसका अर्थ है कि मशीन लर्निंग मॉडल को ऊर्ध्वाधर और उल्टे पाठ की पहचान करनी होगी। इन चुनौतियों के बावजूद, शोधकर्ताओं ने कई तेज़ और शक्तिशाली ओसीआर मॉडल विकसित किए हैं, और उनमें से कई अपेक्षाकृत कम कीमत पर उपलब्ध हैं। आज के एप्लिकेशन के लिए, हम Google के क्लाउड विज़न मॉडल का उपयोग करेंगे, जिसे हम Google क्लाउड एपीआई का उपयोग करके एक्सेस कर सकते हैं।

अगली तकनीक जो हम उपयोग करेंगे वह मशीनी अनुवाद है। यह, OCR की तरह, एक अत्यंत कठिन मशीन सीखने की समस्या है। मानव भाषा विशिष्टताओं और प्रासंगिक जटिलताओं से भरी है जो कंप्यूटर के लिए इसे संसाधित करना और समझना विशेष रूप से कठिन बना देती है। चीनी और अंग्रेजी जैसे असमान भाषा युग्मों के बीच अनुवाद विशेष रूप से गलत और हास्यप्रद परिणाम देता है क्योंकि इन भाषाओं की स्वाभाविक रूप से भिन्न संरचना के कारण डिजिटलीकरण और एम्बेडिंग के लिए बहुत अलग रणनीतियों की आवश्यकता होती है। हालाँकि, इन चुनौतियों के बावजूद, शोधकर्ताओं ने शक्तिशाली और परिष्कृत मॉडल विकसित किए हैं और उन्हें आम तौर पर उपलब्ध कराया है। आज, हम Google के अनुवाद एपीआई का उपयोग करेंगे, जो उपलब्ध सर्वोत्तम और सबसे व्यापक रूप से उपयोग किए जाने वाले मशीनी अनुवाद टूल में से एक है।

आखिरी मशीन लर्निंग तकनीक जिसका हम उपयोग करेंगे वह एलएलएम या लार्ज लैंग्वेज मॉडल है, जो उपभोक्ता कृत्रिम बुद्धिमत्ता के लिए क्रांतिकारी रही है। एलएलएम प्राकृतिक मानव भाषा की संरचना को समझने में सक्षम है, और विस्तृत और सूचनात्मक प्रतिक्रिया उत्पन्न करने के लिए डेटा के एक बड़े समूह को आकर्षित करने में सक्षम है। प्रौद्योगिकी की अभी भी कई सीमाएँ हैं, लेकिन इसके लचीलेपन और डेटा प्रोसेसिंग क्षमताओं ने मॉडल के साथ जुड़ने के लिए कई नई तकनीकों के निर्माण को प्रेरित किया है। ऐसी एक तकनीक को प्रॉम्प्ट इंजीनियरिंग कहा जाता है, जहां उपयोगकर्ता वांछित परिणाम प्राप्त करने के लिए मॉडल में कुशलतापूर्वक शब्दों और संरचित इनपुट या संकेतों को तैयार और संशोधित करते हैं। आज के एप्लिकेशन में, हम अनुवादित रिपोर्ट का विश्लेषण करने में मदद के लिए चैटजीपीटी के एपीआई और कुछ सरल प्रॉम्प्ट इंजीनियरिंग का उपयोग करेंगे।

बैकएंड

क्लाउड सेवा सेटअप

इससे पहले कि हम एप्लिकेशन को कोड करना शुरू करें, हमें पहले सेवाओं के लिए साइन अप करना होगा।

क्योंकि चैटजीपीटी की एपीआई वेबसाइट हमेशा बदलती रहती है, हम चैटजीपीटी एपीआई के लिए साइन अप करने के सटीक चरण प्रदान नहीं कर पाएंगे। हालाँकि, आपको एपीआई दस्तावेज़ीकरण वेबसाइट पर पालन करने में आसान निर्देश मिलने चाहिए। जब तक आप एक एपीआई कुंजी प्राप्त नहीं कर लेते, तब तक आगे बढ़ें, जिसे हमें चैटजीपीटी एपीआई को कॉल करने की आवश्यकता होगी।

Google क्लाउड थोड़ा अधिक जटिल है, लेकिन इसमें साइन अप करना भी अपेक्षाकृत सरल है। बस Google क्लाउड कंसोल पर जाएं और प्रोजेक्ट स्थापित करने के लिए निर्देशों का पालन करें। एक बार प्रोजेक्ट में, आप IAM और एडमिन कंसोल पर नेविगेट करना चाहेंगे, और एक सेवा खाता बनाना चाहेंगे। जबकि Google क्लाउड कंसोल हर समय बदल रहा है, आपको वेबपेज पर केवल "IAM" और "सेवा खाता" खोजकर इंटरफ़ेस को नेविगेट करने में सक्षम होना चाहिए। एक बार सेवा खाता बन जाने के बाद, आप निजी कुंजी फ़ाइल की प्रति अपने कंप्यूटर पर डाउनलोड करना चाहेंगे। आप निजी कुंजी स्ट्रिंग की प्रतिलिपि भी बनाना चाहेंगे, क्योंकि अनुवाद REST API कुंजी फ़ाइल के बजाय निजी कुंजी स्ट्रिंग का उपयोग करता है।

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

पायथन सेटअप

अब जब हमने उचित सेवाओं के लिए साइन अप कर लिया है, तो हम पायथन में अपने एप्लिकेशन को कोडिंग शुरू करने के लिए तैयार हैं। सबसे पहली बात, हम अपने पायथन वातावरण में अपेक्षित पैकेज स्थापित करना चाहेंगे।

Pip install google-cloud-storage google-cloud-vision openai requests

एक बार इंस्टॉलेशन पूरा हो जाने पर, एक नया फ़ोल्डर बनाएं, पीडीएफ फ़ाइल डाउनलोड करें और उसी फ़ोल्डर में एक नई पायथन फ़ाइल बनाएं। हम इसे document_analyze.py कहेंगे. हम आवश्यक पैकेज आयात करके प्रारंभ करते हैं:

 import requests Import openai from google.cloud import vision from google.cloud import storage Import os Import json Import time Import shutil

फिर हम कुछ बुनियादी सेटअप कर सकते हैं ताकि हमारा एप्लिकेशन उन क्लाउड सेवाओं का उपयोग कर सके जिनके लिए हमने अभी साइन अप किया है:

 os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = [Path to your Google Cloud key file] openai.api_key = [your openAI API key]

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

ओसीआर कोड

अब हम कुछ ऐसे फ़ंक्शन बनाना शुरू कर सकते हैं जो एप्लिकेशन के बिल्डिंग ब्लॉक बन जाएंगे। आइए OCR फ़ंक्शंस से शुरुआत करें:

 # upload the file to google cloud storage bucket for further processing def upload_file(file_name, bucket_name, bucket_path): client = storage.Client() bucket = client.get_bucket(bucket_name) blob = bucket.blob(bucket_path) blob.upload_from_filename(file_name) # kick off the OCR process on the document. This is asynchronous because OCR can take a while def async_detect_document(gcs_source_uri, gcs_destination_uri): client = vision.ImageAnnotatorClient() input_config = vision.InputConfig(gcs_source=vision.GcsSource(uri=gcs_source_uri), mime_type= 'application/pdf') output_config = vision.OutputConfig( gcs_destination=vision.GcsDestination(uri=gcs_destination_uri), batch_size=100 ) async_request = vision.AsyncAnnotateFileRequest( features=[vision.Feature(type_=vision.Feature.Type.DOCUMENT_TEXT_DETECTION)], input_config=input_config, output_config=output_config ) operation = client.async_batch_annotate_files(requests=[async_request]) def check_results(bucket_path, prefix): storage_client = storage.Client() bucket = storage_client.get_bucket(bucket_path) blob_list = list(bucket.list_blobs(prefix=prefix)) blb = [b for b in blob_list if 'output-' in b.name and '.json' in b.name] return len(blb) != 0 # download the OCR result file def write_to_text(bucket_name, prefix): bucket = storage.Client().get_bucket(bucket_name) blob_list = list(bucket.list_blobs(prefix=prefix)) if not os.path.exists('ocr_results'): os.mkdir('ocr_results') for blob in blob_list: if blob.name.endswith('.json'): with open(os.path.join('ocr_results', blob.name), 'w') as fp_data: fp_data.write(blob.download_as_string().decode('utf-8')) def delete_objects(bucket, prefix): bucket = storage.Client().get_bucket(bucket) blob_list = list(bucket.list_blobs(prefix=prefix)) for blob in blob_list: blob.delete() print('Blob', blob.name, 'Deleted')

आइए विस्तार से देखें कि प्रत्येक फ़ंक्शन क्या करता है।

upload_file फ़ंक्शन एक ऐसा फ़ंक्शन है जो Google क्लाउड स्टोरेज कंटेनर से एक बकेट लेता है और आपकी फ़ाइल को उसमें अपलोड करता है। Google क्लाउड के उत्कृष्ट सार-संक्षेप इस फ़ंक्शन को लिखना बहुत आसान बनाते हैं।

async_detect_document फ़ंक्शन एसिंक्रोनस रूप से Google क्लाउड के OCR फ़ंक्शन को आमंत्रित करता है। Google क्लाउड में उपलब्ध विकल्पों की संख्या के कारण, हमें कुछ कॉन्फ़िगरेशन ऑब्जेक्ट को तुरंत चालू करना पड़ता है, लेकिन यह वास्तव में Google क्लाउड को यह बताता है कि स्रोत फ़ाइल कहां है और आउटपुट कहां लिखा जाना चाहिए। batch_size वेरिएबल 100 पर सेट है, इसलिए Google क्लाउड दस्तावेज़ को एक बार में 100 पृष्ठों पर संसाधित करेगा। इससे लिखी जाने वाली आउटपुट फ़ाइलों की संख्या कम हो जाती है, जिससे प्रोसेसिंग आसान हो जाती है। ध्यान देने योग्य एक और महत्वपूर्ण बात यह है कि आह्वान अतुल्यकालिक है, जिसका अर्थ है कि प्रसंस्करण समाप्त होने की प्रतीक्षा करने के बजाय पायथन स्क्रिप्ट का निष्पादन जारी रहेगा। हालाँकि इससे इस विशेष चरण में कोई बड़ा फर्क नहीं पड़ता है, यह बाद में और अधिक उपयोगी हो जाएगा जब हम पायथन कोड को वेब एपीआई में बदल देंगे।

check_results फ़ंक्शन यह जांचने के लिए एक सरल क्लाउड स्टोरेज फ़ंक्शन है कि प्रोसेसिंग पूरी हो गई है या नहीं। क्योंकि हम ओसीआर फ़ंक्शन को अतुल्यकालिक रूप से लागू कर रहे हैं, हमें यह देखने के लिए समय-समय पर इस फ़ंक्शन को कॉल करने की आवश्यकता है कि परिणाम फ़ाइल मौजूद है या नहीं। यदि कोई परिणाम फ़ाइल है, तो फ़ंक्शन सत्य लौट आएगा, और हम विश्लेषण जारी रख सकते हैं। यदि कोई परिणाम फ़ाइल नहीं है, तो फ़ंक्शन गलत लौट आएगा और हम प्रसंस्करण समाप्त होने तक प्रतीक्षा करना जारी रखेंगे।

write_to_text फ़ंक्शन आगे की प्रक्रिया के लिए परिणाम फ़ाइल(फ़ाइलों) को डिस्क पर डाउनलोड करता है। फ़ंक्शन एक विशेष उपसर्ग के साथ आपकी बकेट की सभी फ़ाइलों पर पुनरावृति करेगा, आउटपुट स्ट्रिंग पुनर्प्राप्त करेगा, और परिणाम को स्थानीय फ़ाइल सिस्टम पर लिखेगा।

delete_objects फ़ंक्शन, हालांकि ओसीआर के लिए पूरी तरह से प्रासंगिक नहीं है, अपलोड की गई फ़ाइलों को साफ करता है ताकि सिस्टम Google क्लाउड स्टोरेज में अनावश्यक कलाकृतियों को न रखे।

अब जब हमने ओसीआर आमंत्रण का काम पूरा कर लिया है, तो आइए मशीनी अनुवाद कोड पर नजर डालें!

मशीनी अनुवाद कोड

अब हम अनुवाद कार्यों को परिभाषित कर सकते हैं:

 # detect the language we're translating from def detect_language(text): url = 'https://translation.googleapis.com/language/translate/v2/detect' data = { "q": text, "key": [your google cloud API key] } res = requests.post(url, data=data) return res.json()['data']['detections'][0][0]['language'] # translate the text def translate_text(text): url = 'https://translation.googleapis.com/language/translate/v2' language = detect_language(text) if language == 'en': return text data = { "q": text, "source": language, "target": "en", "format": "text", "key": [your google cloud API key] } res = requests.post(url, data=data) return res.json()['data']['translations'][0]['translatedText']

ये कार्य अपेक्षाकृत सीधे हैं। detect_language फ़ंक्शन बाद के translate_text कॉल के लिए स्रोत भाषा निर्धारित करने के लिए भाषा डिटेक्शन एपीआई को कॉल करता है। जबकि हम जानते हैं कि पीडीएफ जापानी भाषा में लिखा गया है, फिर भी भाषा पहचान को चलाना सर्वोत्तम अभ्यास है ताकि एप्लिकेशन अन्य भाषाओं को संभाल सके। translate_text फ़ंक्शन, खोजी गई स्रोत भाषा से पाठ को अंग्रेजी में अनुवाद करने के लिए बस Google अनुवाद एपीआई का उपयोग करता है, हालांकि, यदि यह निर्धारित करता है कि स्रोत भाषा पहले से ही अंग्रेजी है, तो यह अनुवाद को छोड़ देगा।

चैटजीपीटी कोड और प्रॉम्प्ट इंजीनियरिंग

अंत में, हमारे पास ChatGPT का आह्वान है:

 def run_chatgpt_api(report_text): completion = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "user", "content": ''' Consider the following report: --- %s --- 1. Summarize the purpose of the report. 2. Summarize the primary conclusion of the report. 3. Summarize the secondary conclusion of the report 4. Who is the intended audience for this report? 5. What other additional context would a reader be interested in knowing? Please reply in json format with the keys purpose, primaryConclusion, secondaryConclusion, intendedAudience, and additionalContextString. ''' % report_text}, ] ) return completion.choices[0]['message']['content']

ध्यान दें कि पायथन कॉल एक अपेक्षाकृत सरल एपीआई कॉल है, लेकिन संकेत विशिष्ट परिणाम उत्पन्न करने के लिए लिखा गया है:

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

2. प्रश्नों को पैराग्राफ प्रारूप में बताए जाने के बजाय सूचीबद्ध किया गया है। इसलिए प्रतिक्रिया एक समान संरचना का अनुसरण करने की संभावना है। चैटजीपीटी द्वारा पैराग्राफ प्रारूप में उत्तर देने की तुलना में गणना की गई संरचना परिणाम को कोड के साथ पार्स करना अधिक आसान बनाती है।

3. संकेत उत्तर के प्रारूप को निर्दिष्ट करता है, इस मामले में JSON प्रारूप। JSON प्रारूप को कोड के साथ संसाधित करना बहुत आसान है।

4. प्रॉम्प्ट JSON ऑब्जेक्ट की कुंजियाँ निर्दिष्ट करता है, और ऐसी कुंजियाँ चुनता है जिन्हें प्रश्नों के साथ जोड़ना बहुत आसान है।

5. कुंजियाँ आमतौर पर उपयोग किए जाने वाले कन्वेंशन (कैमलकेस) का भी उपयोग करती हैं जिसे चैटजीपीटी को पहचानना चाहिए। JSON कुंजियाँ संकुचन के बजाय पूर्ण शब्द हैं। इससे यह अधिक संभावना है कि चैटजीपीटी प्रतिक्रिया में वास्तविक कुंजी का उपयोग करेगा, क्योंकि चैटजीपीटी को अपने प्रसंस्करण के हिस्से के रूप में "वर्तनी सुधार" करने की आदत है।

6. एडिशनल कॉन्टेक्स्टस्ट्रिंग चैटजीपीटी को अतिरिक्त जानकारी देने के लिए एक आउटलेट प्रदान करता है। यह बड़े भाषा मॉडलों की फ्रीफॉर्म विश्लेषण क्षमता का लाभ उठाता है।

7. संकेत उस वाक्यांश का उपयोग करता है जो अक्सर विषय की तकनीकी चर्चाओं में पाया जाता है। जैसा कि आपने एपीआई कॉल की संरचना से अनुमान लगाया होगा, चैटजीपीटी का "सही" लक्ष्य आवश्यक रूप से संकेत का उत्तर प्रदान करना नहीं है, बल्कि संवाद में अगली पंक्ति की भविष्यवाणी करना है।

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

उपरोक्त कार्य के एक नए निकाय में बुनियादी तकनीकें हैं जिन्हें "प्रॉम्प्ट इंजीनियरिंग" कहा जाता है, जहां उपयोगकर्ता एक विशिष्ट परिणाम प्राप्त करने के लिए अपने संकेतों की संरचना करता है। चैटजीपीटी जैसे बड़े भाषा मॉडल के साथ, प्रॉम्प्ट की सावधानीपूर्वक रचना के परिणामस्वरूप मॉडल की प्रभावशीलता में नाटकीय वृद्धि हो सकती है। कोडिंग में कई समानताएँ हैं, लेकिन त्वरित इंजीनियरिंग के लिए इंजीनियर की ओर से बहुत अधिक अंतर्ज्ञान और अस्पष्ट तर्क की आवश्यकता होती है। जैसे-जैसे चैटजीपीटी जैसे उपकरण कार्यस्थल में अधिक अंतर्निहित हो जाते हैं, इंजीनियरिंग अब केवल एक तकनीकी प्रयास नहीं बल्कि एक दार्शनिक प्रयास भी होगा, और इंजीनियरों को बड़े भाषा मॉडल को बढ़ावा देने के लिए अपने अंतर्ज्ञान और "मन के सिद्धांत" को विकसित करने का ध्यान रखना चाहिए। उनकी दक्षता.

यह सब एक साथ डालें

अब आइए इसे सब एक साथ रखें। यदि आपने पिछले अनुभाग का अनुसरण किया है, तो नीचे दिया गया कोड ब्लॉक समझने में काफी सरल होना चाहिए।

 bucket = [Your bucket name] upload_file_name = [the name of the PDF in the Google Cloud bucket] upload_prefix = [the prefix to use for the analysis results] pdf_to_analyze = [path to the PDF to analyze] upload_file(pdf_to_analyze, bucket, upload_file_name) async_detect_document(f'gs://{bucket}/{upload_file_name}', f'gs://{bucket}/{upload_prefix}') while not check_results(bucket, upload_prefix): print('Not done yet... checking again') time.sleep(5) If __name__ == '__main__': write_to_text(bucket, upload_prefix) all_responses = [] for result_json in os.listdir('ocr_results'): with open(os.path.join('ocr_results', result_json)) as fp_res: response = json.load(fp_res) all_responses.extend(response['responses']) texts = [a['fullTextAnnotation']['text'] for a in all_responses] translated_text = [translate_text(t) for t in texts] print('Running cleanup...') delete_objects(bucket, upload_file_name) delete_objects(bucket, upload_prefix) shutil.rmtree('ocr_results') print('Running Analysis...') analysis = run_chatgpt_api('\n'.join(translated_text)) print('=== purpose ====') print(analysis_res['purpose']) print() print('==== primary conclusion =====') print(analysis_res['primaryConclusion']) print() print('==== secondary conclusion =====') print(analysis_res['secondaryConclusion']) print() print('==== intended audience ====') print(analysis_res['intendedAudience']) print() print('===== additional context =====') print(analysis_res['additionalContextString'])

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

क्योंकि एआई उपकरण नियतिवादी नहीं हैं, यदि आप इस कोड को चलाते हैं तो आपको संभवतः एक समान लेकिन समान परिणाम नहीं मिलेगा। हालाँकि, ऊपर लिंक किए गए पीडीएफ का उपयोग करके मुझे आउटपुट के रूप में जो मिला वह यहां दिया गया है:

 Not done yet... checking again Not done yet... checking again Running cleanup... Blob [pdf name] Deleted Blob [OCR Output Json] Deleted Running Analysis... === purpose ==== The purpose of the report is to analyze the current status and issues of Japan's research capabilities, discuss the government's growth strategy and investment in science and technology, and introduce the initiatives towards realizing a science and technology nation. ==== primary conclusion ===== The primary conclusion of the report is that Japan's research capabilities, as measured by publication index, have been declining internationally, raising concerns about a decline in research capabilities. ==== secondary conclusion ===== The secondary conclusion of the report is that the Kishida Cabinet's growth strategy emphasizes becoming a science and technology nation and strengthening investment in people to achieve growth and distribution. ==== intended audience ==== The intended audience for this report is government officials, policymakers, researchers, and anyone interested in Japan's research capabilities and science and technology policies. ===== additional context ===== The report focuses on the importance of science, technology, and innovation for Japan's future development and highlights the government's efforts to promote a 'new capitalism' based on a virtuous cycle of growth and distribution. It also mentions the revision to the Basic Law on Science, Technology, and Innovation, the 6th Science, Technology, and Innovation Basic Plan, and the concept of Society 5.0 as the future society Japan aims for. The report suggests that comprehensive knowledge is necessary to promote science, technology, and innovation and emphasizes the importance of transcending disciplinary boundaries and utilizing diverse knowledge.

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

पूरा बैकएंड कोड मेरे GitHub पर पाया जा सकता है

फ्रंटएंड

हमने पहले से ही एक शक्तिशाली ऐप बनाया है, लेकिन इसके वर्तमान स्वरूप में उपयोगकर्ता को एप्लिकेशन को पूरी तरह से उपयोग करने के लिए पायथन के बारे में थोड़ा जानना होगा। यदि आपके पास कोई उपयोगकर्ता हो जो कोई कोड पढ़ना या लिखना नहीं चाहता तो क्या होगा? उस स्थिति में, हम इस टूल के इर्द-गिर्द एक वेब एप्लिकेशन बनाना चाहेंगे, ताकि लोग ब्राउज़र के आराम से एआई की पूरी शक्ति का उपयोग कर सकें।

रिएक्ट एप्लिकेशन को मचान बनाना

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

npx create-react-app llm-frontend

और तब:

 cd llm-frontend npm install bootstrap react-bootstrap axios

यदि हम एक पूर्ण एप्लिकेशन विकसित कर रहे थे तो हम राज्य प्रबंधन और रूटिंग को संभालने के लिए पैकेज भी स्थापित करना चाहेंगे, लेकिन यह इस आलेख के दायरे से बाहर है। हम बस App.jsx फ़ाइल में संपादन करेंगे।

विकास सर्वर शुरू करने के लिए npm run start निष्पादित करें, और आपके ब्राउज़र को http://localhost:3000 पर एक पेज खोलना चाहिए। उस पेज को रखें, और अपने पसंदीदा टेक्स्ट एडिटर में App.jsx फ़ाइल खोलें। आपको कुछ इस तरह देखना चाहिए:

 import logo from './logo.svg'; import './App.css'; function App() { return ( <div className="App"> <header className="App-header"> <img src={logo} className="App-logo" alt="logo" /> <p> Edit <code>src/App.js</code> and save to reload. </p> <a className="App-link" href="https://reactjs.org" target="_blank" rel="noopener noreferrer" > Learn React </a> </header> </div> ); } export default App;

आगे बढ़ें और बॉयलरप्लेट कोड हटाएं और इसे कुछ बुनियादी बूटस्ट्रैप घटकों से बदलें।

 import React, {useState, useEffect} from 'react'; Import axios from 'axios'; import Container from 'react-bootstrap/Container'; import Row from 'react-bootstrap/Row'; import Col from 'react-bootstrap/Col'; import 'bootstrap/dist/css/bootstrap.min.css'; function App() { return ( <Container> <Row> <Col md={{ span: 10, offset: 1 }}> Main Application Here </Col> </Row> </Container> ); } export default App;

ऐप सहेजें, और आपको इसे ब्राउज़र में अपडेट देखना चाहिए। अब यह काफी विरल लगेगा, लेकिन चिंता न करें, हम इसे जल्द ही ठीक कर लेंगे।

अनुप्रयोग घटक

इस एप्लिकेशन को काम करने के लिए, हमें चार मुख्य घटकों की आवश्यकता होगी: फ़ाइल अपलोड करने के लिए एक फ़ाइल चयनकर्ता, अनुवाद और सारांश प्रदर्शित करने के लिए एक परिणाम डिस्प्ले, एक टेक्स्ट इनपुट ताकि उपयोगकर्ता अपने प्रश्न पूछ सकें, और प्रदर्शित करने के लिए एक परिणाम डिस्प्ले उपयोगकर्ता के प्रश्नों का उत्तर.

हम सरल घटकों का निर्माण कर सकते हैं और अभी के लिए अधिक जटिल इंटरफेस के लिए प्लेसहोल्डर रख सकते हैं। जब हम इस पर काम कर रहे हों, तो आइए डेटा कंटेनर बनाएं जिनका उपयोग हम इंटरफ़ेस को पावर देने के लिए करेंगे:

 import React, {useState, useEffect} from 'react'; import axios from 'axios'; import Container from 'react-bootstrap/Container'; import Row from 'react-bootstrap/Row'; import Col from 'react-bootstrap/Col'; import Button from 'react-bootstrap/Button'; import Accordion from 'react-bootstrap/Accordion'; import Form from 'react-bootstrap/Form'; import ListGroup from 'react-bootstrap/ListGroup'; import 'bootstrap/dist/css/bootstrap.min.css'; const ResultDisplay = ({ initialAnalysis, userQuestion, setUserQuestion, userQuestionResult, userQuestionMessage, userQuestionAsked }) => { return <Row> <Col> <Row style={{marginTop: '10px'}}> <Col md={{ span: 10, offset: 1 }}> <Accordion defaultActiveKey="0"> <Accordion.Item eventKey="0"> <Accordion.Header>Analysis Result</Accordion.Header> <Accordion.Body> {initialAnalysis.analysis} </Accordion.Body> </Accordion.Item> <Accordion.Item eventKey="1"> <Accordion.Header>Raw Translated Text</Accordion.Header> <Accordion.Body> {initialAnalysis.translatedText} </Accordion.Body> </Accordion.Item> <Accordion.Item eventKey="2"> <Accordion.Header>Raw Source Text</Accordion.Header> <Accordion.Body> {initialAnalysis.rawText} </Accordion.Body> </Accordion.Item> </Accordion> </Col> </Row> <Row style={{marginTop: '10px'}}> <Col md={{ span: 8, offset: 1 }}> <Form.Control type="text" placeholder="Additional Questions" value={userQuestion} onChange={e => setUserQuestion(e.target.value)} /> </Col> <Col md={{ span: 2 }}> <Button variant="primary">Ask</Button> </Col> </Row> <Row><Col>{userQuestionMessage}</Col></Row> <Row style={{marginTop: '10px'}}> <Col md={{span: 10, offset: 1}}> {userQuestionResult && userQuestionAsked ? <ListGroup> <ListGroup.Item> <div><b>Q:</b> {userQuestionAsked}</div> <div><b>A:</b> {userQuestionResult}</div></ListGroup.Item> </ListGroup>: ''} </Col> </Row> </Col> </Row> } function App() { const [file, setFile] = useState(null); const [haveFileAnalysisResults, setHaveFileAnalysisResults] = useState(false); const [message, setMessage] = useState(''); const [userQuestionMessage, setUserMessage] = useState(''); const [initialAnalysis, setInitialAnalysis] = useState({analysis: '', translatedText: '', rawText: ''}); const [userQuestion, setUserQuestion] = useState(''); const [userQuestionResult, setUserQuestionResult] = useState(''); const [userQuestionAsked, setUserQuestionAsked] = useState(''); return ( <Container> <Row> <Col md={{ span: 8, offset: 1 }}> <Form.Group controlId="formFile"> <Form.Label>Select a File to Analyze</Form.Label> <Form.Control type="file" onChange={e => setFile(e.target.files[0])} /> </Form.Group> </Col> <Col md={{span: 2}}> <div style={{marginTop: '30px'}}><Button variant="primary" >Analyze</Button></div> </Col> <Col md={12}>{message}</Col> </Row> {haveFileAnalysisResults? <ResultDisplay initialAnalysis={initialAnalysis} userQuestion={userQuestion} setUserQuestion={setUserQuestion} userQuestionResult={userQuestionResult} userQuestionMessage={userQuestionMessage} userQuestionAsked={userQuestionAsked} />: ''} </Container>); }

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

फ़ाइल सहेजें, और आपको फ़ाइल अपलोड इंटरफ़ेस दिखाने के लिए अपना ब्राउज़र अपडेट देखना चाहिए।

वेरिएबल्स के साथ खेलें और आपको इस तरह का एक इंटरफ़ेस देखना चाहिए। यह हमारे एप्लिकेशन का फ्रंटएंड इंटरफ़ेस होगा।

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

सबसे पहले, आइए उपयोगकर्ता को संदेश भेजने के लिए कुछ उपयोगिता फ़ंक्शन लिखें।

 const flashMessageBuilder = (setMessage) => (message) => { setMessage(message); setTimeout(() => { setMessage(''); }, (5000)); } const flashMessage = flashMessageBuilder(setMessage); const flashUserQuestionMessage = flashMessageBuilder(setUserQuestionMessage);

जैसा कि आप देख सकते हैं, ये सरल फ़ंक्शन हैं जो एक संदेश को उचित स्थान पर प्रदर्शित करते हैं और 5 सेकंड के बाद संदेश को हटाने का समय बनाते हैं। यह एक साधारण यूआई सुविधा है लेकिन ऐप को अधिक गतिशील और प्रयोग करने योग्य बनाती है।

इसके बाद, आइए फ़ाइल का विश्लेषण करने और परिणामों की जांच करने के लिए फ़ंक्शन लिखें।

 const pollForResults = (batchId) => { flashMessage('Checking for results...'); return new Promise((resolve, reject) => { setTimeout(() => { axios.post('http://localhost:5000/check_if_finished', {batchId}) .then(r => r.data) .then(d => { // the result should have a "status" key and a "result" key. if (d.status === 'complete') { resolve(d); // we're done! } else { resolve(pollForResults(batchId)); // wait 5 seconds and try again. } }).catch(e => reject(e)); }, 5000); }) } const analyzeFile = () => { if (file === null) { flashMessage('No file selected!'); return; } flashMessage('Uploading file...'); const formData = new FormData(); formData.append("file", file); axios.post("http://localhost:5000/analyze_file", formData, { headers: { 'Content-Type': 'multipart/form-data' } }).then(r => r.data) .then(d => { // the result should contain a batchId that we use to poll for results. flashMessage('File upload success, waiting for analysis results...'); return pollForResults(d.batchId); }) .then(({analysis, translatedText, rawText}) => { // the result should contain the initial analysis results with the proper format. setInitialAnalysis({analysis, translatedText, rawText}); setHaveFileAnalysisResults(true); // show the results display now that we have results }) .catch(e => { console.log(e); flashMessage('There was an error with the upload. Please check the console for details.'); }) }

फिर से कार्यों का एक बहुत ही सरल सेट। एनालिसिसफ़ाइल फ़ंक्शन विश्लेषण के लिए फ़ाइल को एनालिसिस_फ़ाइल एंडपॉइंट पर भेजता है। एपीआई इसे एक बैच आईडी देगा जिसका उपयोग यह pollForResults फ़ंक्शन के साथ परिणामों की जांच करने के लिए करता है। pollForResults फ़ंक्शन check_if_finished समापन बिंदु पर पहुंचेगा और विश्लेषण समाप्त होने पर परिणाम लौटाएगा, और यदि विश्लेषण अभी भी संसाधित हो रहा है तो 5 सेकंड प्रतीक्षा करें। एनालाइज़फ़ाइल "थ्रेड" डेटा को उचित स्थानों पर डालते हुए निष्पादित करना जारी रखेगा।

अंत में, आइए उस फ़ंक्शन को लिखें जो उपयोगकर्ता को फ्रीफ़ॉर्म प्रश्न पूछने देता है:

 const askUserQuestion = () => { flashUserQuestionMessage('Asking user question...') axios.post('http://localhost:5000/ask_user_question', { text: initialAnalysis.translatedText, userQuestion }).then(r => r.data) .then(d => { setUserQuestionResult(d.result); setUserQuestionAsked(userQuestion); }).catch(e => { console.log(e); flashUserQuestionMessage('There was an issue asking the question. Please check the console for details'); }); }

फिर से, एक काफी सरल कार्य। हम उपयोगकर्ता के प्रश्न के साथ अनुवादित पाठ भी प्रदान करते हैं ताकि हमारा एपीआई चैटजीपीटी प्रॉम्प्ट का निर्माण कर सके। फिर परिणाम को प्रदर्शन के लिए उपयुक्त डेटा कंटेनरों में भेज दिया जाता है।

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

 <Accordion.Item eventKey="0"> <Accordion.Header>Analysis Result</Accordion.Header> <Accordion.Body> <h6>Purpose</h6> <p>{analysis.purpose}</p> <h6>Primary Conclusion</h6> <p>{analysis.primaryConclusion}</p> <h6>Secondary Conclusion</h6> <p>{analysis.secondaryConclusion}</p> <h6>Intended Audience</h6> <p>{analysis.intendedAudience}</p> <h6>Additional Context</h6> <p>{analysis.additionalContextString}</p> </Accordion.Body> </Accordion.Item>

अब फ्रंटएंड पूरा हो गया है, आइए अपने पायथन कोड पर जाएं और बैकएंड बनाएं।

फ्लास्क एपीआई

सबसे पहले, आइए फ्लास्क स्थापित करें, जिसका उपयोग हम अपना बैकएंड लिखने के लिए करेंगे।

Pip install flask flask-cors

फ्लास्क वेब एप्लिकेशन और वेब एपीआई बनाने के लिए एक सरल ढांचा है। इंटरफ़ेस अविश्वसनीय रूप से सरल है, और सर्वर चलाना इतना आसान है:

 from flask import Flask, request, jsonify from flask_cors import CORS app = Flask(__name__) CORS(app) @app.route('/') def hello_world(): return "Hello from flask!" if __name__ == '__main__': app.run(debug=True)

इस फ़ाइल को चलाएँ और अपने ब्राउज़र में http://localhost:5000 पर नेविगेट करें, और आपको "फ्लास्क से नमस्ते!" संदेश।

अब हम एपीआई कार्यक्षमता का निर्माण शुरू कर सकते हैं। आइए आवश्यक फ़ंक्शन आयात करके और कुछ स्थिरांक परिभाषित करके शुरुआत करें:

 from flask import Flask, request, jsonify from flask_cors import CORS import uuid import os import json from document_analyze import upload_file, async_detect_document, check_results, \ write_to_text, translate_text, delete_objects, run_chatgpt_api,\ ask_chatgpt_question app = Flask(__name__) CORS(app) BUCKET = '[YOUR BUCKET NAME]'

यह कोड मानता है कि आपका सर्वर कोड उसी फ़ोल्डर में है जिसमें document_analyze.py फ़ाइल है जिसे हमने पहले लिखा था, लेकिन आप अपनी पसंद की कोई भी निर्देशिका संरचना चुन सकते हैं, जब तक कि सर्वर कोड document_analyze.py से ढूंढ और आयात कर सकता है। आइए फ़ाइल अपलोड एंडपॉइंट के लिए हैंडलर लिखें:

 @app.route('/analyze_file', methods=['POST']) def analyze_file(): file_to_analyze = request.files['file'] batch_name = str(uuid.uuid4()) local_file_path = 'uploads/%s.pdf' % batch_name cloud_file_path = '%s.pdf' % batch_name file_to_analyze.save(local_file_path) upload_file(local_file_path, BUCKET, cloud_file_path) async_detect_document( f'gs://{BUCKET}/{cloud_file_path}', f'gs://{BUCKET}/{batch_name}') return jsonify({ 'batchId': batch_name })

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

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

 @app.route('/check_if_finished', methods=['POST']) def check_if_finished(): batch_name = request.json['batchId'] if not check_results(BUCKET, batch_name): return jsonify({ 'status': 'processing' }) write_to_text(BUCKET, batch_name) all_responses = [] for result_json in os.listdir('ocr_results'): if result_json.endswith('json') and result_json.startswith(batch_name): result_file = os.path.join('ocr_results', result_json) with open(os.path.join('ocr_results', result_json)) as fp_res: response = json.load(fp_res) all_responses.extend(response['responses']) os.remove(result_file) txts = [a['fullTextAnnotation']['text'] for a in all_responses] translated_text = [translate_text(t) for t in txts] print('Running cleanup...') delete_objects(BUCKET, batch_name) os.remove('uploads/%s.pdf' % batch_name) analysis = run_chatgpt_api('\n'.join(translated_text)) analysis_res = json.loads(analysis) return jsonify({ 'status': 'complete', 'analysis': analysis, 'translatedText': translated_text, 'rawText': '\n'.join(txts) })

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

हालाँकि कस्टम प्रश्न बैकएंड एक नई सुविधा है, लेकिन यह काफी सरल है। पहले हम एक कस्टम प्रश्न पूछने के लिए फ़ंक्शन को परिभाषित करना चाहेंगे:

 def ask_chatgpt_question(report_text, question_text): completion = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "user", "content": ''' Consider the following report: --- %s --- Answer the following question: %s ''' % (report_text, question_text)}, ] ) return completion.choices[0]['message']['content']

अब हम फ़ंक्शन आयात कर सकते हैं और एपीआई एंडपॉइंट को परिभाषित कर सकते हैं:

 @app.route('/ask_user_question') def ask_user_question(): report_text = request.json['text'] user_question = request.json['userQuestion'] response = ask_chatgpt_question(report_text, user_question) return jsonify({ 'result': response })

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

थोड़ी देर प्रतीक्षा करें, और आपको वेबएप पर परिणाम दिखाई देगा।

चारों ओर देखें और आपको अनुवादित पाठ भी दिखाई देगा:

और कच्चा स्रोत पाठ:

आइए अब कस्टम प्रश्न इंटरफ़ेस का परीक्षण करें:

बहुत अच्छा! इसके साथ, हमने अपने AI टूल के आसपास एक React.js एप्लिकेशन सफलतापूर्वक बनाया है!

निष्कर्ष

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

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

यदि आप इस ऐप को स्वयं बनाए बिना उपयोग करना चाहते हैं, तो मैंने सामान्य उपयोग के लिए एप्लिकेशन का एक अधिक परिष्कृत संस्करण बनाया और होस्ट किया है। यदि आप इस एप्लिकेशन तक पहुंच चाहते हैं, तो कृपया संपर्क करें और हम वेबसाइट तक पहुंच प्रदान कर सकते हैं।

कृपया अनुवर्ती लेख की तलाश में रहें, जहां हम एलएलएम का अपना उदाहरण बनाते और चलाते हैं। जब लेख प्रकाशित हो जाएगा, तो हम लेख का एक लिंक यहां प्रकाशित करेंगे। बने रहें!