Configura reglas de exclusión específicas de la plantilla

Puedes configurar reglas de exclusión específicas de la plantilla en Model Armor para mitigar las detecciones de falsos positivos. Las reglas de exclusión son reglas específicas de la plantilla que contienen expresiones regulares o frases para excluir de la detección.

Filtros compatibles

Puedes usar reglas de exclusión para los siguientes filtros:

Cuándo usar las reglas de exclusión

Usa reglas de exclusión específicas de la plantilla cuando necesites suprimir detecciones de falsos positivos conocidas para cargas de trabajo específicas sin inhabilitar un filtro por completo:

  • Terminología técnica o específica del dominio: Tu aplicación procesa vocabulario especializado, como comandos de administración del sistema (kill process, abort transaction), terminología de pruebas de seguridad (penetration testing), términos científicos (blast search) o expresiones idiomáticas de la industria, que se superponen con las categorías de seguridad de la IA responsable.
  • Instrucciones operativas o de formato benignas: Tus usuarios o plantillas de instrucciones incluyen instrucciones legítimas que usan verbos imperativos (como "ignore case when sorting this list", "ignore empty rows" o "Summarize my inbox and ignore the emails from the marketing vendor.") que activan falsos positivos en la detección de inyección de instrucciones y jailbreak.
  • Mitigación segmentada mientras se esperan actualizaciones del modelo: Necesitas una solución alternativa inmediata para un falso positivo verificado en un flujo de trabajo de aplicación específico, mientras mantienes el filtro activo para todas las demás entradas.

En la siguiente tabla, se describe cuándo usar cada combinación de tipo de regla y alcance de la coincidencia. Para obtener más información sobre cómo funcionan la concordancia de diccionario y la concordancia de expresiones regulares, consulta Reglas de diccionario y expresiones regulares y Cómo funciona la concordancia.

Configuración de la regla Cuándo usar Ejemplo
Regla de diccionario con coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH) Tienes una lista fija de palabras o frases estáticas que pueden aparecer en cualquier parte de una instrucción o respuesta. Para obtener más información sobre el comportamiento de la coincidencia de diccionarios, consulta Reglas de diccionario y expresiones regulares.

El diccionario contiene la frase ignore empty rows

Coincidencias:

  • ignore empty rows
  • ignore EMPTY-rows
  • please ignore empty rows

No coincide:

  • ignore rows
  • ignore the empty rows
Regla de diccionario con coincidencia completa (MATCHING_SCOPE_FULL_MATCH) Tu aplicación usa opciones de instrucciones predefinidas (como botones de respuesta rápida de la IU o comandos predeterminados) en las que toda la entrada coincide con una frase conocida, y deseas evitar que texto adicional no filtrado eluda el filtro. Para obtener más información sobre el comportamiento de la coincidencia de diccionario, consulta Reglas de diccionario y de expresiones regulares.

El diccionario contiene la frase ignore empty rows

Coincidencias:

  • ignore empty rows
  • ignore EMPTY-rows

No coincide:

  • please ignore empty rows
  • ignore rows
Regla de expresión regular con coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH) Debes excluir patrones estructurados, identificadores dinámicos o combinaciones específicas de verbo y sustantivo dentro de instrucciones o respuestas más grandes. Para obtener más información, consulta Ejemplos de patrones de exclusión de expresiones regulares.

Patrón de expresión regular: (?i)kill process [0-9]+

Coincidencias:

  • kill process 1234
  • How do I Kill Process 99?

No coincide:

  • kill process abc
  • kill the process 1234
Regla de expresión regular con coincidencia completa (MATCHING_SCOPE_FULL_MATCH) Toda la carga útil de entrada sigue un formato estructural estricto (como un identificador de prueba automatizada o un comando estructurado).

Patrón de expresión regular: (?i)^test_case_[0-9]+$

Coincidencias:

  • test_case_42
  • TEST_CASE_001

No coincide:

  • run test_case_42
  • test_case_alpha

Usa un extremo regional o multirregional

Cuando trabajas con una plantilla de Model Armor, debes usar un extremo regional o multirregional (modelarmor.LOCATION.rep.googleapis.com) que coincida con la ubicación de la plantilla.

El extremo global (modelarmor.googleapis.com) no admite la administración de plantillas de Model Armor ni la limpieza de instrucciones y respuestas.

