OpenAI API और Python के साथ GPT-3 की फाइन-ट्यूनिंग

GPT-3, यानी थर्ड-जनरेशन Generative Pre-trained Transformer, OpenAI द्वारा बनाया गया एक अत्याधुनिक न्यूरल नेटवर्क डीप लर्निंग मॉडल है। इंटरनेट के विशाल डेटा का उपयोग करके, GPT-3 बहुत कम इनपुट पर भी विविध और मजबूत मशीन-जनित पाठ उत्पन्न कर सकता है। GPT-3 के अनुप्रयोगों की रेंज व्यापक है और यह केवल टेक्स्ट सारांशण, अनुवाद, चैटबॉट विकास, और कंटेंट जनरेशन तक सीमित नहीं है।

इसके बावजूद, GPT-3 के प्रदर्शन को किसी विशेष उपयोग केस पर फाइन-ट्यूनिंग करके और भी बेहतर किया जा सकता है।

लेकिन फाइन-ट्यूनिंग से हमारा क्या मतलब है?

यह पहले से प्रशिक्षित GPT-3 को किसी कस्टम उपयोग-केस डेटासेट पर प्रशिक्षित करने की प्रक्रिया है। इससे मॉडल उस विशेष उपयोग केस या डोमेन की बारीकियों के अनुरूप बेहतर ढंग से ढल जाता है, जिससे अधिक सटीक परिणाम मिलते हैं।

फाइन-ट्यूनिंग को सफलतापूर्वक करने के लिए आवश्यक पूर्वापेक्षाएँ हैं: (1) Python प्रोग्रामिंग की बुनियादी समझ और (2) मशीन लर्निंग तथा नैचुरल लैंग्वेज प्रोसेसिंग से परिचित होना।

हमारा मशीन लर्निंग में क्लासिफिकेशन: एक परिचय लेख, मशीन लर्निंग में क्लासिफिकेशन क्या है, इसका उपयोग कैसे होता है, और कुछ एल्गोरिद्म के उदाहरणों के बारे में सीखने में मदद करता है।

हम OpenAI द्वारा उपलब्ध कराए गए openai Python पैकेज का उपयोग करेंगे ताकि उनकी API का उपयोग करना और GPT-3 की क्षमताओं तक पहुँचना अधिक सुगम हो।

यह लेख Python के साथ उपयोगकर्ता के अपने डेटा पर GPT-3 मॉडल की फाइन-ट्यूनिंग की प्रक्रिया को चरण-दर-चरण समझाएगा—API क्रेडेंशियल प्राप्त करने से लेकर डेटा तैयार करने, मॉडल को ट्रेन करने और उसे मान्य करने तक।

कौन-से GPT मॉडल फाइन-ट्यून किए जा सकते हैं?

वे GPT मॉडल जिन्हें फाइन-ट्यून किया जा सकता है, उनमें Ada, Babbage, Curie, और Davinci शामिल हैं। ये मॉडल GPT-3 परिवार के हैं। साथ ही, यह ध्यान देना महत्वपूर्ण है कि वर्तमान में हालिया GPT-3.5-turbo मॉडल या अन्य GPT-4 के लिए फाइन-ट्यूनिंग उपलब्ध नहीं है।

मॉडल के बारे में अधिक जानकारी के लिए हमारा GPT-3 के लिए शुरुआती मार्गदर्शक पढ़ें।

GPT की फाइन-ट्यूनिंग के अच्छे उपयोग केस क्या हैं?

क्लासिफिकेशन और कंडीशनल जनरेशन वे दो प्रकार की समस्याएँ हैं जिन्हें GPT-3 जैसे भाषा मॉडल की फाइन-ट्यूनिंग से लाभ हो सकता है। आइए दोनों पर संक्षेप में नज़र डालें।

क्लासिफिकेशन

क्लासिफिकेशन समस्याओं में, प्रॉम्प्ट में दिए गए प्रत्येक इनपुट को पूर्व-परिभाषित क्लासों में से एक में सौंपा जाता है, और कुछ मामले नीचे दर्शाए गए हैं:

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

कंडीशनल जनरेशन

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

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

GPT-3 की फाइन-ट्यूनिंग का चरण-दर-चरण कार्यान्वयन

API कुंजी तक पहुँचने के लिए OpenAI डेवलपर खाता बनाना अनिवार्य है, और चरण नीचे दिए गए हैं:

पहले, OpenAI की आधिकारिक वेबसाइट से एक खाता बनाएं।

इसके बाद, ऊपर-दाएँ कोने में यूज़र प्रोफ़ाइल आइकन चुनें और “View API Keys” पर क्लिक करें, ताकि आप नई API कुंजी बनाने या मौजूदा का उपयोग करने वाले पेज पर पहुँच सकें।

