Registro de modelo Snowflake¶

Privilégios obrigatórios¶

Para criar um modelo, você deve possuir o esquema onde o modelo foi criado ou ter o privilégio CREATE MODEL nele. Para usar um modelo, você deve possuir o modelo ou ter o privilégio USAGE nele. O privilégio USAGE permite que os beneficiários usem o modelo para inferência sem poder ver nenhum de seus componentes internos. Para dar aos usuários acesso a todos os modelos existentes em um esquema, use GRANT USAGE ON ALL MODELS IN SCHEMA <schema> TO ROLE <role>;. Também é possível dar aos usuários acesso a futuros modelos criados em um esquema automaticamente por meio de GRANT USAGE ON FUTURE MODELS IN SCHEMA <schema> TO ROLE <role>;.

Se a função de um usuário tiver USAGE em um modelo, ela aparecerá na página de registro do modelo Snowsight. Para obter detalhes sobre como os privilégios funcionam no Snowflake, consulte Privilégios de controle de acesso.

Limitações atuais¶

Os seguintes limites se aplicam a modelos e versões de modelo.

Abertura do registro de modelo do Snowflake¶

Os modelos são objetos Snowflake de primeira classe e podem ser organizados em um banco de dados e esquema junto com outros objetos Snowflake. O Registro de modelo Snowflake fornece uma classe Python para gerenciar modelos dentro de um esquema. Assim, qualquer esquema Snowflake pode ser usado como registro. Não é necessário inicializar ou preparar um esquema para essa finalidade. Snowflake recomenda a criação de um ou mais esquemas dedicados para essa finalidade, como ML.REGISTRY. Você pode criar o esquema usando CREATE SCHEMA.

Antes de poder criar ou modificar modelos no registro, você deve abrir o registro. A abertura do registro retorna uma referência a ele, que você pode usar para adicionar novos modelos e obter referências a modelos existentes.

from snowflake.ml.registry import Registry

reg = Registry(session=sp_session, database_name="ML", schema_name="REGISTRY")

Registro de modelos e versões¶

Adicionar um modelo ao registro é chamado de registro em log do modelo. Registre em log um modelo chamando o método log_model do registro. Este método serializa o modelo – um objeto Python – e cria um objeto modelo Snowflake a partir dele. Este método também adiciona metadados, como uma descrição, ao modelo, conforme especificado na chamada log_model.

Cada modelo pode ter versões ilimitadas. Para registrar versões adicionais do modelo em log, chame log_model novamente com o mesmo model_name, mas com um version_name diferente.

Você não pode adicionar tags a um modelo quando ele é adicionado ao registro, porque tags são atributos do modelo e log_model adiciona uma versão específica do modelo, criando um modelo apenas quando adiciona sua primeira versão. Você pode atualizar as tags do modelo depois de registrar a primeira versão do modelo em log.

No exemplo a seguir, clf, abreviação de “classificador”, é o objeto do modelo Python, que já foi criado em outro lugar em seu código. Você pode adicionar um comentário no momento do registro, conforme mostrado aqui. A combinação de nome e versão deve ser exclusiva no esquema. Você pode especificar listas de conda_dependencies; os pacotes especificados serão implantados com o modelo.

from snowflake.ml.model import type_hints
mv = reg.log_model(clf,
                   model_name="my_model",
                   version_name="v1",
                   conda_dependencies=["scikit-learn"],
                   comment="My awesome ML model",
                   metrics={"score": 96},
                   sample_input_data=train_features,
                   task=type_hints.Task.TABULAR_BINARY_CLASSIFICATION)

Os argumentos de log_model são descritos aqui.

Argumentos exigidos

Argumentos opcionais

log_model retorna um objeto snowflake.ml.model.ModelVersion, que representa a versão do modelo que foi adicionado ao registro.

Após o registro, o modelo em si não pode ser modificado (embora você possa alterar seus metadados). Para excluir um modelo e todas as suas versões, use o método excluir_modelo do registro.

Como trabalhar com artefatos de modelo¶

Depois que um modelo é registrado, seus artefatos (os arquivos que dão suporte ao modelo, incluindo seus objetos Python serializados e vários arquivos de metadados, como seu manifesto) ficam disponíveis em um estágio interno. Os artefatos não podem ser modificados, mas você pode visualizar ou baixar os artefatos dos modelos que possui.

