:Built-in feature operators

Présentation

L'opérateur id_feature gère une fonctionnalité discrète. Il s'agit notamment des fonctionnalités à valeur unique, telles que les ID utilisateur et les ID d'élément, ainsi que des fonctionnalités à valeurs multiples, comme les couleurs d'un article.

Configuration

{
  "feature_type": "id_feature",
  "feature_name": "item_is_main",
  "expression": "item:is_main",
  "need_prefix": true,
  "separator": "\u001D",
  "default_value": ""
}

• Prend en charge le regroupement de fonctionnalités. Pour plus d'informations, consultez la section Regroupement de fonctionnalités (discrétisation).

• Prend en charge le type array pour les fonctionnalités à valeurs multiples.

Exemples

Les exemples suivants illustrent l'entrée et la sortie pour la fonctionnalité item:is_main selon différentes configurations.

Le symbole ^] représente le séparateur de valeurs multiples. Son code ASCII est "\x1D" ; il peut également s'écrire "\u001d".

Aperçu

L'opérateur raw_feature traite une fonctionnalité continue. Il prend en charge les types numériques tels que int, float et double.

Configuration

{
 "feature_type" : "raw_feature",
 "feature_name" : "ctr",
 "expression" : "item:ctr",
 "normalizer" : "method=log10"
}

• Cet opérateur prend en charge le regroupement/discrétisation des fonctionnalités. Pour plus de détails sur la configuration, consultez la section Regroupement de fonctionnalités (discrétisation).

• Cet opérateur prend en charge les entrées à valeurs multiples de type array.

Exemple

Le symbole ^] représente le séparateur de valeurs multiples. Notez qu'il s'agit d'un seul caractère dont le code ASCII est "\x1D", et non de deux caractères.

Normaliseur

Les opérateurs raw_feature et match_feature prennent en charge quatre types de normaliseurs : minmax, zscore, log10, and expression. Leur configuration et leurs méthodes de calcul sont les suivantes :

• minmax

  Exemple : method=minmax,min=2,1,max=2,2

  Formule : x = (x - min) / (max - min)

• zscore

  Exemple : method=zscore,mean=0,0,standard_deviation=10,0

  Formule : x = (x - mean) / standard_deviation

• log10

  Exemple : method=log10,threshold=1e-10,default=-10

  Formule : x = x > threshold ? log10(x) : default;

• expression

  Exemple : method=expression,expr=sign(x)

  Formule : vous pouvez configurer n'importe quelle fonction ou expression. La variable x représente la valeur d'entrée.

Présentation

L'opérateur expr_feature évalue une expression et renvoie le résultat dans un type spécifié, tel que float, double, int32 ou int64. Il prend en charge le calcul par lots et la diffusion (broadcasting).

Remarque : lorsque vous utilisez cet opérateur de fonctionnalité, **toutes les entrées doivent être convertibles au type double**.

Configuration

{
  "feature_type" : "expr_feature",
  "feature_name" : "ctr_sigmoid",
  "value_type": "float",
  "expression" : "sigmoid(pv/(1+click))",
  "variables": ["item:pv", "item:click"]
}

Lorsque pv = 2, click = 3, la valeur de la fonctionnalité d'expression est 0.6224593312.

Exemples

{
    "feature_name": "expr_feat",
    "feature_type": "expr_feature",
    "value_type": "float",
    "expression": "a+b",
    "variables": ["a", "b"],
    "value_dimension": 3
}

• Calcul scalaire et vectoriel (diffusion)

  • Lorsque a=1 et b=[1, 2, 6], le résultat est [2, 3, 7].

• Calcul element-wise vecteur-vecteur

  • Lorsque la variable a=[3, 2, 1] et la variable b=[1, 2, 6], le résultat est [4, 4, 7].

• Variables temporaires et expressions avec virgules

  • Par exemple : x=roundp(a),(a-x)*b. Dans cet exemple, x est une variable temporaire et ne doit pas être configurée dans variables.

  • Une expression avec virgules est évaluée de gauche à droite et renvoie la valeur de sa sous-expression la plus à droite.

  • Pour réduire la consommation de mémoire, réutilisez les variables existantes en tant que variables temporaires lorsque la sémantique le permet.

Combiner des fonctionnalités d'expression et de séquence

{
  "features": [
    {
      "feature_name": "sphere_distance",
      "feature_type": "expr_feature",
      "expression": "sphere_dist(click_id_lng,click_id_lat,j_lng,j_lat)",
      "variables": ["user:click_id_lng", "user:click_id_lat", "item:j_lng", "item:j_lat"],
      "default_value": "0",
      "value_dimension": 3,
      "stub_type": true
    },
    {
      "feature_name": "time_diff",
      "feature_type": "expr_feature",
      "variables": ["user:cur_time", "user:clk_time_seq"],
      "expression": "cur_time-clk_time_seq",
      "default_value": "0",
      "separator": ";",
      "value_dimension": 3,
      "stub_type": true
    },
    {
      "sequence_name": "click_seq",
      "sequence_length": 3,
      "sequence_delim": ";",
      "sequence_pk": "user:click_item",
      "features": [
        {
          "feature_name": "spherical_distance",
          "feature_type": "raw_feature",
          "expression": "feature:sphere_distance",
          "default_value": "0.0"
        },
        {
          "feature_name": "time_diff_seq",
          "feature_type": "id_feature",
          "expression": "feature:time_diff",
          "default_value": "0.0",
          "num_buckets": 10000
        }
      ]
    }
  ]
}

Expressions

