Richiesta e risposta Di alto livello Modifica Controllo

Servizi di immagine Stability AI

Puoi utilizzare Stability AI Image Services con Amazon Bedrock per accedere a tredici strumenti di modifica delle immagini specializzati. Questi strumenti sono progettati per accelerare i flussi di lavoro creativi professionali. Con Stability AI Image Services puoi generare immagini da uno schizzo, ristrutturare e ridisegnare un'immagine esistente. Puoi anche rimuovere e sostituire oggetti all'interno di un'immagine.

Questa sezione descrive come effettuare chiamate di inferenza a Stability AI Image Services utilizzando. InvokeModel Questa sezione fornisce anche esempi di codice in Python ed esempi di immagini prima e dopo l’utilizzo dei servizi di immagine Stability AI.

I servizi di immagine Stability AI sono disponibili nelle seguenti categorie:

Modifica: servizi di modifica delle AI-based immagini, inclusa la pittura con maschere (riempimento generativo) o con parole. Include strumenti per il posizionamento e la pubblicità dei prodotti, oltre a strumenti di base come la rimozione dello sfondo.
Controllo: può richiedere istruzioni, mappe e altre guide. Questi servizi utilizzano ControlNets tecnologie simili basate su modelli Stable Diffusion.

Nota

La sottoscrizione a qualsiasi modifica o controllo Stability AI Image Service ti iscrive automaticamente a tutti i tredici Stability AI Image Services disponibili.

Richiesta e risposta

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

Campo del corpo della richiesta per l’invocazione del modello

Quando effettui una InvokeModel chiamata utilizzando Stability AI Image Services, riempi il campo del corpo con un oggetto JSON simile al seguente.


{
    'prompt': 'Create an image of a panda'
}

Campo del corpo delle risposte per l’invocazione del modello

Quando effettui una InvokeModel chiamata utilizzando Stability AI Image Services, la risposta è simile alla seguente


{
    'seeds': [2130420379], 
    'finish_reasons': [null], 
    'images': ['...']
}

seeds: (stringa) elenco dei seed utilizzati per generare immagini per il modello.
finish_reasons: enum che indica se la richiesta è stata filtrata o meno. null indica che la richiesta è andata a buon fine. Valori correnti possibili: "Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null.
images: un elenco di immagini generate in formato stringa base64.

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

Di alto livello

La sezione seguente descrive gli esclusivi Stability AI Image Services.

Creative Upscale acquisisce immagini tra 64x64 e 1 megapixel e le esegue l'upscaling alla risoluzione 4K. Questo servizio è in grado di eseguire l'upscaling delle immagini da 20 a 40 volte preservando e spesso migliorando la qualità. Creative Upscale funziona al meglio su immagini altamente degradate e non per foto da 1 megapixel o più, in quanto esegue reimmaginazioni complesse.

Creative Upscale ha i seguenti parametri obbligatori:

prompt: cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 da ingrandire. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel deve essere compreso tra 4.096 e 1.048.576 pixel. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

creatività — (numero) Indica quanto deve essere creativo il modello quando si esegue l'upscaling di un'immagine. Valori più alti comporteranno l'aggiunta di maggiori dettagli all'immagine durante l'upscaling. Intervallo compreso tra 0,1 e 0,5. Impostazione predefinita 0,3
negative_prompt — (stringa) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
style_preset — Guida il modello di immagine verso uno stile particolare. Enum: 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.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
        "creativity": 0.30
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
        "creativity": 0.30
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione Creative Upscale. Il prompt utilizzato è: Quest'arte digitale onirica ritrae un Big Ben vibrante e caleidoscopico a Londra.

Input	Output
«Iconica torre del Big Ben contro un cielo nuvoloso» di Willemijn Doelman. https://www.pexels.com/@willemijn-doelman-2155820368/ Concesso in licenza con CC

