Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Este artigo descreve como criar e usar recursos sob demanda no Azure Databricks.
Para usar recursos sob demanda, seu espaço de trabalho deve estar habilitado para Unity Catalog e você deve usar o Databricks Runtime 13.3 LTS ML ou superior.
O que são recursos sob demanda?
"Sob demanda" refere-se a recursos cujos valores não são conhecidos antecipadamente, mas são calculados no momento da inferência. No Azure Databricks, você usa funções definidas pelo usuário (UDFs) do Python para especificar como calcular recursos sob demanda. Essas funções são regidas pelo Unity Catalog e podem ser detetadas através Catalog Explorer.
Requisitos
- Para usar uma função definida pelo usuário (UDF) para criar um conjunto de treinamento ou para criar um ponto de extremidade Feature Serving, você deve ter
USE CATALOGprivilégio no catálogosystemno Unity Catalog.
Fluxo de Trabalho
Para calcular recursos sob demanda, especifique uma função definida pelo usuário (UDF) do Python que descreve como calcular os valores do recurso.
- Durante o
feature_lookupscreate_training_settreinamento, você fornece essa função e suas ligações de entrada no parâmetro da API. - Você deve registrar o modelo treinado usando o método
log_modelFeature Store . Isso garante que o modelo avalie automaticamente os recursos sob demanda quando for usado para inferência. - Para pontuação em lote, a API
score_batchcalcula e retorna automaticamente todos os valores de recursos, incluindo recursos sob demanda. - Quando você atende um modelo com o Mosaic AI Model Serving, o modelo usa automaticamente o Python UDF para calcular recursos sob demanda para cada solicitação de pontuação.
Criar um Python UDF
Você pode criar um Python UDF usando código SQL ou Python. Os exemplos a seguir criam um Python UDF no catálogo main e no esquema default.
Píton
Para usar o Python, você deve primeiro instalar o databricks-sdk[openai] pacote. Utilizar %pip install da seguinte forma:
%pip install unitycatalog-ai[databricks]
dbutils.library.restartPython()
Em seguida, use um código semelhante ao seguinte para criar um Python UDF:
from unitycatalog.ai.core.databricks import DatabricksFunctionClient
client = DatabricksFunctionClient()
CATALOG = "main"
SCHEMA = "default"
def add_numbers(number_1: float, number_2: float) -> float:
"""
A function that accepts two floating point numbers, adds them,
and returns the resulting sum as a float.
Args:
number_1 (float): The first of the two numbers to add.
number_2 (float): The second of the two numbers to add.
Returns:
float: The sum of the two input numbers.
"""
return number_1 + number_2
function_info = client.create_python_function(
func=add_numbers,
catalog=CATALOG,
schema=SCHEMA,
replace=True
)
Databricks SQL
O código a seguir mostra como usar o Databricks SQL para criar um Python UDF:
%sql
CREATE OR REPLACE FUNCTION main.default.add_numbers(x INT, y INT)
RETURNS INT
LANGUAGE PYTHON
COMMENT 'add two numbers'
AS $$
def add_numbers(n1: int, n2: int) -> int:
return n1 + n2
return add_numbers(x, y)
$$
Depois de executar o código, você pode navegar pelo namespace de três níveis em do Catalog Explorer para exibir a definição de função:
Para obter mais detalhes sobre como criar UDFs Python, consulte Registrar um Python UDF no Unity Catalog e o manual da linguagem SQL.
Como lidar com valores de características ausentes
Quando um Python UDF depende do resultado de um FeatureLookup, o valor retornado se a chave de pesquisa solicitada não for encontrada depende do ambiente. Ao usar score_batch, o valor retornado é None. Ao usar o serviço online, o valor retornado é float("nan").
O código a seguir é um exemplo de como lidar com ambos os casos.
%sql
CREATE OR REPLACE FUNCTION square(x INT)
RETURNS INT
LANGUAGE PYTHON AS
$$
import numpy as np
if x is None or np.isnan(x):
return 0
return x * x
$$
Treinar um modelo usando recursos sob demanda
Para treinar o modelo, use um FeatureFunction, que é passado para a create_training_set API no feature_lookups parâmetro.
O código de exemplo a seguir usa o Python UDF main.default.example_feature que foi definido na seção anterior.
# Install databricks-feature-engineering first with:
# %pip install databricks-feature-engineering
# dbutils.library.restartPython()
from databricks.feature_engineering import FeatureEngineeringClient
from databricks.feature_engineering import FeatureFunction, FeatureLookup
from sklearn import linear_model
fe = FeatureEngineeringClient()
features = [
# The feature 'on_demand_feature' is computed as the sum of the the input value 'new_source_input'
# and the pre-materialized feature 'materialized_feature_value'.
# - 'new_source_input' must be included in base_df and also provided at inference time.
# - For batch inference, it must be included in the DataFrame passed to 'FeatureEngineeringClient.score_batch'.
# - For real-time inference, it must be included in the request.
# - 'materialized_feature_value' is looked up from a feature table.
FeatureFunction(
udf_name="main.default.example_feature", # UDF must be in Unity Catalog so uses a three-level namespace
input_bindings={
"x": "new_source_input",
"y": "materialized_feature_value"
},
output_name="on_demand_feature",
),
# retrieve the prematerialized feature
FeatureLookup(
table_name = 'main.default.table',
feature_names = ['materialized_feature_value'],
lookup_key = 'id'
)
]
# base_df includes the columns 'id', 'new_source_input', and 'label'
training_set = fe.create_training_set(
df=base_df,
feature_lookups=features,
label='label',
exclude_columns=['id', 'new_source_input', 'materialized_feature_value'] # drop the columns not used for training
)
# The training set contains the columns 'on_demand_feature' and 'label'.
training_df = training_set.load_df().toPandas()
# training_df columns ['materialized_feature_value', 'label']
X_train = training_df.drop(['label'], axis=1)
y_train = training_df.label
model = linear_model.LinearRegression().fit(X_train, y_train)
Registe o modelo e adicione-o ao Catálogo Unity.
Os modelos empacotados com metadados de recursos podem ser registrados no Unity Catalog. As tabelas de recursos usadas para criar o modelo devem ser armazenadas no Catálogo Unity.
Para garantir que o modelo avalie automaticamente os recursos sob demanda quando for usado para inferência, você deve definir o URI do registro e, em seguida, registrar o modelo, da seguinte maneira:
import mlflow
mlflow.set_registry_uri("databricks-uc")
fe.log_model(
model=model,
artifact_path="main.default.model",
flavor=mlflow.sklearn,
training_set=training_set,
registered_model_name="main.default.recommender_model"
)
Se o UDF do Python que define os recursos sob demanda importar quaisquer pacotes Python, você deverá especificar esses pacotes usando o argumento extra_pip_requirements. Por exemplo:
import mlflow
mlflow.set_registry_uri("databricks-uc")
fe.log_model(
model=model,
artifact_path="model",
flavor=mlflow.sklearn,
training_set=training_set,
registered_model_name="main.default.recommender_model",
extra_pip_requirements=["scikit-learn==1.20.3"]
)
Limitação
Os recursos sob demanda podem gerar todos os tipos de dados suportados pelo Feature Store , exceto MapType e ArrayType.
Exemplos de blocos de notas: funcionalidades a pedido
O bloco de anotações a seguir mostra um exemplo de como treinar e pontuar um modelo que usa um recurso sob demanda.
Notebook de demonstração de recursos básicos sob demanda
O bloco de anotações a seguir mostra um exemplo de um modelo de recomendação de restaurante. A localização do restaurante é pesquisada a partir de uma tabela online do Databricks. A localização atual do usuário é enviada como parte da solicitação de pontuação. O modelo usa um recurso sob demanda para calcular a distância em tempo real do usuário ao restaurante. Essa distância é então usada como uma entrada para o modelo.