Freigeben über

Verwenden von Funktionen zum Trainieren von Modellen

In diesem Artikel wird beschrieben, wie Sie Modelle mithilfe von Feature Engineering im Unity Catalog oder im Legacy Workspace Feature Store trainieren können. Sie müssen zunächst ein Trainingsdataset erstellen, in dem die zu verwendenden Features und deren Verknüpfung definiert sind. Wenn Sie dann ein Modell trainieren, behält das Modell die Verweise auf die Features bei.

Wenn Sie ein Modell mit Feature Engineering im Unity-Katalog trainieren, können Sie die Modelllinie im Katalog-Explorer anzeigen. Tabellen und Funktionen, die zum Erstellen des Modells verwendet wurden, werden automatisch nachverfolgt und angezeigt. Siehe Datenherkunft des Featurespeichers anzeigen.

Wenn Sie das Modell für Rückschlüsse verwenden, können Sie festlegen, dass Featurewerte aus dem Feature Store abgerufen werden sollen. Sie können das Modell auch mit Model Serving bereitstellen, und es wird automatisch nach Features suchen, die in Onlineshops veröffentlicht wurden. Featurespeichermodelle sind auch mit der pyfunc-Schnittstelle von MLflow kompatibel, sodass Sie MLflow verwenden können, um Batchrückschlüsse mit Featuretabellen durchzuführen.

Wenn Ihr Modell Umgebungsvariablen verwendet, erfahren Sie unter Konfigurieren des Zugriffs auf Ressourcen von Modellbereitstellungsendpunkten, wie Sie sie beim Bereitstellen des Modells verwenden.

Ein Modell kann höchstens 50 Tabellen und 100 Funktionen für Trainings verwenden.

Erstellen eines Trainings-DataSets

Erstellen Sie mithilfe der FeatureEngineeringClient.create_training_set- (für das Feature Engineering in Unity Catalog) oder FeatureStoreClient.create_training_set-API (für einen Feature Store im Arbeitsbereich) ein Trainingsdataset und ein Objekt mit dem Namen FeatureLookup, um bestimmte Features aus einer Featuretabelle für das Modelltraining auszuwählen. Ein FeatureLookup-Objekt gibt jedes Feature an, das im Trainingssatz verwendet werden soll, einschließlich des Namens der Featuretabelle, der Namen der Features und der Schlüssel, die beim Verbinden der Featuretabelle mit dem an create_training_set übergebenen Datenrahmen verwendet werden. Weitere Informationen finden Sie unter Featuresuche.

Verwenden Sie den feature_names-Parameter, wenn Sie ein FeatureLookup erstellen. feature_names nimmt einen einzelnen Funktionsnamen, eine Liste von Funktionsnamen oder None, um alle Funktionen (mit Ausnahme der primären Schlüssel) in der Funktionstabelle zum Zeitpunkt des Erstellens des Trainings-Sets nachzuschlagen.

Hinweis

Der Typ und die Reihenfolge der lookup_key-Spalten im Datenrahmen müssen mit dem Typ und der Reihenfolge der Primärschlüssel (mit Ausnahme der Zeitstempelschlüssel) der Verweisfeaturetabelle übereinstimmen.

Dieser Artikel enthält Codebeispiele für beide Versionen der Syntax.

In diesem Beispiel enthält der von trainingSet.load_df zurückgegebene Datenrahmen eine Spalte für jedes Feature in feature_lookups. Alle Spalten des Datenrahmens für create_training_set werden beibehalten, mit Ausnahme der Spalten, die mit exclude_columns ausgeschlossen wurden.

Feature Engineering im Unity-Katalog

from databricks.feature_engineering import FeatureEngineeringClient, FeatureLookup

# The model training uses two features from the 'customer_features' feature table and
# a single feature from 'product_features'
feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['total_purchases_30d', 'total_purchases_7d'],
      lookup_key='customer_id'
    ),
    FeatureLookup(
      table_name='ml.recommender_system.product_features',
      feature_names=['category'],
      lookup_key='product_id'
    )
  ]

fe = FeatureEngineeringClient()

# Create a training set using training DataFrame and features from Feature Store
# The training DataFrame must contain all lookup keys from the set of feature lookups,
# in this case 'customer_id' and 'product_id'. It must also contain all labels used
# for training, in this case 'rating'.
training_set = fe.create_training_set(
  df=training_df,
  feature_lookups=feature_lookups,
  label='rating',
  exclude_columns=['customer_id', 'product_id']
)

training_df = training_set.load_df()

Arbeitsbereich Feature Store

from databricks.feature_store import FeatureLookup, FeatureStoreClient

# The model training uses two features from the 'customer_features' feature table and
# a single feature from 'product_features'
feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['total_purchases_30d', 'total_purchases_7d'],
      lookup_key='customer_id'
    ),
    FeatureLookup(
      table_name='recommender_system.product_features',
      feature_names=['category'],
      lookup_key='product_id'
    )
  ]

fs = FeatureStoreClient()

# Create a training set using training DataFrame and features from Feature Store
# The training DataFrame must contain all lookup keys from the set of feature lookups,
# in this case 'customer_id' and 'product_id'. It must also contain all labels used
# for training, in this case 'rating'.
training_set = fs.create_training_set(
  df=training_df,
  feature_lookups=feature_lookups,
  label='rating',
  exclude_columns=['customer_id', 'product_id']
)

training_df = training_set.load_df()

Erstellen eines Trainingssets, wenn Nachschlageschlüssel nicht mit den Primärschlüsseln übereinstimmen

Verwenden Sie das Argument lookup_key im FeatureLookup-Objekt für den Spaltennamen im Trainingssatz. create_training_set führt eine geordnete Verknüpfung zwischen den Spalten des im Argument lookup_key angegebenen Trainingssets durch. Dabei wird die Reihenfolge verwendet, in der die primären Schlüssel bei der Erstellung der Featuretabelle festgelegt wurden.

In diesem Beispiel verfügt recommender_system.customer_features über die folgenden Primärschlüssel: customer_id, dt.

Die recommender_system.product_features-Featuretabelle verfügt über den Primärschlüssel product_id.

Wenn das training_df-Objekt die folgenden Spalten aufweist:

  • cid
  • transaction_dt
  • product_id
  • rating

erstellt der folgende Code die richtigen Featuresuchen für TrainingSet:

Feature Engineering im Unity-Katalog

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['total_purchases_30d', 'total_purchases_7d'],
      lookup_key=['cid', 'transaction_dt']
    ),
    FeatureLookup(
      table_name='ml.recommender_system.product_features',
      feature_names=['category'],
      lookup_key='product_id'
    )
  ]

Arbeitsbereich Feature Store

feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['total_purchases_30d', 'total_purchases_7d'],
      lookup_key=['cid', 'transaction_dt']
    ),
    FeatureLookup(
      table_name='recommender_system.product_features',
      feature_names=['category'],
      lookup_key='product_id'
    )
  ]

Wenn create_training_set aufgerufen wird, wird ein Trainings-Datensatz mit einem linken Join erstellt. Dabei werden die Tabellen recommender_system.customer_features und training_df mithilfe der Schlüssel (customer_id,dt) erstellt, die (cid,transaction_dt) entsprechen. Das können Sie im folgenden Code sehen:

Feature Engineering im Unity-Katalog

customer_features_df = spark.sql("SELECT * FROM ml.recommender_system.customer_features")
product_features_df = spark.sql("SELECT * FROM ml.recommender_system.product_features")

training_df.join(
  customer_features_df,
  on=[training_df.cid == customer_features_df.customer_id,
      training_df.transaction_dt == customer_features_df.dt],
  how="left"
).join(
  product_features_df,
  on="product_id",
  how="left"
)

Arbeitsbereich Feature Store

customer_features_df = spark.sql("SELECT * FROM recommender_system.customer_features")
product_features_df = spark.sql("SELECT * FROM recommender_system.product_features")

training_df.join(
  customer_features_df,
  on=[training_df.cid == customer_features_df.customer_id,
      training_df.transaction_dt == customer_features_df.dt],
  how="left"
).join(
  product_features_df,
  on="product_id",
  how="left"
)

Erstellen eines Trainingssets mit zwei Features mit dem gleichen Namen aus verschiedenen Featuretabellen

