Configurer des règles d'exclusion spécifiques aux modèles

Aperçu

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Vous pouvez configurer des règles d'exclusion spécifiques aux modèles dans Model Armor pour atténuer les faux positifs. Les règles d'exclusion sont des règles spécifiques aux modèles qui contiennent des expressions régulières ou des expressions à exclure de la détection.

Filtres acceptés

Vous pouvez utiliser des règles d'exclusion pour les filtres suivants :

• Détection de l'injection de prompt et du jailbreaking (PROMPT_INJECTION_AND_JAILBREAK)
• Filtres de sécurité de l'IA responsable (RESPONSIBLE_AI)

Quand utiliser des règles d'exclusion

Utilisez des règles d'exclusion spécifiques aux modèles lorsque vous devez supprimer des faux positifs connus pour des charges de travail spécifiques sans désactiver complètement un filtre :

• Terminologie technique ou spécifique à un domaine : votre application traite un vocabulaire spécialisé, comme des commandes d'administration système (kill process, abort transaction), des termes de tests de sécurité (penetration testing), des termes scientifiques (blast search) ou des expressions idiomatiques du secteur, qui chevauchent les catégories de sécurité de l'IA responsable.
• Instructions opérationnelles ou de mise en forme bénignes : vos utilisateurs ou vos modèles de prompt incluent des instructions légitimes qui utilisent des verbes impératifs (tels que "ignore case when sorting this list", "ignore empty rows" ou "Summarize my inbox and ignore the emails from the marketing vendor.") qui déclenchent des faux positifs dans la détection de l'injection de prompt et du jailbreak.
• Atténuation ciblée en attendant les mises à jour du modèle : vous avez besoin d'une solution de contournement immédiate pour un faux positif validé dans un workflow d'application spécifique, tout en gardant le filtre actif pour toutes les autres entrées.

Le tableau suivant décrit quand utiliser chaque combinaison de type de règle et de champ d'application. Pour en savoir plus sur le fonctionnement de la correspondance des dictionnaires et des expressions régulières, consultez Règles de dictionnaire et d'expressions régulières et Fonctionnement de la correspondance.

Configuration de la règle	Cas d'utilisation	Exemple
Règle de dictionnaire avec correspondance partielle (MATCHING_SCOPE_PARTIAL_MATCH)	Vous disposez d'une liste fixe de mots ou d'expressions statiques qui peuvent apparaître n'importe où dans une requête ou une réponse. Pour en savoir plus sur le comportement de la correspondance de dictionnaire, consultez Règles de dictionnaire et d'expressions régulières.	Le dictionnaire contient l'expression ignore empty rows Correspondances : ignore empty rows ignore EMPTY-rows please ignore empty rows Pas de correspondance : ignore rows ignore the empty rows
Règle de dictionnaire avec correspondance exacte (MATCHING_SCOPE_FULL_MATCH)	Votre application utilise des options d'invite prédéfinies (telles que des boutons de réponse rapide de l'UI ou des commandes prédéfinies) où l'intégralité de la saisie correspond à une expression connue, et vous souhaitez empêcher que du texte non filtré supplémentaire contourne le filtre. Pour en savoir plus sur le comportement de la correspondance de dictionnaire, consultez Règles de dictionnaire et d'expressions régulières.	Le dictionnaire contient l'expression ignore empty rows Correspondances : ignore empty rows ignore EMPTY-rows Pas de correspondance : please ignore empty rows ignore rows
Règle d'expression régulière avec correspondance partielle (MATCHING_SCOPE_PARTIAL_MATCH)	Vous devez exclure les schémas structurés, les identifiants dynamiques ou les combinaisons spécifiques de verbes et de noms dans les requêtes ou les réponses plus longues. Pour en savoir plus, consultez Exemples de modèles d'exclusion d'expressions régulières.	Modèle d'expression régulière : (?i)kill process [0-9]+ Correspondances : kill process 1234 How do I Kill Process 99? Pas de correspondance : kill process abc kill the process 1234
Règle d'expression régulière avec correspondance exacte (MATCHING_SCOPE_FULL_MATCH)	L'intégralité de la charge utile d'entrée suit un format structurel strict (tel qu'un identifiant de test automatisé ou une commande structurée).	Modèle d'expression régulière : (?i)^test_case_[0-9]+$ Correspondances : test_case_42 TEST_CASE_001 Pas de correspondance : run test_case_42 test_case_alpha