• Fonctions intégrées (scalaire)

  Nom de la fonction	Nombre de paramètres	Description
  rnd	0	Génère un nombre aléatoire dans l'intervalle [0, 1).
  isnan	1	Renvoie 1,0 si l'entrée est NaN et 0,0 dans le cas contraire. Cette fonction nécessite la version 1.0.5 ou ultérieure.
  sin	1	Renvoie le sinus d'un nombre.
  cos	1	Renvoie le cosinus d'un nombre.
  tan	1	Renvoie la tangente d'un nombre.
  asin	1	Renvoie l'arcsinus d'un nombre.
  acos	1	Renvoie l'arccosinus d'un nombre.
  atan	1	Renvoie l'arctangente d'un nombre.
  sinh	1	Renvoie le sinus hyperbolique d'un nombre.
  cosh	1	Renvoie le cosinus hyperbolique d'un nombre.
  tanh	1	Renvoie la tangente hyperbolique d'un nombre.
  asinh	1	Renvoie le sinus hyperbolique inverse d'un nombre.
  acosh	1	Renvoie le cosinus hyperbolique inverse d'un nombre.
  atanh	1	Renvoie la tangente hyperbolique inverse d'un nombre.
  log2	1	Renvoie le logarithme en base 2 d'un nombre.
  log10	1	Renvoie le logarithme en base 10 d'un nombre.
  log	1	Renvoie le logarithme naturel (base e) d'un nombre.
  ln	1	Renvoie le logarithme naturel (base e) d'un nombre.
  exp	1	Élève le nombre d'Euler (e) à la puissance d'un nombre.
  sqrt	1	Renvoie la racine carrée d'un nombre.
  sign	1	Renvoie le signe d'un nombre : -1 pour les nombres négatifs, 1 pour les nombres positifs et 0 pour zéro.
  abs	1	Renvoie la valeur absolue d'un nombre.
  rint	1	Arrondit un nombre à l'entier le plus proche.
  round	1	Arrondit un nombre à l'entier le plus proche en utilisant la méthode « round half away from zero ».
  roundp	2	Arrondit un nombre avec une précision spécifiée. Par exemple, roundp(3.14159, 2) renvoie 3.14.
  mod	2	Renvoie le reste d'une division.
  floor	1	Arrondit un nombre à l'entier inférieur le plus proche.
  ceil	1	Arrondit un nombre à l'entier supérieur le plus proche.
  trunc	1	Tronque un nombre en supprimant sa partie fractionnaire.
  sigmoid	1	Renvoie la sigmoïde d'un nombre.
  sphere_dist	4	Renvoie la distance sphérique entre deux points GPS. Arguments : lng1, lat1, lng2, lat2.
  haversine	4	Renvoie la distance haversine entre deux points GPS. Arguments : lng1, lat1, lng2, lat2.
  min	Variable	Renvoie la valeur minimale d'une liste d'arguments.
  max	Variable	Renvoie la valeur maximale d'une liste d'arguments.
  sum	Variable	Renvoie la somme de tous les arguments.
  avg	Variable	Renvoie la valeur moyenne de tous les arguments.

  Remarque : ces fonctions intégrées prennent en charge le calcul par lots et la diffusion (broadcasting).

• Fonctions intégrées d'opération vectorielle

  Nom de la fonction	Nombre de paramètres	Description
  len	1	Renvoie la longueur (nombre d'éléments) d'un vecteur.
  l2_norm	1	Renvoie le vecteur normalisé L2.
  squared_norm	1	Renvoie la norme L2 au carré d'un vecteur.
  dot	2	Renvoie le produit scalaire de deux vecteurs.
  euclid_dist	2	Renvoie la distance euclidienne entre deux vecteurs.
  corr	2	Renvoie le coefficient de corrélation de Pearson entre deux vecteurs.
  std_dev	1	Renvoie l'écart type d'échantillon d'un vecteur (division par n-1).
  pop_std_dev	1	Renvoie l'écart type de population d'un vecteur (division par n).
  variance	1	Renvoie la variance d'échantillon d'un vecteur (division par n-1).
  pop_variance	1	Renvoie la variance de population d'un vecteur (division par n).
  reduce_min	1	Renvoie la valeur minimale d'un vecteur.
  reduce_max	1	Renvoie la valeur maximale d'un vecteur.
  reduce_sum	1	Renvoie la somme de tous les éléments d'un vecteur.
  reduce_mean	1	Renvoie la valeur moyenne de tous les éléments d'un vecteur.
  reduce_prod	1	Renvoie le produit de tous les éléments d'un vecteur.

  Remarque : si une expression contient l'une de ces fonctions intégrées d'opération vectorielle, toutes les autres variables de l'expression doivent être des scalaires.

• Opérateurs binaires intégrés

  Opérateur	Description	Priorité
  =	Affectation *	0
  \	\		OU logique	1
  &&	ET logique	2
  \		OU binaire	3
  &	ET binaire	4
  <=	Inférieur ou égal à	5
  >=	Supérieur ou égal à	5
  !=	Différent de	5
  ==	Égal à	5
  >	Supérieur à	5
  <	Inférieur à	5
  +	Addition	6
  -	Soustraction	6
  *	Multiplication	7
  /	Division	7
  %	Modulo	7
  ^	Élève x à la puissance y.	8

  * L'opérateur d'affectation est spécial : il modifie l'un de ses arguments et s'applique uniquement aux variables.

• Opérateur ternaire intégré

  Cet opérateur fournit une fonctionnalité de type if-else.

  L'évaluation paresseuse évalue uniquement la branche requise d'une expression.

  Opérateur	Description	Syntaxe
  ?:	Opérateur if-then-else	condition ? value_if_true : value_if_false

• Constantes intégrées

  Constante	Description	Valeur
  _pi	La constante mathématique pi (π).	3.141592653589793
  _e	La constante mathématique e, également connue sous le nom de nombre d'Euler.	2.718281828459045

Présentation

L'opérateur combo_feature crée une caractéristique synthétique en calculant le produit cartésien de plusieurs champs source. Ce processus est également connu sous le nom de croisement de caractéristiques (feature crossing). L'opérateur id_feature est un cas particulier de combo_feature qui n'implique qu'un seul champ source. Généralement, les champs source pour le croisement de caractéristiques proviennent de tables différentes, comme la combinaison d'une caractéristique utilisateur avec une caractéristique d'article.

Configuration

{
  "feature_type" : "combo_feature",
  "feature_name" : "comb_age_item",
  "expression" : ["user:age_class", "item:item_id"],
  "need_prefix": true,
  "separator": "\u001D",
  "default_value": ""
}

• Prend en charge le regroupement de fonctionnalités (binning). Pour les instructions de configuration, consultez regroupement de fonctionnalités (discrétisation).

• Prend en charge les entrées à valeurs multiples de type array.

Exemples

Le symbole ^] représente le séparateur de valeurs multiples. Il s'agit d'un seul caractère dont le code ASCII est "\x1D", et non de deux caractères.

Le nombre de valeurs de sortie se calcule comme suit :

|F1| * |F2| * ... * |Fn|

Où |Fn| représente le nombre de valeurs dans le nième champ source.

Présentation

À l'instar de match_feature, l'opérateur lookup_feature recherche une clé au sein d'un ensemble de paires clé-valeur et renvoie la valeur correspondante.

Cet opérateur dépend de deux paramètres : map et key.

• Le paramètre map est un dictionnaire ou une chaîne à valeurs multiples. Dans une chaîne à valeurs multiples, chaque élément est une paire clé-valeur au format « k1:v1 ».

• Le paramètre key peut être de n'importe quel type de données. Pour plusieurs clés, il est recommandé d'utiliser un tableau en entrée. Pour générer une fonctionnalité, l'opérateur récupère la valeur du paramètre key, la convertit dans le type de clé de la map, puis recherche la valeur correspondante dans la map.

Configuration

{
  "feature_type": "lookup_feature",
  "feature_name": "item_match_item",
  "map": "item:item_attr",
  "key": "item:item_value",
  "need_discrete": true,
  "need_key": true
}

• Prend en charge les opérations de regroupement (binning). Pour la méthode de configuration, consultez regroupement de fonctionnalités (discrétisation).

• Le paramètre map prend en charge les entrées de type dictionnaire, et le paramètre key prend en charge les entrées de type tableau.

Exemple

Pour la configuration ci-dessus, supposons qu'un document contienne les données suivantes :

item_attr : "k1:v1^]k2:v2^]k3:v3"

Le symbole ^] représente le séparateur de valeurs multiples. Il s'agit d'un seul caractère dont le code ASCII est "\x1D", et non de deux caractères. Pour saisir ce caractère, appuyez sur C-q C-5 dans emacs ou sur C-v C-5 dans vim. Ici, item_attr est une chaîne à valeurs multiples.

Lorsque le paramètre map représente plusieurs paires clé-valeur sous forme de chaîne, il doit s'agir d'une chaîne à valeurs multiples, et non d'une chaîne standard.

item_value : "k2"

La fonctionnalité résultante est item_match_item_k2_v2.

feature_name: fg
map: {"k1:123", "k2:234", "k3:3"}
key: {"k1"}
Result: feature={"fg_123"}

map: {"k1:123", "k2:234", "k3:3"}
key: {"k1"}
Result: feature={123}

Combiner les résultats de recherche

Lorsque vous fournissez plusieurs clés, vous pouvez utiliser le paramètre combiner pour agréger les valeurs récupérées.

Pour utiliser le combiner, vous devez définir need_discrete sur false. Dans ce cas, les valeurs recherchées doivent être numériques ou être des chaînes convertibles en nombres.

Présentation

L'opérateur match_feature est généralement utilisé pour la mise en correspondance de fonctionnalités. Au cœur de son fonctionnement, il effectue une recherche de map à deux niveaux.

Configuration

Le fichier de configuration utilise le format JSON.

{
  "feature_name": "user__l1_ctr_1",
  "feature_type": "match_feature",
  "category": "ALL",
  "need_discrete": false,
  "item": "item:category_level1",
  "user": "user:l1_ctr_1",
  "match_type": "hit"
}

• user : Un dictionnaire imbriqué.

  • Le champ user utilise une chaîne pour représenter la map à deux niveaux.

  • Pour la map de premier niveau, | est le séparateur entre les éléments, et ^ est le séparateur entre une clé et sa valeur.

  • Pour la map de second niveau, , est le séparateur entre les éléments, et : est le séparateur entre une clé et sa valeur.

  • Le dictionnaire de premier niveau prend également en charge une entrée Map<K, string>, où K peut être de type string,int32,int64. La valeur de la map est une chaîne qui représente le dictionnaire interne et utilise les mêmes séparateurs.

• category : La clé primaire pour la recherche dans la map de premier niveau.

  ALL est un caractère générique qui correspond à toutes les clés à ce niveau.

• item : La clé secondaire pour la recherche dans la map de second niveau.

  ALL est un caractère générique qui correspond à toutes les clés à ce niveau.

• need_discrete

  • true : Le modèle utilise le nom de fonctionnalité généré à partir de la sortie et ignore la valeur de la fonctionnalité. Par défaut, ce paramètre est false.

  • false : Le modèle utilise la valeur de fonctionnalité correspondante issue de la sortie et ignore le nom de la fonctionnalité.

• match_type

  • hit : Sort une seule fonctionnalité correspondante. L'opérateur interroge d'abord la map de premier niveau en utilisant la valeur category, puis interroge la map de second niveau résultante en utilisant la valeur item pour récupérer la valeur finale. Pour effectuer une correspondance à un seul niveau, définissez la clé de la map de premier niveau sur ALL et définissez le paramètre category dans la configuration de génération de fonctionnalités (FG) sur « ALL ».

  • multihit : Correspond et sort plusieurs valeurs lorsque le caractère générique ALL est utilisé dans les champs category et item.

• normalizer

  La méthode de normalisation. Ce paramètre a la même signification que dans l'opérateur raw_feature et n'agit que lorsque need_discrete=false.

• show_category

  Indique si la valeur category doit être ajoutée en préfixe à la sortie. La valeur par défaut est true si need_discrete=true et match_type=hit, et false dans les autres cas.

• show_item

  Indique si la valeur item doit être ajoutée en préfixe à la sortie. La valeur par défaut est true si need_discrete=true et match_type=hit, et false dans les autres cas.

• value_type

  Le type de données de sortie. La valeur par défaut est string.

• separator

  Facultatif. Le séparateur de valeurs multiples pour le champ key de type chaîne. La valeur par défaut est "\u001D".

• default_value

  Facultatif. La valeur par défaut pour les entrées nulles.

• value_dimension

  Facultatif. Définit la structure de données de la sortie. La valeur par défaut est 0. Si elle est définie sur 1, la sortie est une valeur unique de type value_type ; sinon, il s'agit d'un tableau de type array<value_type>.

• stub_type

  Facultatif. Si ce paramètre est défini sur true, la sortie est traitée comme un résultat intermédiaire et n'est pas envoyée au modèle. Valeur par défaut : false.

Exemples

{
  "feature_name": "brand_hit",
  "feature_type": "match_feature",
  "category": "item:auction_root_category",
  "need_discrete": true,
  "item": "item:brand_id",
  "user": "user:user_brand_tags_hit",
  "match_type": "hit"
}

Présentation

Renvoie des informations sur les correspondances de termes entre deux chaînes. Par exemple, vous pouvez utiliser cette fonctionnalité pour déterminer si une query figure dans le title d'un élément.

L'article « An Exploration of Proximity Measures in Information Retrieval » décrit les méthodes de calcul de ces fonctionnalités.

Supposons que la séquence de term d'un title (document) soit : t1,t2,t1,t3,t5,t4,t2,t3,t4

• MinCover mesure la longueur du segment de document le plus court couvrant chaque query term au moins une fois.

• MinDist (distance minimale par paire) : la distance minimale trouvée entre toute paire de query term s correspondants. Par exemple, si une query Q=t1,t2,t3 présente des distances par paire de 1, 2 et 3 dans un document, la MinDist est min(1,2,3)=1.

• MaxDist (distance maximale par paire) : la distance maximale trouvée entre toute paire de query term s correspondants. Pour le même exemple, MaxDist=max(1,2,3)=3.