Verwenden Sie das optionale Argument output_name in FeatureLookup. Der angegebene Name wird anstelle des Featurenamens im Datenrahmen verwendet, der von TrainingSet.load_df zurückgegeben wird. Mit dem folgenden Code enthält der von training_set.load_df zurückgegebene Datenrahmen beispielsweise die Spalten customer_height und product_height.

Feature Engineering im Unity-Katalog

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['height'],
      lookup_key='customer_id',
      output_name='customer_height',
    ),
    FeatureLookup(
      table_name='ml.recommender_system.product_features',
      feature_names=['height'],
      lookup_key='product_id',
      output_name='product_height'
    ),
  ]

fe = FeatureEngineeringClient()

with mlflow.start_run():
  training_set = fe.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label='rating',
    exclude_columns=['customer_id']
  )
  training_df = training_set.load_df()

Arbeitsbereich Feature Store

feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['height'],
      lookup_key='customer_id',
      output_name='customer_height',
    ),
    FeatureLookup(
      table_name='recommender_system.product_features',
      feature_names=['height'],
      lookup_key='product_id',
      output_name='product_height'
    ),
  ]

fs = FeatureStoreClient()

with mlflow.start_run():
  training_set = fs.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label='rating',
    exclude_columns=['customer_id']
  )
  training_df = training_set.load_df()

Mehrmaliges Erstellen eines TrainingSet mithilfe desselben Features

Um ein TrainingSet mit demselben Feature zu erstellen, das durch verschiedene Nachschlageschlüssel verknüpft ist, sollten Sie mehrere FeatureLookups verwenden. Verwenden Sie eine eindeutige output_name für jede FeatureLookup-Ausgabe.

Feature Engineering im Unity-Katalog

feature_lookups = [
    FeatureLookup(
      table_name='ml.taxi_data.zip_features',
      feature_names=['temperature'],
      lookup_key=['pickup_zip'],
      output_name='pickup_temp'
    ),
    FeatureLookup(
      table_name='ml.taxi_data.zip_features',
      feature_names=['temperature'],
      lookup_key=['dropoff_zip'],
      output_name='dropoff_temp'
    )
  ]

Arbeitsbereich Feature Store

feature_lookups = [
    FeatureLookup(
      table_name='taxi_data.zip_features',
      feature_names=['temperature'],
      lookup_key=['pickup_zip'],
      output_name='pickup_temp'
    ),
    FeatureLookup(
      table_name='taxi_data.zip_features',
      feature_names=['temperature'],
      lookup_key=['dropoff_zip'],
      output_name='dropoff_temp'
    )
  ]

Erstellen eines Trainingssets für nicht überwachte Machine Learning-Modelle

Legen Sie label=None fest, wenn Sie ein Trainingsset für nicht überwachte Lernmodelle erstellen. Das folgende Trainingsset kann beispielsweise verwendet werden, um verschiedene Kunden basierend auf ihren Interessen in Gruppen zu gruppieren:

Feature Engineering im Unity-Katalog

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['interests'],
      lookup_key='customer_id',
    ),
  ]

fe = FeatureEngineeringClient()
with mlflow.start_run():
  training_set = fe.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label=None,
    exclude_columns=['customer_id']
  )

  training_df = training_set.load_df()

Arbeitsbereich Feature Store

feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['interests'],
      lookup_key='customer_id',
    ),
  ]

fs = FeatureStoreClient()
with mlflow.start_run():
  training_set = fs.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label=None,
    exclude_columns=['customer_id']
  )

  training_df = training_set.load_df()

Erstellen Sie ein TrainingSet, wenn Sie einen View als Funktionstabelle verwenden

Um eine Ansicht als Featuretabelle zu verwenden, müssen Sie databricks-feature-engineering Version 0.7.0 oder höher verwenden, die in Databricks Runtime 16.0 ML integriert ist.

