Traga seus próprios tipos de modelos por meio de arquivos serializados¶
O registro de modelos oferece suporte a vários tipos de modelos incorporados. Você também pode registrar outros tipos de modelos, inclusive os treinados com ferramentas externas ou obtidos de repositórios de código aberto, desde que sejam serializáveis e estendam a classe snowflake.ml.model.custom_model.CustomModel.
Este guia explica como:
Criar modelos personalizados.
Registrá-los no Snowflake Model Registry.
Implementá-los 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 permite um número arbitrário de argumentos de palavras-chave ao instanciar a classe ModelContext, permitindo que você inclua facilmente parâmetros, arquivos de configuração ou instâncias de suas próprias classes de modelo ao definir e inicializar um modelo personalizado.
Os atributos do contexto do modelo podem ser tipos de modelos compatíveis, como tipos de modelos integrados ou um caminho, como um caminho para um diretório que contém um arquivo de modelo, parâmetro ou configuração.
Abaixo está um exemplo que demonstra como fornecer argumentos de palavras-chave por meio do contexto do modelo e como usá-los em uma classe de modelo personalizada:
import json
import pandas as pd
from snowflake.ml.model import custom_model
# Initialize ModelContext with keyword arguments
# my_model can be any kind of model
mc = custom_model.ModelContext(
my_model=my_model,
)
# 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)
@custom_model.inference_api
def predict(self, input: pd.DataFrame) -> pd.DataFrame:
# Use the model 'my_model' from the context to make predictions
model_output = self.context['my_model'].predict(input)
return pd.DataFrame({'output': model_output})
Teste e registro de um modelo personalizado¶
Você pode testar um modelo personalizado executando-o localmente.
my_model = ExampleBringYourOwnModel(mc)
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_pipeline,
model_name="my_custom_model_pipeline",
version_name="v1",
conda_dependencies=["scikit-learn"],
comment="My Custom ML Model Pipeline",
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, especificamos o caminho para o modelo serializado usando o atributo model_file do contexto.
pycaret_mc = custom_model.ModelContext(
model_file = 'pycaret_best_model.pkl',
)
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_mc)
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 Regsitry.
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;