Utiliser un point de terminaison régional ou multirégional

Lorsque vous travaillez avec un modèle Model Armor, vous devez utiliser un point de terminaison régional ou multirégional (modelarmor.LOCATION.rep.googleapis.com) correspondant à l'emplacement du modèle.

Le point de terminaison mondial (modelarmor.googleapis.com) n'est pas compatible avec la gestion des modèles Model Armor ni avec la désinfection des requêtes et des réponses.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes.

Obtenir les autorisations requises

Pour obtenir les autorisations nécessaires pour configurer des règles d'exclusion dans les modèles Model Armor, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Model Armor (roles/modelarmor.admin) sur le projet qui contient le modèle Model Armor. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Activer les API

Vous devez activer l'API Model Armor avant de pouvoir utiliser Model Armor.

Console

1. Activez l'API Model Armor, si ce n'est pas déjà fait.

   Rôles requis pour activer les API

   Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation grâce au rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation grâce au rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

   Activer l'API

2. Sélectionnez le projet dans lequel vous souhaitez activer Model Armor.

gcloud

Avant de commencer, suivez ces étapes à l'aide de la Google Cloud CLI avec l'API Model Armor :

1. Dans la console Google Cloud , activez Cloud Shell.

   Activer Cloud Shell

   En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

2. Activez l'API Model Armor si ce n'est pas déjà fait :

   Rôles requis pour activer les API

   Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation grâce au rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation grâce au rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

   gcloud services enable modelarmor.googleapis.com

3. Définissez le remplacement du point de terminaison de l'API à l'aide de la gcloud CLI.

Définir le remplacement du point de terminaison de l'API à l'aide de la gcloud CLI

Cette étape n'est requise que si vous utilisez la gcloud CLI avec Model Armor et que vous souhaitez utiliser une région ou une multirégion autre que la multirégion us par défaut. Vous devez définir manuellement le remplacement du point de terminaison de l'API pour vous assurer que la gcloud CLI achemine correctement les requêtes vers le service Model Armor.

Exécutez la commande suivante pour définir le point de terminaison de l'API pour le service Model Armor.

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

Remplacez LOCATION par la région ou la région multiple dans laquelle vous souhaitez utiliser Model Armor.

Fonctionnement des règles d'exclusion

Vous configurez des règles d'exclusion à l'aide de l'API Model Armor.

Règles de dictionnaire et d'expression régulière

Vous pouvez définir deux types de règles d'exclusion dans un modèle Model Armor :

• Règles de dictionnaire : spécifiez une liste de mots ou d'expressions (wordList, jusqu'à 128 Ko par dictionnaire) à exclure. Un dictionnaire doit contenir au moins une expression, et chaque expression doit contenir au moins deux caractères correspondant à des lettres ou des chiffres. La mise en correspondance par dictionnaire fonctionne comme suit :
  • Non-sensibilité à la casse : les mots et expressions du dictionnaire ne sont pas sensibles à la casse.
  • Caractères non alphanumériques : lors de la recherche de correspondances, tous les caractères autres que les lettres et les chiffres du plan multilingue de base d'Unicode sont remplacés par des espaces. Par exemple, l'expression du dictionnaire Sam Johnson correspond à sam johnson, Sam, Johnson et Sam (Johnson). Les expressions du dictionnaire qui contiennent de nombreux caractères autres que des lettres ou des chiffres peuvent générer des correspondances inattendues, car ces caractères sont traités comme des espaces blancs.
  • Limites de caractères : les caractères entourant une correspondance doivent être d'un type différent de celui des caractères adjacents dans le mot du dictionnaire. Les lettres doivent être adjacentes à des caractères non alphabétiques, et les chiffres doivent être adjacents à des caractères non numériques. Par exemple, le mot du dictionnaire jen correspond aux trois premières lettres de jen123, mais pas à jennifer.
