Stability.ai Diffusion 1.0 Bild zu Bild

Das Modell Stability.ai Diffusion 1.0 verfügt über die folgenden Inferenzparameter und die folgende Modellantwort für Bild-zu-Bild-Inferenzaufrufe.

Anforderung und Antwort

Der Anfragetext wird im body Feld einer Anfrage an InvokeModeloder übergeben InvokeModelWithResponseStream.

Weitere Informationen finden Sie unter https://platform.stability.ai/docs/api-reference#tag/v1generation/operation/ imageToImage.

Request

Das Modell Stability.ai Diffusion 1.0 verfügt über die folgenden Inferenzparameter für Bild-zu-Bild-Inferenzaufrufe.

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

Die folgenden Parameter sind erforderlich.

• text_prompts: (Erforderlich) Eine Reihe von Textaufforderungen, die für die Generierung verwendet werden sollen. Jedes Element ist ein JSON-Objekt, das eine Eingabeaufforderung und eine Gewichtung der Eingabeaufforderung enthält.

  • text: Die Eingabeaufforderung, die Sie an das Modell übergeben möchten.

    Minimum	Maximum
    0	2000

  • weight: (Optional) Die Gewichtung, die das Modell auf die Eingabeaufforderung anwenden soll. Ein Wert kleiner als Null deklariert eine negative Eingabeaufforderung. Verwenden Sie eine negative Eingabeaufforderung, um das Modell anzuweisen, bestimmte Konzepte zu vermeiden. Der Standardwert für weight beträgt eins.

• init_image: (Erforderlich) Das base64-kodierte Bild, das Sie zur Initialisierung des Diffusionsprozesses verwenden möchten.

Die folgenden Parameter sind optional.

• init_image_mode: (Optional) Legt fest, ob image_strength oder step_schedule_* verwendet werden soll, um den Einfluss des Bild in init_image auf das Ergebnis zu steuern. Die möglichen Wert sind IMAGE_STRENGTH oder STEP_SCHEDULE. Die Standardeinstellung ist IMAGE_STRENGTH.

• image_strength: (Optional) Bestimmt, inwiefern das Quellbild in init_image den Diffusionsprozess beeinflusst. Werte nahe 1 ergeben Bilder, die dem Quellbild sehr ähnlich sind. Werte nahe 0 ergeben Bilder, die dem Quellbild sehr unähnlich sind.

• cfg_scale: (Optional) Legt fest, inwiefern das endgültige Bild die Eingabeaufforderung wiedergibt. Verwenden Sie eine niedrigere Zahl, um die Zufälligkeit bei der Generierung zu erhöhen.

  Standard	Minimum	Maximum
  7	0	35

• clip_guidance_preset: (Optional) Aufzählung: FAST_BLUE, FAST_GREEN, NONE, SIMPLE, SLOW, SLOWER, SLOWEST

• sampler: (Optional) Der Sampler, der für den Diffusionsprozess verwendet werden soll. Wenn dieser Wert ausgelassen wird, wählt das Modell automatisch einen geeigneten Sampler für Sie aus.

  Aufzählung: 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.

• numberOfImages: (Optional) Die Anzahl der zu generierenden Bilder. Derzeit unterstützt Amazon Bedrock die Generierung eines Bildes. Wenn Sie einen Wert für samples angeben, muss der Wert eins sein.

  Standard	Minimum	Maximum
  1	1	1

• seed: (Optional) Der Seed bestimmt die anfängliche Einstellung für das Rauschen. Verwenden Sie denselben Startwert und dieselben Einstellungen wie bei einem vorherigen Lauf, damit Inferenzen ein ähnliches Bild erzeugen können. Wenn Sie diesen Wert nicht festlegen oder der Wert 0 ist, wird er als Zufallszahl festgelegt.

  Standard	Minimum	Maximum
  0	0	4294967295

• steps: (Optional) Der Generierungsschritt bestimmt, wie oft das Bild abgetastet wird. Mehr Schritte können zu einem genaueren Ergebnis führen.

  Standard	Minimum	Maximum
  30	10	50

• style_preset: (Optional) Eine Stilvoreinstellung, die das Bildmodell auf einen bestimmten Stil ausrichtet. Diese Liste mit Stilvoreinstellungen ist Änderungen vorbehalten.

  Aufzählung: 3d-model, analog-film, anime, cinematic, comic-book, digital-art, enhance, fantasy-art, isometric, line-art, low-poly, modeling-compound, neon-punk, origami, photographic, pixel-art, tile-texture

• extras: (Optional) Zusätzliche Parameter, die an die Engine übergeben werden. Verwenden Sie es mit Bedacht. Diese Parameter werden für in der Entwicklung befindliche oder experimentelle Funktionen verwendet und können sich ohne Vorwarnung ändern.

Response

Das Modell Stability.ai Diffusion 1.0 verfügt über die folgenden Felder für Text-zu-Bild-Inferenzaufrufe.

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

• result: Das Ergebnis der Operation. Bei Erfolg lautet die Antwort success.

• artifacts: Eine Reihe von Bildern, eines für jedes angeforderte Bild.

  • seed: Der Wert des Seeds, der zur Generierung des Bildes verwendet wurde.

  • base64: Das base64-kodierte Bild, das das Modell generiert hat.

  • finishedReason: Das Ergebnis des Bildgenerierungsprozesses. Gültige Werte für sind:

    • SUCCESS: Der Bildgenerierungsprozess war erfolgreich.

    • ERROR: Es ist ein Fehler aufgetreten.

    • CONTENT_FILTERED: Der Inhaltsfilter hat das Bild gefiltert und das Bild ist möglicherweise unscharf.

Codebeispiel

Das folgende Beispiel zeigt, wie Inferenzen mit dem Modell Stability.ai Diffusion 1.0 und On-Demand-Durchsatz ausgeführt werden. Im Beispiel wird eine Textaufforderung und das Referenzbild an ein Modell gesendet, die Antwort aus dem Modell abgerufen und schließlich das Bild angezeigt.

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