Utilisation de classificateurs personnalisés

La classification personnalisée utilise la classe CUSTOM_CLASSIFIER pour permettre aux ingénieurs de données d’étendre leurs capacités de classification des données en se basant sur leur propre connaissance des données. Vous pouvez créer une instance de la classe CUSTOM_CLASSIFIER dans la base de données et le schéma de votre choix et appeler des méthodes d’instance pour gérer les expressions régulières associées à l’instance.

Commandes et méthodes

Les méthodes et commandes SQL suivantes sont prises en charge :

Contrôle d’accès

Ces sections résument les rôles et les attributions sur divers objets dont vous avez besoin pour utiliser une instance.

Rôles

Vous pouvez utiliser les rôles suivants avec une classification personnalisée :

  • SNOWFLAKE.CLASSIFICATION_ADMIN : rôle de base de données qui vous permet de créer une instance de classification personnalisée.

  • custom_classifier !PRIVACY_USER : rôle de l’instance qui vous permet d’appeler les méthodes suivantes sur l’instance :

    • ADD_REGEX

    • LIST

    • DELETE_CATEGORY

  • Le rôle de compte titulaire du privilège OWNERSHIP sur l’instance peut exécuter les commandes suivantes :

    • DROP CUSTOM_CLASSIFIER

    • SHOW CUSTOM_CLASSIFIER

Attributions

Pour créer et gérer des instances, vous pouvez choisir d’accorder le privilège CREATE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER </sql-reference/sql/grant-privilege> à un rôle ou d’accorder le rôle d’instance PRIVACY_USER à un rôle.

Vous pouvez accorder les rôles d’instance à des rôles de compte et à des rôles de base de données pour permettre à d’autres utilisateurs d’utiliser des instances de classification personnalisée :

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>
Copy

Où :

name

Spécifie le nom de l’instance de classification personnalisée.

role_name

Spécifie le nom d’un rôle de compte.

database_role_name

Spécifie le nom d’un rôle de base de données.

Vous devez utiliser un entrepôt pour appeler des méthodes sur l’instance. Cependant, vous ne pouvez pas utiliser la commande GRANT OWNERSHIP pour transférer la propriété de l’instance à un rôle différent ou à un rôle de base de données.

Pour accorder le rôle personnalisé my_classification_role, le rôle d’instance et les privilèges requis pour créer et utiliser une instance de la classe CUSTOM_CLASSIFIER, exécutez les instructions suivantes :

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;
Copy

Si vous souhaitez activer un rôle spécifique, tel que data_analyst, pour utiliser une instance spécifique, procédez comme suit :

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

Exemple

L’approche de haut niveau pour classer les données à l’aide de classificateurs personnalisés est la suivante :

  1. Identifiez une table à classer.

  2. Utilisez SQL pour effectuer les opérations suivantes :

    1. Créer une instance de classification personnalisée.

    2. Ajouter les catégories de balises système et les expressions régulières à l’instance.

    3. Classer la table.