Você pode acessar artefatos do modelo de um estágio usando, por exemplo, o comando GET ou seu equivalente em Snowpark Python, FileOperation.get.

No entanto, você não pode abordar artefatos de modelo usando a sintaxe usual do caminho de estágio. Em vez disso, use um snow:// URL, uma maneira mais geral de especificar a localização de objetos no Snowflake. Por exemplo, uma versão dentro de um modelo pode ser especificada por um URL do formulário snow://model/<nome_do_modelo>/versions/<nome_da_versão>/.

Sabendo o nome do modelo e a versão que você deseja, você pode usar o comando LIST para visualizar os artefatos do modelo da seguinte forma:

LIST 'snow://model/my_model/versions/V3/';

A saída é semelhante a:

name                                      size                  md5                      last_modified
versions/V3/MANIFEST.yml           30639    2f6186fb8f7d06e737a4dfcdab8b1350        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/functions/apply.py      2249    e9df6db11894026ee137589a9b92c95d        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/functions/predict.py    2251    132699b4be39cc0863c6575b18127f26        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/model.zip             721663    e92814d653cecf576f97befd6836a3c6        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/model/env/conda.yml          332        1574be90b7673a8439711471d58ec746        Thu, 18 Jan 2024 09:24:37 GMT
versions/V3/model/model.yaml       25718    33e3d9007f749bb2e98f19af2a57a80b        Thu, 18 Jan 2024 09:24:37 GMT

Para recuperar um desses artefatos, use o comando SQL GET.

GET 'snow://model/model_my_model/versions/V3/MANIFEST.yml'

Ou o equivalente com Snowpark Python:

session.file.get('snow://model/my_model/versions/V3/MANIFEST.yml', 'model_artifacts')

Exclusão de modelos¶

Use o método delete_model do registro para excluir um modelo e todas as suas versões.

reg.delete_model("mymodel")

Como obter modelos do registro¶

Para obter informações sobre cada modelo, use o método show_models:

model_df = reg.show_models()

O resultado de show_models é um pandas DataFrame. As colunas disponíveis estão listadas aqui:

Para obter uma lista dos modelos no registro, cada um como uma instância Model, use o método models:

model_list = reg.models()

Para obter uma referência a um modelo específico do registro por nome, use o método get_model do registro.

m = reg.get_model("MyModel")

Após ter uma referência para um modelo, seja um da lista retornada pelo método models ou uma recuperada usando get_model, é possível trabalhar com seus metadados e suas versões.

Exibição e atualização dos metadados de um modelo¶

Você pode visualizar e atualizar os atributos de metadados de um modelo no registro, incluindo seu nome, comentário, tags e métricas.

print(m.comment)
m.comment = "A better description than the one I provided originally"

print(m.description)
m.description = "A better description than the one I provided originally"

print(m.show_tags())

m.set_tag("live_version", "v1")

m.get_tag("live_version")

m.unset_tag("live_version")

m.rename("MY_MODEL_TOO")

Como trabalhar com versões de modelo¶

Um modelo pode ter versões ilimitadas, cada uma identificada por uma cadeia de caracteres. Você pode usar qualquer convenção de nomenclatura de versão que desejar. Registrar um modelo na verdade registra uma versão específica do modelo. Para registrar versões adicionais de um modelo, chame log_model novamente com o mesmo model_name, mas com um version_name diferente.

Uma versão de um modelo é representada por uma instância da classe snowflake.ml.model.ModelVersion.

Para obter uma lista de todas as versões de um modelo, chame o método versions do objeto modelo. O resultado é uma lista de instâncias ModelVersion:

version_list = m.versions()

Para obter informações sobre cada modelo como um DataFrame, chame o método show_versions do modelo.

version_df = m.show_versions()

O DataFrame resultante contém as colunas a segui:

m.delete_version("rc1")

default_version = m.default
m.default = "v2"

m = reg.get_model("MyModel")

mv = m.version("v1")
mv = m.default

print(mv.comment)
print(mv.description)

mv.comment = "A model version comment"
mv.description = "Same as setting the comment"

