Traga seus próprios tipos de modelos por meio de arquivos serializados¶
O registro de modelos oferece suporte ao registro em log de tipos de modelos incorporados diretamente no registro. Também fornecemos um método de registro em log de outros tipos de modelos com snowflake.ml.model.custom_model.CustomModel. Modelos serializáveis treinados usando ferramentas externas ou obtidos de repositórios de código aberto podem ser usados com CustomModel.
Este guia explica como:
Criar um modelo personalizado.
Criar contexto de modelo com arquivos e objetos de modelo.
Registrar em log o modelo personalizado no Snowflake Model Registry.
Implementar o modelo para inferência.
Nota
Este guia de início rápido fornece um exemplo de registro de um modelo PyCaret personalizado.
Definição do contexto do modelo por argumentos de palavras-chave¶
O snowflake.ml.model.custom_model.ModelContext pode ser instanciado com argumentos de palavras-chave definidos pelo usuário. Os valores podem ser caminhos de arquivo de cadeia de caracteres ou instâncias de tipos de modelos compatíveis</developer-guide/snowflake-ml/model-registry/built-in-models/overview>. Os arquivos e os modelos serializados serão empacotados com o modelo para uso na lógica de inferência do modelo.
Os arquivos podem ser modelos serializados, arquivos de configuração ou arquivos contendo parâmetros. Um uso comum disso é carregar um arquivo pickle ou json no método do modelo personalizado __init__ ou método de inferência.
Veja a seguir um exemplo que demonstra como fornecer modelos e arquivos com o contexto do modelo e usá-los em uma classe de modelo personalizada:
import pickle
import pandas as pd
from snowflake.ml.model import custom_model
# Initialize ModelContext with keyword arguments
# my_model can be any supported model type
# my_file_path is a local pickle file path
model_context = custom_model.ModelContext(
my_model=my_model,
my_file_path='/path/to/file.pkl',
)
# Define a custom model class that utilizes the context
class ExampleBringYourOwnModel(custom_model.CustomModel):
def __init__(self, context: custom_model.ModelContext) -> None:
super().__init__(context)
# Use 'my_file_path' key from the context to load the pickled object
with open(self.context['my_file_path'], 'rb') as f:
self.obj = pickle.load(f)
@custom_model.inference_api
def predict(self, input: pd.DataFrame) -> pd.DataFrame:
# Use the model with key 'my_model' from the context to make predictions
model_output = self.context['my_model'].predict(input)
return pd.DataFrame({'output': model_output})
# Instantiate the custom model with the model context. This instance can be logged in the model registry.
my_model = ExampleBringYourOwnModel(model_context)
Teste e registro de um modelo personalizado¶
Você pode testar um modelo personalizado executando-o localmente.
my_model = ExampleBringYourOwnModel(model_context)
output_df = my_model.predict(input_df)
Quando o modelo funcionar como pretendido, registre-o no Snowflake Model Registry. Conforme mostrado no próximo exemplo de código, forneça conda_dependencies (ou pip_requirements) para especificar as bibliotecas que a classe de modelo precisa. Forneça sample_input_data (um pandas ou Snowpark DataFrame) para inferir a assinatura de entrada do modelo. Como alternativa, forneça uma assinatura do modelo.
reg = Registry(session=sp_session, database_name="ML", schema_name="REGISTRY")
mv = reg.log_model(my_model,
model_name="my_custom_model",
version_name="v1",
conda_dependencies=["scikit-learn"],
comment="My Custom ML Model",
sample_input_data=train_features)
output_df = mv.run(input_df)
Exemplo: Registro de um modelo PyCaret¶
PyCaret é um pacote de terceiros de baixo código e alta eficiência que o Snowflake não suporta nativamente. Você pode trazer seus próprios tipos de modelos por meio de métodos semelhantes.
Etapa 1: Definir o contexto do modelo¶
Antes de registrar o modelo, defina um ModelContext que se refira ao seu próprio tipo de modelo que não seja nativamente suportado pelo Snowflake ML. Nesse caso, você especifica o caminho para o modelo serializado (pickled) usando o atributo model_file do contexto. Você pode escolher qualquer nome para o atributo, desde que o nome não seja usado para outra coisa.
pycaret_model_context = custom_model.ModelContext(
model_file = 'pycaret_best_model.pkl',
)
Importante
Quando você combina um tipo de modelo compatível (como XGBoost) com modelos ou dados não compatíveis, não é necessário serializar o modelo compatível. Defina o objeto de modelo compatível diretamente no contexto (por exemplo, base_model = my_xgb_model) e ele será serializado automaticamente.
Etapa 2: Criar uma classe de modelo personalizada¶
Defina uma classe de modelo personalizada para registrar um tipo de modelo sem suporte nativo. Neste exemplo, uma classe PyCaretModel, derivada de CustomModel, é definida para que o modelo possa ser registrado no registro.
from pycaret.classification import load_model, predict_model
class PyCaretModel(custom_model.CustomModel):
def __init__(self, context: custom_model.ModelContext) -> None:
super().__init__(context)
model_dir = self.context["model_file"][:-4] # Remove '.pkl' suffix
self.model = load_model(model_dir, verbose=False)
self.model.memory = '/tmp/' # Update memory directory
@custom_model.inference_api
def predict(self, X: pd.DataFrame) -> pd.DataFrame:
model_output = predict_model(self.model, data=X)
return pd.DataFrame({
"prediction_label": model_output['prediction_label'],
"prediction_score": model_output['prediction_score']
})
Nota
Conforme mostrado, defina o diretório de memória do modelo como /tmp/. Os nós de warehouse do Snowflake têm acesso restrito ao diretório. /tmp é sempre gravável e é uma escolha segura quando o modelo precisa de um local para gravar arquivos. Isso pode não ser necessário para outros tipos de modelos.
Etapa 3: Testar o modelo personalizado¶
Teste o modelo PyCaret localmente usando um código como o seguinte.
test_data = [
[1, 237, 1, 1.75, 1.99, 0.00, 0.00, 0, 0, 0.5, 1.99, 1.75, 0.24, 'No', 0.0, 0.0, 0.24, 1],
# Additional test rows...
]
col_names = ['Id', 'WeekofPurchase', 'StoreID', 'PriceCH', 'PriceMM', 'DiscCH', 'DiscMM',
'SpecialCH', 'SpecialMM', 'LoyalCH', 'SalePriceMM', 'SalePriceCH',
'PriceDiff', 'Store7', 'PctDiscMM', 'PctDiscCH', 'ListPriceDiff', 'STORE']
test_df = pd.DataFrame(test_data, columns=col_names)
my_pycaret_model = PyCaretModel(pycaret_model_context)
output_df = my_pycaret_model.predict(test_df)
Etapa 4: Definir uma assinatura de modelo¶
Neste exemplo, use os dados de amostra para inferir uma assinatura do modelo para validação de entrada:
predict_signature = model_signature.infer_signature(input_data=test_df, output_data=output_df)
Etapa 5: Registrar o modelo¶
O código a seguir faz o log (registra) do modelo no Snowflake Model Registry.
snowml_registry = Registry(session)
custom_mv = snowml_registry.log_model(
my_pycaret_model,
model_name="'my_pycaret_best_model",
version_name="version_1",
conda_dependencies=["pycaret==3.0.2", "scipy==1.11.4", "joblib==1.2.0"],
options={"relax_version": False},
signatures={"predict": predict_signature},
comment = 'My PyCaret classification experiment using the CustomModel API'
)
Etapa 6: Verificar o modelo no registro¶
Para verificar se o modelo está disponível no Model Registry, use a função show_models.
snowml_registry.show_models()
Etapa 7: Fazer previsões com o modelo registrado¶
Use a função run para chamar o modelo para previsão.
snowpark_df = session.create_dataframe(test_data, schema=col_nms)
custom_mv.run(snowpark_df).show()
Próximos passos¶
Depois de implantar um modelo PyCaret por meio do Snowflake Model Registry, você pode visualizar o modelo no Snowsight. Navegue até a página Models em AI & ML. Se não o vir, verifique se está usando a função ACCOUNTADMIN ou a função que usou para registrar o modelo.
Para usar o modelo de SQL, use SQL da seguinte forma:
SELECT
my_pycaret_model!predict(*) AS predict_dict,
predict_dict['prediction_label']::text AS prediction_label,
predict_dict['prediction_score']::double AS prediction_score
from pycaret_input_data;