def __init__(self, dim, activation=tf.nn.relu, renorm=False, **kwargs): super(SingleAttentionAggregator, self).__init__(**kwargs) self.dense = layers.Dense(dim, use_bias=False) self.self_layer = layers.Dense(1, use_bias=False) self.neigh_layer = layers.Dense(1, use_bias=False) self.activation = activation self.renorm = renorm
def __init__(self, dim, activation=tf.nn.relu, concat=False, **kwargs): super(MeanAggregator, self).__init__(**kwargs) if concat: dim //= 2 self.concat = concat self.self_layer = layers.Dense(dim, activation=activation, use_bias=False) self.neigh_layer = layers.Dense(dim, activation=activation, use_bias=False)
def __init__(self, dim, activation=tf.nn.relu, concat=False, **kwargs): super(BaseAggregator, self).__init__(**kwargs) if concat: if dim % 2: raise ValueError('dim must be divided exactly ' 'by 2 if concat is True.') dim //= 2 self.concat = concat self.self_layer = layers.Dense(dim, activation=activation, use_bias=False) self.neigh_layer = layers.Dense(dim, activation=activation, use_bias=False)
def fm(self, hidden): o = len(hidden) for i in range(1, o): comb = tf.multiply(hidden[0], hidden[i]) hidden += [comb] fc = tf.concat(hidden, 1) ld = layers.Dense(self.dims[-1], activation=tf.nn.relu, use_bias=True) return ld(fc)
def __init__(self, metapath, dim, aggregator='attention', feature_idx=-1, feature_dim=0, max_id=-1, use_id=False, sparse_feature_idx=-1, sparse_feature_max_id=-1, embedding_dim=16, use_hash_embedding=False, use_residual=False, head_num=4, **kwargs): super(GenieEncoder, self).__init__(metapath, dim, aggregator, feature_idx, feature_dim, max_id, use_id, sparse_feature_idx, sparse_feature_max_id, embedding_dim, use_hash_embedding, use_residual, head_num, **kwargs) self.dim = dim self.depth_fc = [] for layer in range(self.num_layers + 1): self.depth_fc.append(layers.Dense(dim))
def __init__(self, dim, activation=tf.nn.relu, renorm=False, **kwargs): super(GCNAggregator, self).__init__(**kwargs) self.renorm = renorm self.dense = layers.Dense(dim, activation=activation, use_bias=False)
def fc(self, hidden): fc = tf.concat(hidden, 1) ld = layers.Dense(self.dims[-1], activation=tf.nn.relu, use_bias=True) return ld(fc)
def __init__(self, dim=None, feature_idx='f1', feature_dim=0, max_id=-1, sparse_feature_idx=-1, sparse_feature_max_id=-1, embedding_dim=16, use_hash_embedding=False, combiner='concat', **kwargs): super(ShallowEncoder, self).__init__(**kwargs) if combiner not in ['add', 'concat']: raise ValueError('combiner must be \'add\' or \'concat\'.') if combiner == 'add' and dim is None: raise ValueError('add must be used with dim provided.') use_feature = feature_idx != -1 use_id = max_id != -1 use_sparse_feature = sparse_feature_idx != -1 if not isinstance(feature_idx, list) and use_feature: feature_idx = [feature_idx] if isinstance(feature_dim, int) and use_feature: feature_dim = [feature_dim] if use_feature and len(feature_idx) != len(feature_dim): raise ValueError('feature_dim must be the same length as feature' '_idx.idx:%s, dim:%s' % (str(feature_idx), str(feature_dim))) if isinstance(sparse_feature_idx, int) and use_sparse_feature: sparse_feature_idx = [sparse_feature_idx] if isinstance(sparse_feature_max_id, int) and use_sparse_feature: sparse_feature_max_id = [sparse_feature_max_id] if use_sparse_feature and \ len(sparse_feature_idx) != len(sparse_feature_max_id): raise ValueError('sparse_feature_idx must be the same length as' 'sparse_feature_max_id.') embedding_num = (1 if use_id else 0) + \ (len(sparse_feature_idx) if use_sparse_feature else 0) if combiner == 'add': embedding_dim = dim if isinstance(embedding_dim, int) and embedding_num: embedding_dim = [embedding_dim] * embedding_num if embedding_num and len(embedding_dim) != embedding_num: raise ValueError('length of embedding_num must be int(use_id) + ' 'len(sparse_feature_idx)') if isinstance(use_hash_embedding, bool) and embedding_num: use_hash_embedding = [use_hash_embedding] * embedding_num if embedding_num and len(use_hash_embedding) != embedding_num: raise ValueError('length of use_hash_embedding must be int(use_id)' ' + len(sparse_feature_idx)') # model architechture self.dim = dim self.use_id = use_id self.use_feature = use_feature self.use_sparse_feature = use_sparse_feature self.combiner = combiner # feature fetching parameters self.feature_idx = feature_idx self.feature_dim = feature_dim self.sparse_feature_idx = sparse_feature_idx self.sparse_feature_max_id = sparse_feature_max_id self.embedding_dim = embedding_dim # sub-layers if dim: self.dense = layers.Dense(self.dim, use_bias=False) if use_id: embedding_class = \ layers.HashEmbedding if use_hash_embedding[0] \ else layers.Embedding self.embedding = embedding_class(max_id + 1, embedding_dim[0]) embedding_dim = embedding_dim[1:] use_hash_embedding = use_hash_embedding[1:] if use_sparse_feature: self.sparse_embeddings = [] for max_id, dim, use_hash in zip( sparse_feature_max_id, embedding_dim, use_hash_embedding): sparse_embedding_class = \ layers.HashSparseEmbedding if use_hash \ else layers.SparseEmbedding self.sparse_embeddings.append( sparse_embedding_class(max_id + 1, dim))
def __init__(self, dim, *args, **kwargs): super(BasePoolAggregator, self).__init__(dim, *args, **kwargs) self.layers = [layers.Dense(dim, activation=tf.nn.relu)]