Leitfaden zum Generieren von Bildern für Android

Mit der Aufgabe „MediaPipe Image Generator“ können Sie Bilder basierend auf einem Text-Prompt generieren. Dieses wird ein Text-zu-Bild-Modell verwendet, um Bilder mithilfe von Diffusionstechniken zu generieren.

Die Aufgabe akzeptiert einen Text-Prompt und ein optionales Bedingungsbild als Eingabe die das Modell erweitern und als Referenz für die Generierung verwenden kann. Bildgenerator können auch Bilder basierend auf bestimmten Konzepten generieren, die dem Modell während oder Umschulungen. Weitere Informationen findest du unter Anpassen mit LoRA

Das in dieser Anleitung beschriebene Codebeispiel ist auf GitHub Weitere Informationen zu Funktionen, Modellen und Konfigurationsoptionen Sehen Sie sich die Übersicht an.

Codebeispiel

Der MediaPipe Tasks-Beispielcode ist eine einfache Implementierung eines Image Generators. für Android. Du kannst die App als Ausgangspunkt für dein eigenes Android-Gerät verwenden. oder beim Ändern einer vorhandenen App darauf zu verweisen. Beispiel für einen Image Generator gehostet wird auf GitHub

Code herunterladen

In der folgenden Anleitung erfahren Sie, wie Sie eine lokale Kopie des Beispiels erstellen. mit dem Befehlszeilentool git erstellen.

So laden Sie den Beispielcode herunter:

1. Klonen Sie das Git-Repository mit dem folgenden Befehl:

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

2. Konfigurieren Sie optional Ihre Git-Instanz für den Sparse-Checkout, damit Sie nur die Dateien für die Beispiel-App "Image Generator":

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

Nachdem Sie eine lokale Version des Beispielcodes erstellt haben, können Sie das Projekt importieren in Android Studio ein und führen die App aus. Anweisungen hierzu finden Sie im Einrichtungsleitfaden für Android-Geräte

Schlüsselkomponenten

Die folgenden Dateien enthalten den wichtigen Code für dieses Beispiel zur Bildgenerierung Anwendung:

• ImageGenerationHelper.kt: Initialisiert die Aufgabe und übernimmt die Bildgenerierung.
• DiffusionActivity.kt: Generiert Bilder, wenn Plug-ins oder LoRA-Gewichtungen nicht aktiviert sind.
• PluginActivity.kt Implementiert die Plug-in-Modelle, mit denen Nutzer eine Bedingung angeben können Bild als Eingabe verwenden.
• LoRAWeightActivity.kt: Greift auf LoRA-Gewichtungen zu und verarbeitet sie, die zur Anpassung der Grundlage verwendet werden und ermöglichen es ihnen, Bilder bestimmter Konzepte zu generieren.

Einrichtung

In diesem Abschnitt werden die wichtigsten Schritte zum Einrichten Ihrer Entwicklungsumgebung und Code-Projekte zur Verwendung des Image Generator. Allgemeine Informationen zu Einrichten Ihrer Entwicklungsumgebung für die Verwendung von MediaPipe-Aufgaben, einschließlich Anforderungen an die Plattformversion finden Sie im Einrichtungsleitfaden für Android-Geräte

Abhängigkeiten

Bei der Aufgabe "Image Generator" com.google.mediapipe:tasks-vision-image-generator-Bibliothek. Diese Abhängigkeit hinzufügen in die Datei build.gradle Ihrer Android-App ein:

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

Für Geräte mit Android 12 (API 31) oder höher die native OpenCL-Bibliothek hinzufügen Abhängigkeit von AndroidManifest.xml. Weitere Informationen finden Sie in der Dokumentation zum uses-native-library Tag.

Für einige Android-Geräte sind möglicherweise zusätzliche Bibliotheken erforderlich:

<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" />

Modell

Für die Aufgabe „MediaPipe Image Generator“ ist ein trainiertes Foundation Model erforderlich, bei dieser Aufgabe. Installieren Sie nach dem Herunterladen eines Modells die erforderlichen Abhängigkeiten und das Modell in ein geeignetes Format konvertieren. Übertragen Sie die konvertierte auf das Android-Gerät übertragen.

Weitere Informationen zu verfügbaren trainierten Modellen für den Image Generator finden Sie in der Task Übersicht über Modelle.

Foundation Model herunterladen

Für den Image Generator muss das Foundation Model Modellformat runwayml/stable-diffusion-v1-5 EMA-only, basierend auf dem folgenden Modell: runwayml/stable-diffusion-v1-5.

Abhängigkeiten installieren und Modell konvertieren

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

Führen Sie den convert.py Skript:

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

Konvertiertes Modell auf das Gerät übertragen

Übertragen Sie den Inhalt des Ordners <output_path> auf das Android-Gerät.

$ 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

Plug-in-Modelle herunterladen und LoRA-Gewichtungen hinzufügen (optional)

Wenn Sie ein Plug-in-Modell verwenden möchten, prüfen Sie, ob das Modell heruntergeladen werden. Bei Plug-ins, die ein zusätzliches Modell erfordern, müssen entweder im APK gebündelt sein oder bei Bedarf heruntergeladen werden. Plug-in-Modelle sind schlank (ca. 23 MB) und können direkt im APK gebündelt werden. Wir haben jedoch wird empfohlen, Plug-in-Modelle bei Bedarf herunterzuladen.

Wenn Sie ein Modell mit LoRA bei Bedarf herunterladen. Weitere Informationen Weitere Informationen finden Sie unter Plug-in-Modell für LoRA-Gewichtungen.

Aufgabe erstellen

Im Rahmen der Aufgabe „MediaPipe Image Generator“ wird mit der Funktion createFromOptions() für die Aufgabe. Die Funktion createFromOptions() akzeptiert Werte für die Konfiguration Optionen. Weitere Informationen zu Konfigurationsoptionen finden Sie unter Konfiguration Optionen.

