|
|
|
@@ -0,0 +1,770 @@ |
|
|
|
""" Utilities function to manage graph files |
|
|
|
""" |
|
|
|
from os.path import dirname, splitext |
|
|
|
|
|
|
|
|
|
|
|
def load_dataset(filename, filename_targets=None, gformat=None, **kwargs): |
|
|
|
"""Read graph data from filename and load them as NetworkX graphs. |
|
|
|
|
|
|
|
Parameters |
|
|
|
---------- |
|
|
|
filename : string |
|
|
|
The name of the file from where the dataset is read. |
|
|
|
filename_y : string |
|
|
|
The name of file of the targets corresponding to graphs. |
|
|
|
extra_params : dict |
|
|
|
Extra parameters only designated to '.mat' format. |
|
|
|
|
|
|
|
Return |
|
|
|
------ |
|
|
|
data : List of NetworkX graph. |
|
|
|
|
|
|
|
y : List |
|
|
|
|
|
|
|
Targets corresponding to graphs. |
|
|
|
|
|
|
|
Notes |
|
|
|
----- |
|
|
|
This function supports following graph dataset formats: |
|
|
|
|
|
|
|
'ds': load data from .ds file. See comments of function loadFromDS for a example. |
|
|
|
|
|
|
|
'cxl': load data from Graph eXchange Language file (.cxl file). See |
|
|
|
`here <http://www.gupro.de/GXL/Introduction/background.html>`__ for detail. |
|
|
|
|
|
|
|
'sdf': load data from structured data file (.sdf file). See |
|
|
|
`here <http://www.nonlinear.com/progenesis/sdf-studio/v0.9/faq/sdf-file-format-guidance.aspx>`__ |
|
|
|
for details. |
|
|
|
|
|
|
|
'mat': Load graph data from a MATLAB (up to version 7.1) .mat file. See |
|
|
|
README in `downloadable file <http://mlcb.is.tuebingen.mpg.de/Mitarbeiter/Nino/WL/>`__ |
|
|
|
for details. |
|
|
|
|
|
|
|
'txt': Load graph data from a special .txt file. See |
|
|
|
`here <https://ls11-www.cs.tu-dortmund.de/staff/morris/graphkerneldatasets>`__ |
|
|
|
for details. Note here filename is the name of either .txt file in |
|
|
|
the dataset directory. |
|
|
|
""" |
|
|
|
extension = splitext(filename)[1][1:] |
|
|
|
if extension == "ds": |
|
|
|
data, y = loadFromDS(filename, filename_targets) |
|
|
|
elif extension == "cxl": |
|
|
|
import xml.etree.ElementTree as ET |
|
|
|
|
|
|
|
dirname_dataset = dirname(filename) |
|
|
|
tree = ET.parse(filename) |
|
|
|
root = tree.getroot() |
|
|
|
data = [] |
|
|
|
y = [] |
|
|
|
for graph in root.iter('graph'): |
|
|
|
mol_filename = graph.attrib['file'] |
|
|
|
mol_class = graph.attrib['class'] |
|
|
|
data.append(loadGXL(dirname_dataset + '/' + mol_filename)) |
|
|
|
y.append(mol_class) |
|
|
|
elif extension == 'xml': |
|
|
|
dir_dataset = kwargs.get('dirname_dataset', None) |
|
|
|
data, y = loadFromXML(filename, dir_dataset) |
|
|
|
elif extension == "sdf": |
|
|
|
# import numpy as np |
|
|
|
from tqdm import tqdm |
|
|
|
import sys |
|
|
|
|
|
|
|
data = loadSDF(filename) |
|
|
|
|
|
|
|
y_raw = open(filename_targets).read().splitlines() |
|
|
|
y_raw.pop(0) |
|
|
|
tmp0 = [] |
|
|
|
tmp1 = [] |
|
|
|
for i in range(0, len(y_raw)): |
|
|
|
tmp = y_raw[i].split(',') |
|
|
|
tmp0.append(tmp[0]) |
|
|
|
tmp1.append(tmp[1].strip()) |
|
|
|
|
|
|
|
y = [] |
|
|
|
for i in tqdm(range(0, len(data)), desc='ajust data', file=sys.stdout): |
|
|
|
try: |
|
|
|
y.append(tmp1[tmp0.index(data[i].name)].strip()) |
|
|
|
except ValueError: # if data[i].name not in tmp0 |
|
|
|
data[i] = [] |
|
|
|
data = list(filter(lambda a: a != [], data)) |
|
|
|
elif extension == "mat": |
|
|
|
order = kwargs.get('order') |
|
|
|
data, y = loadMAT(filename, order) |
|
|
|
elif extension == 'txt': |
|
|
|
data, y, label_names = load_tud(filename) |
|
|
|
|
|
|
|
return data, y, label_names |
|
|
|
|
|
|
|
|
|
|
|
def save_dataset(Gn, y, gformat='gxl', group=None, filename='gfile', xparams=None): |
|
|
|
"""Save list of graphs. |
|
|
|
""" |
|
|
|
import os |
|
|
|
dirname_ds = os.path.dirname(filename) |
|
|
|
if dirname_ds != '': |
|
|
|
dirname_ds += '/' |
|
|
|
if not os.path.exists(dirname_ds) : |
|
|
|
os.makedirs(dirname_ds) |
|
|
|
|
|
|
|
if xparams is not None and 'graph_dir' in xparams: |
|
|
|
graph_dir = xparams['graph_dir'] + '/' |
|
|
|
if not os.path.exists(graph_dir): |
|
|
|
os.makedirs(graph_dir) |
|
|
|
else: |
|
|
|
graph_dir = dirname_ds |
|
|
|
|
|
|
|
if group == 'xml' and gformat == 'gxl': |
|
|
|
kwargs = {'method': xparams['method']} if xparams is not None else {} |
|
|
|
with open(filename + '.xml', 'w') as fgroup: |
|
|
|
fgroup.write("<?xml version=\"1.0\"?>") |
|
|
|
fgroup.write("\n<!DOCTYPE GraphCollection SYSTEM \"http://www.inf.unibz.it/~blumenthal/dtd/GraphCollection.dtd\">") |
|
|
|
fgroup.write("\n<GraphCollection>") |
|
|
|
for idx, g in enumerate(Gn): |
|
|
|
fname_tmp = "graph" + str(idx) + ".gxl" |
|
|
|
saveGXL(g, graph_dir + fname_tmp, **kwargs) |
|
|
|
fgroup.write("\n\t<graph file=\"" + fname_tmp + "\" class=\"" + str(y[idx]) + "\"/>") |
|
|
|
fgroup.write("\n</GraphCollection>") |
|
|
|
fgroup.close() |
|
|
|
|
|
|
|
|
|
|
|
def loadCT(filename): |
|
|
|
"""load data from a Chemical Table (.ct) file. |
|
|
|
|
|
|
|
Notes |
|
|
|
------ |
|
|
|
a typical example of data in .ct is like this: |
|
|
|
|
|
|
|
3 2 <- number of nodes and edges |
|
|
|
|
|
|
|
0.0000 0.0000 0.0000 C <- each line describes a node (x,y,z + label) |
|
|
|
|
|
|
|
0.0000 0.0000 0.0000 C |
|
|
|
|
|
|
|
0.0000 0.0000 0.0000 O |
|
|
|
|
|
|
|
1 3 1 1 <- each line describes an edge : to, from, bond type, bond stereo |
|
|
|
|
|
|
|
2 3 1 1 |
|
|
|
|
|
|
|
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>`__ |
|
|
|
for detailed format discription. |
|
|
|
""" |
|
|
|
import networkx as nx |
|
|
|
from os.path import basename |
|
|
|
g = nx.Graph() |
|
|
|
with open(filename) as f: |
|
|
|
content = f.read().splitlines() |
|
|
|
g = nx.Graph( |
|
|
|
name = str(content[0]), |
|
|
|
filename = basename(filename)) # set name of the graph |
|
|
|
tmp = content[1].split(" ") |
|
|
|
if tmp[0] == '': |
|
|
|
nb_nodes = int(tmp[1]) # number of the nodes |
|
|
|
nb_edges = int(tmp[2]) # number of the edges |
|
|
|
else: |
|
|
|
nb_nodes = int(tmp[0]) |
|
|
|
nb_edges = int(tmp[1]) |
|
|
|
# patch for compatibility : label will be removed later |
|
|
|
for i in range(0, nb_nodes): |
|
|
|
tmp = content[i + 2].split(" ") |
|
|
|
tmp = [x for x in tmp if x != ''] |
|
|
|
g.add_node(i, atom=tmp[3].strip(), |
|
|
|
label=[item.strip() for item in tmp[3:]], |
|
|
|
attributes=[item.strip() for item in tmp[0:3]]) |
|
|
|
for i in range(0, nb_edges): |
|
|
|
tmp = content[i + g.number_of_nodes() + 2].split(" ") |
|
|
|
tmp = [x for x in tmp if x != ''] |
|
|
|
g.add_edge(int(tmp[0]) - 1, int(tmp[1]) - 1, |
|
|
|
bond_type=tmp[2].strip(), |
|
|
|
label=[item.strip() for item in tmp[2:]]) |
|
|
|
return g |
|
|
|
|
|
|
|
|
|
|
|
def loadGXL(filename): |
|
|
|
from os.path import basename |
|
|
|
import networkx as nx |
|
|
|
import xml.etree.ElementTree as ET |
|
|
|
|
|
|
|
tree = ET.parse(filename) |
|
|
|
root = tree.getroot() |
|
|
|
index = 0 |
|
|
|
g = nx.Graph(filename=basename(filename), name=root[0].attrib['id']) |
|
|
|
dic = {} # used to retrieve incident nodes of edges |
|
|
|
for node in root.iter('node'): |
|
|
|
dic[node.attrib['id']] = index |
|
|
|
labels = {} |
|
|
|
for attr in node.iter('attr'): |
|
|
|
labels[attr.attrib['name']] = attr[0].text |
|
|
|
if 'chem' in labels: |
|
|
|
labels['label'] = labels['chem'] |
|
|
|
labels['atom'] = labels['chem'] |
|
|
|
g.add_node(index, **labels) |
|
|
|
index += 1 |
|
|
|
|
|
|
|
for edge in root.iter('edge'): |
|
|
|
labels = {} |
|
|
|
for attr in edge.iter('attr'): |
|
|
|
labels[attr.attrib['name']] = attr[0].text |
|
|
|
if 'valence' in labels: |
|
|
|
labels['label'] = labels['valence'] |
|
|
|
labels['bond_type'] = labels['valence'] |
|
|
|
g.add_edge(dic[edge.attrib['from']], dic[edge.attrib['to']], **labels) |
|
|
|
return g |
|
|
|
|
|
|
|
|
|
|
|
def saveGXL(graph, filename, method='default', node_labels=[], edge_labels=[], node_attrs=[], edge_attrs=[]): |
|
|
|
if method == 'default': |
|
|
|
gxl_file = open(filename, 'w') |
|
|
|
gxl_file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n") |
|
|
|
gxl_file.write("<!DOCTYPE gxl SYSTEM \"http://www.gupro.de/GXL/gxl-1.0.dtd\">\n") |
|
|
|
gxl_file.write("<gxl xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n") |
|
|
|
if 'name' in graph.graph: |
|
|
|
name = str(graph.graph['name']) |
|
|
|
else: |
|
|
|
name = 'dummy' |
|
|
|
gxl_file.write("<graph id=\"" + name + "\" edgeids=\"false\" edgemode=\"undirected\">\n") |
|
|
|
for v, attrs in graph.nodes(data=True): |
|
|
|
gxl_file.write("<node id=\"_" + str(v) + "\">") |
|
|
|
for l_name in node_labels: |
|
|
|
gxl_file.write("<attr name=\"" + l_name + "\"><int>" + |
|
|
|
str(attrs[l_name]) + "</int></attr>") |
|
|
|
for a_name in node_attrs: |
|
|
|
gxl_file.write("<attr name=\"" + a_name + "\"><float>" + |
|
|
|
str(attrs[a_name]) + "</float></attr>") |
|
|
|
gxl_file.write("</node>\n") |
|
|
|
for v1, v2, attrs in graph.edges(data=True): |
|
|
|
gxl_file.write("<edge from=\"_" + str(v1) + "\" to=\"_" + str(v2) + "\">") |
|
|
|
for l_name in edge_labels: |
|
|
|
gxl_file.write("<attr name=\"" + l_name + "\"><int>" + |
|
|
|
str(attrs[l_name]) + "</int></attr>") |
|
|
|
for a_name in edge_attrs: |
|
|
|
gxl_file.write("<attr name=\"" + a_name + "\"><float>" + |
|
|
|
str(attrs[a_name]) + "</float></attr>") |
|
|
|
gxl_file.write("</edge>\n") |
|
|
|
gxl_file.write("</graph>\n") |
|
|
|
gxl_file.write("</gxl>") |
|
|
|
gxl_file.close() |
|
|
|
elif method == 'benoit': |
|
|
|
import xml.etree.ElementTree as ET |
|
|
|
root_node = ET.Element('gxl') |
|
|
|
attr = dict() |
|
|
|
attr['id'] = str(graph.graph['name']) |
|
|
|
attr['edgeids'] = 'true' |
|
|
|
attr['edgemode'] = 'undirected' |
|
|
|
graph_node = ET.SubElement(root_node, 'graph', attrib=attr) |
|
|
|
|
|
|
|
for v in graph: |
|
|
|
current_node = ET.SubElement(graph_node, 'node', attrib={'id': str(v)}) |
|
|
|
for attr in graph.nodes[v].keys(): |
|
|
|
cur_attr = ET.SubElement( |
|
|
|
current_node, 'attr', attrib={'name': attr}) |
|
|
|
cur_value = ET.SubElement(cur_attr, |
|
|
|
graph.nodes[v][attr].__class__.__name__) |
|
|
|
cur_value.text = graph.nodes[v][attr] |
|
|
|
|
|
|
|
for v1 in graph: |
|
|
|
for v2 in graph[v1]: |
|
|
|
if (v1 < v2): # Non oriented graphs |
|
|
|
cur_edge = ET.SubElement( |
|
|
|
graph_node, |
|
|
|
'edge', |
|
|
|
attrib={ |
|
|
|
'from': str(v1), |
|
|
|
'to': str(v2) |
|
|
|
}) |
|
|
|
for attr in graph[v1][v2].keys(): |
|
|
|
cur_attr = ET.SubElement( |
|
|
|
cur_edge, 'attr', attrib={'name': attr}) |
|
|
|
cur_value = ET.SubElement( |
|
|
|
cur_attr, graph[v1][v2][attr].__class__.__name__) |
|
|
|
cur_value.text = str(graph[v1][v2][attr]) |
|
|
|
|
|
|
|
tree = ET.ElementTree(root_node) |
|
|
|
tree.write(filename) |
|
|
|
elif method == 'gedlib': |
|
|
|
# reference: https://github.com/dbblumenthal/gedlib/blob/master/data/generate_molecules.py#L22 |
|
|
|
# pass |
|
|
|
gxl_file = open(filename, 'w') |
|
|
|
gxl_file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n") |
|
|
|
gxl_file.write("<!DOCTYPE gxl SYSTEM \"http://www.gupro.de/GXL/gxl-1.0.dtd\">\n") |
|
|
|
gxl_file.write("<gxl xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n") |
|
|
|
gxl_file.write("<graph id=\"" + str(graph.graph['name']) + "\" edgeids=\"true\" edgemode=\"undirected\">\n") |
|
|
|
for v, attrs in graph.nodes(data=True): |
|
|
|
gxl_file.write("<node id=\"_" + str(v) + "\">") |
|
|
|
gxl_file.write("<attr name=\"" + "chem" + "\"><int>" + str(attrs['chem']) + "</int></attr>") |
|
|
|
gxl_file.write("</node>\n") |
|
|
|
for v1, v2, attrs in graph.edges(data=True): |
|
|
|
gxl_file.write("<edge from=\"_" + str(v1) + "\" to=\"_" + str(v2) + "\">") |
|
|
|
gxl_file.write("<attr name=\"valence\"><int>" + str(attrs['valence']) + "</int></attr>") |
|
|
|
# gxl_file.write("<attr name=\"valence\"><int>" + "1" + "</int></attr>") |
|
|
|
gxl_file.write("</edge>\n") |
|
|
|
gxl_file.write("</graph>\n") |
|
|
|
gxl_file.write("</gxl>") |
|
|
|
gxl_file.close() |
|
|
|
elif method == 'gedlib-letter': |
|
|
|
# reference: https://github.com/dbblumenthal/gedlib/blob/master/data/generate_molecules.py#L22 |
|
|
|
# and https://github.com/dbblumenthal/gedlib/blob/master/data/datasets/Letter/HIGH/AP1_0000.gxl |
|
|
|
gxl_file = open(filename, 'w') |
|
|
|
gxl_file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n") |
|
|
|
gxl_file.write("<!DOCTYPE gxl SYSTEM \"http://www.gupro.de/GXL/gxl-1.0.dtd\">\n") |
|
|
|
gxl_file.write("<gxl xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n") |
|
|
|
gxl_file.write("<graph id=\"" + str(graph.graph['name']) + "\" edgeids=\"false\" edgemode=\"undirected\">\n") |
|
|
|
for v, attrs in graph.nodes(data=True): |
|
|
|
gxl_file.write("<node id=\"_" + str(v) + "\">") |
|
|
|
gxl_file.write("<attr name=\"x\"><float>" + str(attrs['attributes'][0]) + "</float></attr>") |
|
|
|
gxl_file.write("<attr name=\"y\"><float>" + str(attrs['attributes'][1]) + "</float></attr>") |
|
|
|
gxl_file.write("</node>\n") |
|
|
|
for v1, v2, attrs in graph.edges(data=True): |
|
|
|
gxl_file.write("<edge from=\"_" + str(v1) + "\" to=\"_" + str(v2) + "\"/>\n") |
|
|
|
gxl_file.write("</graph>\n") |
|
|
|
gxl_file.write("</gxl>") |
|
|
|
gxl_file.close() |
|
|
|
|
|
|
|
|
|
|
|
def loadSDF(filename): |
|
|
|
"""load data from structured data file (.sdf file). |
|
|
|
|
|
|
|
Notes |
|
|
|
------ |
|
|
|
A SDF file contains a group of molecules, represented in the similar way as in MOL format. |
|
|
|
Check `here <http://www.nonlinear.com/progenesis/sdf-studio/v0.9/faq/sdf-file-format-guidance.aspx>`__ for detailed structure. |
|
|
|
""" |
|
|
|
import networkx as nx |
|
|
|
from os.path import basename |
|
|
|
from tqdm import tqdm |
|
|
|
import sys |
|
|
|
data = [] |
|
|
|
with open(filename) as f: |
|
|
|
content = f.read().splitlines() |
|
|
|
index = 0 |
|
|
|
pbar = tqdm(total=len(content) + 1, desc='load SDF', file=sys.stdout) |
|
|
|
while index < len(content): |
|
|
|
index_old = index |
|
|
|
|
|
|
|
g = nx.Graph(name=content[index].strip()) # set name of the graph |
|
|
|
|
|
|
|
tmp = content[index + 3] |
|
|
|
nb_nodes = int(tmp[:3]) # number of the nodes |
|
|
|
nb_edges = int(tmp[3:6]) # number of the edges |
|
|
|
|
|
|
|
for i in range(0, nb_nodes): |
|
|
|
tmp = content[i + index + 4] |
|
|
|
g.add_node(i, atom=tmp[31:34].strip()) |
|
|
|
|
|
|
|
for i in range(0, nb_edges): |
|
|
|
tmp = content[i + index + g.number_of_nodes() + 4] |
|
|
|
tmp = [tmp[i:i + 3] for i in range(0, len(tmp), 3)] |
|
|
|
g.add_edge( |
|
|
|
int(tmp[0]) - 1, int(tmp[1]) - 1, bond_type=tmp[2].strip()) |
|
|
|
|
|
|
|
data.append(g) |
|
|
|
|
|
|
|
index += 4 + g.number_of_nodes() + g.number_of_edges() |
|
|
|
while content[index].strip() != '$$$$': # seperator |
|
|
|
index += 1 |
|
|
|
index += 1 |
|
|
|
|
|
|
|
pbar.update(index - index_old) |
|
|
|
pbar.update(1) |
|
|
|
pbar.close() |
|
|
|
|
|
|
|
return data |
|
|
|
|
|
|
|
|
|
|
|
def loadMAT(filename, order): |
|
|
|
"""Load graph data from a MATLAB (up to version 7.1) .mat file. |
|
|
|
|
|
|
|
Notes |
|
|
|
------ |
|
|
|
A MAT file contains a struct array containing graphs, and a column vector lx containing a class label for each graph. |
|
|
|
Check README in `downloadable file <http://mlcb.is.tuebingen.mpg.de/Mitarbeiter/Nino/WL/>`__ for detailed structure. |
|
|
|
""" |
|
|
|
from scipy.io import loadmat |
|
|
|
import numpy as np |
|
|
|
import networkx as nx |
|
|
|
data = [] |
|
|
|
content = loadmat(filename) |
|
|
|
# print(content) |
|
|
|
# print('----') |
|
|
|
for key, value in content.items(): |
|
|
|
if key[0] == 'l': # class label |
|
|
|
y = np.transpose(value)[0].tolist() |
|
|
|
# print(y) |
|
|
|
elif key[0] != '_': |
|
|
|
# print(value[0][0][0]) |
|
|
|
# print() |
|
|
|
# print(value[0][0][1]) |
|
|
|
# print() |
|
|
|
# print(value[0][0][2]) |
|
|
|
# print() |
|
|
|
# if len(value[0][0]) > 3: |
|
|
|
# print(value[0][0][3]) |
|
|
|
# print('----') |
|
|
|
# if adjacency matrix is not compressed / edge label exists |
|
|
|
if order[1] == 0: |
|
|
|
for i, item in enumerate(value[0]): |
|
|
|
# print(item) |
|
|
|
# print('------') |
|
|
|
g = nx.Graph(name=i) # set name of the graph |
|
|
|
nl = np.transpose(item[order[3]][0][0][0]) # node label |
|
|
|
# print(item[order[3]]) |
|
|
|
# print() |
|
|
|
for index, label in enumerate(nl[0]): |
|
|
|
g.add_node(index, atom=str(label)) |
|
|
|
el = item[order[4]][0][0][0] # edge label |
|
|
|
for edge in el: |
|
|
|
g.add_edge( |
|
|
|
edge[0] - 1, edge[1] - 1, bond_type=str(edge[2])) |
|
|
|
data.append(g) |
|
|
|
else: |
|
|
|
from scipy.sparse import csc_matrix |
|
|
|
for i, item in enumerate(value[0]): |
|
|
|
# print(item) |
|
|
|
# print('------') |
|
|
|
g = nx.Graph(name=i) # set name of the graph |
|
|
|
nl = np.transpose(item[order[3]][0][0][0]) # node label |
|
|
|
# print(nl) |
|
|
|
# print() |
|
|
|
for index, label in enumerate(nl[0]): |
|
|
|
g.add_node(index, atom=str(label)) |
|
|
|
sam = item[order[0]] # sparse adjacency matrix |
|
|
|
index_no0 = sam.nonzero() |
|
|
|
for col, row in zip(index_no0[0], index_no0[1]): |
|
|
|
# print(col) |
|
|
|
# print(row) |
|
|
|
g.add_edge(col, row) |
|
|
|
data.append(g) |
|
|
|
# print(g.edges(data=True)) |
|
|
|
return data, y |
|
|
|
|
|
|
|
|
|
|
|
def load_tud(filename): |
|
|
|
"""Load graph data from TUD dataset files. |
|
|
|
|
|
|
|
Notes |
|
|
|
------ |
|
|
|
The graph data is loaded from separate files. |
|
|
|
Check README in `downloadable file <http://tiny.cc/PK_MLJ_data>`__, 2018 for detailed structure. |
|
|
|
""" |
|
|
|
import networkx as nx |
|
|
|
from os import listdir |
|
|
|
from os.path import dirname, basename |
|
|
|
|
|
|
|
|
|
|
|
def get_infos_from_readme(frm): # @todo: add README (cuniform), maybe node/edge label maps. |
|
|
|
"""Get information from DS_label_readme.txt file. |
|
|
|
""" |
|
|
|
|
|
|
|
def get_label_names_from_line(line): |
|
|
|
"""Get names of labels/attributes from a line. |
|
|
|
""" |
|
|
|
str_names = line.split('[')[1].split(']')[0] |
|
|
|
names = str_names.split(',') |
|
|
|
names = [attr.strip() for attr in names] |
|
|
|
return names |
|
|
|
|
|
|
|
|
|
|
|
def get_class_label_map(label_map_strings): |
|
|
|
label_map = {} |
|
|
|
for string in label_map_strings: |
|
|
|
integer, label = string.split('\t') |
|
|
|
label_map[int(integer.strip())] = label.strip() |
|
|
|
return label_map |
|
|
|
|
|
|
|
|
|
|
|
label_names = {'node_labels': [], 'node_attrs': [], |
|
|
|
'edge_labels': [], 'edge_attrs': []} |
|
|
|
class_label_map_strings = [] |
|
|
|
content_rm = open(frm).read().splitlines() |
|
|
|
i = 0 |
|
|
|
while i < len(content_rm): |
|
|
|
line = content_rm[i].strip() |
|
|
|
# get node/edge labels and attributes. |
|
|
|
if line.startswith('Node labels:'): |
|
|
|
label_names['node_labels'] = get_label_names_from_line(line) |
|
|
|
elif line.startswith('Node attributes:'): |
|
|
|
label_names['node_attrs'] = get_label_names_from_line(line) |
|
|
|
elif line.startswith('Edge labels:'): |
|
|
|
label_names['edge_labels'] = get_label_names_from_line(line) |
|
|
|
elif line.startswith('Edge attributes:'): |
|
|
|
label_names['edge_attrs'] = get_label_names_from_line(line) |
|
|
|
# get class label map. |
|
|
|
elif line.startswith('Class labels were converted to integer values using this map:'): |
|
|
|
i += 2 |
|
|
|
line = content_rm[i].strip() |
|
|
|
while line != '' and i < len(content_rm): |
|
|
|
class_label_map_strings.append(line) |
|
|
|
i += 1 |
|
|
|
line = content_rm[i].strip() |
|
|
|
class_label_map = get_class_label_map(class_label_map_strings) |
|
|
|
i += 1 |
|
|
|
|
|
|
|
return label_names, class_label_map |
|
|
|
|
|
|
|
|
|
|
|
# get dataset name. |
|
|
|
dirname_dataset = dirname(filename) |
|
|
|
filename = basename(filename) |
|
|
|
fn_split = filename.split('_A') |
|
|
|
ds_name = fn_split[0].strip() |
|
|
|
|
|
|
|
# load data file names |
|
|
|
for name in listdir(dirname_dataset): |
|
|
|
if ds_name + '_A' in name: |
|
|
|
fam = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_graph_indicator' in name: |
|
|
|
fgi = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_graph_labels' in name: |
|
|
|
fgl = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_node_labels' in name: |
|
|
|
fnl = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_edge_labels' in name: |
|
|
|
fel = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_edge_attributes' in name: |
|
|
|
fea = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_node_attributes' in name: |
|
|
|
fna = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_graph_attributes' in name: |
|
|
|
fga = dirname_dataset + '/' + name |
|
|
|
elif ds_name + '_label_readme' in name: |
|
|
|
frm = dirname_dataset + '/' + name |
|
|
|
# this is supposed to be the node attrs, make sure to put this as the last 'elif' |
|
|
|
elif ds_name + '_attributes' in name: |
|
|
|
fna = dirname_dataset + '/' + name |
|
|
|
|
|
|
|
# get labels and attributes names. |
|
|
|
if 'frm' in locals(): |
|
|
|
label_names, class_label_map = get_infos_from_readme(frm) |
|
|
|
else: |
|
|
|
label_names = {'node_labels': [], 'node_attrs': [], |
|
|
|
'edge_labels': [], 'edge_attrs': []} |
|
|
|
|
|
|
|
content_gi = open(fgi).read().splitlines() # graph indicator |
|
|
|
content_am = open(fam).read().splitlines() # adjacency matrix |
|
|
|
content_gl = open(fgl).read().splitlines() # graph labels |
|
|
|
|
|
|
|
# create graphs and add nodes |
|
|
|
data = [nx.Graph(name=str(i)) for i in range(0, len(content_gl))] |
|
|
|
if 'fnl' in locals(): |
|
|
|
content_nl = open(fnl).read().splitlines() # node labels |
|
|
|
for idx, line in enumerate(content_gi): |
|
|
|
# transfer to int first in case of unexpected blanks |
|
|
|
data[int(line) - 1].add_node(idx) |
|
|
|
labels = [l.strip() for l in content_nl[idx].split(',')] |
|
|
|
if label_names['node_labels'] == []: |
|
|
|
for i, label in enumerate(labels): |
|
|
|
l_name = 'label_' + str(i) |
|
|
|
data[int(line) - 1].nodes[idx][l_name] = label |
|
|
|
label_names['node_labels'].append(l_name) |
|
|
|
else: |
|
|
|
for i, l_name in enumerate(label_names['node_labels']): |
|
|
|
data[int(line) - 1].nodes[idx][l_name] = labels[i] |
|
|
|
else: |
|
|
|
for i, line in enumerate(content_gi): |
|
|
|
data[int(line) - 1].add_node(i) |
|
|
|
|
|
|
|
# add edges |
|
|
|
for line in content_am: |
|
|
|
tmp = line.split(',') |
|
|
|
n1 = int(tmp[0]) - 1 |
|
|
|
n2 = int(tmp[1]) - 1 |
|
|
|
# ignore edge weight here. |
|
|
|
g = int(content_gi[n1]) - 1 |
|
|
|
data[g].add_edge(n1, n2) |
|
|
|
|
|
|
|
# add edge labels |
|
|
|
if 'fel' in locals(): |
|
|
|
content_el = open(fel).read().splitlines() |
|
|
|
for idx, line in enumerate(content_el): |
|
|
|
labels = [l.strip() for l in line.split(',')] |
|
|
|
n = [int(i) - 1 for i in content_am[idx].split(',')] |
|
|
|
g = int(content_gi[n[0]]) - 1 |
|
|
|
if label_names['edge_labels'] == []: |
|
|
|
for i, label in enumerate(labels): |
|
|
|
l_name = 'label_' + str(i) |
|
|
|
data[g].edges[n[0], n[1]][l_name] = label |
|
|
|
label_names['edge_labels'].append(l_name) |
|
|
|
else: |
|
|
|
for i, l_name in enumerate(label_names['edge_labels']): |
|
|
|
data[g].edges[n[0], n[1]][l_name] = labels[i] |
|
|
|
|
|
|
|
# add node attributes |
|
|
|
if 'fna' in locals(): |
|
|
|
content_na = open(fna).read().splitlines() |
|
|
|
for idx, line in enumerate(content_na): |
|
|
|
attrs = [a.strip() for a in line.split(',')] |
|
|
|
g = int(content_gi[idx]) - 1 |
|
|
|
if label_names['node_attrs'] == []: |
|
|
|
for i, attr in enumerate(attrs): |
|
|
|
a_name = 'attr_' + str(i) |
|
|
|
data[g].nodes[idx][a_name] = attr |
|
|
|
label_names['node_attrs'].append(a_name) |
|
|
|
else: |
|
|
|
for i, a_name in enumerate(label_names['node_attrs']): |
|
|
|
data[g].nodes[idx][a_name] = attrs[i] |
|
|
|
|
|
|
|
# add edge attributes |
|
|
|
if 'fea' in locals(): |
|
|
|
content_ea = open(fea).read().splitlines() |
|
|
|
for idx, line in enumerate(content_ea): |
|
|
|
attrs = [a.strip() for a in line.split(',')] |
|
|
|
n = [int(i) - 1 for i in content_am[idx].split(',')] |
|
|
|
g = int(content_gi[n[0]]) - 1 |
|
|
|
if label_names['edge_attrs'] == []: |
|
|
|
for i, attr in enumerate(attrs): |
|
|
|
a_name = 'attr_' + str(i) |
|
|
|
data[g].edges[n[0], n[1]][a_name] = attr |
|
|
|
label_names['edge_attrs'].append(a_name) |
|
|
|
else: |
|
|
|
for i, a_name in enumerate(label_names['edge_attrs']): |
|
|
|
data[g].edges[n[0], n[1]][a_name] = attrs[i] |
|
|
|
|
|
|
|
# load targets. |
|
|
|
targets = [int(i) for i in content_gl] |
|
|
|
if 'class_label_map' in locals(): |
|
|
|
targets = [class_label_map[t] for t in targets] |
|
|
|
|
|
|
|
return data, targets, label_names |
|
|
|
|
|
|
|
|
|
|
|
def loadFromXML(filename, dir_dataset=None): |
|
|
|
import xml.etree.ElementTree as ET |
|
|
|
|
|
|
|
if dir_dataset is not None: |
|
|
|
dir_dataset = dir_dataset |
|
|
|
else: |
|
|
|
dir_dataset = dirname(filename) |
|
|
|
tree = ET.parse(filename) |
|
|
|
root = tree.getroot() |
|
|
|
data = [] |
|
|
|
y = [] |
|
|
|
for graph in root.iter('graph'): |
|
|
|
mol_filename = graph.attrib['file'] |
|
|
|
mol_class = graph.attrib['class'] |
|
|
|
data.append(loadGXL(dir_dataset + '/' + mol_filename)) |
|
|
|
y.append(mol_class) |
|
|
|
|
|
|
|
return data, y |
|
|
|
|
|
|
|
|
|
|
|
def loadFromDS(filename, filename_y): |
|
|
|
"""Load data from .ds file. |
|
|
|
|
|
|
|
Possible graph formats include: |
|
|
|
|
|
|
|
'.ct': see function loadCT for detail. |
|
|
|
|
|
|
|
'.gxl': see dunction loadGXL for detail. |
|
|
|
|
|
|
|
Note these graph formats are checked automatically by the extensions of |
|
|
|
graph files. |
|
|
|
""" |
|
|
|
dirname_dataset = dirname(filename) |
|
|
|
data = [] |
|
|
|
y = [] |
|
|
|
content = open(filename).read().splitlines() |
|
|
|
extension = splitext(content[0].split(' ')[0])[1][1:] |
|
|
|
if filename_y is None or filename_y == '': |
|
|
|
if extension == 'ct': |
|
|
|
for i in range(0, len(content)): |
|
|
|
tmp = content[i].split(' ') |
|
|
|
# remove the '#'s in file names |
|
|
|
data.append( |
|
|
|
loadCT(dirname_dataset + '/' + tmp[0].replace('#', '', 1))) |
|
|
|
y.append(float(tmp[1])) |
|
|
|
elif extension == 'gxl': |
|
|
|
for i in range(0, len(content)): |
|
|
|
tmp = content[i].split(' ') |
|
|
|
# remove the '#'s in file names |
|
|
|
data.append( |
|
|
|
loadGXL(dirname_dataset + '/' + tmp[0].replace('#', '', 1))) |
|
|
|
y.append(float(tmp[1])) |
|
|
|
else: # y in a seperate file |
|
|
|
if extension == 'ct': |
|
|
|
for i in range(0, len(content)): |
|
|
|
tmp = content[i] |
|
|
|
# remove the '#'s in file names |
|
|
|
data.append( |
|
|
|
loadCT(dirname_dataset + '/' + tmp.replace('#', '', 1))) |
|
|
|
elif extension == 'gxl': |
|
|
|
for i in range(0, len(content)): |
|
|
|
tmp = content[i] |
|
|
|
# remove the '#'s in file names |
|
|
|
data.append( |
|
|
|
loadGXL(dirname_dataset + '/' + tmp.replace('#', '', 1))) |
|
|
|
|
|
|
|
content_y = open(filename_y).read().splitlines() |
|
|
|
# assume entries in filename and filename_y have the same order. |
|
|
|
for item in content_y: |
|
|
|
tmp = item.split(' ') |
|
|
|
# assume the 3rd entry in a line is y (for Alkane dataset) |
|
|
|
y.append(float(tmp[2])) |
|
|
|
|
|
|
|
return data, y |
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__': |
|
|
|
# ### Load dataset from .ds file. |
|
|
|
# # .ct files. |
|
|
|
# ds = {'name': 'Alkane', 'dataset': '../../datasets/Alkane/dataset.ds', |
|
|
|
# 'dataset_y': '../../datasets/Alkane/dataset_boiling_point_names.txt'} |
|
|
|
# Gn, y = loadDataset(ds['dataset'], filename_y=ds['dataset_y']) |
|
|
|
## ds = {'name': 'Acyclic', 'dataset': '../../datasets/acyclic/dataset_bps.ds'} # node symb |
|
|
|
## Gn, y = loadDataset(ds['dataset']) |
|
|
|
## ds = {'name': 'MAO', 'dataset': '../../datasets/MAO/dataset.ds'} # node/edge symb |
|
|
|
## Gn, y = loadDataset(ds['dataset']) |
|
|
|
## ds = {'name': 'PAH', 'dataset': '../../datasets/PAH/dataset.ds'} # unlabeled |
|
|
|
## Gn, y = loadDataset(ds['dataset']) |
|
|
|
# print(Gn[1].nodes(data=True)) |
|
|
|
# print(Gn[1].edges(data=True)) |
|
|
|
# print(y[1]) |
|
|
|
|
|
|
|
# # .gxl file. |
|
|
|
# ds = {'name': 'monoterpenoides', |
|
|
|
# 'dataset': '../../datasets/monoterpenoides/dataset_10+.ds'} # node/edge symb |
|
|
|
# Gn, y = loadDataset(ds['dataset']) |
|
|
|
# print(Gn[1].nodes(data=True)) |
|
|
|
# print(Gn[1].edges(data=True)) |
|
|
|
# print(y[1]) |
|
|
|
|
|
|
|
# ### Convert graph from one format to another. |
|
|
|
# # .gxl file. |
|
|
|
# import networkx as nx |
|
|
|
# ds = {'name': 'monoterpenoides', |
|
|
|
# 'dataset': '../../datasets/monoterpenoides/dataset_10+.ds'} # node/edge symb |
|
|
|
# Gn, y = loadDataset(ds['dataset']) |
|
|
|
# y = [int(i) for i in y] |
|
|
|
# print(Gn[1].nodes(data=True)) |
|
|
|
# print(Gn[1].edges(data=True)) |
|
|
|
# print(y[1]) |
|
|
|
# # Convert a graph to the proper NetworkX format that can be recognized by library gedlib. |
|
|
|
# Gn_new = [] |
|
|
|
# for G in Gn: |
|
|
|
# G_new = nx.Graph() |
|
|
|
# for nd, attrs in G.nodes(data=True): |
|
|
|
# G_new.add_node(str(nd), chem=attrs['atom']) |
|
|
|
# for nd1, nd2, attrs in G.edges(data=True): |
|
|
|
# G_new.add_edge(str(nd1), str(nd2), valence=attrs['bond_type']) |
|
|
|
## G_new.add_edge(str(nd1), str(nd2)) |
|
|
|
# Gn_new.append(G_new) |
|
|
|
# print(Gn_new[1].nodes(data=True)) |
|
|
|
# print(Gn_new[1].edges(data=True)) |
|
|
|
# print(Gn_new[1]) |
|
|
|
# filename = '/media/ljia/DATA/research-repo/codes/others/gedlib/tests_linlin/generated_datsets/monoterpenoides/gxl/monoterpenoides' |
|
|
|
# xparams = {'method': 'gedlib'} |
|
|
|
# saveDataset(Gn, y, gformat='gxl', group='xml', filename=filename, xparams=xparams) |
|
|
|
|
|
|
|
# save dataset. |
|
|
|
# ds = {'name': 'MUTAG', 'dataset': '../../datasets/MUTAG/MUTAG.mat', |
|
|
|
# 'extra_params': {'am_sp_al_nl_el': [0, 0, 3, 1, 2]}} # node/edge symb |
|
|
|
# Gn, y = loadDataset(ds['dataset'], extra_params=ds['extra_params']) |
|
|
|
# saveDataset(Gn, y, group='xml', filename='temp/temp') |
|
|
|
|
|
|
|
# test - new way to add labels and attributes. |
|
|
|
# dataset = '../../datasets/SYNTHETICnew/SYNTHETICnew_A.txt' |
|
|
|
# filename = '../../datasets/Fingerprint/Fingerprint_A.txt' |
|
|
|
# dataset = '../../datasets/Letter-med/Letter-med_A.txt' |
|
|
|
# dataset = '../../datasets/AIDS/AIDS_A.txt' |
|
|
|
# dataset = '../../datasets/ENZYMES_txt/ENZYMES_A_sparse.txt' |
|
|
|
# Gn, targets = load_dataset(filename) |
|
|
|
pass |
linlin
GitHub
5 years ago