Generador de imágenes Amazon Titan, modelos G1 - Amazon Bedrock

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Generador de imágenes Amazon Titan, modelos G1

La Amazonía Titan Image Generator G1 V1 y Titan Image Generator G1 V2 Los modelos admiten los siguientes parámetros de inferencia y respuestas del modelo al realizar la inferencia del modelo.

Formatos de solicitud y respuesta

Cuando realice una InvokeModelllamada con los modelos de Amazon Titan Image Generator, sustituya el body campo de la solicitud por el formato que corresponda a su caso de uso. Todas las tareas comparten un objeto imageGenerationConfig, pero cada tarea tiene un objeto de parámetros específico para esa tarea. Se admiten los siguientes casos de uso:

taskType Campo de parámetros de la tarea Tipo de tarea Definición
TEXT_IMAGE textToImageParams Generación

Genere una imagen mediante un petición de texto.

TEXT_IMAGE textToImageParams Generación

(Solo acondicionamiento de imagen, versión 2) Proporcione una imagen de acondicionamiento de entrada adicional junto con un mensaje de texto para generar una imagen que siga el diseño y la composición de la imagen de acondicionamiento.

INPAINTING inPaintingParams Edición

Modifique una imagen cambiando el interior de una máscara para que coincida con el fondo circundante.

OUTPAINTING outPaintingParams Edición Modifique una imagen extendiendo de forma continua la región definida por la máscara.
IMAGE_VARIATION imageVariationParams Edición Modifique una imagen produciendo variaciones de la imagen original.
COLOR_GUIDED_GENERATION (V2 only) colorGuidedGenerationParams Generación Proporcione una lista de códigos de colores hexadecimales junto con un mensaje de texto para generar una imagen que siga la paleta de colores.
BACKGROUND_REMOVAL (V2 only) backgroundRemovalParams Edición Modifique una imagen identificando varios objetos y quitando el fondo, lo que generará una imagen con un fondo transparente.

Las tareas de edición requieren un campo image en la entrada. Este campo consiste en una cadena que define los píxeles de la imagen. Cada píxel está definido por 3 RGB canales, cada uno de los cuales oscila entre 0 y 255 (por ejemplo, (255 255 0) representaría el color amarillo). Estos canales están codificados en base64.

La imagen que utilice debe estar en PNG formato JPEG o.

Si utiliza los métodos de inpainting u outpainting (sustitución o ampliación de imágenes), también define una máscara, una región o regiones que definan las partes de la imagen que se van a modificar. Puede definir la máscara de una de dos maneras.

  • maskPrompt: escriba una petición de texto para describir la parte de la imagen que se va a enmascarar.

  • maskImage: introduzca una cadena codificada en base64 que defina las regiones enmascaradas marcando cada píxel de la imagen de entrada como (0 0 0) o (255 255 255).

    • Un píxel definido como (0 0 0) es un píxel dentro de la máscara.

    • Un píxel definido como (255 255 255) es un píxel fuera de la máscara.

    Puede utilizar una herramienta de edición de fotografías para dibujar máscaras. A continuación, puede convertir la salida JPEG o la PNG imagen a una codificación en base64 para introducirla en este campo. De lo contrario, utilice el campo maskPrompt en su lugar para permitir que el modelo realice una inferencia de la máscara.

Seleccione una pestaña para ver los cuerpos de las API solicitudes correspondientes a los diferentes casos de uso de la generación de imágenes y las explicaciones de los campos.

Text-to-image generation (Request)

Un mensaje de texto para generar la imagen debe tener <= 512 caracteres. Resoluciones <= 1408 en el lado más largo. negativeText (Opcional): un mensaje de texto que tiene menos de 512 caracteres para definir lo que no se debe incluir en la imagen. Consulte la siguiente tabla para ver una lista completa de las resoluciones.

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

Los campos textToImageParams se describen a continuación:

  • texto (obligatorio): una petición de texto para generar la imagen.

  • negativeText(Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen.

    nota

    No utilice palabras negativas en la petición negativeText. Por ejemplo, si no desea incluir espejos en una imagen, escriba mirrors en la petición negativeText. No escriba no mirrors.

Inpainting (Request)

text (opcional): una petición de texto para definir qué se debe cambiar dentro de la máscara. Si no incluye este campo, el modelo intentará reemplazar toda el área de la máscara por el fondo. Debe tener <= 512 caracteres. negativeText (Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen. Debe tener <= 512 caracteres. Los límites de tamaño de la imagen de entrada y la máscara de entrada son <= 1408 en el lado más largo de la imagen. El tamaño de salida es el mismo que el tamaño de entrada.

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

Los campos inPaintingParams se describen a continuación: La máscara define la parte de la imagen que quiera modificar.

  • imagen (obligatoria): la PNG imagen JPEG o imagen que se va a modificar, con el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en RGB valores y codificado en base64. Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen, consulte los ejemplos de código.

  • Para la definición, debe definir uno de los campos siguientes (pero no ambos).

    • maskPrompt— Un mensaje de texto que define la máscara.

    • maskImage— Una cadena que define la máscara especificando una secuencia de píxeles del mismo tamaño que laimage. Cada píxel se convierte en un RGB valor de (0 0 0) (un píxel dentro de la máscara) o (255 255 255) (un píxel fuera de la máscara). Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen, consulte los ejemplos de código.

  • text (opcional): una petición de texto para definir qué se debe cambiar dentro de la máscara. Si no incluye este campo, el modelo intentará reemplazar toda el área de la máscara por el fondo.

  • negativeText(Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen.

    nota

    No utilice palabras negativas en la petición negativeText. Por ejemplo, si no desea incluir espejos en una imagen, escriba mirrors en la petición negativeText. No escriba no mirrors.

Outpainting (Request)

text (obligatorio): una petición de texto para definir qué se debe cambiar fuera de la máscara. Debe tener <= 512 caracteres. negativeText (Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen. Debe tener <= 512 caracteres. Los límites de tamaño de la imagen de entrada y la máscara de entrada son <= 1408 en el lado más largo de la imagen. El tamaño de salida es el mismo que el tamaño de entrada.

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

Los campos outPaintingParams se definen a continuación. La máscara define la región de la imagen que no quiera modificar. La generación amplía de manera fluida la región que defina.

  • imagen (obligatoria): la PNG imagen JPEG o imagen que se va a modificar, con el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en RGB valores y codificado en base64. Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen, consulte los ejemplos de código.

  • Para la definición, debe definir uno de los campos siguientes (pero no ambos).

    • maskPrompt— Un mensaje de texto que define la máscara.

    • maskImage— Una cadena que define la máscara especificando una secuencia de píxeles del mismo tamaño que laimage. Cada píxel se convierte en un RGB valor de (0 0 0) (un píxel dentro de la máscara) o (255 255 255) (un píxel fuera de la máscara). Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen, consulte los ejemplos de código.

  • text (obligatorio): una petición de texto para definir qué se debe cambiar fuera de la máscara.

  • negativeText(Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen.

    nota

    No utilice palabras negativas en la petición negativeText. Por ejemplo, si no desea incluir espejos en una imagen, escriba mirrors en la petición negativeText. No escriba no mirrors.

  • outPaintingMode— Especifica si se permite o no la modificación de los píxeles del interior de la máscara. Se admiten los siguientes valores.

    • DEFAULT— Utilice esta opción para permitir la modificación de la imagen dentro de la máscara para mantenerla coherente con el fondo reconstruido.

    • PRECISE— Utilice esta opción para evitar la modificación de la imagen dentro de la máscara.

Image variation (Request)

La variación de imagen le permite crear variaciones de la imagen original en función de los valores de los parámetros. El límite de tamaño de la imagen de entrada es <= 1408 en el lado más largo de la imagen. Consulta la siguiente tabla para ver una lista completa de las resoluciones.

  • text (opcional): una petición de texto que puede definir qué se debe conservar y qué se debe cambiar en la imagen. Debe tener <= 512 caracteres.

  • negativeText (Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen. Debe tener <= 512 caracteres.

  • text (opcional): una petición de texto que puede definir qué se debe conservar y qué se debe cambiar en la imagen. Debe tener <= 512 caracteres.

  • similarityStrength (Opcional): especifica qué tan similar debe ser la imagen generada a las imágenes de entrada. Utilice un valor más bajo para introducir más aleatoriedad en la generación. El rango aceptado está comprendido entre 0,2 y 1,0 (ambos inclusive), mientras que si falta este parámetro en la solicitud, se utiliza un valor predeterminado de 0,7.

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

Los campos imageVariationParams se definen a continuación.

  • images (obligatorio): una lista de imágenes para las que se pueden generar variaciones. Puede incluir de 1 a 5 imágenes. Una imagen se define como una cadena de imágenes codificada en base64. Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen, consulte los ejemplos de código.

  • text (opcional): una petición de texto que puede definir qué se debe conservar y qué se debe cambiar en la imagen.

  • similarityStrength(Opcional): especifica qué tan similar debe ser la imagen generada a las imágenes de entrada. El rango va de 0,2 a 1,0 y se utilizan valores más bajos para introducir más aleatoriedad.

  • negativeText(Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen.

    nota

    No utilice palabras negativas en la petición negativeText. Por ejemplo, si no desea incluir espejos en una imagen, escriba mirrors en la petición negativeText. No escriba no mirrors.

Conditioned Image Generation (Request) V2 only

El tipo de tarea de generación de imágenes condicionadas permite a los clientes aumentar la text-to-image generación al proporcionar una «imagen condicionada» para lograr un control más preciso sobre la imagen generada resultante.

  • Detección astuta de bordes

  • Mapa de segmentación

El mensaje de texto para generar la imagen debe tener <= 512 caracteres. Resoluciones <= 1408 en el lado más largo. negativeText (Opcional) es un mensaje de texto para definir lo que no se debe incluir en la imagen y tiene menos de 512 caracteres. Consulta la siguiente tabla para ver una lista completa de las resoluciones.

{ "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": { "numberOfImages": int, "height": int, "width": int, "cfgScale": float, "seed": int } }
  • texto (obligatorio): una petición de texto para generar la imagen.

  • negativeText(Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen.

    nota

    No utilice palabras negativas en la petición negativeText. Por ejemplo, si no desea incluir espejos en una imagen, escriba mirrors en la petición negativeText. No escriba no mirrors.

  • conditionImage(Solo V2 opcional): imagen acondicionadora de entrada única que guía el diseño y la composición de la imagen generada. Una imagen se define como una cadena de imágenes codificada en base64. Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen.

  • controlMode(Solo V2 opcional): especifica el tipo de modo de acondicionamiento que se debe utilizar. Se admiten dos tipos de modos de acondicionamiento: CANNY _ EDGE y. SEGMENTATION El valor predeterminado es CANNY _EDGE.

  • controlStrength(Solo V2 opcional): especifica qué tan similares deben ser el diseño y la composición de la imagen generada a los. conditioningImage El intervalo va de 0 a 1,0 y se utilizan valores más bajos para introducir más aleatoriedad. El valor predeterminado es 0.7.

nota

Si controlStrength se proporcionan controlMode o, también se conditionImage deben proporcionar.

Color Guided Content (Request) V2 only

Proporcione una lista de códigos de colores hexadecimales junto con un mensaje de texto para generar una imagen que siga la paleta de colores. Se requiere un mensaje de texto para generar la imagen y debe tener <= 512 caracteres. La resolución máxima es de 1408 en el lado más largo. Se requiere una lista de 1 a 10 códigos de color hexadecimales para especificar los colores de la imagen generada. negativeText Opcional: un mensaje de texto para definir lo que no debe incluirse en la imagen <= 512 caracteres referenceImage (opcional) una imagen de referencia adicional para guiar la paleta de colores de la imagen generada. El límite de tamaño de la imagen de RGB referencia cargada por el usuario es <= 1408 en el lado más largo.

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

Los campos de colorGuidedGeneration parámetros se describen a continuación. Tenga en cuenta que este parámetro es solo para V2.

  • texto (obligatorio): una petición de texto para generar la imagen.

  • colores (obligatorio): lista de hasta 10 códigos de color hexadecimales para especificar los colores de la imagen generada.

  • negativeText(Opcional): un mensaje de texto para definir lo que no se debe incluir en la imagen.

    nota

    No utilice palabras negativas en la petición negativeText. Por ejemplo, si no desea incluir espejos en una imagen, escriba mirrors en la petición negativeText. No escriba no mirrors.

  • referenceImage(Opcional): una imagen de referencia de entrada única que guía la paleta de colores de la imagen generada. Una imagen se define como una cadena de imágenes codificada en base64.

Background Removal (Request)

El tipo de tarea de eliminación del fondo identifica automáticamente varios objetos de la imagen de entrada y elimina el fondo. La imagen de salida tiene un fondo transparente.

Formato de solicitud

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

Formato de respuesta

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

El backgroundRemovalParams campo se describe a continuación.

  • imagen (obligatoria): la PNG imagen JPEG o imagen que se va a modificar, con el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en RGB valores y codificado en base64.

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

El cuerpo de la respuesta es un objeto de transmisión que contiene uno de los siguientes campos.

  • images: si la solicitud se realiza correctamente, devuelve este campo, una lista de cadenas codificadas en base64, cada una de las cuales define una imagen generada. Cada imagen tiene el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en RGB valores y codificado en base64. Para ver ejemplos de cómo codificar una imagen en base64 y decodificar una cadena codificada en base64 y transformarla en una imagen, consulte los ejemplos de código.

  • error: si la solicitud infringe la política de moderación de contenido en una de las siguientes situaciones, se devuelve un mensaje en este campo.

    • Si el texto, la imagen o la imagen de la máscara de entrada están marcados por la política de moderación de contenido.

    • Si la política de moderación de contenido marca al menos una imagen de salida

La imageGenerationConfig compartida y opcional contienen los siguientes campos. Si no incluye este objeto, se utilizan las configuraciones predeterminadas.

  • numberOfImages(Opcional): el número de imágenes que se van a generar.

    Mínimo Máximo Predeterminado
    1 5 1
  • cfgScale(Opcional): especifica la intensidad con la que la imagen generada debe cumplir la solicitud. Utilice un valor más bajo para introducir más asignación al azar en la generación.

    Mínimo Máximo Predeterminado
    1.1 10.0 8.0
  • Los siguientes parámetros definen el tamaño que desea que tenga la imagen de salida. Para obtener más información sobre los precios por tamaño de imagen, consulte los Precios de Amazon Bedrock.

    • height: (opcional) la altura de la imagen en píxeles. El valor predeterminado es 1408.

    • width: (opcional) el ancho de la imagen en píxeles. El valor predeterminado es 1408.

    Se admiten los siguientes tamaños.

    Ancho Alto Relación de aspecto Precio equivalente a
    1024 1024 1:1 1024 x 1024
    768 768 1:1 512 x 512
    512 512 1:1 512 x 512
    768 1152 2:3 1024 x 1024
    384 576 2:3 512 x 512
    1152 768 3:2 1024 x 1024
    576 384 3:2 512 x 512
    768 1 280 3:5 1024 x 1024
    384 640 3:5 512 x 512
    1 280 768 5:3 1024 x 1024
    640 384 5:3 512 x 512
    896 1152 7:9 1024 x 1024
    448 576 7:9 512 x 512
    1152 896 9:7 1024 x 1024
    576 448 9:7 512 x 512
    768 1408 6:11 1024 x 1024
    384 704 6:11 512 x 512
    1408 768 11:6 1024 x 1024
    704 384 11:6 512 x 512
    640 1408 5:11 1024 x 1024
    320 704 5:11 512 x 512
    1408 640 11:5 1024 x 1024
    704 320 11:5 512 x 512
    1152 640 9:5 1024 x 1024
    1173 640 16:9 1024 x 1024
  • seed (opcional): se usa para controlar y reproducir los resultados. Determina el ajuste de ruido inicial. Utilice la misma inicialización y los mismos ajustes que en una ejecución anterior para permitir que la inferencia cree una imagen similar.

    Mínimo Máximo Predeterminado
    0 2.147.483.646 42

Ejemplos de código

Los siguientes ejemplos muestran cómo invocar los modelos de Amazon Titan Image Generator con un rendimiento bajo demanda en Python. SDK Seleccione una pestaña para ver un ejemplo de cada caso de uso. Cada ejemplo muestra la imagen al final.

Text-to-image generation
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate an image from a text prompt with the Amazon Titan Image Generator G1 model (on demand). """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator G1 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator G1 example. """ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v1' prompt = """A photograph of a cup of coffee from the side.""" body = json.dumps({ "taskType": "TEXT_IMAGE", "textToImageParams": { "text": prompt }, "imageGenerationConfig": { "numberOfImages": 1, "height": 1024, "width": 1024, "cfgScale": 8.0, "seed": 0 } }) try: image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.") if __name__ == "__main__": main()
Inpainting
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to use inpainting to generate an image from a source image with the Amazon Titan Image Generator G1 model (on demand). The example uses a mask prompt to specify the area to inpaint. """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator G1 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator G1 example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v1' # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') body = json.dumps({ "taskType": "INPAINTING", "inPaintingParams": { "text": "Modernize the windows of the house", "negativeText": "bad quality, low res", "image": input_image, "maskPrompt": "windows" }, "imageGenerationConfig": { "numberOfImages": 1, "height": 512, "width": 512, "cfgScale": 8.0 } }) image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.") if __name__ == "__main__": main()
Outpainting
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to use outpainting to generate an image from a source image with the Amazon Titan Image Generator G1 model (on demand). The example uses a mask image to outpaint the original image. """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator G1 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator G1 example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v1' # Read image and mask image from file and encode as base64 strings. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') with open("/path/to/mask_image", "rb") as mask_image_file: input_mask_image = base64.b64encode( mask_image_file.read()).decode('utf8') body = json.dumps({ "taskType": "OUTPAINTING", "outPaintingParams": { "text": "Draw a chocolate chip cookie", "negativeText": "bad quality, low res", "image": input_image, "maskImage": input_mask_image, "outPaintingMode": "DEFAULT" }, "imageGenerationConfig": { "numberOfImages": 1, "height": 512, "width": 512, "cfgScale": 8.0 } } ) image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.") if __name__ == "__main__": main()
Image variation
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate an image variation from a source image with the Amazon Titan Image Generator G1 model (on demand). """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator G1 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator G1 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator G1 example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v1' # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') body = json.dumps({ "taskType": "IMAGE_VARIATION", "imageVariationParams": { "text": "Modernize the house, photo-realistic, 8k, hdr", "negativeText": "bad quality, low resolution, cartoon", "images": [input_image], "similarityStrength": 0.7, # Range: 0.2 to 1.0 }, "imageGenerationConfig": { "numberOfImages": 1, "height": 512, "width": 512, "cfgScale": 8.0 } }) image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator G1 model {model_id}.") if __name__ == "__main__": main()
Image conditioning (V2 only)
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate image conditioning from a source image with the Amazon Titan Image Generator G1 V2 model (on demand). """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator V2" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator V2 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator V2 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator V2 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator V2 example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v2:0' # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') body = json.dumps({ "taskType": "TEXT_IMAGE", "textToImageParams": { "text": "A robot playing soccer, anime cartoon style", "negativeText": "bad quality, low res", "conditionImage": input_image, "controlMode": "CANNY_EDGE" }, "imageGenerationConfig": { "numberOfImages": 1, "height": 512, "width": 512, "cfgScale": 8.0 } }) image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator V2 model {model_id}.") if __name__ == "__main__": main()
Color guided content (V2 only)
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate an image from a source image color palette with the Amazon Titan Image Generator G1 V2 model (on demand). """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator V2" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator V2 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator V2 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator V2 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator V2 example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v2:0' # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') body = json.dumps({ "taskType": "COLOR_GUIDED_GENERATION", "colorGuidedGenerationParams": { "text": "digital painting of a girl, dreamy and ethereal, pink eyes, peaceful expression, ornate frilly dress, fantasy, intricate, elegant, rainbow bubbles, highly detailed, digital painting, artstation, concept art, smooth, sharp focus, illustration", "negativeText": "bad quality, low res", "referenceImage": input_image, "colors": ["#ff8080", "#ffb280", "#ffe680", "#ffe680"] }, "imageGenerationConfig": { "numberOfImages": 1, "height": 512, "width": 512, "cfgScale": 8.0 } }) image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator V2 model {model_id}.") if __name__ == "__main__": main()
Background removal (V2 only)
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate an image with background removal with the Amazon Titan Image Generator G1 V2 model (on demand). """ import base64 import io import json import logging import boto3 from PIL import Image from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Image Generator V2" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_image(model_id, body): """ Generate an image using Amazon Titan Image Generator V2 model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: image_bytes (bytes): The image generated by the model. """ logger.info( "Generating image with Amazon Titan Image Generator V2 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) base64_image = response_body.get("images")[0] base64_bytes = base64_image.encode('ascii') image_bytes = base64.b64decode(base64_bytes) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Image generation error. Error is {finish_reason}") logger.info( "Successfully generated image with Amazon Titan Image Generator V2 model %s", model_id) return image_bytes def main(): """ Entrypoint for Amazon Titan Image Generator V2 example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-image-generator-v2:0' # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') body = json.dumps({ "taskType": "BACKGROUND_REMOVAL", "backgroundRemovalParams": { "image": input_image, } }) image_bytes = generate_image(model_id=model_id, body=body) image = Image.open(io.BytesIO(image_bytes)) image.show() except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating image with Amazon Titan Image Generator V2 model {model_id}.") if __name__ == "__main__": main()