• Règles d'expression régulière : spécifiez un modèle d'expression régulière (jusqu'à 1 000 caractères) à faire correspondre et à exclure. Par défaut, les correspondances d'expressions régulières sont sensibles à la casse. Pour effectuer une correspondance insensible à la casse, incluez le flag (?i) dans votre modèle. Par exemple, (?i)kill process [0-9]+ correspond à la fois à kill process 1234 et à Kill Process 1234.

Fonctionnement de la mise en correspondance

Chaque règle d'exclusion est compatible avec le champ matchingScope, qui spécifie la façon dont Model Armor fait correspondre le contenu saisi à la règle :

• Correspondance partielle (MATCHING_SCOPE_PARTIAL_MATCH, par défaut) :
  • Règles de dictionnaire : une correspondance est établie lorsqu'un mot ou une expression du dictionnaire correspond à une sous-chaîne du contenu saisi, sous réserve des règles de limites de caractères du dictionnaire. Par exemple, l'expression de dictionnaire ignore empty rows correspond à ignore empty rows, ignore EMPTY-rows et Please ignore empty rows and summarize this table, mais pas à ignore rows ni à ignore the empty rows.
  • Règles d'expression régulière : la règle est respectée lorsqu'une sous-chaîne du contenu d'entrée correspond au modèle d'expression régulière.
• Correspondance exacte (MATCHING_SCOPE_FULL_MATCH) :
  • Règles de dictionnaire : la correspondance n'est établie que lorsque l'entrée du dictionnaire couvre l'intégralité du contenu saisi. Par exemple, l'expression de dictionnaire ignore empty rows correspond à ignore empty rows et ignore EMPTY-rows, mais pas à please ignore empty rows ni à ignore rows.
  • Règles d'expression régulière : la correspondance n'est établie que lorsque le modèle d'expression régulière correspond à l'intégralité du contenu saisi.

Remplacements des règles d'exclusion lors de la désinfection

Si un modèle inclut des règles d'exclusion, Model Armor les évalue lors du nettoyage des prompts et des réponses du modèle chaque fois qu'un filtre de détection d'injection de prompt et de jailbreaking (PROMPT_INJECTION_AND_JAILBREAK) ou d'IA responsable (RESPONSIBLE_AI) identifie une correspondance potentielle :

• La règle correspond à l'entrée : si une règle d'exclusion correspond à une sous-chaîne (MATCHING_SCOPE_PARTIAL_MATCH, par défaut) ou à l'intégralité de l'entrée du début à la fin (MATCHING_SCOPE_FULL_MATCH), Model Armor remplace matchState et le définit sur NO_MATCH_FOUND pour l'intégralité du type de filtre compatible (y compris toutes les catégories de sécurité de l'IA responsable pour RESPONSIBLE_AI), plutôt que d'exclure des expressions ou des étendues individuelles dans l'entrée. Si aucun autre filtre actif ne détecte d'infraction, filterMatchState renvoie NO_MATCH_FOUND. Model Armor n'enregistre pas d'indicateur dans Cloud Logging ni n'inclut de signal dans la réponse de nettoyage lorsqu'une règle d'exclusion remplace le filtre matchState.
• La règle ne correspond pas à l'intégralité de la saisie (MATCHING_SCOPE_FULL_MATCH) : si la saisie contient du texte supplémentaire au-delà de l'expression ou du modèle configuré, la règle ne correspond pas et le filtre conserve MATCH_FOUND.
• L'entrée dépasse 0,5 Mo : les règles d'exclusion n'évaluent que les 0,5 Mo initiaux du texte d'entrée. Si une entrée dépasse 0,5 Mo et qu'un filtre détecte une correspondance en dehors de la partie analysée initiale, le filtre renvoie EXECUTION_SKIPPED. Pour en savoir plus sur les valeurs messageItems et les limites de charge utile, consultez Limites du système des règles d'exclusion.

