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. # Modelos Amazon Titan En esta sección se describen los parámetros de solicitud y los campos de respuesta de los modelos Amazon Titan. Utilice esta información para realizar llamadas de inferencia a los modelos Amazon Titan con las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) y [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (transmisión). En esta sección también se incluyen ejemplos de código de Python que muestran cómo llamar a los modelos Amazon Titan. Para utilizar un modelo en una operación de inferencia, necesitará el ID del modelo. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Algunos modelos también funcionan con la [API Converse](conversation-inference.md). Para saber si la API Converse es compatible con un modelo de Amazon Titan específico, consulte [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md). Para obtener ejemplos de código, consulte [Ejemplos de código para Amazon Bedrock mediante AWS SDKs](service_code_examples.md). Los modelos fundacionales de Amazon Bedrock admiten modalidades de entrada y salida, que varían de un modelo a otro. Para comprobar las modalidades que admiten los modelos Amazon Titan, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar qué características de Amazon Bedrock son compatibles con los modelos Amazon Titan, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Para comprobar en qué regiones de AWS están disponibles los modelos Amazon Titan, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md). Cuando realiza llamadas de inferencia con modelos Amazon Titan, usted incluye una petición para el modelo. Para obtener información general sobre cómo crear peticiones para los modelos compatibles con Amazon Bedrock, consulte [Conceptos de ingeniería de peticiones](prompt-engineering-guidelines.md). **Topics** + [Modelos Amazon Titan Text](model-parameters-titan-text.md) + [Modelos Amazon Titan Image Generator G1](model-parameters-titan-image.md) + [Amazon Titan Embeddings G1 - Text](model-parameters-titan-embed-text.md) + [Amazon Titan Multimodal Embeddings G1](model-parameters-titan-embed-mm.md) # Modelos Amazon Titan Text Los modelos Amazon Titan Text admiten los siguientes parámetros de inferencia. Para obtener más información sobre las directrices de ingeniería de peticiones de Titan Text, consulte las [directrices de ingeniería de peticiones de Titan Text](https://d2eo22ngex1n9g.cloudfront.net/Documentation/User+Guides/Titan/Amazon+Titan+Text+Prompt+Engineering+Guidelines.pdf). Para obtener más información sobre los modelos Titan, consulte [Información general de los modelos Amazon Titan](titan-models.md). **Topics** + [Solicitud y respuesta](#model-parameters-titan-request-response) + [Ejemplos de código](#inference-titan-code) ## Solicitud y respuesta El cuerpo de la solicitud se pasa en el campo `body` de una solicitud [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html). ------ #### [ Request ] ``` { "inputText": string, "textGenerationConfig": { "temperature": float, "topP": float, "maxTokenCount": int, "stopSequences": [string] } } ``` Se requieren los siguientes parámetros: + **inputText**: petición que se proporciona al modelo para que genere una respuesta. Para generar respuestas en un estilo conversacional, envíe la petición con el siguiente formato: ``` "inputText": "User: \nBot:" ``` Este formato indica al modelo que debe responder en una nueva línea después de que el usuario haya proporcionado una petición. La `textGenerationConfig` es opcional. Puede utilizar los [parámetros de inferencia](inference-parameters.md) para configurarla: + **temperature**: utilice un valor bajo para reducir la asignación al azar de la respuesta. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-text.html) + **topP**: utilice un valor bajo para ignorar las opciones menos probables y reducir la diversidad de respuestas. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-text.html) + **maxTokenCount**: especifique la cantidad máxima de tokens a generar en la respuesta. Los límites máximos de tokens se aplican de forma estricta. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-text.html) + **stopSequences**: especifique las secuencias de caracteres para indicar dónde debe detenerse el modelo. ------ #### [ InvokeModel Response ] ``` { "inputTextTokenCount": int, "results": [{ "tokenCount": int, "outputText": "\n\n", "completionReason": "string" }] } ``` El cuerpo de la respuesta contiene los siguientes campos: + **inputTextTokenCount**: número de tokens de la petición. + **results**: matriz de un elemento; un objeto que contiene los siguientes campos: + **tokenCount**: número de tokens de la respuesta. + **outputText**: texto de la respuesta. + **completionReason**: motivo por el que al final no se ha generado la respuesta. Es posible que se deba a los siguientes motivos: + FINISHED: la respuesta se ha generado por completo. + LENGTH: la respuesta se ha truncado debido a la longitud de la respuesta que ha establecido. + STOP\$1CRITERIA\$1MET: la respuesta se ha truncado porque se ha alcanzado el criterio de parada. + RAG\$1QUERY\$1WHEN\$1RAG\$1DISABLED: la característica está deshabilitada y no se puede completar la consulta. + CONTENT\$1FILTERED: el filtro de contenido aplicado ha filtrado o eliminado el contenido. ------ #### [ InvokeModelWithResponseStream Response ] Cada fragmento de texto en el cuerpo del flujo de respuestas tiene el siguiente formato. Debe decodificar el campo `bytes` (consulte [Envíe un único mensaje con InvokeModel](inference-invoke.md) para ver un ejemplo). ``` { "chunk": { "bytes": b'{ "index": int, "inputTextTokenCount": int, "totalOutputTextTokenCount": int, "outputText": "", "completionReason": "string" }' } } ``` + **index**: índice del fragmento de la respuesta de la transmisión. + **inputTextTokenCount**: número de tokens de la petición. + **totalOutputTextTokenCount**: número de tokens de la respuesta. + **outputText**: texto de la respuesta. + **completionReason**: motivo por el que al final no se ha generado la respuesta. Es posible que se den las siguientes razones. + FINISHED: la respuesta se ha generado por completo. + LENGTH: la respuesta se ha truncado debido a la longitud de la respuesta que ha establecido. + STOP\$1CRITERIA\$1MET: la respuesta se ha truncado porque se ha alcanzado el criterio de parada. + RAG\$1QUERY\$1WHEN\$1RAG\$1DISABLED: la característica está deshabilitada y no se puede completar la consulta. + CONTENT\$1FILTERED: el filtro aplicado ha filtrado o eliminado el contenido. ------ ## Ejemplos de código El siguiente ejemplo muestra cómo ejecutar inferencias con el modelo Amazon Titan Text Premier con el SDK para Python. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to create a list of action items from a meeting transcript with the Amazon Titan Text model (on demand). """ import json import logging import boto3 from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon Titan Text models" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_text(model_id, body): """ Generate text using Amazon Titan Text models on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (json): The response from the model. """ logger.info( "Generating text with Amazon Titan Text model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Text generation error. Error is {finish_reason}") logger.info( "Successfully generated text with Amazon Titan Text model %s", model_id) return response_body def main(): """ Entrypoint for Amazon Titan Text model example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") # You can replace the model_id with any other Titan Text Models # Titan Text Model family model_id is as mentioned below: # amazon.titan-text-premier-v1:0, amazon.titan-text-express-v1, amazon.titan-text-lite-v1 model_id = 'amazon.titan-text-premier-v1:0' prompt = """Meeting transcript: Miguel: Hi Brant, I want to discuss the workstream for our new product launch Brant: Sure Miguel, is there anything in particular you want to discuss? Miguel: Yes, I want to talk about how users enter into the product. Brant: Ok, in that case let me add in Namita. Namita: Hey everyone Brant: Hi Namita, Miguel wants to discuss how users enter into the product. Miguel: its too complicated and we should remove friction. for example, why do I need to fill out additional forms? I also find it difficult to find where to access the product when I first land on the landing page. Brant: I would also add that I think there are too many steps. Namita: Ok, I can work on the landing page to make the product more discoverable but brant can you work on the additonal forms? Brant: Yes but I would need to work with James from another team as he needs to unblock the sign up workflow. Miguel can you document any other concerns so that I can discuss with James only once? Miguel: Sure. From the meeting transcript above, Create a list of action items for each person. """ body = json.dumps({ "inputText": prompt, "textGenerationConfig": { "maxTokenCount": 3072, "stopSequences": [], "temperature": 0.7, "topP": 0.9 } }) response_body = generate_text(model_id, body) print(f"Input token count: {response_body['inputTextTokenCount']}") for result in response_body['results']: print(f"Token count: {result['tokenCount']}") print(f"Output text: {result['outputText']}") print(f"Completion reason: {result['completionReason']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating text with the Amazon Titan Text Premier model {model_id}.") if __name__ == "__main__": main() ``` El siguiente ejemplo muestra cómo ejecutar inferencias con el modelo Amazon Titan Text G1 - Express con el SDK para Python. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to create a list of action items from a meeting transcript with the Amazon &titan-text-express; model (on demand). """ import json import logging import boto3 from botocore.exceptions import ClientError class ImageError(Exception): "Custom exception for errors returned by Amazon &titan-text-express; model" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_text(model_id, body): """ Generate text using Amazon &titan-text-express; model on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (json): The response from the model. """ logger.info( "Generating text with Amazon &titan-text-express; model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get("body").read()) finish_reason = response_body.get("error") if finish_reason is not None: raise ImageError(f"Text generation error. Error is {finish_reason}") logger.info( "Successfully generated text with Amazon &titan-text-express; model %s", model_id) return response_body def main(): """ Entrypoint for Amazon &titan-text-express; example. """ try: logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = 'amazon.titan-text-express-v1' prompt = """Meeting transcript: Miguel: Hi Brant, I want to discuss the workstream for our new product launch Brant: Sure Miguel, is there anything in particular you want to discuss? Miguel: Yes, I want to talk about how users enter into the product. Brant: Ok, in that case let me add in Namita. Namita: Hey everyone Brant: Hi Namita, Miguel wants to discuss how users enter into the product. Miguel: its too complicated and we should remove friction. for example, why do I need to fill out additional forms? I also find it difficult to find where to access the product when I first land on the landing page. Brant: I would also add that I think there are too many steps. Namita: Ok, I can work on the landing page to make the product more discoverable but brant can you work on the additonal forms? Brant: Yes but I would need to work with James from another team as he needs to unblock the sign up workflow. Miguel can you document any other concerns so that I can discuss with James only once? Miguel: Sure. From the meeting transcript above, Create a list of action items for each person. """ body = json.dumps({ "inputText": prompt, "textGenerationConfig": { "maxTokenCount": 4096, "stopSequences": [], "temperature": 0, "topP": 1 } }) response_body = generate_text(model_id, body) print(f"Input token count: {response_body['inputTextTokenCount']}") for result in response_body['results']: print(f"Token count: {result['tokenCount']}") print(f"Output text: {result['outputText']}") print(f"Completion reason: {result['completionReason']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except ImageError as err: logger.error(err.message) print(err.message) else: print( f"Finished generating text with the Amazon &titan-text-express; model {model_id}.") if __name__ == "__main__": main() ``` # Modelos Amazon Titan Image Generator G1 Los modelos Amazon Titan Image Generator G1 V1 y Titan Image Generator G1 V2 admiten los siguientes parámetros de inferencia y respuestas del modelo al realizar la inferencia de modelos. **Topics** + [Parámetros de inferencia](#model-parameters-titan-image-api) + [Ejemplos](#model-parameters-titan-image-code-examples) ## Parámetros de inferencia Cuando realice una llamada a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o con los modelos Amazon Titan Image Generator, sustituya el campo `body` de la solicitud por el formato que se corresponda con 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\$1IMAGE | textToImageParams | Generación | Genere una imagen mediante un petición de texto. | | TEXT\$1IMAGE | textToImageParams | Generación | (Solo acondicionamiento de imagen, versión 2) Proporcione una imagen de acondicionamiento de entrada adicional junto con una petición 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\$1VARIATION | imageVariationParams | Edición | Modifique una imagen produciendo variaciones de la imagen original. | | COLOR\$1GUIDED\$1GENERATION (V2 only) | colorGuidedGenerationParams | Generación | Proporcione una lista de códigos de colores hexadecimales junto con una petición de texto para generar una imagen que siga la paleta de colores. | | BACKGROUND\$1REMOVAL (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 canales RGB, 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 tener formato PNG o JPEG. 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 imagen JPEG o PNG de salida 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 solicitudes de API correspondientes a los distintos casos de uso de la generación de imágenes y las explicaciones de los campos. ------ #### [ Text-to-image generation (Request) ] La petición de texto para generar la imagen puede tener como máximo 512 caracteres. Un máximo de resolución de 1408 en la parte más larga. negativeText (opcional): una petición de texto para definir lo que no se debe incluir en la imagen que tiene como máximo 512 caracteres. Consulte la tabla siguiente para ver una lista completa de resoluciones. ``` { "taskType": "TEXT_IMAGE", "textToImageParams": { "text": "string", "negativeText": "string" }, "imageGenerationConfig": { "quality": "standard" | "premium", "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): una petición 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 un máximo de 512 caracteres. negativeText (opcional): una petición de texto para definir lo que no se debe incluir en la imagen. Debe tener un máximo de 512 caracteres. Los límites de tamaño de la imagen de entrada y la máscara de entrada son como máximo de 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": { "quality": "standard" | "premium", "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. + **image** (obligatoria): la imagen JPEG o PNG que se va a modificar, con el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en valores RGB 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](#model-parameters-titan-image-code-examples). + 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 la `image`. Cada píxel se convierte en un valor RGB 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](#model-parameters-titan-image-code-examples). + **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): una petición 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 un máximo de 512 caracteres. negativeText (opcional): una petición de texto para definir lo que no se debe incluir en la imagen. Debe tener un máximo de 512 caracteres. Los límites de tamaño de la imagen de entrada y la máscara de entrada son como máximo de 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": { "quality": "standard" | "premium", "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 quiere modificar. La generación amplía de manera fluida la región que defina. + **image** (obligatoria): la imagen JPEG o PNG que se va a modificar, con el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en valores RGB 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](#model-parameters-titan-image-code-examples). + 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 la `image`. Cada píxel se convierte en un valor RGB 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](#model-parameters-titan-image-code-examples). + **text** (obligatorio): una petición de texto para definir qué se debe cambiar fuera de la máscara. + **negativeText** (opcional): una petición 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 del interior de la máscara con el fin de mantenerla coherente con el fondo reconstruido. + PRECISE: utilice esta opción para evitar que se modifique 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. Los límites de tamaño de la imagen de entrada son como máximo de 1408 en el lado más largo de la imagen. Consulte la tabla siguiente para ver una lista completa de 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 un máximo de 512 caracteres. + negativeText (opcional): una petición de texto para definir lo que no se debe incluir en la imagen. Debe tener un máximo de 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 un máximo de 512 caracteres. + similarityStrength (opcional): especifica el grado de similitud que debe tener la imagen generada con las imágenes de entrada. Utilice un valor más bajo para introducir más aleatoriedad a la generación. El rango aceptado está comprendido entre 0,2 y 1,0 (ambos inclusive). Si falta este parámetro en la solicitud, se utiliza el valor predeterminado 0,7. ``` { "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 } } ``` Los campos `imageVariationParams` se definen a continuación. + **images** (obligatorio): una lista de imágenes para las que se pueden generar variaciones. Puede incluir entre una y cinco 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](#model-parameters-titan-image-code-examples). + **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 el grado de similitud que debe tener la imagen generada con las imágenes de entrada. El rango oscila entre 0,2 y 1,0 y se utilizan valores bajos para introducir más aleatoriedad. + **negativeText** (opcional): una petición 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 condicionada permite a los clientes aumentar la generación de texto a imagen al proporcionar una “imagen condicionada” para lograr un control más preciso de la imagen generada resultante. + Detección de canny edge + Mapa de segmentación La petición de texto para generar la imagen puede tener un máximo de 512 caracteres. Un máximo de resolución de 1408 en la parte más larga. negativeText (opcional) es una petición de texto para definir lo que no se debe incluir en la imagen y que tiene como máximo 512 caracteres. Consulte la tabla siguiente para ver una lista completa de 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": { "quality": "standard" | "premium", "numberOfImages": int, "height": int, "width": int, "cfgScale": float, "seed": int } } ``` + **texto** (obligatorio): una petición de texto para generar la imagen. + **negativeText** (opcional): una petición 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 de acondicionamiento 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\$1EDGE y SEGMENTATION. El valor predeterminado es CANNY\$1EDGE. + **controlStrength** (solo en V2 opcional): especifica lo similares que deben ser el diseño y la composición de la imagen generada con conditioningImage. El rango oscila entre 0 y 1,0 y se utilizan valores bajos para introducir más aleatoriedad. El valor predeterminado es 0,7. **nota** Si se proporciona controlMode o controlStrength, también se debe proporcionar conditionImage. ------ #### [ Color Guided Content (Request) V2 only ] Proporcione una lista de códigos de colores hexadecimales junto con una petición de texto para generar una imagen que siga la paleta de colores. La petición de texto para generar la imagen puede tener como máximo 512 caracteres. La resolución máxima es de 1408 en el lado más largo. Se necesita una lista de uno a diez códigos de color hexadecimales para especificar los colores de la imagen generada. negativeText es opcional. Una petición de texto para definir lo que no se debe incluir 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 referencia RGB 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": { "quality": "standard" | "premium", "numberOfImages": int, "height": int, "width": int, "cfgScale": float, "seed": int } } ``` Los campos colorGuidedGenerationParams se describen a continuación. Tenga en cuenta que este parámetro es solo para la versión 2. + **texto** (obligatorio): una petición de texto para generar la imagen. + **colors** (obligatorio): lista de hasta diez códigos de color hexadecimales para especificar los colores de la imagen generada. + **negativeText** (opcional): una petición 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 única imagen de referencia de entrada 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 las solicitudes** ``` { "taskType": "BACKGROUND_REMOVAL", "backgroundRemovalParams": { "image": "base64-encoded string" } } ``` **Formato de las respuestas** ``` { "images": [ "base64-encoded string", ... ], "error": "string" } ``` El campo backgroundRemovalParams se describe a continuación. + **image** (obligatoria): la imagen JPEG o PNG que se va a modificar, con el formato de una cadena que especifica una secuencia de píxeles, cada uno definido en valores RGB 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 valores RGB 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](#model-parameters-titan-image-code-examples). + `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. + **quality**: la calidad de la imagen. El valor predeterminado es `standard`. Para obtener más información sobre precios, consulte [Precios de Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/). + **numberOfImages** (opcional): el número de imágenes que se van a generar. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-image.html) + **cfgScale** (opcional): especifica la intensidad con la que la imagen generada debe adherirse a la petición. Utilice un valor más bajo para introducir más asignación al azar en la generación. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-image.html) + 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](https://aws.amazon.com/bedrock/pricing/). + **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. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-image.html) + **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. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-image.html) ## Ejemplos Los siguientes ejemplos muestran cómo invocar el modelo Amazon Titan Image Generator con rendimiento bajo demanda en el SDK para Python. 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() ``` ------ # Amazon Titan Embeddings G1 - Text Titan Embeddings G1 - Text no admite el uso de parámetros de inferencia. En las siguientes secciones se detallan los formatos de solicitud y respuesta y se proporciona un ejemplo de código. **Topics** + [Solicitud y respuesta](#model-parameters-titan-embed-text-request-response) + [Código de ejemplo](#api-inference-examples-titan-embed-text) ## Solicitud y respuesta El cuerpo de la solicitud se pasa al campo `body` de una solicitud [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). ------ #### [ V2 Request ] El parámetro inputText es obligatorio. Los parámetros de la normalización y las dimensiones son opcionales. + inputText: introduzca texto para convertirlo en una incrustación. + normalize (opcional): indicador que especifica si se debe normalizar o no la incrustación de salida. El valor predeterminado es true (verdadero). + dimensions (opcional): el número de dimensiones que debe tener la incrustación de salida. Se aceptan los siguientes valores: 1024 (predeterminado), 512, 256. + embeddingTypes: (opcional) acepta una lista que contenga “float”, “binary” o ambos. El valor predeterminado es `float`. ``` { "inputText": string, "dimensions": int, "normalize": boolean, "embeddingTypes": list } ``` ------ #### [ V2 Response ] Los campos se describen a continuación. + embedding: matriz que representa el vector de incrustación de la entrada que ha proporcionado. Siempre será del tipo `float`. + inputTextTokenCount: número de tokens de la entrada. + embeddingsByType: diccionario o mapa de la lista de incrustaciones. Según la entrada, muestra “float”, “binary” o ambos. + Ejemplo:: `"embeddingsByType": {"binary": [int,..], "float": [float,...]}` + Este campo aparecerá siempre. Incluso si no especifica `embeddingTypes` en la entrada, seguirá apareciendo “float”. Ejemplo:: `"embeddingsByType": {"float": [float,...]}` ``` { "embedding": [float, float, ...], "inputTextTokenCount": int, "embeddingsByType": {"binary": [int,..], "float": [float,...]} } ``` ------ #### [ G1 Request ] El único campo disponible es `inputText` y en él puede incluir texto para convertirlo en una incrustación. ``` { "inputText": string } ``` ------ #### [ G1 Response ] El `body` de la respuesta contiene los siguientes campos. ``` { "embedding": [float, float, ...], "inputTextTokenCount": int } ``` Los campos se describen a continuación. + **embedding**: matriz que representa el vector de incrustación de la entrada que ha proporcionado. + **inputTextTokenCount**: número de tokens de la entrada. ------ ## Código de ejemplo Los siguientes ejemplos muestran cómo llamar a los modelos de incrustación de Amazon Titan para generar incrustaciones. Seleccione la pestaña correspondiente al modelo que esté utilizando: ------ #### [ Amazon Titan Embeddings G1 - Text ] ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate an embedding with the Amazon Titan Embeddings G1 - Text model (on demand). """ import json import logging import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_embedding(model_id, body): """ Generate an embedding with the vector representation of a text input using Amazon Titan Embeddings G1 - Text on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (JSON): The embedding created by the model and the number of input tokens. """ logger.info("Generating an embedding with Amazon Titan Embeddings G1 - Text model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get('body').read()) return response_body def main(): """ Entrypoint for Amazon Titan Embeddings G1 - Text example. """ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = "amazon.titan-embed-text-v1" input_text = "What are the different services that you offer?" # Create request body. body = json.dumps({ "inputText": input_text, }) try: response = generate_embedding(model_id, body) print(f"Generated an embedding: {response['embedding']}") print(f"Input Token count: {response['inputTextTokenCount']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) else: print(f"Finished generating an embedding with Amazon Titan Embeddings G1 - Text model {model_id}.") if __name__ == "__main__": main() ``` ------ #### [ Amazon Titan Text Embeddings V2 ] Cuando se usa Titan Text Embeddings V2, el campo `embedding` no está en la respuesta si `embeddingTypes` solo contiene `binary`. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model """ import json import logging import boto3 from botocore.exceptions import ClientError logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_embedding(model_id, body): """ Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (JSON): The embedding created by the model and the number of input tokens. """ logger.info("Generating an embedding with Amazon Titan Text Embeddings V2 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get('body').read()) return response_body def main(): """ Entrypoint for Amazon Titan Embeddings V2 - Text example. """ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = "amazon.titan-embed-text-v2:0" input_text = "What are the different services that you offer?" # Create request body. body = json.dumps({ "inputText": input_text, "embeddingTypes": ["binary"] }) try: response = generate_embedding(model_id, body) print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding print(f"Input text: {input_text}") print(f"Input Token count: {response['inputTextTokenCount']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) else: print(f"Finished generating an embedding with Amazon Titan Text Embeddings V2 model {model_id}.") if __name__ == "__main__": main() ``` ------ # Amazon Titan Multimodal Embeddings G1 Esta sección contiene formatos del cuerpo de solicitudes y respuestas y ejemplos de código para usar Amazon Titan Multimodal Embeddings G1. **Topics** + [Solicitud y respuesta](#model-parameters-titan-embed-mm-request-response) + [Código de ejemplo](#api-inference-examples-titan-embed-mm) ## Solicitud y respuesta El cuerpo de la solicitud se pasa al campo `body` de una solicitud [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). ------ #### [ Request ] El cuerpo de la solicitud de Amazon Titan Multimodal Embeddings G1 incluye los siguientes campos. ``` { "inputText": string, "inputImage": base64-encoded string, "embeddingConfig": { "outputEmbeddingLength": 256 | 384 | 1024 } } ``` Se requiere al menos uno de los siguientes campos. Incluya ambos para generar un vector de incrustaciones que promedie las incrustaciones de texto y los vectores de incrustaciones de imágenes resultantes. + inputText: introduzca texto para convertirlo en incrustaciones. + **inputImage**: codifique la imagen que desee convertir en incrustaciones en base64 e introduzca la cadena en este campo. 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](#api-inference-examples-titan-embed-mm). El siguiente campo es opcional. + **embeddingConfig**: contiene un campo `outputEmbeddingLength` en el que se especifica una de las siguientes longitudes para el vector de incrustaciones de salida. + 256 + 384 + 1024 (predeterminado) ------ #### [ Response ] El `body` de la respuesta contiene los siguientes campos. ``` { "embedding": [float, float, ...], "inputTextTokenCount": int, "message": string } ``` Los campos se describen a continuación. + **embedding**: matriz que representa el vector de incrustaciones de la entrada que ha proporcionado. + **inputTextTokenCount**: número de tokens que aparece en la entrada de texto. + **message**: especifica los errores que se producen durante la generación. ------ ## Código de ejemplo Los siguientes ejemplos muestran cómo invocar el modelo Amazon Titan Multimodal Embeddings G1 con rendimiento bajo demanda en el SDK de Python. Seleccione una pestaña para ver un ejemplo de cada caso de uso. ------ #### [ Text embeddings ] En este ejemplo se muestra cómo llamar al modelo Amazon Titan Multimodal Embeddings G1 para generar incrustaciones de texto. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate embeddings from text with the Amazon Titan Multimodal Embeddings G1 model (on demand). """ import json import logging import boto3 from botocore.exceptions import ClientError class EmbedError(Exception): "Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_embeddings(model_id, body): """ Generate a vector of embeddings for a text input using Amazon Titan Multimodal Embeddings G1 on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (JSON): The embeddings that the model generated, token information, and the reason the model stopped generating embeddings. """ logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get('body').read()) finish_reason = response_body.get("message") if finish_reason is not None: raise EmbedError(f"Embeddings generation error: {finish_reason}") return response_body def main(): """ Entrypoint for Amazon Titan Multimodal Embeddings G1 example. """ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = "amazon.titan-embed-image-v1" input_text = "What are the different services that you offer?" output_embedding_length = 256 # Create request body. body = json.dumps({ "inputText": input_text, "embeddingConfig": { "outputEmbeddingLength": output_embedding_length } }) try: response = generate_embeddings(model_id, body) print(f"Generated text embeddings of length {output_embedding_length}: {response['embedding']}") print(f"Input text token count: {response['inputTextTokenCount']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except EmbedError as err: logger.error(err.message) print(err.message) else: print(f"Finished generating text embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.") if __name__ == "__main__": main() ``` ------ #### [ Image embeddings ] En este ejemplo se muestra cómo llamar al modelo Amazon Titan Multimodal Embeddings G1 para generar incrustaciones de imágenes. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate embeddings from an image with the Amazon Titan Multimodal Embeddings G1 model (on demand). """ import base64 import json import logging import boto3 from botocore.exceptions import ClientError class EmbedError(Exception): "Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_embeddings(model_id, body): """ Generate a vector of embeddings for an image input using Amazon Titan Multimodal Embeddings G1 on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (JSON): The embeddings that the model generated, token information, and the reason the model stopped generating embeddings. """ logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get('body').read()) finish_reason = response_body.get("message") if finish_reason is not None: raise EmbedError(f"Embeddings generation error: {finish_reason}") return response_body def main(): """ Entrypoint for Amazon Titan Multimodal Embeddings G1 example. """ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') model_id = 'amazon.titan-embed-image-v1' output_embedding_length = 256 # Create request body. body = json.dumps({ "inputImage": input_image, "embeddingConfig": { "outputEmbeddingLength": output_embedding_length } }) try: response = generate_embeddings(model_id, body) print(f"Generated image embeddings of length {output_embedding_length}: {response['embedding']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except EmbedError as err: logger.error(err.message) print(err.message) else: print(f"Finished generating image embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.") if __name__ == "__main__": main() ``` ------ #### [ Text and image embeddings ] En este ejemplo se muestra cómo llamar al modelo Amazon Titan Multimodal Embeddings G1 para generar incrustaciones de una entrada combinada de texto e imágenes. El vector resultante es el promedio del vector de incrustaciones de texto generado y del vector de incrustaciones de imágenes. ``` # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 """ Shows how to generate embeddings from an image and accompanying text with the Amazon Titan Multimodal Embeddings G1 model (on demand). """ import base64 import json import logging import boto3 from botocore.exceptions import ClientError class EmbedError(Exception): "Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1" def __init__(self, message): self.message = message logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def generate_embeddings(model_id, body): """ Generate a vector of embeddings for a combined text and image input using Amazon Titan Multimodal Embeddings G1 on demand. Args: model_id (str): The model ID to use. body (str) : The request body to use. Returns: response (JSON): The embeddings that the model generated, token information, and the reason the model stopped generating embeddings. """ logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id) bedrock = boto3.client(service_name='bedrock-runtime') accept = "application/json" content_type = "application/json" response = bedrock.invoke_model( body=body, modelId=model_id, accept=accept, contentType=content_type ) response_body = json.loads(response.get('body').read()) finish_reason = response_body.get("message") if finish_reason is not None: raise EmbedError(f"Embeddings generation error: {finish_reason}") return response_body def main(): """ Entrypoint for Amazon Titan Multimodal Embeddings G1 example. """ logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") model_id = "amazon.titan-embed-image-v1" input_text = "A family eating dinner" # Read image from file and encode it as base64 string. with open("/path/to/image", "rb") as image_file: input_image = base64.b64encode(image_file.read()).decode('utf8') output_embedding_length = 256 # Create request body. body = json.dumps({ "inputText": input_text, "inputImage": input_image, "embeddingConfig": { "outputEmbeddingLength": output_embedding_length } }) try: response = generate_embeddings(model_id, body) print(f"Generated embeddings of length {output_embedding_length}: {response['embedding']}") print(f"Input text token count: {response['inputTextTokenCount']}") except ClientError as err: message = err.response["Error"]["Message"] logger.error("A client error occurred: %s", message) print("A client error occured: " + format(message)) except EmbedError as err: logger.error(err.message) print(err.message) else: print(f"Finished generating embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.") if __name__ == "__main__": main() ``` ------