Amazon Titan Image Generator G1

Il Titan Image Generator G1 modello Amazon supporta i seguenti parametri di inferenza e risposte del modello durante l'esecuzione dell'inferenza del modello.

Formati di richieste e risposte

Quando effettui una InvokeModelchiamata utilizzando AmazonTitan Image Generator G1, sostituisci il body campo della richiesta con il formato che corrisponde al tuo caso d'uso. Tutte le attività condividono un oggetto imageGenerationConfig, ma ogni attività ha un oggetto di parametri specifico. Sono supportati i seguenti casi d'uso:

taskType	Campo Parametri attività	Tipo di attività	Definizione
TEXT_IMAGE	textToImageParams	Generazione	Genera un'immagine utilizzando un prompt di testo.
INPAINTING	inPaintingParams	Modifica	Modifica un'immagine cambiando l'interno di una maschera in modo che corrisponda allo sfondo circostante.
OUTPAINTING	outPaintingParams	Modifica	Modifica un'immagine estendendo senza soluzione di continuità la regione definita dalla maschera.
IMAGE_VARIATION	imageVariationParams	Modifica	Modifica un'immagine producendo variazioni dell'immagine originale.

Le attività di modifica richiedono un campo image nell'input. Questo campo è costituito da una stringa che definisce i pixel dell'immagine. Ogni pixel è definito da 3 canali RGB, ognuno dei quali va da 0 a 255 (ad esempio, 255 255 0, rappresenterebbe il colore giallo). Questi canali hanno codifica base64.

Il formati dell'immagine che utilizzi deve essere PNG o JPEG.

Se esegui l'inpainting o l'outpainting, definisci anche una maschera, una o più regioni che definiscono parti dell'immagine da modificare. Puoi definire la maschera in due modi.

• maskPrompt: scrivi un prompt di testo per descrivere la parte dell'immagine da mascherare.

• maskImage: inserisci una stringa con codifica base64 che definisce le regioni mascherate contrassegnando ogni pixel dell'immagine di input come (0 0 0) o (255 255 255).

  • Un pixel definito come (0 0 0) è un pixel all'interno della maschera.

  • Un pixel definito come (255 255 255) è un pixel all'esterno della maschera.

  Per disegnare le maschere, puoi utilizzare uno strumento di fotoritocco. Puoi quindi convertire l'immagine JPEG o PNG di output in codifica base64 per inserirla in questo campo. Altrimenti, utilizza il campo maskPrompt per consentire al modello di ricavare la maschera.

Seleziona una scheda per visualizzare i corpi delle richieste API per diversi casi d'uso di generazione di immagini e le spiegazioni dei campi.

Text-to-image generation (Request)

Un prompt di testo per generare l'immagine deve contenere <= 512 caratteri. Risoluzioni <= 1.408 sul lato più lungo. I NegativeText (opzionale) — Un messaggio di testo per definire cosa non includere nell'immagine -- <= 512 caratteri. Consulta la tabella seguente per un elenco completo delle risoluzioni.

{
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "text": "string",      
        "negativeText": "string"
    },
    "imageGenerationConfig": {
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float,
        "seed": int
    }
}

I campi textToImageParams sono descritti di seguito.

• text (obbligatorio): un prompt di testo per generare l'immagine.

• negativeText (opzionale): un prompt di testo per definire cosa non includere nell'immagine.

  Nota

  Non utilizzare parole negative nel prompt negativeText. Ad esempio, se non desideri includere specchi in un'immagine, inserisci mirrors nel prompt negativeText. Non inserire no mirrors.

Inpainting (Request)

text (facoltativo): un messaggio di testo per definire cosa modificare all'interno della maschera. Se non includi questo campo, il modello tenta di sostituire l'intera area della maschera con lo sfondo. Deve contenere <= 512 caratteri. NegativeText (opzionale) — Un messaggio di testo per definire cosa non includere nell'immagine. Deve contenere <= 512 caratteri. I limiti di dimensione per l'immagine di input e la maschera di input sono <= 1.408 sul lato più lungo dell'immagine. La dimensione di output è la stessa della dimensione di input.

{
    "taskType": "INPAINTING",
    "inPaintingParams": {
        "image": "base64-encoded string",                         
        "text": "string",
        "negativeText": "string",        
        "maskPrompt": "string",                      
        "maskImage": "base64-encoded string",                   
    },                                                 
    "imageGenerationConfig": {
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float
    }
}

I campi inPaintingParams sono descritti di seguito. La maschera definisce la parte dell'immagine che desideri modificare.

• image (obbligatorio): l'immagine JPEG o PNG da modificare, formattata come una stringa che specifica una sequenza di pixel, ciascuno definito in valori RGB e con codifica base64. Per esempi su come codificare un'immagine con base64 e decodificare una stringa con codifica base64 e trasformarla in un'immagine, consulta gli esempi di codice.