Pour obtenir des exemples de nettoyage des requêtes et des réponses du modèle à l'aide de règles d'exclusion, consultez Nettoyer une requête avec une règle d'exclusion et Nettoyer une réponse avec une règle d'exclusion.

Remarques

Lorsque vous configurez des règles d'exclusion, tenez compte des points suivants :

• Les règles d'exclusion ne s'appliquent qu'au modèle dans lequel vous les définissez. Vous ne pouvez pas partager de règles d'exclusion entre les modèles.
• Vous ne pouvez configurer des règles d'exclusion pour un type de filtre compatible que lorsque ce filtre est activé dans le modèle. Pour la détection de l'injection de prompt et du jailbreaking (PROMPT_INJECTION_AND_JAILBREAK), définissez filterEnforcement sur ENABLED dans piAndJailbreakFilterSettings. Pour activer les filtres de sécurité de l'IA responsable (RESPONSIBLE_AI), configurez au moins une catégorie de sécurité de l'IA responsable dans raiSettings.raiFilters.
• Model Armor n'est pas compatible avec les règles d'exclusion dans les API de streaming ni avec les paramètres de plancher.
• Model Armor évalue les règles d'exclusion par rapport au texte d'entrée brut avant d'effectuer des transformations de texte telles que la désidentification ou la traduction. Les règles d'exclusion ne sont pas compatibles avec la détection multilingue ni la traduction automatique. Pour exclure du contenu dans plusieurs langues, ajoutez des expressions ou des modèles d'expressions régulières spécifiques à chaque langue cible.
• Les règles d'exclusion sont limitées pour les langues utilisant des caractères non latins et les caractères UTF-8 multi-octets. En particulier, les règles de dictionnaire (wordList) peuvent ne pas correspondre comme prévu pour les scripts qui utilisent des signes diacritiques (comme les scripts indiens) ou les scripts sans espaces entre les mots (comme le chinois et le japonais). Les règles de correspondance exacte (MATCHING_SCOPE_FULL_MATCH) ne correspondent pas aux entrées contenant des caractères UTF-8 multi-octets. Lorsque vous excluez du contenu dans des scripts non latins ou des entrées avec des caractères multi-octets, utilisez des règles d'expression régulière (regex) avec MATCHING_SCOPE_PARTIAL_MATCH.
• Les règles d'exclusion sont soumises à des limites système. Pour en savoir plus, consultez Limites du système de règles d'exclusion.

Créer un modèle avec des règles d'exclusion

Pour créer un modèle avec des règles d'exclusion, incluez l'objet filterRuleSettings dans filterConfig dans une requête POST.

L'exemple suivant crée un modèle qui active les filtres de sécurité pour la détection des injections de prompts et des tentatives de jailbreaking, ainsi que pour l'IA responsable, et configure deux règles d'exclusion avec correspondance partielle (MATCHING_SCOPE_PARTIAL_MATCH) :

• Détection de l'injection de prompt et du jailbreaking (PROMPT_INJECTION_AND_JAILBREAK) : utilise une règle de dictionnaire pour exclure les entrées contenant des expressions spécifiques, telles que ignore case when sorting this list ou ignore empty rows, des détections d'injection de prompt et de jailbreaking.
• IA responsable (RESPONSIBLE_AI) : utilise une règle d'expression régulière pour exclure les entrées correspondant à un modèle spécifié, tel que (?i)kill process [0-9]+, des détections de sécurité de l'IA responsable.

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"

Remplacez les éléments suivants :

