Guida alla generazione di immagini per Android

L'attività MediaPipe Image Generator ti consente di generare immagini in base a un prompt di testo. Questa attività utilizza un modello di conversione da testo a immagine per generare immagini utilizzando tecniche di diffusione.

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

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

Esempio di codice

Il codice di esempio di MediaPipe Tasks è un'implementazione di base di un'app di generatore di immagini per Android. Puoi utilizzare l'app come punto di partenza per la tua app Android o farvi riferimento quando modifichi un'app esistente. Il codice di esempio di Image Generator è ospitato su GitHub.

Scarica il codice

Le istruzioni riportate di seguito mostrano come creare una copia locale del codice di esempio utilizzando lo strumento a riga di comando git.

Per scaricare il codice di esempio:

1. Clona il repository Git utilizzando il seguente comando:

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

2. Se vuoi, configura l'istanza Git in modo da utilizzare il controllo sparse, in modo da avere solo i file per l'app di esempio Image Generator:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/image_generation/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 questa applicazione di esempio di generazione di immagini:

• ImageGenerationHelper.kt: inizializza l'attività e gestisce la generazione delle immagini.
• DiffusionActivity.kt: genera immagini quando i plug-in o i pesi LoRA non sono attivati.
• PluginActivity.kt: implementa i modelli dei plug-in, che consentono agli utenti di fornire un'immagine condizione come input.
• LoRAWeightActivity.kt: accede e gestisce i pesi LoRA, che vengono utilizzati per personalizzare i modelli 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 i progetti di codice specificamente per utilizzare Generatore di immagini. Per informazioni generali sulla configurazione dell'ambiente di sviluppo per l'utilizzo delle attività MediaPipe, inclusi i requisiti della versione della piattaforma, consulta la guida alla configurazione per Android.

Dipendenze

L'attività Generatore di immagini utilizza la libreria com.google.mediapipe:tasks-vision-image-generator. Aggiungi questa dipendenza al file build.gradle della tua app per 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 dipendenza dalla libreria OpenCL nativa. Per ulteriori informazioni, consulta la documentazione relativa al tag uses-native-library.

Aggiungi i seguenti tag uses-native-library al file AndroidManifest.xml:

<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à MediaPipe Image Generator richiede un modello di base addestrato compatibile con questa attività. Dopo aver scaricato un modello, installa le dipendenze richieste e converti il modello in un formato adatto. Quindi, invia il modello convertito al dispositivo Android.

Per ulteriori informazioni sui modelli addestrati disponibili per Generatore di immagini, consulta la sezione Modelli della panoramica dell'attività.

Scarica il modello di base

Image Generator richiede che il modello di base corrisponda al formato del modello runwayml/stable-diffusion-v1-5 EMA-only, in base al seguente 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 lo script convert.py:

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

Invia il modello convertito al 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 dei plug-in e aggiungi i pesi LoRA

Se intendi utilizzare un modello plug-in, controlla se deve essere scaricato. Per i plug-in che richiedono un modello aggiuntivo, i modelli del plug-in devono essere inclusi nell'APK o scaricati on demand. I modelli dei plug-in sono leggeri (~23 MB) e possono essere raggruppati direttamente nell'APK. Tuttavia, consigliamo di scaricare i modelli dei plug-in on demand.

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

Crea l'attività

L'attività MediaPipe Image Generator utilizza la funzione createFromOptions() per configurare l'attività. La funzione createFromOptions() accetta valori per le opzioni di configurazione. Per ulteriori informazioni sulle opzioni di configurazione, consulta Opzioni di configurazione.

Opzioni di configurazione

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

L'attività supporta anche i modelli 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 di condizione possono essere punti di riferimento del viso, contorni dei bordi e stime della profondità, che il modello utilizza come contesto e informazioni aggiuntivi per generare immagini.

Quando aggiungi un modello plug-in al modello di base, configura anche le opzioni del plug-in. Il plug-in di landmark del viso utilizza faceConditionOptions, il plug-in di soglie di Canny utilizza edgeConditionOptions e il plug-in di profondità utilizza depthConditionOptions.

Opzioni di bordo Canny

Configura le seguenti opzioni in edgeConditionOptions.

Per ulteriori informazioni sul funzionamento di queste opzioni di configurazione, consulta Rilevatore di bordi di Canny.

Opzioni di punti di riferimento del viso

Configura le seguenti opzioni in faceConditionOptions.

Per ulteriori informazioni sul funzionamento di queste opzioni di configurazione, consulta l'attività Face Landmarker.

Opzioni di profondità

Configura le seguenti opzioni in depthConditionOptions.

Creare solo con il modello di base

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

imageGenerator = ImageGenerator.createFromOptions(context, options)

Creare con i plug-in

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

Creare con i pesi LoRA

Se includi i pesi LoRA, utilizza il parametro loraWeightsFilePath per indicare la posizione del percorso.

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

imageGenerator = ImageGenerator.createFromOptions(context, options)

Preparazione dei dati

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. Un buon punto di partenza è 20.
• seed (obbligatorio): il seed casuale utilizzato durante la generazione dell'immagine.
• condition image (facoltativo): l'immagine utilizzata dal modello come riferimento per la generazione. Applicabile solo quando si utilizza un modello plug-in.
• (Facoltativo) condition type: il tipo di modello del 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 il parametro conditionType per scegliere il modello di plug-in e il parametro sourceConditionImage per generare l'immagine della condizione.

Se utilizzi un modello di plug-in, utilizza createConditionImage per creare l'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 al prompt, al seed e al numero di iterazioni.

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

Input con pesi LoRA

Se utilizzi i pesi LoRA, assicurati che il token sia nel prompt di testo se intendi generare un'immagine con il concetto specifico rappresentato dai 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 nella sezione precedente. Viene prodotta una singola immagine generata.

Generazione con solo 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
}

Generare con i 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
}

Generare con pesi LoRA

La procedura per generare immagini con un modello personalizzato con pesi LoRA è simile alla procedura con un modello di base standard. Assicurati che il token sia incluso nel prompt ed esegui 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 produrre le immagini intermedie generate durante ogni iterazione, come definito nel parametro di input iterations. Per visualizzare questi risultati intermedi, chiama il metodo setInputs, quindi chiama execute() per eseguire ogni passaggio. Imposta il parametro showResult su true per visualizzare i risultati intermedi.

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 l'immagine generata, un timestamp dell'ora di completamento e l'immagine condizionale, se fornita come input.

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

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

Input:

• Stimolo: "un procione colorato dei cartoni animati che indossa un cappello a larghe falde svolazzanti e tiene in mano un bastone mentre cammina nella foresta, animazione, vista a tre quarti, dipinto"
• Seed: 312687592
• Iterazioni: 20

Immagine generata: