Guida alla generazione di immagini per Android

L'attività Generatore di immagini MediaPipe consente di generare immagini in base a un prompt di testo. Questo utilizza un modello da testo a immagine per generare immagini utilizzando tecniche di diffusione.

L'attività accetta un prompt di testo come input, insieme a un'immagine della condizione facoltativa che il modello può aumentare e utilizzare come riferimento per la generazione. Generatore di immagini possono anche generare immagini in base a concetti specifici forniti al modello durante o riaddestramento. Per ulteriori informazioni, consulta la sezione Personalizzare con LoRA.

L'esempio di codice descritto in queste istruzioni è disponibile su GitHub. Per ulteriori informazioni su funzionalità, modelli e opzioni di configurazione di questa attività, consulta la Panoramica.

Esempio di codice

Il codice di esempio relativo alle attività di MediaPipe è un'implementazione di base di un generatore di immagini per Android. Puoi utilizzare l'app come punto di partenza per il tuo Android di un'app esistente o di farvi riferimento quando modifichi un'app esistente. Esempio di Generatore di immagini il codice è ospitato su GitHub.

Scarica il codice

Le seguenti istruzioni mostrano come creare una copia locale dell'esempio utilizzando lo strumento a riga di comando git.

Per scaricare il codice di esempio:

1. Clona il repository git utilizzando il comando seguente:

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

2. Facoltativamente, configura la tua istanza Git per l'utilizzo di un pagamento sparso, in modo da avere solo i file per l'app di esempio Generatore di immagini:

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

Dopo aver creato una versione locale del codice di esempio, puoi importare il progetto in Android Studio ed eseguire l'app. Per istruzioni, consulta la Guida alla configurazione per Android.

Componenti chiave

I seguenti file contengono il codice fondamentale per questo esempio di generazione di immagini applicazione:

• ImageGenerationHelper.kt: Inizializza l'attività e gestisce la generazione dell'immagine.
• DiffusionActivity.kt: Genera immagini quando i plug-in o le ponderazioni LoRA non sono abilitati.
• PluginActivity.kt: Implementa i modelli di plug-in, che consentono agli utenti di fornire una condizione immagine come input.
• LoRAWeightActivity.kt: Accede ai pesi LoRA e li gestisce, che vengono utilizzati per personalizzare gli elementi di base e consentire loro di generare immagini di concetti specifici.

Configurazione

Questa sezione descrive i passaggi chiave per configurare l'ambiente di sviluppo e per i progetti di codice che usano specificatamente Image Builder. Per informazioni generali su configurare l'ambiente di sviluppo per l'utilizzo delle attività di MediaPipe, tra cui: i requisiti di versione della piattaforma, consulta la Guida alla configurazione per Android.

Dipendenze

L'attività Generatore di immagini utilizza Raccolta com.google.mediapipe:tasks-vision-image-generator. Aggiungi questa dipendenza al file build.gradle della tua app Android:

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

Per i dispositivi con Android 12 (API 31) o versioni successive, aggiungi la libreria OpenCL nativa della dipendenza a AndroidManifest.xml. Per ulteriori informazioni, consulta la documentazione uses-native-library del tag.

Alcuni dispositivi Android potrebbero richiedere anche librerie aggiuntive:

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

Modello

L'attività Generatore di immagini MediaPipe richiede un modello di base addestrato che sia compatibile con questa attività. Dopo aver scaricato un modello, installa le dipendenze richieste convertire il modello in un formato adatto. Quindi, esegui il push modello al dispositivo Android.

Per saperne di più sui modelli addestrati disponibili per Image Builder, consulta l'attività Panoramica, sezione Modelli.

Scarica modello di base

Il generatore di immagini richiede che il modello di base corrisponda Formato del modello runwayml/stable-diffusion-v1-5 EMA-only, in base a quanto segue modello: runwayml/stable-diffusion-v1-5.

Installa le dipendenze e converti il modello

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

Esegui l' convert.py script:

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

Esegui il push del modello convertito nel dispositivo

Invia i contenuti della cartella <output_path> al dispositivo 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

(Facoltativo) Scarica i modelli di plug-in e aggiungi pesi LoRA

Se intendi utilizzare un modello plug-in, controlla se il modello devono essere scaricati. Per i plug-in che richiedono un modello aggiuntivo, i modelli devono essere raggruppati nell'APK o scaricati on demand. Modelli di plug-in sono leggeri (~23 MB) e possono essere raggruppati direttamente nell'APK. Tuttavia, il download dei modelli di plug-in è consigliato su richiesta.

Se hai personalizzato un modello con LoRA scaricarle on demand. Per ulteriori informazioni informazioni, consulta il modello plug-in dei pesi LoRA.

Crea l'attività

