Stability.ai Diffusion 1.0 texto a imagen

El modelo Stability.ai Diffusion 1.0 tiene los siguientes parámetros de inferencia y la respuesta del modelo para realizar llamadas de inferencia de texto a imagen.

Solicitud y respuesta

El cuerpo de la solicitud se pasa en el body campo de una solicitud a InvokeModelo InvokeModelWithResponseStream.

Para obtener más información, consulte https://platform.stability.ai/docs/api-reference#tag/v1generation.

Request

El modelo Stability.ai Diffusion 1.0 tiene los siguientes parámetros de inferencia para realizar llamadas de inferencia de texto a imagen.

{
        "text_prompts": [
            {
                "text": string,
                "weight": float
            }
        ],
        "height": int,
        "width": int,
        "cfg_scale": float,
        "clip_guidance_preset": string,
        "sampler": string,
        "samples",
        "seed": int,
        "steps": int,
        "style_preset": string,
        "extras" :JSON object
        
}
                       

• text_prompts (obligatorio): una matriz de mensajes de texto que se utilizan en la generación. Cada elemento es un JSON objeto que contiene una solicitud y un peso para la solicitud.

  • text: el mensaje que desea pasar al modelo.

    Mínimo	Máximo
    0	2000

  • weight (opcional): la ponderación que el modelo debe aplicar a la petición. Un valor inferior a cero declara una petición negativa. Utilice una petición negativa para indicar al modelo que evite ciertos conceptos. El valor predeterminado de weight es uno.

• cfg_scale: (opcional) determina en qué medida la imagen final representa la petición. Utilice un número más bajo para aumentar la asignación al azar de la generación.

  Mínimo	Máximo	Predeterminado
  0	35	7

• clip_guidance_preset– (opcional) Enum: FAST_BLUE, FAST_GREEN, NONE, SIMPLE SLOW, SLOWER, SLOWEST.

• altura: (opcional) Altura de la imagen que se generará, en píxeles, en un incremento divisible por 64.

  El valor debe ser uno de 1024x1024, 1152x896, 1216x832, 1344x768, 1536x640, 640x1536, 768x1344, 832x1216, 896x1152.

• ancho: (opcional) ancho de la imagen que se generará, en píxeles, en un incremento divisible por 64.

  El valor debe ser uno de 1024x1024, 1152x896, 1216x832, 1344x768, 1536x640, 640x1536, 768x1344, 832x1216, 896x1152.

• sampler: (opcional) el muestreador que se utilizará en el proceso de difusión. Si se omite este valor, el modelo seleccionará automáticamente el muestreador adecuado por usted.

  Enum: DDIM, DDPM, K_DPMPP_2M, K_DPMPP_2S_ANCESTRAL, K_DPM_2, K_DPM_2_ANCESTRAL, K_EULER, K_EULER_ANCESTRAL, K_HEUN K_LMS.

• samples (opcional): el número de imágenes que se van a generar. Actualmente, Amazon Bedrock admite la generación de una imagen. Si proporciona un valor para samples, el valor debe ser uno.

  Predeterminado	Mínimo	Máximo
  1	1	1

• seed (opcional): la inicialización 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. Si no establece este valor, o si el valor es 0, se establece como un número aleatorio.

  Mínimo	Máximo	Predeterminado
  0	4294967295	0

• steps: (opcional) el paso de generación determina cuántas veces se muestreará la imagen. Más pasos pueden dar como resultado un resultado más preciso.

  Mínimo	Máximo	Predeterminado
  10	150	30

• style_preset (opcional): un ajuste preestablecido de estilo que guía el modelo de imagen hacia un estilo concreto. Esta lista de estilos preestablecidos está sujeta a cambios.

  Enum: 3d-model, analog-film, animé, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture.

• extras (opcional): parámetros adicionales que se transfieren al motor. Utilice esta opción con precaución. Estos parámetros se utilizan para funciones experimentales o en desarrollo y pueden cambiar sin previo aviso.

Response

El modelo Stability.ai Diffusion 1.0 devuelve los siguientes campos para realizar llamadas de inferencia de texto a imagen.

{
    "result": string,
    "artifacts": [
        {
            "seed": int,
            "base64": string,
            "finishReason": string
        }
    ]
}

• result: el resultado de la operación. Si se ejecuta correctamente, la respuesta es success.

• artifacts: una matriz de imágenes, una para cada imagen solicitada.

  • seed: el valor de la semilla utilizada para generar la imagen.

  • base64: la imagen codificada en base64 que generó el modelo.

  • finishedReason— El resultado del proceso de generación de imágenes. Los valores válidos son:

    • SUCCESS— El proceso de generación de imágenes se realizó correctamente.

    • ERROR— Se ha producido un error.

    • CONTENT_ FILTERED — El filtro de contenido filtró la imagen y es posible que la imagen esté borrosa.

Ejemplo de código

El siguiente ejemplo muestra cómo realizar inferencias con el modelo Stability.ai Diffusion 1.0 y el rendimiento bajo demanda. En el ejemplo se envía una petición de texto a un modelo, se recupera la respuesta del modelo y, por último, se muestra la imagen.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image with SDXL 1.0 (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 SDXL"
    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 SDXL 1.0 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 SDXL 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())
    print(response_body['result'])

    base64_image = response_body.get("artifacts")[0].get("base64")
    base64_bytes = base64_image.encode('ascii')
    image_bytes = base64.b64decode(base64_bytes)

    finish_reason = response_body.get("artifacts")[0].get("finishReason")

    if finish_reason == 'ERROR' or finish_reason == 'CONTENT_FILTERED':
        raise ImageError(f"Image generation error. Error code is {finish_reason}")


    logger.info("Successfully generated image withvthe SDXL 1.0 model %s", model_id)

    return image_bytes



def main():
    """
    Entrypoint for SDXL example.
    """

    logging.basicConfig(level = logging.INFO,
                        format = "%(levelname)s: %(message)s")

    model_id='stability.stable-diffusion-xl-v1'

    prompt="""Sri lanka tea plantation."""

    # Create request body.
    body=json.dumps({
        "text_prompts": [
        {
        "text": prompt
        }
    ],
    "cfg_scale": 10,
    "seed": 0,
    "steps": 50,
    "samples" : 1,
    "style_preset" : "photographic"

    })

    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 text with SDXL model {model_id}.")


if __name__ == "__main__":
    main()