From 6499b6836be2fe61f3ae2c552d40cc4a47634bfc Mon Sep 17 00:00:00 2001 From: ejohnson643 Date: Sun, 31 Oct 2021 08:54:39 -0500 Subject: [PATCH] Fixed bug in kNN graph loader where the wrong object was called when more neighbors were queried. --- EMBEDR/embedr.py | 6 +- EMBEDR/nearest_neighbors.py | 78 +++++---- .../EMBEDR_Figure_01v1_DimRed_Zoology.py | 38 +++-- .../EMBEDR_Figure_01v1_DimRed_Zoology.ipynb | 148 ++++-------------- 4 files changed, 110 insertions(+), 160 deletions(-) diff --git a/EMBEDR/embedr.py b/EMBEDR/embedr.py index 1cf276e..d75bcc3 100644 --- a/EMBEDR/embedr.py +++ b/EMBEDR/embedr.py @@ -20,7 +20,7 @@ import scipy.stats as st from sklearn.utils import check_array, check_random_state from umap import UMAP - +import warnings class EMBEDR(object): @@ -753,6 +753,7 @@ def load_kNN_graph(self, ## If a path has been found to a matching kNN graph load it! with open(kNN_path, 'rb') as f: kNNObj = pkl.load(f) + kNNObj.verbose = self.verbose ## If the kNN is an ANNOY object, try to load the ANNOY index using the ## current project directory. @@ -774,7 +775,7 @@ def load_kNN_graph(self, print_str += f"... not enough neighbors, querying for more!" print(print_str) - idx, dst = out.query(X, self._max_nn + 1) + idx, dst = kNNObj.query(X, self._max_nn + 1) kNNObj.kNN_dst = dst[:, 1:] kNNObj.kNN_idx = idx[:, 1:] @@ -1004,6 +1005,7 @@ def load_affinity_matrix(self, ## If a path has been found to a matching kNN graph load it! with open(aff_path, 'rb') as f: affObj = pkl.load(f) + affObj.verbose = self.verbose if self.verbose >= 3: print(f"Affinity matrix successfully loaded!") diff --git a/EMBEDR/nearest_neighbors.py b/EMBEDR/nearest_neighbors.py index 34272a9..1f5402f 100644 --- a/EMBEDR/nearest_neighbors.py +++ b/EMBEDR/nearest_neighbors.py @@ -224,10 +224,11 @@ def __init__(self, def fit(self, X, k_NN): - timer_str = f"Finding {k_NN} nearest neighbors using an exact search" - timer_str += f" and the {self.metric} metric..." - timer = utl.Timer(timer_str, verbose=self.verbose) - timer.__enter__() + if self.verbose: + timer_str = f"Finding {k_NN} nearest neighbors using an exact" + timer_str += f" search and the {self.metric} metric..." + timer = utl.Timer(timer_str, verbose=self.verbose) + timer.__enter__() ## Get the data shape self.n_samples, self.n_features = X.shape[0], X.shape[1] @@ -241,7 +242,8 @@ def fit(self, X, k_NN): ## Return the indices and distances of the k_NN nearest neighbors. distances, NN_idx = self.index.kneighbors(n_neighbors=k_NN) - timer.__exit__() + if self.verbose: + timer.__exit__() self.kNN_idx = NN_idx[:, :] self.kNN_dst = distances[:, :] @@ -261,18 +263,20 @@ def query(self, query, k_NN): NFE.args[0] = err_str + "\n\n" + NFE.args[0] raise NFE - timer_str = f"Finding {k_NN} nearest neighbors in an existing kNN" - timer_str += f" graph using an exact search and the {self.metric}" - timer_str += f" metric..." - timer = utl.Timer(timer_str, verbose=self.verbose) - timer.__enter__() + if self.verbose: + timer_str = f"Finding {k_NN} nearest neighbors in an existing kNN" + timer_str += f" graph using an exact search and the {self.metric}" + timer_str += f" metric..." + timer = utl.Timer(timer_str, verbose=self.verbose) + timer.__enter__() ## Find the indices and distances to the nearest neighbors of the ## queried points distances, NN_idx = self.index.kneighbors(query, n_neighbors=k_NN) ## Stop the watch - timer.__exit__() + if self.verbose: + timer.__exit__() ## Return the indices of the nearest neighbors to the queried points ## *in the original graph* and the distances to those points. @@ -367,10 +371,11 @@ def __init__(self, def fit(self, X, k_NN): - timer_str = f"Finding {k_NN} nearest neighbors using an approximate" - timer_str += f" search and the {self.metric} metric..." - timer = utl.Timer(timer_str, verbose=self.verbose) - timer.__enter__() + if self.verbose: + timer_str = f"Finding {k_NN} nearest neighbors using an" + timer_str += f" approximate search and the {self.metric} metric..." + timer = utl.Timer(timer_str, verbose=self.verbose) + timer.__enter__() X = check_array(X, accept_sparse=True, ensure_2d=True) @@ -416,7 +421,8 @@ def getnns(ii): Parallel(n_jobs=self.n_jobs, require="sharedmem")( delayed(getnns)(ii) for ii in range(self.n_samples)) - timer.__exit__() + if self.verbose: + timer.__exit__() self.kNN_idx = NN_idx[:, :] self.kNN_dst = distances[:, :] @@ -438,11 +444,12 @@ def query(self, query, k_NN): err_str += f" constructed! (Run kNNIndex.fit(X, k_NN))" raise ValueError(err_str) - timer_str = f"Finding {k_NN} nearest neighbors to query points in" - timer_str += f" existing kNN graph using an approximate search and the" - timer_str += f" '{self.metric}'' metric..." - timer = utl.Timer(timer_str, verbose=self.verbose) - timer.__enter__() + if self.verbose: + timer_str = f"Finding {k_NN} nearest neighbors to query points in" + timer_str += f" existing kNN graph using an approximate search and" + timer_str += f" the '{self.metric}'' metric..." + timer = utl.Timer(timer_str, verbose=self.verbose) + timer.__enter__() ## Check query shape, if 1D array, reshape. if query.ndim == 1: @@ -480,7 +487,8 @@ def getnns(ii): delayed(getnns)(ii) for ii in range(n_query) ) - timer.__exit__() + if self.verbose: + timer.__exit__() return NN_idx, distances @@ -673,10 +681,11 @@ def check_metric(self, metric): def fit(self, X, k_NN): - timer_str = f"Finding {k_NN} approximate nearest neighbors using" - timer_str += f" NNDescent and the '{self.metric}' metric..." - timer = utl.Timer(timer_str, verbose=self.verbose) - timer.__enter__() + if self.verbose: + timer_str = f"Finding {k_NN} approximate nearest neighbors using" + timer_str += f" NNDescent and the '{self.metric}' metric..." + timer = utl.Timer(timer_str, verbose=self.verbose) + timer.__enter__() ## Get the data shape self.n_samples, self.n_features = X.shape[0], X.shape[1] @@ -739,7 +748,8 @@ def fit(self, X, k_NN): raise ValueError(err_str) - timer.__exit__() + if self.verbose: + timer.__exit__() # return NN_idx[:, 1:], distances[:, 1:] self.kNN_idx = NN_idx[:, 1:] @@ -756,15 +766,17 @@ def query(self, query, k_NN): err_str += f" constructed! (Run kNNIndex.fit(X, k_NN))" raise ValueError(err_str) - timer_str = f"Finding {k_NN} approximate nearest neighbors to query " - timer_str += f" points in the existing NN graph using `pynndescent`" - timer_str += f" and the '{self.metric}' metric..." - timer = utl.Timer(timer_str, verbose=self.verbose) - timer.__enter__() + if self.verbose: + timer_str = f"Finding {k_NN} approximate nearest neighbors to" + timer_str += f" query points in the existing NN graph using" + timer_str += f" `pynndescent` and the '{self.metric}' metric..." + timer = utl.Timer(timer_str, verbose=self.verbose) + timer.__enter__() NN_idx, distances = self.index.query(query, k=k_NN) - timer.__exit__() + if self.verbose: + timer.__exit__() return NN_idx, distances diff --git a/EMBEDR/plots/EMBEDR_Figure_01v1_DimRed_Zoology.py b/EMBEDR/plots/EMBEDR_Figure_01v1_DimRed_Zoology.py index 5c627a5..17d95c0 100644 --- a/EMBEDR/plots/EMBEDR_Figure_01v1_DimRed_Zoology.py +++ b/EMBEDR/plots/EMBEDR_Figure_01v1_DimRed_Zoology.py @@ -49,18 +49,22 @@ def make_figure(X, cluster_labels, clusters_2_label=None, label_colors=None, if label_colors is None: cblind_cmap = sns.color_palette('colorblind') - l2cl = {cl: (ii + 3) % 10 for ii, cl in enumerate(clust_2_label)} - label_colors = [cblind_cmap[l2cl[ll]] if (ll in clust_2_label) - else 'lightgrey' for ll in labels] + l2cl = {cl: (ii + 3) % 10 + for ii, cl in enumerate(clusters_2_label)} + label_colors = [cblind_cmap[l2cl[ll]] if (ll in clusters_2_label) + else 'lightgrey' for ll in cluster_labels.squeeze()] + label_colors = np.asarray(label_colors) if label_sizes is None: - label_sizes = [3 if (ll in clust_2_label) else 1 for ll in labels] + label_sizes = [3 if (ll in clusters_2_label) else 1 + for ll in cluster_labels] + label_sizes = np.asarray(label_sizes) if DRAs is None: ## Set parameters at which to plot data - DRAs = [('tSNE', 7), + DRAs = [('tSNE', 9), ('UMAP', 15), - ('tSNE', 250), + ('tSNE', 350), ('UMAP', 400)] if project_name is None: @@ -89,11 +93,23 @@ def make_figure(X, cluster_labels, clusters_2_label=None, label_colors=None, **EMBEDR_params) Y, _ = embObj.get_tSNE_embedding(X) + if alg.lower() in ['umap']: + embObj = EMBEDR(X=X, + n_neighbors=param, + DRA='umap', + n_data_embed=1, + n_jobs=-1, + project_name=project_name, + project_dir=project_dir, + **EMBEDR_params) + Y, _ = embObj.get_UMAP_embedding(X) + rowNo = int(algNo / n_cols) colNo = int(algNo % n_cols) ax = main_axes[rowNo][colNo] - add_plot_color_by_cluster(Y, cluster_labels) + add_plot_color_by_cluster(Y[0], cluster_labels, ax, label_colors, + label_sizes, clusters_2_label) return @@ -128,7 +144,7 @@ def set_main_grid(fig_wid=7.2, fig_hgt=5.76, n_rows=2, n_cols=2, def add_plot_color_by_cluster(Y, cluster_labels, ax, label_colors, label_sizes, - clusters_2_label): + clusters_2_label, scatter_alpha=0.2): ax.scatter(*Y.T, c=label_colors, @@ -136,7 +152,7 @@ def add_plot_color_by_cluster(Y, cluster_labels, ax, label_colors, label_sizes, alpha=scatter_alpha) for cNo, cluster in enumerate(clusters_2_label): - good_idx = (cluster_labels == clusters) + good_idx = (cluster_labels == cluster).squeeze() cluster_median = np.median(Y[good_idx], axis=0) @@ -329,8 +345,8 @@ def add_plot_color_by_cluster(Y, cluster_labels, ax, label_colors, label_sizes, cell_ont_ids = sorted(cell_ont_ids, key=lambda cO: -cell_ont_counts[cO]) - cell_ont_labels = [f"{cO} (N = {cell_ont_counts[cO]})" - for cO in cell_ont_ids] + cell_ont_labels = np.asarray([f"{cO} (N = {cell_ont_counts[cO]})" + for cO in cell_ont_ids]) cell_ont_cmap = sns.color_palette('husl', len(cell_ont_ids)) diff --git a/projects/Figures/EMBEDR_Figure_01v1_DimRed_Zoology.ipynb b/projects/Figures/EMBEDR_Figure_01v1_DimRed_Zoology.ipynb index 1fd2366..a4e7d1e 100644 --- a/projects/Figures/EMBEDR_Figure_01v1_DimRed_Zoology.ipynb +++ b/projects/Figures/EMBEDR_Figure_01v1_DimRed_Zoology.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 1, "id": "f0301b81-cffd-4f86-ac9a-3ff43ff30e32", "metadata": {}, "outputs": [], @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "id": "c44db56c-cf98-475d-8dcc-cb71e217f9df", "metadata": {}, "outputs": [], @@ -73,7 +73,7 @@ "n_jobs = -1\n", "\n", "## Data directory\n", - "data_dir = f\"../../data/tabula-muris/\"\n", + "data_dir = f\"../../data/TabulaMuris/\"\n", "\n", "## Figure directory\n", "fig_dir = f\"./\"\n", @@ -94,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "120c3c28-8cc6-45e0-bfe1-f37b6403ba22", "metadata": {}, "outputs": [ @@ -102,12 +102,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Input data `X` is 4771 x 50!\n" + "Input data `X` is 5037 x 50!\n" ] } ], "source": [ - "data = sc.read_h5ad(os.path.join(data_dir, f\"04_facs_processed_data/{seq_type}/Processed_{tissue.title()}.h5ad\"))\n", + "data = sc.read_h5ad(os.path.join(data_dir, f\"{seq_type}/Processed_{tissue.title()}.h5ad\"))\n", "data.obs.head()\n", "\n", "X = data.obsm['X_pca']\n", @@ -173,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 69, "id": "7b60463f-c312-4e37-bed7-1604d20a41e7", "metadata": {}, "outputs": [], @@ -183,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 70, "id": "b7b7ba9a", "metadata": {}, "outputs": [], @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 34, "id": "1cc90167", "metadata": {}, "outputs": [ @@ -211,114 +211,56 @@ "\n", "\n" ] - } - ], - "source": [ - "%run ../../EMBEDR/plots/EMBEDR_Figure_01v1_DimRed_Zoology.py" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "408982eb", - "metadata": {}, - "outputs": [ + }, { "data": { "text/plain": [ - "cell_ontology_class\n", - "B cell 44\n", - "Slamf1-negative multipotent progenitor cell 713\n", - "Slamf1-positive multipotent progenitor cell 134\n", - "basophil 25\n", - "common lymphoid progenitor 156\n", - "granulocyte 761\n", - "granulocyte monocyte progenitor cell 134\n", - "granulocytopoietic cell 221\n", - "hematopoietic precursor cell 265\n", - "immature B cell 344\n", - "immature NK T cell 37\n", - "immature T cell 60\n", - "immature natural killer cell 36\n", - "late pro-B cell 306\n", - "macrophage 173\n", - "mature natural killer cell 49\n", - "megakaryocyte-erythroid progenitor cell 55\n", - "monocyte 266\n", - "naive B cell 692\n", - "pre-natural killer cell 22\n", - "precursor B cell 517\n", - "regulatory T cell 27\n", - "Name: cell_ontology_class, dtype: int64" + "
" ] }, - "execution_count": 54, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "# cell_ont_meta\n", - "# cell_ont_ids\n", - "cell_ont_counts" + "%run ../../EMBEDR/plots/EMBEDR_Figure_01v1_DimRed_Zoology.py" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 74, "id": "dbf01928", "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "e8c10905", - "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "EMBEDR_Figure_01v1_DimRed_Zoology.ipynb\r\n", - "\u001b[34mEMBEDR_project\u001b[m\u001b[m/\r\n" + "/Users/EricJohnson/opt/anaconda3/envs/EMBEDR/lib/python3.9/site-packages/numpy/core/_asarray.py:102: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return array(a, dtype, copy=False, order=order)\n" ] - } - ], - "source": [ - "\"../../data/TabulaMuris/FACS/Processed_Marrow.h5ad\"" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "2156ba1c", - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "This works?\n", "\n", - "This works!\n" + "Plotting tSNE embedding (param = 9)\n", + "\n", + "\n", + "Plotting UMAP embedding (param = 15)\n", + "\n", + "\n", + "Plotting tSNE embedding (param = 350)\n", + "\n", + "\n", + "Plotting UMAP embedding (param = 400)\n", + "\n" ] - } - ], - "source": [ - "F01.test_function()" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "fe7522d7", - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -328,36 +270,14 @@ } ], "source": [ - "fig, back_axis, main_gs, main_axes = F01.set_main_grid()" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "c9d38ed5", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "make_figure() missing 2 required positional arguments: 'X' and 'cluster_labels'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/_v/n82vwlfd3wg7_t3361n20xhr0000gn/T/ipykernel_81858/1555668879.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mF01\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m: make_figure() missing 2 required positional arguments: 'X' and 'cluster_labels'" - ] - } - ], - "source": [ - "\n", - "F01.make_figure(X, data.obs)" + "cluster_labels = np.asarray([cell_ont_map[cId] for cId in cell_ont_meta]).reshape(-1, 1)\n", + "F01.make_figure(X, cluster_labels, EMBEDR_params={'verbose':0})" ] }, { "cell_type": "code", "execution_count": null, - "id": "7f2cc201", + "id": "232a8db4", "metadata": {}, "outputs": [], "source": []