Freigeben über

Verwenden von Funktionen zum Trainieren von Modellen

  • Artikel

In diesem Artikel wird beschrieben, wie Sie Modelle mithilfe von Feature Engineering in Unity Catalog oder im lokalen Arbeitsbereichs-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 in Unity Catalog trainieren, können Sie die Modellherkunft 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 verwendet einen einzelnen Featurenamen, eine Liste mit Featurenamen oder „None“ (Keine), um alle Features (mit Ausnahme von Primärschlüsseln) in der Featuretabelle zum Zeitpunkt der Erstellung des Trainingssatzes zu suchen.

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 in Unity Catalog.

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()

Workspace 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 einen geordneten Join zwischen den Spalten aus dem Trainingssatz aus, der im lookup_key-Argument angegeben ist, und verwendet dabei die Reihenfolge, in der die Primärschlüssel beim Erstellen der Featuretabelle angegeben 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 in Unity Catalog.

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'
    )
  ]

Workspace 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 in Unity Catalog.

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"
)

Workspace 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 in Unity Catalog.

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()

Workspace 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 in Unity Catalog.

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'
    )
  ]

Workspace 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 in Unity Catalog.

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()

Workspace 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()

Trainieren von Modellen und Ausführen von Batchrückschlüssen mit Featuretabellen

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_flavor mlflow.keras)
  • Benutzerdefinierte mlflow.pyfunc-Modelle

Feature Engineering in Unity Catalog.

# 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’

Workspace 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 in Unity Catalog.

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

Workspace 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 in Unity Catalog.

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

Workspace 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 in Unity Catalog.

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
)

Workspace 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 in Unity Catalog.

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

Workspace 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 Featurewerte aus dem Featurespeicher ab und verknüpft darüber hinaus alle Werte, die zur Rückschlusszeit 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 Featurewerte

Wenn ein nicht vorhandener Nachschlageschlüssel für die Vorhersage an das Modell übergeben wird, kann der mit FeatureLookup abgerufene Featurewert je nach Umgebung entweder None oder NaN sein. Die Modellimplementierung sollte beide Werte verarbeiten können.

  • Bei Offlineanwendungen, die fe.score_batch verwenden, ist der für ein fehlendes Feature zurückgegebene Wert NaN.
  • Bei Onlineanwendungen mit Model Serving kann der zurückgegebene Wert entweder None oder NaN sein:
    • Wenn keiner der bereitgestellten Nachschlageschlüssel vorhanden ist, lautet der Wert None.
    • Wenn nur eine Teilmenge der Nachschlageschlüssel fehlt, lautet der Wert NaN.

Weitere Informationen zum Behandeln fehlender Featurewerte bei Verwendung von bedarfsgesteuerten Features finden Sie unter Behandeln fehlender Featurewerte.