Configurar regras de exclusão específicas do modelo

Visualizar

Este recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

É possível configurar regras de exclusão específicas do modelo no Model Armor para reduzir detecções de falsos positivos. As regras de exclusão são específicas do modelo e contêm expressões regulares ou frases que serão excluídas da detecção.

Filtros aceitos

É possível usar regras de exclusão para os seguintes filtros:

• Detecção de jailbreak e injeção de comando (PROMPT_INJECTION_AND_JAILBREAK)
• Filtros de segurança de IA responsável (RESPONSIBLE_AI)

Quando usar regras de exclusão

Use regras de exclusão específicas do modelo quando precisar suprimir detecções de falsos positivos conhecidos para cargas de trabalho específicas sem desativar um filtro por completo:

• Terminologia técnica ou específica do domínio: seu aplicativo processa vocabulário especializado, como comandos de administração de sistemas (kill process, abort transaction), terminologia de teste de segurança (penetration testing), termos científicos (blast search) ou expressões idiomáticas do setor, que se sobrepõem às categorias de segurança da IA responsável.
• Instruções operacionais ou de formatação benignas: seus usuários ou modelos de comandos incluem instruções legítimas que usam verbos no imperativo (como "ignore case when sorting this list", "ignore empty rows" ou "Summarize my inbox and ignore the emails from the marketing vendor.") que acionam falsos positivos na detecção de jailbreak e injeção de comando.
• Mitigação direcionada enquanto aguarda atualizações do modelo: você precisa de uma solução alternativa imediata para um falso positivo verificado em um fluxo de trabalho de aplicativo específico, mantendo o filtro ativo para todas as outras entradas.

A tabela a seguir descreve quando usar cada combinação de tipo de regra e escopo de correspondência. Para mais informações sobre como a correspondência de dicionário e de expressão regular funciona, consulte Regras de dicionário e de expressão regular e Como a correspondência funciona.

Configuração da regra	Quando usar	Exemplo
Regra de dicionário com correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH)	Você tem uma lista fixa de palavras ou frases estáticas que podem aparecer em qualquer lugar de um comando ou resposta. Para mais informações sobre o comportamento de correspondência de dicionário, consulte Regras de dicionário e de expressão regular.	O dicionário contém a frase ignore empty rows Correspondências: ignore empty rows ignore EMPTY-rows please ignore empty rows Não corresponde a: ignore rows ignore the empty rows
Regra de dicionário com correspondência exata (MATCHING_SCOPE_FULL_MATCH)	Seu aplicativo usa opções de comandos predefinidos (como botões de resposta rápida da UI ou comandos prontos) em que toda a entrada corresponde a uma frase conhecida, e você quer evitar que mais texto não filtrado bypasse o filtro. Para mais informações sobre o comportamento da correspondência de dicionário, consulte Regras de dicionário e de expressão regular.	O dicionário contém a frase ignore empty rows Correspondências: ignore empty rows ignore EMPTY-rows Não corresponde a: please ignore empty rows ignore rows
Regra de expressão regular com correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH)	Você precisa excluir padrões estruturados, identificadores dinâmicos ou combinações específicas de verbo e substantivo em comandos ou respostas maiores. Para mais informações, consulte Exemplos de padrões de exclusão de expressões regulares.	Padrão de expressão regular: (?i)kill process [0-9]+ Correspondências: kill process 1234 How do I Kill Process 99? Não corresponde a: kill process abc kill the process 1234
Regra de expressão regular com correspondência completa (MATCHING_SCOPE_FULL_MATCH)	Todo o payload de entrada segue um formato estrutural rígido, como um identificador de teste automatizado ou um comando estruturado.	Padrão de expressão regular: (?i)^test_case_[0-9]+$ Correspondências: test_case_42 TEST_CASE_001 Não corresponde a: run test_case_42 test_case_alpha

Usar um endpoint regional ou multirregional

Ao trabalhar com um modelo do Model Armor, use um endpoint regional ou multirregional (modelarmor.LOCATION.rep.googleapis.com) que corresponda ao local do modelo.

O endpoint global (modelarmor.googleapis.com) não oferece suporte ao gerenciamento de modelos do Model Armor nem à limpeza de comandos e respostas.

