מדריך ליצירת תמונות ל-Android

המשימה 'מחולל תמונות של MediaPipe' מאפשרת לכם ליצור תמונות על סמך הנחיה בטקסט. הזה משתמשת במודל של טקסט לתמונה כדי ליצור תמונות בשיטות דיפוזיה.

המשימה תקבל הנחיית טקסט כקלט, יחד עם תמונת מצב אופציונלית שהמודל יכול להרחיב ולהשתמש בהם כחומר עזר ליצירה. מחולל תמונות יכול גם ליצור תמונות לפי קונספטים ספציפיים שסופקו למודל או אימון מחדש. מידע נוסף זמין במאמר התאמה אישית באמצעות LoRA.

דוגמת הקוד שמתוארת בהוראות אלה זמינה במכשירים הבאים: GitHub. מידע נוסף על היכולות, המודלים ואפשרויות ההגדרה במשימה הזאת, ראו סקירה כללית.

קוד לדוגמה

קוד הדוגמה למשימות MediaPipe הוא הטמעה בסיסית של 'מחולל תמונות' לאפליקציה ל-Android. אפשר להשתמש באפליקציה כנקודת התחלה למכשירי Android או להתייחס אליה כשמשנים אפליקציה קיימת. דוגמה לכלי ליצירת תמונות הקוד מתארח GitHub.

להורדת הקוד

בהוראות הבאות מוסבר איך ליצור עותק מקומי של הדוגמה באמצעות כלי שורת הפקודה git.

כדי להוריד את הקוד לדוגמה:

1. משכפלים את מאגר ה-Git באמצעות הפקודה הבאה:

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

2. לחלופין, להגדיר את מכונת ה-Git שלך לשימוש בקופה עם היעדר תשלום, כדי רק את הקבצים עבור האפליקציה לדוגמה של 'מחולל תמונות':

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

אחרי שיוצרים גרסה מקומית של הקוד לדוגמה, אפשר לייבא את הפרויקט אל Android Studio ולהריץ את האפליקציה. לקבלת הוראות, אפשר לעיין במדריך ההגדרה עבור ב-Android.

רכיבים מרכזיים

הקבצים הבאים מכילים את הקוד החשוב של הדוגמה הזו ליצירת תמונה יישום:

• ImageGenerationHelper.kt: הפעלת המשימה וטיפול ביצירת התמונה.
• DiffusionActivity.kt: יוצר תמונות כשיישומי פלאגין או משקולות LoRA אינם מופעלים.
• PluginActivity.kt: הטמעת מודלים של יישומי פלאגין, שמאפשרים למשתמשים לספק תנאי את התמונה בתור קלט.
• LoRAWeightActivity.kt: גישה למשקולות LoRA והטיפול בהן, שמשמשות להתאמה אישית של היסודות מודלים גדולים של שפה ולאפשר להם ליצור תמונות של מושגים ספציפיים.

הגדרה

בקטע הזה מתוארים השלבים העיקריים להגדרת סביבת הפיתוח פרויקטים של קוד במיוחד לשימוש ב'מחולל תמונות'. למידע כללי על להגדיר את סביבת הפיתוח לשימוש במשימות של MediaPipe, כולל הדרישות לגרסאות הפלטפורמה זמינות במדריך ההגדרה עבור ב-Android.

יחסי תלות

במשימה 'יצירת תמונות' נעשה שימוש הספרייה com.google.mediapipe:tasks-vision-image-generator. הוספת התלות הזאת אל הקובץ build.gradle של האפליקציה ל-Android:

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

במכשירים עם Android מגרסה 12 (API 31) ואילך, צריך להוסיף את ספריית OpenCL המקורית התלויות ב-AndroidManifest.xml. למידע נוסף, עיינו במשאבי העזרה בנושא uses-native-library התיוג.

ייתכן שיהיה צורך בספריות נוספות במכשירי Android מסוימים:

<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' נדרש מודל בסיס מאומן ותואם במשימה הזו. לאחר הורדת מודל, מתקינים את יחסי התלות הנדרשים להמיר את המודל לפורמט מתאים. לאחר מכן, דוחפים את למכשיר Android.

לקבלת מידע נוסף על מודלים זמינים מאומנים של 'יוצר התמונות', אפשר לעיין במשימה סקירה כללית בקטע 'מודלים'.

הורדת מודל בסיס

'מחולל התמונות' דורש שמודל הבסיס יתאים פורמט המודל runwayml/stable-diffusion-v1-5 EMA-only, על סמך הקריטריונים הבאים :model runwayml/stable-diffusion-v1-5.

התקנת יחסי תלות והמרה של המודל

$ 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 או להוריד אותם על פי דרישה. מודלים של יישומי פלאגין הם קלים (כ-23MB) וניתן לחלק אותם ישירות ב-APK. אבל אנחנו מומלץ להוריד מודלים של יישומי פלאגין לפי דרישה.

אם התאמתם אישית מודל LoRA, להוריד אותם לפי דרישה. לקבלת מידע נוסף מידע נוסף, ראו מודל פלאגין של משקלי LoRA.

יצירת המשימה

המשימה 'מחולל תמונות של MediaPipe' משתמשת בפונקציה createFromOptions() כדי להגדיר למשימה הזו. הפונקציה createFromOptions() מקבלת ערכים להגדרה אפשרויות. למידע נוסף על אפשרויות ההגדרה, ראו הגדרות אישיות הפרמטר הזה.

אפשרויות תצורה

המשימה הזו כוללת את אפשרויות ההגדרה הבאות לאפליקציות ל-Android:

המשימה תומכת גם במודלים של יישומי פלאגין, שמאפשרים למשתמשים לכלול תמונות של תנאים בקלט המשימה, שבו מודל הבסיס יכול להרחיב ולהשתמש ליצירת שפה, תמונות המצב האלה יכולות להיות ציוני דרך של פנים, קווי מתאר של קצוות הערכות עומק, שבהן המודל משתמש כהקשר נוסף וכמידע נוסף כדי היא יצירת תמונות.

כשמוסיפים מודל פלאגין למודל הבסיס, צריך גם להגדיר את הפלאגין אפשרויות. בפלאגין של מאפיין זיהוי הפנים נעשה שימוש ב-faceConditionOptions, הקצה של Canny הפלאגין משתמש ב-edgeConditionOptions, ופלאגין העומק משתמש depthConditionOptions.

אפשרויות קצה Canny

צריך להגדיר את האפשרויות הבאות ב-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)

הכנת נתונים

מחולל התמונות מקבל את פרטי הקלט הבאים:

• הנחיה (חובה): הנחיית הטקסט שמתארת את התמונה שתיווצר.
• איטרציות (חובה): סך כל האיטרציות ליצירת התמונה. א' נקודת התחלה טובה היא 20.
• seed (חובה): המקור האקראי שבו נעשה שימוש במהלך יצירת התמונה.
• תמונת מצב (אופציונלי): התמונה שמשמשת כחומר עזר של המודל ליצירת תמונות, רלוונטי רק כשמשתמשים במודל פלאגין.
• condition type (סוג התנאי) (אופציונלי): סוג המודל של הפלאגין שבו נעשה שימוש במשימה. רלוונטי רק כשמשתמשים במודל פלאגין.

קלט שכולל רק את מודל הבסיס

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

התמונה שנוצרה: