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á.

Bloquear imagens nocivas com filtros de conteúdo

As Barreiras de Proteção do Amazon Bedrock podem ajudar a bloquear imagens inapropriadas ou nocivas por meio da configuração de filtros de conteúdo dentro de uma barreira de proteção.

Pré-requisitos e limitações

Visão geral

É possível usar detecção e bloqueio de imagens nocivas somente com imagens ou imagens que contêm texto. Ao criar uma barreira de proteção, os usuários podem selecionar a opção de imagem sozinha ou com a opção de texto e definir a respectiva intensidade de filtragem como NENHUMA, BAIXA, MÉDIA ou ALTA. Esses limites serão comuns ao conteúdo de texto e imagem se ambas as modalidades forem selecionadas. As barreiras de proteção avaliarão as imagens enviadas como entrada de usuário ou geradas como saídas das respostas do modelo.

As categorias oferecidas de detecção de conteúdo de imagem nocivo estão descritas abaixo:

Usar o filtro de conteúdo de imagem

Criar ou atualizar uma barreira de proteção com filtros de conteúdo para imagens

Ao criar uma barreira de proteção ou atualizar uma existente, os usuários agora verão, além da opção de texto existente, uma opção para selecionar a imagem.

Classificação do filtro e níveis de bloqueio

A filtragem é feita com base na classificação de confiança das entradas do usuário e das respostas do FM. Todas as entradas e respostas do modelo são classificadas em quatro níveis de solidez: nenhum, baixo, médio e alto. A intensidade do filtro determina a sensibilidade da filtragem de conteúdo prejudicial. À medida que a intensidade do filtro aumenta, a probabilidade de filtrar conteúdo prejudicial aumenta, e a probabilidade de ver conteúdo prejudicial na aplicação diminui. Quando as opções de imagem e texto são selecionadas, a mesma intensidade de filtro é aplicada às duas modalidades para uma categoria específica.

Configurar filtros de conteúdo para imagens por meio da API

Você pode usar a API de barreira de proteção para configurar o filtro de conteúdo de imagem nas Barreiras de Proteção do Amazon Bedrock. O exemplo abaixo mostra um filtro das Barreiras de Proteção do Amazon Bedrock com diferentes categorias de conteúdo nocivo e diferentes intensidades de filtro aplicadas. Você pode usar esse modelo como exemplo para seu caso de uso.

Com a operação contentPolicyConfig, filtersConfig é um objeto, conforme mostrado no exemplo a seguir.

Exemplo de código Python Boto3 para criar uma barreira de proteção com filtros de conteúdo de imagem

import boto3
import botocore
import json


def main():
    bedrock = boto3.client('bedrock', region_name='us-east-1')
    try:
        create_guardrail_response = bedrock.create_guardrail(
            name='my-image-guardrail',
            contentPolicyConfig={
                'filtersConfig': [
                    {
                        'type': 'SEXUAL',
                        'inputStrength': 'HIGH',
                        'outputStrength': 'HIGH',
                        'inputModalities': ['TEXT', 'IMAGE'],
                        'outputModalities': ['TEXT', 'IMAGE']
                    },
                    {
                        'type': 'VIOLENCE',
                        'inputStrength': 'HIGH',
                        'outputStrength': 'HIGH',
                        'inputModalities': ['TEXT', 'IMAGE'],
                        'outputModalities': ['TEXT', 'IMAGE']
                    },
                    {
                        'type': 'HATE',
                        'inputStrength': 'HIGH',
                        'outputStrength': 'HIGH',
                        'inputModalities': ['TEXT', 'IMAGE'],
                        'outputModalities': ['TEXT', 'IMAGE']
                    },
                    {
                        'type': 'INSULTS',
                        'inputStrength': 'HIGH',
                        'outputStrength': 'HIGH',
                        'inputModalities': ['TEXT', 'IMAGE'],
                        'outputModalities': ['TEXT', 'IMAGE']
                    },
                    {
                        'type': 'MISCONDUCT',
                        'inputStrength': 'HIGH',
                        'outputStrength': 'HIGH',
                        'inputModalities': ['TEXT'],
                        'outputModalities': ['TEXT']
                    },
                    {
                        'type': 'PROMPT_ATTACK',
                        'inputStrength': 'HIGH',
                        'outputStrength': 'NONE',
                        'inputModalities': ['TEXT'],
                        'outputModalities': ['TEXT']
                    }
                ]
            },
            blockedInputMessaging='Sorry, the model cannot answer this question.',
            blockedOutputsMessaging='Sorry, the model cannot answer this question.',
        )
        create_guardrail_response['createdAt'] = create_guardrail_response['createdAt'].strftime('%Y-%m-%d %H:%M:%S')
        print("Successfully created guardrail with details:")
        print(json.dumps(create_guardrail_response, indent=2))
    except botocore.exceptions.ClientError as err:
        print("Failed while calling CreateGuardrail API with RequestId = " + err.response['ResponseMetadata']['RequestId'])
        raise err


if __name__ == "__main__":
    main()

Configurar o filtro de imagem para trabalhar com a API ApplyGuardrail

Você pode usar filtros de conteúdo para conteúdo de imagem e texto usando a API ApplyGuardrail. Essa opção permite que você use as configurações do filtro de conteúdo sem invocar o modelo do Amazon Bedrock. É possível atualizar a carga útil da solicitação no script abaixo para vários modelos seguindo a documentação dos parâmetros de inferência para cada modelo de base do Bedrock em que é possível usar as Barreiras de Proteção do Amazon Bedrock.

Você pode atualizar a carga útil da solicitação no script abaixo para vários modelos seguindo a documentação dos parâmetros de inferência para cada modelo de base do Bedrock em que é possível usar as Barreiras de Proteção do Amazon Bedrock.

import boto3
import botocore
import json


guardrail_id = 'guardrail-id'
guardrail_version = 'DRAFT'
content_source = 'INPUT'
image_path = '/path/to/image.jpg'

with open(image_path, 'rb') as image:
    image_bytes = image.read()

content = [
    {
        "text": {
            "text": "Hi, can you explain this image art to me."
        }
    },
    {
        "image": {
            "format": "jpeg",
            "source": {
                "bytes": image_bytes
            }
        }
    }
]


def main():
    bedrock_runtime_client = boto3.client("bedrock-runtime", region_name="us-east-1")
    try:
        print("Making a call to ApplyGuardrail API now")
        response = bedrock_runtime_client.apply_guardrail(
            guardrailIdentifier=guardrail_id,
            guardrailVersion=guardrail_version,
            source=content_source,
            content=content
        )
        print("Received response from ApplyGuardrail API:")
        print(json.dumps(response, indent=2))
    except botocore.exceptions.ClientError as err:
        print("Failed while calling ApplyGuardrail API with RequestId = " + err.response['ResponseMetadata']['RequestId'])
        raise err


if __name__ == "__main__":
    main()

Configurar o filtro de imagem para funcionar com modelos de geração de imagens

Você também pode usar filtros de imagem das Barreiras de Proteção do Amazon Bedrock com modelos de geração de imagens, como o Gerador de Imagens do Titan e os modelos Stability Image ou Diffusion. No momento, é possível usar esses modelos por meio da API InvokeModel, que pode ser invocada com uma barreira de proteção. Você pode atualizar a carga útil da solicitação no script abaixo para vários modelos seguindo a documentação dos parâmetros de inferência para diversos modelos de base do Amazon Bedrock em que é possível usar barreiras de proteção.

import base64
import boto3
import botocore
import json
import os
import random
import string


guardrail_id = 'guardrail-id'
guardrail_version = 'DRAFT'

model_id = 'stability.sd3-large-v1:0'
output_images_folder = '/path/to/folder/'

body = json.dumps(
    {
        "prompt": "Create an image of a beautiful flower", # Prompt for image generation ("A gun" should get blocked by violence)
        "output_format": "jpeg"
    }
)


def main():
    bedrock_runtime_client = boto3.client("bedrock-runtime", region_name="us-west-2")
    try:
        print("Making a call to InvokeModel API for model: {}".format(model_id))
        response = bedrock_runtime_client.invoke_model(
            body=body,
            modelId=model_id,
            trace='ENABLED',
            guardrailIdentifier=guardrail_id,
            guardrailVersion=guardrail_version
        )
        response_body = json.loads(response.get('body').read())
        print("Received response from InvokeModel API (Request Id: {})".format(response['ResponseMetadata']['RequestId']))
        if 'images' in response_body and len(response_body['images']) > 0:
            os.makedirs(output_images_folder, exist_ok=True)
            images = response_body["images"]
            for image in images:
                image_id = ''.join(random.choices(string.ascii_lowercase + string.digits, k=6))
                image_file = os.path.join(output_images_folder, "generated-image-{}.jpg".format(image_id))
                print("Saving generated image {} at {}".format(image_id, image_file))
                with open(image_file, 'wb') as image_file_descriptor:
                    image_file_descriptor.write(base64.b64decode(image.encode('utf-8')))
        else:
            print("No images generated from model")
        guardrail_trace = response_body['amazon-bedrock-trace']['guardrail']
        guardrail_trace['modelOutput'] = ['<REDACTED>']
        print("Guardrail Trace: {}".format(json.dumps(guardrail_trace, indent=2)))
    except botocore.exceptions.ClientError as err:
        print("Failed while calling InvokeModel API with RequestId = {}".format(err.response['ResponseMetadata']['RequestId']))
        raise err


if __name__ == "__main__":
    main()