OpenAI का प्रेफरेंस फाइन-ट्यूनिंग: उदाहरणों के साथ एक मार्गदर्शिका

प्रेफरेंस फाइन-ट्यूनिंग (PFT) एक तकनीक है जिसका उपयोग LLMs को फाइन-ट्यून करने के लिए लंबे समय से किया जा रहा है। OpenAI ने हाल ही में इसे अपने 12-दिवसीय फीचर रोलआउट के हिस्से के रूप में पेश किया।

सुपरवाइज़्ड फाइन-ट्यूनिंग (SFT) और रीइन्फोर्समेंट फाइन-ट्यूनिंग (RFT) के साथ, PFT बड़े भाषा मॉडलों को उपयोगकर्ता प्राथमिकताओं के अनुरूप करने का एक और तरीका है।

इस लेख में, मैं संक्षेप में प्रेफरेंस फाइन-ट्यूनिंग समझाऊंगा और दिखाऊंगा कि OpenAI के डेवलपर डैशबोर्ड में इसे न्यूनतम प्रयास से कैसे उपयोग करें।

OpenAI का प्रेफरेंस फाइन-ट्यूनिंग क्या है?

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

डायरेक्ट प्रेफरेंस ऑप्टिमाइज़ेशन (DPO) PFT की मानक तकनीक है और अपनी सरलता व प्रभावशीलता के कारण एक सशक्त एलाइनमेंट विधि के रूप में लोकप्रिय हुई है।

इसके विपरीत, मानव फीडबैक से रीइन्फोर्समेंट लर्निंग (RLHF) में LLM को एलाइन करने के लिए एक जटिल रिवॉर्ड मॉडल की आवश्यकता होती है, जबकि DPO एलाइनमेंट समस्या को एक लॉस फ़ंक्शन के “प्रत्यक्ष” ऑप्टिमाइज़ेशन के रूप में लेता है। इससे DPO को लागू करना आसान और संगणनात्मक रूप से अधिक कुशल हो जाता है।

DPO के लिए आवश्यक डेटासेट, अन्य एलाइनमेंट विधियों की तरह, किसी दिए गए प्रॉम्प्ट के लिए “preferred” और “not preferred” प्रतिक्रियाओं की एक जोड़ी शामिल करता है। OpenAI के PFT के मामले में, अन्य फाइन-ट्यूनिंग विधियों के समान, डेटासेट JSONL फॉर्मेट में होना चाहिए और इसकी संरचना निम्नलिखित होगी:

{
  "input": {
    "messages": [
      {
        "role": "user",
        "content": "Hello, can you tell me how cold San Francisco is today?"
      }
    ],
    "tools": [],
    "parallel_tool_calls": true
  },
  "preferred_output": [
    {
      "role": "assistant",
      "content": "Today in San Francisco, it is not quite cold as expected. Morning clouds will give away to sunshine, with a high near 68°F (20°C) and a low around 57°F (14°C)."
    }
  ],
  "non_preferred_output": [
    {
      "role": "assistant",
      "content": "It is not particularly cold in San Francisco today."
    }
  ]
}संचालित द्वारा

PFT के लिए आधिकारिक OpenAI दस्तावेज़ SFT और PFT को मिलाने की सिफारिश करता है ताकि एलाइनमेंट बेहतर हो। PFT जैसी एलाइनमेंट तकनीकें आमतौर पर मॉडल को सुपरवाइज़्ड डेटासेट पर फाइन-ट्यून करने के बाद उपयोग की जाती हैं। SFT को PFT के साथ मिलाना उद्योग का मानक माना जाता है और OpenAI भी इसकी वकालत करता है।

प्रेफरेंस फाइन-ट्यूनिंग के लिए डेटासेट को कैसे फ़ॉर्मेट करें

सबसे पहले, हमें यह सुनिश्चित करना होगा कि हमारा डेटासेट OpenAI के प्रेफरेंस फाइन-ट्यूनिंग के लिए आवश्यक फ़ॉर्मेट में हो।

प्रेफरेंस डेटासेट बनाने के कई तरीके हैं। एक तरीका यह है कि अलग-अलग temperatures, top_k, या system prompts पर दिए गए LLM आउटपुट की जोड़ियाँ प्राप्त करें, और फिर किसी दूसरे LLM—अधिमानतः अधिक सक्षम—का उपयोग करके एक आउटपुट को “preferred” और दूसरे को “not preferred” के रूप में चुनें।

