Usando classificadores personalizados para implementar categorias semânticas personalizadas¶

A classe CUSTOM_CLASSIFIER permite que os engenheiros de dados ampliem os recursos de classificação de dados com base em seu próprio conhecimento dos dados. Para classificar dados confidenciais em categorias semânticas personalizadas, crie uma instância da classe CUSTOM_CLASSIFIER em um esquema e chame métodos de instância para adicionar expressões regulares associadas à instância.

Para ver um exemplo completo do uso de uma instância CUSTOM_CLASSIFIER para criar uma categoria semântica personalizada, consulte Exemplo.

Comandos e métodos¶

Os seguintes métodos e comandos SQL são suportados:

Comandos:
Métodos:

Controle de acesso¶

Essas seções resumem as funções e concessões de vários objetos que você precisa para usar uma instância.

Funções¶

Você pode usar as seguintes funções com classificação personalizada:

SNOWFLAKE.CLASSIFICATION_ADMIN: função de banco de dados que permite criar uma instância de classificador personalizado.
custom_classifier !PRIVACY_USER: função de instância que permite que você chame os seguintes métodos na instância:
- ADD_REGEX
- LIST
- DELETE_CATEGORY
A função da conta com privilégio OWNERSHIP na instância pode executar os estes comandos:
- DROP CUSTOM_CLASSIFIER
- SHOW CUSTOM_CLASSIFIER

Conceções¶

Para criar e gerenciar instâncias, você pode escolher conceder o privilégio CREATE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER a uma função ou conceder a função de instância PRIVACY_USER a uma função.

Você pode conceder funções de instância a funções de conta e de banco de dados para permitir que outros usuários trabalhem com instâncias de classificador personalizado:

GRANT SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  TO ROLE <role_name>

REVOKE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  FROM ROLE <role_name>

GRANT SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  TO DATABASE ROLE <database_role_name>

REVOKE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE <name>!PRIVACY_USER
  FROM DATABASE ROLE <database_role_name>

Onde:

name: Especifica o nome da instância do classificador personalizado.
role_name: Especifica o nome de uma função da conta.
database_role_name: Especifica o nome de uma função do banco de dados.

Você deve usar um warehouse para chamar métodos na instância.

Para conceder à função personalizada my_classification_role a função de instância e os privilégios necessários para criar e usar uma instância da classe CUSTOM_CLASSIFIER, execute as seguintes instruções:

USE ROLE ACCOUNTADMIN;
GRANT DATABASE ROLE SNOWFLAKE.CLASSIFICATION_ADMIN
  TO ROLE my_classification_role;
GRANT USAGE ON DATABASE mydb TO ROLE my_classification_role;
GRANT USAGE ON SCHEMA mydb.instances TO ROLE my_classification_role;
GRANT USAGE ON WAREHOUSE wh_classification TO ROLE my_classification_role;

Se você quiser habilitar uma função específica, como data_analyst, para usar uma instância específica, faça o seguinte:

GRANT SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER ROLE
  mydb.sch.my_instance!PRIVACY_USER TO ROLE data_analyst;

Exemplo¶

A abordagem de alto nível para classificar dados com classificadores personalizados é a seguinte:

Identificar uma tabela para classificar.
Use SQL para fazer o seguinte:
1. Criar uma instância de classificador personalizado.
2. Adicionar a categoria semântica personalizada e as expressões regulares à instância.
3. Classificar a tabela.

Conclua estas etapas para criar um classificador personalizado para classificar uma tabela:

Considere uma tabela, data.tables.patient_diagnosis, na qual uma de suas colunas contém códigos de diagnóstico, como códigos ICD-10.
+-------------+----------------------------------------------------------+ | ICD_10_CODE | DESCRIPTION | +-------------+----------------------------------------------------------+ | G30.9 | Alzheimer's disease, unspecified | | G80.8 | Other cerebral palsy | | S13.4XXA | Sprain of ligaments of cervical spine, initial encounter | +-------------+----------------------------------------------------------+
Esta tabela também pode incluir colunas para identificar pacientes, como nome e sobrenome, identificadores exclusivos de seguro saúde e data de nascimento, que foram tratados em uma instituição médica. O proprietário dos dados pode classificar a tabela para garantir que as colunas sejam marcadas corretamente para que a tabela possa ser monitorada.

Neste exemplo, o proprietário dos dados já tem estes privilégios concedidos à sua função:
- OWNERSHIP na tabela a ser classificada.
- OWNERSHIP no esquema que contém a tabela.
- USAGE no banco de dados que contém o esquema e a tabela.
Permita que o proprietário dos dados classifique a tabela concedendo a função de banco de dados SNOWFLAKE.CLASSIFICATION_ADMIN à função de proprietário dos dados:
USE ROLE ACCOUNTADMIN; GRANT DATABASE ROLE SNOWFLAKE.CLASSIFICATION_ADMIN TO ROLE data_owner;
Como proprietário dos dados, crie um esquema para armazenar suas instâncias de classificador personalizado:
USE ROLE data_owner; CREATE SCHEMA data.classifiers;
Use o comando CREATE CUSTOM_CLASSIFIER para criar uma instância de classificador personalizado no esquema data.classifiers:
```
CREATE OR REPLACE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER medical_codes();
```
Opcionalmente, você pode atualizar seu caminho de pesquisa da seguinte maneira:
- Adicione SNOWFLAKE.DATA_PRIVACY para que você não precise especificar o nome totalmente qualificado da classe ao criar uma nova instância da classe.
- Adicione DATA.CLASSIFIERS para que você não precise especificar o nome totalmente qualificado da instância ao chamar um método na instância ou usar um comando com a instância.

Use um comando SHOW CUSTOM_CLASSIFIER para listar cada instância criada. Por exemplo:

SHOW SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER;

Retorna:

+----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
| created_on                       | name          | database_name | schema_name | current_version | comment | owner       |
+----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
| 2023-09-08 07:00:00.123000+00:00 | MEDICAL_CODES | DATA          | CLASSIFIERS | 1.0             | None    | DATA_OWNER  |
+----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+

Chame o método custom_classifier !ADD_REGEX na instância para especificar as tags do sistema e a expressão regular para identificar códigos ICD-10 em uma coluna. A expressão regular neste exemplo corresponde a todos os códigos ICD-10 possíveis. A expressão regular que corresponde ao nome da coluna, ICD.*, e o comentário são opcionais:
```
CALL medical_codes!ADD_REGEX(
  SEMANTIC_CATEGORY => 'ICD_10_CODES',
  PRIVACY_CATEGORY => 'IDENTIFIER',
  VALUE_REGEX => '[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}',
  COL_NAME_REGEX => 'ICD.*',
  DESCRIPTION => 'Add a regex to identify ICD-10 medical codes in a column',
  THRESHOLD => 0.8
);
```
Retorna:
```
+---------------+
|   ADD_REGEX   |
+---------------+
| ICD_10_CODES  |
+---------------+
```
Dica

Teste a expressão regular antes de adicioná-la à instância do classificador personalizado. Por exemplo:
SELECT icd_10_code FROM medical_codes WHERE icd_10_code REGEXP('[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}');
+-------------+ | ICD-10-CODE | +-------------+ | G30.9 | | G80.8 | | S13.4XXA | +-------------+
Nesta consulta, apenas valores válidos que correspondam à expressão regular são retornados. A consulta não retorna valores inválidos como xyz.

Para obter mais detalhes, consulte Funções de cadeia de caracteres (expressões regulares).

Chame o método custom_classifier !LIST na instância para verificar a expressão regular que você adicionou à instância:

SELECT medical_codes!LIST();

Retorna:

+--------------------------------------------------------------------------------+
| MEDICAL_CODES!LIST()                                                           |
+--------------------------------------------------------------------------------+
| {                                                                              |
|   "ICD-10-CODES": {                                                            |
|     "col_name_regex": "ICD.*",                                                 |
|     "description": "Add a regex to identify ICD-10 medical codes in a column", |
|     "privacy_category": "IDENTIFIER",                                          |
|     "threshold": 0.8,                                                          |
|     "value_regex": "[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}"                   |
|   }                                                                            |
| }                                                                              |
+--------------------------------------------------------------------------------+

Para remover uma categoria, chame o método custom_classifier !DELETE_CATEGORY na instância.

Chame o procedimento armazenado SYSTEM$CLASSIFY_SCHEMA para classificar a tabela.
Se a instância não for mais necessária, use o comando DROP CUSTOM_CLASSIFIER para remover uma instância de classificador personalizado do sistema:
```
DROP SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER data.classifiers.medical_codes;
```

Auditoria de classificadores personalizados¶

Você pode usar as seguintes consultas para fazer auditoria da criação de instâncias de classificador personalizado, adicionar expressões regulares a instâncias e descartar a instância.

Para fazer auditoria da criação de instâncias de classificador personalizado, use a seguinte consulta:
```
SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE query_text ILIKE 'create % snowflake.data_privacy.custom_classifier%';
```

Para auditar a adição de expressões regulares a uma instância específica, use a seguinte consulta e substitua DB.SCH.MY_INSTANCE pelo nome da instância que você deseja auditar:

SELECT
    QUERY_HISTORY.user_name,
    QUERY_HISTORY.role_name,
    QUERY_HISTORY.query_text,
    QUERY_HISTORY.query_id
  FROM
    SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY query_history,
    SNOWFLAKE.ACCOUNT_USAGE.ACCESS_HISTORY access_history,
      TABLE(FLATTEN(input => access_history.direct_objects_accessed)) flattened_value
WHERE flattened_value.value:"objectName" = 'DB.SCH.MY_INSTANCE!ADD_REGEX'
AND QUERY_HISTORY.query_id = ACCESS_HISTORY.query_id;

Para fazer auditoria do descarte de uma instância de classificador personalizado, use a seguinte consulta:
```
SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE query_text ILIKE 'drop % snowflake.data_privacy.custom_classifier%';
```