• È necessario definire uno dei campi seguenti (ma non entrambi) per eseguire la definizione.

  • maskPrompt: un prompt di testo che definisce la maschera.

  • maskImage: una stringa che definisce la maschera specificando una sequenza di pixel della stessa dimensione di image. Ogni pixel viene trasformato in un valore RGB di (0 0 0) (un pixel all'interno della maschera) o (255 255 255) (un pixel all'esterno della maschera). Per esempi su come codificare un'immagine con base64 e decodificare una stringa con codifica base64 e trasformarla in un'immagine, consulta gli esempi di codice.

• text (facoltativo): un messaggio di testo per definire cosa modificare all'interno della maschera. Se non includi questo campo, il modello tenta di sostituire l'intera area della maschera con lo sfondo.

• negativeText (opzionale): un prompt di testo per definire cosa non includere nell'immagine.

  Nota

  Non utilizzare parole negative nel prompt negativeText. Ad esempio, se non desideri includere specchi in un'immagine, inserisci mirrors nel prompt negativeText. Non inserire no mirrors.

Outpainting (Request)

text (obbligatorio): un prompt di testo per definire cosa modificare all'esterno della maschera. Deve contenere <= 512 caratteri. NegativeText (opzionale) — Un messaggio di testo per definire cosa non includere nell'immagine. Deve contenere <= 512 caratteri. I limiti di dimensione per l'immagine di input e la maschera di input sono <= 1.408 sul lato più lungo dell'immagine. La dimensione di output è la stessa della dimensione di input.

{
    "taskType": "OUTPAINTING",
    "outPaintingParams": {
        "text": "string",
        "negativeText": "string",        
        "image": "base64-encoded string",                         
        "maskPrompt": "string",                      
        "maskImage": "base64-encoded string",                             
        "outPaintingMode": "DEFAULT | PRECISE"                 
    },                                                 
    "imageGenerationConfig": {
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float
    }
}

I campi outPaintingParams sono definiti di seguito. La maschera definisce la regione dell'immagine che non desideri modificare. La generazione estende senza interruzioni la regione che hai definito.

• image (obbligatorio): l'immagine JPEG o PNG da modificare, formattata come una stringa che specifica una sequenza di pixel, ciascuno definito in valori RGB e con codifica base64. Per esempi su come codificare un'immagine con base64 e decodificare una stringa con codifica base64 e trasformarla in un'immagine, consulta gli esempi di codice.

• È necessario definire uno dei campi seguenti (ma non entrambi) per eseguire la definizione.

  • maskPrompt: un prompt di testo che definisce la maschera.

  • maskImage: una stringa che definisce la maschera specificando una sequenza di pixel della stessa dimensione di image. Ogni pixel viene trasformato in un valore RGB di (0 0 0) (un pixel all'interno della maschera) o (255 255 255) (un pixel all'esterno della maschera). Per esempi su come codificare un'immagine con base64 e decodificare una stringa con codifica base64 e trasformarla in un'immagine, consulta gli esempi di codice.

• text (obbligatorio): un prompt di testo per definire cosa modificare all'esterno della maschera.

• negativeText (opzionale): un prompt di testo per definire cosa non includere nell'immagine.

  Nota

  Non utilizzare parole negative nel prompt negativeText. Ad esempio, se non desideri includere specchi in un'immagine, inserisci mirrors nel prompt negativeText. Non inserire no mirrors.

• outPaintingMode— Speciifica se consentire o meno la modifica dei pixel all'interno della maschera. I valori possibili sono i seguenti:

  • DEFAULT: utilizza questa opzione per consentire la modifica dell'immagine all'interno della maschera in modo da mantenerla coerente con lo sfondo ricostruito.

  • PRECISE: utilizza questa opzione per impedire la modifica dell'immagine all'interno della maschera.

Image variation (Request)

Le variazioni dell'immagine consentono di creare variazioni dell'immagine originale in base ai valori dei parametri. Il limite di dimensione per l'immagine di input è <= 1.408 sul lato più lungo dell'immagine. Consulta la tabella seguente per un elenco completo delle risoluzioni.

• text (opzionale): un prompt di testo che può definire cosa conservare e cosa modificare nell'immagine. Deve contenere <= 512 caratteri.

• negativeText (opzionale): un prompt di testo per definire cosa non includere nell'immagine. Deve contenere <= 512 caratteri.

• text (opzionale): un prompt di testo che può definire cosa conservare e cosa modificare nell'immagine. Deve contenere <= 512 caratteri.

• SimilarityStrength (opzionale): specifica quanto deve essere simile l'immagine generata alle immagini di input. Usa un valore più basso per introdurre una maggiore casualità nella generazione. L'intervallo accettato è compreso tra 0,2 e 1,0 (entrambi inclusi), mentre viene utilizzato il valore predefinito di 0,7 se questo parametro non è presente nella richiesta.

{
     "taskType": "IMAGE_VARIATION",
     "imageVariationParams": {
         "text": "string",
         "negativeText": "string",
         "images": ["base64-encoded string"],
         "similarityStrength": 0.7,  # Range: 0.2 to 1.0
     },
     "imageGenerationConfig": {
         "numberOfImages": int,
         "height": int,
         "width": int,
         "cfgScale": float
     }
}

