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/graph_files.py

844 lines
30 kB
Raw Permalink Blame History 

  1. """ Utilities function to manage graph files

  2. """

  3. # import warnings

  4. # warnings.simplefilter('always', DeprecationWarning)

  5. # warnings.warn('The functions in the module "gklearn.utils.graph_files" will be deprecated and removed since version 0.4.0. Use the corresponding functions in the module "gklearn.dataset" instead.', DeprecationWarning)

  6. 

  7. from os.path import dirname, splitext

  8. 

  9. 

  10. def load_dataset(filename, filename_targets=None, gformat=None, **kwargs):

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

  12. 

  13. 	Parameters

  14. 	----------

  15. 	filename : string

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

  17. 	filename_y : string

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

  19. 	extra_params : dict

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

  21. 

  22. 	Return

  23. 	------

  24. 	data : List of NetworkX graph.

  25. 

  26. 	y : List

  27. 

  28. 	Targets corresponding to graphs.

  29. 

  30. 	Notes

  31. 	-----

  32. 	This function supports following graph dataset formats:

  33. 

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

  35. 

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

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

  38. 

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

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

  41. 	for details.

  42. 

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

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

  45. 	for details.

  46. 

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

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

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

  50. 	the dataset directory.

  51. 	"""

  52. 	import warnings

  53. 	warnings.simplefilter('always', DeprecationWarning)

  54. 	warnings.warn('The function "gklearn.utils.load_dataset" will be deprecated and removed since version 0.4.0. Use the class "gklearn.dataset.DataLoader" instead.', DeprecationWarning)

  55. 

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

  57. 	if extension == "ds":

  58. 		data, y, label_names = load_from_ds(filename, filename_targets)

  59. 	elif extension == "cxl":

  60. 		dir_dataset = kwargs.get('dirname_dataset', None)

  61. 		data, y, label_names = load_from_xml(filename, dir_dataset)

  62. 	elif extension == 'xml':

  63. 		dir_dataset = kwargs.get('dirname_dataset', None)

  64. 		data, y, label_names = load_from_xml(filename, dir_dataset)

  65. 	elif extension == "mat":

  66. 		order = kwargs.get('order')

  67. 		data, y, label_names = load_mat(filename, order)

  68. 	elif extension == 'txt':

  69. 		data, y, label_names = load_tud(filename)

  70. 

  71. 	return data, y, label_names

  72. 

  73. 

  74. def save_dataset(Gn, y, gformat='gxl', group=None, filename='gfile', **kwargs):

  75. 	"""Save list of graphs.

  76. 	"""

  77. 	import warnings

  78. 	warnings.simplefilter('always', DeprecationWarning)

  79. 	warnings.warn('The function "gklearn.utils.save_dataset" will be deprecated and removed since version 0.4.0. Use the class "gklearn.dataset.DataSaver" instead.', DeprecationWarning)

  80. 

  81. 	import os

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

  83. 	if dirname_ds != '':

  84. 		dirname_ds += '/'

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

  86. 

  87. 	if 'graph_dir' in kwargs:

  88. 		graph_dir = kwargs['graph_dir'] + '/'

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

  90. 		del kwargs['graph_dir']

  91. 	else:

  92. 		graph_dir = dirname_ds

  93. 

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

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

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

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

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

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

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

  101. 				save_gxl(g, graph_dir + fname_tmp, **kwargs)

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

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

  104. 			fgroup.close()

  105. 

  106. 

  107. def load_ct(filename): # @todo: this function is only tested on CTFile V2000; header not considered; only simple cases (atoms and bonds are considered.)

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

  109. 

  110. 	Notes

  111. 	------

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

  113. 

  114. 	3 2  <- number of nodes and edges

  115. 

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

  117. 

  118. 	0.0000	0.0000	0.0000 C

  119. 

  120. 	0.0000	0.0000	0.0000 O

  121. 

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

  123. 

  124. 	2  3  1  1

  125. 

  126. 	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>`__

  127. 	for detailed format discription.

  128. 	"""

  129. 	import networkx as nx

  130. 	from os.path import basename

  131. 	g = nx.Graph()

  132. 	with open(filename) as f:

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

  134. 		g = nx.Graph(name=str(content[0]), filename=basename(filename))  # set name of the graph

  135. 

  136. 		# read the counts line.

  137. 		tmp = content[1].split(' ')

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

  139. 		nb_atoms = int(tmp[0].strip())  # number of atoms

  140. 		nb_bonds = int(tmp[1].strip())  # number of bonds

  141. 		count_line_tags = ['number_of_atoms', 'number_of_bonds', 'number_of_atom_lists', '', 'chiral_flag', 'number_of_stext_entries', '', '', '', '', 'number_of_properties', 'CT_version']

  142. 		i = 0

  143. 		while i < len(tmp):

  144. 			if count_line_tags[i] != '': # if not obsoleted

  145. 				g.graph[count_line_tags[i]] = tmp[i].strip()

  146. 			i += 1

  147. 

  148. 		# read the atom block.

  149. 		atom_tags = ['x', 'y', 'z', 'atom_symbol', 'mass_difference', 'charge', 'atom_stereo_parity', 'hydrogen_count_plus_1', 'stereo_care_box', 'valence', 'h0_designator', '', '', 'atom_atom_mapping_number', 'inversion_retention_flag', 'exact_change_flag']

  150. 		for i in range(0, nb_atoms):

  151. 			tmp = content[i + 2].split(' ')

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

  153. 			g.add_node(i)

  154. 			j = 0

  155. 			while j < len(tmp):

  156. 				if atom_tags[j] != '':

  157. 					g.nodes[i][atom_tags[j]] = tmp[j].strip()

  158. 				j += 1

  159. 

  160. 		# read the bond block.

  161. 		bond_tags = ['first_atom_number', 'second_atom_number', 'bond_type', 'bond_stereo', '', 'bond_topology', 'reacting_center_status']

  162. 		for i in range(0, nb_bonds):

  163. 			tmp = content[i + g.number_of_nodes() + 2].split(' ')

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

  165. 			n1, n2 = int(tmp[0].strip()) - 1, int(tmp[1].strip()) - 1

  166. 			g.add_edge(n1, n2)

  167. 			j = 2

  168. 			while j < len(tmp):

  169. 				if bond_tags[j] != '':

  170. 					g.edges[(n1, n2)][bond_tags[j]] = tmp[j].strip()

  171. 				j += 1

  172. 

  173. 	# get label names.

  174. 	label_names = {'node_labels': [], 'edge_labels': [], 'node_attrs': [], 'edge_attrs': []}

  175. 	atom_symbolic = [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, None, None, 1, 1, 1]

  176. 	for nd in g.nodes():

  177. 		for key in g.nodes[nd]:

  178. 			if atom_symbolic[atom_tags.index(key)] == 1:

  179. 				label_names['node_labels'].append(key)

  180. 			else:

  181. 				label_names['node_attrs'].append(key)

  182. 		break

  183. 	bond_symbolic = [None, None, 1, 1, None, 1, 1]

  184. 	for ed in g.edges():

  185. 		for key in g.edges[ed]:

  186. 			if bond_symbolic[bond_tags.index(key)] == 1:

  187. 				label_names['edge_labels'].append(key)

  188. 			else:

  189. 				label_names['edge_attrs'].append(key)

  190. 		break

  191. 

  192. 	return g, label_names

  193. 

  194. 

  195. def load_gxl(filename): # @todo: directed graphs.

  196. 	from os.path import basename

  197. 	import networkx as nx

  198. 	import xml.etree.ElementTree as ET

  199. 

  200. 	tree = ET.parse(filename)

  201. 	root = tree.getroot()

  202. 	index = 0

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

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

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

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

  207. 		labels = {}

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

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

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

  211. 		index += 1

  212. 

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

  214. 		labels = {}

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

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

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

  218. 

  219. 	# get label names.

  220. 	label_names = {'node_labels': [], 'edge_labels': [], 'node_attrs': [], 'edge_attrs': []}

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

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

  223. 			if attr[0].tag == 'int': # @todo: this maybe wrong, and slow.

  224. 				label_names['node_labels'].append(attr.attrib['name'])

  225. 			else:

  226. 				label_names['node_attrs'].append(attr.attrib['name'])

  227. 		break

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

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

  230. 			if attr[0].tag == 'int': # @todo: this maybe wrong, and slow.

  231. 				label_names['edge_labels'].append(attr.attrib['name'])

  232. 			else:

  233. 				label_names['edge_attrs'].append(attr.attrib['name'])

  234. 		break

  235. 

  236. 	return g, label_names

  237. 

  238. 

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

  240. 	if method == 'default':

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

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

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

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

  245. 		if 'name' in graph.graph:

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

  247. 		else:

  248. 			name = 'dummy'

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

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

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

  252. 			for l_name in node_labels:

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

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

  255. 			for a_name in node_attrs:

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

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

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

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

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

  261. 			for l_name in edge_labels:

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

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

  264. 			for a_name in edge_attrs:

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

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

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

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

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

  270. 		gxl_file.close()

  271. 	elif method == 'benoit':

  272. 		import xml.etree.ElementTree as ET

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

  274. 		attr = dict()

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

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

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

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

  279. 

  280. 		for v in graph:

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

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

  283. 				cur_attr = ET.SubElement(

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

  285. 				cur_value = ET.SubElement(cur_attr,

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

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

  288. 

  289. 		for v1 in graph:

  290. 			for v2 in graph[v1]:

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

  292. 					cur_edge = ET.SubElement(

  293. 						graph_node,

  294. 						'edge',

  295. 						attrib={

  296. 							'from': str(v1),

  297. 							'to': str(v2)

  298. 						})

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

  300. 						cur_attr = ET.SubElement(

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

  302. 						cur_value = ET.SubElement(

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

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

  305. 

  306. 		tree = ET.ElementTree(root_node)

  307. 		tree.write(filename)

  308. 	elif method == 'gedlib':

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

  310. #		pass

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  327. 		gxl_file.close()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  345. 		gxl_file.close()

  346. 

  347. 

  348. # def loadSDF(filename):

  349. # 	"""load data from structured data file (.sdf file).

  350. 

  351. # 	Notes

  352. # 	------

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

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

  355. # 	"""

  356. # 	import networkx as nx

  357. # 	from os.path import basename

  358. # 	from tqdm import tqdm

  359. # 	import sys

  360. # 	data = []

  361. # 	with open(filename) as f:

  362. # 		content = f.read().splitlines()

  363. # 		index = 0

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

  365. # 		while index < len(content):

  366. # 			index_old = index

  367. 

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

  369. 

  370. # 			tmp = content[index + 3]

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

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

  373. 

  374. # 			for i in range(0, nb_nodes):

  375. # 				tmp = content[i + index + 4]

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

  377. 

  378. # 			for i in range(0, nb_edges):

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

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

  381. # 				g.add_edge(

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

  383. 

  384. # 			data.append(g)

  385. 

  386. # 			index += 4 + g.number_of_nodes() + g.number_of_edges()

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

  388. # 				index += 1

  389. # 			index += 1

  390. 

  391. # 			pbar.update(index - index_old)

  392. # 		pbar.update(1)

  393. # 		pbar.close()

  394. 

  395. # 	return data

  396. 

  397. 

  398. def load_mat(filename, order): # @todo: need to be updated (auto order) or deprecated.

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

  400. 

  401. 	Notes

  402. 	------

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

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

  405. 	"""

  406. 	from scipy.io import loadmat

  407. 	import numpy as np

  408. 	import networkx as nx

  409. 	data = []

  410. 	content = loadmat(filename)

  411. 	# print(content)

  412. 	# print('----')

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

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

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

  416. 			# print(y)

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

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

  419. 			# print()

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

  421. 			# print()

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

  423. 			# print()

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

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

  426. 			# print('----')

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

  428. 			if order[1] == 0:

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

  430. 					# print(item)

  431. 					# print('------')

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

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

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

  435. 					# print()

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

  437. 						g.add_node(index, label_1=str(label))

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

  439. 					for edge in el:

  440. 						g.add_edge(edge[0] - 1, edge[1] - 1, label_1=str(edge[2]))

  441. 					data.append(g)

  442. 			else:

  443. # 				from scipy.sparse import csc_matrix

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

  445. 					# print(item)

  446. 					# print('------')

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

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

  449. 					# print(nl)

  450. 					# print()

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

  452. 						g.add_node(index, label_1=str(label))

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

  454. 					index_no0 = sam.nonzero()

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

  456. 						# print(col)

  457. 						# print(row)

  458. 						g.add_edge(col, row)

  459. 					data.append(g)

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

  461. 

  462. 	label_names = {'node_labels': ['label_1'], 'edge_labels': [], 'node_attrs': [], 'edge_attrs': []}

  463. 	if order[1] == 0:

  464. 		label_names['edge_labels'].append('label_1')

  465. 

  466. 	return data, y, label_names

  467. 

  468. 

  469. def load_tud(filename):

  470. 	"""Load graph data from TUD dataset files.

  471. 

  472. 	Notes

  473. 	------

  474. 	The graph data is loaded from separate files.

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

  476. 	"""

  477. 	import networkx as nx

  478. 	from os import listdir

  479. 	from os.path import dirname, basename

  480. 

  481. 

  482. 	def get_infos_from_readme(frm): # @todo: add README (cuniform), maybe node/edge label maps.

  483. 		"""Get information from DS_label_readme.txt file.

  484. 		"""

  485. 

  486. 		def get_label_names_from_line(line):

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

  488. 			"""

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

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

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

  492. 			return names

  493. 

  494. 

  495. 		def get_class_label_map(label_map_strings):

  496. 			label_map = {}

  497. 			for string in label_map_strings:

  498. 				integer, label = string.split('\t')

  499. 				label_map[int(integer.strip())] = label.strip()

  500. 			return label_map

  501. 

  502. 

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

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

  505. 		class_label_map = None

  506. 		class_label_map_strings = []

  507. 		with open(frm) as rm:

  508. 			content_rm = rm.read().splitlines()

  509. 		i = 0

  510. 		while i < len(content_rm):

  511. 			line = content_rm[i].strip()

  512. 			# get node/edge labels and attributes.

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

  514. 				label_names['node_labels'] = get_label_names_from_line(line)

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

  516. 				label_names['node_attrs'] = get_label_names_from_line(line)

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

  518. 				label_names['edge_labels'] = get_label_names_from_line(line)

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

  520. 				label_names['edge_attrs'] = get_label_names_from_line(line)

  521. 			# get class label map.

  522. 			elif line.startswith('Class labels were converted to integer values using this map:'):

  523. 				i += 2

  524. 				line = content_rm[i].strip()

  525. 				while line != '' and i < len(content_rm):

  526. 					class_label_map_strings.append(line)

  527. 					i += 1

  528. 					line = content_rm[i].strip()

  529. 				class_label_map = get_class_label_map(class_label_map_strings)

  530. 			i += 1

  531. 

  532. 		return label_names, class_label_map

  533. 

  534. 

  535. 	# get dataset name.

  536. 	dirname_dataset = dirname(filename)

  537. 	filename = basename(filename)

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

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

  540. 

  541. 	# load data file names

  542. 	for name in listdir(dirname_dataset):

  543. 		if ds_name + '_A' in name:

  544. 			fam = dirname_dataset + '/' + name

  545. 		elif ds_name + '_graph_indicator' in name:

  546. 			fgi = dirname_dataset + '/' + name

  547. 		elif ds_name + '_graph_labels' in name:

  548. 			fgl = dirname_dataset + '/' + name

  549. 		elif ds_name + '_node_labels' in name:

  550. 			fnl = dirname_dataset + '/' + name

  551. 		elif ds_name + '_edge_labels' in name:

  552. 			fel = dirname_dataset + '/' + name

  553. 		elif ds_name + '_edge_attributes' in name:

  554. 			fea = dirname_dataset + '/' + name

  555. 		elif ds_name + '_node_attributes' in name:

  556. 			fna = dirname_dataset + '/' + name

  557. 		elif ds_name + '_graph_attributes' in name:

  558. 			fga = dirname_dataset + '/' + name

  559. 		elif ds_name + '_label_readme' in name:

  560. 			frm = dirname_dataset + '/' + name

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

  562. 		elif ds_name + '_attributes' in name:

  563. 			fna = dirname_dataset + '/' + name

  564. 

  565. 	# get labels and attributes names.

  566. 	if 'frm' in locals():

  567. 		label_names, class_label_map = get_infos_from_readme(frm)

  568. 	else:

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

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

  571. 		class_label_map = None

  572. 

  573. 	with open(fgi) as gi:

  574. 		content_gi = gi.read().splitlines()  # graph indicator

  575. 	with open(fam) as am:

  576. 		content_am = am.read().splitlines()  # adjacency matrix

  577. 

  578. 	# load targets.

  579. 	if 'fgl' in locals():

  580. 		with open(fgl) as gl:

  581. 			content_targets = gl.read().splitlines()  # targets (classification)

  582. 		targets = [float(i) for i in content_targets]

  583. 	elif 'fga' in locals():

  584. 		with open(fga) as ga:

  585. 			content_targets = ga.read().splitlines()  # targets (regression)

  586. 		targets = [int(i) for i in content_targets]

  587. 	else:

  588. 		raise Exception('Can not find targets file. Please make sure there is a "', ds_name, '_graph_labels.txt" or "', ds_name, '_graph_attributes.txt"', 'file in your dataset folder.')

  589. 	if class_label_map is not None:

  590. 		targets = [class_label_map[t] for t in targets]

  591. 

  592. 	# create graphs and add nodes

  593. 	data = [nx.Graph(name=str(i)) for i in range(0, len(content_targets))]

  594. 	if 'fnl' in locals():

  595. 		with open(fnl) as nl:

  596. 			content_nl = nl.read().splitlines()  # node labels

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

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

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

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

  601. 			if label_names['node_labels'] == []: # @todo: need fix bug.

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

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

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

  605. 					label_names['node_labels'].append(l_name)

  606. 			else:

  607. 				for i, l_name in enumerate(label_names['node_labels']):

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

  609. 	else:

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

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

  612. 

  613. 	# add edges

  614. 	for line in content_am:

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

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

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

  618. 		# ignore edge weight here.

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

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

  621. 

  622. 	# add edge labels

  623. 	if 'fel' in locals():

  624. 		with open(fel) as el:

  625. 			content_el = el.read().splitlines()

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

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

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

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

  630. 			if label_names['edge_labels'] == []:

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

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

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

  634. 					label_names['edge_labels'].append(l_name)

  635. 			else:

  636. 				for i, l_name in enumerate(label_names['edge_labels']):

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

  638. 

  639. 	# add node attributes

  640. 	if 'fna' in locals():

  641. 		with open(fna) as na:

  642. 			content_na = na.read().splitlines()

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

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

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

  646. 			if label_names['node_attrs'] == []:

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

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

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

  650. 					label_names['node_attrs'].append(a_name)

  651. 			else:

  652. 				for i, a_name in enumerate(label_names['node_attrs']):

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

  654. 

  655. 	# add edge attributes

  656. 	if 'fea' in locals():

  657. 		with open(fea) as ea:

  658. 			content_ea = ea.read().splitlines()

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

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

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

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

  663. 			if label_names['edge_attrs'] == []:

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

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

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

  667. 					label_names['edge_attrs'].append(a_name)

  668. 			else:

  669. 				for i, a_name in enumerate(label_names['edge_attrs']):

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

  671. 

  672. 	return data, targets, label_names

  673. 

  674. 

  675. def load_from_ds(filename, filename_targets):

  676. 	"""Load data from .ds file.

  677. 

  678. 	Possible graph formats include:

  679. 

  680. 	'.ct': see function load_ct for detail.

  681. 

  682. 	'.gxl': see dunction load_gxl for detail.

  683. 

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

  685. 	graph files.

  686. 	"""

  687. 	dirname_dataset = dirname(filename)

  688. 	data = []

  689. 	y = []

  690. 	label_names = {'node_labels': [], 'edge_labels': [], 'node_attrs': [], 'edge_attrs': []}

  691. 	with open(filename) as fn:

  692. 		content = fn.read().splitlines()

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

  694. 	if extension == 'ct':

  695. 		load_file_fun = load_ct

  696. 	elif extension == 'gxl' or extension == 'sdf': # @todo: .sdf not tested yet.

  697. 		load_file_fun = load_gxl

  698. 

  699. 	if filename_targets is None or filename_targets == '':

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

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

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

  703. 			g, l_names = load_file_fun(dirname_dataset + '/' + tmp[0].replace('#', '', 1))

  704. 			data.append(g)

  705. 			_append_label_names(label_names, l_names)

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

  707. 	else:  # targets in a seperate file

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

  709. 			tmp = content[i]

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

  711. 			g, l_names = load_file_fun(dirname_dataset + '/' + tmp.replace('#', '', 1))

  712. 			data.append(g)

  713. 			_append_label_names(label_names, l_names)

  714. 

  715. 		with open(filename_targets) as fnt:

  716. 			content_y = fnt.read().splitlines()

  717. 		# assume entries in filename and filename_targets have the same order.

  718. 		for item in content_y:

  719. 			tmp = item.split(' ')

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

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

  722. 

  723. 	return data, y, label_names

  724. 

  725. 

  726. # def load_from_cxl(filename):

  727. # 	import xml.etree.ElementTree as ET

  728. #

  729. # 	dirname_dataset = dirname(filename)

  730. # 	tree = ET.parse(filename)

  731. # 	root = tree.getroot()

  732. # 	data = []

  733. # 	y = []

  734. # 	for graph in root.iter('graph'):

  735. # 		mol_filename = graph.attrib['file']

  736. # 		mol_class = graph.attrib['class']

  737. # 		data.append(load_gxl(dirname_dataset + '/' + mol_filename))

  738. # 		y.append(mol_class)

  739. 

  740. 

  741. def load_from_xml(filename, dir_dataset=None):

  742. 	import xml.etree.ElementTree as ET

  743. 

  744. 	if dir_dataset is not None:

  745. 		dir_dataset = dir_dataset

  746. 	else:

  747. 		dir_dataset = dirname(filename)

  748. 	tree = ET.parse(filename)

  749. 	root = tree.getroot()

  750. 	data = []

  751. 	y = []

  752. 	label_names = {'node_labels': [], 'edge_labels': [], 'node_attrs': [], 'edge_attrs': []}

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

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

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

  756. 		g, l_names = load_gxl(dir_dataset + '/' + mol_filename)

  757. 		data.append(g)

  758. 		_append_label_names(label_names, l_names)

  759. 		y.append(mol_class)

  760. 

  761. 	return data, y, label_names

  762. 

  763. 

  764. def _append_label_names(label_names, new_names):

  765. 	for key, val in label_names.items():

  766. 		label_names[key] += [name for name in new_names[key] if name not in val]

  767. 

  768. 

  769. if __name__ == '__main__':

  770. #	### Load dataset from .ds file.

  771. #	# .ct files.

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

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

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

  775. # 	ds_file = '../../datasets/Acyclic/dataset_bps.ds'  # node symb

  776. # 	Gn, targets, label_names = load_dataset(ds_file)

  777. # 	ds_file = '../../datasets/MAO/dataset.ds' # node/edge symb

  778. # 	Gn, targets, label_names = load_dataset(ds_file)

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

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

  781. # 	print(Gn[1].graph)

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

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

  784. # 	print(targets[1])

  785. 

  786. # 	# .gxl file.

  787. # 	ds_file = '../../datasets/monoterpenoides/dataset_10+.ds'  # node/edge symb

  788. # 	Gn, y, label_names = load_dataset(ds_file)

  789. # 	print(Gn[1].graph)

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

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

  792. # 	print(y[1])

  793. 

  794. 	# .mat file.

  795. 	ds_file = '../../datasets/MUTAG_mat/MUTAG.mat'

  796. 	order = [0, 0, 3, 1, 2]

  797. 	Gn, targets, label_names = load_dataset(ds_file, order=order)

  798. 	print(Gn[1].graph)

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

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

  801. 	print(targets[1])

  802. 

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

  804. #	# .gxl file.

  805. #	import networkx as nx

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

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

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

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

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

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

  812. #	print(y[1])

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

  814. #	Gn_new = []

  815. #	for G in Gn:

  816. #		G_new = nx.Graph()

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

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

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

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

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

  822. #		Gn_new.append(G_new)

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

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

  825. #	print(Gn_new[1])

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

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

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

  829. 

  830. 	# save dataset.

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

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

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

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

  835. 

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

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

  838. # 	filename = '../../datasets/Fingerprint/Fingerprint_A.txt'

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

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

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

  842. # 	Gn, targets, label_names = load_dataset(filename)

  843. 	pass