Antes de comenzar

Antes de comenzar, completa las siguientes tareas.

Obtén los permisos necesarios

Para obtener los permisos que necesitas para configurar reglas de exclusión en las plantillas de Model Armor, pídele a tu administrador que te otorgue el rol de IAM de Administrador de Model Armor (roles/modelarmor.admin) en el proyecto de Model Armor que contiene la plantilla de Model Armor. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Habilita las APIs

Para poder usar Model Armor, debes habilitar la API de Model Armor.

Console

  1. Habilita la API de Model Armor si aún no está habilitada.

    Roles necesarios para habilitar las APIs

    Para habilitar APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

    Habilitar la API

  2. Elige el proyecto en el que quieres activar Model Armor.

gcloud

Antes de empezar, sigue estos pasos a través de la Google Cloud CLI con la API de Model Armor:

  1. En la consola de Google Cloud , activa Cloud Shell.

    Activa Cloud Shell

    En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

  2. Habilita la API de Model Armor si aún no lo hiciste:

    Roles necesarios para habilitar las APIs

    Para habilitar APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles. 

    gcloud services enable modelarmor.googleapis.com

  3. Configura la anulación del extremo de API con la CLI de gcloud.

Cómo configurar la anulación del extremo de API con la gcloud CLI

Este paso solo es necesario si usas gcloud CLI con Model Armor y deseas usar una región o multirregión que no sea la multirregión predeterminada us. Debes configurar manualmente la anulación del extremo de API para garantizar que la gcloud CLI enrute correctamente las solicitudes al servicio de Model Armor.

Ejecuta el siguiente comando para configurar el extremo de API del servicio de Model Armor.

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

Reemplaza LOCATION por la región o multirregión en la que deseas usar Model Armor.

Cómo funcionan las reglas de exclusión

Puedes configurar reglas de exclusión con la API de Model Armor.

Reglas de diccionario y expresiones regulares

Puedes definir dos tipos de reglas de exclusión en una plantilla de Model Armor:

  • Reglas de diccionario: Especifica una lista de palabras o frases (wordList, hasta 128 KB por diccionario) para excluir. Un diccionario debe contener al menos una frase, y cada frase debe contener al menos dos caracteres que sean letras o dígitos. La concordancia de diccionario funciona de la siguiente manera:
    • No distingue mayúsculas de minúsculas: Las palabras y frases del diccionario no distinguen mayúsculas de minúsculas.
    • Caracteres no alfanuméricos: Cuando se buscan coincidencias, todos los caracteres que no sean letras ni dígitos en el plano multilingüe básico de Unicode se reemplazan por espacios en blanco. Por ejemplo, la frase del diccionario Sam Johnson coincide con sam johnson, Sam, Johnson y Sam (Johnson). Las frases del diccionario que contienen muchos caracteres que no son letras ni dígitos pueden producir coincidencias inesperadas porque esos caracteres se tratan como espacios en blanco.
    • Límites de caracteres: Los caracteres que rodean una coincidencia deben ser de un tipo diferente al de los caracteres adyacentes dentro de la palabra del diccionario. Las letras deben estar junto a caracteres que no sean letras, y los dígitos deben estar junto a caracteres que no sean dígitos. Por ejemplo, la palabra del diccionario jen coincide con las tres primeras letras de jen123, pero no con jennifer.
  • Reglas de expresiones regulares: Especifica un patrón de expresión regular (hasta 1,000 caracteres) para que coincida y se excluya. De forma predeterminada, las coincidencias de expresiones regulares distinguen mayúsculas de minúsculas. Para realizar una coincidencia que no distinga mayúsculas de minúsculas, incluye la marca (?i) en tu patrón. Por ejemplo, (?i)kill process [0-9]+ coincide con kill process 1234 y con Kill Process 1234.

Cómo funciona la correlación