I campi imageVariationParams sono definiti di seguito.

• images (obbligatorio): un elenco di immagini per le quali generare varianti. È possibile includere da 1 a 5 immagini. Un'immagine è definita come una stringa di immagine con codifica Base64. Per esempi su come codificare un'immagine con base64 e decodificare una stringa con codifica base64 e trasformarla in un'immagine, consulta gli esempi di codice.

• text (opzionale): un prompt di testo che può definire cosa conservare e cosa modificare nell'immagine.

• SimilarityStrength (opzionale): specifica quanto deve essere simile l'immagine generata alle immagini di input. Intervallo compreso tra 0,2 e 1,0 con valori inferiori utilizzati per introdurre una maggiore casualità.

• negativeText (opzionale): un prompt di testo per definire cosa non includere nell'immagine.

  Nota

  Non utilizzare parole negative nel prompt negativeText. Ad esempio, se non desideri includere specchi in un'immagine, inserisci mirrors nel prompt negativeText. Non inserire no mirrors.

Response body

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

Il corpo della risposta è un oggetto di streaming che contiene uno dei seguenti campi.

• images: se la richiesta ha esito positivo, restituisce questo campo, un elenco di stringhe con codifica base64, ognuna delle quali definisce un'immagine generata. Ogni immagine è formattata come una stringa che specifica una sequenza di pixel, ciascuno definito in valori RGB e con codifica base64. Per esempi su come codificare un'immagine con base64 e decodificare una stringa con codifica base64 e trasformarla in un'immagine, consulta gli esempi di codice.

• error: se la richiesta viola la policy di moderazione dei contenuti in una delle seguenti situazioni, viene restituito un messaggio in questo campo.

  • Se l'immagine, l'immagine della maschera o il testo di input è contrassegnato dalla policy di moderazione dei contenuti.

  • Se almeno un'immagine di output è contrassegnata dalla policy di moderazione dei contenuti.

Il imageGenerationConfig condiviso e facoltativo contiene i seguenti campi. Se non includi questo oggetto, vengono utilizzate le configurazioni predefinite.

• numberOfImages(Facoltativo): il numero di immagini da generare.

  Minimo	Massimo	Predefinita
  1	5	1

• cfgScale (facoltativo): specifica in che misura l'immagine generata deve aderire al prompt. Utilizza un valore più basso per introdurre una maggiore randomizzazione nella generazione.

  Minimo	Massimo	Predefinita
  1.1	10.0	8.0

• I seguenti parametri definiscono la dimensione desiderata per l'immagine di output. Per ulteriori dettagli sui prezzi in base alle dimensioni dell'immagine, consulta Prezzi di Amazon Bedrock.

  • height (facoltativo): l'altezza dell'immagine in pixel. Il valore predefinito è 1408.

  • width: la larghezza dell'immagine in pixel. Il valore predefinito è 1408.

  Sono ammesse le seguenti dimensioni.

  Larghezza	Altezza	Proporzioni	Prezzo equivalente a
  1.024	1.024	1:1	1.024 x 1.024
  768	768	1:1	512 x 512
  512	512	1:1	512 x 512
  768	1152	2:3	1.024 x 1.024
  384	576	2:3	512 x 512
  1152	768	3:2	1.024 x 1.024
  576	384	3:2	512 x 512
  768	1280	3:5	1.024 x 1.024
  384	640	3:5	512 x 512
  1280	768	5:3	1.024 x 1.024
  640	384	5:3	512 x 512
  896	1152	7:9	1.024 x 1.024
  448	576	7:9	512 x 512
  1152	896	9:7	1.024 x 1.024
  576	448	9:7	512 x 512
  768	1408	6:11	1.024 x 1.024
  384	704	6:11	512 x 512
  1408	768	11:6	1.024 x 1.024
  704	384	11:6	512 x 512
  640	1408	5:11	1.024 x 1.024
  320	704	5:11	512 x 512
  1408	640	11:5	1.024 x 1.024
  704	320	11:5	512 x 512
  1152	640	9:5	1.024 x 1.024
  1173	640	16:9	1.024 x 1.024

• seed (opzionale): da utilizzare per controllare e riprodurre i risultati. Determina l'impostazione iniziale del rumore. Utilizza lo stesso seed e le stesse impostazioni dell'esecuzione precedente per consentire all'inferenza di creare un'immagine simile.

  Nota

  Puoi impostare solo un seed per un'attività di generazione TEXT_IMAGE.

  Minimo	Massimo	Predefinita
  0	2.147.483.646	0

Esempi di codice

Gli esempi seguenti mostrano come richiamare il Titan Image Generator G1 modello Amazon con throughput su richiesta nell'SDK Python. Seleziona una scheda per visualizzare un esempio per ogni caso d'uso. Ogni esempio mostra l'immagine alla fine.

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()