Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Bloccare le immagini dannose con filtri dei contenuti

Guardrail per Amazon Bedrock può aiutare a bloccare immagini inappropriate o dannose durante la configurazione dei filtri dei contenuti in un guardrail.

Prerequisiti e limitazioni

Panoramica

Il rilevamento e il blocco di immagini dannose sono supportati solo per le immagini o per le immagini contenenti testo. Durante la creazione di un guardrail, gli utenti possono selezionare l’opzione immagine da sola o insieme all’opzione testo e impostare il rispettivo livello di intensità del filtro su NESSUNO, BASSO, MEDIO o ALTO. Queste soglie saranno comuni sia ai contenuti di testo che a quelli di immagine se vengono selezionate entrambe le modalità. Guardrail valuterà le immagini inviate come input dagli utenti o generate come output dalle risposte del modello.

Le categorie supportate per il rilevamento di contenuti di immagini dannose sono descritte di seguito:

Utilizzo del filtro di contenuti per immagini

Creazione o aggiornamento di un guardrail con filtri di contenuti per immagini

Durante la creazione di un nuovo guardrail o l’aggiornamento di un guardrail esistente, ora gli utenti visualizzano un’opzione per selezionare l’immagine oltre all’opzione di testo esistente.

Classificazione dei filtri e livelli di blocco

I filtri vengono applicati in base alla classificazione di affidabilità degli input degli utenti e delle risposte del modello di fondazione. Tutti gli input dell’utente e le risposte del modello sono classificati in base a quattro livelli di intensità: Nessuno, Basso, Medio e Alto. L’intensità del filtro determina la sensibilità del filtro applicato a contenuti dannosi. All’aumentare della potenza del filtro, aumenta la probabilità di filtrare i contenuti dannosi e diminuisce la probabilità di vedere contenuti dannosi nell’applicazione. Quando sono selezionate entrambe le opzioni relative a immagine e testo, la stessa intensità di filtro viene applicata a entrambe le modalità per una particolare categoria.

Configurazione dei filtri di contenuti per immagini con API

È possibile utilizzare l’API guardrail per configurare il filtro di contenuti per immagini in Guardrail per Amazon Bedrock. L’esempio seguente mostra un filtro di Guardrail per Amazon Bedrock con diverse categorie di contenuti dannosi e diversi livelli di intensità del filtro applicati. È possibile utilizzare questo modello come esempio per un proprio caso d’uso.

Con l’operazione contentPolicyConfig, filtersConfig è un oggetto, come mostrato nell’esempio seguente.

Esempio di codice Python Boto3 per creare un guardrail con filtri di contenuti per immagini

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

Configurazione del filtro per immagini da utilizzare con l’API ApplyGuardrail

È possibile utilizzare i filtri di contenuti sia per contenuti per immagini che per quelli di testo utilizzando l’API ApplyGuardrail. Questa opzione consente di utilizzare le impostazioni del filtro dei contenuti senza invocare il modello di Amazon Bedrock. È possibile aggiornare il payload della richiesta nello script seguente per vari modelli seguendo la documentazione dei parametri di inferenza per ogni modello di fondazione supportato da Guardrail per Amazon Bedrock.

È possibile aggiornare il payload della richiesta nello script seguente per vari modelli seguendo la documentazione dei parametri di inferenza per ogni modello di fondazione supportato da Guardrail per 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()

Configurazione del filtro per immagini da utilizzare con i modelli di generazione di immagini

È inoltre possibile utilizzare i filtri per immagini di Guardrail per Amazon Bedrock con modelli di generazione di immagini come Generatore di immagini Titan e i modelli Stability Image o Diffusion. Questi modelli sono attualmente supportati tramite l’API InvokeModel che può essere invocata con un guardrail. È possibile aggiornare il payload della richiesta nello script seguente per vari modelli seguendo la documentazione dei parametri di inferenza per i vari modelli di fondazione supportati da Guardrail per Amazon Bedrock.

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