Conservative Upscale acquisisce immagini tra 64x64 e 1 megapixel e le esegue l'upscaling alla risoluzione 4K. Questo servizio può eseguire l'upscaling delle immagini da 20 a 40 volte preservandone tutti gli aspetti. Conservative Upscale riduce al minimo le alterazioni dell'immagine e non deve essere utilizzato per reimmaginare un'immagine.

Conservative Upscale ha i seguenti parametri richiesti:

prompt — Cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 da ingrandire. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

creatività — (numero) Indica quanto deve essere creativo il modello quando si esegue l'upscaling di un'immagine. Valori più alti comporteranno l'aggiunta di maggiori dettagli all'immagine durante l'upscaling. Intervallo compreso tra 0,1 e 0,5. Impostazione predefinita 0,35
negative_prompt — (stringa) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
        "creativity": 0.30
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
        "creativity": 0.30
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione Conservative Upscale. Il prompt utilizzato è: Quest'arte digitale onirica ritrae un Big Ben vibrante e caleidoscopico a Londra.

Input	Output
«Iconica torre del Big Ben contro un cielo nuvoloso» di Willemijn Doelman. https://www.pexels.com/@willemijn-doelman-2155820368/ Concesso in licenza con CC

Fast Upscale migliora la risoluzione dell'immagine di 4 volte utilizzando l'intelligenza artificiale predittiva e generativa. Questo servizio leggero e veloce è ideale per migliorare la qualità delle immagini compresse, rendendolo adatto per post sui social media e altre applicazioni.

Fast upscale ha i seguenti parametri richiesti:

image — (stringa) L'immagine Base64 da eseguire l'upscaling. La larghezza deve essere compresa tra 32 e 1.536 pixel. L'altezza deve essere compresa tra 32 e 1.536 pixel. Il numero totale di pixel deve essere compreso tra 1.024 e 1.048.576 pixel. Formati supportati: jpeg, png, webp.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione Fast Upscale.

Input	Output
«Iconica torre del Big Ben contro un cielo nuvoloso» di Willemijn Doelman. https://www.pexels.com/@willemijn-doelman-2155820368/ Concesso in licenza con CC

Modifica

Nella sezione seguente viene descritta la modifica dei servizi di immagine Stability AI.

Inpaint modifica in modo intelligente le immagini riempiendo o sostituendo aree specifiche con nuovi contenuti basati sul contenuto di un’immagine di maschera.

Inpaint ha i seguenti parametri richiesti:

prompt — Cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (string) L'immagine Base64 da inpaint. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

style_preset: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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.
negative_prompt — (string) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
mask — (string) Controlla l'intensità del processo di inpainting per pixel. È possibile controllarlo tramite una seconda immagine (passata a questo parametro) o tramite il canale alfa del parametro image.
- Passaggio di una maschera: l'immagine passata a questo parametro deve essere un'immagine in bianco e nero che rappresenti, in qualsiasi pixel, la forza dell'inpainting in base a quanto scuro o chiaro è il pixel specificato. I pixel completamente neri rappresentano assenza di intensità di inpainting, mentre i pixel completamente bianchi rappresentano la massima intensità. Se la maschera ha una dimensione diversa dal parametro dell’immagine, verrà ridimensionata automaticamente.
- Supporto per il canale alfa: se non fornisci una maschera esplicita, ne verrà derivata una dal canale alfa del parametro image. I pixel trasparenti verranno sottoposti a inpainting, mentre i pixel opachi saranno preservati. Nel caso in cui venga fornita un’immagine con un canale alfa insieme a una maschera, la maschera avrà la precedenza.
grow_mask — Fa crescere i bordi della maschera verso l'esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le regioni mascherate vicine.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.png"
mask = "./content/mask.png"

region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
    with open(mask, "rb") as mask_file:
        mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "mask": mask_base64,
        "prompt": "artificer of time and space"
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.png"
mask = "./content/mask.png"

region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
    with open(mask, "rb") as mask_file:
        mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "mask": mask_base64,
        "prompt": "artificer of time and space"
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un’operazione Inpaint.

