OpenI
/
graphkit-learn
Not watched
1
0
Fork 0
Code
Releases 2 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
graphkit-learn/gklearn/utils/graphfiles.py

760 lines
26 kB
Raw Permalink Blame History 

  1. """ Utilities function to manage graph files

  2. """

  3. from os.path import dirname, splitext

  4. 

  5. def loadCT(filename):

  6. 	"""load data from a Chemical Table (.ct) file.

  7. 

  8. 	Notes

  9. 	------

  10. 	a typical example of data in .ct is like this:

  11. 

  12. 	3 2  <- number of nodes and edges

  13. 

  14. 	0.0000	0.0000	0.0000 C <- each line describes a node (x,y,z + label)

  15. 

  16. 	0.0000	0.0000	0.0000 C

  17. 

  18. 	0.0000	0.0000	0.0000 O

  19. 

  20. 	1  3  1  1 <- each line describes an edge : to, from, bond type, bond stereo

  21. 

  22. 	2  3  1  1

  23. 	  

  24. 	Check `CTFile Formats file <https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=10&ved=2ahUKEwivhaSdjsTlAhVhx4UKHczHA8gQFjAJegQIARAC&url=https%3A%2F%2Fwww.daylight.com%2Fmeetings%2Fmug05%2FKappler%2Fctfile.pdf&usg=AOvVaw1cDNrrmMClkFPqodlF2inS>`__

  25. 	for detailed format discription.

  26. 	"""

  27. 	import networkx as nx

  28. 	from os.path import basename

  29. 	g = nx.Graph()

  30. 	with open(filename) as f:

  31. 		content = f.read().splitlines()

  32. 		g = nx.Graph(

  33. 			name = str(content[0]),

  34. 			filename = basename(filename))  # set name of the graph

  35. 		tmp = content[1].split(" ")

  36. 		if tmp[0] == '':

  37. 			nb_nodes = int(tmp[1])  # number of the nodes

  38. 			nb_edges = int(tmp[2])  # number of the edges

  39. 		else:

  40. 			nb_nodes = int(tmp[0])

  41. 			nb_edges = int(tmp[1])

  42. 			# patch for compatibility : label will be removed later

  43. 		for i in range(0, nb_nodes):

  44. 			tmp = content[i + 2].split(" ")

  45. 			tmp = [x for x in tmp if x != '']

  46. 			g.add_node(i, atom=tmp[3].strip(), 

  47. 					   label=[item.strip() for item in tmp[3:]], 

  48. 					   attributes=[item.strip() for item in tmp[0:3]])

  49. 		for i in range(0, nb_edges):

  50. 			tmp = content[i + g.number_of_nodes() + 2].split(" ")

  51. 			tmp = [x for x in tmp if x != '']

  52. 			g.add_edge(int(tmp[0]) - 1, int(tmp[1]) - 1,

  53. 					   bond_type=tmp[2].strip(),

  54. 					   label=[item.strip() for item in tmp[2:]])

  55. 	return g

  56. 

  57. 

  58. def loadGXL(filename):

  59. 	from os.path import basename

  60. 	import networkx as nx

  61. 	import xml.etree.ElementTree as ET

  62. 

  63. 	tree = ET.parse(filename)

  64. 	root = tree.getroot()

  65. 	index = 0

  66. 	g = nx.Graph(filename=basename(filename), name=root[0].attrib['id'])

  67. 	dic = {}  # used to retrieve incident nodes of edges

  68. 	for node in root.iter('node'):

  69. 		dic[node.attrib['id']] = index

  70. 		labels = {}

  71. 		for attr in node.iter('attr'):

  72. 			labels[attr.attrib['name']] = attr[0].text

  73. 		if 'chem' in labels:

  74. 			labels['label'] = labels['chem']

  75. 			labels['atom'] = labels['chem']

  76. 		g.add_node(index, **labels)

  77. 		index += 1

  78. 

  79. 	for edge in root.iter('edge'):

  80. 		labels = {}

  81. 		for attr in edge.iter('attr'):

  82. 			labels[attr.attrib['name']] = attr[0].text

  83. 		if 'valence' in labels:

  84. 			labels['label'] = labels['valence']

  85. 			labels['bond_type'] = labels['valence']

  86. 		g.add_edge(dic[edge.attrib['from']], dic[edge.attrib['to']], **labels)

  87. 	return g

  88. 

  89. 

  90. def saveGXL(graph, filename, method='default', node_labels=[], edge_labels=[], node_attrs=[], edge_attrs=[]):

  91. 	if method == 'default':

  92. 		gxl_file = open(filename, 'w')

  93. 		gxl_file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

  94. 		gxl_file.write("<!DOCTYPE gxl SYSTEM \"http://www.gupro.de/GXL/gxl-1.0.dtd\">\n")

  95. 		gxl_file.write("<gxl xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n")

  96. 		if 'name' in graph.graph:

  97. 			name = str(graph.graph['name'])

  98. 		else:

  99. 			name = 'dummy'

  100. 		gxl_file.write("<graph id=\"" + name + "\" edgeids=\"false\" edgemode=\"undirected\">\n")

  101. 		for v, attrs in graph.nodes(data=True):

  102. 			gxl_file.write("<node id=\"_" + str(v) + "\">")

  103. 			for l_name in node_labels:	

  104. 				gxl_file.write("<attr name=\"" + l_name + "\"><int>" + 

  105. 							   str(attrs[l_name]) + "</int></attr>")

  106. 			for a_name in node_attrs:	

  107. 				gxl_file.write("<attr name=\"" + a_name + "\"><float>" + 

  108. 							   str(attrs[a_name]) + "</float></attr>")

  109. 			gxl_file.write("</node>\n")

  110. 		for v1, v2, attrs in graph.edges(data=True):

  111. 			gxl_file.write("<edge from=\"_" + str(v1) + "\" to=\"_" + str(v2) + "\">")

  112. 			for l_name in edge_labels:	

  113. 				gxl_file.write("<attr name=\"" + l_name + "\"><int>" + 

  114. 							   str(attrs[l_name]) + "</int></attr>")

  115. 			for a_name in edge_attrs:	

  116. 				gxl_file.write("<attr name=\"" + a_name + "\"><float>" + 

  117. 							   str(attrs[a_name]) + "</float></attr>")

  118. 			gxl_file.write("</edge>\n")

  119. 		gxl_file.write("</graph>\n")

  120. 		gxl_file.write("</gxl>")

  121. 		gxl_file.close()

  122. 	elif method == 'benoit':

  123. 		import xml.etree.ElementTree as ET

  124. 		root_node = ET.Element('gxl')

  125. 		attr = dict()

  126. 		attr['id'] = str(graph.graph['name'])

  127. 		attr['edgeids'] = 'true'

  128. 		attr['edgemode'] = 'undirected'

  129. 		graph_node = ET.SubElement(root_node, 'graph', attrib=attr)

  130. 	

  131. 		for v in graph:

  132. 			current_node = ET.SubElement(graph_node, 'node', attrib={'id': str(v)})

  133. 			for attr in graph.nodes[v].keys():

  134. 				cur_attr = ET.SubElement(

  135. 					current_node, 'attr', attrib={'name': attr})

  136. 				cur_value = ET.SubElement(cur_attr,

  137. 										  graph.nodes[v][attr].__class__.__name__)

  138. 				cur_value.text = graph.nodes[v][attr]

  139. 	

  140. 		for v1 in graph:

  141. 			for v2 in graph[v1]:

  142. 				if (v1 < v2):  # Non oriented graphs

  143. 					cur_edge = ET.SubElement(

  144. 						graph_node,

  145. 						'edge',

  146. 						attrib={

  147. 							'from': str(v1),

  148. 							'to': str(v2)

  149. 						})

  150. 					for attr in graph[v1][v2].keys():

  151. 						cur_attr = ET.SubElement(

  152. 							cur_edge, 'attr', attrib={'name': attr})

  153. 						cur_value = ET.SubElement(

  154. 							cur_attr, graph[v1][v2][attr].__class__.__name__)

  155. 						cur_value.text = str(graph[v1][v2][attr])

  156. 	

  157. 		tree = ET.ElementTree(root_node)

  158. 		tree.write(filename)

  159. 	elif method == 'gedlib':

  160. 		# reference: https://github.com/dbblumenthal/gedlib/blob/master/data/generate_molecules.py#L22

  161. #		pass

  162. 		gxl_file = open(filename, 'w')

  163. 		gxl_file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

  164. 		gxl_file.write("<!DOCTYPE gxl SYSTEM \"http://www.gupro.de/GXL/gxl-1.0.dtd\">\n")

  165. 		gxl_file.write("<gxl xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n")

  166. 		gxl_file.write("<graph id=\"" + str(graph.graph['name']) + "\" edgeids=\"true\" edgemode=\"undirected\">\n")

  167. 		for v, attrs in graph.nodes(data=True):

  168. 			gxl_file.write("<node id=\"_" + str(v) + "\">")

  169. 			gxl_file.write("<attr name=\"" + "chem" + "\"><int>" + str(attrs['chem']) + "</int></attr>")

  170. 			gxl_file.write("</node>\n")

  171. 		for v1, v2, attrs in graph.edges(data=True):

  172. 			gxl_file.write("<edge from=\"_" + str(v1) + "\" to=\"_" + str(v2) + "\">")

  173. 			gxl_file.write("<attr name=\"valence\"><int>" + str(attrs['valence']) + "</int></attr>")

  174. #			gxl_file.write("<attr name=\"valence\"><int>" + "1" + "</int></attr>")

  175. 			gxl_file.write("</edge>\n")

  176. 		gxl_file.write("</graph>\n")

  177. 		gxl_file.write("</gxl>")

  178. 		gxl_file.close()

  179. 	elif method == 'gedlib-letter':

  180. 		# reference: https://github.com/dbblumenthal/gedlib/blob/master/data/generate_molecules.py#L22

  181. 		# and https://github.com/dbblumenthal/gedlib/blob/master/data/datasets/Letter/HIGH/AP1_0000.gxl

  182. 		gxl_file = open(filename, 'w')

  183. 		gxl_file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

  184. 		gxl_file.write("<!DOCTYPE gxl SYSTEM \"http://www.gupro.de/GXL/gxl-1.0.dtd\">\n")

  185. 		gxl_file.write("<gxl xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n")

  186. 		gxl_file.write("<graph id=\"" + str(graph.graph['name']) + "\" edgeids=\"false\" edgemode=\"undirected\">\n")

  187. 		for v, attrs in graph.nodes(data=True):

  188. 			gxl_file.write("<node id=\"_" + str(v) + "\">")

  189. 			gxl_file.write("<attr name=\"x\"><float>" + str(attrs['attributes'][0]) + "</float></attr>")

  190. 			gxl_file.write("<attr name=\"y\"><float>" + str(attrs['attributes'][1]) + "</float></attr>")

  191. 			gxl_file.write("</node>\n")

  192. 		for v1, v2, attrs in graph.edges(data=True):

  193. 			gxl_file.write("<edge from=\"_" + str(v1) + "\" to=\"_" + str(v2) + "\"/>\n")

  194. 		gxl_file.write("</graph>\n")

  195. 		gxl_file.write("</gxl>")

  196. 		gxl_file.close()

  197. 

  198. 

  199. def loadSDF(filename):

  200. 	"""load data from structured data file (.sdf file).

  201. 

  202. 	Notes

  203. 	------

  204. 	A SDF file contains a group of molecules, represented in the similar way as in MOL format.

  205. 	Check `here <http://www.nonlinear.com/progenesis/sdf-studio/v0.9/faq/sdf-file-format-guidance.aspx>`__ for detailed structure.

  206. 	"""

  207. 	import networkx as nx

  208. 	from os.path import basename

  209. 	from tqdm import tqdm

  210. 	import sys

  211. 	data = []

  212. 	with open(filename) as f:

  213. 		content = f.read().splitlines()

  214. 		index = 0

  215. 		pbar = tqdm(total=len(content) + 1, desc='load SDF', file=sys.stdout)

  216. 		while index < len(content):

  217. 			index_old = index

  218. 

  219. 			g = nx.Graph(name=content[index].strip())  # set name of the graph

  220. 

  221. 			tmp = content[index + 3]

  222. 			nb_nodes = int(tmp[:3])  # number of the nodes

  223. 			nb_edges = int(tmp[3:6])  # number of the edges

  224. 

  225. 			for i in range(0, nb_nodes):

  226. 				tmp = content[i + index + 4]

  227. 				g.add_node(i, atom=tmp[31:34].strip())

  228. 

  229. 			for i in range(0, nb_edges):

  230. 				tmp = content[i + index + g.number_of_nodes() + 4]

  231. 				tmp = [tmp[i:i + 3] for i in range(0, len(tmp), 3)]

  232. 				g.add_edge(

  233. 					int(tmp[0]) - 1, int(tmp[1]) - 1, bond_type=tmp[2].strip())

  234. 

  235. 			data.append(g)

  236. 

  237. 			index += 4 + g.number_of_nodes() + g.number_of_edges()

  238. 			while content[index].strip() != '$$$$':  # seperator

  239. 				index += 1

  240. 			index += 1

  241. 

  242. 			pbar.update(index - index_old)

  243. 		pbar.update(1)

  244. 		pbar.close()

  245. 

  246. 	return data

  247. 

  248. 

  249. def loadMAT(filename, extra_params):

  250. 	"""Load graph data from a MATLAB (up to version 7.1) .mat file.

  251. 

  252. 	Notes

  253. 	------

  254. 	A MAT file contains a struct array containing graphs, and a column vector lx containing a class label for each graph.

  255. 	Check README in `downloadable file <http://mlcb.is.tuebingen.mpg.de/Mitarbeiter/Nino/WL/>`__ for detailed structure.

  256. 	"""

  257. 	from scipy.io import loadmat

  258. 	import numpy as np

  259. 	import networkx as nx

  260. 	data = []

  261. 	content = loadmat(filename)

  262. 	order = extra_params['am_sp_al_nl_el']

  263. 	# print(content)

  264. 	# print('----')

  265. 	for key, value in content.items():

  266. 		if key[0] == 'l':  # class label

  267. 			y = np.transpose(value)[0].tolist()

  268. 			# print(y)

  269. 		elif key[0] != '_':

  270. 			# print(value[0][0][0])

  271. 			# print()

  272. 			# print(value[0][0][1])

  273. 			# print()

  274. 			# print(value[0][0][2])

  275. 			# print()

  276. 			# if len(value[0][0]) > 3:

  277. 			#	 print(value[0][0][3])

  278. 			# print('----')

  279. 			# if adjacency matrix is not compressed / edge label exists

  280. 			if order[1] == 0:

  281. 				for i, item in enumerate(value[0]):

  282. 					# print(item)

  283. 					# print('------')

  284. 					g = nx.Graph(name=i)  # set name of the graph

  285. 					nl = np.transpose(item[order[3]][0][0][0])  # node label

  286. 					# print(item[order[3]])

  287. 					# print()

  288. 					for index, label in enumerate(nl[0]):

  289. 						g.add_node(index, atom=str(label))

  290. 					el = item[order[4]][0][0][0]  # edge label

  291. 					for edge in el:

  292. 						g.add_edge(

  293. 							edge[0] - 1, edge[1] - 1, bond_type=str(edge[2]))

  294. 					data.append(g)

  295. 			else:

  296. 				from scipy.sparse import csc_matrix

  297. 				for i, item in enumerate(value[0]):

  298. 					# print(item)

  299. 					# print('------')

  300. 					g = nx.Graph(name=i)  # set name of the graph

  301. 					nl = np.transpose(item[order[3]][0][0][0])  # node label

  302. 					# print(nl)

  303. 					# print()

  304. 					for index, label in enumerate(nl[0]):

  305. 						g.add_node(index, atom=str(label))

  306. 					sam = item[order[0]]  # sparse adjacency matrix

  307. 					index_no0 = sam.nonzero()

  308. 					for col, row in zip(index_no0[0], index_no0[1]):

  309. 						# print(col)

  310. 						# print(row)

  311. 						g.add_edge(col, row)

  312. 					data.append(g)

  313. 					# print(g.edges(data=True))

  314. 	return data, y

  315. 

  316. 

  317. def loadTXT(filename):

  318. 	"""Load graph data from a .txt file.

  319. 

  320. 	Notes

  321. 	------

  322. 	The graph data is loaded from separate files.

  323. 	Check README in `downloadable file <http://tiny.cc/PK_MLJ_data>`__, 2018 for detailed structure.

  324. 	"""

  325. #	import numpy as np

  326. 	import networkx as nx

  327. 	from os import listdir

  328. 	from os.path import dirname, basename

  329. 	

  330. 	

  331. 	def get_label_names(frm):

  332. 		"""Get label names from DS_label_readme.txt file.

  333. 		"""

  334. 		

  335. 		def get_names_from_line(line):

  336. 			"""Get names of labels/attributes from a line.

  337. 			"""

  338. 			str_names = line.split('[')[1].split(']')[0]

  339. 			names = str_names.split(',')

  340. 			names = [attr.strip() for attr in names]

  341. 			return names

  342. 

  343. 

  344. 		label_names = {'node_labels': [], 'node_attrs': [], 

  345. 					   'edge_labels': [], 'edge_attrs': []}

  346. 		content_rm = open(frm).read().splitlines()

  347. 		for line in content_rm:

  348. 			line = line.strip()

  349. 			if line.startswith('Node labels:'):

  350. 				label_names['node_labels'] = get_names_from_line(line)

  351. 			elif line.startswith('Node attributes:'):

  352. 				label_names['node_attrs'] = get_names_from_line(line)

  353. 			elif line.startswith('Edge labels:'):

  354. 				label_names['edge_labels'] = get_names_from_line(line)

  355. 			elif line.startswith('Edge attributes:'):

  356. 				label_names['edge_attrs'] = get_names_from_line(line)

  357. 		return label_names

  358. 

  359. 	

  360. 	# get dataset name.

  361. 	dirname_dataset = dirname(filename)

  362. 	filename = basename(filename)

  363. 	fn_split = filename.split('_A')

  364. 	ds_name = fn_split[0].strip()

  365. 	

  366. 	# load data file names

  367. 	for name in listdir(dirname_dataset):

  368. 		if ds_name + '_A' in name:

  369. 			fam = dirname_dataset + '/' + name

  370. 		elif ds_name + '_graph_indicator' in name:

  371. 			fgi = dirname_dataset + '/' + name

  372. 		elif ds_name + '_graph_labels' in name:

  373. 			fgl = dirname_dataset + '/' + name

  374. 		elif ds_name + '_node_labels' in name:

  375. 			fnl = dirname_dataset + '/' + name

  376. 		elif ds_name + '_edge_labels' in name:

  377. 			fel = dirname_dataset + '/' + name

  378. 		elif ds_name + '_edge_attributes' in name:

  379. 			fea = dirname_dataset + '/' + name

  380. 		elif ds_name + '_node_attributes' in name:

  381. 			fna = dirname_dataset + '/' + name

  382. 		elif ds_name + '_graph_attributes' in name:

  383. 			fga = dirname_dataset + '/' + name

  384. 		elif ds_name + '_label_readme' in name:

  385. 			frm = dirname_dataset + '/' + name

  386. 		# this is supposed to be the node attrs, make sure to put this as the last 'elif'

  387. 		elif ds_name + '_attributes' in name:

  388. 			fna = dirname_dataset + '/' + name

  389. 			

  390. 	# get labels and attributes names.

  391. 	if 'frm' in locals():

  392. 		label_names = get_label_names(frm)

  393. 	else:

  394. 		label_names = {'node_labels': [], 'node_attrs': [], 

  395. 					   'edge_labels': [], 'edge_attrs': []}

  396. 

  397. 	content_gi = open(fgi).read().splitlines()  # graph indicator

  398. 	content_am = open(fam).read().splitlines()  # adjacency matrix

  399. 	content_gl = open(fgl).read().splitlines()  # graph labels

  400. 

  401. 	# create graphs and add nodes

  402. 	data = [nx.Graph(name=str(i), 

  403. 					 node_labels=label_names['node_labels'],

  404. 					 node_attrs=label_names['node_attrs'],

  405. 					 edge_labels=label_names['edge_labels'],

  406. 					 edge_attrs=label_names['edge_attrs']) for i in range(0, len(content_gl))]

  407. 	if 'fnl' in locals():

  408. 		content_nl = open(fnl).read().splitlines()  # node labels

  409. 		for idx, line in enumerate(content_gi):

  410. 			# transfer to int first in case of unexpected blanks

  411. 			data[int(line) - 1].add_node(idx)

  412. 			labels = [l.strip() for l in content_nl[idx].split(',')]

  413. 			data[int(line) - 1].nodes[idx]['atom'] = str(int(labels[0])) # @todo: this should be removed after.

  414. 			if data[int(line) - 1].graph['node_labels'] == []:

  415. 				for i, label in enumerate(labels):

  416. 					l_name = 'label_' + str(i)

  417. 					data[int(line) - 1].nodes[idx][l_name] = label

  418. 					data[int(line) - 1].graph['node_labels'].append(l_name)

  419. 			else:

  420. 				for i, l_name in enumerate(data[int(line) - 1].graph['node_labels']):

  421. 					data[int(line) - 1].nodes[idx][l_name] = labels[i]

  422. 	else:

  423. 		for i, line in enumerate(content_gi):

  424. 			data[int(line) - 1].add_node(i)

  425. 			

  426. 	# add edges

  427. 	for line in content_am:

  428. 		tmp = line.split(',')

  429. 		n1 = int(tmp[0]) - 1

  430. 		n2 = int(tmp[1]) - 1

  431. 		# ignore edge weight here.

  432. 		g = int(content_gi[n1]) - 1

  433. 		data[g].add_edge(n1, n2)

  434. 

  435. 	# add edge labels

  436. 	if 'fel' in locals():

  437. 		content_el = open(fel).read().splitlines()

  438. 		for idx, line in enumerate(content_el):

  439. 			labels = [l.strip() for l in line.split(',')]

  440. 			n = [int(i) - 1 for i in content_am[idx].split(',')]

  441. 			g = int(content_gi[n[0]]) - 1

  442. 			data[g].edges[n[0], n[1]]['bond_type'] = labels[0] # @todo: this should be removed after.

  443. 			if data[g].graph['edge_labels'] == []:

  444. 				for i, label in enumerate(labels):

  445. 					l_name = 'label_' + str(i)

  446. 					data[g].edges[n[0], n[1]][l_name] = label

  447. 					data[g].graph['edge_labels'].append(l_name)

  448. 			else:

  449. 				for i, l_name in enumerate(data[g].graph['edge_labels']):

  450. 					data[g].edges[n[0], n[1]][l_name] = labels[i]

  451. 

  452. 	# add node attributes

  453. 	if 'fna' in locals():

  454. 		content_na = open(fna).read().splitlines()

  455. 		for idx, line in enumerate(content_na):

  456. 			attrs = [a.strip() for a in line.split(',')]

  457. 			g = int(content_gi[idx]) - 1

  458. 			data[g].nodes[idx]['attributes'] = attrs # @todo: this should be removed after.

  459. 			if data[g].graph['node_attrs'] == []:

  460. 				for i, attr in enumerate(attrs):

  461. 					a_name = 'attr_' + str(i)

  462. 					data[g].nodes[idx][a_name] = attr

  463. 					data[g].graph['node_attrs'].append(a_name)

  464. 			else:

  465. 				for i, a_name in enumerate(data[g].graph['node_attrs']):

  466. 					data[g].nodes[idx][a_name] = attrs[i]

  467. 

  468. 	# add edge attributes

  469. 	if 'fea' in locals():

  470. 		content_ea = open(fea).read().splitlines()

  471. 		for idx, line in enumerate(content_ea):

  472. 			attrs = [a.strip() for a in line.split(',')]

  473. 			n = [int(i) - 1 for i in content_am[idx].split(',')]

  474. 			g = int(content_gi[n[0]]) - 1

  475. 			data[g].edges[n[0], n[1]]['attributes'] = attrs # @todo: this should be removed after.

  476. 			if data[g].graph['edge_attrs'] == []:

  477. 				for i, attr in enumerate(attrs):

  478. 					a_name = 'attr_' + str(i)

  479. 					data[g].edges[n[0], n[1]][a_name] = attr

  480. 					data[g].graph['edge_attrs'].append(a_name)

  481. 			else:

  482. 				for i, a_name in enumerate(data[g].graph['edge_attrs']):

  483. 					data[g].edges[n[0], n[1]][a_name] = attrs[i]

  484. 

  485. 	# load y

  486. 	y = [int(i) for i in content_gl]

  487. 

  488. 	return data, y

  489. 

  490. 

  491. def loadDataset(filename, filename_y=None, extra_params=None):

  492. 	"""Read graph data from filename and load them as NetworkX graphs.

  493. 

  494. 	Parameters

  495. 	----------

  496. 	filename : string

  497. 		The name of the file from where the dataset is read.

  498. 	filename_y : string

  499. 		The name of file of the targets corresponding to graphs.

  500. 	extra_params : dict

  501. 		Extra parameters only designated to '.mat' format.

  502. 

  503. 	Return

  504. 	------

  505. 	data : List of NetworkX graph.

  506. 

  507. 	y : List

  508. 

  509. 	Targets corresponding to graphs.

  510. 		

  511. 	Notes

  512. 	-----

  513. 	This function supports following graph dataset formats:

  514. 

  515. 	'ds': load data from .ds file. See comments of function loadFromDS for a example.

  516. 

  517. 	'cxl': load data from Graph eXchange Language file (.cxl file). See 

  518. 	`here <http://www.gupro.de/GXL/Introduction/background.html>`__ for detail.

  519. 

  520. 	'sdf': load data from structured data file (.sdf file). See 

  521. 	`here <http://www.nonlinear.com/progenesis/sdf-studio/v0.9/faq/sdf-file-format-guidance.aspx>`__

  522. 	for details.

  523. 

  524. 	'mat': Load graph data from a MATLAB (up to version 7.1) .mat file. See

  525. 	README in `downloadable file <http://mlcb.is.tuebingen.mpg.de/Mitarbeiter/Nino/WL/>`__

  526. 	for details.

  527. 

  528. 	'txt': Load graph data from a special .txt file. See

  529. 	`here <https://ls11-www.cs.tu-dortmund.de/staff/morris/graphkerneldatasets>`__

  530. 	for details. Note here filename is the name of either .txt file in

  531. 	the dataset directory.

  532. 	"""

  533. 	extension = splitext(filename)[1][1:]

  534. 	if extension == "ds":

  535. 		data, y = loadFromDS(filename, filename_y)

  536. 	elif extension == "cxl":

  537. 		import xml.etree.ElementTree as ET

  538. 		

  539. 		dirname_dataset = dirname(filename)

  540. 		tree = ET.parse(filename)

  541. 		root = tree.getroot()

  542. 		data = []

  543. 		y = []

  544. 		for graph in root.iter('graph'):

  545. 			mol_filename = graph.attrib['file']

  546. 			mol_class = graph.attrib['class']

  547. 			data.append(loadGXL(dirname_dataset + '/' + mol_filename))

  548. 			y.append(mol_class)

  549. 	elif extension == 'xml':

  550. 		data, y = loadFromXML(filename, extra_params)

  551. 	elif extension == "sdf":

  552. #		import numpy as np

  553. 		from tqdm import tqdm

  554. 		import sys

  555. 

  556. 		data = loadSDF(filename)

  557. 

  558. 		y_raw = open(filename_y).read().splitlines()

  559. 		y_raw.pop(0)

  560. 		tmp0 = []

  561. 		tmp1 = []

  562. 		for i in range(0, len(y_raw)):

  563. 			tmp = y_raw[i].split(',')

  564. 			tmp0.append(tmp[0])

  565. 			tmp1.append(tmp[1].strip())

  566. 

  567. 		y = []

  568. 		for i in tqdm(range(0, len(data)), desc='ajust data', file=sys.stdout):

  569. 			try:

  570. 				y.append(tmp1[tmp0.index(data[i].name)].strip())

  571. 			except ValueError:  # if data[i].name not in tmp0

  572. 				data[i] = []

  573. 		data = list(filter(lambda a: a != [], data))

  574. 	elif extension == "mat":

  575. 		data, y = loadMAT(filename, extra_params)

  576. 	elif extension == 'txt':

  577. 		data, y = loadTXT(filename)

  578. 		# print(len(y))

  579. 		# print(y)

  580. 		# print(data[0].nodes(data=True))

  581. 		# print('----')

  582. 		# print(data[0].edges(data=True))

  583. 		# for g in data:

  584. 		#	 print(g.nodes(data=True))

  585. 		#	 print('----')

  586. 		#	 print(g.edges(data=True))

  587. 

  588. 	return data, y

  589. 

  590. 

  591. def loadFromXML(filename, extra_params):

  592. 	import xml.etree.ElementTree as ET

  593. 	

  594. 	if extra_params:

  595. 		dirname_dataset = extra_params

  596. 	else:

  597. 		dirname_dataset = dirname(filename)

  598. 	tree = ET.parse(filename)

  599. 	root = tree.getroot()

  600. 	data = []

  601. 	y = []

  602. 	for graph in root.iter('graph'):

  603. 		mol_filename = graph.attrib['file']

  604. 		mol_class = graph.attrib['class']

  605. 		data.append(loadGXL(dirname_dataset + '/' + mol_filename))

  606. 		y.append(mol_class)

  607. 		

  608. 	return data, y

  609. 			

  610. 

  611. def loadFromDS(filename, filename_y):

  612. 	"""Load data from .ds file.

  613. 

  614. 	Possible graph formats include:

  615. 

  616. 	'.ct': see function loadCT for detail.

  617. 

  618. 	'.gxl': see dunction loadGXL for detail.

  619. 

  620. 	Note these graph formats are checked automatically by the extensions of 

  621. 	graph files.

  622. 	"""

  623. 	dirname_dataset = dirname(filename)

  624. 	data = []

  625. 	y = []

  626. 	content = open(filename).read().splitlines()

  627. 	extension = splitext(content[0].split(' ')[0])[1][1:]

  628. 	if filename_y is None or filename_y == '':

  629. 		if extension == 'ct': 

  630. 			for i in range(0, len(content)):

  631. 				tmp = content[i].split(' ')

  632. 				# remove the '#'s in file names

  633. 				data.append(

  634. 					loadCT(dirname_dataset + '/' + tmp[0].replace('#', '', 1)))

  635. 				y.append(float(tmp[1]))

  636. 		elif extension == 'gxl':

  637. 			for i in range(0, len(content)):

  638. 				tmp = content[i].split(' ')

  639. 				# remove the '#'s in file names

  640. 				data.append(

  641. 					loadGXL(dirname_dataset + '/' + tmp[0].replace('#', '', 1)))

  642. 				y.append(float(tmp[1]))

  643. 	else:  # y in a seperate file

  644. 		if extension == 'ct':

  645. 			for i in range(0, len(content)):

  646. 				tmp = content[i]

  647. 				# remove the '#'s in file names

  648. 				data.append(

  649. 					loadCT(dirname_dataset + '/' + tmp.replace('#', '', 1)))

  650. 		elif extension == 'gxl':

  651. 			for i in range(0, len(content)):

  652. 				tmp = content[i]

  653. 				# remove the '#'s in file names

  654. 				data.append(

  655. 					loadGXL(dirname_dataset + '/' + tmp.replace('#', '', 1)))													   

  656. 															   

  657. 		content_y = open(filename_y).read().splitlines()

  658. 		# assume entries in filename and filename_y have the same order.

  659. 		for item in content_y:

  660. 			tmp = item.split(' ')

  661. 			# assume the 3rd entry in a line is y (for Alkane dataset)

  662. 			y.append(float(tmp[2]))

  663. 			

  664. 	return data, y

  665. 				

  666. 

  667. def saveDataset(Gn, y, gformat='gxl', group=None, filename='gfile', xparams=None):

  668. 	"""Save list of graphs.

  669. 	"""

  670. 	import os

  671. 	dirname_ds = os.path.dirname(filename)

  672. 	if dirname_ds != '':

  673. 		dirname_ds += '/'

  674. 		os.makedirs(dirname_ds, exist_ok=True)

  675. 				

  676. 	if xparams is not None and 'graph_dir' in xparams:

  677. 		graph_dir = xparams['graph_dir'] + '/'

  678. 		os.makedirs(graph_dir, exist_ok=True)

  679. 	else:

  680. 		graph_dir = dirname_ds 

  681. 			

  682. 	if group == 'xml' and gformat == 'gxl':

  683. 		kwargs = {'method': xparams['method']} if xparams is not None else {}

  684. 		with open(filename + '.xml', 'w') as fgroup:

  685. 			fgroup.write("<?xml version=\"1.0\"?>")

  686. 			fgroup.write("\n<!DOCTYPE GraphCollection SYSTEM \"http://www.inf.unibz.it/~blumenthal/dtd/GraphCollection.dtd\">")

  687. 			fgroup.write("\n<GraphCollection>")

  688. 			for idx, g in enumerate(Gn):

  689. 				fname_tmp = "graph" + str(idx) + ".gxl"

  690. 				saveGXL(g, graph_dir + fname_tmp, **kwargs)

  691. 				fgroup.write("\n\t<graph file=\"" + fname_tmp + "\" class=\"" + str(y[idx]) + "\"/>")

  692. 			fgroup.write("\n</GraphCollection>")

  693. 			fgroup.close()

  694. 			

  695. 			

  696. if __name__ == '__main__':	

  697. #	### Load dataset from .ds file.

  698. #	# .ct files.

  699. #	ds = {'name': 'Alkane', 'dataset': '../../datasets/Alkane/dataset.ds',

  700. #		'dataset_y': '../../datasets/Alkane/dataset_boiling_point_names.txt'}

  701. #	Gn, y = loadDataset(ds['dataset'], filename_y=ds['dataset_y'])

  702. ##	ds = {'name': 'Acyclic', 'dataset': '../../datasets/acyclic/dataset_bps.ds'}  # node symb

  703. ##	Gn, y = loadDataset(ds['dataset'])

  704. ##	ds = {'name': 'MAO', 'dataset': '../../datasets/MAO/dataset.ds'} # node/edge symb

  705. ##	Gn, y = loadDataset(ds['dataset'])

  706. ##	ds = {'name': 'PAH', 'dataset': '../../datasets/PAH/dataset.ds'} # unlabeled

  707. ##	Gn, y = loadDataset(ds['dataset'])

  708. #	print(Gn[1].nodes(data=True))

  709. #	print(Gn[1].edges(data=True))

  710. #	print(y[1])

  711. 	

  712. #	# .gxl file.

  713. #	ds = {'name': 'monoterpenoides', 

  714. #		  'dataset': '../../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  715. #	Gn, y = loadDataset(ds['dataset'])

  716. #	print(Gn[1].nodes(data=True))

  717. #	print(Gn[1].edges(data=True))

  718. #	print(y[1])

  719. 	

  720. #	### Convert graph from one format to another.

  721. #	# .gxl file.

  722. #	import networkx as nx

  723. #	ds = {'name': 'monoterpenoides', 

  724. #		  'dataset': '../../datasets/monoterpenoides/dataset_10+.ds'}  # node/edge symb

  725. #	Gn, y = loadDataset(ds['dataset'])

  726. #	y = [int(i) for i in y]

  727. #	print(Gn[1].nodes(data=True))

  728. #	print(Gn[1].edges(data=True))

  729. #	print(y[1])

  730. #	# Convert a graph to the proper NetworkX format that can be recognized by library gedlib.

  731. #	Gn_new = []

  732. #	for G in Gn:

  733. #		G_new = nx.Graph()

  734. #		for nd, attrs in G.nodes(data=True):

  735. #			G_new.add_node(str(nd), chem=attrs['atom'])

  736. #		for nd1, nd2, attrs in G.edges(data=True):

  737. #			G_new.add_edge(str(nd1), str(nd2), valence=attrs['bond_type'])

  738. ##			G_new.add_edge(str(nd1), str(nd2))

  739. #		Gn_new.append(G_new)

  740. #	print(Gn_new[1].nodes(data=True))

  741. #	print(Gn_new[1].edges(data=True))

  742. #	print(Gn_new[1])

  743. #	filename = '/media/ljia/DATA/research-repo/codes/others/gedlib/tests_linlin/generated_datsets/monoterpenoides/gxl/monoterpenoides'

  744. #	xparams = {'method': 'gedlib'}

  745. #	saveDataset(Gn, y, gformat='gxl', group='xml', filename=filename, xparams=xparams)

  746. 	

  747. 	# save dataset.

  748. #	ds = {'name': 'MUTAG', 'dataset': '../../datasets/MUTAG/MUTAG.mat',

  749. #		  'extra_params': {'am_sp_al_nl_el': [0, 0, 3, 1, 2]}}  # node/edge symb

  750. #	Gn, y = loadDataset(ds['dataset'], extra_params=ds['extra_params'])

  751. #	saveDataset(Gn, y, group='xml', filename='temp/temp')

  752. 	

  753. 	# test - new way to add labels and attributes.

  754. #	dataset = '../../datasets/SYNTHETICnew/SYNTHETICnew_A.txt'

  755. #	dataset = '../../datasets/Fingerprint/Fingerprint_A.txt'

  756. #	dataset = '../../datasets/Letter-med/Letter-med_A.txt'

  757. #	dataset = '../../datasets/AIDS/AIDS_A.txt'

  758. #	dataset = '../../datasets/ENZYMES_txt/ENZYMES_A_sparse.txt'

  759. #	Gn, y_all = loadDataset(dataset)

  760. 	pass