def __init__(self, num_nodes, hidden_size=16, neg_num=5, is_sparse=False, is_distributed=False, embedding_lr=1.0): self.pyreader = L.py_reader(capacity=70, shapes=[[-1, 1, 1], [-1, neg_num + 1, 1]], dtypes=['int64', 'int64'], lod_levels=[0, 0], name='train', use_double_buffer=True) self.num_nodes = num_nodes self.neg_num = neg_num self.embed_init = F.initializer.Uniform( low=-1. / math.sqrt(hidden_size), high=1. / math.sqrt(hidden_size)) print("LEO self.embed_init:", self.embed_init, hidden_size) self.is_sparse = is_sparse self.is_distributed = is_distributed self.hidden_size = hidden_size self.loss = None self.embedding_lr = embedding_lr max_hidden_size = int(math.pow(2, 31) / 4 / num_nodes) self.num_part = int(math.ceil(1. * hidden_size / max_hidden_size))
def __init__(self, num_nodes, num_featuers, hidden_size=16, neg_num=5, is_sparse=False, num_part=1): self.pyreader = L.py_reader(capacity=70, shapes=[[-1, 1, num_featuers, 1], [-1, neg_num + 1, num_featuers, 1]], dtypes=['int64', 'int64'], lod_levels=[0, 0], name='train', use_double_buffer=True) self.num_nodes = num_nodes self.num_featuers = num_featuers self.neg_num = neg_num self.embed_init = F.initializer.TruncatedNormal(scale=1.0 / math.sqrt(hidden_size)) self.is_sparse = is_sparse self.num_part = num_part self.hidden_size = hidden_size self.loss = None
def link_predict_model(num_nodes, hidden_size=16, name='link_predict_task', binary_op_type="Weighted-L2"): pyreader = l.py_reader(capacity=70, shapes=[[-1, 1], [-1, 1], [-1, 1]], dtypes=['int64', 'int64', 'int64'], lod_levels=[0, 0, 0], name=name + '_pyreader', use_double_buffer=True) u, v, label = l.read_file(pyreader) u_embed = l.embedding(input=u, size=[num_nodes, hidden_size], param_attr=fluid.ParamAttr(name='content')) v_embed = l.embedding(input=v, size=[num_nodes, hidden_size], param_attr=fluid.ParamAttr(name='content')) u_embed.stop_gradient = True v_embed.stop_gradient = True edge_embed = binary_op(u_embed, v_embed, binary_op_type) logit = l.fc(input=edge_embed, size=1) loss = l.sigmoid_cross_entropy_with_logits(logit, l.cast(label, 'float32')) loss = l.reduce_mean(loss) prob = l.sigmoid(logit) return pyreader, loss, prob, label
def make_all_py_reader_inputs(input_fields, is_test=False): reader = layers.py_reader( capacity=20, name="test_reader" if is_test else "train_reader", shapes=[input_descs[input_field][0] for input_field in input_fields], dtypes=[input_descs[input_field][1] for input_field in input_fields], lod_levels=[ input_descs[input_field][2] if len(input_descs[input_field]) == 3 else 0 for input_field in input_fields ]) return layers.read_file(reader), reader
def make_all_py_reader_inputs(input_fields, is_test=False): """ Define the input data layers for the transformer model. """ reader = layers.py_reader( capacity=20, name="test_reader" if is_test else "train_reader", shapes=[input_descs[input_field][0] for input_field in input_fields], dtypes=[input_descs[input_field][1] for input_field in input_fields], lod_levels=[ input_descs[input_field][2] if len(input_descs[input_field]) == 3 else 0 for input_field in input_fields ], use_double_buffer=True) return layers.read_file(reader), reader
def node2vec_model(graph, hidden_size=16, neg_num=5): pyreader = l.py_reader( capacity=70, shapes=[[-1, 1, 1], [-1, 1, 1], [-1, neg_num, 1]], dtypes=['int64', 'int64', 'int64'], lod_levels=[0, 0, 0], name='train', use_double_buffer=True) embed_init = fluid.initializer.UniformInitializer(low=-1.0, high=1.0) weight_init = fluid.initializer.TruncatedNormal(scale=1.0 / math.sqrt(hidden_size)) src, pos, negs = l.read_file(pyreader) embed_src = l.embedding( input=src, size=[graph.num_nodes, hidden_size], param_attr=fluid.ParamAttr( name='content', initializer=embed_init)) weight_pos = l.embedding( input=pos, size=[graph.num_nodes, hidden_size], param_attr=fluid.ParamAttr( name='weight', initializer=weight_init)) weight_negs = l.embedding( input=negs, size=[graph.num_nodes, hidden_size], param_attr=fluid.ParamAttr( name='weight', initializer=weight_init)) pos_logits = l.matmul( embed_src, weight_pos, transpose_y=True) # [batch_size, 1, 1] neg_logits = l.matmul( embed_src, weight_negs, transpose_y=True) # [batch_size, 1, neg_num] ones_label = pos_logits * 0. + 1. ones_label.stop_gradient = True pos_loss = l.sigmoid_cross_entropy_with_logits(pos_logits, ones_label) zeros_label = neg_logits * 0. zeros_label.stop_gradient = True neg_loss = l.sigmoid_cross_entropy_with_logits(neg_logits, zeros_label) loss = (l.reduce_mean(pos_loss) + l.reduce_mean(neg_loss)) / 2 return pyreader, loss
def node_classify_model(graph, num_labels, hidden_size=16, name='node_classify_task'): pyreader = l.py_reader(capacity=70, shapes=[[-1, 1], [-1, num_labels]], dtypes=['int64', 'float32'], lod_levels=[0, 0], name=name + '_pyreader', use_double_buffer=True) nodes, labels = l.read_file(pyreader) embed_nodes = l.embedding(input=nodes, size=[graph.num_nodes, hidden_size], param_attr=fluid.ParamAttr(name='content')) embed_nodes.stop_gradient = True logits = l.fc(input=embed_nodes, size=num_labels) loss = l.sigmoid_cross_entropy_with_logits(logits, labels) loss = l.reduce_mean(loss) prob = l.sigmoid(logits) topk = l.reduce_sum(labels, -1) return pyreader, loss, prob, labels, topk
def __init__(self, config, embedding_lr=1.0): self.config = config self.neg_num = self.config.neg_num self.num_nodes = self.config.num_nodes self.embed_dim = self.config.embed_dim self.is_sparse = self.config.is_sparse self.is_distributed = self.config.is_distributed self.embedding_lr = embedding_lr self.pyreader = L.py_reader(capacity=70, shapes=[[-1, 1, 1], [-1, self.neg_num + 1, 1]], dtypes=['int64', 'int64'], lod_levels=[0, 0], name='train', use_double_buffer=True) bound = 1. / math.sqrt(self.embed_dim) self.embed_init = F.initializer.Uniform(low=-bound, high=bound) self.loss = None max_hidden_size = int(math.pow(2, 31) / 4 / self.num_nodes) self.num_part = int(math.ceil(1. * self.embed_dim / max_hidden_size))
def node_classify_model(graph, num_labels, embed_dim=16, name='node_classify_task'): """Build node classify model. Args: graph: The :code:`Graph` data object. num_labels: The number of labels. embed_dim: The dimension of embedding. name: The name of the model. """ pyreader = l.py_reader( capacity=70, shapes=[[-1, 1], [-1, num_labels]], dtypes=['int64', 'float32'], lod_levels=[0, 0], name=name + '_pyreader', use_double_buffer=True) nodes, labels = l.read_file(pyreader) embed_nodes = l.embedding( input=nodes, size=[graph.num_nodes, embed_dim], param_attr='shared_w') embed_nodes.stop_gradient = True logits = l.fc(input=embed_nodes, size=num_labels) loss = l.sigmoid_cross_entropy_with_logits(logits, labels) loss = l.reduce_mean(loss) prob = l.sigmoid(logits) topk = l.reduce_sum(labels, -1) return { 'pyreader': pyreader, 'loss': loss, 'prob': prob, 'labels': labels, 'topk': topk }