Input	Mask (Maschera)	Output
“Uomo in una metropoli” generato da Stable Image Ultra, prompt e modifiche da Sanwal Yousaf. Concesso in licenza in CC BY 4.0

Outpaint inserisce contenuti aggiuntivi in un'immagine per riempire lo spazio in qualsiasi direzione. Altri metodi automatici o manuali per espandere il contenuto dell'immagine possono lasciare artefatti visibili. Il servizio Outpaint riduce al minimo le indicazioni che l'immagine originale è stata modificata.

Outpaint ha i seguenti parametri obbligatori:

image — (string) L'immagine Base64 da sostituire. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

Nota
Almeno una direzione di verniciatura: (sinistra, destra, su o giù) deve essere fornita con un valore diverso da zero. Per ottenere risultati di qualità ottimale, tenete conto della composizione e del contenuto dell'immagine originale quando scegliete le direzioni per la verniciatura.

I parametri seguenti sono facoltativi:

prompt: cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
style_preset: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
creatività — (numero) Indica quanto deve essere creativo il modello quando sovrascrive un'immagine. Valori più alti comporteranno l'aggiunta di contenuti più creativi all'immagine durante la verniciatura. Intervallo compreso tra 0,1 e 1,0. Impostazione predefinita: 0,5.
left — (numero intero) Il numero di pixel da sovrapporre sul lato sinistro dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Impostazione predefinita 0.
right — (numero intero) Il numero di pixel da sovrapporre sul lato destro dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Impostazione predefinita 0.
up — (numero intero) Il numero di pixel da sovrapporre nella parte superiore dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Impostazione predefinita 0.
down — (numero intero) Il numero di pixel da sovrapporre nella parte inferiore dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Impostazione predefinita 0.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "left": 512,
        "right": 512,
        "up": 200,
        "down": 100
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "left": 512,
        "right": 512,
        "up": 200,
        "down": 100
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione Outpaint.

Input	Output
«Iconica torre del Big Ben contro un cielo nuvoloso» di Willemijn Doelman. https://www.pexels.com/@willemijn-doelman-2155820368/ Concesso in licenza con CC

Cerca e ricolora consente di cambiare il colore di un oggetto specifico in un’immagine utilizzando un prompt. Questo servizio è una versione specifica di Inpainting che non richiede una maschera. Segmenta automaticamente l’oggetto e lo ricolora utilizzando i colori richiesti nel prompt.

Cerca e ricolora prevede parametri obbligatori seguenti:

prompt — Cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 da ricolorare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
select_prompt — (stringa) Breve descrizione di cosa cercare nell'immagine. Massimo 10000 caratteri.

I parametri seguenti sono facoltativi:

style_preset: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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.
negative_prompt — (stringa) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
grow_mask — Fa crescere i bordi della maschera verso l'esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le regioni mascherate vicine.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "pink jacket",
        "select_prompt": "jacket"
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)

    base64_image_data = model_response["images"][0]
    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "pink jacket",
        "select_prompt": "jacket"
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione di ricerca e ricolora. Il prompt utilizzato è: giacca rosa.

Input	Output
“Uomo che indossa un piumino” generato da Stable Image Ultra, prompt e modifiche di Sanwal Yousaf. Concesso in licenza in CC BY 4.0

Trova e sostituisci consente di utilizzare un prompt di ricerca per identificare un oggetto in un linguaggio semplice da sostituire. Il servizio segmenta automaticamente l’oggetto e lo sostituisce con l’oggetto richiesto nel prompt senza richiedere una maschera.

Trova e sostituisci prevede parametri obbligatori seguenti:

prompt — Cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 da ricolorare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
search_prompt — (string) Breve descrizione di cosa dipingere nell'immagine. Massimo 10000 caratteri.

I parametri seguenti sono facoltativi:

