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, metapaths_of_groups, fanouts, dim, feature_ixs, feature_dims, aggregator='mean', concat=False, share_aggregator=False, *args, **kwargs): super(LasGNN, self).__init__(*args, **kwargs) shared_embeddings = encoders.SparseSageEncoder.create_sparse_embeddings( feature_dims) if share_aggregator: shared_aggregators = encoders.SparseSageEncoder.create_aggregators( dim, len(fanouts), aggregator, concat=concat) else: shared_aggregators = None self._sparse_sage_encoders = [[ encoders.SparseSageEncoder(metapath, fanouts, dim, feature_ixs, feature_dims, shared_embeddings=shared_embeddings, aggregator=aggregator, concat=concat, shared_aggregators=shared_aggregators) for metapath in metapaths_of_group ] for metapaths_of_group in metapaths_of_groups] self._attention_of_group = [Attention() for _ in metapaths_of_group] self._target_feed_forward = layers.Dense(dim) self._context_feed_forward = layers.Dense(dim)
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, node_type, path_patterns, max_id, dim, sparse_feature_dims, feature_ids, feature_embedding_dim=16, walk_len=3, left_win_size=1, right_win_size=1, num_negs=5, gamma=5, *args, **kwargs): super(LsHNE, self).__init__(node_type, path_patterns, max_id, *args, **kwargs) self.node_type = node_type self.path_patterns = path_patterns self.max_id = max_id self.dim = dim self.walk_len = walk_len self.left_win_size = left_win_size self.right_win_size = right_win_size self.num_negs = num_negs self.view_num = len(path_patterns) if self.view_num < 1: raise ValueError('View Number must be bigger than 1, got{}'.format( self.view_num)) if not isinstance(sparse_feature_dims, list): raise TypeError( 'Expect list for sparse feature dimsgot {}.'.format( type(sparse_feature_dims).__name__)) self.sparse_feature_dims = sparse_feature_dims self.feature_ids = feature_ids self.feature_embedding_dim = feature_embedding_dim self.raw_fdim = feature_embedding_dim * len(feature_ids) self.feature_embedding_layer = [] for d in sparse_feature_dims: self.feature_embedding_layer.append( layers.SparseEmbedding(d, feature_embedding_dim, combiner="sum")) self.hidden_layer = [{}] * self.view_num for i in range(0, self.view_num): self.hidden_layer[i]['src'] = layers.Dense(256) self.hidden_layer[i]['tar'] = layers.Dense(256) self.out_layer = [{}] * self.view_num for i in range(0, self.view_num): self.out_layer[i]['src'] = layers.Dense(self.dim) self.out_layer[i]['tar'] = layers.Dense(self.dim) self.att_vec = tf.get_variable( 'att_vec', shape=[self.view_num, self.dim], initializer=tf.truncated_normal_initializer(stddev=0.1)) self.gamma = gamma
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 __init__(self, node_type, edge_type, max_id, *args, **kwargs): super(BaseGraphSage_SE, self).__init__(node_type, edge_type, max_id, *args, **kwargs) dim = self.embedding_dim() self.sim_to_cor = [ layers.Dense(dim, activation=tf.nn.relu, use_bias=True) for _ in range(2) ] self.cor_to_sim = [ layers.Dense(dim, activation=tf.nn.relu, use_bias=True) for _ in range(2) ]
def __init__(self, metapath, dim, aggregator='mean', feature_idx=-1, feature_dim=0, max_id=-1, use_feature=True, use_id=False, use_residual=False, **kwargs): super(GCNEncoder, self).__init__(**kwargs) self.metapath = metapath self.num_layers = len(metapath) self.use_id = use_id self.use_feature = use_feature self.use_residual = use_residual if use_id: self.id_layer = layers.Embedding(max_id, dim) if use_feature and use_residual: self.feature_layer = layers.Dense(dim, use_bias=False) self.feature_idx = feature_idx self.feature_dim = feature_dim self.aggregators = [] aggregator_class = sparse_aggregators.get(aggregator) for layer in range(self.num_layers): activation = tf.nn.relu if layer < self.num_layers - 1 else None self.aggregators.append( aggregator_class(dim, activation=activation))
def __init__(self, label_idx, label_dim, num_classes=None, sigmoid_loss=False, **kwargs): super(SupervisedModel, self).__init__() self.label_idx = label_idx self.label_dim = label_dim if num_classes is None: num_classes = label_dim if label_dim > 1 and label_dim != num_classes: raise ValueError('laben_dim must match num_classes.') self.num_classes = num_classes self.sigmoid_loss = sigmoid_loss self.predict_layer = layers.Dense(num_classes)
def __init__(self, dim, feature_idx=-1, feature_dim=0, max_id=-1, use_feature=True, use_id=False, **kwargs): super(ShallowEncoder, self).__init__(**kwargs) if not use_feature and not use_id: raise ValueError('Either use_feature or use_id must be True.') self.dim = dim self.use_id = use_feature self.use_feature = use_feature if use_id: self.embedding = layers.Embedding(dim, max_id) if use_feature: self.dense = layers.Dense(self.dim) self.feature_idx = feature_idx self.feature_dim = feature_dim
def __init__(self, dim=None, feature_idx=-1, 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 isinstance(feature_idx, int) 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.') 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.', len(sparse_feature_idx), len(sparse_feature_max_id), sparse_feature_idx, 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, 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 __init__(self, dim, *args, **kwargs): super(BasePoolAggregator, self).__init__(dim, *args, **kwargs) self.layers = [layers.Dense(dim, activation=tf.nn.relu)]