भाग 1: फेस हब को गले लगाने के लिए एक डेटासेट अपलोड करना
परिचय
ट्यूटोरियल का यह हिस्सा आपको एक कस्टम डेटासेट अपलोड करने की प्रक्रिया के माध्यम से हगिंग फेस हब पर चलता है। हगिंग फेस हब एक ऐसा मंच है जो डेवलपर्स को मशीन लर्निंग के लिए डेटासेट और मॉडल पर साझा करने और सहयोग करने की अनुमति देता है।
यहां, हम एक मौजूदा पायथन इंस्ट्रक्शन-फॉलोइंग डेटासेट लेंगे, इसे नवीनतम बड़े भाषा मॉडल (एलएलएम) को प्रशिक्षित करने के लिए उपयुक्त एक प्रारूप में बदल देंगे, और फिर इसे सार्वजनिक उपयोग के लिए गले लगाने के लिए अपलोड करें। हम विशेष रूप से LLAMA 3.2 चैट टेम्पलेट से मेल करने के लिए अपने डेटा को प्रारूपित कर रहे हैं, जो इसे ठीक-ट्यूनिंग Llama 3.2 मॉडल के लिए तैयार करता है।
चरण 1: स्थापना और प्रमाणीकरण
सबसे पहले, हमें आवश्यक पुस्तकालयों को स्थापित करने और हगिंग फेस हब के साथ प्रमाणित करने की आवश्यकता है:
!pip install -q datasets
!huggingface-cli login
यहाँ क्या हो रहा है:
- डेटासेट मशीन लर्निंग डेटासेट के साथ काम करने के लिए फेस की लाइब्रेरी को गले लगा रहा है
- शांत ध्वज -क स्थापना आउटपुट संदेशों को कम करता है
- हगिंगफेस-क्ली लॉगिन आपको अपने हगिंग फेस ऑथेंटिकेशन टोकन में प्रवेश करने के लिए प्रेरित करेगा
- आप अपने टोकन को अपने हगिंग फेस अकाउंट सेटिंग्स → एक्सेस टोकन पर जाकर पा सकते हैं
इस सेल को चलाने के बाद, आपको अपने टोकन में प्रवेश करने के लिए प्रेरित किया जाएगा। यह आपके सत्र को प्रमाणित करता है और आपको सामग्री को हब पर धकेलने की अनुमति देता है।
चरण 2: डेटासेट लोड करें और परिवर्तन फ़ंक्शन को परिभाषित करें
अगला, हम एक मौजूदा डेटासेट को लोड करेंगे और लामा 3.2 चैट प्रारूप से मेल खाने के लिए इसे बदलने के लिए एक फ़ंक्शन को परिभाषित करेंगे:
from datasets import load_dataset
# Load your complete custom dataset
dataset = load_dataset('Vezora/Tested-143k-Python-Alpaca')
# Define a function to transform the data
def transform_conversation(example):
system_prompt = """
You are an expert Python coding assistant. Your role is to help users write clean, efficient, and bug-free Python code.
You have been trained on a diverse set of high-quality Python code samples, all of which passed rigorous
automated testing for functionality and performance.
Always follow best practices in Python programming, provide concise and readable solutions,
and ensure that your responses include informative comments when necessary.
When presented with a coding problem, first create a detailed pseudocode that outlines the
structure and logic of the solution step-by-step. Once the pseudocode is complete,
follow it to generate the actual Python code. This approach will help ensure
clarity and alignment with the desired logic before writing the code.
If asked to modify existing code, provide pseudocode highlighting the changes and
optimizations to be made, focusing on improvements related to performance, error handling,
and robustness. Remember to explain your thought process and rationale clearly for
any modifications or code suggestions you provide.
"""
instruction = example('instruction').strip() # Accessing the instruction column
output = example('output').strip() # Accessing the output column
formatted_text = (
f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
{system_prompt}
<|eot_id|>n<|start_header_id|>user<|end_header_id|>
{instruction}
<|eot_id|><|start_header_id|>assistant<|end_header_id|>
{output}<|eot_id|>"""
)
# instruction = example('instruction').strip() # Accessing the instruction column
# output = example('output').strip() # Accessing the output column
# Apply the new template
# Since there is no system prompt, we construct the string without the SYS part
# formatted_text = f'(INST) {instruction} (/INST) {output} '
return {'text': formatted_text}
यहाँ क्या हो रहा है:
- हम ‘वेजोरा/परीक्षण -143K-Python-lpaca’ डेटासेट लोड करते हैं, जिसमें पायथन प्रोग्रामिंग निर्देश और आउटपुट शामिल हैं
- हम एक परिवर्तन फ़ंक्शन को परिभाषित करते हैं जो प्रत्येक उदाहरण को लामा 3.2 चैट प्रारूप में पुनर्गठन करता है
- हम एक विस्तृत सिस्टम प्रॉम्प्ट शामिल करते हैं जो पायथन कोडिंग असिस्टेंट के रूप में मॉडल को अपनी भूमिका के बारे में संदर्भ देता है
- विशेष टोकन जैसे <| gult_of_text |>, <| start_header_id |>, और <| eot_id |
- यह फ़ंक्शन सिस्टम, उपयोगकर्ता और सहायक संदेशों के साथ एक अच्छी तरह से स्वरूपित बातचीत बनाता है
सिस्टम प्रॉम्प्ट विशेष रूप से महत्वपूर्ण है क्योंकि यह मॉडल के लिए व्यक्तित्व और व्यवहार की अपेक्षाओं को परिभाषित करता है। इस मामले में, हम मॉडल को एक विशेषज्ञ पायथन कोडिंग सहायक के रूप में कार्य करने के लिए निर्देश दे रहे हैं जो सर्वोत्तम प्रथाओं का पालन करता है और अच्छी तरह से कॉम्प्लिम्टेड, कुशल समाधान प्रदान करता है।
चरण 3: डेटासेट में परिवर्तन लागू करें
अब हम अपने परिवर्तन फ़ंक्शन को पूरे डेटासेट पर लागू करते हैं:
# Apply the transformation to the entire dataset
transformed_dataset = dataset('train').map(transform_conversation)यहाँ क्या हो रहा है:
- मानचित्र () फ़ंक्शन डेटासेट में हर उदाहरण पर हमारे परिवर्तन फ़ंक्शन को लागू करता है
- यह डेटासेट में सभी 143,000 उदाहरणों को संसाधित करता है, उन्हें लामा 3.2 चैट प्रारूप में सुधारता है
- परिणाम एक ही सामग्री के साथ एक नया डेटासेट है, लेकिन ठीक से ट्यूनिंग लामा 3.2 के लिए ठीक से संरचित है
यह परिवर्तन महत्वपूर्ण है क्योंकि यह लामा 3.2 मॉडल परिवार द्वारा आवश्यक विशिष्ट टेम्पलेट में डेटा को सुधारता है। इस स्वरूपण के बिना, मॉडल वार्तालाप (सिस्टम, उपयोगकर्ता, सहायक) में विभिन्न भूमिकाओं को नहीं पहचानता है या जहां प्रत्येक संदेश शुरू होता है और समाप्त होता है।
चरण 4: डेटासेट को हगिंग फेस हब पर अपलोड करें
हमारे डेटासेट तैयार होने के साथ, अब हम इसे हगिंग फेस हब पर अपलोड कर सकते हैं:
transformed_dataset.push_to_hub("Llama-3.2-Python-Alpaca-143k")यहाँ क्या हो रहा है:
- PUSH_TO_HUB () विधि हमारे रूपांतरित डेटासेट को हगिंग फेस हब पर अपलोड करती है
- “Llama-3.2-python-alpaca-143k” आपके डेटासेट रिपॉजिटरी का नाम होगा
- यह आपके उपयोगकर्ता नाम के तहत एक नया रिपॉजिटरी बनाता है: https://huggingface.co/datasets/your_username/llama-3.2-python-alpaca-143k
- डेटासेट अब सार्वजनिक रूप से दूसरों के लिए डाउनलोड और उपयोग करने के लिए उपलब्ध होगा
इस सेल को चलाने के बाद, आपको अपलोड स्थिति को इंगित करने वाली प्रगति बार दिखाई देंगे। एक बार पूरा होने के बाद, आप अपने नए अपलोड किए गए डेटासेट को देखने के लिए हगिंग फेस हब पर जा सकते हैं, इसका विवरण संपादित कर सकते हैं, और इसे समुदाय के साथ साझा कर सकते हैं।
यह डेटासेट अब पायथन प्रोग्रामिंग कार्यों पर ठीक-ट्यूनिंग लामा 3.2 मॉडल के लिए उपयोग करने के लिए तैयार है, ठीक से स्वरूपित वार्तालापों के साथ जिसमें सिस्टम निर्देश, उपयोगकर्ता प्रश्न और सहायक प्रतिक्रियाएं शामिल हैं!
भाग 2: फाइन-ट्यूनिंग और एक मॉडल अपलोड करना फेस हब को गले लगाने के लिए
अब जब हमने अपना डेटासेट तैयार किया है और अपलोड किया है, तो आइए एक मॉडल को ठीक करने के लिए आगे बढ़ें और इसे हगिंग फेस हब पर अपलोड करें।
चरण 1: आवश्यक पुस्तकालय स्थापित करें
सबसे पहले, हमें कुशलता से ठीक-ट्यूनिंग बड़ी भाषा मॉडल के लिए सभी आवश्यक पुस्तकालयों को स्थापित करने की आवश्यकता है:
!pip install "unsloth(colab-new) @ git+https://github.com/unslothai/unsloth.git"
!pip install "git+https://github.com/huggingface/transformers.git"
!pip install -U trl
!pip install --no-deps trl peft accelerate bitsandbytes
!pip install torch torchvision torchaudio triton
!pip install xformers
!python -m xformers.info
!python -m bitsandbytesयह क्या करता है: Unsloth (तेजी से LLM फाइन-ट्यूनिंग के लिए एक लाइब्रेरी), ट्रांसफॉर्मर का नवीनतम संस्करण, TRL (सुदृढीकरण सीखने के लिए), PEFT (पैरामीटर-कुशल फाइन-ट्यूनिंग के लिए), और प्रशिक्षण के लिए आवश्यक अन्य निर्भरताएं स्थापित करता है। Xformers और Bitsandbytes पुस्तकालयों को स्मृति दक्षता के साथ मदद करते हैं।
चरण 2: डेटासेट लोड करें
अगला, हम पिछले अनुभाग में तैयार किए गए डेटासेट को लोड करते हैं:
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
import torch
from datasets import load_dataset
max_seq_length = 2048
dataset = load_dataset("nikhiljatiwal/Llama-3.2-Python-Alpaca-143k", split="train")
यह क्या करता है: हमारे मॉडल के लिए अधिकतम अनुक्रम लंबाई सेट करता है और हमारे पहले अपलोड किए गए पायथन कोडिंग डेटासेट को गले लगाने से लोड करता है।
चरण 3: पूर्व-प्रशिक्षित मॉडल को लोड करें
अब हम Llama 3.2 का एक परिमाणित संस्करण लोड करते हैं:
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/Llama-3.2-3B-Instruct-bnb-4bit",
max_seq_length = max_seq_length,
dtype = None,
load_in_4bit = True
)
यह क्या करता है: अनसोलॉथ के रिपॉजिटरी से लामा 3.2 3 बी निर्देश मॉडल का 4-बिट क्वांटाइज्ड संस्करण लोड करता है। मॉडल के अधिकांश प्रदर्शन को बनाए रखते हुए परिमाणीकरण मेमोरी फुटप्रिंट को कम करता है।
चरण 4: PEFT कॉन्फ़िगर करें (पैरामीटर-कुशल फाइन-ट्यूनिंग)
हम लोरा (कम-रैंक अनुकूलन) का उपयोग करके कुशल फाइन-ट्यूनिंग के लिए मॉडल सेट करेंगे:
model = FastLanguageModel.get_peft_model(
model,
r = 16,
target_modules = ("q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",),
lora_alpha = 16,
lora_dropout = 0, # Supports any, but = 0 is optimized
bias = "none", # Supports any, but = "none" is optimized
# (NEW) "unsloth" uses 30% less VRAM, fits 2x larger batch sizes!
use_gradient_checkpointing = "unsloth", # True or "unsloth" for very long context
random_state = 3407,
use_rslora = False, # We support rank stabilized LoRA
loftq_config = None, # And LoftQ
max_seq_length = max_seq_length
)
यह क्या करता है: लोरा के साथ पैरामीटर-कुशल फाइन-ट्यूनिंग के लिए मॉडल को कॉन्फ़िगर करता है। यह तकनीक केवल मूल मॉडल को जमे हुए रखने के दौरान केवल नए मापदंडों की एक छोटी संख्या को प्रशिक्षित करती है, जिससे सीमित संसाधनों के साथ कुशल प्रशिक्षण की अनुमति मिलती है। हम 16 के रैंक के साथ मॉडल में विशिष्ट प्रक्षेपण परतों को लक्षित कर रहे हैं।
चरण 5: सहेजने के लिए Google ड्राइव माउंट करें
यह सुनिश्चित करने के लिए कि हमारे प्रशिक्षित मॉडल को बचाया जाता है, भले ही सत्र डिस्कनेक्ट हो जाए:
from google.colab import drive
drive.mount("/content/drive")यह क्या करता है: चौकियों और अंतिम मॉडल को सहेजने के लिए अपने Google ड्राइव को माउंट करता है।
चरण 6: प्रशिक्षण सेट करें और प्रशिक्षण शुरू करें
अब हम प्रशिक्षण प्रक्रिया को कॉन्फ़िगर करते हैं और शुरू करते हैं:
trainer = SFTTrainer(
model = model,
train_dataset = dataset,
dataset_text_field = "text",
max_seq_length = max_seq_length,
tokenizer = tokenizer,
args = TrainingArguments(
per_device_train_batch_size = 2,
gradient_accumulation_steps = 4,
warmup_steps = 10,
# num_train_epochs = 1, # Set this for 1 full training run.
max_steps = 60,
learning_rate = 2e-4,
fp16 = not torch.cuda.is_bf16_supported(),
bf16 = torch.cuda.is_bf16_supported(),
logging_steps = 1,
optim = "adamw_8bit",
weight_decay = 0.01,
lr_scheduler_type = "linear",
seed = 3407,
output_dir = "/content/drive/My Drive/Llama-3.2-3B-Instruct-bnb-4bit"
),
)
trainer.train()यह क्या करता है: हमारे मॉडल, डेटासेट और प्रशिक्षण मापदंडों के साथ एक पर्यवेक्षित फाइन-ट्यूनिंग ट्रेनर बनाता है। प्रशिक्षण 2 के बैच आकार के साथ 60 चरणों के लिए चलता है, 4 के ढाल संचय और 2E-4 की सीखने की दर। मॉडल चौकियों को Google ड्राइव पर सहेजा जाएगा।
चरण 7: स्थानीय रूप से ठीक-ठीक मॉडल को सहेजें
प्रशिक्षण के बाद, हम अपने मॉडल को बचाते हैं:
model.save_pretrained("lora_model") # Local saving
tokenizer.save_pretrained("lora_model")यह क्या करता है: एक स्थानीय निर्देशिका के लिए ठीक ट्यून किए गए लोरा मॉडल और टोकनकर्ता को बचाता है।
चरण 8: फेस हब को गले लगाने के लिए मॉडल अपलोड करें
अंत में, हम अपने ठीक-ठाक मॉडल को गले लगाने के लिए अपलोड करते हैं:
import os
from google.colab import userdata
HF_TOKEN = userdata.get('HF_WRITE_API_KEY')
model.push_to_hub_merged("nikhiljatiwal/Llama-3.2-3B-Instruct-code-bnb-4bit", tokenizer, save_method = "merged_16bit", token=HF_TOKEN)इस गाइड में, हमने हगिंग फेस का उपयोग करके एआई मॉडल अनुकूलन के लिए एक पूर्ण वर्कफ़्लो का प्रदर्शन किया। हमने एक विशेष सिस्टम प्रॉम्प्ट के साथ एक पायथन इंस्ट्रक्शन डेटासेट को लामा 3.2 प्रारूप में बदल दिया और इसे “llama-3.2-python-alpaca-143k” के रूप में अपलोड किया। हमने तब न्यूनतम कंप्यूटिंग संसाधनों के साथ कुशल तकनीकों (4-बिट क्वांटाइजेशन और लोरा) का उपयोग करके एक लामा 3.2 मॉडल को ठीक किया। अंत में, हमने फेस हब को हग करने के लिए दोनों संसाधनों को साझा किया, जिससे हमारे पायथन कोडिंग सहायक को समुदाय के लिए उपलब्ध हो गया। यह परियोजना दिखाती है कि एआई विकास कैसे सुलभ हो गया है, जिससे डेवलपर्स को अपेक्षाकृत मामूली संसाधनों के साथ विशिष्ट कार्यों के लिए विशेष मॉडल बनाने में सक्षम बनाया गया है।
यह रहा COLAB NOTEBOOK_LLAMA_3_2_3B_INSTRUCT_CODईटी और COLAB NOTEBOOK_LLAMA_3_2_PYTHON_ALPACA_143K । इसके अलावा, हमें फॉलो करना न भूलें ट्विटर और हमारे साथ जुड़ें तार -चैनल और लिंक्डइन जीआरओयूपी। हमारे साथ जुड़ने के लिए मत भूलना 90K+ एमएल सबरेडिट।
🔥 ।
निखिल मार्कटेकपोस्ट में एक प्रशिक्षु सलाहकार है। वह भारतीय प्रौद्योगिकी संस्थान, खड़गपुर में सामग्रियों में एक एकीकृत दोहरी डिग्री का पीछा कर रहा है। निखिल एक एआई/एमएल उत्साही है जो हमेशा बायोमैटेरियल्स और बायोमेडिकल साइंस जैसे क्षेत्रों में अनुप्रयोगों पर शोध कर रहा है। भौतिक विज्ञान में एक मजबूत पृष्ठभूमि के साथ, वह नई प्रगति की खोज कर रहा है और योगदान करने के अवसर पैदा कर रहा है।
