Integrieren eigener Modelltypen mittels serialisierter Dateien¶
Die Modell-Registry unterstützt mehrere integrierte Modelltypen. Sie können auch weitere Typen von Modellen protokollieren, einschließlich solcher, die mit externen Tools trainiert wurden oder aus Open-Source-Repositorys stammen, solange sie serialisierbar sind und die Klasse snowflake.ml.model.custom_model.CustomModel erweitern.
In dieser Anleitung wird Folgendes erklärt:
Erstellen benutzerdefinierter Modelle
Protokollieren dieser Modelle in der Snowflake Model Registry
Bereitstellen dieser Modelle für Inferenz
Bemerkung
Dieser Quickstart bietet ein Beispiel für die Protokollierung eines benutzerdefinierten PyCaret-Modells.
Definieren des Modellkontexts durch Schlüsselwortargumente¶
Snowflake ML erlaubt eine beliebige Anzahl von Schlüsselwortargumenten bei der Instanziierung der Klasse ModelContext, sodass Sie bei der Definition und Initialisierung eines benutzerdefinierten Modells problemlos Parameter, Konfigurationsdateien oder Instanzen Ihrer eigenen Modellklassen einbeziehen können.
Attribute des Modellkontexts können unterstützte Modelltypen sein, z. B. integriert Modelltypen oder ein Pfad, z. B. ein Pfad zu einem Verzeichnis mit einer Modell-, Parameter- oder Konfigurationsdatei.
Nachfolgend finden Sie ein Beispiel für die Bereitstellung von Schlüsselwortargumenten über den Modellkontext und deren Verwendung in einer benutzerdefinierten Modellklasse:
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})
Testen und Protokollieren eines benutzerdefinierten Modells¶
Sie können ein benutzerdefiniertes Modell testen, indem Sie es lokal ausführen.
my_model = ExampleBringYourOwnModel(mc)
output_df = my_model.predict(input_df)
Wenn das Modell wie vorgesehen funktioniert, tragen Sie es in die Snowflake Model Registry ein. Wie im nächsten Codebeispiel gezeigt, geben Sie conda_dependencies (oder pip_requirements) an, um die Bibliotheken anzugeben, die die Modellklasse benötigt. Stellen Sie sample_input_data (ein pandas- oder Snowpark-DataFrame) zur Verfügung, um die Eingabesignatur für das Modell abzuleiten. Alternativ können Sie auch eine Modellsignatur bereitstellen.
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)
Beispiel: Protokollieren eines PyCaret-Modells¶
PyCaret ist ein Low-Code-Paket eines Drittanbieters mit hoher Effizienz, das Snowflake nicht nativ unterstützt. Sie können Ihre eigenen Modelltypen mit ähnlichen Methoden integrieren.
Schritt 1: Modellkontext definieren¶
Bevor Sie das Modell protokollieren, definieren Sie einen ModelContext, der auf Ihren eigenen Modelltyp verweist, der von Snowflake ML nicht nativ unterstützt wird. In diesem Fall geben wir den Pfad zum serialisierten (pickled) Modell über das model_file-Attribut des Kontexts an.
pycaret_mc = custom_model.ModelContext(
model_file = 'pycaret_best_model.pkl',
)
Schritt 2: Benutzerdefinierte Modellklasse erstellen¶
Definieren Sie eine benutzerdefinierte Modellklasse, um einen Modelltyp ohne native Unterstützung zu protokollieren. In diesem Beispiel wird eine PyCaretModel-Klasse definiert, die von CustomModel abgeleitet ist, damit das Modell in der Registry protokolliert werden kann.
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']
})
Bemerkung
Legen Sie, wie gezeigt, das Speicherverzeichnis des Modells auf /tmp/ fest. Die Warehouse-Knoten von Snowflake haben einen eingeschränkten Zugriff auf Verzeichnisse. /tmp ist immer beschreibbar und ist eine sichere Wahl, wenn das Modell einen Platz zum Schreiben von Dateien benötigt. Bei anderen Typen von Modellen ist dies möglicherweise nicht erforderlich.
Schritt 3: Benutzerdefiniertes Modell testen¶
Testen Sie das PyCaret-Modell lokal mit einem Code wie dem folgenden.
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)
Schritt 4: Modellsignatur definieren¶
In diesem Beispiel verwenden Sie die Beispieldaten, um eine Modellsignatur zur Eingabevalidierung abzuleiten:
predict_signature = model_signature.infer_signature(input_data=test_df, output_data=output_df)
Schritt 5: Modell protokollieren¶
Der folgende Code protokolliert (registriert) das Modell in der 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'
)
Schritt 6: Modell in der Registry überprüfen¶
Um zu überprüfen, ob das Modell in der Model Registry verfügbar ist, verwenden Sie die Funktion show_models.
snowml_registry.show_models()
Schritt 7: Vorhersagen mit dem registrierten Modell machen¶
Verwenden Sie die Funktion run, um das Modell für die Vorhersage aufzurufen.
snowpark_df = session.create_dataframe(test_data, schema=col_nms)
custom_mv.run(snowpark_df).show()
Nächste Schritte¶
Nachdem Sie ein PyCaret-Modell über die Snowflake Model Registry bereitgestellt haben, können Sie das Modell in Snowsight anzeigen. Rufen Sie die Seite Models unter AI & ML auf. Wenn Sie es dort nicht sehen, vergewissern Sie sich, dass Sie die ACCOUNTADMIN-Rolle oder die Rolle verwenden, die Sie zum Protokollieren des Modells verwendet haben.
Um das Modell von SQL aus zu verwenden, nutzen Sie SQL wie folgt:
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;