Antes de começar

Antes de começar, conclua as tarefas a seguir.

Receber as permissões necessárias

Para receber as permissões necessárias para configurar regras de exclusão em modelos do Model Armor, peça ao administrador para conceder a você o papel do IAM de Administrador do Model Armor (roles/modelarmor.admin) no projeto que contém o modelo do Model Armor. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Ativar APIs

É necessário ativar a API Model Armor antes de usar o Model Armor.

Console

1. Ative a API Model Armor, se ela ainda não estiver ativada.

   Funções necessárias para ativar APIs

   Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de Proprietário (roles/owner). Caso contrário, é possível receber essa permissão pelo papel de Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.

   Ativar a API

2. Selecione o projeto em que você quer ativar o Model Armor.

gcloud

Antes de começar, siga estas etapas usando a Google Cloud CLI com a API Model Armor:

1. No console do Google Cloud , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Ative a API Model Armor, se ela ainda não estiver ativada:

   Funções necessárias para ativar APIs

   Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de Proprietário (roles/owner). Caso contrário, é possível receber essa permissão pelo papel de Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.

   gcloud services enable modelarmor.googleapis.com

3. Defina a substituição do endpoint de API usando a CLI gcloud.

Definir a substituição do endpoint de API usando a CLI gcloud

Esta etapa só é necessária se você usar a CLI gcloud com o Model Armor e quiser usar uma região ou multirregião diferente da multirregião padrão us. É necessário definir manualmente a substituição do endpoint de API para garantir que a CLI gcloud roteie corretamente as solicitações para o serviço Model Armor.

Execute o comando a seguir para definir o endpoint de API do serviço Model Armor.

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

Substitua LOCATION pela região ou multirregião em que você quer usar o Model Armor.

Como as regras de exclusão funcionam

Você configura regras de exclusão usando a API Model Armor.

Regras de dicionário e de expressão regular

É possível definir dois tipos de regras de exclusão em um modelo do Model Armor:

• Regras de dicionário: especifique uma lista de palavras ou frases (wordList, até 128 KB por dicionário) para excluir. Um dicionário precisa ter pelo menos uma frase, e cada frase precisa ter pelo menos dois caracteres que sejam letras ou dígitos. A correspondência de dicionário funciona da seguinte maneira:
  • Não diferenciação de maiúsculas de minúsculas: as palavras e frases do dicionário não diferenciam maiúsculas de minúsculas.
  • Caracteres não alfanuméricos: ao procurar correspondências, todos os caracteres que não sejam letras e dígitos no Plano Multilíngue Básico do Unicode são substituídos por espaços em branco. Por exemplo, a frase do dicionário Sam Johnson corresponde a sam johnson, Sam, Johnson e Sam (Johnson). Frases do dicionário que contêm muitos caracteres que não são letras ou dígitos podem produzir correspondências inesperadas porque esses caracteres são tratados como espaços em branco.
  • Limites de caracteres: os caracteres ao redor de uma correspondência precisam ser de um tipo diferente dos caracteres adjacentes na palavra do dicionário. As letras precisam estar adjacentes a caracteres que não sejam letras, e os dígitos precisam estar adjacentes a caracteres que não sejam dígitos. Por exemplo, a palavra do dicionário jen corresponde às três primeiras letras de jen123, mas não corresponde a jennifer.
• Regras de expressão regular: especifique um padrão de expressão regular (até 1.000 caracteres) para corresponder e excluir. Por padrão, as correspondências de expressões regulares diferenciam maiúsculas de minúsculas. Para realizar uma correspondência sem diferenciação de maiúsculas e minúsculas, inclua a flag (?i) no seu padrão. Por exemplo, (?i)kill process [0-9]+ corresponde a kill process 1234 e Kill Process 1234.

Como a correspondência funciona

Cada regra de exclusão aceita o campo matchingScope, que especifica como o Model Armor compara o conteúdo de entrada com a regra:

• Correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH, padrão):
  • Regras de dicionário: correspondem quando uma palavra ou frase no dicionário corresponde a uma substring no conteúdo de entrada, sujeita às regras de limite de caracteres do dicionário. Por exemplo, a frase do dicionário ignore empty rows corresponde a ignore empty rows, ignore EMPTY-rows e Please ignore empty rows and summarize this table, mas não a ignore rows ou ignore the empty rows.
  • Regras de expressão regular: correspondem quando qualquer substring no conteúdo de entrada corresponde ao padrão de expressão regular.
• Correspondência exata (MATCHING_SCOPE_FULL_MATCH):
  • Regras de dicionário: só há correspondência quando a entrada do dicionário abrange todo o conteúdo de entrada. Por exemplo, a frase do dicionário ignore empty rows corresponde a ignore empty rows e ignore EMPTY-rows, mas não a please ignore empty rows ou ignore rows.
  • Regras de expressão regular: a correspondência só ocorre quando o padrão de expressão regular corresponde a todo o conteúdo de entrada.

Substituições de regras de exclusão durante a limpeza

Se um modelo incluir regras de exclusão, o Model Armor vai avaliar essas regras durante a sanitização de comandos e respostas do modelo sempre que um filtro de detecção de injeção de comandos e jailbreak (PROMPT_INJECTION_AND_JAILBREAK) ou de IA responsável (RESPONSIBLE_AI) identificar uma possível correspondência:

• A regra corresponde à entrada: se uma regra de exclusão corresponder a uma substring (MATCHING_SCOPE_PARTIAL_MATCH, padrão) ou a toda a entrada do início ao fim (MATCHING_SCOPE_FULL_MATCH), o Model Armor vai substituir matchState e definir como NO_MATCH_FOUND para todo o tipo de filtro compatível (incluindo todas as categorias de segurança de IA responsável para RESPONSIBLE_AI), em vez de excluir frases ou intervalos individuais na entrada. Se nenhum outro filtro ativo detectar uma violação, filterMatchState vai retornar NO_MATCH_FOUND. O Model Armor não registra um indicador no Cloud Logging nem inclui um sinal na resposta de sanitização quando uma regra de exclusão substitui o filtro matchState.
• A regra não corresponde à entrada completa (MATCHING_SCOPE_FULL_MATCH): se a entrada contiver texto adicional além da frase ou do padrão configurado, a regra não vai corresponder e o filtro vai manter MATCH_FOUND.
• A entrada excede 0,5 MB: as regras de exclusão avaliam apenas os 0,5 MB iniciais do texto de entrada. Se uma entrada exceder 0,5 MB e um filtro detectar uma correspondência fora da parte inicial verificada, o filtro vai retornar EXECUTION_SKIPPED. Para detalhes sobre valores de messageItems e limites de payload, consulte Limites do sistema de regras de exclusão.

Para exemplos de higienização de comandos e respostas do modelo com regras de exclusão, consulte Higienizar um comando com uma regra de exclusão e Higienizar uma resposta com uma regra de exclusão.

Considerações

Ao configurar regras de exclusão, considere o seguinte:

• As regras de exclusão se aplicam apenas ao modelo em que são definidas. Não é possível compartilhar regras de exclusão entre modelos.
• Só é possível configurar regras de exclusão para um tipo de filtro compatível quando esse filtro está ativado no modelo. Para detecção de jailbreak e injeção de comando (PROMPT_INJECTION_AND_JAILBREAK), defina filterEnforcement como ENABLED em piAndJailbreakFilterSettings. Para ativar os filtros de segurança de IA responsável (RESPONSIBLE_AI), configure pelo menos uma categoria de segurança de IA responsável em raiSettings.raiFilters.
• O Model Armor não é compatível com regras de exclusão em APIs de streaming ou configurações mínimas.
• O Model Armor avalia as regras de exclusão em relação ao texto de entrada bruto antes de realizar transformações de texto, como desidentificação ou tradução. As regras de exclusão não oferecem suporte à detecção de vários idiomas ou à tradução automática. Para excluir conteúdo em vários idiomas, adicione frases específicas ou padrões de expressão regular para cada idioma de destino.
• As regras de exclusão têm suporte limitado para idiomas que não usam o alfabeto latino e caracteres UTF-8 de vários bytes. Em particular, as regras de dicionário (wordList) podem não corresponder ao esperado para scripts que usam marcas combinadas (como scripts da Índia) ou scripts sem espaços entre palavras (como chinês e japonês). As regras de correspondência exata (MATCHING_SCOPE_FULL_MATCH) não correspondem a entradas que contêm caracteres UTF-8 de vários bytes. Ao excluir conteúdo em scripts não latinos ou entradas com caracteres multibyte, use regras de expressão regular (regex) com MATCHING_SCOPE_PARTIAL_MATCH.
• As regras de exclusão estão sujeitas a limites do sistema. Para mais informações, consulte Limites do sistema de regras de exclusão.

