multipers 2.2.3__cp310-cp310-win_amd64.whl → 2.3.0__cp310-cp310-win_amd64.whl

multipers/data/immuno_regions.py

@@ -1,27 +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
+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

@@ -1,91 +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]):
+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

@@ -1,101 +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
+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

multipers/data/synthetic.py

@@ -1,111 +1,113 @@
-import numpy as np
-
-
-def noisy_annulus(
-    n1: int = 1000,
-    n2: int = 200,
-    r1: float = 1,
-    r2: float = 2,
-    dim: int = 2,
-    center: np.ndarray | list | None = None,
-    **kwargs
-) -> np.ndarray:
-    """Generates a noisy annulus dataset.
-
-    Parameters
-    ----------
-    r1 : float.
-            Lower radius of the annulus.
-    r2 : float.
-            Upper radius of the annulus.
-    n1 : int
-            Number of points in the annulus.
-    n2 : int
-            Number of points in the square.
-    dim : int
-            Dimension of the annulus.
-    center: list or array
-            center of the annulus.
-
-    Returns
-    -------
-    numpy array
-            Dataset. size : (n1+n2) x dim
-
-    """
-    theta = np.random.normal(size=(n1, dim))
-    theta /= np.linalg.norm(theta, axis=1)[:, None]
-    rs = np.sqrt(np.random.uniform(low=r1**2, high=r2**2, size=n1))
-    annulus = rs[:, None] * theta
-    if center is not None:
-        annulus += np.array(center)
-    diffuse_noise = np.random.uniform(size=(n2, dim), low=-1.1 * r2, high=1.1 * r2)
-    if center is not None:
-        diffuse_noise += np.array(center)
-    return np.vstack([annulus, diffuse_noise])
-
-
-def three_annulus(num_pts: int = 500, num_outliers: int = 500):
-    X = np.block(
-        [
-            [np.random.uniform(low=-2, high=2, size=(num_outliers, 2))],
-            [
-                np.array(
-                    noisy_annulus(
-                        r1=0.6,
-                        r2=0.9,
-                        n1=(int)(num_pts * 1 / 3),
-                        n2=0,
-                        center=[1, -0.2],
-                    )
-                )
-            ],
-            [
-                np.array(
-                    noisy_annulus(
-                        r1=0.4,
-                        r2=0.55,
-                        n1=(int)(num_pts * 1 / 3),
-                        n2=0,
-                        center=[-1.2, -1],
-                    )
-                )
-            ],
-            [
-                np.array(
-                    noisy_annulus(
-                        r1=0.3,
-                        r2=0.4,
-                        n1=(int)(num_pts * 1 / 3),
-                        n2=0,
-                        center=[-0.7, 1.1],
-                    )
-                )
-            ],
-        ]
-    )
-    return X
-
-
-def orbit(n: int = 1000, r: float = 1.0, x0=[]):
-    point_list = []
-    if len(x0) != 2:
-        x, y = np.random.uniform(size=2)
-    else:
-        x, y = x0
-    point_list.append([x, y])
-    for _ in range(n - 1):
-        x = (x + r * y * (1 - y)) % 1
-        y = (y + r * x * (1 - x)) % 1
-        point_list.append([x, y])
-    return np.asarray(point_list, dtype=float)
-
-
-def get_orbit5k(num_pts=1000, num_data=5000):
-    from sklearn.preprocessing import LabelEncoder
-
-    rs = [2.5, 3.5, 4, 4.1, 4.3]
-    labels = np.random.choice(rs, size=num_data, replace=True)
-    X = [orbit(n=num_pts, r=r) for r in labels]
-    labels = LabelEncoder().fit_transform(labels)
-    return X, labels
+import numpy as np
+
+
+def noisy_annulus(
+    n1: int = 1000,
+    n2: int = 200,
+    r1: float = 1,
+    r2: float = 2,
+    dim: int = 2,
+    center: np.ndarray | list | None = None,
+    **kwargs
+) -> np.ndarray:
+    """Generates a noisy annulus dataset.
+
+    Parameters
+    ----------
+    r1 : float.
+            Lower radius of the annulus.
+    r2 : float.
+            Upper radius of the annulus.
+    n1 : int
+            Number of points in the annulus.
+    n2 : int
+            Number of points in the square.
+    dim : int
+            Dimension of the annulus.
+    center: list or array
+            center of the annulus.
+
+    Returns
+    -------
+    numpy array
+            Dataset. size : (n1+n2) x dim
+
+    """
+    theta = np.random.normal(size=(n1, dim))
+    theta /= np.linalg.norm(theta, axis=1)[:, None]
+    rs = np.sqrt(np.random.uniform(low=r1**2, high=r2**2, size=n1))
+    annulus = rs[:, None] * theta
+    if center is not None:
+        annulus += np.array(center)
+    diffuse_noise = np.random.uniform(size=(n2, dim), low=-1.1 * r2, high=1.1 * r2)
+    if center is not None:
+        diffuse_noise += np.array(center)
+    return np.vstack([annulus, diffuse_noise])
+
+
+def three_annulus(num_pts: int = 500, num_outliers: int = 500):
+    q, r = divmod(num_pts, 3)
+    num_pts_1, num_pts_2, num_pts_3 =  q, q + (r > 0), q + (r > 1)
+    X = np.block(
+        [
+            [np.random.uniform(low=-2, high=2, size=(num_outliers, 2))],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.6,
+                        r2=0.9,
+                        n1=num_pts_1,
+                        n2=0,
+                        center=[1, -0.2],
+                    )
+                )
+            ],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.4,
+                        r2=0.55,
+                        n1=num_pts_2,
+                        n2=0,
+                        center=[-1.2, -1],
+                    )
+                )
+            ],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.3,
+                        r2=0.4,
+                        n1=num_pts_3,
+                        n2=0,
+                        center=[-0.7, 1.1],
+                    )
+                )
+            ],
+        ]
+    )
+    return X
+
+
+def orbit(n: int = 1000, r: float = 1.0, x0=[]):
+    point_list = []
+    if len(x0) != 2:
+        x, y = np.random.uniform(size=2)
+    else:
+        x, y = x0
+    point_list.append([x, y])
+    for _ in range(n - 1):
+        x = (x + r * y * (1 - y)) % 1
+        y = (y + r * x * (1 - x)) % 1
+        point_list.append([x, y])
+    return np.asarray(point_list, dtype=float)
+
+
+def get_orbit5k(num_pts=1000, num_data=5000):
+    from sklearn.preprocessing import LabelEncoder
+
+    rs = [2.5, 3.5, 4, 4.1, 4.3]
+    labels = np.random.choice(rs, size=num_data, replace=True)
+    X = [orbit(n=num_pts, r=r) for r in labels]
+    labels = LabelEncoder().fit_transform(labels)
+    return X, labels