Stability.ai Diffusion 1.0 Text zu Bild

Das Modell Stability.ai Diffusion 1.0 verfügt über die folgenden Inferenzparameter und die folgende Modellantwort für Text-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.

Request

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

{
        "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 (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.

• 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.

  Minimum	Maximum	Standard
  0	35	7

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

• height: (Optional) Höhe des zu generierenden Bilds in Pixeln, in einer durch 64 teilbaren Steigerung.

  Der Wert muss einer der folgenden sein: 1024x1024, 1152x896, 1216x832, 1344x768, 1536x640, 640x1536, 768x1344, 832x1216, 896x1152.

• width: (Optional) Höhe des zu generierenden Bilds in Pixeln, in einer durch 64 teilbaren Steigerung.

  Der Wert muss einer der folgenden sein: 1024x1024, 1152x896, 1216x832, 1344x768, 1536x640, 640x1536, 768x1344, 832x1216, 896x1152.

• 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.

  Minimum	Maximum	Standard
  0	4294967295	0

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

  Minimum	Maximum	Standard
  10	50	30

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