Execução de experimento para comparar e selecionar modelos¶
Com o Snowflake ML Experiments, você pode configurar experimentos: avaliações organizadas dos resultados do treinamento de modelos. Isso permite comparar rapidamente os resultados do ajuste de hiperparâmetros, diversas métricas de destino e o comportamento de tipos de modelo diferentes de forma organizada para selecionar o melhor modelo de acordo com as suas necessidades. Cada experimento consiste em uma série de execuções, que são metadados e artefatos do treinamento. O Snowflake é imparcial em relação aos artefatos de execução. Você pode enviar qualquer elemento útil para o seu processo de avaliação de modelo.
Depois que você concluir um experimento, os resultados ficarão visíveis no Snowsight. Você também pode recuperar artefatos de execução a qualquer momento em Python ou SQL.
Nota
O Snowflake Experiments requer o snowflake-ml-python versão 1.19.0 ou mais recente.
Requisitos de controle de acesso¶
A criação de um experimento requer o privilégio CREATE EXPERIMENT no esquema em que os artefatos de execução são armazenados. A criação de um experimento requer o privilégio USAGE no banco de dados e no esquema pai.
Criação de um experimento¶
Primeiro, crie um experimento. Para isso, é necessário ter um banco de dados e um esquema existentes, usados para armazenar as informações de execução.
O suporte a experimentos está disponível na classe snowflake.ml.experiment.ExperimentTracking. Use o método set_experiment(name: Optional[str]) para abrir um experimento com o nome fornecido e defini-lo como contexto de experimento ativo para logs e artefatos. Experimentos que ainda não existem serão criados.
O exemplo a seguir mostra como criar ou abrir um experimento chamado My_Experiment no banco de dados e no esquema ativos e defini-lo como experimento ativo usando uma session existente:
from snowflake.ml.experiment import ExperimentTracking
exp = ExperimentTracking(session=session)
exp.set_experiment("My_Experiment")
No menu de navegação, selecione AI & ML » Experiments.
Selecione New Experiment.
Insira o Name do seu experimento.
Selecione o banco de dados e o esquema no qual armazenar os artefatos de execução do experimento.
Selecione Create para criar o experimento ou Cancel para cancelá-lo.
Início da execução do experimento¶
Cada execução em um experimento tem o próprio conjunto de métricas, parâmetros e artefatos. Essas informações são usadas no Snowsight para fornecer visualizações e dados sobre o treinamento do modelo e seus resultados.
Inicie a execução com o método start_run(name: Optional[str]) na instância ExperimentTracking. Esse procedimento retorna uma nova Run, que oferece suporte ao uso em uma instrução with. A Snowflake recomenda que você use instruções with, para que as execuções sejam concluídas com cuidado e para facilitar a decisão sobre o escopo da execução.
with exp.start_run("my_run"):
# .. Train your model and log artifacts
Registro automático das informações de treinamento¶
É possível registrar automaticamente as informações de treinamento de modelos XGBoost, LightGBM ou Keras durante o treinamento. O registro automático é feito gravando um retorno de chamada que faz referência ao seu experimento e as informações sobre o modelo que você está treinando. Cada vez que um método é chamado na instância Model que ajusta um parâmetro ou uma métrica, ele é registrado automaticamente no experimento da execução ativa.
O exemplo a seguir mostra como configurar os retornos de chamada do seu experimento para cada treinador de modelo compatível e, em seguida, iniciar uma execução de treinamento básico para registrar artefatos.
# exp: ExperimentTracking
from xgboost import XGBClassifier
from snowflake.ml.experiment.callback.xgboost import SnowflakeXgboostCallback
from snowflake.ml.model.model_signature import infer_signature
sig = infer_signature(X, y)
callback = SnowflakeXgboostCallback(
exp, model_name="name", model_signature=sig
)
model = XGBClassifier(callbacks=[callback])
with exp.start_run("my_run"):
model.fit(X, y, eval_set=[(X, y)])
# exp: ExperimentTracking
from lightgbm import LGBMClassifier
from snowflake.ml.experiment.callback.lightgbm import SnowflakeLightgbmCallback
from snowflake.ml.model.model_signature import infer_signature
sig = infer_signature(X, y)
callback = SnowflakeLightgbmCallback(
exp, model_name="name", model_signature=sig
)
model = LGBMClassifier()
with exp.start_run("my_run"):
model.fit(X, y, eval_set=[(X, y)], callbacks=[callback])
# exp: ExperimentTracking
import keras
from snowflake.ml.experiment.callback.keras import SnowflakeKerasCallback
from snowflake.ml.model.model_signature import infer_signature
sig = infer_signature(X, y)
callback = SnowflakeKerasCallback(
exp, model_name="name", model_signature=sig
)
model = keras.Sequential()
model.add(keras.layers.Dense(1))
model.compile(
optimizer=keras.optimizers.RMSprop(learning_rate=0.1),
loss="mean_squared_error",
metrics=["mean_absolute_error"],
)
with exp.start_run("my_run"):
model.fit(X, y, validation_split=0.5, callbacks=[callback])
Registro manual de informações e artefatos de treinamento¶
Para modelos que não oferecem suporte ao registro automático ou que são pré-treinados, é possível registrar manualmente as informações de experimentos e carregar os artefatos no Python. Os parâmetros são entradas constantes no modelo de treinamento, enquanto as métricas são avaliadas em uma etapa do modelo. Você pode representar uma época de treinamento como uma etapa correspondente. O exemplo a seguir mostra como registrar parâmetros, registrar métricas e carregar artefatos.
Nota
O valor padrão de etapa é 0.
# Logging requires an active run for the exp: ExperimentTracker instance.
# Log model parameters with the log_param(...) or log_params(...) methods
exp.log_param("learning_rate", 0.01)
exp.log_params({"optimizer": "adam", "batch_size": 64})
# Log model metrics with the log_metric(...) or log_metrics(...) methods
exp.log_metric("loss", 0.3, step=100)
exp.log_metrics({"loss": 0.4, "accuracy": 0.8}, step=200)
# Log your model to the experiment's model registry with the log_model(...) method.
exp.log_model(model, model_name="my_model", signatures={"predict": model_signature})
exp.log_model(model, model_name="my_model", sample_input_data=data)
# Log local artifacts to an experiment run with the log_artifact(...) method.
exp.log_artifact('/tmp/file.txt', artifact_path='artifacts')
Nota
O registro de artefatos não é compatível com notebooks de warehouse.
Conclusão da execução¶
A conclusão de uma execução a torna imutável e a apresenta como finalizada no Snowsight.
Se você iniciou uma execução como parte de uma instrução with, a execução é automaticamente concluída ao sair do escopo. Caso contrário, você pode encerrar uma execução chamando o método end_run(name: Optional[str]) do seu experimento com o nome da execução que será concluída:
experiment.end_run("my_run")
Comparação de execuções de um experimento¶
A avaliação de experimentos é feita no Snowsight. No menu de navegação, selecione AI & ML » Experiments e escolha na lista o experimento que será examinado.
A exibição do experimento contém informações sobre Run count over time, uma visualização da métrica selecionada no momento e uma lista das execuções disponíveis no experimento. O menu suspenso superior direito mostra uma lista das métricas disponíveis para inspeção, que preenche o gráfico Metric Value Range na exibição do experimento.
A lista de execuções nesta página inclui Run name, Status, quando a execução foi Created e uma coluna adicional para cada métrica disponível no experimento. As informações sobre parâmetros e versões de modelo estão disponíveis na exibição de comparação de execuções.
Você pode selecionar até cinco execuções em seu experimento e, em seguida, clicar no botão Compare para ver a comparação, que mostra os metadados de execução, os parâmetros, as métricas e as informações de versão do modelo. Cada métrica é exibida visualmente, o que pode ser alterado usando o seletor na seção Metrics para alternar entre Charts e Tables.
Recuperação de artefatos de uma execução¶
A qualquer momento durante ou depois de uma execução, você pode recuperar artefatos. O exemplo a seguir mostra como listar os artefatos disponíveis de uma execução no caminho logs e baixar o artefato logs/log0.txt da execução my_run no experimento my_experiment para o diretório local /tmp:
# exp: ExperimentTracking
exp.set_experiment("my_experiment")
exp.list_artifacts("my_run", artifact_path="logs")
exp.download_artifacts("my_run", artifact_path="logs/log0.txt", target_path="/tmp")
LIST snow://experiment/my_experiment/versions/my_run/logs;
GET snow://experiment/my_experiment/versions/my_run/logs/log0.txt file:///tmp;
Exclusão de execuções e experimentos¶
Depois de concluir um experimento, você poderá removê-lo, assim como todos os artefatos de execução associados. O exemplo a seguir remove o experimento my_experiment:
# exp: ExperimentTracking
exp.delete_experiment("my_experiment")
DROP EXPERIMENT my_experiment;
Você também pode remover uma execução individual de um experimento. O exemplo a seguir remove a execução my_run do experimento my_experiment:
# exp: ExperimentTracking
exp.set_experiment("my_experiment")
exp.delete_run("my_run")
ALTER EXPERIMENT my_experiment DROP RUN my_run;
Limitações¶
O Snowflake Experiments está sujeito às seguintes limitações:
Cada esquema é limitado a 500 experimentos.
Cada experimento é limitado a 500 execuções.
As execuções são armazenadas por no máximo um ano.
Os parâmetros e as métricas de cada execução são limitados ao total de 200 KB.
Considerações sobre custo¶
O uso do Snowflake Experiments incorre nos custos padrão do Snowflake conforme o consumo. Isso inclui:
Custo de armazenamento de artefatos de execução. Para obter informações gerais sobre os custos de armazenamento, consulte Exploração do custo de armazenamento.