multipers 1.0__cp311-cp311-manylinux_2_34_x86_64.whl

multipers/data/MOL2.py

@@ -0,0 +1,350 @@
+import numpy as np
+from os.path import expanduser
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from os.path import expanduser
+from os import listdir
+import os
+import MDAnalysis as mda
+import matplotlib.pyplot as plt
+from MDAnalysis.topology.guessers import guess_masses
+import multipers as mp
+# from numba import njit
+from tqdm import tqdm
+from typing import Iterable
+from joblib import Parallel, delayed
+from sklearn.base import BaseEstimator,TransformerMixin
+
+
+DATASET_PATH = expanduser("~/Datasets/")
+JC_path = DATASET_PATH + "Cleves-Jain/"
+DUDE_path = DATASET_PATH + "DUD-E/"
+
+
+#pathes = get_data_path()
+#imgs = apply_pipeline(pathes=pathes, pipeline=pipeline_img)
+#distances_to_letter, ytest = img_distances(imgs)
+
+
+def _get_mols_in_path(folder):
+	with open(folder+"/TargetList", "r") as f:
+		train_data =  [folder + "/" + mol.strip() for mol in f.readlines()]
+	criterion = lambda dataset : dataset.endswith(".mol2") and not dataset.startswith("final") and dataset not in train_data
+	test_data = [folder + "/" + dataset for dataset in listdir(folder) if criterion(folder + "/" + dataset)]
+	return train_data, test_data
+def get_data_path_JC(type="dict"):
+	if type == "dict": out = {}
+	elif type == "list": out = []
+	else: raise TypeError(f"Type {out} not supported")
+	for stuff in listdir(JC_path):
+		if stuff.startswith("target_"):
+			current_letter = stuff[-1]
+			to_add = _get_mols_in_path(JC_path + stuff)
+			if type == "dict":	out[current_letter] = to_add
+			elif type == "list": out.append(to_add)
+	decoy_folder = JC_path + "RognanRing850/"
+	to_add = [decoy_folder + mol for mol in listdir(decoy_folder) if mol.endswith(".mol2")]
+	if type == "dict":	out["decoy"] = to_add
+	elif type == "list": out.append(to_add)
+	return out
+def get_all_JC_path():
+	out = []
+	for stuff in listdir(JC_path):
+		if stuff.startswith("target_"):
+			train_data, test_data =  _get_mols_in_path(JC_path + stuff)
+			out += train_data
+			out += test_data
+	decoy_folder = JC_path + "RognanRing850/"
+	out +=[decoy_folder + mol for mol in listdir(decoy_folder) if mol.endswith(".mol2")]
+	return out
+		
+
+def split_multimol(path:str, mol_name:str, out_folder_name:str = "splitted", enforce_charges:bool=False):
+	with open(path + mol_name, "r") as f:
+		lines = f.readlines()
+	splitted_mols = []
+	index = 0
+	for i,line in enumerate(lines):
+		is_last = i == len(lines)-1
+		if line.strip() == "@<TRIPOS>MOLECULE" or is_last:
+			if i != index:
+				molecule = "".join(lines[index:i + is_last])
+				if enforce_charges:
+					# print(f"Replaced molecule {i}")
+					molecule = molecule.replace("NO_CHARGES","USER_CHARGES")
+					# print(molecule)
+					# return
+				index = i
+				splitted_mols.append(molecule)
+	if not os.path.exists(path + out_folder_name):
+		os.mkdir(path + out_folder_name)
+	for i,mol in enumerate(splitted_mols):
+		with open(path + out_folder_name + f"/{i}.mol2", "w") as f:
+			f.write(mol)
+	return [path+out_folder_name + f"/{i}.mol2" for i in range(len(splitted_mols))]
+
+# @njit(parallel=True)
+def apply_pipeline(pathes:dict, pipeline):
+	img_dict = {}
+	for key, value in tqdm(pathes.items(), desc="Applying pipeline"):
+		if len(key) == 1:
+			train_paths, test_paths = value
+			train_imgs = pipeline.transform(train_paths)
+			test_imgs = pipeline.transform(test_paths)
+			img_dict[key] = (train_imgs, test_imgs)
+		else:
+			assert key == "decoy"
+			img_dict[key] = pipeline.transform(value)
+	return img_dict
+
+from sklearn.metrics import pairwise_distances
+def img_distances(img_dict:dict):
+	distances_to_anchors = []
+	ytest = []
+	decoy_list = img_dict["decoy"]
+	for letter, imgs in img_dict.items():
+		if len(letter) != 1 : continue # decoy
+		xtrain, xtest = imgs
+		assert len(xtest)>0
+		train_data, test_data = xtrain, np.concatenate([xtest ,decoy_list])
+		D = pairwise_distances(train_data, test_data)
+		distances_to_anchors.append(D)
+		letter_ytest = np.array([letter]*len(xtest) + ['0']*len(decoy_list), dtype="<U1")
+		ytest.append(letter_ytest)
+	return distances_to_anchors, ytest
+	
+def get_EF_vector_from_distances(distances, ytest, alpha=0.05):
+	EF = []
+	for distance_to_anchors, letter_ytest in zip(distances, ytest):
+		indices = np.argsort(distance_to_anchors, axis=1)
+		n = indices.shape[1]
+		n_max = int(alpha*n)
+		good_indices = (letter_ytest[indices[:,:n_max]] == letter_ytest[0]) ## assumes that ytest[:,0] are the good letters
+		EF_letter = good_indices.sum(axis=1) / (letter_ytest == letter_ytest[0]).sum()
+		EF_letter /= alpha
+		EF.append(EF_letter.mean())
+	return np.mean(EF)
+
+def EF_from_distance_matrix(distances:np.ndarray, labels:list|np.ndarray, alpha:float, anchors_in_test=True):
+	"""
+	Computes the Enrichment Factor from a distance matrix, and its labels.
+	 - First axis of the distance matrix is the anchors on which to compute the EF
+	 - Second axis is the test. For convenience, anchors can be put in test, if the flag anchors_in_test is set to true.
+	 - labels is a table of bools, representing the the labels of the test axis of the distance matrix.
+	 - alpha : the EF alpha parameter.
+	"""
+	n = len(labels)
+	n_max = int(alpha*n)
+	indices = np.argsort(distances, axis=1)
+	EF_ = [((labels[idx[:n_max]]).sum()-anchors_in_test)/(labels.sum()-anchors_in_test) for idx in indices]
+	return np.mean(EF_)/alpha
+
+def EF_AUC(distances:np.ndarray, labels:np.ndarray, anchors_in_test=0):
+	if distances.ndim == 1:
+		distances = distances[None,:]
+	assert distances.ndim == 2
+	indices = np.argsort(distances, axis=1)
+	out = []
+	for i in range(1,distances.size):
+		proportion_of_good_indices = (labels[indices[:,:i]].sum(axis=1).mean() -anchors_in_test)/min(i,labels.sum() -anchors_in_test)
+		out.append(proportion_of_good_indices)
+	# print(out)
+	return np.mean(out)
+
+
+def theorical_max_EF(distances,labels, alpha):
+	n = len(labels)
+	n_max = int(alpha*n)
+	num_true_labels = np.sum(labels == labels[0]) ## if labels are not True / False, assumes that the first one is a good one
+	return min(n_max, num_true_labels)/alpha
+
+
+def theorical_max_EF_from_distances(list_of_distances,list_of_labels, alpha):
+	return np.mean([theorical_max_EF(distances, labels,alpha) for distances, labels in zip(list_of_distances, list_of_labels)])
+
+def plot_EF_from_distances(alphas = [0.01, 0.02, 0.05, 0.1], EF = EF_from_distance_matrix, plot:bool=True):
+	y = np.round([EF(alpha=alpha) for alpha in alphas], decimals=2)
+	if plot:
+		_alphas = np.linspace(0.01, 1., 100)
+		plt.figure()
+		plt.plot(_alphas, [EF(alpha=alpha) for alpha in _alphas])
+		plt.scatter(alphas, y, c='r')
+		plt.title("Enrichment Factor")
+		plt.xlabel(r"$\alpha$" + f" = {alphas}")
+		plt.ylabel(r"$\mathrm{EF}_\alpha$" + f" = {y}")
+	return y
+
+
+def lines2bonds(mol:mda.Universe, bond_types = ['ar','am',3,2,1,0], molecule_format=None):
+	extension = mol.filename.split('.')[-1].lower() if molecule_format is None else molecule_format
+	match extension:
+		case 'mol2':
+			out = lines2bonds_MOL2(mol)['bond_type']
+		case 'pdb':
+			out = lines2bonds_PDB(mol)
+		case _:
+			raise Exception('Invalid, or not supported molecule format.')
+	return LabelEncoder().fit(bond_types).transform(out)
+	
+
+def lines2bonds_MOL2(mol:mda.Universe):
+	_lines = open(mol.filename, "r").readlines()
+	out = []
+	index = 0
+	while index < len(_lines) and  _lines[index].strip() != "@<TRIPOS>BOND":
+		index += 1
+	index += 1
+	while index < len(_lines) and  _lines[index].strip()[0] != "@":
+		line = _lines[index].strip().split(" ")
+		for j,truc in enumerate(line):
+			line[j] = truc.strip()
+		# try:
+		out.append([stuff for stuff in line if len(stuff) > 0])
+		# except:
+		# 	print_lin
+		index +=1
+	out = pd.DataFrame(out, columns=["bond_id","atom1", "atom2", "bond_type"])
+	out.set_index(["bond_id"],inplace=True)
+	return  out
+
+
+def lines2bonds_PDB(mol:mda.Universe):
+	raise Exception('Not yet implemented.')
+	return  
+
+def _mol2graphst(path:str|mda.Universe, filtrations:Iterable[str], molecule_format=None):
+	molecule = path if isinstance(path, mda.Universe) else mda.Universe(path) 
+
+	num_filtrations = len(filtrations)
+	nodes = molecule.atoms.indices.reshape(1,-1)
+	edges = molecule.bonds.dump_contents().T
+	num_vertices = nodes.shape[1]
+	num_edges = edges.shape[1]
+	
+	st = mp.SimplexTreeMulti(num_parameters = num_filtrations)
+	
+	## Edges filtration
+	# edges = np.array(bonds_df[["atom1", "atom2"]]).T
+	edges_filtration = np.zeros((num_edges, num_filtrations), dtype=np.float32) - np.inf
+	for i, filtration in enumerate(filtrations):
+		match filtration:
+			case "bond_length":
+				bond_lengths = molecule.bonds.bonds()
+				edges_filtration[:,i] = bond_lengths
+			case "bond_type":
+				bond_types = lines2bonds(mol=molecule, molecule_format=molecule_format)
+				edges_filtration[:,i] = bond_types
+			case _:
+				pass
+	
+	## Nodes filtration
+	nodes_filtrations = np.zeros((num_vertices,num_filtrations), dtype=np.float32) + np.min(edges_filtration, axis=0) # better than - np.inf
+	st.insert_batch(nodes, nodes_filtrations)
+
+	st.insert_batch(edges, edges_filtration)
+	for i, filtration in enumerate(filtrations):
+		match filtration:
+			case "charge":
+				charges = molecule.atoms.charges
+				st.fill_lowerstar(charges, parameter=i)
+			case "atomic_mass":
+				masses = molecule.atoms.masses
+				null_indices = masses == 0
+				if np.any(null_indices): # guess if necessary
+					masses[null_indices] = guess_masses(molecule.atoms.types)[null_indices]
+				st.fill_lowerstar(-masses, parameter=i)
+			case _:
+				pass
+	st.make_filtration_non_decreasing() # Necessary ?
+	return st
+
+
+def _mol2ripsst(path:str, filtrations:Iterable[str], threshold=np.inf, bond_types:list=['ar','am',3,2,1,0]):
+	import gudhi as gd
+	assert 'bond_length' == filtrations[0], "Bond length has to be first for rips."
+	molecule = path if isinstance(path, mda.Universe) else mda.Universe(path) 
+	num_parameters = len(filtrations)
+	st_rips = gd.RipsComplex(points = molecule.atoms.positions, max_edge_length=threshold).create_simplex_tree()
+	st = mp.SimplexTreeMulti(st_rips, num_parameters=num_parameters, 
+			  default_values = [bond_types.index(0) if f == "bond_type" else -np.inf for f in filtrations[1:]] # the 0 index is the label of 'no bond' in bond_types
+	)
+
+	## Edges filtration
+	mol_bonds = molecule.bonds.indices.T
+	edges_filtration = np.zeros((mol_bonds.shape[1], num_parameters), dtype=np.float32) - np.inf
+	for i, filtration in enumerate(filtrations):
+		match filtration:
+			case "bond_type":
+				edges_filtration[:,i] = lines2bonds(mol=molecule, bond_types=bond_types)
+			case "atomic_mass":
+				continue
+			case "charge":
+				continue
+			case 'bond_length':
+				edges_filtration[:,i] = [st_rips.filtration(s) for s in mol_bonds.T]
+			case _:
+				raise Exception(f"Invalid filtration {filtration}. Available ones : bond_type, atomic_mass, charge, bond_length.")
+	st.assign_batch_filtration(mol_bonds, edges_filtration, propagate=False)
+	min_filtration = edges_filtration.min(axis=0)
+	st.assign_batch_filtration(np.asarray([list(range(st.num_vertices))], dtype=int), np.asarray([min_filtration]*st.num_vertices, dtype=np.float32), propagate=False)
+	## Nodes filtration
+	for i, filtration in enumerate(filtrations):
+		match filtration:
+			case "charge":
+				charges = molecule.atoms.charges
+				st.fill_lowerstar(charges, parameter=i)
+			case "atomic_mass":
+				masses = molecule.atoms.masses
+				null_indices = masses == 0
+				if np.any(null_indices): # guess if necessary
+					masses[null_indices] = guess_masses(molecule.atoms.types)[null_indices]
+				# print(masses)
+				st.fill_lowerstar(-masses, parameter=i)
+			case _:
+				pass
+	st.make_filtration_non_decreasing() # Necessary ?
+	return st
+
+
+class Molecule2SimplexTree(BaseEstimator, TransformerMixin):
+	"""
+	Transforms a list of MDA-compatible files into a list of mulitparameter simplextrees
+	
+	Input
+	-----
+	 X: Iterable[path_to_files:str]
+	
+	Output
+	------
+	 Iterable[multipers.SimplexTreeMulti]
+	
+	Parameters
+	----------
+	 - filtrations : list of filtration names. Available ones : 'charge', 'atomic_mass', 'bond_length', 'bond_type'. Others are ignored.
+	 - graph : bool. If true, will use the graph given by the molecule, otherwise, a Rips Complex Based on the distance. '
+	 In that case bond_length is ignored (it's the 1rst parameter).
+	"""
+	def __init__(self, 
+			delayed:bool=False, 
+			filtrations:Iterable[str]=[],
+			graph:bool=True,
+			n_jobs:int=1) -> None:
+		super().__init__()
+		self.delayed=delayed
+		self.n_jobs = n_jobs
+		self.filtrations=filtrations
+		self.graph=graph
+		self._molecule_format=None
+		return
+	def fit(self, X:Iterable[str], y=None):
+		if len(X) == 0:	return self
+		test_mol = mda.Universe(X[0])
+		self._molecule_format = test_mol.filename.split('.')[-1].lower()
+		return self
+	def transform(self,X:Iterable[str]):
+		_to_simplextree = _mol2graphst if self.graph else _mol2ripsst
+		to_simplex_tree = lambda path_to_mol2_file : _to_simplextree(path=path_to_mol2_file, filtrations=self.filtrations)
+		if self.delayed:
+			return [delayed(to_simplex_tree)(path) for path in X]
+		return Parallel(n_jobs=self.n_jobs, prefer="threads")(delayed(to_simplex_tree)(path) for path in X)
+

multipers/data/UCR.py

@@ -0,0 +1,18 @@
+import numpy as np
+from os.path import expanduser
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+
+def get(dataset:str="UCR/Coffee", test:bool=False, DATASET_PATH:str=expanduser("~/Datasets/"), dim=3,delay=1,skip=1):
+	from gudhi.point_cloud.timedelay import TimeDelayEmbedding
+	dataset_path = DATASET_PATH + dataset + "/" + dataset[4:]
+	dataset_path +=  "_TEST.tsv" if test else "_TRAIN.tsv"
+	data = np.array(pd.read_csv(dataset_path, delimiter='\t', header=None, index_col=None))
+	Y = LabelEncoder().fit_transform(data[:,0])
+	data = data[:,1:]
+	tde = TimeDelayEmbedding(dim=dim, delay=delay, skip=skip).transform(data)
+	return tde, Y
+def get_train(*args, **kwargs):
+	return get(*args, **kwargs, test=False)
+def get_test(*args, **kwargs):
+	return get(*args, **kwargs, test=True)

multipers/data/__init__.py

@@ -0,0 +1 @@
+from .synthetic import *

multipers/data/graphs.py

@@ -0,0 +1,272 @@
+import numpy as np
+from os.path import expanduser, exists
+import networkx as nx
+from warnings import warn
+import pickle
+from joblib import Parallel, delayed
+from tqdm import tqdm
+from sklearn.preprocessing import LabelEncoder
+from scipy.spatial import distance_matrix
+from sklearn.base import BaseEstimator, TransformerMixin, clone
+import multipers as mp
+from typing import Iterable
+
+DATASET_PATH=expanduser("~/Datasets/")
+
+
+def get(dataset:str, filtration:str):
+	graphs, labels = get_graphs(dataset)
+	try:
+		for g in graphs:	
+			for node in g.nodes:
+				g.nodes[node][filtration]
+	except:
+		print(f"Filtration {filtration} not computed, trying to compute it ...", flush=1)
+		compute_filtration(dataset, filtration)
+	return get_graphs(dataset)
+
+
+
+def get_from_file_old(dataset:str, label="lb"):
+	from os import walk
+	from scipy.io import loadmat
+	from warnings import warn
+	path = DATASET_PATH + dataset  +"/mat/"
+	labels:list[int] = []
+	gs:list[nx.Graph] = []
+	for root, dir, files in walk(path):
+		for file in files:
+			file_ppties  = file.split("_")
+			gid = file_ppties[5]
+			i=0
+			while i+1 < len(file_ppties) and file_ppties[i] != label :
+				i+=1
+			if i+1 >= len(file_ppties):
+				warn(f"Cannot find label {label} on file {file}.")
+			else:
+				labels += [file_ppties[i+1]]
+			adj_mat = np.array(loadmat(path + file)['A'], dtype=np.float32)
+			gs.append(nx.Graph(adj_mat))
+	return gs, labels
+
+
+def get_from_file(dataset:str):
+	from os.path import expanduser, exists
+	path = DATASET_PATH + f"{dataset}/{dataset[7:]}."
+	try:
+		graphs_ids = np.loadtxt(path+"graph_idx")
+	except:
+		return get_from_file_old(dataset=dataset)
+	labels:list[int] = LabelEncoder().fit_transform(np.loadtxt(path+"graph_labels"))
+	edges = np.loadtxt(path+"edges", delimiter=',', dtype=int)-1
+	has_intrinsic_filtration = exists(path+"node_attrs")
+	graphs:list[nx.Graph] = []
+	if has_intrinsic_filtration:
+		F = np.loadtxt(path+"node_attrs", delimiter=',')
+	for graph_id in tqdm(np.unique(graphs_ids), desc="Reading graphs from file"):
+		nodes, = np.where(graphs_ids == graph_id)
+		def graph_has_edge(u:int,v:int)->bool:
+			if u in nodes or v in nodes:
+				assert u in nodes and v in nodes, f"Nodes {u} and {v} are not in the same graph"
+				return True
+			return False
+		graph_edges = [(u,v) for u,v in edges if graph_has_edge(u,v)]
+		g = nx.Graph(graph_edges)
+		if has_intrinsic_filtration:
+			node_attrs = {node:F[node] for node in nodes}
+			nx.set_node_attributes(g,node_attrs, "intrinsic")
+		graphs.append(g)
+	return graphs, labels
+
+
+def get_graphs(dataset:str, N:int|str="")->tuple[list[nx.Graph], list[int]]:
+	graphs_path = f"{DATASET_PATH}{dataset}/graphs{N}.pkl"
+	labels_path = f"{DATASET_PATH}{dataset}/labels{N}.pkl"
+	if not exists(graphs_path) or not exists(labels_path):
+		if dataset.startswith("3dshapes/"):
+			return get_from_file_old(dataset,)
+		graphs, labels = get_from_file(dataset,)
+		print("Saving graphs at :", graphs_path)
+		set_graphs(graphs = graphs, labels = labels, dataset = dataset)
+	else:
+		graphs = pickle.load(open(graphs_path, "rb"))
+		labels = pickle.load(open(labels_path, "rb"))
+	from sklearn.preprocessing import LabelEncoder
+	return graphs, LabelEncoder().fit_transform(labels)
+
+
+def set_graphs(graphs:list[nx.Graph], labels:list, dataset:str, N:int|str=""): # saves graphs (and filtration values) into a file
+	graphs_path = f"{DATASET_PATH}{dataset}/graphs{N}.pkl"
+	labels_path = f"{DATASET_PATH}{dataset}/labels{N}.pkl"
+	pickle.dump(graphs, open(graphs_path, "wb"))
+	pickle.dump(labels, open(labels_path, "wb"))
+	return
+
+def reset_graphs(dataset:str, N=None): # Resets filtrations values on graphs
+	graphs, labels = get_from_file(dataset)
+	set_graphs(graphs,labels, dataset)
+	return
+
+
+
+
+def compute_ricci(graphs:list[nx.Graph], alpha=0.5, progress = 1):
+	from GraphRicciCurvature.OllivierRicci import OllivierRicci
+	def ricci(graph, alpha=alpha):
+		return OllivierRicci(graph,alpha=alpha).compute_ricci_curvature()
+	graphs = [ricci(g) for g in tqdm(graphs, disable = not progress, desc="Computing ricci")]
+	def push_back_node(graph):
+		# for node in graph.nodes:
+			# graph.nodes[node]['ricciCurvature'] = np.min([graph[node][node2]['ricciCurvature'] for node2 in graph[node]] + [graph.nodes[node]['ricciCurvature']])
+		node_filtrations = {
+			node: -1 if len(graph[node]) == 0 else np.min([graph[node][node2]['ricciCurvature'] for node2 in graph[node]]) 
+			for node in graph.nodes
+		}
+		nx.set_node_attributes(graph,node_filtrations,"ricciCurvature")
+		return graph
+	graphs = [push_back_node(g) for g in graphs]
+	return graphs
+
+def compute_cc(graphs:list[nx.Graph], progress = 1):
+	def _cc(g):
+		cc = nx.closeness_centrality(g)
+		nx.set_node_attributes(g,cc,"cc")
+		edges_cc = {(u,v):max(cc[u], cc[v]) for u,v in g.edges}
+		nx.set_edge_attributes(g,edges_cc, "cc")
+		return g
+	graphs = Parallel(n_jobs=1, prefer="threads")(delayed(_cc)(g) for g in tqdm(graphs, disable = not progress, desc="Computing cc"))
+	return graphs
+	# for g in tqdm(graphs, desc="Computing cc"):
+	# 	_cc(g)
+	# return graphs
+
+def compute_degree(graphs:list[nx.Graph], progress=1):
+	def _degree(g):
+		degrees = {i:1.1 if degree == 0 else 1 / degree   for i, degree in g.degree}
+		nx.set_node_attributes(g,degrees,"degree")
+		edges_dg = {(u,v):max(degrees[u], degrees[v]) for u,v in g.edges}
+		nx.set_edge_attributes(g,edges_dg, "degree")
+		return g
+	graphs = Parallel(n_jobs=1, prefer="threads")(delayed(_degree)(g) for g in tqdm(graphs, disable = not progress, desc="Computing degree"))
+	return graphs
+	# for g in tqdm(graphs, desc="Computing degree"):
+	# 	_degree(g)
+	# return graphs
+
+def compute_fiedler(graphs:list[nx.Graph], progress = 1): # TODO : make it compatible with non-connexe graphs
+	def _fiedler(g):
+		connected_graphs = [nx.subgraph(g, nodes) for nodes in nx.connected_components(g)]
+		fiedler_vectors = [nx.fiedler_vector(g)**2 if g.number_of_nodes() > 2 else np.zeros(g.number_of_nodes()) for g in connected_graphs] # order of nx.fiedler_vector correspond to nx.laplacian -> g.nodes
+		fiedler_dict = {
+			node:fiedler_vector[node_index]
+			for g,fiedler_vector in zip(connected_graphs, fiedler_vectors)
+			for node_index,node in enumerate(list(g.nodes))
+		}
+		nx.set_node_attributes(g,fiedler_dict,"fiedler")
+		edges_fiedler = {(u,v):max(fiedler_dict[u], fiedler_dict[v]) for u,v in g.edges}
+		nx.set_edge_attributes(g,edges_fiedler, "fiedler")
+		return g
+	graphs = Parallel(n_jobs=1, prefer="threads")(delayed(_fiedler)(g) for g in tqdm(graphs, disable = not progress, desc="Computing fiedler"))
+	return graphs
+	# for g in tqdm(graphs, desc="Computing fiedler"):
+	# 	_fiedler(g)
+	# return graphs
+
+def compute_hks(graphs:list[nx.Graph],t:float, progress = 1):
+	def _hks(g:nx.Graph):
+		w, vps = np.linalg.eig(nx.laplacianmatrix.normalized_laplacian_matrix(g, nodelist=g.nodes()).toarray()) # order is given by g.nodes order
+		w = w.view(dtype=float)
+		vps= vps.view(dtype=float)
+		node_hks = {node:np.sum(np.exp(-t*w)*np.square(vps[node_index,:])) for node_index,node in enumerate(g.nodes)}
+		nx.set_node_attributes(g, node_hks, f"hks_{t}")
+		edges_hks = {(u,v):max(node_hks[u], node_hks[v]) for u,v in g.edges}
+		nx.set_edge_attributes(g,edges_hks, f"hks_{t}")
+		return g
+	graphs = Parallel(n_jobs=1, prefer="threads")(delayed(_hks)(g) for g in tqdm(graphs, disable = not progress, desc=f"Computing hks_{t}"))
+	return graphs
+
+def compute_geodesic(graphs:list[nx.Graph], progress=1):
+	def _f(g:nx.Graph):
+		try:
+			nodes_intrinsic = {i:n["intrinsic"] for i,n in g.nodes.data()}
+		except:
+			warn("This graph doesn't have an intrinsic filtration, will use 0 instead ...")
+			nodes_intrinsic = {i:0 for i,n in g.nodes.data()}
+			# return g
+		node_geodesic = {i:0 for i in g.nodes}
+		nx.set_node_attributes(g, node_geodesic, f"geodesic")
+		edges_geodesic = {(u,v):np.linalg.norm(nodes_intrinsic[u] - nodes_intrinsic[v]) for u,v in g.edges}
+		nx.set_edge_attributes(g,edges_geodesic, f"geodesic")
+		return g 
+	graphs = Parallel(n_jobs=1, prefer="threads")(delayed(_f)(g) for g in tqdm(graphs, disable = not progress, desc=f"Computing geodesic distances on graphs"))
+	return graphs
+
+def compute_filtration(dataset:str, filtration:str, **kwargs):
+	if filtration == "ALL":
+		reset_graphs(dataset) # not necessary
+		graphs,labels = get_graphs(dataset, **kwargs)
+		graphs = compute_geodesic(graphs)
+		graphs = compute_cc(graphs)
+		graphs = compute_degree(graphs)
+		graphs = compute_ricci(graphs)
+		graphs = compute_fiedler(graphs)
+		graphs = compute_hks(graphs, 10)
+		set_graphs(graphs=graphs, labels=labels, dataset=dataset)
+		return
+	graphs,labels = get_graphs(dataset, **kwargs)
+	if filtration == "dijkstra":
+		return
+	elif filtration == "cc":
+		graphs = compute_cc(graphs)
+	elif filtration == "degree":
+		graphs = compute_degree(graphs)
+	elif filtration == "ricciCurvature":
+		graphs = compute_ricci(graphs)
+	elif filtration == "fiedler":
+		graphs = compute_fiedler(graphs)
+	elif filtration == "geodesic":
+		graphs = compute_geodesic(graphs)
+	elif filtration.startswith('hks_'):
+		t = int(filtration[4:]) # don't want do deal with floats, makes dots in title...
+		graphs = compute_hks(graphs=graphs, t=t)
+	else:
+		warn(f"Filtration {filtration} not implemented !")
+		return
+	set_graphs(graphs=graphs, labels=labels, dataset=dataset)
+	return
+
+
+
+class Graph2SimplexTrees(BaseEstimator,TransformerMixin):
+	"""
+	Transforms a list of networkx graphs into a list of simplextree multi
+	
+	Usual Filtrations
+	-----------------
+	- "cc" closeness centrality
+	- "geodesic" if the graph provides data to compute it, e.g., BZR, COX2, PROTEINS
+	- "degree" 
+	- "ricciCurvature" the ricci curvature
+	- "fiedler" the square of the fiedler vector
+	"""
+	def __init__(self, filtrations:Iterable[str]=[], delayed=False, num_collapses=100, progress:bool=False):
+		super().__init__()
+		self.filtrations=filtrations # filtration to search in graph
+		self.delayed = delayed # reverses the filtration #TODO
+		self.num_collapses=num_collapses
+		self.progress=progress
+	def fit(self, X, y=None):
+		return self
+	def transform(self,X:list[nx.Graph]):
+		def todo(graph, filtrations=self.filtrations) -> mp.SimplexTreeMulti: 
+			st = mp.SimplexTreeMulti(num_parameters=len(filtrations))
+			nodes = np.asarray(graph.nodes, dtype=int).reshape(1,-1)
+			nodes_filtrations = np.asarray([[graph.nodes[node][filtration] for filtration in filtrations] for node in graph.nodes], dtype=np.float32)
+			st.insert_batch(nodes, nodes_filtrations)
+			edges = np.asarray(graph.edges, dtype=int).T
+			edges_filtrations = np.asarray([[graph[u][v][filtration] for filtration in filtrations] for u,v in graph.edges], dtype=np.float32)
+			st.insert_batch(edges,edges_filtrations)
+			if st.num_parameters == 2:	st.collapse_edges(num=self.num_collapses) # TODO : wait for a filtration domination update
+			# st.make_filtration_non_decreasing() ## Ricci is not safe ...
+			return [st] # same output for each pipelines, some have a supplementary axis.
+		return [delayed(todo)(graph) for graph in X] if self.delayed else Parallel(n_jobs=-1, prefer="threads")(delayed(todo)(graph) for graph in tqdm(X, desc="Computing simplextrees from graphs", disable=not self.progress))

