multipers 2.3.3b6__cp311-cp311-manylinux_2_39_x86_64.whl

multipers/data/graphs.py

@@ -0,0 +1,466 @@
+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, List, Optional
+from numpy.typing import ArrayLike
+
+DATASET_PATH = expanduser("~/Datasets/")
+
+
+def _check_installed(dataset: str):
+    from warnings import warn
+    from os.path import exists
+
+    assert dataset.startswith(
+        "graphs/"
+    ), "Graph datasets have to be of the form graphs/<name>"
+    if exists(DATASET_PATH + dataset):
+        return
+    else:
+        warn(
+            f"""
+Dataset {dataset} not installed.
+You can find it in https://networkrepository.com
+Then (optinally) configure multipers.data.graphs.DATASET_PATH, which is currently
+> {DATASET_PATH=}
+and puts this dataset in $DATASET_PATH/{dataset}
+"""
+        )
+        raise ValueError("Unknown dataset.")
+
+
+def get(dataset: str, filtration: Optional[str] = None):
+    if filtration is None:
+        return get_graphs(dataset)
+    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=True,
+        )
+        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]]:
+    _check_installed(dataset)
+    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)
+
+
+# saves graphs (and filtration values) into a file
+def set_graphs(graphs: list[nx.Graph], labels: list, dataset: str, N: int | str = ""):
+    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
+
+
+# TODO : make it compatible with non-connexe graphs
+def compute_fiedler(graphs: list[nx.Graph], progress=1):
+    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(
+                    # order of nx.fiedler_vector correspond to nx.laplacian -> g.nodes
+                )
+            )
+            for g in connected_graphs
+        ]
+        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_intrinsic(graphs: list[nx.Graph], progress=1, nowarning=False):
+    def _f(g: nx.Graph):
+        try:
+            nodes_intrinsic = {i: n["intrinsic"] for i, n in g.nodes.data()}
+        except:
+            if not nowarning:
+                raise ValueError("This graph doesn't have an intrinsic filtration.")
+            else:
+                return g
+        edges_intrinsic = {
+            (u, v): np.max([nodes_intrinsic[u], nodes_intrinsic[v]], axis=0)
+            for u, v in g.edges
+        }
+        nx.set_edge_attributes(g, edges_intrinsic, "intrinsic")
+        return g
+
+    graphs = Parallel(n_jobs=1, prefer="threads")(
+        delayed(_f)(g)
+        for g in tqdm(
+            graphs, disable=not progress, desc="Computing geodesic distances on graphs"
+        )
+    )
+    return graphs
+
+
+def compute_filtration(dataset: str, filtration: str = "ALL", **kwargs):
+    if filtration == "ALL":
+        reset_graphs(dataset)  # not necessary
+        graphs, labels = get_graphs(dataset, **kwargs)
+        graphs = compute_intrinsic(graphs, nowarning=True)
+        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_"):
+        # don't want do deal with floats, makes dots in title...
+        t = int(filtration[4:])
+        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=[],
+        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
+        self.num_parameters: int = len(filtrations)
+
+    def fit(self, X, y=None):
+        if len(X) == 0:
+            return self
+        self.num_parameters = len(self.filtrations)
+        if "intrinsic" in self.filtrations:
+            intrinsic_size = len(X[0].nodes[0]["intrinsic"])
+            self.num_parameters += intrinsic_size - 1
+        return self
+
+    def transform(self, X: list[nx.Graph]):
+        def todo(graph, filtrations=self.filtrations) -> list[mp.SimplexTreeMulti]:
+            st = mp.SimplexTreeMulti(num_parameters=self.num_parameters)
+            nodes = np.asarray(graph.nodes, dtype=int).reshape(1, -1)
+            nodes_filtrations = np.asarray(
+                [
+                    [
+                        filtration
+                        for filtration_ in filtrations
+                        for filtration in np.asarray(
+                            graph.nodes[node][filtration_]
+                        ).reshape(-1)
+                        # this reshape is for attributes that are vectors
+                    ]
+                    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(
+                [
+                    [
+                        filtration
+                        for filtration_ in filtrations
+                        for filtration in np.asarray(graph[u][v][filtration_]).reshape(
+                            -1
+                        )
+                        # this reshape is for attributes that are vectors
+                    ]
+                    for u, v in graph.edges
+                ],
+                dtype=np.float32,
+            )
+            st.insert_batch(edges, edges_filtrations)
+            if st.num_parameters == 2:
+                # TODO : wait for a filtration domination update
+                st.collapse_edges(num=self.num_collapses)
+            # st.make_filtration_non_decreasing() ## Ricci is not safe ...
+            # same output for each pipelines, some have a supplementary axis.
+            return [st]
+
+        return (
+            [delayed(todo)(graph) for graph in X]
+            if self.delayed
+            # memory bound imo
+            else [
+                todo(graph=graph)
+                for graph in tqdm(
+                    X,
+                    desc="Computing simplextrees from graphs",
+                    disable=not self.progress,
+                )
+            ]
+            #                     #         ,
+            #     )
+            # 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

multipers/data/pytorch2simplextree.py

@@ -0,0 +1,91 @@
+from tqdm import tqdm
+import numpy as np
+from torch_geometric.data.data import Data
+import networkx as nx
+from sklearn.base import BaseEstimator, TransformerMixin
+from typing import Iterable
+
+
+def modelnet2pts2gs(train_dataset, test_dataset , nbr_size = 8, exp_flag = True, labels_only = False,n=100, n_jobs=1, random=False):
+	from sklearn.neighbors import kneighbors_graph
+	""" 
+    sample points and create neighborhoold graph
+	"""	
+	dataset = train_dataset + test_dataset
+	indices = np.random.choice(range(len(dataset)),replace=False, size=n) if random else range(n)
+
+	dataset:list[Data] = [dataset[i] for i in indices]
+	_,labels = torch_geometric_2nx(dataset, labels_only=True)
+	if labels_only: return labels
+	
+	def data2graph(data:Data):
+		pos = data.pos.numpy()
+		adj = kneighbors_graph(pos, nbr_size, mode='distance', n_jobs=n_jobs) 
+		g = nx.from_scipy_sparse_array(adj, edge_attribute= 'weight')
+		if exp_flag:
+			for u, v in g.edges(): # TODO optimize
+				g[u][v]['weight'] = np.exp(-g[u][v]['weight'])
+		return g
+		#TODO : nx.set_edge_attributes()
+
+	return [data2graph(data) for data in dataset], labels
+def torch_geometric_2nx(dataset, labels_only = False, print_flag = False, weight_flag = False):
+	"""
+	:param dataset:
+	:param labels_only: return labels only
+	:param print_flag:
+	:param weight_flag: whether computing distance as weights or not
+	:return:
+	"""
+	if labels_only:
+		return None, [int(data.y) for data in dataset]
+	def data2graph(data:Data):
+		edges = np.unique(data.edge_index.numpy().T, axis=0)
+		g = nx.from_edgelist(edges)
+		edge_filtration = {(u,v):np.linalg.norm(data.pos[u] - data.pos[v]) for u,v in g.edges}
+		nx.set_node_attributes(g,{node:0 for node in g.nodes}, "geodesic")
+		nx.set_edge_attributes(g, edge_filtration, "geodesic")
+		return g
+	return [data2graph(data) for data in tqdm(dataset, desc="Turning Data to graphs")], [int(data.y) for data in dataset]
+
+
+def modelnet2graphs(version = '10', print_flag = False, labels_only = False, a = 0, b = 10, weight_flag = False):
+	""" load modelnet 10 or 40 and convert to graphs"""
+	from torch_geometric.transforms import FaceToEdge
+	from .shape3d import load_modelnet
+	train_dataset, test_dataset = load_modelnet(version, point_flag = False)
+	dataset = train_dataset + test_dataset
+	if b>0:	dataset = [dataset[i] for i in range(a,b)]
+	if labels_only:
+		return torch_geometric_2nx(dataset, labels_only=True)
+	dataset = [FaceToEdge(remove_faces=False)(data) for data in dataset]
+	graphs, labels = torch_geometric_2nx(dataset, print_flag=print_flag, weight_flag= weight_flag)
+	return graphs, labels
+
+
+
+
+class Torch2SimplexTree(BaseEstimator,TransformerMixin):
+	"""
+	WARNING : build in progress
+	PyTorch Data-like to simplextree.
+	
+	Input
+	-----
+	Class having `pos`, `edges`, `faces` methods
+    
+	Filtrations
+	-----------
+	 - Geodesic (geodesic rips)
+	 - eccentricity 
+	"""
+	import multipers as mp
+	
+	def __init__(self, filtrations:Iterable[str]=[]):
+		super().__init__()
+		
+	def fit(self, X, y=None):
+		return self
+	
+	def transform(self,X:list[nx.Graph]):
+		return

multipers/data/shape3d.py

@@ -0,0 +1,101 @@
+import numpy as np
+from os.path import expanduser
+from torch_geometric.datasets import ModelNet
+
+DATASET_PATH = expanduser("~/Datasets/")
+import os
+
+
+####################### MODELNET
+def load_modelnet(version='10', sample_points = False, reset:bool=False, remove_faces=False):
+	from torch_geometric.transforms import FaceToEdge, SamplePoints
+	"""
+	:param point_flag: Sample points if point_flag true. Otherwise load mesh
+	:return: train_dataset, test_dataset
+	"""
+	assert version in ['10', '40']
+	if sample_points:
+		pre_transform, transform = FaceToEdge(remove_faces=remove_faces), SamplePoints(num=sample_points)
+	else:
+		pre_transform, transform = FaceToEdge(remove_faces=remove_faces), None
+	path = f"{DATASET_PATH}/ModelNet{version}"
+	if reset:
+		# print(f"rm -rf {path}")
+		os.system(f"rm -rf {path+'/processed/'}")
+	train_dataset = ModelNet(path, name=version, train=True, transform=transform, pre_transform=pre_transform)
+	test_dataset = ModelNet(path, name=version, train=False, transform=transform, pre_transform=pre_transform)
+	return train_dataset, test_dataset
+
+
+def get_ModelNet(dataset, num_graph, seed):
+	train,test = load_modelnet(version=dataset[8:])
+	test_size = len(test) / len(train)
+	if num_graph >0:
+		np.random.seed(seed)
+		indices = np.random.choice(len(train), num_graph, replace=False)
+		train = train[indices]
+		indices = np.random.choice(len(test), int(num_graph*test_size), replace=False)
+		test = test[indices]
+		np.random.seed() # resets seed
+	return train, test
+	
+
+def get(dataset:str, num_graph=0, seed=0, node_per_graph=0):
+	if dataset.startswith("ModelNet"):
+		return get_ModelNet(dataset=dataset, num_graph=num_graph, seed=seed)
+	datasets = get_(dataset=dataset, num_sample=num_graph)
+	graphs = []
+	labels = []
+	np.random.seed(seed)
+	for data, ls in datasets:
+		nodes = np.random.choice(range(len(data.pos)), replace=False, size=node_per_graph)
+		for i,node in enumerate(nodes):
+			data_ = data # if i == 0 else None # prevents doing copies
+			graphs.append([data_, node])
+			labels.append(ls[node])
+	return graphs, labels
+
+
+def get_(dataset:str, dataset_num:int|None=None, num_sample:int=0, DATASET_PATH = expanduser("~/Datasets/")):
+	from torch_geometric.io import read_off
+	if dataset.startswith("3dshapes/"):
+		dataset_ = dataset[len("3dshapes/"):]
+	else:
+		dataset_ = dataset
+	if dataset_num is None and "/" in dataset_:
+		position = dataset_.rfind("/")
+		dataset_num = int(dataset_[position+1:-4]) # cuts the "<dataset>/" and the ".off"
+		dataset_ = dataset_[:position]
+
+	if dataset_num is None: # gets a random (available) number for this dataset
+		from os import listdir
+		from random import choice
+		files = listdir(DATASET_PATH+f"3dshapes/{dataset_}")
+		if num_sample <= 0:
+			files = [file for file in files if "label" not in file]
+		else:
+			files = np.random.choice([file for file in files if "label" not in file], replace=False, size=num_sample)
+		dataset_nums = np.sort([int("".join([char for  char in file  if char.isnumeric()])) for file in files])
+		
+		print("Dataset nums : ", *dataset_nums)
+		out = [get_(dataset_, dataset_num=num) for num in dataset_nums]
+		return out
+
+	path = DATASET_PATH+f"3dshapes/{dataset_}/{dataset_num}.off"
+	data = read_off(path)
+	faces = data.face.numpy().T
+	# data = FaceToEdge(remove_faces=remove_faces)(data)
+	#labels 
+	label_path = path.split(".")[0] + "_labels.txt"
+	f = open(label_path, "r")
+	labels = np.zeros(len(data.pos), dtype="<U10") # Assumes labels are of size at most 10 chars
+	current_label=""
+	for i, line in enumerate(f.readlines()):
+		if i %  2 == 0:
+			current_label = line.strip()
+			continue
+		faces_of_label = np.array(line.strip().split(" "), dtype=int) -1 # this starts at 1, python starts at 0
+		# print(faces_of_label.min())
+		nodes_of_label = np.unique(faces[faces_of_label].flatten())
+		labels[nodes_of_label] = current_label  # les labels sont sur les faces
+	return data, labels