Der View muss ein einfacher SELECT View aus der Quelltabelle Delta sein. Eine einfache SELECT Ansicht wird als Ansicht definiert, die aus einer einzigen Delta-Tabelle im Unity-Katalog erstellt wird, die als Featuretabelle verwendet werden kann und deren Primärschlüssel ohne JOIN, GROUP BYoder DISTINCT-Klauseln ausgewählt werden. Zulässige Schlüsselwörter in der SQL-Anweisung sind SELECT, FROM, WHERE, ORDER BY, LIMITund OFFSET.

Im folgenden Beispiel ml.recommender_system.customer_table sind Primärschlüssel cid und dt, wobei dt es sich um eine Zeitreihenspalte handelt. Im Beispiel wird davon ausgegangen, dass der datenframe training_df Spalten cid, dtund labelenthält:

from databricks.feature_engineering import FeatureEngineeringClient, FeatureLookup

customer_features_df = spark.sql("CREATE OR REPLACE VIEW ml.recommender_system.customer_features AS SELECT cid, dt, pid, rating FROM ml.recommender_system.customer_table WHERE rating > 3")

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['pid', 'rating'],
      lookup_key=['cid'],
      timestamp_lookup_key='dt'
    ),
]

fe = FeatureEngineeringClient()

training_set = fe.create_training_set(
  df=training_df,
  feature_lookups=feature_lookups,
  label='label'
)

training_df = training_set.load_df()

Erstellen eines Schulungssatzes mit Standardwerten

Beim Erstellen eines Schulungsdatensatzes können Sie Standardwerte für Features angeben, in denen Fälle behandelt werden, in denen der Featurespeicher keinen berechneten Featurewert für eine ID aufweist.

Verwenden Sie zum Angeben von Standardwerten den default_values Parameter in der FeatureLookup.

Im folgenden Beispiel wird veranschaulicht, wie Standardwerte für eine Reihe von Features angegeben werden:

feature_lookups = [
    FeatureLookup(
        table_name="ml.recommender_system.customer_features",
        feature_names=[
            "membership_tier",
            "age",
            "page_views_count_30days",
        ],
        lookup_key="customer_id",
        default_values={
          "age": 18,
          "membership_tier": "bronze"
        },
    ),
]

Wenn die Feature-Spalten mithilfe des rename_outputs Parameters umbenannt werden, muss default_values die umbenannten Feature-Namen verwenden.

FeatureLookup(
  table_name = 'main.default.table',
  feature_names = ['materialized_feature_value'],
  lookup_key = 'id',
  rename_outputs={"materialized_feature_value": "feature_value"},
  default_values={
    "feature_value": 0
  }
)

Trainieren von Modellen und Durchführen von Batch-Ableitungen mit Funktionstabellen

Wenn Sie ein Modell mithilfe von Features aus dem Featurespeicher trainieren, behält das Modell Verweise auf die Features bei. Wenn Sie das Modell für Rückschlüsse verwenden, können Sie festlegen, dass Featurewerte aus dem Featurespeicher abgerufen werden sollen. Sie müssen den oder die Primärschlüssel der im Modell verwendeten Features angeben. Das Modell ruft die Features, die es benötigt, aus dem Featurespeicher in Ihrem Arbeitsbereich ab. Anschließend werden die Featurewerte bei Bedarf während der Bewertung verknüpft.

So können Sie die Featuresuche zur Rückschlusszeit ermöglichen:

  • Sie müssen das Modell mithilfe der log_model-Methode (FeatureEngineeringClient für Feature Engineering in Unity Catalog) oder FeatureStoreClient (für einen Feature Store im Arbeitsbereich) protokollieren.
  • Sie müssen den von TrainingSet.load_df zurückgegebenen Datenrahmen verwenden, um das Modell zu trainieren. Wenn Sie diesen Datenrahmen in irgendeiner Weise ändern, bevor Sie ihn zum Trainieren des Modells verwenden, werden die Änderungen nicht angewendet, wenn Sie das Modell für Rückschlüsse verwenden. Dadurch wird die Leistung des Modells verringert.
  • Der Modelltyp muss über ein entsprechendes python_flavor-Objekt in MLflow verfügen. MLflow unterstützt die meisten Python-Modelltrainingsframeworks, einschließlich:
    • scikit-learn
    • keras
    • PyTorch
    • SparkML
    • LightGBM
    • XGBoost
    • TensorFlow Keras (mit python_flavormlflow.keras)
  • Benutzerdefinierte mlflow.pyfunc-Modelle

