Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Modelli di Generatore di immagini Amazon Titan G1
<a name="model-parameters-titan-image"></a>

I modelli Titan Image Generator G1 V1 e Titan Image Generator G1 V2 supportano i seguenti parametri di inferenza e risposte del modello durante l’esecuzione dell’inferenza del modello.

**Topics**
+ [Parametri di inferenza](#model-parameters-titan-image-api)
+ [Esempi](#model-parameters-titan-image-code-examples)

## Parametri di inferenza
<a name="model-parameters-titan-image-api"></a>

Quando effettui una [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)chiamata utilizzando i modelli Amazon Titan Image Generator, 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. | 
| TEXT\_IMAGE | textToImageParams | Generazione | (Solo condizionamento immagine V2) Fornisce un’immagine di condizionamento come input insieme a un prompt di testo per generare un’immagine che segua il layout e la composizione dell’immagine di condizionamento.  | 
| 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 ampliando in modo naturale la Regione definita dalla maschera. | 
| IMAGE\_VARIATION | imageVariationParams | Modifica | Modifica un’immagine producendo variazioni dell’immagine originale. | 
| COLOR\_GUIDED\_GENERATION (V2 only) | colorGuidedGenerationParams | Generazione | Fornisce un elenco di codici colore esadecimali insieme a un prompt di testo per generare un’immagine che segua la tavolozza dei colori. | 
| BACKGROUND\_REMOVAL (V2 only) | backgroundRemovalParams | Modifica | Modifica un’immagine identificando più oggetti e rimuovendo lo sfondo, generando un’immagine con uno sfondo trasparente. | 

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 viene eseguito l’inpainting o l’outpainting, definire anche una *maschera*, una o più Regioni che definiscono parti dell’immagine da modificare. È possibile definire la maschera in due modi.
+ `maskPrompt`: scrive un prompt di testo per descrivere la parte dell’immagine da mascherare.
+ `maskImage`: inserisce 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, è possibile utilizzare uno strumento di fotoritocco. Poi è possibile convertire l’immagine JPEG o PNG di output in codifica base64 per inserirla in questo campo. Altrimenti, utilizzare il campo `maskPrompt` per consentire al modello di ricavare la maschera.

Selezionare 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. negativeText (facoltativo): un prompt di testo per definire cosa non includere nell’immagine di <= 512 caratteri. Consultare la tabella riportata di seguito per un elenco completo delle risoluzioni.

```
{
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "text": "string",      
        "negativeText": "string"
    },
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "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** (facoltativo): un prompt di testo per definire cosa non includere nell’immagine.
**Nota**  
Non utilizzare parole negative nel prompt `negativeText`. Ad esempio, per non includere specchi in un’immagine, inserire **mirrors** nel prompt `negativeText`. Non inserire **no mirrors**.

------
#### [ Inpainting (Request) ]

text (facoltativo): un prompt di testo per definire cosa modificare all’interno della maschera. Se questo campo non viene incluso, il modello tenta di sostituire l’intera area della maschera con lo sfondo. Deve contenere <= 512 caratteri. negativeText (facoltativo): un prompt 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",   
        "returnMask": boolean # False by default                
    },                                                 
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float
    }
}
```

I campi `inPaintingParams` sono descritti di seguito. La *maschera* definisce la parte dell’immagine da 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, consultare gli [esempi di codice](#model-parameters-titan-image-code-examples).
+ È necessario definire uno dei seguenti campi (ma non entrambi) per 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, consultare gli [esempi di codice](#model-parameters-titan-image-code-examples).
+ **text** (facoltativo): un prompt 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** (facoltativo): un prompt di testo per definire cosa non includere nell’immagine.
**Nota**  
Non utilizzare parole negative nel prompt `negativeText`. Ad esempio, per non includere specchi in un’immagine, inserire **mirrors** nel prompt `negativeText`. Non inserire **no mirrors**.
+ **ReturnMask** (opzionale) — Se impostata su`true`, la risposta include l'immagine della maschera utilizzata per l'operazione di inpainting come stringa con codifica Base64. Ciò è utile per eseguire il debug o verificare quale area dell'immagine è stata modificata. Il valore predefinito è “`false`”.

------
#### [ Outpainting (Request) ]

text (obbligatorio): un prompt di testo per definire cosa modificare all’esterno della maschera. Deve contenere <= 512 caratteri. negativeText (facoltativo): un prompt 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",    
        "returnMask": boolean, # False by default                                         
        "outPaintingMode": "DEFAULT | PRECISE"                 
    },                                                 
    "imageGenerationConfig": {
        "quality": "standard" | "premium",
        "numberOfImages": int,
        "height": int,
        "width": int,
        "cfgScale": float
    }
}
```

I campi `outPaintingParams` sono definiti di seguito. La *maschera* definisce la Regione dell’immagine da non modificare. La generazione estende senza interruzioni la Regione definita.
+ **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, consultare gli [esempi di codice](#model-parameters-titan-image-code-examples).
+ È necessario definire uno dei seguenti campi (ma non entrambi) per 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, consultare gli [esempi di codice](#model-parameters-titan-image-code-examples).
+ **text** (obbligatorio): un prompt di testo per definire cosa modificare all’esterno della maschera.
+ **negativeText** (facoltativo): un prompt di testo per definire cosa non includere nell’immagine.
**Nota**  
Non utilizzare parole negative nel prompt `negativeText`. Ad esempio, per non includere specchi in un’immagine, inserire **mirrors** nel prompt `negativeText`. Non inserire **no mirrors**.
+ **out PaintingMode**: specifica se consentire o meno la modifica dei pixel all'interno della maschera. I valori possibili sono i seguenti:
  + DEFAULT — Utilizzate questa opzione per consentire la modifica dell'immagine all'interno della maschera per mantenerla coerente con lo sfondo ricostruito.
  + PRECISE: utilizzare questa opzione per impedire la modifica dell’immagine all’interno della maschera.
+ **ReturnMask** (opzionale) — Se impostata su`true`, la risposta include l'immagine della maschera utilizzata per l'operazione di outpainting come stringa con codifica Base64. Ciò è utile per eseguire il debug o verificare quale area dell'immagine è stata preservata. Il valore predefinito è “`false`”.

------
#### [ 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. Consultare la tabella riportata di seguito per un elenco completo delle risoluzioni. 
+ text (facoltativo): un prompt di testo che può definire cosa conservare e cosa modificare nell’immagine. Deve contenere <= 512 caratteri.
+ negativeText (facoltativo): un prompt di testo per definire cosa non includere nell’immagine. Deve contenere <= 512 caratteri.
+ text (facoltativo): un prompt di testo che può definire cosa conservare e cosa modificare nell’immagine. Deve contenere <= 512 caratteri.
+ similarityStrength (facoltativo): specifica quanto deve essere simile l’immagine generata alle immagini di input. Usare un valore più basso per introdurre una maggiore randomizzazione 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": {
         "quality": "standard" | "premium",
         "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 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, consultare gli [esempi di codice](#model-parameters-titan-image-code-examples).
+ **text** (facoltativo): un prompt di testo che può definire cosa conservare e cosa modificare nell’immagine.
+ **similarityStrength** (facoltativo): specifica quanto l’immagine generata deve essere simile alle immagini di input. Intervallo compreso tra 0,2 e 1,0 con valori inferiori utilizzati per introdurre una maggiore randomizzazione.
+ **negativeText** (facoltativo): un prompt di testo per definire cosa non includere nell’immagine.
**Nota**  
Non utilizzare parole negative nel prompt `negativeText`. Ad esempio, per non includere specchi in un’immagine, inserire **mirrors** nel prompt `negativeText`. Non inserire **no mirrors**.

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

Il tipo di attività di generazione di immagini condizionate consente ai clienti di aumentare la generazione da testo a immagine fornendo una’”immagine condizionale” per un controllo più preciso sull’immagine generata risultante.
+ Rilevamento bordi con algoritmo di Canny
+ Mappa di segmentazione

Un prompt di testo per generare l’immagine deve contenere <= 512 caratteri. Risoluzioni <= 1.408 sul lato più lungo. negativeText (facoltativo) è un prompt di testo per definire cosa non includere nell’immagine e contiene <= 512 caratteri. Consultare la tabella riportata di seguito per un elenco completo delle risoluzioni.

```
{
    "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** (obbligatorio): un prompt di testo per generare l’immagine.
+ **negativeText** (facoltativo): un prompt di testo per definire cosa non includere nell’immagine.
**Nota**  
Non utilizzare parole negative nel prompt `negativeText`. Ad esempio, per non includere specchi in un’immagine, inserire **mirrors** nel prompt `negativeText`. Non inserire **no mirrors**.
+ **conditionImage (Optional-V2 solo) — Un'immagine** di condizionamento a input singolo che guida il layout e la composizione dell'immagine generata. Un’immagine è definita come 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.
+ **ControlMode** (Optional-V2 solo): specifica il tipo di modalità di condizionamento da utilizzare. Sono supportati due tipi di modalità di condizionamento: CANNY\_EDGE e SEGMENTATION. Il valore predefinito è CANNY\_EDGE.
+ **ControlStrength** (Optional-V2 solo): specifica quanto devono essere simili il layout e la composizione dell'immagine generata a quelli di ConditioningImage. Intervallo compreso tra 0 e 1,0 con valori inferiori utilizzati per introdurre una maggiore randomizzazione. Il valore predefinito è 0,7.

**Nota**  
Se vengono specificati controlMode o controlStrength, è necessario specificare anche conditionImage.

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

Fornisce un elenco di codici colore esadecimali insieme a un prompt di testo per generare un’immagine che segua la tavolozza dei colori. Un prompt di testo per generare l’immagine deve contenere <= 512 caratteri. La risoluzione massima è 1.408 sul lato più lungo. È necessario un elenco da 1 a 10 codici colore esadecimali per specificare i colori nell’immagine generata, negativeText Facoltativo Un prompt di testo per definire cosa non includere nell’immagine <= 512 caratteri referenceImage facoltativo un’immagine di riferimento aggiuntiva per guidare la tavolozza dei colori nell’immagine generata. Il limite di dimensione per l’immagine di riferimento RGB caricata dall’utente è <= 1.408 sul lato più lungo. 

```
{
    "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
    }
}
```

I campi di colore sono descritti di seguito. GuidedGenerationParams Tenere presente che questo parametro è valido solo per V2.
+ **text** (obbligatorio): un prompt di testo per generare l’immagine.
+ **colors** (obbligatorio): un elenco di un massimo di 10 codici colore esadecimali per specificare i colori nell’immagine generata.
+ **negativeText** (facoltativo): un prompt di testo per definire cosa non includere nell’immagine.
**Nota**  
Non utilizzare parole negative nel prompt `negativeText`. Ad esempio, per non includere specchi in un’immagine, inserire **mirrors** nel prompt `negativeText`. Non inserire **no mirrors**.
+ **referenceImage** (facoltativo): un’unica immagine di riferimento di input che guida la tavolozza dei colori dell’immagine generata. Un’immagine è definita come stringa di immagine con codifica base64.

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

Il tipo di operazione di rimozione dello sfondo identifica automaticamente più oggetti nell’immagine di input e rimuove lo sfondo. L’immagine di output ha uno sfondo trasparente. 

**Formato della richiesta**

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

**Formato di risposta**

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

Il RemovalParams campo di sfondo è descritto di seguito.
+ **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.

------
#### [ 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, consultare gli [esempi di codice](#model-parameters-titan-image-code-examples).
+ `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 viene incluso questo oggetto, vengono utilizzate le configurazioni predefinite.
+ **quality**: la qualità dell’immagine. Il valore predefinito è `standard`. Per i dettagli sui prezzi, consultare [Prezzi di Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
+ **numero OfImages** (opzionale) — Il numero di immagini da generare.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-titan-image.html)
+ **cfgScale** (facoltativo): specifica in che misura l’immagine generata deve aderire al prompt. Utilizzare un valore più basso per introdurre una maggiore randomizzazione nella generazione.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-titan-image.html)
+ I seguenti parametri definiscono la dimensione desiderata per l’immagine di output. Per ulteriori dettagli sui prezzi in base alle dimensioni dell’immagine, consultare [Prezzi di Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
  + **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.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-titan-image.html)
+ **seed** (facoltativo): da utilizzare per controllare e riprodurre i risultati. Determina l’impostazione iniziale del rumore. Utilizzare lo stesso seed e le stesse impostazioni dell’esecuzione precedente per consentire all’inferenza di creare un’immagine simile.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-titan-image.html)

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

Gli esempi seguenti mostrano come invocare i modelli del Generatore di immagini Amazon Titan con throughput su richiesta nell’SDK Python. Selezionare 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()
```

------
#### [ 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()
```

------