• AveDist (distance moyenne par paire) : la moyenne des distances par paire entre tous les query term s correspondants. Pour le même exemple, AveDist=(1+2+3)/3=2.

Notez que tous les opérateurs d'agrégation (MinDist, MaxDist et AveDist) sont définis sur la base des distances par paire entre les query term s correspondants. Si un document ne contient qu'un seul query term correspondant, la valeur de MinDist, AveDist et MaxDist correspond à la longueur du document.

Configuration

{
  "feature_type" : "overlap_feature",
  "feature_name" : "is_contain",
  "query" : "user:attr1",
  "title" : "item:attr2",
  "method" : "is_contain",
  "separator" : " ",
  "normalizer" : ""
}

L'opérateur overlap_feature renvoie une valeur flottante.

Exemple 1

Étant donné une query « high,high2,fiberglass,abc » et un title « high,quality,fiberglass,tube,for,golf,bag » :

Exemple 2

method=index_of, title=the cat sat on the mat.

Présentation

L'historique des comportements d'un utilisateur constitue une caractéristique essentielle. Ces comportements sont généralement représentés sous forme de séquence, comme une série de clics ou d'achats. Les entités composant la séquence peuvent être les éléments eux-mêmes ou leurs attributs.

Configuration

Par exemple, pour traiter une séquence de clics utilisateur d'une longueur maximale de 50, vous pouvez extraire les fonctionnalités item_id, price et ts pour chaque élément. Ici, ts correspond à la différence entre l'heure de la requête (request_time) et l'heure de l'événement (event_time). L'exemple suivant illustre la configuration.

{
  "sequence_name": "click_50_seq",
  "sequence_length": 50,
  "sequence_delim": ";",
  "sequence_pk": "user:click_50_seq",
  "features": [
    {
        "feature_name": "item_id",
        "feature_type": "id_feature",
        "value_type": "string",
        "expression": "item:item_id"
    },
    {
        "feature_name": "price",
        "feature_type": "raw_feature",
        "expression": "item:price"
    },
    {
        "feature_name": "ts",
        "feature_type": "raw_feature",
        "expression": "user:ts"
    },
    {
      "feature_name": "time_diff_seq",
      "feature_type": "custom_feature",
      "operator_name": "SeqExpr",
      "operator_lib_file": "3rdparty/lib64/libseq_expr.so",
      "expression": ["user:cur_time", "user:clk_time_seq"],
      "formula": "cur_time - clk_time_seq",
      "sequence_fields": ["clk_time_seq"],
      "default_value": "0",
      "value_type": "double",
      "is_op_thread_safe": false,
      "value_dimension": 1
    }
  ]
}

• sequence_name : nom de la séquence.

• sequence_length : longueur maximale de la séquence.

• sequence_delim : délimiteur séparant les éléments de la séquence.

• sequence_pk : clé primaire de la séquence. Par exemple, user:click_50_seq stocke les 50 derniers itemID sur lesquels un utilisateur a cliqué. Le service d'inférence de modèle utilise ce champ comme clé pour interroger les side info.

  • Les paramètres de requête du service Online Inference Service (processeur EAS) doivent inclure une fonctionnalité dont la clé est sequence_pk.

    • Par exemple : click_50_seq: 5410233389955966;1832586 (le séparateur correspond à la valeur spécifiée pour sequence_delim)

      • Dans l'exemple ci-dessus, la valeur de la fonctionnalité click_50_seq est 5410233389955966;1832586

  • Les sous-fonctionnalités côté élément de la séquence ne doivent pas être incluses dans la requête adressée au service d'inférence de modèle.

    • Le service d'inférence de modèle utilise ce champ comme clé pour interroger les side info de l'élément.

    • Par exemple, dans cette configuration, les fonctionnalités de séquence item_id, price ne sont pas requises dans la requête adressée au service d'inférence. Elles sont plutôt récupérées depuis le cache d'éléments du processeur et concaténées à l'aide du SDK fg. Ce processus garantit que le format reste cohérent avec celui utilisé lors de l'entraînement hors ligne.

  • Les sous-fonctionnalités côté utilisateur de la séquence doivent être incluses dans la requête adressée au service d'inférence de modèle.

    • Le nom de la fonctionnalité est ${sequence_name}__${input_name}, par exemple : click_50_seq__ts.

    • ${input_name} est généralement configuré avec l'option expression, mais la configuration peut varier selon les types de sous-fonctionnalités. ${input_name} n'inclut pas de préfixe input domain (tel que item: ou user:).

