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á.

# Modelos G1 do Gerador de Imagens do Amazon Titan
<a name="model-parameters-titan-image"></a>

Os modelos Amazon Titan Image Generator G1 V1 e Titan Image Generator G1 V2 aceitam os parâmetros de inferência e respostas de modelo a seguir ao realizar uma inferência do modelo.

**Topics**
+ [Parâmetros de inferência](#model-parameters-titan-image-api)
+ [Exemplos](#model-parameters-titan-image-code-examples)

## Parâmetros de inferência
<a name="model-parameters-titan-image-api"></a>

Ao fazer uma chamada [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) usando modelos do Gerador de Imagens do Amazon Titan, substitua o campo `body` da solicitação pelo formato correspondente ao 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. | 
| TEXT\_IMAGE | textToImageParams | Geração | (Condicionamento de imagem, somente no v2) Forneça uma imagem de condicionamento de entrada adicional com um prompt de texto para gerar uma imagem que siga o layout e a composição da imagem de condicionamento.  | 
| 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. | 
| COLOR\_GUIDED\_GENERATION (V2 only) | colorGuidedGenerationParams | Geração | Forneça uma lista de códigos de cores hexadecimais com um prompt de texto para gerar uma imagem que siga a paleta de cores. | 
| BACKGROUND\_REMOVAL (V2 only) | backgroundRemovalParams | Como editar | Modifique uma imagem identificando vários objetos e removendo o plano de fundo, produzindo uma imagem com um plano de fundo transparente. | 

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ê utilizar o recurso preencher ou expandir imagem, 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 defina as regiões mascaradas, marcando cada pixel na imagem de entrada como (0 0 0) ou (255 255 255).
  + Um pixel definido como (0 0 0) é um pixel que está dentro da máscara.
  + Um pixel definido como (255 255 255) é um pixel que está fora da máscara.

  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. negativeText (opcional): um prompt de texto para definir o que não deve ser incluído na imagem, ou seja <= 512 caracteres. Consulte a tabela abaixo para obter uma lista completa das resoluções.

```
{
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "text": "string",      
        "negativeText": "string"
    },
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float,
        "seed": int
    }
}
```

Os campos `textToImageParams` são descritos abaixo.
+ **text** (obrigatório): um prompt de texto para gerar a imagem.
+ **negativeText** (opcional): um prompt de texto para definir o que não incluir na imagem.
**nota**  
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**.

------
#### [ 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 ser <= 512 caracteres. negativeText (opcional): um prompt de texto para definir o que não incluir na imagem. Deve ser <= 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",   
        "returnMask": boolean # False by default                
    },                                                 
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "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](#model-parameters-titan-image-code-examples).
+ 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](#model-parameters-titan-image-code-examples).
+ **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.
**nota**  
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 ser <= 512 caracteres. negativeText (opcional): um prompt de texto para definir o que não incluir na imagem. Deve ser <= 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",    
        "returnMask": boolean, # False by default                                         
        "outPaintingMode": "DEFAULT | PRECISE"                 
    },                                                 
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float
    }
}
```

Os campos `outPaintingParams` estão definidos abaixo. A *máscara* define a área na imagem que você não deseja modificar. A geração estende perfeitamente a área 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](#model-parameters-titan-image-code-examples).
+ 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](#model-parameters-titan-image-code-examples).
+ **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.
**nota**  
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**.
+ **outPaintingMode**: especifica se é permitida 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 de parâmetro. O limite de tamanho da 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 ser <= 512 caracteres.
+ negativeText (opcional): um prompt de texto para definir o que não incluir na imagem. Deve ser <= 512 caracteres.
+ text (opcional): um prompt de texto que pode definir o que preservar e o que alterar na imagem. Deve ser <= 512 caracteres.
+ similarityStrength (opcional): especifica a semelhança que a imagem gerada deve ter em relação a uma ou mais imagens de entrada. Use um valor menor para aumentar a randomização na geração. O intervalo aceito está entre 0,2 e 1,0 (ambos inclusive), e um padrão de 0,7 será usado se esse parâmetro não for encontrado 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": {
         "quality": "standard" | "premium",
         "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 obter 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](#model-parameters-titan-image-code-examples).
+ **text** (opcional): um prompt de texto que pode definir o que preservar e o que alterar na imagem.
+ **similarityStrength** (opcional): especifica que a semelhança que a imagem gerada deve ter em relação a uma ou mais imagens de entrada. Faixa de 0,2 a 1,0 com valores mais baixos usados para introduzir mais randomização.
+ **negativeText** (opcional): um prompt de texto para definir o que não incluir na imagem.
**nota**  
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**.

------
#### [ Conditioned Image Generation (Request) V2 only ]

O tipo de tarefa da geração de imagens condicionada permite aos clientes aumentar a geração de texto em imagem fornecendo uma “imagem condicional” para obter um controle mais refinado sobre a imagem gerada resultante.
+ Detecção atenta de borda
+ Mapa de segmentação

O prompt de texto para gerar a imagem deve ser <= 512 caracteres. Resoluções <= 1.408 no lado mais longo. negativeText (opcional) é um prompt de texto para definir o que não deve ser incluído na imagem e ser <= 512 caracteres. Consulte a tabela abaixo para obter uma lista completa das resoluções.

```
{
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "text": "string",      
        "negativeText": "string",
        "conditionImage": "base64-encoded string", # [OPTIONAL] base64 encoded image
        "controlMode": "string", # [OPTIONAL] CANNY_EDGE | SEGMENTATION. DEFAULT: CANNY_EDGE
        "controlStrength": float # [OPTIONAL] weight given to the condition image. DEFAULT: 0.7
    },
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float,
        "seed": int
    }
}
```
+ **text** (obrigatório): um prompt de texto para gerar a imagem.
+ **negativeText** (opcional): um prompt de texto para definir o que não incluir na imagem.
**nota**  
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**.
+ **conditionImage** (opcional, somente v2): uma única imagem de condicionamento de entrada que orienta o layout e a composição da imagem gerada. Uma imagem é definida como uma string de imagem codificada em base64. Para exemplos de como codificar uma imagem em base64 e decodificar uma string codificada em base64 e transformá-la em uma imagem.
+ **controlMode** (opcional, somente v2): especifica que tipo de modo de condicionamento deve ser usado. Dois tipos de modo de condicionamento são compatíveis: CANNY\_EDGE e SEGMENTATION. O valor padrão é CANNY\_EDGE.
+ **controlStrength** (opcional, somente v2): especifica a semelhança que o layout e a composição da imagem gerada devem ter com conditioningImage. Faixa de 0 a 1,0 com valores mais baixos usados para introduzir mais randomização. O valor padrão é 0,7.

**nota**  
Se controlMode ou controlStrength forem fornecidos, conditionImage também deverá ser fornecido.

------
#### [ Color Guided Content (Request) V2 only ]

Forneça uma lista de códigos de cores hexadecimais com um prompt de texto para gerar uma imagem que siga a paleta de cores. Um prompt de texto necessário para gerar a imagem deve ter <= 512 caracteres. O máximo de resoluções é de 1.408 no lado mais longo. É necessária uma lista de 1 a 10 códigos de cores hexadecimais para especificar as cores na imagem gerada, negativeText Um prompt de texto A opcional para definir o que não incluir na imagem <= 512 caracteres referenceImage opcional uma imagem de referência adicional para orientar a paleta de cores na imagem gerada. O limite de tamanho para imagem de referência RGB enviada pelo usuário é <= 1.408 no lado mais longo. 

```
{
    "taskType": "COLOR_GUIDED_GENERATION",
    "colorGuidedGenerationParams": {
        "text": "string",      
        "negativeText": "string",
        "referenceImage" "base64-encoded string", # [OPTIONAL]
        "colors": ["string"] # list of color hex codes
    },
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float,
        "seed": int
    }
}
```

Os campos colorGuidedGenerationParams estão descritos abaixo. Este parâmetro é somente para v2.
+ **text** (obrigatório): um prompt de texto para gerar a imagem.
+ **colors** (obrigatório): uma lista de até dez códigos de cores hexadecimais para especificar cores na imagem gerada.
+ **negativeText** (opcional): um prompt de texto para definir o que não incluir na imagem.
**nota**  
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**.
+ **referenceImage** (opcional): uma única imagem de referência de entrada que orienta a paleta de cores da imagem gerada. Uma imagem é definida como uma string de imagem codificada em base64.

------
#### [ Background Removal (Request) ]

O tipo de tarefa da remoção do plano de fundo identifica automaticamente vários objetos na imagem de entrada e remove o plano de fundo. A imagem de saída tem um plano de fundo transparente. 

**Formato de solicitação**

```
{
    "taskType": "BACKGROUND_REMOVAL",
    "backgroundRemovalParams": {
        "image": "base64-encoded string"
    }
}
```

**Formato de resposta**

```
{
  "images": [
    "base64-encoded string", 
    ...
  ],
  "error": "string" 
}
```

O campo backgroundRemovalParams está descrito abaixo.
+ **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.

------
#### [ 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](#model-parameters-titan-image-code-examples).
+ `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.
+ **quality**: a qualidade da imagem. O valor padrão é `standard`. Para obter detalhes de preço, consulte [Preços do Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
+ **numberOfImages** (opcional): o número de imagens a serem geradas.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-image.html)
+ **cfgScale** (opcional): especifica a intensidade com que a imagem gerada deve seguir o prompt. Use um valor menor para aumentar a randomização na geração.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-image.html)
+ 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](https://aws.amazon.com/bedrock/pricing/).
  + **height** (opcional): a altura da imagem em pixels. O valor padrão é 1.408.
  + **width** (opcional): a largura da imagem em pixels. O valor padrão é 1.408.

  Os tamanhos a seguir são permitidos.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-image.html)
