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à.
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).
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.
- 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.
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.
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
.
-
out PaintingMode: specifica 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.
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.
-
number OfImages (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.
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.
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()