Configurare regole di esclusione specifiche per i modelli

Anteprima

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

Puoi configurare regole di esclusione specifiche per i modelli in Model Armor per ridurre i falsi positivi. Le regole di esclusione sono regole specifiche del modello che contengono espressioni regolari o frasi da escludere dal rilevamento.

Filtri supportati

Puoi utilizzare le regole di esclusione per i seguenti filtri:

• Rilevamento di prompt injection e jailbreaking (PROMPT_INJECTION_AND_JAILBREAK)
• Filtri di sicurezza dell'AI responsabile (RESPONSIBLE_AI)

Quando utilizzare le regole di esclusione

Utilizza regole di esclusione specifiche per i modelli quando devi eliminare rilevamenti di falsi positivi noti per workload specifici senza disattivare completamente un filtro:

• Terminologia tecnica o specifica del dominio: i tuoi processi di applicazione utilizzano un vocabolario specializzato, ad esempio comandi di amministrazione di sistema (kill process, abort transaction), terminologia di test di sicurezza (penetration testing), termini scientifici (blast search) o espressioni idiomatiche del settore, che si sovrappongono alle categorie di sicurezza dell'AI responsabile.
• Istruzioni operative o di formattazione benigne: i tuoi utenti o i modelli di prompt includono istruzioni legittime che utilizzano verbi imperativi (ad esempio "ignore case when sorting this list", "ignore empty rows" o "Summarize my inbox and ignore the emails from the marketing vendor.") che attivano falsi positivi nel rilevamento di prompt injection e jailbreak.
• Mitigazione mirata in attesa degli aggiornamenti del modello: hai bisogno di una soluzione alternativa immediata per un falso positivo verificato in un flusso di lavoro dell'applicazione specifico, mantenendo attivo il filtro per tutti gli altri input.

La tabella seguente descrive quando utilizzare ogni combinazione di tipo di regola e ambito di corrispondenza. Per saperne di più su come funzionano la corrispondenza con dizionario e con espressioni regolari, consulta Regole di corrispondenza con dizionario ed espressioni regolari e Come funziona la corrispondenza.

Configurazione della regola	Quando utilizzarlo	Esempio
Regola del dizionario con corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH)	Hai un elenco fisso di parole o frasi statiche che possono essere visualizzate ovunque all'interno di un prompt o di una risposta. Per saperne di più sul comportamento della corrispondenza del dizionario, consulta Regole di dizionario ed espressioni regolari.	Il dizionario contiene la frase ignore empty rows Risultati: ignore empty rows ignore EMPTY-rows please ignore empty rows Non corrisponde a: ignore rows ignore the empty rows
Regola del dizionario con corrispondenza esatta (MATCHING_SCOPE_FULL_MATCH)	La tua applicazione utilizza opzioni di prompt predefinite (ad esempio pulsanti di risposta rapida dell'interfaccia utente o comandi predefiniti) in cui l'intero input corrisponde a una frase nota e vuoi impedire che testo aggiuntivo non filtrato aggiri il filtro. Per saperne di più sul comportamento della corrispondenza del dizionario, consulta Regole di dizionario ed espressioni regolari.	Il dizionario contiene la frase ignore empty rows Risultati: ignore empty rows ignore EMPTY-rows Non corrisponde a: please ignore empty rows ignore rows
Regola di espressione regolare con corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH)	Devi escludere pattern strutturati, identificatori dinamici o combinazioni specifiche di verbi e nomi all'interno di prompt o risposte più grandi. Per saperne di più, vedi Esempio di pattern di esclusione di espressioni regolari.	Pattern di espressione regolare: (?i)kill process [0-9]+ Risultati: kill process 1234 How do I Kill Process 99? Non corrisponde a: kill process abc kill the process 1234
Regola di espressione regolare con corrispondenza completa (MATCHING_SCOPE_FULL_MATCH)	L'intero payload di input segue un formato strutturale rigoroso (ad esempio un identificatore di test automatizzato o un comando strutturato).	Pattern di espressione regolare: (?i)^test_case_[0-9]+$ Risultati: test_case_42 TEST_CASE_001 Non corrisponde a: run test_case_42 test_case_alpha

Utilizza un endpoint regionale o multiregionale