• EXCLUDED_PHRASE_1 et EXCLUDED_PHRASE_2 : mots ou expressions du dictionnaire à exclure de la détection de l'injection de prompt et du jailbreaking, par exemple, ignore case when sorting this list et ignore empty rows.
• EXCLUDED_REGEX_PATTERN : modèle d'expression régulière à exclure de la détection de sécurité de l'IA responsable. Par exemple, (?i)kill process [0-9]+.
• PROJECT_ID : ID du projet auquel appartient le modèle.
• LOCATION : emplacement du modèle.
• TEMPLATE_ID : ID du modèle.

Cette commande renvoie une réponse semblable à la suivante :

{
  "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
  }
}

Mettre à jour les règles d'exclusion dans un modèle

Pour mettre à jour les règles d'exclusion dans un modèle existant, envoyez une requête PATCH avec updateMask défini sur filterConfig.filterRuleSettings. Étant donné que la mise à jour remplace l'intégralité du champ filterRuleSettings, incluez toutes les règles que vous souhaitez conserver avec vos modifications.

L'exemple suivant met à jour les règles d'exclusion de l'exemple précédent en ajoutant une règle d'expression régulière à l'ensemble de règles PROMPT_INJECTION_AND_JAILBREAK et en supprimant l'ensemble de règles 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"

Remplacez les éléments suivants :

