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 au modèle lorsque vous devez supprimer les détections de faux positifs connues 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 prompts 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 prompts 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 de la correspondance. 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 de requête prédéfinies (comme des boutons de réponse rapide dans l'interface utilisateur ou des commandes prédéfinies) où l'intégralité de l'entrée correspond à une expression connue, et vous souhaitez empêcher que du texte supplémentaire non filtré contourne le filtre. Pour en savoir plus sur le comportement de correspondance des dictionnaires, consultez Règles de dictionnaire et d'expression régulière.	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 complète (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. Pour savoir comment la résidence des données est appliquée pour chaque région ou zone multirégionale, consultez Application de la résidence des données pour les modèles.

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 de 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 un emplacement multirégional autre que l'emplacement multirégional par défaut us. 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 l'emplacement multirégional dans lequel 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 de 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 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 autres que des lettres, et les chiffres doivent être adjacents à des caractères autres que des chiffres. 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 non sensible à la casse, incluez l'indicateur (?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 du 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 : correspond 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 : ne correspondent que lorsque l'entrée du dictionnaire couvre l'intégralité du contenu d'entrée. 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 d'injection de prompt et de détection 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 un résultat de filtre MATCH_FOUND ou EXECUTION_SKIPPED et définit matchState sur NO_MATCH_FOUND pour l'ensemble 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. Dans la réponse de désinfection, filterMatchState est NO_MATCH_FOUND lorsqu'aucun élément malveillant n'est détecté ou lorsque les règles d'exclusion remplacent les résultats du filtre. Pour résoudre les problèmes, activez Cloud Logging pour les opérations de nettoyage (logSanitizeOperations) dans le modèle et filtrez sur les libellés modelarmor.googleapis.com/exclusion_rule_overridden_filters ou modelarmor.googleapis.com/exclusion_rule_skipped_filters. Model Armor enregistre ces libellés lorsque des règles d'exclusion remplacent les résultats de filtre ou lorsque le executionState d'un filtre est défini sur EXECUTION_SKIPPED. Pour en savoir plus, consultez Afficher les journaux des règles d'exclusion.
• 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 130 000 jetons (0,5 Mo) : les règles d'exclusion n'évaluent que les 130 000 premiers jetons (0,5 Mo) du texte saisi. Si une entrée dépasse 130 000 jetons (0,5 Mo) et qu'un filtre détecte une correspondance en dehors de la partie initialement analysée, le filtre renvoie EXECUTION_SKIPPED. Pour en savoir plus sur les valeurs messageItems et les limites de charge utile, consultez Limites du système pour les règles d'exclusion.

Pour obtenir des exemples de nettoyage des prompts et des réponses de modèle avec des règles d'exclusion, consultez Nettoyer un prompt 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 l'anonymisation 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 scripts 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écifiées, 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 des détections de sécurité de l'IA responsable les entrées correspondant à un modèle spécifié, tel que (?i)kill process [0-9]+.

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 jailbreak, par exemple ignore case when sorting this list et ignore empty rows.
• EXCLUDED_REGEX_PATTERN : expression régulière à exclure de la détection de l'injection de prompt et du jailbreak (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 injections de prompt 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 non sensible à la casse ((?i)) avec MATCHING_SCOPE_PARTIAL_MATCH pour ancrer votre expression régulière à des noms de cibles opérationnelles 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 du contenu	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 limiter 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 de non-sensibilité à 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 d'un processus, interrupteurs électriques ou de CVC, et expressions 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 termes choquants	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 du 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.

Afficher les journaux des règles d'exclusion

Pour enregistrer les résultats de l'évaluation des règles d'exclusion, définissez logSanitizeOperations sur true lorsque vous configurez la journalisation dans les modèles. Lorsque la journalisation est activée, Model Armor écrit des entrées de journal SanitizeOperationLogEntry pour la ressource surveillée modelarmor.googleapis.com/SanitizeOperation dans Cloud Logging.

Pour en savoir plus sur l'activation et l'interrogation des journaux de désinfection, consultez Configurer la journalisation.

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 précisément le champ d'application des règles à des contextes spécifiques : évitez d'exclure des verbes seuls 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 générales 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îne accidentelles dans des mots non lié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 adverses à 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 l'anonymisation ou la traduction. Assurez-vous que vos modèles correspondent au format d'origine avant l'anonymisation, 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 scénarios 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 avec des règles d'exclusion.
• Consultez les limites du système de règles d'exclusion.
• Découvrez comment configurer la journalisation pour Model Armor.
• Découvrez comment créer et gérer des modèles Model Armor.