1. Introdução
O que é o MediaPipe?
Com o MediaPipe Solutions, é possível aplicar soluções de machine learning (ML) nos apps. Ele oferece um framework para configurar pipelines de processamento pré-criados que entregam saídas imediatas, interativas e úteis para os usuários. É possível personalizar muitas dessas soluções com MediaPipe Model Maker para atualizar os modelos padrão.
A conversão de texto em imagem é uma das várias tarefas de ML que o MediaPipe Solutions oferece.
Neste codelab, você vai começar com um app Android quase vazio e avançar por várias etapas até conseguir gerar novas imagens diretamente no seu dispositivo Android.
O que você vai aprender
- Como implementar a conversão de texto em imagem localmente em um app Android com o MediaPipe Tasks.
O que é necessário
- Uma versão instalada do Android Studio (este codelab foi escrito e testado com o Android Studio Giraffe).
- Um dispositivo Android com pelo menos 8 GB de RAM.
- Conhecimento básico de desenvolvimento para Android e a capacidade de executar um script Python pré-escrito.
2. Adicionar o MediaPipe Tasks ao app Android
Fazer o download do app inicial do Android
Este codelab vai começar com um exemplo pré-criado que consiste na interface que será usada para uma versão básica da geração de imagens. Você pode encontrar esse app inicial no repositório oficial de exemplos do MediaPipe aqui. Clone o repositório ou faça o download do arquivo ZIP clicando em "Code" > "Download ZIP".
Importar o app para o Android Studio
- Abra o Android Studio.
- Na tela Welcome to Android Studio, selecione Open no canto superior direito.
- Navegue até o local em que você clonou ou fez o download do repositório e abra o diretório codelabs/image_generation_basic/android/start.
- Nessa fase, o app não deve compilar porque você ainda não incluiu a dependência do MediaPipe Tasks.
Para corrigir o app e fazê-lo funcionar, acesse o arquivo build.gradle e role a tela para baixo até // Step 1 - Add dependency. Inclua a seguinte linha e clique no botão Sync Now que aparece no banner na parte de cima do Android Studio.
// Step 1 - Add dependency
implementation 'com.google.mediapipe:tasks-vision-image-generator:latest.release'
Depois que a sincronização for concluída, clique na seta verde run ( 
) no canto superior direito do Android Studio para verificar se tudo foi aberto e instalado corretamente. O app será aberto em uma tela com dois botões de opção e um botão com o rótulo INITIALIZE. Se você clicar nesse botão, será direcionado imediatamente para uma interface separada que consiste em um comando de texto e outras opções, além de um botão com o rótulo GENERATE.
Infelizmente, esse é o limite do app inicial. Agora é hora de aprender a concluir esse app e começar a gerar novas imagens no seu dispositivo.
3. Configurar o gerador de imagens
Neste exemplo, a maior parte do trabalho de geração de imagens vai acontecer no arquivo ImageGenerationHelper.kt. Ao abrir esse arquivo, você vai notar uma variável na parte de cima da classe chamada imageGenerator. Esse é o objeto de tarefa que vai fazer o trabalho pesado no seu app de geração de imagens.
Logo abaixo desse objeto, você vai encontrar uma função chamada initializeImageGenerator() com o seguinte comentário: // Step 2 - initialize the image generator. Como você pode imaginar, é aqui que você vai inicializar o objeto ImageGenerator. Substitua o corpo da função pelo código a seguir para definir o caminho do modelo de geração de imagens e inicializar o objeto ImageGenerator:
// Step 2 - initialize the image generator
val options = ImageGeneratorOptions.builder()
.setImageGeneratorModelDirectory(modelPath)
.build()
imageGenerator = ImageGenerator.createFromOptions(context, options)
Abaixo, você vai encontrar outra função chamada setInput(). Ela aceita três parâmetros: uma string de comando que será usada para definir a imagem gerada, o número de iterações que a tarefa deve passar ao gerar a nova imagem e um valor de semente que pode ser usado para criar novas versões de uma imagem com base no mesmo comando ao gerar a mesma imagem quando a mesma semente é usada. O objetivo dessa função é definir esses parâmetros iniciais para o gerador de imagens quando você tenta criar uma imagem que mostra etapas intermediárias.
Substitua o corpo de setInput() (em que você verá o comentário // Step 3 - accept inputs) por esta linha:
// Step 3 - accept inputs
imageGenerator.setInputs(prompt, iteration, seed)
As duas etapas seguintes são onde a geração ocorre. A função generate() aceita as mesmas entradas que setInput, mas cria uma imagem como uma chamada única que não retorna nenhuma imagem de etapa intermediária. Você pode substituir o corpo dessa função (que inclui o comentário // Step 4 - generate without showing iterations) pelo seguinte:
// Step 4 - generate without showing iterations
val result = imageGenerator.generate(prompt, iteration, seed)
val bitmap = BitmapExtractor.extract(result?.generatedImage())
return bitmap
É importante saber que essa tarefa acontece de forma síncrona, então você precisa chamar a função de uma linha de execução em segundo plano. Você vai aprender mais sobre isso um pouco mais tarde neste codelab.
A etapa final que você vai realizar neste arquivo é preencher a função execute() (rotulada como "Step 5"). Ela vai aceitar um parâmetro que informa se deve retornar uma imagem intermediária ou não para a única etapa de geração que será realizada com a função execute() do ImageGenerator. Substitua o corpo da função por este código:
// Step 5 - generate with iterations
val result = imageGenerator.execute(showResult)
if (result == null || result.generatedImage() == null) {
return Bitmap.createBitmap(512, 512, Bitmap.Config.ARGB_8888)
.apply {
val canvas = Canvas(this)
val paint = Paint()
paint.color = Color.WHITE
canvas.drawPaint(paint)
}
}
val bitmap =
BitmapExtractor.extract(result.generatedImage())
return bitmap
E é isso para o arquivo auxiliar. Na próxima seção, você vai preencher o arquivo ViewModel que processa a lógica desse exemplo.
4. Reunir o app
O arquivo MainViewModel vai processar os estados da interface e outras lógicas relacionadas a esse app de exemplo. Abra-o agora.
Na parte de cima do arquivo, você vai encontrar o comentário // Step 6 - set model path. É aqui que você vai informar ao app onde ele pode encontrar os arquivos de modelo necessários para a geração de imagens. Para este exemplo, defina o valor como /data/local/tmp/image_generator/bins/.
// Step 6 - set model path
private val MODEL_PATH = "/data/local/tmp/image_generator/bins/"
Em seguida, role a tela para baixo até a função generateImage(). Na parte de baixo dessa função, você vai encontrar as etapas 7 e 8, que serão usadas para gerar imagens com iterações retornadas ou nenhuma, respectivamente. Como essas duas operações acontecem de forma síncrona, elas são encapsuladas em uma corrotina. Comece substituindo // Step 7 - Generate without showing iterations por este bloco de código para chamar generate() do arquivo ImageGenerationHelper e, em seguida, atualize o estado da interface.
// Step 7 - Generate without showing iterations
val result = helper?.generate(prompt, iteration, seed)
_uiState.update {
it.copy(outputBitmap = result)
}
A etapa 8 é um pouco mais complicada. Como a função execute() executa apenas uma etapa em vez de todas as etapas para geração de imagens, você precisa chamar cada etapa individualmente por um loop. Você também precisa determinar se a etapa atual deve ser mostrada ao usuário. Por fim, atualize o estado da interface se a iteração atual precisar ser mostrada. Você pode fazer tudo isso agora.
// Step 8 - Generate with showing iterations
helper?.setInput(prompt, iteration, seed)
for (step in 0 until iteration) {
isDisplayStep =
(displayIteration > 0 && ((step + 1) % displayIteration == 0))
val result = helper?.execute(isDisplayStep)
if (isDisplayStep) {
_uiState.update {
it.copy(
outputBitmap = result,
generatingMessage = "Generating... (${step + 1}/$iteration)",
)
}
}
}
Nesse ponto, você deve conseguir instalar o app, inicializar o gerador de imagens e criar uma nova imagem com base em um comando de texto.
... exceto que agora o app falha quando você tenta inicializar o gerador de imagens. Isso acontece porque você precisa copiar os arquivos de modelo para o dispositivo. Para acessar as informações mais atualizadas sobre modelos de terceiros conhecidos, convertê-los para essa tarefa do MediaPipe e copiá-los para o dispositivo, consulte esta seção da documentação oficial.
Além de copiar arquivos diretamente para o dispositivo de desenvolvimento, também é possível configurar o Firebase Storage para fazer o download dos arquivos necessários diretamente para o dispositivo do usuário no momento da execução.
5. Implantar e testar o app
Depois de tudo isso, você terá um app funcional que pode aceitar um comando de texto e gerar novas imagens totalmente no dispositivo. Implante o app em um dispositivo Android físico para testá-lo, mas lembre-se de que você vai querer testar com um dispositivo com pelo menos 8 GB de memória.
- Clique em "Run" () na barra de ferramentas do Android Studio para executar o app.
- Selecione o tipo de etapas de geração (final ou com iterações) e pressione o botão INITIALIZE.
- Na próxima tela, defina as propriedades desejadas e clique no botão GENERATE para ver o que a ferramenta apresenta.
6. Parabéns!
Você conseguiu! Neste codelab, você aprendeu a adicionar a conversão de texto em imagem no dispositivo a um app Android.
Próximas etapas
Há mais coisas que você pode fazer com a tarefa de geração de imagens, incluindo
- usar uma imagem de base para estruturar imagens geradas por plug-ins ou treinar seus próprios pesos LoRA adicionais usando a Vertex AI.
- Use o Firebase Storage para recuperar arquivos de modelo no dispositivo sem precisar usar a ferramenta ADB.
Estamos ansiosos para ver todas as coisas legais que você faz com essa tarefa experimental. Fique atento a ainda mais Codelabs e conteúdo da equipe do MediaPipe.