Quando utilizzi un modello Model Armor, devi utilizzare un endpoint regionale o multiregionale (modelarmor.LOCATION.rep.googleapis.com) che corrisponda alla posizione del modello.

L'endpoint globale (modelarmor.googleapis.com) non supporta la gestione dei modelli Model Armor o la sanificazione dei prompt e delle risposte.

Prima di iniziare

Prima di iniziare, completa le seguenti attività.

Ottieni le autorizzazioni richieste

Per ottenere le autorizzazioni necessarie per configurare le regole di esclusione nei modelli Model Armor, chiedi all'amministratore di concederti il ruolo IAM Model Armor Admin (roles/modelarmor.admin) sul progetto Model Armor che contiene il modello Model Armor. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Abilita API

Prima di poter utilizzare Model Armor, devi abilitare l'API Model Armor.

Console

1. Abilita l'API Model Armor, se non è già abilitata.

   Ruoli richiesti per abilitare le API

   Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

   Abilitare l'API

2. Seleziona il progetto in cui vuoi attivare Model Armor.

gcloud

Prima di iniziare, segui questi passaggi utilizzando Google Cloud CLI con l'API Model Armor:

1. Nella console Google Cloud , attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

2. Abilita l'API Model Armor, se non è già abilitata:

   Ruoli richiesti per abilitare le API

   Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

   gcloud services enable modelarmor.googleapis.com

3. Imposta l'override dell'endpoint API utilizzando gcloud CLI.

Imposta l'override dell'endpoint API utilizzando gcloud CLI

Questo passaggio è necessario solo se utilizzi gcloud CLI con Model Armor e vuoi utilizzare una regione o una multi-regione diversa dalla multi-regione us predefinita. Devi impostare manualmente l'override dell'endpoint API per assicurarti che gcloud CLI indirizzi correttamente le richieste al servizio Model Armor.

Esegui questo comando per impostare l'endpoint API per il servizio Model Armor.

gcloud config set api_endpoint_overrides/modelarmor "https://modelarmor.LOCATION.rep.googleapis.com/"

Sostituisci LOCATION con la regione o la multi-regione in cui vuoi utilizzare Model Armor.

Come funzionano le regole di esclusione

Configura le regole di esclusione utilizzando l'API Model Armor.

Regole di dizionario ed espressioni regolari

Puoi definire due tipi di regole di esclusione all'interno di un modello Model Armor:

• Regole del dizionario: specifica un elenco di parole o frasi (wordList, fino a 128 KB per dizionario) da escludere. Un dizionario deve contenere almeno una frase e ogni frase deve contenere almeno due caratteri costituiti da lettere o cifre. La corrispondenza del dizionario funziona nel seguente modo:
  • Insensibilità alle maiuscole: le parole e le frasi del dizionario non fanno distinzione tra maiuscole e minuscole.
  • Caratteri non alfanumerici: durante la scansione per trovare corrispondenze, tutti i caratteri diversi da lettere e cifre nel Basic Multilingual Plane vengono sostituiti con spazi vuoti. Ad esempio, la frase del dizionario Sam Johnson corrisponde a sam johnson, Sam, Johnson e Sam (Johnson). Le frasi del dizionario che contengono molti caratteri diversi da lettere o cifre potrebbero produrre corrispondenze inaspettate perché questi caratteri vengono trattati come spazi vuoti.
  • Limiti dei caratteri: i caratteri che circondano una corrispondenza devono essere di un tipo diverso rispetto ai caratteri adiacenti all'interno della parola del dizionario. Le lettere devono essere adiacenti a caratteri non alfabetici e le cifre devono essere adiacenti a caratteri non numerici. Ad esempio, la parola del dizionario jen corrisponde alle prime tre lettere di jen123, ma non a jennifer.
• Regole di espressione regolare: specifica un pattern di espressione regolare (fino a 1000 caratteri) da corrispondere ed escludere. Per impostazione predefinita, le corrispondenze delle espressioni regolari sono sensibili alle maiuscole. Per eseguire una corrispondenza senza distinzione tra maiuscole e minuscole, includi il flag (?i) nel pattern. Ad esempio, (?i)kill process [0-9]+ corrisponde sia a kill process 1234 sia a Kill Process 1234.

Come funziona la corrispondenza

Ogni regola di esclusione supporta il campo matchingScope, che specifica in che modo Model Armor confronta i contenuti di input con la regola:

• Corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH, impostazione predefinita):
  • Regole del dizionario: si verifica una corrispondenza quando una parola o una frase nel dizionario corrisponde a una sottostringa nei contenuti di input, in base alle regole di delimitazione dei caratteri del dizionario. Ad esempio, la frase del dizionario ignore empty rows corrisponde a ignore empty rows, ignore EMPTY-rows e Please ignore empty rows and summarize this table, ma non a ignore rows o ignore the empty rows.
  • Regole di espressione regolare: la corrispondenza si verifica quando una sottostringa nel contenuto di input corrisponde al pattern dell'espressione regolare.
• Corrispondenza esatta (MATCHING_SCOPE_FULL_MATCH):
  • Regole del dizionario: la corrispondenza si verifica solo quando la voce del dizionario copre l'intero contenuto dell'input. Ad esempio, la frase del dizionario ignore empty rows corrisponde a ignore empty rows e ignore EMPTY-rows, ma non a please ignore empty rows o ignore rows.
  • Regole di espressione regolare: la corrispondenza si verifica solo quando il pattern dell'espressione regolare corrisponde all'intero contenuto di input.

Override delle regole di esclusione durante la sanificazione

Se un modello include regole di esclusione, Model Armor valuta queste regole durante la sanificazione dei prompt e delle risposte del modello ogni volta che un filtro di prompt injection e jailbreaking (PROMPT_INJECTION_AND_JAILBREAK) o di AI responsabile (RESPONSIBLE_AI) identifica una potenziale corrispondenza:

• La regola corrisponde all'input: se una regola di esclusione corrisponde a una sottostringa (MATCHING_SCOPE_PARTIAL_MATCH, impostazione predefinita) o all'intero input dall'inizio alla fine (MATCHING_SCOPE_FULL_MATCH), Model Armor esegue l'override di matchState e lo imposta su NO_MATCH_FOUND per l'intero tipo di filtro supportato (incluse tutte le categorie di sicurezza dell'AI responsabile per RESPONSIBLE_AI), anziché escludere singole frasi o intervalli all'interno dell'input. Se nessun altro filtro attivo rileva una violazione, filterMatchState restituisce NO_MATCH_FOUND. Model Armor non registra un indicatore in Cloud Logging né include un segnale nella risposta di sanificazione quando una regola di esclusione sostituisce il filtro matchState.
• La regola non corrisponde all'input completo (MATCHING_SCOPE_FULL_MATCH): se l'input contiene testo aggiuntivo oltre alla frase o al pattern configurato, la regola non corrisponde e il filtro mantiene MATCH_FOUND.
• L'input supera 0,5 MB: le regole di esclusione valutano solo i primi 0,5 MB di testo di input. Se un input supera 0,5 MB e un filtro rileva una corrispondenza al di fuori della porzione iniziale scansionata, il filtro restituisce EXECUTION_SKIPPED. Per informazioni dettagliate sui valori di messageItems e sui limiti del payload, consulta Limiti del sistema di regole di esclusione.

Per esempi di sanitizzazione di prompt e risposte del modello con regole di esclusione, consulta Sanificare un prompt con una regola di esclusione e Sanificare una risposta con una regola di esclusione.

Considerazioni

Quando configuri le regole di esclusione, tieni presente quanto segue:

• Le regole di esclusione si applicano solo al modello in cui le definisci. Non puoi condividere le regole di esclusione tra i modelli.
• Puoi configurare regole di esclusione per un tipo di filtro supportato solo quando il filtro è abilitato nel modello. Per il rilevamento di prompt injection e jailbreaking (PROMPT_INJECTION_AND_JAILBREAK), imposta filterEnforcement su ENABLED in piAndJailbreakFilterSettings. Per attivare i filtri di sicurezza dell'AI responsabile (RESPONSIBLE_AI), configura almeno una categoria di sicurezza dell'AI responsabile in raiSettings.raiFilters.
• Model Armor non supporta le regole di esclusione nelle API di streaming o nelle impostazioni di base.
• Model Armor valuta le regole di esclusione in base al testo di input non elaborato prima di eseguire trasformazioni del testo come l'anonimizzazione o la traduzione. Le regole di esclusione non supportano il rilevamento multilingue o la traduzione automatica. Per escludere contenuti in più lingue, aggiungi frasi specifiche per la lingua o pattern di espressioni regolari per ogni lingua di destinazione.
• Le regole di esclusione supportano in modo limitato le lingue con caratteri non latini e i caratteri UTF-8 multibyte. In particolare, le regole del dizionario (wordList) potrebbero non corrispondere come previsto per gli script che utilizzano segni di combinazione (come gli script indiani) o gli script senza spazi tra le parole (come il cinese e il giapponese). Le regole di corrispondenza esatta (MATCHING_SCOPE_FULL_MATCH) non corrispondono agli input contenenti caratteri UTF-8 multibyte. Quando escludi contenuti in script non latini o input con caratteri multibyte, utilizza regole di espressioni regolari (regex) con MATCHING_SCOPE_PARTIAL_MATCH.
• Le regole di esclusione sono soggette a limiti di sistema. Per saperne di più, consulta Limiti di sistema delle regole di esclusione.

