Snowpark ML Ops: migração da API da versão preliminar do registro de modelo

Anteriormente, a Snowflake disponibilizou uma versão preliminar do registro do modelo de forma privada para clientes selecionados. O recurso de registro descrito neste tópico apresenta alterações significativas na funcionalidade e APIs em comparação com a versão de versão preliminar. Mais notavelmente, a funcionalidade principal do registro agora é hospedada nativamente no Snowflake usando um novo objeto de modelo em nível de esquema.

Nota

A versão de versão preliminar pública ainda não oferece suporte à implantação de modelos no Snowpark Container Services (SPCS). Se você depende dessa funcionalidade, continue usando o registro de versão preliminar privada por enquanto.

Esta tabela resume as principais diferenças entre as duas implementações de registro. A API da versão de versão preliminar disponível de forma privada é designado como “API de versão preliminar”, enquanto a API atual lançada publicamente é chamada de “API pública”.

API de versão preliminar

API pública

Os metadados são armazenados em tabelas. Os modelos são armazenados em estágios. A API do registro é uma biblioteca Python que cria e mantém esses objetos para os modelos armazenados no registro.

  • Os usuários devem ter privilégios para criar esquemas, tabelas e estágios para criar um registro.

  • O registro pode se tornar inconsistente atualizando os metadados do modelo fora da API Python.

  • Os modelos devem ser implantados explicitamente para serem usados.

  • Os modelos individuais não podem ter controle de acesso baseado em função (embora as implantações de modelo, que são funções definidas pelo usuário, possam).

  • A portabilidade da API do registro requer a implementação de toda a funcionalidade do registro na nova linguagem.

Os modelos são objetos nativos no nível do esquema, como tabelas e estágios. A API do registro Python é uma classe que facilita a interação com objetos de modelo em Python, usando SQL nos bastidores.

  • Os modelos são armazenados em um esquema existente. Os esquemas não precisam de nenhuma preparação especial para serem usados como registro, e os usuários precisam apenas de um privilégio para criar um modelo em um esquema que não lhes pertence.

  • Nenhum metadado é armazenado fora do objeto do modelo, portanto o registro não pode se tornar inconsistente.

  • Os modelos contêm métodos que podem ser chamados de SQL ou Python e não precisam ser implantados explicitamente.

  • Os privilégios de uso podem ser concedidos de forma independente em modelos específicos.

  • Portar a API do registro para outra linguagem é simples, pois a biblioteca Python é uma camada fina sobre SQL.

As seções a seguir descrevem as diferenças entre as duas APIs com mais detalhes.

Importação e acesso da API de registro

Ambas as APIs de registro estão no pacote principal do Snowpark ML, snowflake.ml.

API de versão preliminar

 
from snowflake.ml.registry import model_registry
Copy

Use model_registry.ModelRegistry para acessar a funcionalidade do registro.

API pública

 
from snowflake.ml.registry import Registry
Copy

Use a classe Registry para acessar a funcionalidade do registro.

Criação de um registro

A API da versão preliminar requer que o registro seja criado pela biblioteca Python.

API de versão preliminar

 
model_registry.create_model_registry(...)
Copy

Necessário antes de usar o registro pela primeira vez.

API pública

Não aplicável. Qualquer esquema existente pode ser usado como registro.

Abertura de um registro

Você abre um registro para adicionar novos modelos e trabalhar com os modelos que já estão nele.

API de versão preliminar

 
reg = model_registry.ModelRegistry(
          session=session,
          database_name="MODEL_REGISTRY")
Copy

API pública

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

Registro em log de um modelo

Adicionar um modelo ao registro é chamado de log. Ambas as APIs usam um método de registro chamado log_model para essa finalidade. Este método tem duas pequenas diferenças na API pública:

  • O parâmetro que especifica a versão do modelo, anteriormente denominado model_version, agora é denominado version_name para refletir melhor sua semântica.

  • Você não pode definir tags ao registrar um modelo em log. Em vez disso, adicione tags após o registro em log usando o método set_tag do modelo.

Obtenção de uma referência para um modelo

Obter uma referência a um modelo permite atualizar seus metadados e realizar outras operações nele.

API de versão preliminar

Obter um modelo do registro sempre retorna uma versão específica do modelo, portanto é necessário especificar a versão desejada ao recuperar o modelo.

model = model_registry.ModelReference(
            registry=registry,
            model_name="my_model",
            model_version="101")
Copy

API pública

As versões do modelo são separadas do próprio modelo. Para obter uma referência ao modelo:

m = reg.get_model("my_model")
Copy

Para obter uma referência a uma versão específica, primeiro obtenha uma referência ao modelo acima e, em seguida, recupere a versão desejada. Observe que o objeto modelo possui um atributo, default, que contém a versão do modelo que você designou como padrão. Este é o objeto ModelVersion real, não uma cadeia de caracteres.

mv = m.version('v1')
mv = m.default
Copy

Implantação de um modelo

API de versão preliminar

Os modelos devem ser implantados explicitamente em um warehouse (como uma função definida pelo usuário) ou no Snowpark Container Services (como um serviço). Este exemplo ilustra a implantação em um warehouse.

model.deploy(
    deployment_name="my_warehouse_predict",
    target_method="predict",
    permanent=True)
Copy

API pública

Não é necessário implantar explicitamente um modelo.

Uso de um modelo para inferência

Inferência refere-se ao uso do modelo para fazer previsões com base em dados de teste.

