Materialisera funktionsvyer

Viktigt!

Den här funktionen finns som allmänt tillgänglig förhandsversion. Arbetsyteadministratörer kan styra åtkomsten till den här funktionen från sidan Förhandsversioner . Se Hantera förhandsversioner av Azure Databricks.

När du har skapat definitionerna för funktionsvyn, som lagras i Unity Catalog, kan du skapa funktionsdata från källtabellen med hjälp av funktionsdefinitionerna. Den här processen kallas materialisering av dina funktioner. Azure Databricks skapar och hanterar Lakeflow-pipelines för att fylla i tabeller i Unity Catalog för modellträning och batchbedömning eller onlineservering.

Mer information om servering av Feature Views finns i Serve Feature Views.

Kravspecifikation

  • Funktioner måste skapas som funktionsvyer och lagras i Unity Catalog.
  • Versionskrav finns i Krav.
  • ColumnSelection funktioner kan förverkligas i onlinebutiker. Se ColumnSelection-materialisering.
  • RequestSource det går inte att materialisera funktionerna eftersom de representerar data som tillhandahålls vid slutsatsdragningen.

behörigheter

Materialisering samspelar med MANAGE och READ FEATURE Unity Catalog-behörigheterna på funktionen. Fullständiga behörighetsbeskrivningar finns i LÄS FUNKTION.

  • Materialisering av en funktion kräver MANAGE. Att anropa materialize_features eller delete_materialized_feature skapar och hanterar de bakomliggande Lakeflow-pipelines och Unity Catalog-tabellerna, så detta är en hanteringsåtgärd. Du måste ha MANAGE på funktionen, tillsammans med READ FEATURE för att läsa funktionsdefinitionen som materialiseras.
  • Läsning av materialiserade data kräver READ FEATURE. READ FEATURE på funktionen ger åtkomst till de offline- och onlinetabeller som stöder den, så att du kan använda materialiserade data för modellträning och servering. list_materialized_features kräver också READ FEATURE.

Precis som med alla Unity Catalog-objekt behöver USE CATALOG du även i den överordnade katalogen och USE SCHEMA i det överordnade schemat. READ FEATURE och MANAGE som beviljas för ett schema eller en katalog gäller alla nuvarande och framtida objekt som det innehåller.

API-datastrukturer

OfflineStoreConfig

Konfiguration för offline-lagret där materialiserade funktioner skrivs in. När materialize_features anropas skapar funktionsarkivets serverdel tabeller med det här prefixet. Varje pipelinekörning materialiserar de senaste egenskapsvärdena i tabellen enligt schema för materialisering.

OfflineStoreConfig(
    catalog_name: str,        # Catalog name for the offline table where materialized features will be stored
    schema_name: str,         # Schema name for the offline table
    table_name_prefix: str    # Table name prefix for the offline table. The pipeline may create multiple tables with this prefix, each updated at different cadences
)

from databricks.feature_engineering.entities import OfflineStoreConfig

offline_store = OfflineStoreConfig(
    catalog_name="main",
    schema_name="feature_store",
    table_name_prefix="customer_features"
)

OnlineStoreConfig

Konfiguration för onlinebutiken, som lagrar funktioner som används av modellservern. Materialisering skapar Delta-tabeller med catalog.schema.table_name_prefix, och strömmar tabellerna till Online Feature Store med samma namn.

from databricks.feature_engineering.entities import OnlineStoreConfig

online_store = OnlineStoreConfig(
    catalog_name="main",
    schema_name="feature_store",
    table_name_prefix="customer_features_serving",
    online_store_name="customer_features_store"
)

MaterializedFeature

Representerar en funktionsvy som har materialiserats, d.v.s. en förberäknad representation som är tillgänglig i Unity Catalog. Det finns separata materialiserade funktioner för offlinetabellen och onlinetabellen. Vanligtvis instansierar användarna inte en MaterializedFeature direkt.

API-funktionsanrop

materialize_features()

Materialiserar en lista över funktionsvyer i antingen en deltatabell offline eller till en onlinefunktionsbutik. Egenskaper måste registreras i Unity Catalog innan den här funktionen anropas (till exempel med create_feature eller register_feature). Lokalt konstruerade funktioner som inte har registrerats fungerar inte.

FeatureEngineeringClient.materialize_features(
    features: List[Feature],                                               # List of Feature Views to materialize
    offline_config: Optional[OfflineStoreConfig] = None,                   # Offline store config (aggregation features only)
    online_config: Optional[OnlineStoreConfig] = None,                     # Online store config
    trigger: Union[CronSchedule, TableTrigger, StreamingMode],              # Materialization trigger
) -> List[MaterializedFeature]:

Metoden returnerar en lista över materialiserade funktioner som innehåller metadata om när funktionsvärden uppdateras och Unity Catalog-tabellerna där funktionerna materialiseras.

Om både en OnlineStoreConfig och en OfflineStoreConfig tillhandahålls returneras två materialiserade funktioner per tillhandahållen funktion, en för varje typ av butik.

Parametern trigger styr när materialiseringspipelinen körs:

  • CronSchedule: Körs enligt ett fast schema. Stöds för batchaggregeringsfunktioner (AggregationFunction från DeltaTableSource).
  • TableTrigger: Körs när den uppströms Delta-tabellen tar emot en commit. Stöd för ColumnSelection funktioner och aggregeringsfunktioner (AggregationFunction) som stöds av en DeltaTableSource. För aggregeringsfunktioner stryps pipelinen till att köras högst en gång per halva funktionens fönsterlängd. Till exempel högst en gång var 30:e minut under ett 1-timmesfönster, men aldrig oftare än var 5:e minut.
  • StreamingMode: Körs som en pipeline för kontinuerlig direktuppspelning. Krävs för funktioner som backas upp av en StreamSource.

Du kan inte blanda funktioner som kräver olika utlösartyper i ett enda materialize_features anrop. Utfärda separata anrop i stället.

Materialisera till offlinebutik

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    CronSchedule, OfflineStoreConfig,
)

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=features,
    offline_config=OfflineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="customer_features"
    ),
    trigger=CronSchedule(
        quartz_cron_expression="0 0 * * * ?",  # Hourly
        timezone_id="UTC",
    ),
)

Materialisera till onlinebutik

Note

Om du vill materialisera aggregeringsfunktioner till en onlinebutik måste du även materialisera till en offlinebutik. Både offline_config och online_config krävs. online_store_name Måste referera till en befintlig onlinefunktionsbutik. Anvisningar om hur du skapar en finns i Databricks Online Feature Stores.

ColumnSelection funktionaliteter kräver inte en OfflineStoreConfig. Se ColumnSelection-materialisering.

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    CronSchedule, OfflineStoreConfig, OnlineStoreConfig,
)

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=features,
    offline_config=OfflineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="customer_features"
    ),
    online_config=OnlineStoreConfig(
        catalog_name="main",
        schema_name="feature_store",
        table_name_prefix="customer_features_serving",
        online_store_name="customer_features_store"
    ),
    trigger=CronSchedule(
        quartz_cron_expression="0 0 * * * ?",  # Hourly
        timezone_id="UTC",
    ),
)

Materialisera strömningsfunktioner

Direktuppspelningsfunktioner kan bara materialiseras till onlinebutiker. parametern offline_config stöds inte. Offline-materialisering stöds inte eftersom streamingfunktioner kräver en realtidspipeline för att säkerställa uppdatering inom mindre än en sekund. För offlineträning eller utvärdering beräknar funktionsteknikerklienten om funktionsvärdena baserat på varje utvärderad datapunkt.

Direktuppspelningsfunktioner kan inte blandas med batchfunktioner i samma materialize_features anrop.

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    OnlineStoreConfig, StreamingMode,
)

fe = FeatureEngineeringClient()

materialized = fe.materialize_features(
    features=[streaming_feature],
    online_config=OnlineStoreConfig(
        catalog_name="my_catalog",
        schema_name="my_schema",
        table_name_prefix="streaming_features_serving",
        online_store_name="feature_store_online"
    ),
    trigger=StreamingMode(),
)

list_materialized_features()

Returnerar materialiseringarna för en enskild funktion som identifieras med dess fullständiga namn. feature_name är obligatorisk och kan endast anges som nyckelordsargument. Om du vill granska materialiseringarna i många funktioner anger du först funktionerna i en katalog eller ett schema och anropar list_materialized_features sedan varje funktion som returneras.

Som standard returneras högst 100 materialiseringar. Du kan ändra den här gränsen med hjälp av parametern max_results .

FeatureEngineeringClient.list_materialized_features(
    *,                                      # Arguments are keyword-only
    feature_name: str,                      # Required: full name of the feature whose materializations to list
    max_results: int = 100,                 # Maximum number of materializations to return
) -> List[MaterializedFeature]:

delete_materialized_feature()

Innan du tar bort en materialiserad funktion tar du bort eller uppdaterar modeller eller funktionsspecifikationer som refererar till funktionen.