L'attività Generatore di immagini MediaPipe utilizza la funzione createFromOptions() per configurare dell'attività. La funzione createFromOptions() accetta i valori per la configurazione le opzioni di CPU e memoria disponibili. Per ulteriori informazioni sulle opzioni di configurazione, vedi Configurazione opzioni.

Opzioni di configurazione

Questa attività include le seguenti opzioni di configurazione per le app per Android:

L'attività supporta anche modelli di plug-in, che consentono agli utenti di includere immagini delle condizioni nell'input dell'attività, che il modello di base può aumentare e utilizzare come riferimento per la generazione. Queste immagini possono essere punti di riferimento di volti, contorni dei bordi e stime di profondità, che il modello utilizza come contesto aggiuntivo e generare immagini.

Quando aggiungi un modello plug-in al modello di base, configura anche il plug-in le opzioni di CPU e memoria disponibili. Il plug-in dei punti di riferimento Face utilizza faceConditionOptions, il bordo di Canny Il plug-in utilizza edgeConditionOptions, mentre il plug-in Depth usa depthConditionOptions.

Opzioni per i bordi Canny

Configura le seguenti opzioni in edgeConditionOptions.

Per ulteriori informazioni su come funzionano queste opzioni di configurazione, consulta Rilevatore di bordi Canny.

Opzioni punto di riferimento volto

Configura le seguenti opzioni in faceConditionOptions.

Per ulteriori informazioni su come funzionano queste opzioni di configurazione, consulta Attività Punti di riferimento volti.

Opzioni di profondità

Configura le seguenti opzioni in depthConditionOptions.

Crea solo con il modello di base

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

imageGenerator = ImageGenerator.createFromOptions(context, options)

Crea con plug-in

Se applichi un modello di plug-in facoltativo, imposta le opzioni di base per modello di plug-in con setPluginModelBaseOptions. Se il modello plug-in richiede aggiuntivo scaricato per creare l'immagine della condizione, specifica il percorso 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)
    

Crea con i pesi LoRA

Se includi pesi LoRA, usa il parametro loraWeightsFilePath per puntano alla posizione del percorso.

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

imageGenerator = ImageGenerator.createFromOptions(context, options)

Preparazione dei dati

Il generatore di immagini accetta i seguenti input:

• prompt (obbligatorio): il prompt di testo che descrive l'immagine da generare.
• iterations (obbligatorio): le iterazioni totali per generare l'immagine. R un buon punto di partenza è 20.
• seed (obbligatorio): il seed casuale utilizzato durante la generazione dell'immagine.
• condition image (facoltativa): l'immagine utilizzata dal modello come riferimento per di classificazione. Applicabile solo quando si utilizza un modello di plug-in.
• (Facoltativo) condition type: il tipo di modello di plug-in utilizzato con l'attività. Applicabile solo quando si utilizza un modello di plug-in.

Input con solo il modello di base

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

Input con plug-in

Se applichi un modello di plug-in facoltativo, utilizza anche conditionType per scegliere il modello plug-in e il parametro sourceConditionImage per per generare l'immagine della condizione.

Se utilizzi un modello plug-in, usa createConditionImage per creare immagine della condizione:

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

Dopo aver creato l'immagine della condizione, includila come input insieme alla un prompt, il seed e il numero di iterazioni.

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

Input con ponderazioni LoRA

Se utilizzi pesi LoRA, assicurati che il token sia nel prompt di testo se intendi generare un'immagine con il concetto specifico rappresentato i pesi.

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

Esegui l'attività

Utilizza il metodo generate() per generare un'immagine utilizzando gli input forniti in nella sezione precedente. Viene generata una singola immagine.

Genera solo con il modello di base

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

Genera con plug-in

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
}

Genera con pesi LoRA

Il processo di generazione di immagini con un modello personalizzato con pesi LoRA è in modo simile al processo con un modello di base standard. Assicurati che il token è incluso nel prompt ed eseguire lo stesso codice.

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

Generazione iterativa

Il generatore di immagini può anche restituire le immagini intermedie generate durante ogni come definito nel parametro di input iterations. Per visualizzare questi risultati intermedi, chiama il metodo setInputs, quindi chiama execute() per l'esecuzione per ogni passaggio. Imposta il parametro showResult su true per visualizzare la parte intermedia che consentono di analizzare i dati e visualizzare i risultati.

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

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

    return bitmap
}

Gestire e visualizzare i risultati

Il generatore di immagini restituisce un ImageGeneratorResult, che include i valori generati immagine, il timestamp del momento di completamento e l'immagine condizionale, se fornito come input.

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

L'immagine seguente è stata generata dai seguenti input, utilizzando solo un un modello di base.

Input:

• Prompt: "un procione colorato a cartone animato che indossa un cappello a tesa larga flosto con in mano un bastone che cammina nella foresta, animata, vista di tre quarti, pittura"
• Seed: 312687592
• Iterazioni: 20

Immagine generata: