इस पोस्ट का अनुवाद एक एआई द्वारा किया गया है और इसे केवल सतही रूप से बैक ट्रांसलेशन के माध्यम से जांचा गया है।

बहुभाषी ब्लॉगिंग में क्यों रुचि रखें

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

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

लक्षित भाषाओं का चयन

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

पाइपलाइन बनाना

अनुवाद के लिए एआई का लाभ उठाना

क्यों कोई जनरेटिव एआई (जैसे OpenAI) को नियम-आधारित प्रणाली (जैसे Google Translate) के मुकाबले स्वचालित अनुवाद के लिए चुन सकता है, इस पर बहुत सा साहित्य उपलब्ध है। मैंने OpenAI को चुनने का मुख्य कारण व्यक्तिगत अनुभव है। जब मैं अन्य भाषाओं से अंग्रेजी में सामग्री का अनुवाद करता हूं, तो मैंने देखा है कि नियम-आधारित अनुवाद अक्सर मुझे अजीब व्याकरण देते हैं। मैं कल्पना नहीं कर सकता कि अन्य भाषाओं को बेहतर अनुभव मिलेगा। एआई का उपयोग करके, मैं अधिक प्राकृतिक ध्वनि वाले अनुवाद प्राप्त करने की उम्मीद कर रहा हूं।

OpenAI पाइपलाइन सेट करना

OpenAI के पास पहले से ही एक सीधा और अच्छी तरह से प्रलेखित पायथन पैकेज है जो उनके एपीआई को लपेटता है। पायथन में पहले से ही अच्छी तरह से अनुभव होने के कारण, अपने अनुवाद सेटअप के लिए इसका उपयोग करना एक सरल निर्णय था।

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

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

हम एक साधारण पायथन स्क्रिप्ट के साथ कुंजी का परीक्षण कर सकते हैं ताकि यह सुनिश्चित किया जा सके कि हमने इसे सही तरीके से सेट किया है।

"""OpenAI API कुंजी मान्य है या नहीं, इसका परीक्षण करें।"""
   कुंजी = get_openapi_key()
   क्लाइंट = OpenAI(api_key=कुंजी)

   पूर्णता = क्लाइंट.chat.completions.create(
   	model="gpt-4o-mini",
   	messages=[
       	{
           	"role": "system",
           	"content": "आप एक स्वास्थ्य-चेक API हैं। बस 'OK' का उत्तर दें",
       	},
       	{"role": "user", "content": "चेक करें"},
   	],
   )
   यदि पूर्णता.choices[0].message.content == "OK":
   	print("OpenAI कुंजी मान्य और कार्यशील है")
   अन्य:
   	print(पूर्णता.choices[0].message)

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

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

def openai_format(
	id: str, model: str, language: str, dialect: str, content: str
) -> dict:
	if dialect:
    	system_message = f"""आप एक अनुवाद बैकएंड हैं।
    	उपयोगकर्ता इनपुट का अनुवाद {language} में {dialect}
    	बोलचाल का उपयोग करते हुए करें। केवल अनुवाद लौटाएं
    	markdown संरचना को बनाए रखते हुए। यह संभव है कि आप
    	mid-code block से शुरू कर रहे हैं।"""
	else:
    	system_message = f"""आप एक अनुवाद बैकएंड हैं।
    	उपयोगकर्ता इनपुट का अनुवाद {language} में करें। केवल लौटाएं
    	अनुवाद मिलान करने वाले markdown प्रारूप में। यह
    	संभव है कि आप mid-code block से शुरू कर रहे हैं।"""
	formatted_prompt = {
    	"custom_id": id,
    	"method": "POST",
    	"url": "/v1/chat/completions",
    	"body": {
        	"model": model,
        	"messages": [
            	{"role": "system", "content": system_message},
            	{"role": "user", "content": content},
        	],
        	"temperature": 0.1,
    	},
	}
	return formatted_prompt

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

import json
from tempfile import TemporaryDirectory
from openai import OpenAI

def send_openai_batch(formatted_prompts: list, description=None):
	key = get_openapi_key()
	client = OpenAI(api_key=key)
	if not description:
    	description = "Markdown translation batch"
	with TemporaryDirectory() as tmpdirname:
    	with open(f"{tmpdirname}/batchinput.json", "a") as f:
        	for prompt in formatted_prompts:
            	f.write(json.dumps(prompt) + "\n")

    	batch_input_file = client.files.create(
        	file=open(f"{tmpdirname}/batchinput.json", "rb"),
        	purpose="batch"
    	)

    	batch_input_file_id = batch_input_file.id

    	batch = client.batches.create(
        	input_file_id=batch_input_file_id,
        	endpoint="/v1/chat/completions",
        	completion_window="24h",
        	metadata={"description": description},
    	)
	return batch

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

from time import sleep

def openai_check_results(batch_id: str):
	key = get_openapi_key()
	client = OpenAI(api_key=key)
	result = client.batches.retrieve(batch_id)
	return result


def wait_for_openai(batch_id: str):
	while True:
    	result = openai_check_results(batch_id)
    	if result.status in ["validating", "in_progress"]:
        	print(f"OpenAI का इंतज़ार कर रहे हैं (बैच की स्थिति {result.status})")
        	sleep(5)
        	continue
    	else:
        	break
	if result.status in ["failed", "expired",
                 	"canceling", "canceled"]:
    	raise ValueError(f"OpenAI बैच {batch_id} विफल रहा")

वास्तविक परिणाम प्राप्त करना बहुत सीधा है। एक बार जब हमें हरी बत्ती मिल जाती है, तो हम बस परिणाम वस्तु से पाठ प्राप्त कर सकते हैं। लौटाया गया मान JSON-फॉर्मेटेड स्ट्रिंग्स की एक श्रृंखला है, जो उसी प्रारूप में है जिसका हमने अनुरोध के लिए उपयोग किया था। एक बार जब हम JSON लोड कर लेते हैं, तो OpenAI की प्रतिक्रिया result["response"]["body"]["choices"][0]["message"]["content"] में छिपी होती है।

from collections import defaultdict

def build_openai_results(batch_id: str):
	key = get_openapi_key()
	client = OpenAI(api_key=key)
	result = openai_check_results(batch_id)

	file_response = client.files.content(result.output_file_id
	).text.split("\n")

	result_dict = defaultdict(dict)

	for json_str in file_response:
    	if json_str == "":
        	continue
    	result = json.loads(json_str)
    	id = result["custom_id"]
    	result_dict[id] = result["response"]["body"][
            	"choices"][0]["message" ]["content"]

	return result_dict

निष्कर्ष

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