As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
Amazon Titan Image Generator G1
O Titan Image Generator G1 modelo da Amazon suporta os seguintes parâmetros de inferência e respostas do modelo ao realizar a inferência do modelo.
Formato de solicitação e resposta
Ao fazer uma InvokeModelchamada usando a AmazonTitan Image Generator G1, substitua o body
campo da solicitação pelo formato que corresponda ao seu caso de uso. Todas as tarefas compartilham um objeto imageGenerationConfig
, mas cada tarefa tem um objeto de parâmetros específico da tarefa. Os casos de uso a seguir são compatíveis.
Tipo de tarefa |
Campo de parâmetros da tarefa |
Tipo de tarefa |
Definição |
TEXT_IMAGE |
textToImageParams |
Geração |
Gere uma imagem usando um prompt de texto.
|
INPAINTING |
inPaintingParams |
Como editar |
Modifique uma imagem alterando a parte interna de uma máscara para combinar com o fundo ao redor.
|
OUTPAINTING |
outPaintingParams |
Como editar |
Modifique uma imagem estendendo perfeitamente a região definida pela máscara. |
IMAGE_VARIATION |
imageVariationParams |
Como editar |
Modifique uma imagem produzindo variações da imagem original. |
As tarefas de edição exigem um campo image
na entrada. Esse campo consiste em uma string que define os pixels na imagem. Cada pixel é definido por três canais RGB, em que cada um varia de 0 a 255 (por exemplo, [255 255 0] representaria a cor amarela). Esses canais são codificados em base64.
As imagens usadas devem estar no formato JPEG ou PNG.
Se você realizar pintura embutida ou pintura externa, também definirá uma máscara, isto é, uma ou várias regiões que definem partes da imagem a serem modificadas. Você pode definir a máscara executando uma das ações a seguir.
-
maskPrompt
: escreva um prompt de texto para descrever a parte da imagem a ser mascarada.
-
maskImage
: insira uma string codificada em base64 que define as regiões mascaradas, marcando cada pixel na imagem de entrada como (0 0 0) ou (255 255 255).
Você pode usar uma ferramenta de edição de fotos para desenhar máscaras. Depois, você pode converter a imagem JPEG ou PNG de saída em codificação base64 para inserir nesse campo. Caso contrário, use o campo maskPrompt
para permitir que o modelo deduza a máscara.
Selecione uma guia para ver os corpos de solicitação de API para diferentes casos de uso de geração de imagens e as explicações dos campos.
- Text-to-image generation (Request)
-
Um prompt de texto para gerar a imagem deve ter <= 512 caracteres. Resoluções <= 1.408 no lado mais longo. I NegativeText (opcional) — Uma solicitação de texto para definir o que não incluir na imagem -- <= 512 caracteres. Consulte a tabela abaixo para obter uma lista completa das resoluções.
{
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"text": "string",
"negativeText": "string"
},
"imageGenerationConfig": {
"numberOfImages": int,
"height": int,
"width": int,
"cfgScale": float,
"seed": int
}
}
Os campos textToImageParams
são descritos abaixo.
- Inpainting (Request)
-
text (opcional): um prompt de texto para definir o que alterar dentro da máscara. Se você não incluir esse campo, o modelo tentará substituir toda a área da máscara pelo plano de fundo. Deve ter <= 512 caracteres. Texto negativo (opcional) — Uma solicitação de texto para definir o que não incluir na imagem. Deve ter <= 512 caracteres. Os limites de tamanho da imagem de entrada e da máscara de entrada são <= 1.408 no lado maior da imagem. O tamanho da saída é igual ao tamanho da entrada.
{
"taskType": "INPAINTING",
"inPaintingParams": {
"image": "base64-encoded string",
"text": "string",
"negativeText": "string",
"maskPrompt": "string",
"maskImage": "base64-encoded string",
},
"imageGenerationConfig": {
"numberOfImages": int,
"height": int,
"width": int,
"cfgScale": float
}
}
Os campos inPaintingParams
são descritos abaixo. A máscara define a parte da imagem que você deseja modificar.
-
image (obrigatório): a imagem JPEG ou PNG que deseja modificar, formatada como uma string que especifica uma sequência de pixels, cada um definido em valores RGB e codificado em base64. Para conferir exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem, consulte os exemplos de código.
-
Você deve especificar um dos campos a seguir (mas não ambos) para definir.
-
maskPrompt: um prompt de texto que define a máscara.
-
maskImage: uma string que define a máscara ao especificar uma sequência de pixels do mesmo tamanho que image
. Cada pixel é transformado em um valor RGB de (0 0 0) (um pixel dentro da máscara) ou (255 255 255) (um pixel fora da máscara). Para conferir exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem, consulte os exemplos de código.
-
text (opcional): um prompt de texto para definir o que alterar dentro da máscara. Se você não incluir esse campo, o modelo tentará substituir toda a área da máscara pelo plano de fundo.
-
negativeText (opcional): um prompt de texto para definir o que não incluir na imagem.
Não use palavras negativas no prompt negativeText
. Por exemplo, se você não quiser incluir espelhos em uma imagem, insira mirrors
no prompt negativeText
. Não insira no mirrors
.
- Outpainting (Request)
-
text (obrigatório): um prompt de texto para definir o que alterar fora da máscara. Deve ter <= 512 caracteres. Texto negativo (opcional) — Uma solicitação de texto para definir o que não incluir na imagem. Deve ter <= 512 caracteres. Os limites de tamanho da imagem de entrada e da máscara de entrada são <= 1.408 no lado maior da imagem. O tamanho da saída é igual ao tamanho da entrada.
{
"taskType": "OUTPAINTING",
"outPaintingParams": {
"text": "string",
"negativeText": "string",
"image": "base64-encoded string",
"maskPrompt": "string",
"maskImage": "base64-encoded string",
"outPaintingMode": "DEFAULT | PRECISE"
},
"imageGenerationConfig": {
"numberOfImages": int,
"height": int,
"width": int,
"cfgScale": float
}
}
Os campos outPaintingParams
estão definidos abaixo. A máscara define a área da imagem que você não deseja modificar. A geração estende perfeitamente a região que você define.
-
image (obrigatório): a imagem JPEG ou PNG que deseja modificar, formatada como uma string que especifica uma sequência de pixels, cada um definido em valores RGB e codificado em base64. Para conferir exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem, consulte os exemplos de código.
-
Você deve especificar um dos campos a seguir (mas não ambos) para definir.
-
maskPrompt: um prompt de texto que define a máscara.
-
maskImage: uma string que define a máscara ao especificar uma sequência de pixels do mesmo tamanho que image
. Cada pixel é transformado em um valor RGB de (0 0 0) (um pixel dentro da máscara) ou (255 255 255) (um pixel fora da máscara). Para conferir exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem, consulte os exemplos de código.
-
text (obrigatório): um prompt de texto para definir o que alterar fora da máscara.
-
negativeText (opcional): um prompt de texto para definir o que não incluir na imagem.
Não use palavras negativas no prompt negativeText
. Por exemplo, se você não quiser incluir espelhos em uma imagem, insira mirrors
no prompt negativeText
. Não insira no mirrors
.
-
out PaintingMode — Especifica se é permitido ou não a modificação dos pixels dentro da máscara. Os valores a seguir são possíveis.
-
DEFAULT: use essa opção para permitir a modificação da imagem dentro da máscara a fim de mantê-la consistente com o plano de fundo reconstruído.
-
PRECISE: use essa opção para impedir a modificação da imagem dentro da máscara.
- Image variation (Request)
-
A variação da imagem permite criar variações da imagem original com base nos valores dos parâmetros. O limite de tamanho para a imagem de entrada é <= 1.408 no lado maior da imagem. Consulte a tabela abaixo para obter uma lista completa das resoluções.
-
text (opcional): um prompt de texto que pode definir o que preservar e o que alterar na imagem. Deve ter <= 512 caracteres.
-
negativeText (opcional): um prompt de texto para definir o que não incluir na imagem. Deve ter <= 512 caracteres.
-
text (opcional): um prompt de texto que pode definir o que preservar e o que alterar na imagem. Deve ter <= 512 caracteres.
-
SimilarityStrength (opcional) — Especifica o quão semelhante a imagem gerada deve ser às imagens de entrada. Use um valor menor para introduzir mais aleatoriedade na geração. O intervalo aceito está entre 0,2 e 1,0 (ambos inclusive), enquanto um padrão de 0,7 é usado se esse parâmetro estiver ausente na solicitação.
{
"taskType": "IMAGE_VARIATION",
"imageVariationParams": {
"text": "string",
"negativeText": "string",
"images": ["base64-encoded string"],
"similarityStrength": 0.7, # Range: 0.2 to 1.0
},
"imageGenerationConfig": {
"numberOfImages": int,
"height": int,
"width": int,
"cfgScale": float
}
}
Os campos imageVariationParams
estão definidos abaixo.
-
images (obrigatório): uma lista de imagens das quais deseja gerar variações. Você pode incluir de 1 a 5 imagens. Uma imagem é definida como uma string de imagem codificada em base64. Para conferir exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem, consulte os exemplos de código.
-
text (opcional): um prompt de texto que pode definir o que preservar e o que alterar na imagem.
-
SimilarityStrength (opcional) — Especifica a semelhança entre a imagem gerada e as imagens de entrada. Faixa de 0,2 a 1,0 com valores mais baixos usados para introduzir mais aleatoriedade.
-
negativeText (opcional): um prompt de texto para definir o que não incluir na imagem.
Não use palavras negativas no prompt negativeText
. Por exemplo, se você não quiser incluir espelhos em uma imagem, insira mirrors
no prompt negativeText
. Não insira no mirrors
.
- Response body
-
{
"images": [
"base64-encoded string",
...
],
"error": "string"
}
O corpo da resposta é um objeto de streaming que contém um dos campos a seguir.
-
images
: se a solicitação for bem-sucedida, ela retornará esse campo, uma lista de strings codificadas em base64 em que cada uma define uma imagem gerada. Cada imagem é formatada como uma string que especifica uma sequência de pixels, cada um definido em valores RGB e codificado em base64. Para conferir exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem, consulte os exemplos de código.
-
error
: se a solicitação violar a política de moderação de conteúdo em uma das situações a seguir, uma mensagem será retornada nesse campo.
-
Se o texto, a imagem ou a imagem de máscara de entrada for sinalizado pela política de moderação de conteúdo.
-
Se pelo menos uma imagem de saída for sinalizada pela política de moderação de conteúdo.
O imageGenerationConfig
compartilhado e opcional contém os campos a seguir. Se você não incluir esse objeto, as configurações padrão serão usadas.
-
número OfImages (opcional) — O número de imagens a serem geradas.
Mínimo |
Máximo |
Padrão |
1 |
5 |
1 |
-
cfgScale (opcional): especifica a intensidade com que a imagem gerada deve seguir o prompt. Use um valor menor para introduzir mais aleatoriedade na geração.
Mínimo |
Máximo |
Padrão |
1.1 |
10.0 |
8.0 |
-
Os parâmetros a seguir definem o tamanho que você deseja que a imagem de saída tenha. Para obter mais detalhes sobre preços por tamanho de imagem, consulte Preços do Amazon Bedrock.
Os tamanhos a seguir são permitidos.
Largura |
Altura |
Taxa de proporção |
Preço equivalente a |
1024 |
1024 |
1:1 |
1024x1024 |
768 |
768 |
1:1 |
512x512 |
512 |
512 |
1:1 |
512x512 |
768 |
1152 |
2:3 |
1024x1024 |
384 |
576 |
2:3 |
512x512 |
1152 |
768 |
3:2 |
1024x1024 |
576 |
384 |
3:2 |
512x512 |
768 |
1.280 |
3:5 |
1024x1024 |
384 |
640 |
3:5 |
512x512 |
1.280 |
768 |
5:3 |
1024x1024 |
640 |
384 |
5:3 |
512x512 |
896 |
1152 |
7:9 |
1024x1024 |
448 |
576 |
7:9 |
512x512 |
1152 |
896 |
9:7 |
1024x1024 |
576 |
448 |
9:7 |
512x512 |
768 |
1.408 |
6:11 |
1024x1024 |
384 |
704 |
6:11 |
512x512 |
1.408 |
768 |
11:6 |
1024x1024 |
704 |
384 |
11:6 |
512x512 |
640 |
1.408 |
5:11 |
1024x1024 |
320 |
704 |
5:11 |
512x512 |
1.408 |
640 |
11:5 |
1024x1024 |
704 |
320 |
11:5 |
512x512 |
1152 |
640 |
9:5 |
1024x1024 |
1173 |
640 |
16:9 |
1024x1024 |
-
seed (opcional): use para controlar e reproduzir resultados. Determina a configuração inicial de ruído. Use a mesma Próximo e as mesmas configurações de uma execução anterior para permitir que a inferência crie uma imagem semelhante.
Mínimo |
Máximo |
Padrão |
0 |
2.147.483.646 |
0 |
Exemplos de código
Os exemplos a seguir mostram como invocar o Titan Image Generator G1 modelo da Amazon com taxa de transferência sob demanda no SDK do Python. Selecione uma guia para ver um exemplo para cada caso de uso. Cada exemplo exibe a imagem no final.
- Text-to-image generation
-
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image from a text prompt with the Amazon Titan Image Generator G1 model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Titan Image Generator G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Titan Image Generator G1 model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Titan Image Generator G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Titan Image Generator G1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.titan-image-generator-v1'
prompt = """A photograph of a cup of coffee from the side."""
body = json.dumps({
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"text": prompt
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 1024,
"width": 1024,
"cfgScale": 8.0,
"seed": 0
}
})
try:
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.")
if __name__ == "__main__":
main()
- Inpainting
-
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use inpainting to generate an image from a source image with
the Amazon Titan Image Generator G1 model (on demand).
The example uses a mask prompt to specify the area to inpaint.
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Titan Image Generator G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Titan Image Generator G1 model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Titan Image Generator G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Titan Image Generator G1 example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.titan-image-generator-v1'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "INPAINTING",
"inPaintingParams": {
"text": "Modernize the windows of the house",
"negativeText": "bad quality, low res",
"image": input_image,
"maskPrompt": "windows"
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.")
if __name__ == "__main__":
main()
- Outpainting
-
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use outpainting to generate an image from a source image with
the Amazon Titan Image Generator G1 model (on demand).
The example uses a mask image to outpaint the original image.
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Titan Image Generator G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Titan Image Generator G1 model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Titan Image Generator G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Titan Image Generator G1 example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.titan-image-generator-v1'
# Read image and mask image from file and encode as base64 strings.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
with open("/path/to/mask_image", "rb") as mask_image_file:
input_mask_image = base64.b64encode(
mask_image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "OUTPAINTING",
"outPaintingParams": {
"text": "Draw a chocolate chip cookie",
"negativeText": "bad quality, low res",
"image": input_image,
"maskImage": input_mask_image,
"outPaintingMode": "DEFAULT"
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
}
)
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.")
if __name__ == "__main__":
main()
- Image variation
-
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image variation from a source image with the
Amazon Titan Image Generator G1 model (on demand).
"""
import base64
import io
import json
import logging
import boto3
from PIL import Image
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Titan Image Generator G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_image(model_id, body):
"""
Generate an image using Amazon Titan Image Generator G1 model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
image_bytes (bytes): The image generated by the model.
"""
logger.info(
"Generating image with Amazon Titan Image Generator G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get("body").read())
base64_image = response_body.get("images")[0]
base64_bytes = base64_image.encode('ascii')
image_bytes = base64.b64decode(base64_bytes)
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Image generation error. Error is {finish_reason}")
logger.info(
"Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id)
return image_bytes
def main():
"""
Entrypoint for Amazon Titan Image Generator G1 example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.titan-image-generator-v1'
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
body = json.dumps({
"taskType": "IMAGE_VARIATION",
"imageVariationParams": {
"text": "Modernize the house, photo-realistic, 8k, hdr",
"negativeText": "bad quality, low resolution, cartoon",
"images": [input_image],
"similarityStrength": 0.7, # Range: 0.2 to 1.0
},
"imageGenerationConfig": {
"numberOfImages": 1,
"height": 512,
"width": 512,
"cfgScale": 8.0
}
})
image_bytes = generate_image(model_id=model_id,
body=body)
image = Image.open(io.BytesIO(image_bytes))
image.show()
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.")
if __name__ == "__main__":
main()