Procédez comme suit pour créer un classificateur personnalisé afin de classer une table :

  1. Prenons une table, data.tables.patient_diagnosis, dont l’une des colonnes contient des codes de diagnostic tels que des codes 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 |
    +-------------+----------------------------------------------------------+
    
    Copy

    Cette table peut également comprendre des colonnes permettant d’identifier les patients qui ont été traités dans un établissement médical, comme le prénom et le nom, les identificateurs uniques de l’assurance maladie et la date de naissance. Le propriétaire de données peut classer la table pour s’assurer que les colonnes sont correctement balisées afin que la table puisse être surveillée.

    Dans cet exemple, le propriétaire de données dispose déjà de ces privilèges dans le cadre de son rôle :

    • OWNERSHIP sur la table à classer.

    • OWNERSHIP sur le schéma contenant la table.

    • USAGE sur la base de données contenant le schéma et la table.

  2. Autorisez le propriétaire de données à classer la table en accordant le rôle de base de données SNOWFLAKE.CLASSIFICATION_ADMIN au rôle de propriétaire de données :

    USE ROLE ACCOUNTADMIN;
    GRANT DATABASE ROLE SNOWFLAKE.CLASSIFICATION_ADMIN
      TO ROLE data_owner;
    
    Copy
  3. En tant que propriétaire de données, créez un schéma pour stocker vos instances de classification personnalisée :

    USE ROLE data_owner;
    CREATE SCHEMA data.classifiers;
    
    Copy
  4. Utilisez la commande CREATE CUSTOM_CLASSIFIER pour créer une instance de classification personnalisée dans le schéma data.classifiers :

    CREATE OR REPLACE SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER medical_codes();
    
    Copy

    Vous pouvez également mettre à jour votre chemin de recherche comme suit :

    • Ajoutez SNOWFLAKE.DATA_PRIVACY pour ne pas avoir à spécifier le nom complet de la classe lors de la création d’une nouvelle instance de la classe.

    • Ajoutez DATA.CLASSIFIERS pour ne pas avoir à spécifier le nom complet de la classe lors de l’appel d’une méthode sur l’instance ou de l’utilisation d’une commande avec l’instance.

  5. Utilisez une commande SHOW CUSTOM_CLASSIFIER pour répertorier chaque instance que vous créez. Par exemple :

    SHOW SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER;
    
    Copy

    Renvoie :

    +----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
    | 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  |
    +----------------------------------+---------------+---------------+-------------+-----------------+---------+-------------+
    
  6. Appelez la méthode custom_classifier !ADD_REGEX sur l’instance pour spécifier les balises système et l’expression régulière permettant d’identifier les codes ICD-10 dans une colonne. L’expression régulière de cet exemple correspond à tous les codes ICD-10 possibles. L’expression régulière correspondant au nom de colonne, ICD.*, et le commentaire sont facultatifs :

    CALL medical_codes!ADD_REGEX(
      'ICD_10_CODES',
      'IDENTIFIER',
      '[A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4}',
      'ICD.*',
      'Add a regex to identify ICD-10 medical codes in a column',
      0.8,
    );
    
    Copy

    Renvoie :

    +---------------+
    |   ADD_REGEX   |
    +---------------+
    | ICD_10_CODES  |
    +---------------+
    

    Astuce

    Testez l’expression régulière avant d’ajouter une expression régulière à l’instance de classification personnalisée. Par exemple :

    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}');
    
    Copy
    +-------------+
    | ICD-10-CODE |
    +-------------+
    | G30.9       |
    | G80.8       |
    | S13.4XXA    |
    +-------------+
    

    Dans cette requête, seules les valeurs valides correspondant à l’expression régulière sont renvoyées. La requête ne renvoie pas de valeurs non valides telles que xyz.

    Pour plus de détails, voir Fonctions de chaîne (expressions régulières).

  7. Appelez la méthode custom_classifier !LIST sur l’instance pour vérifier l’expression régulière que vous avez ajoutée à l’instance :

    SELECT medical_codes!LIST();
    
    Copy

    Renvoie :

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

    Pour supprimer une catégorie, appelez la méthode custom_classifier !DELETE_CATEGORY sur l’instance.

  8. Utilisez SQL pour classer la table. Pour plus de détails, voir Utilisation de SQL pour classer de manière asynchrone les tables d’un schéma.

  9. Si l’instance n’est plus nécessaire, utilisez la commande DROP CUSTOM_CLASSIFIER pour supprimer une instance de classification personnalisée du système :

    DROP SNOWFLAKE.DATA_PRIVACY.CUSTOM_CLASSIFIER data.classifiers.medical_codes;
    
    Copy

Audit des classificateurs personnalisés

Vous pouvez utiliser les requêtes suivantes pour auditer la création d’instances de classification personnalisées, l’ajout d’expressions régulières aux instances et la suppression de l’instance.

  • Pour auditer la création d’instances de classification personnalisées, utilisez la requête suivante :

    SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
    WHERE query_text ILIKE 'create % snowflake.data_privacy.custom_classifier%';
    
    Copy
  • Pour auditer l’ajout d’expressions régulières à une instance spécifique, utilisez la requête suivante et remplacez DB.SCH.MY_INSTANCE par le nom de l’instance que vous souhaitez auditer :

    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;
    
    Copy
  • Pour auditer la suppression d’une instance de classification personnalisée, utilisez la requête suivante :

    SELECT * FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
    WHERE query_text ILIKE 'drop % snowflake.data_privacy.custom_classifier%';
    
    Copy