इस ट्यूटोरियल के डेमो के लिए, मैं Hugging Face से एक प्रेफरेंस डेटासेट डाउनलोड करूँगा और उसे पुनर्संरचित करूँगा। मैं argilla/ultrafeedback-binarized-preferences का उपयोग करूँगा, जो एक प्रेफरेंस डेटासेट है, लेकिन मैं केवल पहली 50 पंक्तियाँ ही लूँगा।

Hugging Face से प्रेफरेंस डेटासेट का एक उदाहरण।

डेटासेट की संरचना को OpenAI की फाइन-ट्यूनिंग आवश्यकताओं में बदलने के लिए एक Python स्क्रिप्ट पर्याप्त होगी, लेकिन आप अपने अनुप्रयोग के आधार पर कोई और तरीका भी अपना सकते हैं।

import datasets
import copy 
import json

instance_structure = {
  "input": {
    "messages": [
      {
        "role": "user",
        "content": ""
      }
    ],
    "tools": [],
    "parallel_tool_calls": True
  },
  "preferred_output": [
    {
      "role": "assistant",
      "content": ""
    }
  ],
  "non_preferred_output": [
    {
      "role": "assistant",
      "content": ""
    }
  ]
}

ds = datasets.load_dataset("argilla/ultrafeedback-binarized-preferences", trust_remote_code=True, split="train")
ds_sample = ds.select(range(50)) #select the first 50 rows
ds_list = []
for sample in ds_sample:
  instance = copy.deepcopy(instance_structure)
  instance["input"]["messages"][0]["content"] = sample["instruction"]
  instance["preferred_output"][0]["content"] = sample["chosen_response"]
  instance["non_preferred_output"][0]["content"] = sample["rejected_response"]
  ds_list.append(instance)
  
with open("preference_dataset.jsonl", 'w') as out:
  for json_line in ds_list:
      jout = json.dumps(json_line) + '\\n'
      out.write(jout)संचालित द्वारा

सुनिश्चित करें कि आपके डेटासेट का फ़ॉर्मेट jsonl हो, json नहीं। आपकी फ़ाइल के अंत में संभव है एक खाली पंक्ति हो—उसे अवश्य हटाएँ।

OpenAI का प्रेफरेंस फाइन-ट्यूनिंग कैसे चलाएँ

डेटासेट तैयार होने के बाद, प्रेफरेंस फाइन-ट्यूनिंग चलाने के लिए आप ये चरण अपनाएँ:

1. OpenAI के डैशबोर्ड पर जाएँ।
2. फाइन-ट्यूनिंग सेक्शन देखें और नया फाइन-ट्यूनिंग जॉब बनाने के लिए Create चुनें।
3. फाइन-ट्यूनिंग के लिए विधि के रूप में डायरेक्ट प्रेफरेंस ऑप्टिमाइज़ेशन चुनें।
4. अपना प्रशिक्षण और वैलिडेशन डेटा (यदि है) अपलोड करें।

OpenAI आपको हाइपरपैरामीटर्स निर्दिष्ट करने देता है, लेकिन आप उन्हें खाली भी छोड़ सकते हैं और सिस्टम स्वतः निर्णय करेगा। आपके डेटासेट के आकार के अनुसार प्रशिक्षण में समय लग सकता है।

निष्कर्ष

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

OpenAI की डिस्टिलेशन, रीइन्फोर्समेंट फाइन-ट्यूनिंग और सुपरवाइज़्ड फाइन-ट्यूनिंग की तरह, प्रेफरेंस फाइन-ट्यूनिंग में आपका मुख्य योगदान OpenAI के फ़ॉर्मेट और संरचना के अनुसार डेटासेट तैयार करना होगा; शेष का ध्यान उनके टूल्स रखेंगे:

अधिक जानने के लिए, मैं ये संसाधन सुझाता हूँ:

• OpenAI मॉडल डिस्टिलेशन: उदाहरणों के साथ मार्गदर्शिका
• OpenAI का रीइन्फोर्समेंट फाइन-ट्यूनिंग क्या है?
• OpenAI का फाइन-ट्यूनिंग दस्तावेज़
• प्रेफरेंस फाइन-ट्यूनिंग का OpenAI डेमो प्रेज़ेंटेशन