Cada regla de exclusión admite el campo matchingScope, que especifica cómo Model Armor compara el contenido de entrada con la regla:

  • Coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH, predeterminada):
    • Reglas de diccionario: Se genera una coincidencia cuando una palabra o frase del diccionario coincide con una subcadena del contenido de entrada, sujeta a las reglas de límite de caracteres del diccionario. Por ejemplo, la frase del diccionario ignore empty rows coincide con ignore empty rows, ignore EMPTY-rows y Please ignore empty rows and summarize this table, pero no con ignore rows ni ignore the empty rows.
    • Reglas de expresiones regulares: Coincide cuando cualquier subcadena del contenido de entrada coincide con el patrón de expresión regular.
  • Coincidencia exacta (MATCHING_SCOPE_FULL_MATCH):
    • Reglas de diccionario: Solo se generan coincidencias cuando la entrada del diccionario abarca todo el contenido de entrada. Por ejemplo, la frase del diccionario ignore empty rows coincide con ignore empty rows y ignore EMPTY-rows, pero no con please ignore empty rows ni ignore rows.
    • Reglas de expresiones regulares: La coincidencia se produce solo cuando el patrón de la expresión regular coincide con todo el contenido de entrada.

Anulaciones de reglas de exclusión durante el saneamiento

Si una plantilla incluye reglas de exclusión, Model Armor evalúa esas reglas durante la limpieza de instrucciones y respuestas del modelo cada vez que un filtro de detección de inyección de instrucciones y jailbreaks (PROMPT_INJECTION_AND_JAILBREAK) o de IA responsable (RESPONSIBLE_AI) identifica una posible coincidencia:

  • La regla coincide con la entrada: Si una regla de exclusión coincide con una subcadena (MATCHING_SCOPE_PARTIAL_MATCH, valor predeterminado) o con toda la entrada de principio a fin (MATCHING_SCOPE_FULL_MATCH), Model Armor anula matchState y lo establece en NO_MATCH_FOUND para todo ese tipo de filtro admitido (incluidas todas las categorías de seguridad de la IA responsable para RESPONSIBLE_AI), en lugar de excluir frases o tramos individuales dentro de la entrada. Si ningún otro filtro activo detecta un incumplimiento, filterMatchState devuelve NO_MATCH_FOUND. Model Armor no registra un indicador en Cloud Logging ni incluye un indicador en la respuesta de limpieza cuando una regla de exclusión anula el filtro matchState.
  • La regla no coincide con la entrada completa (MATCHING_SCOPE_FULL_MATCH): Si la entrada contiene texto adicional más allá de la frase o el patrón configurados, la regla no coincide y el filtro conserva MATCH_FOUND.
  • La entrada supera los 0.5 MB: Las reglas de exclusión solo evalúan los primeros 0.5 MB del texto de entrada. Si una entrada supera los 0.5 MB y un filtro detecta una coincidencia fuera de la porción inicial analizada, el filtro devuelve EXECUTION_SKIPPED. Para obtener detalles sobre los valores de messageItems y los límites de carga útil, consulta Límites del sistema de reglas de exclusión.

Para ver ejemplos de cómo limpiar instrucciones y respuestas del modelo con reglas de exclusión, consulta Limpia una instrucción con una regla de exclusión y Limpia una respuesta con una regla de exclusión.

Consideraciones

Cuando configures reglas de exclusión, ten en cuenta lo siguiente:

  • Las reglas de exclusión solo se aplican a la plantilla en la que las defines. No puedes compartir reglas de exclusión entre plantillas.
  • Solo puedes configurar reglas de exclusión para un tipo de filtro compatible cuando ese filtro está habilitado en la plantilla. Para la detección de inyección de instrucciones y jailbreak (PROMPT_INJECTION_AND_JAILBREAK), establece filterEnforcement en ENABLED en piAndJailbreakFilterSettings. Para habilitar los filtros de seguridad de IA responsable (RESPONSIBLE_AI), configura al menos una categoría de seguridad de IA responsable en raiSettings.raiFilters.
  • Model Armor no admite reglas de exclusión en las APIs de transmisión ni en la configuración mínima.
  • Model Armor evalúa las reglas de exclusión en relación con el texto de entrada sin procesar antes de realizar transformaciones de texto, como la anonimización o la traducción. Las reglas de exclusión no admiten la detección de varios idiomas ni la traducción automática. Para excluir contenido en varios idiomas, agrega frases específicas de cada idioma o patrones de expresiones regulares para cada idioma objetivo.
  • Las reglas de exclusión tienen compatibilidad limitada con idiomas que no usan escrituras latinas y con caracteres UTF-8 multibyte. En particular, es posible que las reglas de diccionario (wordList) no coincidan según lo esperado para las escrituras que usan marcas diacríticas (como las escrituras índicas) o las escrituras sin espacios entre palabras (como el chino y el japonés). Las reglas de coincidencia exacta (MATCHING_SCOPE_FULL_MATCH) no coinciden con las entradas que contienen caracteres UTF-8 multibyte. Cuando excluyas contenido en escrituras no latinas o entradas con caracteres multibyte, usa reglas de expresiones regulares (regex) con MATCHING_SCOPE_PARTIAL_MATCH.
  • Las reglas de exclusión están sujetas a los límites del sistema. Para obtener más información, consulta Límites del sistema de reglas de exclusión.

