allowable_features_pretrain=None,

node_id_to_go_labels=None):

"""

n_nodes = g.number_of_nodes()

n_edges = g.number_of_edges()

# nodes

nx_node_ids = [n_i for n_i in g.nodes()] # contains list of nx node ids

# in a particular ordering. Will be used as a mapping to convert

# between nx node ids and data obj node indices

x = torch.tensor(np.ones(n_nodes).reshape(-1, 1), dtype=torch.float)

# we don't have any node labels, so set to dummy 1. dim n_nodes x 1

center_node_idx = nx_node_ids.index(center_id)

center_node_idx = torch.tensor([center_node_idx], dtype=torch.long)

# edges

edges_list = []

edge_features_list = []

for node_1, node_2, attr_dict in g.edges(data=True):

edge_feature = [attr_dict['w1'], attr_dict['w2'], attr_dict['w3'],

attr_dict['w4'], attr_dict['w5'], attr_dict['w6'],

attr_dict['w7'], 0, 0] # last 2 indicate self-loop

# and masking

edge_feature = np.array(edge_feature, dtype=int)

# convert nx node ids to data obj node index

i = nx_node_ids.index(node_1)

j = nx_node_ids.index(node_2)

edges_list.append((i, j))

edge_features_list.append(edge_feature)

edges_list.append((j, i))

edge_features_list.append(edge_feature)

# data.edge_index: Graph connectivity in COO format with shape [2, num_edges]

edge_index = torch.tensor(np.array(edges_list).T, dtype=torch.long)

# data.edge_attr: Edge feature matrix with shape [num_edges, num_edge_features]

edge_attr = torch.tensor(np.array(edge_features_list),

dtype=torch.float)

try:

species_id = int(nx_node_ids[0].split('.')[0]) # nx node id is of the form:

# species_id.protein_id

species_id = torch.tensor([species_id], dtype=torch.long)

except: # occurs when nx node id has no species id info. For the extract

# substructure context pair transform, where we convert a data obj to

# a nx graph obj (which does not have original node id info)

species_id = torch.tensor([0], dtype=torch.long) # dummy species

# id is 0

# construct data obj

data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr)

data.species_id = species_id

data.center_node_idx = center_node_idx

if node_id_to_go_labels: # supervised case with go node labels

# Construct a dim n_pretrain_go_classes tensor and a

# n_downstream_go_classes tensor for the center node. 0 is no data

# or negative, 1 is positive.

downstream_go_node_feature = [0] * len(allowable_features_downstream)

pretrain_go_node_feature = [0] * len(allowable_features_pretrain)

if center_id in node_id_to_go_labels:

go_labels = node_id_to_go_labels[center_id]

# get indices of allowable_features_downstream that match with elements

# in go_labels

_, node_feature_indices, _ = np.intersect1d(

allowable_features_downstream, go_labels, return_indices=True)

for idx in node_feature_indices:

downstream_go_node_feature[idx] = 1

# get indices of allowable_features_pretrain that match with

# elements in go_labels

_, node_feature_indices, _ = np.intersect1d(

allowable_features_pretrain, go_labels, return_indices=True)

for idx in node_feature_indices:

pretrain_go_node_feature[idx] = 1

data.go_target_downstream = torch.tensor(np.array(downstream_go_node_feature),

dtype=torch.long)

data.go_target_pretrain = torch.tensor(np.array(pretrain_go_node_feature),

dtype=torch.long)

"""

G = nx.Graph()

# edges

edge_index = data.edge_index.cpu().numpy()

edge_attr = data.edge_attr.cpu().numpy()

n_edges = edge_index.shape[1]

for j in range(0, n_edges, 2):

begin_idx = int(edge_index[0, j])

end_idx = int(edge_index[1, j])

w1, w2, w3, w4, w5, w6, w7, _, _ = edge_attr[j].astype(bool)

if not G.has_edge(begin_idx, end_idx):

G.add_edge(begin_idx, end_idx, w1=w1, w2=w2, w3=w3, w4=w4, w5=w5,

w6=w6, w7=w7)

# # add center node id information in final nx graph object

# nx.set_node_attributes(G, {data.center_node_idx.item(): True}, 'is_centre')

def __init__(self,

root,

data_type,

empty=False,

transform=None,

pre_transform=None,

pre_filter=None):

