Elastic Algorithm Service (EAS) incluye un procesador EasyRec integrado que despliega modelos de recomendación entrenados con EasyRec o TensorFlow como servicios de puntuación con ingeniería de características integrada. El procesador optimiza conjuntamente la ingeniería de características y la inference para lograr una puntuación de alto rendimiento.
Contexto
El procesador EasyRec es un servicio de inference basado en la especificación de procesadores de PAI-EAS (Develop custom processors by using C or C++). Admite dos escenarios:
Para modelos de aprendizaje profundo entrenados con feature generation (FG) y EasyRec, el procesador EasyRec mejora el rendimiento de la puntuación al almacenar en caché las características de los elementos en memoria y optimizar la transformación de características y la inference. FeatureStore gestiona las características en línea y en tiempo real. El PAI-Rec recommendation platform genera código que simplifica el entrenamiento, la transformación de características y la inference. En combinación con el PAI-Rec DPI engine, permite un despliegue rápido del modelo y la integración del servicio.
El procesador EasyRec también puede servir modelos entrenados con EasyRec o TensorFlow sin el generador de características (modo bypass).
Arquitectura de un motor de recomendación basado en el procesador EasyRec:
Nota: El procesador también admite datos sin conexión de MaxCompute.
El procesador EasyRec incluye los siguientes módulos:
Caché de características de elementos: Almacena en memoria las características de FeatureStore para reducir la sobrecarga de red. Admite actualizaciones de características incrementales y en tiempo real.
Generador de características: Módulo de ingeniería de características (Feature generation overview and configuration) que utiliza la misma implementación para el procesamiento sin conexión y en línea, lo cual garantiza la consistencia. La implementación se basa en soluciones comprobadas de Taobao. Concepts of data fields, data features, and FG features in EasyRec cubre la terminología de FG. Puede extender FG con custom feature operators.
TFModel: Carga archivos SavedModel exportados desde EasyRec y utiliza Blade para optimizar la inference del modelo en CPU y GPU.
Módulos de Instrumentación de características y Actualización incremental del modelo: Estos módulos admiten escenarios de entrenamiento en tiempo real. Entrenamiento en tiempo real.
Limitaciones
La inference en CPU solo es compatible con las familias de instancias de propósito general g6, g7 y g8 (solo CPU Intel).
La inference en GPU es compatible con las GPU T4, A10, GU30, L20, 3090 y 4090, pero no con la P100.
Versiones
Utilice la versión más reciente para obtener las mejores funciones y el mejor rendimiento.
Paso 1: Desplegar el servicio
Para desplegar un servicio de modelo EasyRec con eascmd, establezca Processor type en easyrec-{version}. Service deployment: EASCMD cubre el proceso completo de despliegue. Las siguientes secciones proporcionan ejemplos de archivos de configuración.
Nueva biblioteca FeatureGenerator (fg_mode=normal)
Este ejemplo utiliza el tipo de nodo PyOdps3 con la nueva biblioteca FeatureGenerator. Esta biblioteca admite operadores de transformación integrados y personalizados, tipos de entrada complejos (matrices, mapas) y dependencias de características basadas en DAG.
El siguiente ejemplo utiliza PAI-FeatureStore para la gestión de datos de características. Reemplace ${fs_project},${fs_model} con los valores reales. Step 2: Create and deploy an EAS model service proporciona el procedimiento completo.
import json
import os
service_name = 'ali_rec_rnk_with_fg'
config = {
'name': service_name,
'metadata': {
"cpu": 8,
#"cuda": "11.2",
"gateway": "default",
"gpu": 0,
"memory": 32000,
"rolling_strategy": {
"max_unavailable": 1
},
"rpc": {
"enable_jemalloc": 1,
"max_queue_size": 256
}
},
"processor_envs": [
{
"name": "ADAPTE_FG_CONFIG",
"value": "true"
}
],
"model_path": "",
"processor": "easyrec-3.5",
"storage": [
{
"mount_path": "/home/admin/docker_ml/workspace/model/",
"oss": {
"path": "oss://easyrec/ali_rec_sln_acc_rnk/20250722/export/final_with_fg"
}
}
],
# When you change fg_mode, the invocation method must also be changed.
# If fg_mode is 'normal' or 'tf', use the EasyRecRequest SDK.
# If fg_mode is 'bypass', use the TFRequest SDK.
'model_config': {
'outputs': 'probs_ctr,probs_cvr',
'fg_mode': 'normal',
'steady_mode': True,
'period': 2880,
'access_key_id': f'{o.account.access_id}',
'access_key_secret': f'{o.account.secret_access_key}',
"load_feature_from_offlinestore": True,
'region': 'cn-shanghai',
'fs_project': '${fs_project}',
'fs_model': '${fs_model}',
'fs_entity': 'item',
'featuredb_username': 'guest',
'featuredb_password': '123456',
'log_iterate_time_threshold': 100,
'iterate_featuredb_interval': 5,
'mc_thread_pool_num': 1,
}
}
with open('echo.json', 'w') as output_file:
json.dump(config, output_file)
os.system(f'/home/admin/usertools/tools/eascmd -i {o.account.access_id} -k {o.account.secret_access_key} -e pai-eas.cn-shanghai.aliyuncs.com create echo.json')
# os.system(f'/home/admin/usertools/tools/eascmd -i {o.account.access_id} -k {o.account.secret_access_key} -e pai-eas.cn-shanghai.aliyuncs.com modify {service_name} -s echo.json')Reemplace los valores de featuredb_username y featuredb_password con credenciales válidas.
Versión con operadores TF de FeatureGenerator (fg_mode=tf)
Importante: La versión con operadores TF de FeatureGenerator solo admite un conjunto limitado de características integradas: id_feature, raw_feature, combo_feature, lookup_feature, match_feature, and sequence_feature. No se admiten operadores personalizados de FeatureGenerator.
El siguiente script de despliegue incluye el par de AccessKey en texto plano. No utiliza PAI-FeatureStore ni carga datos desde MaxCompute para reducir la carga en Hologres.
Utilice PAI-FeatureStore con MaxCompute para despliegues en producción. Step 2: Create and deploy an EAS model service muestra un método más seguro mediante un script de Python, el objeto o de DataWorks y tokens STS temporales con load_feature_from_offlinestore establecido en True.
bizdate=$1
# Change the invocation method based on fg_mode: EasyRecRequest for 'normal'/'tf', TFRequest for 'bypass'
cat << EOF > echo.json
{
"name":"ali_rec_rnk_with_fg",
"metadata": {
"instance": 2,
"rpc": {
"enable_jemalloc": 1,
"max_queue_size": 100
}
},
"cloud": {
"computing": {
"instance_type": "ecs.g7.large",
"instances": null
}
},
"model_config": {
"remote_type": "hologres",
"url": "postgresql://<AccessKeyID>:<AccessKeySecret>@<endpoint>:<port>/<database>",
"tables": [{"name":"<schema>.<table_name>","key":"<index_column_name>","value": "<column_name>"}],
"period": 2880,
"fg_mode": "tf",
"outputs":"probs_ctr,probs_cvr",
},
"model_path": "",
"processor": "easyrec-3.5",
"storage": [
{
"mount_path": "/home/admin/docker_ml/workspace/model/",
"oss": {
"path": "oss://easyrec/ali_rec_sln_acc_rnk/20221122/export/final_with_fg"
}
}
]
}
EOF
# Run the deployment command.
eascmd create echo.json
# eascmd -i <AccessKeyID> -k <AccessKeySecret> -e <endpoint> create echo.json
# Run the update command.
eascmd update ali_rec_rnk_with_fg -s echo.jsonOmitir FeatureGenerator (fg_mode=bypass)
Si no utiliza FeatureGenerator, ensamble la solicitud en el lado del cliente. How to use EAS for inference without training with EasyRec.
bizdate=$1
# Change the invocation method based on fg_mode: EasyRecRequest for 'normal'/'tf', TFRequest for 'bypass'
cat << EOF > echo.json
{
"name":"ali_rec_rnk_no_fg",
"metadata": {
"instance": 2,
"rpc": {
"enable_jemalloc": 1,
"max_queue_size": 100
}
},
"cloud": {
"computing": {
"instance_type": "ecs.g7.large",
"instances": null
}
},
"model_config": {
"fg_mode": "bypass"
},
"processor": "easyrec-3.5",
"processor_envs": [
{
"name": "INPUT_TILE",
"value": "2"
}
],
"storage": [
{
"mount_path": "/home/admin/docker_ml/workspace/model/",
"oss": {
"path": "oss://easyrec/ali_rec_sln_acc_rnk/20221122/export/final/"
}
}
],
"warm_up_data_path": "oss://easyrec/ali_rec_sln_acc_rnk/rnk_warm_up.bin"
}
EOF
# Run the deployment command.
eascmd create echo.json
# eascmd -i <AccessKeyID> -k <AccessKeySecret> -e <endpoint> create echo.json
# Run the update command.
eascmd update ali_rec_rnk_no_fg -s echo.jsonLa siguiente tabla describe los parámetros clave. JSON deployment cubre parámetros adicionales.
|
Parámetro |
Obligatorio |
Descripción |
Ejemplo |
|
processor |
Sí |
Nombre del procesador EasyRec. |
|
|
fg_mode |
Sí |
Modo de ingeniería de características. El modo seleccionado determina el SDK y el formato de solicitud para la invocación del servicio.
|
|
|
outputs |
Sí |
Nombres de las variables de salida del modelo de TensorFlow, como probs_ctr. Separe varios nombres con comas (,). Para encontrar los nombres de las variables de salida, ejecute el comando de TensorFlow saved_model_cli. |
"outputs":"probs_ctr,probs_cvr" |
|
save_req |
No |
Indica si se deben guardar los datos de solicitud en el directorio del modelo para pruebas de calentamiento y rendimiento. Valores válidos:
|
"save_req": "false" |
|
Parámetros de caché de características de artículos |
|||
|
period |
Sí |
Intervalo de actualización de la caché de características de artículos, en minutos. Para características que se actualizan diariamente, establezca un valor mayor a 1,440 (minutos por día), por ejemplo, 2,880 (dos días). Esto evita actualizaciones redundantes, ya que las características también se refrescan durante los despliegues rutinarios. |
|
|
remote_type |
Sí |
Origen de datos para las características de artículos. Valores válidos:
|
|
|
tables |
No |
Tabla de características de artículos. Este parámetro es obligatorio cuando remote_type se establece en hologres. Incluye los siguientes subparámetros:
Puede leer datos de artículos de entrada desde varias tablas. La configuración debe tener el siguiente formato:
Si las tablas comparten nombres de columna, las columnas de la tabla que aparece después en la lista sobrescriben las de la tabla anterior. |
|
|
url |
No |
Endpoint de Hologres. |
|
|
Parámetros de acceso del procesador a PAI-FeatureStore |
|||
|
fs_project |
No |
Nombre del proyecto de PAI-FeatureStore. Obligatorio al utilizar PAI-FeatureStore. Configure a FeatureStore project. |
"fs_project": "fs_demo" |
|
fs_model |
No |
Nombre de la característica del modelo en PAI-FeatureStore. |
"fs_model": "fs_rank_v1" |
|
fs_entity |
No |
Nombre de la entidad en PAI-FeatureStore. |
"fs_entity": "item" |
|
region |
No |
Región donde reside el proyecto de PAI-FeatureStore. |
"region": "cn-beijing" |
|
access_key_id |
No |
AccessKey ID utilizado para acceder a PAI-FeatureStore. |
"access_key_id": "xxxxx" |
|
access_key_secret |
No |
AccessKey Secret utilizado para acceder a PAI-FeatureStore. |
"access_key_secret": "xxxxx" |
|
featuredb_username |
No |
Nombre de usuario para FeatureDB. |
"featuredb_username": "xxxxx" |
|
featuredb_password |
No |
Contraseña para FeatureDB. |
"featuredb_password": "xxxxx" |
|
load_feature_from_offlinestore |
No |
Indica si se deben cargar características sin conexión directamente desde OfflineStore de PAI-FeatureStore. Valores válidos:
|
"load_feature_from_offlinestore": True |
|
iterate_featuredb_interval |
No |
Intervalo, en segundos, para actualizar características estadísticas en tiempo real. Un intervalo más corto mejora la frescura de las características, pero incrementa los costos de lectura cuando las características cambian con frecuencia. Encuentre un equilibrio entre precisión y costo. |
"iterate_featuredb_interval": 5 |
|
input_tile: Parámetros para difusión automática de características |
|||
|
INPUT_TILE |
No |
Establezca la variable de entorno INPUT_TILE en 1 para habilitar la difusión automática de características de artículos. Esto permite pasar un único valor para características que permanecen constantes dentro de una solicitud, como user_id. Cuando la variable de entorno INPUT_TILE se establece en 2, la operación
Nota
|
"processor_envs": [ { "name": "INPUT_TILE", "value": "2" } ] |
|
ADAPTE_FG_CONFIG |
No |
Habilita la compatibilidad con modelos entrenados con una versión anterior de FeatureGenerator. |
"processor_envs": [ { "name": "ADAPTE_FG_CONFIG", "value": "true" } ] |
|
DISABLE_FG_PRECISION |
No |
Para compatibilidad con modelos entrenados con una versión anterior de FeatureGenerator. La versión anterior limita las características de tipo float a seis dígitos significativos de forma predeterminada, mientras que la nueva versión elimina este límite. Para aplicar el comportamiento anterior (límite de 6 dígitos), establezca esta variable en |
"processor_envs": [ { "name": "DISABLE_FG_PRECISION", "value": "false" } ] |
Optimización de inference del procesador EasyRec
|
Parámetro |
Obligatorio |
Descripción |
Ejemplo |
|
TF_XLA_FLAGS |
No |
Para inference con GPU, este parámetro habilita XLA para compilar y optimizar el modelo, además de realizar automáticamente la fusión de operadores. |
"processor_envs": [ { "name": "TF_XLA_FLAGS", "value": "--tf_xla_auto_jit=2" }, { "name": "XLA_FLAGS", "value": "--xla_gpu_cuda_data_dir=/usr/local/cuda/" }, { "name": "XLA_ALIGN_SIZE", "value": "64" } ] |
|
Parámetros de programación de TF |
No |
inter_op_parallelism_threads: Controla el número de hilos para ejecutar diferentes operaciones en paralelo. intra_op_parallelism_threads: Controla el número de hilos utilizados dentro de una sola operación. Para una CPU de 32 núcleos, establecer estos parámetros en 16 generalmente mejora el rendimiento. Tenga en cuenta que la suma de ambos recuentos de hilos no puede exceder el número total de núcleos de CPU. |
"model_config": { "inter_op_parallelism_threads": 16, "intra_op_parallelism_threads": 16, } |
|
rpc.worker_threads |
No |
Parámetro ubicado bajo |
"metadata": { "rpc": { "worker_threads": 15 } |
Paso 2: Llamar al servicio
2.1 Configuración de red
Tanto el motor PAI-Rec como el servicio de puntuación se ejecutan en PAI-EAS y requieren una conexión de red directa. En la página de instancias de PAI-EAS, haga clic en 'VPC' para configurar la misma VPC, vSwitch y security group. Access public or on-premises resources from EAS. Si utiliza Hologres, configure también la misma VPC. La siguiente figura muestra un ejemplo.
2.2 Obtener información del servicio
Después del despliegue, vaya a la página Elastic Algorithm Service (EAS). Busque su servicio y haga clic en Invocation Information en la columna Service Method para consultar el endpoint y el token.
2.3 Ejemplos de código del SDK
El servicio de modelo EasyRec utiliza Protocol Buffers (Protobuf) para la entrada y salida, por lo que no es posible probarlo desde la consola de PAI-EAS.
Antes de llamar al servicio, confirme el fg_mode en model_config del Paso 1. Cada modo requiere un SDK de cliente diferente.
|
Modo (fg_mode) |
Clase de solicitud |
|
normal o tf (con ingeniería de características integrada) |
EasyRecRequest |
|
bypass (sin ingeniería de características integrada) |
TFRequest |
Con FG fg_mode=normal or tf
Java
La configuración de Maven se cubre en Java SDK guide. El siguiente código envía una solicitud al servicio ali_rec_rnk_with_fg:
import com.aliyun.openservices.eas.predict.http.*;
import com.aliyun.openservices.eas.predict.request.EasyRecRequest;
PredictClient client = new PredictClient(new HttpConfig());
// When you access the service through a public gateway, use the endpoint that starts with your user ID (UID). You can obtain this endpoint from the invocation information of the service in the EAS console.
client.setEndpoint("xxxxxxx.vpc.cn-hangzhou.pai-eas.aliyuncs.com");
client.setModelName("ali_rec_rnk_with_fg");
// Replace this with your service token.
client.setToken("******");
EasyRecRequest easyrecRequest = new EasyRecRequest(separator);
// userFeatures: User features. Features are separated by \u0002 (CTRL_B). Feature names and values are separated by a colon (:).
// user_fea0:user_fea0_val\u0002user_fea1:user_fea1_val
// For more information about the feature value format, see: https://easyrec.readthedocs.io/en/latest/feature/rtp_fg.html
easyrecRequest.appendUserFeatureString(userFeatures);
// You can also add one user feature at a time:
// easyrecRequest.addUserFeature(String userFeaName, T userFeaValue).
// The data type T of the feature value can be String, float, long, or int.
// contextFeatures: Context features. Features are separated by \u0002 (CTRL_B). Feature names and their values are separated by a colon (:). Multiple values for the same feature are also separated by colons.
// ctxt_fea0:ctxt_fea0_ival0:ctxt_fea0_ival1:ctxt_fea0_ival2\u0002ctxt_fea1:ctxt_fea1_ival0:ctxt_fea1_ival1:ctxt_fea1_ival2
easyrecRequest.appendContextFeatureString(contextFeatures);
// You can also add one context feature at a time:
// easyrecRequest.addContextFeature(String ctxtFeaName, List<Object> ctxtFeaValue).
// The data type of ctxtFeaValue can be String, Float, Long, or Integer.
// itemIdStr: A list of item IDs to predict, separated by a comma (,).
easyrecRequest.appendItemStr(itemIdStr, ",");
// You can also add one item ID at a time:
// easyrecRequest.appendItemId(String itemId)
easyrecPredictProtos.PBResponse response = client.predict(easyrecRequest);
for (Map.Entry<String, easyrecPredictProtos.Results> entry : response.getResultsMap().entrySet()) {
String key = entry.getKey();
easyrecPredictProtos.Results value = entry.getValue();
System.out.print("key: " + key);
for (int i = 0; i < value.getScoresCount(); i++) {
System.out.format("value: %.6g\n", value.getScores(i));
}
}
// Get the features after FG processing to check for consistency with offline features.
// Set DebugLevel to 1 to return the generated features.
easyrecRequest.setDebugLevel(1);
easyrecPredictProtos.PBResponse response = client.predict(easyrecRequest);
Map<String, String> genFeas = response.getGenerateFeaturesMap();
for(String itemId: genFeas.keySet()) {
System.out.println(itemId);
System.out.println(genFeas.get(itemId));
}Python
La configuración del entorno se cubre en Python SDK guide. Utilice el cliente Java en producción para obtener un mejor rendimiento. Ejemplo:
from eas_prediction import PredictClient
from eas_prediction.easyrec_request import EasyRecRequest
from eas_prediction.easyrec_predict_pb2 import PBFeature
from eas_prediction.easyrec_predict_pb2 import PBRequest
if __name__ == '__main__':
endpoint = 'http://xxxxxxx.vpc.cn-hangzhou.pai-eas.aliyuncs.com'
service_name = 'ali_rec_rnk_with_fg'
token = '******'
client = PredictClient(endpoint, service_name)
client.set_token(token)
client.init()
req = PBRequest()
uid = PBFeature()
uid.string_feature = 'u0001'
req.user_features['user_id'] = uid
age = PBFeature()
age.int_feature = 12
req.user_features['age'] = age
weight = PBFeature()
weight.float_feature = 129.8
req.user_features['weight'] = weight
req.item_ids.extend(['item_0001', 'item_0002', 'item_0003'])
easyrec_req = EasyRecRequest()
easyrec_req.add_feed(req, debug_level=0)
res = client.predict(easyrec_req)
print(res)Parámetros:
endpoint: Endpoint del servicio. Para obtenerlo, vaya a la página Elastic Algorithm Service (EAS), busque su servicio y haga clic en Invocation Information en la columna Service Method.
service_name: Nombre del servicio. Obténgalo desde la página Elastic Algorithm Service (EAS).
token: Token del servicio. Encuéntrelo en el cuadro de diálogo Invocation Information.
Sin FG fg_mode=bypass
Java
La configuración de Maven se cubre en Java SDK guide. El siguiente código envía una solicitud al servicio ali_rec_rnk_no_fg:
import java.util.List;
import com.aliyun.openservices.eas.predict.http.PredictClient;
import com.aliyun.openservices.eas.predict.http.HttpConfig;
import com.aliyun.openservices.eas.predict.request.TFDataType;
import com.aliyun.openservices.eas.predict.request.TFRequest;
import com.aliyun.openservices.eas.predict.response.TFResponse;
public class TestEasyRec {
public static TFRequest buildPredictRequest() {
TFRequest request = new TFRequest();
request.addFeed("user_id", TFDataType.DT_STRING,
new long[]{3}, new String []{ "u0001", "u0001", "u0001"});
request.addFeed("age", TFDataType.DT_FLOAT,
new long[]{3}, new float []{ 18.0f, 18.0f, 18.0f});
// Note: If you set INPUT_TILE=2, for features that have the same value, you only need to pass the value once:
// request.addFeed("user_id", TFDataType.DT_STRING,
// new long[]{1}, new String []{ "u0001" });
// request.addFeed("age", TFDataType.DT_FLOAT,
// new long[]{1}, new float []{ 18.0f});
request.addFeed("item_id", TFDataType.DT_STRING,
new long[]{3}, new String []{ "i0001", "i0002", "i0003"});
request.addFetch("probs");
return request;
}
public static void main(String[] args) throws Exception {
PredictClient client = new PredictClient(new HttpConfig());
// To use a direct network connection, use the setDirectEndpoint method. Example:
// client.setDirectEndpoint("pai-eas-vpc.cn-shanghai.aliyuncs.com");
// You must enable the direct network connection in the EAS console and provide the source vSwitch used to access the EAS service.
// A direct network connection offers better stability and performance.
client.setEndpoint("xxxxxxx.vpc.cn-hangzhou.pai-eas.aliyuncs.com");
client.setModelName("ali_rec_rnk_no_fg");
client.setToken("");
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
try {
TFResponse response = client.predict(buildPredictRequest());
// "probs" is an output field of the model. You can use the curl command to view the model's inputs and outputs:
// curl xxxxxxx.vpc.cn-hangzhou.pai-eas.aliyuncs.com -H "Authorization:{token}"
List<Float> result = response.getFloatVals("probs");
System.out.print("Predict Result: [");
for (int j = 0; j < result.size(); j++) {
System.out.print(result.get(j).floatValue());
if (j != result.size() - 1) {
System.out.print(", ");
}
}
System.out.print("]\n");
} catch (Exception e) {
e.printStackTrace();
}
}
long endTime = System.currentTimeMillis();
System.out.println("Spend Time: " + (endTime - startTime) + "ms");
client.shutdown();
}
}Python
La configuración del entorno se describe en Python SDK guide. El SDK de Python se recomienda solo para depuración; utilice el SDK de Java en producción. El siguiente código envía una solicitud al servicio ali_rec_rnk_no_fg:
#!/usr/bin/env python
from eas_prediction import PredictClient
from eas_prediction import StringRequest
from eas_prediction import TFRequest
if __name__ == '__main__':
client = PredictClient('http://xxxxxxx.vpc.cn-hangzhou.pai-eas.aliyuncs.com', 'ali_rec_rnk_no_fg')
client.set_token('')
client.init()
# Note: Replace server_default with the actual signature_name of your model. For more information, see the SDK guide mentioned above.
req = TFRequest('server_default')
req.add_feed('user_id', [3], TFRequest.DT_STRING, ['u0001'] * 3)
req.add_feed('age', [3], TFRequest.DT_FLOAT, [18.0] * 3)
# Note: After enabling the INPUT_TILE=2 optimization, you can pass a single value for the preceding features.
# req.add_feed('user_id', [1], TFRequest.DT_STRING, ['u0001'])
# req.add_feed('age', [1], TFRequest.DT_FLOAT, [18.0])
req.add_feed('item_id', [3], TFRequest.DT_STRING,
['i0001', 'i0002', 'i0003'])
for x in range(0, 100):
resp = client.predict(req)
print(resp)2.4 Construir una solicitud de servicio personalizada
Para lenguajes distintos a Python y Java, genere el código de solicitud de predicción a partir de los siguientes archivos .proto:
-
tf_predict.proto: definición de solicitud para un modelo de TensorFlow.
syntax = "proto3"; option cc_enable_arenas = true; option go_package = ".;tf"; option java_package = "com.aliyun.openservices.eas.predict.proto"; option java_outer_classname = "PredictProtos"; enum ArrayDataType { // Not a legal value for DataType. Used to indicate a DataType field // has not been set. DT_INVALID = 0; // Data types that all computation devices are expected to be // capable to support. DT_FLOAT = 1; DT_DOUBLE = 2; DT_INT32 = 3; DT_UINT8 = 4; DT_INT16 = 5; DT_INT8 = 6; DT_STRING = 7; DT_COMPLEX64 = 8; // Single-precision complex DT_INT64 = 9; DT_BOOL = 10; DT_QINT8 = 11; // Quantized int8 DT_QUINT8 = 12; // Quantized uint8 DT_QINT32 = 13; // Quantized int32 DT_BFLOAT16 = 14; // Float32 truncated to 16 bits. Only for cast ops. DT_QINT16 = 15; // Quantized int16 DT_QUINT16 = 16; // Quantized uint16 DT_UINT16 = 17; DT_COMPLEX128 = 18; // Double-precision complex DT_HALF = 19; DT_RESOURCE = 20; DT_VARIANT = 21; // Arbitrary C++ data types } // Dimensions of an array message ArrayShape { repeated int64 dim = 1 [packed = true]; } // Protocol buffer representing an array message ArrayProto { // Data Type. ArrayDataType dtype = 1; // Shape of the array. ArrayShape array_shape = 2; // DT_FLOAT. repeated float float_val = 3 [packed = true]; // DT_DOUBLE. repeated double double_val = 4 [packed = true]; // DT_INT32, DT_INT16, DT_INT8, DT_UINT8. repeated int32 int_val = 5 [packed = true]; // DT_STRING. repeated bytes string_val = 6; // DT_INT64. repeated int64 int64_val = 7 [packed = true]; // DT_BOOL. repeated bool bool_val = 8 [packed = true]; } // PredictRequest specifies which TensorFlow model to run, as well as // how inputs are mapped to tensors and how outputs are filtered before // returning to user. message PredictRequest { // A named signature to evaluate. If unspecified, the default signature // will be used string signature_name = 1; // Input tensors. // Names of input tensor are alias names. The mapping from aliases to real // input tensor names is expected to be stored as named generic signature // under the key "inputs" in the model export. // Each alias listed in a generic signature named "inputs" should be provided // exactly once in order to run the prediction. map<string, ArrayProto> inputs = 2; // Output filter. // Names specified are alias names. The mapping from aliases to real output // tensor names is expected to be stored as named generic signature under // the key "outputs" in the model export. // Only tensors specified here will be run/fetched and returned, with the // exception that when none is specified, all tensors specified in the // named signature will be run/fetched and returned. repeated string output_filter = 3; // Debug flags // 0: just return prediction results, no debug information // 100: return prediction results, and save request to model_dir // 101: save timeline to model_dir int32 debug_level = 100; } // Response for PredictRequest on successful run. message PredictResponse { // Output tensors. map<string, ArrayProto> outputs = 1; } -
easyrec_predict.proto: definición de solicitud para un modelo de TensorFlow con FG.
syntax = "proto3"; option cc_enable_arenas = true; option go_package = ".;easyrec"; option java_package = "com.aliyun.openservices.eas.predict.proto"; option java_outer_classname = "EasyRecPredictProtos"; import "tf_predict.proto"; // context features message ContextFeatures { repeated PBFeature features = 1; } message PBFeature { oneof value { int32 int_feature = 1; int64 long_feature = 2; string string_feature = 3; float float_feature = 4; } } // PBRequest specifies the request for aggregator message PBRequest { // Debug flags // 0: just return prediction results, no debug information // 3: return features generated by FG module, string format, feature values are separated by \u0002, // could be used for checking feature consistency and generating online deep learning samples // 100: return prediction results, and save request to model_dir // 101: save timeline to model_dir // 102: for recall models such as DSSM and MIND, not only return Faiss retrieved results // but also return user embedding vectors. int32 debug_level = 1; // user features map<string, PBFeature> user_features = 2; // item ids, static(daily updated) item features // are fetched from the feature cache residing in // each processor node by item_ids repeated string item_ids = 3; // context features for each item, realtime item features // could be passed as context features. map<string, ContextFeatures> context_features = 4; // embedding retrieval neighbor number. int32 faiss_neigh_num = 5; } // return results message Results { repeated double scores = 1 [packed = true]; } enum StatusCode { OK = 0; INPUT_EMPTY = 1; EXCEPTION = 2; } // PBResponse specifies the response for aggregator message PBResponse { // results map<string, Results> results = 1; // item features map<string, string> item_features = 2; // fg generate features map<string, string> generate_features = 3; // context features map<string, ContextFeatures> context_features = 4; string error_msg = 5; StatusCode status_code = 6; // item ids repeated string item_ids = 7; repeated string outputs = 8; // all fg input features map<string, string> raw_features = 9; // output tensors map<string, ArrayProto> tf_outputs = 10; }