• Fonctionnalités : les side info d'une séquence, qui incluent des informations telles que les valeurs d'attributs statiques d'un élément et les informations temporelles comportementales.

  • sequence_fields : spécifie les noms de champs de la séquence d'entrée. La valeur est une string ou un tableau [string].

    • Lorsqu'un opérateur de fonctionnalité ne possède qu'un seul champ d'entrée, le contenu de ce champ doit être une séquence. Dans ce cas, il n'est pas nécessaire de configurer sequence_fields.

    • Lorsqu'un opérateur de fonctionnalité possède plusieurs champs d'entrée, si vous ne configurez pas sequence_fields, toutes les fonctionnalités côté élément (telles que item:XXX) sont considérées comme des champs d'entrée de séquence.

  • La table d'entrée d'une tâche hors ligne doit inclure des colonnes correspondant à toutes les sous-fonctionnalités.

    • Lorsque la colonne est une séquence (voir les règles pour sequence_fields), elle est nommée ${sequence_name}__${input_name}.

      • Par exemple, dans cette configuration, la table hors ligne nécessite 4 colonnes : click_50_seq__item_id, click_50_seq__price, click_50_seq__ts et click_50_seq__clk_time_seq.

      • Le type recommandé pour une colonne dans une table hors ligne est array (pour de meilleures performances), tandis que le type string utilisant sequence_delim comme séparateur d'éléments est également pris en charge.

    • Si la colonne n'est pas une séquence, nommez-la ${input_name} sans préfixe.

      • Par exemple, dans cette configuration, la table hors ligne nécessite une colonne non séquentielle : ${cur_time}

    • Vous pouvez utiliser la configuration globale input_alias pour définir un alias plus court pour un nom de colonne long (voir l'exemple ci-dessous).

  • Le regroupement de fonctionnalités (binning) est pris en charge. Pour plus de détails sur la configuration, consultez Regroupement de fonctionnalités (discrétisation). Lorsque le regroupement est configuré, le type d'élément de sortie est int64 et la forme est déterminée par la configuration value_dimension.

  • value_dimension (ou value_dim) : dimension de chaque élément de la séquence. Pour une sequence_raw_feature, le type de sortie est 1 lorsque ce paramètre est défini sur array<float> et array<array<float>> pour les autres valeurs. Pour une sequence_id_feature, le type de sortie est array<string> lorsque ce paramètre est défini sur 1 et array<array<string>> pour les autres valeurs. La valeur par défaut est 0.

Tout type de fonctionnalité peut être configuré en tant que sous-fonctionnalité de séquence. Voici un exemple :

{
  "features": [
    {
      "sequence_name": "common_seq",
      "sequence_length": 50,
      "sequence_delim": ";",
      "sequence_pk": "user:click_50_seq",
      "features": [
        {
          "feature_name": "item_id",
          "feature_type": "id_feature",
          "value_type": "String",
          "expression": "item:item_id",
          "value_dimension": 1
        },
        {
          "feature_name": "price",
          "feature_type": "raw_feature",
          "expression": "item:price"
        },
        {
          "feature_name": "ts",
          "feature_type": "raw_feature",
          "expression": "user:ts"
        },
        {
          "feature_name": "expr_feat",
          "feature_type": "expr_feature",
          "expression": "a > b",
          "variables": ["item:a", "item:b"],
          "sequence_fields": "a",
          "default_value": "0",
          "value_dimension": 1
        },
        {
          "feature_name": "lookup_feat",
          "feature_type": "lookup_feature",
          "map": "user:dict",
          "key": "item:prop",
          "separator": ",",
          "default_value": "0",
          "value_type": "float",
          "combiner": "sum",
          "boundaries": [0.0, 0.15, 0.5]
        },
        {
          "feature_name": "match_feat",
          "feature_type": "match_feature",
          "user": "user:nested_dict",
          "category": "item:pkey",
          "item": "item:skey",
          "separator": "\u001D",
          "default_value": "0",
          "matchType": "hit",
          "value_type": "float",
          "value_dimension": 1
        },
        {
          "feature_name": "bm25_score",
          "feature_type": "bm25_feature",
          "separator": " ",
          "default_value": "0",
          "query": "user:query",
          "document": "item:document",
          "sequence_fields": "query",
          "document_number": 100,
          "avg_doc_length": 6,
          "term_doc_freq_dict": {
            "this": 30,
            "example": 10,
            "document": 15
          }
        },
        {
          "feature_name": "overlap_feat",
          "feature_type": "overlap_feature",
          "query": "user:query2",
          "title": "item:title2",
          "sequence_fields": "query2",
          "method": "index_of",
          "separator": " ",
          "default_value": "-1"
        },
        {
          "feature_type": "kv_dot_product",
          "feature_name": "query_doc_sim",
          "query": "user:query3",
          "document": "item:title",
          "sequence_fields": "query3",
          "separator": "|",
          "default_value": "0"
        },
        {
          "feature_name": "seg_feat",
          "feature_type": "tokenize_feature",
          "expression": "input_a",
          "default_value": "0",
          "output_type": "word",
          "tokenizer_type": "sentencepiece",
          "vocab_file": "spmodel.model"
        },
        {
          "feature_name": "txt_norm",
          "feature_type": "text_normalizer",
          "expression": "input",
          "default_value": "<oov>",
          "parameter": 28
        },
        {
          "feature_name": "seq_combo_feat",
          "feature_type": "combo_feature",
          "expression": ["user:tags", "item:cat"],
          "sequence_fields": ["tags"],
          "separator": "_",
          "default_value": "0",
          "value_dimension": 1
        },
        {
          "feature_name": "norm_str",
          "feature_type": "str_replace_feature",
          "expression": ["user:profile"],
          "default_value": "",
          "replace_file": "synonyms.txt",
          "replacements": {
            "|": "",
            "aa": "x",
            "a": "X"
          },
          "value_dimension": 1
        },
        {
          "feature_name": "query_tokens",
          "feature_type": "regex_replace_feature",
          "expression": ["user:query_tokens"],
          "default_value": "",
          "value_type": "string",
          "regex_pattern": [ "\\|", "#", "\\(.*\\)" ],
          "replacement": "",
          "value_dimension": 1
        },
        {
          "feature_name": "slice",
          "feature_type": "slice_feature",
          "value_type": "int32",
          "expression": ["context:array"],
          "slice": "0:3",
          "value_dimension": 3,
          "num_buckets": 100000
        },
        {
          "feature_name": "mask_feature",
          "feature_type": "bool_mask_feature",
          "value_type": "float",
          "expression": [
            "user:click_items",
            "item:is_valid"
          ]
        },
        {
          "feature_name": "time_diff_seq",
          "feature_type": "custom_feature",
          "operator_name": "SeqExpr",
          "operator_lib_file": "3rdparty/lib64/libseq_expr.so",
          "expression": ["user:cur_time", "user:clk_time_seq"],
          "formula": "cur_time - clk_time_seq",
          "sequence_fields": ["clk_time_seq"],
          "default_value": "0",
          "value_type": "double",
          "is_op_thread_safe": false,
          "value_dimension": 1
        }
      ]
    }
  ],
  "input_alias": {
    "common_seq__clk_time_seq": "clk_time_seq"
  }
}

Remarque : le paramètre input_alias spécifie un alias pour un champ d'entrée. Le format est "origin_field": "alias_field", ce qui permet d'utiliser un nom plus court pour remplacer le nom du champ d'entrée d'origine.

Format aplati

Généralement, vous pouvez obtenir la version séquence en ajoutant le préfixe sequence_ à un type de fonctionnalité non séquentiel (feature_type). Notez que pour les fonctionnalités de séquence, vous devez généralement configurer une default_value.

Exemples :

• sequence_id_feature : la valeur de sortie est toujours une string. Si vous avez besoin d'un autre type, utilisez plutôt slice_feature.

• sequence_raw_feature : le type de valeur de sortie est fixé à float. Si vous avez besoin d'autres types, utilisez plutôt slice_feature.

• sequence_match_feature

• sequence_lookup_feature

• sequence_expr_feature

• sequence_combo_feature

• sequence_overlap_feature

• sequence_bm25_feature

• sequence_kv_dot_product

• sequence_text_normalizer

• sequence_tokenize_feature

• sequence_combine_feature

Cas particulier 1 : certains types de transformation de fonctionnalités disposent à la fois d'une version séquence et d'une version non séquence.

Pour activer la version correspondante, définissez is_sequence: true/false.

Dans ce cas, le paramètre feature_type ne nécessite pas le préfixe sequence_.

Exemples :

• str_replace_feature

• regex_replace_feature

• custom_feature

Cas particulier 2 : certains types de transformation de fonctionnalités ne disposent que d'une version séquence.

Dans ce cas, le paramètre feature_type ne nécessite pas le préfixe sequence_.

Exemples :

• slice_feature

• bool_mask_feature

Pour ces deux cas particuliers, vous pouvez ajouter les paramètres facultatifs suivants :

• sequence_length : longueur maximale de la séquence. Les éléments dépassant cette longueur sont tronqués. La valeur par défaut est -1, ce qui signifie que la séquence n'est pas tronquée.

• sequence_delim : séparateur entre les éléments de la séquence. La valeur par défaut est ;.

Le code suivant fournit un exemple de configuration.

{
  "feature_name": "clk_seq__item_id",
  "feature_type": "sequence_id_feature",
  "sequence_name": "clk_seq",
  "sequence_length": 50,
  "sequence_delim": ";",
  "expression": "item:clk_item_seq",
  "separator": "\u001D",
  "default_value": ""
},
{
  "feature_name": "clk_seq__item_price",
  "feature_type": "sequence_raw_feature",
  "sequence_name": "clk_seq",
  "sequence_length": 50,
  "sequence_delim": ";",
  "expression": "item:clk_item_prices",
  "separator": "\u001D",
  "default_value": "0"
},
{
  "feature_name": "test",
  "feature_type": "sequence_lookup_feature",
  "map": "user:prefer_tags",
  "key": "item:tags",
  "sequence_length": 2,
  "separator": ",",
  "default_value": "-1024",
  "value_type": "int32",
  "normalizer": "method=expression,expr=x+1",
  "combiner": "sum",
  "default_bucketize_value": 50,
  "num_buckets": 10000
},
{
  "feature_name": "test",
  "feature_type": "sequence_combo_feature",
  "separator": "_",
  "default_value": "0",
  "expression": ["user:f1", "item:f2"],
  "hash_bucket_size": 10000
}

Dans l'exemple précédent, les champs d'entrée clk_item_seq et clk_item_prices doivent être une séquence, qui peut être un tableau ou une chaîne dont les éléments sont séparés par le caractère configuré par sequence_delim.

• Avec cette configuration, le service en ligne (processeur) n'interroge pas les side info. Vous devez fournir l'entrée complète.

• Le nom du champ d'entrée pour une fonctionnalité de séquence au format aplati est identique au nom configuré et n'est pas précédé de ${sequence_name}__.

Génération de fonctionnalités en ligne

Vous pouvez obtenir les sideinfo comportementaux de deux manières. La première consiste à récupérer les sideinfo depuis le cache d'éléments du processeur EasyRec. Le champ spécifié par sequence_pk est utilisé comme clé primaire pour rechercher les informations d'attribut de l'élément dans le cache d'éléments. La seconde consiste à renseigner les valeurs de champ correspondantes dans la requête. Par exemple, le champ « ts » dans la configuration précédente représente (request_time - event_time), c'est-à-dire l'heure de la requête de recommandation moins l'heure du comportement utilisateur. Cette valeur changeant à chaque requête, elle doit donc être obtenue à partir de la requête.

user_features {
  key: "click_50_seq"
  value {
    string_feature: "9008721;34926279;22487529;73379;840804;911247;31999202;7421440;4911004;40866551"
  }
}

user_features {
  key: "click_50_seq__ts"
  value {
    string_feature: "23;113;401363;401369;401375;401405;486678;486803;486922;486969"
  }
}

Présentation

L'opérateur combine_feature agrège plusieurs valeurs d'une fonctionnalité d'entrée en une seule valeur à l'aide d'une stratégie de combinaison spécifiée (combiner).

Sa version séquence, sequence_combine_feature, agrège les valeurs au sein de chaque élément d'une fonctionnalité de séquence, transformant ainsi une séquence multivaleur en une séquence monovaleur.

Fonctionnalités clés

• Combinaison multivaleur : agrège plusieurs valeurs d'une fonctionnalité en une seule valeur.

• Stratégie de combinaison flexible : prend en charge diverses stratégies, telles que sum, mean, max, min et count.

• Map de valeurs : convertit les identifiants de chaîne en valeurs numériques, idéal pour le traitement d'une séquence d'événements comportementaux.

• Prise en charge des doubles séparateurs : vous permet de configurer à la fois un délimiteur de séquence et un séparateur multivaleur.

Configuration

Configuration de base (combinaison numérique)

{
  "feature_name": "combine_feat",
  "feature_type": "combine_feature",
  "expression": "user:behavior_seq",
  "combiner": "sum",
  "separator": "|"
}

Vous pouvez configurer la version séquence de deux manières :

• Définissez le paramètre feature_type sur sequence_combine_feature.

• Ajoutez le paramètre "is_sequence": true.

{
  "feature_name": "seq_combine_feat",
  "feature_type": "sequence_combine_feature",
  "expression": "user:behavior_seq",
  "combiner": "sum",
  "separator": "|",
  "sequence_delim": ";"
}

Ou :

{
  "feature_name": "seq_combine_feat",
  "feature_type": "combine_feature",
  "expression": "user:behavior_seq",
  "combiner": "sum",
  "is_sequence": true,
  "separator": "|",
  "sequence_delim": ";"
}

Configuration de map de valeurs (événements comportementaux)

{
  "feature_name": "behavior_score",
  "feature_type": "sequence_combine_feature",
  "expression": "user:action_events",
  "combiner": "sum",
  "separator": "|",
  "sequence_delim": ";",
  "value_map": {
    "expo": 1,
    "click": 2,
    "buy": 4
  }
}

L'opérateur applique d'abord la map de valeurs, puis combine les valeurs résultantes.

Paramètres

Exemples

Exemple 1 : Combinaison numérique de base (somme)

Configuration :

{
  "feature_name": "score_sum",
  "feature_type": "sequence_combine_feature",
  "expression": "user:scores",
  "combiner": "sum",
  "separator": ",",
  "sequence_delim": ";"
}

Entrée et sortie :

Exemple 2 : Séquence d'événements comportementaux (avec table de correspondance des valeurs)

Configuration :

{
  "feature_name": "behavior_weight",
  "feature_type": "sequence_combine_feature",
  "expression": "user:actions",
  "combiner": "sum",
  "separator": "|",
  "sequence_delim": ";",
  "value_map": {
    "expo": 1,
    "click": 2,
    "buy": 4
  }
}

Entrée et sortie :

Présentation

L'opérateur tokenize_feature tokenize une chaîne d'entrée et renvoie soit la chaîne tokenisée, soit les ID de jetons correspondants. Cet opérateur prend en charge les fichiers de vocabulaire au format tokenizer.json de la bibliothèque tokenizers-cpp.

Pour plus d'informations sur le format des fichiers de vocabulaire, consultez les ressources suivantes :

1. https://github.com/huggingface/tokenizers

2. https://github.com/mlc-ai/tokenizers-cpp

Configuration

{
    "feature_name": "title_token",
    "feature_type": "tokenize_feature",
    "expression": "item:title",
    "default_value": "",
    "vocab_file": "tokenizer.json",
    "tokenizer_type": "sentencepiece",
    "output_type": "word_id",
    "output_delim": ","
}

Exemple

Lorsque output_type est défini sur word_id, l'opérateur renvoie une chaîne d'ID de jetons, séparés par le caractère spécifié dans output_delim.

Exemples de vocabulaires

Présentation

L'opérateur text_normalizer effectue la normalisation du texte. Ses fonctionnalités incluent la conversion de la casse, la conversion du chinois traditionnel en chinois simplifié, la conversion des caractères pleine largeur en demi-largeur, le filtrage des caractères spéciaux, la conversion d'encodage GBK/UTF-8 et la segmentation des caractères chinois.

Configuration

{
    "feature_name": "txt_norm",
    "feature_type": "text_normalizer",
    "expression": "item:title",
    "stop_char_file": "stop_char.txt",
    "max_length": 256,
    "parameter": 0,
    "remove_space": false,
    "is_gbk_input": false,
    "is_gbk_output": false
}

Remarque :

• Le fichier stop_char_file doit utiliser l'encodage GBK.

• Chaque ligne du fichier stop_char_file ne peut contenir qu'un seul caractère. Dans le cas contraire, le filtrage échouera.

Options de normalisation du texte

Le paramètre parameter spécifie la somme d'un ou plusieurs des nombres suivants.

Par exemple, si les fonctions requises sont la conversion des majuscules en minuscules, la conversion des caractères pleine largeur en demi-largeur, la conversion du chinois traditionnel en chinois simplifié et le filtrage des caractères spéciaux, alors parameter=4+8+16+32=60.

La valeur par défaut du paramètre parameter est 60.

#define __NORMALIZED_LOWER2UPPER__ 		2 			/* Convert lowercase to uppercase. */
#define __NORMALIZED_UPPER2LOWER__ 		4 			/* Convert uppercase to lowercase. */
#define __NORMALIZED_SBC2DBC__ 			8 			/* Convert full-width to half-width characters. */
#define __NORMALIZED_BIG52GBK__			16 			/* Convert Traditional to Simplified Chinese. */
#define __NORMALIZED_FILTER__ 			32 			/* Filter special characters. */
#define __NORMALIZED_SPLITCHARS__		512 		/* Split Chinese characters into single characters, separated by spaces. */

Exemple

{
  "feature_name": "txt_norm",
  "feature_type": "text_normalizer",
  "expression": "input_a",
  "parameter": 28
}

• inputs=["Regular Expression Code Generator", "HTML Filtering Tool", "Regular Expression Syntax Cheatsheet", "The Cat/"]

• outputs=["regex code generator", "HTML filtering tool", "regular expression syntax quick reference", "the cat/"]

Fonctionnalités

L'algorithme BM25 (Best Matching) est un algorithme de correspondance de texte de premier plan en recherche d'information, utilisé pour calculer les scores de pertinence de recherche. L'algorithme commence par analyser une requête en termes q_i. Ensuite, pour chaque résultat de recherche D, il calcule le score de pertinence de chaque terme q_i pour D. Enfin, il calcule une somme pondérée des scores de pertinence de chaque terme q_i afin d'obtenir le score de pertinence final entre la requête et D.

Pour le chinois, vous pouvez aborder la tokenisation des requêtes comme une analyse morphologique, en traitant chaque terme comme un morphème q_i.

La formule générale de l'algorithme BM25 est la suivante :

score(Q, d)=\sum_{i=1}^n w_i R(q_i,d)

Où Q représente une requête, q_i est le i-ième terme de la requête, d est un document, w_i est le poids de q_i, et R(q_i, d) est le score de pertinence de q_i pour le document d.

Importance des termes

Il existe plusieurs méthodes pour déterminer la pertinence d'un terme par rapport à un document. L'une des plus courantes est la fréquence inverse de document (IDF). La formule est la suivante :

IDF(q_i) = log \frac{N-n(q_i)+0.5}{n(q_i) + 0.5}

Ici, N représente le nombre total de documents dans le corpus, et n(q_i) représente le nombre total de documents dans le corpus qui contiennent qi.

Selon la définition de l'IDF, pour une collection de documents donnée, plus il y a de documents contenant le terme q_i, plus le poids de q_i est faible. En d'autres termes, lorsque de nombreux documents contiennent q_i, le pouvoir discriminant de q_i est faible. Par conséquent, q_i est moins important pour déterminer la pertinence.

Pertinence des termes

Dans BM25, le score de pertinence entre un terme q_i et un document d, noté R(q_i,d), est :

R(q_i,d)= \frac{f_i \cdot (k_1+1)}{f_i + K} \cdot \frac{qf_i \cdot (k_2+1)}{qf_i + k_2}

K=k_1 \cdot \left( 1 - b + b \cdot \frac{dl}{avgdl} \right)

k_1, k_2, b sont des facteurs d'ajustement, généralement définis sur la base de l'expérience. Les valeurs courantes sont k_1=1.2, b=0.75, k_2=0. f_i est la fréquence du terme q_i dans le document d, et qf_i est la fréquence du terme q_i dans la requête. dl est la longueur du document d, et avgdl est la longueur moyenne des documents pour l'ensemble des documents. Étant donné qu'un terme q_i n'apparaît généralement qu'une seule fois dans une requête (qf_i=1), la formule se simplifie comme suit :

R(q_i,d)= \frac{f_i \cdot (k_1+1)}{f_i + K}

D'après la définition de K, vous pouvez constater que le paramètre b ajuste l'impact de la longueur du document sur la pertinence. Plus la valeur de b est élevée, plus l'effet de la longueur du document sur le score de pertinence est important, et vice versa. Plus la longueur relative d'un document est grande, plus la valeur de K est élevée, ce qui réduit le score de pertinence. Cela s'explique par le fait qu'un document plus long est plus susceptible de contenir q_i. Par conséquent, pour une même valeur de f_i, la pertinence d'un long document par rapport à q_i est plus faible que celle d'un court document par rapport à q_i.

La formule du score de pertinence de l'algorithme BM25 peut être résumée comme suit :

score(Q,d)=\sum_{j=1}^n IDF(q_i) \frac{f_{i}\cdot(k_1+1)}{f_{i}+k_1 \cdot (1-b+b\cdot \frac{dl}{avgdl})}

La formule BM25 démontre que l'utilisation de différentes méthodes de tokenisation, de pondération des termes et de détermination de la pertinence terme-document peut produire diverses méthodes de scoring de pertinence de recherche, offrant ainsi une grande flexibilité pour la conception d'algorithmes.

Configuration

{
  "feature_type": "bm25_feature",
  "feature_name": "query_doc_relevance",
  "query": "user:query",
  "document": "item:title",
  "term_doc_freq_file": "term_doc_freq.txt",
  "document_number": 1000,
  "avg_doc_length": 100.0,
  "k1": 1.2,
  "b": 0.75,
  "separator": "\u001D",
  "default_value": ""
}

• Spécifiez soit term_doc_freq_file, soit term_doc_freq_dict. Le premier a la priorité et est utilisé si les deux sont spécifiés.

• Lorsque vous utilisez cette fonctionnalité dans le service en ligne, placez le fichier term_doc_freq_file et fg.json dans le même répertoire.

Présentation

Calcule le produit scalaire des vecteurs de deux index key-value, ou la taille de l'intersection de deux ensembles.

Configuration

{
  "feature_type": "kv_dot_product",
  "feature_name": "query_doc_sim",
  "query": "user:query",
  "document": "item:title",
  "separator": "|",
  "default_value": "0"
}

• Cette fonctionnalité prend en charge les types complexes, tels que array et map. Utilisez des types complexes pour des performances optimales.

• Lorsque l'entrée ne contient pas de partie value, la valeur value par défaut est 1,0. Vous pouvez utiliser cette propriété pour déterminer la taille de l'intersection de deux ensembles.

• Si vous ne configurez pas default_value, la valeur par défaut est définie sur 0.

Exemples

Présentation

L'opérateur str_replace_feature remplace toutes les sous-chaînes correspondantes dans une chaîne d'entrée par les remplacements spécifiés.

Les correspondances qui se chevauchent sont remplacées de manière gloutonne.

Configuration

{
  "feature_name": "norm_str",
  "feature_type": "str_replace_feature",
  "expression": ["user:query"],
  "default_value": "",
  "replacements": {
    "brown": "box",
    "dogs": "jugs",
    "fox": "with",
    "jumped": "five",
    "over": "dozen",
    "quick": "my",
    "the": "pack",
    "the lazy": "liquor",
    "|": "",
    "aa": "x",
    "a": "X"
  },
  "value_dimension": 1
}

• Vous pouvez configurer à la fois replace_file et replacements. Les dictionnaires de remplacement des deux sources sont fusionnés, et replacements a une priorité plus élevée.

• Cet opérateur prend en charge le regroupement de fonctionnalités (binning). Pour plus de détails sur la configuration, consultez la section Regroupement de fonctionnalités (discrétisation) :

  • hash_bucket_size : hache le résultat de la transformation de la fonctionnalité et applique une opération modulo.

  • vocab_list : regroupe l'entrée en fonction d'un vocabulaire et mappe chaque valeur à son index dans la liste.

  • vocab_dict : regroupe l'entrée en mappant chaque valeur de fonctionnalité à sa valeur correspondante dans le vocab_dict.

  • vocab_file : lit le vocab_list ou le vocab_dict à partir d'un fichier.

• Cet opérateur prend en charge les entrées multivalues de type array.

Exemple

Le tableau suivant présente la sortie pour l'exemple de configuration précédent.

Présentation

L'opérateur regex_replace_feature remplace les sous-chaînes correspondant à une expression régulière par une chaîne de remplacement spécifiée.

Vous pouvez configurer plusieurs motifs. L'opérateur remplace toute sous-chaîne correspondant à l'un des motifs spécifiés.

Configuration

{
  "feature_name": "query",
  "feature_type": "regex_replace_feature",
  "expression": ["user:query"],
  "regex_pattern": "\\|",
  "replacement": " ",
  "default_value": ""
}

• Cet opérateur prend en charge le regroupement de fonctionnalités. Pour plus de détails sur la configuration, consultez la documentation sur le regroupement de fonctionnalités (discrétisation). Les paramètres suivants sont disponibles :

  • hash_bucket_size : hache la valeur de la fonctionnalité et applique une opération modulo.

  • vocab_list : regroupe la valeur de la fonctionnalité en fonction d'une liste de vocabulaire et la mappe à son index dans la liste.

  • vocab_dict : mappe chaque valeur de fonctionnalité à une valeur correspondante dans le vocab_dict.

  • vocab_file : lit le vocab_list ou le vocab_dict à partir d'un fichier.

• Prend en charge les entrées array multivalues.

Exemple

Introduction

Filtre les éléments d'une séquence à l'aide d'un masque booléen, de manière similaire à tf.boolean_mask(tensor, mask).

Il s'agit d'un type de sequence feature.

Configuration

{
  "feature_name": "mask_feature",
  "feature_type": "bool_mask_feature",
  "value_type": "float",
  "expression": [
    "user:click_items",
    "item:is_valid"
  ],
  "sequence_delim": ","
}

• Prend en charge le regroupement de fonctionnalités. Pour plus de détails sur la configuration, consultez la section Regroupement de fonctionnalités (discrétisation).

• Prend en charge les entrées multivalues sous forme de tableaux ou de tableaux imbriqués.

Exemples

Utilisation avec les fonctionnalités d'expression

{
  "features": [
    {
      "feature_name": "mask",
      "feature_type": "expr_feature",
      "expression": "price>100",
      "variables": ["item:price"],
      "value_dimension": 3
    },
    {
      "feature_name": "filter_list",
      "feature_type": "bool_mask_feature",
      "expression": [
        "user:click_items",
        "feature:mask"
      ],
      "num_buckets": 10000
    }
  ]
}

Présentation

Découpe un tableau d'entrée à l'aide de la syntaxe de découpage de style Python ou récupère un élément à un index spécifique.

Il s'agit d'un type de sequence feature.

Configuration

{
  "feature_name": "test_feature",
  "feature_type": "slice_feature",
  "value_type": "float",
  "expression": [
    "user:click_items"
  ],
  "slice": "2:4"
}

• Cet opérateur prend en charge le binning des fonctionnalités. Pour obtenir des détails sur la configuration, consultez binning des fonctionnalités (discrétisation).

• Cet opérateur prend en charge les entrées à valeurs multiples, y compris les tableaux et les tableaux imbriqués.

Exemple

Lorsque vous définissez sequence_delim="," et value_dimension=1, l'entrée et la sortie sont les suivantes :