MediaPipe के साथ, Android पर डिवाइस पर इमेज जनरेट करना

1. परिचय

MediaPipe क्या है?

MediaPipe Solutions की मदद से अपने ऐप्लिकेशन में मशीन लर्निंग (एमएल) से जुड़े समाधान लागू किए जा सकते हैं. यह पहले से बनी प्रोसेसिंग पाइपलाइन को कॉन्फ़िगर करने का फ़्रेमवर्क उपलब्ध कराता है. इससे उपयोगकर्ताओं को तुरंत, दिलचस्प, और काम का आउटपुट मिलता है. डिफ़ॉल्ट मॉडल को अपडेट करने के लिए, MediaPipe Model Maker की मदद से, इनमें से कई समाधानों को अपनी पसंद के मुताबिक भी बनाया जा सकता है.

टेक्स्ट-टू-इमेज जनरेट करना, MediaPipe Solutions के दिए जाने वाले एमएल टास्क में से एक है.

MediaPipe Tasks, Android, iOS, Python (इसमें Raspberry Pi! के साथ-साथ) और वेब पर भी उपलब्ध है. फ़िलहाल, यह टास्क सिर्फ़ Android पर उपलब्ध है. यह सुझाव दिया जाता है कि आप टेस्ट करने के लिए, कम से कम 8 जीबी रैम वाले डिवाइस पर जांच करें.

इस कोडलैब में, शुरुआत में ऐसे Android ऐप्लिकेशन का इस्तेमाल किया जाता है जो ज़्यादा सुविधाओं का इस्तेमाल नहीं करता. इसके बाद, कई चरणों को पूरा करते जाएं, जब तक कि सीधे अपने Android डिवाइस पर नई इमेज जनरेट नहीं हो जातीं.

आप इन चीज़ों के बारे में जानेंगे

• MediaPipe Tasks वाले Android ऐप्लिकेशन में स्थानीय तौर पर चल रही टेक्स्ट-टू-इमेज जनरेट करने की प्रोसेस लागू करने का तरीका.

आपको इनकी ज़रूरत होगी

• Android Studio का इंस्टॉल किया गया वर्शन (इस कोडलैब को Android Studio जिराफ़ की मदद से लिखा गया था और इसकी जांच की गई थी).
• कम से कम 8 जीबी रैम वाला Android डिवाइस.
• Android के डेवलपमेंट की बुनियादी जानकारी और पहले से लिखी गई Python स्क्रिप्ट को चलाने की सुविधा.

2. Android ऐप्लिकेशन में MediaPipe Tasks जोड़ें

Android स्टार्टर ऐप्लिकेशन डाउनलोड करें

यह कोडलैब, पहले से तैयार एक सैंपल से शुरू होगा. इसमें यूज़र इंटरफ़ेस (यूआई) शामिल है. इसका इस्तेमाल, इमेज जनरेट करने के बुनियादी वर्शन के लिए किया जाएगा. आपको उस शुरुआती ऐप्लिकेशन को यहां आधिकारिक MediaPipe सैंपल रेपो में मिल जाएगा. कोड > पर क्लिक करके रेपो का क्लोन बनाएं या ज़िपफ़ाइल डाउनलोड करें ZIP डाउनलोड करें.

• संग्रह में ऐसे अन्य MediaPipe नमूने हैं जो इस कोडलैब से संबंधित नहीं हैं. इस कोडलैब का कोड, codelabs/image_generation_basic/android फ़ोल्डर में मौजूद है.
• हमने इस कोडलैब के लिए, एक बुनियादी यूज़र इंटरफ़ेस (यूआई) और बॉयलरप्लेट कोड लागू किया है. सोर्स कोड codelabs/image_generation_basic/android/start/ फ़ोल्डर में है.
• इस ट्यूटोरियल के नीचे दिए गए चरणों में, आप बाइनरी के सेट का इस्तेमाल करने के लिए कोड लिखेंगे.
• अगर आपको किसी भी चरण में आगे बढ़ने का तरीका नहीं पता है, तो codelabs/image_generation_basic/android/finish/ फ़ोल्डर में जाकर, पूरा किया गया ऐप्लिकेशन देखें.

ऐप्लिकेशन को Android Studio में इंपोर्ट करें