+ **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.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-image.html)

## Exemplos
<a name="model-parameters-titan-image-code-examples"></a>

Os exemplos a seguir mostram como invocar os modelos do Gerador de Imagens do Amazon Titan com throughput sob demanda no SDK para 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()
```

------
#### [ Image conditioning (V2 only) ]

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image conditioning from a source image with the
Amazon Titan Image Generator G1 V2 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 V2"

    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 V2 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 V2 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 V2 model %s", model_id)

    return image_bytes


def main():
    """
    Entrypoint for Amazon Titan Image Generator V2 example.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        model_id = 'amazon.titan-image-generator-v2:0'

        # 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": "TEXT_IMAGE",
            "textToImageParams": {
                "text": "A robot playing soccer, anime cartoon style",
                "negativeText": "bad quality, low res",
                "conditionImage": input_image,
                "controlMode": "CANNY_EDGE"
            },
            "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 V2 model {model_id}.")


if __name__ == "__main__":
    main()
```

------
#### [ Color guided content (V2 only) ]

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image from a source image color palette with the
Amazon Titan Image Generator G1 V2 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 V2"

    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 V2 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 V2 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 V2 model %s", model_id)

    return image_bytes


def main():
    """
    Entrypoint for Amazon Titan Image Generator V2 example.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        model_id = 'amazon.titan-image-generator-v2:0'

        # 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": "COLOR_GUIDED_GENERATION",
            "colorGuidedGenerationParams": {
                "text": "digital painting of a girl, dreamy and ethereal, pink eyes, peaceful expression, ornate frilly dress, fantasy, intricate, elegant, rainbow bubbles, highly detailed, digital painting, artstation, concept art, smooth, sharp focus, illustration",
                "negativeText": "bad quality, low res",
                "referenceImage": input_image,
                "colors": ["#ff8080", "#ffb280", "#ffe680", "#ffe680"]
            },
            "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 V2 model {model_id}.")


if __name__ == "__main__":
    main()
```

------
#### [ Background removal (V2 only) ]

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image with background removal with the
Amazon Titan Image Generator G1 V2 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 V2"

    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 V2 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 V2 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 V2 model %s", model_id)

    return image_bytes


def main():
    """
    Entrypoint for Amazon Titan Image Generator V2 example.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        model_id = 'amazon.titan-image-generator-v2:0'

        # 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": "BACKGROUND_REMOVAL",
            "backgroundRemovalParams": {
                "image": input_image,
            }
        })

        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 V2 model {model_id}.")


if __name__ == "__main__":
    main()
```

------