diff --git a/Python/phate/branch_prediction.py b/Python/phate/branch_prediction.py new file mode 100644 index 0000000..2a3dd49 --- /dev/null +++ b/Python/phate/branch_prediction.py @@ -0,0 +1,501 @@ +import numpy as np +import graphtools +from sklearn.neighbors import NearestNeighbors +from sklearn.base import BaseEstimator, TransformerMixin +import scprep, scipy as sp, phate + +class BranchPointPredictor(BaseEstimator, TransformerMixin): + def __init__( + self, + phate_op: phate.PHATE, # a trained PHATE operator + extrema_percentile:float = 50, # percentile to mask when calculating extrema + diffusion_iterations:int=20 # number of iterations to diffuse + ): + + self.phate_op = phate_op + self.extrema_percentile = extrema_percentile + self.diffusion_iterations = diffusion_iterations + + def fit(self, X, y=None): + self.diffuse_dirac_for_end_points() + self.assign_branches(X) + self.plot_branchs(X) + self.plot_branch_classes(X) + return self + + def transform(self, X): + return self.classes + + + # NOTE: these two properties are for convenience of the developer + # and they just expose the underlying PHATE operator values + @property + def diff_op(self): + try: + return self.phate_op.diff_op + except AttributeError: + return None + + @property + def optimal_t(self): + try: + return self.phate_op.optimal_t + except AttributeError: + return None + + + # NOTE: listing all properties up top for readability + @property + def dmap(self): + ''' + Returns the diffusion map calculated from the diffusion operator + ''' + try: + return self._dmap + except AttributeError: + self._calc_dmap() + return self._dmap + + @property + def n_use(self): + ''' + The number of eigenvectors in the diffusion map to use + for downstream analyses + ''' + try: + return self._n_use + except AttributeError: + self._calc_num_to_consider() + return self._n_use + + @property + def most_distinct_points(self): + ''' + The most distinct points **prior** to downstream analysis. + These are the extrema. + ''' + try: + return self._most_distinct_points + except AttributeError: + self._calc_extrema() + return self._most_distinct_points + + @property + def is_landmarked(self): + ''' + Whether or not the graph in the PHATE operator is a Landmark Graph + which matters when reconstructing class labels + ''' + return isinstance(self.phate_op.graph, graphtools.graphs.kNNLandmarkGraph) + + # NOTE: these two properties are for handling reconstruction from the landmark operator + # back to the original data space. + @property + def pmn(self): + try: + return self.phate_op.graph.transitions + except Exception: + return None + + @property + def pnm(self): + try: + return self.phate_op.graph._data_transitions() + except Exception: + return None + + @property + def n_rows(self): + return self.pmn.shape[0] if self.pmn is not None else self.diff_op.shape[0] + + @property + def nn_dist(self): + ''' + Nearest Neighbor distance matrix calculated on diffusion operator + ''' + try: + return self._nn_dist + except AttributeError: + self._knn_on_diff_op() + return self._nn_dist + + @property + def nn_idxs(self): + ''' + Nearest Neighbor indicies calculated on diffusion operator + ''' + try: + return self._nn_idxs + except AttributeError: + self._knn_on_diff_op() + return self._nn_idxs + + @property + def n_nbrs(self): + try: + return self._n_nbrs + except AttributeError: + self.max_likelihood_pointwise_dimensionality_est() + return self._n_nbrs + + @property + def nbrs_dim_est(self): + try: + return self._nbrs_dim_est + except AttributeError: + self.max_likelihood_pointwise_dimensionality_est() + return self._nbrs_dim_est + + @property + def most_distinct_points_adjusted(self): + try: + return self._most_distinct_points_adjusted + except AttributeError: + self.max_likelihood_pointwise_dimensionality_est() + return self._most_distinct_points_adjusted + + @property + def classes(self): + ''' + Branch class labels + ''' + try: + return self._classes + except AttributeError: + self.diffuse_dirac_for_end_points() + return self._classes + + @property + def branch_classes(self): + try: + return self._branch_classes + except AttributeError: + self.assign_branches(self.phate_op.X) + return self._branch_classes + + @property + def branch_points(self): + try: + return self._branch_points + except AttributeError: + self.diffuse_dirac_for_end_points() + return self._branch_points + + # NOTE: sets property dmap + def _calc_dmap(self, t=None): + if t is None: + t = self.optimal_t + + evals, evecs = np.linalg.eig(self.diff_op) + + # sort eigenvectors in descending order + idx = np.abs(evals).argsort()[::-1] + evals = evals[idx] + evecs = evecs[:, idx] + + # do diffusion + evals = np.power(evals, self.optimal_t) + evecs = evecs.dot(np.diag(evals)) + + self.evals = evals + self.evecs = evecs + self._dmap = evecs + return evecs + + # NOTE: sets property n_use + def _calc_num_to_consider(self): + dmap = self.dmap + evals = self.evals + + # Number of eigenvectors (~ dimensions) to consider. + dmap_diff = evals - np.roll(evals, 1) + + n_evecs = 1 + # Increase the number of eigenvectors until + while (dmap_diff[n_evecs + 1] > 2 * dmap_diff[n_evecs]): + n_evecs += 1 + + self._n_use = n_evecs + return n_evecs + + # NOTE: sets property most_distinct_points + def _calc_extrema(self): + # NOTE: these functions are equivalent, but + # v2 is used in latest version on GitHub and + # although v1 looks cleaner + return self.__calc_extrema_v2() + return self.__calc_extrema_v1() + + def __calc_extrema_v1(self): + dmap = self.dmap + + # Ignore first (trivial) eigenvector + dmap = dmap[:, 1:].copy() + + # Mask lower 50% abs val + lower_half_abs = np.percentile(np.abs(dmap), self.extrema_percentile) + dmap[np.abs(dmap) < lower_half_abs] = 0 + + max_idxs = dmap.argmax(axis=0) + min_idxs = dmap.argmin(axis=0) + extrema_idxs = np.unique(np.hstack((max_idxs, min_idxs))) + self._most_distinct_points = extrema_idxs + return extrema_idxs + + def __calc_extrema_v2(self): + # Find the extremas (min and max) of the considered eigenvectors. + # Keep them in the order of the eigenvalues by weaving min and max values. + # min_eigs = phate_op_eigvecs[:,1:n_eigvecs+1].argmin(0) + # max_eigs = phate_op_eigvecs[:,1:n_eigvecs+1].argmax(0) + # combined_eigs = np.empty((min_eigs.size + max_eigs.size,), dtype=min_eigs.dtype) + # combined_eigs[0::2] = min_eigs + # combined_eigs[1::2] = max_eigs + + # Remove duplicates. + + # for e in combined_eigs: + # if e not in most_distinct_points: + # most_distinct_points.append(e) + + n_consider = self.n_use + dmap = self.dmap + + most_distinct_points = [] + + # Always skip the first trivial eigenvector + for i in np.arange(n_consider): + cur_eigvec = np.copy(dmap[:,i+1]) + # Sometimes the eigvectors are skewed towards one side (much more possitive values than negative + # values and vice versa). This part ensures only the extrema on the more significant side is taken. + lower_half_abs = np.percentile(np.abs(cur_eigvec), self.extrema_percentile) + cur_eigvec[np.abs(cur_eigvec) < lower_half_abs] = 0 + + max_eig = np.argmax(cur_eigvec) + min_eig = np.argmin(cur_eigvec) + + if cur_eigvec[max_eig] > 0 and max_eig not in most_distinct_points: + most_distinct_points.append(max_eig) + + if cur_eigvec[min_eig] < 0 and min_eig not in most_distinct_points: + most_distinct_points.append(min_eig) + + most_distinct_points = np.array(most_distinct_points) + self._most_distinct_points = most_distinct_points + return most_distinct_points + + + def _knn_on_diff_op(self): + # NOTE: using KNN on diff_map is not invertable + # i.e. need to revert landmark graph here! + dmap = self.dmap + + ####################### + # INTRINSIC DIMENSION # + ####################### + + # Based on maxLikPointwiseDimEst() of this R package. + # https://cran.r-project.org/web/packages/intrinsicDimension/README.html + + # Up to 100 dimensions of diffusion maps, + # raised to the same power as tdetermined by PHATE. + dm_dims = min(self.diff_op.shape[1], 100) # NOTE: oroginaly was data.shape[1] + diff_map = dmap[:,:dm_dims] + # diff_map = diff_map.dot(np.diag(np.power(phate_op_eigvals[:dm_dims], 11))) + if self.is_landmarked: + diff_map = self.phate_op.graph.interpolate(diff_map) + + # Rank all neighbors in diffusion map coordinates. + nbrs = NearestNeighbors( + # n_neighbors=dm_dims, + n_neighbors=diff_map.shape[0], + algorithm='ball_tree' + ).fit(diff_map) + + nn_distances, nn_indices = nbrs.kneighbors(diff_map) + nn_distances = nn_distances[:, 1:] + nn_indices = nn_indices[:, 1:] + self._nn_dist = nn_distances + self._nn_idxs = nn_indices + return nn_distances, nn_indices + + def max_likelihood_pointwise_dimensionality_est(self): + n_rows = self.n_rows + nn_dist = self.nn_dist + nn_idxs = self.nn_idxs + most_distinct_points = np.copy(self.most_distinct_points) + + # Maximum Likelihood pointwise dimensionality estimation + # Hill (1975), Levina and Bickel (2005) + row_max = np.max(nn_dist, axis=1) + row_max = row_max.reshape(len(row_max), 1) + dim_est = np.sum(np.log(row_max / nn_dist), axis=1) + + # Calculate the average dim_est of local neighborhood. + n_nbrs = min(n_rows // 20, 100) + nbrs_dim_est = np.average(dim_est[nn_idxs[:, :n_nbrs]], axis=1) + # nbrs_dim_est = phate_op.graph.interpolate(nbrs_dim_est) + + # Calculate ranking of neighborhood dim_est, from low to high + temp = nbrs_dim_est.argsort() + nbrs_dim_est_ranks = np.empty_like(temp) + nbrs_dim_est_ranks[temp] = np.arange(len(nbrs_dim_est)) + + # Make sure that all distinct points are end points (low dim_est), + # not branch point (high dim_est) + low_dim_est_mask = nbrs_dim_est_ranks[most_distinct_points] < n_rows // 2 + most_distinct_points = most_distinct_points[low_dim_est_mask] + + self._most_distinct_points_adjusted = most_distinct_points + self._n_nbrs = n_nbrs + self._nbrs_dim_est = nbrs_dim_est + return n_nbrs, nbrs_dim_est + + def diffuse_dirac_for_end_points(self): + n_nbrs = self.n_nbrs + nbrs_dim_est = self.nbrs_dim_est + # NOTE: use adjusted distinct points from max_likelihood_pointwise_dimensionality_est + most_distinct_points = self.most_distinct_points_adjusted + + ################################## + # DIFFUSING DIRAC FOR END POINTS # + ################################## + pnm = self.pnm + pmn = self.pmn + opt_t = self.optimal_t + nn_idxs = self.nn_idxs + n_rows = self.n_rows + + branch_points = [] + classes = np.zeros(n_rows, dtype="int32") # NOTE: original was data + classes_value = np.repeat(-float('inf'), n_rows) + for end_point_index in np.arange(most_distinct_points.size): + cur_end_point = most_distinct_points[end_point_index] + + if self.is_landmarked: + undo_diff = (pmn @ self.diff_op @ pnm) + diff_op_t = np.linalg.matrix_power(undo_diff, opt_t) + else: + diff_op_t = np.linalg.matrix_power(self.diff_op, opt_t) + + branch_point_dim_est_avg_cache = -float('inf') + + for it in range(self.diffusion_iterations): + branch_from_end_point = diff_op_t[:, cur_end_point] + + branch_max = np.max(branch_from_end_point) + branch_min = np.min(branch_from_end_point) + + branch_threshold = branch_min + (branch_max - branch_min) * 0.1 + + deviation_from_branch_threshold = branch_from_end_point - branch_threshold + deviation_from_branch_threshold[deviation_from_branch_threshold < 0] = float('inf') + + cur_branch_point = deviation_from_branch_threshold.argmin() + potential_branch_points = np.argpartition(deviation_from_branch_threshold, 20)[:20] + + branch_point_dim_est_avg = np.average(nbrs_dim_est[potential_branch_points]) + if (branch_point_dim_est_avg < branch_point_dim_est_avg_cache): + break + branch_point_dim_est_avg_cache = branch_point_dim_est_avg + + if self.is_landmarked: + undo_diff = (pmn @ self.diff_op @ pnm) + diff_op_t = diff_op_t.dot(undo_diff) + else: + diff_op_t = diff_op_t.dot(self.diff_op) + + branch_points.append(cur_branch_point) + on_branch_mask = diff_op_t[:, cur_end_point] > branch_threshold + color = diff_op_t[:, cur_end_point] + + on_branch_mask[color < classes_value] = 0 + + color[np.logical_not(on_branch_mask)] = -np.max(color) + + classes_value[on_branch_mask] = color[on_branch_mask] + classes[on_branch_mask] = end_point_index + 1 + + ##################### + # REMOVE DUPLICATES # + ##################### + # We want to remove branch points that are too close together. + branch_points = np.array(branch_points) + branch_point_nbrs = nn_idxs[branch_points, :n_nbrs] + branch_point_pairs_mask = np.isin(branch_point_nbrs, branch_points) + center_branch_point = branch_points[np.where(branch_point_pairs_mask)[0]] + neighbor_branch_point = branch_point_nbrs[branch_point_pairs_mask] + branch_point_pairs = list(zip(center_branch_point, neighbor_branch_point)) + + # For each pair of branch_points, keep only the one with higher eigenvalue. + # (mdb_pairs, by construction, is sorted by decreasing eigenvalue corresponding + # to the first point of each pair.) + points_to_exclude = [] + for pair in branch_point_pairs: + if pair[0] not in points_to_exclude: + points_to_exclude.append(pair[1]) + + branch_points = np.delete( + branch_points, + np.argwhere(np.isin(branch_points, points_to_exclude)) + ) + self._classes = classes + self._branch_points = branch_points + return branch_points + + def assign_branches(self, emb): + ################### + # ASSIGN BRANCHES # + ################### + dmap = self.dmap + most_distinct_points = self.most_distinct_points_adjusted + + # Find coordinates between every point and every MDP. + all_dm_coords = dmap + if self.is_landmarked: + all_dm_coords = (self.pmn @ self.dmap @ self.pnm) + mdp_dm_coords = all_dm_coords[most_distinct_points,:] + pairwise_dist = sp.spatial.distance.cdist(all_dm_coords, mdp_dm_coords) + + # For every point, rank MDPs by increasing distance. + s = np.argsort(pairwise_dist, axis=1) + i = np.arange(pairwise_dist.shape[0]).reshape(-1, 1) + j = np.arange(pairwise_dist.shape[1]) + + mdp_ranking = np.empty_like(pairwise_dist, dtype=int) + mdp_ranking[i, s] = j + 1 + + # Assign every point to the branch between its two most highly ranked MDPs. + mdp_1 = np.argwhere(mdp_ranking==1)[:,1] + 1 + mdp_2 = np.argwhere(mdp_ranking==2)[:,1] + 1 + + branch_classes = list(zip(mdp_1, mdp_2)) + branch_classes = [str(sorted(branch_class)) for branch_class in branch_classes] + self._branch_classes = branch_classes + + def plot_branchs(self, emb): + most_distinct_points = self.most_distinct_points_adjusted + branch_points = self.branch_points + # Plot by class with end points and branch points + classes = self.classes + ax = scprep.plot.scatter2d(emb, c=classes) + plot_numbers = np.repeat("", emb.shape[0]) + plot_numbers[most_distinct_points] = np.arange(most_distinct_points.shape[0]) + 1 + plot_numbers[branch_points] = "*" + bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + + for i, txt in enumerate(plot_numbers): + ax.annotate(txt, (emb[i][0], emb[i][1]), size=15, bbox=bbox_props) + + def plot_branch_classes(self, emb): + branch_classes = self.branch_classes + most_distinct_points = self.most_distinct_points_adjusted + + ax = scprep.plot.scatter2d(emb, c=branch_classes) + + plot_numbers = np.repeat("", emb.shape[0]) + plot_numbers[most_distinct_points] = np.arange(most_distinct_points.shape[0]) + 1 + bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + + # sys.stdout = open('trash', 'w') + for i, txt in enumerate(plot_numbers): + ax.annotate(txt, (emb[i][0], emb[i][1]), size=15, bbox=bbox_props) \ No newline at end of file diff --git a/Python/tutorial/brach_prediction.py b/Python/tutorial/brach_prediction.py new file mode 100644 index 0000000..bfa25ce --- /dev/null +++ b/Python/tutorial/brach_prediction.py @@ -0,0 +1,326 @@ +import matplotlib.pyplot as plt +import numpy as np +import phate +import random +import scipy as sp +import scprep +import sys + +from sklearn.neighbors import NearestNeighbors + +# import pickle +# pickle.load(open("good_sim.pkl", "rb")) + +random.seed(123) +sim = scprep.run.SplatSimulate(group_prob=[0.20, 0.20, 0.20, 0.20, 0.20], path_from=[0, 0, 0, 3, 3], path_skew=[0.5, 0.5, 0.5, 0.5, 0.5], path_length=[100, 100, 100, 100, 100], dropout_type='binomial', dropout_prob=0.4, batch_cells=2000) + +data = sim['counts'] +data = scprep.normalize.library_size_normalize(data) +data = scprep.transform.sqrt(data) +phate_op = phate.PHATE() +data_ph = phate_op.fit_transform(data) +ax = scprep.plot.scatter2d(data_ph, c=sim['group']) + +################ +# DISTINCTNESS # +################ +# Find and sort eigenvectors and eigenvalues of diffusion operators. +phate_op_eigvals, phate_op_eigvecs = np.linalg.eig(phate_op.diff_op) +idx = np.abs(phate_op_eigvals).argsort()[::-1] +phate_op_eigvals = phate_op_eigvals[idx] +phate_op_eigvecs = phate_op_eigvecs[:,idx] +phate_op_eigvals = np.power(phate_op_eigvals, phate_op.optimal_t) +phate_op_eigvecs = phate_op_eigvecs.dot(np.diag(phate_op_eigvals)) + +# Number of eigenvectors (~ dimensions) to consider. +phate_op_eigvals_diff = phate_op_eigvals - np.roll(phate_op_eigvals, 1) +n_eigvecs = 1 + +# Increase the number of eigenvectors until +while (phate_op_eigvals_diff[n_eigvecs + 1] + > 2 * phate_op_eigvals_diff[n_eigvecs]): + n_eigvecs += 1 + +# Find the extremas (min and max) of the considered eigenvectors. +# Keep them in the order of the eigenvalues by weaving min and max values. +# min_eigs = phate_op_eigvecs[:,1:n_eigvecs+1].argmin(0) +# max_eigs = phate_op_eigvecs[:,1:n_eigvecs+1].argmax(0) +# combined_eigs = np.empty((min_eigs.size + max_eigs.size,), dtype=min_eigs.dtype) +# combined_eigs[0::2] = min_eigs +# combined_eigs[1::2] = max_eigs + +# Remove duplicates. + +# for e in combined_eigs: +# if e not in most_distinct_points: +# most_distinct_points.append(e) + +most_distinct_points = [] + +# Always skip the first trivial eigenvector +for i in np.arange(n_eigvecs): + cur_eigvec = np.copy(phate_op_eigvecs[:,i + 1]) + # Sometimes the eigvectors are skewed towards one side (much more possitive values than negative values and vice versa). This part ensures only the extrema on the more significant side is taken. + lower_half_abs = np.percentile(np.abs(cur_eigvec), 50) + cur_eigvec[np.abs(cur_eigvec) < lower_half_abs] = 0 + max_eig = np.argmax(cur_eigvec) + min_eig = np.argmin(cur_eigvec) + if cur_eigvec[max_eig] > 0 and max_eig not in most_distinct_points: + most_distinct_points.append(max_eig) + if cur_eigvec[min_eig] < 0 and min_eig not in most_distinct_points: + most_distinct_points.append(min_eig) + +most_distinct_points = np.array(most_distinct_points) + +# These extremas could contain branch points but +# We will classify them based on their intrinsic dimensionality. + +####################### +# INTRINSIC DIMENSION # +####################### + +# Based on maxLikPointwiseDimEst() of this R package. +# https://cran.r-project.org/web/packages/intrinsicDimension/README.html + +# Up to 100 dimensions of diffusion maps, +# raised to the same power as tdetermined by PHATE. +dm_dims = min(data.shape[1], 100) +diff_map = phate_op_eigvecs[:,:dm_dims] +# diff_map = diff_map.dot(np.diag(np.power(phate_op_eigvals[:dm_dims], 11))) + +# Rank all neighbors in diffusion map coordinates. +nbrs = NearestNeighbors( + # n_neighbors=dm_dims, + n_neighbors=diff_map.shape[0], + algorithm='ball_tree' + ).fit(diff_map) +nn_distances, nn_indices = nbrs.kneighbors(diff_map) +nn_distances = nn_distances[:,1:] +nn_indices = nn_indices[:,1:] + +# Maximum Likelihood pointwise dimensionality estimation +# Hill (1975), Levina and Bickel (2005) +row_max = np.max(nn_distances, axis=1) +row_max = row_max.reshape(len(row_max), 1) +dim_est = np.sum(np.log(row_max / nn_distances), axis=1) + +# Calculate the average dim_est of local neighborhood. +n_nbrs = min(data.shape[0] // 20, 100) +nbrs_dim_est = np.average(dim_est[nn_indices[:,:n_nbrs]], axis=1) + +# Calculate ranking of neighborhood dim_est, from low to high +temp = nbrs_dim_est.argsort() +nbrs_dim_est_ranks = np.empty_like(temp) +nbrs_dim_est_ranks[temp] = np.arange(len(nbrs_dim_est)) + +# Make sure that all distinct points are end points (low dim_est), not branch point (high dim_est) +low_dim_est_mask = nbrs_dim_est_ranks[most_distinct_points] < data.shape[0] // 2 +most_distinct_points = most_distinct_points[low_dim_est_mask] + +################################## +# DIFFUSING DIRAC FOR END POINTS # +################################## + +branch_points = [] +classes = np.zeros(data.shape[0], dtype="int32") +classes_value = np.repeat(-float('inf'), data.shape[0]) +for end_point_index in np.arange(most_distinct_points.size): + cur_end_point = most_distinct_points[end_point_index] + diff_op_t = np.linalg.matrix_power(phate_op.diff_op, phate_op.optimal_t) + branch_point_dim_est_avg_cache = -float('inf') + for it in range(20): + branch_from_end_point = diff_op_t[:,cur_end_point] + branch_max = np.max(branch_from_end_point) + branch_min = np.min(branch_from_end_point) + branch_threshold = branch_min + (branch_max - branch_min) * 0.2 + deviation_from_branch_threshold = \ + branch_from_end_point - branch_threshold + deviation_from_branch_threshold[deviation_from_branch_threshold < 0] = \ + float('inf') + cur_branch_point = deviation_from_branch_threshold.argmin() + potential_branch_points = \ + np.argpartition(deviation_from_branch_threshold, 20)[:20] + branch_point_dim_est_avg = \ + np.average(nbrs_dim_est[potential_branch_points]) + if (branch_point_dim_est_avg < branch_point_dim_est_avg_cache): + break + branch_point_dim_est_avg_cache = branch_point_dim_est_avg + diff_op_t = diff_op_t.dot(phate_op.diff_op) + branch_points.append(cur_branch_point) + on_branch_mask = diff_op_t[:,cur_end_point] > branch_threshold + color = diff_op_t[:,cur_end_point] + on_branch_mask[color < classes_value] = 0 + color[np.logical_not(on_branch_mask)] = -np.max(color) + classes_value[on_branch_mask] = color[on_branch_mask] + classes[on_branch_mask] = end_point_index + 1 + # ax = scprep.plot.scatter2d(data_ph, c=color) + # plot_numbers = np.repeat("", data_ph.shape[0]) + # plot_numbers[cur_end_point] = 'e' + # plot_numbers[cur_branch_point] = 'b' + # bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + # sys.stdout = open('trash', 'w') + # for i, txt in enumerate(plot_numbers): + # ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props) + # sys.stdout = sys.__stdout__ + +##################### +# REMOVE DUPLICATES # +##################### +# We want to remove branch points that are too close together. + +branch_points = np.array(branch_points) +branch_point_nbrs = nn_indices[branch_points,:n_nbrs] +branch_point_pairs_mask = np.isin(branch_point_nbrs, branch_points) +center_branch_point = branch_points[np.where(branch_point_pairs_mask)[0]] +neighbor_branch_point = branch_point_nbrs[branch_point_pairs_mask] +branch_point_pairs = list(zip(center_branch_point, neighbor_branch_point)) + +# For each pair of branch_points, keep only the one with higher eigenvalue. +# (mdb_pairs, by construction, is sorted by decreasing eigenvalue corresponding +# to the first point of each pair.) +points_to_exclude = [] +for pair in branch_point_pairs: + if pair[0] not in points_to_exclude: + points_to_exclude.append(pair[1]) + +branch_points = np.delete(branch_points, + np.argwhere(np.isin(branch_points, points_to_exclude))) + +#################### +# PLOTTING RESULTS # +#################### + +# Plot by class with end points and branch points +ax = scprep.plot.scatter2d(data_ph, c=classes) +plot_numbers = np.repeat("", data_ph.shape[0]) +plot_numbers[most_distinct_points] = \ + np.arange(most_distinct_points.shape[0]) + 1 +plot_numbers[branch_points] = "*" +bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + +sys.stdout = open('trash', 'w') +for i, txt in enumerate(plot_numbers): + ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props) + +sys.stdout = sys.__stdout__ + +################## +# OTHER PLOTTING # +################## + +# Plot by an eigenvector +eigvec_index = 1 +size = np.ones(data.shape[0]) +size[np.argmax(phate_op_eigvecs[:,eigvec_index])] = 50 +size[np.argmin(phate_op_eigvecs[:,eigvec_index])] = 50 +scprep.plot.scatter2d(data_ph, c=phate_op_eigvecs[:,eigvec_index], s=size) + +# Plot one point +point_index = 1000 +size = np.ones(data.shape[0]) +size[point_index] +ax = scprep.plot.scatter2d(data_ph, c=sim['group'], s=size) +plot_numbers = np.repeat("", data_ph.shape[0]) +plot_numbers[point_index] = "p" +bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + +sys.stdout = open('trash', 'w') +for i, txt in enumerate(plot_numbers): + ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props) + +sys.stdout = sys.__stdout__ + +# Based on most distinct indices. +size = np.ones(data.shape[0]) +size[most_distinct_points] = 50 +ax = scprep.plot.scatter2d(data_ph, c=sim['group'], s=size) +plot_numbers = np.repeat("", data_ph.shape[0]) +plot_numbers[most_distinct_points] = \ + np.arange(most_distinct_points.shape[0]) + 1 +bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + +sys.stdout = open('trash', 'w') +for i, txt in enumerate(plot_numbers): + ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props) + +sys.stdout = sys.__stdout__ + +# Based on intrinsic dimensionality. +highest_nbrs_dim_est = nbrs_dim_est.argsort()[-5:] +size = np.ones(data.shape[0]) +size[highest_nbrs_dim_est] = 50 +scprep.plot.scatter2d(data_ph, c=nbrs_dim_est, s=size) + +# Based on ranking of intrinsic dimensionality +scprep.plot.scatter2d(data_ph, c=nbrs_dim_est_ranks, s=size) + +############## +# CENTRALITY # +############## + +def _power_iteration(A, num_simulations): + # Ideally choose a random vector + # To decrease the chance that our vector + # Is orthogonal to the eigenvector + b_k = np.random.rand(A.shape[1]) + b_k = b_k[:, np.newaxis] + for _ in range(num_simulations): + # calculate the matrix-by-vector product Ab + b_k1 = np.dot(A, b_k) + # calculate the norm + b_k1_norm = np.linalg.norm(b_k1) + # re normalize the vector + b_k = b_k1 / b_k1_norm + return b_k + +kernel = phate_op.graph.kernel +centrality = _power_iteration(kernel.todense(), 100) +scprep.plot.scatter2d(data_ph, c=np.log(centrality), s=size) + +most_central_nn_indices = (-centrality).flatten().argsort()[0,:5].tolist()[0] + +size = np.ones(data.shape[0]) +size[most_central_nn_indices] = 50 +scprep.plot.scatter2d(data_ph, c=np.log(centrality), s=size) + +################### +# ASSIGN BRANCHES # +################### + +# Find coordinates between every point and every MDP. +all_dm_coords = diff_map +mdp_dm_coords = diff_map[most_distinct_points,:] +pairwise_dist = sp.spatial.distance.cdist(all_dm_coords, mdp_dm_coords) + +# For every point, rank MDPs by increasing distance. +s = np.argsort(pairwise_dist, axis=1) +i = np.arange(pairwise_dist.shape[0]).reshape(-1, 1) +j = np.arange(pairwise_dist.shape[1]) +mdp_ranking = np.empty_like(pairwise_dist, dtype=int) +mdp_ranking[i, s] = j + 1 + +# Assign every point to the branch between its two most highly ranked MDPs. +mdp_1 = np.argwhere(mdp_ranking==1)[:,1] + 1 +mdp_2 = np.argwhere(mdp_ranking==2)[:,1] + 1 +branch_classes = list(zip(mdp_1, mdp_2)) +branch_classes = [str(sorted(branch_class)) for branch_class in branch_classes] +ax = scprep.plot.scatter2d(data_ph, c=branch_classes) +plot_numbers = np.repeat("", data_ph.shape[0]) +plot_numbers[most_distinct_points] = \ + np.arange(most_distinct_points.shape[0]) + 1 +bbox_props = dict(boxstyle="circle,pad=0.3", fc="w", ec="r", lw=2) + +sys.stdout = open('trash', 'w') +for i, txt in enumerate(plot_numbers): + ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props) + +sys.stdout = sys.__stdout__ + +################# +# DELTA DIM EST # +################# + +diff_op_1 = phate_op.diff_op +diff_op_t = np.linalg.matrix_power(phate_op.diff_op, phate_op.optimal_t) +delta_dim_est = np.abs(diff_op_1.dot(dim_est) - diff_op_t.dot(dim_est)) +scprep.plot.scatter2d(data_ph, c=delta_dim_est, s=size) \ No newline at end of file diff --git a/Python/tutorial/branch_point.ipynb b/Python/tutorial/branch_point.ipynb new file mode 100644 index 0000000..5c5c269 --- /dev/null +++ b/Python/tutorial/branch_point.ipynb @@ -0,0 +1,662 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys, random, numpy as np, scipy as sp\n", + "import phate, scprep, graphtools\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.neighbors import NearestNeighbors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Add local development version of PHATE to python path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append(os.path.abspath('../phate'))\n", + "# sys.path = sys.path[:-2]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create test data" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "tree, branches = phate.tree.gen_dla(\n", + " n_dim = 200, n_branch = 10, branch_length = 300, rand_multiplier = 2, seed=37, sigma = 5\n", + ")\n", + "data = tree\n", + "clusters = branches" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating PHATE...\n", + " Running PHATE on 3000 observations and 200 variables.\n", + " Calculating graph and diffusion operator...\n", + " Calculating PCA...\n", + " Calculated PCA in 0.80 seconds.\n", + " Calculating KNN search...\n", + " Calculated KNN search in 0.40 seconds.\n", + " Calculating affinities...\n", + " Calculated affinities in 0.01 seconds.\n", + " Calculated graph and diffusion operator in 1.22 seconds.\n", + " Calculating landmark operator...\n", + " Calculating SVD...\n", + " Calculated SVD in 0.21 seconds.\n", + " Calculating KMeans...\n", + " Calculated KMeans in 2.03 seconds.\n", + " Calculated landmark operator in 2.55 seconds.\n", + " Calculating optimal t...\n", + " Automatically selected t = 54\n", + " Calculated optimal t in 2.74 seconds.\n", + " Calculating diffusion potential...\n", + " Calculated diffusion potential in 0.50 seconds.\n", + " Calculating metric MDS...\n", + " Calculated metric MDS in 1.82 seconds.\n", + "Calculated PHATE in 8.84 seconds.\n" + ] + } + ], + "source": [ + "phate_op = phate.PHATE()\n", + "data_ph = phate_op.fit_transform(data)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Predictor" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from branch_prediction import BranchPointPredictor" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit predictor" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "bpp = BranchPointPredictor(phate_op)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniforge/base/envs/mps/lib/python3.10/site-packages/scprep/plot/utils.py:104: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", + " fig.show()\n", + "/opt/homebrew/Caskroom/miniforge/base/envs/mps/lib/python3.10/site-packages/scprep/plot/utils.py:104: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", + " fig.show()\n" + ] + }, + { + "data": { + "text/html": [ + "
BranchPointPredictor(phate_op=PHATE())
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "BranchPointPredictor(phate_op=PHATE())" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bpp.fit(data_ph)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 6, 603, 247]), array(['[1, 3]', '[2, 3]'], dtype=' 2 * phate_op_eigvals_diff[n_eigvecs]):\n", + " n_eigvecs += 1\n", + "n_eigvecs" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# NOTE: this matches bpp.n_use\n", + "bpp.n_use" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# Find the extremas (min and max) of the considered eigenvectors.\n", + "# Keep them in the order of the eigenvalues by weaving min and max values.\n", + "# min_eigs = phate_op_eigvecs[:,1:n_eigvecs+1].argmin(0)\n", + "# max_eigs = phate_op_eigvecs[:,1:n_eigvecs+1].argmax(0)\n", + "# combined_eigs = np.empty((min_eigs.size + max_eigs.size,), dtype=min_eigs.dtype)\n", + "# combined_eigs[0::2] = min_eigs\n", + "# combined_eigs[1::2] = max_eigs\n", + "\n", + "# Remove duplicates.\n", + "\n", + "# for e in combined_eigs:\n", + "# if e not in most_distinct_points:\n", + "# most_distinct_points.append(e)\n", + "\n", + "most_distinct_points = []\n", + "\n", + "# Always skip the first trivial eigenvector\n", + "for i in np.arange(n_eigvecs):\n", + " cur_eigvec = np.copy(phate_op_eigvecs[:,i + 1])\n", + " # Sometimes the eigvectors are skewed towards one side (much more possitive values than negative values and vice versa). This part ensures only the extrema on the more significant side is taken.\n", + " lower_half_abs = np.percentile(np.abs(cur_eigvec), 50)\n", + " cur_eigvec[np.abs(cur_eigvec) < lower_half_abs] = 0\n", + " max_eig = np.argmax(cur_eigvec)\n", + " min_eig = np.argmin(cur_eigvec)\n", + " if cur_eigvec[max_eig] > 0 and max_eig not in most_distinct_points:\n", + " most_distinct_points.append(max_eig)\n", + " if cur_eigvec[min_eig] < 0 and min_eig not in most_distinct_points:\n", + " most_distinct_points.append(min_eig)\n", + "\n", + "most_distinct_points = np.array(most_distinct_points)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# These extremas could contain branch points but \n", + "# We will classify them based on their intrinsic dimensionality.\n", + "\n", + "#######################\n", + "# INTRINSIC DIMENSION #\n", + "#######################\n", + "\n", + "# Based on maxLikPointwiseDimEst() of this R package.\n", + "# https://cran.r-project.org/web/packages/intrinsicDimension/README.html\n", + "\n", + "# Up to 100 dimensions of diffusion maps, \n", + "# raised to the same power as tdetermined by PHATE.\n", + "dm_dims = min(data.shape[1], 100)\n", + "diff_map = phate_op_eigvecs[:,:dm_dims]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**NOTE** change from current code in `./branch_prediction.py` as that implementation doesn't handle landmark operators" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((1840, 100), (3000, 100))" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diff_map.shape, (bpp.pmn @ diff_map).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "diff_map = (bpp.pmn @ diff_map)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# diff_map = diff_map.dot(np.diag(np.power(phate_op_eigvals[:dm_dims], 11)))\n", + "\n", + "# Rank all neighbors in diffusion map coordinates.\n", + "nbrs = NearestNeighbors(\n", + " # n_neighbors=dm_dims,\n", + " n_neighbors=diff_map.shape[0],\n", + " algorithm='ball_tree'\n", + " ).fit(diff_map)\n", + "nn_distances, nn_indices = nbrs.kneighbors(diff_map)\n", + "nn_distances = nn_distances[:,1:]\n", + "nn_indices = nn_indices[:,1:]\n", + "\n", + "# Maximum Likelihood pointwise dimensionality estimation\n", + "# Hill (1975), Levina and Bickel (2005)\n", + "row_max = np.max(nn_distances, axis=1)\n", + "row_max = row_max.reshape(len(row_max), 1)\n", + "dim_est = np.sum(np.log(row_max / nn_distances), axis=1)\n", + "\n", + "# Calculate the average dim_est of local neighborhood.\n", + "n_nbrs = min(data.shape[0] // 20, 100)\n", + "nbrs_dim_est = np.average(dim_est[nn_indices[:,:n_nbrs]], axis=1)\n", + "\n", + "# Calculate ranking of neighborhood dim_est, from low to high\n", + "temp = nbrs_dim_est.argsort()\n", + "nbrs_dim_est_ranks = np.empty_like(temp)\n", + "nbrs_dim_est_ranks[temp] = np.arange(len(nbrs_dim_est))\n", + "\n", + "# Make sure that all distinct points are end points (low dim_est), not branch point (high dim_est)\n", + "low_dim_est_mask = nbrs_dim_est_ranks[most_distinct_points] < data.shape[0] // 2\n", + "most_distinct_points = most_distinct_points[low_dim_est_mask]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: copy-pasted my code from `phate.branch_prediction.py`\n", + "# to handle landmarked graph\n", + "is_landmarked = True\n", + "\n", + "##################################\n", + "# DIFFUSING DIRAC FOR END POINTS #\n", + "##################################\n", + "\n", + "branch_points = []\n", + "classes = np.zeros(data.shape[0], dtype=\"int32\")\n", + "classes_value = np.repeat(-float('inf'), data.shape[0])\n", + "for end_point_index in np.arange(most_distinct_points.size):\n", + " cur_end_point = most_distinct_points[end_point_index]\n", + "\n", + "\n", + " # NOTE: begin change\n", + " if is_landmarked:\n", + " undo_diff = (bpp.pmn @ phate_op.diff_op @ bpp.pnm)\n", + " diff_op_t = np.linalg.matrix_power(undo_diff, phate_op.optimal_t)\n", + " else:\n", + " diff_op_t = np.linalg.matrix_power(phate_op.diff_op, phate_op.optimal_t) \n", + " # NOTE: end change\n", + " # NOTE: original\n", + " # diff_op_t = np.linalg.matrix_power(phate_op.diff_op, phate_op.optimal_t)\n", + " \n", + " \n", + " branch_point_dim_est_avg_cache = -float('inf')\n", + " for it in range(20):\n", + " branch_from_end_point = diff_op_t[:,cur_end_point]\n", + " branch_max = np.max(branch_from_end_point)\n", + " branch_min = np.min(branch_from_end_point)\n", + " branch_threshold = branch_min + (branch_max - branch_min) * 0.2\n", + " deviation_from_branch_threshold = \\\n", + " branch_from_end_point - branch_threshold\n", + " deviation_from_branch_threshold[deviation_from_branch_threshold < 0] = \\\n", + " float('inf')\n", + " cur_branch_point = deviation_from_branch_threshold.argmin()\n", + " potential_branch_points = \\\n", + " np.argpartition(deviation_from_branch_threshold, 20)[:20]\n", + " branch_point_dim_est_avg = \\\n", + " np.average(nbrs_dim_est[potential_branch_points])\n", + " if (branch_point_dim_est_avg < branch_point_dim_est_avg_cache):\n", + " break\n", + " branch_point_dim_est_avg_cache = branch_point_dim_est_avg\n", + "\n", + " # NOTE: begin change\n", + " if is_landmarked: \n", + " undo_diff = (bpp.pmn @ phate_op.diff_op @ bpp.pnm)\n", + " diff_op_t = diff_op_t.dot(undo_diff)\n", + " else:\n", + " diff_op_t = diff_op_t.dot(phate_op.diff_op)\n", + " # NOTE: end change\n", + "\n", + " # NOTE: original\n", + " # diff_op_t = diff_op_t.dot(phate_op.diff_op)\n", + " \n", + " branch_points.append(cur_branch_point)\n", + " on_branch_mask = diff_op_t[:,cur_end_point] > branch_threshold\n", + " color = diff_op_t[:,cur_end_point]\n", + " on_branch_mask[color < classes_value] = 0\n", + " color[np.logical_not(on_branch_mask)] = -np.max(color)\n", + " classes_value[on_branch_mask] = color[on_branch_mask]\n", + " classes[on_branch_mask] = end_point_index + 1\n", + " # ax = scprep.plot.scatter2d(data_ph, c=color)\n", + " # plot_numbers = np.repeat(\"\", data_ph.shape[0])\n", + " # plot_numbers[cur_end_point] = 'e'\n", + " # plot_numbers[cur_branch_point] = 'b'\n", + " # bbox_props = dict(boxstyle=\"circle,pad=0.3\", fc=\"w\", ec=\"r\", lw=2)\n", + " # sys.stdout = open('trash', 'w')\n", + " # for i, txt in enumerate(plot_numbers):\n", + " # ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props)\n", + " # sys.stdout = sys.__stdout__" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "#####################\n", + "# REMOVE DUPLICATES #\n", + "#####################\n", + "# We want to remove branch points that are too close together.\n", + "\n", + "branch_points = np.array(branch_points)\n", + "branch_point_nbrs = nn_indices[branch_points,:n_nbrs]\n", + "branch_point_pairs_mask = np.isin(branch_point_nbrs, branch_points)\n", + "center_branch_point = branch_points[np.where(branch_point_pairs_mask)[0]]\n", + "neighbor_branch_point = branch_point_nbrs[branch_point_pairs_mask]\n", + "branch_point_pairs = list(zip(center_branch_point, neighbor_branch_point))\n", + "\n", + "# For each pair of branch_points, keep only the one with higher eigenvalue.\n", + "# (mdb_pairs, by construction, is sorted by decreasing eigenvalue corresponding \n", + "# to the first point of each pair.)\n", + "points_to_exclude = []\n", + "for pair in branch_point_pairs:\n", + " if pair[0] not in points_to_exclude:\n", + " points_to_exclude.append(pair[1])\n", + "\n", + "branch_points = np.delete(branch_points,\n", + " np.argwhere(np.isin(branch_points, points_to_exclude)))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniforge/base/envs/mps/lib/python3.10/site-packages/scprep/plot/utils.py:104: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "####################\n", + "# PLOTTING RESULTS #\n", + "####################\n", + "\n", + "# Plot by class with end points and branch points\n", + "ax = scprep.plot.scatter2d(data_ph, c=classes)\n", + "plot_numbers = np.repeat(\"\", data_ph.shape[0])\n", + "plot_numbers[most_distinct_points] = \\\n", + " np.arange(most_distinct_points.shape[0]) + 1\n", + "plot_numbers[branch_points] = \"*\"\n", + "bbox_props = dict(boxstyle=\"circle,pad=0.3\", fc=\"w\", ec=\"r\", lw=2)\n", + "\n", + "# sys.stdout = open('trash', 'w')\n", + "for i, txt in enumerate(plot_numbers):\n", + " ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props)\n", + "\n", + "# sys.stdout = sys.__stdout__" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniforge/base/envs/mps/lib/python3.10/site-packages/scprep/plot/utils.py:104: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "###################\n", + "# ASSIGN BRANCHES #\n", + "###################\n", + "\n", + "# Find coordinates between every point and every MDP.\n", + "all_dm_coords = diff_map\n", + "mdp_dm_coords = diff_map[most_distinct_points,:]\n", + "pairwise_dist = sp.spatial.distance.cdist(all_dm_coords, mdp_dm_coords)\n", + "\n", + "# For every point, rank MDPs by increasing distance.\n", + "s = np.argsort(pairwise_dist, axis=1)\n", + "i = np.arange(pairwise_dist.shape[0]).reshape(-1, 1)\n", + "j = np.arange(pairwise_dist.shape[1])\n", + "mdp_ranking = np.empty_like(pairwise_dist, dtype=int)\n", + "mdp_ranking[i, s] = j + 1\n", + "\n", + "# Assign every point to the branch between its two most highly ranked MDPs.\n", + "mdp_1 = np.argwhere(mdp_ranking==1)[:,1] + 1\n", + "mdp_2 = np.argwhere(mdp_ranking==2)[:,1] + 1\n", + "branch_classes = list(zip(mdp_1, mdp_2))\n", + "branch_classes = [str(sorted(branch_class)) for branch_class in branch_classes]\n", + "ax = scprep.plot.scatter2d(data_ph, c=branch_classes)\n", + "plot_numbers = np.repeat(\"\", data_ph.shape[0])\n", + "plot_numbers[most_distinct_points] = \\\n", + " np.arange(most_distinct_points.shape[0]) + 1\n", + "bbox_props = dict(boxstyle=\"circle,pad=0.3\", fc=\"w\", ec=\"r\", lw=2)\n", + "\n", + "# sys.stdout = open('trash', 'w')\n", + "for i, txt in enumerate(plot_numbers):\n", + " ax.annotate(txt, (data_ph[i][0], data_ph[i][1]), size=15, bbox=bbox_props)\n", + "\n", + "# sys.stdout = sys.__stdout__\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mps", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}