Konfigurationsoptionen

Diese Aufgabe bietet die folgenden Konfigurationsoptionen für Android-Apps:

Die Aufgabe unterstützt auch Plug-in-Modelle, mit denen Nutzer Zustandsbilder hinzufügen können in der Aufgabeneingabe, die das Foundation Model erweitern und als Referenz verwenden kann für die Generation. Dabei kann es sich um Sehenswürdigkeiten, Umrisse oder Tiefenschätzungen, die das Modell als zusätzlichen Kontext und Informationen verwendet, Bilder generieren.

Beim Hinzufügen eines Plug-in-Modells zum Foundation Model auch das Plug-in konfigurieren Optionen. Das Plug-in für die Gesichtsmarkierung verwendet faceConditionOptions, den Canny Edge verwendet das Plug-in edgeConditionOptions, das Depth-Plug-in depthConditionOptions

Canny Edge-Optionen

Konfigurieren Sie die folgenden Optionen in edgeConditionOptions.

Weitere Informationen zur Funktionsweise dieser Konfigurationsoptionen finden Sie unter Canny Edge-Detektor

Optionen für Gesichts-Markierungen

Konfigurieren Sie die folgenden Optionen in faceConditionOptions.

Weitere Informationen zur Funktionsweise dieser Konfigurationsoptionen finden Sie in der Face Landmarker erstellen:

Tiefenoptionen

Konfigurieren Sie die folgenden Optionen in depthConditionOptions.

Nur mit dem Basismodell erstellen

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

imageGenerator = ImageGenerator.createFromOptions(context, options)

Mit Plug-ins erstellen

Wenn Sie ein optionales Plug-in-Modell anwenden, legen Sie die Basisoptionen für das Plug-in-Modell mit setPluginModelBaseOptions. Wenn für das Plug-in-Modell ein zusätzliches heruntergeladenes Modell zum Erstellen des Bedingungsbilds, geben Sie den Pfad in 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)
    

Mit LoRA-Gewichtungen erstellen

Wenn Sie LoRA-Gewichtungen einbeziehen, verwenden Sie den Parameter loraWeightsFilePath, um auf die Pfadposition zeigen.

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

imageGenerator = ImageGenerator.createFromOptions(context, options)

Daten vorbereiten

Der Image Generator akzeptiert die folgenden Eingaben:

• prompt (erforderlich): der Text-Prompt, der das zu generierende Bild beschreibt.
• iterations (erforderlich): Die gesamten Iterationen zum Generieren des Bildes. A ist 20 ein guter Ausgangspunkt.
• seed (erforderlich): Der bei der Bildgenerierung nach dem Zufallsprinzip verwendete Seed.
• condition image (optional): Das Bild, für das das Modell als Referenz verwendet wird Generation. Gilt nur bei Verwendung eines Plug-in-Modells.
• condition type (optional): Der Typ des Plug-in-Modells, das mit der Aufgabe verwendet wird. Gilt nur bei Verwendung eines Plug-in-Modells.

Eingaben nur mit dem Basismodell

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

Eingaben über Plug-ins

Wenn Sie ein optionales Plug-in-Modell anwenden, verwenden Sie auch die conditionType zur Auswahl des Plug-in-Modells und den Parameter sourceConditionImage für das Bedingungsbild generieren.

Wenn Sie ein Plug-in-Modell verwenden, erstellen Sie mit dem createConditionImage die Zustandsbild:

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

Nachdem Sie das Bedingungsbild erstellt haben, fügen Sie es als Eingabe zusammen mit dem Prompt, Seed und Anzahl der Iterationen.

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

Eingaben mit LoRA-Gewichtungen

Wenn Sie LoRA-Gewichtungen verwenden, achten Sie darauf, dass sich das Token in der Text-Eingabeaufforderung befindet, wenn möchten Sie ein Bild mit dem Konzept generieren, das durch die Gewichte.

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

Aufgabe ausführen

Verwenden Sie die Methode generate(), um ein Bild anhand der Eingaben in im vorherigen Abschnitt. Dadurch wird ein einzelnes generiertes Bild erzeugt.

Nur mit dem Basismodell generieren

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

Mit Plug-ins generieren

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
}

Mit LoRA-Gewichtungen generieren

Der Prozess zum Generieren von Bildern mit einem Modell, das mit LoRA-Gewichtungen angepasst wurde, ist ähnlich wie bei einem Standard-Fundament-Modell. Das Token muss im Prompt enthalten ist, und führen Sie denselben Code aus.

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

Iterative Generierung

Der Image Generator kann auch die generierten Zwischenbilder während der einzelnen Iteration gemäß der Definition im Eingabeparameter iterations. So rufen Sie diese auf Zwischenergebnisse: Methode setInputs und dann execute() zum Ausführen aufrufen Schritt zu halten. Legen Sie den showResult-Parameter auf true fest, um die Zwischenstufe anzuzeigen. Ergebnisse.

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

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

    return bitmap
}

Ergebnisse verarbeiten und anzeigen

Der Bildgenerator gibt ein ImageGeneratorResult zurück, das die generierten den Zeitstempel der Fertigstellung und das bedingte Bild, falls vorhanden, als Eingabe bereitgestellt wurde.

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

Das folgende Bild wurde aus den folgenden Eingaben mit nur einem Foundation Model.

Eingaben:

• Prompt: „Ein bunter Cartoon-Waschbär mit einem flauschigen Hut mit breiter Krempe mit einem Stock, der durch den Wald läuft, animierte Dreiviertelansicht, Malerei“
• Seed-Wert: 312687592
• Iterationen: 20

Generiertes Bild: