आज, हम मेटा का उपयोग करके कोड लामा मॉडल को फाइन-ट्यून करने की क्षमता की घोषणा करते हुए उत्साहित हैं अमेज़न SageMaker जम्पस्टार्ट. बड़े भाषा मॉडल (एलएलएम) का कोड लामा परिवार 7 अरब से 70 अरब पैरामीटर के पैमाने पर पूर्व-प्रशिक्षित और ठीक-ठीक कोड पीढ़ी मॉडल का एक संग्रह है। फाइन-ट्यून किए गए कोड लामा मॉडल बेस कोड लामा मॉडल की तुलना में बेहतर सटीकता और व्याख्या प्रदान करते हैं, जैसा कि इसके परीक्षण से स्पष्ट है ह्यूमनएवल और एमबीपीपी डेटासेट। आप इसका उपयोग करके सेजमेकर जम्पस्टार्ट के साथ कोड लामा मॉडल को फाइन-ट्यून और तैनात कर सकते हैं अमेज़ॅन सैजमेकर स्टूडियो कुछ क्लिक के साथ या सेजमेकर पायथन एसडीके का उपयोग करके यूआई। लामा मॉडलों की फ़ाइन-ट्यूनिंग इसमें प्रदान की गई स्क्रिप्ट पर आधारित है लामा-रेसिपी GitHub रेपो PyTorch FSDP, PEFT/LoRA, और Int8 परिमाणीकरण तकनीकों का उपयोग करके मेटा से।

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

सेजमेकर जम्पस्टार्ट क्या है?

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

कोड लामा क्या है?

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

कोड लामा मॉडल को फाइन-ट्यून क्यों करें

मेटा ने कोड लामा प्रदर्शन बेंचमार्क प्रकाशित किए ह्यूमनएवल और एमबीपीपी पायथन, जावा और जावास्क्रिप्ट जैसी सामान्य कोडिंग भाषाओं के लिए। ह्यूमनइवल पर कोड लामा पायथन मॉडल के प्रदर्शन ने विभिन्न कोडिंग भाषाओं और कार्यों में 38बी पायथन मॉडल पर 7% से लेकर 57बी पायथन मॉडल पर 70% तक अलग-अलग प्रदर्शन प्रदर्शित किया। इसके अलावा, SQL प्रोग्रामिंग भाषा पर फाइन-ट्यून किए गए कोड लामा मॉडल ने बेहतर परिणाम दिखाए हैं, जैसा कि SQL मूल्यांकन बेंचमार्क में स्पष्ट है। ये प्रकाशित बेंचमार्क कोड लामा मॉडल को फाइन-ट्यूनिंग करने, विशिष्ट कोडिंग डोमेन और कार्यों के लिए बेहतर प्रदर्शन, अनुकूलन और अनुकूलन को सक्षम करने के संभावित लाभों पर प्रकाश डालते हैं।

सेजमेकर स्टूडियो यूआई के माध्यम से नो-कोड फाइन-ट्यूनिंग

सेजमेकर स्टूडियो का उपयोग करके अपने लामा मॉडल को फाइन-ट्यूनिंग शुरू करने के लिए, निम्नलिखित चरणों को पूरा करें:

1. सेजमेकर स्टूडियो कंसोल पर, चुनें कूदना शुरू करो नेविगेशन फलक में

आपको ओपन सोर्स और मालिकाना मॉडल से लेकर 350 से अधिक मॉडलों की सूची मिलेगी।

2. कोड लामा मॉडल खोजें।
   

यदि आपको कोड लामा मॉडल दिखाई नहीं देते हैं, तो आप अपने सेजमेकर स्टूडियो संस्करण को बंद करके और पुनः आरंभ करके अपडेट कर सकते हैं। संस्करण अपडेट के बारे में अधिक जानकारी के लिए देखें स्टूडियो ऐप्स बंद करें और अपडेट करें. आप चुनकर अन्य मॉडल वेरिएंट भी पा सकते हैं सभी कोड जनरेशन मॉडल का अन्वेषण करें या खोज बॉक्स में कोड लामा खोज रहे हैं।

सेजमेकर जम्पस्टार्ट वर्तमान में कोड लामा मॉडल के लिए निर्देश फाइन-ट्यूनिंग का समर्थन करता है। निम्नलिखित स्क्रीनशॉट कोड लामा 2 70बी मॉडल के लिए फ़ाइन-ट्यूनिंग पृष्ठ दिखाता है।

3. के लिए प्रशिक्षण डेटा स्थान, आप इंगित कर सकते हैं अमेज़न सरल भंडारण सेवा (अमेज़ॅन S3) बकेट जिसमें फ़ाइन-ट्यूनिंग के लिए प्रशिक्षण और सत्यापन डेटासेट शामिल हैं।
4. फ़ाइन-ट्यूनिंग के लिए अपना परिनियोजन कॉन्फ़िगरेशन, हाइपरपैरामीटर और सुरक्षा सेटिंग्स सेट करें।
5. चुनें रेलगाड़ी सेजमेकर एमएल इंस्टेंस पर फाइन-ट्यूनिंग कार्य शुरू करने के लिए।
   

हम अगले भाग में निर्देश को ठीक करने के लिए आवश्यक डेटासेट प्रारूप पर चर्चा करेंगे।

6. मॉडल को ठीक करने के बाद, आप इसे सेजमेकर जम्पस्टार्ट पर मॉडल पेज का उपयोग करके तैनात कर सकते हैं।

फाइन-ट्यून किए गए मॉडल को तैनात करने का विकल्प फाइन-ट्यूनिंग समाप्त होने पर दिखाई देगा, जैसा कि निम्नलिखित स्क्रीनशॉट में दिखाया गया है।

सेजमेकर पायथन एसडीके के माध्यम से फाइन-ट्यून करें

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

अपना फाइन-ट्यूनिंग कार्य पूरा करने के लिए निम्नलिखित चरणों को पूरा करें। आप संपूर्ण फाइन-ट्यूनिंग कोड यहां से प्राप्त कर सकते हैं गिटहब भंडार.

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

{
	'system_prompt': 'a chat',
	'question': 'Please focus on the efficiency of this problem and provide code in python:nYou are given two strings `s` and `t` consisting of only lowercase English letters.nnReturn _the minimum number of characters that need to be appended to the end of_ `s` _so that_ `t` _becomes a **subsequence** of_ `s`.nnA **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.nn**Example 1:**nn**Input:** s = "coaching ", t = "coding "n**Output:** 4n**Explanation:** Append the characters "ding " to the end of s so that s = "coachingding ".nNow, t is a subsequence of s ( "**co**aching**ding** ").nIt can be shown that appending any 3 characters to the end of s will never make t a subsequence.nn**Example 2:**nn**Input:** s = "abcde ", t = "a "n**Output:** 0n**Explanation:** t is already a subsequence of s ( "**a**bcde ").nn**Example 3:**nn**Input:** s = "z ", t = "abcde "n**Output:** 5n**Explanation:** Append the characters "abcde " to the end of s so that s = "zabcde ".nNow, t is a subsequence of s ( "z**abcde** ").nIt can be shown that appending any 4 characters to the end of s will never make t a subsequence.nn**Constraints:**nn* `1 <= s.length, t.length <= 105`n* `s` and `t` consist only of lowercase English letters.',
	'response': '### Explanationn The algorithm maintains two pointers, `i` and `j`, to iterate through the given strings `s` and `t`. The pointer `i` iterates through the string `s` and the pointer `j` iterates through the string `t`. While iterating through `s`, if we find a character that matches the current character in `t`, we increment the `j` pointer. This is because the matched character can be a part of the subsequence we are looking for. The iteration stops when either `i` reaches the end of `s` or `j` reaches the end of `t`.nnAt the end, we subtract the index `j` from the length of `t`. This gives us the minimum number of characters that need to be appended to the end of `s` so that `t` becomes a subsequence of `s`.nn### Pseudocode:n```nMIN-ADDITION(s, t)n s_len = LENGTH(s)n t_len = LENGTH(t)n i = 1n j = 1n WHILE i <= s_len AND j <= t_lenn IF s[i] == t[j]n j = j + 1n ENDIFn i = i + 1n ENDWHILEn RETURN t_len - j + 1nENDMIN-ADDITIONn```nn### Coden```pythonndef min_addition(s: str, t: str) -> int:n s_len = len(s)n t_len = len(t)n i, j = 0, 0n while i < s_len and j < t_len:n if s[i] == t[j]:n j += 1n i += 1n return t_len - jn```n'
}

प्रशिक्षण फ़ोल्डर में एक हो सकता है template.json इनपुट और आउटपुट स्वरूपों का वर्णन करने वाली फ़ाइल। निम्नलिखित एक उदाहरण टेम्पलेट है:

{
    "prompt": "{system_prompt} ### Input: {question}",
    "completion": "{response}"
}

टेम्प्लेट से मिलान करने के लिए, JSON लाइन फ़ाइलों में प्रत्येक नमूने को शामिल करना होगा system_prompt, question, तथा response खेत। इस प्रदर्शन में, हम इसका उपयोग करते हैं डॉल्फिन कोडर डेटासेट गले मिलते चेहरे से.

डेटासेट तैयार करने और उसे S3 बकेट पर अपलोड करने के बाद, आप निम्नलिखित कोड का उपयोग करके फाइन-ट्यूनिंग शुरू कर सकते हैं:

from sagemaker.jumpstart.estimator import JumpStartEstimator

model_id = "meta-textgeneration-llama-codellama-7b" 
model_version = "*"
train_data_location = f"s3://{your_own_bucket_hosting_training_data}/" # training data in s3 bucket

estimator = JumpStartEstimator(
    model_id=model_id,
    model_version=model_version,
    hyperparameters= hyperparameters,
    environment={
        "accept_eula": "false"
    },  # please change `accept_eula` to be `true` to accept EULA.
)

estimator.fit({"training": train_data_location})

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

finetuned_predictor = estimator.deploy()

फाइन-ट्यूनिंग तकनीक

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

• निम्न-रैंक अनुकूलन (LoRA) - यह बड़े मॉडलों की कुशल फाइन-ट्यूनिंग के लिए एक प्रकार का पैरामीटर कुशल फाइन-ट्यूनिंग (पीईएफटी) है। इस पद्धति से, आप पूरे मॉडल को फ़्रीज़ कर देते हैं और मॉडल में केवल समायोज्य पैरामीटर या परतों का एक छोटा सेट जोड़ते हैं। उदाहरण के लिए, लामा 7 2बी के लिए सभी 7 अरब मापदंडों को प्रशिक्षित करने के बजाय, आप 1% से भी कम मापदंडों को ठीक कर सकते हैं। यह मेमोरी आवश्यकता को महत्वपूर्ण रूप से कम करने में मदद करता है क्योंकि आपको केवल 1% पैरामीटर के लिए ग्रेडिएंट, ऑप्टिमाइज़र स्थिति और अन्य प्रशिक्षण-संबंधित जानकारी संग्रहीत करने की आवश्यकता होती है। इसके अलावा, इससे प्रशिक्षण के समय के साथ-साथ लागत भी कम करने में मदद मिलती है। इस विधि के बारे में अधिक जानकारी के लिए देखें लोरा: बड़े भाषा मॉडल का निम्न-रैंक अनुकूलन.
• Int8 परिमाणीकरण - LoRA जैसे अनुकूलन के साथ भी, Llama 70B जैसे मॉडल अभी भी प्रशिक्षित करने के लिए बहुत बड़े हैं। प्रशिक्षण के दौरान मेमोरी फ़ुटप्रिंट को कम करने के लिए, आप प्रशिक्षण के दौरान Int8 परिमाणीकरण का उपयोग कर सकते हैं। परिमाणीकरण आम तौर पर फ़्लोटिंग पॉइंट डेटा प्रकारों की सटीकता को कम कर देता है। हालाँकि इससे मॉडल भार को संग्रहीत करने के लिए आवश्यक मेमोरी कम हो जाती है, लेकिन यह जानकारी के नुकसान के कारण प्रदर्शन को ख़राब कर देता है। Int8 परिमाणीकरण केवल एक चौथाई परिशुद्धता का उपयोग करता है लेकिन प्रदर्शन में गिरावट नहीं लाता है क्योंकि यह केवल बिट्स को नहीं गिराता है। यह डेटा को एक प्रकार से दूसरे प्रकार में राउंड करता है। Int8 परिमाणीकरण के बारे में जानने के लिए, देखें LLM.int8(): स्केल पर ट्रांसफार्मर के लिए 8-बिट मैट्रिक्स गुणन.
• पूरी तरह से साझा डेटा समानांतर (एफएसडीपी) - यह एक प्रकार का डेटा-समानांतर प्रशिक्षण एल्गोरिदम है जो डेटा समानांतर श्रमिकों में मॉडल के मापदंडों को विभाजित करता है और वैकल्पिक रूप से प्रशिक्षण गणना के हिस्से को सीपीयू में लोड कर सकता है। हालाँकि पैरामीटर अलग-अलग GPU में विभाजित हैं, प्रत्येक माइक्रोबैच की गणना GPU कार्यकर्ता के लिए स्थानीय है। यह मापदंडों को अधिक समान रूप से विभाजित करता है और प्रशिक्षण के दौरान संचार और गणना ओवरलैपिंग के माध्यम से अनुकूलित प्रदर्शन प्राप्त करता है।

निम्न तालिका विभिन्न सेटिंग्स के साथ प्रत्येक मॉडल का विवरण सारांशित करती है।

लामा मॉडल की फ़ाइन-ट्यूनिंग निम्नलिखित द्वारा प्रदान की गई स्क्रिप्ट पर आधारित है गीथहब रेपो.

प्रशिक्षण के लिए समर्थित हाइपरपैरामीटर

कोड लामा 2 फाइन-ट्यूनिंग कई हाइपरपैरामीटर का समर्थन करता है, जिनमें से प्रत्येक फाइन-ट्यून किए गए मॉडल की मेमोरी आवश्यकता, प्रशिक्षण गति और प्रदर्शन को प्रभावित कर सकता है:

• युग - फ़ाइन-ट्यूनिंग एल्गोरिदम द्वारा प्रशिक्षण डेटासेट के माध्यम से लिए जाने वाले पासों की संख्या। 1 से बड़ा पूर्णांक होना चाहिए। डिफ़ॉल्ट 5 है।
• सीखने की दर - वह दर जिस पर प्रशिक्षण उदाहरणों के प्रत्येक बैच के माध्यम से काम करने के बाद मॉडल वजन अपडेट किया जाता है। एक सकारात्मक फ्लोट 0 से अधिक होना चाहिए। डिफ़ॉल्ट 1e-4 है।
• अनुदेश_ट्यून किया गया - मॉडल को निर्देश-प्रशिक्षित करना है या नहीं। होना चाहिए True or False. डिफ़ॉल्ट है False.
• प्रति_डिवाइस_ट्रेन_बैच_आकार - प्रशिक्षण के लिए प्रति जीपीयू कोर/सीपीयू बैच आकार। एक धनात्मक पूर्णांक होना चाहिए. डिफ़ॉल्ट 4 है.
• प्रति_डिवाइस_eval_बैच_आकार - मूल्यांकन के लिए प्रति जीपीयू कोर/सीपीयू बैच आकार। एक धनात्मक पूर्णांक होना चाहिए. डिफ़ॉल्ट 1 है.
• अधिकतम_ट्रेन_नमूने - डिबगिंग उद्देश्यों या त्वरित प्रशिक्षण के लिए, प्रशिक्षण उदाहरणों की संख्या को इस मान तक छोटा करें। मान -1 का अर्थ है सभी प्रशिक्षण नमूनों का उपयोग करना। एक धनात्मक पूर्णांक या -1 होना चाहिए. डिफ़ॉल्ट -1 है.
• max_val_samples - डिबगिंग उद्देश्यों या त्वरित प्रशिक्षण के लिए, सत्यापन उदाहरणों की संख्या को इस मान तक छोटा करें। मान -1 का अर्थ है सभी सत्यापन नमूनों का उपयोग करना। एक धनात्मक पूर्णांक या -1 होना चाहिए. डिफ़ॉल्ट -1 है.
• अधिकतम_इनपुट_लंबाई - टोकननाइजेशन के बाद अधिकतम कुल इनपुट अनुक्रम लंबाई। इससे अधिक लंबे अनुक्रमों को छोटा कर दिया जाएगा. यदि -1, max_input_length न्यूनतम 1024 और टोकननाइज़र द्वारा परिभाषित अधिकतम मॉडल लंबाई पर सेट है। यदि सकारात्मक मान पर सेट किया जाए, max_input_length प्रदान किए गए मान के न्यूनतम पर सेट किया गया है और model_max_length टोकननाइज़र द्वारा परिभाषित। एक धनात्मक पूर्णांक या -1 होना चाहिए. डिफ़ॉल्ट -1 है.
• सत्यापन_विभाजन_अनुपात – यदि सत्यापन चैनल है none, ट्रेन डेटा से ट्रेन-सत्यापन विभाजन का अनुपात 0-1 के बीच होना चाहिए। डिफ़ॉल्ट 0.2 है.
• ट्रेन_डेटा_विभाजित_बीज - यदि सत्यापन डेटा मौजूद नहीं है, तो यह एल्गोरिदम द्वारा उपयोग किए जाने वाले प्रशिक्षण और सत्यापन डेटा में इनपुट प्रशिक्षण डेटा के यादृच्छिक विभाजन को ठीक करता है। पूर्णांक होना चाहिए। डिफ़ॉल्ट 0 है.
• प्रीप्रोसेसिंग_नम_वर्कर्स - प्रीप्रोसेसिंग के लिए उपयोग की जाने वाली प्रक्रियाओं की संख्या। अगर None, मुख्य प्रक्रिया का उपयोग प्रीप्रोसेसिंग के लिए किया जाता है। डिफ़ॉल्ट है None.
• लोरा_आर – लोरा आर. एक धनात्मक पूर्णांक होना चाहिए. डिफ़ॉल्ट 8 है.
• lora_alpha -लोरा अल्फ़ा. एक धनात्मक पूर्णांक होना चाहिए. डिफ़ॉल्ट 32 है
• लोरा_ड्रॉपआउट - लोरा ड्रॉपआउट। 0 और 1 के बीच एक सकारात्मक फ़्लोट होना चाहिए। डिफ़ॉल्ट 0.05 है।
• int8_मात्राकरण - अगर True, मॉडल को प्रशिक्षण के लिए 8-बिट परिशुद्धता के साथ लोड किया गया है। 7बी और 13बी के लिए डिफ़ॉल्ट है False. 70B के लिए डिफ़ॉल्ट है True.
• Enable_fsdp - यदि सत्य है, तो प्रशिक्षण एफएसडीपी का उपयोग करता है। 7बी और 13बी के लिए डिफ़ॉल्ट सत्य है। 70B के लिए डिफ़ॉल्ट ग़लत है. ध्यान दें कि int8_quantization एफएसडीपी के साथ समर्थित नहीं है.

हाइपरपैरामीटर चुनते समय, निम्नलिखित पर विचार करें:

• की स्थापना int8_quantization=True स्मृति की आवश्यकता कम हो जाती है और प्रशिक्षण तेज़ हो जाता है।
• घटाना per_device_train_batch_size और max_input_length मेमोरी की आवश्यकता कम हो जाती है और इसलिए इसे छोटे इंस्टेंस पर चलाया जा सकता है। हालाँकि, बहुत कम मान सेट करने से प्रशिक्षण का समय बढ़ सकता है।
• यदि आप Int8 परिमाणीकरण का उपयोग नहीं कर रहे हैं (int8_quantization=False), एफएसडीपी का उपयोग करें (enable_fsdp=True) तेज और कुशल प्रशिक्षण के लिए।

प्रशिक्षण के लिए समर्थित उदाहरण प्रकार

निम्न तालिका विभिन्न मॉडलों के प्रशिक्षण के लिए समर्थित इंस्टेंस प्रकारों का सारांश प्रस्तुत करती है।

इंस्टेंस प्रकार चुनते समय, निम्नलिखित पर विचार करें:

• G5 इंस्टेंस समर्थित इंस्टेंस प्रकारों के बीच सबसे कुशल प्रशिक्षण प्रदान करते हैं। इसलिए, यदि आपके पास G5 इंस्टेंस उपलब्ध हैं, तो आपको उनका उपयोग करना चाहिए।
• प्रशिक्षण का समय काफी हद तक उपलब्ध GPU और CUDA मेमोरी की मात्रा पर निर्भर करता है। इसलिए, समान संख्या में GPU (उदाहरण के लिए, ml.g5.2xlarge और ml.g5.4xlarge) वाले उदाहरणों पर प्रशिक्षण लगभग समान है। इसलिए, आप प्रशिक्षण के लिए सस्ते उदाहरण (ml.g5.2xlarge) का उपयोग कर सकते हैं।
• पी3 इंस्टेंसेस का उपयोग करते समय, प्रशिक्षण 32-बिट परिशुद्धता के साथ किया जाएगा क्योंकि इन इंस्टेंसेस पर bfloat16 समर्थित नहीं है। इसलिए, प्रशिक्षण कार्य में g3 उदाहरणों की तुलना में p5 उदाहरणों पर प्रशिक्षण करते समय CUDA मेमोरी की दोगुनी मात्रा की खपत होगी।

प्रति उदाहरण प्रशिक्षण की लागत के बारे में जानने के लिए, देखें अमेज़ॅन EC2 G5 उदाहरण.

मूल्यांकन

सुव्यवस्थित मॉडलों के प्रदर्शन का आकलन करने के लिए मूल्यांकन एक महत्वपूर्ण कदम है। हम गैर-ठीक-ट्यून किए गए मॉडलों की तुलना में फाइन-ट्यून किए गए मॉडलों में सुधार दिखाने के लिए गुणात्मक और मात्रात्मक दोनों मूल्यांकन प्रस्तुत करते हैं। गुणात्मक मूल्यांकन में, हम फाइन-ट्यून और गैर-फाइन-ट्यून दोनों मॉडलों से एक उदाहरण प्रतिक्रिया दिखाते हैं। मात्रात्मक मूल्यांकन में, हम उपयोग करते हैं ह्यूमनएवल, सही और सटीक परिणाम देने की क्षमताओं का परीक्षण करने के लिए पायथन कोड उत्पन्न करने के लिए OpenAI द्वारा विकसित एक परीक्षण सूट। ह्यूमनएवल रिपोजिटरी एमआईटी लाइसेंस के अंतर्गत है। हमने विभिन्न आकारों में सभी कोड LIama मॉडलों के Python वेरिएंट को फाइन-ट्यून किया है (कोड LIama Python 7B, 13B, 34B, और 70B)। डॉल्फिन कोडर डेटासेट), और मूल्यांकन परिणाम निम्नलिखित अनुभागों में प्रस्तुत करें।

गुणात्मक मूल्यांकन

अपने सुव्यवस्थित मॉडल को तैनात करने के साथ, आप कोड उत्पन्न करने के लिए एंडपॉइंट का उपयोग शुरू कर सकते हैं। निम्नलिखित उदाहरण में, हम एक परीक्षण नमूने पर बेस और फाइन-ट्यून किए गए कोड LIama 34B पायथन वेरिएंट दोनों से प्रतिक्रियाएं प्रस्तुत करते हैं। डॉल्फिन कोडर डेटासेट:

alpaca_format = """{system_prompt}

### Input:
{question}

### Response:n"""

system="You are a coding AI"
prompt = """Please explain the reasoning behind the following solution and 
provide code in python: Given a string `s`, return the longest palindromic 
substring in `s`. **Example 1:** **Input:** s = "babad " **Output:** "bab " 
**Explanation:** "aba " is also a valid answer. **Example 2:** 
**Input:** s = "cbbd " **Output:** "bb " 
**Constraints:** * `1 <= s.length <= 1000` * `s` consist of only digits 
and English letters."""

payload = json.dumps({
    "inputText": alpaca_format.format(system_prompt=system, question=prompt),
    "textGenerationConfig": {
    "maxTokenCount": 2048,
    "temperature":0.2
}})

finetuned_response = finetuned_predictor.predict(payload)
finetuned_response["generated_text"]

सुव्यवस्थित कोड लामा मॉडल, पिछली क्वेरी के लिए कोड प्रदान करने के अलावा, दृष्टिकोण और एक छद्म कोड का विस्तृत विवरण उत्पन्न करता है।

कोड लामा 34बी पायथन नॉन-फाइन-ट्यून्ड रिस्पांस:

### Code
def longestPalindrome(s):
    # Fill this in.
    longest = ""
    for i in range(len(s)):
        for j in range(len(s), i, -1):
            if len(longest) >= j-i:
                break
            elif s[i:j] == s[i:j][::-1]:
                longest = s[i:j]
                break
    return longest

print(longestPalindrome("abaxyzzyxf"))
# axyzzyx
###Reference:
- [https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/]
(https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/)

कोड लामा 34बी पायथन फाइन-ट्यून्ड रिस्पांस

### Explanation
The algorithm uses dynamic programming to find the longest palindromic substring. 
It initializes a 2D boolean table `dp` with the same dimensions as the input string `s`. 
The `dp[i][j]` value is set to `true` if the substring from index `i` to index `j` is a palindrome.

The algorithm then iterates through the string in a nested loop, starting from the first character to the last. 
It checks if the substring from index `i` to index `j` is a palindrome. 
If it is, it sets the `dp[i][j]` value to `true`. 
If the substring is of length 2 or 3, it sets the `dp[i][j]` value to `true` as well.

After the nested loop, the algorithm iterates through the `dp` table to find the longest palindromic substring. 
It keeps track of the maximum length and the starting and ending indices of the substring.

Finally, the algorithm returns the substring from the starting index to the ending index.

### Code
```python
def longestPalindrome(s: str) -> str:
    n = len(s)
    dp = [[False] * n for _ in range(n)]

    for i in range(n):
        dp[i][i] = True
        if i + 1 < n:
            dp[i][i + 1] = s[i] == s[i + 1]

    max_len = 1
    start = 0
    end = 0

    for i in range(n - 1):
        for j in range(i + 1, n):
            if j - i == 1 or dp[i + 1][j - 1]:
                dp[i][j] = s[i] == s[j]
                if j - i + 1 > max_len:
                    max_len = j - i + 1
                    start = i
                    end = j

    return s[start:end + 1]
```

वास्तविक्ता

### Explanation 
1. Initialize `start` and `maxLength` for result substring. 
2. Iterate through the given string `s` using the index `i`. 
3. For each index `i`, create two pointers `l` and `r` starting at `i`. 
4. Check if there's a consecutive sequence of identical characters, increment the right pointer `r` until the end of the sequence is reached. 
5. Update the index `i` to the current value of `r`. 
6. Expand the pointers `l` and `r` outwards to find the longest palindromic substring, checking that characters on both sides are equal. 
7. If the current length of the substring is greater than `maxLength`, update `start` and `maxLength`. 
8. Return the longest palindromic substring using the `start` and `maxLength`. 

### Code 
```python 
def longest_palindromic_substring(s: str) → str:
    n = len(s)
    if n == 0:
        return ""
    
    start, max_length = 0, 1
    for i in range(n):
        l, r = i, i
        while r < n - 1 and s[r] == s[r + 1]:
            r += 1
            i = r
        while l > 0 and r < n - 1 and s[l - 1] == s[r + 1]:
            l -= 1
            r += 1
        length = r - l + 1
        if length > max_length:
            start, max_length = l, length
    return s[start:start + max_length]
```

दिलचस्प बात यह है कि कोड लामा 34बी पायथन का हमारा परिष्कृत संस्करण सबसे लंबे पैलिंड्रोमिक सबस्ट्रिंग के लिए एक गतिशील प्रोग्रामिंग-आधारित समाधान प्रदान करता है, जो चयनित परीक्षण उदाहरण से जमीनी सच्चाई में प्रदान किए गए समाधान से अलग है। हमारा सुव्यवस्थित मॉडल गतिशील प्रोग्रामिंग-आधारित समाधान को विस्तार से समझाता है। दूसरी ओर, गैर-फाइन-ट्यून्ड मॉडल ठीक इसके बाद संभावित आउटपुट को मतिभ्रम करता है print स्टेटमेंट (बाएं सेल में दिखाया गया है) क्योंकि आउटपुट axyzzyx दी गई स्ट्रिंग में सबसे लंबा पैलिंड्रोम नहीं है। समय की जटिलता के संदर्भ में, गतिशील प्रोग्रामिंग समाधान आम तौर पर प्रारंभिक दृष्टिकोण से बेहतर होता है। गतिशील प्रोग्रामिंग समाधान में O(n^2) की समय जटिलता है, जहां n इनपुट स्ट्रिंग की लंबाई है। यह गैर-फाइन-ट्यून्ड मॉडल के प्रारंभिक समाधान की तुलना में अधिक कुशल है, जिसमें O(n^2) की द्विघात समय जटिलता भी थी लेकिन कम अनुकूलित दृष्टिकोण के साथ।

यह आशाजनक लग रहा है! याद रखें, हमने कोड LIama Python वेरिएंट को केवल 10% के साथ फाइन-ट्यून किया है डॉल्फिन कोडर डेटासेट. तलाशने के लिए और भी बहुत कुछ है!

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

ह्यूमनएवल के साथ मात्रात्मक मूल्यांकन

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

प्रत्येक पायथन-आधारित प्रोग्रामिंग प्रश्न के लिए, हम इसे k प्रतिक्रियाएँ प्राप्त करने के लिए SageMaker एंडपॉइंट पर तैनात कोड LIama मॉडल पर भेजते हैं। इसके बाद, हम HumanEval रिपॉजिटरी में एकीकरण परीक्षणों पर प्रत्येक k प्रतिक्रिया को चलाते हैं। यदि k प्रतिक्रियाओं में से कोई भी प्रतिक्रिया एकीकरण परीक्षण पास कर लेती है, तो हम मानते हैं कि परीक्षण मामला सफल है; अन्यथा, असफल. फिर हम अंतिम मूल्यांकन स्कोर के रूप में सफल मामलों के अनुपात की गणना करने के लिए प्रक्रिया को दोहराते हैं pass@k. मानक अभ्यास का पालन करते हुए, हम अपने मूल्यांकन में k को 1 के रूप में सेट करते हैं, ताकि प्रति प्रश्न केवल एक प्रतिक्रिया उत्पन्न हो सके और परीक्षण किया जा सके कि यह एकीकरण परीक्षण पास करता है या नहीं।

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

%pip3 install human_eval
import json
from human_eval.evaluation import evaluate_functional_correctness
from human_eval.data import write_jsonl, read_problems
from tqdm import tqdm
problems = read_problems()

num_samples_per_task = 1 # value k: number of responses for each question
samples = [
    dict(task_id=task_id, completion=generate_one_completion(problems[task_id]["prompt"]))
    for task_id in tqdm(problems)
    for _ in range(num_samples_per_task)
]
write_jsonl("samples.jsonl", samples)

evaluate_functional_correctness('./samples.jsonl')

निम्न तालिका विभिन्न मॉडल आकारों में गैर-फाइन-ट्यून किए गए मॉडल की तुलना में फाइन-ट्यून किए गए कोड LIama पायथन मॉडल के सुधार को दर्शाती है। शुद्धता सुनिश्चित करने के लिए, हम सेजमेकर एंडपॉइंट्स में गैर-फाइन-ट्यून कोड LIama मॉडल भी तैनात करते हैं और मानव मूल्यांकन मूल्यांकन के माध्यम से चलते हैं। पास@1 संख्याएँ (निम्न तालिका में पहली पंक्ति) रिपोर्ट की गई संख्याओं से मेल खाती हैं कोड लामा शोध पत्र। अनुमान पैरामीटर लगातार इस प्रकार सेट किए गए हैं "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

जैसा कि हम परिणामों से देख सकते हैं, सभी फाइन-ट्यून कोड LIama पायथन वेरिएंट गैर-फाइन-ट्यून मॉडल की तुलना में महत्वपूर्ण सुधार दिखाते हैं। विशेष रूप से, कोड LIama Python 70B गैर-फाइन-ट्यून किए गए मॉडल से लगभग 12% बेहतर प्रदर्शन करता है।

अब आप अपने स्वयं के डेटासेट पर कोड LIama मॉडल को फाइन-ट्यूनिंग करने का प्रयास कर सकते हैं।

क्लीन अप

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

निष्कर्ष

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

लेखक के बारे में

डॉ शिन हुआंग Amazon SageMaker JumpStart और Amazon SageMaker बिल्ट-इन एल्गोरिदम के लिए एक वरिष्ठ एप्लाइड साइंटिस्ट हैं। वह स्केलेबल मशीन लर्निंग एल्गोरिदम विकसित करने पर ध्यान केंद्रित करता है। उनकी शोध रुचि प्राकृतिक भाषा प्रसंस्करण, सारणीबद्ध डेटा पर व्याख्यात्मक गहन शिक्षा और गैर-पैरामीट्रिक स्पेस-टाइम क्लस्टरिंग के मजबूत विश्लेषण के क्षेत्र में है। उन्होंने एसीएल, आईसीडीएम, केडीडी सम्मेलनों और रॉयल स्टैटिस्टिकल सोसाइटी: सीरीज़ ए में कई पत्र प्रकाशित किए हैं।

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

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

डॉ आशीष खेतानी Amazon SageMaker बिल्ट-इन एल्गोरिदम के साथ एक वरिष्ठ एप्लाइड साइंटिस्ट हैं और मशीन लर्निंग एल्गोरिदम विकसित करने में मदद करते हैं। उन्होंने इलिनोइस विश्वविद्यालय उरबाना-शैंपेन से पीएचडी की उपाधि प्राप्त की। वह मशीन लर्निंग और सांख्यिकीय अनुमान में एक सक्रिय शोधकर्ता हैं, और उन्होंने NeurIPS, ICML, ICLR, JMLR, ACL और EMNLP सम्मेलनों में कई पत्र प्रकाशित किए हैं।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
• प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• प्लेटोईएसजी. कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
• प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
• स्रोत: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/