Stability.ai Diffusion 1.0 da immagine a immagine

Il modello Stability.ai Diffusion 1.0 ha i seguenti parametri di inferenza e la risposta del modello per effettuare chiamate di inferenza da immagine a immagine.

Richiesta e risposta

Il corpo della richiesta viene passato nel body campo di una richiesta a InvokeModelo InvokeModelWithResponseStream.

Per ulteriori informazioni, consulta https://platform.stability.ai/docs/api-reference#tag/v1generation/operation/ imageToImage.

Request

Il modello Stability.ai Diffusion 1.0 ha i seguenti parametri di inferenza per effettuare chiamate di inferenza da immagine a immagine.

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

I seguenti sono parametri obbligatori.

• text_prompts (obbligatorio): una matrice di prompt di testo da utilizzare per la generazione. Ogni elemento è un JSON oggetto che contiene un prompt e un peso per il prompt.

  • text: il prompt che desideri passare al modello.

    Minimo	Massimo
    0	2000

  • weight (facoltativo): il peso che il modello deve applicare al prompt. Un valore inferiore a zero dichiara un prompt negativo. Utilizza un prompt negativo per indicare al modello di evitare determinati concetti. Il valore predefinito per weight è uno.

• init_image (obbligatorio): l'immagine con codifica base64 che desideri utilizzare per inizializzare il processo di diffusione.

I seguenti sono parametri opzionali.

• init_image_mode (facoltativo): determina se utilizzare image_strength o step_schedule_* per controllare l'influenza che l'immagine in init_image ha sul risultato. I valori possibili sono IMAGE_STRENGTH o STEP_SCHEDULE. L'impostazione predefinita è _IMAGE. STRENGTH

• image_strength (facoltativo): determina l'influenza dell'immagine di origine in init_image sul processo di diffusione. I valori vicini a 1 producono immagini molto simili all'immagine di origine. I valori vicini a 0 producono immagini molto simili all'immagine di origine.

• cfg_scale (facoltativo): determina in che misura l'immagine finale ritrae il prompt. Utilizza un numero più basso per aumentare la casualità nella generazione.

  Predefinita	Minimo	Massimo
  7	0	35

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

• sampler (facoltativo): il campionatore da utilizzare per il processo di diffusione. Se questo valore viene omesso, il modello seleziona automaticamente un campionatore appropriato.

  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 (facoltativo): il numero di immagini da generare. Attualmente Amazon Bedrock supporta la generazione di un'immagine. Se fornisci un valore per samples, il valore deve essere uno.

  Predefinita	Minimo	Massimo
  1	1	1

• seed (facoltativo): il seed determina l'impostazione iniziale del rumore. Utilizza lo stesso seed e le stesse impostazioni dell'esecuzione precedente per consentire all'inferenza di creare un'immagine simile. Se non imposti questo valore, o il valore è 0, viene impostato su un numero random.

  Predefinita	Minimo	Massimo
  0	0	4294967295

• steps (facoltativo): la fase di generazione determina quante volte l'immagine viene campionata. Ulteriori passaggi possono portare a un risultato più accurato.

  Predefinita	Minimo	Massimo
  30	10	50

• style_preset (facoltativo): una preimpostazione di stile che guida il modello di immagine verso uno stile particolare. Questo elenco di preimpostazioni di stile è soggetto a modifiche.

  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 (facoltativo): parametri aggiuntivi passati al motore. Utilizza questa soluzione con cautela. Questi parametri vengono utilizzati per funzionalità in fase di sviluppo o sperimentali e possono cambiare senza preavviso.

Response

Il modello Stability.ai Diffusion 1.0 ha i seguenti campi per effettuare chiamate di inferenza da testo a immagine.

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

• result: il risultato dell'operazione. In caso di successo, la risposta è success.

• artifacts: una serie di immagini, una per ogni immagine richiesta.

  • seed: il valore del seed utilizzato per generare l'immagine.

  • base64: l'immagine con codifica base64 generata dal modello.

  • finishedReason— Il risultato del processo di generazione dell'immagine. I valori validi sono:

    • SUCCESS— Il processo di generazione dell'immagine è riuscito.

    • ERROR— Si è verificato un errore.

    • CONTENT_ FILTERED — Il filtro dei contenuti ha filtrato l'immagine e l'immagine potrebbe essere sfocata.

esempio di codice

L'esempio seguente mostra come eseguire l'inferenza con il modello Stability.ai Diffusion 1.0 e la velocità di trasmissione effettiva on demand. L'esempio invia un prompt di testo e un'immagine di riferimento a un modello, recupera la risposta dal modello e infine mostra l'immagine.

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