Feature Engineering im Unity-Katalog

# Train model
import mlflow
from sklearn import linear_model

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['total_purchases_30d'],
      lookup_key='customer_id',
    ),
    FeatureLookup(
      table_name='ml.recommender_system.product_features',
      feature_names=['category'],
      lookup_key='product_id'
    )
  ]

fe = FeatureEngineeringClient()

with mlflow.start_run():

  # df has columns ['customer_id', 'product_id', 'rating']
  training_set = fe.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label='rating',
    exclude_columns=['customer_id', 'product_id']
  )

  training_df = training_set.load_df().toPandas()

  # "training_df" columns ['total_purchases_30d', 'category', 'rating']
  X_train = training_df.drop(['rating'], axis=1)
  y_train = training_df.rating

  model = linear_model.LinearRegression().fit(X_train, y_train)

  fe.log_model(
    model=model,
    artifact_path="recommendation_model",
    flavor=mlflow.sklearn,
    training_set=training_set,
    registered_model_name="recommendation_model"
  )

# Batch inference

# If the model at model_uri is packaged with the features, the FeatureStoreClient.score_batch()
# call automatically retrieves the required features from Feature Store before scoring the model.
# The DataFrame returned by score_batch() augments batch_df with
# columns containing the feature values and a column containing model predictions.

fe = FeatureEngineeringClient()

# batch_df has columns 'customer_id' and 'product_id'
predictions = fe.score_batch(
    model_uri=model_uri,
    df=batch_df
)

# The 'predictions' DataFrame has these columns:
# 'customer_id', 'product_id', 'total_purchases_30d', 'category', 'prediction'

Arbeitsbereich Feature Store

# Train model
import mlflow
from sklearn import linear_model

feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['total_purchases_30d'],
      lookup_key='customer_id',
    ),
    FeatureLookup(
      table_name='recommender_system.product_features',
      feature_names=['category'],
      lookup_key='product_id'
    )
  ]

fs = FeatureStoreClient()

with mlflow.start_run():

  # df has columns ['customer_id', 'product_id', 'rating']
  training_set = fs.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label='rating',
    exclude_columns=['customer_id', 'product_id']
  )

  training_df = training_set.load_df().toPandas()

  # "training_df" columns ['total_purchases_30d', 'category', 'rating']
  X_train = training_df.drop(['rating'], axis=1)
  y_train = training_df.rating

  model = linear_model.LinearRegression().fit(X_train, y_train)

  fs.log_model(
    model=model,
    artifact_path="recommendation_model",
    flavor=mlflow.sklearn,
    training_set=training_set,
    registered_model_name="recommendation_model"
  )

# Batch inference

# If the model at model_uri is packaged with the features, the FeatureStoreClient.score_batch()
# call automatically retrieves the required features from Feature Store before scoring the model.
# The DataFrame returned by score_batch() augments batch_df with
# columns containing the feature values and a column containing model predictions.

fs = FeatureStoreClient()

# batch_df has columns 'customer_id' and 'product_id'
predictions = fs.score_batch(
    model_uri=model_uri,
    df=batch_df
)

# The 'predictions' DataFrame has these columns:
# 'customer_id', 'product_id', 'total_purchases_30d', 'category', 'prediction'

Verwenden von benutzerdefinierten Featurewerten beim Bewerten eines Modells, das mit Featuremetadaten gepackt ist

Standardmäßig sucht ein Modell, das mit Featuremetadaten gepackt ist, beim Rückschluss Features in Featuretabellen. Um benutzerdefinierte Featurewerte für die Bewertung zu verwenden, fügen Sie sie in den DataFrame ein, der an FeatureEngineeringClient.score_batch (für das Feature Engineering in Unity Catalog) oder FeatureStoreClient.score_batch (für einen Feature Store im Arbeitsbereich) übergeben wird.

Angenommen, Sie packen ein Modell mit diesen beiden Features:

Feature Engineering im Unity-Katalog

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['account_creation_date', 'num_lifetime_purchases'],
      lookup_key='customer_id',
    ),
  ]

Arbeitsbereich Feature Store

feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['account_creation_date', 'num_lifetime_purchases'],
      lookup_key='customer_id',
    ),
  ]

Beim Rückschluss können Sie benutzerdefinierte Werte für das Feature account_creation_date angeben, indem Sie für einen Datenrahmen das score_batch-Objekt aufrufen, das eine Spalte mit dem Namen account_creation_date enthält. In diesem Fall sucht die API nur das num_lifetime_purchases-Feature aus dem Featurespeicher und verwendet die bereitgestellten benutzerdefinierten account_creation_date-Spaltenwerte für die Modellbewertung.

Feature Engineering im Unity-Katalog

# batch_df has columns ['customer_id', 'account_creation_date']
predictions = fe.score_batch(
  model_uri='models:/ban_prediction_model/1',
  df=batch_df
)

Arbeitsbereich Feature Store

# batch_df has columns ['customer_id', 'account_creation_date']
predictions = fs.score_batch(
  model_uri='models:/ban_prediction_model/1',
  df=batch_df
)

Trainieren und Bewerten eines Modells mithilfe einer Kombination aus Featurespeicherfeatures und -daten von außerhalb des Featurespeichers

Sie können ein Modell mithilfe einer Kombination aus Featurespeicherfeatures und -daten von außerhalb des Featurespeichers trainieren. Wenn Sie das Modell mit Featuremetadaten verpacken, ruft das Modell Featurewerte aus dem Featurespeicher für Rückschlüsse ab.

Um ein Modell zu trainieren, schließen Sie die zusätzlichen Daten als Spalten in den DataFrame ein, die an FeatureEngineeringClient.create_training_set (für das Feature Engineering in Unity Catalog) oder FeatureStoreClient.create_training_set (für einen Feature Store im Arbeitsbereich) übergeben werden. In diesem Beispiel werden das Feature total_purchases_30d aus dem Featurespeicher und die externe Spalte browser verwendet.

Feature Engineering im Unity-Katalog

feature_lookups = [
    FeatureLookup(
      table_name='ml.recommender_system.customer_features',
      feature_names=['total_purchases_30d'],
      lookup_key='customer_id',
    ),
  ]

fe = FeatureEngineeringClient()

# df has columns ['customer_id', 'browser', 'rating']
training_set = fe.create_training_set(
  df=df,
  feature_lookups=feature_lookups,
  label='rating',
  exclude_columns=['customer_id']  # 'browser' is not excluded
)

Arbeitsbereich Feature Store

feature_lookups = [
    FeatureLookup(
      table_name='recommender_system.customer_features',
      feature_names=['total_purchases_30d'],
      lookup_key='customer_id',
    ),
  ]

fs = FeatureStoreClient()

# df has columns ['customer_id', 'browser', 'rating']
training_set = fs.create_training_set(
  df=df,
  feature_lookups=feature_lookups,
  label='rating',
  exclude_columns=['customer_id']  # 'browser' is not excluded
)

Beim Rückschluss muss der in FeatureStoreClient.score_batch verwendete Datenrahmen die Spalte browser enthalten.

Feature Engineering im Unity-Katalog

# At inference, 'browser' must be provided
# batch_df has columns ['customer_id', 'browser']
predictions = fe.score_batch(
  model_uri=model_uri,
  df=batch_df
)

Arbeitsbereich Feature Store

# At inference, 'browser' must be provided
# batch_df has columns ['customer_id', 'browser']
predictions = fs.score_batch(
  model_uri=model_uri,
  df=batch_df
)

Laden von Modellen und Durchführen einer Batchrückschlüssen mithilfe von MLflow

Nachdem ein Modell mithilfe der log_model-Methode von FeatureEngineeringClient (für Feature Engineering in Unity Catalog) oder FeatureStoreClient (für den Arbeitsbereichs-Featurespeicher) protokolliert wurde, kann für Rückschlüsse MLflow verwendet werden. mlflow.pyfunc.predict ruft Funktionswerte aus dem Feature Store ab und fügt auch alle Werte zusammen, die zum Zeitpunkt der Ableitung bereitgestellt werden. Sie müssen den oder die Primärschlüssel der im Modell verwendeten Features angeben.

Hinweis

Für Batchrückschlüsse mit MLflow ist MLflow Version 2.11 oder höher erforderlich. Modelle, die Featuretabellen für Zeitreihen verwenden, werden nicht unterstützt. Verwenden Sie score_batch für Batch-Rückschlüsse mit Featuretabellen für Zeitreihen. Siehe Trainieren von Modellen und Ausführen von Batchrückschlüssen mit Featuretabellen.

# Train model
import mlflow
from sklearn import linear_model

feature_lookups = [
  FeatureLookup(
    table_name='ml.recommender_system.customer_features',
    feature_names=['total_purchases_30d'],
    lookup_key='customer_id',
  ),
  FeatureLookup(
    table_name='ml.recommender_system.product_features',
    feature_names=['category'],
    lookup_key='product_id'
  )
]

fe = FeatureEngineeringClient()

with mlflow.start_run():

  # df has columns ['customer_id', 'product_id', 'rating']
  training_set = fe.create_training_set(
    df=df,
    feature_lookups=feature_lookups,
    label='rating',
    exclude_columns=['customer_id', 'product_id']
  )

  training_df = training_set.load_df().toPandas()

  # "training_df" columns ['total_purchases_30d', 'category', 'rating']
  X_train = training_df.drop(['rating'], axis=1)
  y_train = training_df.rating

  model = linear_model.LinearRegression().fit(X_train, y_train)

  fe.log_model(
    model=model,
    artifact_path="recommendation_model",
    flavor=mlflow.sklearn,
    training_set=training_set,
    registered_model_name="recommendation_model",
    #refers to the default value of "result_type" if not provided at inference
    params={"result_type":"double"},
  )

# Batch inference with MLflow

# NOTE: the result_type parameter can only be used if a default value
# is provided in log_model. This is automatically done for all models
# logged using Databricks Runtime for ML 15.0 or above.
# For earlier Databricks Runtime versions, use set_result as shown below.

# batch_df has columns 'customer_id' and 'product_id'
model = mlflow.pyfunc.load_model(model_version_uri)

# If result_type parameter is provided in log_model
predictions = model.predict(df, {"result_type":"double"})

# If result_type parameter is NOT provided in log_model
model._model_impl.set_result_type("double")
predictions = model.predict(df)

Behandeln fehlender Funktionen

Wenn ein nicht vorhandener Lookup-Schlüssel zur Vorhersage an das Modell übergeben wird, kann der durch FeatureLookup abgerufene Funktionswert je nach Umgebung entweder None oder NaN sein. Ihre Implementierung des Modells sollte in der Lage sein, beide Werte zu handhaben.

  • Bei Offline-Anwendungen, die fe.score_batch verwenden, ist der zurückgegebene Wert für eine fehlende Funktion NaN.
  • Bei Online-Anwendungen, die Model Serving verwenden, kann der zurückgegebene Wert entweder None oder NaN lauten:
    • Wenn keiner der angegebenen Lookup-Schlüssel vorhanden ist, lautet der Wert None.
    • Wenn nur eine Untermenge der Lookup-Schlüssel nicht vorhanden ist, lautet der Wert NaN.

Wie Sie bei der Verwendung von on-demand Funktionen mit fehlenden Funktionswerten umgehen, erfahren Sie unter Handling von fehlenden Funktionswerten.

Beispielnotebooks

Das einfache Notizbuch zeigt, wie Sie eine Featuretabelle erstellen, es zum Trainieren eines Modells verwenden und die Batchbewertung mithilfe der automatischen Featuresuche ausführen. Außerdem wird die Feature engineering-Benutzeroberfläche angezeigt, mit der Sie nach Features suchen und verstehen können, wie Features erstellt und verwendet werden.

Grundlegendes zum Feature Engineering im Beispielnotebook für Unity Catalog

Notebook abrufen

Das Taxibeispiel-Notizbuch veranschaulicht den Prozess des Erstellens von Features, des Aktualisierens von Features und deren Verwendung für das Modelltraining und die Batch-Inferenz.

Notebook mit Feature Engineering-Taxibeispiel in Unity Catalog

Notebook abrufen

  • Last updated on