As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Modelos da Stability AI
Esta seção descreve os parâmetros de solicitação e os campos de resposta dos modelos da Stability AI. Use essas informações para fazer chamadas de inferência para modelos de IA de estabilidade com a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operação. Esta seção também inclui exemplos de código do Python que mostram como chamar modelos da Stability AI. Para usar um modelo em uma operação de inferência, o ID do modelo é necessário. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Alguns modelos também funcionam com a [API Converse](conversation-inference.md). Para verificar se a API Converse pode ser usada em um modelo da Stability AI específico, consulte [Modelos compatíveis e recursos do modelo](conversation-inference-supported-models-features.md). Para obter mais exemplos de código, consulte [Exemplos de código para o Amazon Bedrock usando AWS SDKs](service_code_examples.md).
Os modelos de base no Amazon Bedrock são compatíveis com as modalidades de entrada e saída, que variam de modelo para modelo. Para verificar as modalidades compatíveis com os modelos da Stability AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar quais recursos do Amazon Bedrock são compatíveis com os modelos da Stability AI, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md). Para verificar em quais AWS regiões os modelos de IA de estabilidade estão disponíveis, consulte[Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
Ao fazer chamadas de inferência com modelos da Stability AI, inclua um prompt para o modelo. Para obter informações gerais sobre como criar prompts para os modelos compatíveis com o Amazon Bedrock, consulte [Conceitos de engenharia de prompts](prompt-engineering-guidelines.md). Para ter informações sobre prompts específicos da Stability AI, consulte o [guia de engenharia de prompts da Stability AI](https://platform.stability.ai/docs/getting-started).
## Modelos e serviços de imagem compatíveis
O Amazon Bedrock é compatível com os modelos e serviços de imagem da Stability AI a seguir.
**nota**
O suporte a todos os outros modelos da Stability AI está em processo de descontinuação.
| Modelo | Casos de uso | Exemplo |
| --- | --- | --- |
| [Imagem estável Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Uma marca de luxo usa o Stable Image Ultra para criar elementos visuais deslumbrantes de sua coleção mais recente para revistas, garantindo uma percepção premium que corresponde aos seus elevados padrões. |
| [Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Uma equipe de desenvolvimento de jogos usa SD3 .5 Large para criar texturas ambientais detalhadas e conceitos de personagens, acelerando seu fluxo criativo. |
| [Núcleo de imagem estável](model-parameters-diffusion-stable-image-core-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Um varejista on-line usa o Stable Image Core para gerar rapidamente imagens de produtos para recém-chegados, permitindo que ele liste itens com mais rapidez e mantenha seu catálogo. up-to-date |
| [Stability AI Image Services](stable-image-services.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Uma empresa de mídia usa pesquisa e recoloração, transferência de estilo e remoção de plano de fundo para gerar variações de imagens para uma campanha publicitária. |
**Topics**
+ [Modelos e serviços de imagem compatíveis](#supported-stability-models)
+ [Solicitação e resposta do Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md)
+ [Stable Diffusion 3.5 Large da Stability AI](model-parameters-diffusion-3-5-large.md)
+ [Solicitação e resposta do Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md)
+ [Stability AI Image Services](stable-image-services.md)
# Solicitação e resposta do Stable Image Ultra
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)operação.
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando um modelo Stable Image Ultra, preencha o campo body com um objeto JSON semelhante ao mostrado abaixo.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campo de corpo de respostas de invocação do modelo**
Ao fazer uma chamada `InvokeModel` usando um modelo Stable Image Ultra, a resposta é semelhante à mostrada a seguir.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Uma resposta com um motivo final que não seja `null` terá a seguinte aparência:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
Para obter mais informações, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 geração](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
O modelo Stability.ai Stable Image Ultra tem os seguintes parâmetros de inferência para uma chamada de text-to-image inferência.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campos opcionais**
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **modo** — Defina como text-to-image. Padrão: text-to-image. Enum: `text-to-image`.
+ **output\$1format**: especifica o formato da imagem de saída. Formatos compatíveis: JPEG, PNG. Dimensões compatíveis: altura de 640 px a 1.536px, largura de 640 px a 1.536 px.
+ **seed**: (número) um valor específico que é usado para orientar a “aleatoriedade” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Intervalo: de 0 a 4294967295.
+ **negative\$1prompt**: palavras-chave do que você não deseja ver na imagem de saída. Máximo: 10.000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
#### [ Image to image ]
O modelo Stability.ai Stable Image Ultra tem os seguintes parâmetros de inferência para uma chamada de image-to-image inferência.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Campos opcionais**
+ **image**: (string) a imagem em base64 a ser usada como ponto de partida para a geração. Formatos compatíveis: JPEG, PNG e WebP.
+ **strength**: (número) nível de influência do parâmetro de imagem sobre a imagem gerada. Imagens com valores de intensidade mais baixos serão mais parecidas com a imagem original. Intervalo: de 0,0 a 1,0. Padrão: 0,35.
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: especifica o formato da imagem de saída. Formatos compatíveis: JPEG, PNG. Dimensões compatíveis: altura de 640 px a 1.536px, largura de 640 px a 1.536 px.
+ **seed**: (número) um valor específico que é usado para orientar a “aleatoriedade” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Intervalo: de 0 a 4294967295.
+ **negative\$1prompt**: palavras-chave do que você não deseja ver na imagem de saída. Máximo: 10.000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stable Diffusion 3.5 Large da Stability AI
O modelo Stable Diffusion 3.5 Large usa 8 bilhões de parâmetros e suporta saída de resolução de 1 megapixel para geração text-to-image e image-to-image geração.
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando um modelo Stable Diffusion 3.5 Large, preencha o campo body com um objeto JSON semelhante ao mostrado abaixo.
+ **prompt**: (string) descrição de texto da imagem de saída desejada. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Campo de corpo de respostas de invocação do modelo**
Ao fazer uma chamada `InvokeModel` usando um modelo Stable Diffusion 3.5 Large, a resposta é semelhante à mostrada abaixo.
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Uma resposta com um motivo final que não seja `null` terá a seguinte aparência:
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
------
#### [ Text to image ]
O modelo Stability.ai Stable Diffusion 3.5 Large tem os seguintes parâmetros de inferência para uma chamada de text-to-image inferência.
+ **prompt** (string) — Descrição de texto da imagem de saída desejada. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Parâmetros opcionais**
+ **aspect\$1ratio** (string) — Controla a proporção da imagem gerada. Válido somente para text-to-image solicitações. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Padrão 1:1.
+ **mode** (string) (GenerationMode) - Padrão: text-to-image. Enum: image-to-image ou text-to-image. Controla se é uma image-to-image geração text-to-image ou, o que afeta quais parâmetros são necessários:
+ text-to-image requer somente o parâmetro prompt.
+ image-to-image requer os parâmetros de alerta, imagem e intensidade.
+ **semente** (número) — Valor para controlar a aleatoriedade na geração. Varia de 0 a 4.294.967.295. Padrão: 0 (propagação aleatória).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Texto descrevendo elementos a serem excluídos da imagem de saída. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Formato da imagem de saída. Enumeração: jpeg, png, webp. Padrão: png.
```
import boto3
import json
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
```
------
#### [ Image to image ]
O modelo Stability.ai Stable Diffusion 3.5 Large tem os seguintes parâmetros de inferência para uma chamada de image-to-image inferência.
+ **prompt** (string) — Descrição de texto da imagem de saída desejada. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **image** (string) — Imagem de entrada codificada em Base64. Mínimo de 64 pixels por lado. Formatos compatíveis: jpeg, png e webp.
+ **mode** (string) (GenerationMode) - Padrão: text-to-image. Enum: image-to-image ou text-to-image. Controla se é uma image-to-image geração text-to-image ou, o que afeta quais parâmetros são necessários:
+ text-to-image requer somente o parâmetro prompt.
+ image-to-image requer os parâmetros de alerta, imagem e intensidade.
+ **força** (número) — Controla a influência da imagem de entrada na saída. Varia de 0 a 1. O valor 0 preserva a imagem de entrada e o valor 1 ignora a imagem de entrada.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **semente** (número) — Valor para controlar a aleatoriedade na geração. Varia de 0 a 4.294.967.295. Padrão: 0 (propagação aleatória).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Texto descrevendo elementos a serem excluídos da imagem de saída. Máximo de 10 mil caracteres.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format** (string) — Formato da imagem de saída. Enumeração: jpeg, png, webp. Padrão: png.
```
import boto3
import base64
import json
# Load and encode image
with open('input_image.jpg', 'rb') as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.',
'image': image_base64,
'strength': 0.7
})
)
```
------
# Solicitação e resposta do Stable Image Core
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando um modelo Stability AI Stable Diffusion Stable Image Core, preencha o campo do corpo com um objeto JSON semelhante ao mostrado abaixo.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo de corpo de respostas de invocação do modelo**
Quando você faz uma InvokeModel chamada usando um modelo Stability AI Stable Diffusion Stable Image Core, a resposta se parece com a seguinte
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
Para obter mais informações, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 geração](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
O modelo Stable Image Core tem os parâmetros de inferência a seguir para uma chamada de inferência de texto para imagem.
**text\$1prompts** (obrigatório): uma matriz de prompts de texto a serem usados na geração. Cada elemento é um objeto JSON que contém um prompt e um peso para o prompt.
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-diffusion-stable-image-core-text-image-request-response.html)
**Campos opcionais**
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format**: especifica o formato da imagem de saída. Formatos compatíveis: JPEG, PNG. Dimensões compatíveis: altura de 640 px a 1.536px, largura de 640 px a 1.536 px.
+ **seed**: (número) um valor específico que é usado para orientar a “aleatoriedade” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Intervalo: de 0 a 4294967295.
+ **negative\$1prompt**: palavras-chave do que você não deseja ver na imagem de saída. Máximo: 10.000 caracteres.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.stable-image-core-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stability AI Image Services
Você pode usar o Stability AI Image Services com o Amazon Bedrock para acessar treze ferramentas especializadas de edição de imagens projetadas para acelerar fluxos de trabalho criativos profissionais. Com o Stability AI Image Services, você pode gerar imagens com base em um esboço, reestruturar e aplicar um novo estilo em uma imagem existente ou remover e substituir objetos dentro de uma imagem.
Esta seção descreve como fazer chamadas de inferência para Stability AI Image Services usando o. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Ela também oferece exemplos de código em Python e exemplos de imagens antes e depois do uso do Stability AI Image Services.
O Stability AI Image Services está disponível nas seguintes categorias:
+ **Edição**: serviços de edição de imagem baseados em IA, como preenchimento com máscaras (preenchimento generativo) ou com palavras. Inclui ferramentas para colocação de produtos e publicidade, bem como ferramentas básicas, como remoção de plano de fundo.
+ **Controle**: pode receber prompts, mapas e outros guias. Esses serviços utilizam ControlNets tecnologias similares baseadas em modelos de difusão estável.
**nota**
A assinatura de qualquer edição ou controle do Stability AI Image Service inscreve você automaticamente em todos os treze Stability AI Image Services disponíveis.
**Topics**
+ [Solicitação e reposta](#model-parameters-stable-image-services-request-response)
+ [Sofisticado](#stable-image-services-upscale)
+ [Edição](#stable-image-services-edit)
+ [Controle](#stable-image-services-control)
## Solicitação e reposta
O corpo da solicitação é passado no `body` campo de uma solicitação para [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Campo do corpo da solicitação de invocação do modelo**
Ao fazer uma InvokeModel chamada usando o Stability AI Image Services, preencha o campo body com um objeto JSON semelhante ao mostrado abaixo.
```
{
'prompt': 'Create an image of a panda'
}
```
**Campo de corpo de respostas de invocação do modelo**
Quando você faz uma InvokeModel chamada usando o Stability AI Image Services, a resposta se parece com a seguinte
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds**: (string) lista de propagações usadas para gerar imagens para o modelo.
+ **finish\$1reasons**: enumeração indicando se a solicitação foi filtrada ou não. `null` indicará que a solicitação foi bem-sucedida. Valores atuais possíveis: `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images**: uma lista de imagens geradas no formato de string base64.
Para obter mais informações, consulte [https://platform.us.stability. ai/docs/api-reference\$1tag/v1 geração](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Sofisticado
A seção a seguir descreve os sofisticados Stability AI Image Services.
### Luxo criativo
O Creative Upscale captura imagens entre 64x64 e 1 megapixel e as aprimora para a resolução 4K. Esse serviço pode aprimorar as imagens em 20 a 40 vezes, preservando e, muitas vezes, aprimorando a qualidade. O Creative Upscale funciona melhor em imagens altamente degradadas e não serve para fotos de 1 megapixel ou mais, pois realiza reimaginações pesadas.
O Creative Upscale tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image** ‐ (string) A imagem Base64 a ser aprimorada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels deve estar entre 4.096 e 1.048.576 pixels. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **criatividade** ‐ (número) Indica o quão criativo o modelo deve ser ao aprimorar uma imagem. Valores mais altos resultarão na adição de mais detalhes à imagem durante o aumento de escala. Intervalo entre 0,1 e 0,5. Padrão 0.3
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação da Creative Upscale usando o seguinte prompt: *Essa arte digital onírica captura um pássaro vibrante e caleidoscópico em uma* floresta tropical exuberante.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-creative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-creative-upscale.jpg) |
### Alto padrão conservador
O Conservative Upscale captura imagens entre 64x64 e 1 megapixel e as aprimora para resolução 4K. Esse serviço pode aprimorar as imagens em 20 a 40 vezes, preservando todos os aspectos. O Conservative Upscale minimiza as alterações na imagem e não deve ser usado para reimaginar uma imagem.
O Conservative Upscale tem os seguintes parâmetros necessários:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image** ‐ (string) A imagem Base64 a ser aprimorada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **criatividade** ‐ (número) Indica o quão criativo o modelo deve ser ao aprimorar uma imagem. Valores mais altos resultarão na adição de mais detalhes à imagem durante o aumento de escala. Intervalo entre 0,1 e 0,5. Padrão 0,35
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação da Conservative Upscale usando o seguinte prompt: *foto de uma galinha gigante em uma floresta*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-conservative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-conservative-upscale.jpg) |
### Aumento rápido
O Fast Upscale melhora a resolução da imagem em 4 vezes usando IA preditiva e generativa. Esse serviço leve e rápido é ideal para aprimorar a qualidade das imagens compactadas, tornando-o adequado para postagens em mídias sociais e outros aplicativos.
O Fast Upscale tem os seguintes parâmetros necessários:
+ **image** ‐ (string) A imagem Base64 a ser aprimorada. A largura deve estar entre 32 e 1.536 pixels. A altura deve estar entre 32 e 1.536 pixels. A contagem total de pixels deve estar entre 1.024 e 1.048.576 pixels. Formatos compatíveis: jpeg, png e webp.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação Fast Upscale.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-fast-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-fast-upscale.jpg) |
## Edição
A seção a seguir descreve a edição do Stability AI Image Services.
### Preencher
O recurso preencher modifica imagens de forma inteligente preenchendo ou substituindo áreas especificadas por um novo conteúdo com base no conteúdo de uma imagem de máscara.
O preenchimento tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) a imagem em base64 à qual aplicar o preenchimento. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e tile-texture.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **mask**: (string) controla a intensidade do processo de preenchimento por pixel, seja por meio de uma segunda imagem (transmitida para esse parâmetro) ou por meio do canal alfa do parâmetro de imagem.
+ **Transmissão de uma máscara**: a imagem transmitida para esse parâmetro deve ser uma imagem em preto e branco que represente, em qualquer pixel, a intensidade do preenchimento com base em quão escuro ou claro é o pixel em questão. Os pixels totalmente pretos não representam a intensidade do preenchimento, enquanto os pixels totalmente brancos representam a intensidade máxima. Caso a máscara tenha um tamanho diferente do parâmetro da imagem, ela será redimensionada automaticamente.
+ **Suporte ao canal alfa**: se você não fornecer uma máscara explícita, uma será derivada do canal alfa do parâmetro de imagem. Os pixels transparentes serão preenchidos enquanto os pixels opacos serão preservados. Caso uma imagem com um canal alfa seja fornecida com uma máscara, a máscara terá precedência.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
------
#### [ 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de preenchimento.
| Input | Máscara | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-image-inpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/mask-image-inpaint.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-image-inpaint.jpg) |
### Pintura externa
O Outpaint insere conteúdo adicional em uma imagem para preencher o espaço em qualquer direção. Em comparação com outras tentativas automáticas ou manuais de expandir o conteúdo em uma imagem, o serviço Outpaint minimiza as indicações de que a imagem original foi editada.
O Outpaint tem os seguintes parâmetros necessários:
+ **image** ‐ (string) A imagem Base64 a ser pintada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
**nota**
Pelo menos uma direção de pintura: (esquerda, direita, para cima ou para baixo) deve ser fornecida com um valor diferente de zero. Para obter resultados de melhor qualidade, considere a composição e o conteúdo da imagem original ao escolher as direções de pintura.
Os seguintes parâmetros são opcionais:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e tile-texture.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **criatividade** ‐ (número) Indica o quão criativo o modelo deve ser ao pintar uma imagem. Valores mais altos resultarão na adição de mais conteúdo criativo à imagem durante a pintura. Intervalo entre 0,1 e 1,0. Padrão: 0,5.
+ **left** ‐ (inteiro) O número de pixels a serem pintados no lado esquerdo da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
+ **right** ‐ (inteiro) O número de pixels a serem pintados no lado direito da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
+ **up** ‐ (inteiro) O número de pixels a serem pintados na parte superior da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 0.
+ **down** ‐ (inteiro) O número de pixels a serem pintados na parte inferior da imagem. Pelo menos uma direção de pintura externa deve ser fornecida com um valor diferente de zero. Faixa de 0 a 2000. Padrão 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação Outpaint.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-image-outpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-image-outpaint.jpg) |
### Pesquisar e recolorir
Pesquisar e recolorir permite que você altere a cor de um objeto específico em uma imagem usando um prompt. Esse serviço é uma versão específica do preenchimento que não requer máscara. Ele segmentará automaticamente o objeto e a aplicará uma nova cor usando as cores solicitadas no prompt.
Pesquisar e recolorir tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) a imagem em base64 que deve ser colorida novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
+ **select\$1prompt**: (string) breve descrição do que pesquisar na imagem. Máximo de 10 mil caracteres.
Os seguintes parâmetros são opcionais:
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e tile-texture.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
------
#### [ 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de pesquisa e recoloração usando o seguinte prompt: *pink jacket*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-search-recolor.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-search-recolor.jpg) |
### Pesquisar e substituir
Pesquisar e substituir permite que você use um prompt de pesquisa em linguagem simples para identificar um objeto a ser substituído. O serviço segmentará automaticamente o objeto e o substituirá pelo objeto solicitado no prompt sem precisar de uma máscara.
Pesquisar e substituir tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) a imagem em base64 que deve ser colorida novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
+ **search\$1prompt**: (string) breve descrição sobre onde aplicar preenchimento na imagem. Máximo de 10 mil caracteres.
Os seguintes parâmetros são opcionais:
+ **style\$1preset**: (string) orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e tile-texture.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
------
#### [ 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de pesquisa e substituição usando o seguinte prompt: *jacket*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-search-replace.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-search-replace.jpg) |
### Apagar
Apagar permite que você remova elementos indesejados usando máscaras de imagem e mantenha a consistência do plano de fundo de forma inteligente.
Apagar tem os seguintes parâmetros obrigatórios:
+ **image**: (string) a imagem em base64 a ser apagada. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **mask**: (string) controla a intensidade do processo de preenchimento por pixel, seja por meio de uma segunda imagem (transmitida para esse parâmetro) ou por meio do canal alfa do parâmetro de imagem.
+ **Transmissão de uma máscara**: a imagem transmitida para esse parâmetro deve ser uma imagem em preto e branco que represente, em qualquer pixel, a intensidade do preenchimento com base em quão escuro ou claro é o pixel em questão. Os pixels totalmente pretos não representam a intensidade do preenchimento, enquanto os pixels totalmente brancos representam a intensidade máxima. Caso a máscara tenha um tamanho diferente do parâmetro da imagem, ela será redimensionada automaticamente.
+ **Suporte ao canal alfa**: se você não fornecer uma máscara explícita, uma será derivada do canal alfa do parâmetro de imagem. Os pixels transparentes serão preenchidos enquanto os pixels opacos serão preservados. Caso uma imagem com um canal alfa seja fornecida com uma máscara, a máscara terá precedência.
+ **grow\$1mask**: aumenta as bordas da máscara para fora em todas as direções de acordo com o número especificado de pixels. A área expandida ao redor da máscara ficará desfocada, o que pode ajudar a suavizar a transição entre o conteúdo com preenchimento e a imagem original. Varia de 0 a 20. Padrão: 5. Experimente esse parâmetro se você notar emendas ou arestas ao redor do conteúdo com preenchimento. Observe que o crescimento excessivo pode obscurecer detalhes finos na and/or mesclagem de máscaras nas regiões mascaradas próximas.
**nota**
Para obter os melhores resultados de apagamento, a máscara de definir com precisão as áreas a serem removidas. Se nenhuma máscara explícita for fornecida, o serviço usará o canal alfa da imagem de entrada. A máscara terá precedência se ambos forem fornecidos.
------
#### [ 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de apagamento.
| Input | Máscara | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-erase-object.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/mask-erase-object.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-erase-object.jpg) |
### Remover plano de fundo
Remover plano de fundo permite isolar os objetos do fundo com precisão.
Remover plano de fundo tem os seguintes parâmetros obrigatórios:
+ **image**: (string) a imagem em base64 da qual o plano de fundo deve ser removido. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de remoção de plano de fundo.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-remove-background.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-remove-background.jpg) |
## Controle
A seção a seguir descreve o controle do Stability AI Image Services.
### Controlar esboço
Aprimore esboços grosseiros desenhados à mão para obter saídas refinadas com controle preciso. Para imagens sem esboço, controlar esboço permite a manipulação detalhada da aparência final, aproveitando as linhas de contorno e as bordas da imagem.
Controlar esboço tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) A imagem em base64 do esboço. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **control\$1strength**: (número) grau de influência ou controle que a imagem tem na geração. Representado como uma número flutuante entre 0 e 1, em que 0 é a influência mínima e 1 é a máxima. Padrão: 0,7.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma chamada de controle de esboço usando o seguinte prompt: *a house with background of mountains and river flowing nearby*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-control-sketch.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-control-sketch.jpg) |
| | |
### Controlar estrutura
Controlar estrutura permite gerar imagens enquanto mantém a estrutura de uma imagem de entrada. Isso é especialmente valioso para cenários avançados de criação de conteúdo, como recriar cenas ou renderizar personagens com base em modelos.
Controlar estrutura tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) A imagem em base64 do esboço. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **control\$1strength**: (número) grau de influência ou controle que a imagem tem na geração. Representado como uma número flutuante entre 0 e 1, em que 0 é a influência mínima e 1 é a máxima. Padrão: 0,7.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma operação de controle de estrutura usando o seguinte prompt: *surreal structure with motion generated sparks lighting the scene*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-control-structure.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-control-structure.jpg) |
### Guia de estilo
O guia de estilo permite que você extraia elementos estilísticos de uma imagem de entrada e os utilize para orientar a criação de uma imagem de saída com base no prompt. O resultado é uma nova imagem no mesmo estilo da imagem de entrada.
Guia de estilo tem os seguintes parâmetros obrigatórios:
+ **prompt**: o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul. Mínimo de 0 e máximo de 10 mil caracteres.
+ **image**: (string) A imagem em base64 do esboço. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **aspect\$1ratio**: (string) controla a proporção da imagem gerada. Esse parâmetro só é válido para text-to-image solicitações. Padrão 1:1. Enumeração: 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Padrão 1:1.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **fidelity**: (número) Até que ponto o estilo da imagem de saída se assemelha ao estilo da imagem de entrada. Varia de 0 a 1. Padrão: 0,5.
+ **style\$1preset**: orienta o modelo de imagem em direção a um estilo específico. Enumeração: 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 e 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma chamada do guia de estilo usando o seguinte prompt: *wide shot of modern metropolis*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-style-guide.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-style-guide.jpg) |
### Transferência de estilo
A transferência de estilo permite que você aplique características visuais de imagens de estilo de referência às imagens de destino. Enquanto o serviço guia de estilo extrai elementos estilísticos de uma imagem de entrada e os utiliza para orientar a criação de uma imagem de saída com base no prompt, a transferência de estilo transforma especificamente o conteúdo existente e, ao mesmo tempo, preserva a composição original. Essa ferramenta ajuda a criar conteúdo consistente em vários ativos.
A transferência de estilo tem os seguintes parâmetros obrigatórios:
+ **init\$1image**: (string) uma imagem em base64 contendo o assunto que você deseja estilizar novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
+ **style\$1image**: (string) uma imagem em base64 contendo o assunto que você deseja estilizar novamente. Cada lado da imagem deve ter pelo menos 64 pixels. A contagem total de pixels não pode ultrapassar 9.437.184 pixels. A taxa de proporção deve estar entre 1:2.5 e 2.5:1. Formatos compatíveis: jpeg, png e webp.
Os seguintes parâmetros são opcionais:
+ **prompt**: (string) o que você deseja ver na imagem de saída. Um prompt forte e descritivo que define claramente os elementos, as cores e os assuntos proporcionará melhores resultados. Para controlar o peso de determinada palavra, use o formato (word:weight), em que “word” é a palavra da qual você gostaria de controlar o peso e “weight” é um valor. Um valor entre 0 e 1,0 remove a ênfase da palavra e um valor entre 1,1 e 2 enfatiza a palavra. Por exemplo: o céu estava nítido, com a especificação (blue:0.3) e (green:1.8), significaria um céu azul e verde, mas mais verde do que azul.
+ **negative\$1prompt**: (string) uma sinopse de texto descrevendo o que você não deseja ver na imagem de saída. Este é um recurso avançado. Máximo de 10 mil caracteres.
+ **seed**: (número) um valor específico que é usado para orientar a “randomização” da geração. (Omita esse parâmetro ou passe 0 para usar uma propagação aleatória.) Varia de 0 a 4.294.967.295. Padrão: 0.
+ **output\$1format**: (string) dita o tipo de conteúdo da imagem gerada. Enumeração: jpeg, png, webp. Padrão: png.
+ **composition\$1fidelity**: (número) até que ponto o estilo da imagem de saída se assemelha ao estilo da imagem de entrada. Varia de 0 a 1. Padrão: 0,9.
+ **style\$1strength**: (número) às vezes chamado de redução de ruído, esse parâmetro controla quanta influência o parâmetro da imagem tem sobre a imagem gerada. Um valor de 0 produziria uma imagem idêntica à entrada. Um valor de 1 seria como se você não tivesse passado nenhuma imagem. Varia de 0 a 1. Padrão: 1.
+ **change\$1strength**: (número) quanto a imagem original deve mudar. Varia de 0,1 a 1. Padrão: 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)
```
------
A tabela a seguir mostra as imagens de entrada e saída de uma chamada de transferência de estilo.
| Input | Estilo | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/input-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/style-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/images/stable-image-services/output-style-transfer.jpg) |