Phi 4 Multimodal: डेमो प्रोजेक्ट के साथ मार्गदर्शिका

Phi-4-multimodal Microsoft द्वारा विकसित एक हल्का मल्टिमोडल फाउंडेशन मॉडल है। यह Microsoft के Phi परिवार के स्मॉल लैंग्वेज मॉडल्स (SLMs) का हिस्सा है।

इस ट्यूटोरियल में, मैं चरण-दर-चरण समझाऊँगा कि कैसे Phi-4-multimodal का उपयोग करके एक मल्टिमोडल भाषा ट्यूटर बनाया जाए जो टेक्स्ट, इमेज और ऑडियो के साथ काम कर सके। इस एप्लिकेशन की प्रमुख विशेषताएँ हैं:

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

पहले हम Phi-4-multimodal मॉडल का एक बहुत संक्षिप्त परिचय करेंगे, और फिर ऐप बनाना शुरू करेंगे।

Phi-4-Multimodal क्या है?

Phi-4-multimodal टेक्स्ट, विज़न और स्पीच प्रोसेसिंग के लिए बनाया गया एक उन्नत AI मॉडल है। यह कई मोडैलिटी को सहजता से एकीकृत करने देता है, जिससे यह भाषा सीखने वाले अनुप्रयोगों के लिए आदर्श बनता है। इसकी कुछ प्रमुख क्षमताएँ इस प्रकार हैं:

• टेक्स्ट प्रोसेसिंग: इसमें व्याकरण सुधार, अनुवाद और वाक्य निर्माण शामिल हैं।
• विज़न प्रोसेसिंग: Phi 4 ऑप्टिकल कैरेक्टर रिकग्निशन (OCR), इमेज सारांशण और मल्टिमोडल इंटरैक्शन कर सकता है।
• स्पीच प्रोसेसिंग: यह ऑटोमैटिक स्पीच रिकग्निशन (ASR) के साथ उच्चारण फीडबैक और स्पीच-टू-टेक्स्ट अनुवाद भी कर सकता है।

128K टोकन कॉन्टेक्स्ट लंबाई के साथ, Phi-4 मल्टिमोडल मॉडल कुशल तर्क-वितर्क और मेमोरी-सीमित वातावरणों के लिए अनुकूलित है, जो इसे रियल-टाइम AI-संचालित भाषा सीखने के लिए एक उपयुक्त विकल्प बनाता है।

चरण 1: पूर्वापेक्षाएँ

जिस मल्टिमोडल भाषा ट्यूटर ऐप का हम निर्माण करने जा रहे हैं, वह एक AI-संचालित इंटरेक्टिव टूल है जिसे टेक्स्ट, इमेज और ऑडियो-आधारित इंटरैक्शन के संयोजन के माध्यम से उपयोगकर्ताओं को नई भाषाएँ सीखने में सहायता के लिए डिज़ाइन किया गया है।

शुरू करने से पहले, आइए सुनिश्चित कर लें कि निम्नलिखित टूल और लाइब्रेरीज़ इंस्टॉल हैं:

• Python 3.8+
• torch
• Transformers
• PIL
• Soundfile
• Gradio

आवश्यक डिपेंडेंसीज़ इंस्टॉल करने के लिए निम्न कमांड चलाएँ:

pip install gradio transformers torch soundfile pillowसंचालित द्वारा

बेहतर प्रदर्शन के लिए हमें यह भी सुनिश्चित करना होगा कि FlashAttention2 इंस्टॉल हो:

pip install flash-attn --no-build-isolationसंचालित द्वारा

नोट: यह प्रोजेक्ट Google Colab नोटबुक पर A100 GPU का उपयोग करता है। यदि आप एक पुराने GPU (जैसे, NVIDIA V100) का उपयोग करते हैं, तो आपको मॉडल इनिशियलाइज़ेशन स्टेप में _attn_implementation="eager" सेट करके FlashAttention2 को अक्षम करना पड़ सकता है।

उपरोक्त डिपेंडेंसीज़ इंस्टॉल होने के बाद, निम्न इम्पोर्ट कमांड चलाएँ:

import gradio as gr
import torch
import requests
import io
import os
import soundfile as sf
from PIL import Image
from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfigसंचालित द्वारा

चरण 2: Phi-4-Multimodal लोड करना

Phi-4 की मल्टिमोडल क्षमताओं का लाभ उठाने के लिए, हम पहले मॉडल और उसके प्रोसेसर—दोनों—लोड करते हैं। मॉडल पाथ Hugging Face से सेट किया जाता है, जबकि प्रोसेसर टेक्स्ट को टोकनाइज़ करता है, इमेज को रीसाइज़ और नॉर्मलाइज़ करता है, और ऑडियो वेवफॉर्म को मॉडल-संगत फ़ॉर्मेट में बदलता है ताकि मल्टिमोडल प्रोसेसिंग सहज हो सके।

# Load model and processor
model_path = "microsoft/Phi-4-multimodal-instruct"
processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_path, 
    device_map="cuda", 
    torch_dtype="auto", 
    trust_remote_code=True,
    _attn_implementation='flash_attention_2',
).cuda()
generation_config = GenerationConfig.from_pretrained(model_path)संचालित द्वारा

मॉडल इनिशियलाइज़ेशन स्टेप में 'AutoModelForCausalLM.from_pretrained()' फ़ंक्शन का उपयोग किया जाता है ताकि प्रीट्रेंड Phi-4 मॉडल को कॉज़ल लैंग्वेज मॉडलिंग (CLM) के लिए लोड किया जा सके और device_map="cuda" का उपयोग करके मॉडल को GPU पर लोड किया जा सके।

इस चरण में एक प्रमुख पैरामीटर `_attn_implementation='flash_attention_2'` है, जो लंबी संदर्भ-लंबाई के लिए तेज़ और अधिक मेमोरी-कुशल अटेंशन मैकेनिज़्म हेतु FlashAttention2 का उपयोग करता है।

चरण 3: प्रमुख फंक्शनैलिटी बनाना

अब जबकि हमने मॉडल लोड कर लिया है, आइए प्रमुख फंक्शनैलिटी बनाते हैं।

1. प्रतिक्रिया को साफ़ करना

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

def clean_response(response, instruction_keywords):
    """Removes the prompt text dynamically based on instruction keywords."""
    for keyword in instruction_keywords:
        if response.lower().startswith(keyword.lower()):
            response = response[len(keyword):].strip()
    return responseसंचालित द्वारा

हम बस strip() फ़ंक्शन का उपयोग करते हैं ताकि निर्देशात्मक कीवर्ड्स के आधार पर प्रॉम्प्ट टेक्स्ट हटाया जा सके।

2. इनपुट प्रोसेसिंग

अब, हम अपने इनपुट प्रोसेस करते हैं, जो उपयोगकर्ता इनपुट या परिदृश्य के आधार पर टेक्स्ट, इमेज या ऑडियो हो सकते हैं।

def process_input(file, input_type, question):
    user_prompt = "<|user|>"
    assistant_prompt = "<|assistant|>"
    prompt_suffix = "<|end|>"
    
    if input_type == "Image":
	prompt= f'{user_prompt}<|image_1|>{question}{prompt_suffix}{assistant_prompt}'
        image = Image.open(file)
	inputs = processor(text=prompt, images=image, return_tensors='pt').to(model.device)
    elif input_type == "Audio":
 	prompt= f'{user_prompt}<|audio_1|>{question}{prompt_suffix}{assistant_prompt}'
        audio, samplerate = sf.read(file)
        inputs = processor(text=prompt, audios=[(audio, samplerate)], return_tensors='pt').to(model.device)
    elif input_type == "Text":
        prompt = f'{user_prompt}{question} "{file}"{prompt_suffix}{assistant_prompt}'
        inputs = processor(text=prompt, return_tensors='pt').to(model.device)
    else:
        return "Invalid input type"    
    
    generate_ids = model.generate(**inputs, max_new_tokens=1000, generation_config=generation_config)
    response = processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
    return clean_response(response, [question])संचालित द्वारा

उपरोक्त फ़ंक्शन टेक्स्ट, इमेज और ऑडियो इनपुट को संभालने और Phi-4-multimodal मॉडल का उपयोग करके प्रतिक्रिया उत्पन्न करने के लिए ज़िम्मेदार है। इस वर्कफ़्लो का तकनीकी विवरण इस प्रकार है:

1. इमेज इनपुट प्रोसेसिंग: यदि इनपुट प्रकार "Image" है, तो प्रॉम्प्ट को इमेज प्लेसहोल्डर (<|image_1|>) के साथ फ़ॉर्मैट किया जाता है। फिर इमेज लोड की जाती है, और प्रोसेसर साथ के टेक्स्ट को टोकनाइज़ करते हुए दृश्य फीचर्स एक्सट्रैक्ट करता है। प्रोसेस्ड इनपुट्स को अनुकूलित गणना के लिए GPU पर भेजा जाता है।
2. ऑडियो इनपुट प्रोसेसिंग: यदि इनपुट प्रकार "Audio" है, तो प्रॉम्प्ट को ऑडियो प्लेसहोल्डर (<|audio_1|>) के साथ स्ट्रक्चर किया जाता है। ऑडियो फ़ाइल को sf.read() फ़ंक्शन से पढ़ा जाता है, जिससे रॉ वेवफॉर्म और सैंपल रेट निकाला जाता है। इसके बाद प्रोसेसर ऑडियो और टेक्स्ट—दोनों—को एन्कोड करता है, जिससे मल्टिमोडल समझ सुचारू हो।
3. टेक्स्ट इनपुट प्रोसेसिंग: यदि इनपुट प्रकार "Text" है, तो टेक्स्ट को सीधे प्रॉम्प्ट में शामिल किया जाता है। प्रोसेसर इनपुट को टोकनाइज़ और एन्कोड करता है, जिससे मॉडल द्वारा आगे प्रोसेसिंग के लिए तैयारी हो जाती है।

3. अनुवाद और व्याकरण सुधार

अगले चरण में, हम Phi-4-multimodal मॉडल का उपयोग करके टेक्स्ट का अनुवाद और व्याकरण सुधार प्रोसेस करते हैं। 

def process_text_translate(text, target_language):
    prompt = f'Translate the following text to {target_language}: "{text}"'
    return process_input(text, "Text", prompt)
def process_text_grammar(text):
    prompt = f'Check the grammar and provide corrections if needed for the following text: "{text}"'
    return process_input(text, "Text", prompt)संचालित द्वारा

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

इसी तरह, process_text_grammar() फ़ंक्शन एक व्याकरण सुधार प्रॉम्प्ट बनाता है, process_input() फ़ंक्शन को इनपुट टेक्स्ट और प्रकार के साथ कॉल करता है, और टेक्स्ट का व्याकरण-संशोधित संस्करण लौटाता है। दोनों फ़ंक्शनों से अनुवाद और व्याकरण सुधार के लिए मॉडल की क्षमताओं का सुव्यवस्थित उपयोग होता है।

चरण 4: Gradio के साथ मल्टिमोडल डेमो बनाना

अब हमारे पास सभी प्रमुख लॉजिक फ़ंक्शंस मौजूद हैं। अगला कदम है Gradio के साथ इंटरेक्टिव UI बनाना।

def gradio_interface():
    with gr.Blocks() as demo:
        gr.Markdown("# Phi 4 Powered - Multimodal Language Tutor")        
        with gr.Tab("Text-Based Learning"):
            text_input = gr.Textbox(label="Enter Text")
            language_input = gr.Textbox(label="Target Language", value="French")
            text_output = gr.Textbox(label="Response")
            text_translate_btn = gr.Button("Translate")
            text_grammar_btn = gr.Button("Check Grammar")
            text_clear_btn = gr.Button("Clear")
            text_translate_btn.click(process_text_translate, inputs=[text_input, language_input], outputs=text_output)
            text_grammar_btn.click(process_text_grammar, inputs=[text_input], outputs=text_output)
            text_clear_btn.click(lambda: ("", "", ""), outputs=[text_input, language_input, text_output])        
        with gr.Tab("Image-Based Learning"):
            image_input = gr.Image(type="filepath", label="Upload Image")
            language_input_image = gr.Textbox(label="Target Language for Translation", value="English")
            image_output = gr.Textbox(label="Response")
            image_clear_btn = gr.Button("Clear")
            image_translate_btn = gr.Button("Translate Text in Image")
            image_summarize_btn = gr.Button("Summarize Image")
            image_translate_btn.click(process_input, inputs=[image_input, gr.Textbox(value="Image", visible=False), gr.Textbox(value="Extract and translate text", visible=False)], outputs=image_output)
            image_summarize_btn.click(process_input, inputs=[image_input, gr.Textbox(value="Image", visible=False), gr.Textbox(value="Summarize this image", visible=False)], outputs=image_output)
            image_clear_btn.click(lambda: (None, "", ""), outputs=[image_input, language_input_image, image_output])
        with gr.Tab("Audio-Based Learning"):
            audio_input = gr.Audio(type="filepath", label="Upload Audio")
            language_input_audio = gr.Textbox(label="Target Language for Translation", value="English")
            transcript_output = gr.Textbox(label="Transcribed Text")
            translated_output = gr.Textbox(label="Translated Text")
            audio_clear_btn = gr.Button("Clear")
            audio_transcribe_btn = gr.Button("Transcribe & Translate")
            audio_transcribe_btn.click(process_input, inputs=[audio_input, gr.Textbox(value="Audio", visible=False), gr.Textbox(value="Transcribe this audio", visible=False)], outputs=transcript_output)
            audio_transcribe_btn.click(process_input, inputs=[audio_input, gr.Textbox(value="Audio", visible=False), language_input_audio], outputs=translated_output)
            audio_clear_btn.click(lambda: (None, "", "", ""), outputs=[audio_input, language_input_audio, transcript_output, translated_output])        
        demo.launch(debug=True)

if __name__ == "__main__":
    gradio_interface()संचालित द्वारा

उपरोक्त कोड Gradio इंटरफ़ेस को तीन इंटरेक्टिव टैब्स में व्यवस्थित करता है—टेक्स्ट-आधारित सीखना, इमेज-आधारित सीखना और ऑडियो-आधारित सीखना—जो प्रत्येक अलग-अलग भाषा सीखने की फंक्शनैलिटी के लिए डिज़ाइन किए गए हैं।

उपयोगकर्ता अनुवाद या व्याकरण सुधार के लिए टेक्स्ट दर्ज कर सकते हैं, टेक्स्ट एक्सट्रैक्शन और सारांशण के लिए इमेज अपलोड कर सकते हैं, या भाषण ट्रांसक्रिप्शन और अनुवाद के लिए ऑडियो प्रदान कर सकते हैं। 

प्रत्येक फ़ंक्शन Gradio की click() मेथड के माध्यम से ट्रिगर होता है, जो ऊपर वर्णित process_text_translate(), process_text_grammar(), और process_input() जैसे प्रोसेसिंग फ़ंक्शंस को आवश्यक इनपुट पास करते हुए कॉल करता है और आउटपुट को डायनेमिक रूप से अपडेट करता है।

Clear बटन प्रत्येक टैब में शामिल है ताकि इनपुट और आउटपुट रीसेट किए जा सकें, जिससे उपयोगकर्ता अनुभव सुगम रहे। अंत में, इंटरफ़ेस demo.launch(debug=True) के साथ लॉन्च किया जाता है, जो डेवलपर्स को एप्लिकेशन में किसी भी त्रुटि को आसानी से डिबग करने देता है।

चरण 5: ऐप का परीक्षण

यहाँ इस एप्लिकेशन के साथ मेरे कुछ प्रयोग दिए गए हैं।

अनुवाद और व्याकरण जाँच

अनुवाद और व्याकरण जाँच कार्यों के लिए, मैंने "Hello world" टेक्स्ट दिया और मॉडल को इसे फ्रेंच में अनुवाद करने और उसके व्याकरण को सत्यापित करने का निर्देश दिया (अनुवाद और व्याकरण जाँच के लिए अलग-अलग बटनों पर ध्यान दें)।

इमेज में मौजूद टेक्स्ट का अनुवाद

इस उदाहरण में, मैंने स्पेनिश में एक स्टॉप साइन की इमेज प्रदान की जो पैदल यात्रियों को एक विशेष पथ पर न चलने का निर्देश देती है। मॉडल ने साइन के अर्थ की सटीक व्याख्या की और यह प्रतिक्रिया उत्पन्न की: "Do not walk on the track."

ऑडियो ट्रांसक्रिप्शन और अनुवाद

ऑडियो ट्रांसक्रिप्शन के लिए, मैंने इंग्लिश ऑडियो फ़ाइल प्रदान की और मॉडल को भाषण को ट्रांसक्राइब करने और ट्रांसक्रिप्शन को फ्रेंच में अनुवाद करने का निर्देश दिया।

निष्कर्ष

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