• EXCLUDED_PHRASE_1 et EXCLUDED_PHRASE_2 : mots ou expressions du dictionnaire à exclure de la détection de l'injection de prompt et du jailbreaking, par exemple, ignore case when sorting this list et ignore empty rows.
• EXCLUDED_REGEX_PATTERN : modèle d'expression régulière à exclure de la détection de l'injection de prompt et du jailbreaking (par exemple, (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b).
• PROJECT_ID : ID du projet auquel appartient le modèle.
• LOCATION : emplacement du modèle.
• TEMPLATE_ID : ID du modèle.

Exemples de formats d'exclusion d'expressions régulières

Lorsque vous écrivez des règles d'exclusion d'expressions régulières, limitez vos modèles à des termes de domaine ou à des noms cibles spécifiques afin que Model Armor exclue les faux positifs connus sans ignorer les véritables cas de non-respect des règles de sécurité. Lorsque vous transmettez des modèles d'expression régulière dans des corps de requête JSON ("pattern"), échappez chaque barre oblique inverse par une deuxième barre oblique inverse (par exemple, utilisez \\b et \\s).

Exemples de détection de l'injection de prompt et du jailbreaking

Les verbes impératifs tels que ignore, disregard, bypass ou override apparaissent fréquemment dans les prompts hostiles et les instructions légitimes pour le tri des e-mails, la mise en forme des données, la gestion des exceptions ou la configuration du système. Pour éviter d'exclure de larges catégories de requêtes, combinez les limites de mots (\\b), les groupes sans capture ((?:...)) et l'indicateur insensible à la casse ((?i)) avec MATCHING_SCOPE_PARTIAL_MATCH pour ancrer votre expression régulière à des noms cibles opérationnels spécifiques.

Le tableau suivant fournit un exemple de modèle d'expression régulière de correspondance partielle (avec des barres obliques inversées échappées au format JSON) et un exemple de prompt pour un scénario courant de faux positifs d'injection de prompt et de jailbreak.

Catégorie d'instruction	Conditions de déclenchement	Scénarios de faux positifs	Exemple de modèle d'expression régulière de correspondance partielle	Exemple de prompt
Tri et filtrage des contenus	ignore, disregard	Tri des e-mails, gestion des exceptions et examen des brouillons	(?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.

Exemples de filtres de sécurité pour l'IA responsable

La documentation technique, les commandes d'administration système et les expressions idiomatiques courantes contiennent souvent des mots qui chevauchent les catégories de sécurité de l'IA responsable. Pour atténuer les faux positifs dans les requêtes ou les réponses plus longues, combinez les limites de mots (\\b), les groupes sans capture ((?:...)) et l'indicateur d'insensibilité à la casse ((?i)) avec MATCHING_SCOPE_PARTIAL_MATCH.

Le tableau suivant fournit des exemples de modèles d'expressions régulières de correspondance partielle (avec des barres obliques inverses échappées au format JSON) et des exemples d'invites pour les scénarios courants de faux positifs liés à l'IA responsable.

Catégorie de risque	Conditions de déclenchement	Scénarios de faux positifs	Exemple de modèle d'expression régulière de correspondance partielle	Exemple de prompt
Violence ou blessure	kill	Arrêt de processus, interrupteurs électriques ou CVC, et expressions idiomatiques courantes	(?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.
Langage toxique ou choquant	abort, terminate	Transactions de base de données, cycle de vie des missions et conditions d'emploi ou contractuelles	(?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b	Abort retry.
Correspondances de sous-chaînes dans les termes de domaine	Sous-chaînes de caractères qui se chevauchent	Termes universitaires, botanique, ornithologie, aviation et noms propres	(?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b	I love reading Dickens.
Armes ou explosifs	bomb, blast, detonate	Bio-informatique, expressions idiomatiques liées au divertissement, équipements industriels ou nettoyage	(?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.

Bonnes pratiques pour configurer des règles d'exclusion

Suivez ces bonnes pratiques pour minimiser les faux positifs sans affaiblir la stratégie de sécurité de votre modèle :

• Limitez la portée des règles à des contextes spécifiques : évitez d'exclure des verbes uniques ou des termes généraux (tels que ignore, kill ou abort) ou d'utiliser des caractères génériques non contraints (tels que .*ignore.*). Étant donné que MATCHING_SCOPE_PARTIAL_MATCH remplace matchState par NO_MATCH_FOUND pour l'ensemble du filtre chaque fois qu'une sous-chaîne correspond, des règles trop larges peuvent masquer de véritables cas de non-respect ailleurs dans la même requête ou réponse. Associez toujours les verbes déclencheurs à des noms cibles spécifiques (par exemple, ignore case when sorting this list ou (?i)kill process [0-9]+).
• Utiliser des limites de mots et regrouper les modèles : dans les règles d'expression régulière, utilisez des limites de mots (\b) pour éviter les correspondances de sous-chaînes accidentelles dans des mots non associés. Regroupez les expressions associées dans une seule expression régulière en utilisant des groupes sans capture ((?:...)) et l'alternation (|) pour respecter la limite système de 10 règles par ensemble de règles.
• Préférez MATCHING_SCOPE_FULL_MATCH pour des entrées prévisibles : lorsque vous excluez des invites d'UI prédéfinies, des commandes prédéfinies ou des charges utiles de test automatisées, définissez matchingScope sur MATCHING_SCOPE_FULL_MATCH (ou ancrez les expressions régulières avec ^ et $). La portée de correspondance exacte empêche les utilisateurs d'ajouter des instructions adversariales à une expression exclue pour contourner la détection.
• Rédigez des règles pour le texte brut non transformé : Model Armor évalue les règles d'exclusion avant la désidentification ou la traduction. Assurez-vous que vos modèles correspondent au format d'origine avant la désidentification, et ajoutez des expressions ou des modèles d'expression régulière spécifiques à chaque langue acceptée par votre application.
• Examiner et supprimer les règles temporaires après la mise à niveau des filtres : lorsque vous mettez à niveau un modèle vers une version de filtre plus récente, réévaluez vos cas de test de faux positifs et supprimez les règles d'exclusion résolues par les modèles de détection mis à jour.

Étapes suivantes

• Découvrez des exemples de nettoyage des requêtes et de nettoyage des réponses du modèle à l'aide de règles d'exclusion.
• Consultez les limites du système de règles d'exclusion.
• Découvrez comment créer et gérer des modèles Model Armor.