Os LLMs vão além da geração de texto. Também é possível gerar imagens a partir de descrições textuais. Ter imagens como uma modalidade pode ser extremamente útil em diversas áreas, como MedTech, arquitetura, turismo, desenvolvimento de jogos e muito mais. Neste capítulo, exploraremos os dois modelos de geração de imagens mais populares, DALL-E e Midjourney.
Nesta lição, abordaremos:
- Geração de imagens e por que ela é útil.
- DALL-E e Midjourney, o que são e como funcionam.
- Como construir um aplicativo de geração de imagens.
Após concluir esta lição, você será capaz de:
- Construir um aplicativo de geração de imagens.
- Definir limites para seu aplicativo com metaprompts.
- Trabalhar com DALL-E e Midjourney.
Aplicativos de geração de imagens são uma ótima maneira de explorar as capacidades da IA Generativa. Eles podem ser usados, por exemplo:
-
Edição e síntese de imagens. Você pode gerar imagens para diversos casos de uso, como edição e síntese de imagens.
-
Aplicação em diversos setores. Eles também podem ser usados para gerar imagens para diferentes indústrias, como MedTech, Turismo, Desenvolvimento de Jogos e mais.
Como parte desta lição, continuaremos trabalhando com nossa startup, Edu4All. Os alunos criarão imagens para suas avaliações; exatamente quais imagens serão criadas fica a critério dos alunos. Eles podem criar ilustrações para seu próprio conto de fadas, criar um novo personagem para sua história ou ajudá-los a visualizar suas ideias e conceitos.
Aqui está um exemplo do que os alunos da Edu4All poderiam gerar se estivessem trabalhando em sala de aula sobre monumentos:
usando um prompt como:
"Cachorro ao lado da Torre Eiffel ao amanhecer"
DALL-E e Midjourney são dois dos modelos de geração de imagens mais populares, permitindo que você use prompts para gerar imagens.
Vamos começar com o DALL-E, que é um modelo de IA Generativa que gera imagens a partir de descrições textuais.
DALL-E é uma combinação de dois modelos, CLIP e atenção difusa.
-
CLIP, é um modelo que gera embeddings, que são representações numéricas de dados, a partir de imagens e texto.
-
Atenção difusa, é um modelo que gera imagens a partir de embeddings. O DALL-E é treinado em um conjunto de dados de imagens e texto e pode ser usado para gerar imagens a partir de descrições textuais. Por exemplo, o DALL-E pode ser usado para gerar imagens de um gato com chapéu ou um cachorro com moicano.
O Midjourney funciona de maneira semelhante ao DALL-E, gerando imagens a partir de prompts textuais. O Midjourney também pode ser usado para gerar imagens com prompts como “um gato com chapéu” ou “um cachorro com moicano”.
Primeiro, DALL-E. O DALL-E é um modelo de IA Generativa baseado na arquitetura transformer com um transformer autoregressivo.
Um transformer autoregressivo define como um modelo gera imagens a partir de descrições textuais, gerando um pixel de cada vez e, em seguida, usando os pixels gerados para gerar o próximo pixel. Ele passa por várias camadas em uma rede neural até que a imagem esteja completa.
Com esse processo, o DALL-E controla atributos, objetos, características e mais na imagem que gera. No entanto, o DALL-E 2 e 3 têm mais controle sobre a imagem gerada.
Então, o que é necessário para construir um aplicativo de geração de imagens? Você precisará das seguintes bibliotecas:
- python-dotenv, é altamente recomendado usar esta biblioteca para manter seus segredos em um arquivo .env separado do código.
- openai, esta biblioteca será usada para interagir com a API da OpenAI.
- pillow, para trabalhar com imagens em Python.
- requests, para ajudar a fazer requisições HTTP.
Se ainda não foi feito, siga as instruções na página Microsoft Learn para criar um recurso e modelo Azure OpenAI. Selecione o modelo DALL-E 3.
-
Crie um arquivo .env com o seguinte conteúdo:
AZURE_OPENAI_ENDPOINT=<your endpoint> AZURE_OPENAI_API_KEY=<your key> AZURE_OPENAI_DEPLOYMENT="dall-e-3"Localize essas informações no Portal Azure OpenAI Foundry para seu recurso na seção "Implantações".
-
Colete as bibliotecas acima em um arquivo chamado requirements.txt assim:
python-dotenv openai pillow requests -
Em seguida, crie um ambiente virtual e instale as bibliotecas:
python3 -m venv venv source venv/bin/activate pip install -r requirements.txtPara Windows, use os seguintes comandos para criar e ativar seu ambiente virtual:
python3 -m venv venv venv\Scripts\activate.bat
-
Adicione o seguinte código em um arquivo chamado app.py:
import openai import os import requests from PIL import Image import dotenv from openai import OpenAI, AzureOpenAI # import dotenv dotenv.load_dotenv() # configure Azure OpenAI service client client = AzureOpenAI( azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"], api_key=os.environ['AZURE_OPENAI_API_KEY'], api_version = "2024-02-01" ) try: # Create an image by using the image generation API generation_response = client.images.generate( prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', size='1024x1024', n=1, model=os.environ['AZURE_OPENAI_DEPLOYMENT'] ) # Set the directory for the stored image image_dir = os.path.join(os.curdir, 'images') # If the directory doesn't exist, create it if not os.path.isdir(image_dir): os.mkdir(image_dir) # Initialize the image path (note the filetype should be png) image_path = os.path.join(image_dir, 'generated-image.png') # Retrieve the generated image image_url = generation_response.data[0].url # extract image URL from response generated_image = requests.get(image_url).content # download the image with open(image_path, "wb") as image_file: image_file.write(generated_image) # Display the image in the default image viewer image = Image.open(image_path) image.show() # catch exceptions except openai.InvalidRequestError as err: print(err)
Vamos explicar este código:
-
Primeiro, importamos as bibliotecas necessárias, incluindo a biblioteca OpenAI, a biblioteca dotenv, a biblioteca requests e a biblioteca Pillow.
import openai import os import requests from PIL import Image import dotenv
-
Em seguida, carregamos as variáveis de ambiente do arquivo .env.
# import dotenv dotenv.load_dotenv()
-
Depois disso, configuramos o cliente do serviço Azure OpenAI.
# Get endpoint and key from environment variables client = AzureOpenAI( azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"], api_key=os.environ['AZURE_OPENAI_API_KEY'], api_version = "2024-02-01" )
-
Em seguida, geramos a imagem:
# Create an image by using the image generation API generation_response = client.images.generate( prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', size='1024x1024', n=1, model=os.environ['AZURE_OPENAI_DEPLOYMENT'] )
O código acima responde com um objeto JSON que contém a URL da imagem gerada. Podemos usar a URL para baixar a imagem e salvá-la em um arquivo.
-
Por fim, abrimos a imagem e usamos o visualizador padrão de imagens para exibi-la:
image = Image.open(image_path) image.show()
Vamos analisar o código que gera a imagem em mais detalhes:
generation_response = client.images.generate(
prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils',
size='1024x1024', n=1,
model=os.environ['AZURE_OPENAI_DEPLOYMENT']
)- prompt, é o prompt textual usado para gerar a imagem. Neste caso, estamos usando o prompt "Coelho em um cavalo, segurando um pirulito, em um campo nebuloso onde crescem narcisos".
- size, é o tamanho da imagem gerada. Neste caso, estamos gerando uma imagem de 1024x1024 pixels.
- n, é o número de imagens geradas. Neste caso, estamos gerando duas imagens.
- temperature, é um parâmetro que controla a aleatoriedade do resultado de um modelo de IA Generativa. A temperatura é um valor entre 0 e 1, onde 0 significa que o resultado é determinístico e 1 significa que o resultado é aleatório. O valor padrão é 0.7.
Há mais coisas que você pode fazer com imagens, que abordaremos na próxima seção.
Você viu até agora como conseguimos gerar uma imagem com algumas linhas de código em Python. No entanto, há mais coisas que você pode fazer com imagens.
Você também pode fazer o seguinte:
- Realizar edições. Fornecendo uma imagem existente, uma máscara e um prompt, você pode alterar uma imagem. Por exemplo, você pode adicionar algo a uma parte da imagem. Imagine nossa imagem do coelho; você pode adicionar um chapéu ao coelho. Para fazer isso, basta fornecer a imagem, uma máscara (identificando a parte da área para a alteração) e um prompt textual para dizer o que deve ser feito.
Nota: isso não é suportado no DALL-E 3.
Aqui está um exemplo usando GPT Image:
response = client.images.edit(
model="gpt-image-1",
image=open("sunlit_lounge.png", "rb"),
mask=open("mask.png", "rb"),
prompt="A sunlit indoor lounge area with a pool containing a flamingo"
)
image_url = response.data[0].urlA imagem base conteria apenas o lounge com piscina, mas a imagem final teria um flamingo:
-
Criar variações. A ideia é que você pegue uma imagem existente e peça para que variações sejam criadas. Para criar uma variação, você fornece uma imagem e um prompt textual e um código como este:
response = openai.Image.create_variation( image=open("bunny-lollipop.png", "rb"), n=1, size="1024x1024" ) image_url = response['data'][0]['url']
Nota: isso só é suportado no OpenAI.
Temperatura é um parâmetro que controla a aleatoriedade do resultado de um modelo de IA Generativa. A temperatura é um valor entre 0 e 1, onde 0 significa que o resultado é determinístico e 1 significa que o resultado é aleatório. O valor padrão é 0.7.
Vamos ver um exemplo de como a temperatura funciona, executando este prompt duas vezes:
Prompt: "Coelho em um cavalo, segurando um pirulito, em um campo nebuloso onde crescem narcisos"
Agora vamos executar o mesmo prompt novamente para ver que não obteremos a mesma imagem duas vezes:
Como você pode ver, as imagens são semelhantes, mas não idênticas. Vamos tentar alterar o valor da temperatura para 0.1 e ver o que acontece:
generation_response = client.images.create(
prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here
size='1024x1024',
n=2
)Então, vamos tentar tornar a resposta mais determinística. Podemos observar nas duas imagens que geramos que na primeira imagem há um coelho e na segunda imagem há um cavalo, então as imagens variam bastante.
Portanto, vamos alterar nosso código e definir a temperatura como 0, assim:
generation_response = client.images.create(
prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here
size='1024x1024',
n=2,
temperature=0
)Agora, ao executar este código, você obtém estas duas imagens:
Aqui você pode ver claramente como as imagens se assemelham mais.
Com nosso demo, já podemos gerar imagens para nossos clientes. No entanto, precisamos criar alguns limites para nosso aplicativo.
Por exemplo, não queremos gerar imagens que não sejam adequadas para o trabalho ou que não sejam apropriadas para crianças.
Podemos fazer isso com metaprompts. Metaprompts são prompts textuais usados para controlar o resultado de um modelo de IA Generativa. Por exemplo, podemos usar metaprompts para controlar o resultado e garantir que as imagens geradas sejam adequadas para o trabalho ou apropriadas para crianças.
Agora, como os metaprompts funcionam?
Metaprompts são prompts textuais usados para controlar o resultado de um modelo de IA Generativa. Eles são posicionados antes do prompt textual e são usados para controlar o resultado do modelo, sendo incorporados em aplicativos para controlar o resultado do modelo. Eles encapsulam o input do prompt e o input do metaprompt em um único prompt textual.
Um exemplo de metaprompt seria o seguinte:
You are an assistant designer that creates images for children.
The image needs to be safe for work and appropriate for children.
The image needs to be in color.
The image needs to be in landscape orientation.
The image needs to be in a 16:9 aspect ratio.
Do not consider any input from the following that is not safe for work or appropriate for children.
(Input)
Agora, vamos ver como podemos usar metaprompts em nosso demo.
disallow_list = "swords, violence, blood, gore, nudity, sexual content, adult content, adult themes, adult language, adult humor, adult jokes, adult situations, adult"
meta_prompt =f"""You are an assistant designer that creates images for children.
The image needs to be safe for work and appropriate for children.
The image needs to be in color.
The image needs to be in landscape orientation.
The image needs to be in a 16:9 aspect ratio.
Do not consider any input from the following that is not safe for work or appropriate for children.
{disallow_list}
"""
prompt = f"{meta_prompt}
Create an image of a bunny on a horse, holding a lollipop"
# TODO add request to generate imageA partir do prompt acima, você pode ver como todas as imagens criadas consideram o metaprompt.
Apresentamos a Edu4All no início desta lição. Agora é hora de capacitar os alunos para gerar imagens para suas avaliações.
Os alunos criarão imagens para suas avaliações contendo monumentos; exatamente quais monumentos serão criados fica a critério dos alunos. Os alunos são incentivados a usar sua criatividade nesta tarefa para colocar esses monumentos em diferentes contextos.
Aqui está uma possível solução:
import openai
import os
import requests
from PIL import Image
import dotenv
from openai import AzureOpenAI
# import dotenv
dotenv.load_dotenv()
# Get endpoint and key from environment variables
client = AzureOpenAI(
azure_endpoint = os.environ["AZURE_OPENAI_ENDPOINT"],
api_key=os.environ['AZURE_OPENAI_API_KEY'],
api_version = "2024-02-01"
)
disallow_list = "swords, violence, blood, gore, nudity, sexual content, adult content, adult themes, adult language, adult humor, adult jokes, adult situations, adult"
meta_prompt = f"""You are an assistant designer that creates images for children.
The image needs to be safe for work and appropriate for children.
The image needs to be in color.
The image needs to be in landscape orientation.
The image needs to be in a 16:9 aspect ratio.
Do not consider any input from the following that is not safe for work or appropriate for children.
{disallow_list}
"""
prompt = f"""{meta_prompt}
Generate monument of the Arc of Triumph in Paris, France, in the evening light with a small child holding a Teddy looks on.
""""
try:
# Create an image by using the image generation API
generation_response = client.images.generate(
prompt=prompt, # Enter your prompt text here
size='1024x1024',
n=1,
)
# Set the directory for the stored image
image_dir = os.path.join(os.curdir, 'images')
# If the directory doesn't exist, create it
if not os.path.isdir(image_dir):
os.mkdir(image_dir)
# Initialize the image path (note the filetype should be png)
image_path = os.path.join(image_dir, 'generated-image.png')
# Retrieve the generated image
image_url = generation_response.data[0].url # extract image URL from response
generated_image = requests.get(image_url).content # download the image
with open(image_path, "wb") as image_file:
image_file.write(generated_image)
# Display the image in the default image viewer
image = Image.open(image_path)
image.show()
# catch exceptions
except openai.BadRequestError as err:
print(err)Após concluir esta lição, confira nossa coleção de aprendizado sobre IA generativa para continuar aprimorando seus conhecimentos sobre IA generativa!
Vá para a Lição 10, onde veremos como criar aplicações de IA com low-code
Aviso Legal:
Este documento foi traduzido usando o serviço de tradução por IA Co-op Translator. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.