Crea un modello con regole di esclusione

Per creare un modello con regole di esclusione, includi l'oggetto filterRuleSettings all'interno di filterConfig in una richiesta POST.

L'esempio seguente crea un modello che attiva l'injection di prompt e il rilevamento di jailbreak e i filtri di sicurezza dell'AI responsabile e configura due regole di esclusione con corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH):

• Rilevamento di prompt injection e jailbreaking (PROMPT_INJECTION_AND_JAILBREAK): utilizza una regola del dizionario per escludere gli input contenenti frasi specifiche, ad esempio ignore case when sorting this list o ignore empty rows, dai rilevamenti di prompt injection e jailbreaking.
• AI responsabile (RESPONSIBLE_AI): utilizza una regola di espressione regolare per escludere gli input che corrispondono a un pattern specificato, ad esempio (?i)kill process [0-9]+, dai rilevamenti di sicurezza dell'AI responsabile.

export TEMPLATE_WITH_EXCLUSIONS='{
  "filterConfig": {
    "piAndJailbreakFilterSettings": {
      "filterEnforcement": "ENABLED",
      "confidenceLevel": "LOW_AND_ABOVE"
    },
    "raiSettings": {
      "raiFilters": [
        {
          "filterType": "DANGEROUS",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HARASSMENT",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HATE_SPEECH",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "SEXUALLY_EXPLICIT",
          "confidenceLevel": "LOW_AND_ABOVE"
        }
      ]
    },
    "filterRuleSettings": {
      "ruleSets": [
        {
          "filterTypes": [
            "PROMPT_INJECTION_AND_JAILBREAK"
          ],
          "rules": [
            {
              "exclusionRule": {
                "dictionary": {
                  "wordList": {
                    "words": [
                      "EXCLUDED_PHRASE_1",
                      "EXCLUDED_PHRASE_2"
                    ]
                  }
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        },
        {
          "filterTypes": [
            "RESPONSIBLE_AI"
          ],
          "rules": [
            {
              "exclusionRule": {
                "regex": {
                  "pattern": "EXCLUDED_REGEX_PATTERN"
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        }
      ]
    }
  }
}'

curl -X POST \
  -d "$TEMPLATE_WITH_EXCLUSIONS" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates?template_id=TEMPLATE_ID"

Sostituisci quanto segue:

• EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: le parole o le frasi del dizionario da escludere dal rilevamento di prompt injection e jailbreaking, ad esempio ignore case when sorting this list e ignore empty rows.
• EXCLUDED_REGEX_PATTERN: il pattern dell'espressione regolare da escludere dal rilevamento della sicurezza dell'AI responsabile, ad esempio (?i)kill process [0-9]+.
• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Questo comando restituisce una risposta simile alla seguente:

{
  "filterConfig": {
    "raiSettings": {
      "raiFilters": [
        {
          "filterType": "DANGEROUS",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HARASSMENT",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HATE_SPEECH",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "SEXUALLY_EXPLICIT",
          "confidenceLevel": "LOW_AND_ABOVE"
        }
      ]
    },
    "piAndJailbreakFilterSettings": {
      "filterEnforcement": "ENABLED",
      "confidenceLevel": "LOW_AND_ABOVE"
    },
    "filterRuleSettings": {
      "ruleSets": [
        {
          "filterTypes": [
            "PROMPT_INJECTION_AND_JAILBREAK"
          ],
          "rules": [
            {
              "exclusionRule": {
                "dictionary": {
                  "wordList": {
                    "words": [
                      "ignore case when sorting this list",
                      "ignore empty rows"
                    ]
                  }
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        },
        {
          "filterTypes": [
            "RESPONSIBLE_AI"
          ],
          "rules": [
            {
              "exclusionRule": {
                "regex": {
                  "pattern": "(?i)kill process [0-9]+"
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        }
      ]
    }
  },
  "templateMetadata": {
    "dataResidencyCompliant": true
  }
}

Aggiorna le regole di esclusione in un modello

Per aggiornare le regole di esclusione in un modello esistente, invia una richiesta PATCH con updateMask impostato su filterConfig.filterRuleSettings. Poiché l'aggiornamento sostituisce l'intero campo filterRuleSettings, includi tutte le regole che vuoi conservare insieme alle modifiche.

L'esempio seguente aggiorna le regole di esclusione dell'esempio precedente aggiungendo una regola di espressione regolare al set di regole PROMPT_INJECTION_AND_JAILBREAK e rimuovendo il set di regole RESPONSIBLE_AI:

export EXCLUSION_RULES_UPDATE='{
  "filterConfig": {
    "filterRuleSettings": {
      "ruleSets": [
        {
          "filterTypes": [
            "PROMPT_INJECTION_AND_JAILBREAK"
          ],
          "rules": [
            {
              "exclusionRule": {
                "dictionary": {
                  "wordList": {
                    "words": [
                      "EXCLUDED_PHRASE_1",
                      "EXCLUDED_PHRASE_2"
                    ]
                  }
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            },
            {
              "exclusionRule": {
                "regex": {
                  "pattern": "EXCLUDED_REGEX_PATTERN"
                },
                "matchingScope": "MATCHING_SCOPE_FULL_MATCH"
              }
            }
          ]
        }
      ]
    }
  }
}'

curl -X PATCH \
  -d "$EXCLUSION_RULES_UPDATE" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID?updateMask=filterConfig.filterRuleSettings"

Sostituisci quanto segue:

• EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: le parole o le frasi del dizionario da escludere dal rilevamento di prompt injection e jailbreaking, ad esempio ignore case when sorting this list e ignore empty rows.
• EXCLUDED_REGEX_PATTERN: il pattern dell'espressione regolare da escludere dal rilevamento di prompt injection e jailbreaking, ad esempio (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b.
• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Esempi di pattern di esclusione delle espressioni regolari

Quando scrivi regole di esclusione delle espressioni regolari, limita l'ambito dei pattern a termini di dominio o sostantivi target specifici in modo che Model Armor escluda i falsi positivi noti senza ignorare le violazioni effettive della sicurezza. Quando passi pattern di espressioni regolari all'interno dei corpi delle richieste JSON ("pattern"), esegui l'escape di ogni barra rovesciata con una seconda barra rovesciata (ad esempio, utilizza \\b e \\s).

Esempi di rilevamento di prompt injection e jailbreaking

Verbi imperativi come ignore, disregard, bypass o override compaiono spesso sia nei prompt malevoli sia nelle istruzioni legittime per la classificazione delle email, la formattazione dei dati, la gestione degli errori o la configurazione del sistema. Per evitare di escludere ampie categorie di prompt, combina i limiti delle parole (\\b), i gruppi non di acquisizione ((?:...)) e il flag senza distinzione tra maiuscole e minuscole ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH per ancorare l'espressione regolare a sostantivi di destinazione operativi specifici.

La tabella seguente fornisce un esempio di pattern di espressione regolare di corrispondenza parziale (con barre rovesciate con escape JSON) e un esempio di prompt per lo scenario di falsi positivi di prompt injection e jailbreak.

Categoria istruzione	Termini di attivazione	Scenari di falsi positivi	Esempio di pattern di espressione regolare a corrispondenza parziale	Prompt di esempio
Triage e filtraggio dei contenuti	ignore, disregard	Triage delle email, gestione degli errori e revisione delle bozze	(?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b	Summarize my inbox and ignore the emails from the marketing vendor.

Esempi di filtri di sicurezza per l'AI responsabile

La documentazione tecnica, i comandi di amministrazione del sistema e le espressioni idiomatiche comuni spesso contengono parole che si sovrappongono alle categorie di sicurezza dell'AI responsabile. Per ridurre i falsi positivi in prompt o risposte più grandi, combina i limiti delle parole (\\b), i gruppi non di acquisizione ((?:...)) e il flag che non fa distinzione tra maiuscole e minuscole ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH.

La tabella seguente fornisce esempi di pattern di espressioni regolari a corrispondenza parziale (con barre rovesciate con escape JSON) ed esempi di prompt per scenari comuni di falsi positivi dell'AI responsabile.

Categoria di rischio	Termini di attivazione	Scenari di falsi positivi	Esempio di pattern di espressione regolare a corrispondenza parziale	Prompt di esempio
Violenza o danno	kill	Interruzione di processi, interruttori elettrici o dell'impianto di climatizzazione ed espressioni idiomatiche comuni	(?i)\\b(?:kill\\s+(?:-9|all|process(?:es)?|switch(?:es)?|jobs?|pods?|sessions?|bill|lights?)|time\\s+to\\s+kill|dressed\\s+to\\s+kill)\\b	Please kill all pods in the namespace.
Tossicità o linguaggio offensivo	abort, terminate	Transazioni di database, ciclo di vita della missione e termini di impiego o contratto	(?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b	Abort retry.
Corrispondenze di sottostringhe nei termini del dominio	Sottostringhe di caratteri sovrapposte	Termini accademici, botanica, ornitologia, aviazione e nomi propri	(?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b	I love reading Dickens.
Armi o esplosivi	bomb, blast, detonate	Bioinformatica, espressioni idiomatiche di intrattenimento e attrezzature industriali o pulizia	(?i)\\b(?:blast\\s+(?:search|alignment|radius|furnace)|box\\s+office\\s+bomb|had\\s+a\\s+blast)\\b	Run a blast search on the genetic sequence.

Best practice per la configurazione delle regole di esclusione

Segui queste best practice per ridurre al minimo i falsi positivi senza compromettere la postura di sicurezza del modello:

• Limita le regole di ambito a contesti specifici: evita di escludere singoli verbi o termini generici (come ignore, kill o abort) o di utilizzare caratteri jolly senza vincoli (come .*ignore.*). Poiché MATCHING_SCOPE_PARTIAL_MATCH esegue l'override di matchState su NO_MATCH_FOUND per l'intero filtro ogni volta che una sottostringa corrisponde, regole troppo generiche possono mascherare violazioni reali altrove nello stesso prompt o risposta. Associa sempre i verbi di attivazione a nomi di destinazione specifici (ad esempio, ignore case when sorting this list o (?i)kill process [0-9]+).
• Utilizza i limiti delle parole e consolida i pattern: nelle regole delle espressioni regolari, utilizza i limiti delle parole (\b) per evitare corrispondenze accidentali di sottostringhe all'interno di parole non correlate. Consolida le frasi correlate in un'unica espressione regolare utilizzando gruppi non di acquisizione ((?:...)) e alternanza (|) per rimanere entro il limite di sistema di 10 regole per set di regole.
• Preferisci MATCHING_SCOPE_FULL_MATCH per input prevedibili: quando escludi prompt UI predefiniti, comandi predefiniti o payload di test automatici, imposta matchingScope su MATCHING_SCOPE_FULL_MATCH (o ancora le espressioni regolari con ^ e $). L'ambito di corrispondenza esatta impedisce agli utenti di aggiungere istruzioni ostili a una frase esclusa per aggirare il rilevamento.
• Scrivi regole per il testo non elaborato e non trasformato: Model Armor valuta le regole di esclusione prima della deidentificazione o della traduzione. Assicurati che i pattern corrispondano al formato originale prima della deidentificazione e aggiungi frasi specifiche per la lingua o pattern di espressioni regolari per ogni lingua supportata dalla tua applicazione.
• Rivedi e ritira le regole temporanee dopo gli upgrade dei filtri: quando esegui l'upgrade di un modello a una versione del filtro più recente, valuta nuovamente gli scenari di test dei falsi positivi e rimuovi le regole di esclusione risolte dai modelli di rilevamento aggiornati.

Passaggi successivi

• Consulta esempi di come sanificare i prompt e sanificare le risposte del modello con regole di esclusione.
• Esamina i limiti del sistema di regole di esclusione.
• Scopri come creare e gestire i modelli Model Armor.