Klassifizierung (ML-gestützte Snowflake Cortex-Funktionen)¶
Bei der Klassifizierung werden Algorithmen des maschinellen Lernens eingesetzt, um Daten anhand der in Trainingsdaten erkannten Muster verschiedenen Klassen zuzuordnen. Binäre Klassifizierung (zwei Klassen) und Mehrklassen-Klassifizierung (mehr als zwei Klassen) werden unterstützt. Zu den üblichen Anwendungsfällen für die Klassifizierung gehören die Vorhersage der Kundenabwanderung (Customer Churn), die Erkennung von Kreditkartenbetrug und die Spam-Erkennung.
Bei der Klassifizierung wird ein Klassifizierungsmodellobjekt erstellt, dem eine Referenz auf die Trainingsdaten hinzugefügt wird. Das Modell wird an die bereitgestellten Trainingsdaten angepasst. Anschließend verwenden Sie das resultierende Klassifizierungsmodellobjekt auf Schemaebene, um neue Datenpunkte zu klassifizieren und die Genauigkeit des Modells durch seine Evaluation-APIs zu verstehen.
Wichtig
Rechtlicher Hinweis Diese ML-basierte Snowflake Cortex-Funktion wird durch Machine Learning-Technologie unterstützt. Die Machine Learning-Technologie und die bereitgestellten Ergebnisse können ungenau, unangemessen oder verzerrt sein. Entscheidungen auf der Grundlage von Ergebnissen aus Prozessen des maschinellen Lernens, einschließlich solcher, die in automatische Pipelines integriert sind, erfordern eine von Menschen durchgeführte Überwachung und Überprüfung, um sicherzustellen, dass die vom Modell generierten Inhalte korrekt sind. Die von ML-basierten Snowflake Cortex-Funktionen ausgeführten Abfragen werden wie alle anderen SQL-Abfragen behandelt, deren Metadaten untersucht werden können.
Metadaten. Wenn Sie ML-basierte Snowflake Cortex-Funktionen verwenden, protokolliert Snowflake allgemeine Fehlermeldungen, die von einer ML-Funktion zurückgegeben werden, zusätzlich zu dem, was in Metadatenfeldern erwähnt wird. Diese Fehlerprotokolle helfen uns, auftretende Probleme zu beheben und diese Funktionen zu verbessern, um unser Angebot für Sie zu optimieren.
Weitere Informationen dazu finden Sie unter Snowflake AI Trust and Safety FAQ.
Allgemeine Informationen zu Klassifizierungsmodellen¶
Die Snowflake Cortex Classification-Funktion wird von einem Gradient-Boosting-Modul unterstützt. Bei der binären Klassifizierung wird das Modell mit einer AUC-Verlustfunktion („Fläche unter der Kurve“ einer ROC-Kurve) trainiert. Bei der Mehrklassen-Klassifizierung wird das Modell mit einer Funktion für den logistischen Verlust trainiert.
Geeignete Trainingsdatensets für die Klassifizierung enthalten eine Zielspalte, die die beschriftete Klasse jedes Datenpunkts darstellt, und mindestens eine Merkmalsspalte.
Das Klassifizierungsmodell unterstützt numerische, boolesche und Zeichenfolgen-Datentypen für Merkmale (Features) und Bezeichnungen. Numerische Merkmale werden als kontinuierlich behandelt, während Zeichenfolgen- und boolesche Merkmale als kategorisch behandelt werden. Um numerische Merkmale als kategorisch zu behandeln, wandeln Sie sie in Zeichenfolgen um. Das Modell kann NULL-Werte in den Merkmalen verarbeiten. Die Kardinalität der Beschriftungsspalte label muss größer als 1 und kleiner als die Anzahl der Zeilen im Datenset sein.
Die Inferenzdaten müssen die gleichen Merkmalsnamen und -typen wie die Trainingsdaten haben. Es ist kein Fehler, wenn ein kategorisches Merkmal einen Wert hat, der im Trainingsdatenset nicht vorhanden ist. Spalten in den Inferenzdaten, die im Trainingsdatenset nicht vorhanden waren, werden ignoriert.
Klassifizierungsmodelle können hinsichtlich ihrer Vorhersagequalität bewertet werden. Im Evaluierungsprozess wird ein zusätzliches Modell auf den ursprünglichen Daten trainiert, wobei jedoch einige Datenpunkte zurückgehalten werden. Die zurückgehaltenen Datenpunkte werden dann für die Inferenz verwendet, und die vorhergesagten Klassen werden mit den tatsächlichen Klassen verglichen.
Aktuelle Einschränkungen¶
Die Trainings- und Inferenzddaten müssen numerisch, boolesch oder Zeichenfolgen sein. Andere Typen müssen in einen dieser Typen umgewandelt werden.
Sie können den Klassifizierungsalgorithmus weder auswählen noch ändern.
Die Modellparameter können nicht manuell festgelegt oder angepasst werden.
Das Training unterstützt maximal 1.000 Spalten und 10 Millionen Zeilen, obwohl es möglich ist, dass der Arbeitsspeicher bereits unterhalb dieser Grenze erschöpft ist. Versuchen Sie es in diesem Fall mit einem größeren Warehouse.
SNOWFLAKE.ML.CLASSIFICATION-Instanzen können nicht geklont werden. Wenn Sie eine Datenbank klonen oder replizieren, die ein Klassifizierungsmodell enthält, wird das Modell derzeit übersprungen.
Vorbereiten der Klassifizierung¶
Bevor Sie die Klassifizierung nutzen können, müssen Sie Folgendes tun:
Wählen Sie ein virtuelles Warehouse aus, in dem Sie Ihre Modelle trainieren und ausführen können.
Erteilen Sie die Berechtigungen, die zum Erstellen von Klassifizierungsmodellen erforderlich sind.
Sie können auch Ihren Suchpfad ändern, um das SNOWFLAKE.ML-Schema einzuschließen.
Auswählen eines virtuellen Warehouses¶
Ein virtuelles Snowflake-Warehouse stellt die Computeressourcen für Training und Nutzung der Machine Learning-Modelle für die Klassifizierung zur Verfügung. In diesem Abschnitt finden Sie allgemeine Hinweise zur Auswahl des optimalen Typs und der optimalen Größe des Warehouses für die Klassifizierung. Der Schwerpunkt liegt dabei auf dem Trainingsschritt, dem zeit- und speicherintensivsten Teil des Prozesses.
Wählen Sie den Warehouse-Typ auf Grundlage des Umfangs Ihrer Trainingsdaten aus. Standard-Warehouses unterliegen einer niedrigeren Snowpark-Speichergrenze und eignen sich besser für Trainingsjobs mit weniger Zeilen oder Merkmalen (Features). Wenn die Anzahl der Zeilen und Merkmale zunimmt, sollten Sie die Verwendung eines Snowpark-optimierten Warehouses in Betracht ziehen, um sicherzustellen, dass die Job erfolgreich ausgeführt werden können. Um optimale Performance zu erzielen, sollten Sie Ihre Modelle mit dedizierten Warehouses trainieren, in denen keine anderen Workloads parallel ausgeführt werden.
Anhand der nachstehenden Tabelle, die Ausführungszeiten von Trainingsläufen in Abhängigkeit von Datenumfang und Warehouse-Typ enthält, können Sie Typ und Größe des von Ihnen benötigten Warehouses ermitteln. Die Trainingszeiten können von den angegebenen Werten abweichen.
Typ/Größe des Warehouses |
Anzahl der Zeilen |
Anzahl der Spalten |
Trainingszeit (Sekunden) |
|---|---|---|---|
Standard-XS |
1000 |
10 |
8 |
Standard-XS |
10.000 |
100 |
27 |
Standard-XS |
100.000 |
1000 |
323 |
Standard-XL |
1000 |
10 |
8 |
Standard-XL |
10.000 |
100 |
15 |
Standard-XL |
100.000 |
1000 |
300 |
Snowpark-optimiertes XL |
1000 |
10 |
11 |
Snowpark-optimiertes XL |
10.000 |
100 |
15 |
Snowpark-optimiertes XL |
100.000 |
1000 |
375 |
Erteilen von Berechtigungen zum Erstellen von Klassifizierungsmodellen¶
Das Training eines Klassifizierungsmodells führt zu einem Objekt auf Schemaebene. Daher muss die Rolle, mit der Sie Modelle erstellen, über die Berechtigung CREATE SNOWFLAKE.ML.CLASSIFICATION für das Schema verfügen, in dem das Modell erstellt wird, damit das Modell dort gespeichert werden kann. Diese Berechtigung ist vergleichbar mit anderen Schemaberechtigungen wie CREATE TABLE oder CREATE VIEW.
Snowflake empfiehlt, eine Rolle mit dem Namen analyst zu erstellen, die von Personen verwendet wird, deren Aufgabe das Erstellen von Klassifizierungsmodellen ist.
Im folgenden Beispiel ist die Rolle admin der Eigentümer des Schemas admin_db.admin_schema. Die Rolle analyst muss in der Lage sein, Modelle in diesem Schema zu erstellen.
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;
Um dieses Schema verwenden zu können, wird einem Benutzer die Rolle analyst zugewiesen:
USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;
Wenn die Rolle analyst über die Berechtigung CREATE SCHEMA in der Datenbank analyst_db verfügt, kann die Rolle ein neues Schema analyst_db.analyst_schema erstellen und in diesem Schema Klassifizierungsmodelle erstellen:
USE ROLE analyst;
CREATE SCHEMA analyst_db.analyst_schema;
USE SCHEMA analyst_db.analyst_schema;
Um einer Rolle die Berechtigung zum Erstellen eines Modells für das Schema zu entziehen, verwenden Sie REVOKE <Berechtigungen>:
REVOKE CREATE SNOWFLAKE.ML.CLASSIFICATION ON SCHEMA admin_db.admin_schema FROM ROLE analyst;
Trainieren, Verwenden, Anzeigen, Löschen und Aktualisieren von Modellen¶
Bemerkung
SNOWFLAKE.ML.CLASSIFICATION wird mit eingeschränkten Berechtigungen ausgeführt, sodass der Konstruktor standardmäßig keinen Zugriff auf Ihre Daten hat. Sie müssen daher Tabellen und Ansichten als Referenzen übergeben, mit denen auch die Berechtigungen des Aufrufers weitergeben werden. Sie können anstelle eines Verweises auf eine Tabelle oder Ansicht auch eine Abfragereferenz angeben.
Weitere Informationen zu Training, Inferenz und Evaluations-APIs finden Sie in der CLASSIFICATION-Referenz.
Verwenden Sie CREATE SNOWFLAKE.ML.CLASSIFICATION, um ein Modell zu erstellen und zu trainieren.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION <model_name>(...);
Verwenden Sie die PREDICT-Methode des Modells, um Inferenzen (Vorhersagen) für ein Datenset auszuführen.
SELECT <model_name>!PREDICT(...);
Um ein Modell auszuwerten, rufen Sie die bereitgestellten Evaluationsmethoden auf.
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();
Um die Rangfolge der Feature Importance (Merkmalsbedeutung) eines Modells anzuzeigen, rufen Sie dessen SHOW_FEATURE_IMPORTANCE-Methode auf.
CALL <model_name>!SHOW_FEATURE_IMPORTANCE();
Um die während des Trainings generierten Protokolleinträge zu untersuchen, verwenden Sie die Methode SHOW_TRAINING_LOGS.
CALL <model_name>!SHOW_TRAINING_LOGS();
Tipp
Beispiele für die Verwendung dieser Methoden finden Sie unter Beispiele.
Um alle Klassifizierungsmodelle anzuzeigen, verwenden Sie den Befehl SHOW.
SHOW SNOWFLAKE.ML.CLASSIFICATION;
Um ein Klassifizierungsmodell zu löschen, verwenden Sie den DROP-Befehl.
DROP SNOWFLAKE.ML.CLASSIFICATION <model_name>;
Modelle sind unveränderlich und können nicht direkt aktualisiert werden. Um ein Modell zu aktualisieren, müssen Sie das bestehende Modell löschen und ein neues Modell trainieren. Für diesen Zweck ist die CREATE OR REPLACE-Variante des CREATE-Befehls hilfreich.
Beispiele¶
Einrichten der Daten für die Beispiele¶
In den Beispielen unter diesem Thema werden zwei Tabellen verwendet. Die erste Tabelle namens training_purchase_data hat zwei Merkmalsspalten: eine binäre Beschriftungsspalte und eine Mehrklassen-Beschriftungsspalte. Die zweite Tabelle namens prediction_purchase_data hat zwei Merkmalsspalten. Verwenden Sie den nachstehenden SQL-Code, um diese Tabellen zu erstellen.
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))
);
Trainieren und Verwenden eines binären Klassifikators¶
Erstellen Sie zuerst eine Ansicht mit Binärdaten für das Training.
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;
Die SELECT-Anweisung gibt Ergebnisse in der folgenden Form zurück.
+---------------------+-------------+-------+
| USER_INTEREST_SCORE | USER_RATING | LABEL |
|---------------------+-------------+-------|
| 4 | 0 | False |
| 3 | 3 | False |
| 0 | 0 | False |
| 3 | 0 | False |
| 0 | 2 | False |
+---------------------+-------------+-------+
Erstellen Sie anhand dieser Ansicht ein binäres Klassifizierungsmodell, und trainieren Sie es.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_binary(
INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
TARGET_COLNAME => 'label'
);
Nachdem Sie das Modell erstellt haben, verwenden Sie dessen PREDICT-Methode, um Bezeichnungen (Labels) für die nicht beschrifteten Kaufdaten abzuleiten. Sie können die Funktion OBJECT_CONSTRUCT verwenden, um Schlüssel-Wert-Paare von Merkmalen für das Argument INPUT_DATA zu erstellen.
SELECT model_binary!PREDICT(INPUT_DATA => object_construct(*))
as prediction from prediction_purchase_data;
Das Modell gibt eine Ausgabe im folgenden Format zurück. Das Vorhersageobjekt enthält die vorhergesagten Wahrscheinlichkeiten für jede Klasse sowie die vorhergesagte Klasse auf der Grundlage der maximalen vorhergesagten Wahrscheinlichkeit. Die Vorhersagen werden in der gleichen Reihenfolge zurückgegeben, in der die ursprünglichen Merkmale bereitgestellt wurden.
+--------------------------------------------------+
| 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 |
| } |
| } |
+--------------------------------------------------+
Um Merkmale mit Vorhersagen zu verknüpfen, verwenden Sie eine Abfrage wie die folgende.
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 |
| | | } |
| | | } |
+---------------------+-------------+----------------------------+
Trainieren und Verwenden eines Mehrklassen-Klassifikators¶
Erstellen Sie eine Ansicht mit Binärdaten für das Training.
CREATE OR REPLACE multiclass_classification_view AS
SELECT uuid, user_interest_score, user_rating, class
FROM training_purchase_data;
SELECT * FROM multiclass_classification_view;
Diese SELECT-Anweisung gibt Ergebnisse in der folgenden Form zurück.
+---------------------+-------------+-----------------+
| 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 |
+---------------------+-------------+-----------------+
Erstellen Sie nun aus dieser Ansicht ein Mehrklassen-Klassifizierungsmodell.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_multiclass(
INPUT_DATA => SYSTEM$REFERENCE('view', 'multiclass_classification_view'),
TARGET_COLNAME => 'class'
);
Nachdem Sie das Modell erstellt haben, verwenden Sie dessen PREDICT-Methode, um Bezeichnungen (Labels) für die nicht beschrifteten Kaufdaten abzuleiten. Verwenden Sie die Funktion OBJECT_CONSTRUCT, um automatisch Schlüssel-Wert-Paare für das Argument INPUT_DATA zu erstellen.
SELECT *, model_multiclass!PREDICT(
INPUT_DATA => object_construct(*))
as predictions from prediction_purchase_data;
Das Modell gibt eine Ausgabe im folgenden Format zurück. Das Vorhersageobjekt enthält die vorhergesagten Wahrscheinlichkeiten für jede Klasse sowie die vorhergesagte Klasse auf der Grundlage der maximalen vorhergesagten Wahrscheinlichkeit. Die Vorhersagen werden in der gleichen Reihenfolge zurückgegeben wie die ursprünglich bereitgestellten Merkmale und können in derselben Abfrage verknüpft werden.
+---------------------+-------------+--------------------------------------+
| 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 |
| | | } |
| | | } |
+---------------------+-------------+--------------------------------------+
Speichern von Ergebnissen in einer Tabelle und Untersuchen von Vorhersagen¶
Die Ergebnisse der Aufrufe der PREDICT-Methode der Modelle können direkt in eine Abfrage eingelesen werden, aber das Speichern der Ergebnisse in einer Tabelle ermöglicht eine bequeme Untersuchung der Vorhersagen.
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;
Die Schlüssel- und Vorhersagespalten können dann in weiteren Abfragen untersucht werden. Die folgende Abfrage untersucht Vorhersagen.
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;
Die obige Abfrage gibt Ergebnisse in der folgenden Form zurück.
+-------------------+------------------------------------+----------------------------------+----------------------------+
| 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 | | |
| | } | | |
+-------------------+------------------------------------+----------------------------------+----------------------------+
Verwenden von Evaluationsfunktionen¶
Die Evaluation ist standardmäßig auf allen Instanzen aktiviert. Die Evaluation kann jedoch manuell über das CONFIG_OBJECT-Argument aktiviert oder deaktiviert werden. Wenn für den Schlüssel „evaluate“ der Wert FALSE angegeben wird, ist die Evaluation nicht verfügbar.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model(
INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
TARGET_COLNAME => 'label',
CONFIG_OBJECT => {'evaluate': TRUE}
);
Wenn die Evaluation aktiviert ist, können mithilfe der hier gezeigten Evaluations-APIs Bewertungskennzahlen ermittelt werden.
CALL model!SHOW_EVALUATION_METRICS();
CALL model!SHOW_GLOBAL_EVALUATION_METRICS();
CALL model!SHOW_THRESHOLD_METRICS();
CALL model!SHOW_CONFUSION_MATRIX();
Eine Beschreibung der zurückgegebenen Kennzahlen finden Sie unter Erläuterungen zu Bewertungskennzahlen.
Modellrollen und Nutzungsberechtigungen¶
Jede Klassifizierungsmodellinstanz umfasst zwei Modellrollen: mladmin und mlconsumer. Diese Rollen sind auf das Modell selbst beschränkt: model!mladmin und model!mlconsumer. Der Eigentümer des Modellobjekts (ursprünglich sein Ersteller) erhält automatisch die Rollen model!mladmin und model!mlconsumer, die er Kontorollen und Datenbankrollen zuweisen kann.
Die Rolle mladmin erlaubt die Nutzung aller APIs, die vom Modellobjekt aus aufgerufen werden können, einschließlich, aber nicht beschränkt auf Vorhersagemethoden und Evaluationsmethoden. Die Rolle mlconsumer erlaubt nur die Nutzung der Vorhersage-APIs, nicht aber anderer Untersuchungs-APIs.
Das folgende SQL-Beispiel veranschaulicht das Zuweisen von Klassifizierungsmodellrollen zu andere Rollen. Die Rolle r1 kann ein Klassifizierungsmodell erstellen und weist der Rolle r2 die Berechtigung mlconsumer zu, sodass r2 die PREDICT-Methode dieses Modells aufrufen kann. Dann weist r1 die Rolle mladmin einer Rolle r3 zu, sodass r3 alle Methoden des Modells aufrufen kann.
Zuerst erstellt die Rolle r1 ein Modellobjekt, wodurch r1 zum Eigentümer des Modells model wird.
USE ROLE r1;
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model(
INPUT_DATA => SYSTEM$REFERENCE('TABLE', 'test_classification_dataset'),
TARGET_COLNAME => 'LABEL'
);
Anhand der folgenden Anweisungen können Sie sehen, dass die Rolle r2 die PREDICT-Methode des Modells nicht aufrufen kann.
USE ROLE r2;
SELECT model!PREDICT(1); -- privilege error
Als Nächstes weist r1 der Rolle r2 die Instanzrolle mlocnosumer zu, wodurch r2 die PREDICT-Methode des Modells aufrufen kann.
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')
);
Auf ähnliche Weise benötigt die Rolle r3 die Instanzrolle mladmin, um die Bewertungskennzahlen des Modells anzeigen zu können.
USE ROLE r3;
CALL model!SHOW_EVALUATION_METRICS(); -- privilege error
Die Rolle r1 weist r3 die benötigte Rolle zu, sodass r3 nun die SHOW_EVALUATION_METRICS-Methode des Modells aufrufen kann.
USE ROLE r1;
GRANT SNOWFLAKE.ML.CLASSIFICATION ROLE model!mladmin TO ROLE r3;
USE ROLE r3;
CALL model!SHOW_EVALUATION_METRICS();
Sie können die Berechtigungen wie folgt entziehen.
USE ROLE r1;
REVOKE SNOWFLAKE.ML.CLASSIFICATION ROLE model!mlconsumer FROM ROLE r2;
REVOKE SNOWFLAKE.ML.CLASSIFICATION ROLE model!mladmin FROM ROLE r3;
Verwenden Sie die folgenden Befehle, um zu ermitteln, welche Kontorollen und Datenbankrollen jeder dieser Instanzrollen zugewiesen wurden.
SHOW GRANTS TO SNOWFLAKE.ML.CLASSIFICATION ROLE <model_name>!mladmin;
SHOW GRANTS TO SNOWFLAKE.ML.CLASSIFICATION ROLE <model_name>!mlconsumer;
Erläuterungen zu Bewertungskennzahlen¶
Kennzahlen messen, wie genau ein Modell neue Daten vorhersagt. Bei der Snowflake-Klassifizierung werden die Modelle derzeit durch die Auswahl einer Zufallsstichprobe aus dem gesamten Datenset evaluiert. Ein neues Modell wird ohne diese Zeilen trainiert, und dann werden die Zeilen als Inferenz-Input verwendet. Der Anteil der Zufallsstichprobe kann mit dem Schlüssel test_fraction im Objekt EVALUATION_CONFIG konfiguriert werden.
Kennzahlen in show_evaluation_metrics¶
show_evaluation_metrics berechnet für jede Klasse die folgenden Werte. Siehe SHOW_EVALUATION_METRICS.
Positive Instanzen: Dateninstanzen (Zeilen), die zu der Klasse gehören, die von Interesse ist, oder zu der Klasse, die vorhergesagt wird.
Negative Instanzen: Instanzen von Daten (Zeilen), die nicht zu der interessierenden Klasse gehören oder das Gegenteil von dem sind, was vorhergesagt wird.
True Positives (TP): Korrekte Vorhersagen von positiven Instanzen.
True Negatives (TN): Korrekte Vorhersagen von negativen Instanzen.
False Positive (FP): Falsche Vorhersagen von positiven Instanzen.
False Negatives (FN): Falsche Vorhersagen von negativen Instanzen.
Unter Verwendung der oben genannten Werte werden für jede Klasse die folgenden Kennzahlen angegeben. Bei jeder Kennzahl bedeutet ein höherer Wert ein aussagekräftigeres Modell.
Precision: Das Verhältnis der True-Positive-Instanzen zur Gesamtzahl der vorhergesagten positiven Instanzen. Die Kennzahl misst, wie viele der vorhergesagten positiven Instanzen tatsächlich positiv sind.
Recall (Sensitivität): Das Verhältnis von True-Positive-Instanzen zur Gesamtzahl der tatsächlich positiven Instanzen. Die Kennzahl misst, wie viele der tatsächlich positiven Instanzen korrekt vorhergesagt wurden.
F1-Maß: Das harmonische Mittel aus „Precision“ und „Recall“. Diese Kennzahl bietet ein Gleichgewicht zwischen „Precision“ und „Recall“, insbesondere bei einer ungleichmäßigen Klassenverteilung.
Kennzahlen in show_global_evaluation_metrics¶
show_global_evaluation_metrics berechnet die (globalen) Gesamtkennzahlen für alle vom Modell vorhergesagten Klassen, indem für die von show_evaluation_metrics berechneten Kennzahlen pro Klasse ein Mittelwert gebildet wird. Siehe SHOW_GLOBAL_EVALUATION_METRICS.
Derzeit werden für die Kennzahlen „Precision“, „Recall“, „F1“ und AUC die Mittelwerte macro und weighted gebildet.
Der logistische Verlust (LogLoss) wird für das Modell als Ganzes berechnet. Das Ziel der Vorhersage ist es, die Verlustfunktion zu minimieren.
Kennzahlen in show_threshold_metrics¶
show_threshold_metrics liefert für jede Klasse Rohzählungen und Kennzahlen für einen bestimmten Schwellenwert. Diese Werte können verwendet werden, um ROC- und PR-Kurven zu erstellen oder Schwellenwerte anzupassen. Der Schwellenwert jeder spezifischen Klasse variiert zwischen 0 und 1; es wird eine Vorhersagewahrscheinlichkeit zugewiesen. Siehe SHOW_THRESHOLD_METRICS.
Die Stichprobe wird als zu einer Klasse gehörig eingestuft, wenn die vorhergesagte Wahrscheinlichkeit einer Zugehörigkeit zu dieser Klasse den angegebenen Schwellenwert überschreitet. Die Werte für True/False Positives/Negatives werden berechnet, wobei die Negative-Klasse alle Instanzen umfasst, die nicht zu der betrachteten Klasse gehört. Anschließend werden die folgenden Kennzahlen berechnet.
True Positive Rate (TPR): Der Anteil der tatsächlich positiven Instanzen, die das Modell korrekt identifiziert (entspricht „Recall“).
False Positive Rate (FPR): Der Anteil der tatsächlich negativen Instanzen, die fälschlicherweise als positiv vorhergesagt wurden.
Accuracy: Die Genauigkeit, die sich aus dem Verhältnis von korrekten Vorhersagen (sowohl True Positives als auch True Negatives) zur Gesamtzahl der Vorhersagen ergibt und ein Gesamtmaß für die Leistung des Modells ist. In Fällen mit einem Ungleichgewicht kann diese Kennzahl irreführend sein.
Support: Die Anzahl der tatsächlichen Vorkommen einer Klasse in dem angegebenen Datenset. Höhere Support-Werte weisen auf eine größere Repräsentation einer Klasse im Datenset hin. Der Support-Wert ist selbst keine Kennzahl des Modells, sondern eine Eigenschaft des Datensets.
Wahrheitsmatrix (Konfusionsmatrix) in show_confusion_matrix¶
Die Wahrheitsmatrix ist eine Tabelle, die zur Bewertung der Leistung eines Modells verwendet wird, indem die vorhergesagten und tatsächlichen Werte verglichen werden und die Fähigkeit des Modells, positive und negative Instanzen korrekt zu identifizieren, bewertet wird. Ziel ist es, die Anzahl der Instanzen auf der Diagonalen der Matrix zu maximieren und die Anzahl der Instanzen außerhalb der Diagonalen zu minimieren. Siehe SHOW_CONFUSION_MATRICX.
Sie können die Wahrheitsmatrix in Snowsight wie folgt visualisieren.
CALL model_binary!SHOW_CONFUSION_MATRIX();
Die Ergebnisse sehen wie folgt aus.
+--------------+--------------+-----------------+-------+------+
| 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 |
+--------------+--------------+-----------------+-------+------+
Um die Wahrheitsmatrix zu visualisieren, klicken Sie auf Chart, dann auf Chart Type, und dann auf Heatgrid. Wählen Sie unter „Data“ für Cell values die Option NONE, für Rows die Option PREDICTED_CLASS und für Columns die Option ACTUAL_CLASS aus. Das Ergebnis sieht ähnlich aus wie in der folgenden Abbildung.
Erläuterungen zur Feature Importance¶
Ein Klassifizierungsmodell kann die relative Bedeutung aller im Modell verwendeten Features (Merkmale) erklären. Diese Informationen sind nützlich, um zu verstehen, welche Faktoren Ihre Daten wirklich beeinflussen.
Die Methode SHOW_FEATURE_IMPORTANCE zählt, wie oft die Modellstrukturbäume die jeweiligen Features für eine Entscheidung verwendet haben. Diese Feature Importance-Bewertungen werden dann auf Werte zwischen 0 und 1 normalisiert, sodass sie in der Summe 1 ergeben. Die sich daraus resultierenden Punktzahlen ergeben eine ungefähre Rangliste der Features in Ihrem trainierten Modell.
Features, deren Punktzahlen nahe beieinander liegen, sind ähnlich wichtig. Die Verwendung mehrerer Features, die einander sehr ähnlich sind, kann dazu führen, dass die Importance-Bewertung dieser Features sinkt.
Einschränkungen¶
Sie können das zur Berechnung der Feature Importance verwendete Verfahren nicht frei wählen.
Die Feature Importance-Bewertung kann hilfreich sein, um ein Gefühl dafür zu bekommen, welche Features für die Genauigkeit Ihres Modells wichtig sind, aber die tatsächlichen Werte müssen als Schätzung angesehen werden.
Beispiel¶
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 |
+------+---------------------+---------------+---------------+
Hinweise zu Kosten¶
Das Trainieren und Verwenden von Klassifizierungsmodellen verursacht Compute- und Speicherkosten.
Für die Nutzung beliebiger APIs aus dem Klassifizierungs-Feature (Trainieren eines Modells, Vorhersagen mit dem Modell, Abrufen von Kennzahlen) ist ein aktives Warehouse erforderlich. Die Computekosten für die Verwendung von Klassifizierungsfunktionen werden über das Warehouse abgerechnet. Allgemeine Informationen zu den Snowflake-Computekosten finden Sie unter Erläuterungen zu den Computekosten.
Die Speicherkosten entstehen bei der Speicherung des Klassifizierungsmodells, das während des Trainingsprozesses erstellt wurde. Um die mit Ihrer Modellinstanz verknüpften Objekte anzuzeigen, navigieren Sie zu den Account Usage-Ansichten (z. B. ACCOUNT_USAGE.TABLES und ACCOUNT_USAGE.STAGES). Die Spalten DATABASE und SCHEMA für Klassifizierungsmodellobjekte enthalten NULL, aber die Spalte INSTANCE_ID ist bei Objekten, die in einer Modellinstanz enthalten sind, ausgefüllt. Diese Objekte werden vollständig von der Modellinstanz verwaltet. Sie können nicht separat auf sie zugreifen, und sie können sie auch nicht löschen. Um die mit Ihren Modellen verbundenen Speicherkosten zu reduzieren, löschen Sie unbenutzte oder veraltete Modelle.
Verwenden der Klassifizierung in Snowpark¶
session.call ist noch nicht mit Klassifizierungsmodellen kompatibel. Um ein Klassifizierungsmodell in Snowpark zu nutzen, verwenden Sie stattdessen session.sql, wie hier gezeigt.
session.sql("CREATE SNOWFLAKE.ML.CLASSIFICATION model(...)").collect()
session.sql("SELECT model!PREDICT(...)").collect()