Tar bort en materialiserad funktion. Vilken funktion som ska skickas beror på funktionstypen:

  • Sammansättningsfunktioner: Skicka den materialiserade offlinefunktionen. Om det finns en materialiserad onlinefunktion för samma funktion tas båda bort.
  • ColumnSelection funktioner: Överför den materialiserade funktionen online. ColumnSelection funktioner materialiseras endast i onlinebutiken (se ColumnSelection-materialisering), så det finns ingen motsvarande offlinefunktion.

Som en del av materialiseringen grupperas funktionerna efter datakälla och aggregeringsfönster för effektivitet. ColumnSelection funktioner har inget aggregeringsfönster, så de grupperas endast efter datakälla. Materialiseringspipelinen, offlinetabellen och onlinetabellen tas inte bort förrän alla grupperade funktioner har tagits bort. När den senaste materialiserade funktionen i en grupp tas bort schemalägger funktionsarkivet de associerade resurserna för automatisk rensning av en bakgrundsprocess. Se Rensning av bakgrundsresurser.

Om du vill rensa materialiserade funktioner kan du titta på tabellen som är associerad med en materialiserad funktion. Varje funktion i tabellen (en per kolumn) måste tas bort innan beräknings- och Delta-tabellresurser rensas.

Använd list_materialized_features() för att hämta materialized_feature argumentet.

FeatureEngineeringClient.delete_materialized_feature(
    materialized_feature: MaterializedFeature,  # Required: The materialized feature to delete
) -> None

from databricks.feature_engineering import FeatureEngineeringClient

fe = FeatureEngineeringClient()

feature_names = [
    "main.feature_store.amount_sum_sliding_7d_1d",
    "main.feature_store.amount_sum_sliding_30d_1d",
    "main.feature_store.transaction_count_sliding_7d_1d",
    "main.feature_store.latest_transaction_amount",
    "main.feature_store.latest_user_tier",
]

for name in feature_names:
    mfs = fe.list_materialized_features(feature_name=name)   # required, keyword-only
    offline = [mf for mf in mfs if not mf.is_online]
    for mf in (offline or mfs):
        fe.delete_materialized_feature(materialized_feature=mf)
    fe.delete_feature(full_name=name)

ColumnSelection-materialisering

ColumnSelection funktioner väljer det senaste värdet för en enskild kolumn per entitetsnyckel utan aggregering. De kan bara realiseras i onlinebutiker. För offlineanvändningsfall (träning och batchinferens) ColumnSelection hämtas funktionerna direkt från källdata vid frågetillfället, så offlinematerialisering behövs inte.

Materialiseringsbeteende

  • Pipelinen skriver den senaste raden per entitetsnyckel till onlinetabellen, utan aggregeringsfönster.
  • Onlinematerialisering fyller onlinetabellen med det senaste värdet per entitetsnyckel.

Exempel

from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering.entities import (
    DeltaTableSource, Feature, ColumnSelection, TableTrigger, OnlineStoreConfig,
)

fe = FeatureEngineeringClient()

delta_source = DeltaTableSource(
    catalog_name="catalog",
    schema_name="schema",
    table_name="transactions",
)

amount_feature = Feature(
    source=delta_source,
    function=ColumnSelection("amount"),
    entity=["user_id"],
    timeseries_column="transaction_time",
    name="latest_transaction_amount",
)

# Register before materializing
amount_feature = fe.register_feature(
    feature=amount_feature,
    catalog_name="catalog",
    schema_name="schema",
)

mfs = fe.materialize_features(
    features=[amount_feature],
    online_config=OnlineStoreConfig(
        catalog_name="catalog",
        schema_name="feats_online",
        table_name_prefix="txn_",
        online_store_name="lb_usw2"
    ),
    trigger=TableTrigger(),
)

ColumnSelection-funktioner använder TableTrigger, som kör pipelinen när källtabeln Delta tar emot en ny commit. Nej offline_config behövs eftersom ColumnSelection funktioner läss direkt från källan för offlineanvändningsfall (träning och batchinferens).

Note

RequestSource funktioner kan inte materialiseras eftersom de representerar data som tillhandahålls av anroparen vid slutsatsdragningstid (eller extraheras från den märkta DataFrame vid träningstid). Det finns ingen källtabell att läsa från. Värdena finns bara i nyttolasten för begäran eller i dataramen för träning.

Rensning av bakgrundsresurser

När du tar bort en materialiserad funktion tar Databricks bort funktionsmetadata omedelbart. Den tillhörande infrastrukturen (tabeller, pipelines och jobb) rensas asynkront av en bakgrundsprocess.