from sklearn import metrics

test_accuracy = metrics.accuracy_score(test_labels, prediction)

test_confusion_matrix = metrics.confusion_matrix(test_labels, prediction)

# scalar metric
mv.set_metric("test_accuracy", test_accuracy)

# hierarchical (dictionary) metric
mv.set_metric("evaluation_info", {"dataset_used": "my_dataset", "accuracy": test_accuracy, "f1_score": f1_score})

# multivalent (matrix) metric
mv.set_metric("confusion_matrix", test_confusion_matrix)

metrics = mv.show_metrics()

mv.delete_metric("test_accuracy")

mv.export("~/mymodel/")

mv.export("~/mymodel/", export_mode=ExportMode.FULL)

clf = mv.load()

conda_env = session.file.get("snow://model/<modelName>/versions/<versionName>/runtimes/python_runtime/env/conda.yml", ".")
open("~/conda.yml", "w").write(conda_env)

conda env create --name newenv --file=~/conda.yml
conda activate newenv

clf = mv.load(options={"use_gpu": True})

Como chamar métodos de modelo¶

As versões do modelo podem ter métodos, que são funções anexadas que podem ser executadas para realizar inferência ou outras operações do modelo. As versões de um modelo podem ter métodos diferentes e as assinaturas desses métodos também podem ser diferentes.

Para chamar um método de uma versão de modelo, use mv.run, em que mv é um objeto ModelVersion. Especifique o nome da função a ser chamada e passe um Snowpark ou pandas DataFrame que contenha os dados de inferência, juntamente com os parâmetros necessários. O método é executado em um warehouse Snowflake.

O valor de retorno do método é um Snowpark ou pandas DataFrame, que corresponde ao tipo de DataFrame passado. DataFrames Snowpark são avaliados lentamente, então o método é executado somente quando o método do DataFrame collect, show ou to_pandas for chamado.

O exemplo a seguir ilustra a execução do método predict de um modelo. O método predict deste modelo não requer nenhum parâmetro além dos dados de inferência (test_features aqui). Se assim fosse, eles seriam passados como argumentos adicionais após os dados de inferência.

remote_prediction = mv.run(test_features, function_name="predict")
remote_prediction.show()   # assuming test_features is Snowpark DataFrame

Para ver quais métodos podem ser chamados em um determinado modelo, chame mv.show_functions. O valor de retorno deste método é uma lista de objetos ModelFunctionInfo. Cada um desses objetos inclui os seguintes atributos:

• name: o nome da função que pode ser chamada em Python ou SQL.

• target_method: o nome do método Python no modelo registrado original.

Compartilhamento de modelos¶

O registro de modelo pode armazenar dois tipos de modelos. É possível distingui-los usando a coluna MODEL_TYPE na saída de SHOW MODELS.

• CORTEX_FINETUNED: Modelos gerados com o Cortex Fine-tuning sem código do usuário. Para compartilhar esse tipo de modelo, use o compartilhamento de dados.

• USER_MODEL: Modelos com código do usuário, como modelos desenvolvidos usando classes de modelagem do Snowpark ML. Esses modelos não podem ser compartilhados no momento. A capacidade de compartilhar modelos com código de usuário estará disponível em um lançamento futuro.

Considerações sobre custo¶

O uso do registro de modelo do Snowflake incorre em custos padrão baseados no consumo do Snowflake. Isso inclui:

• Custo de armazenamento de artefatos, metadados e funções do modelo. Para obter informações gerais sobre os custos de armazenamento, consulte Exploração do custo de armazenamento.

• Custo de cópia de arquivos entre estágios para o Snowflake. Consulte COPY FILES.

• Custo de operações de objetos de modelo sem servidor por meio da interface Snowsight UI ou SQL ou Python, como mostra os modelos e versões de modelo e alteração de comentários, tags e métricas do modelo.

• Custos de computação do warehouse, que variam de acordo com o tipo de modelo e a quantidade de dados usados na inferência. Para obter informações gerais sobre os custos de computação do Snowflake, consulte Explicação dos custos de computação. Os custos de computação do warehouse são incorridos para:

  • Operações de criação de modelo e versão

  • Invocação dos métodos de um modelo