style_preset: (stringa) guida il modello di immagine verso uno stile particolare. Enum: 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.
negative_prompt — (stringa) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
grow_mask — Fa crescere i bordi della maschera verso l'esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le regioni mascherate vicine.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "jacket",
        "search_prompt": "sweater",
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "jacket",
        "search_prompt": "sweater",
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")
    image_data = base64.b64decode(base64_image_data)

    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione di ricerca e sostituzione. Il prompt utilizzato è: giacca.

Input	Output
“Modella che indossa un maglione autunnale” generato da Stable Image Ultra. Prompt e modifiche di Sanwal Yousaf. Concesso in licenza in CC BY 4.0

Cancella consente di rimuovere elementi indesiderati utilizzando maschere di immagini, mantenendo al contempo in modo intelligente la coerenza dello sfondo.

Cancella ha i seguenti parametri richiesti:

image — (stringa) L'immagine Base64 da cui cancellare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
mask — (string) Controlla l'intensità del processo di inpainting per pixel. È possibile controllarlo tramite una seconda immagine (passata a questo parametro) o tramite il canale alfa del parametro image.
- Passaggio di una maschera: l'immagine passata a questo parametro deve essere un'immagine in bianco e nero che rappresenti, in qualsiasi pixel, la forza dell'inpainting in base a quanto scuro o chiaro è il pixel specificato. I pixel completamente neri rappresentano assenza di intensità di inpainting, mentre i pixel completamente bianchi rappresentano la massima intensità. Se la maschera ha una dimensione diversa dal parametro dell’immagine, verrà ridimensionata automaticamente.
- Supporto per il canale alfa: se non fornisci una maschera esplicita, ne verrà derivata una dal canale alfa del parametro image. I pixel trasparenti verranno sottoposti a inpainting, mentre i pixel opachi saranno preservati. Nel caso in cui venga fornita un’immagine con un canale alfa insieme a una maschera, la maschera avrà la precedenza.
grow_mask — Fa crescere i bordi della maschera verso l'esterno in tutte le direzioni del numero di pixel specificato. L’area ampliata intorno alla maschera verrà sfocata, il che può aiutare a rendere più uniforme la transizione tra il contenuto sottoposto a inpainting e l’immagine originale. Intervallo compreso tra 0 e 20. Impostazione predefinita: 5. Utilizza questo parametro se noti giunzioni o edge irregolari intorno al contenuto sottoposto a inpainting. Nota che una crescita eccessiva può oscurare i dettagli più piccoli della maschera e and/or unire le regioni mascherate vicine.

Nota

Per risultati di cancellazione ottimali, assicurati che la maschera definisca accuratamente le aree da rimuovere. Se non viene fornita alcuna maschera esplicita, il servizio utilizza il canale alfa dell’immagine di input. La maschera ha la precedenza se vengono fornite entrambe.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.png"
mask = "./content/mask.png"

region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
    with open(mask, "rb") as mask_file:
        mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "mask": mask_base64
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.png" 
mask = "./content/mask.png"

region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
    with open(mask, "rb") as mask_file:
        mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "mask": mask_base64
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un’operazione Cancella.

Input	Mask (Maschera)	Output
“Scrivania per studenti” generato da Stable Image Ultra. Prompt e modifiche di Sanwal Yousaf. Concesso in licenza in CC BY 4.0

Rimuovi sfondo consente di isolare i soggetti dallo sfondo con precisione.

Rimuovi sfondo prevede parametri obbligatori seguenti:

image — (stringa) L'immagine Base64 da cui rimuovere lo sfondo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.png"

region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")

    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un’operazione Rimuovi sfondo.

Input	Output
“Modella che indossa un maglione autunnale” generato da Stable Image Ultra. Prompt e modifiche di Sanwal Yousaf. Concesso in licenza in CC BY 4.0

Controllo

Nella sezione seguente viene descritto il controllo dei servizi Stability AI Image.

Trasforma schizzi grezzi disegnati a mano in risultati raffinati con un controllo preciso. Per le immagini non trattate da schizzo, Control Sketch consente una manipolazione dettagliata dell'aspetto finale utilizzando le linee di contorno e i bordi all'interno dell'immagine.

Schizzo di controllo ha i seguenti parametri richiesti:

prompt: cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 dello schizzo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

control_strength — (numero) Quanta influenza, o controllo, ha l'immagine sulla generazione. Rappresentata come un float compreso tra 0 e 1, dove 0 è l’influenza minima e 1 è la massima. Impostazione predefinita: 0,7.
negative_prompt — (string) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
style_preset — Guida il modello di immagine verso uno stile particolare. Enum: 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.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "a house with background of mountains and river flowing nearby"
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "a house with background of mountains and river flowing nearby"
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di una chiamata Control Sketch. Il prompt utilizzato è: una casa sullo sfondo delle montagne e del fiume che scorre nelle vicinanze.

Input	Output
“Schizzo di casa, montagne e fiume” di Sanwal Yousaf. Concesso in licenza in CC BY 4.0

Struttura di controllo consente di generare immagini mantenendo la struttura di un’immagine di input. Ciò è particolarmente utile per scenari avanzati di creazione di contenuti, come la ricreazione di scene o il rendering di personaggi a partire da modelli.

Schizzo di controllo ha i seguenti parametri richiesti:

prompt — Cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 dello schizzo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

control_strength — (numero) Quanta influenza, o controllo, ha l'immagine sulla generazione. Rappresentata come un float compreso tra 0 e 1, dove 0 è l’influenza minima e 1 è la massima. Impostazione predefinita: 0,7.
negative_prompt — (string) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
style_preset — Guida il modello di immagine verso uno stile particolare. Enum: 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.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "surreal structure with motion generated sparks lighting the scene"

    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "surreal structure with motion generated sparks lighting the scene"

    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di un'operazione di Control Structure. Il prompt utilizzato è: struttura surreale con scintille generate dal movimento che illuminano la scena.

Input	Output
“Persona seduta su una scatola marrone” di Pawel L. Concessa in licenza con CC

Style Guide consente di estrarre elementi stilistici da un'immagine di input. Li utilizza per guidare la creazione di un'immagine di output in base al prompt. Il risultato è una nuova immagine nello stesso stile dell’immagine di input.

La guida di stile ha i seguenti parametri richiesti:

prompt: cosa desideri vedere nell'immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu. Minimo 0 e massimo 10.000 caratteri.
image — (stringa) L'immagine Base64 dello schizzo. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

aspect_ratio: (stringa) controlla le proporzioni dell’immagine generata. Questo parametro è valido solo per le richieste da testo a immagine. Il valore predefinito è 1:1. Enum: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Impostazione predefinita: 1:1.
negative_prompt — (string) Una porzione di testo che descrive ciò che non desiderate vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
fidelity — (numero) Quanto lo stile dell'immagine di output è simile allo stile dell'immagine di input. Intervallo compreso tra 0 e 1. Impostazione predefinita: 0,5.
style_preset — Guida il modello di immagine verso uno stile particolare. Enum: 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.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "wide shot of modern metropolis" 
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/input.jpg"

