Classificação (funções baseadas em Snowflake Cortex ML)¶
A classificação usa algoritmos de machine learning para classificar os dados em diferentes classes usando padrões detectados nos dados de treinamento. Classificação binária (duas classes) e classificação multiclasse (mais de duas classes) são suportadas. Os casos de uso comuns de classificação incluem previsão de rotatividade de clientes, detecção de fraude de cartão de crédito e detecção de spam.
A classificação envolve a criação de um objeto de modelo de classificação, passando uma referência aos dados de treinamento. O modelo é ajustado aos dados de treinamento fornecidos. Em seguida, você usa o objeto de modelo de classificação em nível de esquema resultante para classificar novos pontos de dados e entender a precisão do modelo por meio das APIs de avaliação.
Importante
Aviso legal. Esta função baseada em ML do Snowflake Cortex é alimentada por tecnologia de aprendizado de máquina. A tecnologia de aprendizado de máquina e os resultados fornecidos podem ser imprecisos, inadequados ou tendenciosos. As decisões baseadas em resultados de aprendizado de máquina, incluindo aquelas incorporadas em pipelines automáticos, devem ter supervisão humana e processos de revisão para garantir que o conteúdo gerado pelo modelo seja preciso. As consultas de função baseadas em ML do Snowflake Cortex serão tratadas como qualquer outra consulta SQL e podem ser consideradas metadados.
Metadados. Quando você usa funções baseadas em ML do Snowflake Cortex, o Snowflake registra mensagens de erro genéricas retornadas por uma função ML, além do que é mencionado em campos de metadados. Esses logs de erros nos ajudam a solucionar problemas que surgem e a melhorar essas funções para melhor atender você.
Para obter mais informações, consulte FAQ sobre confiança e segurança do Snowflake AI.
Sobre o modelo de classificação¶
A função de classificação do Snowflake Cortex é baseada em uma máquina de gradient boosting. Para a classificação binária, o modelo é treinado usando uma função de perda de área sob a curva. Para a classificação multiclasse, o modelo é treinado usando uma função de perda logística.
Conjuntos de dados de treinamento adequados para uso com classificação incluem uma coluna de destino representando a classe rotulada de cada ponto de dados e pelo menos uma coluna de recurso.
O modelo de classificação oferece suporte a tipos de dados numéricos, booleanos e de cadeia de caracteres para recursos e rótulos. Os recursos numéricos são tratados como contínuos, enquanto os recursos de cadeia de caracteres e booleanos são tratados como categóricos. Para tratar recursos numéricos como categóricos, converta-os em cadeias de caracteres. O modelo pode lidar com valores NULL em recursos. A cardinalidade da coluna do rótulo deve ser maior que 1 e menor que o número de linhas no conjunto de dados.
Os dados de inferência devem ter os mesmos nomes e tipos de recursos que os dados de treinamento. Não é um erro um recurso categórico ter um valor que não está presente no conjunto de dados de treinamento. As colunas nos dados de inferência que não estavam presentes no conjunto de dados de treinamento serão ignoradas.
Os modelos de classificação podem ser avaliados quanto à qualidade da previsão. No processo de avaliação, um modelo adicional é treinado nos dados originais, mas com alguns pontos de dados retidos. Os pontos de dados retidos são então usados para inferência e as classes previstas são comparadas com as classes reais.
Limitações atuais¶
Os dados de treinamento e inferência devem ser numéricos, booleanos ou cadeia de caracteres. Outros tipos devem ser convertidos em um desses tipos.
Você não pode escolher ou modificar o algoritmo de classificação.
Os parâmetros do modelo não podem ser especificados ou ajustados manualmente.
O treinamento oferece suporte a, no máximo, 1.000 colunas e 10 milhões de linhas, embora seja possível ficar sem memória abaixo desse limite. Neste caso, experimente um warehouse maior.
As instâncias SNOWFLAKE.ML.CLASSIFICATION não podem ser clonadas. Quando você clona ou replica um banco de dados que contém um modelo de classificação, o modelo é ignorado no momento.
Preparação para classificação¶
Antes de poder usar a classificação, você deve:
Selecionar um warehouse virtual para treinar e executar seus modelos.
Conceder os privilégios necessários para criar modelos de classificação.
Você também pode modificar seu caminho de pesquisa para incluir o esquema SNOWFLAKE.ML.
Seleção de um warehouse virtual¶
Um warehouse virtual do Snowflake fornece os recursos de computação para treinamento e uso dos modelos de machine learning de classificação. Esta seção fornece orientações gerais sobre como selecionar o melhor tamanho e tipo de warehouse para a classificação, com foco na etapa de treinamento, a parte mais demorada e que consome muita memória do processo.
Você deve escolher o tipo de warehouse com base no tamanho dos seus dados de treinamento. Os warehouses padrão estão sujeitos a um limite de memória menor do Snowpark e são mais apropriados para tarefas de treinamento com menos linhas ou recursos. Conforme o número de linhas e recursos aumenta, considere usar um warehouse otimizado para Snowpark para garantir que as tarefas possam ser executadas com êxito. Para obter o melhor desempenho, treine seus modelos usando um warehouse dedicado sem outras cargas de trabalho simultâneas.
Use a tabela abaixo, que fornece tempos de treinamento para diversos tamanhos de dados e tipos de warehouse, para entender o tipo e tamanho de warehouse que você precisa. Os tempos de treinamento podem variar dos valores fornecidos.
Tipo e tamanho do warehouse |
Número de linhas |
Numero de colunas |
Tempo de treinamento (segundos) |
|---|---|---|---|
Padrão XS |
1000 |
10 |
8 |
Padrão XS |
10,000 |
100 |
27 |
Padrão XS |
100,000 |
1000 |
323 |
Padrão XL |
1000 |
10 |
8 |
Padrão XL |
10,000 |
100 |
15 |
Padrão XL |
100,000 |
1000 |
300 |
XL otimizado para Snowpark |
1000 |
10 |
11 |
XL otimizado para Snowpark |
10,000 |
100 |
15 |
XL otimizado para Snowpark |
100,000 |
1000 |
375 |
Concessão de privilégios para criar modelos de classificação¶
O treinamento de um modelo de classificação resulta em um objeto no nível do esquema. Portanto, a função que você usa para criar modelos deve ter o privilégio CREATE SNOWFLAKE.ML.CLASSIFICATION no esquema onde o modelo será criado, permitindo que o modelo seja armazenado lá. Este privilégio é semelhante a outros privilégios de esquema como CREATE TABLE ou CREATE VIEW.
Snowflake recomenda que você crie uma função chamada analyst para ser usada por pessoas que precisam criar modelos de classificação.
No exemplo a seguir, a função admin é a proprietária do esquema admin_db.admin_schema. A função analyst precisa criar modelos neste esquema.
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;
Para usar este esquema, um usuário assume a função analyst:
USE ROLE analyst;
USE SCHEMA admin_db.admin_schema;
Se a função analyst tiver privilégios CREATE SCHEMA no banco de dados analyst_db, a função poderá criar um novo esquema analyst_db.analyst_schema e criar modelos de classificação nesse esquema:
USE ROLE analyst;
CREATE SCHEMA analyst_db.analyst_schema;
USE SCHEMA analyst_db.analyst_schema;
Para revogar o privilégio de criação de modelo de uma função no esquema, use REVOKE <privilégios>:
REVOKE CREATE SNOWFLAKE.ML.CLASSIFICATION ON SCHEMA admin_db.admin_schema FROM ROLE analyst;
Treinamento, uso, visualização, exclusão e atualização de modelos¶
Nota
SNOWFLAKE.ML.CLASSIFICATION é executado com privilégios limitados, portanto, por padrão, ele não tem acesso aos seus dados. Você deve, portanto, passar tabelas e exibições como referências, que transmitem os privilégios do chamador. Você também pode fornecer uma referência de consulta em vez de uma referência a uma tabela ou exibição.
Consulte a referência de CLASSIFICATION para obter informações sobre treinamento, inferência e APIs de avaliação.
Use CREATE SNOWFLAKE.ML.CLASSIFICATION para criar e treinar um modelo.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION <model_name>(...);
Para executar a inferência (previsão) em um conjunto de dados, use o método PREDICT do modelo.
SELECT <model_name>!PREDICT(...);
Para avaliar um modelo, chame os métodos de avaliação fornecidos.
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();
Para mostrar a classificação de importância do recurso de um modelo, chame seu método SHOW_FEATURE_IMPORTANCE.
CALL <model_name>!SHOW_FEATURE_IMPORTANCE();
Para investigar os logs gerados durante o treinamento, use o método SHOW_TRAINING_LOGS.
CALL <model_name>!SHOW_TRAINING_LOGS();
Dica
Para obter exemplos de uso desses métodos, consulte os exemplos.
Para visualizar todos os modelos de classificação, use o comando SHOW.
SHOW SNOWFLAKE.ML.CLASSIFICATION;
Para excluir um modelo de classificação, use o comando DROP.
DROP SNOWFLAKE.ML.CLASSIFICATION <model_name>;
Os modelos são imutáveis e não podem ser atualizados no local. Para atualizar um modelo, descarte o modelo existente e treine um novo. A variante CREATE OR REPLACE do comando CREATE é útil para esta finalidade.
Exemplos¶
Configuração dos dados para os exemplos¶
Os exemplos neste tópico usam duas tabelas. A primeira tabela, training_purchase_data, possui duas colunas de recursos: uma coluna de rótulo binário e uma coluna de rótulo multiclasse. A segunda tabela é chamada prediction_purchase_data e possui duas colunas de recursos. Use SQL abaixo para criar essas tabelas.
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))
);
Treinamento e uso de um classificador binário¶
Primeiro, crie uma exibição contendo dados binários para treinamento.
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;
A instrução SELECT retorna resultados no seguinte formato.
+---------------------+-------------+-------+
| USER_INTEREST_SCORE | USER_RATING | LABEL |
|---------------------+-------------+-------|
| 4 | 0 | False |
| 3 | 3 | False |
| 0 | 0 | False |
| 3 | 0 | False |
| 0 | 2 | False |
+---------------------+-------------+-------+
Usando esta exibição, crie e treine um modelo de classificação binária.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_binary(
INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
TARGET_COLNAME => 'label'
);
Depois de criar o modelo, use o método PREDICT para inferir rótulos para os dados de compra não rotulados. Você pode usar a função OBJECT_CONSTRUCT para criar pares chave-valor de recursos para o argumento INPUT_DATA.
SELECT model_binary!PREDICT(INPUT_DATA => object_construct(*))
as prediction from prediction_purchase_data;
O modelo retorna a saída no seguinte formato. O objeto de previsão inclui probabilidades previstas para cada classe e a classe prevista com base na probabilidade máxima prevista. As previsões são retornadas na mesma ordem em que os recursos originais foram fornecidos.
+--------------------------------------------------+
| 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 |
| } |
| } |
+--------------------------------------------------+
Para associar recursos a previsões, use uma consulta como a seguinte.
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 |
| | | } |
| | | } |
+---------------------+-------------+----------------------------+
Treinamento e uso de um classificador multiclasse¶
Crie uma exibição contendo dados binários para treinamento.
CREATE OR REPLACE multiclass_classification_view AS
SELECT uuid, user_interest_score, user_rating, class
FROM training_purchase_data;
SELECT * FROM multiclass_classification_view;
Esta instrução SELECT retorna resultados no seguinte formato.
+---------------------+-------------+-----------------+
| 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 |
+---------------------+-------------+-----------------+
Agora crie um modelo de classificação multiclasse a partir desta exibição.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model_multiclass(
INPUT_DATA => SYSTEM$REFERENCE('view', 'multiclass_classification_view'),
TARGET_COLNAME => 'class'
);
Depois de criar o modelo, use o método PREDICT para inferir rótulos para os dados de compra não rotulados. Use a função OBJECT_CONSTRUCT para criar automaticamente pares chave-valor para o argumento INPUT_DATA.
SELECT *, model_multiclass!PREDICT(
INPUT_DATA => object_construct(*))
as predictions from prediction_purchase_data;
O modelo retorna a saída no seguinte formato. O objeto de previsão inclui probabilidades previstas para cada classe e a classe prevista com base na probabilidade máxima prevista. As previsões são retornadas na mesma ordem que os recursos originais fornecidos e podem ser unidas na mesma consulta.
+---------------------+-------------+--------------------------------------+
| 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 |
| | | } |
| | | } |
+---------------------+-------------+--------------------------------------+
Como salvar resultados em uma tabela e explorar previsões¶
Os resultados das chamadas ao método PREDICT dos modelos podem ser lidos diretamente em uma consulta, mas salvar os resultados em uma tabela permite explorar previsões de maneira conveniente.
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;
As colunas de chave e previsão podem então ser exploradas em consultas posteriores. A consulta abaixo explora previsões.
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;
A consulta acima retorna resultados no seguinte formato.
+-------------------+------------------------------------+----------------------------------+----------------------------+
| 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 | | |
| | } | | |
+-------------------+------------------------------------+----------------------------------+----------------------------+
Uso de funções de avaliação¶
Por padrão, a avaliação está habilitada em todas as instâncias. No entanto, a avaliação pode ser habilitada ou desabilitada manualmente usando o argumento do objeto de configuração. Se a chave ‘avaliar’ for especificada com o valor FALSE, a avaliação não estará disponível.
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model(
INPUT_DATA => SYSTEM$REFERENCE('view', 'binary_classification_view'),
TARGET_COLNAME => 'label',
CONFIG_OBJECT => {'evaluate': TRUE}
);
Quando a avaliação está habilitada, as métricas de avaliação podem ser obtidas usando as APIs de avaliação mostradas aqui.
CALL model!SHOW_EVALUATION_METRICS();
CALL model!SHOW_GLOBAL_EVALUATION_METRICS();
CALL model!SHOW_THRESHOLD_METRICS();
CALL model!SHOW_CONFUSION_MATRIX();
Consulte Como entender as métricas de avaliação para obter uma descrição das métricas retornadas.
Funções de modelo e privilégios de uso¶
Cada instância do modelo de classificação inclui duas funções de modelo, mladmin e mlconsumer. Essas funções têm como escopo o próprio modelo: model!mladmin e model!mlconsumer. O proprietário do objeto de modelo (inicialmente, seu criador) recebe automaticamente as funções model!mladmin e model!mlconsumer e pode conceder essas funções a funções de conta e de banco de dados.
A função mladmin permite o uso de todas as APIs invocáveis do objeto modelo, incluindo, entre outros, métodos de previsão e métodos de avaliação. A função mlconsumer permite o uso apenas nas APIs de previsão, e não em outras APIs exploratórias.
O exemplo de SQL a seguir ilustra a concessão de funções de modelo de classificação a outras funções. A função r1 pode criar um modelo de classificação e concede à função r2 o privilégio mlconsumer para que r2 possa chamar o método PREDICT desse modelo. Então r1 concede a função mladmin a outra função, r3, para que r3 possa chamar todos os métodos do modelo.
Primeiro, a função r1 cria um objeto modelo, tornando r1 o proprietário do modelo model.
USE ROLE r1;
CREATE OR REPLACE SNOWFLAKE.ML.CLASSIFICATION model(
INPUT_DATA => SYSTEM$REFERENCE('TABLE', 'test_classification_dataset'),
TARGET_COLNAME => 'LABEL'
);
Você pode ver executando as instruções abaixo que a função r2 não pode chamar o método PREDICT do modelo.
USE ROLE r2;
SELECT model!PREDICT(1); -- privilege error
Em seguida, r1 concede a r2 a função de instância mlocnosumer, após a qual r2 pode chamar o método PREDICT do modelo.
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')
);
Da mesma forma, a função r3 não pode ver as métricas de avaliação do modelo sem a função de instância mladmin.
USE ROLE r3;
CALL model!SHOW_EVALUATION_METRICS(); -- privilege error
A função r1 concede a função necessária a r3 e r3 pode então chamar o método SHOW_EVALUATION_METRICS do modelo.
USE ROLE r1;
GRANT SNOWFLAKE.ML.CLASSIFICATION ROLE model!mladmin TO ROLE r3;
USE ROLE r3;
CALL model!SHOW_EVALUATION_METRICS();
Você pode revogar os privilégios da seguinte maneira.
USE ROLE r1;
REVOKE SNOWFLAKE.ML.CLASSIFICATION ROLE model!mlconsumer FROM ROLE r2;
REVOKE SNOWFLAKE.ML.CLASSIFICATION ROLE model!mladmin FROM ROLE r3;
Use os comandos a seguir para ver quais funções de conta e funções de banco de dados receberam cada uma dessas funções de instância.
SHOW GRANTS TO SNOWFLAKE.ML.CLASSIFICATION ROLE <model_name>!mladmin;
SHOW GRANTS TO SNOWFLAKE.ML.CLASSIFICATION ROLE <model_name>!mlconsumer;
Como entender as métricas de avaliação¶
As métricas medem a precisão com que um modelo prevê novos dados. A classificação do Snowflake atualmente avalia modelos selecionando uma amostra aleatória de todo o conjunto de dados. Um novo modelo é treinado sem essas linhas e então as linhas são usadas como entrada de inferência. A parte da amostra aleatória pode ser configurada usando a chave test_fraction no objeto EVALUATION_CONFIG.
Métricas em show_evaluation_metrics¶
show_evaluation_metrics calcula os seguintes valores para cada classe. Consulte SHOW_EVALUATION_METRICS.
Instâncias positivas: instâncias de dados (linhas) que pertencem à classe de interesse ou à classe que está sendo prevista.
Instâncias negativas: instâncias de dados (linhas) que não pertencem à classe de interesse ou são o oposto do que está sendo previsto.
Verdadeiros positivos (TP): previsões corretas de instâncias positivas.
Verdadeiros negativos (TN): previsões corretas de instâncias negativas,
Falsos positivos (FP): previsões incorretas de instâncias positivas
Falsos negativos (FN): previsões incorretas de instâncias negativas.
Usando os valores acima, as seguintes métricas são relatadas para cada classe. Para cada métrica, um valor mais alto indica um modelo mais preditivo.
Precisão: a proporção de verdadeiros positivos em relação ao total de positivos previstos. Ele mede quantas das instâncias positivas previstas são realmente positivas.
Recall (sensibilidade): a proporção de verdadeiros positivos em relação ao total de positivos reais. Ele mede quantas das instâncias positivas reais foram previstas corretamente.
Pontuação F1: a média harmônica de precisão e recall. Ele fornece um equilíbrio entre precisão e recall, especialmente quando há uma distribuição desigual de classes.
Métricas em show_global_evaluation_metrics¶
show_global_evaluation_metrics calcula métricas gerais (globais) para todas as classes previstas pelo modelo calculando a média das métricas por classe calculadas por show_evaluation_metrics. Consulte SHOW_GLOBAL_EVALUATION_METRICS.
Atualmente, a média macro e weighted é usada para as métricas Precisão, Recall, F1, AUC.
A perda logística (LogLoss) é calculada para o modelo como um todo. O objetivo da previsão é minimizar a função de perda.
Métricas em show_threshold_metrics¶
show_threshold_metrics fornece contagens e métricas brutas para um limite específico para cada classe. Isso pode ser usado para traçar curvas ROC e PR ou fazer ajuste de limite, se desejado. O limite varia de 0 a 1 para cada classe específica; uma probabilidade prevista é atribuída. Consulte SHOW_THRESHOLD_METRICS.
A amostra é classificada como pertencente a uma classe se a probabilidade prevista de estar nessa classe exceder o limite especificado. Os verdadeiros e falsos positivos e negativos são calculados considerando a classe negativa como toda instância que não pertence à classe que está sendo considerada. As seguintes métricas são então calculadas.
Taxa de verdadeiros positivos (TPR): a proporção de instâncias positivas reais que o modelo identifica corretamente (equivalente a recall).
Taxa de falsos positivos (FPR): a proporção de instâncias negativas reais que foram previstas incorretamente como positivas.
Precisão: a proporção de previsões corretas (verdadeiros positivos e verdadeiros negativos) em relação ao número total de previsões, uma medida geral do desempenho do modelo. Esta métrica pode ser enganosa em casos desequilibrados.
Suporte: o número de ocorrências reais de uma classe no conjunto de dados especificado. Valores de suporte mais altos indicam uma representação maior de uma classe no conjunto de dados. O suporte não é em si uma métrica do modelo, mas uma característica do conjunto de dados.
Matriz de confusão em show_confusion_matrix¶
A matriz de confusão é uma tabela usada para avaliar o desempenho de um modelo comparando valores previstos e reais e avaliando sua capacidade de identificar corretamente instâncias positivas e negativas. O objetivo é maximizar o número de instâncias na diagonal da matriz enquanto minimiza o número de instâncias fora da diagonal. Consulte SHOW_CONFUSION_MATRICX.
Você pode visualizar a matriz de confusão no Snowsight da seguinte maneira.
CALL model_binary!SHOW_CONFUSION_MATRIX();
Os resultados são semelhantes aos seguintes.
+--------------+--------------+-----------------+-------+------+
| 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 |
+--------------+--------------+-----------------+-------+------+
Para visualizar a matriz de confusão, clique em Chart, depois em Chart Type e depois em Heatgrid. Em Dados, para Cell values selecione NONE, para Rows selecione PREDICTED_CLASS e para Columns selecione ACTUAL_CLASS. O resultado é semelhante à figura abaixo.
Como entender a importância do recurso¶
Um modelo de classificação pode explicar a importância relativa de todos os recursos usados no modelo. Essas informações são úteis para entender quais fatores estão realmente influenciando seus dados.
O método SHOW_FEATURE_IMPORTANCE conta o número de vezes que as árvores do modelo usaram cada recurso para tomar uma decisão. Essas pontuações de importância do recurso são então normalizadas para valores entre 0 e 1 para que sua soma seja 1. As pontuações resultantes representam uma classificação aproximada dos recursos em seu modelo treinado.
Recursos que estão próximos em pontuação têm importância semelhante. O uso de vários recursos muito semelhantes entre si pode resultar em pontuações de importância reduzidas para esses recursos.
Limitações¶
Você não pode escolher a técnica usada para calcular a importância do recurso.
As pontuações de importância do recurso podem ser úteis para obter intuição sobre quais recursos são importantes para a precisão do seu modelo, mas os valores reais devem ser considerados estimativas.
Exemplo¶
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 |
+------+---------------------+---------------+---------------+
Considerações sobre custo¶
O treinamento e o uso de modelos de classificação incorrem em custos de computação e armazenamento.
O uso de quaisquer APIs do recurso de classificação (treinar um modelo, prever com o modelo, recuperar métricas) exige um warehouse ativo. O custo de computação do uso de funções de classificação é cobrado do warehouse. Consulte Explicação dos custos de computação para obter informações gerais sobre os custos de computação do Snowflake.
Os custos de armazenamento incorridos refletem o armazenamento das instâncias de modelo de classificação criadas durante a etapa de treinamento. Para visualizar os objetos associados à sua instância de modelo, navegue até suas exibições do Account Usage (por exemplo, ACCOUNT_USAGE.TABLES e ACCOUNT_USAGE.STAGES). As colunas DATABASE e SCHEMA para objetos de modelo de classificação contêm NULL, mas a coluna INSTANCE_ID é preenchida para objetos contidos em uma instância de modelo. Esses objetos são totalmente gerenciados pela instância do modelo e não é possível acessá-los ou excluí-los separadamente. Para reduzir os custos de armazenamento associados aos seus modelos, exclua modelos não utilizados ou obsoletos.
Uso de classificação no Snowpark¶
session.call ainda não é compatível com modelos de classificação. Para trabalhar com um modelo de classificação no Snowpark, use session.sql, conforme mostrado aqui.
session.sql("CREATE SNOWFLAKE.ML.CLASSIFICATION model(...)").collect()
session.sql("SELECT model!PREDICT(...)").collect()