Crea una plantilla con reglas de exclusión

Para crear una plantilla con reglas de exclusión, incluye el objeto filterRuleSettings dentro de filterConfig en una solicitud POST.

En el siguiente ejemplo, se crea una plantilla que habilita la detección de inyección de instrucciones y jailbreaking, y los filtros de seguridad de IA responsable, y se configuran dos reglas de exclusión con coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH):

  • Detección de inyección de instrucciones y jailbreak (PROMPT_INJECTION_AND_JAILBREAK): Usa una regla de diccionario para excluir de las detecciones de inyección de instrucciones y jailbreak las entradas que contienen frases especificadas, como ignore case when sorting this list o ignore empty rows.
  • IA responsable (RESPONSIBLE_AI): Usa una regla de expresión regular para excluir de las detecciones de seguridad de la IA responsable las entradas que coinciden con un patrón especificado, como (?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"

Reemplaza lo siguiente:

  • EXCLUDED_PHRASE_1 y EXCLUDED_PHRASE_2: Palabras o frases del diccionario que se excluirán de la detección de inyección de instrucciones y jailbreak, por ejemplo, ignore case when sorting this list y ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: Es el patrón de expresión regular que se excluirá de la detección de seguridad de la IA responsable; por ejemplo, (?i)kill process [0-9]+.
  • PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
  • LOCATION: Es la ubicación de la plantilla.
  • TEMPLATE_ID: Es el ID de la plantilla.

Este comando devuelve una respuesta similar a la siguiente:

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

Actualiza las reglas de exclusión en una plantilla

Para actualizar las reglas de exclusión en una plantilla existente, envía una solicitud PATCH con updateMask establecido en filterConfig.filterRuleSettings. Dado que la actualización reemplaza todo el campo filterRuleSettings, incluye todas las reglas que desees conservar junto con tus modificaciones.

En el siguiente ejemplo, se actualizan las reglas de exclusión del ejemplo anterior agregando una regla de expresión regular al conjunto de reglas PROMPT_INJECTION_AND_JAILBREAK y quitando el conjunto de reglas 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"

Reemplaza lo siguiente:

  • EXCLUDED_PHRASE_1 y EXCLUDED_PHRASE_2: Palabras o frases del diccionario que se excluirán de la detección de inyección de instrucciones y jailbreak, por ejemplo, ignore case when sorting this list y ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: Es el patrón de expresión regular que se excluirá de la detección de inyección de instrucciones y jailbreak, por ejemplo, (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b.
  • PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
  • LOCATION: Es la ubicación de la plantilla.
  • TEMPLATE_ID: Es el ID de la plantilla.

Ejemplos de patrones de exclusión de expresiones regulares

Cuando escribas reglas de exclusión de expresiones regulares, limita el alcance de tus patrones a términos de dominio específicos o sustantivos objetivo para que Model Armor excluya los falsos positivos conocidos sin ignorar los incumplimientos genuinos de seguridad. Cuando pases patrones de expresiones regulares dentro de cuerpos de solicitudes JSON ("pattern"), escapa cada barra inversa con una segunda barra inversa (por ejemplo, usa \\b y \\s).

Ejemplos de detección de inyección de instrucciones y jailbreak

Los verbos imperativos, como ignore, disregard, bypass o override, aparecen con frecuencia tanto en las instrucciones adversarias como en las instrucciones legítimas para la clasificación de correos electrónicos, el formato de datos, el manejo de errores o la configuración del sistema. Para evitar excluir categorías amplias de instrucciones, combina límites de palabras (\\b), grupos que no capturan ((?:...)) y la marca que no distingue mayúsculas de minúsculas ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH para anclar tu expresión regular a sustantivos de destino operativos específicos.

En la siguiente tabla, se proporcionan ejemplos de patrones de expresiones regulares de coincidencia parcial (con barras inversas con escape JSON) y ejemplos de instrucciones para situaciones comunes de inyección de instrucciones y falsos positivos de jailbreak.

Categoría de instrucción Términos de activación Situaciones de falsos positivos Ejemplo de patrón de expresión regular de coincidencia parcial Instrucción de ejemplo
Clasificación y filtrado de contenido ignore, disregard Clasificación de correos electrónicos, manejo de errores y revisión de borradores (?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.

Ejemplos de filtros de seguridad de IA responsable

La documentación técnica, los comandos de administración del sistema y las expresiones idiomáticas comunes suelen contener palabras que se superponen con las categorías de seguridad de la IA responsable. Para mitigar los falsos positivos en mensajes o respuestas más grandes, combina los límites de palabras (\\b), los grupos que no capturan ((?:...)) y la marca que no distingue mayúsculas de minúsculas ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH.

En la siguiente tabla, se proporcionan ejemplos de patrones de expresiones regulares de coincidencia parcial (con barras inversas con escape JSON) y ejemplos de instrucciones para situaciones comunes de falsos positivos de la IA responsable.

Categoría de riesgo Términos de activación Situaciones de falsos positivos Ejemplo de patrón de expresión regular de coincidencia parcial Instrucción de ejemplo
Violencia o daños kill Finalización del proceso, interruptores eléctricos o de HVAC, y expresiones idiomáticas comunes (?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.
Lenguaje ofensivo o tóxico abort, terminate Transacciones de la base de datos, ciclo de vida de la misión y condiciones de empleo o contrato (?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b Abort retry.
Coincidencias de subcadenas en términos de dominio Subcadenas de caracteres superpuestas Términos académicos, botánica, ornitología, aviación y nombres propios (?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b I love reading Dickens.
Armas o explosivos bomb, blast, detonate Bioinformática, modismos de entretenimiento y equipos industriales o de limpieza (?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.

Prácticas recomendadas para configurar reglas de exclusión

Sigue estas prácticas recomendadas para minimizar los falsos positivos sin debilitar la postura de seguridad de tu plantilla:

  • Delimita las reglas de alcance a contextos específicos: Evita excluir verbos individuales o términos generales (como ignore, kill o abort) o usar comodines sin restricciones (como .*ignore.*). Dado que MATCHING_SCOPE_PARTIAL_MATCH anula matchState a NO_MATCH_FOUND para todo el filtro cada vez que coincide una subcadena, las reglas demasiado generales pueden ocultar incumplimientos reales en otras partes de la misma instrucción o respuesta. Siempre combina los verbos de activación con sustantivos objetivo específicos (por ejemplo, ignore case when sorting this list o (?i)kill process [0-9]+).
  • Usa límites de palabras y consolida patrones: En las reglas de expresiones regulares, usa límites de palabras (\b) para evitar coincidencias accidentales de subcadenas dentro de palabras no relacionadas. Consolida las frases relacionadas en una sola expresión regular usando grupos que no capturan ((?:...)) y alternancia (|) para mantenerte dentro del límite del sistema de 10 reglas por conjunto de reglas.
  • Prefiere MATCHING_SCOPE_FULL_MATCH para entradas predecibles: Cuando excluyas mensajes predefinidos de la IU, comandos predeterminados o cargas útiles de pruebas automatizadas, establece matchingScope en MATCHING_SCOPE_FULL_MATCH (o ancla expresiones regulares con ^ y $). El alcance de coincidencia exacta evita que los usuarios agreguen instrucciones adversarias a una frase excluida para eludir la detección.
  • Escribe reglas para el texto sin procesar y sin transformar: Model Armor evalúa las reglas de exclusión antes de la seudoanonimización o la traducción. Asegúrate de que tus patrones coincidan con el formato original antes de la seudonimización y agrega frases específicas del idioma o patrones de expresiones regulares para cada idioma que admita tu aplicación.
  • Revisa y retira las reglas temporales después de actualizar los filtros: Cuando actualices una plantilla a una versión de filtro más reciente, vuelve a evaluar tus casos de prueba de falsos positivos y quita las reglas de exclusión que se resuelvan con los modelos de detección actualizados.

¿Qué sigue?