Używanie funkcji do trenowania modeli

W tym artykule opisano sposób trenowania modeli przy użyciu Feature Engineering w Unity Catalog lub starszego Workspace Feature Store. Najpierw należy utworzyć zestaw danych szkoleniowych, który definiuje funkcje do użycia i sposób ich dołączania. Następnie podczas trenowania modelu model zachowuje odwołania do funkcji.

Podczas trenowania modelu przy użyciu Feature Engineering w Unity Catalog można wyświetlić genezę modelu w Katalog Explorer. Tabele i funkcje, które zostały użyte do utworzenia modelu, są automatycznie śledzone i wyświetlane. Zobacz Zarządzanie funkcjami i pochodzenie danych.

Jeśli używasz modelu do wnioskowania, możesz pobrać wartości funkcji z magazynu funkcji. Możesz również obsłużyć model z obsługą modelu i będzie automatycznie wyszukiwać funkcje opublikowane w sklepach online. Modele przechowywania funkcji są również zgodne z interfejsem MLflow pyfunc, więc można użyć interfejsu MLflow pyfunc do wnioskowania wsadowego z tabelami funkcji.

Jeśli model używa zmiennych środowiskowych, dowiedz się więcej o sposobie ich używania podczas obsługi modelu w trybie online w artykule Konfigurowanie dostępu do zasobów z punktów końcowych obsługujących model.

Model może używać co najwyżej 50 tabel i 100 funkcji do trenowania.

Tworzenie zestawu danych szkoleniowych

Aby wybrać określone funkcje z tabeli funkcji na potrzeby trenowania modelu, należy utworzyć zestaw danych szkoleniowych przy użyciu FeatureEngineeringClient.create_training_set (dla Feature Engineering w Unity Catalog) lub interfejsu API FeatureStoreClient.create_training_set (dla Workspace Feature Store) oraz obiektu o nazwie FeatureLookup. FeatureLookup określa każdy element do użycia w zestawie treningowym, w tym nazwę tabeli cech, nazwy cech oraz klucze, które mają być używane podczas łączenia tabeli cech z DataFrame przekazanym do create_training_set. Aby uzyskać więcej informacji, zobacz Wyszukiwanie funkcji.

Użyj parametru feature_names podczas tworzenia elementu FeatureLookup. feature_names przyjmuje pojedynczą nazwę cechy, listę nazw cech lub "None," aby wyszukać wszystkie cechy (z wyłączeniem kluczy podstawowych) w tabeli cech w momencie utworzenia zbioru treningowego.

Ten artykuł zawiera przykłady kodu dla obu wersji składni.

W tym przykładzie ramka danych zwrócona przez trainingSet.load_df zawiera kolumnę dla każdej funkcji w feature_lookups. Zachowuje wszystkie kolumny ramki danych podane do create_training_set z wyjątkiem tych wykluczonych przy użyciu exclude_columns.

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Tworzenie elementu TrainingSet, gdy klucze odnośnika nie są zgodne z kluczami podstawowymi

Użyj argumentu lookup_key w FeatureLookup jako nazwy kolumny w zestawie treningowym. create_training_set wykonuje uporządkowane sprzężenia między kolumnami z zestawu treningowego określonego w argumencie lookup_key przy użyciu kolejności, w której klucze podstawowe zostały określone podczas tworzenia tabeli funkcji.

W tym przykładzie recommender_system.customer_features są następujące klucze podstawowe: customer_id, dt.

Tabela funkcji recommender_system.product_features ma klucz podstawowy product_id.

Jeśli training_df ma następujące kolumny:

• cid
• transaction_dt
• product_id
• rating

Poniższy kod spowoduje utworzenie prawidłowych odnośników funkcji dla elementu TrainingSet:

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Gdy wywoływany jest create_training_set, tworzy zestaw danych treningowych, wykonując połączenie lewostronne, łącząc tabele recommender_system.customer_features i training_df poprzez klucze (customer_id,dt) odpowiadające (cid,transaction_dt), jak pokazano w poniższym kodzie:

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Tworzenie zestawu TrainingSet zawierającego dwie funkcje o tej samej nazwie z różnych tabel funkcji

