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 do Amazon Titan
<a name="model-parameters-titan"></a>

Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos do Amazon Titan. Use essas informações para fazer chamadas de inferência a modelos do Amazon Titan com as operações [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Esta seção também inclui exemplos de código do Python que mostram como chamar modelos do Amazon Titan. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo Amazon Titan, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).

Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos do Amazon Titan, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar com quais recursos do Amazon Bedrock os modelos do Amazon Titan são compatíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais regiões da AWS os modelos do Amazon Titan estão disponíveis, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).

Ao fazer chamadas de inferência com modelos do Amazon Titan, inclua um prompt no modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). 

**Topics**
+ [Modelos Amazon Titan Text](model-parameters-titan-text.md)
+ [Modelos G1 do Gerador de Imagens do Amazon Titan](model-parameters-titan-image.md)
+ [Amazon Titan Embeddings G1 - Text](model-parameters-titan-embed-text.md)
+ [Amazon Titan Multimodal Embeddings G1](model-parameters-titan-embed-mm.md)

# Modelos Amazon Titan Text
<a name="model-parameters-titan-text"></a>

Os modelos Amazon Titan Text são compatíveis com os parâmetros de inferência a seguir.

Para obter mais informações sobre as diretrizes de engenharia de prompts do Titan Text, consulte o documento [Titan Text Prompt Engineering Guidelines](https://d2eo22ngex1n9g.cloudfront.net/Documentation/User+Guides/Titan/Amazon+Titan+Text+Prompt+Engineering+Guidelines.pdf). 

Para obter mais informações sobre modelos do Titan, consulte [Visão geral dos modelos do Amazon Titan](titan-models.md).

**Topics**
+ [Solicitação e reposta](#model-parameters-titan-request-response)
+ [Exemplos de código](#inference-titan-code)

## Solicitação e reposta
<a name="model-parameters-titan-request-response"></a>

O corpo da solicitação é enviado no campo `body` de uma solicitação [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).

------
#### [ Request ]

```
{
    "inputText": string,
    "textGenerationConfig": {
        "temperature": float,  
        "topP": float,
        "maxTokenCount": int,
        "stopSequences": [string]
    }
}
```

Os seguintes parâmetros são obrigatórios:
+ **inputText**: o prompt a ser fornecido ao modelo para gerar uma resposta. Para gerar respostas em um estilo conversacional, envie o prompt usando o seguinte formato:

  ```
  "inputText": "User: <theUserPrompt>\nBot:"
  ```

  Esse formato indica ao modelo que ele deve responder em uma nova linha depois que o usuário fornecer uma solicitação.

A `textGenerationConfig` é opcional. É possível usá-la para configurar os seguintes [parâmetros de inferência](inference-parameters.md):
+ **temperature**: use um valor menor para reduzir a randomização nas respostas.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **topP**: use um valor menor para ignorar opções menos prováveis e reduzir a diversidade de respostas.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **maxTokenCount**: especifique o número máximo de tokens a serem gerados na resposta. Os limites máximos de tokens são rigorosamente aplicados.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **stopSequences**: especifique uma sequência de caracteres para indicar onde o modelo deve parar.

------
#### [ InvokeModel Response ]

```
{
    "inputTextTokenCount": int,
    "results": [{
        "tokenCount": int,
        "outputText": "\n<response>\n",
        "completionReason": "string"
    }]
}
```

O corpo da resposta contém os seguintes campos:
+ **inputTextTokenCount**: o número de tokens no prompt.
+ **results**: uma matriz de um item, um objeto que contém os seguintes campos:
  + **tokenCount**: o número de tokens na resposta.
  + **outputText**: o texto na resposta.
  + **completionReason**: o motivo pelo qual a resposta terminou de ser gerada. Os seguintes motivos são possíveis:
    + FINISHED: a resposta foi totalmente gerada.
    + LENGTH: a resposta foi truncada devido ao tamanho da resposta que você definiu.
    + STOP\$1CRITERIA\$1MET: a resposta foi truncada porque o critério de parada foi atingido.
    + RAG\$1QUERY\$1WHEN\$1RAG\$1DISABLED: o recurso está desabilitado e não pode concluir a consulta.
    + CONTENT\$1FILTERED: o conteúdo foi filtrado ou removido pelo filtro de conteúdo aplicado.

------
#### [ InvokeModelWithResponseStream Response ]

Cada fragmento de texto no corpo do fluxo da resposta tem o formato a seguir. Você deve decodificar o campo `bytes` (consulte [Envie uma única solicitação com InvokeModel](inference-invoke.md) para obter um exemplo).

```
{
    "chunk": {
        "bytes": b'{
            "index": int,
            "inputTextTokenCount": int,
            "totalOutputTextTokenCount": int,
            "outputText": "<response-chunk>",
            "completionReason": "string"
        }'
    }
}
```
+ **index**: o índice do fragmento na resposta de streaming.
+ **inputTextTokenCount**: o número de tokens no prompt.
+ **totalOutputTextTokenCount**: o número de tokens na resposta.
+ **outputText**: o texto na resposta.
+ **completionReason**: o motivo pelo qual a resposta terminou de ser gerada. Os seguintes motivos são possíveis.
  + FINISHED: a resposta foi totalmente gerada.
  + LENGTH: a resposta foi truncada devido ao tamanho da resposta que você definiu.
  + STOP\$1CRITERIA\$1MET: a resposta foi truncada porque o critério de parada foi atingido.
  + RAG\$1QUERY\$1WHEN\$1RAG\$1DISABLED: o recurso está desabilitado e não pode concluir a consulta.
  + CONTENT\$1FILTERED: o conteúdo foi filtrado ou removido pelo filtro aplicado.

------

## Exemplos de código
<a name="inference-titan-code"></a>

O exemplo a seguir mostra como executar inferência com o modelo Amazon Titan Text Premier usando o SDK para Python.

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to create a list of action items from a meeting transcript
with the Amazon Titan Text model (on demand).
"""
import json
import logging
import boto3

from botocore.exceptions import ClientError


class ImageError(Exception):
    "Custom exception for errors returned by Amazon Titan Text models"

    def __init__(self, message):
        self.message = message


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text(model_id, body):
    """
    Generate text using Amazon Titan Text models on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (json): The response from the model.
    """

    logger.info(
        "Generating text with Amazon Titan Text 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())

    finish_reason = response_body.get("error")

    if finish_reason is not None:
        raise ImageError(f"Text generation error. Error is {finish_reason}")

    logger.info(
        "Successfully generated text with Amazon Titan Text model %s", model_id)

    return response_body


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

        # You can replace the model_id with any other Titan Text Models
        # Titan Text Model family model_id is as mentioned below:
        # amazon.titan-text-premier-v1:0, amazon.titan-text-express-v1, amazon.titan-text-lite-v1
        model_id = 'amazon.titan-text-premier-v1:0'

        prompt = """Meeting transcript: Miguel: Hi Brant, I want to discuss the workstream  
            for our new product launch Brant: Sure Miguel, is there anything in particular you want
            to discuss? Miguel: Yes, I want to talk about how users enter into the product.
            Brant: Ok, in that case let me add in Namita. Namita: Hey everyone 
            Brant: Hi Namita, Miguel wants to discuss how users enter into the product.
            Miguel: its too complicated and we should remove friction.  
            for example, why do I need to fill out additional forms?  
            I also find it difficult to find where to access the product
            when I first land on the landing page. Brant: I would also add that
            I think there are too many steps. Namita: Ok, I can work on the
            landing page to make the product more discoverable but brant
            can you work on the additonal forms? Brant: Yes but I would need 
            to work with James from another team as he needs to unblock the sign up workflow.
            Miguel can you document any other concerns so that I can discuss with James only once?
            Miguel: Sure.
            From the meeting transcript above, Create a list of action items for each person. """

        body = json.dumps({
            "inputText": prompt,
            "textGenerationConfig": {
                "maxTokenCount": 3072,
                "stopSequences": [],
                "temperature": 0.7,
                "topP": 0.9
            }
        })

        response_body = generate_text(model_id, body)
        print(f"Input token count: {response_body['inputTextTokenCount']}")

        for result in response_body['results']:
            print(f"Token count: {result['tokenCount']}")
            print(f"Output text: {result['outputText']}")
            print(f"Completion reason: {result['completionReason']}")

    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 text with the Amazon Titan Text Premier model {model_id}.")


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

O exemplo a seguir mostra como executar inferência com o modelo Amazon Titan Text G1 - Express usando o SDK para Python.

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to create a list of action items from a meeting transcript
with the Amazon &titan-text-express; model (on demand).
"""
import json
import logging
import boto3

from botocore.exceptions import ClientError


class ImageError(Exception):
    "Custom exception for errors returned by Amazon &titan-text-express; model"

    def __init__(self, message):
        self.message = message


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text(model_id, body):
    """
    Generate text using Amazon &titan-text-express; model on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (json): The response from the model.
    """

    logger.info(
        "Generating text with Amazon &titan-text-express; 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())

    finish_reason = response_body.get("error")

    if finish_reason is not None:
        raise ImageError(f"Text generation error. Error is {finish_reason}")

    logger.info(
        "Successfully generated text with Amazon &titan-text-express; model %s", model_id)

    return response_body


def main():
    """
    Entrypoint for Amazon &titan-text-express; example.
    """
    try:
        logging.basicConfig(level=logging.INFO,
                            format="%(levelname)s: %(message)s")

        model_id = 'amazon.titan-text-express-v1'

        prompt = """Meeting transcript: Miguel: Hi Brant, I want to discuss the workstream  
            for our new product launch Brant: Sure Miguel, is there anything in particular you want
            to discuss? Miguel: Yes, I want to talk about how users enter into the product.
            Brant: Ok, in that case let me add in Namita. Namita: Hey everyone 
            Brant: Hi Namita, Miguel wants to discuss how users enter into the product.
            Miguel: its too complicated and we should remove friction.  
            for example, why do I need to fill out additional forms?  
            I also find it difficult to find where to access the product
            when I first land on the landing page. Brant: I would also add that
            I think there are too many steps. Namita: Ok, I can work on the
            landing page to make the product more discoverable but brant
            can you work on the additonal forms? Brant: Yes but I would need 
            to work with James from another team as he needs to unblock the sign up workflow.
            Miguel can you document any other concerns so that I can discuss with James only once?
            Miguel: Sure.
            From the meeting transcript above, Create a list of action items for each person. """

        body = json.dumps({
            "inputText": prompt,
            "textGenerationConfig": {
                "maxTokenCount": 4096,
                "stopSequences": [],
                "temperature": 0,
                "topP": 1
            }
        })

        response_body = generate_text(model_id, body)
        print(f"Input token count: {response_body['inputTextTokenCount']}")

        for result in response_body['results']:
            print(f"Token count: {result['tokenCount']}")
            print(f"Output text: {result['outputText']}")
            print(f"Completion reason: {result['completionReason']}")

    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 text with the Amazon &titan-text-express; model {model_id}.")


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

# 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\$1IMAGE | textToImageParams | Geração |  Gere uma imagem usando um prompt de texto.  | 
| TEXT\$1IMAGE | 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\$1VARIATION | imageVariationParams | Como editar | Modifique uma imagem produzindo variações da imagem original. | 
| COLOR\$1GUIDED\$1GENERATION (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\$1REMOVAL (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\$1EDGE e SEGMENTATION. O valor padrão é CANNY\$1EDGE.
+ **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()
```

------

# Amazon Titan Embeddings G1 - Text
<a name="model-parameters-titan-embed-text"></a>

O Titan Embeddings G1 - Text não permite o uso de parâmetros de inferência. As seções a seguir detalham os formatos de solicitação e de resposta e fornecem um exemplo de código.

**Topics**
+ [Solicitação e reposta](#model-parameters-titan-embed-text-request-response)
+ [Código de exemplo](#api-inference-examples-titan-embed-text)

## Solicitação e reposta
<a name="model-parameters-titan-embed-text-request-response"></a>

O corpo da solicitação é enviado no campo `body` de uma solicitação [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). 

------
#### [ V2 Request ]

O parâmetro inputText é necessário. Os parâmetros de normalização e de dimensões são opcionais.
+ inputText: inserção do texto a ser convertido em incorporações.
+ normalize: (opcional) sinalizador que indica se as incorporações de saída devem ou não ser normalizadas. O valor padrão é verdadeiro.
+ dimensions: (opcional) o número de dimensões que as incorporações de saída devem ter. Os seguintes valores são aceitos: 1.024 (padrão), 512, 256.
+ embeddingTypes: (opcional) aceita uma lista contendo “float”, “binary” ou ambos. O padrão é `float`. 

```
{
    "inputText": string,
    "dimensions": int,
    "normalize": boolean,
    "embeddingTypes": list
}
```

------
#### [ V2 Response ]

Os campos são descritos abaixo.
+ embedding: uma matriz que representa o vetor de incorporação da entrada fornecida. O tipo sempre será `float`.
+ inputTextTokenCount: o número de tokens na entrada.
+ embeddingsByType: um dicionário ou mapa da lista de incorporação. Depende da entrada, listas “float”, “binary” ou ambas.
  + Exemplo: `"embeddingsByType": {"binary": [int,..], "float": [float,...]}`
  + Esse campo sempre aparecerá. Mesmo que você não especifique `embeddingTypes` na entrada, ainda haverá “float”. Exemplo: `"embeddingsByType": {"float": [float,...]}`

```
{
    "embedding": [float, float, ...],
    "inputTextTokenCount": int,
    "embeddingsByType": {"binary": [int,..], "float": [float,...]}
}
```

------
#### [ G1 Request ]

O único campo disponível é `inputText`, no qual você pode incluir texto para converter em uma incorporação.

```
{
    "inputText": string
}
```

------
#### [ G1 Response ]

O `body` da resposta contém os campos a seguir.

```
{
    "embedding": [float, float, ...],
    "inputTextTokenCount": int
}
```

Os campos são descritos abaixo.
+ **embedding**: uma matriz que representa o vetor de incorporação da entrada fornecida.
+ **inputTextTokenCount**: o número de tokens na entrada.

------

## Código de exemplo
<a name="api-inference-examples-titan-embed-text"></a>

Os exemplos a seguir mostram como chamar modelos de incorporação do Amazon Titan para gerar incorporação. Selecione a guia que corresponde ao modelo que você está usando:

------
#### [ Amazon Incorporador do Titan G1 - Text ]

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Embeddings G1 - Text model (on demand).
"""

import json
import logging
import boto3


from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_embedding(model_id, body):
    """
    Generate an embedding with the vector representation of a text input using Amazon Titan Embeddings G1 - Text on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embedding created by the model and the number of input tokens.
    """

    logger.info("Generating an embedding with Amazon Titan Embeddings G1 - Text 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())

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Embeddings G1 - Text example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "amazon.titan-embed-text-v1"
    input_text = "What are the different services that you offer?"


    # Create request body.
    body = json.dumps({
        "inputText": input_text,
    })


    try:

        response = generate_embedding(model_id, body)

        print(f"Generated an embedding: {response['embedding']}")
        print(f"Input Token count:  {response['inputTextTokenCount']}")

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))

    else:
        print(f"Finished generating an embedding with Amazon Titan Embeddings G1 - Text model {model_id}.")


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

------
#### [ Amazon Incorporador de Texto do Titan v2 ]

Ao usar o Titan Text Embeddings V2, o campo `embedding` não estará na resposta se o `embeddingTypes` contiver apenas `binary`. 

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model
"""

import json
import logging
import boto3


from botocore.exceptions import ClientError


logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_embedding(model_id, body):
    """
    Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embedding created by the model and the number of input tokens.
    """

    logger.info("Generating an embedding with Amazon Titan Text Embeddings 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())

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Embeddings V2 - Text example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "amazon.titan-embed-text-v2:0"
    input_text = "What are the different services that you offer?"


    # Create request body.
    body = json.dumps({
        "inputText": input_text,
        "embeddingTypes": ["binary"]
    })


    try:

        response = generate_embedding(model_id, body)

        print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
        print(f"Input text: {input_text}")
        print(f"Input Token count:  {response['inputTextTokenCount']}")

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))

    else:
        print(f"Finished generating an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")


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

------

# Amazon Titan Multimodal Embeddings G1
<a name="model-parameters-titan-embed-mm"></a>

Esta seção fornece formatos de corpo de solicitação e de resposta e exemplos de código para uso do Amazon Titan Multimodal Embeddings G1.

**Topics**
+ [Solicitação e reposta](#model-parameters-titan-embed-mm-request-response)
+ [Código de exemplo](#api-inference-examples-titan-embed-mm)

## Solicitação e reposta
<a name="model-parameters-titan-embed-mm-request-response"></a>

O corpo da solicitação é enviado no campo `body` de uma solicitação [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).

------
#### [ Request ]

O corpo da solicitação para o Amazon Titan Multimodal Embeddings G1 inclui os campos a seguir.

```
{
    "inputText": string,
    "inputImage": base64-encoded string,
    "embeddingConfig": {
        "outputEmbeddingLength": 256 | 384 | 1024
    }
}
```

Pelo menos um dos campos a seguir é obrigatório. Inclua os dois para gerar um vetor de incorporações que calcule a média dos vetores de incorporações de texto e de incorporações de imagens resultantes.
+ **inputText**: insira o texto a ser convertido em incorporações.
+ **inputImage**: codifique a imagem que deseja converter em incorporações em base64 e insira a string nesse campo. 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](#api-inference-examples-titan-embed-mm).

O campo a seguir é opcional.
+ **embeddingConfig**: contém um campo `outputEmbeddingLength`, no qual você especifica um dos tamanhos a seguir para o vetor de incorporações de saída.
  + 256
  + 384
  + 1.024 (padrão)

------
#### [ Response ]

O `body` da resposta contém os campos a seguir.

```
{
    "embedding": [float, float, ...],
    "inputTextTokenCount": int,
    "message": string
}
```

Os campos são descritos abaixo.
+ **embedding**: uma matriz que representa o vetor de incorporações da entrada fornecida.
+ **inputTextTokenCount**: o número de tokens na entrada de texto.
+ **message**: especifica quaisquer erros que ocorram durante a geração.

------

## Código de exemplo
<a name="api-inference-examples-titan-embed-mm"></a>

Os exemplos a seguir mostram como invocar o modelo Amazon Titan Multimodal Embeddings G1 com throughput sob demanda no SDK para Python. Selecione uma guia para visualizar um exemplo para cada caso de uso.

------
#### [ Text embeddings ]

Este exemplo mostra como chamar o modelo Amazon Titan Multimodal Embeddings G1 para gerar incorporações de texto.

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from text with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""

import json
import logging
import boto3


from botocore.exceptions import ClientError

class EmbedError(Exception):
    "Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"

    def __init__(self, message):
        self.message = message

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_embeddings(model_id, body):
    """
    Generate a vector of embeddings for a text input using Amazon Titan Multimodal Embeddings G1 on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embeddings that the model generated, token information, and the
        reason the model stopped generating embeddings.
    """

    logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings 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())

    finish_reason = response_body.get("message")

    if finish_reason is not None:
        raise EmbedError(f"Embeddings generation error: {finish_reason}")

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "amazon.titan-embed-image-v1"
    input_text = "What are the different services that you offer?"
    output_embedding_length = 256

    # Create request body.
    body = json.dumps({
        "inputText": input_text,
        "embeddingConfig": {
            "outputEmbeddingLength": output_embedding_length
        }
    })


    try:

        response = generate_embeddings(model_id, body)

        print(f"Generated text embeddings of length {output_embedding_length}: {response['embedding']}")
        print(f"Input text token count:  {response['inputTextTokenCount']}")

    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 EmbedError as err:
        logger.error(err.message)
        print(err.message)

    else:
        print(f"Finished generating text embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")


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

------
#### [ Image embeddings ]

Este exemplo mostra como chamar o modelo Amazon Titan Multimodal Embeddings G1 para gerar incorporações de imagem.

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from an image with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""

import base64
import json
import logging
import boto3

from botocore.exceptions import ClientError

class EmbedError(Exception):
    "Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"

    def __init__(self, message):
        self.message = message

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_embeddings(model_id, body):
    """
    Generate a vector of embeddings for an image input using Amazon Titan Multimodal Embeddings G1 on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embeddings that the model generated, token information, and the
        reason the model stopped generating embeddings.
    """

    logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings 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())

    finish_reason = response_body.get("message")

    if finish_reason is not None:
        raise EmbedError(f"Embeddings generation error: {finish_reason}")

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    # 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')

    model_id = 'amazon.titan-embed-image-v1'
    output_embedding_length = 256

    # Create request body.
    body = json.dumps({
        "inputImage": input_image,
        "embeddingConfig": {
            "outputEmbeddingLength": output_embedding_length
        }
    })


    try:

        response = generate_embeddings(model_id, body)

        print(f"Generated image embeddings of length {output_embedding_length}: {response['embedding']}")

    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 EmbedError as err:
        logger.error(err.message)
        print(err.message)

    else:
        print(f"Finished generating image embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")


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

------
#### [ Text and image embeddings ]

Este exemplo mostra como chamar o modelo Amazon Titan Multimodal Embeddings G1 para gerar incorporações de uma saída de texto e de imagem combinados. O vetor resultante é a média do vetor de incorporações de texto e do vetor de incorporações de imagem gerados.

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from an image and accompanying text with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""

import base64
import json
import logging
import boto3

from botocore.exceptions import ClientError

class EmbedError(Exception):
    "Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"

    def __init__(self, message):
        self.message = message

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_embeddings(model_id, body):
    """
    Generate a vector of embeddings for a combined text and image input using Amazon Titan Multimodal Embeddings G1 on demand.
    Args:
        model_id (str): The model ID to use.
        body (str) : The request body to use.
    Returns:
        response (JSON): The embeddings that the model generated, token information, and the
        reason the model stopped generating embeddings.
    """

    logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings 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())

    finish_reason = response_body.get("message")

    if finish_reason is not None:
        raise EmbedError(f"Embeddings generation error: {finish_reason}")

    return response_body


def main():
    """
    Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
    """

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    model_id = "amazon.titan-embed-image-v1"
    input_text = "A family eating dinner"
    # 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')
    output_embedding_length = 256

    # Create request body.
    body = json.dumps({
        "inputText": input_text,
        "inputImage": input_image,
        "embeddingConfig": {
            "outputEmbeddingLength": output_embedding_length
        }
    })


    try:

        response = generate_embeddings(model_id, body)

        print(f"Generated embeddings of length {output_embedding_length}: {response['embedding']}")
        print(f"Input text token count:  {response['inputTextTokenCount']}")

    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 EmbedError as err:
        logger.error(err.message)
        print(err.message)

    else:
        print(f"Finished generating embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")


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

------