Llama 3.2 Vision का फाइन-ट्यूनिंग

हमने बड़े भाषा मॉडलों के फाइन-ट्यूनिंग (LLMs) पर कई गाइड देखे हैं, लेकिन मल्टीमोडल मॉडलों के फाइन-ट्यूनिंग की प्रक्रिया को कवर करने वाले संसाधन बहुत कम हैं। इस ट्यूटोरियल में, हम Llama 3.2 Vision नामक अत्याधुनिक मल्टीमोडल मॉडल का अन्वेषण करेंगे और दिखाएंगे कि Amazon उत्पाद डेटासेट का उपयोग करके इसे कैसे फाइन-ट्यून किया जाए। हमारा उद्देश्य एक ऐसा उत्पाद विवरण जनरेटर बनाना है जो Amazon पर सूचीबद्ध उत्पादों के लिए सटीक और सरल इमेज कैप्शन प्रदान करे।

यदि आप LLMs के फाइन-ट्यूनिंग में नए हैं, तो कृपया Fine-tuning with Llama 3 कोर्स लें ताकि आप आम कार्यप्रणालियों और शब्दावली से परिचित हो सकें। आप हमारा Llama 3.2 90B ट्यूटोरियल भी देख सकते हैं, जिसमें Streamlit को फ्रंट एंड के रूप में, कैप्शन जनरेशन के लिए Llama 3.2 90B, और API के रूप में Groq का उपयोग करके इमेज कैप्शनिंग ऐप बनाना शामिल है।

छवि: लेखक द्वारा

Llama 3.2 Vision मॉडलों को समझना

Llama 3.2 ऐसे मल्टीमोडल मॉडल प्रस्तुत करता है जो छवि और पाठ दोनों डेटा को संसाधित कर प्राकृतिक और सटीक प्रतिक्रियाएँ उत्पन्न कर सकते हैं। Llama 3.2 विज़न मॉडल 11B और 90B पैरामीटर वेरिएंट में उपलब्ध हैं और विशेष रूप से उच्च सटीकता के साथ इमेज रीज़निंग उपयोग मामलों को संभालने के लिए डिज़ाइन किए गए हैं। ये मॉडल सामान्य उद्योग बेंचमार्क पर कई मौजूदा ओपन-सोर्स और क्लोज़्ड मल्टीमोडल मॉडलों से बेहतर प्रदर्शन करते हैं।

सभी मॉडल वेरिएंट्स के बारे में विस्तार से जानने के लिए पढ़ें Llama 3.2 गाइड: यह कैसे काम करता है, उपयोग के मामले, और अधिक।

Llama 3.2 विज़न मॉडल दस्तावेज़-स्तरीय समझ, चार्ट और ग्राफ़ विश्लेषण, इमेज कैप्शनिंग, और विज़ुअल ग्राउंडिंग जैसे कार्यों में उत्कृष्ट हैं, जहाँ प्राकृतिक भाषा विवरणों का उपयोग करके छवियों में वस्तुओं की पहचान की जाती है।

Llama 3.2 Vision मॉडल आर्किटेक्चर

Llama 3.2 Vision मॉडल पुराने Llama 3.1 टेक्स्ट-ओनली मॉडल के ऊपर बनाया गया है, जो एक उन्नत ट्रांसफॉर्मर-आधारित भाषा मॉडल है। इसे सुपर्वाइज्ड लर्निंग (SFT) और मानव फीडबैक के साथ रिइनफोर्समेंट लर्निंग (RLHF) से फाइन-ट्यून किया गया है ताकि सहायतापूर्णता और सुरक्षा के लिए मानवीय प्राथमिकताओं के अनुरूप बनाया जा सके। 

इमेज पहचान को सक्षम करने के लिए, Llama 3.2 Vision में अलग से प्रशिक्षित एक विज़न अडैप्टर शामिल है। यह अडैप्टर क्रॉस-अटेंशन लेयर्स का उपयोग करके इमेज एन्कोडर के आउटपुट को प्री-ट्रेंड Llama 3.1 भाषा मॉडल में एकीकृत करता है, जिससे यह पाठ और छवि-आधारित दोनों कार्यों को प्रभावी ढंग से संभाल सके।

