Classification (fonctions optimisées par le ML de Snowflake Cortex)¶
La classification utilise des algorithmes de machine learning pour classer les données dans différentes catégories en utilisant des modèles détectés dans les données d’entraînement. La classification binaire (deux classes) et la classification multi-classes (plus de deux classes) sont prises en charge. Les cas d’utilisation courants de la classification comprennent la prédiction du roulement des clients, la détection des fraudes à la carte de crédit et la détection des spams.
La classification implique la création d’un objet de modèle de classification, avec une référence aux données d’entraînement. Le modèle est ajusté aux données d’entraînement fournies. Vous utilisez ensuite l’objet de modèle de classification de niveau schéma résultant pour classer de nouveaux points de données et pour comprendre la précision du modèle grâce à ses APIs d’évaluation.
Important
Mention légale. Cette fonction Snowflake Cortex basée sur le ML est alimentée par une technologie de machine learning. La technologie de machine learning et les résultats fournis peuvent être inexacts, incorrects ou biaisés. Les décisions basées sur les résultats du machine learning, y compris celles qui sont intégrées dans des pipelines automatiques, devraient être soumises à une supervision humaine et à des processus d’examen pour s’assurer que le contenu généré par le modèle est exact. Les requêtes de fonctions Snowflake Cortex basées sur le ML seront traitées comme toute autre requête SQL et peuvent être considérées comme des métadonnées.
Métadonnées. Lorsque vous utilisez des fonctions Snowflake Cortex basées sur le ML, Snowflake enregistre les messages d’erreur génériques renvoyés par une fonction ML, en plus de ce qui est mentionné dans les champs de métadonnées. Ces journaux d’erreurs nous aident à résoudre les problèmes qui surviennent et à améliorer ces fonctions pour mieux répondre à vos demandes.
Pour plus d’informations, voir la FAQ relative à la confiance et à la sécurité concernant l’AI de Snowflake.
À propos du modèle de classification¶
La fonction Snowflake Cortex Classification est optimisée par une machine de renforcement du gradient. Pour la classification binaire, le modèle est entraîné à l’aide d’une fonction de perte d’aire sous la courbe. Pour la classification multi-classes, le modèle est entraîné à l’aide d’une fonction de perte logistique.
Les ensembles de données d’entraînement adaptés à la classification comprennent une colonne cible représentant la classe étiquetée de chaque point de données et au moins une colonne de fonctions.
Le modèle de classification prend en charge les types de données numériques, booléennes et de chaînes pour les fonctions et les étiquettes. Les fonctions numériques sont traitées comme des fonctions continues, tandis que les chaînes de caractères et les fonctions booléennes sont traitées comme des chaînes catégoriques. Pour traiter les fonctions numériques comme des catégories, transformez-les en chaînes. Le modèle peut traiter des valeurs NULL dans les fonctions. La cardinalité de la colonne des étiquettes doit être supérieure à 1 et inférieure au nombre de lignes de l’ensemble de données.
Les données d’inférence doivent avoir les mêmes noms et types de fonctions que les données d’entraînement. Le fait qu’une fonction catégorique ait une valeur qui n’est pas présente dans l’ensemble de données d’entraînement ne constitue pas une erreur. Les colonnes des données d’inférence qui n’étaient pas présentes dans l’ensemble de données d’entraînement sont ignorées.
Les modèles de classification peuvent être évalués en fonction de la qualité de la prédiction. Dans le processus d’évaluation, un modèle supplémentaire est entraîné sur les données d’origine, mais avec certains points de données non pris en compte. Les points de données retenus sont ensuite utilisés pour l’inférence et les classes prédites sont comparées aux classes réelles.
Limites actuelles¶
Les données d’entraînement et d’inférence doivent être numériques, booléennes ou sous forme de chaînes. Les autres types doivent être convertis en l’un de ces types.
Vous ne pouvez pas choisir ou modifier l’algorithme de classification.
Les paramètres du modèle ne peuvent pas être spécifiés ou ajustés manuellement.
L’entraînement prend en charge un maximum de 1 000 colonnes et 10 millions de lignes, bien qu’il soit possible de manquer de mémoire en deçà de cette limite. Dans ce cas, essayez un entrepôt plus grand.
Les instances SNOWFLAKE.ML.CLASSIFICATION ne peuvent pas être clonées. Lorsque vous clonez ou répliquez une base de données contenant un modèle de classification, le modèle est actuellement ignoré.
Préparation à la classification¶
Avant de pouvoir utiliser la classification, vous devez :
Sélectionner un entrepôt virtuel dans lequel vous entraînerez et exécuterez vos modèles.
Accorder les privilèges nécessaires à la création de modèles de classification.
Vous pourriez également vouloir modifier votre chemin de recherche pour inclure le schéma SNOWFLAKE.ML.
Sélection d’un entrepôt virtuel¶
Un entrepôt virtuel Snowflake fournit les ressources de calcul nécessaires à l’entraînement et à l’utilisation des modèles de machine learning de classification. Cette section fournit des conseils généraux sur le choix de la meilleure taille et du meilleur type d’entrepôt pour la classification, en se concentrant sur l’étape d’entraînement, la partie du processus qui prend le plus de temps et qui mobilise le plus de mémoire.
Vous devriez choisir le type d’entrepôt en fonction de la taille de vos données d’entraînement. Les entrepôts standard sont soumis à une limite de mémoire Snowpark inférieure et sont plus appropriés pour les tâches d’entraînement avec moins de lignes ou de fonctionnalités. Au fur et à mesure que le nombre de lignes et de fonctionnalités augmente, envisagez d’utiliser un entrepôt optimisé par Snowpark pour vous assurer que les tâches peuvent être exécutées avec succès. Pour de meilleures performances, entraînez vos modèles à l’aide d’un entrepôt dédié sans autres charges de travail simultanées.
Utilisez le tableau ci-dessous, qui indique les durées d’entraînement pour une variété de tailles de données et de types d’entrepôts, afin de comprendre le type et la taille de l’entrepôt dont vous avez besoin. Les temps d’entraînement peuvent varier par rapport aux valeurs indiquées.
Type et taille de l’entrepôt |
Nombre de lignes |
Nombre de colonnes |
Durée de l’entraînement (secondes) |
|---|---|---|---|
XS standard |
1000 |
10 |
8 |
XS standard |
10,000 |
100 |
27 |
XS standard |
100,000 |
1000 |
323 |
XL standard |
1000 |
10 |
8 |
XL standard |
10,000 |
100 |
15 |
XL standard |
100,000 |
1000 |
300 |
XL optimisé pour Snowpark |
1000 |
10 |
11 |
XL optimisé pour Snowpark |
10,000 |
100 |
15 |
XL optimisé pour Snowpark |
100,000 |
1000 |
375 |
Octroi de privilèges pour la création de modèles de classification¶
L’entraînement d’un modèle de classification se traduit par un objet au niveau du schéma. Par conséquent, le rôle que vous utilisez pour créer des modèles doit avoir le privilège CREATE SNOWFLAKE.ML.CLASSIFICATION sur le schéma où le modèle sera créé, ce qui permet au modèle d’y être stocké. Ce privilège est similaire à d’autres privilèges de schéma tels que CREATE TABLE ou CREATE VIEW.
Snowflake vous recommande de créer un rôle nommé analyst qui sera utilisé par les personnes qui doivent créer des modèles de classification.
Dans l’exemple suivant, le rôle admin est le propriétaire du schéma admin_db.admin_schema. Le rôle analyst doit créer des modèles dans ce schéma.
USE ROLE admin;
GRANT USAGE ON admin_db TO ROLE analyst;
GRANT USAGE ON admin_schema TO ROLE analyst;
GRANT CREATE SNOWFLAKE.ML.CLASSIFICATION ON SCHEMA admin_db.admin_schema TO ROLE analyst;
Pour utiliser ce schéma, un utilisateur assume le rôle analyst :
USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;
Si le rôle analyst dispose des privilèges CREATE SCHEMA dans la base de données analyst_db, il peut créer un nouveau schéma analyst_db.analyst_schema et créer des modèles de classification dans ce schéma :
USE ROLE analyst;
CREATE SCHEMA analyst_db.analyst_schema;
USE SCHEMA analyst_db.analyst_schema;
Pour révoquer le privilège de création de modèle d’un rôle sur le schéma, utilisez REVOKE <privilèges> :
REVOKE CREATE SNOWFLAKE.ML.CLASSIFICATION ON SCHEMA admin_db.admin_schema FROM ROLE analyst;
Entraînement, utilisation, vue, suppression et mise à jour des modèles¶
Note
SNOWFLAKE.ML.CLASSIFICATION s’exécute avec des privilèges limités ; par défaut, il n’a donc pas accès à vos données. Vous devez donc transmettre les tables et les vues en tant que références, qui transmettent les privilèges de l’appelant. Vous pouvez également fournir une référence de requête au lieu d’une référence à une table ou à une vue.
Voir la référence de CLASSIFICATION pour des informations sur les APIs d’entraînement, d’inférence et d’évaluation.
Utilisez CREATE SNOWFLAKE.ML.CLASSIFICATION pour créer et entraîner un modèle.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION <model_name>(...);
Pour effectuer une inférence (prédiction) sur un ensemble de données, utilisez la méthode PREDICT du modèle.
SELECT <model_name>!PREDICT(...);
Pour évaluer un modèle, utilisez les méthodes d’évaluation proposées.
CALL <model_name>!SHOW_EVALUATION_METRICS();
CALL <model_name>!SHOW_GLOBAL_EVALUATION_METRICS();
CALL <model_name>!SHOW_THRESHOLD_METRICS();
CALL <model_name>!SHOW_CONFUSION_MATRIX();
Pour afficher le classement de l’importance des fonctionnalités d’un modèle, appelez sa méthode SHOW_FEATURE_IMPORTANCE.
CALL <model_name>!SHOW_FEATURE_IMPORTANCE();
Pour examiner les journaux générés pendant l’entraînement, utilisez la méthode SHOW_TRAINING_LOGS.
CALL <model_name>!SHOW_TRAINING_LOGS();
Astuce
Pour des exemples d’utilisation de ces méthodes, voir Exemples.
Pour afficher tous les modèles de classification, utilisez la commande SHOW.
SHOW SNOWFLAKE.ML.CLASSIFICATION;
Pour supprimer un modèle de classification, utilisez la commande DROP.
DROP SNOWFLAKE.ML.CLASSIFICATION <model_name>;
Les modèles sont immuables et ne peuvent pas être mis à jour sur place. Pour mettre à jour un modèle, il faut supprimer le modèle existant et en entraîner un nouveau. La variante CREATE OR REPLACE de la commande CREATE est utile à cet effet.
Exemples¶
Configuration des données pour les exemples¶
Les exemples de cette rubrique utilisent deux tables. La première table, training_purchase_data, comporte deux colonnes de fonctionnalités : une colonne d’étiquettes binaires et une colonne d’étiquettes multi-classes. La deuxième table est appelée prediction_purchase_data et comporte deux colonnes de fonctionnalités. Utilisez le SQL ci-dessous pour créer ces tables.
CREATE OR REPLACE TABLE training_purchase_data AS (
SELECT
CAST(UNIFORM(0, 4, RANDOm()) as VARCHAR) as user_interest_score,
UNIFORM(0, 3, RANDOM()) as user_rating, FALSE AS label,
'not_interested' AS class
FROM TABLE(GENERATOR(rowCount => 100))
UNION ALL
SELECT
CAST(UNIFORM(4, 7, RANDOM()) AS VARCHAR) AS user_interest_score,
UNIFORM(3, 7, RANDOM()) AS user_rating, FALSE AS label,
'add_to_wishlist' AS class
FROM TABLE(GENERATOR(rowCount => 100))
UNION ALL
SELECT
CAST(UNIFORM(7, 10, RANDOM()) AS VARCHAR) AS user_interest_score,
UNIFORM(7, 10, RANDOM()) AS user_rating,
TRUE as label, 'purchase' AS class
FROM TABLE(GENERATOR(rowCount => 100))
);
CREATE OR REPLACE table prediction_purchase_data AS (
SELECT
CAST(UNIFORM(0, 4, RANDOM()) AS VARCHAR) AS user_interest_score,
UNIFORM(0, 3, RANDOM()) AS user_rating
FROM TABLE(GENERATOR(rowCount => 100))
UNION ALL
SELECT
CAST(UNIFORM(4, 7, RANDOM()) AS VARCHAR) AS user_interest_score,
UNIFORM(3, 7, RANDOM()) AS user_rating
FROM TABLE(GENERATOR(rowCount => 100))
UNION ALL
SELECT
CAST(UNIFORM(7, 10, RANDOM()) AS VARCHAR) AS user_interest_score,
UNIFORM(7, 10, RANDOM()) AS user_rating
FROM TABLE(GENERATOR(rowCount => 100))
);
Entraînement et utilisation d’un classificateur binaire¶
Tout d’abord, créez une vue contenant des données binaires pour l’entraînement.
CREATE OR REPLACE view binary_classification_view AS
SELECT uuid, user_interest_score, user_rating, label
FROM training_purchase_data;
SELECT * FROM binary_classification_view;
L’instruction SELECT renvoie des résultats sous la forme suivante.
+---------------------+-------------+-------+
| USER_INTEREST_SCORE | USER_RATING | LABEL |
|---------------------+-------------+-------|
| 4 | 0 | False |
| 3 | 3 | False |
| 0 | 0 | False |
| 3 | 0 | False |
| 0 | 2 | False |
+---------------------+-------------+-------+
À l’aide de cette vue, créez et entraînez un modèle de classification binaire.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_binary(
INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
TARGET_COLNAME => 'label'
);
Après avoir créé le modèle, utilisez sa méthode PREDICT pour déduire des étiquettes pour les données d’achat non étiquetées. Vous pouvez utiliser la fonction OBJECT_CONSTRUCT pour créer des paires clé-valeur de fonctionnalités pour l’argument INPUT_DATA.
SELECT model_binary!PREDICT(INPUT_DATA => object_construct(*))
as prediction from prediction_purchase_data;
Le modèle renvoie des résultats au format suivant. L’objet de prédiction comprend des probabilités prédites pour chaque classe et la classe prédite sur la base de la probabilité prédite maximale. Les prédictions sont renvoyées dans le même ordre que celui dans lequel les fonctionnalités originales ont été fournies.
+--------------------------------------------------+
| PREDICTION |
|--------------------------------------------------|
| { |
| "class": "False", |
| "logs": null, |
| "probability": { |
| "False": 0.997954711, |
| "True": 0.002045289 |
| } |
| } |
| { |
| "class": "False", |
| "logs": null, |
| "probability": { |
| "False": 0.9972659439, |
| "True": 0.0027340561 |
| } |
| } |
| { |
| "class": "False", |
| "logs": null, |
| "probability": { |
| "False": 0.9971540571, |
| "True": 0.0028459429 |
| } |
| } |
| { |
| "class": "False", |
| "logs": null, |
| "probability": { |
| "False": 0.9971536503, |
| "True": 0.0028463497 |
| } |
| } |
| { |
| "class": "False", |
| "logs": null, |
| "probability": { |
| "False": 0.9972659439, |
| "True": 0.0027340561 |
| } |
| } |
+--------------------------------------------------+
Pour associer des fonctionnalités à des prédictions, utilisez une requête telle que la suivante.
SELECT *, model_binary!PREDICT(
INPUT_DATA => object_construct(*))
as predictions from prediction_purchase_data;
+---------------------+-------------+----------------------------+
| USER_INTEREST_SCORE | USER_RATING | PREDICTIONS |
|---------------------+-------------+----------------------------|
| 4 | 0 | { |
| | | "class": "False", |
| | | "logs": null, |
| | | "probability": { |
| | | "False": 0.997954711, |
| | | "True": 0.002045289 |
| | | } |
| | | } |
| 2 | 3 | { |
| | | "class": "False", |
| | | "logs": null, |
| | | "probability": { |
| | | "False": 0.9972659439, |
| | | "True": 0.0027340561 |
| | | } |
| | | } |
| 3 | 2 | { |
| | | "class": "False", |
| | | "logs": null, |
| | | "probability": { |
| | | "False": 0.9971540571, |
| | | "True": 0.0028459429 |
| | | } |
| | | } |
| 1 | 1 | { |
| | | "class": "False", |
| | | "logs": null, |
| | | "probability": { |
| | | "False": 0.9971536503, |
| | | "True": 0.0028463497 |
| | | } |
| | | } |
| 0 | 3 | { |
| | | "class": "False", |
| | | "logs": null, |
| | | "probability": { |
| | | "False": 0.9972659439, |
| | | "True": 0.0027340561 |
| | | } |
| | | } |
+---------------------+-------------+----------------------------+
Entraînement et utilisation d’un classificateur multi-classes¶
Créez une vue contenant des données binaires pour l’entraînement.
CREATE OR REPLACE multiclass_classification_view AS
SELECT uuid, user_interest_score, user_rating, class
FROM training_purchase_data;
SELECT * FROM multiclass_classification_view;
Cette instruction SELECT renvoie des résultats sous la forme suivante.
+---------------------+-------------+-----------------+
| USER_INTEREST_SCORE | USER_RATING | CLASS |
|---------------------+-------------+---------------- |
| 4 | 0 | not_interested |
| 3 | 3 | not_interested |
| 0 | 0 | add_to_wishlist |
| 3 | 0 | purchase |
| 0 | 2 | not_interested |
| 2 | 1 | purchase |
| 1 | 0 | not_interested |
+---------------------+-------------+-----------------+
Créez maintenant un modèle de classification multi-classes à partir de cette vue.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_multiclass(
INPUT_DATA => SYSTEM$REFERENCE('view', 'multiclass_classification_view'),
TARGET_COLNAME => 'class'
);
Après avoir créé le modèle, utilisez sa méthode PREDICT pour déduire des étiquettes pour les données d’achat non étiquetées. Utilisez la fonction OBJECT_CONSTRUCT pour créer automatiquement des paires clé-valeur pour l’argument INPUT_DATA.
SELECT *, model_multiclass!PREDICT(
INPUT_DATA => object_construct(*))
as predictions from prediction_purchase_data;
Le modèle renvoie des résultats au format suivant. L’objet de prédiction comprend des probabilités prédites pour chaque classe et la classe prédite sur la base de la probabilité prédite maximale. Les prédictions sont renvoyées dans le même ordre que les fonctionnalités originales fournies et peuvent être jointes dans la même requête.
+---------------------+-------------+--------------------------------------+
| USER_INTEREST_SCORE | USER_RATING | PREDICTIONS |
|---------------------+-------------+--------------------------------------|
| 4 | 0 | { |
| | | "class": "not_interested", |
| | | "logs": null, |
| | | "probability": { |
| | | "add_to_wishlist": 0.0114593962, |
| | | "not_interested": 0.988124481, |
| | | "purchase": 0.0004161228 |
| | | } |
| | | } |
| 2 | 3 | { |
| | | "class": "not_interested", |
| | | "logs": null, |
| | | "probability": { |
| | | "add_to_wishlist": 0.060358652, |
| | | "not_interested": 0.9283297874, |
| | | "purchase": 0.0113115606 |
| | | } |
| | | } |
| 3 | 2 | { |
| | | "class": "not_interested", |
| | | "logs": null, |
| | | "probability": { |
| | | "add_to_wishlist": 0.0004839615, |
| | | "not_interested": 0.9990937618, |
| | | "purchase": 0.0004222767 |
| | | } |
| | | } |
| 1 | 1 | { |
| | | "class": "not_interested", |
| | | "logs": null, |
| | | "probability": { |
| | | "add_to_wishlist": 0.0004852349, |
| | | "not_interested": 0.9991116684, |
| | | "purchase": 0.0004030968 |
| | | } |
| | | } |
| 0 | 3 | { |
| | | "class": "not_interested", |
| | | "logs": null, |
| | | "probability": { |
| | | "add_to_wishlist": 0.0515227848, |
| | | "not_interested": 0.937059287, |
| | | "purchase": 0.0114179283 |
| | | } |
| | | } |
+---------------------+-------------+--------------------------------------+
Enregistrement des résultats dans une table et exploration des prédictions¶
Les résultats des appels à la méthode PREDICT des modèles peuvent être lus directement dans une requête, mais l’enregistrement des résultats dans une table permet d’explorer plus facilement les prédictions.
CREATE OR REPLACE TABLE my_predictions AS
SELECT *, model_multiclass!PREDICT(INPUT_DATA => object_construct(*)) as predictions from prediction_purchase_data;
SELECT * FROM my_predictions;
Les colonnes de clés et de prédictions peuvent ensuite être explorées dans d’autres requêtes. La requête ci-dessous explore les prédictions.
SELECT
predictions:class AS predicted_class,
predictions:probability AS predicted_probabilities,
predictions:probability:not_interested AS not_interested_class_probability,
predictions['probability']['purchase'] AS purchase_class_probability
FROM my_predictions;
La requête ci-dessus renvoie des résultats sous la forme suivante.
+-------------------+------------------------------------+----------------------------------+----------------------------+
| PREDICTED_CLASS | PREDICTED_PROBABILITIES | NOT_INTERESTED_CLASS_PROBABILITY | PURCHASE_CLASS_PROBABILITY |
|-------------------+------------------------------------+----------------------------------+----------------------------|
| "not_interested" | { | 0.988124481 | 0.0004161228 |
| | "add_to_wishlist": 0.0114593962, | | |
| | "not_interested": 0.988124481, | | |
| | "purchase": 0.0004161228 | | |
| | } | | |
| "not_interested" | { | 0.988124481 | 0.0004161228 |
| | "add_to_wishlist": 0.0114593962, | | |
| | "not_interested": 0.988124481, | | |
| | "purchase": 0.0004161228 | | |
| | } | | |
| "not_interested" | { | 0.9990628483 | 0.0004207292 |
| | "add_to_wishlist": 0.0005164225, | | |
| | "not_interested": 0.9990628483, | | |
| | "purchase": 0.0004207292 | | |
| | } | | |
| "add_to_wishlist" | { | 0.0011554733 | 0.0032013896 |
| | "add_to_wishlist": 0.9956431372, | | |
| | "not_interested": 0.0011554733, | | |
| | "purchase": 0.0032013896 | | |
| | } | | |
| "add_to_wishlist" | { | 0.0011554733 | 0.0032013896 |
| | "add_to_wishlist": 0.9956431372, | | |
| | "not_interested": 0.0011554733, | | |
| | "purchase": 0.0032013896 | | |
| | } | | |
+-------------------+------------------------------------+----------------------------------+----------------------------+
Utilisation des fonctions d’évaluation¶
Par défaut, l’évaluation est activée pour toutes les instances. Cependant, l’évaluation peut être activée ou désactivée manuellement en utilisant l’argument de l’objet config. Si la clé « évaluer » est spécifiée avec la valeur FALSE, l’évaluation n’est pas disponible.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model(
INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
TARGET_COLNAME => 'label',
CONFIG_OBJECT => {'evaluate': TRUE}
);
Lorsque l’évaluation est activée, les métriques d’évaluation peuvent être obtenues à l’aide d’APIs d’évaluation présentées ici.
CALL model!SHOW_EVALUATION_METRICS();
CALL model!SHOW_GLOBAL_EVALUATION_METRICS();
CALL model!SHOW_THRESHOLD_METRICS();
CALL model!SHOW_CONFUSION_MATRIX();
Voir Compréhension des mesures d’évaluation pour une description des métriques renvoyées.
Rôles et privilèges d’utilisation du modèle¶
Chaque instance de modèle de classification comprend deux rôles de modèle, mladmin et mlconsumer. Ces rôles sont scopés au modèle lui-même : model!mladmin et model!mlconsumer. Le propriétaire de l’objet du modèle (initialement, son créateur) se voit automatiquement attribuer les rôles model!mladmin et model!mlconsumer, et peut accorder ces rôles aux rôles de compte et de base de données.
Le rôle mladmin permet d’utiliser toutes les APIs pouvant être appelées à partir de l’objet de modèle, y compris, mais sans s’y limiter, les méthodes de prédiction et les méthodes d’évaluation. Le rôle mlconsumer ne peut être utilisé que pour des APIs de prédiction, et non pour d’autres APIs d’explorations.
L’exemple de SQL suivant illustre l’attribution de rôles de modèle de classification à d’autres rôles. Le rôle r1 peut créer un modèle de classification et accorde au rôle r2 le privilège mlconsumer afin que le rôle r2 puisse appeler la méthode PREDICT de ce modèle. Ensuite, r1 accorde le rôle mladmin à un autre rôle, r3, de sorte que r3 puisse appeler toutes les méthodes du modèle.
Tout d’abord, le rôle r1 crée un objet modèle, faisant de r1 le propriétaire du modèle model.
USE ROLE r1;
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model(
INPUT_DATA => SYSTEM$REFERENCE('TABLE', 'test_classification_dataset'),
TARGET_COLNAME => 'LABEL'
);
Vous pouvez constater en exécutant les instructions ci-dessous que le rôle r2 ne peut pas appeler la méthode PREDICT du modèle.
USE ROLE r2;
SELECT model!PREDICT(1); -- privilege error
Ensuite, r1 accorde à r2 le rôle d’instance mlocnosumer, après quoi r2 peut appeler la méthode PREDICT du modèle.
USE ROLE r1;
GRANT SNOWFLAKE.ML.CLASSIFICATION ROLE model!mlconsumer TO ROLE r2;
USE ROLE r2;
CALL model!PREDICT(
INPUT_DATA => system$query_reference(
'SELECT object_construct(*) FROM test_classification_dataset')
);
De même, le rôle r3 ne peut pas voir les mesures d’évaluation du modèle sans le rôle d’instance mladmin.
USE ROLE r3;
CALL model!SHOW_EVALUATION_METRICS(); -- privilege error
Le rôle r1 accorde le rôle requis à r3, et r3 peut alors appeler la méthode SHOW_EVALUATION_METRICS du modèle.
USE ROLE r1;
GRANT SNOWFLAKE.ML.CLASSIFICATION ROLE model!mladmin TO ROLE r3;
USE ROLE r3;
CALL model!SHOW_EVALUATION_METRICS();
Vous pouvez révoquer les privilèges de la manière suivante.
USE ROLE r1;
REVOKE SNOWFLAKE.ML.CLASSIFICATION ROLE model!mlconsumer FROM ROLE r2;
REVOKE SNOWFLAKE.ML.CLASSIFICATION ROLE model!mladmin FROM ROLE r3;
Utilisez les commandes suivantes pour voir quels rôles de compte et quels rôles de base de données ont été attribués à chacun de ces rôles d’instance.
SHOW GRANTS TO SNOWFLAKE.ML.CLASSIFICATION ROLE <model_name>!mladmin;
SHOW GRANTS TO SNOWFLAKE.ML.CLASSIFICATION ROLE <model_name>!mlconsumer;
Compréhension des mesures d’évaluation¶
Les métriques mesurent la précision avec laquelle un modèle prédit de nouvelles données. La classification Snowflake évalue actuellement les modèles en sélectionnant un échantillon aléatoire de l’ensemble des données. Un nouveau modèle est entraîné sans ces lignes, puis les lignes sont utilisées comme entrée d’inférence. La partie de l’échantillon aléatoire peut être configurée à l’aide de la clé test_fraction de l’objet EVALUATION_CONFIG.
Métriques dans show_evaluation_metrics¶
show_evaluation_metrics calcule les valeurs suivantes pour chaque classe. Voir SHOW_EVALUATION_METRICS.
Instances positives : instances de données (lignes) qui appartiennent à la classe d’intérêt ou à la classe prédite.
Instances négatives : instances de données (lignes) qui n’appartiennent pas à la classe d’intérêt ou qui sont à l’opposé de ce qui est prédit.
Vraies positifs (TP) : prédictions correctes d’instances positives.
Vrais négatifs (TN) : prédictions correctes d’instances négatives,
Faux positifs (FP) : prédictions incorrectes d’instances positives
Faux négatifs (FN) : prédictions incorrectes d’instances négatives.
En utilisant les valeurs ci-dessus, les métriques suivantes sont rapportées pour chaque classe. Pour chaque métrique, une valeur élevée indique un modèle plus prédictif.
Précision : rapport entre le nombre de vrais positifs et le nombre total de positifs prédits. Cela mesure le nombre d’instances positives prédites qui sont effectivement positives.
Rappel (sensibilité) : le rapport entre le nombre de vrais positifs et le nombre total de positifs réels. Cela mesure le nombre d’instances positives réelles qui ont été correctement prédites.
Score F1 : moyenne harmonique de la précision et du rappel. Cela offre un équilibre entre la précision et la mémorisation, en particulier lorsque la répartition des classes est inégale.
Métriques dans show_global_evaluation_metrics¶
show_global_evaluation_metrics calcule les métriques (globales) pour toutes les classes prédites par le modèle en faisant la moyenne des métriques par classe calculées par show_evaluation_metrics. Voir SHOW_GLOBAL_EVALUATION_METRICS.
Actuellement, les moyennes macro et weighted sont utilisées pour les métriques Précision, Rappel, F1, AUC.
La perte logistique (LogLoss) est calculée pour l’ensemble du modèle. L’objectif de la prédiction est de minimiser la fonction de perte.
Métriques dans show_threshold_metrics¶
show_threshold_metrics fournit des chiffres bruts et des métriques pour un seuil spécifique pour chaque classe. Cela peut être utilisé pour tracer les courbes ROC et PR ou pour effectuer un réglage du seuil si nécessaire. Le seuil varie de 0 à 1 pour chaque classe spécifique ; une probabilité prédite est attribuée. Voir SHOW_THRESHOLD_METRICS.
L’échantillon est classé comme appartenant à une classe si la probabilité prédite d’appartenir à cette classe dépasse le seuil spécifié. Les vrais et faux positifs et négatifs sont calculés en considérant la classe négative comme toute instance n’appartenant pas à la classe considérée. Les métriques suivantes sont ensuite calculées.
Taux de vrais positifs (TPR) : la proportion d’instances positives réelles que le modèle identifie correctement (équivalent au rappel).
Taux de faux positifs (FPR) : la proportion d’instances négatives réelles qui ont été incorrectement prédites comme positives.
Précision : le rapport entre les prédictions correctes (les vrais positifs et les vrais négatifs) et le nombre total de prédictions, une mesure globale de la performance du modèle. Cette métrique peut être trompeuse dans les cas déséquilibrés.
Support : le nombre d’occurrences réelles d’une classe dans l’ensemble de données spécifié. Des valeurs de support plus élevées indiquent une plus grande représentation d’une classe dans l’ensemble de données. Le support n’est pas en soi une mesure du modèle, mais une caractéristique de l’ensemble de données.
Matrice de confusion dans show_confusion_matrix¶
La matrice de confusion est un tableau utilisé pour évaluer les performances d’un modèle en comparant les valeurs prédites et réelles et en évaluant sa capacité à identifier correctement les instances positives et négatives. L’objectif est de maximiser le nombre d’instances sur la diagonale de la matrice tout en minimisant le nombre d’instances hors diagonale. Voir SHOW_CONFUSION_MATRICX.
Vous pouvez visualiser la matrice de confusion dans Snowsight de la manière suivante.
CALL model_binary!SHOW_CONFUSION_MATRIX();
Les résultats sont les suivants.
+--------------+--------------+-----------------+-------+------+
| DATASET_TYPE | ACTUAL_CLASS | PREDICTED_CLASS | COUNT | LOGS |
|--------------+--------------+-----------------+-------+------|
| EVAL | false | false | 37 | NULL |
| EVAL | false | true | 1 | NULL |
| EVAL | true | false | 0 | NULL |
| EVAL | true | true | 22 | NULL |
+--------------+--------------+-----------------+-------+------+
Pour visualiser la matrice de confusion, cliquez sur Chart, puis Chart Type, puis Heatgrid. Sous Données, pour Cell values sélectionnez NONE, pour Rows sélectionnez PREDICTED_CLASS, et pour Columns sélectionnez ACTUAL_CLASS. Le résultat est similaire à la figure ci-dessous.
Présentation de l’importance des fonctions¶
Un modèle de classification peut expliquer l’importance relative de toutes les fonctionnalités utilisées dans le modèle. Cette information est utile pour comprendre quels sont les facteurs qui influencent réellement vos données.
La méthode SHOW_FEATURE_IMPORTANCE compte le nombre de fois où les arborescences du modèle ont utilisé chaque fonction pour prendre une décision. Ces scores d’importance des fonctions sont ensuite normalisés à des valeurs comprises entre 0 et 1, de sorte que leur somme soit égale à 1. Les scores obtenus représentent un classement approximatif des fonctions de votre modèle entraîné.
Les fonctions dont le score est proche ont une importance similaire. L’utilisation de plusieurs fonctions très similaires les unes aux autres peut entraîner une réduction des scores d’importance pour ces fonctions.
Limitations¶
Vous ne pouvez pas choisir la technique utilisée pour calculer l’importance des fonctions.
Les scores d’importance des fonctions peuvent être utiles pour obtenir une intuition sur les fonctions qui sont importantes pour la précision de votre modèle ; mais les valeurs réelles doivent être considérées comme des estimations.
Exemple¶
CALL model_binary!SHOW_FEATURE_IMPORTANCE();
+------+---------------------+---------------+---------------+
| RANK | FEATURE | SCORE | FEATURE_TYPE |
|------+---------------------+---------------+---------------|
| 1 | USER_RATING | 0.9295302013 | user_provided |
| 2 | USER_INTEREST_SCORE | 0.07046979866 | user_provided |
+------+---------------------+---------------+---------------+
Considérations relatives aux clients¶
L’entraînement et l’utilisation de modèles de classification entraînent des coûts de calcul et de stockage.
L’utilisation de n’importe quelles APIs de la fonction de classification (entraînement d’un modèle, prédiction à l’aide du modèle, récupération de métriques) nécessite un entrepôt actif. Les coûts de calcul liés à l’utilisation des fonctions de classification sont imputés à l’entrepôt. Consultez Comprendre le coût du calcul pour obtenir des informations générales sur les coûts de calcul de Snowflake.
Les coûts de stockage que vous supportez reflètent le stockage des instances du modèle créées au cours de l’étape d’entraînement. Pour voir les objets associés à votre instance de modèle, accédez aux vues Account Usage (par exemple, ACCOUNT_USAGE.TABLES et ACCOUNT_USAGE.STAGES). Les colonnes DATABASE et SCHEMA pour les objets du modèle de classification contiennent NULL, mais la colonne INSTANCE_ID est remplie pour les objets contenus par une instance de modèle. Ces objets sont entièrement gérés par l’instance de modèle, et vous ne pouvez pas y accéder ou les supprimer séparément. Pour réduire les coûts de stockage associés à vos modèles, supprimez les modèles inutilisés ou obsolètes.
Utilisation de la classification dans Snowpark¶
session.call n’est pas encore compatible avec les modèles de classification. Pour travailler avec un modèle de classification dans Snowpark, utilisez session.sql à la place, comme indiqué ici.
session.sql("CREATE SNOWFLAKE.ML.CLASSIFICATION model(...)").collect()
session.sql("SELECT model!PREDICT(...)").collect()