Użyj opcjonalnego argumentu output_name w elem.FeatureLookup Podana nazwa jest używana zamiast nazwy funkcji w ramce danych zwracanej przez TrainingSet.load_dfelement . Na przykład przy użyciu następującego kodu ramka danych zwrócona przez training_set.load_df zawiera kolumny customer_height i product_height.

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Tworzenie zestawu trainingSet przy użyciu tej samej funkcji wiele razy

Aby utworzyć zestaw TrainingSet przy użyciu tej samej funkcji przyłączonej przez różne klucze odnośników, użyj wielu funkcjiLookups. Użyj unikatowego output_name elementu dla poszczególnych danych wyjściowych funkcjiLookup.

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Tworzenie zestawu szkoleniowego dla nienadzorowanych modeli uczenia maszynowego

Ustaw label=None podczas tworzenia zestawu treningowego dla modeli uczenia nienadzorowanego. Na przykład następujący zestaw TrainingSet może służyć do klastrowania różnych klientów w grupach na podstawie ich zainteresowań:

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Tworzenie zestawu TrainingSet w przypadku korzystania z widoku jako tabeli funkcji

Aby użyć widoku jako tabeli funkcji, należy użyć databricks-feature-engineering w wersji 0.7.0 lub nowszej, która jest wbudowana w środowisko Databricks Runtime 16.0 ML.

Widok musi być prostym widokiem SELECT ze źródłowej tabeli Delta. Prosty widok SELECT jest definiowany jako widok utworzony na podstawie pojedynczej tabeli Delta w katalogu Unity, który może być używany jako tabela cech i w którym klucze główne są wybierane bez klauzul JOIN, GROUP BYlub DISTINCT. Dopuszczalne słowa kluczowe w instrukcji SQL to SELECT, FROM, WHERE, ORDER BY, LIMITi OFFSET.

W poniższym przykładzie ml.recommender_system.customer_table ma klucze cid podstawowe i dt, gdzie dt jest kolumną szeregów czasowych. W przykładzie przyjęto założenie, że ramka danych training_df zawiera kolumny cid, dti label:

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

Tworzenie zestawu treningowego z wartościami domyślnymi

Podczas tworzenia zestawu danych treningowych można określić wartości domyślne dla cech do obsługi przypadków, w których repozytorium cech nie ma obliczonej wartości cechy dla danego identyfikatora.

Aby określić wartości domyślne, użyj parametru default_values w pliku FeatureLookup.

W poniższym przykładzie pokazano, jak określić wartości domyślne dla zestawu funkcji:

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"
        },
    ),
]

Jeśli nazwy kolumn funkcji zostaną zmienione przy użyciu parametru rename_outputs , default_values należy użyć nazw funkcji o zmienionej nazwie.

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

Trenowanie modeli i wykonywanie wnioskowania wsadowego za pomocą tabel cech

Podczas trenowania modelu przy użyciu funkcji ze sklepu Feature Store model zachowuje odwołania do funkcji. Jeśli używasz modelu do wnioskowania, możesz sprawić, aby pobrał wartości cech z Feature Store. Musisz podać podstawowe klucze funkcji używanych w modelu. Model pobiera funkcje wymagane ze sklepu Feature Store w obszarze roboczym. Następnie łączy wartości funkcji zgodnie z potrzebami podczas oceniania.

Aby obsługiwać wyszukiwanie funkcji w czasie wnioskowania:

• Należy zarejestrować model przy użyciu metody log_modelFeatureEngineeringClient (dla przygotowywania cech w Unity Catalog) lub FeatureStoreClient (w przypadku Workspace Feature Store).
• Aby wytrenować model, musisz użyć ramki danych zwróconej przez TrainingSet.load_df program . Jeśli zmodyfikujesz tę ramkę danych w jakikolwiek sposób przed użyciem go do trenowania modelu, modyfikacje nie będą stosowane podczas korzystania z modelu do wnioskowania. Zmniejsza to wydajność modelu.
• Typ modelu musi mieć odpowiedni python_flavor element w narzędziu MLflow. Platforma MLflow obsługuje większość platform trenowania modeli języka Python, w tym:
  • scikit-learn
  • Keras
  • PyTorch
  • SparkML
  • LightGBM
  • XGBoost
  • TensorFlow Keras (przy użyciu elementu python_flavormlflow.keras)
• Niestandardowe modele Pyfunc platformy MLflow

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Używanie niestandardowych wartości funkcji podczas oceniania modelu spakowanego za pomocą metadanych funkcji

Domyślnie model spakowany z metadanymi funkcji wyszukuje funkcje z tabel funkcji podczas wnioskowania. Aby użyć niestandardowych wartości cech do skoringu, uwzględnij je w ramce danych przesyłanej do FeatureEngineeringClient.score_batch (dla Feature Engineering w Unity Catalog) lub FeatureStoreClient.score_batch (dla Workspace Feature Store).

Załóżmy na przykład, że utworzysz pakiet modelu z następującymi dwiema funkcjami:

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Podczas wnioskowania można podać niestandardowe wartości dla funkcji account_creation_date, wywołując score_batch w DataFrame, który zawiera kolumnę o nazwie account_creation_date. W tym przypadku API wyszukuje tylko cechę num_lifetime_purchases z Feature Store i korzysta z podanych niestandardowych wartości kolumn account_creation_date dla oceny modelu.

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Trenowanie i ocenianie modelu przy użyciu kombinacji funkcji sklepu Feature Store i danych znajdujących się poza magazynem funkcji

Model można wytrenować przy użyciu kombinacji funkcji i danych ze sklepu Feature Store spoza sklepu Feature Store. Podczas tworzenia pakietu modelu z metadanymi funkcji model pobiera wartości funkcji z magazynu funkcji w celu wnioskowania.

Aby wytrenować model, uwzględnij dodatkowe dane jako kolumny w ramce danych przekazanej do FeatureEngineeringClient.create_training_set (w przypadku Feature Engineering w Unity Catalog) lub FeatureStoreClient.create_training_set (w przypadku Workspace Feature Store). W tym przykładzie wykorzystano funkcję total_purchases_30d z Feature Store i zewnętrzną kolumnę browser.

Inżynieria funkcji w Katalogu Unity

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
)

Magazyn funkcji obszaru roboczego

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
)

W wnioskowaniu ramka danych używana w FeatureStoreClient.score_batch musi zawierać kolumnę browser.

Inżynieria funkcji w Katalogu Unity

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

Magazyn funkcji obszaru roboczego

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

Ładowanie modeli i wykonywanie wnioskowania wsadowego przy użyciu biblioteki MLflow

Po zarejestrowaniu modelu przy użyciu metody log_modelFeatureEngineeringClient (w przypadku inżynierii cech w katalogu aparatu Unity) lub FeatureStoreClient (w przypadku magazynu funkcji obszaru roboczego) można użyć biblioteki MLflow podczas wnioskowania. mlflow.pyfunc.predict pobiera wartości cech z Feature Store i łączy wszystkie wartości podane w trakcie wnioskowania. Musisz podać podstawowe klucze funkcji używanych w modelu.

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

Obsługa brakujących wartości funkcji

Gdy klucz wyszukiwania nieistniejącego jest przekazywany do modelu na potrzeby przewidywania, wartość funkcji pobierana przez FeatureLookup element może być albo None , w NaNzależności od środowiska. Implementacja modelu powinna być w stanie obsłużyć obie wartości.

• W przypadku aplikacji w trybie offline przy użyciu metody fe.score_batchzwracana wartość brakującej funkcji to NaN.
• W przypadku aplikacji online korzystających z funkcji modelowania zwracana wartość może mieć wartość None lub NaN:
  • Jeśli żaden z podanych kluczy odnośników nie istnieje, wartość to None.
  • Jeśli nie istnieje tylko podzbiór kluczy odnośników, wartość to NaN.

Aby obsłużyć brakujące wartości funkcji podczas korzystania z funkcji na żądanie, zobacz Jak obsługiwać brakujące wartości funkcji.

Przykładowe notatniki

W podstawowym notatniku pokazano sposób tworzenia tabeli cech, jej użycie do szkolenia modelu i uruchamianie ocen wsadowych przy użyciu automatycznego wyszukiwania cech. Przedstawia również interfejs użytkownika inżynierii funkcji, którego można użyć do wyszukiwania funkcji i zrozumienia sposobu tworzenia i używania funkcji.

Przykładowy notatnik podstawowej inżynierii cech w katalogu Unity

Pobierz laptopa

Przykładowy notatnik dotyczący taksówek ilustruje proces tworzenia cech, ich aktualizowania i wykorzystywania do trenowania modelu oraz wnioskowania zbiorczego.

Inżynieria funkcji w Unity Catalog na przykładzie notatnika taxi

Pobierz laptopa