def call(self, inputs): samples = euler_ops.sample_fanout( inputs, self.metapath, self.fanouts, default_node=self._max_id + 1)[0] h = self.agg(inputs, samples, False) h_neg = self.agg(inputs, samples, True) return [h, h_neg]
def call(self, inputs): samples = euler_ops.sample_fanout( inputs, self.metapath, self.fanouts, default_node=0)[0] hidden = [self.node_encoder(sample) for sample in samples] hidden = self.layerwise_embed(hidden) output = self.fm(hidden) output_shape = inputs.shape.concatenate(self.dims[-1]) output_shape = [d if d is not None else -1 for d in output_shape.as_list()] return tf.reshape(output, output_shape)
def call(self, inputs): samples = euler_ops.sample_fanout( inputs, self.metapath, self.fanouts, default_node=self._max_id + 1)[0] hidden = [self.node_encoder(sample) for sample in samples] for layer in range(self.num_layers): aggregator = self.aggregators[layer] next_hidden = [] for hop in range(self.num_layers - layer): neigh_shape = [-1, self.fanouts[hop], self.dims[layer]] h = aggregator((hidden[hop], tf.reshape(hidden[hop + 1], neigh_shape))) next_hidden.append(h) hidden = next_hidden output_shape = inputs.shape.concatenate(self.dims[-1]) output_shape = [d if d is not None else -1 for d in output_shape.as_list()] return tf.reshape(hidden[0], output_shape)
def call(self, inputs, training=None): if training is None: training = utils_context.training if not training: return super(ScalableSageEncoder, self).call(inputs) node, neighbor = samples = euler_ops.sample_fanout( inputs, [self.edge_type], [self.fanout], default_node=self.max_id + 1)[0] node_embedding, neigh_embedding = [ self.node_encoder(sample) for sample in samples ] node_embeddings = [] neigh_embeddings = [] for layer in range(self.num_layers): aggregator = self.aggregators[layer] neigh_shape = [-1, self.fanout, self.dims[layer]] neigh_embedding = tf.reshape(neigh_embedding, neigh_shape) node_embedding = aggregator((node_embedding, neigh_embedding)) node_embeddings.append(node_embedding) if layer < self.num_layers - 1: neigh_embedding = tf.nn.embedding_lookup( self.stores[layer], neighbor) neigh_embeddings.append(neigh_embedding) self.update_store_op = self._update_store(node, node_embeddings) store_loss, self.optimize_store_op = \ self._optimize_store(node, node_embeddings) self.get_update_gradient_op = lambda loss: \ self._update_gradient(loss + store_loss, neighbor, neigh_embeddings) output_shape = inputs.shape.concatenate(node_embedding.shape[-1]) output_shape = [ d if d is not None else -1 for d in output_shape.as_list() ] return tf.reshape(node_embedding, output_shape)