Eftersom flera materialiserade funktioner kan dela samma tabeller och pipelines tas inte dessa delade resurser bort förrän alla materialiserade funktioner som refererar till dem har tagits bort. När den senaste materialiserade funktionen som delar en uppsättning tabeller tas bort tar bakgrundsprocessen automatiskt bort följande resurser:

  • Delta-offlinetabellerna som innehåller materialiserade funktionsdata
  • Onlinetabellerna, om funktionerna materialiserades till en onlinebutik
  • Materialiseringspipelinen
  • Orkestreringsjobbet

Den här bakgrundsprocessen använder ett systemtjänsthuvudnamn som hanteras av Databricks för att utföra dessa rensningsåtgärder åt dig, bland annat genom att ta bort tabeller, pipelines och jobb i arbetsytan. Ingen åtgärd krävs från din sida. Rensningen hanteras fullständigt av feature store.

Note

Det kan uppstå en kort fördröjning mellan borttagningen av den senaste materialiserade funktionen i en grupp och borttagningen av de associerade tabellerna och andra resurser.

Visa materialiseringsstatus

För att se materialiseringsstatusen för dina Feature Views i Databricks UI och felsöka materialiseringsfel, se Utforska Feature Views i Unity-katalogen.

Begränsningar

Batch-funktioner

  • Pipelines för materialisering i batch körs som serverlösa Lakeflow-pipelines.
  • Funktioner för rullande batchfönster kan inte materialiseras. På grund av hög precision i tidskorrekthet genereras rullande fönsterfunktioner för offlineträning eller batchinferens dynamiskt för varje datapunkt.
  • ColumnSelection funktioner kan endast göras tillgängliga för onlinebutiker.
  • RequestSource funktioner kan inte materialiseras.
  • Materialiserade funktioner kan bara tas bort på arbetsytan där de skapades.
  • För materialiserade aggregeringsfunktioner kan den materialiserade onlinefunktionen inte tas bort direkt. Ta bort den kopplade offlinematerialiserade funktionen och ändringen sprids till båda.
  • För materialiserade aggregeringsfunktioner som skapades före den 20 april 2026 fortsätter materialiseringspipelinen att producera nya funktionsvärden tills alla materialiserade funktioner i pipelinen har tagits bort, vilket utlöser resursrensning. Om du vill skapa en uppdaterad pipeline som stöder borttagning per funktion tar du bort och materialiserar funktionen igen.
  • För materialiserade ColumnSelection funktioner fortsätter materialiseringspipelinen att producera nya funktionsvärden tills alla materialiserade funktioner i pipelinen har tagits bort, vilket utlöser resursrensning.

Direktuppspelningsfunktioner

  • Direktuppspelningsfunktioner kan bara materialiseras till onlinebutiker. Offlinematerialisering behövs inte eftersom strömningsfunktioner vid träningstillfället är utformade för att omberäknas från historiska händelser per datapunkt för att ge noggrannhet på millisekundersnivå.
  • Strömningsfunktioner kan inte blandas med batchfunktioner i ett enda materialize_features anrop.
  • compute_features stöder inte direktuppspelningsfunktioner.
  • Arbetsytan måste finnas i en region som stöder Lakebase-instanser.
  • Endast JSON-serialiserade Kafka-meddelanden stöds. Meddelandescheman måste anges direkt i JSON-schemaformat. Schemaregister (Confluent, Glue) stöds inte formellt under förhandsversionen, men om du anger schemat direkt kan pipelines läsa från ämnen som styrs av ett schemaregister.
  • Endast RollingWindow stöds för strömningsaggregeringsfunktioner. TumblingWindow och SlidingWindow bör användas med batchfunktioner.
  • Endast Count, Avg, Sum, StddevPop, Max, Min, First, LastNFirstDistinctLastFirstN, och LastDistinct aggregeringsfunktioner stöds för strömningsfunktioner.
  • Kolumnvalsfunktioner från strömmande källor hanterar inte meddelanden som inte är i ordning. Den senaste händelsen på Kafka-strömmen visas, även om kolumnvärdet för tidsserier är tidigare än en tidigare mottagen händelse.
  • Streamningspipelines startas om två gånger i veckan. Varje omstart kan orsaka bearbetningsfördröjningar och starttider på upp till 1 minut. Förutom omstarter är p99-färskheten 200 ms.
  • Funktionsbakfyllnad för materialisering stöds inte. När en funktion materialiseras beräknas den från den punkten framåt. Nyligen skapade aggregeringar i webbutiken är inte korrekta förrän deras tidsfönster har passerat.
  • Endast Databricks Online Feature Store stöds.
  • Pipelines för strömmande materialisering körs som serverlösa Lakeflow-pipelines.
  • Endast arbetsytor på Enterprise-nivå.
  • Last updated on