region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    params = {
        "image": image_base64,
        "prompt": "wide shot of modern metropolis" 
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di una chiamata Style Guide. Il prompt utilizzato è: inquadratura panoramica di una metropoli moderna.

Input	Output
“Inpainting astratta” di Steven Johnson. Concesso in licenza con CC

Trasferimento di stile consente di applicare le caratteristiche visive delle immagini di stile di riferimento alle immagini di destinazione. Il servizio Style Guide estrae elementi stilistici da un'immagine di input e li utilizza per guidare la creazione di un'immagine di output in base al prompt. Style Transfer trasforma specificamente i contenuti esistenti preservando la composizione originale. Questo strumento aiuta a creare contenuti coerenti su più risorse.

Trasferimento di stile ha i seguenti parametri richiesti:

init_image — (stringa) Un'immagine Base64 contenente il soggetto che desideri modificare lo stile. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.
style_image — (string) Un'immagine Base64 contenente il soggetto che desideri modificare. Ogni lato dell’immagine deve avere una dimensione di almeno 64 pixel. Il numero totale di pixel non può superare 9.437.184 pixel. Le proporzioni devono essere comprese tra 1:2.5 e 2.5:1. Formati supportati: jpeg, png, webp.

I parametri seguenti sono facoltativi:

prompt: (stringa) cosa si desidera vedere nell’immagine di output. Un prompt forte e descrittivo che definisca chiaramente elementi, colori e soggetti porterà a risultati migliori. Per controllare il peso di una determinata parola utilizza il formato (word:weight), dove word è la parola di cui vuoi controllare il peso e weight è un valore. Un valore pari a 0 o 1,0 riduce l’enfasi sulla parola, mentre un valore compreso tra 1,1 e 2 la aumenta. Ad esempio: il cielo era nitido (blu: 0,3) e (verde: 1,8) indica un cielo blu e verde, ma più verde che blu.
negative_prompt — (string) Una porzione di testo che descrive ciò che non desideri vedere nell'immagine di output. Questa è una caratteristica avanzata. Massimo 10000 caratteri.
seed: (numero) un valore specifico utilizzato per determinare la “casualità” della generazione. Ometti questo parametro o passa 0 per utilizzare un seed casuale. Intervallo compreso tra 0 e 4294967294. Impostazione predefinita: 0.
output_format — (string) Determina il tipo di contenuto dell'immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
composition_fidelity — (numero) Quanto lo stile dell'immagine di output è simile allo stile dell'immagine di input. Intervallo compreso tra 0 e 1. Impostazione predefinita: 0,9.
style_strength — (numero) A volte indicato come denoising, questo parametro controlla l'influenza del parametro style_image sull'immagine generata. Un valore pari a 0 restituirebbe un’immagine identica all’input. Un valore pari a 1 sarebbe come se non fosse stata trasmessa alcuna immagine. Intervallo compreso tra 0 e 1. Impostazione predefinita: 1.
change_strength — (numero) Quanto deve cambiare l'immagine originale. Intervallo compreso tra 0,1 e 1. Impostazione predefinita: 0,9.

API


import base64
import json
import requests
import io
import os
from PIL import Image

image = "./content/input.jpg"
style_image = "./content/style.jpg"

region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
    "Content-Type":"application/json",
    "Authorization":f"Bearer {api_key}"
}

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    with open(style_image, "rb") as style_image_file:
        style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')

    params = {
        "init_image": image_base64,
        "style_image": style_image_base64,
        "prompt": "statue"
    }
    response = requests.request("POST", url, json=params, headers=headers)
    response.raise_for_status()
    model_response = json.loads(response.text)
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

Python


import boto3
import base64
import io
import json
from PIL import Image

image = "./content/cat_statue_512x512.jpg"
style_image = "./content/glowbot_style.jpg"

region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"

bedrock = boto3.client("bedrock-runtime", region_name=region)

try:
    with open(image, "rb") as image_file:
        image_base64 = base64.b64encode(image_file.read()).decode('utf-8')

    with open(style_image, "rb") as style_image_file:
        style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')

    params = {
        "init_image": image_base64,
        "style_image": style_image_base64,
        "prompt": "statue"
    }
    request = json.dumps(params)
    response = bedrock.invoke_model(modelId=model_id, body=request)
    model_response = json.loads(response["body"].read())
    base64_image_data = model_response["images"][0]

    if not base64_image_data:
        raise ValueError("No image data found in model response.")

    image_data = base64.b64decode(base64_image_data)
    image = Image.open(io.BytesIO(image_data))
    image.save("image.png")
    print("Successfully saved image.")

except Exception as e:
    print(e)

La tabella seguente mostra le immagini di input e output di una chiamata Trasferimento di stile.

Input	Stile	Output
“Statua di donna in piedi” di Simon Berger. Concesso in licenza con CC	“Luci blu” di Pixabay. Concesso in licenza con CC0

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Stable Image Core

TwelveLabs Modelli