"""

self.root = root

self.data_type = data_type

super(BioDataset, self).__init__(root, transform, pre_transform, pre_filter)

if not empty:

self.data, self.slices = torch.load(self.processed_paths[0])

@property

def raw_file_names(self):

# raise NotImplementedError('Data is assumed to be processed')

if self.data_type == 'supervised': # 8 labelled species

file_name_list = ['3702', '6239', '511145', '7227', '9606', '10090', '4932', '7955']

else: # unsupervised: 8 labelled species, and 42 top unlabelled species by n_nodes.

file_name_list = ['3702', '6239', '511145', '7227', '9606', '10090',

'4932', '7955', '3694', '39947', '10116', '443255', '9913', '13616',

'3847', '4577', '8364', '9823', '9615', '9544', '9796', '3055', '7159',

'9031', '7739', '395019', '88036', '9685', '9258', '9598', '485913',

'44689', '9593', '7897', '31033', '749414', '59729', '536227', '4081',

'8090', '9601', '749927', '13735', '448385', '457427', '3711', '479433',

'479432', '28377', '9646']

return file_name_list

@property

def processed_file_names(self):

return 'geometric_data_processed.pt'

def download(self):

raise NotImplementedError('Must indicate valid location of raw data. '

'No download allowed')

def process(self):

'''

def node_type(node):

if node < author_idx:

return 1

elif node < venue_idx:

return 2

elif node < term_idx:

return 3

else:

return 4

line = json.loads(line)

x_list, edges_list, edges_attr_list = [], [], []

# id convert procedure and x feature construct

node_id_convert = dict()

paper_idx, author_idx, venue_idx, term_idx = 0, 0, 0, 0

if len(line['papers']):

for idx, paper in enumerate(line['papers']):

node_id_convert[paper['convert_id']] = idx

paper_x = np.zeros(10)

paper_x[: 3] = 1, paper["n_citation"], paper['year']

x_list.append(paper_x)

else:

node_id_convert[line["center_id"]['convert_id']] = 0

paper_x = np.zeros(10)

paper_x[: 3] = 1, line["center_id"]["n_citation"], line["center_id"]["year"]

x_list.append(paper_x)

author_idx = len(node_id_convert)

for idx, author in enumerate(line['authors'], len(node_id_convert)):

node_id_convert[author['convert_id']] = idx

author_x = np.zeros(10)

author_x[3: 6] = 2, author['org'], author['paper_num']

x_list.append(author_x)

venue_idx = len(node_id_convert)

for idx, venue in enumerate(line["venue"], len(node_id_convert)):

node_id_convert[venue['convert_id']] = idx

venue_x = np.zeros(10)

venue_x[6: 9] = 3, venue['convert_id'] - 2260000, venue['sub_cat']

x_list.append(venue_x)

term_idx = len(node_id_convert)

for idx, term in enumerate(line['terms'], len(node_id_convert)):

node_id_convert[term['convert_id']] = idx

term_x = np.zeros(10)

term_x[9] = 4

x_list.append(term_x)

# edge_feature construct

edges_list = []

for src, deses in line['edges'].items():

for des in deses:

# print(line)

# print(src, deses)

try:

src_convert, des_convert = node_id_convert[int(src)], node_id_convert[int(des)]

edges_list.append((src_convert, des_convert))

src_t, des_t = node_type(src_convert), node_type(des_convert)

tmp = src_t if src_t != 1 else des_t

if tmp == 1:

edges_attr_list.append([1])

elif tmp == 2:

edges_attr_list.append([2])

elif tmp == 3:

edges_attr_list.append([3])

elif tmp == 4:

edges_attr_list.append([4])

else:

raise ValueError("The node type is wrong {}".format(tmp))

except KeyError as e:

print(e)

print(line)

print(line['edges'])

print("src",int(src), "des", int(des))

raise ValueError("key")

x = torch.tensor(np.array(x_list), dtype=torch.float)

edge_index = torch.tensor(np.array(edges_list).T, dtype=torch.long)

edge_attr = torch.tensor(np.array(edges_attr_list),dtype=torch.float)

data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr)

data.center_node_idx = node_id_convert[line["center_id"]['convert_id']]

data.y = line["center_id"]['cat']

def __init__(self,

root,

data_type,

transform=None,

pre_transform=None,

pre_filter=None,

dataset='zinc250k',

empty=False):

self.dataset = dataset

self.root = root

self.data_type = data_type

super(DblpDataset, self).__init__(root, transform, pre_transform, pre_filter)

self.transform, self.pre_transform, self.pre_filter = transform, pre_transform, pre_filter

if not empty:

self.data, self.slices = torch.load(self.processed_paths[0])

@property

def raw_file_names(self):

return []

@property

def processed_file_names(self):

if self.data_type == 'supervised':

return ['dblpfinetune.graph']

else:

return ['dblp.graph']

def download(self):

pass

def process(self):

data_list = []

data_cat = [2, 3, 5, 6, 11, 12, 13, 14, 15, 16,

17, 18, 19, 21, 23, 25, 26, 27, 28, 29,

32, 34, 36, 37, 41]

with open('../data/dblp/' + "graph", "r") as infile:

for line in infile:

l_data = json.loads(line)

if l_data['center_id']['cat'] in data_cat:

data = line_to_graph_data_obj_simple(line)

data_list.append(data)

else:

continue

data, slices = self.collate(data_list)