API de versão preliminar

Especifique o nome da implantação que você usou quando implantou o modelo para executar a inferência.

result_dataframe = model.predict(
    "my_warehouse_predict", test_dataframe)
Copy

API pública

Os modelos são executados em um warehouse. Você pode chamar métodos do modelo em Python ou em SQL.

Python

Você chama métodos usando o método run de uma versão do modelo.

remote_prediction = mv.run(
    test_features, function_name="predict")
Copy

SQL

Você pode chamar métodos da versão padrão usando uma consulta SELECT simples ou especificar uma versão usando uma cláusula WITH.

-- Use default version
SELECT my_model!predict() FROM test_table;

-- Use a specific version
WITH my_model_v1 AS MODEL my_model VERSION "1"
     SELECT my_model_v1!predict() FROM test_table;
Copy

Acesso e atualização de descrições

API de versão preliminar

A referência do modelo fornece métodos getter e setter para a descrição. (Nesta API, uma referência de modelo é sempre para uma versão específica do modelo.)

print(model.get_model_description())

model.set_model_description("A better description")
Copy

API pública

Tanto os modelos quanto as versões do modelo fornecem acesso a uma descrição por meio de seus atributos comment e description equivalentes.

print(m.comment)
m.comment = "A better description"

print(m.description)
m.description = "A better description"

print(mv.comment)
mv.comment = "A better description"

print(mv.description)
mv.description = "A better description"
Copy

Acesso e atualização de tags

API de versão preliminar

As tags são definidas e acessadas no nível da versão do modelo (as referências do modelo sempre se referem a uma versão específica).

Obter todas as tags

print(model.get_tags())
Copy

Adicionar tag ou definir um novo valor de tag

model.set_tag("minor_rev", "1")
Copy

Remover uma tag

model.remove_tag("minor_rev")
Copy

API pública

As tags são definidas no nível do modelo (um modelo compreende uma coleção de versões) e são implementadas usando tags SQL. Consulte Marcação de objetos para saber como criar tags e definir seus valores permitidos.

Obter todas as tags

print(m.show_tags())
Copy

Adicionar tag ou definir um novo valor de tag

m.set_tag("minor_rev", "1")
Copy

Remover uma tag

m.unset_tag("minor_rev")
Copy

Acesso e atualização de métricas

Em ambas APIs, as métricas são definidas no nível da versão do modelo.

API de versão preliminar

Definir métrica escalar

model.set_metric("test_accuracy", test_accuracy)
Copy

Definir métrica hierárquica (dicionário)

model.set_metric("dataset_test", {"accuracy": test_accuracy})
Copy

Definir métrica multivalente (matriz)

model.set_metric("confusion_matrix", test_confusion_matrix)
Copy

Obter todas as métricas

print(model.get_metrics())
Copy

Remover uma métrica

model.remove_metric("test_accuracy")
Copy

API pública

Definir métrica escalar

m.set_metric("test_accuracy", test_accuracy)
Copy

Definir métrica hierárquica (dicionário)

mo.set_metric("dataset_test", {"accuracy": test_accuracy})
Copy

Definir métrica multivalente (matriz)

m.set_metric("confusion_matrix", test_confusion_matrix)
Copy

Obter todas as métricas

print(m.get_metrics())
Copy

Remover uma métrica

m.remove_metric("test_accuracy")
Copy

Exclusão de um modelo

API de versão preliminar

Você só pode excluir versões específicas de um modelo. Para excluir completamente o modelo, exclua todas as suas versões.

registry.delete_model(
    model_name="my_model",
    model_version="100")
Copy

API pública

Excluir um modelo exclui todas as suas versões. Atualmente não é possível excluir apenas uma versão.

reg.delete_model("mymodel")
Copy

Listagem de versões de um modelo

API de versão preliminar

O método list_models retorna DataFrame de todas as versões do modelo. Você pode filtrar isso para mostrar apenas as versões de um modelo específico.

model_list = registry.list_models()
model_list.filter(model_list["NAME"] == "mymodel").show()
Copy

API pública

Dada uma referência de modelo, você pode obter as versões do modelo como uma lista de instâncias de ModelVersion ou como DataFrame contendo informações sobre as versões do modelo.

Obter lista de instâncias ModelVersions

version_list = m.versions()
Copy

Obter DataFrame de informações

version_df = m.show_versions()
Copy

Gerenciamento do ciclo de vida do modelo

Seu objetivo é gerenciar o ciclo de vida de um modelo usando tags. Por exemplo, você pode criar uma tag chamada stage para registrar o status atual do modelo, usando valores como “experimental”, “alfa”, “beta”, “produção”, “obsoleto” e “descontinuado”.

Na API pública, as tags são implementadas usando objetos de tag SQL. Consulte Marcação de objetos para saber como criar tags e definir seus valores permitidos.

A API pública também tem o conceito de versão padrão de um modelo, que é o modelo usado quando uma versão não é especificada, principalmente em SQL. Ao treinar uma nova versão de um modelo e o novo modelo estiver pronto para uso generalizado, você poderá atualizar a versão padrão. Você pode definir a versão padrão usando o atributo default do modelo.

m.default = "2"
Copy

Você pode então obter a versão padrão do modelo, como um objeto ModelVersion, como segue.

mv = m.default
Copy

Ou você pode chamar o método predict imediatamente.

m.default.run(test_features, function_name="predict"))
Copy
Linguagem: Português