Llama 3.2 Vision की प्रमुख विशेषताएँ

• इमेज समझ: यह छवियों में वस्तुओं को आसानी से पहचान और वर्गीकृत कर सकता है, जिससे इमेज कैप्शनिंग और दृश्य व्याख्या जैसे कार्य संभव होते हैं।
• जटिल OCR और चार्ट समझ: Llama 3.2 मॉडल का 90B संस्करण चार्ट और ग्राफ़ जैसे जटिल विज़ुअलाइज़ेशनों से अंतर्दृष्टि निकालने में उत्कृष्ट है।
• दस्तावेज़ समझ: यह एंड-टू-एंड OCR (ऑप्टिकल कैरेक्टर रिकग्निशन) को सपोर्ट करता है, जिससे उपयोगकर्ता सीधे दस्तावेज़ों से पाठ और डेटा निकाल सकते हैं।
• विज़ुअल ग्राउंडिंग: नया मॉडल उपयोगकर्ताओं को वस्तुओं की सही पहचान करने या विज़ुअल डेटा से जुड़ी पूछताछ का उत्तर देने की सुविधा देता है।

Llama 3.2 Vision के उपयोग के मामले

Llama 3.2 Vision विज़ुअल प्रश्नोत्तर, दस्तावेज़ विश्लेषण, इमेज कैप्शनिंग, इमेज-टेक्स्ट रिट्रीवल और विज़ुअल ग्राउंडिंग जैसे उपयोग मामलों में उत्कृष्ट है।

1. Visual Question Answering (VQA): छवि की सामग्री समझकर उसके आधार पर प्रश्नों का उत्तर दें।
2. Document VQA (DocVQA): मानचित्र या अनुबंध जैसे दस्तावेज़ों का विश्लेषण करें, पाठ और लेआउट दोनों की व्याख्या करके प्रश्नों का उत्तर दें।
3. इमेज कैप्शनिंग: विवरण निकालकर और दृश्यों को समझकर प्राकृतिक भाषा में कैप्शन जनरेट करें।
4. इमेज-टेक्स्ट रिट्रीवल: छवियों को पाठ विवरणों से मिलाएँ, जिससे उन्नत खोज और संगठन संभव हो।
5. विज़ुअल ग्राउंडिंग: प्राकृतिक भाषा के विवरणों के आधार पर छवियों में वस्तुओं या क्षेत्रों की सटीक पहचान करें।

Amazon उत्पाद डेटासेट पर Llama 3.2 Vision का फाइन-ट्यूनिंग

इस प्रोजेक्ट के लिए, हम कोडिंग और कंप्यूटिंग वातावरण के रूप में Kaggle, फाइन-ट्यूनिंग फ्रेमवर्क के रूप में Unsloth, और Amazon उत्पाद विवरण डेटासेट का उपयोग करेंगे। Unsloth तेज है, कम GPU मेमोरी उपयोग करता है, और पारंपरिक तरीकों की तुलना में कम लाइनों का कोड मांगता है। 

यदि आप टेक्स्ट जनरेशन समाधान के लिए LLMs को फाइन-ट्यून करना चाहते हैं, तो हमारे पास आपके लिए उपयुक्त ट्यूटोरियल है: Llama 3.2 का फाइन-ट्यूनिंग और लोकल रूप से उपयोग: चरण-दर-चरण गाइड।

1. सेटअप करना

एक नया Kaggle नोटबुक बनाएँ और एक्सेलेरेटर को दो T4 GPUs उपयोग करने के लिए सेट करें। अपना Hugging Face टोकन Kaggle सीक्रेट के रूप में जोड़ें ताकि बाद में आप अपने मॉडल को सुरक्षित रूप से अपने Hugging Face रिपॉजिटरी में पुश कर सकें। फिर pip कमांड का उपयोग करके unsloth Python पैकेज इंस्टॉल करें।

%%capture
!pip install unslothसंचालित द्वारा

Unsloth के बारे में अधिक जानने के लिए पढ़ें Unsloth गाइड: LLM फाइन-ट्यूनिंग का अनुकूलन और तेज़ी।

2. मॉडल लोड करें

इस सेटअप में, हम Llama-3.2-11B-Vision-Instruct मॉडल लोड कर रहे हैं, विशेष रूप से Unsloth द्वारा प्रदत्त संस्करण, जो कुशल फाइन-ट्यूनिंग और इन्फ़रेंस के लिए अनुकूलित है। मॉडल को 4-बिट क्वांटाइज़ेशन में लोड किया गया है ताकि मेमोरी उपयोग और संगणनात्मक आवश्यकताओं को काफी कम किया जा सके, जिससे T4 GPUs पर बड़े विज़न मॉडल चलाना संभव हो जाए।

from unsloth import FastVisionModel
import torch

model, tokenizer = FastVisionModel.from_pretrained(
    "unsloth/Llama-3.2-11B-Vision-Instruct",
    load_in_4bit = True,
    use_gradient_checkpointing = "unsloth",
)संचालित द्वारा

3. LoRA सेट करना

LoRA (Low-Rank Adaptation) एक तकनीक है जो बड़े प्री-ट्रेंड मॉडलों में मॉडल के विशिष्ट हिस्सों में सीखने योग्य लो-रैंक मैट्रिस जोड़कर कुशलतापूर्वक फाइन-ट्यूनिंग करती है। यह तरीका हल्का और संगणनात्मक रूप से कुशल है और प्री-ट्रेंड मॉडल की मुख्य संरचना में बदलाव किए बिना कार्य-विशिष्ट फाइन-ट्यूनिंग की अनुमति देता है।

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

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, 
    finetune_language_layers   = True, 
    finetune_attention_modules = True,
    finetune_mlp_modules       = True,
    r = 16,           
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    random_state = 3443,
    use_rslora = False,
    loftq_config = None,
)संचालित द्वारा

4. डेटासेट लोड करना

Hugging Face Hub से philschmid/amazon-product-descriptions-vlm डेटासेट लोड करें और केवल पहले 500 सैंपल चुनें। इस डेटासेट में उत्पाद छवियाँ और उत्पाद विवरण अन्य आवश्यक जानकारी के साथ शामिल हैं।

from datasets import load_dataset
dataset = load_dataset("philschmid/amazon-product-descriptions-vlm", 
                       split = "train[0:500]")


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

Dataset({
    features: ['image', 'Uniq Id', 'Product Name', 'Category', 'Selling Price', 'Model Number', 'About Product', 'Product Specification', 'Technical Details', 'Shipping Weight', 'Variants', 'Product Url', 'Is Amazon Seller', 'description'],
    num_rows: 500
})संचालित द्वारा

यह उत्पाद की छवियों में से एक है। 

dataset[45]["image"]संचालित द्वारा

यह रहा इसका विवरण। 

dataset[45]["description"]संचालित द्वारा

'Authentic Dale Earnhardt Jr. 1:24 scale diecast car. Nationwide Raw Finish.  Collectible model car for racing fans.  Perfect gift for NASCAR enthusiasts.'संचालित द्वारा

5. डेटासेट प्रोसेस करना

अब, हम उस डेटासेट को प्रोसेस करेंगे जिसमें केवल पाठ और छवियाँ हों। प्रॉम्प्ट टेम्पलेट्स में उपयोगकर्ता के प्रश्न, छवियाँ, और उत्पाद विवरण शामिल हैं। 

instruction = """
You are an expert Amazon worker who is good at writing product descriptions. 
Write the product description accurately by looking at the image.
"""


def convert_to_conversation(sample):
    conversation = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": instruction},
                {"type": "image", "image": sample["image"]},
            ],
        },
        {
            "role": "assistant",
            "content": [{"type": "text", "text": sample["description"]}],
        },
    ]
    return {"messages": conversation}


pass


converted_dataset = [convert_to_conversation(sample) for sample in dataset]संचालित द्वारा

नया डेटासेट टेबलर नहीं है; इसके बजाय, यह OpenAI के फॉर्मेट जैसा प्रॉम्प्ट स्टाइल अपनाता है।

converted_dataset[45]संचालित द्वारा

{'messages': [{'role': 'user',
   'content': [{'type': 'text',
     'text': '\nYou are an expert Amazon worker who is good at writing product descriptions. \nWrite the product description accurately by looking at the image.\n'},
    {'type': 'image',
     'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x302>}]},
  {'role': 'assistant',
   'content': [{'type': 'text',
     'text': 'Authentic Dale Earnhardt Jr. 1:24 scale diecast car. Nationwide Raw Finish.  Collectible model car for racing fans.  Perfect gift for NASCAR enthusiasts.'}]}]}संचालित द्वारा

6. फाइन-ट्यूनिंग से पहले मॉडल इन्फ़रेंस

हम डेटासेट से 46वाँ सैंपल चुनेंगे और उस पर इन्फ़रेंस चलाएँगे ताकि बिना फाइन-ट्यूनिंग के यह बॉक्स से बाहर उत्पाद विवरण कितना अच्छा लिखता है, आकलन कर सकें।

FastVisionModel.for_inference(model)  # Enable for inference!

image = dataset[45]["image"]

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": instruction},
        ],
    }
]
input_text = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True
)
inputs = tokenizer(
    image,
    input_text,
    add_special_tokens=False,
    return_tensors="pt",
).to("cuda")

from transformers import TextStreamer

text_streamer = TextStreamer(tokenizer, skip_prompt=True)
_ = model.generate(
    **inputs,
    streamer=text_streamer,
    max_new_tokens=128,
    use_cache=True,
    temperature=1.5,
    min_p=0.1
)संचालित द्वारा

जनरेटेड विवरण लंबा और गलत है। लिखने की शैली भी अलग है। 

The image showcases a race car featuring the well-known sponsorship branding "Nationwide," likely the primary vehicle in the Nationwide Series. The vehicle has a blue hood with the "Nationwide" logo prominently displayed and white text that reads, "on your side," on the windscreen. The car is predominantly white and grey, adorned with sponsor decals on various parts of the vehicle.

The front grille showcases the Chevrolet "Bowtie" logo, and the car is equipped with Chevrolet emblems and other sponsor decals, including:

• A white 88 logo on the front windscreen

Notably, the vehicle's wheels are equipped with "GoodYearसंचालित द्वारा

7. फाइन-ट्यूनिंग के लिए मॉडल तैयार करना

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

from unsloth import is_bf16_supported
from unsloth.trainer import UnslothVisionDataCollator
from trl import SFTTrainer, SFTConfig

FastVisionModel.for_training(model)  # Enable for training!

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    data_collator=UnslothVisionDataCollator(model, tokenizer),  # Must use!
    train_dataset=converted_dataset,
    args=SFTConfig(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=30,
        learning_rate=2e-4,
        fp16=not is_bf16_supported(),
        bf16=is_bf16_supported(),
        logging_steps=5,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
        report_to="none",  # For Weights and Biases
        remove_unused_columns=False,
        dataset_text_field="",
        dataset_kwargs={"skip_prepare_dataset": True},
        dataset_num_proc=4,
        max_seq_length=2048,
    ),
)संचालित द्वारा

8. मॉडल का प्रशिक्षण

trainer.train() को चलाकर प्रशिक्षण प्रक्रिया शुरू करें। 

trainer_stats = trainer.train()संचालित द्वारा

मॉडल ने 16 मिनट में एक एPOCH पूरा कर लिया है, और प्रशिक्षण लॉस धीरे-धीरे कम हुआ है। यह अच्छा परिणाम है।

9. फाइन-ट्यूनिंग के बाद मॉडल इन्फ़रेंस

अब हम अपने मॉडल का परीक्षण करेंगे कि फाइन-ट्यूनिंग सफल रही या नहीं। हम डेटासेट से वही सैंपल छवि चुनेंगे और उस पर इन्फ़रेंस चलाएँगे।

FastVisionModel.for_inference(model)  # Enable for inference!

image = dataset[45]["image"]

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": instruction},
        ],
    }
]
input_text = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True
)
inputs = tokenizer(
    image,
    input_text,
    add_special_tokens=False,
    return_tensors="pt",
).to("cuda")

from transformers import TextStreamer

text_streamer = TextStreamer(tokenizer, skip_prompt=True)
_ = model.generate(
    **inputs,
    streamer=text_streamer,
    max_new_tokens=128,
    use_cache=True,
    temperature=1.5,
    min_p=0.1
)संचालित द्वारा

परिणाम अच्छे हैं लेकिन पूरी तरह सटीक नहीं। हैशटैग अनावश्यक थे। सर्वोत्तम परिणामों के लिए, हमें पूरे डेटासेट पर कम से कम 3 Epochs तक मॉडल को प्रशिक्षित करने की आवश्यकता होगी। 

Bring the thrill of NASCAR racing to your desk or shelf with the 1/64 Die-Cast 2016 NASCAR 88 Dale Earnhardt Jr. Nationwide Chevrolet SS!  Highly detailed and precision engineered, this collectible die-cast car captures the iconic look of Earnhardt's famous No. 88 ride. Perfect for kids and adults alike, this miniature masterpiece makes a great gift. #NASCAR #DieCast #CollectibleCars #DaleEarnhardtJr #Nationwide<|eot_id|>संचालित द्वारा

10. मॉडल और टोकनाइज़र सहेजना

आइए मॉडल को लोकल रूप से सहेजें और फिर उसे Hugging Face Hub पर पुश करें। मॉडल को Hugging Face सर्वर पर अपलोड करने के लिए, हमें अपने Hugging Face टोकन का उपयोग करके लॉग इन करना होगा। 

Hugging Face की रूपांतरकारी दुनिया, जो मशीन लर्निंग और बड़े भाषा मॉडलों (LLMs) के लिए AI समुदाय का ओपन-सोर्स हब है, के बारे में पढ़ने के लिए ब्लॉग देखें What is Hugging Face? The AI Community's Open-Source Oasis।

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(hf_token)संचालित द्वारा

इसके बाद, मॉडल और टोकनाइज़र को लोकल रूप से सहेजें।

model.save_pretrained("llama_3.2_vision_amazon_product") # Local saving
tokenizer.save_pretrained("llama_3.2_vision_amazon_product")संचालित द्वारा

फिर push_to_hub का उपयोग करके मॉडल को Hugging Face हब पर सहेजें।

model.push_to_hub(
    "kingabzpro/llama_3.2_vision_amazon_product"
)  # Online saving
tokenizer.push_to_hub(
    "kingabzpro/llama_3.2_vision_amazon_product"
)  # Online savingसंचालित द्वारा

Saved model to https://huggingface.co/kingabzpro/llama_3.2_vision_amazon_productसंचालित द्वारा

उपरोक्त कमांड नया मॉडल रिपॉजिटरी बनाएगा और सभी फ़ाइलें Hugging Face पर पुश कर देगा। 

स्रोत: kingabzpro/llama_3.2_vision_amazon_product

यदि आप उपरोक्त कोड चलाने में समस्याओं का सामना कर रहे हैं, तो कृपया Kaggle नोटबुक देखें: Fine-tuning Llama 3.2 Vision on Amazon Dataset

निष्कर्ष

Llama 3.2 Vision मॉडलों का फाइन-ट्यूनिंग संभावनाओं की एक नई दुनिया खोलता है, खासकर उन परिदृश्यों में जहाँ प्रासंगिक और सटीक परिणाम देने के लिए छवियों और पाठ दोनों की आवश्यकता होती है। कस्टम डेटासेट पर फाइन-ट्यूनिंग करके, हम प्रदर्शन में सुधार कर सकते हैं और शैली को VQA, DocVQA, इमेज कैप्शनिंग और इमेज-टेक्स्ट रिट्रीवल जैसे अनुप्रयोगों के लिए अनुकूलित कर सकते हैं।

इस ट्यूटोरियल में, हमने Llama 3.2 Vision मॉडलों के बारे में गहराई से सीखा। हमने मॉडल के 11B वेरिएंट को Amazon उत्पाद विवरण डेटासेट पर फाइन-ट्यून भी किया ताकि एक अत्यधिक कस्टमाइज़्ड उत्पाद विवरण जनरेटर तैयार किया जा सके, जो वांछित शैली अपनाए और उत्पादों के सटीक विवरण प्रदान करे।

आपकी अगली कड़ी यह सीखना है कि AI एप्लीकेशन कैसे बनाएं और इसे Docker इमेज का उपयोग करके क्लाउड पर डिप्लॉय करें। गाइड देखें: How to Deploy LLM Applications Using Docker: A Step-by-Step Guide।