multipers/data/immuno_regions.py

@@ -0,0 +1,27 @@
+import numpy as np
+from pandas import read_csv
+from os.path import expanduser
+from os import walk
+from sklearn.preprocessing import LabelEncoder
+
+
+
+def get(DATASET_PATH = expanduser("~/Datasets/")):
+	DATASET_PATH += "1.5mmRegions/"
+	X, labels = [],[]
+	for label in ["FoxP3", "CD8", "CD68"]:
+	#     for label in ["FoxP3", "CD8"]:
+		for root, dirs, files in walk(DATASET_PATH + label+"/"):
+			for name in files:
+				X.append(np.array(read_csv(DATASET_PATH+label+"/"+name))/1500) ## Rescaled
+				labels.append(label)
+	return X, LabelEncoder().fit_transform(np.array(labels))
+
+def get_immuno(i=1, DATASET_PATH = expanduser("~/Datasets/")):
+	immu_dataset = read_csv(DATASET_PATH+f"LargeHypoxicRegion{i}.csv")
+	X = np.array(immu_dataset['x'])
+	X /= np.max(X)
+	Y = np.array(immu_dataset['y'])
+	Y /= np.max(Y)
+	labels = LabelEncoder().fit_transform(immu_dataset['Celltype'])
+	return np.asarray([X,Y]).T, labels