Criar um modelo com regras de exclusão

Para criar um modelo com regras de exclusão, inclua o objeto filterRuleSettings em filterConfig em uma solicitação POST.

O exemplo a seguir cria um modelo que ativa a detecção de injeção de comando e jailbreak e filtros de segurança de IA responsável, além de configurar duas regras de exclusão com correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH):

• Detecção de jailbreak e injeção de comando (PROMPT_INJECTION_AND_JAILBREAK): usa uma regra de dicionário para excluir entradas que contenham frases específicas, como ignore case when sorting this list ou ignore empty rows, das detecções de jailbreak e injeção de comando.
• IA responsável (RESPONSIBLE_AI): usa uma regra de expressão regular para excluir entradas que correspondem a um padrão especificado, como (?i)kill process [0-9]+, das detecções de segurança da IA responsável.

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"

Substitua:

• EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: as palavras ou frases do dicionário a serem excluídas da detecção de jailbreak e injeção de comando, por exemplo, ignore case when sorting this list e ignore empty rows.
• EXCLUDED_REGEX_PATTERN: o padrão de expressão regular a ser excluído da detecção de segurança da IA responsável, por exemplo, (?i)kill process [0-9]+.
• PROJECT_ID: o ID do projeto a que o modelo pertence.
• LOCATION: o local do modelo.
• TEMPLATE_ID: o ID do modelo.

Esse comando retorna uma resposta semelhante a esta:

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

Atualizar regras de exclusão em um modelo

Para atualizar as regras de exclusão em um modelo, envie uma solicitação PATCH com updateMask definido como filterConfig.filterRuleSettings. Como a atualização substitui todo o campo filterRuleSettings, inclua todas as regras que você quer manter junto com as modificações.

O exemplo a seguir atualiza as regras de exclusão do exemplo anterior adicionando uma regra de expressão regular ao conjunto de regras PROMPT_INJECTION_AND_JAILBREAK e removendo o conjunto de regras 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"

Substitua:

• EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: as palavras ou frases do dicionário a serem excluídas da detecção de jailbreak e injeção de comando, por exemplo, ignore case when sorting this list e ignore empty rows.
• EXCLUDED_REGEX_PATTERN: o padrão de expressão regular a ser excluído da detecção de jailbreak e injeção de comando. Por exemplo, (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b.
• PROJECT_ID: o ID do projeto a que o modelo pertence.
• LOCATION: o local do modelo.
• TEMPLATE_ID: o ID do modelo.

Exemplos de padrões de exclusão de expressões regulares

Ao escrever regras de exclusão de expressões regulares, defina o escopo dos padrões para termos de domínio ou substantivos específicos. Assim, o Model Armor exclui falsos positivos conhecidos sem ignorar violações genuínas de segurança. Ao transmitir padrões de expressão regular em corpos de solicitação JSON ("pattern"), faça o escape de cada barra invertida com uma segunda barra invertida. Por exemplo, use \\b e \\s.

Exemplos de detecção de jailbreak e injeção de comando

Verbos no imperativo, como ignore, disregard, bypass ou override, aparecem com frequência em injeções de comandos maliciosos adversários e instruções legítimas para triagem de e-mails, formatação de dados, tratamento de erros ou configuração do sistema. Para evitar a exclusão de categorias amplas de comandos, combine limites de palavras (\\b), grupos não capturados ((?:...)) e a flag sem diferenciação de maiúsculas e minúsculas ((?i)) com MATCHING_SCOPE_PARTIAL_MATCH para ancorar sua expressão regular a substantivos de destino operacionais específicos.

A tabela a seguir fornece um exemplo de padrão de expressão regular de correspondência parcial (com barras invertidas com escape JSON) e um exemplo de comando para um cenário comum de injeção de comando e falso positivo de jailbreak.

Categoria de instrução	Termos de acionamento	Cenários de falso positivo	Exemplo de padrão de expressão regular de correspondência parcial	Exemplo de comando
Triagem e filtragem de conteúdo	ignore, disregard	Triagem de e-mails, tratamento de erros e revisão de rascunhos	(?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.

Exemplos de filtros de segurança da IA responsável

A documentação técnica, os comandos de administração do sistema e as expressões idiomáticas comuns geralmente contêm palavras que se sobrepõem às categorias de segurança da IA responsável. Para reduzir os falsos positivos em comandos ou respostas maiores, combine limites de palavras (\\b), grupos não capturados ((?:...)) e a flag sem diferenciação de maiúsculas e minúsculas ((?i)) com MATCHING_SCOPE_PARTIAL_MATCH.

A tabela a seguir fornece exemplos de padrões de expressões regulares de correspondência parcial (com barras invertidas com escape JSON) e exemplos de comandos para cenários comuns de falsos positivos de IA responsável.

Categoria de risco	Termos de acionamento	Cenários de falso positivo	Exemplo de padrão de expressão regular de correspondência parcial	Exemplo de comando
Violência ou ofensa	kill	Encerramento de processos, interruptores elétricos ou de AVAC e expressões idiomáticas comuns	(?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.
Linguagem tóxica ou ofensiva	abort, terminate	Transações de banco de dados, ciclo de vida da missão e termos de emprego ou contrato	(?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b	Abort retry.
Correspondências de substring em termos de domínio	Substrings de caracteres sobrepostas	Termos acadêmicos, botânica, ornitologia, aviação e nomes próprios	(?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b	I love reading Dickens.
Armas ou explosivos	bomb, blast, detonate	Bioinformática, expressões de entretenimento e equipamentos industriais ou de limpeza	(?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áticas recomendadas para configurar regras de exclusão

Siga estas práticas recomendadas para minimizar falsos positivos sem enfraquecer a postura de segurança do seu modelo:

• Delimite as regras de escopo a contextos específicos: evite excluir verbos únicos ou termos amplos (como ignore, kill ou abort) ou usar caracteres curinga sem restrições (como .*ignore.*). Como MATCHING_SCOPE_PARTIAL_MATCH substitui matchState a NO_MATCH_FOUND em todo o filtro sempre que uma substring corresponde, regras muito amplas podem mascarar violações reais em outro lugar no mesmo comando ou resposta. Sempre combine verbos de acionamento com substantivos específicos (por exemplo, ignore case when sorting this list ou (?i)kill process [0-9]+).
• Use limites de palavras e consolide padrões: em regras de expressão regular, use limites de palavras (\b) para evitar correspondências acidentais de substrings em palavras não relacionadas. Consolide frases relacionadas em uma única expressão regular usando grupos não capturadores ((?:...)) e alternância (|) para ficar dentro do limite do sistema de 10 regras por conjunto de regras.
• Prefira MATCHING_SCOPE_FULL_MATCH para entradas previsíveis: ao excluir solicitações predefinidas da UI, comandos prontos ou payloads de teste automatizados, defina matchingScope como MATCHING_SCOPE_FULL_MATCH ou ancore expressões regulares com ^ e $. O escopo de correspondência exata impede que os usuários anexem instruções adversárias a uma frase excluída para burlar a detecção.
• Escrever regras para texto bruto e não transformado: o Model Armor avalia as regras de exclusão antes da desidentificação ou tradução. Verifique se os padrões correspondem ao formato original antes da desidentificação e adicione frases ou padrões de expressões regulares específicos de cada idioma compatível com seu aplicativo.
• Analise e desative regras temporárias após upgrades de filtro: quando você faz upgrade de um modelo para uma versão de filtro mais recente, reavalie seus casos de teste de falso positivo e remova as regras de exclusão resolvidas pelos modelos de detecção atualizados.

A seguir

• Confira exemplos de como limpar comandos e limpar respostas do modelo com regras de exclusão.
• Confira os limites do sistema de regras de exclusão.
• Saiba como criar e gerenciar modelos do Model Armor.