Stability.ai Diffusion 1.0 image vers image

Le modèle Stability.ai Diffusion 1.0 comporte les paramètres d’inférence et la réponse du modèle suivants pour effectuer des appels d’inférence image vers image.

Demande et réponse

Le corps de la demande est transmis dans le body champ d'une demande à InvokeModelou InvokeModelWithResponseStream.

Pour plus d'informations, consultez https://platform.stability.ai/docs/api-reference#tag/v1generation/operation/ imageToImage.

Request

Le modèle Stability.ai Diffusion 1.0 comporte les paramètres d’inférence suivants pour un appel d’inférence image vers image.

{
        "text_prompts": [
            {
                "text": string,
                "weight": float
            }
        ],
        "init_image" : string ,
        "init_image_mode" : string,
        "image_strength" : float,
        "cfg_scale": float,
        "clip_guidance_preset": string,
        "sampler": string,
        "samples" : int,
        "seed": int,
        "steps": int,
        "style_preset": string,
        "extras" : json object
}
                       

Les paramètres suivants sont obligatoires.

• text_prompts (obligatoire) : tableau d’invites de texte à utiliser pour la génération. Chaque élément est un JSON objet qui contient une invite et un poids pour l'invite.

  • text : invite que vous souhaitez transmettre au modèle.

    Minimum	Maximum
    0	2000

  • weight (facultatif) : pondération que le modèle doit appliquer à l’invite. Une valeur inférieure à zéro indique une invite négative. Utilisez une invite négative pour indiquer au modèle d’éviter certains concepts. La valeur par défaut de weight est un.

• init_image (obligatoire) : image codée en base64 que vous souhaitez utiliser pour initialiser le processus de diffusion.

Les paramètres suivants sont facultatifs.

• init_image_mode (facultatif) : détermine s’il faut utiliser image_strength ou step_schedule_* pour contrôler l’influence de l’image indiquée dans init_image sur le résultat. Les valeurs possibles sont IMAGE_STRENGTH ou STEP_SCHEDULE. La valeur par défaut est IMAGE _STRENGTH.

• image_strength (facultatif) : détermine l’influence de l’image source indiquée dans init_image sur le processus de diffusion. Les valeurs proches de 1 produisent des images très similaires à l’image source. Les valeurs proches de 0 produisent des images très différentes de l’image source.

• cfg_scale (facultatif) : détermine dans quelle mesure l’image finale représente l’invite. Utilisez un nombre inférieur pour augmenter le caractère aléatoire de la génération.

  Par défaut	Minimum	Maximum
  7	0	35

• clip_guidance_preset (facultatif) : énumération : FAST_BLUE, FAST_GREEN, NONE, SIMPLE, SLOW, SLOWER, SLOWEST.

• sampler (facultatif) : échantillonneur à utiliser pour le processus de diffusion. Si cette valeur est omise, le modèle sélectionne automatiquement un échantillonneur approprié.

  Énumération : 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 (facultatif) : nombre d’images à générer. Amazon Bedrock prend actuellement en charge la génération d’une seule image. Si vous fournissez une valeur pour samples, elle doit être égale à un.

  Par défaut	Minimum	Maximum
  1	1	1

• seed (facultatif) : l’amorçage détermine le réglage initial du bruit. Utilisez le même amorçage et les mêmes paramètres que lors de l'exécution précédente pour permettre à l'inférence de créer une image similaire. Si vous ne définissez pas cette valeur, ou si elle est égale à 0, un nombre aléatoire est choisi.

  Par défaut	Minimum	Maximum
  0	0	4294967295

• steps (facultatif) : l’étape de génération détermine le nombre de fois où l’image est échantillonnée. Un plus grand nombre d'étapes contribue à obtenir un résultat plus précis.

  Par défaut	Minimum	Maximum
  30	10	50

• style_preset (facultatif) : préréglage de style qui guide le modèle d’image vers un style particulier. Cette liste de préréglages de style est susceptible d’être modifiée.

  Énumération : 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 (facultatif) : paramètres supplémentaires transmis au moteur. À utiliser avec précaution. Ces paramètres sont utilisés pour des fonctionnalités en cours de développement ou expérimentales et peuvent être modifiés sans avertissement.

Response

Le modèle Stability.ai Diffusion 1.0 renvoie les champs suivants pour un appel d’inférence texte vers image.

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

• result : résultat de l’opération. En cas de succès, la réponse est success.

• artifacts : tableau d’images, une pour chaque image demandée.

  • seed : valeur de l’amorçage utilisé pour générer l’image.

  • base64 : image codée en base64 générée par le modèle.

  • finishedReason— Le résultat du processus de génération de l'image. Les valeurs valides sont :

    • SUCCESS— Le processus de génération d'image a réussi.

    • ERROR— Une erreur s'est produite.

    • CONTENT_ FILTERED — Le filtre de contenu a filtré l'image et celle-ci est peut-être floue.

Exemple de code

L’exemple suivant montre comment exécuter l’inférence avec le modèle Stability.ai Diffusion 1.0 et le débit à la demande. L’exemple envoie une invite de texte et une image de référence à un modèle, extrait la réponse du modèle et enfin, affiche l’image.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an image from a reference 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="""A space ship."""

    # Read reference image from file and encode as base64 strings.
    with open("/path/to/image", "rb") as image_file:
        init_image = base64.b64encode(image_file.read()).decode('utf8')

    # Create request body.
    body=json.dumps({
        "text_prompts": [
        {
        "text": prompt
        }
    ],
    "init_image": init_image,
    "style_preset" : "isometric"
    })

    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()