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 várias áreas, como MedTech, arquitetura, turismo, desenvolvimento de jogos e muito mais. Neste capítulo, vamos explorar os dois modelos de geração de imagens mais populares: DALL-E e Midjourney.
Nesta lição, iremos abordar:
- Geração de imagens e por que é útil.
- DALL-E e Midjourney: o que são e como funcionam.
- Como construir uma aplicação de geração de imagens.
Após completar esta lição, será capaz de:
- Construir uma aplicação de geração de imagens.
- Definir limites para a sua aplicação com meta prompts.
- Trabalhar com DALL-E e Midjourney.
As aplicações de geração de imagens são uma excelente forma de explorar as capacidades da IA Generativa. Elas podem ser usadas, por exemplo:
-
Edição e síntese de imagens. Pode gerar imagens para diversos casos de uso, como edição e síntese de imagens.
-
Aplicação em várias indústrias. Também podem ser usadas para gerar imagens para diversas indústrias, como MedTech, Turismo, Desenvolvimento de Jogos e mais.
Como parte desta lição, continuaremos a trabalhar com a nossa startup, Edu4All. Os alunos irão criar imagens para os seus trabalhos, sendo que o tipo de imagens fica ao critério deles. Podem ser ilustrações para o seu próprio conto de fadas, criar um novo personagem para a sua história ou ajudá-los a visualizar as suas ideias e conceitos.
Aqui está um exemplo do que os alunos da Edu4All poderiam gerar se estivessem a trabalhar em aula sobre monumentos:
usando um prompt como:
"Cão ao lado da Torre Eiffel ao amanhecer"
DALL-E e Midjourney são dois dos modelos de geração de imagens mais populares, permitindo usar prompts para gerar imagens.
Comecemos pelo 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 num 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 um chapéu ou de um cão com um moicano.
O Midjourney funciona de forma 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 um chapéu" ou "um cão com um 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 usando os pixels gerados para gerar o próximo pixel. Passa por várias camadas numa rede neural até que a imagem esteja completa.
Com este 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 controlo sobre a imagem gerada.
Então, o que é necessário para construir uma aplicação de geração de imagens? Precisa das seguintes bibliotecas:
- python-dotenv, é altamente recomendado usar esta biblioteca para manter os seus segredos num ficheiro .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 pedidos HTTP.
Se ainda não o fez, 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 ficheiro .env com o seguinte conteúdo:
AZURE_OPENAI_ENDPOINT=<your endpoint> AZURE_OPENAI_API_KEY=<your key> AZURE_OPENAI_DEPLOYMENT="dall-e-3"Localize esta informação no Portal Azure OpenAI Foundry para o seu recurso na secção "Deployments".
-
Reúna as bibliotecas acima num ficheiro chamado requirements.txt da seguinte forma:
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 o seu ambiente virtual:
python3 -m venv venv venv\Scripts\activate.bat
-
Adicione o seguinte código num ficheiro 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 ficheiro .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" )
-
A seguir, 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 o URL da imagem gerada. Podemos usar o URL para descarregar a imagem e guardá-la num ficheiro.
-
Por fim, abrimos a imagem e usamos o visualizador de imagens padrão para exibi-la:
image = Image.open(image_path) image.show()
Vamos analisar o código que gera a imagem com mais detalhe:
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 a usar o prompt "Coelho a cavalo, segurando um chupa-chupa, num prado enevoado onde crescem narcisos".
- size, é o tamanho da imagem gerada. Neste caso, estamos a gerar uma imagem de 1024x1024 pixels.
- n, é o número de imagens geradas. Neste caso, estamos a gerar 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 pode fazer com imagens, que iremos abordar na próxima secção.
Até agora, vimos como conseguimos gerar uma imagem com algumas linhas de código em Python. No entanto, há mais coisas que pode fazer com imagens.
Também pode fazer o seguinte:
- Realizar edições. Ao fornecer uma imagem existente, uma máscara e um prompt, pode alterar uma imagem. Por exemplo, pode adicionar algo a uma parte de uma imagem. Imagine a nossa imagem do coelho, pode adicionar um chapéu ao coelho. Para isso, deve fornecer a imagem, uma máscara (identificando a parte da área para a alteração) e um prompt textual para indicar o que deve ser feito.
Nota: isto 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 é pegar numa imagem existente e pedir que sejam criadas variações. Para criar uma variação, deve fornecer uma imagem e um prompt textual e usar 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: isto só é suportado na OpenAI.
A 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 a cavalo, segurando um chupa-chupa, num prado enevoado onde crescem narcisos"
Agora vamos executar o mesmo prompt novamente para ver que não obtemos a mesma imagem duas vezes:
Como 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
)Vamos tentar tornar a resposta mais determinística. Podemos observar nas duas imagens que gerámos que na primeira imagem há um coelho e na segunda imagem há um cavalo, então as imagens variam bastante.
Vamos, portanto, alterar o nosso código e definir a temperatura para 0, como segue:
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, obtém estas duas imagens:
Aqui pode ver claramente como as imagens se assemelham mais.
Com o nosso exemplo, já conseguimos gerar imagens para os nossos clientes. No entanto, precisamos de criar alguns limites para a nossa aplicação.
Por exemplo, não queremos gerar imagens que não sejam apropriadas para o trabalho ou que não sejam adequadas 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 apropriadas para o trabalho ou adequadas para crianças.
Então, como funcionam os metaprompts?
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 aplicações para controlar o resultado do modelo. Encapsulam o input do prompt e o input do metaprompt num ú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 no nosso exemplo.
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, pode ver como todas as imagens criadas consideram o metaprompt.
Introduzimos a Edu4All no início desta lição. Agora é hora de capacitar os alunos para gerar imagens para os seus trabalhos.
Os alunos irão criar imagens para os seus trabalhos contendo monumentos, sendo que os monumentos específicos ficam ao critério dos alunos. Os alunos são incentivados a usar a 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)Depois de concluir esta lição, explore a nossa coleção de aprendizagem sobre IA generativa para continuar a aprofundar os seus conhecimentos sobre IA generativa!
Avance para a Lição 10, onde iremos explorar como criar aplicações de IA com low-code
Aviso:
Este documento foi traduzido utilizando o serviço de tradução por IA Co-op Translator. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se uma tradução profissional realizada por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.