1. Android Studio खोलें.
2. Android Studio में आपका स्वागत है स्क्रीन पर, सबसे ऊपर दाएं कोने में मौजूद खोलें को चुनें.

3. उस जगह पर जाएं जहां आपने डेटा स्टोर करने की जगह को क्लोन किया है या डाउनलोड किया है. इसके बाद, codelabs/image_ Generation_basic/android/start डायरेक्ट्री खोलें.
4. इस चरण में, ऐप्लिकेशन को कंपाइल नहीं करना चाहिए, क्योंकि आपने अभी तक MediaPipe Tasks डिपेंडेंसी को शामिल नहीं किया है.

आपको build.gradle फ़ाइल में जाकर और नीचे की ओर स्क्रोल करके, ऐप्लिकेशन को ठीक करना होगा और फिर उसे चलाना होगा. इसके बाद, नीचे की ओर स्क्रोल करके // चरण 1 - डिपेंडेंसी जोड़ें पर जाएं. यहां दी गई लाइन शामिल करें. इसके बाद, Android Studio में सबसे ऊपर मौजूद बैनर में, अभी सिंक करें बटन पर क्लिक करें.

// Step 1 - Add dependency
implementation 'com.google.mediapipe:tasks-vision-image-generator:latest.release'

सिंक की प्रोसेस पूरी हो जाने के बाद, Android Studio में सबसे ऊपर दाईं ओर मौजूद हरे रंग के चलाएं ऐरो ( ) पर क्लिक करके पुष्टि करें कि सब कुछ ठीक से खुला और इंस्टॉल हो गया है. आपको स्क्रीन पर ऐप्लिकेशन खुला हुआ दिखेगा. इसमें दो रेडियो बटन और एक बटन होगा जिस पर शुरू करें लेबल होगा. इस बटन पर क्लिक करने पर, आपको तुरंत एक अलग यूज़र इंटरफ़ेस (यूआई) पर ले जाया जाएगा. इसमें टेक्स्ट प्रॉम्प्ट और जनरेट करें लेबल वाले बटन के बगल में अन्य विकल्प होंगे.

माफ़ करें, यह स्टार्टर ऐप्लिकेशन की सीमा के बारे में है. इसलिए, अब समय आ गया है कि आप इस ऐप्लिकेशन को पूरा करने का तरीका जानें और अपने डिवाइस पर नई इमेज जनरेट करना शुरू करें!

3. इमेज जनरेटर सेट अप करना

इस उदाहरण के लिए, इमेज जनरेट करने का ज़्यादातर काम ImageGenerationHelper.kt फ़ाइल में होगा. इस फ़ाइल को खोलने पर, आपको क्लास में सबसे ऊपर एक वैरिएबल दिखेगा. इस वैरिएबल को ImageGenerator कहा जाता है. यह वह Task ऑब्जेक्ट है जिसकी मदद से इमेज जनरेट करने वाले ऐप्लिकेशन में काफ़ी काम किया जा सकता है.

उस ऑब्जेक्ट के ठीक नीचे, आपको इन चीज़ों के साथ beforeizeImageGenerator() नाम का एक फ़ंक्शन दिखेगा: // चरण 2 - इमेज जनरेटर शुरू करें. जैसा कि आपको लग सकता है, यहां पर ImageGenerator ऑब्जेक्ट को शुरू किया जाएगा. इमेज जनरेट करने वाले मॉडल का पाथ सेट करने और ImageGenerator ऑब्जेक्ट को शुरू करने के लिए, उस फ़ंक्शन के मुख्य हिस्से को नीचे दिए गए कोड से बदलें:

// Step 2 - initialize the image generator
val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

imageGenerator = ImageGenerator.createFromOptions(context, options)

इसके नीचे, आपको setइनपुट() नाम का एक और फ़ंक्शन दिखेगा. इसमें तीन पैरामीटर स्वीकार किए जाते हैं: जनरेट की गई इमेज के बारे में बताने के लिए प्रॉम्प्ट स्ट्रिंग, नई इमेज जनरेट करने के दौरान टास्क को कितने इटरेशन पूरे करने होंगे, और एक सीड वैल्यू, जिसका इस्तेमाल उसी प्रॉम्प्ट पर आधारित इमेज के नए वर्शन बनाने के लिए किया जा सकता है. साथ ही, एक ही सीड का इस्तेमाल करने पर एक ही इमेज जनरेट होती है. इस फ़ंक्शन का मकसद इमेज जनरेट करने वाले टूल के लिए ये शुरुआती पैरामीटर सेट करना है. ऐसा तब किया जाता है, जब ऐसी इमेज बनाने की कोशिश की जाती है जिसमें बीच के चरण दिखाए जाते हों.

आगे बढ़ें और setइनपुट() बॉडी (जहां आपको टिप्पणी दिखाई देगी // चरण 3 - इनपुट स्वीकार करें) को इस लाइन से बदलें:

// Step 3 - accept inputs
imageGenerator.setInputs(prompt, iteration, seed)

अगले दो चरण में, कॉन्टेंट जनरेट होता है. generate() फ़ंक्शन, setइनपुट के जैसे इनपुट स्वीकार करता है. हालांकि, यह वन-शॉट कॉल के तौर पर एक इमेज बनाता है, जो इंटरमीडिएट चरण वाली इमेज नहीं दिखाता. इस फ़ंक्शन के मुख्य हिस्से (जिसमें टिप्पणी // चरण 4 - बार-बार दिखाए बिना जनरेट करना शामिल है) को इस तरह से बदला जा सकता है:

// Step 4 - generate without showing iterations
val result = imageGenerator.generate(prompt, iteration, seed)
val bitmap = BitmapExtractor.extract(result?.generatedImage())
return bitmap

यह जानना ज़रूरी है कि यह टास्क सिंक्रोनस रूप से होता है. इसलिए, आपको बैकग्राउंड थ्रेड से फ़ंक्शन को कॉल करना होगा. इस कोडलैब में, आपको इस बारे में थोड़ी देर बाद जानकारी मिलेगी.

इस फ़ाइल में आपको आखिरी चरण एक्ज़ीक्यूट() फ़ंक्शन भरना होगा (इसे पांचवे चरण के तौर पर लेबल किया गया है). इससे एक पैरामीटर स्वीकार किया जाएगा, जो यह बताता है कि उसे जनरेशन के एक चरण के लिए इंटरमीडिएट इमेज दिखानी है या नहीं. ImageGenerator insert() फ़ंक्शन की मदद से ऐसा किया जाएगा या नहीं. फ़ंक्शन के मुख्य हिस्से को इस कोड से बदलें:

// Step 5 - generate with iterations
val result = imageGenerator.execute(showResult)

if (result == null || result.generatedImage() == null) {
    return Bitmap.createBitmap(512, 512, Bitmap.Config.ARGB_8888)
        .apply {
            val canvas = Canvas(this)
            val paint = Paint()
            paint.color = Color.WHITE
            canvas.drawPaint(paint)
        }
}

val bitmap =
    BitmapExtractor.extract(result.generatedImage())

return bitmap

हेल्पर फ़ाइल में बस इतना ही. अगले सेक्शन में, आपको ViewModel फ़ाइल की जानकारी मिलेगी, जो इस उदाहरण के लिए लॉजिक को हैंडल करती है.

4. ऐप्लिकेशन को एक ही जगह पर लाना

MainViewModel फ़ाइल, इस उदाहरण ऐप्लिकेशन से जुड़े यूज़र इंटरफ़ेस (यूआई) की स्थितियों और अन्य लॉजिक को हैंडल करेगी. आगे बढ़ें और इसे अभी खोलें.

फ़ाइल के सबसे ऊपर आपको टिप्पणी // चरण 6 - मॉडल पाथ सेट करना दिखेगा. यहां आपको अपने ऐप्लिकेशन को बताया जाएगा कि वह इमेज जनरेट करने के लिए ज़रूरी मॉडल फ़ाइलें कहां ढूंढ सकता है. इस उदाहरण के लिए, वैल्यू को /data/local/tmp/image_generator/bins/ पर सेट किया जाएगा.

// Step 6 - set model path
private val MODEL_PATH = "/data/local/tmp/image_generator/bins/"

इसके बाद, नीचे की ओर स्क्रोल करके, generateImage() फ़ंक्शन पर जाएं. इस फ़ंक्शन के सबसे नीचे, आपको सातवां और आठवां चरण, दोनों दिखेंगे. इनका इस्तेमाल ऐसी इमेज जनरेट करने के लिए किया जाएगा जिनके लिए, बार-बार दोहराया गया हो या कोई भी न हो. ये दोनों कार्रवाइयां सिंक्रोनस होती हैं, इसलिए ये एक कोरोटिन में रैप हो जाती हैं. शुरुआत करने के लिए, ImageGenerationHelper फ़ाइल से generate() को कॉल करने के लिए, // चरण 7 - जनरेट करें को इस ब्लॉक के साथ बार-बार न दिखाया जा सके. इसके बाद, यूज़र इंटरफ़ेस (यूआई) की स्थिति को अपडेट करें.

// Step 7 - Generate without showing iterations
val result = helper?.generate(prompt, iteration, seed)
_uiState.update {
    it.copy(outputBitmap = result)
}

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

// Step 8 - Generate with showing iterations
helper?.setInput(prompt, iteration, seed)
for (step in 0 until iteration) {
    isDisplayStep =
        (displayIteration > 0 && ((step + 1) % displayIteration == 0))
    val result = helper?.execute(isDisplayStep)

    if (isDisplayStep) {
        _uiState.update {
            it.copy(
                outputBitmap = result,
                generatingMessage = "Generating... (${step + 1}/$iteration)",
            )
        }
    }
}

इस स्थिति में, आपको अपना ऐप्लिकेशन इंस्टॉल करना चाहिए. साथ ही, इमेज जनरेटर को शुरू करने और टेक्स्ट प्रॉम्प्ट के आधार पर नई इमेज बनाने का विकल्प भी होना चाहिए

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

फ़ाइलों को सीधे अपने डेवलपमेंट डिवाइस पर कॉपी करने के साथ-साथ, Firebase स्टोरेज सेट अप किया जा सकता है, ताकि रन टाइम के दौरान उपयोगकर्ता के डिवाइस पर ज़रूरी फ़ाइलें सीधे डाउनलोड की जा सकें.

5. ऐप्लिकेशन को डिप्लॉय और टेस्ट करें

इन सभी चीज़ों के बाद, आपके पास एक ऐसा ऐप्लिकेशन होना चाहिए जो काम कर रहा हो, जो टेक्स्ट प्रॉम्प्ट को स्वीकार करके, उपयोगकर्ता के डिवाइस पर ही नई इमेज जनरेट कर सके! ऐप्लिकेशन को टेस्ट करने के लिए, किसी Android डिवाइस पर डिप्लॉय करें. हालांकि, याद रखें कि आपको इसे कम से कम 8 जीबी मेमोरी वाले डिवाइस पर आज़माना चाहिए.

1. ऐप्लिकेशन चलाने के लिए, Android Studio के टूलबार में, चलाएं ( ) पर क्लिक करें.
2. जनरेशन चरणों का टाइप चुनें (आखिरी या बार-बार दोहराना) और फिर शुरू करें बटन दबाएं.
3. अगली स्क्रीन पर, अपनी पसंद की प्रॉपर्टी सेट करें और जनरेट करें बटन पर क्लिक करके देखें कि टूल क्या करता है.

6. बधाई हो!

आपने कर दिखाया! इस कोडलैब में, आपने किसी Android ऐप्लिकेशन में, उपयोगकर्ता के डिवाइस पर मौजूद टेक्स्ट-टू-इमेज जनरेट करने की सुविधा जोड़ने का तरीका सीखा है.

अगले चरण

इमेज जनरेट करने के टास्क में और भी बहुत कुछ किया जा सकता है. इसमें ये शामिल हैं

• बेस इमेज का इस्तेमाल करके, प्लगिन की मदद से जनरेट की गई इमेज को स्ट्रक्चर करें या Vertex AI की मदद से, अपने अतिरिक्त LoRA वज़न को ट्रेनिंग दें.
• अपने डिवाइस पर मॉडल फ़ाइलें पाने के लिए, Firebase स्टोरेज का इस्तेमाल करें. इसके लिए, ADB टूल का इस्तेमाल करने की ज़रूरत नहीं है.

हमें एक्सपेरिमेंट के तौर पर शुरू किए गए इस टास्क से, आपकी बनाई शानदार सुविधाओं का इंतज़ार रहेगा. साथ ही, हम MediaPipe की टीम से मिले और भी कोडलैब के साथ-साथ अन्य कॉन्टेंट पर भी नज़र बनाए रखेंगे!