Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Servizi di immagine Stability AI
Puoi utilizzare Stability AI Image Services con Amazon Bedrock per accedere a tredici strumenti di modifica delle immagini specializzati progettati per accelerare i flussi di lavoro creativi professionali. Con i servizi di immagine Stability AI puoi generare immagini da uno schizzo, ristrutturare e ridisegnare un’immagine esistente o rimuovere e sostituire oggetti all’interno di un’immagine.
Questa sezione descrive come effettuare chiamate di inferenza a Stability AI Image Services utilizzando. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) 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:
+ **Edit** ‐ servizi di modifica delle AI-based immagini, tra cui 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 prompt, mappe e altre guide. Questi servizi utilizzano ControlNets tecnologie simili basate su modelli Stable Diffusion.
**Nota**
L'abbonamento a qualsiasi servizio di modifica o controllo di Stability AI Image Service ti iscrive automaticamente a tutti i tredici Stability AI Image Services disponibili.
**Topics**
+ [Richiesta e risposta](#model-parameters-stable-image-services-request-response)
+ [Di lusso](#stable-image-services-upscale)
+ [Modifica](#stable-image-services-edit)
+ [Controllo](#stable-image-services-control)
## Richiesta e risposta
Il corpo della richiesta viene passato nel `body` campo di una richiesta a. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
**Campo del corpo della richiesta per l’invocazione del modello**
Quando effettui una InvokeModel chiamata utilizzando Stability AI Image Services, compila il campo body 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](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Di lusso
La sezione seguente descrive i servizi di immagine Stability AI di alto livello.
### Creative Upscale
Creative Upscale scatta immagini tra 64x64 e 1 megapixel e le converte alla risoluzione 4K. Questo servizio è in grado di eseguire l'upscaling delle immagini da 20 a 40 volte, preservandone e spesso migliorandone la qualità. Creative Upscale funziona al meglio su immagini altamente degradate e non è adatto a foto da 1 megapixel o più, in quanto esegue pesanti reimmaginazioni.
Creative Upscale presenta i seguenti parametri obbligatori:
+ **prompt**: ciò che 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 di cui eseguire l'upscaling. 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. Predefinito 0,3
+ **negative\_prompt**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica 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 utilizzando il seguente prompt: *Questa arte digitale onirica cattura un vivace e caleidoscopico Big Ben a Londra*.
| Input | Output |
| --- | --- |
|  |  |
### Elegante e conservativo
Conservative Upscale scatta immagini tra 64x64 e 1 megapixel e le converte alla risoluzione 4K. Questo servizio può eseguire l'upscaling delle immagini da 20 a 40 volte preservando tutti gli aspetti. Conservative Upscale riduce al minimo le alterazioni dell'immagine e non deve essere usato per reimmaginare un'immagine.
Conservative Upscale presenta i seguenti parametri obbligatori:
+ **prompt**: ciò che 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 di cui eseguire l'upscaling. 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. Valore predefinito: 0,35
+ **negative\_prompt**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica 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 utilizzando il seguente prompt: *Questa arte digitale onirica cattura un vivace e caleidoscopico Big Ben a Londra*.
| Input | Output |
| --- | --- |
|  |  |
### Veloce e di alto livello
Fast Upscale migliora la risoluzione delle immagini 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 obbligatori:
+ **image** ‐ (string) L'immagine Base64 di cui 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**: (stringa) indica 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 |
| --- | --- |
|  |  |
## Modifica
Nella sezione seguente viene descritta la modifica dei servizi di immagine Stability AI.
### Inpaint
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**: ciò che 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 colorare. 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**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **mask**: (stringa) controlla l’intensità del processo di inpainting su una base per pixel, tramite una seconda immagine (passata a questo parametro) o tramite il canale alfa del parametro dell’immagine.
+ **Inserimento di una maschera**: l’immagine passata a questo parametro deve essere un’immagine in bianco e nero che rappresenti, in ogni pixel, la forza dell’inpainting in base al grado di oscurità o luce del pixel in questione. 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 canale alfa**: se non fornisci una maschera esplicita, ne verrà derivata una dal canale alfa del parametro dell’immagine. 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**: espande gli edge 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 aree 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 |
| --- | --- | --- |
|  |  |  |
### Vernice esterna
Outpaint inserisce contenuti aggiuntivi in un'immagine per riempire lo spazio in qualsiasi direzione. Rispetto ad altri tentativi automatici o manuali di espandere il contenuto di un'immagine, 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 colorare. 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 outpaint: (sinistra, destra, su o giù) deve essere fornita con un valore diverso da zero. Per ottenere risultati di qualità ottimale, considerate la composizione e il contenuto dell'immagine originale quando scegliete le direzioni per la verniciatura.
I parametri seguenti sono facoltativi:
+ **prompt**: ciò che 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **creatività** ‐ (numero) Indica quanto deve essere creativo il modello quando deve sovraperniciare un'immagine. Valori più alti comporteranno l'aggiunta di più contenuti creativi all'immagine durante l'outpainting. Intervallo compreso tra 0,1 e 1,0. Impostazione predefinita: 0,5.
+ **left** ‐ (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. Valore predefinito 0.
+ **right** ‐ (intero) Il numero di pixel da sovrapporre sul lato destro dell'immagine. Almeno una direzione di outpainting deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 0.
+ **up** ‐ (intero) Il numero di pixel da sovrapporre alla parte superiore dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 0.
+ **down** ‐ (intero) Il numero di pixel da sovrapporre alla parte inferiore dell'immagine. Almeno una direzione di verniciatura deve essere fornita con un valore diverso da zero. Intervallo da 0 a 2000. Valore predefinito 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 |
| --- | --- |
|  |  |
### Cerca e ricolora
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**: ciò che 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) un testo che descrive ciò che non si desidera 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **grow\_mask**: espande gli edge 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 aree 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 utilizzando il seguente prompt: *giacca rosa*.
| Input | Output |
| --- | --- |
|  |  |
### Trova e sostituisci
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**: ciò che 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** ‐ (stringa) breve descrizione di cosa colorare 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) un testo che descrive ciò che non si desidera 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **grow\_mask**: espande gli edge 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 aree 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 Trova e sostituisci utilizzando il seguente prompt: *giacca*.
| Input | Output |
| --- | --- |
|  |  |
### Cancella
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 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **mask**: (stringa) controlla l’intensità del processo di inpainting su una base per pixel, tramite una seconda immagine (passata a questo parametro) o tramite il canale alfa del parametro dell’immagine.
+ **Inserimento di una maschera**: l’immagine passata a questo parametro deve essere un’immagine in bianco e nero che rappresenti, in ogni pixel, la forza dell’inpainting in base al grado di oscurità o luce del pixel in questione. 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 canale alfa**: se non fornisci una maschera esplicita, ne verrà derivata una dal canale alfa del parametro dell’immagine. 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**: espande gli edge 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 aree 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 |
| --- | --- | --- |
|  |  |  |
### Rimuovi sfondo
Rimuovi sfondo consente di isolare i soggetti dallo sfondo con precisione.
Rimuovi sfondo prevede parametri obbligatori seguenti:
+ **image**: (string) 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**: (stringa) indica 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 |
| --- | --- |
|  |  |
## Controllo
Nella sezione seguente viene descritto il controllo dei servizi Stability AI Image.
### Schizzo di controllo
Trasforma schizzi grezzi disegnati a mano in risultati raffinati con un controllo preciso. Per le immagini non disegnate, 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**: ciò che 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**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica 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 Schizzo di controllo utilizzando il seguente prompt: *una casa con sullo sfondo le montagne e il fiume che scorre nelle vicinanze*.
| Input | Output |
| --- | --- |
|  |  |
| | |
### Struttura di controllo
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**: ciò che 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**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica 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 Struttura di controllo utilizzando il seguente prompt: *struttura surreale con scintille generate dal movimento che illuminano la scena*.
| Input | Output |
| --- | --- |
|  |  |
### Guida di stile
La Guida di stile consente di estrarre elementi stilistici da un’immagine di input e utilizzarli 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**: ciò che 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**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **fidelity**: (numero) quanto lo stile dell’immagine di output assomiglia 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 Guida di stile utilizzando il seguente prompt: *ripresa panoramica di una metropoli moderna*.
| Input | Output |
| --- | --- |
|  |  |
### Trasferimento di stile
Trasferimento di stile consente di applicare le caratteristiche visive delle immagini di stile di riferimento alle immagini di destinazione. Mentre il servizio Guida di stile estrae gli elementi stilistici da un’immagine di input e li utilizza per guidare la creazione di un’immagine di output in base al prompt, Trasferimento di stile trasforma specificamente il contenuto esistente 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 a cui 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**: (stringa) un’immagine Base64 contenente il soggetto di cui 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.
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**: (stringa) un testo che descrive ciò che non si desidera 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**: (stringa) indica il tipo di contenuto dell’immagine generata. Enum: jpeg, png, webp. Impostazione predefinita: png.
+ **composition\_fidelity**: (numero) quanto lo stile dell’immagine di output assomiglia allo stile dell’immagine di input. Intervallo compreso tra 0 e 1. Impostazione predefinita: 0,9.
+ **style\_strength**: (numero) a volte chiamato 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 |
| --- | --- | --- |
|  |  |  |