Com a tarefa "Gerador de imagens do MediaPipe", você gera imagens com base em um comando de texto. Essa tarefa usa um modelo de texto para imagem para gerar imagens usando técnicas de difusão.
A tarefa aceita um comando de texto como entrada, junto com uma imagem de condição opcional que o modelo pode ampliar e usar como referência para geração. O Image Generator também pode gerar imagens com base em conceitos específicos fornecidos ao modelo durante o treinamento ou retreinamento. Para mais informações, consulte Personalizar com LoRA.
O exemplo de código descrito nestas instruções está disponível no GitHub. Para mais informações sobre os recursos, modelos e opções de configuração dessa tarefa, consulte a Visão geral.
Exemplo de código
O código de exemplo do MediaPipe Tasks é uma implementação básica de um app gerador de imagens para Android. Você pode usar o app como ponto de partida para seu próprio app Android ou consultá-lo ao modificar um app já existente. O código de exemplo do Gerador de imagens está hospedado no GitHub (link em inglês).
Fazer o download do código
As instruções a seguir mostram como criar uma cópia local do código de exemplo usando a ferramenta de linha de comando git.
Para fazer o download do código de exemplo:
- Clone o repositório git usando o seguinte comando:
git clone https://github.com/google-ai-edge/mediapipe-samples
- Como opção, configure sua instância git para usar a finalização da compra esparsa para que você tenha
apenas os arquivos do app de exemplo Gerador de imagens:
cd mediapipe git sparse-checkout init --cone git sparse-checkout set examples/image_generator/android
Depois de criar uma versão local do código de exemplo, você poderá importar o projeto para o Android Studio e executar o app. Para conferir instruções, consulte o Guia de configuração para Android.
Principais componentes
Os arquivos a seguir contêm o código essencial para este aplicativo de exemplo de geração de imagens:
- ImageGenerationHelper.kt: inicializa a tarefa e processa a geração da imagem.
- DiffusionActivity.kt: gera imagens quando plug-ins ou pesos da LoRA não estão ativados.
- PluginActivity.kt: implementa os modelos de plug-in, o que permite que os usuários forneçam uma imagem de condição como uma entrada.
- LoRAWeightActivity.kt (link em inglês): acessa e processa os pesos da LoRA, que são usados para personalizar modelos de fundação e permitir que eles gerem imagens de conceitos específicos.
Configuração
Esta seção descreve as principais etapas para configurar seu ambiente de desenvolvimento e projetos de código especificamente para usar o Image Generator. Para ter informações gerais sobre como configurar seu ambiente de desenvolvimento para usar tarefas do MediaPipe, incluindo requisitos de versão da plataforma, consulte o Guia de configuração para Android.
Dependências
A tarefa Gerador de imagem usa a
biblioteca com.google.mediapipe:tasks-vision-image-generator
. Adicione esta dependência
ao arquivo build.gradle
do seu app Android:
dependencies {
implementation 'com.google.mediapipe:tasks-vision-image-generator:latest.release'
}
Para dispositivos com o Android 12 (nível 31 da API) ou versões mais recentes, adicione a dependência da biblioteca OpenCL
nativa a AndroidManifest.xml
. Para mais informações, consulte a documentação sobre a tag uses-native-library
.
Alguns dispositivos Android também podem exigir outras bibliotecas:
<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" />
Modelo
A tarefa do gerador de imagens do MediaPipe requer um modelo de fundação treinado que seja compatível com ela. Depois de fazer o download de um modelo, instale as dependências necessárias e converta o modelo em um formato adequado. Em seguida, envie o modelo convertido ao dispositivo Android.
Para mais informações sobre os modelos treinados disponíveis para o Gerador de imagens, consulte a seção Modelos de visão geral da tarefa.
Fazer o download do modelo de base
O gerador de imagens exige que o modelo de fundação corresponda ao
formato runwayml/stable-diffusion-v1-5 EMA-only
, com base no seguinte
modelo:
runwayml/stable-diffusion-v1-5 (link em inglês).
Instalar dependências e converter o modelo
$ pip install torch typing_extensions numpy Pillow requests pytorch_lightning absl-py
Execute o script convert.py
:
$ python3 convert.py --ckpt_path <ckpt_path> --output_path <output_path>
Enviar o modelo convertido ao dispositivo
Envie o conteúdo da pasta <output_path>
para o 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
Fazer o download de modelos do plug-in e adicionar pesos de LoRA (opcional)
Se você pretende usar um modelo de plug-in, verifique se é necessário fazer o download dele. Para plug-ins que exigem um modelo adicional, os modelos de plug-in precisam ser agrupados no APK ou transferidos por download sob demanda. Os modelos de plug-in são leves (aproximadamente 23 MB) e podem ser agrupados diretamente no APK. No entanto, recomendamos o download de modelos de plug-in sob demanda.
Se você personalizou um modelo com o LoRA, faça o download dele sob demanda. Para mais informações, consulte o modelo de plug-in dos pesos da LoRA.
Criar a tarefa
A tarefa do gerador de imagens do MediaPipe usa a função createFromOptions()
para configurar a
tarefa. A função createFromOptions()
aceita valores para as opções de
configuração. Para mais informações sobre as opções de configuração, consulte Opções de
configuração.
Opções de configuração
Esta tarefa tem as seguintes opções de configuração para apps Android:
Nome da opção | Descrição | Intervalo de valor |
---|---|---|
imageGeneratorModelDirectory |
O diretório de modelo do gerador de imagens que armazena os pesos do modelo. | PATH |
loraWeightsFilePath |
Define o caminho para o arquivo de pesos do LoRA. Opcional e aplicável somente se o modelo tiver sido personalizado com a LoRA. | PATH |
errorListener |
Define um listener de erro opcional. | N/A |
A tarefa também oferece suporte a modelos de plug-in, o que permite que os usuários incluam imagens de condição na entrada da tarefa, que o modelo de fundação pode ampliar e usar como referência para geração. Essas imagens de condição podem ser pontos de referência de rostos, contornos de bordas e estimativas de profundidade, que o modelo usa como contexto e informações adicionais para gerar imagens.
Ao adicionar um modelo de plug-in ao modelo de base, configure também as opções
do plug-in. O plug-in do ponto de referência do rosto usa faceConditionOptions
, o plug-in
Canny Edge usa edgeConditionOptions
e o plug-in Depth usa
depthConditionOptions
.
Opções do Canny Edge
Configure as seguintes opções em edgeConditionOptions
.
Nome da opção | Descrição | Intervalo de valor | Valor padrão |
---|---|---|---|
threshold1 |
Primeiro limite do procedimento de história. | Float |
100 |
threshold2 |
Segundo limite do procedimento de história. | Float |
200 |
apertureSize |
Tamanho da abertura do operador Sobel. O intervalo típico é de 3 a 7. | Integer |
3 |
l2Gradient |
Define se a norma L2 é usada para calcular a magnitude do gradiente da imagem em vez da norma L1 padrão. | BOOLEAN |
False |
EdgePluginModelBaseOptions |
O objeto BaseOptions que define o caminho
para o modelo do plug-in. |
Objeto BaseOptions |
N/A |
Para mais informações sobre como essas opções de configuração funcionam, consulte Detector de borda Canny.
Opções de ponto de referência do rosto
Configure as seguintes opções em faceConditionOptions
.
Nome da opção | Descrição | Intervalo de valor | Valor padrão |
---|---|---|---|
minFaceDetectionConfidence |
A pontuação de confiança mínima para que a detecção facial seja considerada bem-sucedida. | Float [0.0,1.0] |
0.5 |
minFacePresenceConfidence |
A pontuação de confiança mínima da pontuação de presença facial na detecção de pontos de referência de rostos. | Float [0.0,1.0] |
0.5 |
faceModelBaseOptions |
O objeto BaseOptions que define o caminho
para o modelo que cria a imagem de condição. |
Objeto BaseOptions |
N/A |
FacePluginModelBaseOptions |
O objeto BaseOptions que define o caminho
para o modelo do plug-in. |
Objeto BaseOptions |
N/A |
Para mais informações sobre como essas opções de configuração funcionam, consulte a tarefa do Face Markdown.
Opções de profundidade
Configure as seguintes opções em depthConditionOptions
.
Nome da opção | Descrição | Intervalo de valor | Valor padrão |
---|---|---|---|
depthModelBaseOptions |
O objeto BaseOptions que define o caminho
para o modelo que cria a imagem de condição. |
Objeto BaseOptions |
N/A |
depthPluginModelBaseOptions |
O objeto BaseOptions que define o caminho
para o modelo do plug-in. |
Objeto BaseOptions |
N/A |
Criar apenas com o modelo de fundação
val options = ImageGeneratorOptions.builder()
.setImageGeneratorModelDirectory(modelPath)
.build()
imageGenerator = ImageGenerator.createFromOptions(context, options)
Criar com plug-ins
Se você estiver aplicando um modelo de plug-in opcional, defina as opções básicas para o
modelo com setPluginModelBaseOptions
. Se o modelo do plug-in precisar de outro modelo transferido por download para criar a imagem de condição, especifique o caminho em BaseOptions
.
Ponto de referência do rosto
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)
Canny Edge
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)
Detalhes
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)
Criar com pesos da LoRA
Se você estiver incluindo pesos LoRA, use o parâmetro loraWeightsFilePath
para apontar para o local do caminho.
val options = ImageGeneratorOptions.builder()
.setLoraWeightsFilePath(weightsPath)
.setImageGeneratorModelDirectory(modelPath)
.build()
imageGenerator = ImageGenerator.createFromOptions(context, options)
preparar dados
O gerador de imagens aceita as seguintes entradas:
- prompt (obrigatório): o comando de texto que descreve a imagem a ser gerada.
- iterations (obrigatório): o total de iterações para gerar a imagem. Um bom ponto de partida é 20.
- seed (obrigatório): a semente aleatória usada durante a geração da imagem.
- imagem de condição (opcional): a imagem que o modelo usa como referência para geração. Aplicável somente ao usar um modelo de plug-in.
- condition type (opcional): o tipo de modelo de plug-in usado com a tarefa. Aplicável somente ao usar um modelo de plug-in.
Entradas apenas com o modelo de fundação
fun setInput(prompt: String, iteration: Int, seed: Int) {
imageGenerator.setInputs(prompt, iteration, seed)
}
Entradas com plug-ins
Se você estiver aplicando um modelo de plug-in opcional, use também o parâmetro conditionType
para escolher o modelo do plug-in e o parâmetro sourceConditionImage
para gerar a imagem de condição.
Nome da opção | Descrição | Valor |
---|---|---|
conditionType |
O modelo de plug-in aplicado ao modelo de fundação. | {"FACE", "EDGE", "DEPTH"} |
sourceConditionImage |
A imagem de origem usada para criar a imagem de condição. | Objeto MPImage |
Se você estiver usando um modelo de plug-in, use createConditionImage
para criar a
imagem de condição:
fun createConditionImage(
inputImage: MPImage,
conditionType: ConditionType
): Bitmap {
val result =
imageGenerator.createConditionImage(inputImage, conditionType)
return BitmapExtractor.extract(result)
}
Depois de criar a imagem de condição, inclua como uma entrada junto com o comando, a semente e o número de iterações.
imageGenerator.setInputs(
prompt,
conditionalImage,
conditionType,
iteration,
seed
)
Entradas com pesos da LoRA
Se você estiver usando pesos LoRA, verifique se o token está no prompt de texto caso você pretenda gerar uma imagem com o conceito específico representado pelos pesos.
fun setInput(prompt: String, iteration: Int, seed: Int) {
imageGenerator.setInputs(prompt, iteration, seed)
}
Executar a tarefa
Use o método generate()
para gerar uma imagem usando as entradas fornecidas na
seção anterior. Isso produz uma única imagem gerada.
Gerar apenas com o modelo de fundação
fun generate(prompt: String, iteration: Int, seed: Int): Bitmap {
val result = imageGenerator.generate(prompt, iteration, seed)
val bitmap = BitmapExtractor.extract(result?.generatedImage())
return bitmap
}
Gerar com plug-ins
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
}
Gerar com pesos da LoRA
O processo de gerar imagens com um modelo personalizado com pesos LoRA é semelhante ao processo com um modelo de fundação padrão. Verifique se o token está incluído no prompt e execute o mesmo código.
fun generate(prompt: String, iteration: Int, seed: Int): Bitmap {
val result = imageGenerator.generate(prompt, iteration, seed)
val bitmap = BitmapExtractor.extract(result?.generatedImage())
return bitmap
}
Geração iterativa
O gerador de imagens também pode gerar as imagens intermediárias geradas durante cada
iteração, conforme definido no parâmetro de entrada iterations
. Para visualizar esses
resultados intermediários, chame o método setInputs
e, em seguida, chame execute()
para executar
cada etapa. Defina o parâmetro showResult
como true
para exibir os resultados intermediários.
fun execute(showResult: Boolean): Bitmap {
val result = imageGenerator.execute(showResult)
val bitmap =
BitmapExtractor.extract(result.generatedImage())
return bitmap
}
Gerenciar e mostrar resultados
O gerador de imagens retorna um ImageGeneratorResult
, que inclui a imagem
gerada, um carimbo de data/hora do momento de conclusão e a imagem condicional, se ela
tiver sido fornecida como entrada.
val bitmap = BitmapExtractor.extract(result.generatedImage())
A imagem a seguir foi gerada a partir das entradas a seguir, usando apenas um modelo de fundação.
Entradas:
- Instrução: "um guaxinim colorido de desenho animado usando um chapéu de aba larga flexível segurando um graveto caminhando pela floresta, animação, visão de três quartos, pintura"
- Semente: 312687592
- Iterações: 20
Imagem gerada: