Android के लिए इमेज जनरेट करने की गाइड

MediaPipe Image Generator टास्क की मदद से, टेक्स्ट प्रॉम्प्ट के आधार पर इमेज जनरेट की जा सकती हैं. इस टास्क में, टेक्स्ट-टू-इमेज मॉडल का इस्तेमाल किया जाता है. इससे डिफ़्यूज़न तकनीकों का इस्तेमाल करके इमेज जनरेट की जाती हैं.

इस टास्क में, टेक्स्ट प्रॉम्प्ट को इनपुट के तौर पर स्वीकार किया जाता है. साथ ही, इसमें एक ऐसी इमेज भी शामिल की जा सकती है जो मॉडल को जनरेट करने के लिए रेफ़रंस के तौर पर इस्तेमाल करनी होती है. इमेज जनरेटर, ट्रेनिंग या फिर से ट्रेनिंग के दौरान मॉडल को दिए गए खास कॉन्सेप्ट के आधार पर भी इमेज जनरेट कर सकता है. ज़्यादा जानकारी के लिए, LoRA की मदद से पसंद के मुताबिक बनाना लेख पढ़ें.

इन निर्देशों में बताया गया कोड सैंपल, GitHub पर उपलब्ध है. इस टास्क की क्षमताओं, मॉडल, और कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानने के लिए, खास जानकारी देखें.

कोड का उदाहरण

MediaPipe Tasks के उदाहरण कोड में, Android के लिए इमेज जनरेट करने वाले ऐप्लिकेशन को बुनियादी तौर पर लागू किया गया है. इस ऐप्लिकेशन का इस्तेमाल, अपने Android ऐप्लिकेशन को बनाने के लिए किया जा सकता है. इसके अलावा, मौजूदा ऐप्लिकेशन में बदलाव करते समय भी इसका इस्तेमाल किया जा सकता है. इमेज जनरेट करने वाले ऐप्लिकेशन का उदाहरण कोड, GitHub पर होस्ट किया गया है.

कोड डाउनलोड करना

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

उदाहरण के तौर पर दिए गए कोड को डाउनलोड करने के लिए:

1. नीचे दिए गए कमांड का इस्तेमाल करके, git रिपॉज़िटरी को क्लोन करें:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. अगर आपको सिर्फ़ Image Generator के उदाहरण ऐप्लिकेशन की फ़ाइलें चाहिए, तो अपने git इंस्टेंस को स्पार्स चेकआउट का इस्तेमाल करने के लिए कॉन्फ़िगर करें:

   cd mediapipe-samples
   git sparse-checkout init --cone
   git sparse-checkout set examples/image_generation/android
   

उदाहरण के तौर पर दिए गए कोड का लोकल वर्शन बनाने के बाद, प्रोजेक्ट को Android Studio में इंपोर्ट किया जा सकता है. इसके बाद, ऐप्लिकेशन को चलाया जा सकता है. निर्देशों के लिए, Android के लिए सेटअप गाइड देखें.

मुख्य कॉम्पोनेंट

नीचे दी गई फ़ाइलों में, इमेज जनरेट करने के इस उदाहरण वाले ऐप्लिकेशन का ज़रूरी कोड शामिल है:

• ImageGenerationHelper.kt: यह टास्क को शुरू करता है और इमेज जनरेट करने की प्रोसेस को मैनेज करता है.
• DiffusionActivity.kt: जब प्लगिन या LoRA वेट चालू नहीं होते हैं, तब इमेज जनरेट करता है.
• PluginActivity.kt: यह प्लगिन मॉडल लागू करता है. इससे उपयोगकर्ता, इनपुट के तौर पर किसी शर्त की इमेज दे पाते हैं.
• LoRAWeightActivity.kt: यह LoRA वेट को ऐक्सेस और मैनेज करता है. इनका इस्तेमाल फ़ाउंडेशन मॉडल को पसंद के मुताबिक बनाने के लिए किया जाता है. साथ ही, इनकी मदद से खास कॉन्सेप्ट की इमेज जनरेट की जा सकती हैं.

सेटअप

इस सेक्शन में, इमेज जनरेटर का इस्तेमाल करने के लिए, डेवलपमेंट एनवायरमेंट और कोड प्रोजेक्ट सेट अप करने के मुख्य चरणों के बारे में बताया गया है. MediaPipe Tasks का इस्तेमाल करने के लिए, डेवलपमेंट एनवायरमेंट सेट अप करने के बारे में सामान्य जानकारी पाने के लिए, Android के लिए सेटअप गाइड देखें. इसमें प्लैटफ़ॉर्म के वर्शन से जुड़ी ज़रूरी शर्तों के बारे में भी बताया गया है.

डिपेंडेंसी

इमेज जनरेट करने वाले टास्क में com.google.mediapipe:tasks-vision-image-generator लाइब्रेरी का इस्तेमाल किया जाता है. अपने Android ऐप्लिकेशन की build.gradle फ़ाइल में, यह डिपेंडेंसी जोड़ें:

dependencies {
    implementation 'com.google.mediapipe:tasks-vision-image-generator:latest.release'
}

Android 12 (एपीआई 31) या इसके बाद के वर्शन वाले डिवाइसों के लिए, नेटिव OpenCL लाइब्रेरी की डिपेंडेंसी जोड़ें. ज़्यादा जानकारी के लिए, uses-native-library टैग से जुड़ा दस्तावेज़ देखें.

AndroidManifest.xml फ़ाइल में ये uses-native-library टैग जोड़ें:

<uses-native-library android:name="libOpenCL.so" android:required="false" />
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false" />

मॉडल

MediaPipe Image Generator टास्क के लिए, ट्रेनिंग पा चुका ऐसा फ़ाउंडेशन मॉडल ज़रूरी है जो इस टास्क के साथ काम करता हो. मॉडल डाउनलोड करने के बाद, ज़रूरी डिपेंडेंसी इंस्टॉल करें और मॉडल को सही फ़ॉर्मैट में बदलें. इसके बाद, बदले गए मॉडल को Android डिवाइस पर पुश करें.

इमेज जनरेटर के लिए उपलब्ध ट्रेन किए गए मॉडल के बारे में ज़्यादा जानने के लिए, टास्क की खास जानकारी वाला मॉडल सेक्शन देखें.

बुनियादी मॉडल डाउनलोड करना

इमेज जनरेटर के लिए, यह ज़रूरी है कि फ़ाउंडेशन मॉडल, stable-diffusion-v1-5/stable-diffusion-v1-5 EMA-only मॉडल फ़ॉर्मैट से मेल खाता हो. यह मॉडल, इस मॉडल पर आधारित है: stable-diffusion-v1-5/stable-diffusion-v1-5 EMA-only.

डिपेंडेंसी इंस्टॉल करना और मॉडल को बदलना

$ pip install torch typing_extensions numpy Pillow requests pytorch_lightning absl-py

convert.py स्क्रिप्ट चलाएं:

$ python3 convert.py --ckpt_path <ckpt_path> --output_path <output_path>

बदले गए मॉडल को डिवाइस पर पुश करें

<output_path> फ़ोल्डर के कॉन्टेंट को Android डिवाइस पर पुश करें.

$ adb shell rm -r /data/local/tmp/image_generator/ # Remove any previously loaded weights
$ adb shell mkdir -p /data/local/tmp/image_generator/
$ adb push <output_path>/. /data/local/tmp/image_generator/bins

प्लगिन मॉडल डाउनलोड करें और LoRA वेट जोड़ें (ज़रूरी नहीं)

अगर आपको प्लगिन मॉडल का इस्तेमाल करना है, तो देखें कि मॉडल को डाउनलोड करना ज़रूरी है या नहीं. जिन प्लगिन के लिए किसी अन्य मॉडल की ज़रूरत होती है उनके लिए, प्लगिन मॉडल को APK में बंडल किया जाना चाहिए या मांग पर डाउनलोड किया जाना चाहिए. प्लगिन मॉडल हल्के होते हैं (~23 एमबी) और इन्हें सीधे APK में बंडल किया जा सकता है. हालांकि, हमारा सुझाव है कि आप प्लगिन मॉडल को ज़रूरत के हिसाब से डाउनलोड करें.

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

टास्क बनाना

MediaPipe Image Generator टास्क, टास्क को सेट अप करने के लिए createFromOptions() फ़ंक्शन का इस्तेमाल करता है. createFromOptions() फ़ंक्शन, कॉन्फ़िगरेशन के विकल्पों के लिए वैल्यू स्वीकार करता है. कॉन्फ़िगरेशन के विकल्पों के बारे में ज़्यादा जानने के लिए, कॉन्फ़िगरेशन के विकल्प देखें.

कॉन्फ़िगरेशन विकल्प

इस टास्क में, Android ऐप्लिकेशन के लिए कॉन्फ़िगरेशन के ये विकल्प होते हैं:

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

फ़ाउंडेशन मॉडल में प्लगिन मॉडल जोड़ते समय, प्लगिन के विकल्प भी कॉन्फ़िगर करें. फ़ेस लैंडमार्क प्लगिन faceConditionOptions का इस्तेमाल करता है, कैन्यी एज प्लगिन edgeConditionOptions का इस्तेमाल करता है, और डेप्थ प्लगिन depthConditionOptions का इस्तेमाल करता है.

कैन्यी एज के विकल्प

edgeConditionOptions में जाकर, ये विकल्प कॉन्फ़िगर करें.

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

चेहरे की पहचान करने वाले पॉइंट के विकल्प

faceConditionOptions में जाकर, ये विकल्प कॉन्फ़िगर करें.

इन कॉन्फ़िगरेशन विकल्पों के काम करने के तरीके के बारे में ज़्यादा जानने के लिए, चेहरे की पहचान करने से जुड़ा टास्क देखें.

डेप्थ के विकल्प

depthConditionOptions में जाकर, ये विकल्प कॉन्फ़िगर करें.

सिर्फ़ फ़ाउंडेशन मॉडल का इस्तेमाल करके जनरेट करना

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

imageGenerator = ImageGenerator.createFromOptions(context, options)

प्लगिन की मदद से कॉन्टेंट बनाना

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

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

val faceModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("face_landmarker.task")
    .build()

val facePluginModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("face_landmark_plugin.tflite")
    .build()

val faceConditionOptions = FaceConditionOptions.builder()
    .setFaceModelBaseOptions(faceModelBaseOptions)
    .setPluginModelBaseOptions(facePluginModelBaseOptions)
    .setMinFaceDetectionConfidence(0.3f)
    .setMinFacePresenceConfidence(0.3f)
    .build()

val conditionOptions = ConditionOptions.builder()
    .setFaceConditionOptions(faceConditionOptions)
    .build()

imageGenerator =
    ImageGenerator.createFromOptions(context, options, conditionOptions)
    

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

val edgePluginModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("canny_edge_plugin.tflite")
    .build()

val edgeConditionOptions = EdgeConditionOptions.builder()
    .setThreshold1(100.0f)
    .setThreshold2(100.0f)
    .setApertureSize(3)
    .setL2Gradient(false)
    .setPluginModelBaseOptions(edgePluginModelBaseOptions)
    .build()

val conditionOptions = ConditionOptions.builder()
    .setEdgeConditionOptions(edgeConditionOptions)
    .build()

imageGenerator =
    ImageGenerator.createFromOptions(context, options, conditionOptions)
    

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

val depthModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("depth_model.tflite")
    .build()

val depthPluginModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("depth_plugin.tflite")
    .build()

val depthConditionOptions =
    ConditionOptions.DepthConditionOptions.builder()
        .setDepthModelBaseOptions(depthModelBaseOptions)
        .setPluginModelBaseOptions(depthPluginModelBaseOptions)
        .build()

val conditionOptions = ConditionOptions.builder()
    .setDepthConditionOptions(depthConditionOptions)
    .build()

imageGenerator =
    ImageGenerator.createFromOptions(context, options, conditionOptions)
    

LoRA वेट का इस्तेमाल करके इमेज जनरेट करना

अगर आपको LoRA वेट शामिल करने हैं, तो पाथ की जगह की ओर इशारा करने के लिए loraWeightsFilePath पैरामीटर का इस्तेमाल करें.

val options = ImageGeneratorOptions.builder()
    .setLoraWeightsFilePath(weightsPath)
    .setImageGeneratorModelDirectory(modelPath)
    .build()

imageGenerator = ImageGenerator.createFromOptions(context, options)

डेटा तैयार करना

इमेज जनरेटर में ये इनपुट दिए जा सकते हैं:

• prompt (ज़रूरी है): यह टेक्स्ट प्रॉम्प्ट, जनरेट की जाने वाली इमेज के बारे में बताता है.
• iterations (ज़रूरी है): इमेज जनरेट करने के लिए कुल इटरेशन. शुरुआत के लिए 20 एक अच्छा विकल्प है.
• seed (ज़रूरी है): इमेज जनरेट करने के दौरान इस्तेमाल किया गया रैंडम सीड.
• स्थिति की इमेज (वैकल्पिक): यह वह इमेज होती है जिसे मॉडल, जनरेट करने के लिए रेफ़रंस के तौर पर इस्तेमाल करता है. यह सिर्फ़ प्लगिन मॉडल का इस्तेमाल करते समय लागू होता है.
• शर्त का टाइप (ज़रूरी नहीं): टास्क के साथ इस्तेमाल किया गया प्लगिन मॉडल. यह सिर्फ़ प्लगिन मॉडल का इस्तेमाल करते समय लागू होता है.

सिर्फ़ फ़ाउंडेशन मॉडल के साथ इनपुट

fun setInput(prompt: String, iteration: Int, seed: Int) {
    imageGenerator.setInputs(prompt, iteration, seed)
}

प्लगिन के साथ इनपुट

अगर आपको कोई वैकल्पिक प्लगिन मॉडल लागू करना है, तो प्लगिन मॉडल चुनने के लिए conditionType पैरामीटर का इस्तेमाल करें. साथ ही, स्थिति के हिसाब से इमेज जनरेट करने के लिए sourceConditionImage पैरामीटर का इस्तेमाल करें.

अगर प्लगिन मॉडल का इस्तेमाल किया जा रहा है, तो createConditionImage का इस्तेमाल करके, स्थिति के हिसाब से इमेज बनाएं:

fun createConditionImage(
    inputImage: MPImage,
    conditionType: ConditionType
): Bitmap {
    val result =
        imageGenerator.createConditionImage(inputImage, conditionType)
    return BitmapExtractor.extract(result)
}

कंडीशन इमेज बनाने के बाद, इसे प्रॉम्प्ट, सीड, और इटरेशन की संख्या के साथ इनपुट के तौर पर शामिल करें.

imageGenerator.setInputs(
    prompt,
    conditionalImage,
    conditionType,
    iteration,
    seed
)

LoRA वेट वाले इनपुट

अगर LoRA वेट का इस्तेमाल किया जा रहा है, तो पक्का करें कि टोकन टेक्स्ट प्रॉम्प्ट में हो. ऐसा तब करें, जब आपको वेट से दिखाए गए कॉन्सेप्ट के हिसाब से इमेज जनरेट करनी हो.

fun setInput(prompt: String, iteration: Int, seed: Int) {
    imageGenerator.setInputs(prompt, iteration, seed)
}

टास्क को रन करना

पिछले सेक्शन में दिए गए इनपुट का इस्तेमाल करके इमेज जनरेट करने के लिए, generate() तरीके का इस्तेमाल करें. इससे जनरेट की गई एक इमेज मिलती है.

सिर्फ़ फ़ाउंडेशन मॉडल का इस्तेमाल करके जनरेट करना

fun generate(prompt: String, iteration: Int, seed: Int): Bitmap {
    val result = imageGenerator.generate(prompt, iteration, seed)
    val bitmap = BitmapExtractor.extract(result?.generatedImage())
    return bitmap
}

प्लगिन की मदद से जनरेट करना

fun generate(
    prompt: String,
    inputImage: MPImage,
    conditionType: ConditionType,
    iteration: Int,
    seed: Int
): Bitmap {
    val result = imageGenerator.generate(
        prompt,
        inputImage,
        conditionType,
        iteration,
        seed
    )
    val bitmap = BitmapExtractor.extract(result?.generatedImage())
    return bitmap
}

LoRA वेट की मदद से जनरेट करना

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

fun generate(prompt: String, iteration: Int, seed: Int): Bitmap {
    val result = imageGenerator.generate(prompt, iteration, seed)
    val bitmap = BitmapExtractor.extract(result?.generatedImage())
    return bitmap
}

बार-बार जनरेट करना

इमेज जनरेटर, हर इटरेशन के दौरान जनरेट की गई इंटरमीडिएट इमेज भी आउटपुट कर सकता है. ऐसा iterations इनपुट पैरामीटर में तय किए गए तरीके से किया जाता है. इन इंटरमीडिएट नतीजों को देखने के लिए, setInputs तरीके को कॉल करें. इसके बाद, हर चरण को चलाने के लिए execute() को कॉल करें. इंटरमीडिएट नतीजे दिखाने के लिए, showResult पैरामीटर को true पर सेट करें.

fun execute(showResult: Boolean): Bitmap {
    val result = imageGenerator.execute(showResult)

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

    return bitmap
}

नतीजों को मैनेज करना और दिखाना

इमेज जनरेटर, ImageGeneratorResult दिखाता है. इसमें जनरेट की गई इमेज, इमेज जनरेट होने का टाइमस्टैंप, और शर्त के हिसाब से इमेज शामिल होती है. हालांकि, शर्त के हिसाब से इमेज तब शामिल होती है, जब उसे इनपुट के तौर पर दिया गया हो.

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

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

इनपुट:

• प्रॉम्प्ट: "एक रंगीन कार्टून रैकून, जिसने चौड़ी किनारी वाली टोपी पहनी हो. वह जंगल में एक छड़ी पकड़े हुए चल रहा हो. ऐनिमेशन वाली इमेज, तीन-चौथाई व्यू, पेंटिंग"
• सीड: 312687592
• इटरेशन: 20

जनरेट की गई इमेज: