Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Bloqueo de imágenes dañinas con filtros de contenido

Las barreras de protección de Amazon Bedrock pueden ayudar a bloquear imágenes inapropiadas o dañinas al configurar filtros de contenido dentro de una barrera de protección.

Requisitos previos y limitaciones

Información general

La detección y el bloqueo de imágenes dañinas solo se admiten en el caso de imágenes o imágenes que contengan texto. Al crear una barrera de protección, los usuarios pueden seleccionar la propia opción de imagen o junto con la opción de texto y establecer la intensidad de filtrado correspondiente en NINGUNA, BAJA, MEDIA o ALTA. Estos umbrales serán comunes al contenido de texto e imagen si se seleccionan ambas modalidades. Las barreras de protección evaluarán las imágenes enviadas como entrada por los usuarios o generadas como salidas desde las respuestas del modelo.

Las categorías admitidas para la detección de contenido de imágenes dañino se describen a continuación:

Uso del filtro de contenido de imagen

Creación o actualización de una barrera de protección con filtros de contenido para imágenes

Al crear una nueva barrera de protección o actualizar una existente, los usuarios ahora verán una opción para seleccionar una imagen además de la opción de texto existente.

Filtrado de los niveles de bloqueo y clasificación

El filtrado se realiza en función de la clasificación de confianza de las entradas de los usuarios y las respuestas del FM. Todas las entradas de los usuarios y las respuestas del modelo se clasifican en cuatro niveles de intensidad: ninguno, bajo, medio y alto. La intensidad del filtro determina la sensibilidad al filtrar el contenido dañino. A medida que aumenta la intensidad del filtro, aumenta la probabilidad de filtrar contenido dañino y disminuye la probabilidad de ver contenido dañino en la aplicación. Cuando se seleccionan las opciones de imagen y texto, se aplica la misma intensidad del filtro a ambas modalidades para una categoría en particular.

Configuración de filtros de contenido para imágenes con API

Puede usar la API de barreras de protección para configurar el filtro de contenido de imagen en Barreras de protección para Amazon Bedrock. En el siguiente ejemplo, se muestra un filtro de Barreras de protección para Amazon Bedrock al que se han aplicado distintas categorías de contenido dañino y distintas intensidades de filtrado. Puede utilizar esta plantilla como ejemplo para su propio caso de uso.

Con la operación contentPolicyConfig, filtersConfig es un objeto, como se muestra en el siguiente ejemplo.

Ejemplo de código de Python Boto3 para crear una barrera de protección con filtros de contenido de imagen

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

Configuración del filtro de imagen para utilizarla con la API ApplyGuardrail

Puede usar filtros de contenido tanto para contenido de imagen como de texto mediante la API ApplyGuardrail. Esta opción le permite usar la configuración del filtro de contenido sin invocar el modelo de Amazon Bedrock. Puede actualizar la carga útil de la solicitud del siguiente script para varios modelos siguiendo la documentación de parámetros de inferencia de cada modelo fundacional de Bedrock compatible con Barreras de protección para Amazon Bedrock.

Puede actualizar la carga útil de la solicitud del siguiente script para varios modelos siguiendo la documentación de parámetros de inferencia de cada modelo fundacional de Bedrock compatible con Barreras de protección para 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()

Configuración del filtro de imagen para trabajar con modelos de generación de imágenes

También puede usar los filtros de imagen de Barreras de protección de Amazon Bedrock con modelos de generación de imágenes como Titan Image Generator y Stability Image o Diffusion. Actualmente, estos modelos son compatibles con la API InvokeModel, que se puede invocar con un barrera de protección. Puede actualizar la carga útil de la solicitud del siguiente script para varios modelos siguiendo la documentación de parámetros de inferencia de los distintos modelos fundacionales de Amazon Bedrock que admiten barreras de protección.

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