add kv seq feature

Author: 浅梦

deepctr/inputs.py

@@ -13,10 +13,9 @@
 from tensorflow.python.keras.layers import  Embedding, Input, Flatten
 from tensorflow.python.keras.regularizers import l2
 
-from .layers.sequence import SequencePoolingLayer
+from .layers.sequence import SequencePoolingLayer, SequenceMultiplyLayer
 from .layers.utils import Hash,concat_fun,Linear
 
-
 class SparseFeat(namedtuple('SparseFeat', ['name', 'dimension', 'use_hash', 'dtype','embedding_name','embedding'])):
     __slots__ = ()
 
@@ -25,6 +24,16 @@ def __new__(cls, name, dimension, use_hash=False, dtype="int32", embedding_name=
             embedding_name = name
         return super(SparseFeat, cls).__new__(cls, name, dimension, use_hash, dtype, embedding_name,embedding)
 
+    def __hash__(self):
+        return self.name.__hash__()
+
+    def __eq__(self, other):
+        if self.name == other.name:
+            return True
+        return False
+
+    def __repr__(self):
+        return 'SparseFeat:'+self.name
 
 class DenseFeat(namedtuple('DenseFeat', ['name', 'dimension', 'dtype'])):
     __slots__ = ()
@@ -33,6 +42,16 @@ def __new__(cls, name, dimension=1, dtype="float32"):
 
         return super(DenseFeat, cls).__new__(cls, name, dimension, dtype)
 
+    def __hash__(self):
+        return self.name.__hash__()
+
+    def __eq__(self, other):
+        if self.name == other.name:
+            return True
+        return False
+
+    def __repr__(self):
+        return 'DenseFeat:'+self.name
 
 class VarLenSparseFeat(namedtuple('VarLenFeat', ['name', 'dimension', 'maxlen', 'combiner', 'use_hash', 'dtype','embedding_name','embedding'])):
     __slots__ = ()
@@ -42,6 +61,17 @@ def __new__(cls, name, dimension, maxlen, combiner="mean", use_hash=False, dtype
             embedding_name = name
         return super(VarLenSparseFeat, cls).__new__(cls, name, dimension, maxlen, combiner, use_hash, dtype, embedding_name,embedding)
 
+    def __hash__(self):
+        return self.name.__hash__()
+
+    def __eq__(self, other):
+        if self.name == other.name:
+            return True
+        return False
+
+    def __repr__(self):
+        return 'VarLenSparseFeat:'+self.name
+
 def get_feature_names(feature_columns):
     features = build_input_features(feature_columns)
     return list(features.keys())
@@ -209,6 +239,30 @@ def get_varlen_pooling_list(embedding_dict, features, varlen_sparse_feature_colu
         pooling_vec_list.append(vec)
     return pooling_vec_list
 
+def get_varlen_multiply_list(embedding_dict, features, varlen_sparse_feature_columns_name_dict):
+    multiply_vec_list = []
+    print(embedding_dict)
+    for key_feature in varlen_sparse_feature_columns_name_dict:
+        for value_feature in varlen_sparse_feature_columns_name_dict[key_feature]:
+            key_feature_length_name = key_feature.name + '_seq_length'
+            if isinstance(value_feature, VarLenSparseFeat):
+                value_input = embedding_dict[value_feature.name]
+            elif isinstance(value_feature, DenseFeat):
+                value_input = features[value_feature.name]
+            else:
+                raise TypeError("Invalid feature column type,got",type(value_feature))
+            if key_feature_length_name in features:
+                varlen_vec = SequenceMultiplyLayer(supports_masking=False)(
+                    [embedding_dict[key_feature.name], features[key_feature_length_name], value_input])
+                vec = SequencePoolingLayer('sum', supports_masking=False)(
+                    [varlen_vec, features[key_feature_length_name]])
+            else:
+                varlen_vec = SequenceMultiplyLayer(supports_masking=True)(
+                    [embedding_dict[key_feature.name], value_input])
+                vec = SequencePoolingLayer('sum', supports_masking=True)( varlen_vec)
+            multiply_vec_list.append(vec)
+    return multiply_vec_list
+
 def get_dense_input(features,feature_columns):
     dense_feature_columns = list(filter(lambda x:isinstance(x,DenseFeat),feature_columns)) if feature_columns else []
     dense_input_list = []

deepctr/layers/sequence.py

@@ -739,3 +739,52 @@ def get_config(self, ):
         config = {'k': self.k, 'axis': self.axis}
         base_config = super(KMaxPooling, self).get_config()
         return dict(list(base_config.items()) + list(config.items()))
+
+
+class SequenceMultiplyLayer(Layer):
+
+    def __init__(self, supports_masking, **kwargs):
+        super(SequenceMultiplyLayer, self).__init__(**kwargs)
+        self.supports_masking = supports_masking
+
+    def build(self, input_shape):
+        if not self.supports_masking:
+            self.seq_len_max = int(input_shape[0][1])
+        super(SequenceMultiplyLayer, self).build(
+            input_shape)  # Be sure to call this somewhere!
+
+    def call(self, input_list, mask=None, **kwargs):
+        if self.supports_masking:
+            if mask is None:
+                raise ValueError(
+                    "When supports_masking=True,input must support masking")
+            key_input, value_input = input_list
+            mask = tf.cast(mask[0], tf.float32)
+            mask = tf.expand_dims(mask, axis=2)
+        else:
+            key_input, key_length_input, value_input = input_list
+            mask = tf.sequence_mask(key_length_input,
+                                    self.seq_len_max, dtype=tf.float32)
+            mask = tf.transpose(mask, (0, 2, 1))
+
+        embedding_size = key_input.shape[-1]
+        mask = tf.tile(mask, [1, 1, embedding_size])
+        key_input *= mask
+        if len(tf.shape(value_input)) == 2:
+            value_input = tf.expand_dims(value_input, axis=2)
+            value_input = tf.tile(value_input, [1, 1, embedding_size])
+        return tf.multiply(key_input,value_input)
+
+    def compute_output_shape(self, input_shape):
+        return input_shape[0]
+
+    def compute_mask(self, inputs, mask):
+        if self.supports_masking:
+            return mask[0]
+        else:
+            return None
+
+    def get_config(self, ):
+        config = {'supports_masking': self.supports_masking}
+        base_config = super(SequenceMultiplyLayer, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))