Dela via

Använda funktioner för att träna modeller

  • Artikel

Den här artikeln beskriver hur du kan träna modeller med funktionsutveckling i Unity Catalog eller det lokala funktionsarkivet för arbetsytor. Du måste först skapa en träningsdatauppsättning som definierar vilka funktioner som ska användas och hur du ansluter dem. När du sedan tränar en modell behåller modellen referenser till funktionerna.

När du tränar en modell med funktionsteknik i Unity Catalog kan du visa modellens ursprung i Katalogutforskaren. Tabeller och funktioner som användes för att skapa modellen spåras och visas automatiskt. Se Visa ursprung för funktionsarkiv.

När du använder modellen för slutsatsdragning kan du välja att låta den hämta funktionsvärden från funktionsarkivet. Du kan också hantera modellen med modellservering och den kommer automatiskt att söka efter funktioner som publiceras i onlinebutiker. Funktionslagermodeller är också kompatibla med MLflow pyfunc-gränssnittet, så du kan använda MLflow för att utföra batchinferens med funktionstabeller.

Om din modell använder miljövariabler kan du lära dig mer om hur du använder dem när du hanterar modellen online på Konfigurera åtkomst till resurser från modell som betjänar slutpunkter.

En modell kan använda högst 50 tabeller och 100 funktioner för träning.

Skapa en träningsdatamängd

Om du vill välja specifika funktioner från en funktionstabell för modellträning skapar du en träningsdatauppsättning med api:et FeatureEngineeringClient.create_training_set (för funktionsutveckling i Unity Catalog) eller FeatureStoreClient.create_training_set (för Funktionslager för arbetsyta) och ett objekt som kallas för FeatureLookup. A FeatureLookup anger varje funktion som ska användas i träningsuppsättningen, inklusive namnet på funktionstabellen, namnen på funktionerna och de nycklar som ska användas när du ansluter funktionstabellen med dataramen som skickas till create_training_set. Mer information finns i Funktionssökning .

Använd parametern feature_names när du skapar en FeatureLookup. feature_names tar ett enda funktionsnamn, en lista med funktionsnamn eller Ingen för att leta upp alla funktioner (exklusive primära nycklar) i funktionstabellen när träningsuppsättningen skapas.

Kommentar

Typen och ordningen på lookup_key kolumnerna i DataFrame måste matcha typen och ordningen på de primära nycklarna (exklusive tidsstämpelnycklar) i referensfunktionstabellen.

Den här artikeln innehåller kodexempel för båda versionerna av syntaxen.

I det här exemplet innehåller dataramen som returneras av trainingSet.load_df en kolumn för varje funktion i feature_lookups. Den bevarar alla kolumner i dataramen som tillhandahålls förutom create_training_set de som undantas med hjälp av exclude_columns.

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Skapa en TrainingSet när uppslagsnycklarna inte matchar de primära nycklarna

Använd argumentet lookup_key i FeatureLookup för kolumnnamnet i träningsuppsättningen. create_training_set utför en ordnad koppling mellan kolumnerna från träningsuppsättningen lookup_key som anges i argumentet med hjälp av den ordning som de primära nycklarna angavs när funktionstabellen skapades.

I det här exemplet recommender_system.customer_features har följande primära nycklar: customer_id, dt.

Funktionstabellen recommender_system.product_features har primärnyckeln product_id.

training_df Om har följande kolumner:

  • cid
  • transaction_dt
  • product_id
  • rating

följande kod skapar rätt funktionssökningar för TrainingSet:

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

När create_training_set anropas skapar den en träningsdatauppsättning genom att utföra en vänsterkoppling, ansluta tabellerna recommender_system.customer_features och training_df använda nycklarna (customer_id,dt) som motsvarar (cid,transaction_dt), enligt följande kod:

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Skapa en TrainingSet som innehåller två funktioner med samma namn från olika funktionstabeller

Använd det valfria argumentet output_name i FeatureLookup. Det angivna namnet används i stället för funktionsnamnet i dataramen som returneras av TrainingSet.load_df. Med följande kod innehåller dataramen som returneras av training_set.load_df kolumner och customer_heightproduct_height.

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Skapa en TrainingSet med samma funktion flera gånger

Om du vill skapa en TrainingSet med samma funktion som är kopplad till olika uppslagsnycklar använder du flera FeatureLookups. Använd ett unikt output_name för varje FeatureLookup-utdata.

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Skapa en TrainingSet för oövervakade maskininlärningsmodeller

Ange label=None när du skapar en TrainingSet för oövervakade inlärningsmodeller. Följande TrainingSet kan till exempel användas för att gruppera olika kunder i grupper baserat på deras intressen:

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Träna modeller och utföra batchinferens med funktionstabeller

När du tränar en modell med funktioner från Funktionsarkiv behåller modellen referenser till funktionerna. När du använder modellen för slutsatsdragning kan du välja att låta den hämta funktionsvärden från Funktionsarkiv. Du måste ange primärnyckeln för de funktioner som används i modellen. Modellen hämtar de funktioner som krävs från Funktionsarkivet på din arbetsyta. Sedan kopplas funktionsvärdena efter behov under bedömning.

Så här stöder du funktionssökning vid inferenstid:

  • Du måste logga modellen med hjälp log_model av FeatureEngineeringClient metoden (för Funktionsutveckling i Unity Catalog) eller FeatureStoreClient (för Arbetsytans funktionslager).
  • Du måste använda dataramen som returneras av TrainingSet.load_df för att träna modellen. Om du ändrar dataramen på något sätt innan du använder den för att träna modellen tillämpas inte ändringarna när du använder modellen för slutsatsdragning. Detta minskar modellens prestanda.
  • Modelltypen måste ha en motsvarande python_flavor i MLflow. MLflow stöder de flesta Träningsramverk för Python-modeller, inklusive:
    • scikit-learn
    • keras
    • PyTorch
    • SparkML
    • LightGBM
    • XGBoost
    • TensorFlow Keras (med hjälp av python_flavormlflow.keras)
  • Anpassade MLflow pyfunc-modeller

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Använda anpassade funktionsvärden vid bedömning av en modell som paketeras med funktionsmetadata

Som standard letar en modell som paketerats med funktionsmetadata upp funktioner från funktionstabeller vid slutsatsdragning. Om du vill använda anpassade funktionsvärden för bedömning kan du inkludera dem i dataramen som skickas till FeatureEngineeringClient.score_batch (för funktionsutveckling i Unity Catalog) eller FeatureStoreClient.score_batch (för arbetsytans funktionslager).

Anta till exempel att du paketera en modell med följande två funktioner:

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Vid slutsatsdragning kan du ange anpassade värden för funktionen account_creation_date genom att anropa score_batch på en DataFrame som innehåller en kolumn med namnet account_creation_date. I det här fallet söker API:et num_lifetime_purchases bara upp funktionen från Funktionsarkivet och använder de angivna anpassade account_creation_date kolumnvärdena för modellbedömning.

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Träna och poängsätta en modell med hjälp av en kombination av funktionslagerfunktioner och data som finns utanför funktionsarkivet

Du kan träna en modell med hjälp av en kombination av Funktioner Store-funktioner och data utanför Funktionsarkivet. När du paketera modellen med funktionsmetadata hämtar modellen funktionsvärden från Funktionsarkiv för slutsatsdragning.

Om du vill träna en modell tar du med extra data som kolumner i dataramen som skickas till FeatureEngineeringClient.create_training_set (för funktionsutveckling i Unity Catalog) eller FeatureStoreClient.create_training_set (för arbetsytans funktionslager). I det här exemplet används funktionen total_purchases_30d från Funktionsarkivet och den externa kolumnen browser.

Funktionsteknik i Unity-katalogen

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
)

Funktionsarkiv för arbetsyta

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
)

Vid slutsatsdragning måste dataramen som används i FeatureStoreClient.score_batch innehålla browser kolumnen.

Funktionsteknik i Unity-katalogen

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

Funktionsarkiv för arbetsyta

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

Läsa in modeller och utföra batchinferens med MLflow

När en modell har loggats med metoden log_modelFeatureEngineeringClient (för funktionsteknik i Unity Catalog) eller FeatureStoreClient (för Funktionsarkiv för arbetsyta) kan MLflow användas vid slutsatsdragning. MLflow.pyfunc.predict hämtar funktionsvärden från Funktionsarkivet och ansluter även alla värden som anges vid slutsatsdragningen. Du måste ange primärnyckeln för de funktioner som används i modellen.

Kommentar

Batch-slutsatsdragning med MLflow kräver MLflow version 2.11 och senare. Modeller som använder tidsseriefunktionstabeller stöds inte. Om du vill göra batch-slutsatsdragning med tidsseriefunktionstabeller använder du score_batch. Se Träna modeller och utföra batchinferens med funktionstabeller.

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