Vor- und Nachbearbeitung mit Modellen

In diesem Thema wird anhand einiger Modelltypen und Szenarios erklärt, wie Sie Modelle erstellen, dies in der Snowflake Model Registry protokollieren und dann bereitstellen. Dazu zählen:

  • Speicherinterne scikit-learn-Modelle und -Pipelines.

  • Ihre eigenen benutzerdefinierten Modelle.

  • Mehr als ein Modell.

Speicherinterne scikit-learn-Modelle und -Pipelines.

Snowflake ML ermöglicht die nahtlose Integration von speicherinternen Modellen scikit-learn in die Model Registry durch die Verwendung von Schlüsselwortargumenten mit der Klasse ModelContext. Im Folgenden finden Sie ein Beispiel für die Übergabe eines speicherinternen scikit-learn-Modells als Schlüsselwortargument an den Modellkontext und dessen Aufruf in einer benutzerdefinierten Modellklasse.

from sklearn import datasets, svm
import pandas as pd
from snowflake.ml.model import custom_model

# Step 1: Import the Iris dataset
iris_X, iris_y = datasets.load_iris(return_X_y=True)

# Step 2: Initialize a scikit-learn LinearSVC model and train it
svc = svm.LinearSVC()
svc.fit(iris_X, iris_y)

# Step 3: Initialize ModelContext with keyword arguments
mc = custom_model.ModelContext(
    my_model=svc,
)

# Step 4: Define a custom model class to utilize the context
class ExampleSklearnModel(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 from the context for predictions
        model_output = self.context['my_model'].predict(input)
        # Return the predictions in a DataFrame
        return pd.DataFrame({'output': model_output})
Copy

Verwenden von scikit-learn Pipelines mit Snowflake ML

Das folgende Beispiel zeigt, wie Sie scikit-learn Pipelines innerhalb von Snowflake ML verwenden können. Dazu gehören Vorverarbeitungsschritte wie Skalierung oder Imputation, gefolgt von einem Vorhersagemodell, die alle innerhalb einer benutzerdefinierten Modellklasse unter Verwendung des ModelContext verwaltet werden.

from sklearn import datasets
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
import pandas as pd
from snowflake.ml.model import custom_model

# Step 1: Load the Iris dataset
iris_X, iris_y = datasets.load_iris(return_X_y=True)

# Step 2: Create a scikit-learn pipeline
# The pipeline includes:
# - A SimpleImputer to handle missing values
# - A StandardScaler to standardize the data
# - A Support Vector Classifier (SVC) for predictions
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler()),
    ('classifier', SVC(kernel='linear', probability=True))
])

# Step 3: Fit the pipeline to the dataset
pipeline.fit(iris_X, iris_y)

# Step 4: Initialize ModelContext with the pipeline
mc = custom_model.ModelContext(
    pipeline_model=pipeline,
)

# Step 5: Define a custom model class to utilize the pipeline
class ExamplePipelineModel(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 pipeline from the context to process input and make predictions
        predictions = self.context['pipeline_model'].predict(input)
        probabilities = self.context['pipeline_model'].predict_proba(input)

        # Return predictions and probabilities as a DataFrame
        return pd.DataFrame({
            'predictions': predictions,
            'probability_class_0': probabilities[:, 0],
            'probability_class_1': probabilities[:, 1]
        })

# Example usage:
# Convert new input data into a DataFrame
new_input = pd.DataFrame(iris_X[:5])  # Using the first 5 samples for demonstration

# Initialize the custom model and run predictions
custom_pipeline_model = ExamplePipelineModel(context=mc)
result = custom_pipeline_model.predict(new_input)

print(result)
Copy

Ihr eigenes Modell verwenden

Das folgende Beispiel verwendet Ihr eigenes Modell als benutzerdefiniertes Modell.

mc = custom_model.ModelContext(
    my_model=your_own_model,
)

from snowflake.ml.model import custom_model
import pandas as pd
import json

class ExampleYourOwnModel(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:
        model_output = self.context['my_model'].predict(features)
        return pd.DataFrame({'output': model_output})
Copy

Mehr als ein Modell verwenden

Im Folgenden sehen Sie ein benutzerdefiniertes Modell, das mehrere Modelle kombiniert und eine Konfigurationsdatei verwendet, um bei der Erstellung von Vorhersagen eine Verzerrung anzuwenden.

mc = custom_model.ModelContext(
    model1=model1,
    model2=model2,
    feature_preproc=preproc
    }
)
Copy

Bemerkung

model1 und model2 sind Objekte eines beliebigen Modelltyps, der von der Registry nativ unterstützt wird. feature_preproc ist ein scikit-learn pipeline-Objekt.

from snowflake.ml.model import custom_model
import pandas as pd
import json

class ExamplePipelineModel(custom_model.CustomModel):

    @custom_model.inference_api
    def predict(self, input: pd.DataFrame) -> pd.DataFrame:
        ...
        return pd.DataFrame(...)


# Here is the fully-functional custom model that uses both model1 and model2
class ExamplePipelineModel(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:
        features = self.context['feature_preproc'].transform(input)
        model_output = self.context['model1'].predict(
            self.context['model2'].predict(features)
        )
        return pd.DataFrame({'output': model_output})
Copy
Sprache: Deutsch