Stability.ai Diffusion 1.0 de texto para imagem

O modelo Stability.ai Diffusion 1.0 tem os parâmetros de inferência e a resposta de modelo a seguir para fazer chamadas de inferência de texto para imagem.

Solicitação e reposta

O corpo da solicitação é passado no body campo de uma solicitação para InvokeModelou InvokeModelWithResponseStream.

Para obter mais informações, consulte https://platform.stability.ai/docs/api-reference#tag/v1generation.

Request

O modelo Stability.ai Diffusion 1.0 tem os parâmetros de inferência a seguir para chamadas de inferência de texto para imagem.

{
        "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 (obrigatório): uma matriz de prompts de texto a serem usados na geração. Cada elemento é um JSON objeto que contém uma solicitação e um peso para a solicitação.

  • text: o prompt que você deseja enviar ao modelo.

    Mínimo	Máximo
    0	2000

  • peso (opcional): o peso que o modelo deve aplicar ao prompt. Um valor menor que zero declara um prompt negativo. Use um prompt negativo para fazer com que o modelo evite certos conceitos. O valor padrão para weight é 1.

• cfg_scale (opcional): determina o quanto a imagem final retrata o prompt. Use um número menor para aumentar a aleatoriedade na geração.

  Mínimo	Máximo	Padrão
  0	35	7

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

• altura — (Opcional) Altura da imagem a ser gerada, em pixels, em um incremento divisível por 64.

  O valor deve ser um dos seguintes: 1024x1024, 1152x896, 1216x832, 1344x768, 1536x640, 640x1536, 768x1344, 832x1216, 896x1152.

• largura — (Opcional) Largura da imagem a ser gerada, em pixels, em um incremento divisível por 64.

  O valor deve ser um dos seguintes: 1024x1024, 1152x896, 1216x832, 1344x768, 1536x640, 640x1536, 768x1344, 832x1216, 896x1152.

• sampler (Opcional): o amostrador a ser usado no processo de difusão. Se esse valor for omitido, o modelo selecionará automaticamente um amostrador apropriado para você.

  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): o número de imagens a serem geradas. No momento, o Amazon Bedrock oferece suporte à geração de uma imagem. Se você fornecer um valor para samples, esse valor deverá ser um.

  Padrão	Mínimo	Máximo
  1	1	1

• seed (opcional): a semente determina a configuração inicial de ruído. Use a mesma semente e as mesmas configurações de uma execução anterior para permitir que a inferência crie uma imagem semelhante. Se você não definir esse valor ou se for 0, ele será definido como um número aleatório.

  Mínimo	Máximo	Padrão
  0	4294967295	0

• steps (opcional): a etapa de geração determina quantas vezes a imagem é amostrada. Mais etapas podem resultar em um resultado mais preciso.

  Mínimo	Máximo	Padrão
  10	150	30

• style_preset (opcional): uma predefinição de estilo que orienta o modelo de imagem em direção a um estilo específico. Essa lista de predefinições de estilo está sujeita a alterações.

  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 extras enviados ao mecanismo. Use com cautela. Esses parâmetros são usados para recursos experimentais ou em desenvolvimento e podem ser alterados sem aviso prévio.

Response

O modelo Stability.ai Diffusion 1.0 retorna os campos a seguir para chamadas de inferência de texto para imagem.

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

• result: o resultado da operação. Se for bem-sucedida, a resposta será success.

• artifacts: uma matriz de imagens, uma para cada imagem solicitada.

  • seed: o valor da semente usada para gerar a imagem.

  • base64: a imagem codificada em base64 que o modelo gerou.

  • finishedReason— O resultado do processo de geração de imagens. Os valores válidos são:

    • SUCCESS— O processo de geração de imagens foi bem-sucedido.

    • ERROR— Ocorreu um erro.

    • CONTENT_ FILTERED — O filtro de conteúdo filtrou a imagem e a imagem pode ficar desfocada.

Exemplo de código

O exemplo a seguir mostra como executar inferência com o modelo Stability.ai Diffusion 1.0 e o throughput sob demanda. O exemplo envia um prompt de texto para um modelo, recupera a resposta do modelo e, por fim, mostra a imagem.

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