1. Introdução
Última atualização:12/10/2023
Geração de imagens com o Imagen
O Google Imagen é um modelo de linguagem grande e poderoso do Google que pode gerar imagens realistas e criativas com base em descrições de texto. O Imagen na Vertex AI permite que os usuários criem 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 por comandos de texto, legendas de imagens, perguntas e respostas visuais e ajuste de modelos de imagens com base em temas e estilos.
Geração de comandos
Para criar uma imagem usando o Imagen, é necessário fornecer uma descrição de texto da imagem, conhecida como comando, que será usada para gerar uma imagem. No entanto, para gerar uma imagem fotorrealista de alta qualidade, é necessário ter experiência em comandos. Também pode ser dependente do domínio se você quiser gerar uma imagem relacionada a domínios de negócios específicos, como varejo, fabricação 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
O Gradio é uma biblioteca Python de código aberto que permite criar rapidamente componentes de interface personalizáveis e fáceis de usar 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. É possível integrar a GUI do Gradio diretamente ao notebook do Jupyter ou compartilhá-la 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:
- 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 zero-shot e aprendizado few-shot com o modelo Text Bison de maneira programática para gerar comandos específicos do Imagen para geração de imagens.
- Como gerar imagens usando o modelo do Imagen pela API e pelo comando.
- Como criar, implantar e testar o aplicativo do Gradio no 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.
- API Vertex AI ativada.
- Requisitos de rede para o Gradio: URL pública de acesso à instância do notebook.
2. Etapas da configuração
Criar o notebook
- Faça login no projeto.
- Navegue até o Workbench no menu de navegação à esquerda.
- Em "NOTEBOOKS GERENCIADOS PELO USUÁRIO", crie um novo notebook com as opções padrão.
- Clique em "ABRIR O 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. Esse notebook pode ser importado no seu ambiente e executado no estado em que se encontra (exceto para mudar os detalhes do projeto).
3. Executar o código
Instalar/importar as dependências e bibliotecas necessárias
- Instale o app do Gradio.
- Importe as APIs 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 a ser gerada.
Por exemplo: persona, assunto, plano de fundo, iluminação e outras descrições.
A função que gera o comando é fornecida abaixo:
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
)
Comando zero-shot e few-shot
O comando zero-shot é uma técnica de geração de texto em que o modelo não recebe contexto ou exemplos para gerar texto. Isso pode ser desafiador, 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 pré-existentes.
O comando de poucos disparos (few-shot) é uma técnica de geração de texto em que o modelo recebe um pequeno número de 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, o comando few-shot também pode ser limitador, já que o modelo só pode gerar texto semelhante aos exemplos fornecidos.
Confira abaixo o exemplo de código para os comandos zero-shot e few-shot.
**# Comando few-shot usado no código**
few_shot_prompt = f"""You are an expert in writing prompts for Image Generation Models. Using the provided phrases and keywords, concatenate them and add on some realistic details to generate logical and Meaningful prompt that can be used for image generation.
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"""You are an expert in writing prompts for Image Generation Models. Me ajude a escrever uma lista de comandos significativos para o Modelo de Geração de Imagem, incluindo especificamente as palavras: "{params_list_str}". Remember to include these words in the prompt and make the prompt meaningful."""
Geração de imagens usando o Imagen
Usa um comando de entrada do usuário e um comando negativo(opcional) e os transmite 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 um comando de 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 = "Prompt: A Young Woman Showcasing and selling an undecorated Fresh Christmas Tree from A bunch of trees. Cold Lighting, High Quality and detailed Image Taken By Professional Photographer from far."
negative_prompt = "Distorted and unattractive faces"
generated_images_list = image_generation(user_prompt,negative_prompt)
#show one of the generated image
generated_images_list[0].show()
Saída -
4. Implantar o app do Gradio
O Gradio é usado para o front-end, em que os usuários podem inserir as palavras-chave e gerar comandos estruturados. Esses comandos podem ser usados diretamente ou editados pelo usuário e transmitidos ao 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 aprendizado de máquina. Para esse aplicativo, os blocos são usados para adicionar flexibilidade e fluxos de dados complexos. Os blocos fornecem 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, botão de opção e outras opções. Esses componentes oferecem aos desenvolvedores flexibilidade e controle sobre como aceitar entradas dos usuários e transmiti-las ao Text Bison, ao Imagen ou a qualquer outro modelo de ML.
Para esse projeto, o aplicativo é criado usando blocos para adicionar flexibilidade e complexidade
fluxos de dados para o aplicativo. Além dos blocos, vários componentes do Gradio são
usados, incluindo:
- Linhas e 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 de imagem para mostrar os resultados.
- Outros auxiliares, como EventData, atualização 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 de entrada 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 do 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 do Gradio.
Confira abaixo a captura de tela da geração de imagens no app do Gradio.
Alguns exemplos :
Exemplo 1 :
[Imagem à esquerda] Comando (usando palavras-chave simples como comandos) : Um casal de amigos navegando.
[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 fotografada 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. Ela é colocada perto de uma janela, e há uma parede visível ao fundo. Iluminação quente, alta qualidade, foto HDR fotografada por um fotógrafo profissional de longe.
5. Limpeza
Para liberar espaço nos seus recursos,
- Pare o app do Gradio.
- Pare/exclua o notebook do Workbench.
6. Parabéns
Parabéns! Você implantou um aplicativo do Gradio para criar comandos e imagens com a API Text Bison do Google e a API Imagen.