1. Introdução
Última atualização:12/10/2023
Geração de imagens com o Imagegen
O Google Imagen é um modelo de linguagem grande do Google que pode gerar imagens realistas e criativas com base em descrições de texto. Com o Imagen na Vertex AI, os usuários podem criar produtos de IA de última geração que transformam a imaginação do usuário em recursos visuais de alta qualidade em segundos. Além da geração de imagens com base em texto, ele também oferece suporte à edição de imagens com comandos de texto, legendagem de imagens, perguntas e respostas visuais e ajuste de modelos de imagens com base em assunto e estilo.
Geração de comandos
Para criar uma imagem usando o Imagen, você precisa fornecer uma descrição em texto da imagem, conhecida como comando, que será usada para gerar a imagem. No entanto, para gerar uma imagem fotorrealista de alta qualidade, é necessário ter experiência com comandos. Também pode ser dependente do domínio se você quiser gerar uma imagem relacionada a domínios comerciais específicos, como varejo, manufatura etc. Uma abordagem mais fácil para criar um comando é fornecer um conjunto de palavras-chave ao modelo Text Bison.
A abordagem geral é a seguinte:
Interface do Gradio (link em inglês)
O Gradio é uma biblioteca Python de código aberto que permite criar rapidamente componentes de interface fáceis de usar e personalizáveis para seu modelo de aprendizado de máquina, qualquer API ou até mesmo uma função Python arbitrária usando algumas linhas de código. Você pode integrar a GUI do Gradio diretamente ao seu notebook Jupyter ou compartilhar como um link com qualquer pessoa. O Gradio oferece suporte a uma ampla variedade de tipos de mídia, incluindo texto, imagens, vídeos e áudio. Ele também oferece vários componentes de interface pré-criados, como campos de entrada, botões, controles deslizantes e menus suspensos.
O que você vai criar
Neste codelab, você vai implantar um app do Gradio que vai:
- Gere um comando de texto usando palavras-chave ou frases. O comando gerado também pode ser editado manualmente.
- Gere imagens com base no comando gerado na interface.
O que você vai aprender
- Como usar o aprendizado sem disparos e o aprendizado few-shot de forma programática com o modelo text-bison para gerar comandos específicos do Imagen para geração de imagens.
- Como gerar imagens usando o modelo do Imagen por API e comando.
- Como criar, implantar e testar um aplicativo do Gradio em um notebook do Vertex AI Workbench.
O que é necessário
- Acesso a um projeto do GCP, por exemplo, "Cloud-llm-preview4".
- Acesso para criar o Vertex AI Workbench
- A API Vertex AI está ativada.
- Requisitos de rede para o Gradio: URL público de acesso à instância de notebook
2. Etapas da configuração
Criar o notebook
- Fazer login no projeto
- Acesse o workbench no menu de navegação à esquerda.
- Em NOTEBOOKS GERENCIADOS PELO USUÁRIO, crie um notebook com as opções padrão.
- Clique em ABRIR JUPYTERLAB quando a instância for provisionada.
Observação: pode levar alguns minutos para iniciar o notebook se ele estiver parado.
Buscar o código
Colocamos o arquivo de código aqui. É possível importar e executar esse notebook no seu ambiente no estado em que se encontra, exceto nos detalhes do projeto.
3. Executar o código
Instalar/importar as dependências e bibliotecas necessárias
- Instalar o app do Gradio
- Importe as APIs da Vertex AI para Text-Bison e geração de imagens.
- Importe todas as outras bibliotecas necessárias.
Geração de comandos usando o Text-Bison
Usa uma entrada do usuário que contém palavras-chave e/ou frases, ou seja, uma lista separada por vírgulas de palavras-chave ou frases que podem ser usadas para construir uma frase que descreve a imagem necessária a ser gerada.
Por exemplo: pessoa, assunto, plano de fundo, iluminação e outras descrições.
A função que gera o comando é fornecida da seguinte maneira:
def prompt_generation(persona,signal,theme, lighting, quality, extra_desc):
model = TextGenerationModel.from_pretrained("text-bison")
response_few_shot = model.predict(
few_shot_prompt,
**parameters
)
response_single_shot = model.predict(
prompt,
**parameters
)
Comandos de poucos disparos e sem disparos
O comando zero-shot é uma técnica de geração de texto em que o modelo não recebe contexto nem exemplos para gerar texto. Isso pode ser difícil, já que o modelo precisa confiar no próprio conhecimento para gerar um texto coerente e informativo.
No entanto, o comando zero-shot também pode ser muito criativo, já que o modelo não é limitado por exemplos preexistentes.
O comando few-shot é uma técnica de geração de texto em que o modelo recebe alguns exemplos para gerar texto. Isso pode ser mais fácil do que o comando zero-shot, já que o modelo tem algumas orientações sobre o que gerar. No entanto, os comandos few-shot também podem ser limitados, já que o modelo só consegue gerar texto semelhante aos exemplos que recebeu.
Confira abaixo o exemplo de código para os comandos de poucos disparos e sem disparos.
**# Comando de poucos disparos usado no código**
few_shot_prompt = f"""Você é especialista em escrever comandos para modelos de geração de imagens. Usando as frases e palavras-chave fornecidas, concatene-as e adicione alguns detalhes realistas para gerar um comando lógico e significativo que possa ser usado para geração de imagens.
input: people, gardening, house garden, colorful plants, Real, HD image, Photo.
output: A Photo of people gardening in a house garden landscape with few coloured flowering plants. Realistic FULL HD Images, Elegant and natural facial and eye features taken by professional photographer
input: plumber, faucet, kitchen, high quality, natural lighting, Photo
output: A Photo of a plumber fixing a faucet in the kitchen. High quality image with natural indoor lighting.
input: house and garden, halloween, warm lighting, high quality image, Sketch
output: A Sketch of Beautiful House and Garden with Halloween Decorations. Warm lighting, High Quality, 4K photograph taken by professional photographer from front.
input: nice living room, warm lighting,Professional Photographer from far, Photo
output: A photo of a Well designed Living Room. Warm lighting, High Quality, 4K photograph taken by Professional Photographer from far
input: {params_list_str}
output:
"""
# Comando zero-shot usado no código
prompt = f"""Você é especialista em escrever comandos para modelos de geração de imagens. Me ajude a escrever uma lista de comandos significativos para o modelo de geração de imagens, incluindo especificamente as palavras: "{params_list_str}". Não se esqueça de incluir essas palavras no comando e dar sentido a ele."""
Geração de imagens usando o Imagen
Usa um comando de entrada do usuário e um comando negativo(opcional) e os envia ao modelo (imagegeneration@002).
def image_generation_completion(input, negative_prompt):
input_prompt = input
model = ImageGenerationModel.from_pretrained("imagegeneration@002")
response = model.generate_images(
prompt=input_prompt,
number_of_images=4, #kept to static value of 4
negative_prompt=negative_prompt
)
O código a seguir é incluído para gerar imagens com base em uma entrada do usuário e um comando negativo. O código final usa o comando gerado pelo modelo text-bison.
from vertexai.preview.vision_models import ImageGenerationModel
def image_generation(input, negative_prompt):
input_prompt = input
model = ImageGenerationModel.from_pretrained("imagegeneration@002")
response = model.generate_images(
prompt=input_prompt,
number_of_images=4, #kept to static value of 4.. can be a max value of 8
negative_prompt=negative_prompt
)
images = response.images
return images
user_prompt = "Comando: uma jovem mostrando e vendendo uma árvore de Natal fresca e sem decoração de A bunch of trees. Iluminação fria, imagem de alta qualidade e detalhada tirada por um fotógrafo profissional de longe"
negative_prompt = "Rostos distorcidos e sem graça"
generated_images_list = image_generation(user_prompt,negative_prompt)
#mostrar uma das imagens geradas
generated_images_list[0].show()
Saída:
4. Implantar o app do Gradio
O Gradio é usado no front-end, em que os usuários podem inserir palavras-chave e gerar comandos estruturados. Esses comandos podem ser usados diretamente ou editados pelo usuário e inseridos no Imagen para gerar imagens de acordo com as entradas. O Gradio é uma biblioteca Python que pode ser usada para criar interfaces de usuário para modelos de machine learning. Para esse aplicativo, os blocos são usados para adicionar flexibilidade e fluxos de dados complexos. Os blocos oferecem gerenciamento de layout de aplicativos usando linhas e colunas:
with gr.Blocks() as demo:
#Prompt Generation Part
with gr.Row():
with gr.Column(scale=1):
Persona = gr.Textbox(label="Persona", info = "Customer segment such as Plumber, Electrician etc.")
with gr.Column(scale=1):
Signals = gr.Textbox(label="Signals", info = "Main content of banner such as Faucet, Lamp etc.")
with gr.Column(scale=1):
Theme = gr.Textbox(label="Theme", info = "Context of the banner such as Halloween, Kitchen etc.")
with gr.Row():
with gr.Column(scale=1):
photo_modifiers = gr.Textbox(label="Photography Modifiers", info = "Photography specific modifiers and parameters such as Lighting(Dramatic/Natural/Warm/Cold), Camera Proximity etc.")
with gr.Column(scale=1):
quality_modifiers = gr.Textbox(label="Image Quality Modifier", info = "Quality Modifiers like high-quality, beautiful, stylized. 4K, HDR, By a professional etc")
with gr.Column(scale=1):
other_desc = gr.Textbox(label="Any Other Description", info = "Other Descriptions for Image such as Style (Painting/Photo/Sketch), Bakground/Foreground Context")
with gr.Row():
btn = gr.Button("Submit")
with gr.Row():
returned_prompts = gr.Textbox(label="Result Prompts", interactive = True)
btn.click(fn=prompt_generation, inputs=[Persona, Signals,Theme, photo_modifiers, quality_modifiers, other_desc], outputs = returned_prompts)
Para processar as entradas e saídas do usuário, o Gradio oferece vários componentes, como imagem, vídeo, controle deslizante, menu suspenso, caixa de texto, rádio e outras opções. Esses componentes oferecem aos desenvolvedores flexibilidade e controle sobre como aceitar entradas dos usuários e enviá-las para o Test-bison, o Imagen ou qualquer outro modelo de ML.
Para este projeto, o aplicativo é criado usando Blocos para adicionar flexibilidade e complexidade.
os dados fluem para o aplicativo. Além dos blocos, vários componentes do Gradio são
usados, incluindo:
- Linhas, colunas para layouts adequados.
- Botão, caixa de texto, menu suspenso e controle deslizante para alcançar a funcionalidade necessária e a facilidade de uso
- Componente Imagem para mostrar resultados.
- Outros helpers, como EventData e update, para oferecer suporte a mudanças dinâmicas na interface.
Confira abaixo um snippet de código usado para gerar imagens com base em comandos positivos e negativos:
#Image Generation part
with gr.Row():
with gr.Column(scale=1):
image_prompt = gr.Textbox(label="Image Generation Prompt")
with gr.Accordion("Advanced options", open=False): #Let's hide the advanced options!
with gr.Row():
negative_prompt = gr.Textbox(label="Negative prompt", info = "Specify What not to Include in Image ex. Bad Quality Image")
with gr.Row():
with gr.Column(scale=1):
img_btn = gr.Button("Generate Images")
with gr.Row():
with gr.Column():
output_image_1 = gr.Image(label = "Result Image 1", visible = False)
with gr.Column():
output_image_2 = gr.Image(label = "Result Image 2", visible = False)
with gr.Row():
with gr.Column():
output_image_3 = gr.Image(label = "Result Image 3", visible = False)
with gr.Column():
output_image_4 = gr.Image(label = "Result Image 4", visible = False)
returned_prompts.select(populate_image_prompt, inputs = [returned_prompts], outputs = image_prompt)
img_btn.click(fn=image_generation_completion, inputs=[image_prompt,negative_prompt], outputs = [output_image_1,output_image_2,output_image_3,output_image_4])
Para executar e testar o aplicativo Gradio, basta digitar um comando de texto e clicar no botão "Gerar". O Imagen vai gerar uma imagem com base no seu comando. Você pode testar comandos diferentes para ver que tipos de imagens o Imagen pode gerar.
Confira abaixo a captura de tela da geração de comandos no app Gradio.
Confira abaixo a captura de tela da geração de imagens no app Gradio.
Alguns exemplos
Exemplo 1
[Imagem à esquerda] Comando (usando palavras-chave simples como comandos) : um casal de amigos andando de barco.
[Imagem à direita] Comando (usando comandos gerados pelo Text-Bison) : uma foto de dois jovens pescando em um barco cercado por árvores escuras na floresta. Os homens estão usando uma camisa e estão em um barco. Iluminação natural, alta qualidade, foto 4K tirada por um fotógrafo profissional.
Exemplo 2
[Imagem à esquerda] Comando ((Usando palavras-chave simples como comandos)) : uma árvore de Natal
[Imagem à direita] Comando (usando comandos gerados pelo Text-Bison) : Uma árvore de Natal em uma sala com uma lâmpada e móveis. A árvore é decorada com luzes e enfeites. Ele está perto de uma janela, e há uma parede visível ao fundo. Iluminação quente, alta qualidade, foto HDR tirada de longe por um fotógrafo profissional.
5. Limpeza
Para limpar seus recursos,
- Pare o app do Gradio.
- Pare/exclua o notebook do Workbench.
6. Parabéns
Parabéns! Você implantou um aplicativo Gradio para criar comandos e imagens com a API Google Text-Bison e a API Imagen.