1. Introdução
Última atualização:12/10/2023
Geração de imagens do Imagegen
O Google Imagen é um poderoso modelo de linguagem grande do Google que pode gerar imagens realistas e criativas a partir de 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 deles em recursos visuais de alta qualidade em segundos. Além da geração de imagens a partir de texto, o recurso também oferece suporte à edição de imagens por comandos de texto, legendagem de imagens, perguntas e respostas visuais e assunto e Ajuste de modelos de imagem com base em 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 usa para gerar uma imagem. No entanto, para gerar uma imagem fotorrealista de alta qualidade, é necessário ter experiência na criação de prompts. 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, manufatura etc. Uma abordagem mais fácil para criar um comando é fornecer um conjunto de palavras-chave ao modelo Text Bison.
A abordagem geral é:
interface do GRadio
O GRadio é uma biblioteca de Python de código aberto que permite criar rapidamente componentes de IU personalizáveis e fáceis de usar para seu modelo de machine learning, qualquer API ou até mesmo uma função arbitrária do Python usando algumas linhas de código. É possível integrar a GUI do GRadio diretamente ao seu notebook Jupyter ou compartilhá-la como um link com qualquer pessoa. O gRadio oferece suporte a diversos tipos de mídia, incluindo texto, imagens, vídeos e áudio. Ele também fornece vários componentes de IU 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 GRadio que:
- Gere um comando de texto usando palavras-chave ou frases. O comando gerado também pode ser editado manualmente.
- Gerar imagens com base no comando gerado na interface.
O que você vai aprender
- Como usar o aprendizado zero-shot e few-shot com o modelo text-bison de maneira programática para gerar comandos específicos de imagem para geração de imagens.
- Como gerar imagens usando o modelo do Imagen por meio de API e prompt.
- Como criar, implantar e testar o aplicativo GRadio usando o 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úblico de acesso à instância do notebook
2. Etapas da configuração
Criar o notebook
- Fazer 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. depois que a instância for provisionada.
Observação: pode levar alguns minutos para iniciar o notebook se ele estiver em estado interrompido.
Buscar o código
Colocamos o arquivo de código aqui. Este notebook pode ser importado para seu ambiente e executado no estado em que se encontra (exceto para alterar os detalhes do projeto).
3. Executar o código
Instalar/importar as dependências e bibliotecas necessárias
- Instalar o app 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 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 criar uma sentença descrevendo a imagem necessária a ser gerada.
Por exemplo: persona, assunto, plano de fundo, iluminação e outras descrições.
A função que gera o comando é apresentada em:
Ⰳdef prompt_generation(persona,signal,theme, iluminação, qualidade, 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 few-shot e zero-shot
Os comandos zero-shot são uma técnica de geração de texto em que o modelo não recebe contexto ou exemplos para gerar texto. Isso pode ser um desafio, já que o modelo precisa confiar no próprio conhecimento para gerar um texto coerente e informativo.
No entanto, os comandos zero-shot também podem ser muito criativos, já que o modelo não é limitado por nenhum exemplo preexistente.
Os comandos few-shot são 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 os comandos zero-shot, porque o modelo tem orientações sobre o que gerar. No entanto, os comandos few-shot também podem ser limitantes, já que o modelo só é capaz de gerar textos semelhantes aos exemplos fornecidos.
Confira abaixo o exemplo de código para os comandos Few-Shot e Zero-shot.
鰃**# Algumas ações de sequência foram usadas no código**
few_shot_prompt = f"""Você é especialista em escrever comandos para modelos de geração de imagens. Use as frases e palavras-chave fornecidas para concatená-las e adicionar detalhes realistas para gerar comandos lógicos e relevantes que podem ser usados na 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. Quero ajuda para escrever uma lista de comandos significativos para o modelo de geração de imagens, incluindo especificamente as palavras: "{params_list_str}". Lembre-se de incluir essas palavras no comando e fazer com que ele seja significativo."""
Geração de imagens usando o Imagen
Usa um comando de entrada do usuário e um comando negativo(opcional) e alimenta o mesmo modelo da mesma forma (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 importar 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 mulher mostrando e vendendo uma árvore de Natal doce em um monte de árvores. Iluminação fria, alta qualidade e imagens detalhadas tiradas por fotógrafos profissionais de longe."
negative_prompt = "Rostos distorcidos e pouco atrativos"
generate_images_list = image_generation(user_prompt,negative_prompt)
#show uma das imagens geradas
generated_images_list[0].show()
Saída -
4. Implantar o app GRadio
O gcloud é usado para 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 depois inseridos no Imagen para gerar imagens de acordo com as entradas. O gRadio é uma biblioteca do Python que pode ser usada para criar interfaces do usuário para modelos de machine learning. Neste aplicativo, os blocos são usados para adicionar flexibilidade e fluxos de dados complexos. O Blocks oferece gerenciamento de layout do aplicativo usando linhas e colunas:
temporada com gr.Blocks() como demonstração:
#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")
com gr.Row():
btn = gr.Button("Submit")
com gr.Row():
returned_prompts = gr.Textbox(label="Result Prompts", interactive = True)
btn.click(fn=prompt_generation, input=[Persona, Signals,Theme, photo_modifiers, quality_modifiers, other_desc], outputs = return_prompts)
Para gerenciar 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 dão aos desenvolvedores flexibilidade e controle sobre como aceitar entradas dos usuários e alimentá-las ao Test-bison, imagen ou qualquer outro modelo de ML.
Neste projeto, o aplicativo é criado usando blocos para adicionar flexibilidade e
fluxos de dados para o aplicativo. Além dos blocos, vários componentes do GRadio são
usado, incluindo:
- Linhas e colunas para layouts adequados.
- Botão, Caixa de texto, Lista suspensa e Controle deslizante para alcançar a funcionalidade necessária e facilidade de uso
- Imagem para exibir resultados.
- Outros auxiliares, como EventData, 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 entradas e comandos negativos:
ᰃ #Parte de geração de imagem
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. Teste comandos diferentes para ver os tipos de imagem que 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): alguns amigos andando de barco.
[Imagem à direita] Prompt (usando comandos gerados por Text-Bison): uma foto de dois jovens pescando em um barco cercado por árvores escuras na floresta. Homens vestindo camisas e 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. Ele está posicionado perto de uma janela com uma parede visível ao fundo. Iluminação quente, alta qualidade, foto HDR fotografada por fotógrafo profissional tirada de longe.
5. Limpeza
Para limpar seus recursos,
- Interrompa o app GRadio.
- Parar/excluir o notebook do Workbench.
6. Parabéns
Parabéns! Você implantou um aplicativo GRadio para criar comandos e imagens com as APIs Text-Bison e Imagen do Google.