“Create new secret key” टैब से एक सार्थक नाम देकर (इस मामले में GPT3_fine_tuning_key) नई सीक्रेट कुंजी बनाएँ, और फिर API कुंजी स्वतः उत्पन्न हो जाएगी।

यदि आप अटक गए हैं या कठिनाइयों का सामना कर रहे हैं, तो अवश्य देखें सारा कोड वाला DataLab वर्कबुक।

डेटासेट

इस उपयोग केस में, हम प्रश्न-उत्तर परिदृश्य के लिए GPT-3 मॉडल को फाइन-ट्यून करेंगे, जिसमें एक संरचित प्रश्न-उत्तर पैटर्न शामिल है, जो मॉडल को समझने में मदद करता है कि उसे कौन-सा कार्य करना है। पूरे प्रशिक्षण और परीक्षण डेटा में प्रत्येक प्रश्न और उत्तर की जोड़ी के लिए एक सुसंगत फ़ॉर्मेट बनाए रखा गया है।

प्रश्न-उत्तर डेटासेट में एक एंट्री का निम्नलिखित फ़ॉर्मेट होता है:

{
"prompt": "my prompt ->",
"completion": "the answer of the prompt. \n"
}संचालित द्वारा

• “prompt” वह इनपुट टेक्स्ट है जिसे मॉडल पढ़ता और प्रोसेस करता है। मुख्य सेपरेटर तीर का चिह्न (->) है, जो प्रॉम्प्ट को अपेक्षित प्रतिक्रिया से अलग करता है।
• “completion” प्रॉम्प्ट के लिए अपेक्षित प्रतिक्रिया है। उत्तर के अंत को दर्शाने के लिए बैकस्लैश “\n” को स्टॉप सीक्वेंस के रूप में उपयोग किया जाता है।

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

हमारा डेटा साइंस के लिए ChatGPT चीट शीट उपयोगकर्ताओं को 60+ प्रॉम्प्ट्स तक पहुँच प्रदान करती है।

training_data = [
	{
    	"prompt": "What is the capital of France?->",
    	"completion": """ The capital of France is Paris.\n"""
	},
	{
    	"prompt": "What is the primary function of the heart?->",
    	"completion": """ The primary function of the heart is to pump blood throughout the body.\n"""
	},
	{
    	"prompt": "What is photosynthesis?->",
    	"completion": """ Photosynthesis is the process by which green plants and some other organisms convert sunlight into chemical energy stored in the form of glucose.\n"""
	},
	{
    	"prompt": "Who wrote the play 'Romeo and Juliet'?->",
    	"completion": """ William Shakespeare wrote the play 'Romeo and Juliet'.\n"""
	},
	{
    	"prompt": "Which element has the atomic number 1?->",
    	"completion": """ Hydrogen has the atomic number 1.\n"""
	},
	{
    	"prompt": "What is the largest planet in our solar system?->",
    	"completion": """ Jupiter is the largest planet in our solar system.\n"""
	},
	{
    	"prompt": "What is the freezing point of water in Celsius?->",
    	"completion": """ The freezing point of water in Celsius is 0 degrees.\n"""
	},
	{
    	"prompt": "What is the square root of 144?->",
    	"completion": """ The square root of 144 is 12.\n"""
	},
	{
    	"prompt": "Who is the author of 'To Kill a Mockingbird'?->",
    	"completion": """ The author of 'To Kill a Mockingbird' is Harper Lee.\n"""
	},
	{
    	"prompt": "What is the smallest unit of life?->",
    	"completion": """ The smallest unit of life is the cell.\n"""
	}
]

validation_data = [
	{
    	"prompt": "Which gas do plants use for photosynthesis?->",
    	"completion": """ Plants use carbon dioxide for photosynthesis.\n"""
	},
	{
    	"prompt": "What are the three primary colors of light?->",
    	"completion": """ The three primary colors of light are red, green, and blue.\n"""
	},
	{
    	"prompt": "Who discovered penicillin?->",
    	"completion": """ Sir Alexander Fleming discovered penicillin.\n"""
	},
	{
    	"prompt": "What is the chemical formula for water?->",
    	"completion": """ The chemical formula for water is H2O.\n"""
	},
	{
    	"prompt": "What is the largest country by land area?->",
    	"completion": """ Russia is the largest country by land area.\n"""
	},
	{
    	"prompt": "What is the speed of light in a vacuum?->",
    	"completion": """ The speed of light in a vacuum is approximately 299,792 kilometers per second.\n"""
	},
	{
    	"prompt": "What is the currency of Japan?->",
    	"completion": """ The currency of Japan is the Japanese Yen.\n"""
	},
	{
    	"prompt": "What is the smallest bone in the human body?->",
    	"completion": """ The stapes, located in the middle ear, is the smallest bone in the human body.\n"""
	}
]संचालित द्वारा

सेटअप

इम्प्लीमेंटेशन प्रक्रिया में उतरने से पहले, हमें आवश्यक लाइब्रेरियाँ—खासकर OpenAI की Python लाइब्रेरी—इंस्टॉल करके कार्य-पर्यावरण तैयार करना होगा, जैसा नीचे दिखाया गया है:

pip install --upgrade openaiसंचालित द्वारा

अब हम लाइब्रेरी इम्पोर्ट कर सकते हैं।

import os
from openai import OpenAI

client = OpenAI(
  api_key=os.environ['OPENAI_API_KEY'],
)संचालित द्वारा

डेटासेट तैयार करें

जैसा ऊपर दिखाया गया है, सूची (list) फ़ॉर्मेट के साथ काम करना छोटे डेटासेट के लिए सुविधाजनक हो सकता है। हालाँकि, डेटा को JSONL (JSON Lines) फ़ॉर्मेट में सहेजने के कई लाभ हैं। लाभों में स्केलेबिलिटी, इंटरऑपरेबिलिटी, सरलता, और OpenAI API के साथ संगतता शामिल है, जो फाइन-ट्यूनिंग जॉब बनाते समय डेटा को JSONL फ़ॉर्मेट में ही मांगता है।

निम्नलिखित कोड सहायक फ़ंक्शन prepare_data का उपयोग करके प्रशिक्षण और वैलिडेशन दोनों डेटा को JSONL फ़ॉर्मेट में बनाता है:

import json

training_file_name = "training_data.jsonl"
validation_file_name = "validation_data.jsonl"

def prepare_data(dictionary_data, final_file_name):
    with open(final_file_name, 'w') as outfile:
        for entry in dictionary_data:
        	json.dump(entry, outfile)
        	outfile.write('\n')

prepare_data(training_data, "training_data.jsonl")
prepare_data(validation_data, "validation_data.jsonl")संचालित द्वारा

अंत में, हम दोनों डेटासेट को OpenAI डेवलपर खाते में इस प्रकार अपलोड करते हैं:

training_file_id = client.files.create(
  file=open(training_file_name, "rb"),
  purpose="fine-tune"
)

validation_file_id = client.files.create(
  file=open(validation_file_name, "rb"),
  purpose="fine-tune"
)

print(f"Training File ID: {training_file_id}")
print(f"Validation File ID: {validation_file_id}")संचालित द्वारा

उपरोक्त कोड के सफल निष्पादन पर प्रशिक्षण और वैलिडेशन डेटा के यूनिक आइडेंटिफ़ायर नीचे की तरह प्रदर्शित होते हैं।

इस स्तर पर हमारे पास फाइन-ट्यूनिंग आगे बढ़ाने के लिए सारी जानकारी मौजूद है।

फाइन-ट्यूनिंग जॉब बनाएँ

यह फाइन-ट्यूनिंग प्रक्रिया Microsoft Azure पर फाइन-ट्यूनिंग करने वाले openai-cookbook से काफी प्रेरित है।

फाइन-ट्यूनिंग करने के लिए हम निम्न दो चरण अपनाएँगे: (1) हाइपरपैरामीटर्स परिभाषित करना, और (2) फाइन-ट्यूनिंग ट्रिगर करना।

हम davinci मॉडल को फाइन-ट्यून करेंगे और इसे 15 epochs तक चलाएँगे, बैच साइज 3 और लर्निंग रेट मल्टिप्लायर 0.3 के साथ, प्रशिक्षण और वैलिडेशन डेटासेट का उपयोग करते हुए।

response = client.fine_tuning.jobs.create(
  training_file=training_file_id.id, 
  validation_file=validation_file_id.id,
  model="davinci-002", 
  hyperparameters={
    "n_epochs": 15,
	"batch_size": 3,
	"learning_rate_multiplier": 0.3
  }
)
job_id = response.id
status = response.status

print(f'Fine-tunning model with jobID: {job_id}.')
print(f"Training Response: {response}")
print(f"Training Status: {status}")संचालित द्वारा

ऊपर दिया गया कोड jobID (ftjob-WsCjQMEmSvRMFCbhdTqxZzOf), प्रशिक्षण प्रतिक्रिया, और प्रशिक्षण स्थिति (pending) की निम्न जानकारी उत्पन्न करता है।

यह pending स्थिति कोई प्रासंगिक जानकारी नहीं देती। हालाँकि, हम निम्न कोड चलाकर प्रशिक्षण प्रक्रिया के बारे में अधिक जानकारी प्राप्त कर सकते हैं:

import signal
import datetime


def signal_handler(sig, frame):
    status = client.fine_tuning.jobs.retrieve(job_id).status
    print(f"Stream interrupted. Job is still {status}.")
    return


print(f"Streaming events for the fine-tuning job: {job_id}")

signal.signal(signal.SIGINT, signal_handler)

events = client.fine_tuning.jobs.list_events(fine_tuning_job_id=job_id)
try:
    for event in events:
        print(
            f'{datetime.datetime.fromtimestamp(event.created_at)} {event.message}'
        )
except Exception:
    print("Stream interrupted (client disconnected).")संचालित द्वारा

सभी epochs नीचे जनरेट होते हैं, साथ ही फाइन-ट्यूनिंग की स्थिति भी, जो succeeded है।

फाइन-ट्यूनिंग जॉब की स्थिति जाँचें

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

import time

status = client.fine_tuning.jobs.retrieve(job_id).status
if status not in ["succeeded", "failed"]:
    print(f"Job not in terminal status: {status}. Waiting.")
    while status not in ["succeeded", "failed"]:
        time.sleep(2)
        status = client.fine_tuning.jobs.retrieve(job_id).status
        print(f"Status: {status}")
else:
    print(f"Finetune job {job_id} finished with status: {status}")
print("Checking other finetune jobs in the subscription.")
result = client.fine_tuning.jobs.list()
print(f"Found {len(result.data)} finetune jobs.")संचालित द्वारा

निष्पादन का परिणाम नीचे दिया गया है:

कुल 2 फाइन-ट्यून जॉब हैं।

मॉडल का वैलिडेशन

अंततः, फाइन-ट्यून किया गया मॉडल “fine_tuned_model” एट्रिब्यूट से प्राप्त किया जा सकता है। नीचे दिया गया प्रिंट स्टेटमेंट दर्शाता है कि अंतिम मॉडल का नाम है: ft:davinci-002:personal::8gKnyxn3

# Retrieve the finetuned model
fine_tuned_model = result.data[0].fine_tuned_model
print(fine_tuned_model)

संचालित द्वारा

इस मॉडल के साथ, हम एक प्रॉम्प्ट, मॉडल का नाम देकर, और openai.Completion.create() फ़ंक्शन से क्वेरी बनाकर इसके परिणामों को वैलिडेट करने के लिए क्वेरी चला सकते हैं। परिणाम को उत्तर डिक्शनरी से इस प्रकार प्राप्त किया जाता है:

new_prompt = "Which part is the smallest bone in the entire human body?"
answer = client.completions.create(
  model=fine_tuned_model,
  prompt=new_prompt
)

print(answer.choices[0].text)

new_prompt = "Which type of gas is utilized by plants during the process of photosynthesis?"
answer = client.completions.create(
  model=fine_tuned_model,
  prompt=new_prompt
)

print(answer.choices[0].text)संचालित द्वारा

हालाँकि प्रॉम्प्ट वैलिडेशन डेटासेट में लिखे गए बिल्कुल उसी तरह नहीं हैं, फिर भी मॉडल उन्हें सही उत्तरों से मैप करने में सक्षम रहा। पिछले अनुरोधों के उत्तर नीचे दिखाए गए हैं।

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

निष्कर्ष

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

इसके अलावा, हमने openai Python पैकेज का परिचय दिया, जिसका उपयोग OpenAI की API के माध्यम से GPT-3 की क्षमताओं तक पहुँच को सरल बनाने के लिए किया जाता है। इस लेख में Python और कस्टम डेटासेट का उपयोग करके GPT-3 मॉडल की फाइन-ट्यूनिंग में शामिल सभी चरण—API क्रेडेंशियल प्राप्त करने से लेकर डेटा तैयार करने, मॉडल को ट्रेन करने और उसका वैलिडेशन करने तक—कवर किए गए हैं।

फाइन-ट्यूनिंग के लाभों पर प्रकाश डालकर और प्रक्रिया की व्यापक मार्गदर्शिका प्रदान करके, यह लेख डेटा वैज्ञानिकों, डेवलपर्स और अन्य हितधारकों की मदद करने का लक्ष्य रखता है ताकि वे अपनी विशिष्ट आवश्यकताओं और अपेक्षाओं के अनुरूप अधिक सटीक और कुशल GPT-3 मॉडल बना सकें।

हमारे पास GPT-4 क्या है और यह क्यों महत्वपूर्ण है? पर एक लेख और Transformers और Hugging Face का उपयोग: एक परिचय ट्यूटोरियल भी है। अपने ज्ञान को अगले स्तर पर ले जाने के लिए इन्हें अवश्य पढ़ें।