diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d81fea0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ + +# Jupyter Notebook +.ipynb_checkpoints diff --git a/GSFA/GSFA_time_complexity.R b/GSFA/GSFA_time_complexity.R new file mode 100644 index 0000000..c2104f4 --- /dev/null +++ b/GSFA/GSFA_time_complexity.R @@ -0,0 +1,43 @@ +library(data.table) +library(tidyverse) +library(Matrix) +library(GSFA) +library(ggplot2) + +install.packages('reticulate') +library(reticulate) +use_python("/usr/bin/python3") +py_discover_config() +np <- import("numpy") + +npz <- np$load("inhouse_GSFA_inputs.npz", allow_pickle=TRUE) +Y <- npz$get("array1") +G <- npz$get("array2") + +print(dim(Y)) +print(dim(G)) +print("loaded data") + +dev_res <- deviance_residual_transform(Y) +top_gene_index <- select_top_devres_genes(dev_res, num_top_genes = 6000) +dev_res_filtered <- dev_res[, top_gene_index] + +write.csv(top_gene_index, "inhouse_top_genes.csv") +rm(npz) +rm(Y) +print(dim(dev_res_filtered)) +print("processed data") + +set.seed(14314) +time_start = Sys.time() +num_cells = 5000 +fit <- fit_gsfa_multivar(Y = dev_res_filtered[1:num_cells,], G = G[1:num_cells,], + K = 20, + prior_type = "mixture_normal", + init.method = "svd", + niter = 3000, used_niter = 1000, + verbose = T, return_samples = T) +print(Sys.time()-time_start) +rm(G) +rm(dev_res_filtered) +saveRDS(fit, file = "fitted_inhouse.rds") diff --git a/GSFA/README.md b/GSFA/README.md new file mode 100644 index 0000000..2c130cf --- /dev/null +++ b/GSFA/README.md @@ -0,0 +1,8 @@ +# GSFA[(Guided Sparse Factor Analysis)] (Guided Sparse Factor Analysis) + +``` +Yifan Zhou, Kaixuan Luo, Lifan Liang, Mengjie Chen and Xin He. A new Bayesian factor analysis method improves detection of genes and biological processes affected by perturbations in single-cell CRISPR screening. Nature Methods. (2023). doi: 10.1038/s41592-023-02017-4. PMID: 37770710 +``` + +Training scripts for GSFA to use as a benchmark. +Link to paper: [paper](https://www.nature.com/articles/s41592-023-02017-4) diff --git a/GSFA/inhouse_GSFA.R b/GSFA/inhouse_GSFA.R new file mode 100644 index 0000000..835982d --- /dev/null +++ b/GSFA/inhouse_GSFA.R @@ -0,0 +1,46 @@ +library(data.table) +library(tidyverse) +library(Matrix) +library(GSFA) +library(ggplot2) + +install.packages('reticulate') +library(reticulate) +use_python("/usr/bin/python3") +py_discover_config() +np <- import("numpy") + +# read in inputs generated by inhouse_gsfa_preprocessing.ipynb +npz <- np$load("inhouse_GSFA_inputs.npz", allow_pickle=TRUE) +Y <- npz$get("array1") +G <- npz$get("array2") + +print(dim(Y)) +print(dim(G)) +print("loaded data") + +# GSFA-specific preprocessing of gene expression +dev_res <- deviance_residual_transform(Y) +top_gene_index <- select_top_devres_genes(dev_res, num_top_genes = 6000) +dev_res_filtered <- dev_res[, top_gene_index] +# save for downstream analysis +np$savez("inhouse_GSFA_preprocessed.npz", array1 = dev_res_filtered) +write.csv(top_gene_index, "inhouse_top_genes.csv") +rm(npz) +rm(Y) +print(dim(dev_res_filtered)) +print("processed data") + +# train and save GSFA model +set.seed(14314) +time_start = Sys.time() +fit <- fit_gsfa_multivar(Y = dev_res_filtered, G = G, + K = 20, + prior_type = "mixture_normal", + init.method = "svd", + niter = 3000, used_niter = 1000, + verbose = T, return_samples = T) +print(Sys.time()-time_start) +rm(G) +rm(dev_res_filtered) +saveRDS(fit, file = "fitted_inhouse.rds") diff --git a/GSFA/inhouse_gsfa_preprocessing.ipynb b/GSFA/inhouse_gsfa_preprocessing.ipynb new file mode 100644 index 0000000..eb47346 --- /dev/null +++ b/GSFA/inhouse_gsfa_preprocessing.ipynb @@ -0,0 +1,249 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "0c3f7ba9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dfbdfee5", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "sys.path.append(\"..\")\n", + "from src.Spectra.Spectra_Pert import vectorize_perts\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " generate_k_fold,\n", + " inhouse_preprocess,\n", + " read_aws_h5ad,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "426b0898-25f4-492b-b77c-d9f1fc17010f", + "metadata": {}, + "source": [ + "### Get train/test splits consistent with other models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dd10044-66e2-41c3-a724-282c4792f6d8", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/inhouse_prior_graph_preprocessing.ipynb\n", + "unfilterd_adata = read_aws_h5ad(\"path to preprocessed h5ad here\")\n", + "adata = filter_noisy_genes(unfilterd_adata)\n", + "adata = inhouse_preprocess(adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d7e163dc-2a94-41de-b7f5-f717ac47fb4a", + "metadata": {}, + "outputs": [], + "source": [ + "# powered perturbations\n", + "adata.obs[\"condition\"] = adata.obs[\"condition\"].astype(str)\n", + "adata.obs[\"Treatment\"] = adata.obs[\"Treatment\"].astype(str)\n", + "adata.obs[\"pert_treat\"] = adata.obs[\"condition\"] + \"+\" + adata.obs[\"Treatment\"]\n", + "obs_df = pd.DataFrame(adata.obs[\"pert_treat\"])\n", + "category_counts = obs_df[\"pert_treat\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"pert_treat\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2e20577d-23ec-4336-a3f5-8fcae53252a8", + "metadata": {}, + "outputs": [], + "source": [ + "train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata, adata.X, adata.obs[\"condition\"], fold_idx=0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "431abcfa-4929-4c0c-8651-c1f9c35f37f2", + "metadata": {}, + "source": [ + "### Process GSFA-specifc input" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96e401f3", + "metadata": {}, + "outputs": [], + "source": [ + "# use inhouse dataset from s3://pert-spectra\n", + "adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/rnaseq565.filtered.actionet.guide_corrected.h5ad\"\n", + ")\n", + "adata = inhouse_preprocess(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "76e4b5e7", + "metadata": {}, + "outputs": [], + "source": [ + "# filter adata to perturbations with at least 50 samples for each treatment\n", + "adata.obs[\"condition\"] = adata.obs[\"condition\"].astype(str)\n", + "adata.obs[\"Treatment\"] = adata.obs[\"Treatment\"].astype(str)\n", + "adata.obs[\"pert_treat\"] = adata.obs[\"condition\"] + \"+\" + adata.obs[\"Treatment\"]\n", + "obs_df = pd.DataFrame(adata.obs[\"pert_treat\"])\n", + "category_counts = obs_df[\"pert_treat\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"pert_treat\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fdfbf4b", + "metadata": {}, + "outputs": [], + "source": [ + "# create binary perturbation matrix\n", + "D, pert_labels = vectorize_perts(adata, \"condition\", [\"ctrl\", \"nan\"])\n", + "pert_idx = np.array(\n", + " [\n", + " adata.var_names.get_loc(i.split(\"_\")[1])\n", + " if i.split(\"_\")[1] in adata.var_names\n", + " else -1\n", + " for i in pert_labels\n", + " ]\n", + ")\n", + "# add ctrl one-hot-encoding\n", + "ctrl_vector = np.array([1.0 if i == \"ctrl\" else 0.0 for i in adata.obs[\"condition\"]])\n", + "D = np.concatenate([D, ctrl_vector.reshape(len(ctrl_vector), 1)], axis=1).astype(\n", + " np.float32\n", + ")\n", + "pert_idx = np.append(pert_idx, [-1, -1])\n", + "pert_labels = pert_labels + [\"ctrl\"]\n", + "print(D.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4ac6b398", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to kfold and TNFA+ treatment\n", + "D_train = D[train_idx]\n", + "adata_train = adata[train_idx]\n", + "D_train = D_train[adata_train.obs[\"Treatment\"] == \"TNFA+\"]\n", + "adata_train = adata_train[adata_train.obs[\"Treatment\"] == \"TNFA+\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0eb35473", + "metadata": {}, + "outputs": [], + "source": [ + "# subset further for GSFA to run without OOM issues\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "Y, _, G, _ = train_test_split(\n", + " adata_train.layers[\"counts\"],\n", + " D_train,\n", + " test_size=0.2,\n", + " random_state=42,\n", + " stratify=D_train,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5d496dfd-bbdf-4e90-aba2-a224674d2876", + "metadata": {}, + "outputs": [], + "source": [ + "# save inputs for GSFA\n", + "np.savez(\"rna565_GSFA_inputs.npz\", array1=Y.todense(), array2=G)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c8d4ae72-33c8-4fe1-997b-47be95d0084b", + "metadata": {}, + "outputs": [], + "source": [ + "# save additional perturbation labels for downstream analysis\n", + "np.savez(\"rna565_G_labels.npz\", pert_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c76eeff-6cbb-4d30-a2ae-a336fd6e1794", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/GSFA/load_inhouse_GSFA.R b/GSFA/load_inhouse_GSFA.R new file mode 100644 index 0000000..95e5fe1 --- /dev/null +++ b/GSFA/load_inhouse_GSFA.R @@ -0,0 +1,13 @@ +fitted_rna565_GSFA <- readRDS("~/GSFA/fitted_rna565_GSFA.Rds") + +Z <- fitted_rna565_GSFA$posterior_means$Z_pm +beta <- fitted_rna565_GSFA$posterior_means$beta_pm +W <- fitted_rna565_GSFA$posterior_means$W_pm +F <- fitted_rna565_GSFA$posterior_means$F_pm +lsfr <- fitted_rna565_GSFA$lfsr + +write.csv(Z,"~/GSFA/rna565_gsfa_outputs/Z.csv") +write.csv(beta,"~/GSFA/rna565_gsfa_outputs/beta.csv") +write.csv(W,"~/GSFA/rna565_gsfa_outputs/W.csv") +write.csv(F,"~/GSFA/rna565_gsfa_outputs/F.csv") +write.csv(lsfr,"~/GSFA/rna565_gsfa_outputs/lsfr.csv") diff --git a/GSFA/load_norman_GSFA.R b/GSFA/load_norman_GSFA.R new file mode 100644 index 0000000..e06c2b6 --- /dev/null +++ b/GSFA/load_norman_GSFA.R @@ -0,0 +1,13 @@ +fitted_norman_GSFA <- readRDS("~/GSFA/fitted_norman_GSFA.rds") + +Z <- fitted_norman_GSFA$posterior_means$Z_pm +beta <- fitted_norman_GSFA$posterior_means$beta_pm +W <- fitted_norman_GSFA$posterior_means$W_pm +F <- fitted_norman_GSFA$posterior_means$F_pm +lsfr <- fitted_norman_GSFA$lfsr + +write.csv(Z,"~/GSFA/norman_gsfa_outputs/Z.csv") +write.csv(beta,"~/GSFA/norman_gsfa_outputs/beta.csv") +write.csv(W,"~/GSFA/norman_gsfa_outputs/W.csv") +write.csv(F,"~/GSFA/norman_gsfa_outputs/F.csv") +write.csv(lsfr,"~/GSFA/norman_gsfa_outputs/lsfr.csv") diff --git a/GSFA/norman_GSFA.R b/GSFA/norman_GSFA.R new file mode 100644 index 0000000..4b68e5a --- /dev/null +++ b/GSFA/norman_GSFA.R @@ -0,0 +1,46 @@ +library(data.table) +library(tidyverse) +library(Matrix) +library(GSFA) +library(ggplot2) + +install.packages('reticulate') +library(reticulate) +use_python("/usr/bin/python3") +py_discover_config() +np <- import("numpy") + +# read in inputs generated by norman_gsfa_preprocessing.ipynb +npz <- np$load("norman_GSFA_inputs.npz", allow_pickle=TRUE) +Y <- npz$get("array1") +G <- npz$get("array2") + +print(dim(Y)) +print(dim(G)) +print("loaded data") + +# GSFA-specific preprocessing of gene expression +dev_res <- deviance_residual_transform(Y) +top_gene_index <- select_top_devres_genes(dev_res, num_top_genes = 4000) +dev_res_filtered <- dev_res[, top_gene_index] +# save for downstream analysis +np$savez("norman_GSFA_preprocessed.npz", array1 = dev_res_filtered) +write.csv(top_gene_index, "norman_top_genes.csv") +rm(npz) +rm(Y) +print(dim(dev_res_filtered)) +print("processed data") + +# train and save GSFA model +set.seed(14314) +time_start = Sys.time() +fit <- fit_gsfa_multivar(Y = dev_res_filtered, G = G, + K = 20, + prior_type = "mixture_normal", + init.method = "svd", + niter = 3000, used_niter = 1000, + verbose = T, return_samples = T) +print(Sys.time()-time_start) +rm(G) +rm(dev_res_filtered) +saveRDS(fit, file = "fitted_norman.rds") diff --git a/GSFA/norman_gsfa_preprocessing.ipynb b/GSFA/norman_gsfa_preprocessing.ipynb new file mode 100644 index 0000000..9db834a --- /dev/null +++ b/GSFA/norman_gsfa_preprocessing.ipynb @@ -0,0 +1,242 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "id": "0c3f7ba9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "dfbdfee5", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "sys.path.append(\"..\")\n", + "from src.Spectra.Spectra_Pert import vectorize_perts\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " generate_k_fold,\n", + " read_aws_h5ad,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "15d54d79-721c-4e13-869d-b398460d7fb7", + "metadata": {}, + "source": [ + "### Get train/test split consistent with other models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1868a84f-9b4a-4853-8658-e597e027af94", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/norman_prior_graph_preprocessing.ipynb\n", + "unfiltered_adata = read_aws_h5ad(\"path to preprocessed h5ad here\")\n", + "adata = filter_noisy_genes(unfiltered_adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b62c8814-501e-4f9d-a5f9-f7ac30f16912", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to powered perturbations\n", + "obs_df = pd.DataFrame(adata.obs[\"perturbation_name\"])\n", + "category_counts = obs_df[\"perturbation_name\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"perturbation_name\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0ffce6f2-b975-40f6-ab97-0f676c5bb0d9", + "metadata": {}, + "outputs": [], + "source": [ + "# retrieve same data splits for consistency\n", + "train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata,\n", + " adata.X,\n", + " adata.obs[\"perturbation_name\"],\n", + " fold_idx=0,\n", + " perturbation_key=\"perturbation_name\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "347d91bf-eb3f-470b-8fff-956b1dedd41a", + "metadata": {}, + "source": [ + "### Process GSFA-specifc inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "96e401f3", + "metadata": {}, + "outputs": [], + "source": [ + "# use Norman dataset from https://github.com/theislab/sc-pert\n", + "adata = read_aws_h5ad(\"path to h5ad here\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "76e4b5e7", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to powered perturbations\n", + "obs_df = pd.DataFrame(adata.obs[\"perturbation_name\"])\n", + "category_counts = obs_df[\"perturbation_name\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"perturbation_name\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fdfbf4b", + "metadata": {}, + "outputs": [], + "source": [ + "# create binary perturbation matrix\n", + "D, pert_labels = vectorize_perts(adata, \"perturbation_name\", [\"control\", \"nan\"])\n", + "pert_idx = np.array(\n", + " [\n", + " adata.var_names.get_loc(i.split(\"_\")[1])\n", + " if i.split(\"_\")[1] in adata.var_names\n", + " else -1\n", + " for i in pert_labels\n", + " ]\n", + ")\n", + "# add ctrl one-hot-encoding\n", + "ctrl_vector = np.array(\n", + " [1.0 if i == \"control\" else 0.0 for i in adata.obs[\"perturbation_name\"]]\n", + ")\n", + "D = np.concatenate([D, ctrl_vector.reshape(len(ctrl_vector), 1)], axis=1).astype(\n", + " np.float32\n", + ")\n", + "pert_idx = np.append(pert_idx, [-1, -1])\n", + "pert_labels = pert_labels + [\"ctrl\"]\n", + "print(D.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4ac6b398", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to kfold\n", + "adata_train = adata[train_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0eb35473", + "metadata": {}, + "outputs": [], + "source": [ + "# subset further for GSFA to run without OOM issues\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "Y, _, G, _ = train_test_split(\n", + " adata_train.layers[\"counts\"],\n", + " D[train_idx],\n", + " test_size=0.70,\n", + " random_state=42,\n", + " stratify=D[train_idx],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5d496dfd-bbdf-4e90-aba2-a224674d2876", + "metadata": {}, + "outputs": [], + "source": [ + "# save inputs for GSFA\n", + "np.savez(\"norman_GSFA_inputs.npz\", array1=Y.todense(), array2=G)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c8d4ae72-33c8-4fe1-997b-47be95d0084b", + "metadata": {}, + "outputs": [], + "source": [ + "# save perturbation labels for downstream analysis\n", + "np.savez(\"norman_G_labels.npz\", pert_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17c84b85-395a-4b9c-adef-3b505a5b8fb0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..bcd8787 --- /dev/null +++ b/LICENSE @@ -0,0 +1 @@ +Copyright (C) 2024 Insitro, Inc. This software and any derivative works are licensed under the terms of the Creative Commons Attribution-NonCommercial 4.0 International Public License (CC-BY-NC 4.0), accessible at https://creativecommons.org/licenses/by-nc/4.0/legalcode diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..dd89917 --- /dev/null +++ b/Makefile @@ -0,0 +1,64 @@ +ENV_NAME=pertspectra +CONDA_BASE=$(shell conda run -n base conda info --base) +ENV_DIR=$(CONDA_BASE)/envs/$(ENV_NAME) + + +## Installation +.PHONY: check-conda +check-conda: +ifeq (,$(shell which conda)) + $(error "This project uses conda for environment management. Please install conda before continuing.") +endif + +check-conda-lock: +ifeq (,$(shell which conda-lock)) + $(error "conda-lock command not found, install with `pip install conda-lock`") +endif + +.PHONY: conda-lock +conda-lock: check-conda + pip install conda-lock && \ + conda-lock lock -f environment.yaml -p osx-64 -p linux-64 + +.PHONY: install-env +install-env: check-conda check-conda-lock + conda-lock install -p $(ENV_DIR) conda-lock.yml && \ + conda run -p $(ENV_DIR) python -m pip install -r requirements.txt + +.PHONY: install-pre-commit +install-pre-commit: + conda run -p $(ENV_DIR) pre-commit install + +.PHONY: jupyter-kernel +jupyter-kernel: + conda run -p $(ENV_DIR) $(ENV_DIR)/bin/pip install ipykernel + conda run -p $(ENV_DIR) $(ENV_DIR)/bin/ipython kernel install --user --name=$(ENV_NAME) + +install: install-env install-pre-commit jupyter-kernel + +## Linting + +.PHONY: format +format: + ruff check --fix + +.PHONY: type-check +type-check: + pre-commit run mypy --all-files + +.PHONY: lint +lint: + pre-commit run --all-files + + +## Testing +COVERAGE_REPORT_FILE=coverage.xml +PYTEST_REPORT_FILE=report.xml + +.PHONY: pytest +pytest: + pytest -v --junitxml $(PYTEST_REPORT_FILE) $(ENV_NAME) + +.PHONY: pytest-cov +pytest-cov: + pytest --cov $(PACKAGE_NAME) $(ENV_NAME) diff --git a/PertSpectra_load_checkpoints/pertspectra_inhouse.ipynb b/PertSpectra_load_checkpoints/pertspectra_inhouse.ipynb new file mode 100644 index 0000000..a57962c --- /dev/null +++ b/PertSpectra_load_checkpoints/pertspectra_inhouse.ipynb @@ -0,0 +1,432 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "65f8246a", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb2ff34c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seed set\n" + ] + } + ], + "source": [ + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import torch\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " generate_k_fold,\n", + " load_model,\n", + " read_aws_h5ad,\n", + " set_seed,\n", + " write_adata_to_s3,\n", + ")\n", + "\n", + "set_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "d6389804-10c8-4626-8982-bf994a98c18b", + "metadata": {}, + "source": [ + "## Load Model from Checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5280863b", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/inhouse_prior_graph_preprocessing.ipynb\n", + "unfilterd_adata = read_aws_h5ad(\"path to preprocessed h5ad\")\n", + "adata = filter_noisy_genes(unfilterd_adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "device = torch.device(\"cuda:0\")\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2972c1e4", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to powered perturbations\n", + "adata.obs[\"condition\"] = adata.obs[\"condition\"].astype(str)\n", + "adata.obs[\"Treatment\"] = adata.obs[\"Treatment\"].astype(str)\n", + "adata.obs[\"pert_treat\"] = adata.obs[\"condition\"] + \"+\" + adata.obs[\"Treatment\"]\n", + "obs_df = pd.DataFrame(adata.obs[\"pert_treat\"])\n", + "category_counts = obs_df[\"pert_treat\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"pert_treat\"].isin(filtered_categories)]\n", + "labels = adata.obs[\"Treatment\"].values" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0a65f48c", + "metadata": {}, + "outputs": [], + "source": [ + "# load model from checkpoint\n", + "s3_dir = \"s3://pert-spectra/PertSpectra_checkpoints/\"\n", + "experiment_name = \"pertspectra_inhouse/\"\n", + "model_name = \"kfold_4\"\n", + "wrapper, adata = load_model(\n", + " adata=adata,\n", + " s3_dir=s3_dir,\n", + " experiment_name=experiment_name,\n", + " model_name=model_name,\n", + " use_cell_types=True,\n", + " cell_type_key=\"Treatment\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "89206201", + "metadata": {}, + "outputs": [], + "source": [ + "# save trained PertSpectra parameters\n", + "adata.uns[\"SPECTRA_factors\"] = wrapper.factors\n", + "adata.uns[\"SPECTRA_L\"] = wrapper.internal_model.L\n", + "adata.uns[\"SPECTRA_pert_scores\"] = wrapper.cell_scores" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4d3a17dc", + "metadata": {}, + "outputs": [], + "source": [ + "# reconstruct binarized perturbation matrix\n", + "pert_idx = list(wrapper.internal_model.pert_idx)\n", + "pert_labels = [x.split(\"_\")[-1] for x in wrapper.internal_model.pert_labels]\n", + "adata.uns[\"Spectra_pert_labels\"] = pert_labels\n", + "D = []\n", + "for i in adata.obs[\"condition\"]:\n", + " d = [0.0 for _ in range(len(pert_idx))]\n", + " # add intercept\n", + " d[-1] = 1\n", + " if i == \"nan\":\n", + " D.append(d)\n", + " continue\n", + " # control\n", + " if i == \"ctrl\":\n", + " d[-2] = 1.0\n", + " D.append(d)\n", + " continue\n", + " guides = i.split(\"+\")\n", + "\n", + " # pert or intergenic\n", + " if guides[0] in adata.var_names:\n", + " adata_idx = adata.var_names.get_loc(guides[0])\n", + " one_hot_idx = pert_idx.index(adata_idx)\n", + " d[one_hot_idx] = 1.0\n", + " else:\n", + " one_hot_idx = pert_labels.index(guides[0])\n", + " d[one_hot_idx] = 1.0\n", + "\n", + " if len(guides) > 1:\n", + " if guides[1] in adata.var_names:\n", + " adata_idx = adata.var_names.get_loc(guides[1])\n", + " one_hot_idx = pert_idx.index(adata_idx)\n", + " d[one_hot_idx] = 1.0\n", + " else:\n", + " one_hot_idx = pert_labels.index(guides[1])\n", + " d[one_hot_idx] = 1.0\n", + " D.append(d)\n", + "D = np.stack(D).astype(np.float32)" + ] + }, + { + "cell_type": "markdown", + "id": "1a483a3b-44d7-455b-957e-b2b89ff527ff", + "metadata": {}, + "source": [ + "## Reconstructed Gene Expression\n", + "- Visualize reconstructed gene expression for a single perturbation\n", + "- Save reconstructed gene expression for all heldout cells" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "4184472e", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "SPECTRA(\n", + " (theta): ParameterDict(\n", + " (global): Parameter containing: [torch.cuda.FloatTensor of size 4997x20 (cuda:0)]\n", + " (TNFA+): Parameter containing: [torch.cuda.FloatTensor of size 4997x5 (cuda:0)]\n", + " (TNFA-): Parameter containing: [torch.cuda.FloatTensor of size 4997x5 (cuda:0)]\n", + " )\n", + " (alpha): ParameterDict(\n", + " (TNFA+): Parameter containing: [torch.cuda.FloatTensor of size 24x25 (cuda:0)]\n", + " (TNFA-): Parameter containing: [torch.cuda.FloatTensor of size 24x25 (cuda:0)]\n", + " )\n", + " (eta): ParameterDict(\n", + " (global): Parameter containing: [torch.cuda.FloatTensor of size 20x20 (cuda:0)]\n", + " (TNFA+): Parameter containing: [torch.cuda.FloatTensor of size 5x5 (cuda:0)]\n", + " (TNFA-): Parameter containing: [torch.cuda.FloatTensor of size 5x5 (cuda:0)]\n", + " )\n", + " (gene_scaling): ParameterDict(\n", + " (global): Parameter containing: [torch.cuda.FloatTensor of size 4997 (cuda:0)]\n", + " (TNFA+): Parameter containing: [torch.cuda.FloatTensor of size 4997 (cuda:0)]\n", + " (TNFA-): Parameter containing: [torch.cuda.FloatTensor of size 4997 (cuda:0)]\n", + " )\n", + " (kappa): ParameterDict(\n", + " (global): Parameter containing: [torch.cuda.FloatTensor of size (cuda:0)]\n", + " (TNFA+): Parameter containing: [torch.cuda.FloatTensor of size (cuda:0)]\n", + " (TNFA-): Parameter containing: [torch.cuda.FloatTensor of size (cuda:0)]\n", + " )\n", + ")" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wrapper.internal_model.to(torch.device(\"cuda:0\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6a88483", + "metadata": {}, + "outputs": [], + "source": [ + "# retrieve heldout cells\n", + "train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata, adata.X, adata.obs[\"condition\"], fold_idx=4\n", + ")\n", + "loss_weights = np.ones(adata.shape[0])\n", + "holdout_adata = adata[test_idx]\n", + "train_adata = adata[train_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "1328f936", + "metadata": {}, + "outputs": [], + "source": [ + "# visualize reconstructed vs observed expression for cells of a given perturbation\n", + "holdout_perts = \"RIPK1\"\n", + "hold_idx = [\n", + " i for i, x in enumerate(holdout_adata.obs[\"condition\"]) if x == holdout_perts\n", + "]\n", + "X_holdout = torch.from_numpy(holdout_adata.X[hold_idx])\n", + "D_holdout = torch.from_numpy(D[hold_idx])\n", + "labels_holdout = labels[hold_idx]\n", + "loss_weights_holdout = torch.from_numpy(loss_weights[hold_idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "9657f513", + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " loss, recon = wrapper.internal_model.loss(\n", + " X=X_holdout,\n", + " D=D_holdout,\n", + " labels=labels_holdout,\n", + " loss_weights=loss_weights_holdout,\n", + " forward=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "d91358d1", + "metadata": {}, + "outputs": [], + "source": [ + "mean_reconstruction = torch.mean(recon[\"TNFA+\"], dim=0).detach().cpu().numpy()\n", + "observed = torch.from_numpy(\n", + " holdout_adata[\n", + " (holdout_adata.obs[\"Treatment\"] == \"TNFA+\")\n", + " & (holdout_adata.obs[\"condition\"] == holdout_perts)\n", + " ].X\n", + ")\n", + "mean_observed = torch.mean(observed, dim=0).detach().cpu().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08ccadde-8c6c-494f-bfeb-feddfd668d1b", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "spearmans = spearmanr(mean_reconstruction, mean_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "bd66f54b-a52a-48e7-8529-f3d2a31a15b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spearman correlation: SignificanceResult(statistic=0.9771781192927307, pvalue=0.0)\n" + ] + } + ], + "source": [ + "# Plot with Seaborn\n", + "plt.figure(figsize=(8, 6))\n", + "sns.set(style=\"whitegrid\")\n", + "\n", + "sns.scatterplot(x=mean_observed, y=mean_reconstruction, s=5)\n", + "plt.title(f\"Observed vs Predicted Mean Expression of {holdout_perts} Perturbed Cells\")\n", + "plt.ylabel(\"Predicted\")\n", + "plt.xlabel(\"Observed\")\n", + "\n", + "plt.show()\n", + "\n", + "# Print Spearman correlation\n", + "print(f\"Spearman correlation: {spearmans}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "cc37848e-715c-4e13-88ee-6299afc776ea", + "metadata": {}, + "outputs": [], + "source": [ + "# get reconstruction for all heldout samples\n", + "X_holdout = torch.from_numpy(holdout_adata.X)\n", + "D_holdout = torch.from_numpy(D[test_idx])\n", + "labels_holdout = labels[test_idx]\n", + "loss_weights_holdout = torch.from_numpy(np.ones(holdout_adata.shape[0]))\n", + "recons = []\n", + "losses = []\n", + "with torch.no_grad():\n", + " for i in range(0, len(X_holdout), 10000):\n", + " loss, recon = wrapper.internal_model.loss(\n", + " X=X_holdout[i : i + 10000],\n", + " D=D_holdout[i : i + 10000],\n", + " labels=labels_holdout[i : i + 10000],\n", + " loss_weights=loss_weights_holdout[i : i + 10000],\n", + " forward=True,\n", + " )\n", + " losses.append(loss[\"TNFA+\"].detach().cpu().numpy())\n", + " recons.append(recon[\"TNFA+\"].detach().cpu().numpy())\n", + "adata.uns[\"recon\"] = np.concatenate(recons)\n", + "adata.uns[\"losses\"] = np.array(losses)" + ] + }, + { + "cell_type": "markdown", + "id": "f51bf3e9-ef18-4dcd-b964-7891bf9346df", + "metadata": {}, + "source": [ + "## Save anndata for downstream analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "973e78cf", + "metadata": {}, + "outputs": [], + "source": [ + "# save anndata for downstream analysis\n", + "from scipy import sparse\n", + "\n", + "adata.X = sparse.csr_matrix(adata.X)\n", + "write_adata_to_s3(s3_dir + experiment_name, \"fold_4\", adata)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "511f8aae", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/PertSpectra_load_checkpoints/pertspectra_norman.ipynb b/PertSpectra_load_checkpoints/pertspectra_norman.ipynb new file mode 100644 index 0000000..f02020a --- /dev/null +++ b/PertSpectra_load_checkpoints/pertspectra_norman.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "65f8246a", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb2ff34c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seed set\n" + ] + } + ], + "source": [ + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " generate_k_fold,\n", + " load_model,\n", + " read_aws_h5ad,\n", + " set_seed,\n", + " write_adata_to_s3,\n", + ")\n", + "\n", + "set_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "45dd3375-ab1b-423d-9179-7da6da1e6151", + "metadata": {}, + "source": [ + "## Load Model from Checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5280863b", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/norman_prior_graph_preprocessing.ipynb\n", + "unfiltered_adata = read_aws_h5ad(\"path to preprocessed h5ad\")\n", + "adata = filter_noisy_genes(unfiltered_adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "device = torch.device(\"cuda:0\")\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "78ccb7d2", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to powered perturbations\n", + "obs_df = pd.DataFrame(adata.obs[\"perturbation_name\"])\n", + "category_counts = obs_df[\"perturbation_name\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"perturbation_name\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "266cc119", + "metadata": {}, + "outputs": [], + "source": [ + "# load model from checkpoint\n", + "s3_dir = \"s3://pert-spectra/PertSpectra_checkpoints/\"\n", + "experiment_name = \"pertspectra_norman/\"\n", + "model_name = \"kfold_4\"\n", + "wrapper, adata = load_model(\n", + " adata=adata,\n", + " s3_dir=s3_dir,\n", + " experiment_name=experiment_name,\n", + " model_name=model_name,\n", + " use_cell_types=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fba884f4-488e-444c-9421-12068d735c70", + "metadata": {}, + "outputs": [], + "source": [ + "# save trained PertSpectra parameters\n", + "adata.uns[\"SPECTRA_factors\"] = wrapper.factors\n", + "adata.uns[\"SPECTRA_L\"] = wrapper.internal_model.L\n", + "adata.uns[\"SPECTRA_pert_scores\"] = wrapper.cell_scores" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9292bf1c", + "metadata": {}, + "outputs": [], + "source": [ + "# reconstruct binarized perturbation matrix\n", + "pert_idx = list(wrapper.internal_model.pert_idx)\n", + "pert_labels = [x.split(\"_\")[-1] for x in wrapper.internal_model.pert_labels]\n", + "adata.uns[\"Spectra_pert_labels\"] = pert_labels\n", + "D = []\n", + "for i in adata.obs[\"perturbation_name\"]:\n", + " d = [0.0 for _ in range(len(pert_idx))]\n", + " # add intercept\n", + " d[-1] = 1\n", + " if i == \"control\":\n", + " d[-2] = 1.0\n", + " D.append(d)\n", + " continue\n", + " guides = i.split(\"+\")\n", + "\n", + " # pert or intergenic\n", + " one_hot_idx = pert_labels.index(guides[0])\n", + " d[one_hot_idx] = 1.0\n", + "\n", + " if len(guides) > 1:\n", + " one_hot_idx = pert_labels.index(guides[1])\n", + " d[one_hot_idx] = 1.0\n", + " D.append(d)\n", + "D = np.stack(D).astype(np.float32)" + ] + }, + { + "cell_type": "markdown", + "id": "d3fef4ad-89a7-4fb6-a8ba-b865ef6e3cf8", + "metadata": {}, + "source": [ + "## Reconstructed Gene Expression\n", + "- Visualize reconstructed gene expression for a single perturbation\n", + "- Save reconstructed gene expression for all heldout cells" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4184472e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SPECTRA()" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wrapper.internal_model.to(torch.device(\"cuda:0\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a55ef361", + "metadata": {}, + "outputs": [], + "source": [ + "# train-val-test split\n", + "train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata,\n", + " adata.X,\n", + " adata.obs[\"perturbation_name\"],\n", + " fold_idx=4,\n", + " perturbation_key=\"perturbation_name\",\n", + ")\n", + "loss_weights = np.ones(adata.shape[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "671c346f", + "metadata": {}, + "outputs": [], + "source": [ + "holdout_adata = adata[test_idx]\n", + "train_adata = adata[train_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1328f936", + "metadata": {}, + "outputs": [], + "source": [ + "holdout_perts = \"CBL\"\n", + "hold_idx = [\n", + " i\n", + " for i, x in enumerate(holdout_adata.obs[\"perturbation_name\"])\n", + " if x == holdout_perts\n", + "]\n", + "X_holdout = torch.from_numpy(holdout_adata.X[hold_idx])\n", + "D_holdout = torch.from_numpy(D[hold_idx])\n", + "loss_weights_holdout = torch.from_numpy(loss_weights[hold_idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9657f513", + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " loss, recon = wrapper.internal_model.loss_no_cell_types(\n", + " X=X_holdout, D=D_holdout, loss_weights=loss_weights_holdout, forward=True\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f5fc4fdc", + "metadata": {}, + "outputs": [], + "source": [ + "mean_reconstruction = recon.detach().cpu().numpy().mean(axis=0)\n", + "observed = torch.from_numpy(\n", + " holdout_adata[(holdout_adata.obs[\"perturbation_name\"] == holdout_perts)].X\n", + ")\n", + "mean_observed = torch.mean(observed, dim=0).detach().cpu().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dca3a452-df0a-4a84-9573-3511c77bb470", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "spearmans = spearmanr(mean_reconstruction, mean_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "5f2a50e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spearman correlation: SignificanceResult(statistic=0.9697197539302803, pvalue=9.701068316902012e-35)\n" + ] + } + ], + "source": [ + "plt.scatter(\n", + " mean_observed, mean_reconstruction, s=[5 for _ in range(len(mean_observed))]\n", + ")\n", + "plt.title(f\"Observed vs predicted mean expression of {holdout_perts} perturbed cells\")\n", + "plt.ylabel(\"Predicted\")\n", + "plt.xlabel(\"Observed\")\n", + "plt.show()\n", + "print(f\"Spearman correlation: {spearmans}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ed5cd7ac-d347-439e-ae0f-9cd99b541be3", + "metadata": {}, + "outputs": [], + "source": [ + "# get reconstruction for all heldout samples\n", + "X_holdout = torch.from_numpy(holdout_adata.X)\n", + "D_holdout = torch.from_numpy(D[test_idx])\n", + "loss_weights_holdout = torch.from_numpy(np.ones(holdout_adata.shape[0]))\n", + "recons = []\n", + "losses = []\n", + "with torch.no_grad():\n", + " for i in range(0, len(X_holdout), 1000):\n", + " loss, recon = wrapper.internal_model.loss_no_cell_types(\n", + " X=X_holdout[i : i + 1000],\n", + " D=D_holdout[i : i + 1000],\n", + " loss_weights=loss_weights_holdout[i : i + 1000],\n", + " forward=True,\n", + " )\n", + " losses.append(loss.detach().cpu().numpy())\n", + " recons.append(recon.detach().cpu().numpy())\n", + "adata.uns[\"recon\"] = np.concatenate(recons)\n", + "adata.uns[\"losses\"] = np.array(losses)" + ] + }, + { + "cell_type": "markdown", + "id": "3754cfd3-adb5-4091-bcbb-44d7739514a7", + "metadata": {}, + "source": [ + "## Save anndata for downstream analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "973e78cf", + "metadata": {}, + "outputs": [], + "source": [ + "# save anndata for downstream analysis\n", + "from scipy import sparse\n", + "\n", + "adata.X = sparse.csr_matrix(adata.X)\n", + "write_adata_to_s3(s3_dir + experiment_name, \"fold_4\", adata)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0e80c98-9b9b-4d73-91d8-9b750d1c7e7e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/PertSpectra_load_checkpoints/pertspectra_replogle.ipynb b/PertSpectra_load_checkpoints/pertspectra_replogle.ipynb new file mode 100644 index 0000000..8964992 --- /dev/null +++ b/PertSpectra_load_checkpoints/pertspectra_replogle.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "65f8246a", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bb2ff34c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seed set\n" + ] + } + ], + "source": [ + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " load_model,\n", + " read_aws_h5ad,\n", + " set_seed,\n", + " split_data_by_cell,\n", + " write_adata_to_s3,\n", + ")\n", + "\n", + "set_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "1c40154b-7828-4142-9187-170e7909ed72", + "metadata": {}, + "source": [ + "## Load Model from Checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5280863b", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/replogle_prior_graph_preprocessing.ipynb\n", + "unfilterd_adata = read_aws_h5ad(\"path to preprocessed h5ad\")\n", + "adata = filter_noisy_genes(unfilterd_adata)\n", + "adata.X = adata.X.todense()\n", + "device = torch.device(\"cuda:0\")\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5375d253", + "metadata": {}, + "outputs": [], + "source": [ + "# filter adata to perturbations with at least 50 samples\n", + "obs_df = pd.DataFrame(adata.obs[\"gene\"])\n", + "category_counts = obs_df[\"gene\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"gene\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1551462a", + "metadata": {}, + "outputs": [], + "source": [ + "# get the filtered 'strong' perturbations, but do not use the limited gene expression\n", + "# references the svae filtered replogle anndata to subset to those cells (https://github.com/Genentech/sVAE/blob/main/entry_points/replogle-preprocessing.ipynb)\n", + "filtered_replogle = read_aws_h5ad(\"path to svae filtered replogle h5ad\")\n", + "filtered_perts = set(filtered_replogle.obs[\"gene\"].unique()).union(\n", + " set([\"SKP2\", \"CUL1\", \"UBE2N\"])\n", + ")\n", + "adata = adata[adata.obs[\"gene\"].isin(filtered_perts)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15bdbc4d", + "metadata": {}, + "outputs": [], + "source": [ + "# load model from checkpoint\n", + "s3_dir = \"s3://pert-spectra/PertSpectra_checkpoints/\"\n", + "experiment_name = \"pertspectra_replogle/\"\n", + "model_name = \"replogle\"\n", + "wrapper, adata = load_model(\n", + " adata=adata,\n", + " s3_dir=s3_dir,\n", + " experiment_name=experiment_name,\n", + " model_name=model_name,\n", + " use_cell_types=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b375310a-07eb-47f0-a4d1-c17b19697eae", + "metadata": {}, + "outputs": [], + "source": [ + "# save trained PertSpectra parameters\n", + "adata.uns[\"SPECTRA_factors\"] = wrapper.factors\n", + "adata.uns[\"SPECTRA_L\"] = wrapper.internal_model.L\n", + "adata.uns[\"SPECTRA_pert_scores\"] = wrapper.cell_scores" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6da069f6", + "metadata": {}, + "outputs": [], + "source": [ + "# reconstruct binarized perturbation matrix\n", + "pert_idx = list(wrapper.internal_model.pert_idx)\n", + "pert_labels = [x.split(\"_\")[-1] for x in wrapper.internal_model.pert_labels]\n", + "adata.uns[\"Spectra_pert_labels\"] = pert_labels\n", + "D = []\n", + "for i in adata.obs[\"gene\"]:\n", + " d = [0.0 for _ in range(len(pert_idx))]\n", + " # add intercept\n", + " d[-1] = 1\n", + " if i == \"non-targeting\":\n", + " d[-2] = 1.0\n", + " D.append(d)\n", + " continue\n", + " guides = i.split(\"+\")\n", + "\n", + " # pert or intergenic\n", + " one_hot_idx = pert_labels.index(guides[0])\n", + " d[one_hot_idx] = 1.0\n", + "\n", + " if len(guides) > 1:\n", + " one_hot_idx = pert_labels.index(guides[1])\n", + " d[one_hot_idx] = 1.0\n", + " D.append(d)\n", + "D = np.stack(D).astype(np.float32)" + ] + }, + { + "cell_type": "markdown", + "id": "e7fd5be1-49a2-47b0-bc6c-7a84d489c1f2", + "metadata": {}, + "source": [ + "## Reconstructed Gene Expression\n", + "- Visualize reconstructed gene expression for a single perturbation\n", + "- Save reconstructed gene expression for all heldout cells" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4184472e", + "metadata": {}, + "outputs": [], + "source": [ + "# wrap in cpu\n", + "wrapper.internal_model.to(torch.device(\"cpu\"))\n", + "wrapper.internal_model.device = torch.device(\"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "83785bb5", + "metadata": {}, + "outputs": [], + "source": [ + "train_idx, val_idx, test_idx = split_data_by_cell(\n", + " adata.X, adata.obs[\"gene\"], test_size=0.2, val_size=0.2\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1328f936", + "metadata": {}, + "outputs": [], + "source": [ + "holdout_perts = \"RIOK2\"\n", + "X_holdout = torch.from_numpy(adata.X[test_idx])\n", + "D_holdout = torch.from_numpy(D[test_idx])\n", + "loss_weights = torch.from_numpy(np.ones(X_holdout.shape[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9657f513", + "metadata": {}, + "outputs": [], + "source": [ + "with torch.no_grad():\n", + " loss, recon = wrapper.internal_model.loss_no_cell_types(\n", + " X=X_holdout, D=D_holdout, loss_weights=loss_weights, forward=True\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "f5fc4fdc", + "metadata": {}, + "outputs": [], + "source": [ + "mean_reconstruction = torch.mean(recon, dim=0).detach().cpu().numpy()\n", + "observed = torch.from_numpy(adata[(adata.obs[\"gene\"] == holdout_perts)].X)\n", + "mean_observed = torch.mean(observed, dim=0).detach().cpu().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2cd3319c-e86e-4d1b-bfcf-79b066430efd", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "spearmans = spearmanr(mean_reconstruction, mean_observed)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5f2a50e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spearman correlation: SignificanceResult(statistic=0.9748835210506989, pvalue=0.0)\n" + ] + } + ], + "source": [ + "plt.scatter(\n", + " mean_observed, mean_reconstruction, s=[5 for _ in range(len(mean_observed))]\n", + ")\n", + "plt.title(f\"Observed vs predicted mean expression of {holdout_perts} perturbed cells\")\n", + "plt.ylabel(\"Predicted\")\n", + "plt.xlabel(\"Observed\")\n", + "plt.show()\n", + "spearmans = spearmanr(mean_reconstruction, mean_observed)\n", + "print(f\"Spearman correlation: {spearmans}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d3d8e895", + "metadata": {}, + "outputs": [], + "source": [ + "# get reconstruction for all heldout samples\n", + "X_holdout = torch.from_numpy(adata.X[test_idx])\n", + "D_holdout = torch.from_numpy(D[test_idx])\n", + "loss_weights = torch.from_numpy(np.ones(X_holdout.shape[0]))\n", + "recons = []\n", + "losses = []\n", + "with torch.no_grad():\n", + " for i in range(0, len(X_holdout), 10000):\n", + " loss, recon = wrapper.internal_model.loss_no_cell_types(\n", + " X=X_holdout[i : i + 10000],\n", + " D=D_holdout[i : i + 10000],\n", + " loss_weights=loss_weights[i : i + 10000],\n", + " forward=True,\n", + " )\n", + " losses.append(loss.detach().cpu().numpy())\n", + " recons.append(recon.detach().cpu().numpy())\n", + "adata.uns[\"recon\"] = np.concatenate(recons)\n", + "adata.uns[\"losses\"] = np.array(losses)" + ] + }, + { + "cell_type": "markdown", + "id": "c1312828-84ee-4a2b-81d8-6713cde9ce67", + "metadata": {}, + "source": [ + "## Save anndata for downstream analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "973e78cf", + "metadata": {}, + "outputs": [], + "source": [ + "# save anndata for downstream analysis\n", + "from scipy import sparse\n", + "\n", + "adata.X = sparse.csr_matrix(adata.X)\n", + "write_adata_to_s3(s3_dir + experiment_name, \"replogle\", adata)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0e29cc0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/PertSpectra_training_scripts/train_PertSpectra_inhouse.py b/PertSpectra_training_scripts/train_PertSpectra_inhouse.py new file mode 100644 index 0000000..5f16689 --- /dev/null +++ b/PertSpectra_training_scripts/train_PertSpectra_inhouse.py @@ -0,0 +1,208 @@ +import argparse +import sys + +import numpy as np +import pandas as pd +import torch + +sys.path.append("..") +from src.Spectra import Spectra_Pert as spc_linear +from src.Spectra.Spectra_Pert import vectorize_perts, vectorize_perts_combinations +from utils import ( + filter_noisy_genes, + generate_k_fold, + generate_loss_weights, + read_aws_h5ad, + set_seed, + write_model_pickle_to_s3, +) + + +def train(args): + # read in anndata containing prior graph + unfilterd_adata = read_aws_h5ad(args.anndata_s3_url) + adata = filter_noisy_genes(unfilterd_adata) + adata.layers["logcounts"] = adata.X.copy() + adata.X = adata.X.todense() + device = torch.device(args.device) + gene_network = adata.uns["sparse_gene_network"].todense() + + # filter adata to perturbations with at least 50 samples for each treatment + adata.obs["condition"] = adata.obs["condition"].astype(str) + adata.obs["Treatment"] = adata.obs["Treatment"].astype(str) + adata.obs["pert_treat"] = adata.obs["condition"] + "+" + adata.obs["Treatment"] + obs_df = pd.DataFrame(adata.obs["pert_treat"]) + category_counts = obs_df["pert_treat"].value_counts() + filtered_categories = category_counts[category_counts >= 50].index + adata = adata[adata.obs["pert_treat"].isin(filtered_categories)] + + if args.cell_type_key == "Treatment": + L = {"global": args.global_latent_dim} + adj_matrices = {"global": gene_network.copy()} + for key in adata.obs[args.cell_type_key].unique(): + L[key] = args.celltype_latent_dim + adj_matrices[key] = gene_network.copy() + + # init model parameters + vocab = adata.var_names + labels = adata.obs[args.cell_type_key].values + word2id = dict((v, idx) for idx, v in enumerate(vocab)) + X = adata.X + loss_weights = generate_loss_weights(adata, args.perturbation_key) + + # perturbation labels + if args.perturbation_key in adata.obs: + if not args.encode_combos_as_unique: + D, pert_labels = vectorize_perts( + adata, args.perturbation_key, args.control_key + ) + pert_idx = np.array( + [ + adata.var_names.get_loc(i.split("_")[1]) + if i.split("_")[1] in adata.var_names + else -1 + for i in pert_labels + ] + ) + else: + D, pert_labels = vectorize_perts_combinations( + adata, args.perturbation_key, args.control_key + ) + pert_idx = np.array( + [ + adata.var_names.get_loc(i) if i in adata.var_names else -1 + for i in pert_labels + ] + ) + + # add ctrl one-hot-encoding + ctrl_vector = np.array( + [1.0 if i == "ctrl" else 0.0 for i in adata.obs[args.perturbation_key]] + ) + basal_vector = np.array([1.0 for i in adata.obs[args.perturbation_key]]) + D = np.concatenate( + [D, ctrl_vector.reshape(len(ctrl_vector), 1)], axis=1 + ).astype(np.float32) + D = np.concatenate( + [D, basal_vector.reshape(len(basal_vector), 1)], axis=1 + ).astype(np.float32) + pert_idx = np.append(pert_idx, [-1, -1]) + pert_labels = pert_labels + ["ctrl", "basal"] + else: + print("Perturbation key not found or not given!") + D = np.array([]) + pert_idx = np.array([]) + + # init Spectra wrapper + wrapper = spc_linear.SPECTRA_Model( + X=X, + labels=labels, + pert_idx=pert_idx, + pert_labels=pert_labels, + L=L, + vocab=vocab, + adj_matrix=adj_matrices, + use_weights=args.use_weights, + lam=args.lam, + psi=args.psi, + delta=args.delta, + kappa=None, + rho=args.rho, + use_cell_types=args.use_cell_types, + ) + wrapper.initialize(None, word2id, adata.X, 0) + wrapper.internal_model.to(device) + + # train-val-test split + train_idx, val_idx, test_idx = generate_k_fold( + adata, X, adata.obs[args.perturbation_key], fold_idx=args.kfold_idx + ) + X_train = X[train_idx] + D_train = D[train_idx] + loss_weights_train = loss_weights[train_idx] + labels_train = labels[train_idx] + X_val = X[val_idx] + D_val = D[val_idx] + loss_weights_val = loss_weights[val_idx] + labels_val = labels[val_idx] + + # train model + train_loss, val_loss = wrapper.train( + X_train, + D_train, + loss_weights_train, + X_val, + D_val, + loss_weights_val, + labels=labels_train, + labels_val=labels_val, + ) + + write_model_pickle_to_s3( + s3_url=args.model_save_s3_url + args.experiment_name + "/", + model_name=f"kfold_{args.kfold_idx}", + model=wrapper, + ) + + +if __name__ == "__main__": + # set seed for reproducibility + set_seed(0) + parser = argparse.ArgumentParser(description="Run pertspectra experiment.") + # Passing in hyperparameters as arguments + parser.add_argument("--weight_decay", type=float, default=0.001) + parser.add_argument("--lam", type=float, default=0.01) + parser.add_argument("--psi", type=float, default=0.01) + parser.add_argument("--delta", type=float, default=0.001) + parser.add_argument("--kappa", type=float, default=0.00001) + parser.add_argument("--rho", type=float, default=0.001) + parser.add_argument("--global_latent_dim", type=int, default=20) + parser.add_argument("--celltype_latent_dim", type=int, default=5) + parser.add_argument("--use_highly_variable", type=bool, default=False) + parser.add_argument("--use_weights", type=bool, default=True) + parser.add_argument("--kfold_idx", type=int, default=0) + + # cell type + parser.add_argument( + "--use_cell_types", + type=bool, + default=True, + action=argparse.BooleanOptionalAction, + ) + # encode combos as unique + parser.add_argument( + "--encode_combos_as_unique", + type=bool, + default=False, + action=argparse.BooleanOptionalAction, + ) + # cell type key: Treatment, treatment_and_pert + parser.add_argument("--cell_type_key", type=str, default="Treatment") + # perturbation key if using perturbations + parser.add_argument("--perturbation_key", type=str, default="condition") + # control key + parser.add_argument("--control_key", type=str, default=["ctrl", "nan"]) + # prior to use: None, stringdb + parser.add_argument("--prior", type=str, default="stringdb") + # device to use + parser.add_argument("--device", type=str, default="cuda:0") + # name of wandb run + parser.add_argument( + "--experiment_name", + type=str, + default="pertspectra_inhouse", + ) + + parser.add_argument( + "--anndata_s3_url", + type=str, + default="s3://pert-spectra/inhouse_adata_spectra.h5ad", + ) + parser.add_argument( + "--model_save_s3_url", + type=str, + default="s3://pert-spectra/PertSpectra_checkpoints/", + ) + args = parser.parse_args() + + train(args) diff --git a/PertSpectra_training_scripts/train_PertSpectra_norman.py b/PertSpectra_training_scripts/train_PertSpectra_norman.py new file mode 100644 index 0000000..bace2e1 --- /dev/null +++ b/PertSpectra_training_scripts/train_PertSpectra_norman.py @@ -0,0 +1,183 @@ +import argparse +import sys + +import numpy as np +import pandas as pd +import torch + +sys.path.append("..") +from src.Spectra import Spectra_Pert as spc_linear +from src.Spectra.Spectra_Pert import ( + get_guide_one_hot_cols, + vectorize_perts_combinations, +) +from utils import ( + filter_noisy_genes, + generate_k_fold, + generate_loss_weights, + read_aws_h5ad, + set_seed, + write_model_pickle_to_s3, +) + + +def train(args): + # read in anndata containing prior graph + unfilterd_adata = read_aws_h5ad(args.anndata_s3_url) + adata = filter_noisy_genes(unfilterd_adata) + adata.layers["logcounts"] = adata.X.copy() + adata.X = adata.X.todense() + device = torch.device(args.device) + gene_network = adata.uns["sparse_gene_network"].todense() + if args.prior == "None": + gene_network = np.zeros(gene_network.shape) + + # filter adata to perturbations with at least 50 samples + obs_df = pd.DataFrame(adata.obs[args.perturbation_key]) + category_counts = obs_df[args.perturbation_key].value_counts() + filtered_categories = category_counts[category_counts >= 50].index + adata = adata[adata.obs[args.perturbation_key].isin(filtered_categories)] + + # init model parameters + L = args.global_latent_dim + adj_matrices = gene_network.copy() + vocab = adata.var_names + word2id = dict((v, idx) for idx, v in enumerate(vocab)) + loss_weights = generate_loss_weights(adata, args.perturbation_key) + X = adata.X + + # create binary perturbation label matrix from data + if args.perturbation_key in adata.obs: + if not args.encode_combos_as_unique: + pert_labels = get_guide_one_hot_cols(adata.obs) + adata.obs["num_guides"] = adata.obs[pert_labels].sum(1) + # combinations encoded as application of two individual guides + D = adata.obs[pert_labels].to_numpy().astype(np.float32) + pert_id = [] + for i in pert_labels: + guide = i.split("_")[1] + if guide in adata.var_names: + pert_id.append(adata.var_names.get_loc(guide)) + else: + pert_id.append(-1) + pert_idx = np.array(pert_id) + else: + D, pert_labels = vectorize_perts_combinations( + adata, args.perturbation_key, args.control_key + ) + pert_idx = np.array( + [ + adata.var_names.get_loc(i) if i in adata.var_names else -1 + for i in pert_labels + ] + ) + # add ctrl one-hot-encoding + ctrl_vector = np.array( + [1.0 if i == "control" else 0.0 for i in adata.obs[args.perturbation_key]] + ) + basal_vector = np.array([1.0 for i in adata.obs[args.perturbation_key]]) + D = np.concatenate( + [D, ctrl_vector.reshape(len(ctrl_vector), 1)], axis=1 + ).astype(np.float32) + D = np.concatenate( + [D, basal_vector.reshape(len(basal_vector), 1)], axis=1 + ).astype(np.float32) + pert_idx = np.append(pert_idx, [-1, -1]) + pert_labels = pert_labels + ["ctrl", "basal"] + else: + print("Perturbation key not found or not given!") + D = np.array([]) + pert_idx = np.array([]) + + # init Spectra wrapper + wrapper = spc_linear.SPECTRA_Model( + X=X, + labels=None, + pert_idx=pert_idx, + pert_labels=pert_labels, + L=L, + vocab=vocab, + adj_matrix=adj_matrices, + use_weights=args.use_weights, + lam=args.lam, + psi=args.psi, + delta=args.delta, + kappa=None, + rho=args.rho, + use_cell_types=args.use_cell_types, + ) + wrapper.initialize(None, word2id, adata.X, 0) + wrapper.internal_model.to(device) + + # train-val-test split + train_idx, val_idx, _ = generate_k_fold( + adata, X, D, fold_idx=args.kfold_idx, perturbation_key=args.perturbation_key + ) + X_train = X[train_idx] + D_train = D[train_idx] + loss_weights_train = loss_weights[train_idx] + X_val = X[val_idx] + D_val = D[val_idx] + loss_weights_val = loss_weights[val_idx] + + # train model + train_loss, val_loss = wrapper.train( + X_train, D_train, loss_weights_train, X_val, D_val, loss_weights_val + ) + # save to s3 + write_model_pickle_to_s3( + s3_url=args.model_save_s3_url + args.experiment_name + "/", + model_name=f"kfold_{args.kfold_idx}", + model=wrapper, + ) + + +if __name__ == "__main__": + # set seed for reproducibility + set_seed(0) + parser = argparse.ArgumentParser(description="Run pertspectra experiment.") + # Passing in hyperparameters as arguments. + parser.add_argument("--weight_decay", type=float, default=0.001) + parser.add_argument("--lam", type=float, default=1) + parser.add_argument("--psi", type=float, default=0.01) + parser.add_argument("--delta", type=float, default=0.001) + parser.add_argument("--kappa", type=float, default=0.00001) + parser.add_argument("--rho", type=float, default=0.05) + parser.add_argument("--use_highly_variable", type=bool, default=False) + parser.add_argument("--use_weights", type=bool, default=True) + parser.add_argument("--global_latent_dim", type=int, default=200) + parser.add_argument("--kfold_idx", type=int, default=2) + + # cell type + parser.add_argument("--use_cell_types", type=bool, default=False) + # encode combos as unique + parser.add_argument( + "--encode_combos_as_unique", + type=bool, + default=False, + action=argparse.BooleanOptionalAction, + ) + # perturbation key if using perturbations + parser.add_argument("--perturbation_key", type=str, default="perturbation_name") + # control key + parser.add_argument("--control_key", type=str, default=["control"]) + # prior to use: None, stringdb + parser.add_argument("--prior", type=str, default="stringdb") + # device to use + parser.add_argument("--device", type=str, default="cuda:0") + # name of training run + parser.add_argument("--experiment_name", type=str, default="pertspectra_norman") + + parser.add_argument( + "--anndata_s3_url", + type=str, + default="s3://pert-spectra/norman_adata_spectra.h5ad", + ) + parser.add_argument( + "--model_save_s3_url", + type=str, + default="s3://pert-spectra/PertSpectra_checkpoints/", + ) + args = parser.parse_known_args()[0] + + train(args) diff --git a/PertSpectra_training_scripts/train_PertSpectra_replogle.py b/PertSpectra_training_scripts/train_PertSpectra_replogle.py new file mode 100644 index 0000000..2ddaacf --- /dev/null +++ b/PertSpectra_training_scripts/train_PertSpectra_replogle.py @@ -0,0 +1,172 @@ +import argparse +import sys + +import numpy as np +import pandas as pd +import torch + +sys.path.append("..") +from src.Spectra import Spectra_Pert as spc_linear +from src.Spectra.Spectra_Pert import ( + vectorize_perts, +) +from utils import ( + filter_noisy_genes, + generate_loss_weights, + read_aws_h5ad, + set_seed, + split_data_by_cell, + write_model_pickle_to_s3, +) + + +def train(args): + # read in anndata containing prior graph + unfilterd_adata = read_aws_h5ad(args.anndata_s3_url) + adata = filter_noisy_genes(unfilterd_adata) + adata.layers["logcounts"] = adata.X.copy() + adata.X = adata.X.todense() + device = torch.device(args.device) + gene_network = adata.uns["sparse_gene_network"].todense() + if args.prior == "None": + gene_network = np.zeros(gene_network.shape) + + # filter adata to perturbations with at least 50 samples + obs_df = pd.DataFrame(adata.obs[args.perturbation_key]) + category_counts = obs_df[args.perturbation_key].value_counts() + filtered_categories = category_counts[category_counts >= 50].index + adata = adata[adata.obs[args.perturbation_key].isin(filtered_categories)] + + # replogle specific - filter to strong perturbations as done by Lopez et al, 2022 + filtered_replogle = read_aws_h5ad( + "s3://pert-spectra/svae_replogle_k562_gw_dataset_with_nt_guides.h5ad" + ) + filtered_perts = set(filtered_replogle.obs[args.perturbation_key].unique()).union( + set(["SKP2", "CUL1", "UBE2N"]) + ) + adata = adata[adata.obs[args.perturbation_key].isin(filtered_perts)] + + # init model parameters + L = args.global_latent_dim + adj_matrices = gene_network.copy() + vocab = adata.var_names + word2id = dict((v, idx) for idx, v in enumerate(vocab)) + loss_weights = generate_loss_weights(adata, args.perturbation_key) + X = adata.X + + # create binary perturbation label matrix from data + if args.perturbation_key in adata.obs: + D, pert_labels = vectorize_perts(adata, args.perturbation_key, args.control_key) + pert_idx = np.array( + [ + adata.var_names.get_loc(i.split("_")[1]) + if i.split("_")[1] in adata.var_names + else -1 + for i in pert_labels + ] + ) + # add ctrl one-hot-encoding + ctrl_vector = np.array( + [ + 1.0 if i == args.control_key else 0.0 + for i in adata.obs[args.perturbation_key] + ] + ) + basal_vector = np.array([1.0 for i in adata.obs[args.perturbation_key]]) + D = np.concatenate( + [D, ctrl_vector.reshape(len(ctrl_vector), 1)], axis=1 + ).astype(np.float32) + D = np.concatenate( + [D, basal_vector.reshape(len(basal_vector), 1)], axis=1 + ).astype(np.float32) + pert_idx = np.append(pert_idx, [-1, -1]) + pert_labels = pert_labels + ["ctrl", "basal"] + print(D.shape) + else: + print("Perturbation key not found or not given!") + D = np.array([]) + pert_idx = np.array([]) + + # init Spectra wrapper + wrapper = spc_linear.SPECTRA_Model( + X=X, + labels=None, + pert_idx=pert_idx, + pert_labels=pert_labels, + L=L, + vocab=vocab, + adj_matrix=adj_matrices, + use_weights=args.use_weights, + lam=args.lam, + psi=args.psi, + delta=args.delta, + kappa=None, + rho=args.rho, + use_cell_types=args.use_cell_types, + ) + wrapper.initialize(None, word2id, adata.X, 0) + wrapper.internal_model.to(device) + + # train-val-test split + train_idx, val_idx, _ = split_data_by_cell(X, adata.obs[args.perturbation_key]) + X_train = X[train_idx] + D_train = D[train_idx] + loss_weights_train = loss_weights[train_idx] + X_val = X[val_idx] + D_val = D[val_idx] + loss_weights_val = loss_weights[val_idx] + + # train model + train_loss, val_loss = wrapper.train( + X_train, D_train, loss_weights_train, X_val, D_val, loss_weights_val + ) + # save to s3 + write_model_pickle_to_s3( + s3_url=args.model_save_s3_url + args.experiment_name + "/", + model_name="replogle", + model=wrapper, + ) + + +if __name__ == "__main__": + # set seed for reproducibility + set_seed(0) + parser = argparse.ArgumentParser(description="Run pertspectra experiment.") + # Passing in hyperparameters as arguments. + parser.add_argument("--weight_decay", type=float, default=0.001) + parser.add_argument("--lam", type=float, default=1) + parser.add_argument("--psi", type=float, default=0.01) + parser.add_argument("--delta", type=float, default=0.001) + parser.add_argument("--kappa", type=float, default=0.00001) + parser.add_argument("--rho", type=float, default=0.001) + parser.add_argument("--use_highly_variable", type=bool, default=False) + parser.add_argument("--use_weights", type=bool, default=True) + parser.add_argument("--global_latent_dim", type=float, default=300) + parser.add_argument("--seed", type=int, default=0) + + # cell type + parser.add_argument("--use_cell_types", type=bool, default=False) + # perturbation key if using perturbations + parser.add_argument("--perturbation_key", type=str, default="gene") + # control key + parser.add_argument("--control_key", type=str, default=["non-targeting"]) + # prior to use: None, stringdb + parser.add_argument("--prior", type=str, default="stringdb") + # device to use + parser.add_argument("--device", type=str, default="cuda:0") + # name of wandb run + parser.add_argument("--experiment_name", type=str, default="pertspectra_replogle") + + parser.add_argument( + "--anndata_s3_url", + type=str, + default="s3://pert-spectra/replogle_adata_spectra.h5ad", + ) + parser.add_argument( + "--model_save_s3_url", + type=str, + default="s3://pert-spectra/PertSpectra_checkpoints/", + ) + args = parser.parse_known_args()[0] + + train(args) diff --git a/README.md b/README.md new file mode 100644 index 0000000..ad9ee79 --- /dev/null +++ b/README.md @@ -0,0 +1,78 @@ +# PertSpectra: Guided triplet factor analysis of perturb-seq data with a prior +Factor analysis model for perturb-seq data, guided by perturbation labels and prior graph regularization +Code accompanying [TODO: paper link here]() + +## Abstract +Computational modeling of interventional data is a rapidly expanding area of machine learning. In drug discovery, measuring the effects of genetic +interventions on cells is important for characterizing unknown disease mechanisms, but interpreting the resulting measurements remains a challenging task. Reliable latent space interpretability and modeling interactions between interventions are key areas of improvement for current models +in literature. Therefore, we propose PertSpectra, an extension of previously described factor analysis method Spectra (Kunes et al., 2024) to +explicitly support intervensional data. PertSpectra leverages Spectra’s differentiable graph regularization to incorporate prior biological knowledge +to generate sparse, biologically relevant latent factors that capture perturbational effects. We assess PertSpectra on three single cell sequencing +datasets with genetic perturbations, measuring latent space interpretability, predictive ability on unseen combinations of perturbations, and identification of perturbations of similar biological function. We show that PertSpectra provides an integrated modeling approach to understanding +combinatorial interventional data in the context of drug discovery. + +## Directory Overview +Outline of the organization of the codebase. +* `.`: Contains notebooks and helper functions for downstream analyses +* `./src`: Contains the PertSpectra code, edited from the Spectra codebase +* `./data`: Contains instructions for downloading datasets used in analysis +* `./data_preprocessing`: Contains notebooks for preprocessing the input data +* `./PertSpectra_training_scripts`: Contains training scripts for PertSpectra +* `./PertSpectra_load_checkpoints`: Contains notebooks for loading trained PertSpectra models from checkpoints +* `./scETM`: Contains notebooks for training scETM +* `./GSFA`: Contains notebooks for preprocessing and training GSFA +* `./figures`: Contains notebooks for figures + +## Environment Setup +PertSpectra has been tested on Linux systems. + +Please execute: + +``` +make install +``` + +This will generate a conda environment called `pertspectra` and an associated jupyter kernel that +can be used to execute the notebooks in this code repository. + + +## Data / Setup +Data preprocessing and setup. +### Gene expression normalization +The model expects log-normalized count data. Ensure that the log-normalized expression is either in the `.X` field or `.layers` field of the anndata. + +### Stringdb graph pruning +The model accepts an adjacency matrix as a prior to regularize against during training. Currently, the model regularizes against a stringdb prior graph - the notebooks to subset the stringdb graph to the input genes measured in the perturb-seq experiment are located in the `prior_graph_preprocessing/` subdirectory. Otherwise, create any prior graph as desired as a sparse adjacency matrix and store under `.uns["sparse_gene_network"]` in the anndata. + +## Training +Overview of training and saving the model. +### Launching training runs +Training scripts for PertSpectra are located in `./PertSpectra_training_scripts`. Run +``` python3 [training script] [args]``` +to launch a training run. + +### Model loading +The model can be loaded with a helper function in `utils.py` (refer to `utils.py` for details): +``` +wrapper, adata = load_model( + adata=adata, + s3_dir='s3_directory_where_training_runs_are_stored', + experiment_name='folder_in_s3_directory_where_training_run_is_located', + model_name='name_of_saved_model_pickle', + markers_top_n=50, + use_cell_types=False, + ) +``` +From the loaded model, we also need to reconstruct the binarized perturbation matrix (cell x perturbation), as the binarization may differ across different models. For details on reconstructing the binarized perturbation matrix, refer to the analysis notebooks. + +The returned anndata from `load_model` also saves the following outputs from the model: +* `adata.uns['SPECTRA_pert_scores']` stores the learned perturbation-level factors +* `adata.uns['SPECTRA_factors']` stores the learned gene-level factors + +For full details on loading saved PertSpectra models, see `./PertSpectra_load_checkpoints`. + +## Downstream analysis +Please reference the Jupyter notebooks in the main directory for all code relating to downstream analysis. + +## Figure Generation +Code to generate figures based on the downstream analyses located in `./figures`. diff --git a/conda-lock.yml b/conda-lock.yml new file mode 100644 index 0000000..45ce8fe --- /dev/null +++ b/conda-lock.yml @@ -0,0 +1,1254 @@ +# This lock file was generated by conda-lock (https://github.com/conda/conda-lock). DO NOT EDIT! +# +# A "lock file" contains a concrete list of package versions (with checksums) to be installed. Unlike +# e.g. `conda env create`, the resulting environment will not change as new package versions become +# available, unless you explicitly update the lock file. +# +# Install this environment as "YOURENV" with: +# conda-lock install -n YOURENV conda-lock.yml +# To update a single package to the latest version compatible with the version constraints in the source: +# conda-lock lock --lockfile conda-lock.yml --update PACKAGE +# To re-solve the entire environment, e.g. after changing a version constraint in the source file: +# conda-lock -f /home/ubuntu/PertSpectra/environment.yaml -f environment.yaml --lockfile conda-lock.yml +version: 1 +metadata: + content_hash: + linux-64: 3ac846264487603b3725735229011bbaed4344c1650661cadb7bb4dcbb5bc09a + osx-64: 57072fde0fa71f96db2a7fc7b3e6423f1288587cadd631dbf726f1e93ceac827 + channels: + - url: conda-forge + used_env_vars: [] + - url: bioconda + used_env_vars: [] + - url: defaults + used_env_vars: [] + platforms: + - linux-64 + - osx-64 + sources: + - /home/ubuntu/PertSpectra/environment.yaml + - environment.yaml +package: +- name: _libgcc_mutex + version: '0.1' + manager: conda + platform: linux-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 + hash: + md5: d7c89558ba9fa0495403155b64376d81 + sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 + category: main + optional: false +- name: _openmp_mutex + version: '4.5' + manager: conda + platform: linux-64 + dependencies: + _libgcc_mutex: '0.1' + libgomp: '>=7.5.0' + url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + hash: + md5: 73aaf86a425cc6e73fcf236a5a46396d + sha256: fbe2c5e56a653bebb982eda4876a9178aedfc2b545f25d0ce9c4c0b508253d22 + category: main + optional: false +- name: bzip2 + version: 1.0.8 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc-ng: '>=12' + url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + hash: + md5: 62ee74e96c5ebb0af99386de58cf9553 + sha256: 5ced96500d945fb286c9c838e54fa759aa04a7129c59800f0846b4335cee770d + category: main + optional: false +- name: bzip2 + version: 1.0.8 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + hash: + md5: 7ed4301d437b59045be7e051a0308211 + sha256: cad153608b81fb24fc8c509357daa9ae4e49dfc535b2cb49b91e23dbd68fc3c5 + category: main + optional: false +- name: ca-certificates + version: 2024.12.14 + manager: conda + platform: linux-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-64/ca-certificates-2024.12.14-hbcca054_0.conda + hash: + md5: 720523eb0d6a9b0f6120c16b2aa4e7de + sha256: 1afd7274cbc9a334d6d0bc62fa760acc7afdaceb0b91a8df370ec01fd75dc7dd + category: main + optional: false +- name: ca-certificates + version: 2024.12.14 + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-64/ca-certificates-2024.12.14-h8857fd0_0.conda + hash: + md5: b7b887091c99ed2e74845e75e9128410 + sha256: ddaafdcd1b8ace6ffeea22b6824ca9db8a64cf0a2652a11d7554ece54935fa06 + category: main + optional: false +- name: cffi + version: 1.17.1 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libffi: '>=3.4,<4.0a0' + libgcc: '>=13' + pycparser: '' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + url: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py311hf29c0ef_0.conda + hash: + md5: 55553ecd5328336368db611f350b7039 + sha256: bc47aa39c8254e9e487b8bcd74cfa3b4a3de3648869eb1a0b89905986b668e35 + category: main + optional: false +- name: cffi + version: 1.17.1 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + libffi: '>=3.4,<4.0a0' + pycparser: '' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + url: https://conda.anaconda.org/conda-forge/osx-64/cffi-1.17.1-py311h137bacd_0.conda + hash: + md5: a4b0f531064fa3dd5e3afbb782ea2cd5 + sha256: 012ee7b1ed4f9b0490d6e90c72decf148d7575173c7eaf851cd87fd434d2cacc + category: main + optional: false +- name: cfgv + version: 3.3.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + hash: + md5: 57df494053e17dce2ac3a0b33e1b2a2e + sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + category: main + optional: false +- name: cfgv + version: 3.3.1 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + hash: + md5: 57df494053e17dce2ac3a0b33e1b2a2e + sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + category: main + optional: false +- name: colorama + version: 0.4.6 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + hash: + md5: 962b9857ee8e7018c22f2776ffa0b2d7 + sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 + category: main + optional: false +- name: colorama + version: 0.4.6 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + hash: + md5: 962b9857ee8e7018c22f2776ffa0b2d7 + sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 + category: main + optional: false +- name: coverage + version: 7.6.10 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=13' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + tomli: '' + url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.6.10-py311h2dc5d0c_0.conda + hash: + md5: 2a772b30e69ba8319651e9f3ab01608f + sha256: c5782231c9255f0492728bfb74ebcddf2dd8f5561d4f792d9d186d9d360242b8 + category: main + optional: false +- name: coverage + version: 7.6.10 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + tomli: '' + url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.6.10-py311ha3cf9ac_0.conda + hash: + md5: 79facfcf4bd19a0c0beb0041ee307db0 + sha256: b32d8dfaaff9938aed6be84421a7d3499c205347ee177df5dee484c8d4a7e33a + category: main + optional: false +- name: distlib + version: 0.3.9 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda + hash: + md5: 8d88f4a2242e6b96f9ecff9a6a05b2f1 + sha256: 0e160c21776bd881b79ce70053e59736f51036784fa43a50da10a04f0c1b9c45 + category: main + optional: false +- name: distlib + version: 0.3.9 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda + hash: + md5: 8d88f4a2242e6b96f9ecff9a6a05b2f1 + sha256: 0e160c21776bd881b79ce70053e59736f51036784fa43a50da10a04f0c1b9c45 + category: main + optional: false +- name: exceptiongroup + version: 1.2.2 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + hash: + md5: a16662747cdeb9abbac74d0057cc976e + sha256: cbde2c64ec317118fc06b223c5fd87c8a680255e7348dd60e7b292d2e103e701 + category: main + optional: false +- name: exceptiongroup + version: 1.2.2 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.2.2-pyhd8ed1ab_1.conda + hash: + md5: a16662747cdeb9abbac74d0057cc976e + sha256: cbde2c64ec317118fc06b223c5fd87c8a680255e7348dd60e7b292d2e103e701 + category: main + optional: false +- name: filelock + version: 3.16.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda + hash: + md5: d692e9ba6f92dc51484bf3477e36ce7c + sha256: 18dca6e2194732df7ebf824abaefe999e4765ebe8e8a061269406ab88fc418b9 + category: main + optional: false +- name: filelock + version: 3.16.1 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.16.1-pyhd8ed1ab_1.conda + hash: + md5: d692e9ba6f92dc51484bf3477e36ce7c + sha256: 18dca6e2194732df7ebf824abaefe999e4765ebe8e8a061269406ab88fc418b9 + category: main + optional: false +- name: identify + version: 2.6.5 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + ukkonen: '' + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.5-pyhd8ed1ab_0.conda + hash: + md5: c1b0f663ff141265d1be1242259063f0 + sha256: e8ea11b8e39a98a9c34efb5c21c3fca718e31e1f41fd9ae5f6918b8eb402da59 + category: main + optional: false +- name: identify + version: 2.6.5 + manager: conda + platform: osx-64 + dependencies: + ukkonen: '' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.5-pyhd8ed1ab_0.conda + hash: + md5: c1b0f663ff141265d1be1242259063f0 + sha256: e8ea11b8e39a98a9c34efb5c21c3fca718e31e1f41fd9ae5f6918b8eb402da59 + category: main + optional: false +- name: iniconfig + version: 2.0.0 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + hash: + md5: 6837f3eff7dcea42ecd714ce1ac2b108 + sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + category: main + optional: false +- name: iniconfig + version: 2.0.0 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + hash: + md5: 6837f3eff7dcea42ecd714ce1ac2b108 + sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + category: main + optional: false +- name: ld_impl_linux-64 + version: '2.43' + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda + hash: + md5: 048b02e3962f066da18efe3a21b77672 + sha256: 7c91cea91b13f4314d125d1bedb9d03a29ebbd5080ccdea70260363424646dbe + category: main + optional: false +- name: libcxx + version: 19.1.6 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-19.1.6-hf95d169_1.conda + hash: + md5: 1bad6c181a0799298aad42fc5a7e98b7 + sha256: c40661648c34c08e21b69e0eec021ccaf090ffff070d2a9cbcb1519e1b310568 + category: main + optional: false +- name: libexpat + version: 2.6.4 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=13' + url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.6.4-h5888daf_0.conda + hash: + md5: db833e03127376d461e1e13e76f09b6c + sha256: 56541b98447b58e52d824bd59d6382d609e11de1f8adf20b23143e353d2b8d26 + category: main + optional: false +- name: libexpat + version: 2.6.4 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.6.4-h240833e_0.conda + hash: + md5: 20307f4049a735a78a29073be1be2626 + sha256: d10f43d0c5df6c8cf55259bce0fe14d2377eed625956cddce06f58827d288c59 + category: main + optional: false +- name: libffi + version: 3.4.2 + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=9.4.0' + url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.2-h7f98852_5.tar.bz2 + hash: + md5: d645c6d2ac96843a2bfaccd2d62b3ac3 + sha256: ab6e9856c21709b7b517e940ae7028ae0737546122f83c2aa5d692860c3b149e + category: main + optional: false +- name: libffi + version: 3.4.2 + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.2-h0d85af4_5.tar.bz2 + hash: + md5: ccb34fb14960ad8b125962d3d79b31a9 + sha256: 7a2d27a936ceee6942ea4d397f9c7d136f12549d86f7617e8b6bad51e01a941f + category: main + optional: false +- name: libgcc + version: 14.2.0 + manager: conda + platform: linux-64 + dependencies: + _libgcc_mutex: '0.1' + _openmp_mutex: '>=4.5' + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda + hash: + md5: 3cb76c3f10d3bc7f1105b2fc9db984df + sha256: 53eb8a79365e58849e7b1a068d31f4f9e718dc938d6f2c03e960345739a03569 + category: main + optional: false +- name: libgcc-ng + version: 14.2.0 + manager: conda + platform: linux-64 + dependencies: + libgcc: 14.2.0 + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda + hash: + md5: e39480b9ca41323497b05492a63bc35b + sha256: 3a76969c80e9af8b6e7a55090088bc41da4cffcde9e2c71b17f44d37b7cb87f7 + category: main + optional: false +- name: libgomp + version: 14.2.0 + manager: conda + platform: linux-64 + dependencies: + _libgcc_mutex: '0.1' + url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-14.2.0-h77fa898_1.conda + hash: + md5: cc3573974587f12dda90d96e3e55a702 + sha256: 1911c29975ec99b6b906904040c855772ccb265a1c79d5d75c8ceec4ed89cd63 + category: main + optional: false +- name: liblzma + version: 5.6.3 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=13' + url: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.6.3-hb9d3cd8_1.conda + hash: + md5: 2ecf2f1c7e4e21fcfe6423a51a992d84 + sha256: e6e425252f3839e2756e4af1ea2074dffd3396c161bf460629f9dfd6a65f15c6 + category: main + optional: false +- name: liblzma + version: 5.6.3 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + url: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.6.3-hd471939_1.conda + hash: + md5: f9e9205fed9c664421c1c09f0b90ce6d + sha256: c70639ff3cb034a8e31cb081c907879b6a639bb12b0e090069a68eb69125b10e + category: main + optional: false +- name: libnsl + version: 2.0.1 + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=12' + url: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hd590300_0.conda + hash: + md5: 30fd6e37fe21f86f4bd26d6ee73eeec7 + sha256: 26d77a3bb4dceeedc2a41bd688564fe71bf2d149fdcf117049970bc02ff1add6 + category: main + optional: false +- name: libsqlite + version: 3.47.2 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=13' + libzlib: '>=1.3.1,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.47.2-hee588c1_0.conda + hash: + md5: b58da17db24b6e08bcbf8fed2fb8c915 + sha256: 48af21ebc2cbf358976f1e0f4a0ab9e91dfc83d0ef337cf3837c6f5bc22fb352 + category: main + optional: false +- name: libsqlite + version: 3.47.2 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + libzlib: '>=1.3.1,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.47.2-hdb6dae5_0.conda + hash: + md5: 44d9799fda97eb34f6d88ac1e3eb0ea6 + sha256: 4d5e188d921f93c97ce172fc8c4341e8171670ec98d76f9961f65f6306fcda77 + category: main + optional: false +- name: libstdcxx + version: 14.2.0 + manager: conda + platform: linux-64 + dependencies: + libgcc: 14.2.0 + url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-14.2.0-hc0a3c3a_1.conda + hash: + md5: 234a5554c53625688d51062645337328 + sha256: 4661af0eb9bdcbb5fb33e5d0023b001ad4be828fccdcc56500059d56f9869462 + category: main + optional: false +- name: libuuid + version: 2.38.1 + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=12' + url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + hash: + md5: 40b61aab5c7ba9ff276c41cfffe6b80b + sha256: 787eb542f055a2b3de553614b25f09eefb0a0931b0c87dbcce6efdfd92f04f18 + category: main + optional: false +- name: libxcrypt + version: 4.4.36 + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=12' + url: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + hash: + md5: 5aa797f8787fe7a17d1b0821485b5adc + sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c + category: main + optional: false +- name: libzlib + version: 1.3.1 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=13' + url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda + hash: + md5: edb0dca6bc32e4f4789199455a1dbeb8 + sha256: d4bfe88d7cb447768e31650f06257995601f89076080e76df55e3112d4e47dc4 + category: main + optional: false +- name: libzlib + version: 1.3.1 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda + hash: + md5: 003a54a4e32b02f7355b50a837e699da + sha256: 8412f96504fc5993a63edf1e211d042a1fd5b1d51dedec755d2058948fcced09 + category: main + optional: false +- name: ncurses + version: '6.5' + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc-ng: '>=12' + url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-he02047a_1.conda + hash: + md5: 70caf8bb6cf39a0b6b7efc885f51c0fe + sha256: 6a1d5d8634c1a07913f1c525db6455918cbc589d745fac46d9d6e30340c8731a + category: main + optional: false +- name: ncurses + version: '6.5' + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-hf036a51_1.conda + hash: + md5: e102bbf8a6ceeaf429deab8032fc8977 + sha256: b0b3180039ef19502525a2abd5833c00f9624af830fd391f851934d57bffb9af + category: main + optional: false +- name: nodeenv + version: 1.9.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + setuptools: '' + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + hash: + md5: 7ba3f09fceae6a120d664217e58fe686 + sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + category: main + optional: false +- name: nodeenv + version: 1.9.1 + manager: conda + platform: osx-64 + dependencies: + setuptools: '' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + hash: + md5: 7ba3f09fceae6a120d664217e58fe686 + sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + category: main + optional: false +- name: openssl + version: 3.4.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + ca-certificates: '' + libgcc: '>=13' + url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.4.0-h7b32b05_1.conda + hash: + md5: 4ce6875f75469b2757a65e10a5d05e31 + sha256: f62f6bca4a33ca5109b6d571b052a394d836956d21b25b7ffd03376abf7a481f + category: main + optional: false +- name: openssl + version: 3.4.0 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + ca-certificates: '' + url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.4.0-hc426f3f_1.conda + hash: + md5: eaae23dbfc9ec84775097898526c72ea + sha256: 879a960d586cf8a64131ac0c060ef575cfb8aa9f6813093cba92042a86ee867c + category: main + optional: false +- name: packaging + version: '24.2' + manager: conda + platform: linux-64 + dependencies: + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + hash: + md5: 3bfed7e6228ebf2f7b9eaa47f1b4e2aa + sha256: da157b19bcd398b9804c5c52fc000fcb8ab0525bdb9c70f95beaa0bb42f85af1 + category: main + optional: false +- name: packaging + version: '24.2' + manager: conda + platform: osx-64 + dependencies: + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-24.2-pyhd8ed1ab_2.conda + hash: + md5: 3bfed7e6228ebf2f7b9eaa47f1b4e2aa + sha256: da157b19bcd398b9804c5c52fc000fcb8ab0525bdb9c70f95beaa0bb42f85af1 + category: main + optional: false +- name: pip + version: 24.3.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9,<3.13.0a0' + setuptools: '' + wheel: '' + url: https://conda.anaconda.org/conda-forge/noarch/pip-24.3.1-pyh8b19718_2.conda + hash: + md5: 04e691b9fadd93a8a9fad87a81d4fd8f + sha256: da8c8888de10c1e4234ebcaa1550ac2b4b5408ac20f093fe641e4bc8c9c9f3eb + category: main + optional: false +- name: pip + version: 24.3.1 + manager: conda + platform: osx-64 + dependencies: + setuptools: '' + wheel: '' + python: '>=3.9,<3.13.0a0' + url: https://conda.anaconda.org/conda-forge/noarch/pip-24.3.1-pyh8b19718_2.conda + hash: + md5: 04e691b9fadd93a8a9fad87a81d4fd8f + sha256: da8c8888de10c1e4234ebcaa1550ac2b4b5408ac20f093fe641e4bc8c9c9f3eb + category: main + optional: false +- name: platformdirs + version: 4.3.6 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + hash: + md5: 577852c7e53901ddccc7e6a9959ddebe + sha256: bb50f6499e8bc1d1a26f17716c97984671121608dc0c3ecd34858112bce59a27 + category: main + optional: false +- name: platformdirs + version: 4.3.6 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda + hash: + md5: 577852c7e53901ddccc7e6a9959ddebe + sha256: bb50f6499e8bc1d1a26f17716c97984671121608dc0c3ecd34858112bce59a27 + category: main + optional: false +- name: pluggy + version: 1.5.0 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda + hash: + md5: e9dcbce5f45f9ee500e728ae58b605b6 + sha256: 122433fc5318816b8c69283aaf267c73d87aa2d09ce39f64c9805c9a3b264819 + category: main + optional: false +- name: pluggy + version: 1.5.0 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.5.0-pyhd8ed1ab_1.conda + hash: + md5: e9dcbce5f45f9ee500e728ae58b605b6 + sha256: 122433fc5318816b8c69283aaf267c73d87aa2d09ce39f64c9805c9a3b264819 + category: main + optional: false +- name: pre-commit + version: 4.0.1 + manager: conda + platform: linux-64 + dependencies: + cfgv: '>=2.0.0' + identify: '>=1.0.0' + nodeenv: '>=0.11.1' + python: '>=3.9' + pyyaml: '>=5.1' + virtualenv: '>=20.10.0' + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.0.1-pyha770c72_1.conda + hash: + md5: d0ea6ed474bf7f6db88fc85e6dc809b1 + sha256: 3cfe4c777f1bb3f869cefd732357c7c657df7f0bba5c11cd64ced21e0b0a2b5b + category: main + optional: false +- name: pre-commit + version: 4.0.1 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + pyyaml: '>=5.1' + identify: '>=1.0.0' + nodeenv: '>=0.11.1' + cfgv: '>=2.0.0' + virtualenv: '>=20.10.0' + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.0.1-pyha770c72_1.conda + hash: + md5: d0ea6ed474bf7f6db88fc85e6dc809b1 + sha256: 3cfe4c777f1bb3f869cefd732357c7c657df7f0bba5c11cd64ced21e0b0a2b5b + category: main + optional: false +- name: pre_commit + version: 4.0.1 + manager: conda + platform: linux-64 + dependencies: + pre-commit: '>=4.0.1,<4.0.2.0a0' + url: https://conda.anaconda.org/conda-forge/noarch/pre_commit-4.0.1-hd8ed1ab_1.conda + hash: + md5: 6767ba12c472102bf249d00ee023ac5d + sha256: 7c57984df8a0d936b1f81762d557bc79e98769c06b79631b86980327cac2a538 + category: main + optional: false +- name: pre_commit + version: 4.0.1 + manager: conda + platform: osx-64 + dependencies: + pre-commit: '>=4.0.1,<4.0.2.0a0' + url: https://conda.anaconda.org/conda-forge/noarch/pre_commit-4.0.1-hd8ed1ab_1.conda + hash: + md5: 6767ba12c472102bf249d00ee023ac5d + sha256: 7c57984df8a0d936b1f81762d557bc79e98769c06b79631b86980327cac2a538 + category: main + optional: false +- name: pycparser + version: '2.22' + manager: conda + platform: linux-64 + dependencies: + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + hash: + md5: 12c566707c80111f9799308d9e265aef + sha256: 79db7928d13fab2d892592223d7570f5061c192f27b9febd1a418427b719acc6 + category: main + optional: false +- name: pycparser + version: '2.22' + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda + hash: + md5: 12c566707c80111f9799308d9e265aef + sha256: 79db7928d13fab2d892592223d7570f5061c192f27b9febd1a418427b719acc6 + category: main + optional: false +- name: pytest + version: 8.3.4 + manager: conda + platform: linux-64 + dependencies: + colorama: '' + exceptiongroup: '>=1.0.0rc8' + iniconfig: '' + packaging: '' + pluggy: <2,>=1.5 + python: '>=3.9' + tomli: '>=1' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + hash: + md5: 799ed216dc6af62520f32aa39bc1c2bb + sha256: 75245ca9d0cbd6d38bb45ec02430189a9d4c21c055c5259739d738a2298d61b3 + category: main + optional: false +- name: pytest + version: 8.3.4 + manager: conda + platform: osx-64 + dependencies: + packaging: '' + colorama: '' + iniconfig: '' + python: '>=3.9' + exceptiongroup: '>=1.0.0rc8' + tomli: '>=1' + pluggy: <2,>=1.5 + url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.3.4-pyhd8ed1ab_1.conda + hash: + md5: 799ed216dc6af62520f32aa39bc1c2bb + sha256: 75245ca9d0cbd6d38bb45ec02430189a9d4c21c055c5259739d738a2298d61b3 + category: main + optional: false +- name: pytest-cov + version: 6.0.0 + manager: conda + platform: linux-64 + dependencies: + coverage: '>=7.5' + pytest: '>=4.6' + python: '>=3.9' + toml: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-6.0.0-pyhd8ed1ab_1.conda + hash: + md5: 79963c319d1be62c8fd3e34555816e01 + sha256: 09acac1974e10a639415be4be326dd21fa6d66ca51a01fb71532263fba6dccf6 + category: main + optional: false +- name: pytest-cov + version: 6.0.0 + manager: conda + platform: osx-64 + dependencies: + toml: '' + python: '>=3.9' + pytest: '>=4.6' + coverage: '>=7.5' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-6.0.0-pyhd8ed1ab_1.conda + hash: + md5: 79963c319d1be62c8fd3e34555816e01 + sha256: 09acac1974e10a639415be4be326dd21fa6d66ca51a01fb71532263fba6dccf6 + category: main + optional: false +- name: python + version: 3.11.11 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + bzip2: '>=1.0.8,<2.0a0' + ld_impl_linux-64: '>=2.36.1' + libexpat: '>=2.6.4,<3.0a0' + libffi: '>=3.4,<4.0a0' + libgcc: '>=13' + liblzma: '>=5.6.3,<6.0a0' + libnsl: '>=2.0.1,<2.1.0a0' + libsqlite: '>=3.47.0,<4.0a0' + libuuid: '>=2.38.1,<3.0a0' + libxcrypt: '>=4.4.36' + libzlib: '>=1.3.1,<2.0a0' + ncurses: '>=6.5,<7.0a0' + openssl: '>=3.4.0,<4.0a0' + readline: '>=8.2,<9.0a0' + tk: '>=8.6.13,<8.7.0a0' + tzdata: '' + url: https://conda.anaconda.org/conda-forge/linux-64/python-3.11.11-h9e4cc4f_1_cpython.conda + hash: + md5: 8387070aa413ce9a8cc35a509fae938b + sha256: b29ce0836fce55bdff8d5c5b71c4921a23f87d3b950aea89a9e75784120b06b0 + category: main + optional: false +- name: python + version: 3.11.11 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + bzip2: '>=1.0.8,<2.0a0' + libexpat: '>=2.6.4,<3.0a0' + libffi: '>=3.4,<4.0a0' + liblzma: '>=5.6.3,<6.0a0' + libsqlite: '>=3.47.0,<4.0a0' + libzlib: '>=1.3.1,<2.0a0' + ncurses: '>=6.5,<7.0a0' + openssl: '>=3.4.0,<4.0a0' + readline: '>=8.2,<9.0a0' + tk: '>=8.6.13,<8.7.0a0' + tzdata: '' + url: https://conda.anaconda.org/conda-forge/osx-64/python-3.11.11-h9ccd52b_1_cpython.conda + hash: + md5: 9b20fb7c571405d29f33ae2fc5990d8d + sha256: 4c53c4c48a0f42577ae405553ab899b3ef5ee23b2a1bf4fbbc694c46f884f6fc + category: main + optional: false +- name: python_abi + version: '3.11' + manager: conda + platform: linux-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-64/python_abi-3.11-5_cp311.conda + hash: + md5: 139a8d40c8a2f430df31048949e450de + sha256: 2660b8059b3ee854bc5d3c6b1fce946e5bd2fe8fbca7827de2c5885ead6209de + category: main + optional: false +- name: python_abi + version: '3.11' + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.11-5_cp311.conda + hash: + md5: e6d62858c06df0be0e6255c753d74787 + sha256: 9b092850a268aca99600b724bae849f51209ecd5628e609b4699debc59ff1945 + category: main + optional: false +- name: pyyaml + version: 6.0.2 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=13' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + yaml: '>=0.2.5,<0.3.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py311h9ecbd09_1.conda + hash: + md5: abeb54d40f439b86f75ea57045ab8496 + sha256: e721e5ff389a7b2135917c04b27391be3d3382e261bb60a369b1620655365c3d + category: main + optional: false +- name: pyyaml + version: 6.0.2 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + yaml: '>=0.2.5,<0.3.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.2-py311h3336109_1.conda + hash: + md5: b0132bec7165a53403dcc393ff761a9e + sha256: d8f4513c53a7c0be9f1cdb9d1af31ac85cf8a6f0e4194715e36e915c03104662 + category: main + optional: false +- name: readline + version: '8.2' + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=12' + ncurses: '>=6.3,<7.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda + hash: + md5: 47d31b792659ce70f470b5c82fdfb7a4 + sha256: 5435cf39d039387fbdc977b0a762357ea909a7694d9528ab40f005e9208744d7 + category: main + optional: false +- name: readline + version: '8.2' + manager: conda + platform: osx-64 + dependencies: + ncurses: '>=6.3,<7.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h9e318b2_1.conda + hash: + md5: f17f77f2acf4d344734bda76829ce14e + sha256: 41e7d30a097d9b060037f0c6a2b1d4c4ae7e942c06c943d23f9d481548478568 + category: main + optional: false +- name: setuptools + version: 75.6.0 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + hash: + md5: fc80f7995e396cbaeabd23cf46c413dc + sha256: abb12e1dd515b13660aacb5d0fd43835bc2186cab472df25b7716cd65e095111 + category: main + optional: false +- name: setuptools + version: 75.6.0 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-75.6.0-pyhff2d567_1.conda + hash: + md5: fc80f7995e396cbaeabd23cf46c413dc + sha256: abb12e1dd515b13660aacb5d0fd43835bc2186cab472df25b7716cd65e095111 + category: main + optional: false +- name: tk + version: 8.6.13 + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=12' + libzlib: '>=1.2.13,<2.0.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h4845f30_101.conda + hash: + md5: d453b98d9c83e71da0741bb0ff4d76bc + sha256: e0569c9caa68bf476bead1bed3d79650bb080b532c64a4af7d8ca286c08dea4e + category: main + optional: false +- name: tk + version: 8.6.13 + manager: conda + platform: osx-64 + dependencies: + libzlib: '>=1.2.13,<2.0.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h1abcd95_1.conda + hash: + md5: bf830ba5afc507c6232d4ef0fb1a882d + sha256: 30412b2e9de4ff82d8c2a7e5d06a15f4f4fef1809a72138b6ccb53a33b26faf5 + category: main + optional: false +- name: toml + version: 0.10.2 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + hash: + md5: b0dd904de08b7db706167240bf37b164 + sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + category: main + optional: false +- name: toml + version: 0.10.2 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + hash: + md5: b0dd904de08b7db706167240bf37b164 + sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + category: main + optional: false +- name: tomli + version: 2.2.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + hash: + md5: ac944244f1fed2eb49bae07193ae8215 + sha256: 18636339a79656962723077df9a56c0ac7b8a864329eb8f847ee3d38495b863e + category: main + optional: false +- name: tomli + version: 2.2.1 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.2.1-pyhd8ed1ab_1.conda + hash: + md5: ac944244f1fed2eb49bae07193ae8215 + sha256: 18636339a79656962723077df9a56c0ac7b8a864329eb8f847ee3d38495b863e + category: main + optional: false +- name: tzdata + version: 2024b + manager: conda + platform: linux-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + hash: + md5: 8ac3367aafb1cc0a068483c580af8015 + sha256: 4fde5c3008bf5d2db82f2b50204464314cc3c91c1d953652f7bd01d9e52aefdf + category: main + optional: false +- name: tzdata + version: 2024b + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2024b-hc8b5060_0.conda + hash: + md5: 8ac3367aafb1cc0a068483c580af8015 + sha256: 4fde5c3008bf5d2db82f2b50204464314cc3c91c1d953652f7bd01d9e52aefdf + category: main + optional: false +- name: ukkonen + version: 1.0.1 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + cffi: '' + libgcc: '>=13' + libstdcxx: '>=13' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + url: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py311hd18a35c_5.conda + hash: + md5: 4e8447ca8558a203ec0577b4730073f3 + sha256: 4542cc3093f480c7fa3e104bfd9e5b7daeff32622121be6847f9e839341b0790 + category: main + optional: false +- name: ukkonen + version: 1.0.1 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + cffi: '' + libcxx: '>=17' + python: '>=3.11,<3.12.0a0' + python_abi: 3.11.* + url: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.0.1-py311hf2f7c97_5.conda + hash: + md5: 1b576e5588d90b82f96e3e21490b085d + sha256: d1aaec2edf78eeb79407d907679a78ecc0c97f7390046a45d561e22b348de553 + category: main + optional: false +- name: virtualenv + version: 20.28.1 + manager: conda + platform: linux-64 + dependencies: + distlib: '>=0.3.7,<1' + filelock: '>=3.12.2,<4' + platformdirs: '>=3.9.1,<5' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.28.1-pyhd8ed1ab_0.conda + hash: + md5: 680b1c287b10cefc8bda0530b217229f + sha256: c8bde4547ddbd21ea89e483a7c65d8a5e442c0db494b0b977e389b75b9d03d62 + category: main + optional: false +- name: virtualenv + version: 20.28.1 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + distlib: '>=0.3.7,<1' + filelock: '>=3.12.2,<4' + platformdirs: '>=3.9.1,<5' + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.28.1-pyhd8ed1ab_0.conda + hash: + md5: 680b1c287b10cefc8bda0530b217229f + sha256: c8bde4547ddbd21ea89e483a7c65d8a5e442c0db494b0b977e389b75b9d03d62 + category: main + optional: false +- name: wheel + version: 0.45.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + hash: + md5: 75cb7132eb58d97896e173ef12ac9986 + sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + category: main + optional: false +- name: wheel + version: 0.45.1 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + hash: + md5: 75cb7132eb58d97896e173ef12ac9986 + sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + category: main + optional: false +- name: yaml + version: 0.2.5 + manager: conda + platform: linux-64 + dependencies: + libgcc-ng: '>=9.4.0' + url: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 + hash: + md5: 4cb3ad778ec2d5a7acbdf254eb1c42ae + sha256: a4e34c710eeb26945bdbdaba82d3d74f60a78f54a874ec10d373811a5d217535 + category: main + optional: false +- name: yaml + version: 0.2.5 + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h0d85af4_2.tar.bz2 + hash: + md5: d7e08fcf8259d742156188e8762b4d20 + sha256: 5301417e2c8dea45b401ffee8df3957d2447d4ce80c83c5ff151fc6bfe1c4148 + category: main + optional: false diff --git a/data/inhouse/README.md b/data/inhouse/README.md new file mode 100644 index 0000000..224d421 --- /dev/null +++ b/data/inhouse/README.md @@ -0,0 +1,3 @@ +# Inhouse NF-kB pathway combinatorial screening dataset +Inhouse dataset specifically targeting NF-kB pathway genes\ +Data download available at s3://pert-spectra/data/inhouse.h5ad diff --git a/data/norman/README.md b/data/norman/README.md new file mode 100644 index 0000000..c68f145 --- /dev/null +++ b/data/norman/README.md @@ -0,0 +1,10 @@ +# Exploring genetic interaction manifolds constructed from rich single-cell phenotypes +Paper: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6746554/.\ +``` +Norman TM, Horlbeck MA, Replogle JM, Ge AY, Xu A, Jost M, Gilbert LA, Weissman JS. +Exploring genetic interaction manifolds constructed from rich single-cell phenotypes. +Science. 2019 Aug 23;365(6455):786-793. doi: 10.1126/science.aax4438. Epub 2019 Aug 8. +PMID: 31395745; PMCID: PMC6746554. +``` +We use the preprocessed data used by SAMS-VAE ([Berekt & Karaletsos](https://github.com/insitro/sams-vae)), originally from Theis Lab (https://github.com/theislab/sc-pert). \ +URL for data download: https://ndownloader.figshare.com/files/34027562. diff --git a/data/replogle/README.md b/data/replogle/README.md new file mode 100644 index 0000000..b98e065 --- /dev/null +++ b/data/replogle/README.md @@ -0,0 +1,12 @@ +# Mapping information-rich genotype-phenotype landscapes with genome-scale Perturb-seq +Paper: https://www.cell.com/cell/fulltext/S0092-8674(22)00597-9.\ +``` +J. M. Replogle, R. A. Saunders, A. N. Pogson, J. A. Hussmann, A. Lenail, A. Guna, L. Masci- +broda, E. J. Wagner, K. Adelman, G. Lithwick-Yanai, N. Iremadze, F. Oberstrass, D. Lip- +son, J. L. Bonnar, M. Jost, T. M. Norman, and J. S. Weissman. Mapping information- +rich genotype-phenotype landscapes with genome-scale perturb-seq. Cell, 185(14):2559– +2575.e28, 2022. ISSN 0092-8674. doi: https://doi.org/10.1016/j.cell.2022.05.013. URL +https://www.sciencedirect.com/science/article/pii/S0092867422005979. +``` +Raw data `K562_essential_raw_singlecell_01.h5ad` can be downloaded from [FigShare](https://plus.figshare.com/articles/dataset/_Mapping_information-rich_genotype-phenotype_landscapes_with_genome-scale_Perturb-seq_Replogle_et_al_2022_processed_Perturb-seq_datasets/20029387).\ +We filter down to strong perturbations using sVAE's ([Lopez et al, 2022](https://arxiv.org/abs/2211.03553)) preprocessed anndata, which can be generated using their preprocessing [notebook](https://github.com/Genentech/sVAE/blob/main/entry_points/replogle-preprocessing.ipynb). diff --git a/data_preprocessing/inhouse_prior_graph_preprocessing.ipynb b/data_preprocessing/inhouse_prior_graph_preprocessing.ipynb new file mode 100644 index 0000000..36086bd --- /dev/null +++ b/data_preprocessing/inhouse_prior_graph_preprocessing.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3cc45e64", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2d35f5c7", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import inhouse_preprocess, read_aws_csv, read_aws_h5ad" + ] + }, + { + "cell_type": "markdown", + "id": "7fc8f323-ab37-4a50-95c7-91f6d1876eeb", + "metadata": {}, + "source": [ + "## Data Preprocessing\n", + "- Ensure that the data is downloaded or fetch directly from s3 (see `../data` for instructions)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b5f89eea", + "metadata": {}, + "outputs": [], + "source": [ + "data_path = \"s3://pert-spectra/data/inhouse.h5ad\"\n", + "adata = read_aws_h5ad(data_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0ab6141-ecf4-4f76-94ed-9ec1aeabf2ae", + "metadata": {}, + "outputs": [], + "source": [ + "adata = inhouse_preprocess(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b45a7b29", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to hvg\n", + "sc.pp.highly_variable_genes(adata, n_top_genes=5000, subset=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8813d26b", + "metadata": {}, + "outputs": [], + "source": [ + "# ensure all perts are in adata\n", + "idx = []\n", + "pert_list = adata.obs[\"condition\"].unique()\n", + "for i in range(len(adata.var_names)):\n", + " if (adata.var[\"highly_variable\"][i]) or (adata.var_names[i] in pert_list):\n", + " idx.append(i)\n", + "adata = adata[:, idx]" + ] + }, + { + "cell_type": "markdown", + "id": "6cb93634-955e-4de4-9364-29fd1efee349", + "metadata": {}, + "source": [ + "## Generating StringDB prior graph" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cade1ddc", + "metadata": {}, + "outputs": [], + "source": [ + "# stringdb prior\n", + "stringdb_hq = read_aws_csv(\"s3://pert-spectra/references/StringDB.HQ.txt\", sep=\"\\t\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "837bd514", + "metadata": {}, + "outputs": [], + "source": [ + "# ensg mapping\n", + "gene_name_df = read_aws_csv(\n", + " \"s3://pert-spectra/references/Homo_sapiens.gene_info\", sep=\"\\t\"\n", + ")\n", + "gene_to_ensg = {}\n", + "gene_name_mapping = {}\n", + "for symbol, synonyms, ref in zip(\n", + " gene_name_df[\"Symbol\"], gene_name_df[\"Synonyms\"], gene_name_df[\"dbXrefs\"]\n", + "):\n", + " syn_set = set(synonyms.split(\"|\")).union(set([symbol]))\n", + " refs = ref.split(\"|\")\n", + " ensg = None\n", + " for r in refs:\n", + " label = r.split(\":\")\n", + " if label[0] == \"Ensembl\":\n", + " ensg = label[1]\n", + " break\n", + " if ensg is None:\n", + " continue\n", + " assert ensg[:4] == \"ENSG\"\n", + " gene_to_ensg[symbol] = ensg\n", + " gene_name_mapping[symbol] = syn_set\n", + " # make sure name mapping goes both ways\n", + " for syn in syn_set:\n", + " if syn in gene_name_mapping:\n", + " gene_name_mapping[syn].add(symbol)\n", + " else:\n", + " gene_name_mapping[syn] = set([symbol])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4c10530a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_11863/2928678895.py:1: ImplicitModificationWarning: Trying to modify attribute `.var` of view, initializing view as actual.\n", + " adata.var['gene_symbols'] = adata.var_names\n" + ] + } + ], + "source": [ + "adata.var[\"gene_symbols\"] = adata.var_names\n", + "adata.var_names = [i.split(\".\")[0] for i in adata.var[\"gene_id\"]]\n", + "inhouse_ensg_to_gene = {}\n", + "for symbol, ensgid in zip(adata.var[\"gene_symbols\"], adata.var_names):\n", + " inhouse_ensg_to_gene[ensgid] = symbol" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5a884a01", + "metadata": {}, + "outputs": [], + "source": [ + "dataset_measured_genes = set(adata.var[\"gene_symbols\"])\n", + "dataset_measured_ensg = set(adata.var_names)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "73bd2fda", + "metadata": {}, + "outputs": [], + "source": [ + "# first, check if gene name has ensembl id\n", + "# if it does, use that to match\n", + "# else, use gene name mapping\n", + "edges = []\n", + "for index, row in stringdb_hq.iterrows():\n", + " gene1 = row[\"i_genes\"]\n", + " gene2 = row[\"j_genes\"]\n", + " if gene1 not in gene_to_ensg:\n", + " # neither gene has ensg\n", + " if gene2 not in gene_to_ensg:\n", + " gene1_syn = set([gene1])\n", + " gene2_syn = set([gene2])\n", + " if gene1 in gene_name_mapping:\n", + " gene1_syn = gene_name_mapping[gene1].union(set([gene1]))\n", + " if gene2 in gene_name_mapping:\n", + " gene2_syn = gene_name_mapping[gene2].union(set([gene2]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_genes)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_genes)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = (\n", + " gene1\n", + " if gene1 in dataset_measured_genes\n", + " else list(alias_intersect_1)[0]\n", + " )\n", + " gene2 = (\n", + " gene2\n", + " if gene2 in dataset_measured_genes\n", + " else list(alias_intersect_2)[0]\n", + " )\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " # gene1 does not have ensemblid, gene2 does have ensemblid\n", + " else:\n", + " ensg2 = gene_to_ensg[gene2]\n", + " gene1_syn = set([gene1])\n", + " gene2_syn = set([ensg2])\n", + " if gene1 in gene_name_mapping:\n", + " gene1_syn = gene_name_mapping[gene1].union(set([gene1]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_genes)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_ensg)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = (\n", + " gene1\n", + " if gene1 in dataset_measured_genes\n", + " else list(alias_intersect_1)[0]\n", + " )\n", + " gene2 = inhouse_ensg_to_gene[list(alias_intersect_2)[0]]\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " else:\n", + " # gene1 has ensemblid, gene2 does not have ensemblid\n", + " if gene2 not in gene_to_ensg:\n", + " ensg1 = gene_to_ensg[gene1]\n", + " gene1_syn = set([ensg1])\n", + " gene2_syn = set([gene2])\n", + " if gene2 in gene_name_mapping:\n", + " gene2_syn = gene_name_mapping[gene2].union(set([gene2]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_ensg)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_genes)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = inhouse_ensg_to_gene[list(alias_intersect_1)[0]]\n", + " gene2 = (\n", + " gene2\n", + " if gene2 in dataset_measured_genes\n", + " else list(alias_intersect_2)[0]\n", + " )\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " # both genes have ensmblid\n", + " else:\n", + " ensg1 = gene_to_ensg[gene1]\n", + " ensg2 = gene_to_ensg[gene2]\n", + " gene1_syn = set([ensg1])\n", + " gene2_syn = set([ensg2])\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_ensg)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_ensg)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = inhouse_ensg_to_gene[list(alias_intersect_1)[0]]\n", + " gene2 = inhouse_ensg_to_gene[list(alias_intersect_2)[0]]\n", + " edges.append([gene1, gene2, row[\"x\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9e2e5c9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gene1gene2score
0GPC1HS3ST10.949
1SLCO2B1HS3ST10.172
2SDC4HS3ST10.930
3HSPG2HS3ST10.941
4GPC6HS3ST10.949
............
210287KRT8MUC5AC0.575
210288GANMUC5AC0.270
210289MYCMUC5AC0.266
210290GCNT7MUC5AC0.905
210291MUC13MUC5AC0.974
\n", + "

210292 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " gene1 gene2 score\n", + "0 GPC1 HS3ST1 0.949\n", + "1 SLCO2B1 HS3ST1 0.172\n", + "2 SDC4 HS3ST1 0.930\n", + "3 HSPG2 HS3ST1 0.941\n", + "4 GPC6 HS3ST1 0.949\n", + "... ... ... ...\n", + "210287 KRT8 MUC5AC 0.575\n", + "210288 GAN MUC5AC 0.270\n", + "210289 MYC MUC5AC 0.266\n", + "210290 GCNT7 MUC5AC 0.905\n", + "210291 MUC13 MUC5AC 0.974\n", + "\n", + "[210292 rows x 3 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inhouse_network = pd.DataFrame(edges, columns=[\"gene1\", \"gene2\", \"score\"])\n", + "inhouse_network" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b6bd6d19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gene1gene2score
0ENSG00000228541ENSG000002285410.000
1STARD13-ASSTARD13-AS0.000
2CLDND2CLDND20.000
3ENSG00000230333ENSG000002303330.000
4ENSG00000246090ENSG000002460900.000
............
211669KRT8MUC5AC0.575
211670GANMUC5AC0.270
211671MYCMUC5AC0.266
211672GCNT7MUC5AC0.905
211673MUC13MUC5AC0.974
\n", + "

211674 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " gene1 gene2 score\n", + "0 ENSG00000228541 ENSG00000228541 0.000\n", + "1 STARD13-AS STARD13-AS 0.000\n", + "2 CLDND2 CLDND2 0.000\n", + "3 ENSG00000230333 ENSG00000230333 0.000\n", + "4 ENSG00000246090 ENSG00000246090 0.000\n", + "... ... ... ...\n", + "211669 KRT8 MUC5AC 0.575\n", + "211670 GAN MUC5AC 0.270\n", + "211671 MYC MUC5AC 0.266\n", + "211672 GCNT7 MUC5AC 0.905\n", + "211673 MUC13 MUC5AC 0.974\n", + "\n", + "[211674 rows x 3 columns]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# add genes measured in inhouse with no connections found in StringDB\n", + "missing_genes = dataset_measured_genes.difference(\n", + " set(inhouse_network[\"gene1\"].unique())\n", + ")\n", + "for g in missing_genes:\n", + " inhouse_network = pd.concat(\n", + " [pd.DataFrame([[g, g, 0]], columns=inhouse_network.columns), inhouse_network],\n", + " ignore_index=True,\n", + " )\n", + "inhouse_network" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "05005170", + "metadata": {}, + "outputs": [], + "source": [ + "# create one-hot-encoding mapping based on adata var structure\n", + "adata.var_names = adata.var[\"gene_symbols\"]\n", + "\n", + "\n", + "def map_gene_to_onehot(name: str):\n", + " return adata.var_names.get_loc(name)\n", + "\n", + "\n", + "inhouse_network[\"gene1\"] = inhouse_network[\"gene1\"].apply(map_gene_to_onehot)\n", + "inhouse_network[\"gene2\"] = inhouse_network[\"gene2\"].apply(map_gene_to_onehot)\n", + "inhouse_network = inhouse_network.sort_values(by=[\"gene1\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b884a780", + "metadata": {}, + "outputs": [], + "source": [ + "# create weighted adj matrix\n", + "import networkx\n", + "\n", + "edgeList = inhouse_network.values.tolist()\n", + "G = networkx.DiGraph()\n", + "for i in range(len(edgeList)):\n", + " G.add_edge(edgeList[i][0], edgeList[i][1], weight=edgeList[i][2])\n", + "A = networkx.adjacency_matrix(\n", + " G, nodelist=[i for i in range(len(adata.var_names))]\n", + ").toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cbd774ea", + "metadata": {}, + "outputs": [], + "source": [ + "# turn to sparse\n", + "from scipy import sparse\n", + "\n", + "sA = sparse.csr_matrix(A)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f262408", + "metadata": {}, + "outputs": [], + "source": [ + "# write to adata\n", + "adata.uns[\"sparse_gene_network\"] = sA\n", + "adata.write_h5ad(\"../inhouse_adata_spectra.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a40a09e3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/data_preprocessing/norman_filtering.ipynb b/data_preprocessing/norman_filtering.ipynb new file mode 100644 index 0000000..cc8fac3 --- /dev/null +++ b/data_preprocessing/norman_filtering.ipynb @@ -0,0 +1,316 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "fe4ff200-83d2-43db-9409-416aea41f2ff", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ea22a349", + "metadata": {}, + "outputs": [], + "source": [ + "import anndata as an\n", + "import matplotlib.pyplot as plt\n", + "import scanpy as sc\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "f1b7d7e3-dfc9-45f4-b313-a19db12bcc7d", + "metadata": {}, + "source": [ + "## Data Filtering\n", + "- Ensure that the data is downloaded (see `../data` for instructions)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4f643f95", + "metadata": {}, + "outputs": [], + "source": [ + "data_path = \"norman.h5ad\"\n", + "adata = an.read_h5ad(data_path)\n", + "sc.pp.calculate_qc_metrics(adata, percent_top=None, log1p=True, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "45a2d041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min read count: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# read_count\n", + "read_count_filter = 100\n", + "print(f\"Min read count: {min(adata.obs['read_count'])}\")\n", + "sns.histplot(adata.obs[\"read_count\"])\n", + "plt.axvline(read_count_filter, 0, 6000, color=\"red\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "591bf5b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min UMI count: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# UMI_count\n", + "umi_count_filter = 10\n", + "print(f\"Min UMI count: {min(adata.obs['UMI_count'])}\")\n", + "sns.histplot(adata.obs[\"UMI_count\"])\n", + "plt.axvline(umi_count_filter, 0, 6000, color=\"red\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bfdaa7ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min total counts: 1633.098876953125\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# total_counts\n", + "total_count_filter = 2000\n", + "print(f\"Min total counts: {min(adata.obs['total_counts'])}\")\n", + "sns.histplot(adata.obs[\"total_counts\"])\n", + "plt.axvline(total_count_filter, 0, 6000, color=\"red\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "bed06790", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min n_genes_by_counts: 974\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# n_genes_by_counts\n", + "print(f\"Min n_genes_by_counts: {min(adata.obs['n_genes_by_counts'])}\")\n", + "sns.histplot(adata.obs[\"n_genes_by_counts\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8fb84285", + "metadata": {}, + "outputs": [], + "source": [ + "# UMAP projections\n", + "sc.pp.neighbors(adata)\n", + "sc.tl.umap(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6a127931", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(\n", + " adata, color=[\"read_count\", \"UMI_count\", \"total_counts\", \"n_genes_by_counts\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1cbf9e8f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(adata, color=\"leiden\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "14b6e48c", + "metadata": {}, + "outputs": [], + "source": [ + "# filter the anndata and save\n", + "filtered_adata = adata[\n", + " (adata.obs[\"read_count\"] >= read_count_filter)\n", + " & (adata.obs[\"UMI_count\"] >= umi_count_filter)\n", + " & (adata.obs[\"total_counts\"] >= total_count_filter)\n", + "]\n", + "filtered_adata.write(\"norman_filtered.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4feaa85", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/data_preprocessing/norman_prior_graph_preprocessing.ipynb b/data_preprocessing/norman_prior_graph_preprocessing.ipynb new file mode 100644 index 0000000..0fe08a5 --- /dev/null +++ b/data_preprocessing/norman_prior_graph_preprocessing.ipynb @@ -0,0 +1,1034 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3cc45e64", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2d35f5c7", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import read_aws_csv, read_aws_h5ad" + ] + }, + { + "cell_type": "markdown", + "id": "f0a90a7f-b171-48e1-83c9-ab73ec9af158", + "metadata": {}, + "source": [ + "## Data Preprocessing\n", + "- Ensure that the data is downloaded (see `../data` for instructions)\n", + "- Ensure that the data was filtered using `norman_filtering.ipynb`" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "b5f89eea", + "metadata": {}, + "outputs": [], + "source": [ + "data_path = \"path to filtered norman.h5ad\"\n", + "adata = read_aws_h5ad(data_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "cb93a4f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "105" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get perturbation genes\n", + "pert_list = set()\n", + "for t in adata.obs[\"perturbation_name\"]:\n", + " if \"+\" not in t and t != \"control\":\n", + " pert_list.add(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c0cc203f", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to hvg\n", + "sc.pp.highly_variable_genes(adata, n_top_genes=5000, subset=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "37d7ff87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 101578 × 5035\n", + " obs: 'guide_identity', 'read_count', 'UMI_count', 'coverage', 'gemgroup', 'good_coverage', 'number_of_cells', 'guide_AHR', 'guide_ARID1A', 'guide_ARRDC3', 'guide_ATL1', 'guide_BAK1', 'guide_BCL2L11', 'guide_BCORL1', 'guide_BPGM', 'guide_C19orf26', 'guide_C3orf72', 'guide_CBFA2T3', 'guide_CBL', 'guide_CDKN1A', 'guide_CDKN1B', 'guide_CDKN1C', 'guide_CEBPA', 'guide_CEBPB', 'guide_CEBPE', 'guide_CELF2', 'guide_CITED1', 'guide_CKS1B', 'guide_CLDN6', 'guide_CNN1', 'guide_CNNM4', 'guide_COL1A1', 'guide_COL2A1', 'guide_CSRNP1', 'guide_DLX2', 'guide_DUSP9', 'guide_EGR1', 'guide_ELMSAN1', 'guide_ETS2', 'guide_FEV', 'guide_FOSB', 'guide_FOXA1', 'guide_FOXA3', 'guide_FOXF1', 'guide_FOXL2', 'guide_FOXO4', 'guide_GLB1L2', 'guide_HES7', 'guide_HK2', 'guide_HNF4A', 'guide_HOXA13', 'guide_HOXB9', 'guide_HOXC13', 'guide_IER5L', 'guide_IGDCC3', 'guide_IKZF3', 'guide_IRF1', 'guide_ISL2', 'guide_JUN', 'guide_KIAA1804', 'guide_KIF18B', 'guide_KIF2C', 'guide_KLF1', 'guide_KMT2A', 'guide_LHX1', 'guide_LYL1', 'guide_MAML2', 'guide_MAP2K3', 'guide_MAP2K6', 'guide_MAP4K3', 'guide_MAP4K5', 'guide_MAP7D1', 'guide_MAPK1', 'guide_MEIS1', 'guide_MIDN', 'guide_NCL', 'guide_NIT1', 'guide_OSR2', 'guide_PLK4', 'guide_POU3F2', 'guide_PRDM1', 'guide_PRTG', 'guide_PTPN1', 'guide_PTPN12', 'guide_PTPN13', 'guide_PTPN9', 'guide_RHOXF2', 'guide_RREB1', 'guide_RUNX1T1', 'guide_S1PR2', 'guide_SAMD1', 'guide_SET', 'guide_SGK1', 'guide_SLC38A2', 'guide_SLC4A1', 'guide_SLC6A9', 'guide_SNAI1', 'guide_SPI1', 'guide_STIL', 'guide_TBX2', 'guide_TBX3', 'guide_TGFBR2', 'guide_TMSB4X', 'guide_TP73', 'guide_TSC22D1', 'guide_UBASH3A', 'guide_UBASH3B', 'guide_ZBTB1', 'guide_ZBTB10', 'guide_ZBTB25', 'guide_ZC3HAV1', 'guide_ZNF318', 'guide_ids', 'n_genes', 'n_genes_by_counts', 'total_counts', 'total_counts_mt', 'pct_counts_mt', 'leiden', 'perturbation_name', 'perturbation_type', 'perturbation_value', 'perturbation_unit', 'log1p_n_genes_by_counts', 'log1p_total_counts'\n", + " var: 'index', 'n_cells', 'mt', 'n_cells_by_counts', 'mean_counts', 'pct_dropout_by_counts', 'total_counts', 'highly_variable', 'means', 'dispersions', 'dispersions_norm', 'log1p_mean_counts', 'log1p_total_counts'\n", + " uns: 'doi', 'guide_ids_colors', 'hvg', 'leiden', 'leiden_colors', 'neighbors', 'pca', 'perturbation_type_colors', 'preprocessing_nb_link', 'umap'\n", + " obsm: 'X_pca', 'X_umap'\n", + " varm: 'PCs'\n", + " layers: 'counts'\n", + " obsp: 'connectivities', 'distances'" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ensure all perts are in adata\n", + "idx = []\n", + "for i in range(len(adata.var_names)):\n", + " if (adata.var[\"highly_variable\"][i]) or (adata.var_names[i] in pert_list):\n", + " idx.append(i)\n", + "adata_subset = adata[:, idx]\n", + "adata_subset" + ] + }, + { + "cell_type": "markdown", + "id": "99cd823e-a774-4e07-a6b1-d1586e5411e3", + "metadata": {}, + "source": [ + "## StringDB prior graph" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "cade1ddc", + "metadata": {}, + "outputs": [], + "source": [ + "# stringdb prior\n", + "stringdb_hq = read_aws_csv(\"s3://pert-spectra/references/StringDB.HQ.txt\", sep=\"\\t\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "9410883b", + "metadata": {}, + "outputs": [], + "source": [ + "# ensg mapping\n", + "gene_name_df = read_aws_csv(\n", + " \"s3://pert-spectra/references/Homo_sapiens.gene_info\", sep=\"\\t\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "977803fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
#tax_idGeneIDSymbolLocusTagSynonymsdbXrefschromosomemap_locationdescriptiontype_of_geneSymbol_from_nomenclature_authorityFull_name_from_nomenclature_authorityNomenclature_statusOther_designationsModification_dateFeature_type
096061A1BG-A1B|ABG|GAB|HYST2477MIM:138670|HGNC:HGNC:5|Ensembl:ENSG00000121410...1919q13.43alpha-1-B glycoproteinprotein-codingA1BGalpha-1-B glycoproteinOalpha-1B-glycoprotein|HEL-S-163pA|epididymis s...20240617-
196062A2M-A2MD|CPAMD5|FWP007|S863-7MIM:103950|HGNC:HGNC:7|Ensembl:ENSG00000175899...1212p13.31alpha-2-macroglobulinprotein-codingA2Malpha-2-macroglobulinOalpha-2-macroglobulin|C3 and PZP-like alpha-2-...20240617-
296063A2MP1-A2MPHGNC:HGNC:8|Ensembl:ENSG00000291190|AllianceGe...1212p13.31alpha-2-macroglobulin pseudogene 1pseudoA2MP1alpha-2-macroglobulin pseudogene 1Opregnancy-zone protein pseudogene20240617-
396069NAT1-AAC1|MNAT|NAT-1|NATIMIM:108345|HGNC:HGNC:7645|Ensembl:ENSG00000171...88p22N-acetyltransferase 1protein-codingNAT1N-acetyltransferase 1Oarylamine N-acetyltransferase 1|N-acetyltransf...20240617-
4960610NAT2-AAC2|NAT-2|PNATMIM:612182|HGNC:HGNC:7646|Ensembl:ENSG00000156...88p22N-acetyltransferase 2protein-codingNAT2N-acetyltransferase 2Oarylamine N-acetyltransferase 2|N-acetyltransf...20240617-
...................................................
1934517411588923215trnD---MT-tRNA-AsptRNA----20200909-
1934527411588923216trnP---MT-tRNA-ProtRNA----20200909-
1934537411588923217trnA---MT-tRNA-AlatRNA----20200909-
1934547411588923218COX1---MT-cytochrome c oxidase subunit Iprotein-coding---cytochrome c oxidase subunit I20230818-
193455741158892321916S rRNA---MT-l-rRNArRNA----20200909-
\n", + "

193456 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " #tax_id GeneID Symbol LocusTag Synonyms \\\n", + "0 9606 1 A1BG - A1B|ABG|GAB|HYST2477 \n", + "1 9606 2 A2M - A2MD|CPAMD5|FWP007|S863-7 \n", + "2 9606 3 A2MP1 - A2MP \n", + "3 9606 9 NAT1 - AAC1|MNAT|NAT-1|NATI \n", + "4 9606 10 NAT2 - AAC2|NAT-2|PNAT \n", + "... ... ... ... ... ... \n", + "193451 741158 8923215 trnD - - \n", + "193452 741158 8923216 trnP - - \n", + "193453 741158 8923217 trnA - - \n", + "193454 741158 8923218 COX1 - - \n", + "193455 741158 8923219 16S rRNA - - \n", + "\n", + " dbXrefs chromosome \\\n", + "0 MIM:138670|HGNC:HGNC:5|Ensembl:ENSG00000121410... 19 \n", + "1 MIM:103950|HGNC:HGNC:7|Ensembl:ENSG00000175899... 12 \n", + "2 HGNC:HGNC:8|Ensembl:ENSG00000291190|AllianceGe... 12 \n", + "3 MIM:108345|HGNC:HGNC:7645|Ensembl:ENSG00000171... 8 \n", + "4 MIM:612182|HGNC:HGNC:7646|Ensembl:ENSG00000156... 8 \n", + "... ... ... \n", + "193451 - MT \n", + "193452 - MT \n", + "193453 - MT \n", + "193454 - MT \n", + "193455 - MT \n", + "\n", + " map_location description type_of_gene \\\n", + "0 19q13.43 alpha-1-B glycoprotein protein-coding \n", + "1 12p13.31 alpha-2-macroglobulin protein-coding \n", + "2 12p13.31 alpha-2-macroglobulin pseudogene 1 pseudo \n", + "3 8p22 N-acetyltransferase 1 protein-coding \n", + "4 8p22 N-acetyltransferase 2 protein-coding \n", + "... ... ... ... \n", + "193451 - tRNA-Asp tRNA \n", + "193452 - tRNA-Pro tRNA \n", + "193453 - tRNA-Ala tRNA \n", + "193454 - cytochrome c oxidase subunit I protein-coding \n", + "193455 - l-rRNA rRNA \n", + "\n", + " Symbol_from_nomenclature_authority \\\n", + "0 A1BG \n", + "1 A2M \n", + "2 A2MP1 \n", + "3 NAT1 \n", + "4 NAT2 \n", + "... ... \n", + "193451 - \n", + "193452 - \n", + "193453 - \n", + "193454 - \n", + "193455 - \n", + "\n", + " Full_name_from_nomenclature_authority Nomenclature_status \\\n", + "0 alpha-1-B glycoprotein O \n", + "1 alpha-2-macroglobulin O \n", + "2 alpha-2-macroglobulin pseudogene 1 O \n", + "3 N-acetyltransferase 1 O \n", + "4 N-acetyltransferase 2 O \n", + "... ... ... \n", + "193451 - - \n", + "193452 - - \n", + "193453 - - \n", + "193454 - - \n", + "193455 - - \n", + "\n", + " Other_designations Modification_date \\\n", + "0 alpha-1B-glycoprotein|HEL-S-163pA|epididymis s... 20240617 \n", + "1 alpha-2-macroglobulin|C3 and PZP-like alpha-2-... 20240617 \n", + "2 pregnancy-zone protein pseudogene 20240617 \n", + "3 arylamine N-acetyltransferase 1|N-acetyltransf... 20240617 \n", + "4 arylamine N-acetyltransferase 2|N-acetyltransf... 20240617 \n", + "... ... ... \n", + "193451 - 20200909 \n", + "193452 - 20200909 \n", + "193453 - 20200909 \n", + "193454 cytochrome c oxidase subunit I 20230818 \n", + "193455 - 20200909 \n", + "\n", + " Feature_type \n", + "0 - \n", + "1 - \n", + "2 - \n", + "3 - \n", + "4 - \n", + "... ... \n", + "193451 - \n", + "193452 - \n", + "193453 - \n", + "193454 - \n", + "193455 - \n", + "\n", + "[193456 rows x 16 columns]" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gene_name_df" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "837bd514", + "metadata": {}, + "outputs": [], + "source": [ + "gene_to_ensg = {}\n", + "gene_name_mapping = {}\n", + "for symbol, synonyms, ref in zip(\n", + " gene_name_df[\"Symbol\"], gene_name_df[\"Synonyms\"], gene_name_df[\"dbXrefs\"]\n", + "):\n", + " syn_set = set(synonyms.split(\"|\")).union(set([symbol]))\n", + " refs = ref.split(\"|\")\n", + " ensg = None\n", + " for r in refs:\n", + " label = r.split(\":\")\n", + " if label[0] == \"Ensembl\":\n", + " ensg = label[1]\n", + " break\n", + " if ensg is None:\n", + " continue\n", + " assert ensg[:4] == \"ENSG\"\n", + " gene_to_ensg[symbol] = ensg\n", + " gene_name_mapping[symbol] = syn_set\n", + " # make sure name mapping goes both ways\n", + " for syn in syn_set:\n", + " if syn in gene_name_mapping:\n", + " gene_name_mapping[syn].add(symbol)\n", + " else:\n", + " gene_name_mapping[syn] = set([symbol])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "4c10530a", + "metadata": {}, + "outputs": [], + "source": [ + "adata_subset.var[\"gene_symbols\"] = adata_subset.var_names.copy()\n", + "adata_subset.var_names = adata_subset.var[\"index\"].copy()\n", + "norman_ensg_to_gene = {}\n", + "for symbol, ensgid in zip(adata_subset.var[\"gene_symbols\"], adata_subset.var_names):\n", + " norman_ensg_to_gene[ensgid] = symbol" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "5a884a01", + "metadata": {}, + "outputs": [], + "source": [ + "dataset_measured_genes = set(adata_subset.var[\"gene_symbols\"])\n", + "dataset_measured_ensg = set(adata_subset.var_names)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "73bd2fda", + "metadata": {}, + "outputs": [], + "source": [ + "# first, check if gene name has ensembl id\n", + "# if it does, use that to match\n", + "# else, use gene name mapping\n", + "edges = []\n", + "for index, row in stringdb_hq.iterrows():\n", + " gene1 = row[\"i_genes\"]\n", + " gene2 = row[\"j_genes\"]\n", + " if gene1 not in gene_to_ensg:\n", + " # neither gene has ensg\n", + " if gene2 not in gene_to_ensg:\n", + " gene1_syn = set([gene1])\n", + " gene2_syn = set([gene2])\n", + " if gene1 in gene_name_mapping:\n", + " gene1_syn = gene_name_mapping[gene1].union(set([gene1]))\n", + " if gene2 in gene_name_mapping:\n", + " gene2_syn = gene_name_mapping[gene2].union(set([gene2]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_genes)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_genes)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = (\n", + " gene1\n", + " if gene1 in dataset_measured_genes\n", + " else list(alias_intersect_1)[0]\n", + " )\n", + " gene2 = (\n", + " gene2\n", + " if gene2 in dataset_measured_genes\n", + " else list(alias_intersect_2)[0]\n", + " )\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " # gene1 does not have ensemblid, gene2 does have ensemblid\n", + " else:\n", + " ensg2 = gene_to_ensg[gene2]\n", + " gene1_syn = set([gene1])\n", + " gene2_syn = set([ensg2])\n", + " if gene1 in gene_name_mapping:\n", + " gene1_syn = gene_name_mapping[gene1].union(set([gene1]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_genes)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_ensg)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = (\n", + " gene1\n", + " if gene1 in dataset_measured_genes\n", + " else list(alias_intersect_1)[0]\n", + " )\n", + " gene2 = norman_ensg_to_gene[list(alias_intersect_2)[0]]\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " else:\n", + " # gene1 has ensemblid, gene2 does not have ensemblid\n", + " if gene2 not in gene_to_ensg:\n", + " ensg1 = gene_to_ensg[gene1]\n", + " gene1_syn = set([ensg1])\n", + " gene2_syn = set([gene2])\n", + " if gene2 in gene_name_mapping:\n", + " gene2_syn = gene_name_mapping[gene2].union(set([gene2]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_ensg)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_genes)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = norman_ensg_to_gene[list(alias_intersect_1)[0]]\n", + " gene2 = (\n", + " gene2\n", + " if gene2 in dataset_measured_genes\n", + " else list(alias_intersect_2)[0]\n", + " )\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " # both genes have ensmblid\n", + " else:\n", + " ensg1 = gene_to_ensg[gene1]\n", + " ensg2 = gene_to_ensg[gene2]\n", + " gene1_syn = set([ensg1])\n", + " gene2_syn = set([ensg2])\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_ensg)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_ensg)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = norman_ensg_to_gene[list(alias_intersect_1)[0]]\n", + " gene2 = norman_ensg_to_gene[list(alias_intersect_2)[0]]\n", + " edges.append([gene1, gene2, row[\"x\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "9e2e5c9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gene1gene2score
0MISPUSH1C0.212
1TUBB1USH1C0.184
2CRYMUSH1C0.289
3LIN7BUSH1C0.152
4TAX1BP3USH1C0.919
............
223491N4BP2ZNF518A0.179
223492PHIPZNF518A0.160
223493BRD2ZNF518A0.228
223494GSTP1ZNF518A0.165
223495MYL12BZNF518A0.189
\n", + "

223496 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " gene1 gene2 score\n", + "0 MISP USH1C 0.212\n", + "1 TUBB1 USH1C 0.184\n", + "2 CRYM USH1C 0.289\n", + "3 LIN7B USH1C 0.152\n", + "4 TAX1BP3 USH1C 0.919\n", + "... ... ... ...\n", + "223491 N4BP2 ZNF518A 0.179\n", + "223492 PHIP ZNF518A 0.160\n", + "223493 BRD2 ZNF518A 0.228\n", + "223494 GSTP1 ZNF518A 0.165\n", + "223495 MYL12B ZNF518A 0.189\n", + "\n", + "[223496 rows x 3 columns]" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "norman_network = pd.DataFrame(edges, columns=[\"gene1\", \"gene2\", \"score\"])\n", + "norman_network" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "b6bd6d19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gene1gene2score
0ZNF720ZNF7200.000
1LINC00467LINC004670.000
2RP3-473L9.4RP3-473L9.40.000
3RP11-380O24.1RP11-380O24.10.000
4LINC01597LINC015970.000
............
225103N4BP2ZNF518A0.179
225104PHIPZNF518A0.160
225105BRD2ZNF518A0.228
225106GSTP1ZNF518A0.165
225107MYL12BZNF518A0.189
\n", + "

225108 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " gene1 gene2 score\n", + "0 ZNF720 ZNF720 0.000\n", + "1 LINC00467 LINC00467 0.000\n", + "2 RP3-473L9.4 RP3-473L9.4 0.000\n", + "3 RP11-380O24.1 RP11-380O24.1 0.000\n", + "4 LINC01597 LINC01597 0.000\n", + "... ... ... ...\n", + "225103 N4BP2 ZNF518A 0.179\n", + "225104 PHIP ZNF518A 0.160\n", + "225105 BRD2 ZNF518A 0.228\n", + "225106 GSTP1 ZNF518A 0.165\n", + "225107 MYL12B ZNF518A 0.189\n", + "\n", + "[225108 rows x 3 columns]" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# add genes measured in Norman with no connections found in StringDB\n", + "missing_genes = dataset_measured_genes.difference(set(norman_network[\"gene1\"].unique()))\n", + "for g in missing_genes:\n", + " norman_network = pd.concat(\n", + " [pd.DataFrame([[g, g, 0]], columns=norman_network.columns), norman_network],\n", + " ignore_index=True,\n", + " )\n", + "norman_network" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "05005170", + "metadata": {}, + "outputs": [], + "source": [ + "# create one-hot-encoding mapping based on adata var structure\n", + "adata_subset.var_names = adata_subset.var[\"gene_symbols\"]\n", + "\n", + "\n", + "def map_gene_to_onehot(name: str):\n", + " return adata_subset.var_names.get_loc(name)\n", + "\n", + "\n", + "norman_network[\"gene1\"] = norman_network[\"gene1\"].apply(map_gene_to_onehot)\n", + "norman_network[\"gene2\"] = norman_network[\"gene2\"].apply(map_gene_to_onehot)\n", + "norman_network = norman_network.sort_values(by=[\"gene1\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "b884a780", + "metadata": {}, + "outputs": [], + "source": [ + "# create weighted adj matrix\n", + "import networkx\n", + "\n", + "edgeList = norman_network.values.tolist()\n", + "G = networkx.DiGraph()\n", + "for i in range(len(edgeList)):\n", + " G.add_edge(edgeList[i][0], edgeList[i][1], weight=edgeList[i][2])\n", + "A = networkx.adjacency_matrix(\n", + " G, nodelist=[i for i in range(len(adata_subset.var_names))]\n", + ").toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "cbd774ea", + "metadata": {}, + "outputs": [], + "source": [ + "# turn to sparse\n", + "from scipy import sparse\n", + "\n", + "sA = sparse.csr_matrix(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "3f262408", + "metadata": {}, + "outputs": [], + "source": [ + "# write to adata\n", + "adata_subset.uns[\"sparse_gene_network\"] = sA\n", + "adata_subset.write_h5ad(\"../norman_adata_spectra.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93494551", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/data_preprocessing/replogle_prior_graph_preprocessing.ipynb b/data_preprocessing/replogle_prior_graph_preprocessing.ipynb new file mode 100644 index 0000000..8d5f174 --- /dev/null +++ b/data_preprocessing/replogle_prior_graph_preprocessing.ipynb @@ -0,0 +1,1102 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3cc45e64", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2d35f5c7", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "from matplotlib import pyplot as plt\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import read_aws_csv, read_aws_h5ad" + ] + }, + { + "cell_type": "markdown", + "id": "0da5cab4-9744-4009-8c38-4623a5b26279", + "metadata": {}, + "source": [ + "## Data Preprocessing\n", + "- Ensure that the data is downloaded (see `../data` for instructions)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b5f89eea", + "metadata": {}, + "outputs": [], + "source": [ + "data_path = \"path to raw replogle.h5ad\"\n", + "adata = read_aws_h5ad(data_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "05562663", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "adata[adata.obs[\"gene\"] != \"non-targeting\"].obs[\"gene\"].value_counts().hist(bins=200)\n", + "plt.title(\"Number of perturbations by number of cells\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "92623d3e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "adata[adata.obs[\"gene_transcript\"] != \"non-targeting\"].obs[\n", + " \"gene_transcript\"\n", + "].value_counts().hist(bins=200)\n", + "plt.title(\"Number of gene transcripts by number of cells\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7b643a2f", + "metadata": {}, + "outputs": [], + "source": [ + "sc.pp.filter_cells(adata, min_counts=100)\n", + "sc.pp.filter_genes(adata, min_cells=100)\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "sc.pp.log1p(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "cb93a4f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2057" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get perturbation genes\n", + "pert_list = set()\n", + "for t in adata.obs[\"gene\"]:\n", + " if \"+\" not in t and t != \"non-targeting\":\n", + " pert_list.add(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "c0cc203f", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to hvg\n", + "sc.pp.highly_variable_genes(adata, n_top_genes=5000, subset=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "37d7ff87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 310385 × 5000\n", + " obs: 'gem_group', 'gene', 'gene_id', 'transcript', 'gene_transcript', 'sgID_AB', 'mitopercent', 'UMI_count', 'z_gemgroup_UMI', 'core_scale_factor', 'core_adjusted_UMI_count'\n", + " var: 'gene_name', 'chr', 'start', 'end', 'class', 'strand', 'length', 'in_matrix', 'mean', 'std', 'cv', 'fano', 'highly_variable', 'means', 'dispersions', 'dispersions_norm'\n", + " uns: 'log1p', 'hvg'" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ensure all perts are in adata\n", + "idx = []\n", + "for i in range(len(adata.var_names)):\n", + " if (adata.var[\"highly_variable\"][i]) or (adata.var_names[i] in pert_list):\n", + " idx.append(i)\n", + "adata_subset = adata[:, idx]\n", + "adata_subset" + ] + }, + { + "cell_type": "markdown", + "id": "2f2ad658-a6cb-465c-b826-f34fd4fbdbed", + "metadata": {}, + "source": [ + "## StringDB prior graph" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "cade1ddc", + "metadata": {}, + "outputs": [], + "source": [ + "# stringdb prior\n", + "stringdb_hq = read_aws_csv(\"s3://pert-spectra/references/StringDB.HQ.txt\", sep=\"\\t\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "9410883b", + "metadata": {}, + "outputs": [], + "source": [ + "# ensg mapping\n", + "gene_name_df = read_aws_csv(\n", + " \"s3://pert-spectra/references/Homo_sapiens.gene_info\", sep=\"\\t\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "977803fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
#tax_idGeneIDSymbolLocusTagSynonymsdbXrefschromosomemap_locationdescriptiontype_of_geneSymbol_from_nomenclature_authorityFull_name_from_nomenclature_authorityNomenclature_statusOther_designationsModification_dateFeature_type
096061A1BG-A1B|ABG|GAB|HYST2477MIM:138670|HGNC:HGNC:5|Ensembl:ENSG00000121410...1919q13.43alpha-1-B glycoproteinprotein-codingA1BGalpha-1-B glycoproteinOalpha-1B-glycoprotein|HEL-S-163pA|epididymis s...20240617-
196062A2M-A2MD|CPAMD5|FWP007|S863-7MIM:103950|HGNC:HGNC:7|Ensembl:ENSG00000175899...1212p13.31alpha-2-macroglobulinprotein-codingA2Malpha-2-macroglobulinOalpha-2-macroglobulin|C3 and PZP-like alpha-2-...20240617-
296063A2MP1-A2MPHGNC:HGNC:8|Ensembl:ENSG00000291190|AllianceGe...1212p13.31alpha-2-macroglobulin pseudogene 1pseudoA2MP1alpha-2-macroglobulin pseudogene 1Opregnancy-zone protein pseudogene20240617-
396069NAT1-AAC1|MNAT|NAT-1|NATIMIM:108345|HGNC:HGNC:7645|Ensembl:ENSG00000171...88p22N-acetyltransferase 1protein-codingNAT1N-acetyltransferase 1Oarylamine N-acetyltransferase 1|N-acetyltransf...20240617-
4960610NAT2-AAC2|NAT-2|PNATMIM:612182|HGNC:HGNC:7646|Ensembl:ENSG00000156...88p22N-acetyltransferase 2protein-codingNAT2N-acetyltransferase 2Oarylamine N-acetyltransferase 2|N-acetyltransf...20240617-
...................................................
1934517411588923215trnD---MT-tRNA-AsptRNA----20200909-
1934527411588923216trnP---MT-tRNA-ProtRNA----20200909-
1934537411588923217trnA---MT-tRNA-AlatRNA----20200909-
1934547411588923218COX1---MT-cytochrome c oxidase subunit Iprotein-coding---cytochrome c oxidase subunit I20230818-
193455741158892321916S rRNA---MT-l-rRNArRNA----20200909-
\n", + "

193456 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " #tax_id GeneID Symbol LocusTag Synonyms \\\n", + "0 9606 1 A1BG - A1B|ABG|GAB|HYST2477 \n", + "1 9606 2 A2M - A2MD|CPAMD5|FWP007|S863-7 \n", + "2 9606 3 A2MP1 - A2MP \n", + "3 9606 9 NAT1 - AAC1|MNAT|NAT-1|NATI \n", + "4 9606 10 NAT2 - AAC2|NAT-2|PNAT \n", + "... ... ... ... ... ... \n", + "193451 741158 8923215 trnD - - \n", + "193452 741158 8923216 trnP - - \n", + "193453 741158 8923217 trnA - - \n", + "193454 741158 8923218 COX1 - - \n", + "193455 741158 8923219 16S rRNA - - \n", + "\n", + " dbXrefs chromosome \\\n", + "0 MIM:138670|HGNC:HGNC:5|Ensembl:ENSG00000121410... 19 \n", + "1 MIM:103950|HGNC:HGNC:7|Ensembl:ENSG00000175899... 12 \n", + "2 HGNC:HGNC:8|Ensembl:ENSG00000291190|AllianceGe... 12 \n", + "3 MIM:108345|HGNC:HGNC:7645|Ensembl:ENSG00000171... 8 \n", + "4 MIM:612182|HGNC:HGNC:7646|Ensembl:ENSG00000156... 8 \n", + "... ... ... \n", + "193451 - MT \n", + "193452 - MT \n", + "193453 - MT \n", + "193454 - MT \n", + "193455 - MT \n", + "\n", + " map_location description type_of_gene \\\n", + "0 19q13.43 alpha-1-B glycoprotein protein-coding \n", + "1 12p13.31 alpha-2-macroglobulin protein-coding \n", + "2 12p13.31 alpha-2-macroglobulin pseudogene 1 pseudo \n", + "3 8p22 N-acetyltransferase 1 protein-coding \n", + "4 8p22 N-acetyltransferase 2 protein-coding \n", + "... ... ... ... \n", + "193451 - tRNA-Asp tRNA \n", + "193452 - tRNA-Pro tRNA \n", + "193453 - tRNA-Ala tRNA \n", + "193454 - cytochrome c oxidase subunit I protein-coding \n", + "193455 - l-rRNA rRNA \n", + "\n", + " Symbol_from_nomenclature_authority \\\n", + "0 A1BG \n", + "1 A2M \n", + "2 A2MP1 \n", + "3 NAT1 \n", + "4 NAT2 \n", + "... ... \n", + "193451 - \n", + "193452 - \n", + "193453 - \n", + "193454 - \n", + "193455 - \n", + "\n", + " Full_name_from_nomenclature_authority Nomenclature_status \\\n", + "0 alpha-1-B glycoprotein O \n", + "1 alpha-2-macroglobulin O \n", + "2 alpha-2-macroglobulin pseudogene 1 O \n", + "3 N-acetyltransferase 1 O \n", + "4 N-acetyltransferase 2 O \n", + "... ... ... \n", + "193451 - - \n", + "193452 - - \n", + "193453 - - \n", + "193454 - - \n", + "193455 - - \n", + "\n", + " Other_designations Modification_date \\\n", + "0 alpha-1B-glycoprotein|HEL-S-163pA|epididymis s... 20240617 \n", + "1 alpha-2-macroglobulin|C3 and PZP-like alpha-2-... 20240617 \n", + "2 pregnancy-zone protein pseudogene 20240617 \n", + "3 arylamine N-acetyltransferase 1|N-acetyltransf... 20240617 \n", + "4 arylamine N-acetyltransferase 2|N-acetyltransf... 20240617 \n", + "... ... ... \n", + "193451 - 20200909 \n", + "193452 - 20200909 \n", + "193453 - 20200909 \n", + "193454 cytochrome c oxidase subunit I 20230818 \n", + "193455 - 20200909 \n", + "\n", + " Feature_type \n", + "0 - \n", + "1 - \n", + "2 - \n", + "3 - \n", + "4 - \n", + "... ... \n", + "193451 - \n", + "193452 - \n", + "193453 - \n", + "193454 - \n", + "193455 - \n", + "\n", + "[193456 rows x 16 columns]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gene_name_df" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "837bd514", + "metadata": {}, + "outputs": [], + "source": [ + "gene_to_ensg = {}\n", + "gene_name_mapping = {}\n", + "for symbol, synonyms, ref in zip(\n", + " gene_name_df[\"Symbol\"], gene_name_df[\"Synonyms\"], gene_name_df[\"dbXrefs\"]\n", + "):\n", + " syn_set = set(synonyms.split(\"|\")).union(set([symbol]))\n", + " refs = ref.split(\"|\")\n", + " ensg = None\n", + " for r in refs:\n", + " label = r.split(\":\")\n", + " if label[0] == \"Ensembl\":\n", + " ensg = label[1]\n", + " break\n", + " if ensg is None:\n", + " continue\n", + " assert ensg[:4] == \"ENSG\"\n", + " gene_to_ensg[symbol] = ensg\n", + " gene_name_mapping[symbol] = syn_set\n", + " # make sure name mapping goes both ways\n", + " for syn in syn_set:\n", + " if syn in gene_name_mapping:\n", + " gene_name_mapping[syn].add(symbol)\n", + " else:\n", + " gene_name_mapping[syn] = set([symbol])" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "4c10530a", + "metadata": {}, + "outputs": [], + "source": [ + "replogle_ensg_to_gene = {}\n", + "for symbol, ensgid in zip(adata_subset.var[\"gene_name\"], adata_subset.var_names):\n", + " replogle_ensg_to_gene[ensgid] = symbol" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "5a884a01", + "metadata": {}, + "outputs": [], + "source": [ + "dataset_measured_genes = set(adata_subset.var[\"gene_name\"])\n", + "dataset_measured_ensg = set(adata_subset.var_names)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "73bd2fda", + "metadata": {}, + "outputs": [], + "source": [ + "# first, check if gene name has ensembl id\n", + "# if it does, use that to match\n", + "# else, use gene name mapping\n", + "edges = []\n", + "for index, row in stringdb_hq.iterrows():\n", + " gene1 = row[\"i_genes\"]\n", + " gene2 = row[\"j_genes\"]\n", + " if gene1 not in gene_to_ensg:\n", + " # neither gene has ensg\n", + " if gene2 not in gene_to_ensg:\n", + " gene1_syn = set([gene1])\n", + " gene2_syn = set([gene2])\n", + " if gene1 in gene_name_mapping:\n", + " gene1_syn = gene_name_mapping[gene1].union(set([gene1]))\n", + " if gene2 in gene_name_mapping:\n", + " gene2_syn = gene_name_mapping[gene2].union(set([gene2]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_genes)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_genes)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = (\n", + " gene1\n", + " if gene1 in dataset_measured_genes\n", + " else list(alias_intersect_1)[0]\n", + " )\n", + " gene2 = (\n", + " gene2\n", + " if gene2 in dataset_measured_genes\n", + " else list(alias_intersect_2)[0]\n", + " )\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " # gene1 does not have ensemblid, gene2 does have ensemblid\n", + " else:\n", + " ensg2 = gene_to_ensg[gene2]\n", + " gene1_syn = set([gene1])\n", + " gene2_syn = set([ensg2])\n", + " if gene1 in gene_name_mapping:\n", + " gene1_syn = gene_name_mapping[gene1].union(set([gene1]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_genes)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_ensg)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = (\n", + " gene1\n", + " if gene1 in dataset_measured_genes\n", + " else list(alias_intersect_1)[0]\n", + " )\n", + " gene2 = replogle_ensg_to_gene[list(alias_intersect_2)[0]]\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " else:\n", + " # gene1 has ensemblid, gene2 does not have ensemblid\n", + " if gene2 not in gene_to_ensg:\n", + " ensg1 = gene_to_ensg[gene1]\n", + " gene1_syn = set([ensg1])\n", + " gene2_syn = set([gene2])\n", + " if gene2 in gene_name_mapping:\n", + " gene2_syn = gene_name_mapping[gene2].union(set([gene2]))\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_ensg)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_genes)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = replogle_ensg_to_gene[list(alias_intersect_1)[0]]\n", + " gene2 = (\n", + " gene2\n", + " if gene2 in dataset_measured_genes\n", + " else list(alias_intersect_2)[0]\n", + " )\n", + " edges.append([gene1, gene2, row[\"x\"]])\n", + "\n", + " # both genes have ensmblid\n", + " else:\n", + " ensg1 = gene_to_ensg[gene1]\n", + " ensg2 = gene_to_ensg[gene2]\n", + " gene1_syn = set([ensg1])\n", + " gene2_syn = set([ensg2])\n", + "\n", + " alias_intersect_1 = gene1_syn.intersection(dataset_measured_ensg)\n", + " alias_intersect_2 = gene2_syn.intersection(dataset_measured_ensg)\n", + "\n", + " if (len(alias_intersect_1) > 0) and (len(alias_intersect_2) > 0):\n", + " gene1 = replogle_ensg_to_gene[list(alias_intersect_1)[0]]\n", + " gene2 = replogle_ensg_to_gene[list(alias_intersect_2)[0]]\n", + " edges.append([gene1, gene2, row[\"x\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "9e2e5c9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gene1gene2score
0M6PRARF50.157
1MIFARF50.164
2AP4S1ARF50.250
3CHMP4BARF50.327
4NME4ARF50.212
............
801575PTGES3EIF3L0.150
801576NR2C2EIF3L0.270
801577NSA2EIF3L0.315
801578PSMB3EIF3L0.169
801579ADSLEIF3L0.161
\n", + "

801580 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " gene1 gene2 score\n", + "0 M6PR ARF5 0.157\n", + "1 MIF ARF5 0.164\n", + "2 AP4S1 ARF5 0.250\n", + "3 CHMP4B ARF5 0.327\n", + "4 NME4 ARF5 0.212\n", + "... ... ... ...\n", + "801575 PTGES3 EIF3L 0.150\n", + "801576 NR2C2 EIF3L 0.270\n", + "801577 NSA2 EIF3L 0.315\n", + "801578 PSMB3 EIF3L 0.169\n", + "801579 ADSL EIF3L 0.161\n", + "\n", + "[801580 rows x 3 columns]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "replogle_network = pd.DataFrame(edges, columns=[\"gene1\", \"gene2\", \"score\"])\n", + "replogle_network" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "b6bd6d19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
gene1gene2score
0SEPTIN2SEPTIN20.000
1ZNF433-AS1ZNF433-AS10.000
2SLC16A1-AS1SLC16A1-AS10.000
3AP000873.2AP000873.20.000
4CHKB-DTCHKB-DT0.000
............
802163PTGES3EIF3L0.150
802164NR2C2EIF3L0.270
802165NSA2EIF3L0.315
802166PSMB3EIF3L0.169
802167ADSLEIF3L0.161
\n", + "

802168 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " gene1 gene2 score\n", + "0 SEPTIN2 SEPTIN2 0.000\n", + "1 ZNF433-AS1 ZNF433-AS1 0.000\n", + "2 SLC16A1-AS1 SLC16A1-AS1 0.000\n", + "3 AP000873.2 AP000873.2 0.000\n", + "4 CHKB-DT CHKB-DT 0.000\n", + "... ... ... ...\n", + "802163 PTGES3 EIF3L 0.150\n", + "802164 NR2C2 EIF3L 0.270\n", + "802165 NSA2 EIF3L 0.315\n", + "802166 PSMB3 EIF3L 0.169\n", + "802167 ADSL EIF3L 0.161\n", + "\n", + "[802168 rows x 3 columns]" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# add genes measured in Replogle with no connections found in StringDB\n", + "missing_genes = dataset_measured_genes.difference(\n", + " set(replogle_network[\"gene1\"].unique())\n", + ")\n", + "for g in missing_genes:\n", + " replogle_network = pd.concat(\n", + " [pd.DataFrame([[g, g, 0]], columns=replogle_network.columns), replogle_network],\n", + " ignore_index=True,\n", + " )\n", + "replogle_network" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05005170", + "metadata": {}, + "outputs": [], + "source": [ + "# create one-hot-encoding mapping based on adata var structure\n", + "adata_subset.var_names = adata_subset.var[\"gene_name\"]\n", + "\n", + "\n", + "def map_gene_to_onehot(name: str):\n", + " return adata_subset.var_names.get_loc(name)\n", + "\n", + "\n", + "replogle_network[\"gene1\"] = replogle_network[\"gene1\"].apply(map_gene_to_onehot)\n", + "replogle_network[\"gene2\"] = replogle_network[\"gene2\"].apply(map_gene_to_onehot)\n", + "replogle_network = replogle_network.sort_values(by=[\"gene1\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "b884a780", + "metadata": {}, + "outputs": [], + "source": [ + "# create weighted adj matrix\n", + "import networkx\n", + "\n", + "edgeList = replogle_network.values.tolist()\n", + "G = networkx.DiGraph()\n", + "for i in range(len(edgeList)):\n", + " G.add_edge(edgeList[i][0], edgeList[i][1], weight=edgeList[i][2])\n", + "A = networkx.adjacency_matrix(\n", + " G, nodelist=[i for i in range(len(adata_subset.var_names))]\n", + ").toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "cbd774ea", + "metadata": {}, + "outputs": [], + "source": [ + "# turn to sparse\n", + "from scipy import sparse\n", + "\n", + "sA = sparse.csr_matrix(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "8a481c1a", + "metadata": {}, + "outputs": [], + "source": [ + "adata_subset.X = sparse.csr_matrix(adata_subset.X)\n", + "adata_subset.layers[\"logcounts\"] = adata_subset.X.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "3f262408", + "metadata": {}, + "outputs": [], + "source": [ + "# write to adata\n", + "adata_subset.uns[\"sparse_gene_network\"] = sA\n", + "adata_subset.write_h5ad(\"../replogle_adata_spectra.h5ad\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93494551", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/environment.yaml b/environment.yaml new file mode 100755 index 0000000..a3f6159 --- /dev/null +++ b/environment.yaml @@ -0,0 +1,11 @@ +name: pertspectra +channels: + - conda-forge + - bioconda + - defaults +dependencies: + - python>=3.11,<3.12 + - pip>=23.2.0 + - pre_commit>=2.20.0 + - pytest-cov>=2.7.1 + - pytest>=7.2.0 diff --git a/figures/figures.ipynb b/figures/figures.ipynb new file mode 100644 index 0000000..3a1d0da --- /dev/null +++ b/figures/figures.ipynb @@ -0,0 +1,813 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "78401ded-13c1-40c3-b027-9b71f36ed06e", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b8dbb8d4-7a06-4c04-8eaa-4b57734bc4de", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import read_aws_csv" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "244869a4-dfa7-4b2d-b8e1-f87c79e2349e", + "metadata": {}, + "outputs": [], + "source": [ + "# aws s3 path to figures data\n", + "figure_data_path = \"s3://pert-spectra/figures/\"" + ] + }, + { + "cell_type": "markdown", + "id": "198bd21e-c8da-4c40-9bd9-927a402ce0af", + "metadata": {}, + "source": [ + "# Time complexity" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "46c09872-9f78-401d-9678-6c6eaaefc14e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load the data\n", + "time_df = read_aws_csv(figure_data_path + \"runtime/time_complexity_cells.txt\", sep=\",\")\n", + "time_df[\" time\"] = time_df[\" time\"] / 60 # Convert time to minutes\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "sns.lineplot(data=time_df, x=\" cells\", y=\" time\", hue=\"model\", marker=\"o\")\n", + "\n", + "# Add labels and title\n", + "plt.xlabel(\"Number of Cells\")\n", + "plt.ylabel(\"Minutes\")\n", + "plt.title(\"Training Time vs. Number of Cells for Different Models\")\n", + "plt.legend(title=\"Model\")\n", + "plt.grid(True)\n", + "plt.yscale(\"log\") # Optional: Use logarithmic scale for y-axis for better visualization\n", + "\n", + "# Show plot\n", + "plt.savefig(\"figure_pngs/training_runtime_cells.png\", dpi=600, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "89468d72-019e-4c28-8fd5-d5da29e01699", + "metadata": {}, + "source": [ + "# Reconstruction - Spearman Correlation" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "853ccb5a-7507-4b96-aec1-f40f2e76a87d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "recon_path = \"reconstruction_spearmans/\"\n", + "data = {\n", + " \"Inhouse\": {\n", + " \"PertSpectra\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"pertspectra_inhouse_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " \"scETM\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"scETM_inhouse_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " \"GSFA\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"GSFA_inhouse_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " },\n", + " \"Norman\": {\n", + " \"PertSpectra\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"pertspectra_norman_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " \"scETM\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"scETM_norman_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " \"GSFA\": list(\n", + " read_aws_csv(\n", + " figure_data_path + recon_path + \"GSFA_norman_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " },\n", + " \"Replogle\": {\n", + " \"PertSpectra\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"pertspectra_replogle_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " \"scETM\": list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"scETM_replogle_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " ),\n", + " \"GSFA\": [\n", + " 0\n", + " for _ in range(\n", + " len(\n", + " list(\n", + " read_aws_csv(\n", + " figure_data_path\n", + " + recon_path\n", + " + \"scETM_replogle_spearman_correlations.csv\",\n", + " header=None,\n", + " )[0]\n", + " )\n", + " )\n", + " )\n", + " ],\n", + " },\n", + "}\n", + "\n", + "# Prepare data for Seaborn\n", + "records = []\n", + "for dataset in data:\n", + " for model in data[dataset]:\n", + " for value in data[dataset][model]:\n", + " records.append(\n", + " {\"Dataset\": dataset, \"Model\": model, \"Spearman Correlation\": value}\n", + " )\n", + "\n", + "df = pd.DataFrame(records)\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "ax = sns.barplot(\n", + " x=\"Dataset\",\n", + " y=\"Spearman Correlation\",\n", + " hue=\"Model\",\n", + " data=df,\n", + " errorbar=\"sd\",\n", + " capsize=0.1,\n", + ")\n", + "\n", + "# Optionally add text labels above the bars\n", + "for i, p in enumerate(ax.patches):\n", + " if i == 6:\n", + " break\n", + " height = p.get_height()\n", + " ax.annotate(\n", + " f\"{height:.2f}\",\n", + " xy=(p.get_x() + p.get_width() / 2, height),\n", + " xytext=(0, 3), # 3 points vertical offset\n", + " textcoords=\"offset points\",\n", + " ha=\"center\",\n", + " va=\"bottom\",\n", + " )\n", + "\n", + "# Add a title and labels\n", + "ax.set_title(\"Reconstruction of Gene Expression\")\n", + "ax.set_ylabel(\"Spearman Correlation\")\n", + "\n", + "# Show legend and plot\n", + "plt.legend(title=\"Model\")\n", + "plt.savefig(\"figure_pngs/recon.png\", dpi=600, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "58ddcb38-4830-4dbf-8b63-d740632b02e6", + "metadata": {}, + "source": [ + "# Signal Recovery/Interpretability of Factors" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a7cbb85a-aa7a-4ec2-b6f6-a5f7575cf08a", + "metadata": {}, + "outputs": [], + "source": [ + "# csvs containing pvalues per perturbation from the hypergeometric tests\n", + "model_recovery_inhouse = read_aws_csv(\n", + " figure_data_path\n", + " + \"process_recovery_hypergeo_pvals/pertspectra_inhouse_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=None,\n", + ")\n", + "gsfa_recovery_inhouse = read_aws_csv(\n", + " figure_data_path\n", + " + \"process_recovery_hypergeo_pvals/GSFA_inhouse_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=None,\n", + ")\n", + "model_recovery_norman = read_aws_csv(\n", + " figure_data_path\n", + " + \"process_recovery_hypergeo_pvals/pertspectra_norman_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=None,\n", + ")\n", + "gsfa_recovery_norman = read_aws_csv(\n", + " figure_data_path\n", + " + \"process_recovery_hypergeo_pvals/GSFA_norman_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=None,\n", + ")\n", + "model_recovery_replogle = read_aws_csv(\n", + " figure_data_path\n", + " + \"process_recovery_hypergeo_pvals/pertspectra_replogle_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "54086b31-2a3e-4caf-8eda-22ae35b52dff", + "metadata": {}, + "outputs": [], + "source": [ + "# inhouse\n", + "assert len(model_recovery_inhouse) == len(gsfa_recovery_inhouse)\n", + "df = model_recovery_inhouse.merge(gsfa_recovery_inhouse, left_on=0, right_on=0)\n", + "model_inhouse_recovered = 0\n", + "gsfa_inhouse_recovered = 0\n", + "for i, row in df.iterrows():\n", + " if row[\"1_x\"] < 0.001:\n", + " model_inhouse_recovered += 1\n", + " if row[\"1_y\"] < 0.001:\n", + " gsfa_inhouse_recovered += 1\n", + "model_inhouse_recovered /= len(model_recovery_inhouse)\n", + "gsfa_inhouse_recovered /= len(gsfa_recovery_inhouse)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2b19d42a-8061-49de-8c51-c5a7f3d2371a", + "metadata": {}, + "outputs": [], + "source": [ + "# norman\n", + "assert len(model_recovery_norman) == len(gsfa_recovery_norman)\n", + "df = model_recovery_norman.merge(gsfa_recovery_norman, left_on=0, right_on=0)\n", + "model_norman_recovered = 0\n", + "gsfa_norman_recovered = 0\n", + "for i, row in df.iterrows():\n", + " if row[\"1_x\"] < 0.001:\n", + " model_norman_recovered += 1\n", + " if row[\"1_y\"] < 0.001:\n", + " gsfa_norman_recovered += 1\n", + "model_norman_recovered /= len(model_recovery_norman)\n", + "gsfa_norman_recovered /= len(gsfa_recovery_norman)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ebec88ad-54f0-4e8a-96e4-5c2a87308721", + "metadata": {}, + "outputs": [], + "source": [ + "# replogle\n", + "model_replogle_recovered = 0\n", + "for i, row in model_recovery_replogle.iterrows():\n", + " if row[1] < 0.001:\n", + " model_replogle_recovered += 1\n", + "model_replogle_recovered /= len(model_recovery_replogle)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bcebc9de-b1b0-4393-9f6b-6b9680feecdb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot fraction of perturbations recovered\n", + "# Define the metrics\n", + "datasets = [\"Inhouse\", \"Norman\", \"Replogle\"]\n", + "models = [\"PertSpectra\", \"GSFA\"]\n", + "values = {\n", + " \"Inhouse\": [model_inhouse_recovered, gsfa_inhouse_recovered],\n", + " \"Norman\": [model_norman_recovered, gsfa_norman_recovered],\n", + " \"Replogle\": [model_replogle_recovered, 0.0],\n", + "}\n", + "\n", + "# Prepare data in long-form for Seaborn\n", + "records = []\n", + "for dataset in datasets:\n", + " for i, model in enumerate(models):\n", + " records.append(\n", + " {\n", + " \"Dataset\": dataset,\n", + " \"Model\": model,\n", + " \"Fraction of Perturbations\": values[dataset][i],\n", + " }\n", + " )\n", + "\n", + "df = pd.DataFrame(records)\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "ax = sns.barplot(\n", + " x=\"Dataset\", y=\"Fraction of Perturbations\", hue=\"Model\", data=df, errorbar=None\n", + ")\n", + "\n", + "# Add a title and labels\n", + "ax.set_title(\"Fraction of Perturbations With Recovered Signal\")\n", + "ax.set_ylabel(\"Fraction of Perturbations\")\n", + "\n", + "# Optionally add text labels above the bars\n", + "for i, p in enumerate(ax.patches):\n", + " if i == 6:\n", + " break\n", + " height = p.get_height()\n", + " ax.annotate(\n", + " f\"{height:.2f}\",\n", + " xy=(p.get_x() + p.get_width() / 2, height),\n", + " xytext=(0, 3), # 3 points vertical offset\n", + " textcoords=\"offset points\",\n", + " ha=\"center\",\n", + " va=\"bottom\",\n", + " )\n", + "\n", + "# Show legend and plot\n", + "plt.legend(title=\"Model\")\n", + "plt.savefig(\"recovered_GO.png\", dpi=600, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "333b3171-2090-428c-a92c-fd0943a03675", + "metadata": {}, + "source": [ + "# AUPRC" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "41226468-7e0a-44dc-a6bb-6c85e5d51b26", + "metadata": {}, + "outputs": [], + "source": [ + "# csvs containing recall metrics\n", + "model_aucpr_inhouse = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/pertspectra_inhouse_aucpr.csv\"\n", + ")\n", + "scETM_aucpr_inhouse = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/scETM_inhouse_aucpr.csv\"\n", + ")\n", + "gsfa_aucpr_inhouse = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/GSFA_inhouse_aucpr.csv\"\n", + ")\n", + "model_aucpr_norman = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/pertspectra_norman_aucpr.csv\"\n", + ")\n", + "scETM_aucpr_norman = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/scETM_norman_aucpr.csv\"\n", + ")\n", + "gsfa_aucpr_norman = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/GSFA_norman_aucpr.csv\"\n", + ")\n", + "model_aucpr_replogle = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/pertspectra_replogle_aucpr.csv\"\n", + ")\n", + "scETM_aucpr_replogle = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/scETM_replogle_aucpr.csv\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1acc7695-5308-4fb5-964c-c999e3999aed", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# StringDb recall\n", + "data = {\n", + " \"Inhouse\": {\n", + " \"PertSpectra\": model_aucpr_inhouse[[\"AUC\"]].iloc[0].values[0],\n", + " \"scETM\": scETM_aucpr_inhouse[[\"AUC\"]].iloc[0].values[0],\n", + " \"GSFA\": gsfa_aucpr_inhouse[[\"AUC\"]].iloc[0].values[0],\n", + " },\n", + " \"Norman\": {\n", + " \"PertSpectra\": model_aucpr_norman[[\"AUC\"]].iloc[0].values[0],\n", + " \"scETM\": scETM_aucpr_norman[[\"AUC\"]].iloc[0].values[0],\n", + " \"GSFA\": gsfa_aucpr_norman[[\"AUC\"]].iloc[0].values[0],\n", + " },\n", + " \"Replogle\": {\n", + " \"PertSpectra\": model_aucpr_replogle[[\"AUC\"]].iloc[0].values[0],\n", + " \"scETM\": scETM_aucpr_replogle[[\"AUC\"]].iloc[0].values[0],\n", + " \"GSFA\": 0,\n", + " },\n", + "}\n", + "\n", + "datasets = data.keys()\n", + "model_labels = [\"PertSpectra\", \"scETM\", \"GSFA\"]\n", + "\n", + "# Prepare data in long-form for Seaborn\n", + "records = []\n", + "for dataset in datasets:\n", + " for model in model_labels:\n", + " records.append(\n", + " {\"Dataset\": dataset, \"Model\": model, \"AUPRC\": data[dataset][model]}\n", + " )\n", + "\n", + "df = pd.DataFrame(records)\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "ax = sns.barplot(x=\"Dataset\", y=\"AUPRC\", hue=\"Model\", data=df, errorbar=None)\n", + "\n", + "# Add a title and labels\n", + "ax.set_title(\"AUPRC for StringDB\")\n", + "ax.set_ylabel(\"AUPRC\")\n", + "\n", + "# Show legend and plot\n", + "plt.legend(title=\"Model\")\n", + "plt.savefig(\"figure_pngs/auprc_stringdb.png\", dpi=600, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8b9f6ef1-ff4a-4951-8885-177b8246c1fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "# Example data setup (assuming model_aucpr_*, scETM_aucpr_*, etc. are appropriately defined DataFrames)\n", + "data = {\n", + " \"Inhouse\": {\n", + " \"PertSpectra\": model_aucpr_inhouse[[\"AUC\"]].iloc[1].values[0],\n", + " \"scETM\": scETM_aucpr_inhouse[[\"AUC\"]].iloc[1].values[0],\n", + " \"GSFA\": gsfa_aucpr_inhouse[[\"AUC\"]].iloc[1].values[0],\n", + " },\n", + " \"Norman\": {\n", + " \"PertSpectra\": model_aucpr_norman[[\"AUC\"]].iloc[1].values[0],\n", + " \"scETM\": scETM_aucpr_norman[[\"AUC\"]].iloc[1].values[0],\n", + " \"GSFA\": gsfa_aucpr_norman[[\"AUC\"]].iloc[1].values[0],\n", + " },\n", + " \"Replogle\": {\n", + " \"PertSpectra\": model_aucpr_replogle[[\"AUC\"]].iloc[1].values[0],\n", + " \"scETM\": scETM_aucpr_replogle[[\"AUC\"]].iloc[1].values[0],\n", + " \"GSFA\": 0,\n", + " },\n", + "}\n", + "\n", + "datasets = data.keys()\n", + "model_labels = [\"PertSpectra\", \"scETM\", \"GSFA\"]\n", + "\n", + "# Prepare data in long-form for Seaborn\n", + "records = []\n", + "for dataset in datasets:\n", + " for model in model_labels:\n", + " records.append(\n", + " {\"Dataset\": dataset, \"Model\": model, \"AUPRC\": data[dataset][model]}\n", + " )\n", + "\n", + "df = pd.DataFrame(records)\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "ax = sns.barplot(x=\"Dataset\", y=\"AUPRC\", hue=\"Model\", data=df, errorbar=None)\n", + "\n", + "# Add a title and labels\n", + "ax.set_title(\"AUPRC for CORUM\")\n", + "ax.set_ylabel(\"AUPRC\")\n", + "\n", + "# Show legend and plot\n", + "plt.legend(title=\"Model\")\n", + "plt.savefig(\"figure_pngs/auprc_corum.png\", dpi=600, bbox_inches=\"tight\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4305070d-375f-4374-9583-07fd867a4514", + "metadata": {}, + "source": [ + "# Best F1" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "83c08895-fe85-4423-9cab-8563c10fa695", + "metadata": {}, + "outputs": [], + "source": [ + "# csvs containing recall metrics\n", + "pertspectra_f1_inhouse = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/pertspectra_inhouse_f1.csv\"\n", + ")\n", + "scETM_f1_inhouse = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/scETM_inhouse_f1.csv\"\n", + ")\n", + "gsfa_f1_inhouse = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/GSFA_inhouse_f1.csv\"\n", + ")\n", + "pertspectra_f1_norman = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/pertspectra_norman_f1.csv\"\n", + ")\n", + "scETM_f1_norman = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/scETM_norman_f1.csv\"\n", + ")\n", + "gsfa_f1_norman = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/GSFA_norman_f1.csv\"\n", + ")\n", + "pertspectra_f1_replogle = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/pertspectra_replogle_f1.csv\"\n", + ")\n", + "scETM_f1_replogle = read_aws_csv(\n", + " figure_data_path + \"pert_embedding_recall/scETM_replogle_f1.csv\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "97cc2c12-2bf0-4045-9b7c-ce5ee0c03807", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = {\n", + " \"Inhouse\": {\n", + " \"PertSpectra\": pertspectra_f1_inhouse[[\"F1\"]].iloc[0].values[0],\n", + " \"scETM\": scETM_f1_inhouse[[\"F1\"]].iloc[0].values[0],\n", + " \"GSFA\": gsfa_f1_inhouse[[\"F1\"]].iloc[0].values[0],\n", + " },\n", + " \"Norman\": {\n", + " \"PertSpectra\": pertspectra_f1_norman[[\"F1\"]].iloc[0].values[0],\n", + " \"scETM\": scETM_f1_norman[[\"F1\"]].iloc[0].values[0],\n", + " \"GSFA\": gsfa_f1_norman[[\"F1\"]].iloc[0].values[0],\n", + " },\n", + " \"Replogle\": {\n", + " \"PertSpectra\": pertspectra_f1_replogle[[\"F1\"]].iloc[0].values[0],\n", + " \"scETM\": scETM_f1_replogle[[\"F1\"]].iloc[0].values[0],\n", + " \"GSFA\": 0,\n", + " },\n", + "}\n", + "\n", + "datasets = data.keys()\n", + "model_labels = [\"PertSpectra\", \"scETM\", \"GSFA\"]\n", + "\n", + "# Prepare data in long-form for Seaborn\n", + "records = []\n", + "for dataset in datasets:\n", + " for model in model_labels:\n", + " records.append({\"Dataset\": dataset, \"Model\": model, \"F1\": data[dataset][model]})\n", + "\n", + "df = pd.DataFrame(records)\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "ax = sns.barplot(x=\"Dataset\", y=\"F1\", hue=\"Model\", data=df, errorbar=None)\n", + "\n", + "# Add a title and labels\n", + "ax.set_title(\"Best F1 for StringDB\")\n", + "ax.set_ylabel(\"F1 Score\")\n", + "\n", + "# Show legend and plot\n", + "plt.legend(title=\"Model\")\n", + "# plt.savefig('figure_pngs/f1_stringdb.png', dpi=600, bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e456118c-735f-40aa-b5b8-7f405dfaf23d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Assuming the model_f1_* variables are DataFrames with F1 scores\n", + "data = {\n", + " \"Inhouse\": {\n", + " \"PertSpectra\": pertspectra_f1_inhouse[[\"F1\"]].iloc[1].values[0],\n", + " \"scETM\": scETM_f1_inhouse[[\"F1\"]].iloc[1].values[0],\n", + " \"GSFA\": gsfa_f1_inhouse[[\"F1\"]].iloc[1].values[0],\n", + " },\n", + " \"Norman\": {\n", + " \"PertSpectra\": pertspectra_f1_norman[[\"F1\"]].iloc[1].values[0],\n", + " \"scETM\": scETM_f1_norman[[\"F1\"]].iloc[1].values[0],\n", + " \"GSFA\": gsfa_f1_norman[[\"F1\"]].iloc[1].values[0],\n", + " },\n", + " \"Replogle\": {\n", + " \"PertSpectra\": pertspectra_f1_replogle[[\"F1\"]].iloc[1].values[0],\n", + " \"scETM\": scETM_f1_replogle[[\"F1\"]].iloc[1].values[0],\n", + " \"GSFA\": 0,\n", + " },\n", + "}\n", + "\n", + "datasets = data.keys()\n", + "model_labels = [\"PertSpectra\", \"scETM\", \"GSFA\"]\n", + "\n", + "# Prepare data in long-form for Seaborn\n", + "records = []\n", + "for dataset in datasets:\n", + " for model in model_labels:\n", + " records.append({\"Dataset\": dataset, \"Model\": model, \"F1\": data[dataset][model]})\n", + "\n", + "df = pd.DataFrame(records)\n", + "\n", + "# Initialize the matplotlib figure\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot with Seaborn\n", + "sns.set(style=\"whitegrid\")\n", + "ax = sns.barplot(x=\"Dataset\", y=\"F1\", hue=\"Model\", data=df, errorbar=None)\n", + "\n", + "# Add a title and labels\n", + "ax.set_title(\"Best F1 for CORUM\")\n", + "ax.set_ylabel(\"F1 Score\")\n", + "\n", + "# Show legend and plot\n", + "plt.legend(title=\"Model\")\n", + "# plt.savefig('figure_pngs/f1_corum.png', dpi=600, bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f3608bd-815f-4efc-acc3-1769ea75b18f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/figures/summary_radar_plot.ipynb b/figures/summary_radar_plot.ipynb new file mode 100644 index 0000000..a1f17a4 --- /dev/null +++ b/figures/summary_radar_plot.ipynb @@ -0,0 +1,1852 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "d93d54a2", + "metadata": {}, + "outputs": [], + "source": [ + "from os import listdir\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import plotly.express as px" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d9d985c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/pertspectra_inhouse_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/pertspectra_inhouse_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/pertspectra_norman_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/pertspectra_norman_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/factor_enrichments/GSFA_norman_factor_enrichment.pickle to factor_enrichments/GSFA_norman_factor_enrichment.pickle\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/GSFA_norman_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/GSFA_norman_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/factor_enrichments/GSFA_inhouse_factor_enrichment.pickle to factor_enrichments/GSFA_inhouse_factor_enrichment.pickle\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/GSFA_inhouse_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/GSFA_inhouse_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/GSFA_inhouse_aucpr.csv to pert_embedding_recall/GSFA_inhouse_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/GSFA_inhouse_f1.csv to pert_embedding_recall/GSFA_inhouse_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/GSFA_norman_f1.csv to pert_embedding_recall/GSFA_norman_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/scETM_inhouse_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/scETM_inhouse_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/GSFA_norman_aucpr.csv to pert_embedding_recall/GSFA_norman_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/pertspectra_inhouse_aucpr.csv to pert_embedding_recall/pertspectra_inhouse_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/pertspectra_inhouse_f1.csv to pert_embedding_recall/pertspectra_inhouse_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/pertspectra_norman_f1.csv to pert_embedding_recall/pertspectra_norman_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/pertspectra_replogle_aucpr.csv to pert_embedding_recall/pertspectra_replogle_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/pertspectra_replogle_f1.csv to pert_embedding_recall/pertspectra_replogle_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/pertspectra_replogle_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/pertspectra_replogle_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/pertspectra_norman_aucpr.csv to pert_embedding_recall/pertspectra_norman_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/scETM_inhouse_aucpr.csv to pert_embedding_recall/scETM_inhouse_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/scETM_inhouse_f1.csv to pert_embedding_recall/scETM_inhouse_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/scETM_norman_f1.csv to pert_embedding_recall/scETM_norman_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/scETM_norman_aucpr.csv to pert_embedding_recall/scETM_norman_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/scETM_replogle_aucpr.csv to pert_embedding_recall/scETM_replogle_aucpr.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_recall/scETM_replogle_f1.csv to pert_embedding_recall/scETM_replogle_f1.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/scETM_norman_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/scETM_norman_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/process_recovery_hypergeo_pvals/GSFA_norman_hypergeo_neighbors_recovery_pvalues.csv to process_recovery_hypergeo_pvals/GSFA_norman_hypergeo_neighbors_recovery_pvalues.csv\n", + "download: s3://pert-spectra/figures/process_recovery_hypergeo_pvals/pertspectra_inhouse_hypergeo_neighbors_recovery_pvalues.csv to process_recovery_hypergeo_pvals/pertspectra_inhouse_hypergeo_neighbors_recovery_pvalues.csv\n", + "download: s3://pert-spectra/figures/process_recovery_hypergeo_pvals/pertspectra_norman_hypergeo_neighbors_recovery_pvalues.csv to process_recovery_hypergeo_pvals/pertspectra_norman_hypergeo_neighbors_recovery_pvalues.csv\n", + "download: s3://pert-spectra/figures/process_recovery_hypergeo_pvals/GSFA_inhouse_hypergeo_neighbors_recovery_pvalues.csv to process_recovery_hypergeo_pvals/GSFA_inhouse_hypergeo_neighbors_recovery_pvalues.csv\n", + "download: s3://pert-spectra/figures/process_recovery_hypergeo_pvals/pertspectra_replogle_hypergeo_neighbors_recovery_pvalues.csv to process_recovery_hypergeo_pvals/pertspectra_replogle_hypergeo_neighbors_recovery_pvalues.csv\n", + "download: s3://pert-spectra/figures/pert_embedding_cluster_gprofiler/scETM_replogle_pert_emb_gprofiler.pickle to pert_embedding_cluster_gprofiler/scETM_replogle_pert_emb_gprofiler.pickle\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/GSFA_inhouse_spearman_correlations.csv to reconstruction_spearmans/GSFA_inhouse_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/scETM_inhouse_spearman_correlations.csv to reconstruction_spearmans/scETM_inhouse_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/factor_enrichments/pertspectra_inhouse_factor_enrichment.pickle to factor_enrichments/pertspectra_inhouse_factor_enrichment.pickle\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/pertspectra_inhouse_spearman_correlations.csv to reconstruction_spearmans/pertspectra_inhouse_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/GSFA_norman_spearman_correlations.csv to reconstruction_spearmans/GSFA_norman_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/runtime/.ipynb_checkpoints/time_complexity_cells-checkpoint.txt to runtime/.ipynb_checkpoints/time_complexity_cells-checkpoint.txt\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/scETM_norman_spearman_correlations.csv to reconstruction_spearmans/scETM_norman_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/pertspectra_replogle_spearman_correlations.csv to reconstruction_spearmans/pertspectra_replogle_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/runtime/.ipynb_checkpoints/time_complexity_perts-checkpoint.txt to runtime/.ipynb_checkpoints/time_complexity_perts-checkpoint.txt\n", + "download: s3://pert-spectra/figures/factor_enrichments/pertspectra_norman_factor_enrichment.pickle to factor_enrichments/pertspectra_norman_factor_enrichment.pickle\n", + "download: s3://pert-spectra/figures/factor_enrichments/pertspectra_replogle_factor_enrichment.pickle to factor_enrichments/pertspectra_replogle_factor_enrichment.pickle\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/scETM_replogle_spearman_correlations.csv to reconstruction_spearmans/scETM_replogle_spearman_correlations.csv\n", + "download: s3://pert-spectra/figures/runtime/time_complexity_cells.txt to runtime/time_complexity_cells.txt\n", + "download: s3://pert-spectra/figures/reconstruction_spearmans/pertspectra_norman_spearman_correlations.csv to reconstruction_spearmans/pertspectra_norman_spearman_correlations.csv\n" + ] + } + ], + "source": [ + "!aws s3 cp --recursive s3://pert-spectra/figures/ . " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "88d496c9", + "metadata": {}, + "outputs": [], + "source": [ + "reconstruction_spearman_files = listdir(\"reconstruction_spearmans/\")\n", + "reconstruction_spearman_dict = {}\n", + "for fname in reconstruction_spearman_files:\n", + " method = fname.split(\"_\")[0]\n", + " if method not in reconstruction_spearman_dict:\n", + " reconstruction_spearman_dict[method] = {}\n", + " dataset = fname.split(\"_\")[1]\n", + " perf = np.mean(\n", + " [\n", + " float(i)\n", + " for i in open(f\"reconstruction_spearmans/{fname}\", \"r\")\n", + " .read()\n", + " .strip()\n", + " .split(\"\\n\")\n", + " ]\n", + " )\n", + " reconstruction_spearman_dict[method][dataset] = perf\n", + "spearman_df = pd.DataFrame.from_dict(reconstruction_spearman_dict).transpose()\n", + "spearman_df.reset_index(inplace=True)\n", + "spearman_df.rename(columns={\"index\": \"model\"}, inplace=True)\n", + "spearman_df = spearman_df.melt(\"model\", var_name=\"Dataset\", value_name=\"Spearman\")\n", + "spearman_df.loc[spearman_df[\"model\"] == \"pertspectra\", \"model\"] = \"PertSpectra\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "59db6493", + "metadata": {}, + "outputs": [], + "source": [ + "runtimes = pd.read_csv(\"runtime/time_complexity_cells.txt\", header=0, sep=\",\")\n", + "runtimes = runtimes.loc[runtimes[\"cells\"] == 10000]\n", + "runtimes[\"time\"] = -1 * np.log10(runtimes[\"time\"])\n", + "runtimes[\"Dataset\"] = \"norman\"\n", + "runtimes2 = runtimes.copy()\n", + "runtimes2[\"Dataset\"] = \"replogle\"\n", + "runtimes3 = runtimes.copy()\n", + "runtimes3[\"Dataset\"] = \"inhouse\"\n", + "runtimes = pd.concat([runtimes, runtimes2, runtimes3])\n", + "runtimes.drop(columns=[\"cells\", \"perturbations\"], inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2e29c05a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
modeltimeDataset
3GSFA-4.137166norman
7scETM-2.995324norman
11PertSpectra-2.718502norman
3GSFA-4.137166replogle
7scETM-2.995324replogle
11PertSpectra-2.718502replogle
3GSFA-4.137166inhouse
7scETM-2.995324inhouse
11PertSpectra-2.718502inhouse
\n", + "
" + ], + "text/plain": [ + " model time Dataset\n", + "3 GSFA -4.137166 norman\n", + "7 scETM -2.995324 norman\n", + "11 PertSpectra -2.718502 norman\n", + "3 GSFA -4.137166 replogle\n", + "7 scETM -2.995324 replogle\n", + "11 PertSpectra -2.718502 replogle\n", + "3 GSFA -4.137166 inhouse\n", + "7 scETM -2.995324 inhouse\n", + "11 PertSpectra -2.718502 inhouse" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "runtimes" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3deb102a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 1\n", + "0 ATP6AP1 1.000000\n", + "1 RPL30 1.000000\n", + "2 DDX21 0.000379\n", + "3 PHB 0.025197\n", + "4 DMAP1 0.100606\n", + " 0 1\n", + "0 AHR 2.638282e-11\n", + "1 ARID1A 1.923624e-01\n", + "2 BAK1 1.453943e-04\n", + "3 BCL2L11 6.373444e-05\n", + "4 CBL 2.470848e-04\n", + " 0 1\n", + "0 AHR 7.461950e-07\n", + "1 ARID1A 6.365297e-06\n", + "2 BAK1 8.785246e-04\n", + "3 BCL2L11 1.197726e-02\n", + "4 CBL 2.916654e-04\n", + " 0 1\n", + "0 RIPK1 0.000001\n", + "1 MAP3K7 1.000000\n", + "2 IKBKB 0.000002\n", + "3 SKP1 1.000000\n", + "4 BIRC3 0.014625\n", + " 0 1\n", + "0 SKP2 5.679505e-05\n", + "1 NFKBIA 1.931082e-08\n", + "2 TRAF2 1.415568e-15\n", + "3 BIRC2 1.293259e-16\n", + "4 TAB1 7.861270e-06\n" + ] + } + ], + "source": [ + "reconstruction_hypergeo_files = listdir(\"process_recovery_hypergeo_pvals/\")\n", + "reconstruction_hypergeo_dict = {}\n", + "for fname in reconstruction_hypergeo_files:\n", + " method = fname.split(\"_\")[0]\n", + " if method not in reconstruction_hypergeo_dict:\n", + " reconstruction_hypergeo_dict[method] = {}\n", + " dataset = fname.split(\"_\")[1]\n", + " perf = pd.read_csv(f\"process_recovery_hypergeo_pvals/{fname}\", header=None, sep=\",\")\n", + " print(perf.head())\n", + " perf[1] = -1 * np.log10(perf[1])\n", + " perf = np.mean(perf[1])\n", + " reconstruction_hypergeo_dict[method][dataset] = perf\n", + "hypergeo_df = pd.DataFrame.from_dict(reconstruction_hypergeo_dict).transpose()\n", + "hypergeo_df.reset_index(inplace=True)\n", + "hypergeo_df.rename(columns={\"index\": \"model\"}, inplace=True)\n", + "hypergeo_df = hypergeo_df.melt(\"model\", var_name=\"Dataset\", value_name=\"hypergeo\")\n", + "hypergeo_df.loc[hypergeo_df[\"model\"] == \"pertspectra\", \"model\"] = \"PertSpectra\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "49c8b694", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2785192646688491\n", + "0.8294573643410853\n", + "0.8203125\n", + "0.6979655712050078\n", + "0.2461233916199274\n", + "0.8203125\n", + "0.6796407185628742\n", + "0.6895475819032763\n" + ] + } + ], + "source": [ + "reconstruction_f1_files = listdir(\"pert_embedding_recall_f1\")\n", + "reconstruction_f1_dict = {}\n", + "for fname in reconstruction_f1_files:\n", + " method = fname.split(\"_\")[0]\n", + " if method not in reconstruction_f1_dict:\n", + " reconstruction_f1_dict[method] = {}\n", + " dataset = fname.split(\"_\")[1]\n", + " perf = pd.read_csv(\n", + " f\"pert_embedding_recall_f1/{fname}\", header=0, index_col=0, sep=\",\"\n", + " )\n", + " perf = perf.loc[\"StringDB\", \"F1\"]\n", + " print(perf)\n", + " reconstruction_f1_dict[method][dataset] = perf\n", + "f1_df = pd.DataFrame.from_dict(reconstruction_f1_dict).transpose()\n", + "f1_df.reset_index(inplace=True)\n", + "f1_df.rename(columns={\"index\": \"model\"}, inplace=True)\n", + "f1_df = f1_df.melt(\"model\", var_name=\"Dataset\", value_name=\"F1\")\n", + "f1_df.loc[f1_df[\"model\"] == \"pertspectra\", \"model\"] = \"PertSpectra\"" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2b55a0b4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7530475544691059\n", + "0.685748863225066\n", + "0.215161882377014\n", + "0.2525738309904994\n", + "0.7260584258594132\n", + "0.7327761570507714\n", + "0.675809046108318\n", + "0.5736430637940849\n" + ] + } + ], + "source": [ + "reconstruction_aucpr_files = listdir(\"pert_embedding_recall_aucpr\")\n", + "reconstruction_aucpr_dict = {}\n", + "for fname in reconstruction_aucpr_files:\n", + " method = fname.split(\"_\")[0]\n", + " if method not in reconstruction_aucpr_dict:\n", + " reconstruction_aucpr_dict[method] = {}\n", + " dataset = fname.split(\"_\")[1]\n", + " perf = pd.read_csv(\n", + " f\"pert_embedding_recall_aucpr/{fname}\", header=0, index_col=0, sep=\",\"\n", + " )\n", + " perf = perf.loc[\"StringDB\", \"AUC\"]\n", + " print(perf)\n", + " reconstruction_aucpr_dict[method][dataset] = perf\n", + "aucpr_df = pd.DataFrame.from_dict(reconstruction_aucpr_dict).transpose()\n", + "aucpr_df.reset_index(inplace=True)\n", + "aucpr_df.rename(columns={\"index\": \"model\"}, inplace=True)\n", + "aucpr_df = aucpr_df.melt(\"model\", var_name=\"Dataset\", value_name=\"auPRC\")\n", + "aucpr_df.loc[aucpr_df[\"model\"] == \"pertspectra\", \"model\"] = \"PertSpectra\"" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "59c55378", + "metadata": {}, + "outputs": [], + "source": [ + "# combine the metrics into 1 df\n", + "all_perf = (\n", + " spearman_df.merge(runtimes, on=[\"model\", \"Dataset\"], how=\"outer\")\n", + " .merge(hypergeo_df, on=[\"model\", \"Dataset\"], how=\"outer\")\n", + " .merge(f1_df, on=[\"model\", \"Dataset\"], how=\"outer\")\n", + " .merge(aucpr_df, on=[\"model\", \"Dataset\"], how=\"outer\")\n", + ")\n", + "all_perf.rename(\n", + " columns={\n", + " \"model\": \"Model\",\n", + " \"Spearman\": \"Spearman R\",\n", + " \"time\": \"Runtime -log10(sec)
21 perts,10K cells\",\n", + " \"hypergeo\": \"Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)\",\n", + " \"F1\": \"Recall:F1\",\n", + " \"auPRC\": \"Recall:auPRC\",\n", + " },\n", + " inplace=True,\n", + ")\n", + "all_perf.loc[all_perf[\"Dataset\"] == \"norman\", \"Dataset\"] = \"Norman\"\n", + "all_perf.loc[all_perf[\"Dataset\"] == \"inhouse\", \"Dataset\"] = \"Inhouse\"\n", + "all_perf.loc[all_perf[\"Dataset\"] == \"replogle\", \"Dataset\"] = \"Replogle\"\n", + "\n", + "for column in all_perf.columns[2::]:\n", + " all_perf[column] = (all_perf[column] - all_perf[column].min()) / (\n", + " all_perf[column].max() - all_perf[column].min()\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "a705ce3a", + "metadata": {}, + "outputs": [], + "source": [ + "all_perf.fillna(0, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "9a8f2cf6", + "metadata": {}, + "outputs": [], + "source": [ + "all_perf_melted = all_perf.melt(id_vars=[\"Model\", \"Dataset\"], var_name=\"Metric\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "d964f716", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "Model=GSFA
Dataset=Inhouse
value=%{r}
Metric=%{theta}", + "legendgroup": "GSFA, Inhouse", + "line": { + "color": "#ff0000", + "dash": "solid" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "GSFA, Inhouse", + "r": [ + 0.011130752463737357, + 0, + 0.0990448741980258, + 0.7601549215706523, + 0.8748829077705612, + 0.011130752463737357 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=GSFA
Dataset=Norman
value=%{r}
Metric=%{theta}", + "legendgroup": "GSFA, Norman", + "line": { + "color": "#ff0000", + "dash": "dot" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "GSFA, Norman", + "r": [ + 0, + 0, + 0.24331602055827575, + 0.9843231068843358, + 0.9623128139117564, + 0 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=GSFA
Dataset=Replogle
value=%{r}
Metric=%{theta}", + "legendgroup": "GSFA, Replogle", + "line": { + "color": "#ff0000", + "dash": "dash" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "GSFA, Replogle", + "r": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=PertSpectra
Dataset=Inhouse
value=%{r}
Metric=%{theta}", + "legendgroup": "PertSpectra, Inhouse", + "line": { + "color": "#00ff00", + "dash": "solid" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "PertSpectra, Inhouse", + "r": [ + 1, + 1, + 1, + 0.7745857445560906, + 0.856403484293659, + 1 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=PertSpectra
Dataset=Norman
value=%{r}
Metric=%{theta}", + "legendgroup": "PertSpectra, Norman", + "line": { + "color": "#00ff00", + "dash": "dot" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "PertSpectra, Norman", + "r": [ + 0.9934537881913026, + 1, + 0.5005301087955898, + 1, + 1, + 0.9934537881913026 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=PertSpectra
Dataset=Replogle
value=%{r}
Metric=%{theta}", + "legendgroup": "PertSpectra, Replogle", + "line": { + "color": "#00ff00", + "dash": "dash" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "PertSpectra, Replogle", + "r": [ + 0.9714246276290128, + 1, + 0, + 0, + 0, + 0.9714246276290128 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=scETM
Dataset=Inhouse
value=%{r}
Metric=%{theta}", + "legendgroup": "scETM, Inhouse", + "line": { + "color": "#0000ff", + "dash": "solid" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "scETM, Inhouse", + "r": [ + 0.9929171151899834, + 0.8048713983489332, + 0, + 0.7431717458879673, + 0.666463525646199, + 0.9929171151899834 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=scETM
Dataset=Norman
value=%{r}
Metric=%{theta}", + "legendgroup": "scETM, Norman", + "line": { + "color": "#0000ff", + "dash": "dot" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "scETM, Norman", + "r": [ + 0.9925487919516428, + 0.8048713983489332, + 0, + 0.9843231068843358, + 0.9498236706980512, + 0.9925487919516428 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + }, + { + "hovertemplate": "Model=scETM
Dataset=Replogle
value=%{r}
Metric=%{theta}", + "legendgroup": "scETM, Replogle", + "line": { + "color": "#0000ff", + "dash": "dash" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "scETM, Replogle", + "r": [ + 0.8292982343569246, + 0.8048713983489332, + 0, + 0.05553572149724144, + 0.06955371848439953, + 0.8292982343569246 + ], + "showlegend": true, + "subplot": "polar", + "theta": [ + "Spearman R", + "Runtime -log10(sec)
21 perts,10K cells", + "Recovery Known Biological Functions
Hypergeometric Test -log10(FDR)", + "Recall:F1", + "Recall:auPRC", + "Spearman R" + ], + "type": "scatterpolar" + } + ], + "layout": { + "legend": { + "title": { + "text": "Model, Dataset" + }, + "tracegroupgap": 0 + }, + "margin": { + "t": 60 + }, + "polar": { + "angularaxis": { + "direction": "counterclockwise", + "rotation": 45 + }, + "domain": { + "x": [ + 0, + 1 + ], + "y": [ + 0, + 1 + ] + } + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "white", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "white", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "#C8D4E3", + "linecolor": "#C8D4E3", + "minorgridcolor": "#C8D4E3", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "#C8D4E3", + "linecolor": "#C8D4E3", + "minorgridcolor": "#C8D4E3", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "white", + "showlakes": true, + "showland": true, + "subunitcolor": "#C8D4E3" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "white", + "polar": { + "angularaxis": { + "gridcolor": "#EBF0F8", + "linecolor": "#EBF0F8", + "ticks": "" + }, + "bgcolor": "white", + "radialaxis": { + "gridcolor": "#EBF0F8", + "linecolor": "#EBF0F8", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "white", + "gridcolor": "#DFE8F3", + "gridwidth": 2, + "linecolor": "#EBF0F8", + "showbackground": true, + "ticks": "", + "zerolinecolor": "#EBF0F8" + }, + "yaxis": { + "backgroundcolor": "white", + "gridcolor": "#DFE8F3", + "gridwidth": 2, + "linecolor": "#EBF0F8", + "showbackground": true, + "ticks": "", + "zerolinecolor": "#EBF0F8" + }, + "zaxis": { + "backgroundcolor": "white", + "gridcolor": "#DFE8F3", + "gridwidth": 2, + "linecolor": "#EBF0F8", + "showbackground": true, + "ticks": "", + "zerolinecolor": "#EBF0F8" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "#DFE8F3", + "linecolor": "#A2B1C6", + "ticks": "" + }, + "baxis": { + "gridcolor": "#DFE8F3", + "linecolor": "#A2B1C6", + "ticks": "" + }, + "bgcolor": "white", + "caxis": { + "gridcolor": "#DFE8F3", + "linecolor": "#A2B1C6", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "#EBF0F8", + "linecolor": "#EBF0F8", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "#EBF0F8", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "#EBF0F8", + "linecolor": "#EBF0F8", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "#EBF0F8", + "zerolinewidth": 2 + } + } + } + } + }, + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = all_perf_melted\n", + "fig = px.line_polar(\n", + " df,\n", + " r=\"value\",\n", + " theta=\"Metric\",\n", + " color=\"Model\",\n", + " line_dash=\"Dataset\",\n", + " line_close=True,\n", + " color_discrete_sequence=[\"#ff0000\", \"#00ff00\", \"#0000ff\"],\n", + " direction=\"counterclockwise\",\n", + " start_angle=45,\n", + " template=\"plotly_white\",\n", + ")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "c00ef03f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function line_polar in module plotly.express._chart_types:\n", + "\n", + "line_polar(data_frame=None, r=None, theta=None, color=None, line_dash=None, hover_name=None, hover_data=None, custom_data=None, line_group=None, text=None, symbol=None, animation_frame=None, animation_group=None, category_orders=None, labels=None, color_discrete_sequence=None, color_discrete_map=None, line_dash_sequence=None, line_dash_map=None, symbol_sequence=None, symbol_map=None, markers=False, direction='clockwise', start_angle=90, line_close=False, line_shape=None, render_mode='auto', range_r=None, range_theta=None, log_r=False, title=None, template=None, width=None, height=None) -> plotly.graph_objs._figure.Figure\n", + " In a polar line plot, each row of `data_frame` is represented as vertex\n", + " of a polyline mark in polar coordinates.\n", + " \n", + " Parameters\n", + " ----------\n", + " data_frame: DataFrame or array-like or dict\n", + " This argument needs to be passed for column names (and not keyword\n", + " names) to be used. Array-like and dict are transformed internally to a\n", + " pandas DataFrame. Optional: if missing, a DataFrame gets constructed\n", + " under the hood using the other arguments.\n", + " r: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " position marks along the radial axis in polar coordinates.\n", + " theta: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " position marks along the angular axis in polar coordinates.\n", + " color: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " assign color to marks.\n", + " line_dash: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " assign dash-patterns to lines.\n", + " hover_name: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like appear in bold\n", + " in the hover tooltip.\n", + " hover_data: str, or list of str or int, or Series or array-like, or dict\n", + " Either a name or list of names of columns in `data_frame`, or pandas\n", + " Series, or array_like objects or a dict with column names as keys, with\n", + " values True (for default formatting) False (in order to remove this\n", + " column from hover information), or a formatting string, for example\n", + " ':.3f' or '|%a' or list-like data to appear in the hover tooltip or\n", + " tuples with a bool or formatting string as first element, and list-like\n", + " data to appear in hover as second element Values from these columns\n", + " appear as extra data in the hover tooltip.\n", + " custom_data: str, or list of str or int, or Series or array-like\n", + " Either name or list of names of columns in `data_frame`, or pandas\n", + " Series, or array_like objects Values from these columns are extra data,\n", + " to be used in widgets or Dash callbacks for example. This data is not\n", + " user-visible but is included in events emitted by the figure (lasso\n", + " selection etc.)\n", + " line_group: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " group rows of `data_frame` into lines.\n", + " text: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like appear in the\n", + " figure as text labels.\n", + " symbol: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " assign symbols to marks.\n", + " animation_frame: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " assign marks to animation frames.\n", + " animation_group: str or int or Series or array-like\n", + " Either a name of a column in `data_frame`, or a pandas Series or\n", + " array_like object. Values from this column or array_like are used to\n", + " provide object-constancy across animation frames: rows with matching\n", + " `animation_group`s will be treated as if they describe the same object\n", + " in each frame.\n", + " category_orders: dict with str keys and list of str values (default `{}`)\n", + " By default, in Python 3.6+, the order of categorical values in axes,\n", + " legends and facets depends on the order in which these values are first\n", + " encountered in `data_frame` (and no order is guaranteed by default in\n", + " Python below 3.6). This parameter is used to force a specific ordering\n", + " of values per column. The keys of this dict should correspond to column\n", + " names, and the values should be lists of strings corresponding to the\n", + " specific display order desired.\n", + " labels: dict with str keys and str values (default `{}`)\n", + " By default, column names are used in the figure for axis titles, legend\n", + " entries and hovers. This parameter allows this to be overridden. The\n", + " keys of this dict should correspond to column names, and the values\n", + " should correspond to the desired label to be displayed.\n", + " color_discrete_sequence: list of str\n", + " Strings should define valid CSS-colors. When `color` is set and the\n", + " values in the corresponding column are not numeric, values in that\n", + " column are assigned colors by cycling through `color_discrete_sequence`\n", + " in the order described in `category_orders`, unless the value of\n", + " `color` is a key in `color_discrete_map`. Various useful color\n", + " sequences are available in the `plotly.express.colors` submodules,\n", + " specifically `plotly.express.colors.qualitative`.\n", + " color_discrete_map: dict with str keys and str values (default `{}`)\n", + " String values should define valid CSS-colors Used to override\n", + " `color_discrete_sequence` to assign a specific colors to marks\n", + " corresponding with specific values. Keys in `color_discrete_map` should\n", + " be values in the column denoted by `color`. Alternatively, if the\n", + " values of `color` are valid colors, the string `'identity'` may be\n", + " passed to cause them to be used directly.\n", + " line_dash_sequence: list of str\n", + " Strings should define valid plotly.js dash-patterns. When `line_dash`\n", + " is set, values in that column are assigned dash-patterns by cycling\n", + " through `line_dash_sequence` in the order described in\n", + " `category_orders`, unless the value of `line_dash` is a key in\n", + " `line_dash_map`.\n", + " line_dash_map: dict with str keys and str values (default `{}`)\n", + " Strings values define plotly.js dash-patterns. Used to override\n", + " `line_dash_sequences` to assign a specific dash-patterns to lines\n", + " corresponding with specific values. Keys in `line_dash_map` should be\n", + " values in the column denoted by `line_dash`. Alternatively, if the\n", + " values of `line_dash` are valid line-dash names, the string\n", + " `'identity'` may be passed to cause them to be used directly.\n", + " symbol_sequence: list of str\n", + " Strings should define valid plotly.js symbols. When `symbol` is set,\n", + " values in that column are assigned symbols by cycling through\n", + " `symbol_sequence` in the order described in `category_orders`, unless\n", + " the value of `symbol` is a key in `symbol_map`.\n", + " symbol_map: dict with str keys and str values (default `{}`)\n", + " String values should define plotly.js symbols Used to override\n", + " `symbol_sequence` to assign a specific symbols to marks corresponding\n", + " with specific values. Keys in `symbol_map` should be values in the\n", + " column denoted by `symbol`. Alternatively, if the values of `symbol`\n", + " are valid symbol names, the string `'identity'` may be passed to cause\n", + " them to be used directly.\n", + " markers: boolean (default `False`)\n", + " If `True`, markers are shown on lines.\n", + " direction: str\n", + " One of '`counterclockwise'` or `'clockwise'`. Default is `'clockwise'`\n", + " Sets the direction in which increasing values of the angular axis are\n", + " drawn.\n", + " start_angle: int (default `90`)\n", + " Sets start angle for the angular axis, with 0 being due east and 90\n", + " being due north.\n", + " line_close: boolean (default `False`)\n", + " If `True`, an extra line segment is drawn between the first and last\n", + " point.\n", + " line_shape: str (default `'linear'`)\n", + " One of `'linear'`, `'spline'`, `'hv'`, `'vh'`, `'hvh'`, or `'vhv'`\n", + " render_mode: str\n", + " One of `'auto'`, `'svg'` or `'webgl'`, default `'auto'` Controls the\n", + " browser API used to draw marks. `'svg'` is appropriate for figures of\n", + " less than 1000 data points, and will allow for fully-vectorized output.\n", + " `'webgl'` is likely necessary for acceptable performance above 1000\n", + " points but rasterizes part of the output. `'auto'` uses heuristics to\n", + " choose the mode.\n", + " range_r: list of two numbers\n", + " If provided, overrides auto-scaling on the radial axis in polar\n", + " coordinates.\n", + " range_theta: list of two numbers\n", + " If provided, overrides auto-scaling on the angular axis in polar\n", + " coordinates.\n", + " log_r: boolean (default `False`)\n", + " If `True`, the radial axis is log-scaled in polar coordinates.\n", + " title: str\n", + " The figure title.\n", + " template: str or dict or plotly.graph_objects.layout.Template instance\n", + " The figure template name (must be a key in plotly.io.templates) or\n", + " definition.\n", + " width: int (default `None`)\n", + " The figure width in pixels.\n", + " height: int (default `None`)\n", + " The figure height in pixels.\n", + " \n", + " Returns\n", + " -------\n", + " plotly.graph_objects.Figure\n", + "\n" + ] + } + ], + "source": [ + "help(px.line_polar)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c75a64d4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/inhouse_GSFA_metrics.ipynb b/inhouse_GSFA_metrics.ipynb new file mode 100644 index 0000000..21afd07 --- /dev/null +++ b/inhouse_GSFA_metrics.ipynb @@ -0,0 +1,632 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " get_gprofiler,\n", + " inhouse_preprocess,\n", + " perturbation_signal_recovery,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + " read_aws_npz,\n", + " read_aws_pickle,\n", + " retrieve_stringdb_neighbors,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "39762015-fa94-4ae8-9038-405f7c56a03b", + "metadata": {}, + "outputs": [], + "source": [ + "# read learned parameters\n", + "Z = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/inhouse_gsfa_outputs/Z.csv\"\n", + ").to_numpy()\n", + "W = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/inhouse_gsfa_outputs/W.csv\"\n", + ").to_numpy()\n", + "F = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/inhouse_gsfa_outputs/F.csv\"\n", + ").to_numpy()\n", + "beta = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/inhouse_gsfa_outputs/beta.csv\"\n", + ").to_numpy()\n", + "lsfr = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/inhouse_gsfa_outputs/lsfr.csv\"\n", + ").to_numpy()\n", + "# read gene and perturbation information\n", + "gene_labels = read_aws_csv(\"s3://pert-spectra/gsfa_checkpoints/inhouse_top_genes.csv\")[\n", + " \"x\"\n", + "].to_numpy()\n", + "pert_labels = read_aws_npz(\"s3://pert-spectra/gsfa_checkpoints/inhouse_G_labels.npz\")[\n", + " \"arr_0\"\n", + "]\n", + "pert_labels = [x.split(\"_\")[1] for x in pert_labels[:-1]]\n", + "pert_labels = pert_labels + [\"ctrl\"]\n", + "# read inputs and preprocessed input\n", + "preprocessed_Y = read_aws_npz(\n", + " \"s3://pert-spectra/gsfa_checkpoints/inhouse_GSFA_preprocessed.npz\"\n", + ")[\"array1\"]\n", + "G = read_aws_npz(\"s3://pert-spectra/gsfa_checkpoints/inhouse_GSFA_inputs.npz\")[\"array2\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "601bbfb0-17ed-4694-850c-fcbf1fef961b", + "metadata": {}, + "outputs": [], + "source": [ + "# read in adata of raw data for reference\n", + "adata = read_aws_h5ad(\"path to raw inhouse h5ad\")\n", + "adata = adata[:, gene_labels - 1]\n", + "adata = inhouse_preprocess(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a6ea3e4a-7c2f-41ba-b136-9ef9a6ab3029", + "metadata": {}, + "outputs": [], + "source": [ + "# filter adata to perturbations with at least 50 samples for each treatment\n", + "adata.obs[\"condition\"] = adata.obs[\"condition\"].astype(str)\n", + "adata.obs[\"Treatment\"] = adata.obs[\"Treatment\"].astype(str)\n", + "adata.obs[\"pert_treat\"] = adata.obs[\"condition\"] + \"+\" + adata.obs[\"Treatment\"]\n", + "obs_df = pd.DataFrame(adata.obs[\"pert_treat\"])\n", + "category_counts = obs_df[\"pert_treat\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"pert_treat\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression (on DE genes if available)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "# for GSFA, measure reconstruction on training\n", + "from scipy.stats import spearmanr\n", + "\n", + "reconstruction = Z @ W.T\n", + "# rebuild pert labels\n", + "G_labels = []\n", + "for row in G:\n", + " pert_idx = np.where(row == 1)[0].tolist()\n", + " perts = [pert_labels[i] for i in pert_idx]\n", + " G_labels.append(\"+\".join(perts))\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "\n", + "for pert in set(G_labels):\n", + " hold_idx = [i for i, x in enumerate(G_labels) if x == pert]\n", + " if not hold_idx:\n", + " continue\n", + " recon = reconstruction[hold_idx]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = preprocessed_Y[hold_idx].mean(axis=0)\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "971dead3-70d4-41a5-98c0-ab485b32da4f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "import seaborn as sns\n", + "\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "cfa5cc5e-a7c8-44b2-92de-2c5d083721a1", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/GSFA_inhouse_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aaf8dc3-7e5b-4748-8685-fc8560bf7fc7", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Put into df\n", + "pert_emb_df = pd.DataFrame(beta[:-1], index=pert_labels)\n", + "pert_emb_df = pert_emb_df.drop(columns=[0]).astype(\"float\")\n", + "\n", + "# Compute the pairwise distances\n", + "df = pert_emb_df.drop(index=[\"ctrl\", \"intergenic\"])\n", + "\n", + "distance = \"euclidean\"\n", + "\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "clustermap = sns.clustermap(distance_matrix, cmap=\"viridis_r\")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5c7d0199-28ac-4e7c-b4b5-180844815fe6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.cluster.hierarchy import dendrogram\n", + "\n", + "den = dendrogram(\n", + " clustermap.dendrogram_col.linkage, labels=distance_matrix.index, color_threshold=2\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0a73d648-3099-47e8-b7d2-6c9e54b4b8c5", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "from collections import defaultdict\n", + "\n", + "\n", + "def get_cluster_classes(den, label=\"ivl\"):\n", + " cluster_idxs = defaultdict(list)\n", + " for c, pi in zip(den[\"color_list\"], den[\"icoord\"]):\n", + " for leg in pi[1:3]:\n", + " i = (leg - 5.0) / 10.0\n", + " if abs(i - int(i)) < 1e-5:\n", + " cluster_idxs[c].append(int(i))\n", + " cluster_classes = {}\n", + " for c, l in cluster_idxs.items(): # noqa\n", + " i_l = [den[label][i] for i in l]\n", + " cluster_classes[c] = i_l\n", + " return cluster_classes\n", + "\n", + "\n", + "clusters = get_cluster_classes(den)\n", + "# extract functions for clusters\n", + "cluster_process = {}\n", + "for c in clusters:\n", + " cluster_df = pd.DataFrame(clusters[c], columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(cluster_df)\n", + " cluster_process[c] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "id": "fa1a6087-7597-4ac7-8c6b-ebc945044ef8", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/GSFA_inhouse_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "2b11d8f8-00ca-47cf-acde-53d5d1c88bef", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "id": "16fceeb8-b9a3-495f-a799-f733d21cba7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.685749\n", + "CORUM 0.536772\n", + " F1 Threshold\n", + "StringDB 0.689548 0.011192\n", + "CORUM 0.632953 0.016780\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/GSFA_inhouse_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/GSFA_inhouse_f1.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": {}, + "outputs": [], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, W.T, fdr=5e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "a9e4b2f0-41d1-434d-b67e-94c6bef8ddd4", + "metadata": {}, + "outputs": [], + "source": [ + "with open(\n", + " \"figures/factor_enrichments/GSFA_inhouse_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "c48ac5d8-e953-4b82-b6ca-9e59bc8e49bf", + "metadata": {}, + "source": [ + "## Overlap with prior knowledge/ground truth (stringdb)\n", + "- Group A: a set of GO terms associated with a perturbation (either drivers from msigdb, or from literature) and its neighbors in stringdb\n", + "- Group B: a set of GO terms from the interpretability analysis\n", + "- Hypergeometric test on the overlap of the two groups" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6867de68-b31b-452d-8f3f-167e5af8d2c9", + "metadata": {}, + "outputs": [], + "source": [ + "# load precomputed factor_to_go dict if available\n", + "filtered_factor_to_go = read_aws_pickle(\n", + " \"s3://pert-spectra/figures/factor_enrichments/GSFA_inhouse_factor_enrichment.pickle\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bf3b1040-d325-4154-9f9e-92d4ec8d9ab7", + "metadata": {}, + "outputs": [], + "source": [ + "# get neighbors for each perturbation\n", + "pert_neighbors = retrieve_stringdb_neighbors(pert_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "781275db-dc25-4733-84e6-010ebbc17cdd", + "metadata": {}, + "outputs": [], + "source": [ + "# construct group A - known processes for each perturbation\n", + "gene_sets = read_aws_pickle(\"s3://pert-spectra/references/GO_to_Gene.pickle\")\n", + "# subset to biological processes\n", + "go_reference = read_aws_csv(\"s3://pert-spectra/references/GO_terms.txt.gz\", zipped=True)\n", + "go_bp = go_reference[go_reference[\"go_category\"] == \"biological_process\"]\n", + "go_bp_ids = set(go_bp[\"go_id\"].values)\n", + "filtered_go_terms = {key: gene_sets[key] for key in go_bp_ids if key in gene_sets}\n", + "\n", + "# GO terms per perturbation AND its neighbors in stringdb\n", + "pert_to_go = {key: set() for key in df.index}\n", + "for goterm in filtered_go_terms:\n", + " for pert in df.index:\n", + " if pert in filtered_go_terms[goterm] and set(\n", + " filtered_go_terms[goterm]\n", + " ).intersection(pert_neighbors[pert]):\n", + " pert_to_go[pert].add(goterm)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "acdb19ec-92d3-4d85-9a0b-23c3711b879b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_32012/994851414.py:11: RuntimeWarning: divide by zero encountered in log\n", + " delta_loading = np.abs(np.log(np.abs(pert_loading))-np.log(np.abs(ctrl_loading)))\n" + ] + } + ], + "source": [ + "# construct set B - model identified processes for each perturbation\n", + "n = 2 # number of top factors to get processes from\n", + "model_pert_to_go = {}\n", + "for pert in pert_emb_df.index:\n", + " if pert in [\"ctrl\", \"intergenic\", \"basal\"]:\n", + " continue\n", + " # get top factors\n", + " pert_emb_df = pd.DataFrame(beta[:-1], index=pert_labels)\n", + " pert_loading = pert_emb_df.loc[pert].to_numpy()[1:].astype(float)\n", + " ctrl_loading = pert_emb_df.loc[\"intergenic\"].to_numpy()[1:].astype(float)\n", + " delta_loading = np.abs(np.log(np.abs(pert_loading)) - np.log(np.abs(ctrl_loading)))\n", + " top_n_factors = np.argpartition(np.array(delta_loading), -n)[-n:]\n", + " # get processes\n", + " model_processes = set()\n", + " for f in top_n_factors:\n", + " proc = filtered_factor_to_go[f]\n", + " model_processes = model_processes.union(set(proc[\"Term\"]))\n", + " model_pert_to_go[pert] = model_processes" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "26781b0d-61c6-45ca-9b42-ee77c73ceed2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overlap for RIPK1: 9 out of 38 in researchDB\n", + "P-value for RIPK1: 1.1308619075120921e-07\n", + "Overlap for MAP3K7: 0 out of 23 in researchDB\n", + "P-value for MAP3K7: 1.0\n", + "Overlap for IKBKB: 7 out of 24 in researchDB\n", + "P-value for IKBKB: 3.830013304044622e-07\n", + "Overlap for SKP1: 0 out of 7 in researchDB\n", + "P-value for SKP1: 1.0\n", + "Overlap for BIRC3: 3 out of 20 in researchDB\n", + "P-value for BIRC3: 0.007686716976516679\n", + "Overlap for TAB2: 0 out of 5 in researchDB\n", + "P-value for TAB2: 1.0\n", + "Overlap for NFKBIA: 6 out of 28 in researchDB\n", + "P-value for NFKBIA: 1.8192895607157648e-05\n", + "Overlap for SKP2: 1 out of 6 in researchDB\n", + "P-value for SKP2: 0.11702982854059442\n", + "Overlap for TRAF6: 4 out of 46 in researchDB\n", + "P-value for TRAF6: 0.018440536255468803\n", + "Overlap for FBXW11: 5 out of 13 in researchDB\n", + "P-value for FBXW11: 3.4478778936666224e-06\n", + "Overlap for TRAF5: 4 out of 14 in researchDB\n", + "P-value for TRAF5: 0.00020482544648502187\n", + "Overlap for CHUK: 7 out of 21 in researchDB\n", + "P-value for CHUK: 1.84359744108617e-07\n", + "Overlap for RBCK1: 0 out of 11 in researchDB\n", + "P-value for RBCK1: 1.0\n", + "Overlap for TAB1: 0 out of 9 in researchDB\n", + "P-value for TAB1: 1.0\n", + "Overlap for IKBKG: 5 out of 17 in researchDB\n", + "P-value for IKBKG: 2.6711340009329823e-05\n", + "Overlap for CUL1: 2 out of 7 in researchDB\n", + "P-value for CUL1: 0.008357243957233893\n", + "Overlap for TNFRSF1A: 7 out of 21 in researchDB\n", + "P-value for TNFRSF1A: 2.298789369209975e-07\n", + "Overlap for TRAF2: 1 out of 29 in researchDB\n", + "P-value for TRAF2: 0.2850611728304155\n", + "Overlap for TRADD: 6 out of 13 in researchDB\n", + "P-value for TRADD: 1.0736863763836888e-07\n", + "Overlap for BIRC2: 4 out of 30 in researchDB\n", + "P-value for BIRC2: 0.0024805517666413985\n", + "Overlap for UBE2N: 0 out of 16 in researchDB\n", + "P-value for UBE2N: 1.0\n" + ] + } + ], + "source": [ + "pvals = perturbation_signal_recovery(\n", + " pert_to_go,\n", + " model_pert_to_go,\n", + " list(filtered_go_terms.keys()),\n", + " list(pert_emb_df.index),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "id": "c3e93509-ea30-44d2-b978-5627a449c255", + "metadata": {}, + "outputs": [], + "source": [ + "# save as csv for visualization\n", + "pd.DataFrame.from_dict(data=pvals, orient=\"index\").to_csv(\n", + " \"figures/process_recovery_hypergeo_pvals/GSFA_inhouse_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c7cbc9b-d955-4778-82ea-9e31b1934f59", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/inhouse_pertspectra_metrics.ipynb b/inhouse_pertspectra_metrics.ipynb new file mode 100644 index 0000000..0e7e833 --- /dev/null +++ b/inhouse_pertspectra_metrics.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " generate_k_fold,\n", + " get_gprofiler,\n", + " perturbation_signal_recovery,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + " read_aws_pickle,\n", + " retrieve_stringdb_neighbors,\n", + " set_seed,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8adbe3c2-a83b-4a8a-95ec-5f4c103f316c", + "metadata": {}, + "outputs": [], + "source": [ + "# read in trained model outputs generated from ./PertSpectra_load_checkpoints/pertspectra_inhouse.ipynb\n", + "adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/PertSpectra_checkpoints/pertspectra_inhouse/fold_0.h5ad\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression of test set\n", + "- Compute correlation for the mean expression aggregated on perturbation, across all kfolds" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d62bb784-fd4f-4a86-acd4-fd54e784aa73", + "metadata": {}, + "outputs": [], + "source": [ + "n_folds = 5\n", + "model_adatas = []\n", + "for n in range(0, n_folds):\n", + " # new adata\n", + " adata_n = adata.copy()\n", + " # load model from checkpoint\n", + " s3_dir = \"s3://pert-spectra/PertSpectra_checkpoints/\"\n", + " experiment_name = \"pertspectra_inhouse/\"\n", + " model_name = f\"fold_{n}.h5ad\"\n", + " m_adata = read_aws_h5ad(s3_dir + experiment_name + model_name)\n", + " model_adatas.append(m_adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ac5cff31-fd20-4c61-8d0b-7eb7d25a213b", + "metadata": {}, + "outputs": [], + "source": [ + "# iterate through all models and get the losses and correlations\n", + "# take the mean loss and correlation for the test set\n", + "from scipy.stats import spearmanr\n", + "\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "\n", + "set_seed(0)\n", + "\n", + "for n in range(n_folds):\n", + " adata_n = model_adatas[n]\n", + " train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata_n, adata_n.X, adata_n.obs[\"condition\"], fold_idx=n\n", + " )\n", + " loss_weights = np.ones(adata_n.shape[0])\n", + " adata_test = adata_n[test_idx]\n", + "\n", + " for pert in adata_test.obs[\"condition\"].unique():\n", + " hold_idx = [\n", + " i\n", + " for i, x in enumerate(\n", + " adata_test[adata_test.obs[\"Treatment\"] == \"TNFA+\"].obs[\"condition\"]\n", + " )\n", + " if x == pert\n", + " ]\n", + " recon = adata_test.uns[\"recon\"]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = np.squeeze(\n", + " np.array(\n", + " adata_test[adata_test.obs[\"Treatment\"] == \"TNFA+\"][hold_idx].X.mean(\n", + " axis=0\n", + " )\n", + " )\n", + " )\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "62812bb6-f82a-4c0b-ad92-18ec1bb9084d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAHHCAYAAAA238WJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABRgklEQVR4nO3deZxO9f//8ec1ZjUrhlkwi7HvUTH2UJNURLZUg7aPDyFKJB9Li4+yli0lJD6kkDaUtcUSIoSQrTAaYYxlhpn3749+c31dZoYZzTXXHPO4325zu7nOeV/nvF7nOteZp3Od64zNGGMEAAAAy3JzdQEAAAD4Zwh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4m75QDdr1izZbDYdOnQoz5Z56NAh2Ww2zZo1K8+WmVPNmjVT9erV8329+Gey2g+bNWumZs2auaymaznjvfJP2Ww2DR8+PE+WlfG+HTNmTJ4sz0q6deumqKgoV5dR4Lny2I68lXE827x5s9PXVVD2m5sKdAcOHNAzzzyjcuXKydvbWwEBAWrYsKEmTpyoixcv5nWNLjNv3jxNmDDB1WU43euvv64lS5a4ugzkwIULFzR8+HCtWbPG1aUAwE07duyYhg8frm3btrm6lBwr6JnAPbdP+OKLL9ShQwd5eXnp8ccfV/Xq1ZWamqrvvvtOL7zwgnbt2qXp06c7o9Z8N2/ePO3cuVP9+vVzmB4ZGamLFy/Kw8PDNYXlsddff10PP/yw2rZt6+pSCpUVK1bk+jkXLlzQiBEjJKlAnd0DbgW32rG9IDt27JhGjBihqKgo1a5d29Xl5EhBzwS5CnQHDx5U586dFRkZqVWrViksLMw+r1evXtq/f7+++OKLf1yUMUaXLl2Sj49PpnmXLl2Sp6en3Nxc92mxzWaTt7e3y9aP/HPlyhWlp6fL09Mzz5ftjGXCGs6fPy9fX19Xl1GguWIb3erH9vT0dKWmprq0x4xjqrNkZIT8VFD2m1ylojfeeEPJycmaMWOGQ5jLUL58efXt29f++MqVK3rllVcUExMjLy8vRUVF6aWXXlJKSorD86KionT//fdr+fLluv322+Xj46N33nlHa9askc1m0/z58/Xyyy+rdOnSKlq0qJKSkiRJGzdu1L333qvAwEAVLVpUTZs21ffff3/DPj799FO1bt1a4eHh8vLyUkxMjF555RWlpaXZxzRr1kxffPGFDh8+LJvNJpvNZr8GJbvPy1etWqXGjRvL19dXQUFBatOmjXbv3u0wZvjw4bLZbNq/f7+6deumoKAgBQYGqnv37rpw4cINa8+wZcsWNWjQQD4+PoqOjta0adMyjUlJSdGwYcNUvnx5eXl5qWzZsho4cKDD9rfZbDp//rxmz55t77Nbt276+eefZbPZtHTpUod12mw21alTx2E9rVq1Ur169RymffXVV/Zt4e/vr9atW2vXrl2ZatyzZ48efvhhFS9eXN7e3rr99tsd1in937UQ33//vfr376+SJUvK19dXDz30kP78888bbqtu3brJz89Pv/32m+Li4uTr66vw8HCNHDlSxhj7uKuvsZowYYJ9v/3ll19yXKsk7dq1S82bN5ePj4/KlCmjV199NcsDWFbX0F26dEnDhw9XxYoV5e3trbCwMLVr104HDhzQoUOHVLJkSUnSiBEj7K/X1deY5XWNWfn555/VrVs3+yUXoaGh6tGjh06dOuUwLjf7ekpKip577jmVLFlS/v7+evDBB/X777/nqB5JOnnypJ544gmFhITI29tbtWrV0uzZs7MdP378eEVGRsrHx0dNmzbVzp07HeafOHFC3bt3V5kyZeTl5aWwsDC1adMm0/WFOdnPM/a/AwcO6L777pO/v7+6du2q3r17y8/PL8v3fZcuXRQaGupwTMrpe2rJkiWqXr26vL29Vb16dS1evDgnmzDH61m1apXc3Nz0n//8x+F58+bNk81m09SpU+3TbDabevfurblz56pSpUry9vZW3bp1tW7dOofnZuwrv/zyix555BEVK1ZMjRo1ss//8MMPVbduXfn4+Kh48eLq3Lmzjh496rCMffv2qX379goNDZW3t7fKlCmjzp076+zZs/YxX3/9tRo1aqSgoCD5+fmpUqVKeumll+zzXXlsz7g+Oq+O7ddu/2rVqsnLy0vLli3LtoaM38UrVqxQ7dq15e3trapVq2rRokWZxp45c0b9+vVT2bJl5eXlpfLly2v06NEOx5HsjqlTpkzRHXfcIUnq3r27/ViWsd2joqLUrVu3LLfR1cfMG2UE6e9PNZ555hmVKFFCAQEBevzxx3X69GmH5d4KmUCSZHKhdOnSply5cjkeHx8fbySZhx9+2EyePNk8/vjjRpJp27atw7jIyEhTvnx5U6xYMTNo0CAzbdo0s3r1arN69WojyVStWtXUrl3bjBs3zowaNcqcP3/erFy50nh6eprY2FgzduxYM378eFOzZk3j6elpNm7caF/2zJkzjSRz8OBB+7S2bduajh07mjfffNNMnTrVdOjQwUgyzz//vH3MihUrTO3atU1wcLCZM2eOmTNnjlm8eLExxpiDBw8aSWbmzJn28V9//bVxd3c3FStWNG+88YYZMWKECQ4ONsWKFXNY97Bhw4wkc9ttt5l27dqZKVOmmCeffNJIMgMHDrzhNm3atKkJDw83pUqVMr179zZvvfWWadSokZFkZsyYYR+XlpZm7rnnHlO0aFHTr18/884775jevXsbd3d306ZNG/u4OXPmGC8vL9O4cWN7nz/88INJS0szQUFBZsCAAfax48ePN25ubsbNzc2cPXvWvp6AgACHbffBBx8Ym81m7r33XvP222+b0aNHm6ioKBMUFOSwLXbu3GkCAwNN1apVzejRo82kSZNMkyZNjM1mM4sWLcr0Gt52222mefPm5u233zYDBgwwRYoUMR07drzhNouPjzfe3t6mQoUK5rHHHjOTJk0y999/v5Fkhg4dah+X8bpWrVrVlCtXzvz3v/8148ePN4cPH85xrcePHzclS5Y0xYoVM8OHDzdvvvmmqVChgqlZs2am/bBp06amadOm9sdXrlwxLVq0MJJM586dzaRJk8yoUaNM8+bNzZIlS0xycrKZOnWqkWQeeugh++u1ffv2XG3P3NSYlTFjxpjGjRubkSNHmunTp5u+ffsaHx8fc+edd5r09HT7uNzs648++qiRZB555BEzadIk065dO3s9w4YNu249Fy5cMFWqVDEeHh7mueeeM2+99ZZp3LixkWQmTJiQ6fWtUaOGiYqKMqNHjzYjRowwxYsXNyVLljQnTpywj23QoIEJDAw0L7/8snnvvffM66+/bu666y6zdu1a+5ic7ufx8fHGy8vLxMTEmPj4eDNt2jTzwQcfmHXr1hlJ5qOPPnLo5/z588bX19f06tUr1+tavny5cXNzM9WrVzfjxo0zQ4YMMYGBgaZatWomMjLyutsxN+vp1auXcXd3N1u2bDHGGHPs2DFTvHhx07JlS4d9QJKpXr26CQ4ONiNHjjSjR482kZGRxsfHx+zYscM+LmNfqVq1qmnTpo2ZMmWKmTx5sjHGmFdffdXYbDbTqVMnM2XKFPuxNSoqypw+fdoYY0xKSoqJjo424eHh5tVXXzXvvfeeGTFihLnjjjvMoUOHjDF/vz88PT3N7bffbiZOnGimTZtmnn/+edOkSZNM+8itcGzP2P5VqlQxJUuWNCNGjDCTJ082P/30U7Y1REZGmooVK5qgoCAzaNAgM27cOFOjRg3j5uZmVqxYYR93/vx5U7NmTVOiRAnz0ksvmWnTppnHH3/c2Gw207dv30zb89pj6qFDh8zIkSONJPP000/bj2UHDhyw1xEfH5/lNrr6mHm9jJDxe6NGjRqmcePG5q233jK9evUybm5upkmTJg77qZUzwdVyHOjOnj1rJGXaYbKzbds2I8k8+eSTDtOff/55I8msWrXKPi0yMtJIMsuWLXMYm/FilStXzly4cME+PT093VSoUMHExcU5vCgXLlww0dHR5u6777ZPyyrQXb2sDM8884wpWrSouXTpkn1a69atszwIZvXi1a5d25QqVcqcOnXKPm379u3Gzc3NPP744/ZpGS9ejx49HJb50EMPmRIlSmRa17WaNm1qJJmxY8fap6WkpNjXn5qaaoz5O6i5ubmZb7/91uH506ZNM5LM999/b5/m6+ub5ZundevW5s4777Q/bteunWnXrp0pUqSI+eqrr4wxxmzdutVIMp9++qkxxphz586ZoKAg89RTTzks68SJEyYwMNBheosWLUyNGjUctnl6erpp0KCBqVChgn1axmt47S+L5557zhQpUsScOXPmutss4z8Wzz77rMN6WrdubTw9Pc2ff/5pjPm/1zUgIMCcPHnSYRk5rbVfv35GksN/Kk6ePGkCAwNvGOjef/99I8mMGzcuUw8Zff/555/Zhhxn1JiVrN4///vf/4wks27dOvu0nO7rGceKf//73w7jHnnkkRwFugkTJhhJ5sMPP7RPS01NNbGxscbPz88kJSUZY/7v9fXx8TG///67fezGjRuNJPPcc88ZY4w5ffq0kWTefPPNbNeZm/08Y/8bNGiQw9j09HRTunRp0759e4fpH330kcO2zM26ateubcLCwhzeEytWrDCSbhjocrOe8+fPm/Lly5tq1aqZS5cumdatW5uAgABz+PBhh+dKMpLM5s2b7dMOHz5svL29zUMPPWSflrGvdOnSxeH5hw4dMkWKFDGvvfaaw/QdO3YYd3d3+/SffvrJSDILFy7Mtr/x48cbSfb3e1ZutWO7JOPm5mZ27dp1w/Ub83+/iz/55BP7tLNnz5qwsDBz22232ae98sorxtfX1/z6668Ozx80aJApUqSIOXLkiDHm+sfUH3/8MdO2vrqO3AS6azOCMf/3e6Nu3br2bWeMMW+88YbD7yxjrJ0Jrpbjj1wzTmH6+/vnaPyXX34pSerfv7/D9AEDBkhSpmvtoqOjFRcXl+Wy4uPjHa6n27Ztm/bt26dHHnlEp06dUmJiohITE3X+/Hm1aNFC69atu+7HR1cv69y5c0pMTFTjxo114cIF7dmzJ0f9Xe348ePatm2bunXrpuLFi9un16xZU3fffbd9W1ztX//6l8Pjxo0b69SpUw6nirPj7u6uZ555xv7Y09NTzzzzjE6ePKktW7ZIkhYuXKgqVaqocuXK9u2TmJio5s2bS5JWr159w/U0btxYW7du1fnz5yVJ3333ne677z7Vrl1b3377rSTp22+/lc1ms3888vXXX+vMmTPq0qWLw3qLFCmievXq2df7119/adWqVerYsaP9NUhMTNSpU6cUFxenffv26Y8//nCo5+mnn5bNZnOoLy0tTYcPH75hL5LUu3dv+78zPopITU3VN9984zCuffv29o82c1vrl19+qfr16+vOO++0P79kyZLq2rXrDev75JNPFBwcrGeffTbTvKv7zkp+1Sg5vn8uXbqkxMRE1a9fX5K0devWTONvtK9nvD/69OnjMO7aC4+z8+WXXyo0NFRdunSxT/Pw8FCfPn2UnJystWvXOoxv27atSpcubX985513ql69evY6fHx85OnpqTVr1mT6aCZDTvfzq/Xs2dPhsc1mU4cOHfTll18qOTnZPn3BggUqXbp0rt9TGceh+Ph4BQYG2pd39913q2rVqjfcjrnpqWjRopo1a5Z2796tJk2a6IsvvtD48eMVERGRabmxsbGqW7eu/XFERITatGmj5cuXO3ykJWXeVxYtWqT09HR17NjRoabQ0FBVqFDBXlNGv8uXL8/2Y6qgoCBJf3+8ltPLC26FY3vTpk1z9PpnCA8P10MPPWR/nPEx5U8//aQTJ07Ya2jcuLGKFSvmUEPLli2VlpaW6SP1a4+pee3ajHC1p59+2uHLCj179pS7u7vDa2f1TJAhx1+KCAgIkPR3szlx+PBhubm5qXz58g7TQ0NDFRQUlOmXcHR0dLbLunbevn37JP39Imbn7NmzKlasWJbzdu3apZdfflmrVq3KtLGuvt4ipzJ6qVSpUqZ5VapU0fLlyzNd4HvtgS+j1tOnT9u3dXbCw8MzXSxcsWJFSX9/ll+/fn3t27dPu3fvzvZNdPLkyRt09fcOdeXKFa1fv15ly5bVyZMn1bhxY+3atcsh0FWtWtW+02a8NhkHl2tl9LZ//34ZYzR06FANHTo02xqv/sV7vW12I25ubipXrpzDtKu32dWu3d9yU+vhw4czXU8oZb1vXOvAgQOqVKmS3N1z/eXzfKtR+js8jhgxQvPnz8+0H2X1/rnRvp5xrIiJibmpeg4fPqwKFSpk+qJUlSpV7POvVqFChUzLqFixoj766CNJkpeXl0aPHq0BAwYoJCRE9evX1/3336/HH39coaGhknK+n2dwd3dXmTJlMo3r1KmTJkyYoKVLl+qRRx5RcnKyvvzySz3zzDP2EJ/TdWX0mVV/lSpVyjJsXy23PTVs2FA9e/bU5MmTFRcXpx49emT5vOy294ULF/Tnn3/at6mU9bHeGJPlMiTZf1FHR0erf//+GjdunObOnavGjRvrwQcf1KOPPmoPe506ddJ7772nJ598UoMGDVKLFi3Url07Pfzww9l+ye5WOLZf73drVsqXL5/pP5BX1xAaGqp9+/bp559/dloNuXW95V+77/j5+SksLMzhuG/1TJAhV4EuPDw808XDN3KjMwsZskvXWc3L+N/Vm2++me3Xnf38/LKcfubMGTVt2lQBAQEaOXKkYmJi5O3tra1bt+rFF1906rdvrlakSJEsp5urLtL/J9LT01WjRg2NGzcuy/lly5a94TJuv/12eXt7a926dYqIiFCpUqVUsWJFNW7cWFOmTFFKSoq+/fZbh//NZWy/OXPmOByoM2SElYxxzz//fLZnZq/9z4Czt1mG7Pa33NSa3/Kzxo4dO+qHH37QCy+8oNq1a8vPz0/p6em69957s3z/5Nfrlpf69eunBx54QEuWLNHy5cs1dOhQjRo1SqtWrdJtt92W4/08g5eXV5ahoX79+oqKitJHH32kRx55RJ999pkuXryoTp062cfkdl03K7frSUlJsd8P8cCBA7pw4YKKFi36j2rI6r1ns9n01VdfZbkfXX2cHzt2rLp166ZPP/1UK1asUJ8+fTRq1Cht2LBBZcqUkY+Pj9atW6fVq1friy++0LJly7RgwQI1b95cK1asyHY/za2Cdmy/3u/Wf1LD3XffrYEDB2Y5PyMA3mwN2eWGtLS0LLfvP+nxVsoEuToS3H///Zo+fbrWr1+v2NjY646NjIxUenq69u3bZ/+fsiQlJCTozJkzioyMzM2qHWT8Tz4gIEAtW7bM1XPXrFmjU6dOadGiRWrSpIl9+sGDBzONzWkYzehl7969mebt2bNHwcHBefr1+2PHjmVK97/++qsk2b91ExMTo+3bt6tFixY37CO7+Z6enrrzzjv17bffKiIiQo0bN5b095m7lJQUzZ07VwkJCQ7bMeO1KVWq1HVfm4yzZR4eHrl+DW9Genq6fvvtN4cDzbXbLDu5qTUyMtJ+puNqWe0b14qJidHGjRt1+fLlbO9nlN1rlV81nj59WitXrtSIESMcvuWY1fJyKuNYkXGGMjf1ZDz/559/Vnp6ukNoyvio5NpjTVa1/vrrr5n2g5iYGA0YMEADBgzQvn37VLt2bY0dO1YffvhhjvfznOjYsaMmTpyopKQkLViwQFFRUfaPsDPqyMm6Mvr8J/tfTtaTYdiwYdq9e7fGjBmjF198UYMGDdJbb72VaVx227to0aI3/BguJiZGxhhFR0dnCglZqVGjhmrUqKGXX35ZP/zwgxo2bKhp06bp1VdflfT3mfoWLVqoRYsWGjdunF5//XUNGTJEq1evzrJnqx/bb0bG2f6rl51VDcnJyf9o379e7cWKFdOZM2cyTT98+HCmT1puZN++fbrrrrvsj5OTk3X8+HHdd999km6NTJAhV7ctGThwoHx9ffXkk08qISEh0/wDBw5o4sSJkmTfWNfeVTnjfxWtW7e+mXolSXXr1lVMTIzGjBnjcO1JhuvdyiIjBV+delNTUzVlypRMY319fXN0ujUsLEy1a9fW7NmzHXbCnTt3asWKFfZtkVeuXLmid955x/44NTVV77zzjkqWLGm/VqVjx476448/9O6772Z6/sWLF+3XxUl/95nVm0f6O7xt3LhRq1evtge64OBgValSRaNHj7aPyRAXF6eAgAC9/vrrunz5cqblZbw2pUqVUrNmzfTOO+/o+PHj2Y7LS5MmTbL/2xijSZMmycPDQy1atLju83JT63333acNGzZo06ZNDvPnzp17w/rat2+vxMREhzqvrleS/QzIta9XftWY1ftHyvw+z41WrVpJUqYwkNNl3nfffTpx4oQWLFhgn3blyhW9/fbb8vPzU9OmTR3GL1myxOH6zE2bNmnjxo32Oi5cuKBLly45PCcmJkb+/v7220LkdD/PiU6dOiklJUWzZ8/WsmXL1LFjR4f5OV3X1ceha2/VkXHrnevJTU8bN27UmDFj1K9fPw0YMEAvvPCCJk2alOl6RUlav369w8e9R48e1aeffqp77rnnhmfF2rVrpyJFimjEiBGZ9jljjP1WOUlJSbpy5YrD/Bo1asjNzc3+mv3111+Zlp/xCc+1t/vIYPVj+804duyYw61ukpKS9MEHH6h27dr2M7cdO3bU+vXrtXz58kzPP3PmTKbXIisZgSar3z0xMTHasGGDUlNT7dM+//zzTLeqyYnp06c77M9Tp07VlStX7O/3WyETZMjVGbqYmBjNmzdPnTp1UpUqVRz+UsQPP/yghQsX2u8dU6tWLcXHx2v69On2U5qbNm3S7Nmz1bZtW4fEnFtubm5677331KpVK1WrVk3du3dX6dKl9ccff2j16tUKCAjQZ599luVzGzRooGLFiik+Pl59+vSRzWbTnDlzsjytWbduXS1YsED9+/fXHXfcIT8/Pz3wwANZLvfNN99Uq1atFBsbqyeeeEIXL17U22+/rcDAwDz7W5QZwsPDNXr0aB06dEgVK1bUggULtG3bNk2fPt1+Zuexxx7TRx99pH/9619avXq1GjZsqLS0NO3Zs0cfffSR/Z5/GX1+8803GjdunMLDwxUdHW2/xqpx48Z67bXXdPToUYfg1qRJE73zzjuKiopyuDYoICBAU6dO1WOPPaY6deqoc+fOKlmypI4cOaIvvvhCDRs2tAeWyZMnq1GjRqpRo4aeeuoplStXTgkJCVq/fr1+//13bd++Pc+2mbe3t5YtW6b4+HjVq1dPX331lb744gu99NJLObpYN6e1Dhw4UHPmzNG9996rvn37ytfXV9OnT7efRbqexx9/XB988IH69++vTZs2qXHjxjp//ry++eYb/fvf/1abNm3k4+OjqlWrasGCBapYsaKKFy+u6tWrq3r16vlSY0BAgJo0aaI33nhDly9fVunSpbVixYos/zebU7Vr11aXLl00ZcoUnT17Vg0aNNDKlSu1f//+HD3/6aef1jvvvKNu3bppy5YtioqK0scff6zvv/9eEyZMyPRFrvLly6tRo0bq2bOnUlJSNGHCBJUoUcL+8dGvv/6qFi1aqGPHjqpatarc3d21ePFiJSQkqHPnzvbtkNP9/Ebq1Kmj8uXLa8iQIUpJSXH4uDW36xo1apRat26tRo0aqUePHvrrr7/09ttvq1q1aln+5/dm1nPp0iXFx8erQoUKeu211yT9fV/Ezz77TN27d9eOHTsczj5Ur15dcXFx6tOnj/0eZBnPuZGYmBi9+uqrGjx4sA4dOqS2bdvK399fBw8e1OLFi/X000/r+eef16pVq9S7d2916NBBFStW1JUrVzRnzhwVKVJE7du3lySNHDlS69atU+vWrRUZGamTJ09qypQpKlOmjMM9765l5WP7zahYsaKeeOIJ/fjjjwoJCdH777+vhIQEzZw50z7mhRde0NKlS3X//ferW7duqlu3rs6fP68dO3bo448/1qFDhxQcHHzd9cTExCgoKEjTpk2Tv7+/fH19Va9ePUVHR+vJJ5/Uxx9/rHvvvVcdO3bUgQMHHM6M50Zqaqr9/bx3715NmTJFjRo10oMPPijp1sgEdrn6Tuz/9+uvv5qnnnrKREVFGU9PT+Pv728aNmxo3n77bYev+F6+fNmMGDHCREdHGw8PD1O2bFkzePBghzHG/P0V5datW2daT8ZXkrP7KvpPP/1k2rVrZ0qUKGG8vLxMZGSk6dixo1m5cqV9TFa3Lfn+++9N/fr1jY+PjwkPDzcDBw40y5cvN5LM6tWr7eOSk5PNI488YoKCghy+9p/VV5SNMeabb74xDRs2ND4+PiYgIMA88MAD5pdffnEYk/EV5Wu/Op9VnVlp2rSpqVatmtm8ebOJjY013t7eJjIy0kyaNCnT2NTUVDN69GhTrVo14+XlZYoVK2bq1q1rRowYYb+PnDHG7NmzxzRp0sT4+PgYSQ5fF09KSjJFihQx/v7+5sqVK/bpH374oZFkHnvssSzrXL16tYmLizOBgYHG29vbxMTEmG7dujncvsAYYw4cOGAef/xxExoaajw8PEzp0qXN/fffbz7++ONM2+bHH3/MtI5rX7OsxMfHG19fX3PgwAH7/ZtCQkLMsGHDTFpamn1cxuua3e0qclKrMcb8/PPPpmnTpsbb29uULl3avPLKK2bGjBk3vG2JMX9/fX7IkCH290xoaKh5+OGH7fdnMsaYH374wdStW9d4enpmuq1HXteYld9//9089NBDJigoyAQGBpoOHTqYY8eOZaolN/v6xYsXTZ8+fUyJEiWMr6+veeCBB8zRo0dzdNsSY4xJSEgw3bt3N8HBwcbT09PUqFEj0/vz6td37NixpmzZsvZ7MGbcy88YYxITE02vXr1M5cqVja+vrwkMDDT16tXLdL84Y3K2n2fsf9czZMgQI8mUL18+2zE5fU998sknpkqVKsbLy8tUrVrVLFq0yMTHx+foPnQ5WU/G7YKuvu2NMcZs3rzZuLu7m549e9qnSTK9evUyH374oalQoYLx8vIyt912W6b3bHb7ytU9NWrUyPj6+hpfX19TuXJl06tXL7N3715jjDG//fab6dGjh4mJiTHe3t6mePHi5q677jLffPONfRkrV640bdq0MeHh4cbT09OEh4ebLl26ONx641Y7tmds/5zK+F28fPlyU7NmTePl5WUqV66c5e/gc+fOmcGDB5vy5csbT09PExwcbBo0aGDGjBljv03IjY6pn376qalatapxd3fPtN3Hjh1rSpcubby8vEzDhg3N5s2bs71tSVb1ZWz3tWvXmqefftoUK1bM+Pn5ma5duzrcSsQYa2eCq9mMKcBXJgN5oFu3bvr4449veIYCQN6y2Wzq1atXjs9WFmbNmjVTYmJirr94mJeioqJUvXp1ff755y6rATfPdX8QFQAAAHmCQAcAAGBxBDoAAACL4xo6AAAAi+MMHQAAgMUR6AAAACwub/4IoMWlp6fr2LFj8vf3d8qfUgEAAHnPGKNz584pPDw8y7+XXJgQ6PT3nzrJyR+rBwAABc/Ro0cd/mpRYUSgk+x/Gujo0aMKCAhwcTUAACAnkpKSVLZs2Ux/4q8wItBJ9o9ZAwICCHQAAFgMl0vxpQgAAADLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMW5u7oAAPnryJEjSkxMdHUZ1xUcHKyIiAhXlwEAlkGgAwqRI0eOqHLlKrp48YKrS7kuH5+i2rNnN6EOAHKIQAcUIomJibp48YLq9RimgLAoV5eTpaTjh7Tx/RFKTEwk0AFADhX4QDd8+HCNGDHCYVqlSpW0Z88eSdKlS5c0YMAAzZ8/XykpKYqLi9OUKVMUEhLiinIBSwgIi1LxiEquLgMAkEcs8aWIatWq6fjx4/af7777zj7vueee02effaaFCxdq7dq1OnbsmNq1a+fCagEAAPJXgT9DJ0nu7u4KDQ3NNP3s2bOaMWOG5s2bp+bNm0uSZs6cqSpVqmjDhg2qX79+fpcKAACQ7yxxhm7fvn0KDw9XuXLl1LVrVx05ckSStGXLFl2+fFktW7a0j61cubIiIiK0fv16V5ULAACQrwr8Gbp69epp1qxZqlSpko4fP64RI0aocePG2rlzp06cOCFPT08FBQU5PCckJEQnTpzIdpkpKSlKSUmxP05KSnJW+QAAAE5X4ANdq1at7P+uWbOm6tWrp8jISH300Ufy8fG5qWWOGjUq0xctAAAArMoSH7leLSgoSBUrVtT+/fsVGhqq1NRUnTlzxmFMQkJCltfcZRg8eLDOnj1r/zl69KiTqwYAAHAeywW65ORkHThwQGFhYapbt648PDy0cuVK+/y9e/fqyJEjio2NzXYZXl5eCggIcPgBAACwqgL/kevzzz+vBx54QJGRkTp27JiGDRumIkWKqEuXLgoMDNQTTzyh/v37q3jx4goICNCzzz6r2NhYvuEKAAAKjQIf6H7//Xd16dJFp06dUsmSJdWoUSNt2LBBJUuWlCSNHz9ebm5uat++vcONhQEAAAqLAh/o5s+ff9353t7emjx5siZPnpxPFQEAABQslruGDgAAAI4IdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZnuUD33//+VzabTf369bNPu3Tpknr16qUSJUrIz89P7du3V0JCguuKBAAAyEeWCnQ//vij3nnnHdWsWdNh+nPPPafPPvtMCxcu1Nq1a3Xs2DG1a9fORVUCAADkL8sEuuTkZHXt2lXvvvuuihUrZp9+9uxZzZgxQ+PGjVPz5s1Vt25dzZw5Uz/88IM2bNjgwooBAADyh2UCXa9evdS6dWu1bNnSYfqWLVt0+fJlh+mVK1dWRESE1q9fn99lAgAA5Dt3VxeQE/Pnz9fWrVv1448/Zpp34sQJeXp6KigoyGF6SEiITpw4keXyUlJSlJKSYn+clJSUp/UCAADkpwJ/hu7o0aPq27ev5s6dK29v7zxZ5qhRoxQYGGj/KVu2bJ4sFwAAwBUKfKDbsmWLTp48qTp16sjd3V3u7u5au3at3nrrLbm7uyskJESpqak6c+aMw/MSEhIUGhqa5TIHDx6ss2fP2n+OHj2aD50AAAA4R4H/yLVFixbasWOHw7Tu3burcuXKevHFF1W2bFl5eHho5cqVat++vSRp7969OnLkiGJjY7NcppeXl7y8vJxeOwAAQH4o8IHO399f1atXd5jm6+urEiVK2Kc/8cQT6t+/v4oXL66AgAA9++yzio2NVf369V1RMgAAQL4q8IEuJ8aPHy83Nze1b99eKSkpiouL05QpU1xdFgAAQL6wZKBbs2aNw2Nvb29NnjxZkydPdk1BAAAALmTJQAfg1rd7925Xl3BdwcHBioiIcHUZACCJQAeggLl49pQkmx599FFXl3JdPj5FtWfPbkIdgAKBQAegQLl84Zwko9qPvKiS0ZVdXU6Wko4f0sb3RygxMZFAB6BAINABKJD8SkWoeEQlV5cBAJZQ4G8sDAAAgOsj0AEAAFgcgQ4AAMDiCHQAAAAWR6ADAACwOAIdAACAxRHoAAAALI5ABwAAYHEEOgAAAIsj0AEAAFgcgQ4AAMDiCHQAAAAWR6ADAACwOAIdAACAxRHoAAAALI5ABwAAYHEEOgAAAIsj0AEAAFgcgQ4AAMDiCHQAAAAWR6ADAACwOAIdAACAxRHoAAAALM7d1QUAt5IjR44oMTHR1WVka/fu3a4uAQDgBAQ6II8cOXJElStX0cWLF1xdyg1dTkl1dQkAgDxEoAPySGJioi5evKB6PYYpICzK1eVk6fiO9dq5dLquXLni6lIAAHmIQAfksYCwKBWPqOTqMrKUdPyQq0sAADgBX4oAAACwOAIdAACAxRHoAAAALI5r6GAZ3BIEAICsEehgCdwSBACA7BHoYAncEgQAgOwR6GAp3BIEAIDM+FIEAACAxRHoAAAALI5ABwAAYHEEOgAAAIsj0AEAAFgcgQ4AAMDiCHQAAAAWR6ADAACwOAIdAACAxRHoAAAALI5ABwAAYHEEOgAAAIsj0AEAAFgcgQ4AAMDiCHQAAAAWR6ADAACwOAIdAACAxbm7ugAAsKrdu3e7uoTrCg4OVkREhKvLAJAPCHQAkEsXz56SZNOjjz7q6lKuy8enqPbs2U2oAwoBAh0A5NLlC+ckGdV+5EWVjK7s6nKylHT8kDa+P0KJiYkEOqAQKPCBburUqZo6daoOHTokSapWrZr+85//qFWrVpKkS5cuacCAAZo/f75SUlIUFxenKVOmKCQkxIVVAygM/EpFqHhEJVeXAQAF/0sRZcqU0X//+19t2bJFmzdvVvPmzdWmTRvt2rVLkvTcc8/ps88+08KFC7V27VodO3ZM7dq1c3HVAAAA+afAn6F74IEHHB6/9tprmjp1qjZs2KAyZcpoxowZmjdvnpo3by5JmjlzpqpUqaINGzaofv36rigZAAAgXxX4M3RXS0tL0/z583X+/HnFxsZqy5Ytunz5slq2bGkfU7lyZUVERGj9+vUurBQAACD/FPgzdJK0Y8cOxcbG6tKlS/Lz89PixYtVtWpVbdu2TZ6engoKCnIYHxISohMnTmS7vJSUFKWkpNgfJyUlOat0AAAAp7PEGbpKlSpp27Zt2rhxo3r27Kn4+Hj98ssvN728UaNGKTAw0P5TtmzZPKwWAAAgf1ki0Hl6eqp8+fKqW7euRo0apVq1amnixIkKDQ1Vamqqzpw54zA+ISFBoaGh2S5v8ODBOnv2rP3n6NGjTu4AAADAeSwR6K6Vnp6ulJQU1a1bVx4eHlq5cqV93t69e3XkyBHFxsZm+3wvLy8FBAQ4/AAAAFhVgb+GbvDgwWrVqpUiIiJ07tw5zZs3T2vWrNHy5csVGBioJ554Qv3791fx4sUVEBCgZ599VrGxsXzDFQAAFBpOC3TlypXTjz/+qBIlSjhMP3PmjOrUqaPffvstR8s5efKkHn/8cR0/flyBgYGqWbOmli9frrvvvluSNH78eLm5ual9+/YONxYGAAAoLJwW6A4dOqS0tLRM01NSUvTHH3/keDkzZsy47nxvb29NnjxZkydPznWNAAAAt4I8D3RLly61/zvjY9EMaWlpWrlypaKiovJ6tQCALOzevdvVJVxXcHAwf2sWyAN5Hujatm0rSbLZbIqPj3eY5+HhoaioKI0dOzavVwsAuMrFs6ck2fToo4+6upTr8vEpqj17dhPqgH8ozwNdenq6JCk6Olo//vijgoOD83oVAIAbuHzhnCSj2o+8qJLRlV1dTpaSjh/SxvdHKDExkUAH/ENOu4bu4MGDzlo0ACCH/EpFqHhEJVeXAcDJnHrbkpUrV2rlypU6efKk/cxdhvfff9+ZqwYAACg0nBboRowYoZEjR+r2229XWFiYbDabs1YFAABQqDkt0E2bNk2zZs3SY4895qxVAAAAQE7801+pqalq0KCBsxYPAACA/89pge7JJ5/UvHnznLV4AAAA/H9O+8j10qVLmj59ur755hvVrFlTHh4eDvPHjRvnrFUDAAAUKk4LdD///LNq164tSdq5c6fDPL4gAQAAkHecFuhWr17trEUDAADgKk67hg4AAAD5w2ln6O66667rfrS6atUqZ60aAACgUHFaoMu4fi7D5cuXtW3bNu3cuVPx8fHOWi0AAECh47RAN378+CynDx8+XMnJyc5aLQAAQKGT79fQPfroo/wdVwAAgDyU74Fu/fr18vb2zu/VAgAA3LKc9pFru3btHB4bY3T8+HFt3rxZQ4cOddZqAQAACh2nBbrAwECHx25ubqpUqZJGjhype+65x1mrBQAAKHScFuhmzpzprEUDAADgKk4LdBm2bNmi3bt3S5KqVaum2267zdmrBAAAKFScFuhOnjypzp07a82aNQoKCpIknTlzRnfddZfmz5+vkiVLOmvVAAAAhYrTvuX67LPP6ty5c9q1a5f++usv/fXXX9q5c6eSkpLUp08fZ60WAACg0HHaGbply5bpm2++UZUqVezTqlatqsmTJ/OlCAAAgDzktDN06enp8vDwyDTdw8ND6enpzlotAABAoeO0QNe8eXP17dtXx44ds0/7448/9Nxzz6lFixbOWi0AAECh47RAN2nSJCUlJSkqKkoxMTGKiYlRdHS0kpKS9PbbbztrtQAAAIWO066hK1u2rLZu3apvvvlGe/bskSRVqVJFLVu2dNYqAQAACqU8P0O3atUqVa1aVUlJSbLZbLr77rv17LPP6tlnn9Udd9yhatWq6dtvv83r1QIAABRaeR7oJkyYoKeeekoBAQGZ5gUGBuqZZ57RuHHj8nq1AAAAhVaeB7rt27fr3nvvzXb+Pffcoy1btuT1agEAAAqtPA90CQkJWd6uJIO7u7v+/PPPvF4tAABAoZXnga506dLauXNntvN//vlnhYWF5fVqAQAACq08D3T33Xefhg4dqkuXLmWad/HiRQ0bNkz3339/Xq8WAACg0Mrz25a8/PLLWrRokSpWrKjevXurUqVKkqQ9e/Zo8uTJSktL05AhQ/J6tQAAAIVWnge6kJAQ/fDDD+rZs6cGDx4sY4wkyWazKS4uTpMnT1ZISEherxYAAKDQcsqNhSMjI/Xll1/q9OnT2r9/v4wxqlChgooVK+aM1QEAABRqTvtLEZJUrFgx3XHHHc5cBQAAQKHntL/lCgAAgPxBoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFFfhAN2rUKN1xxx3y9/dXqVKl1LZtW+3du9dhzKVLl9SrVy+VKFFCfn5+at++vRISElxUMQAAQP4q8IFu7dq16tWrlzZs2KCvv/5aly9f1j333KPz58/bxzz33HP67LPPtHDhQq1du1bHjh1Tu3btXFg1AABA/nF3dQE3smzZMofHs2bNUqlSpbRlyxY1adJEZ8+e1YwZMzRv3jw1b95ckjRz5kxVqVJFGzZsUP369V1RNgAAQL4p8GfornX27FlJUvHixSVJW7Zs0eXLl9WyZUv7mMqVKysiIkLr1693SY0AAAD5qcCfobtaenq6+vXrp4YNG6p69eqSpBMnTsjT01NBQUEOY0NCQnTixIksl5OSkqKUlBT746SkJKfVDAAA4GyWOkPXq1cv7dy5U/Pnz/9Hyxk1apQCAwPtP2XLls2jCgEAAPKfZQJd79699fnnn2v16tUqU6aMfXpoaKhSU1N15swZh/EJCQkKDQ3NclmDBw/W2bNn7T9Hjx51ZukAAABOVeADnTFGvXv31uLFi7Vq1SpFR0c7zK9bt648PDy0cuVK+7S9e/fqyJEjio2NzXKZXl5eCggIcPgBAACwqgJ/DV2vXr00b948ffrpp/L397dfFxcYGCgfHx8FBgbqiSeeUP/+/VW8eHEFBATo2WefVWxsLN9wBQAAhUKBD3RTp06VJDVr1sxh+syZM9WtWzdJ0vjx4+Xm5qb27dsrJSVFcXFxmjJlSj5XCgAA4BoFPtAZY244xtvbW5MnT9bkyZPzoSIAAICCpcBfQwcAAIDrI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4txdXQAAoHDbvXu3q0u4rpSUFHl5ebm6jOsKDg5WRESEq8uACxHoAAAucfHsKUk2Pfroo64u5fpsNskYV1dxXT4+RbVnz25CXSFGoAMAuMTlC+ckGdV+5EWVjK7s6nKydHzHeu1cOr1A15h0/JA2vj9CiYmJBLpCjEAHAHApv1IRKh5RydVlZCnp+CFJBbtGQOJLEQAAAJZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOLcXV0ACoYjR44oMTHR1WVka/fu3a4uAQAKtIJ+nAwODlZERISry7hlEeigI0eOqHLlKrp48YKrS7mhyympri4BAAqUi2dPSbLp0UcfdXUp1+XjU1R79uwm1DkJgQ5KTEzUxYsXVK/HMAWERbm6nCwd37FeO5dO15UrV1xdCgAUKJcvnJNkVPuRF1UyurKry8lS0vFD2vj+CCUmJhLonKTAB7p169bpzTff1JYtW3T8+HEtXrxYbdu2tc83xmjYsGF69913debMGTVs2FBTp05VhQoVXFe0RQWERal4RCVXl5GlpOOHXF0CABRofqUiCuwxHM5X4L8Ucf78edWqVUuTJ0/Ocv4bb7yht956S9OmTdPGjRvl6+uruLg4Xbp0KZ8rBQAAcI0Cf4auVatWatWqVZbzjDGaMGGCXn75ZbVp00aS9MEHHygkJERLlixR586d87NUAAAAlyjwZ+iu5+DBgzpx4oRatmxpnxYYGKh69epp/fr1LqwMAAAg/xT4M3TXc+LECUlSSEiIw/SQkBD7vKykpKQoJSXF/jgpKck5BQIAAOQDS5+hu1mjRo1SYGCg/ads2bKuLgkAAOCmWTrQhYaGSpISEhIcpickJNjnZWXw4ME6e/as/efo0aNOrRMAAMCZLB3ooqOjFRoaqpUrV9qnJSUlaePGjYqNjc32eV5eXgoICHD4AQAAsKoCfw1dcnKy9u/fb3988OBBbdu2TcWLF1dERIT69eunV199VRUqVFB0dLSGDh2q8PBwh3vVAQAA3MoKfKDbvHmz7rrrLvvj/v37S5Li4+M1a9YsDRw4UOfPn9fTTz+tM2fOqFGjRlq2bJm8vb1dVTIAAEC+KvCBrlmzZjLGZDvfZrNp5MiRGjlyZD5WBQAAUHBY+ho6AAAAEOgAAAAsj0AHAABgcQQ6AAAAiyPQAQAAWByBDgAAwOIIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAQAAWJy7qwsoDI4cOaLExERXl5Gt3bt3u7oEAADwDxDonOzIkSOqXLmKLl684OpSbuhySqqrSwAAADeBQOdkiYmJunjxgur1GKaAsChXl5Ol4zvWa+fS6bpy5YqrSwEAADeBQJdPAsKiVDyikqvLyFLS8UOuLgEAAPwDfCkCAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4m6pQDd58mRFRUXJ29tb9erV06ZNm1xdEgAAgNPdMoFuwYIF6t+/v4YNG6atW7eqVq1aiouL08mTJ11dGgAAgFPdMoFu3Lhxeuqpp9S9e3dVrVpV06ZNU9GiRfX++++7ujQAAACnuiUCXWpqqrZs2aKWLVvap7m5ually5Zav369CysDAABwPndXF5AXEhMTlZaWppCQEIfpISEh2rNnT6bxKSkpSklJsT8+e/asJCkpKSnPa0tOTpYk/XV4r66kXMzz5eeFpOOHJUln/9gnD3ebi6vJGjXmDWrMG9SYN6gxb1iixhNHJP39OzEvf9dmLMsYk2fLtCqbuQW2wrFjx1S6dGn98MMPio2NtU8fOHCg1q5dq40bNzqMHz58uEaMGJHfZQIAACc4evSoypQp4+oyXOqWOEMXHBysIkWKKCEhwWF6QkKCQkNDM40fPHiw+vfvb3+cnp6uv/76SyVKlJDNlvl/N0lJSSpbtqyOHj2qgICAvG+gACgMPUqFo096vHUUhj7p8dbhij6NMTp37pzCw8PzZX0F2S0R6Dw9PVW3bl2tXLlSbdu2lfR3SFu5cqV69+6dabyXl5e8vLwcpgUFBd1wPQEBAbf0m1EqHD1KhaNPerx1FIY+6fHWkd99BgYG5tu6CrJbItBJUv/+/RUfH6/bb79dd955pyZMmKDz58+re/furi4NAADAqW6ZQNepUyf9+eef+s9//qMTJ06odu3aWrZsWaYvSgAAANxqbplAJ0m9e/fO8iPWf8rLy0vDhg3L9DHtraQw9CgVjj7p8dZRGPqkx1tHYemzoLolvuUKAABQmN0SNxYGAAAozAh0AAAAFkegAwAAsDgCHQAAgMUVykA3efJkRUVFydvbW/Xq1dOmTZuyHXv58mWNHDlSMTEx8vb2Vq1atbRs2TKHMevWrdMDDzyg8PBw2Ww2LVmyxMkd5Exe9zlq1Cjdcccd8vf3V6lSpdS2bVvt3bvX2W1cV173OHXqVNWsWdN+Y8zY2Fh99dVXzm7juvK6x6v997//lc1mU79+/ZxQee7kdZ/Dhw+XzWZz+KlcubKz27guZ7yWf/zxhx599FGVKFFCPj4+qlGjhjZv3uzMNq4rr3uMiorK9DrabDb16tXL2a1cV173mZaWpqFDhyo6Olo+Pj6KiYnRK6+84tK/UZrXPZ47d079+vVTZGSkfHx81KBBA/3444/ObqPwMIXM/Pnzjaenp3n//ffNrl27zFNPPWWCgoJMQkJCluMHDhxowsPDzRdffGEOHDhgpkyZYry9vc3WrVvtY7788kszZMgQs2jRIiPJLF68OJ+6yZ4z+oyLizMzZ840O3fuNNu2bTP33XefiYiIMMnJyfnVlgNn9Lh06VLzxRdfmF9//dXs3bvXvPTSS8bDw8Ps3Lkzv9py4IweM2zatMlERUWZmjVrmr59+zq5k+tzRp/Dhg0z1apVM8ePH7f//Pnnn/nVUibO6PGvv/4ykZGRplu3bmbjxo3mt99+M8uXLzf79+/Pr7YcOKPHkydPOryGX3/9tZFkVq9enU9dZeaMPl977TVTokQJ8/nnn5uDBw+ahQsXGj8/PzNx4sT8asuBM3rs2LGjqVq1qlm7dq3Zt2+fGTZsmAkICDC///57frV1Syt0ge7OO+80vXr1sj9OS0sz4eHhZtSoUVmODwsLM5MmTXKY1q5dO9O1a9csxxeUQOfsPo35+0AryaxduzZvis6l/OjRGGOKFStm3nvvvX9e8E1wVo/nzp0zFSpUMF9//bVp2rSpywOdM/ocNmyYqVWrllPqvRnO6PHFF180jRo1ck7BNyE/3pN9+/Y1MTExJj09PW+KvgnO6LN169amR48e1x2Tn/K6xwsXLpgiRYqYzz//3GFMnTp1zJAhQ/K4+sKpUH3kmpqaqi1btqhly5b2aW5ubmrZsqXWr1+f5XNSUlLk7e3tMM3Hx0ffffedU2v9J/Krz7Nnz0qSihcvngdV505+9JiWlqb58+fr/Pnzio2Nzbvic8iZPfbq1UutW7d2WLarOLPPffv2KTw8XOXKlVPXrl115MiRvG8gB5zV49KlS3X77berQ4cOKlWqlG677Ta9++67zmniBvLjPZmamqoPP/xQPXr0kM1my7vic8FZfTZo0EArV67Ur7/+Kknavn27vvvuO7Vq1coJXVyfM3q8cuWK0tLSLPf71EoKVaBLTExUWlpapj8HFhISohMnTmT5nLi4OI0bN0779u1Tenq6vv76ay1atEjHjx/Pj5JvSn70mZ6ern79+qlhw4aqXr16nvdwI87scceOHfLz85OXl5f+9a9/afHixapatarTesmOs3qcP3++tm7dqlGjRjm1/pxyVp/16tXTrFmztGzZMk2dOlUHDx5U48aNde7cOaf2kxVn9fjbb79p6tSpqlChgpYvX66ePXuqT58+mj17tlP7yUp+HHeWLFmiM2fOqFu3bnldfo45q89Bgwapc+fOqly5sjw8PHTbbbepX79+6tq1q1P7yYozevT391dsbKxeeeUVHTt2TGlpafrwww+1fv36Av371EoKVaC7GRMnTlSFChVUuXJleXp6qnfv3urevbvc3G6tTZfbPnv16qWdO3dq/vz5+Vzpzctpj5UqVdK2bdu0ceNG9ezZU/Hx8frll19cVHXu3KjHo0ePqm/fvpo7d26m/ylbSU5ey1atWqlDhw6qWbOm4uLi9OWXX+rMmTP66KOPXFh5zuWkx/T0dNWpU0evv/66brvtNj399NN66qmnNG3aNBdWnnO5Pe7MmDFDrVq1Unh4eD5X+s/kpM+PPvpIc+fO1bx587R161bNnj1bY8aMcUk4vxk56XHOnDkyxqh06dLy8vLSW2+9pS5dutxyv09dpVBtxeDgYBUpUkQJCQkO0xMSEhQaGprlc0qWLKklS5bo/PnzOnz4sPbs2SM/Pz+VK1cuP0q+Kc7us3fv3vr888+1evVqlSlTxik93Igze/T09FT58uVVt25djRo1SrVq1dLEiROd1kt2nNHjli1bdPLkSdWpU0fu7u5yd3fX2rVr9dZbb8nd3V1paWlO7+ta+fW+DAoKUsWKFbV///48rT8nnNVjWFhYprPHVapUcclHy85+HQ8fPqxvvvlGTz75pFPqzyln9fnCCy/Yz9LVqFFDjz32mJ577jmXnEl3Vo8xMTFau3atkpOTdfToUW3atEmXL18u0L9PraRQBTpPT0/VrVtXK1eutE9LT0/XypUrb3iNlLe3t0qXLq0rV67ok08+UZs2bZxd7k1zVp/GGPXu3VuLFy/WqlWrFB0d7bQebiQ/X8v09HSlpKTkSd254YweW7RooR07dmjbtm32n9tvv11du3bVtm3bVKRIEaf2lJX8ei2Tk5N14MABhYWF5VntOeWsHhs2bJjp1kG//vqrIiMj87aBHHD26zhz5kyVKlVKrVu3zvPac8NZfV64cCHTmaoiRYooPT09bxvIAWe/lr6+vgoLC9Pp06e1fPnyAv371FJc/a2M/DZ//nzj5eVlZs2aZX755Rfz9NNPm6CgIHPixAljjDGPPfaYGTRokH38hg0bzCeffGIOHDhg1q1bZ5o3b26io6PN6dOn7WPOnTtnfvrpJ/PTTz8ZSWbcuHHmp59+MocPH87v9uyc0WfPnj1NYGCgWbNmjcNtBC5cuJDf7RljnNPjoEGDzNq1a83BgwfNzz//bAYNGmRsNptZsWJFfrdnjHFOj9cqCN9ydUafAwYMMGvWrDEHDx4033//vWnZsqUJDg42J0+ezO/2jDHO6XHTpk3G3d3dvPbaa2bfvn1m7ty5pmjRoubDDz/M7/aMMc7bX9PS0kxERIR58cUX87OdbDmjz/j4eFO6dGn7bUsWLVpkgoODzcCBA/O7PWOMc3pctmyZ+eqrr8xvv/1mVqxYYWrVqmXq1atnUlNT87u9W1KhC3TGGPP222+biIgI4+npae68806zYcMG+7ymTZua+Ph4++M1a9aYKlWqGC8vL1OiRAnz2GOPmT/++MNheatXrzaSMv1cvRxXyOs+s+pRkpk5c2Y+dZRZXvfYo0cPExkZaTw9PU3JkiVNixYtXBbmMuR1j9cqCIHOmLzvs1OnTiYsLMx4enqa0qVLm06dOrns/mwZnPFafvbZZ6Z69erGy8vLVK5c2UyfPj0/WsmWM3pcvny5kWT27t2bHy3kSF73mZSUZPr27WsiIiKMt7e3KVeunBkyZIhJSUnJr5YyyeseFyxYYMqVK2c8PT1NaGio6dWrlzlz5kx+tXPLsxnjwttQAwAA4B8rVNfQAQAA3IoIdAAAABZHoAMAALA4Ah0AAIDFEegAAAAsjkAHAABgcQQ6AAAAiyPQAYCLDB8+XLVr1y4wywFgXQQ6wKL+/PNP9ezZUxEREfLy8lJoaKji4uL0/fffu7q0AuuTTz5Rs2bNFBgYKD8/P9WsWVMjR47UX3/95erScsxms2nJkiUO055//nmHv7sJoPAh0AEW1b59e/3000+aPXu2fv31Vy1dulTNmjXTqVOnXF2aLl++7OoSMhkyZIg6deqkO+64Q1999ZV27typsWPHavv27ZozZ85NLzerXlNTU/9Jqbnm5+enEiVK5Os6ARQwrv7bYwBy7/Tp00aSWbNmzXXHSTJTpkwx9957r/H29jbR0dFm4cKFDmOOHDliOnToYAIDA02xYsXMgw8+aA4ePGifv2nTJtOyZUtTokQJExAQYJo0aWK2bNmS5XoeeOABU7RoUTNs2DAzbNgwU6tWLTNjxgxTtmxZ4+vra3r27GmuXLliRo8ebUJCQkzJkiXNq6++6rCssWPHmurVq5uiRYuaMmXKmJ49e5pz587Z58+cOdMEBgaaZcuWmcqVKxtfX18TFxdnjh07lu122Lhxo5FkJkyYkO32zDBlyhRTrlw54+HhYSpWrGg++OCDHPf67rvvmqioKGOz2ezLfeKJJ0xwcLDx9/c3d911l9m2bZt9WRnPy+m2joyMdPg7ypGRkVkuJy0tzYwYMcKULl3aeHp6mlq1apmvvvrKPv/gwYNGkvnkk09Ms2bNjI+Pj6lZs6b54Ycfst2GAAo2ztABFuTn5yc/Pz8tWbJEKSkp1x07dOhQtW/fXtu3b1fXrl3VuXNn7d69W9LfZ5fi4uLk7++vb7/9Vt9//738/Px077332s8ynTt3TvHx8fruu++0YcMGVahQQffdd5/OnTvnsJ7hw4froYce0o4dO9SjRw9J0oEDB/TVV19p2bJl+t///qcZM2aodevW+v3337V27VqNHj1aL7/8sjZu3Ghfjpubm9566y3t2rVLs2fP1qpVqzRw4ECHdV24cEFjxozRnDlztG7dOh05ckTPP/98tttg7ty58vPz07///e8s5wcFBUmSFi9erL59+2rAgAHauXOnnnnmGXXv3l2rV6++Ya/79+/XJ598okWLFmnbtm2SpA4dOujkyZP66quvtGXLFtWpU0ctWrTI9iPeG23rH3/8UZI0c+ZMHT9+3P74WhMnTtTYsWM1ZswY/fzzz4qLi9ODDz6offv2OYwbMmSInn/+eW3btk0VK1ZUly5ddOXKlWy3I4ACzNWJEsDN+fjjj02xYsWMt7e3adCggRk8eLDZvn27wxhJ5l//+pfDtHr16pmePXsaY4yZM2eOqVSpkklPT7fPT0lJMT4+Pmb58uVZrjctLc34+/ubzz77zGE9/fr1cxg3bNgwU7RoUZOUlGSfFhcXZ6KiokxaWpp9WqVKlcyoUaOy7XPhwoWmRIkS9sczZ840ksz+/fvt0yZPnmxCQkKyXUarVq1MzZo1s52foUGDBuapp55ymNahQwdz33332R9n16uHh4c5efKkfdq3335rAgICzKVLlxzGxsTEmHfeecf+vKvPrF0ru229ePHiTOu/ejnh4eHmtddecxhzxx13mH//+9/GmP87Q/fee+/Z5+/atctIMrt37862HgAFF2foAItq3769jh07pqVLl+ree+/VmjVrVKdOHc2aNcthXGxsbKbHGWfotm/frv3798vf399+1q948eK6dOmSDhw4IElKSEjQU089pQoVKigwMFABAQFKTk7WkSNHHJZ7++23Z6oxKipK/v7+9schISGqWrWq3NzcHKadPHnS/vibb75RixYtVLp0afn7++uxxx7TqVOndOHCBfuYokWLKiYmxv44LCzMYRnXMsZkO+9qu3fvVsOGDR2mNWzY0L69MmTVa2RkpEqWLGl/vH37diUnJ6tEiRL2bevn56eDBw/at+21crqtrycpKUnHjh3LUR81a9a0/zssLEySrrsdARRc7q4uAMDN8/b21t133627775bQ4cO1ZNPPqlhw4apW7duOXp+cnKy6tatq7lz52aalxFO4uPjderUKU2cOFGRkZHy8vJSbGxspgv/fX19My3Dw8PD4bHNZstyWnp6uiTp0KFDuv/++9WzZ0+99tprKl68uL777js98cQTSk1NVdGiRbNd7vVCW8WKFfXdd9/p8uXLmZ57M7Lq9dppycnJCgsL05o1azKNzfiI91o53dZ55eptYbPZJMn+WgCwFs7QAbeQqlWr6vz58w7TNmzYkOlxlSpVJEl16tTRvn37VKpUKZUvX97hJzAwUJL0/fffq0+fPrrvvvtUrVo1eXl5KTEx0Sn1b9myRenp6Ro7dqzq16+vihUr6tixY/94uY888oiSk5M1ZcqULOefOXNGklSlSpVMt335/vvvVbVq1Vyvs06dOjpx4oTc3d0zbdvg4OAsn5OTbe3h4aG0tLRs1xsQEKDw8PA86wOANRDoAAs6deqUmjdvrg8//FA///yzDh48qIULF+qNN95QmzZtHMYuXLhQ77//vn799VcNGzZMmzZtUu/evSVJXbt2VXBwsNq0aaNvv/1WBw8e1Jo1a9SnTx/9/vvvkqQKFSpozpw52r17tzZu3KiuXbvKx8fHKX2VL19ely9f1ttvv63ffvtNc+bM0bRp0/7xcuvVq6eBAwdqwIABGjhwoNavX6/Dhw9r5cqV6tChg2bPni1JeuGFFzRr1ixNnTpV+/bt07hx47Ro0aLrfuEiOy1btlRsbKzatm2rFStW6NChQ/rhhx80ZMgQbd68Ocvn5GRbR0VFaeXKlTpx4oROnz6d5XJeeOEFjR49WgsWLNDevXs1aNAgbdu2TX379s11HwCsgUAHWJCfn5/q1aun8ePHq0mTJqpevbqGDh2qp556SpMmTXIYO2LECM2fP181a9bUBx98oP/973/2MzVFixbVunXrFBERoXbt2qlKlSp64okndOnSJQUEBEiSZsyYodOnT6tOnTp67LHH1KdPH5UqVcopfdWqVUvjxo3T6NGjVb16dc2dO1ejRo3Kk2WPHj1a8+bN08aNGxUXF6dq1aqpf//+qlmzpuLj4yVJbdu21cSJEzVmzBhVq1ZN77zzjmbOnKlmzZrlen02m01ffvmlmjRpou7du6tixYrq3LmzDh8+rJCQkCyfk5NtPXbsWH399dcqW7asbrvttiyX06dPH/Xv318DBgxQjRo1tGzZMi1dulQVKlTIdR8ArMFmcnq1MADLsdlsWrx4sdq2bevqUgAATsQZOgAAAIsj0AEAAFgcty0BbmFcUQEAhQNn6AAAACyOQAcAAGBxBDoAAACLI9ABAABYHIEOAADA4gh0AAAAFkegAwAAsDgCHQAAgMUR6AAAACzu/wG05JCpt/cppAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2336d296-2911-4607-a902-552a7e7b92fd", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/pertspectra_inhouse_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aaf8dc3-7e5b-4748-8685-fc8560bf7fc7", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Compute the pairwise distances\n", + "tnfa_pos_pert_embeddings_df = pd.DataFrame(\n", + " adata.uns[\"SPECTRA_pert_scores\"], index=adata.uns[\"Spectra_pert_labels\"]\n", + ")\n", + "df = tnfa_pos_pert_embeddings_df.drop(index=[\"basal\", \"ctrl\", \"intergenic\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "clustermap = sns.clustermap(distance_matrix, cmap=\"viridis_r\")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b2181a72-86cf-47a0-aa04-ab154fe0bf95", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.cluster.hierarchy import dendrogram\n", + "\n", + "den = dendrogram(\n", + " clustermap.dendrogram_col.linkage,\n", + " labels=distance_matrix.index,\n", + " color_threshold=0.01,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "00c46f2e-04d9-4b79-bc0e-b1362d6af844", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "from collections import defaultdict\n", + "\n", + "\n", + "def get_cluster_classes(den, label=\"ivl\"):\n", + " cluster_idxs = defaultdict(list)\n", + " for c, pi in zip(den[\"color_list\"], den[\"icoord\"]):\n", + " for leg in pi[1:3]:\n", + " i = (leg - 5.0) / 10.0\n", + " if abs(i - int(i)) < 1e-5:\n", + " cluster_idxs[c].append(int(i))\n", + " cluster_classes = {}\n", + " for c, l in cluster_idxs.items(): # noqa\n", + " i_l = [den[label][i] for i in l]\n", + " cluster_classes[c] = i_l\n", + " return cluster_classes\n", + "\n", + "\n", + "clusters = get_cluster_classes(den)\n", + "# extract functions for clusters\n", + "cluster_process = {}\n", + "for c in clusters:\n", + " cluster_df = pd.DataFrame(clusters[c], columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(cluster_df)\n", + " cluster_process[c] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ebfece22-89bd-4010-bcb9-e99431c63e94", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/pertspectra_inhouse_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "55eaf3f0-4b9f-4028-a042-f6f03996350f", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ffd66c94-5f10-407c-b019-17d09a11a0ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.675809\n", + "CORUM 0.705489\n", + " F1 Threshold\n", + "StringDB 0.697966 0.007078\n", + "CORUM 0.639556 0.160069\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/pertspectra_inhouse_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/pertspectra_inhouse_f1.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c3ef0a88-3b42-4d4c-b7f4-79c018ee3f45", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the precision-recall curve\n", + "prior = \"StringDB\"\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(\n", + " pr_dict[prior][\"recall\"],\n", + " pr_dict[prior][\"precision\"],\n", + " marker=\".\",\n", + " label=\"Precision-Recall Curve\",\n", + ")\n", + "# Adding labels and title\n", + "plt.xlabel(\"Recall\")\n", + "plt.ylabel(\"Precision\")\n", + "plt.title(\"Precision-Recall Curve\")\n", + "plt.legend()\n", + "# Save the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": {}, + "outputs": [], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, adata.uns[\"SPECTRA_factors\"], fdr=1e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "999ea1a6-b9f9-4cdd-a8cc-15e4db23f7f7", + "metadata": {}, + "outputs": [], + "source": [ + "# save latent enrichment results\n", + "with open(\n", + " \"figures/factor_enrichments/pertspectra_inhouse_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "78d01afb-6501-4424-99f5-05839747f118", + "metadata": {}, + "source": [ + "## Overlap with prior knowledge/ground truth (stringdb)\n", + "- Group A: a set of GO terms associated with a perturbation (either drivers from msigdb, or from literature) and its neighbors in stringdb\n", + "- Group B: a set of GO terms from the interpretability analysis\n", + "- Hypergeometric test on the overlap of the two groups" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d0274191-ea1a-4abf-8704-53f99a08fa3c", + "metadata": {}, + "outputs": [], + "source": [ + "# load precomputed factor_to_go dict if available\n", + "filtered_factor_to_go = read_aws_pickle(\n", + " \"s3://pert-spectra/figures/factor_enrichments/pertspectra_inhouse_factor_enrichment.pickle\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "782c4388-f53b-4963-8ee1-578de81d67de", + "metadata": {}, + "outputs": [], + "source": [ + "# get neighbors for each perturbation\n", + "pert_neighbors = retrieve_stringdb_neighbors(adata.uns[\"Spectra_pert_labels\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "abfc3fd4-806e-459d-af34-0b9f365a8e91", + "metadata": {}, + "outputs": [], + "source": [ + "# construct group A - known processes for each perturbation\n", + "gene_sets = read_aws_pickle(\"s3://pert-spectra/references/GO_to_Gene.pickle\")\n", + "# BP only go terms\n", + "go_reference = read_aws_csv(\"s3://pert-spectra/references/GO_terms.txt.gz\", zipped=True)\n", + "go_bp = go_reference[go_reference[\"go_category\"] == \"biological_process\"]\n", + "go_bp_ids = set(go_bp[\"go_id\"].values)\n", + "filtered_go_terms = {key: gene_sets[key] for key in go_bp_ids if key in gene_sets}\n", + "\n", + "# GO terms per perturbation AND its neighbors in stringdb\n", + "pert_to_go = {key: set() for key in adata.uns[\"Spectra_pert_labels\"]}\n", + "for goterm in filtered_go_terms:\n", + " for pert in adata.uns[\"Spectra_pert_labels\"]:\n", + " if pert in filtered_go_terms[goterm] and set(\n", + " filtered_go_terms[goterm]\n", + " ).intersection(pert_neighbors[pert]):\n", + " pert_to_go[pert].add(goterm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3245b161-3e6c-4966-99d9-b7bb1d2ba6e6", + "metadata": {}, + "outputs": [], + "source": [ + "# construct set B - model identified processes for each perturbation\n", + "n = 2 # number of top factors to get processes from\n", + "model_pert_to_go = {}\n", + "for pert in adata.uns[\"Spectra_pert_labels\"]:\n", + " if pert in [\"ctrl\", \"intergenic\", \"basal\"]:\n", + " continue\n", + " # get top factors\n", + " tnfa_pos_pert_embeddings_df = pd.DataFrame(\n", + " adata.uns[\"SPECTRA_pert_scores\"], index=adata.uns[\"Spectra_pert_labels\"]\n", + " )\n", + " pert_loading = tnfa_pos_pert_embeddings_df.loc[pert]\n", + " intergenic_loading = tnfa_pos_pert_embeddings_df.loc[\"intergenic\"]\n", + " delta_loading = np.abs(np.log(pert_loading) - np.log(intergenic_loading))\n", + " top_n_factors = np.argpartition(np.array(delta_loading), -n)[-n:]\n", + " # get processes\n", + " model_processes = set()\n", + " for f in top_n_factors:\n", + " proc = filtered_factor_to_go[f]\n", + " model_processes = model_processes.union(set(proc[\"Term\"]))\n", + " model_pert_to_go[pert] = model_processes" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e6a99270-618f-467b-8c0c-67610171ddbd", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overlap for SKP2: 2 out of 6 in researchDB\n", + "P-value for SKP2: 0.005521122949289679\n", + "Overlap for NFKBIA: 4 out of 28 in researchDB\n", + "P-value for NFKBIA: 0.0018530509193777707\n", + "Overlap for TRAF2: 12 out of 29 in researchDB\n", + "P-value for TRAF2: 9.372890092145309e-14\n", + "Overlap for BIRC2: 12 out of 30 in researchDB\n", + "P-value for BIRC2: 1.5352819800190863e-13\n", + "Overlap for TAB1: 6 out of 9 in researchDB\n", + "P-value for TAB1: 9.880142853042106e-07\n", + "Overlap for UBE2N: 6 out of 16 in researchDB\n", + "P-value for UBE2N: 3.5981263241025083e-07\n", + "Overlap for CHUK: 12 out of 21 in researchDB\n", + "P-value for CHUK: 8.970401417521286e-16\n", + "Overlap for RBCK1: 8 out of 11 in researchDB\n", + "P-value for RBCK1: 4.469976857613242e-09\n", + "Overlap for IKBKB: 15 out of 24 in researchDB\n", + "P-value for IKBKB: 1.262837991043831e-14\n", + "Overlap for TNFRSF1A: 12 out of 21 in researchDB\n", + "P-value for TNFRSF1A: 3.557360199375414e-11\n", + "Overlap for TRAF6: 14 out of 46 in researchDB\n", + "P-value for TRAF6: 8.701845914835026e-14\n", + "Overlap for BIRC3: 8 out of 20 in researchDB\n", + "P-value for BIRC3: 2.0442561238209195e-09\n", + "Overlap for TRADD: 11 out of 13 in researchDB\n", + "P-value for TRADD: 2.20628781790212e-13\n", + "Overlap for TRAF5: 9 out of 14 in researchDB\n", + "P-value for TRAF5: 8.644484310231755e-13\n", + "Overlap for IKBKG: 12 out of 17 in researchDB\n", + "P-value for IKBKG: 7.268024700298374e-13\n", + "Overlap for TAB2: 5 out of 5 in researchDB\n", + "P-value for TAB2: 2.730409006194343e-07\n", + "Overlap for RIPK1: 28 out of 38 in researchDB\n", + "P-value for RIPK1: 3.1419351093251465e-29\n", + "Overlap for SKP1: 3 out of 7 in researchDB\n", + "P-value for SKP1: 0.00023036479244599009\n", + "Overlap for MAP3K7: 10 out of 23 in researchDB\n", + "P-value for MAP3K7: 4.7379439102193765e-08\n", + "Overlap for FBXW11: 11 out of 13 in researchDB\n", + "P-value for FBXW11: 2.0898341048664293e-13\n", + "Overlap for CUL1: 2 out of 7 in researchDB\n", + "P-value for CUL1: 0.007218985999647311\n" + ] + } + ], + "source": [ + "pvals = perturbation_signal_recovery(\n", + " pert_to_go,\n", + " model_pert_to_go,\n", + " list(filtered_go_terms.keys()),\n", + " list(adata.uns[\"Spectra_pert_labels\"]),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b057ceb0-49b0-4c4d-870d-d9a3fe7b1428", + "metadata": {}, + "outputs": [], + "source": [ + "# save as csv for visualization\n", + "pd.DataFrame.from_dict(data=pvals, orient=\"index\").to_csv(\n", + " \"figures/process_recovery_hypergeo_pvals/MODEL_inhouse_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99859d27-3a23-42f0-9d01-1087d698d118", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/inhouse_scETM_metrics.ipynb b/inhouse_scETM_metrics.ipynb new file mode 100644 index 0000000..331d955 --- /dev/null +++ b/inhouse_scETM_metrics.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " get_gprofiler,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d15b3b79-f031-4029-b4cc-3085534cf1ed", + "metadata": {}, + "outputs": [], + "source": [ + "# read in scETM results\n", + "adata = read_aws_h5ad(\"s3://pert-spectra/scETM_checkpoints/scetm_inhouse/fold_0.h5ad\")\n", + "# read in pertspectra results to retrieve gene labels\n", + "ref_adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/PertSpectra_checkpoints/pertspectra_inhouse/fold_0.h5ad\"\n", + ")\n", + "adata.var_names = ref_adata.var_names" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression of test set\n", + "- Compute correlation for the mean expression aggregated on perturbation, across all kfolds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "n_folds = 5\n", + "model_adatas = []\n", + "for n in range(0, n_folds):\n", + " # new adata\n", + " adata_n = adata.copy()\n", + " # load model from checkpoint\n", + " s3_dir = \"s3://pert-spectra/scETM_checkpoints/\"\n", + " experiment_name = \"scetm_inhouse/\"\n", + " model_name = f\"fold_{n}.h5ad\"\n", + " m_adata = read_aws_h5ad(s3_dir + experiment_name + model_name)\n", + " model_adatas.append(m_adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e0c30413-c2c1-4058-b3bf-4dc74437c0dd", + "metadata": {}, + "outputs": [], + "source": [ + "# iterate through all models and get the losses and correlations\n", + "# take the mean loss and correlation for the test set\n", + "from scipy.stats import spearmanr\n", + "\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "\n", + "for n in range(n_folds):\n", + " adata_n = model_adatas[n]\n", + " loss_weights = np.ones(adata_n.shape[0])\n", + "\n", + " for pert in adata_n.obs[\"condition\"].unique():\n", + " hold_idx = [\n", + " i\n", + " for i, x in enumerate(\n", + " adata_n[adata_n.obs[\"Treatment\"] == \"TNFA+\"].obs[\"condition\"]\n", + " )\n", + " if x == pert\n", + " ]\n", + " recon = adata_n[adata_n.obs[\"Treatment\"] == \"TNFA+\"][hold_idx].uns[\"recon\"]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = np.squeeze(\n", + " np.array(\n", + " adata_n[adata_n.obs[\"Treatment\"] == \"TNFA+\"][hold_idx].X.mean(axis=0)\n", + " )\n", + " )\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e61e2799-ed83-421e-86d4-565da4876c10", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4b36f1b2-1b9c-4686-b9fb-43c1d9f64b59", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/scETM_inhouse_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aaf8dc3-7e5b-4748-8685-fc8560bf7fc7", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# aggregate cell embeddings to perturbation embeddings\n", + "cell_emb = adata.uns[\"cell_emb\"] @ adata.uns[\"topics\"]\n", + "perts = []\n", + "pert_emb = []\n", + "for i in adata.obs[\"condition\"].unique():\n", + " if \"+\" not in i and i != \"nan\":\n", + " perts.append(i)\n", + " pert_emb.append(cell_emb[adata.obs[\"condition\"] == i].mean(axis=0))\n", + "pert_emb = np.array(pert_emb)\n", + "pert_emb_df = pd.DataFrame(pert_emb, index=perts)\n", + "\n", + "# Compute the pairwise distances\n", + "df = pert_emb_df.drop(index=[\"ctrl\", \"intergenic\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "clustermap = sns.clustermap(distance_matrix, cmap=\"viridis_r\")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "271cd67a-9441-471b-b125-819e8b7b738a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.cluster.hierarchy import dendrogram\n", + "\n", + "den = dendrogram(\n", + " clustermap.dendrogram_col.linkage,\n", + " labels=distance_matrix.index,\n", + " color_threshold=0.25,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "89af6f64-194f-4f1c-a5ed-dafd7243d371", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "from collections import defaultdict\n", + "\n", + "\n", + "def get_cluster_classes(den, label=\"ivl\"):\n", + " cluster_idxs = defaultdict(list)\n", + " for c, pi in zip(den[\"color_list\"], den[\"icoord\"]):\n", + " for leg in pi[1:3]:\n", + " i = (leg - 5.0) / 10.0\n", + " if abs(i - int(i)) < 1e-5:\n", + " cluster_idxs[c].append(int(i))\n", + " cluster_classes = {}\n", + " for c, l in cluster_idxs.items(): # noqa\n", + " i_l = [den[label][i] for i in l]\n", + " cluster_classes[c] = i_l\n", + " return cluster_classes\n", + "\n", + "\n", + "clusters = get_cluster_classes(den)\n", + "# extract functions for clusters\n", + "cluster_process = {}\n", + "for c in clusters:\n", + " cluster_df = pd.DataFrame(clusters[c], columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(cluster_df)\n", + " cluster_process[c] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "018bb814-e2b1-47a1-8331-22ec810dfeb3", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/scETM_inhouse_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "126853e8-6814-45b0-9420-6b822cb8f42c", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b02b6a47-b384-457b-b9ed-7840807a880e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.573643\n", + "CORUM 0.520186\n", + " F1 Threshold\n", + "StringDB 0.679641 0.0\n", + "CORUM 0.630435 0.0\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/scETM_inhouse_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/scETM_inhouse_f1.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-30 15:49:36,590 [INFO] Parsing data files for GSEA.............................\n", + "2024-12-30 15:49:36,656 [INFO] 17782 gene_sets have been filtered out when max_size=300 and min_size=10\n", + "2024-12-30 15:49:36,657 [INFO] 1203 gene_sets used for further statistical testing.....\n" + ] + } + ], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, np.abs(adata.uns[\"gene_emb\"]), fdr=5e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b785ba3-f9c1-4207-b784-1ffe2ba74c30", + "metadata": {}, + "outputs": [], + "source": [ + "# save latent enrichment results\n", + "with open(\n", + " \"figures/factor_enrichments/scETM_inhouse_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/norman_GSFA_metrics.ipynb b/norman_GSFA_metrics.ipynb new file mode 100644 index 0000000..25f8cc8 --- /dev/null +++ b/norman_GSFA_metrics.ipynb @@ -0,0 +1,735 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " get_gprofiler,\n", + " perturbation_signal_recovery,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + " read_aws_npz,\n", + " read_aws_pickle,\n", + " retrieve_stringdb_neighbors,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "39762015-fa94-4ae8-9038-405f7c56a03b", + "metadata": {}, + "outputs": [], + "source": [ + "# read learned parameters\n", + "Z = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/norman_gsfa_outputs/Z.csv\"\n", + ").to_numpy()\n", + "W = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/norman_gsfa_outputs/W.csv\"\n", + ").to_numpy()\n", + "F = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/norman_gsfa_outputs/F.csv\"\n", + ").to_numpy()\n", + "beta = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/norman_gsfa_outputs/beta.csv\"\n", + ").to_numpy()\n", + "lsfr = read_aws_csv(\n", + " \"s3://pert-spectra/gsfa_checkpoints/norman_gsfa_outputs/lsfr.csv\"\n", + ").to_numpy()\n", + "# read gene and perturbation information\n", + "gene_labels = read_aws_csv(\"s3://pert-spectra/gsfa_checkpoints/norman_top_genes.csv\")[\n", + " \"x\"\n", + "].to_numpy()\n", + "pert_labels = read_aws_npz(\"s3://pert-spectra/gsfa_checkpoints/norman_G_labels.npz\")[\n", + " \"arr_0\"\n", + "]\n", + "pert_labels = [x.split(\"_\")[1] for x in pert_labels[:-1]]\n", + "pert_labels = pert_labels + [\"ctrl\"]\n", + "# read inputs and preprocessed input\n", + "preprocessed_Y = read_aws_npz(\n", + " \"s3://pert-spectra/gsfa_checkpoints/norman_GSFA_preprocessed.npz\"\n", + ")[\"array1\"]\n", + "G = read_aws_npz(\"s3://pert-spectra/gsfa_checkpoints/norman_GSFA_inputs.npz\")[\"array2\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "601bbfb0-17ed-4694-850c-fcbf1fef961b", + "metadata": {}, + "outputs": [], + "source": [ + "# read in adata of raw data for reference\n", + "adata = read_aws_h5ad(\"path to raw Norman adata here\")\n", + "adata = adata[:, gene_labels - 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7888facf-9e1c-4b41-9f48-2e0d194a36af", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to powered perturbations\n", + "obs_df = pd.DataFrame(adata.obs[\"perturbation_name\"])\n", + "category_counts = obs_df[\"perturbation_name\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"perturbation_name\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression (on DE genes if available)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "# for GSFA, measure reconstruction on training\n", + "from scipy.stats import spearmanr\n", + "\n", + "reconstruction = Z @ W.T\n", + "# rebuild pert labels\n", + "G_labels = []\n", + "for row in G:\n", + " pert_idx = np.where(row == 1)[0].tolist()\n", + " perts = [pert_labels[i] for i in pert_idx]\n", + " G_labels.append(\"+\".join(perts))\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "\n", + "for pert in set(G_labels):\n", + " hold_idx = [i for i, x in enumerate(G_labels) if x == pert]\n", + " if not hold_idx:\n", + " continue\n", + " recon = reconstruction[hold_idx]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = preprocessed_Y[hold_idx].mean(axis=0)\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bc94b654-4864-485b-94e7-c1cb1f6f8baf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "import seaborn as sns\n", + "\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "e7033192-d47d-4568-aa9a-63a7aac918c0", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/GSFA_norman_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aaf8dc3-7e5b-4748-8685-fc8560bf7fc7", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "from scipy.cluster.hierarchy import dendrogram, fcluster, linkage\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Put into df\n", + "pert_emb_df = pd.DataFrame(beta[:-1], index=pert_labels)\n", + "pert_emb_df = pert_emb_df.drop(columns=[0]).astype(\"float\")\n", + "\n", + "# Compute the pairwise distances\n", + "df = pert_emb_df.drop(index=[\"ctrl\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "\n", + "# Compute the linkage matrix using the condensed distance matrix\n", + "linkage_matrix = linkage(distance_matrix, method=\"ward\")\n", + "\n", + "# Plot the dendrogram (optional)\n", + "dendro = dendrogram(linkage_matrix, no_plot=True)\n", + "\n", + "# Assign clusters\n", + "max_d = 10 # Max distance for flat clusters\n", + "clusters = fcluster(linkage_matrix, max_d, criterion=\"distance\")\n", + "\n", + "# Create a color palette for clusters\n", + "palette = sns.color_palette(\"husl\", len(np.unique(clusters)))\n", + "\n", + "# Map each cluster id to a color\n", + "cluster_colors = [palette[i - 1] for i in clusters]\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "\n", + "clustermap = sns.clustermap(\n", + " distance_matrix, cmap=\"viridis_r\", row_colors=cluster_colors\n", + ")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "# clustermap.cax.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d187a4f5-b9d8-4dfd-a98b-c759446de3e6", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "index_names = list(distance_matrix.index)\n", + "cluster_df = pd.DataFrame({\"Pert\": index_names, \"Cluster\": clusters})\n", + "cluster_process = {}\n", + "for cluster_id in np.unique(clusters):\n", + " points_in_cluster = cluster_df[cluster_df[\"Cluster\"] == cluster_id][\"Pert\"].tolist()\n", + " gprofiler_in = pd.DataFrame(points_in_cluster, columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(gprofiler_in)\n", + " cluster_process[cluster_id] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7dedf5b-de4c-4142-bbd4-1a2e4a4a4ec0", + "metadata": {}, + "outputs": [], + "source": [ + "# Create descriptions for each cluster (for demonstration purpose)\n", + "cluster_descriptions = {\n", + " 1: \"\",\n", + " 2: \"Embryonic development\",\n", + " 3: \"Transcription cis-regulatory region binding, metabolic process\",\n", + " 4: \"protein serine/threonine kinase activity\",\n", + " 5: \"\",\n", + " 6: \"DNA-binding transcription factor activity, RNA polymerase II transcription regulatory region\",\n", + " 7: \"\",\n", + " 8: \"DNA binding, negative regulation of biosynthetic process\",\n", + " 9: \"\",\n", + " 10: \"chromatin\",\n", + " 11: \"epidermal growth factor\",\n", + " 12: \"collagen type II trimer\",\n", + " 13: \"\",\n", + " 14: \"\",\n", + " 15: \"C/EBP complex\",\n", + " 16: \"\",\n", + "}\n", + "\n", + "# Create a consistent color palette\n", + "unique_clusters = sorted(np.unique(clusters))\n", + "palette = sns.color_palette(\"husl\", len(unique_clusters))\n", + "cluster_colors = [palette[i - 1] for i in clusters]\n", + "cluster_colors = {cid: palette[i] for i, cid in enumerate(unique_clusters)}\n", + "\n", + "# Create clustermap using consistent colors\n", + "row_colors = [cluster_colors[cid] for cid in clusters]\n", + "clustermap = sns.clustermap(\n", + " distance_matrix, cmap=\"viridis_r\", row_colors=[palette[i - 1] for i in clusters]\n", + ")\n", + "clustermap.savefig(\n", + " \"figures/figure_pngs/GSFA_norman_clustermap.png\", dpi=600, bbox_inches=\"tight\"\n", + ")\n", + "\n", + "# Prepare data for the table\n", + "cluster_data = {\n", + " \"Cluster ID\": unique_clusters,\n", + " \"Description\": [cluster_descriptions[cid] for cid in unique_clusters],\n", + "}\n", + "\n", + "cluster_df = pd.DataFrame(cluster_data)\n", + "\n", + "# Plot the table with colors matching the clustermap\n", + "fig, ax = plt.subplots(figsize=(18, 4))\n", + "ax.axis(\"off\")\n", + "ax.axis(\"tight\")\n", + "\n", + "# Create table while applying the color to the row background\n", + "table = ax.table(\n", + " cellText=cluster_df.values,\n", + " colLabels=[\"Cluster ID\", \"Description\"],\n", + " cellColours=[[cluster_colors[cid]] * 2 for cid in cluster_df[\"Cluster ID\"]],\n", + " cellLoc=\"center\",\n", + " loc=\"center\",\n", + ")\n", + "\n", + "# Customize table appearance\n", + "table.auto_set_font_size(False)\n", + "table.set_fontsize(10)\n", + "table.scale(1, 1.5)\n", + "\n", + "plt.savefig(\n", + " \"figures/figure_pngs/GSFA_norman_clustermap_descriptions.png\",\n", + " dpi=600,\n", + " bbox_inches=\"tight\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 250, + "id": "23b3a2e6-f20f-4626-bcc9-32e9e4ef0d54", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/GSFA_norman_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "dc06a81d-1fbe-4b46-82f2-0464e55727e7", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 237, + "id": "73b5c140-05f1-486b-9d28-7592ed1556bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.732776\n", + "CORUM 0.946837\n", + " F1 Threshold\n", + "StringDB 0.820312 1.0\n", + "CORUM 0.972222 1.0\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/GSFA_norman_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/GSFA_norman_f1.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, W.T, fdr=5e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "ff945301-46b0-4beb-9f4e-9bc17ede92d0", + "metadata": {}, + "outputs": [], + "source": [ + "with open(\n", + " \"figures/factor_enrichments/GSFA_norman_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "6e5f583b-5c2e-45ea-a210-33b0f6ab2b3e", + "metadata": {}, + "source": [ + "## Overlap with prior knowledge/ground truth (stringdb)\n", + "- Group A: a set of GO terms associated with a perturbation (either drivers from msigdb, or from literature) and its neighbors in stringdb\n", + "- Group B: a set of GO terms from the interpretability analysis\n", + "- Hypergeometric test on the overlap of the two groups" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3f70b845-17f9-429e-9bdf-6d36d6fb0a44", + "metadata": {}, + "outputs": [], + "source": [ + "# load precomputed factor_to_go dict if available\n", + "filtered_factor_to_go = read_aws_pickle(\n", + " \"s3://pert-spectra/figures/factor_enrichments/GSFA_norman_factor_enrichment.pickle\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0a0ca673-3177-412f-937d-f0ec50c3824f", + "metadata": {}, + "outputs": [], + "source": [ + "# get neighbors for each perturbation\n", + "pert_neighbors = retrieve_stringdb_neighbors(pert_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "28d8b858-9326-489e-be3f-00a756eb3fb0", + "metadata": {}, + "outputs": [], + "source": [ + "# construct group A - known processes for each perturbation\n", + "gene_sets = read_aws_pickle(\"s3://pert-spectra/references/GO_to_Gene.pickle\")\n", + "# BP only go terms\n", + "go_reference = read_aws_csv(\"s3://pert-spectra/references/GO_terms.txt.gz\", zipped=True)\n", + "go_bp = go_reference[go_reference[\"go_category\"] == \"biological_process\"]\n", + "go_bp_ids = set(go_bp[\"go_id\"].values)\n", + "filtered_go_terms = {key: gene_sets[key] for key in go_bp_ids if key in gene_sets}\n", + "\n", + "# GO terms per perturbation AND its neighbors in stringdb\n", + "pert_to_go = {key: set() for key in df.index}\n", + "for goterm in filtered_go_terms:\n", + " for pert in df.index:\n", + " if pert in filtered_go_terms[goterm] and set(\n", + " filtered_go_terms[goterm]\n", + " ).intersection(pert_neighbors[pert]):\n", + " pert_to_go[pert].add(goterm)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b3b81d9d-7264-4dac-b14b-1f35c84479c2", + "metadata": {}, + "outputs": [], + "source": [ + "# construct set B - model identified processes for each perturbation\n", + "n = 10 # number of top factors to get processes from\n", + "model_pert_to_go = {}\n", + "for pert in pert_emb_df.index:\n", + " if pert in [\"ctrl\", \"intergenic\", \"basal\"]:\n", + " continue\n", + " # get top factors\n", + " pert_emb_df = pd.DataFrame(beta[:-1], index=pert_labels)\n", + " pert_loading = pert_emb_df.loc[pert].to_numpy()[1:].astype(float)\n", + " ctrl_loading = pert_emb_df.loc[\"ctrl\"].to_numpy()[1:].astype(float)\n", + " delta_loading = np.abs(np.log(np.abs(pert_loading)) - np.log(np.abs(ctrl_loading)))\n", + " top_n_factors = np.argpartition(np.array(delta_loading), -n)[-n:]\n", + " # get processes\n", + " model_processes = set()\n", + " for f in top_n_factors:\n", + " proc = filtered_factor_to_go[f]\n", + " model_processes = model_processes.union(set(proc[\"Term\"]))\n", + " model_pert_to_go[pert] = model_processes" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f3a8ecfa-1184-4a30-b787-1ce5e56a5562", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overlap for AHR: 5 out of 12 in researchDB\n", + "P-value for AHR: 2.1319858454369287e-07\n", + "Overlap for ARID1A: 5 out of 16 in researchDB\n", + "P-value for ARID1A: 2.2083684093482343e-06\n", + "Overlap for BAK1: 5 out of 43 in researchDB\n", + "P-value for BAK1: 0.00046615592180678417\n", + "Overlap for BCL2L11: 3 out of 29 in researchDB\n", + "P-value for BCL2L11: 0.008310750164771933\n", + "Overlap for CBL: 5 out of 28 in researchDB\n", + "P-value for CBL: 0.00014285653454198518\n", + "Overlap for CDKN1A: 3 out of 37 in researchDB\n", + "P-value for CDKN1A: 0.0090102759706699\n", + "Overlap for CDKN1B: 2 out of 38 in researchDB\n", + "P-value for CDKN1B: 0.08621078058192475\n", + "Overlap for CDKN1C: 3 out of 15 in researchDB\n", + "P-value for CDKN1C: 0.0008590529302742615\n", + "Overlap for CEBPA: 10 out of 34 in researchDB\n", + "P-value for CEBPA: 9.605689713987963e-11\n", + "Overlap for CEBPB: 8 out of 33 in researchDB\n", + "P-value for CEBPB: 3.5589724354327065e-08\n", + "Overlap for CEBPE: 5 out of 9 in researchDB\n", + "P-value for CEBPE: 9.287161274422125e-08\n", + "Overlap for CITED1: 6 out of 14 in researchDB\n", + "P-value for CITED1: 1.0848735073457748e-08\n", + "Overlap for COL1A1: 3 out of 29 in researchDB\n", + "P-value for COL1A1: 0.005941572402352278\n", + "Overlap for COL2A1: 0 out of 12 in researchDB\n", + "P-value for COL2A1: 1.0\n", + "Overlap for DUSP9: 0 out of 5 in researchDB\n", + "P-value for DUSP9: 1.0\n", + "Overlap for EGR1: 9 out of 18 in researchDB\n", + "P-value for EGR1: 6.076427546891436e-13\n", + "Overlap for ETS2: 4 out of 5 in researchDB\n", + "P-value for ETS2: 1.2643534179980056e-07\n", + "Overlap for FOSB: 3 out of 11 in researchDB\n", + "P-value for FOSB: 0.0005638568648125962\n", + "Overlap for FOXA1: 7 out of 15 in researchDB\n", + "P-value for FOXA1: 1.0193815225213786e-09\n", + "Overlap for FOXL2: 4 out of 7 in researchDB\n", + "P-value for FOXL2: 1.5792583093509072e-06\n", + "Overlap for FOXO4: 4 out of 8 in researchDB\n", + "P-value for FOXO4: 3.8416764921953e-06\n", + "Overlap for HK2: 1 out of 13 in researchDB\n", + "P-value for HK2: 0.15293459959857644\n", + "Overlap for HNF4A: 6 out of 18 in researchDB\n", + "P-value for HNF4A: 2.0064461479781388e-07\n", + "Overlap for IKZF3: 2 out of 6 in researchDB\n", + "P-value for IKZF3: 0.0033188033960969143\n", + "Overlap for IRF1: 4 out of 19 in researchDB\n", + "P-value for IRF1: 0.00011774780147504422\n", + "Overlap for JUN: 9 out of 38 in researchDB\n", + "P-value for JUN: 6.800257732829314e-10\n", + "Overlap for KIF18B: 4 out of 5 in researchDB\n", + "P-value for KIF18B: 1.02966073190364e-07\n", + "Overlap for KIF2C: 1 out of 8 in researchDB\n", + "P-value for KIF2C: 0.11717918583009142\n", + "Overlap for KMT2A: 4 out of 14 in researchDB\n", + "P-value for KMT2A: 5.737318595565771e-05\n", + "Overlap for LHX1: 3 out of 15 in researchDB\n", + "P-value for LHX1: 0.001550750199766002\n", + "Overlap for MAP2K3: 5 out of 18 in researchDB\n", + "P-value for MAP2K3: 6.727417522597989e-06\n", + "Overlap for MAP2K6: 2 out of 21 in researchDB\n", + "P-value for MAP2K6: 0.027671721378544775\n", + "Overlap for MAPK1: 9 out of 55 in researchDB\n", + "P-value for MAPK1: 1.2457826721768169e-08\n", + "Overlap for MEIS1: 2 out of 11 in researchDB\n", + "P-value for MEIS1: 0.011117126714865002\n", + "Overlap for NCL: 3 out of 8 in researchDB\n", + "P-value for NCL: 0.0002326125897755479\n", + "Overlap for PLK4: 1 out of 5 in researchDB\n", + "P-value for PLK4: 0.059561646093364874\n", + "Overlap for POU3F2: 2 out of 9 in researchDB\n", + "P-value for POU3F2: 0.008122844993866516\n", + "Overlap for PTPN1: 1 out of 14 in researchDB\n", + "P-value for PTPN1: 0.1896342601320953\n", + "Overlap for PTPN12: 0 out of 5 in researchDB\n", + "P-value for PTPN12: 1.0\n", + "Overlap for S1PR2: 0 out of 5 in researchDB\n", + "P-value for S1PR2: 1.0\n", + "Overlap for SGK1: 7 out of 17 in researchDB\n", + "P-value for SGK1: 4.12440746718372e-09\n", + "Overlap for SLC38A2: 1 out of 11 in researchDB\n", + "P-value for SLC38A2: 0.12020964276782159\n", + "Overlap for SNAI1: 3 out of 13 in researchDB\n", + "P-value for SNAI1: 0.0005804369395604471\n", + "Overlap for SPI1: 12 out of 25 in researchDB\n", + "P-value for SPI1: 8.848408979799951e-16\n", + "Overlap for STIL: 1 out of 13 in researchDB\n", + "P-value for STIL: 0.15204982937479228\n", + "Overlap for TBX2: 4 out of 8 in researchDB\n", + "P-value for TBX2: 1.9410436163852128e-06\n", + "Overlap for TBX3: 4 out of 14 in researchDB\n", + "P-value for TBX3: 2.0954324972493857e-05\n", + "Overlap for TGFBR2: 3 out of 55 in researchDB\n", + "P-value for TGFBR2: 0.020165641355063494\n", + "Overlap for TP73: 4 out of 17 in researchDB\n", + "P-value for TP73: 5.875369519782811e-05\n" + ] + } + ], + "source": [ + "pvals = perturbation_signal_recovery(\n", + " pert_to_go,\n", + " model_pert_to_go,\n", + " list(filtered_go_terms.keys()),\n", + " list(pert_emb_df.index),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "712834c7-e823-4117-a2f6-dc704c391d7c", + "metadata": {}, + "outputs": [], + "source": [ + "# save as csv for visualization\n", + "pd.DataFrame.from_dict(data=pvals, orient=\"index\").to_csv(\n", + " \"figures/process_recovery_hypergeo_pvals/GSFA_norman_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cde32c38-f16b-4f39-9dcd-5e5f480b3720", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/norman_pertspectra_metrics.ipynb b/norman_pertspectra_metrics.ipynb new file mode 100644 index 0000000..317909c --- /dev/null +++ b/norman_pertspectra_metrics.ipynb @@ -0,0 +1,796 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " generate_k_fold,\n", + " get_gprofiler,\n", + " perturbation_signal_recovery,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + " read_aws_pickle,\n", + " retrieve_stringdb_neighbors,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e6ad83c5-40dc-4f4e-8412-3e8fcdf847fa", + "metadata": {}, + "outputs": [], + "source": [ + "# read in trained model outputs generated from ./PertSpectra_load_checkpoints/pertspectra_norman.ipynb\n", + "adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/PertSpectra_checkpoints/pertspectra_norman/fold_0.h5ad\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression of test set\n", + "- Compute correlation for the mean expression aggregated on perturbation, across all kfolds" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "n_folds = 5\n", + "model_adatas = []\n", + "for n in range(0, n_folds):\n", + " # new adata\n", + " adata_n = adata.copy()\n", + " # load model from checkpoint\n", + " s3_dir = \"s3://pert-spectra/PertSpectra_checkpoints/\"\n", + " experiment_name = \"pertspectra_norman/\"\n", + " model_name = f\"fold_{n}.h5ad\"\n", + " m_adata = read_aws_h5ad(s3_dir + experiment_name + model_name)\n", + " model_adatas.append(m_adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c6d0cd6c-c29b-4fa1-98f2-e31e7f5eefa1", + "metadata": {}, + "outputs": [], + "source": [ + "# iterate through all models and get the losses and correlations\n", + "# take the mean loss and correlation for the test set\n", + "from scipy.stats import spearmanr\n", + "\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "\n", + "\n", + "for n in range(n_folds):\n", + " adata_n = model_adatas[n]\n", + " train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata_n,\n", + " adata_n.X,\n", + " adata_n.obs[\"perturbation_name\"],\n", + " fold_idx=n,\n", + " perturbation_key=\"perturbation_name\",\n", + " )\n", + " loss_weights = np.ones(adata_n.shape[0])\n", + " adata_test = adata_n[test_idx]\n", + "\n", + " for pert in adata_test.obs[\"perturbation_name\"].unique():\n", + " hold_idx = [\n", + " i for i, x in enumerate(adata_test.obs[\"perturbation_name\"]) if x == pert\n", + " ]\n", + " recon = adata_test[hold_idx].uns[\"recon\"]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = np.squeeze(np.array(adata_test[hold_idx].X.mean(axis=0)))\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c46c85fa-1d93-4baf-9226-6b4423a8c054", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f5ff3e3c-db63-41e3-be86-e2b45ef46b1e", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/pertspectra_norman_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebf9b816-2a19-44f0-ae84-ab1e041edc65", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.cluster.hierarchy import dendrogram, fcluster, linkage\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Compute the pairwise distances\n", + "pert_embeddings_df = pd.DataFrame(\n", + " adata.uns[\"SPECTRA_pert_scores\"], index=adata.uns[\"Spectra_pert_labels\"]\n", + ")\n", + "df = pert_embeddings_df.drop(index=[\"basal\", \"ctrl\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "# distance_matrix = (distance_matrix - distance_matrix.min()) / (distance_matrix.max() - distance_matrix.min())\n", + "\n", + "# Compute the linkage matrix using the condensed distance matrix\n", + "linkage_matrix = linkage(distance_matrix, method=\"ward\")\n", + "\n", + "# Plot the dendrogram (optional)\n", + "dendro = dendrogram(linkage_matrix, no_plot=True)\n", + "\n", + "# Assign clusters\n", + "max_d = 0.09\n", + "clusters = fcluster(linkage_matrix, max_d, criterion=\"distance\")\n", + "\n", + "# Create a color palette for clusters\n", + "palette = sns.color_palette(\"husl\", len(np.unique(clusters)))\n", + "\n", + "# Map each cluster id to a color\n", + "cluster_colors = [palette[i - 1] for i in clusters]\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "\n", + "clustermap = sns.clustermap(\n", + " distance_matrix, cmap=\"viridis_r\", row_colors=cluster_colors\n", + ")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "clustermap.cax.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2fabc196-a8ff-4660-af5a-0d2b8ebb1804", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "index_names = list(distance_matrix.index)\n", + "cluster_df = pd.DataFrame({\"Pert\": index_names, \"Cluster\": clusters})\n", + "cluster_process = {}\n", + "for cluster_id in np.unique(clusters):\n", + " points_in_cluster = cluster_df[cluster_df[\"Cluster\"] == cluster_id][\"Pert\"].tolist()\n", + " gprofiler_in = pd.DataFrame(points_in_cluster, columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(gprofiler_in)\n", + " cluster_process[cluster_id] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d6d8eae-7390-49c1-bc1c-62b35882406e", + "metadata": {}, + "outputs": [], + "source": [ + "# Create descriptions for each cluster (for demonstration purpose)\n", + "cluster_descriptions = {\n", + " 1: \"Developmental processes, kinase activity\",\n", + " 2: \"Tyrosine phosphatase activity\",\n", + " 3: \"Transcription factor activity, DNA binding\",\n", + " 4: \"Embryonic development\",\n", + " 5: \"No signficant gprofiler hits\",\n", + " 6: \"Kinase inhibitor activity\",\n", + " 7: \"No signficant gprofiler hits\",\n", + " 8: \"Embryonic morphogenesis\",\n", + " 9: \"DNA-binding transcription activator\",\n", + " 10: \"RNA polymerase II transcription regulation\",\n", + " 11: \"C/EBP complex\",\n", + "}\n", + "\n", + "# Create a consistent color palette\n", + "unique_clusters = sorted(np.unique(clusters))\n", + "palette = sns.color_palette(\"husl\", len(unique_clusters))\n", + "cluster_colors = [palette[i - 1] for i in clusters]\n", + "cluster_colors = {cid: palette[i] for i, cid in enumerate(unique_clusters)}\n", + "\n", + "# Create clustermap using consistent colors\n", + "row_colors = [cluster_colors[cid] for cid in clusters]\n", + "clustermap = sns.clustermap(\n", + " distance_matrix, cmap=\"viridis_r\", row_colors=[palette[i - 1] for i in clusters]\n", + ")\n", + "clustermap.ax_row_dendrogram.set_visible(False)\n", + "# clustermap.ax_col_dendrogram.set_visible(False)\n", + "clustermap.savefig(\n", + " \"figures/figure_pngs/pertspectra_norman_clustermap.png\",\n", + " dpi=600,\n", + " bbox_inches=\"tight\",\n", + ")\n", + "\n", + "# Prepare data for the table\n", + "cluster_data = {\n", + " \"Cluster ID\": unique_clusters,\n", + " \"Description\": [cluster_descriptions[cid] for cid in unique_clusters],\n", + "}\n", + "\n", + "cluster_df = pd.DataFrame(cluster_data)\n", + "\n", + "# Plot the table with colors matching the clustermap\n", + "fig, ax = plt.subplots(figsize=(12, 4))\n", + "ax.axis(\"off\")\n", + "ax.axis(\"tight\")\n", + "\n", + "# Create table while applying the color to the row background\n", + "table = ax.table(\n", + " cellText=cluster_df.values,\n", + " colLabels=[\"Cluster ID\", \"Description\"],\n", + " cellColours=[[cluster_colors[cid]] * 2 for cid in cluster_df[\"Cluster ID\"]],\n", + " cellLoc=\"center\",\n", + " loc=\"center\",\n", + ")\n", + "\n", + "# Customize table appearance\n", + "table.auto_set_font_size(False)\n", + "table.set_fontsize(10)\n", + "table.scale(1, 1.5)\n", + "\n", + "plt.savefig(\n", + " \"figures/figure_pngs/pertspectra_norman_clustermap_descriptions.png\",\n", + " dpi=600,\n", + " bbox_inches=\"tight\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "id": "ee08b960-8bb8-4013-ac51-15196d579af7", + "metadata": {}, + "outputs": [], + "source": [ + "# save\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/MODEL_norman_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "efbb23aa-4769-446b-a189-1106752453b3", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "33be8fb8-a88c-4718-a38e-7569aa58740d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.753048\n", + "CORUM 0.946676\n", + " F1 Threshold\n", + "StringDB 0.829457 0.973018\n", + "CORUM 0.972222 1.000000\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/pertspectra_norman_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/pertspectra_norman_f1.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7cd2b514-5abb-4060-b0e0-a7a854ccf942", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior = \"StringDB\"\n", + "sns.set(style=\"whitegrid\")\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "sns.lineplot(\n", + " x=pr_dict[prior][\"recall\"],\n", + " y=pr_dict[prior][\"precision\"],\n", + " marker=\"o\",\n", + " label=\"Precision-Recall Curve\",\n", + ")\n", + "\n", + "# Add labels and title\n", + "plt.xlabel(\"Recall\")\n", + "plt.ylabel(\"Precision\")\n", + "plt.title(\"Norman: StringDB Precision-Recall Curve for PertSpectra\")\n", + "plt.legend().set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-13 18:26:07,684 [INFO] Parsing data files for GSEA.............................\n", + "2024-12-13 18:26:07,780 [INFO] 17889 gene_sets have been filtered out when max_size=300 and min_size=10\n", + "2024-12-13 18:26:07,781 [INFO] 1096 gene_sets used for further statistical testing.....\n", + "2024-12-13 18:26:07,781 [INFO] Start to run GSEA...Might take a while..................\n", + "2024-12-13 18:26:35,994 [INFO] Congratulations. GSEApy runs successfully................\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "163\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-13 18:26:38,066 [INFO] Parsing data files for GSEA.............................\n", + "2024-12-13 18:26:38,167 [INFO] 17889 gene_sets have been filtered out when max_size=300 and min_size=10\n", + "2024-12-13 18:26:38,168 [INFO] 1096 gene_sets used for further statistical testing.....\n", + "2024-12-13 18:26:38,169 [INFO] Start to run GSEA...Might take a while..................\n", + "2024-12-13 18:27:06,036 [INFO] Congratulations. GSEApy runs successfully................\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "298\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-13 18:27:08,089 [WARNING] Duplicated values found in preranked stats: 0.02% of genes\n", + "The order of those genes will be arbitrary, which may produce unexpected results.\n", + "2024-12-13 18:27:08,090 [INFO] Parsing data files for GSEA.............................\n", + "2024-12-13 18:27:08,186 [INFO] 17889 gene_sets have been filtered out when max_size=300 and min_size=10\n", + "2024-12-13 18:27:08,187 [INFO] 1096 gene_sets used for further statistical testing.....\n" + ] + } + ], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, adata.uns[\"SPECTRA_factors\"], fdr=5e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc5264d2-0934-40e3-a209-7e318a46a583", + "metadata": {}, + "outputs": [], + "source": [ + "with open(\n", + " \"figures/factor_enrichments/pertspectra_norman_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "b6af72e5-1c50-48d1-8e59-9702b8b3a85d", + "metadata": {}, + "source": [ + "## Proposed Metric 2 continued: Overlap with prior knowledge/ground truth (stringdb)\n", + "- Group A: a set of GO terms associated with a perturbation (either drivers from msigdb, or from literature) and its neighbors in stringdb\n", + "- Group B: a set of GO terms from the interpretability analysis\n", + "- Hypergeometric test on the overlap of the two groups" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f5b8dcc5-32bf-42d3-9ce9-3f1bbe5bf530", + "metadata": {}, + "outputs": [], + "source": [ + "# load precomputed factor_to_go dict if available\n", + "filtered_factor_to_go = read_aws_pickle(\n", + " \"s3://pert-spectra/figures/factor_enrichments/pertspectra_norman_factor_enrichment.pickle\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "31343240-e846-45a8-89f9-0734617a8b09", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# get neighbors for each perturbation\n", + "pert_neighbors = retrieve_stringdb_neighbors(adata.uns[\"Spectra_pert_labels\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8bfb16c9-bc3d-4942-a10a-e889ee39f2a4", + "metadata": {}, + "outputs": [], + "source": [ + "# construct group A - known processes for each perturbation\n", + "gene_sets = read_aws_pickle(\"s3://pert-spectra/references/GO_to_Gene.pickle\")\n", + "# BP only go terms\n", + "go_reference = read_aws_csv(\"s3://pert-spectra/references/GO_terms.txt.gz\", zipped=True)\n", + "go_bp = go_reference[go_reference[\"go_category\"] == \"biological_process\"]\n", + "go_bp_ids = set(go_bp[\"go_id\"].values)\n", + "filtered_go_terms = {key: gene_sets[key] for key in go_bp_ids if key in gene_sets}\n", + "\n", + "# GO terms per perturbation AND its neighbors in stringdb\n", + "pert_to_go = {key: set() for key in adata.uns[\"Spectra_pert_labels\"]}\n", + "for goterm in filtered_go_terms:\n", + " for pert in adata.uns[\"Spectra_pert_labels\"]:\n", + " if pert in filtered_go_terms[goterm] and set(\n", + " filtered_go_terms[goterm]\n", + " ).intersection(pert_neighbors[pert]):\n", + " pert_to_go[pert].add(goterm)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b2190d7b-8c1d-4fdb-9ed5-221e715ae099", + "metadata": {}, + "outputs": [], + "source": [ + "# construct set B - model identified processes for each perturbation\n", + "n = 10 # number of top factors to get processes from\n", + "model_pert_to_go = {}\n", + "for pert in adata.uns[\"Spectra_pert_labels\"]:\n", + " if pert in [\"ctrl\", \"intergenic\", \"basal\"]:\n", + " continue\n", + " # get top factors\n", + " pert_embeddings_df = pd.DataFrame(\n", + " adata.uns[\"SPECTRA_pert_scores\"], index=adata.uns[\"Spectra_pert_labels\"]\n", + " )\n", + " pert_loading = pert_embeddings_df.loc[pert]\n", + " ctrl_loading = pert_embeddings_df.loc[\"ctrl\"]\n", + " delta_loading = np.abs(np.log(pert_loading) - np.log(ctrl_loading))\n", + " top_n_factors = np.argpartition(np.array(delta_loading), -n)[-n:]\n", + " # get processes\n", + " model_processes = set()\n", + " for f in top_n_factors:\n", + " proc = filtered_factor_to_go[f]\n", + " model_processes = model_processes.union(set(proc[\"Term\"]))\n", + " model_pert_to_go[pert] = model_processes" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "daa45a87-632e-46f7-8caf-c1de5463c5dc", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overlap for AHR: 8 out of 12 in researchDB\n", + "P-value for AHR: 4.845823421588032e-12\n", + "Overlap for ARID1A: 1 out of 16 in researchDB\n", + "P-value for ARID1A: 0.18058513844900828\n", + "Overlap for BAK1: 4 out of 43 in researchDB\n", + "P-value for BAK1: 8.604968054508552e-05\n", + "Overlap for BCL2L11: 5 out of 29 in researchDB\n", + "P-value for BCL2L11: 3.511897516201057e-05\n", + "Overlap for CBL: 4 out of 28 in researchDB\n", + "P-value for CBL: 0.00015631895405348394\n", + "Overlap for CDKN1A: 15 out of 37 in researchDB\n", + "P-value for CDKN1A: 9.94025808969477e-20\n", + "Overlap for CDKN1B: 13 out of 38 in researchDB\n", + "P-value for CDKN1B: 4.2909462790682503e-16\n", + "Overlap for CDKN1C: 4 out of 15 in researchDB\n", + "P-value for CDKN1C: 2.365186115944503e-05\n", + "Overlap for CEBPA: 7 out of 34 in researchDB\n", + "P-value for CEBPA: 2.2822948081394184e-08\n", + "Overlap for CEBPB: 10 out of 33 in researchDB\n", + "P-value for CEBPB: 5.670390667165458e-13\n", + "Overlap for CEBPE: 2 out of 9 in researchDB\n", + "P-value for CEBPE: 0.0017532384752871838\n", + "Overlap for CITED1: 7 out of 14 in researchDB\n", + "P-value for CITED1: 1.7522486320600642e-10\n", + "Overlap for COL1A1: 10 out of 29 in researchDB\n", + "P-value for COL1A1: 1.171842110722407e-11\n", + "Overlap for COL2A1: 1 out of 12 in researchDB\n", + "P-value for COL2A1: 0.06012023574110627\n", + "Overlap for DUSP9: 2 out of 5 in researchDB\n", + "P-value for DUSP9: 0.00153909025679683\n", + "Overlap for EGR1: 7 out of 18 in researchDB\n", + "P-value for EGR1: 4.6232048631669204e-10\n", + "Overlap for ETS2: 0 out of 5 in researchDB\n", + "P-value for ETS2: 1.0\n", + "Overlap for FOSB: 8 out of 11 in researchDB\n", + "P-value for FOSB: 2.821729541176879e-10\n", + "Overlap for FOXA1: 7 out of 15 in researchDB\n", + "P-value for FOXA1: 2.2846765707660486e-10\n", + "Overlap for FOXL2: 4 out of 7 in researchDB\n", + "P-value for FOXL2: 1.9453990596871714e-07\n", + "Overlap for FOXO4: 3 out of 8 in researchDB\n", + "P-value for FOXO4: 8.312021414586989e-05\n", + "Overlap for HK2: 0 out of 13 in researchDB\n", + "P-value for HK2: 1.0\n", + "Overlap for HNF4A: 8 out of 18 in researchDB\n", + "P-value for HNF4A: 2.964510745573481e-11\n", + "Overlap for IKZF3: 2 out of 6 in researchDB\n", + "P-value for IKZF3: 0.0011041577637246342\n", + "Overlap for IRF1: 7 out of 19 in researchDB\n", + "P-value for IRF1: 3.2140371659103896e-11\n", + "Overlap for JUN: 14 out of 38 in researchDB\n", + "P-value for JUN: 3.3731394971336345e-20\n", + "Overlap for KIF18B: 2 out of 5 in researchDB\n", + "P-value for KIF18B: 0.0009097386111233253\n", + "Overlap for KIF2C: 2 out of 8 in researchDB\n", + "P-value for KIF2C: 0.006701346521695229\n", + "Overlap for KMT2A: 4 out of 14 in researchDB\n", + "P-value for KMT2A: 1.0435444603803768e-06\n", + "Overlap for LHX1: 4 out of 15 in researchDB\n", + "P-value for LHX1: 6.9312991269755605e-06\n", + "Overlap for MAP2K3: 14 out of 18 in researchDB\n", + "P-value for MAP2K3: 1.6969977201863256e-18\n", + "Overlap for MAP2K6: 13 out of 21 in researchDB\n", + "P-value for MAP2K6: 3.9511035294897324e-15\n", + "Overlap for MAPK1: 6 out of 55 in researchDB\n", + "P-value for MAPK1: 9.632130141049859e-06\n", + "Overlap for MEIS1: 3 out of 11 in researchDB\n", + "P-value for MEIS1: 0.00011537613165619079\n", + "Overlap for NCL: 2 out of 8 in researchDB\n", + "P-value for NCL: 0.004359967761603796\n", + "Overlap for PLK4: 1 out of 5 in researchDB\n", + "P-value for PLK4: 0.05842913374150724\n", + "Overlap for POU3F2: 2 out of 9 in researchDB\n", + "P-value for POU3F2: 0.0021589123872628973\n", + "Overlap for PTPN1: 1 out of 14 in researchDB\n", + "P-value for PTPN1: 0.13016740932186296\n", + "Overlap for PTPN12: 1 out of 5 in researchDB\n", + "P-value for PTPN12: 0.03477850399423442\n", + "Overlap for S1PR2: 1 out of 5 in researchDB\n", + "P-value for S1PR2: 0.05691742035245258\n", + "Overlap for SGK1: 6 out of 17 in researchDB\n", + "P-value for SGK1: 3.3205018690768594e-08\n", + "Overlap for SLC38A2: 0 out of 11 in researchDB\n", + "P-value for SLC38A2: 1.0\n", + "Overlap for SNAI1: 3 out of 13 in researchDB\n", + "P-value for SNAI1: 0.0001730097629803037\n", + "Overlap for SPI1: 5 out of 25 in researchDB\n", + "P-value for SPI1: 3.2646388203028726e-06\n", + "Overlap for STIL: 3 out of 13 in researchDB\n", + "P-value for STIL: 0.001438174753528276\n", + "Overlap for TBX2: 4 out of 8 in researchDB\n", + "P-value for TBX2: 4.942710375809906e-07\n", + "Overlap for TBX3: 6 out of 14 in researchDB\n", + "P-value for TBX3: 1.0268128265777117e-09\n", + "Overlap for TGFBR2: 13 out of 55 in researchDB\n", + "P-value for TGFBR2: 2.400695076793383e-16\n", + "Overlap for TP73: 10 out of 17 in researchDB\n", + "P-value for TP73: 3.454158558799769e-16\n" + ] + } + ], + "source": [ + "pvals = perturbation_signal_recovery(\n", + " pert_to_go,\n", + " model_pert_to_go,\n", + " list(filtered_go_terms.keys()),\n", + " list(adata.uns[\"Spectra_pert_labels\"]),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "85bc6476-2818-40b0-b187-02671693cb8f", + "metadata": {}, + "outputs": [], + "source": [ + "# save as csv for visualization\n", + "pd.DataFrame.from_dict(data=pvals, orient=\"index\").to_csv(\n", + " \"figures/process_recovery_hypergeo_pvals/pertspectra_norman_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78d8aaed-10e6-49fd-a838-70839e8b2561", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/norman_scETM_metrics.ipynb b/norman_scETM_metrics.ipynb new file mode 100644 index 0000000..8cc942b --- /dev/null +++ b/norman_scETM_metrics.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " get_gprofiler,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00d0db8a-5c3d-4e9f-bce0-46c90135cab4", + "metadata": {}, + "outputs": [], + "source": [ + "# read in scETM results\n", + "adata = read_aws_h5ad(\"s3://pert-spectra/scETM_checkpoints/scetm_norman/fold_0.h5ad\")\n", + "# read in pertspectra results to retrieve gene labels\n", + "ref_adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/PertSpectra_checkpoints/pertspectra_norman/fold_0.h5ad\"\n", + ")\n", + "adata.var_names = ref_adata.var_names" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression (on DE genes if available)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "n_folds = 5\n", + "model_adatas = []\n", + "for n in range(0, n_folds):\n", + " # new adata\n", + " adata_n = adata.copy()\n", + " # load model from checkpoint\n", + " s3_dir = \"s3://pert-spectra/scETM_checkpoints/\"\n", + " experiment_name = \"scetm_norman/\"\n", + " model_name = f\"fold_{n}.h5ad\"\n", + " m_adata = read_aws_h5ad(s3_dir + experiment_name + model_name)\n", + " model_adatas.append(m_adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cfe07156-f95b-481e-a1ac-495e69f7e954", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "(18547, 4990)\n", + "test\n", + "1\n", + "(20156, 4990)\n", + "test\n", + "2\n", + "(21410, 4990)\n", + "test\n", + "3\n", + "(20621, 4990)\n", + "test\n", + "4\n", + "(20752, 4990)\n", + "test\n" + ] + } + ], + "source": [ + "# iterate through all models and get the losses and correlations\n", + "# take the mean loss and correlation for the test set\n", + "from scipy.stats import spearmanr\n", + "\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "\n", + "\n", + "for n in range(n_folds):\n", + " adata_n = model_adatas[n]\n", + " loss_weights = np.ones(adata_n.shape[0])\n", + "\n", + " for pert in adata_n.obs[\"perturbation_name\"].unique():\n", + " hold_idx = [\n", + " i for i, x in enumerate(adata_n.obs[\"perturbation_name\"]) if x == pert\n", + " ]\n", + " recon = adata_n[hold_idx].uns[\"recon\"]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = np.squeeze(np.array(adata_n[hold_idx].X.mean(axis=0)))\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0], n]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "72f27f1d-a5a5-46f8-a9a4-efcd5f3119fb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "import seaborn as sns\n", + "\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e4dcca93-bc7e-4bae-b434-50f2a2fb52ab", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/scETM_norman_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aaf8dc3-7e5b-4748-8685-fc8560bf7fc7", + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "from scipy.cluster.hierarchy import dendrogram, fcluster, linkage\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# aggregate cell embeddings to perturbation embeddings\n", + "cell_emb = adata.uns[\"cell_emb\"] @ adata.uns[\"topics\"]\n", + "perts = []\n", + "pert_emb = []\n", + "for i in adata.obs[\"perturbation_name\"].unique():\n", + " if \"+\" not in i and i != \"nan\":\n", + " perts.append(i)\n", + " pert_emb.append(cell_emb[adata.obs[\"perturbation_name\"] == i].mean(axis=0))\n", + "pert_emb = np.array(pert_emb)\n", + "pert_emb_df = pd.DataFrame(pert_emb, index=perts)\n", + "\n", + "# Compute the pairwise distances\n", + "df = pert_emb_df.drop(index=[\"control\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "\n", + "# Compute the linkage matrix using the condensed distance matrix\n", + "linkage_matrix = linkage(distance_matrix, method=\"ward\")\n", + "\n", + "# Plot the dendrogram (optional)\n", + "dendro = dendrogram(linkage_matrix, no_plot=True)\n", + "\n", + "# Assign clusters\n", + "max_d = 1.2 # Max distance for flat clusters\n", + "clusters = fcluster(linkage_matrix, max_d, criterion=\"distance\")\n", + "\n", + "# Create a color palette for clusters\n", + "palette = sns.color_palette(\"husl\", len(np.unique(clusters)))\n", + "\n", + "# Map each cluster id to a color\n", + "cluster_colors = [palette[i - 1] for i in clusters]\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "\n", + "clustermap = sns.clustermap(\n", + " distance_matrix, cmap=\"viridis_r\", row_colors=cluster_colors\n", + ")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "# clustermap.cax.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "c655f7dc-7d39-43dd-9af5-6ca0faf6d8eb", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "index_names = list(distance_matrix.index)\n", + "cluster_df = pd.DataFrame({\"Pert\": index_names, \"Cluster\": clusters})\n", + "cluster_process = {}\n", + "for cluster_id in np.unique(clusters):\n", + " points_in_cluster = cluster_df[cluster_df[\"Cluster\"] == cluster_id][\"Pert\"].tolist()\n", + " gprofiler_in = pd.DataFrame(points_in_cluster, columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(gprofiler_in)\n", + " cluster_process[cluster_id] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e41dff85-043e-46d2-8737-4db7d7bf969c", + "metadata": {}, + "outputs": [], + "source": [ + "# Create descriptions for each cluster (for demonstration purpose)\n", + "cluster_descriptions = {\n", + " 1: \"Protein tyrosine phosphatase activity\",\n", + " 2: \"\",\n", + " 3: \"protein serine/threonine kinase activity\",\n", + " 4: \"DNA-binding transcription factor activity, RNA polymerase II transcription\",\n", + " 5: \"MAPK activity, regulation of IRE1-mediated unfolded protein\",\n", + " 6: \"morphogenesis, DNA-binding transcription factor activity, transcription by RNA polymerase II\",\n", + " 7: \"negative regulation of ERBB signaling pathway\",\n", + " 8: \"MAPK activity, procentriole replication\",\n", + " 9: \"vesicle lumen\",\n", + " 10: \"collagen trimer\",\n", + " 11: \"DNA-binding transcription factor activity, RNA polymerase II transcription\",\n", + " 12: \"\",\n", + " 13: \"\",\n", + " 14: \"C/EBP complex\",\n", + "}\n", + "\n", + "# Create a consistent color palette\n", + "unique_clusters = sorted(np.unique(clusters))\n", + "palette = sns.color_palette(\"husl\", len(unique_clusters))\n", + "cluster_colors = [palette[i - 1] for i in clusters]\n", + "cluster_colors = {cid: palette[i] for i, cid in enumerate(unique_clusters)}\n", + "\n", + "# Create clustermap using consistent colors\n", + "row_colors = [cluster_colors[cid] for cid in clusters]\n", + "clustermap = sns.clustermap(\n", + " distance_matrix, cmap=\"viridis_r\", row_colors=[palette[i - 1] for i in clusters]\n", + ")\n", + "clustermap.savefig(\n", + " \"figures/figure_pngs/scETM_norman_clustermap.png\", dpi=600, bbox_inches=\"tight\"\n", + ")\n", + "\n", + "# Prepare data for the table\n", + "cluster_data = {\n", + " \"Cluster ID\": unique_clusters,\n", + " \"Description\": [cluster_descriptions[cid] for cid in unique_clusters],\n", + "}\n", + "\n", + "cluster_df = pd.DataFrame(cluster_data)\n", + "\n", + "# Plot the table with colors matching the clustermap\n", + "fig, ax = plt.subplots(figsize=(18, 4))\n", + "ax.axis(\"off\")\n", + "ax.axis(\"tight\")\n", + "\n", + "# Create table while applying the color to the row background\n", + "table = ax.table(\n", + " cellText=cluster_df.values,\n", + " colLabels=[\"Cluster ID\", \"Description\"],\n", + " cellColours=[[cluster_colors[cid]] * 2 for cid in cluster_df[\"Cluster ID\"]],\n", + " cellLoc=\"center\",\n", + " loc=\"center\",\n", + ")\n", + "\n", + "# Customize table appearance\n", + "table.auto_set_font_size(False)\n", + "table.set_fontsize(10)\n", + "table.scale(1, 1.5)\n", + "\n", + "plt.savefig(\n", + " \"figures/figure_pngs/scETM_norman_clustermap_descriptions.png\",\n", + " dpi=600,\n", + " bbox_inches=\"tight\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "a53c2cec-1c3d-465d-a627-47bcc7aa4da7", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/scETM_norman_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "5ad3121b-7c81-435e-9d09-ab431200706a", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "4509c613-b436-4143-8246-b9d83125b4bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.726058\n", + "CORUM 0.946866\n", + " F1 Threshold\n", + "StringDB 0.820312 1.0\n", + "CORUM 0.972222 1.0\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/scETM_norman_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/scETM_norman_f1.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, np.abs(adata.uns[\"gene_emb\"]), fdr=0.05)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d1e2990-edee-430e-957f-328342271a42", + "metadata": {}, + "outputs": [], + "source": [ + "# save latent enrichment results\n", + "with open(\n", + " \"figures/factor_enrichments/scETM_norman_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..46cb4d7 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,3 @@ +[tool.ruff.lint] +select = ["E4", "E7", "E9", "F", "I"] + diff --git a/replogle_pertspectra_metrics.ipynb b/replogle_pertspectra_metrics.ipynb new file mode 100644 index 0000000..0ac04bb --- /dev/null +++ b/replogle_pertspectra_metrics.ipynb @@ -0,0 +1,946 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " get_gprofiler,\n", + " perturbation_signal_recovery,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + " read_aws_pickle,\n", + " retrieve_stringdb_neighbors,\n", + " split_data_by_cell,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c57d97ad-da1a-4853-b825-a45aae5ca3dc", + "metadata": {}, + "outputs": [], + "source": [ + "# read in trained model outputs generated from ./PertSpectra_load_checkpoints/pertspectra_replogle.ipynb\n", + "adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/PertSpectra_checkpoints/pertspectra_replogle/replogle.h5ad\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression (on DE genes if available)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "train_idx, val_idx, test_idx = split_data_by_cell(\n", + " adata.X, adata.obs[\"gene\"], test_size=0.2, val_size=0.2\n", + ")\n", + "adata_test = adata[test_idx]\n", + "\n", + "for pert in adata_test.obs[\"gene\"].unique():\n", + " hold_idx = [i for i, x in enumerate(adata_test.obs[\"gene\"]) if x == pert]\n", + " recon = adata.uns[\"recon\"][hold_idx]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = np.squeeze(np.array(adata_test[hold_idx].X.mean(axis=0)))\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c75473ab-68bf-4be3-b2bf-a5bc3fe081d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a03e387a-9b61-4b4e-90c2-e1995d46c9e6", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/model_replogle_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99d3263b-8988-47a6-a57b-0dce4186eb6b", + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Compute the pairwise distances\n", + "pert_embeddings_df = pd.DataFrame(\n", + " adata.uns[\"SPECTRA_pert_scores\"], index=adata.uns[\"Spectra_pert_labels\"]\n", + ")\n", + "df = pert_embeddings_df.drop(index=[\"basal\", \"ctrl\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "clustermap = sns.clustermap(distance_matrix, cmap=\"viridis_r\")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7a684ec0-9241-42a4-b65b-b3bdf51b7c7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scipy\n", + "\n", + "den = scipy.cluster.hierarchy.dendrogram(\n", + " clustermap.dendrogram_col.linkage,\n", + " labels=distance_matrix.index,\n", + " color_threshold=0.25,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c63a3f07-044f-44e7-bbb3-26890d565536", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "from collections import defaultdict\n", + "\n", + "\n", + "def get_cluster_classes(den, label=\"ivl\"):\n", + " cluster_idxs = defaultdict(list)\n", + " for c, pi in zip(den[\"color_list\"], den[\"icoord\"]):\n", + " for leg in pi[1:3]:\n", + " i = (leg - 5.0) / 10.0\n", + " if abs(i - int(i)) < 1e-5:\n", + " cluster_idxs[c].append(int(i))\n", + " cluster_classes = {}\n", + " for c, l in cluster_idxs.items(): # noqa\n", + " i_l = [den[label][i] for i in l]\n", + " cluster_classes[c] = i_l\n", + " return cluster_classes\n", + "\n", + "\n", + "clusters = get_cluster_classes(den)\n", + "# extract functions for clusters\n", + "cluster_process = {}\n", + "for c in clusters:\n", + " cluster_df = pd.DataFrame(clusters[c], columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(cluster_df)\n", + " cluster_process[c] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c4149852-b136-46a4-bdec-f065425455b6", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/pertspectra_replogle_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "84864ce6-2724-4d11-a955-1ec4585c7876", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d281c6a7-767a-44c0-aeb1-3c5bf11e27a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.215162\n", + "CORUM 0.262926\n", + " F1 Threshold\n", + "StringDB 0.246123 0.869706\n", + "CORUM 0.306326 0.884541\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/pertspectra_replogle_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/pertspectra_replogle_f1.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cd6af182-b82d-4fe1-a5a8-fccb34556130", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the precision-recall curve\n", + "prior = \"StringDB\"\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(\n", + " pr_dict[prior][\"recall\"],\n", + " pr_dict[prior][\"precision\"],\n", + " marker=\".\",\n", + " label=\"Precision-Recall Curve\",\n", + ")\n", + "# Adding labels and title\n", + "plt.xlabel(\"Recall\")\n", + "plt.ylabel(\"Precision\")\n", + "plt.title(\"Precision-Recall Curve\")\n", + "plt.legend()\n", + "# Save the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, adata.uns[\"SPECTRA_factors\"], fdr=5e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e82f91a-70e9-44c2-b802-058348b77052", + "metadata": {}, + "outputs": [], + "source": [ + "filtered_factor_to_go" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b91d73c-87de-4197-8f7c-2554ee3d0491", + "metadata": {}, + "outputs": [], + "source": [ + "with open(\n", + " \"figures/factor_enrichments/MODEL_replogle_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "b01b3f40-7d97-481a-8e57-01627cd627ad", + "metadata": {}, + "source": [ + "## Overlap with prior knowledge/ground truth\n", + "- Group A: a set of GO terms associated with a perturbation (either drivers from msigdb, or from literature) and its neighbors in stringdb\n", + "- Group B: a set of GO terms from the interpretability analysis\n", + "- Hypergeometric test on the overlap of the two groups" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "96895bc7-560b-4893-9f3f-40a8f733779f", + "metadata": {}, + "outputs": [], + "source": [ + "# load precomputed factor_to_go dict if available\n", + "filtered_factor_to_go = read_aws_pickle(\n", + " \"s3://pert-spectra/figures/factor_enrichments/pertspectra_replogle_factor_enrichment.pickle\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e9eca6ce-4fc7-4f6a-b140-0b2276d9abe4", + "metadata": {}, + "outputs": [], + "source": [ + "# get neighbors for each perturbation\n", + "pert_neighbors = retrieve_stringdb_neighbors(adata.uns[\"Spectra_pert_labels\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ce927aaa-f5b4-4403-ab21-beeb1202a4f7", + "metadata": {}, + "outputs": [], + "source": [ + "# construct group A - known processes for each perturbation\n", + "gene_sets = read_aws_pickle(\"s3://pert-spectra/references/GO_to_Gene.pickle\")\n", + "# BP only go terms\n", + "go_reference = read_aws_csv(\"s3://pert-spectra/references/GO_terms.txt.gz\", zipped=True)\n", + "go_bp = go_reference[go_reference[\"go_category\"] == \"biological_process\"]\n", + "go_bp_ids = set(go_bp[\"go_id\"].values)\n", + "filtered_go_terms = {key: gene_sets[key] for key in go_bp_ids if key in gene_sets}\n", + "\n", + "# GO terms per perturbation AND its neighbors in stringdb\n", + "pert_to_go = {key: set() for key in adata.uns[\"Spectra_pert_labels\"]}\n", + "for goterm in filtered_go_terms:\n", + " for pert in adata.uns[\"Spectra_pert_labels\"]:\n", + " if pert in filtered_go_terms[goterm] and set(\n", + " filtered_go_terms[goterm]\n", + " ).intersection(pert_neighbors[pert]):\n", + " pert_to_go[pert].add(goterm)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e9433684-9108-4d8b-8c0f-f9c3f79155e5", + "metadata": {}, + "outputs": [], + "source": [ + "# construct set B - model identified processes for each perturbation\n", + "n = 10 # number of top factors to get processes from\n", + "model_pert_to_go = {}\n", + "for pert in adata.uns[\"Spectra_pert_labels\"]:\n", + " if pert in [\"ctrl\", \"intergenic\", \"basal\"]:\n", + " continue\n", + " # get top factors\n", + " pert_embeddings_df = pd.DataFrame(\n", + " adata.uns[\"SPECTRA_pert_scores\"], index=adata.uns[\"Spectra_pert_labels\"]\n", + " )\n", + " pert_loading = pert_embeddings_df.loc[pert]\n", + " ctrl_loading = pert_embeddings_df.loc[\"ctrl\"]\n", + " delta_loading = np.abs(np.log(pert_loading) - np.log(ctrl_loading))\n", + " top_n_factors = np.argpartition(np.array(delta_loading), -n)[-n:]\n", + " # get processes\n", + " model_processes = set()\n", + " for f in top_n_factors:\n", + " proc = filtered_factor_to_go[f]\n", + " model_processes = model_processes.union(set(proc[\"Term\"]))\n", + " model_pert_to_go[pert] = model_processes" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "739fb773-f08a-486c-b70b-3317bc749cd4", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overlap for ATP6AP1: 0 out of 9 in researchDB\n", + "P-value for ATP6AP1: 1.0\n", + "Overlap for RPL30: 0 out of 5 in researchDB\n", + "P-value for RPL30: 1.0\n", + "Overlap for DDX21: 3 out of 13 in researchDB\n", + "P-value for DDX21: 5.980456287677466e-05\n", + "Overlap for PHB: 2 out of 24 in researchDB\n", + "P-value for PHB: 0.010741839670463106\n", + "Overlap for DMAP1: 1 out of 14 in researchDB\n", + "P-value for DMAP1: 0.06354093376899977\n", + "Overlap for MCRS1: 1 out of 19 in researchDB\n", + "P-value for MCRS1: 0.10580925901854948\n", + "Overlap for CCNH: 3 out of 7 in researchDB\n", + "P-value for CCNH: 3.0005424766078534e-05\n", + "Overlap for NUMA1: 1 out of 6 in researchDB\n", + "P-value for NUMA1: 0.03329641937620341\n", + "Overlap for ALDOA: 0 out of 6 in researchDB\n", + "P-value for ALDOA: 1.0\n", + "Overlap for SNAPC3: 0 out of 5 in researchDB\n", + "P-value for SNAPC3: 1.0\n", + "Overlap for SEC61A1: 0 out of 8 in researchDB\n", + "P-value for SEC61A1: 1.0\n", + "Overlap for CCT3: 3 out of 10 in researchDB\n", + "P-value for CCT3: 5.402090913326375e-05\n", + "Overlap for EIF6: 2 out of 6 in researchDB\n", + "P-value for EIF6: 0.000615303446286681\n", + "Overlap for UTP20: 1 out of 5 in researchDB\n", + "P-value for UTP20: 0.04628097253128953\n", + "Overlap for FBL: 1 out of 6 in researchDB\n", + "P-value for FBL: 0.028199168104588085\n", + "Overlap for RPS7: 3 out of 9 in researchDB\n", + "P-value for RPS7: 8.84599979430884e-06\n", + "Overlap for BUB1B: 2 out of 7 in researchDB\n", + "P-value for BUB1B: 0.00040051787251466374\n", + "Overlap for PES1: 0 out of 6 in researchDB\n", + "P-value for PES1: 1.0\n", + "Overlap for ATP6V1A: 2 out of 11 in researchDB\n", + "P-value for ATP6V1A: 0.0007310971425003066\n", + "Overlap for NFRKB: 1 out of 13 in researchDB\n", + "P-value for NFRKB: 0.02948322206040407\n", + "Overlap for MIOS: 0 out of 5 in researchDB\n", + "P-value for MIOS: 1.0\n", + "Overlap for NEDD8: 1 out of 8 in researchDB\n", + "P-value for NEDD8: 0.05022968114062165\n", + "Overlap for TAF1: 0 out of 23 in researchDB\n", + "P-value for TAF1: 1.0\n", + "Overlap for RAD21: 1 out of 11 in researchDB\n", + "P-value for RAD21: 0.015586554804595597\n", + "Overlap for RPS6: 4 out of 9 in researchDB\n", + "P-value for RPS6: 3.850507725903189e-07\n", + "Overlap for MAX: 0 out of 7 in researchDB\n", + "P-value for MAX: 1.0\n", + "Overlap for VPS72: 1 out of 10 in researchDB\n", + "P-value for VPS72: 0.08166368798369315\n", + "Overlap for GATA1: 2 out of 20 in researchDB\n", + "P-value for GATA1: 0.008055568024662566\n", + "Overlap for SUPT4H1: 1 out of 8 in researchDB\n", + "P-value for SUPT4H1: 0.009473365146555657\n", + "Overlap for C1QBP: 0 out of 12 in researchDB\n", + "P-value for C1QBP: 1.0\n", + "Overlap for RPL26: 4 out of 7 in researchDB\n", + "P-value for RPL26: 4.910516979866623e-08\n", + "Overlap for UBA3: 0 out of 5 in researchDB\n", + "P-value for UBA3: 1.0\n", + "Overlap for MED17: 1 out of 9 in researchDB\n", + "P-value for MED17: 0.058361519318946814\n", + "Overlap for SNRPG: 1 out of 6 in researchDB\n", + "P-value for SNRPG: 0.02866347810549369\n", + "Overlap for PRPF19: 1 out of 6 in researchDB\n", + "P-value for PRPF19: 0.044798272846770126\n", + "Overlap for NAF1: 0 out of 6 in researchDB\n", + "P-value for NAF1: 1.0\n", + "Overlap for TXNL4A: 2 out of 5 in researchDB\n", + "P-value for TXNL4A: 0.000529721111247926\n", + "Overlap for RPS19: 2 out of 11 in researchDB\n", + "P-value for RPS19: 0.0009645903158693221\n", + "Overlap for AATF: 1 out of 6 in researchDB\n", + "P-value for AATF: 0.03791093137572726\n", + "Overlap for PHB2: 2 out of 19 in researchDB\n", + "P-value for PHB2: 0.009185594870537925\n", + "Overlap for VPS28: 0 out of 9 in researchDB\n", + "P-value for VPS28: 1.0\n", + "Overlap for RPS28: 1 out of 7 in researchDB\n", + "P-value for RPS28: 0.03336150600238275\n", + "Overlap for EXOSC7: 2 out of 13 in researchDB\n", + "P-value for EXOSC7: 0.002471059938780703\n", + "Overlap for WDR12: 0 out of 5 in researchDB\n", + "P-value for WDR12: 1.0\n", + "Overlap for POLD1: 2 out of 12 in researchDB\n", + "P-value for POLD1: 0.0035245791373806645\n", + "Overlap for COPS3: 0 out of 6 in researchDB\n", + "P-value for COPS3: 1.0\n", + "Overlap for NVL: 3 out of 5 in researchDB\n", + "P-value for NVL: 2.4319712243376875e-06\n", + "Overlap for PAF1: 0 out of 13 in researchDB\n", + "P-value for PAF1: 1.0\n", + "Overlap for RAD51: 5 out of 28 in researchDB\n", + "P-value for RAD51: 1.0101324774451766e-06\n", + "Overlap for CCT5: 3 out of 10 in researchDB\n", + "P-value for CCT5: 4.480528947125347e-05\n", + "Overlap for MED1: 1 out of 35 in researchDB\n", + "P-value for MED1: 0.1771416321151657\n", + "Overlap for EXOC1: 0 out of 9 in researchDB\n", + "P-value for EXOC1: 1.0\n", + "Overlap for CCNK: 1 out of 10 in researchDB\n", + "P-value for CCNK: 0.03587615783321504\n", + "Overlap for RPL10: 2 out of 6 in researchDB\n", + "P-value for RPL10: 0.000615303446286681\n", + "Overlap for ACTR8: 5 out of 16 in researchDB\n", + "P-value for ACTR8: 5.384424999101365e-08\n", + "Overlap for SNRPD3: 2 out of 6 in researchDB\n", + "P-value for SNRPD3: 0.0005149057259652727\n", + "Overlap for LAMTOR4: 0 out of 5 in researchDB\n", + "P-value for LAMTOR4: 1.0\n", + "Overlap for TAF7: 1 out of 17 in researchDB\n", + "P-value for TAF7: 0.10010863013860945\n", + "Overlap for RFC4: 2 out of 5 in researchDB\n", + "P-value for RFC4: 0.00016526499161894154\n", + "Overlap for RPTOR: 1 out of 27 in researchDB\n", + "P-value for RPTOR: 0.27462065680998554\n", + "Overlap for RPL23: 1 out of 10 in researchDB\n", + "P-value for RPL23: 0.041995859043389136\n", + "Overlap for SMC1A: 4 out of 10 in researchDB\n", + "P-value for SMC1A: 2.4186483678243333e-08\n", + "Overlap for SF3A2: 1 out of 5 in researchDB\n", + "P-value for SF3A2: 0.014186403172397456\n", + "Overlap for EIF2B3: 1 out of 6 in researchDB\n", + "P-value for EIF2B3: 0.03652850935432338\n", + "Overlap for POLD3: 1 out of 8 in researchDB\n", + "P-value for POLD3: 0.05868377093103718\n", + "Overlap for INTS3: 1 out of 7 in researchDB\n", + "P-value for INTS3: 0.04888428544377561\n", + "Overlap for MNAT1: 2 out of 11 in researchDB\n", + "P-value for MNAT1: 0.00139474279814442\n", + "Overlap for GRB2: 2 out of 16 in researchDB\n", + "P-value for GRB2: 0.0011432815400414342\n", + "Overlap for INO80B: 3 out of 13 in researchDB\n", + "P-value for INO80B: 0.00012280139562832808\n", + "Overlap for CCT8: 2 out of 10 in researchDB\n", + "P-value for CCT8: 0.0030106276764372197\n", + "Overlap for BOP1: 1 out of 6 in researchDB\n", + "P-value for BOP1: 0.03329641937620341\n", + "Overlap for COPS8: 0 out of 6 in researchDB\n", + "P-value for COPS8: 1.0\n", + "Overlap for INO80: 1 out of 20 in researchDB\n", + "P-value for INO80: 0.031251091286424816\n", + "Overlap for UBE2N: 2 out of 16 in researchDB\n", + "P-value for UBE2N: 0.007349623192881736\n", + "Overlap for TAF12: 1 out of 17 in researchDB\n", + "P-value for TAF12: 0.12302325506021794\n", + "Overlap for EIF2B2: 2 out of 9 in researchDB\n", + "P-value for EIF2B2: 0.0009190149284216131\n", + "Overlap for EIF2B4: 0 out of 8 in researchDB\n", + "P-value for EIF2B4: 1.0\n", + "Overlap for TELO2: 1 out of 5 in researchDB\n", + "P-value for TELO2: 0.037472286923089536\n", + "Overlap for BCR: 2 out of 14 in researchDB\n", + "P-value for BCR: 0.002795217526457602\n", + "Overlap for RPL11: 4 out of 15 in researchDB\n", + "P-value for RPL11: 4.932969797549702e-06\n", + "Overlap for MED30: 0 out of 6 in researchDB\n", + "P-value for MED30: 1.0\n", + "Overlap for PPP1CA: 1 out of 18 in researchDB\n", + "P-value for PPP1CA: 0.036471485600401074\n", + "Overlap for MED10: 0 out of 5 in researchDB\n", + "P-value for MED10: 1.0\n", + "Overlap for EXOSC4: 2 out of 15 in researchDB\n", + "P-value for EXOSC4: 0.007603333550124456\n", + "Overlap for KANSL2: 0 out of 7 in researchDB\n", + "P-value for KANSL2: 1.0\n", + "Overlap for MED14: 0 out of 7 in researchDB\n", + "P-value for MED14: 1.0\n", + "Overlap for NCBP1: 5 out of 24 in researchDB\n", + "P-value for NCBP1: 3.952539644538647e-07\n", + "Overlap for EXOSC3: 1 out of 14 in researchDB\n", + "P-value for EXOSC3: 0.08421492165545252\n", + "Overlap for SUPT6H: 2 out of 9 in researchDB\n", + "P-value for SUPT6H: 0.0011577054718808673\n", + "Overlap for COPS5: 2 out of 12 in researchDB\n", + "P-value for COPS5: 0.0016176646331365141\n", + "Overlap for UPF1: 4 out of 11 in researchDB\n", + "P-value for UPF1: 1.4839056717361259e-06\n", + "Overlap for SDHA: 0 out of 6 in researchDB\n", + "P-value for SDHA: 1.0\n", + "Overlap for DAD1: 1 out of 6 in researchDB\n", + "P-value for DAD1: 0.045713472662023885\n", + "Overlap for TRRAP: 3 out of 18 in researchDB\n", + "P-value for TRRAP: 0.0003614867115463507\n", + "Overlap for CPSF6: 1 out of 8 in researchDB\n", + "P-value for CPSF6: 0.03742397846149575\n", + "Overlap for TAF6: 2 out of 14 in researchDB\n", + "P-value for TAF6: 0.005215080250213804\n", + "Overlap for GINS4: 1 out of 5 in researchDB\n", + "P-value for GINS4: 0.028598634586795634\n", + "Overlap for METTL3: 3 out of 13 in researchDB\n", + "P-value for METTL3: 0.00012656348190672007\n", + "Overlap for MED7: 0 out of 7 in researchDB\n", + "P-value for MED7: 1.0\n", + "Overlap for TTK: 3 out of 11 in researchDB\n", + "P-value for TTK: 2.9651787336133862e-05\n", + "Overlap for GTF2H1: 1 out of 7 in researchDB\n", + "P-value for GTF2H1: 0.014338369809308697\n", + "Overlap for RPS9: 0 out of 5 in researchDB\n", + "P-value for RPS9: 1.0\n", + "Overlap for CHMP6: 1 out of 25 in researchDB\n", + "P-value for CHMP6: 0.08187584716296124\n", + "Overlap for SEH1L: 2 out of 11 in researchDB\n", + "P-value for SEH1L: 0.0006118761218801126\n", + "Overlap for MED8: 0 out of 5 in researchDB\n", + "P-value for MED8: 1.0\n", + "Overlap for MTOR: 5 out of 63 in researchDB\n", + "P-value for MTOR: 0.00022537551709343121\n", + "Overlap for TAF2: 0 out of 12 in researchDB\n", + "P-value for TAF2: 1.0\n", + "Overlap for MED6: 0 out of 6 in researchDB\n", + "P-value for MED6: 1.0\n", + "Overlap for ENO1: 0 out of 6 in researchDB\n", + "P-value for ENO1: 1.0\n", + "Overlap for MED20: 1 out of 6 in researchDB\n", + "P-value for MED20: 0.045255964139129114\n", + "Overlap for ATP6V1B2: 0 out of 5 in researchDB\n", + "P-value for ATP6V1B2: 1.0\n", + "Overlap for GAB2: 0 out of 6 in researchDB\n", + "P-value for GAB2: 1.0\n", + "Overlap for MYBBP1A: 4 out of 11 in researchDB\n", + "P-value for MYBBP1A: 1.2223399245264868e-06\n", + "Overlap for KANSL3: 0 out of 8 in researchDB\n", + "P-value for KANSL3: 1.0\n", + "Overlap for MCM3: 2 out of 6 in researchDB\n", + "P-value for MCM3: 0.00027671399181365935\n", + "Overlap for RFC5: 3 out of 5 in researchDB\n", + "P-value for RFC5: 9.646951764033886e-07\n", + "Overlap for NUP62: 3 out of 12 in researchDB\n", + "P-value for NUP62: 5.5790530145847814e-05\n", + "Overlap for GLRX3: 1 out of 6 in researchDB\n", + "P-value for GLRX3: 0.031908474742726685\n", + "Overlap for TADA3: 1 out of 19 in researchDB\n", + "P-value for TADA3: 0.08802395013148663\n", + "Overlap for METTL14: 2 out of 9 in researchDB\n", + "P-value for METTL14: 0.0012215579257578778\n", + "Overlap for MCM5: 3 out of 6 in researchDB\n", + "P-value for MCM5: 1.3088944199027693e-06\n", + "Overlap for SMG5: 2 out of 5 in researchDB\n", + "P-value for SMG5: 0.0009853709543044674\n", + "Overlap for DKC1: 2 out of 12 in researchDB\n", + "P-value for DKC1: 0.0033095825799992597\n", + "Overlap for SKP2: 0 out of 6 in researchDB\n", + "P-value for SKP2: 1.0\n", + "Overlap for RPS3A: 3 out of 5 in researchDB\n", + "P-value for RPS3A: 6.1926356356671515e-06\n", + "Overlap for NCBP2: 2 out of 19 in researchDB\n", + "P-value for NCBP2: 0.001539819932302026\n", + "Overlap for CHMP3: 0 out of 26 in researchDB\n", + "P-value for CHMP3: 1.0\n", + "Overlap for KAT8: 0 out of 10 in researchDB\n", + "P-value for KAT8: 1.0\n", + "Overlap for HSPA9: 3 out of 8 in researchDB\n", + "P-value for HSPA9: 2.5499492628815173e-05\n", + "Overlap for POLD2: 1 out of 5 in researchDB\n", + "P-value for POLD2: 0.028598634586795634\n", + "Overlap for CASP8AP2: 0 out of 5 in researchDB\n", + "P-value for CASP8AP2: 1.0\n", + "Overlap for UBE2I: 2 out of 11 in researchDB\n", + "P-value for UBE2I: 0.00045257392877956064\n", + "Overlap for EXOSC8: 1 out of 12 in researchDB\n", + "P-value for EXOSC8: 0.03556147437814442\n", + "Overlap for EIF2B1: 1 out of 6 in researchDB\n", + "P-value for EIF2B1: 0.040670816947906745\n", + "Overlap for YEATS4: 1 out of 13 in researchDB\n", + "P-value for YEATS4: 0.0736482173215087\n", + "Overlap for RPL5: 4 out of 12 in researchDB\n", + "P-value for RPL5: 1.8029092140895893e-07\n", + "Overlap for KIF20A: 0 out of 6 in researchDB\n", + "P-value for KIF20A: 1.0\n", + "Overlap for EIF2B5: 1 out of 11 in researchDB\n", + "P-value for EIF2B5: 0.05442069701975445\n", + "Overlap for WDR61: 0 out of 6 in researchDB\n", + "P-value for WDR61: 1.0\n", + "Overlap for ATF5: 2 out of 6 in researchDB\n", + "P-value for ATF5: 0.0003405680502523435\n", + "Overlap for HINFP: 0 out of 7 in researchDB\n", + "P-value for HINFP: 1.0\n", + "Overlap for EXOSC6: 2 out of 11 in researchDB\n", + "P-value for EXOSC6: 0.0018034167554763156\n", + "Overlap for MAGOH: 2 out of 8 in researchDB\n", + "P-value for MAGOH: 0.001194722130001048\n", + "Overlap for MAD2L1: 5 out of 9 in researchDB\n", + "P-value for MAD2L1: 2.5363032932725105e-09\n", + "Overlap for HSPD1: 3 out of 18 in researchDB\n", + "P-value for HSPD1: 0.00020118530173201323\n", + "Overlap for XPO1: 2 out of 8 in researchDB\n", + "P-value for XPO1: 0.0010311513996934835\n", + "Overlap for EIF4G2: 1 out of 5 in researchDB\n", + "P-value for EIF4G2: 0.030146560935722915\n", + "Overlap for RPL7: 0 out of 5 in researchDB\n", + "P-value for RPL7: 1.0\n", + "Overlap for BRD8: 0 out of 10 in researchDB\n", + "P-value for BRD8: 1.0\n", + "Overlap for CLTC: 2 out of 13 in researchDB\n", + "P-value for CLTC: 0.0017894707781930812\n", + "Overlap for RBM4: 1 out of 8 in researchDB\n", + "P-value for RBM4: 0.030656133269285887\n", + "Overlap for DNAJA3: 2 out of 8 in researchDB\n", + "P-value for DNAJA3: 0.0009038201917254252\n", + "Overlap for SUPT16H: 3 out of 7 in researchDB\n", + "P-value for SUPT16H: 1.5546548801441513e-05\n", + "Overlap for MCM6: 3 out of 5 in researchDB\n", + "P-value for MCM6: 5.374919107367473e-06\n", + "Overlap for TSG101: 1 out of 24 in researchDB\n", + "P-value for TSG101: 0.10133881660330367\n", + "Overlap for TAF8: 0 out of 7 in researchDB\n", + "P-value for TAF8: 1.0\n", + "Overlap for MCM2: 4 out of 10 in researchDB\n", + "P-value for MCM2: 2.618018946162168e-07\n", + "Overlap for PRPF6: 2 out of 6 in researchDB\n", + "P-value for PRPF6: 0.0005857221455239715\n", + "Overlap for CDC73: 2 out of 20 in researchDB\n", + "P-value for CDC73: 0.005107020540025154\n", + "Overlap for EXOSC2: 2 out of 12 in researchDB\n", + "P-value for EXOSC2: 0.002042317444150196\n", + "Overlap for EP400: 1 out of 10 in researchDB\n", + "P-value for EP400: 0.06984722382984401\n", + "Overlap for CHAF1B: 3 out of 5 in researchDB\n", + "P-value for CHAF1B: 3.6691488048685227e-07\n", + "Overlap for RPS24: 2 out of 5 in researchDB\n", + "P-value for RPS24: 0.0006620439075372245\n", + "Overlap for EXOC4: 0 out of 9 in researchDB\n", + "P-value for EXOC4: 1.0\n", + "Overlap for MED12: 0 out of 8 in researchDB\n", + "P-value for MED12: 1.0\n", + "Overlap for ATP6V1H: 1 out of 9 in researchDB\n", + "P-value for ATP6V1H: 0.06173790884147587\n", + "Overlap for NUDT21: 1 out of 9 in researchDB\n", + "P-value for NUDT21: 0.046116910946927304\n", + "Overlap for CCT7: 2 out of 9 in researchDB\n", + "P-value for CCT7: 0.001602393812389033\n", + "Overlap for CUL1: 0 out of 7 in researchDB\n", + "P-value for CUL1: 1.0\n", + "Overlap for RRS1: 1 out of 6 in researchDB\n", + "P-value for RRS1: 0.024943816481445866\n", + "Overlap for YEATS2: 0 out of 13 in researchDB\n", + "P-value for YEATS2: 1.0\n", + "Overlap for AP2S1: 0 out of 7 in researchDB\n", + "P-value for AP2S1: 1.0\n", + "Overlap for NCKAP1: 1 out of 10 in researchDB\n", + "P-value for NCKAP1: 0.09189207950588776\n", + "Overlap for XRCC5: 2 out of 25 in researchDB\n", + "P-value for XRCC5: 0.007925137444318536\n", + "Overlap for DICER1: 1 out of 10 in researchDB\n", + "P-value for DICER1: 0.02972129585261667\n", + "Overlap for CCT4: 1 out of 11 in researchDB\n", + "P-value for CCT4: 0.03433672065092231\n", + "Overlap for SMC3: 5 out of 11 in researchDB\n", + "P-value for SMC3: 1.2919646600125852e-09\n", + "Overlap for ERCC3: 1 out of 16 in researchDB\n", + "P-value for ERCC3: 0.07818335296874425\n", + "Overlap for MCM4: 2 out of 6 in researchDB\n", + "P-value for MCM4: 0.00038676590840153185\n", + "Overlap for CPSF3: 0 out of 6 in researchDB\n", + "P-value for CPSF3: 1.0\n", + "Overlap for CCT2: 3 out of 12 in researchDB\n", + "P-value for CCT2: 7.369246161295306e-05\n", + "Overlap for TCP1: 2 out of 12 in researchDB\n", + "P-value for TCP1: 0.002331790613204371\n", + "Overlap for NUP54: 0 out of 6 in researchDB\n", + "P-value for NUP54: 1.0\n", + "Overlap for MIS12: 3 out of 5 in researchDB\n", + "P-value for MIS12: 3.134875270533881e-06\n", + "Overlap for CTR9: 0 out of 15 in researchDB\n", + "P-value for CTR9: 1.0\n", + "Overlap for ERCC2: 0 out of 14 in researchDB\n", + "P-value for ERCC2: 1.0\n", + "Overlap for TRMT112: 0 out of 5 in researchDB\n", + "P-value for TRMT112: 1.0\n", + "Overlap for PNPT1: 0 out of 7 in researchDB\n", + "P-value for PNPT1: 1.0\n", + "Overlap for MED21: 0 out of 6 in researchDB\n", + "P-value for MED21: 1.0\n", + "Overlap for RPS3: 7 out of 15 in researchDB\n", + "P-value for RPS3: 4.927470217586745e-12\n" + ] + } + ], + "source": [ + "pvals = perturbation_signal_recovery(\n", + " pert_to_go,\n", + " model_pert_to_go,\n", + " list(filtered_go_terms.keys()),\n", + " list(adata.uns[\"Spectra_pert_labels\"]),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "98cb9f87-58e7-46fb-ab9c-bfc04fb7209a", + "metadata": {}, + "outputs": [], + "source": [ + "# save as csv for visualization\n", + "pd.DataFrame.from_dict(data=pvals, orient=\"index\").to_csv(\n", + " \"figures/process_recovery_hypergeo_pvals/pertspectra_replogle_hypergeo_neighbors_recovery_pvalues.csv\",\n", + " header=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39264204-40a8-46b4-b24f-5e88fb3280ce", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/replogle_scETM_metrics.ipynb b/replogle_scETM_metrics.ipynb new file mode 100644 index 0000000..fc70a14 --- /dev/null +++ b/replogle_scETM_metrics.ipynb @@ -0,0 +1,402 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b8270f66-7a27-4263-aa97-25abeb2cf34d", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "529f64f3-c83e-481d-872c-df89b9dd063b", + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from utils import (\n", + " auprc,\n", + " factor_enrichment_gsea,\n", + " get_gprofiler,\n", + " read_aws_csv,\n", + " read_aws_h5ad,\n", + " split_data_by_cell,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db596f53-18d6-4c3b-82ac-601923be6eb1", + "metadata": {}, + "outputs": [], + "source": [ + "# read in scETM results\n", + "adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/scETM_checkpoints/scetm_replogle/scetm_replogle.h5ad\"\n", + ")\n", + "# read in pertspectra results to retrieve gene labels\n", + "ref_adata = read_aws_h5ad(\n", + " \"s3://pert-spectra/PertSpectra_checkpoints/pertspectra_replogle/replogle.h5ad\"\n", + ")\n", + "adata.var_names = ref_adata.var_names" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bf773-5e0c-43b8-8df2-4ce3376be959", + "metadata": {}, + "source": [ + "# Reconstruction" + ] + }, + { + "cell_type": "markdown", + "id": "3b4b092b-2120-48c6-a492-84656e8b7169", + "metadata": {}, + "source": [ + "## Spearman Coefficient\n", + "- Spearman correlation between predicted and observed expression (on DE genes if available)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e2885bd3-5433-47d6-88d5-47be83df5b5a", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "test_corr_singles = []\n", + "test_corr_combos = []\n", + "train_idx, val_idx, test_idx = split_data_by_cell(\n", + " adata.X, adata.obs[\"gene\"], test_size=0.2, val_size=0.2\n", + ")\n", + "adata_test = adata[test_idx]\n", + "for pert in adata_test.obs[\"gene\"].unique():\n", + " hold_idx = [i for i, x in enumerate(adata_test.obs[\"gene\"]) if x == pert]\n", + " recon = adata_test.uns[\"recon\"][hold_idx]\n", + " # correlation\n", + " mean_reconstruction = recon.mean(axis=0)\n", + " mean_observed = np.squeeze(np.array(adata_test[hold_idx].X.mean(axis=0)))\n", + " if (\"+\" in pert) and (\"ctrl\" not in pert):\n", + " test_corr_combos.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )\n", + " else:\n", + " test_corr_singles.append(\n", + " [pert, spearmanr(mean_reconstruction, mean_observed)[0]]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9f7404d5-c4b3-44be-a6c3-0e213a6704b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot train correlation distribution vs test correlation distribution\n", + "import seaborn as sns\n", + "\n", + "test_corr = np.array(test_corr_singles + test_corr_combos)[:, 1].astype(float)\n", + "sns.histplot(test_corr, label=\"test_corr\")\n", + "plt.title(\"Correlation between predicted and observed expression per perturbation\")\n", + "plt.xlabel(\"Spearman Correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c6817a48-76e2-4d36-9725-68dab2568d2f", + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\n", + " \"figures/reconstruction_spearmans/scETM_replogle_spearman_correlations.csv\",\n", + " test_corr,\n", + " delimiter=\",\",\n", + " fmt=\"%.2f\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "64fc0b35-f87e-4d8a-87f1-e6080a3ee83f", + "metadata": {}, + "source": [ + "# Perturbation Embedding Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "c36ebe2b-2835-44ed-9f71-a52b522125b1", + "metadata": {}, + "source": [ + "## Hierarchical Clustering + Enrichment\n", + "- Perform enrichment tests (gprofiler) on hierarchical clustering of perturbation embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aaf8dc3-7e5b-4748-8685-fc8560bf7fc7", + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# aggregate cell embeddings to perturbation embeddings\n", + "cell_emb = adata.uns[\"cell_emb\"] @ adata.uns[\"topics\"]\n", + "perts = []\n", + "pert_emb = []\n", + "for i in adata.obs[\"gene\"].unique():\n", + " if \"+\" not in i and i != \"nan\":\n", + " perts.append(i)\n", + " pert_emb.append(cell_emb[adata.obs[\"gene\"] == i].mean(axis=0))\n", + "pert_emb = np.array(pert_emb)\n", + "pert_emb_df = pd.DataFrame(pert_emb, index=perts)\n", + "\n", + "# Compute the pairwise distances\n", + "df = pert_emb_df.drop(index=[\"non-targeting\"])\n", + "\n", + "distance = \"euclidean\"\n", + "distances = pdist(df.values, metric=distance)\n", + "\n", + "# Convert the distances into a square distance matrix\n", + "distance_matrix = pd.DataFrame(squareform(distances), index=df.index, columns=df.index)\n", + "clustermap = sns.clustermap(distance_matrix, cmap=\"viridis_r\")\n", + "clustermap.fig.suptitle(f\"Pairwise {distance} distance of perturbation latent vectors\")\n", + "# clustermap.ax_row_dendrogram.set_visible(False)\n", + "clustermap.ax_col_dendrogram.set_visible(False)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "bc7de299-d751-480c-b275-23ffab452b3e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhkAAAG/CAYAAAD1t8XlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADAv0lEQVR4nOzdd3hUVfoH8O/0XjLpZdILCQmhdxQBKYqoiCirrGIB62Jf+dnWyqqsZXXFtrpiwy4qIr2J9N5JSEjvbVImU8/vD7yHSUybkEnB9/M8eUiGKWfu3Ln3vee85z0ixhgDIYQQQkgXE/d0AwghhBByYaIggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCek3f2CbrcbhYWF0Ol0EIlE3f3yhBBCCOkExhhqa2sRFhYGsbhjfRTdHmQUFhbCbDZ398sSQgghpAvk5eUhIiKiQ/ft9iBDp9MBONtIvV7f3S9PCCGEkE6wWCwwm838PN4R3R5kCEMker2eggxCCCGkj/Em1YESPwkhhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT7R7auwChhjaLA7e+rlCSGkW6hkEq9WrSTkQtJjQcbc/+7CoVJ7T708IYR0i6FRfvjqjlEUaJA/pR4bLjmQV91TL00IId1mT04VrA5XTzeDkB7RYz0Zgj2PT4JaLunpZhBCSJdqsLsw9Ll1Pd0MQnpUjwcZarkEanmPN4MQQgghXYxmlxBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8wusgo6CgADfeeCP8/f2hVqsxcOBA7N271xdtI4QQQkgf5tXc0aqqKowZMwaXXHIJVq1ahaCgIJw+fRpGo9FHzSOEEEJIX+VVkPHiiy/CbDbjww8/5LdFR0d3dZsIIYQQcgHwarjkhx9+wNChQ3HttdciKCgIgwYNwnvvvdfmY2w2GywWS5MfQgghhFz4vAoysrKysHTpUiQkJGD16tW444478Le//Q3Lli1r9TGLFy+GwWDgP2az+bwbTQghhJDez6sgw+12Y/DgwXjhhRcwaNAgLFiwALfffjuWLl3a6mMWLVqEmpoa/pOXl3fejSaEEEJI7+dVkBEaGoqUlJQmtyUnJyM3N7fVxygUCuj1+iY/hBBCCLnweRVkjBkzBidPnmxy26lTpxAVFdWljSKEEEJI3+dVkHH//fdjx44deOGFF5CZmYnPPvsM7777Lu6++25ftY8QQgghfZRXQcawYcPw3Xff4fPPP0dqaiqeffZZvPbaa7jhhht81T5CCCGE9FFe1ckAgOnTp2P69Om+aAshhBBCLiC0dgkhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT5BQQYhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT3gVZPzjH/+ASCRq8hMSEuKrthFCCCGkD5N6+4D+/ftj3bp1/G+JRNKlDSKEEELIhcHrIEMqlVLvBSGEEELa5XVORkZGBsLCwhATE4Prr78eWVlZbd7fZrPBYrE0+SGEEELIhc+rIGPEiBFYtmwZVq9ejffeew/FxcUYPXo0KioqWn3M4sWLYTAY+I/ZbD7vRhNCCCGk9/MqyJg2bRquueYapKWlYdKkSVi5ciUA4KOPPmr1MYsWLUJNTQ3/ycvLO78WE0IIIaRP8Donw5NGo0FaWhoyMjJavY9CoYBCoTiflyGEEEJIH3RedTJsNhuOHz+O0NDQrmoPIYQQQi4QXgUZDz30EDZv3ozs7Gzs3LkTs2bNgsViwU033eSr9hFCCCGkj/JquCQ/Px9z5sxBeXk5AgMDMXLkSOzYsQNRUVG+ah8hhBBC+iivgozly5f7qh2EEEIIucDQ2iWEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT5BQQYhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT5BQQYhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPnFeQcbixYshEolw3333dVFzCCGEEHKh6HSQsXv3brz77rsYMGBAV7aHEEIIIReITgUZdXV1uOGGG/Dee+/Bz8+vzfvabDZYLJYmP4QQQgi58HUqyLj77rtx+eWXY9KkSe3ed/HixTAYDPzHbDZ35iUJIYQQ0sd4HWQsX74c+/btw+LFizt0/0WLFqGmpob/5OXled1IQgghhPQ9Um/unJeXh4ULF2LNmjVQKpUdeoxCoYBCoehU4wghhBDSd3kVZOzduxelpaUYMmQIv83lcmHLli148803YbPZIJFIuryRhBBCCOl7vAoyJk6ciMOHDze5bd68eejXrx/+/ve/U4BBCCGEEM6rIEOn0yE1NbXJbRqNBv7+/n+4nRBCCCF/blTxkxBCCCE+4VVPRks2bdrUBc0ghBBCyIWGejIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT5BQQYhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QlpTzeAkL6AMQarw9XTzSB9SIPd2eLvhHSESiaBSCTq6WacNwoyCGkHYwyz3t6OvTlVPd0U0kcNfW59TzeB9DFDo/zw1R2j+nygQcMlhLTD6nBRgEEI6VZ7cqouiN5T6skgxAt7Hp8EtVzS080ghFygGuwuDH1uXU83o8tQkEGIF9RyCdRy+toQQkhH0HAJIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT7hVZCxdOlSDBgwAHq9Hnq9HqNGjcKqVat81TZCCCGE9GFeBRkRERH45z//iT179mDPnj2YMGECrrzyShw9etRX7SOEEEJIH+VVfeQrrriiyd/PP/88li5dih07dqB///5d2jBCCCGE9G2dXoTB5XLhq6++Qn19PUaNGtXq/Ww2G2w2G//bYrF09iUJIYQQ0od4nfh5+PBhaLVaKBQK3HHHHfjuu++QkpLS6v0XL14Mg8HAf8xm83k1mBBCCCF9g9c9GUlJSThw4ACqq6vxzTff4KabbsLmzZtbDTQWLVqEBx54gP9tsVgo0CCEEPKnwRiD1eHq0H0b7M4Wf2+PSiaBSCTyum2+5nWQIZfLER8fDwAYOnQodu/ejddffx3vvPNOi/dXKBRQKBTn10pCCCGkD2KMYdbb27E3p8rrxw59bn3H7xvlh6/uGNXrAo3zrpPBGGuSc0EIIYSQs6wOV6cCDG/tyanqcG9Jd/KqJ+P//u//MG3aNJjNZtTW1mL58uXYtGkTfvnlF1+1jxBCCLkg7Hl8EtRySZc+Z4PdhaHPrevS5+xKXgUZJSUlmDt3LoqKimAwGDBgwAD88ssvuPTSS33VPkIIIeSCoJZLoJZ3elJnn+TVu/3vf//rq3YQQggh5AJDa5cQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT5BQQYhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJyjIIIQQQohPUJBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxiR4PMhhjPd0EQgghhPhAjwcZN76/iwINQggh5ALU40HG/rxqWB2unm4GIYQQQrpYjwcZhBBCCLkwUZBBCCGEEJ+gIIMQQgghPkFBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn6AggxBCCCE+QUEGIYQQQnyCggxCCCGE+AQFGYQQQgjxCQoyCCGEEOITFGQQQgghxCekPd2A3ooxBqvD1dPNIL1Ag93Z4u/kz0slk0AkEvV0M8ifRFvno44en3pqn6UgowWMMcx6ezv25lT1dFNILzP0ufU93QTSCwyN8sNXd4yiQIP4nDfno7aOTz21z9JwSQusDhcFGISQVu3JqaKeTtItuup81FP7LPVktGPP45Oglkt6uhmEkF6gwe7C0OfW9XQzyJ9UZ85HPb3PehVkLF68GN9++y1OnDgBlUqF0aNH48UXX0RSUpKv2tfj1HIJ1HKKxQghhPSsvng+8mq4ZPPmzbj77ruxY8cOrF27Fk6nE5MnT0Z9fb2v2kcIIYSQPsqrkOiXX35p8veHH36IoKAg7N27FxdddFGXNowQQgghfdt59bvU1NQAAEwmU6v3sdlssNls/G+LxXI+L0kIIYSQPqLTs0sYY3jggQcwduxYpKamtnq/xYsXw2Aw8B+z2dzZlySEEEJIH9LpIOOee+7BoUOH8Pnnn7d5v0WLFqGmpob/5OXldfYlCSGEENKHdGq45N5778UPP/yALVu2ICIios37KhQKKBSKTjWOEOJbVNnWO1T9tfOoSuqfk1dBBmMM9957L7777jts2rQJMTExvmoXIcTHqLLt+aHqr96hKql/Tl4FGXfffTc+++wzrFixAjqdDsXFxQAAg8EAlUrlkwYSQnyDKtuS7iRUnOxrdR7I+fHq0166dCkAYPz48U1u//DDD3HzzTd3uhGMsU4/lhBy/qiyLfGVnq44+WfS0vBne0N8vh7G8nq4xBeo+4yQntUXKwkSQs7pyPBnS0N8vh7GogXSCCGEkD6us8Ofvl44jS5dCCGEkAtIR4Y/u2sYi4IMQggh5ALSm4Y/abiEEEIIIT5BQQYhhBBCfIKCDEIIIYT4BAUZhBBCCPEJCjIIIYQQ4hMUZBBCCCHEJ3rHHBdCCCF9grcr957vyrW0emvfRkEGIYSQDjnflXs7s3Itrd7at9FwCSGEkA7piZV7fV32mvgW9WQQQgjxmq9X7qXVWy8MFGQQQgjxWm8qXU16LxouIYQQQohPUJBBCCGEEJ+gIIMQQgghPkEDaoQQQsgFrKXaJm3VL+nK2iQUZBBCCCEXqI7UNmlev6Qra5PQcAkhhBBygepMbZOurE1CPRmEEEJ8hjEG5nB7/Ti33dXkdzc6d1UtkompWujv2qtt4ovaJBRkEEII8QnGGMrePgR7jsXrx1rB+O9Fz+2EqpNBhjxKj8A7BvS5QIMxBrfbCpfrXLDlclnhckkgFqs69X56orYJBRmEEEJ8gjncnQowAEAFEX6F/rzbYM+xgDncEPmwOmlXY4xh777ZqKnZB5tTDmAJAGDr1uFQSO0wGIZgyOAv+kTgREEGIYQQnwt9fES3nuiZ3YWi53Z22+t1JbfbipqafQAAhdSO/07+W5P/r6nZC7fbColE3RPN8woFGYQQQnxOJJdA3I1BhvdZIL3TuLE7eTDhcjVg668jerhF3qEggxBCCOmlJBJ1n+ixaA1NYSWEEEKIT/SKIIMx1v6dCCGEENKn9IogY/7a+RRoEEII8Rpj7GwdjRZ+BK39P513zmGMocFh5X83OKxocDSc9zbq8ZwMbdITOFThgNVphVrWd8edCCGEdK+O1uEobmWWSV+todHVGGP466q/Yn/JUQDPAgDGf3kxRGIHBgUNwkdTP+r0NurxION8McbArNb27+iFJhFwgxVuZ9dnRItUnSumQggh5KzzqcMB9M0aGr5gdVpxoOwARGJAl/xok//bX7r/vDoB+nSQwRhDzl9ugHX//i593kaJHLjiBQBAxpixULrsXfr8AKAaPBhRn35CgQYhhHQBb+pw9NUaGp5DFy5XQ6crf7Zl0+xNUElVsDqtGP/l+PN+vr4dZFitXR5gAIDSZceq7x/q8uf1ZN23D8xqhUhNQ0SEEHK+WqrD0dq6KZ5ZBp49102er5etecIYw/4Dc/nfW38d4ZPKnyqpqktTF/p0kOEpYduvEKtUPd2MdrmtVmSMGdvTzSCEkAtaT+VrMMbgcDj433aPIMZud0DqUSZMJpN1+PndbissloNNbmu38idjgL3h3N/2BkCmA7oxeLpgggyxSgUx9QoQQkiP8uw9aD7DQ9AdvQQ9ka/BGMMHH3yAvLw8fpuDiQEMAQC8/PLLkInOBRlmsxm33HKL19ti9KhN+G37+PYaA3wwBcg9AODDs7e9HA9EDgJu+aXbAo0LJsgghBDSs9rqPfDsMejuWR3dla/hcDiaBBgAIBO5cbNyd4v3z8vLg8PhgFwu9+p1JJKmvfaMMdR7rNZa73JBxRohytsJtQg4o/yLx4vuABwNgFzj1Wt2FgUZhBBCukRHew+6e1aHN+umdNWaJw899FCrwYPdbseSJUu65HUYY5ixLxO7K2uh/P22tF+PYrifGisAiADgocyz/7Ekvkte0xsUZHQBb6bRuj3u5/Zi6i1NeSWE9CUt9R701VkdnSGXy73uoegMq5tht6UekIrROCWc376rthENYiU07kZA3nOpBBRknKfzmUbrTQIoTXklhPQlLfUeXCgro/ZWh8f0BwCkbTvawy05h4KM8+SrabTN0ZTXtjHG4LTTIcwbDo9EPIfNBQejANYbUnnvmuJIvNfSFNfWklUFvW1qqye1pFesFNIEBRldyBfTaGnKa/sYY/j25X0ozqrp6ab0KXYwwHj29w8e/hVy9M4DZ28VGmfA1Q8N7rUnHNK2jkxxbWl6K5Ui9w4FGV2IptH2DKfdTQFGJ8ghwsPVvb+2TG9VdLoGTrsbMsWfuyR1W5r3FPTklNY/tK2TU1ypFLl3KMggF5R5L42lgz7xKYfNhQ8f+bWnm9HrMcZQ3kZPQU9OaW2uI1Nc+3TSKmOAxwqrZ4tyqbulVgYFGeSCIlNIKMggpBfwpqegp3sHOjLFtasyvhhjsNvtTf72uWVXAgV7zv29JB4wj+yWolwUZBBC/pQ6myzssLla/N0bf7akUc+eAs8hFGZ3oeSlsye/nh4+6Q4tVQRdtmwZbrvtNt++X88AQ9BNRbm8DjK2bNmCl19+GXv37kVRURG+++47XHXVVT5oGiGE+EZXJQt3dtjkz5Y0KvQUtDWE0puGT3ylpYqgBQUFnar62Sk9UJTL6/ku9fX1SE9Px5tvvumL9pA/EcbY2amTXfAj6Irn6pbuS9KjejpZWEga/bPxtiLohWzhwoWdfmynD1FydbcX5vK6J2PatGmYNm2aL9pC/kR8Ne20KxLy/mxXmX923ZksTEmj5/zZK4LKZLJOP/bgodv4715fFHnevxsuqHyek2Gz2WCz2fjfFkvnV8UjF46evpJsS9HpGlhrHT458fzZxuL7gs4kC3dF8bfO5nMAF8Z+1NcqgnqezN12V5O8EWF5d8+ETrvd7tVS7t6orT3Mf/fq+Rk7mwQqWHYVcNvarmtYC3weZCxevBhPP/20r1+m1/NmfRNPnV3rRNAX1jzx5kqSMYYVrx1A6RnfBqu+utqkXpK+r6fzOYDu248YY3B6XCQ2qRLbaIPD7QQASBWK824LY+wPdTRaSgBtbyl5XySNMsZQ/v4R/nfxczt53giAPyRzAsCSJUs6tZQ7YwwuVwP/2+VqgFjcRfVsHNamSaAFu88mf7awja1Oa5O/O8vnQcaiRYvwwAMP8L8tFgvMZrOvX7ZXOZ/1TTx1pvJnX1jzxJsrSYfN5fMAw5eogFPf1xt64bpjP2KMYfmTj6Dw1HF+m0MkBaJvBwAsnX8DZOxskBGWlILrn37xvF6refVNzxO5Z49Be0vJe578uwpzuOHIq21ym5A34oTrDwGGwNul3Blj2LtvNmpq9vHbtv46AgbDEKQP+KDzb8ALjDH8ddVfcaDsAL9t/rr5+GTaJ516Pp8HGQqFAgqFwtcv06t11/omLbHu2wdXZWWXlzvvDT0kfanwFo3FX5i6ah/s6PCL0+7Cx49vB9Cx4ZbzGVZx2mxNAgwAkDEn7s1e+of7Fp48BqfNBom4c3kGrSWENq+f0ZHEUXuO5WwviI+OTyGPDEPxS7tb/D9heffOLuXudlubBBiCmpq92H/gRq+f7w860CPR6GpsEmAAwKGyQ016NrxBdTK6WfP1TRhjyJ13CxoPHfLZa/pi7ZPe0ENChbdIT+uKfbCzwy8dCVq7aljlznc/gUyh/MPtDlsjls5v+eTn2cXuTXd76OMjAKDdBNDmiaNumxPFz+8CAJS/fwQBt6V2+DW9IZK3PimzK5d3Hzf27Pvf+uvZ7eGZh9Fpn13n1d1XzVyFad+e30QPr4OMuro6ZGZm8r+zs7Nx4MABmEwmREZGnldj/gyar2/ibmjwaYDhK7QqLCFdw5fDL101rCJTKCFT/jHIaM4zmKj43zH+e/n7RxB0V3qHXqujVT/bqtLpyKttdQqskNPRXfkcnSWR+ODYWvTHXpK2KCXnPvPO5mV4HWTs2bMHl1xyCf9byLe46aab8L///a9TjbjQdTSi98Uqrl2tL6wK2xuXfe+KKpG+ciHMVPCF1vajjnyWnd2mXTX80l3Dc01mXLjdqPzwXHKks6DuXHvaOOl3p9ZyOprnc9D34ax7NtzDf5+/bj7eGvOW18/hdZAxfvx4KlaEc7NFWpr94ZmvIAyHCHJvuRXRyz9vcSemVVzPX19Y9r235WbQjJezPIMKxhh+eP0ASrLbHv9v7bMMjtFjxsKBkCkkXm3XvjQEyBjDV889zv/+9vmnMc41vQdb1L72cjo6sobKn+n8d7TiKP+9s3kZlJPRCa3NFhGu8D3zFZjV2mQ4pPHgwV49zNDeVFtvp9R2d4Job8j872toxkvXB6cl2Ra8d9+WCzqAc9psKM48yf8uOX0KiO659niryXoqXhQBq/jo3DAQYwy48D7aLtXrg4y2TnodPeF19YmuvdkifTVfwdupth0ZNunJBNG+NPukJ9CMl3O8CU6b71dtbUcK4LqGL/IoPHM6vBnIceSfGwa6IIJHxny6EmuvDjK8Oem1dcLz5YnOM4+iL+QrtMUXU217MuDqS13PpPdoKTj1DCTa2q+Ex1IA13VaW1TNl3Ux/lSWXQXctMJnT9+7g4wuOun58kTX2TwKxhjcDQ1wVVXx25yVlRBbrX9I/uyJmhTnm4Ta1wMu8uclBBHtJX62lNwpU0gglYubJIQ21NqhhrzVx5yPzian9qVk347kUfiyLsYFr2A30MkaGB3Rq4MMT5056fXWEx1jDLkt9NCcnnRpi/fviSGH3pqE2tm5971ZT82G6S0zXrr7hCes/itw2FyQNqt90FaOhtBDIeRbtPe4T34vnuX5GJFIxD/31j6H9rZLR/NIWupR6au5IkIeBWMM5e8d5kMXvqyLQc5PnwkyeutJrzNYY6NXPTR9Ncejqwnrlgh+eP0ArnlkSJccsHtKb5kN05Nd+915wmtpe3/4yK8IjtE3uV9HcjRaWq69vccJj5HKxS1+7p6fQ3vb5XySnPtqroiQR+G2u5rkRrQ0RbYvXZD09vadjz4TZFzI4tatbdJLcyHkePjiC+60u5usW1KSbemyA3ZPodkw3XvCa217tzVV1ZtET899fe5zo3gJcM/f22qHJ2+2S0eTnHsyV8RzYTOg9QXQhPuer44UA2stobQ7inJ99tln/Pdly5bhtttua+PevuXLgOyCCTJamoXS1uyT3rD2hkBqMl0wvTSAd7VBukJXH7B7yoU6G6a14aD21uHwde/TvJfOBvDtnXTbSyD2PCj//Na56epSj1oL0jbqLsx7aSykcjHfRi1tl/a2RV9Ici5//0iTRcaar2QqaL7iaWdPeu0VA2srobQ7inIVFhby3wsKCuBwOCDpio/QY3vNHrAEPx24p81ZtgzA7Rvv5X/f6/F7V7gggoyOzEJp3iPQG9beuFD1ZG0Qb646e5u+cKLwVm/OG+iqbe3ZvtKc2jbu2TKpXIwf/32wQ/kfffl41XwVU+Bc8StPzVc87eh79jYYaSuhtCNFuXotj+2115CGBrESGndjq3e3ikQ47FF060j5kVbv2xkXRpDRiVkof9Y8h95Yd6QrXYgn6r6sL+YNMMZ6XQG589kWnj1JvSFnqaMLoHnLc3ikNU3KoHsMkYQ+PgKQieGud6DkpT38/3t6LZMLIVfjgggyPLU3C6Uv5zmcr75Qd4RcuPpC3gDgmwJLzce8W3uNru6J68gsGaB7e0q87R3oaL6A5/BIa8/jOQxT+nswAQCQiVHxwdEmPRutDed0F8YY9h+Y2yOv3ZrOBD0XXJBxIcxC6ei6KF4/bxfWHXFVVjYJ5jrSro5cUQG9dyaIoCunnPpqGmlv3IZ/5l6mlR65Gj+8fgAzFg5s8X5dvY062pPUvKfk7DTfc13sDlsjpApFj+xTnV3NtbnmwzDN/6+loZOWhnO6i9tthcVysEdeuzULNy30+jEXRJDRpAvMav3DCc9ziKA3JIO2FQ16sy7K+Wivx0dI3mxtGXpvc1wYY/iuA1dUQO8ef/bllNOuvHrvzdvQU0sBW08XkmreJqGOhueih5737UhbyjxyNYRZUR1pQ0vbwpv333y2i1Ira/JYe6MT//v7tib3ZYxh+ZOPoPDUcX6/pfNvRFhSCq5/+sVu36d8sZpryCPDUPzS7hb/z1fDOReCzuRr9Pkgo/lMhowxY5suUNbGEEFPJYPm3XFnq//XXeuitNfj425oaDXA6Ey7vBmb780zQfrKlNOi0zWw1jq6ZBv66qTekYCtJxJCm6+++uEjvzYpvNW8VktrvRJtcbvPnSibX3S0tl3aKgLWkuZ1ZT5+fPsfioF9/+rhJu/lmkeGwGmzNQkwBIUnj8Fps0GmVHboPbbXNs/fuz0YlrX+ekKxL4GQm9FRjDHY7Xb+t91uh0wm61BP74Wo7wcZzWYyAE1PeN4MEQjDABKTyac7ve1Ix6LB3rIuSlu9Hp1pV2tj874Yi/flF7erppwKJwPPGiBdoau2pbBseVvfidYCEc/t37xHoLMBW2sBVFcFQy3VzPAsvNVSrZaWtLXvffrkDv6757RXoGMFvRy29stoN68rIzxWCOBbqzvj6c53PwFwtiejq7jdblT899xshp6o1um5kmpzzXM3ip/bCZlZ16HnZYzhgw8+QF5eHr9tyZIlMJvNuOWWW9p45NlaGfPm/aVDr9OX9LogoyNDG60Na8StW9ukNDdjrMnj4tathcTPj0fxLQ0HNO8J6Yr301m9Jb+krXZ0NCnL8/+ajzu31mXekZNGW1dBza/kujrg6Krxc4fN1eUBRlcSli1vi2cgInxuzbe/Z49A889MCNg6GnB1Rw9HR+totLZfrfxP6+Ppnvu757TX5t+Fm18cA7lS+nuvw34+7PLD6wdwxd/O5Sa09325/snhWP7Mrjbb2xKZ4vx7LZorf+/IeQ2BdEXPh2e10D88fwu5G63lcvzheR2OJgGGIC8vDw6Ho83HCrUyLjS9Ksjo6NBGa0GA59V2S+uDnJ50KX8sWugBEXTl9NbePiZ+PlorutWStgKB1rqGhROXTCFp9fFtbd/mV2od+SzaS+rsaKJmZ6+qu7ogV4sBnN3VZD2NruAZiAgn+/aupD0JAdv5BFzNezjOt2ejo59D854IQVlu27MdWrLitf0oPXPuhLbq7cNnhzDs7j/kdfzQwQAOAA8wgHPDIj2lvVkg7elsz4fnEFVHBT88FCUv72n/ji146KGHAJztyfgz611BRgeHNjoSBLS2PojwWE/xv26FSCSC22rlPSEtJZCSploquuVuaPBqm7XVNSycuNoag24vSc8b3iZ1tnWF2/yA31bw0tFZJd6+r84mqXZkeKStoa2W1vRoXla7rTZ7PqZ5omJ7PR2ebepIkNreVX1Hcgc6U4CrNZ4BBtD2cEzz1xWGUeTKtg/rJdmWDg23CLpjDRBvnrezyZ+lnQgWKj8/4fVjBHK5vNOPvZD0qiDDU0t5AK6GBmSOHQfgXBDQ0ecCWq/9kH/X3T4fNvmzyL3lVkR+8N8O39/z4HLzi2MgEon+cPJq6aQlaC9JzxtdmdQpXFWrdDIA6PDJ3pvApT2dfT8l2RaIRKIOX8kLvS/NZyp4trOtstqC9hIVAe+GlpoHqc23W/PXa689nU3y7IyOBmUAEGDWofz37vwVr+7HNX8fArH4j4mKnvfr6HthjOGr5x7nf3/1/BP4y7Mvd/kxsVuOsQ7vA6S2hlVIx/TaIKN5HgBjDPk3z+N/C0GA+b13O/Rcf5jm6pEh7e2wSUuRffP8D2+CoAtJ48GDYI2tl7D11Pwgvurtw00OfB050LaXpNfa67b0/549CnOfG9XqibF5j0JrV9dCwDP93vQuCV7OZ9ZNR4ZhOpt4K1NIIJWL/zBTwfOzbO0743lba8MrrV2dd7RwVWvbraXXa+v/hR6A7tCRoExQ7pEvUJpTi29e3Itr/v7H4RDP+3U0YdVha0Rx5kn+d3HGiS6bYdKbdLa3hjGGNhcGIb03yGiu1VkkHTihtTTNVZn+x4IuQu9JWzMmWspDiPr8M+TecGOT4RlvgqCO8NzxnZWV/IPry0M67WW3e3OgnffSWDDGWr2SFm7r6BBCW8FN8274tq6uhZOkZzu9DRK6YtZNS0mq3g7htDVc095n6VmMasWr+zHzkcFt9hI0v+q+5pEhf3jtthJvO5q06a3W8i+62vlM8SzNqcW3L+/rVK9L856Lb1961uvn6Is8C351pDy5oPz9IzDeluyLJnUIA9Dg8vgOM9Zk7ZLeoNcEGWd7As4FDK6GBrit1hankzafRdLuczc2/iFAaTz4x8zvjszmaDEPoaqq9fyPDl7Vt/mazQIbz/euGpiOyM8+a7F7tKe0dCXQ0lTGriSVi5uctFa8uh8z7hvY5D7Ciex8exXayhURVtT0nAngeWLqyIwUb07+vso/6YrZG56fuWfSYmlOLb59aV+TnILmQUnzq24hh6Cjxal8VWOlK/Mv2rLyrXPHp5b25fZ0tOBXc067rUnPRenpU169bnfp6twQz2RUbxJT28sP8WynUC+jqzAAT+N5ZOzI4rfNPpiFL9Nju+w1ukLvCDIYQ8lfb4XtwLkvlpB7wWeDeGitZkNHurxi165B1qWTz7fFrWov/6MzWurFEVgPHETOnL906VLqrQ39dPT5mxcbYwB+fPtccR/PYYSWXrszml9Jl+bUNsm+B/544D3ftTRaGpYRnq/5SbWjvD35B8foMfPhwV4HmZ3J1/AcuujIlXZbV/3enqyb594AbRenah6o9bVCR2U55050Le3LXaGlz6entlPz4lftKf/waLv36WmMMSxbtoz/vWTJEoSHh3fZ89ugQIaoX5Pb9loa0ODuXft6rwgyFA40CTA8Wffta3PGgufOme9xcsttpapm4f0PnEdL29c8/8Mbnc3raDx4kK8l0lIwINQe6chaKC1NI/Y2CbZ5sTG3WI7S3Pomt7WWN+F54HPam161ttX70dI2b+9E1pk6F77qhhd4e/Ivybbg25f3tTic0DwQ8DzxtpR/0pFckx9eP4CZD7c91CHwNpBo63vTUu6NoKV9qflU0M5M2+xNgUlnelDaa39Lz+nt7KWu4jlE0WThsla4CuvbvU93aW07OBwOFBQUNLmt+d9dZefIZIzY8ccqrb1BrwgyPLXUE9DWjAXPq+ZGj5Ob3eN3z52gsYPVNjur+dBGR7+IbZ3cO5LX0draJq3VHmn1/q1MI+6q2iHtJXN6Hvg87/fhI78iKKr1qnvdNVbekaCkMwdfIQBoLfnUMwBo3rMiDCd4Jkc2T6pd8dp+iMUiFGf98WQtbOfmBbVaSowsybbAWuv4Q/6FvdHp9XturiOfoWfvk+dsFofNBYlHqeiWpoI2H2pq73P66Y0DHWl2r7XyTd8trtU8d+N8nW/tjJ7UVvVQwcKFC/H666/7rA1qSe8ZLm+u1wUZLQ2FNJ+x4Hlw6GiJbm/8YSaKF0MFzfM/Ovy4Nk7uzRdya0vzYOB81kLxxdCPJ29Pxm1dzXX0Ss9uO3cybKi1Q42zc9nPp3DT+STpCY9paYjEM8hqLx+ieXLkH4aPzrS/fZoX1PIczvJMxGwpGPAsk91ZHfkMhd6nsxUwz81m+fCRXxEUo//D/ZtM73yt6fegvaCmPL/3XC13Rlme9yfujnwnGWNw2prmbnSVthYu660c+XVAO5NtujIXo6/pdUFGazyrteW3scBYS9pakMyT0KXc1oJr3SFh269gjPG8lLba35EZMc3vyxiDq6qq3cJjIqWySXDXFcvNe544V3bgytWbegEd8ekT506GnlUvmxegaivoaBKEut344fVzV4ze1B/wHLpob4iked2N5lrqzWiNUOTKaXd3uKBW82mSzbWXZNhVhGGzlnpZSlsYUmnS7maBVnclcfYlK//T/nfyq+efwLWP+WbWiaiLE8JJz+sdQUYHrgRPT57Cf/d2yKOjvR3CsExbC651B5FSiTyPQKet9nuzvomQs9G83LpnIOV5Am2+tkvzIZbzVdaBg7zEi9UPz0fz9Tk8p6m2GVS8dqDNWRIt6cg02uAYPa74WzpWvHaAb6e2EmaBpr0ZbV2RCkWuPJ9HGIbwxSJ1XUkoN++5bgfpOh0JvIozTsBpt3VDa/58elMeUFfp+bCRMTz++bmDcu7NN7dcY96LIYPOaj4sE7dubYce52po4L93djzec0jEVVXV4WXWGWNw/z7dV+C2WnmvjOftQgJoq8MyDQ1NenHaK1LWHbor16I5Iej49uW9TbrZV7yy/w+zWJprbx/oSHKnEKw0D8TaKjQm9Ga0V8mypecRhiGaL1zXG5VkW7Di1Y6trEz6lt66z7WFoevKrn/22WedbMS5121SN6MX6PGeDIUDSCo693fj4SPI9ajs2ZNamyrbnOeU2I4OzXhq3mPgTQ2Q1laSVQ4aBBHQJKBonkDbPOeipXoinmJ+/AHZV8w4e18vcg/O52vn6y7t9maLNE+U7Mg4tzcJd56JjGfzDFqur3HjsyPxye9DPW0dyIThmtaKg3nmKDQP5hlj3VbR8nx1ZvEx0nV8FQx0JImyN2FgWCU/d4xtLUjoaPBQWFiImE6UuZh76Az/vbfNMunxIKMlvkjm7CjPA2/zXoCOaN72jjyuo70W3jy2sYXeisaDB5u8p44GUQIhwAA6vkYJA3Ag/V6vXqc7NZ8t0tI6HN5qLxBpUpjM7uJluZv3XHgGWKvfP1cXoK3enfaGazxzFFYtPZc46Xa78e3LB5r0sPhydgLpnTp6nPNVJdC+tlaIE26Uic8F9EVFRS3er7Cw0KftOFDX0P6dekjPD5f0Mp65H549Cq0O4/wudu2aFm/PW7Cgw6+dsO1X3rvgrbh1a5G4dw/it275w/8pUlLOtad5oaxO1uzv6BolbrEcFkPvqkDnSRhW8iSRifCzxwm4K7nd7ibDL588vh3vLtyMb17a2+Y0UG+Ke3X0c/R8npaSTzszO4H0bR3tneytlUAvJJ3pLdo5sudKnLeGgozmWsk1aDx8BDnXXddqoNFakS/b0Y53/4lVqiYLt3nj9KRLkXf7/Bbr1tuOnWuDrVn9EM8cjI4M9XgGU31x/LS5Fa/tb3LS//CRX/Hty/s6vNKnt3547UCL00lLsi2d7jlprjN5LJ5TUAMjtV3SDkL+zM73+Hjw0O1eP6Yz9TJ8ncHRK4dLequ28kW6oshX85O+t7xdK6V5DkZHhqk8g6nO5J/0Nq2d8H32et0wbbIzr+E5xEL5DoScv04ncf6utrYTvamdCGxsPi7NQD0ZXvJlvoi7jTVK2uI5HOL1MsVe8gymejJ3xhfmPjeqx147wNx6NVNCSN/TWn6GL3kmgPYWFGT0Ip3tGfAcDvGmSNaF0BPRlbqrJkdLPBMyCSGkM3pjAigFGb1IV/QMeNM7caH1RJwvz+W1CSGEnD8KMi4wBQvv6+km9Fmey2sTQgg5fxRkXGA8h04IIYSQnkRBBiGEEEJ8goIMQgghhPgEBRmEEEII8QkKMgghhBDiExRkEEIIIcQnKMgghBBCiE9QkEEIIYQQn+hUkPHWW28hJiYGSqUSQ4YMwdatW7u6XYQQQgjp47wOMr744gvcd999eOyxx7B//36MGzcO06ZNQ25uri/aRwghhJA+yusg45VXXsGtt96K2267DcnJyXjttddgNpuxdOlSX7SPEEIIIX2U1Js72+127N27F48++miT2ydPnozffvutxcfYbDbYbDb+d01NDQDAbTu7WpzL6kKdy+VVo0nf4WIuWO31Pd0MQkgHMOaA3eHo1GMlIqDW9uf6rjvggk1ka/+OHSQSOVBf7+7QfW1wwS1qf70lS6MbrjYWzqwVMbisHTsHC/fzZiFOr4KM8vJyuFwuBAcHN7k9ODgYxcXFLT5m8eLFePrpp/9we8HSmwEAeQCGe9MI0vecmtHTLSCEdINFWNnTTfiTGdfuPcI69Dw1Xr1qbW0tDAZDh+7rVZAhEIlETf5mjP3hNsGiRYvwwAMP8L/dbjcqKyvh7+/f6mMIIYQQ0rswxlBbW4uwsI6FLoCXQUZAQAAkEskfei1KS0v/0LshUCgUUCgUTW4zGo3evCwhhBBCeoGO9mAIvEr8lMvlGDJkCNauXdvk9rVr12L06NFevTAhhBBCLmxeD5c88MADmDt3LoYOHYpRo0bh3XffRW5uLu644w5ftI8QQgghfZTXQcZ1112HiooKPPPMMygqKkJqaip+/vlnREVF+aJ9hBBCCOmjRMybuSiEEEIIIR1Ea5cQQgghxCcoyCCEEEKIT1CQQQghhBCfoCCDEEIIIT7RK4MMt7vt2u0//vgjlixZgp9++qnd52poaMDOnTt5rfXDhw93SRt7QmNjIz799FO8+OKL+PTTT2G1Wnu0PW63GxaLBS6XC9u3b0djY6PXz9FXPh9HB9dzOHHiRLv3af65LVu27A8/Xe2ZZ57hP08//TQeeeQR/n+FhYUAgJKSEjz//PO488478fzzz7e6VIC3SkpK/vBaXeX777/HZZddhsrKSrz00kvYs2dPlz6/p+zsbK/2z/r6s+t4HDp0iH/mzZ+jrq79tSe8UVVV1aXP56moqMirNSua68x33fNcsG3btk6/tqfTp0/z34uLi/H444/zz2rTpk1d8hp9UVdt3+Z6bHZJQ0MDDh8+jOHDh0MkEuHgwYNwOBxISUnB6NGjMXPmTHz55Ze4/fbbccMNN+CJJ55AVlYWRowYgaCgIBw+fBh79+5FQUEBPvroI+zevRsPP/ww5HI5Fi9ejEmTJkGpVOL6669HcnIyNm/ejAULFqC0tBRmsxmPP/44Tp48if/7v/+DWq1GfX09nn/+eRw9ehSnTp3CpEmTUFFRgY8//hgWiwU6nQ6RkZFQq9Ww2+3o378/TCYT1q9fj+uvvx5arRbBwcF49NFHkZWVhSeffBKffvoprrzyShgMBqxZswZlZWUYPnw4rrvuOqxZswbr169HcHAwUlNTcebMGWzYsAEOhwMrV65EYWEhPvzwQ+zevRuXX345rrvuOsyePRu33XYbMjIykJ6ejq+//hqPPPII/Pz84Ofnh08++QT19fWYM2cO8vLysGLFCjz11FM4fvw4VqxYgXnz5uFf//oXcnJykJaWhquvvhqnT5/GgQMH8OOPPyIiIgLl5eV48cUXAZw9OYSHh2P48OH48ccfERMTg7S0NADAe++9h/feew8xMTHYv38/LrnkElitVixbtgwbN27E+vXr8eSTT8LlcuGdd97BwoULkZubi2PHjmHQoEF46aWXcM011+Df//43Ro0ahfXr1+Oaa67Btm3b8N5772HTpk2oq6vD+PHj8f3330MkEsFgMGD69OlgjOHpp5/GzJkzsWTJEgQFBeHRRx9FQEAAvvrqK5jNZuTl5WHfvn0oKSnBG2+8gfXr1yMnJwdarRZ2ux1XXHEFnnjiCcTHx2PevHn4xz/+gfvvvx/l5eVITU3FoEGDMGjQIDDGcOmll+Ktt97C4cOHsWnTJowfP57vx6dOnQJw9sC1bt06fPnll4iLi4PD4UBQUBBuvvlm2O12TJ06Ff/85z/x/PPP46677sKbb76Jffv2YdCgQUhNTcWAAQNw/fXXQ61W49ixY4iIiEBkZCRGjBjR5veosbERX3/9NW688UZ+2/r16/HDDz/grrvuQlJSEhhjmDBhAoKDg3HLLbfgmWeeQVxcHFQqFcaMGYN///vfeOyxx7BkyRK89dZb8PPzQ21tLV588UV89NFHGDlyJBwOBzQaDfLy8uDn5wfgbHE+AJDJZEhNTUV1dTXuvPNOfP7556irq0NQUBBycnJgNBpx4MABXHvttcjIyMDtt98OlUqFoKAgfPzxx7jjjjuwf/9+LFu2DL/99huuvPJKLF68GMDZoO3UqVOQyWSwWCw4dOgQ/Pz8sG7dOmRmZqKwsBDjx49HTk4OYmNjoVarcd9992HQoEFQKpV8m5SVlWH79u2oqanB3LlzUVVVxd+H1WpFRkYG0tLS8Ntvv+Gf//wnfvzxRxQWFqKiogJ33303Lr30UixbtgwSiQSTJk3Cm2++icbGRtTW1iIjIwOffvopZs6ciccffxyffvop7rzzTuTm5qKxsRFKpRJutxsulwtSqRSJiYmoqqqCUqnEiRMnIJFIcO+996KiogIvvPACvv/+exw7dgz3338/VCoVNm3ahIsuugh79uzBt99+i7vvvhsvvfQSEhISkJSUhKeeegoTJkzAzz//jIKCAgQFBWHfvn1QKBR48803ERwcjCuuuAI2mw2//vor0tLScPfdd0Oj0WD27Nmw2WxIS0vDF198gVmzZsFgMODxxx+H3W7Htm3bkJiYCJVKBZVKBY1GgwULFqC8vBwJCQlYtGgRKioqMHv2bAQHB2P69OnIy8vDyZMnsXfvXpSWlkKn02H37t3YsWMHdDodzGYz/P39cezYMQQGBiIhIQE33XQTtmzZgttuuw3fffcdJk6ciK1bt2LDhg245ZZb8M033yA3Nxd33nknJk2ahO+//x7XXnstjEYjsrKysHDhQgwcOBDJycmYOXMmtm3bhh9++AGBgYFobGxEWloann/+ecTFxeHkyZNYv349nn/+eezfvx8qlQoBAQHQarX47rvvkJCQgICAADDGYDQaMWTIENx66614++23cf/99/P9XrBq1Sps3LgRw4YNw/333w+FQoHbbrsNkZGR+OGHHzB69Gjs378fDocDqampqKqqwtixY/HEE0/Abrfjt99+w6uvvoqSkhJUVlZi8+bNkMvlGDp0KMaNG4e//vWvyMrKQkNDA1JSUpCfn4+PP/4YcrkclZWV2LVrF6677jocPXoUEyZMwNSpU2GxWBAbG4tly5YhNjYWFRUVGDFiBN555x0kJCTwfffdd99Feno6Tp8+DblcjjVr1kCtVuObb75BQUEBkpKScPHFF+Onn37ClClTsHbtWkyaNAmBgYEdPtd3W5Cxe/du/iX59ddfAQAajYZ/+err68EYg0wmg9vthlKphNPpRFxcHKRSKQoLC2G1WjFmzBjs2rULIpEIFRUVMJlMEIvFKC8vh0KhQGxsLDIzM6HRaOByudDY2IiEhATk5OSgoaEBUqkUOp0OGo0GNpsNDocDarUaDQ0NqKurg9vt5muqSCQSuN1uvP3227j77rthMBhgMBhQWloKhUKB6upqGI1GWCwW2Gw2SCQSAMCECROwdu1aBAYGwmKx8KtgqVQKh8MBkUgEiUQCp9MJxhjcbjfEYjEkEgkMBgOcTieAs3XitVotysvL+Uq2QUFBqK2tRWBgIMrKyiCRSJCUlISMjAyoVCo4HA44HA40NDSAMQaJRAKtVguXy4W6ujqkpKTgzJkz0Ol0KC8vh1gshlwuh1gsRm1tLdLT05GXlweLxQIAGDNmDM6cOQOVSgWJRIKSkhJeWl74/Gw2G5RKJRwOBxQKBW+/Wq2Gy+WCn58f/P39kZ+fjxEjRuC3336D3W4HcDbY7N+/P44dO4aYmBgUFBTg4osv5gfJoqIipKSkoF+/fli5ciXi4uJw6NAh/jmJRCKEhISgsrKyyfYUdmvhwFhdXQ3gbI+En58fdDodGGMQi8UoKytDYGAgysvLYbfbYTQaUVFRAa1Wi4aGBshkMn6ysNvtCAkJQVVVFVJSUnD06FFoNBrU19ejsbEREokERqMRUqkU1dXVSExMhNFoRH5+Purr6zFs2DBs2bIF/fr1Q3Z2NiwWC/R6PUQiEYYOHYrffvsNLpcLMpmMf55SqRTx8fFobGzEmTNnMGnSJFgsFuzYsQN1dXXw8/ODSCSCUqlEYWEhRCIRNBoNGGO4//77sWPHDmzevBkOhwMSiQQNDQ1Qq9XQaDQoLy8HYwwREREoLCzEmDFj+Pfvt99+4yd3rVaLuro6iMViMMYglUpht9ubrD8kEonAGENAQAACAgJgMBiwf/9+aDQa1NbWQiqVQiKRYMyYMTh58iTEYjEUCgWOHz8OqVTK10BSqVS444478MMPP0AmkyEvLw+NjY2w2WyQSqVwOp2Qy+W48sorsWLFCr6/Cc+vUqnAGMO4cWcXj9q5cyesViucTicaGxv5tvrrX/8KlUqF1atXIycnB06nk++XwomksbGRHyuE9+10OpGamsprBNntdigUCtTX18Nut0Mul8PlckGn06GxsRGhoaHIzs6GWCxGv379cObMGf4ZaLVaOBwOREZG4vjx4xg9ejSOHz8O4GyvhNFohE6ng0KhwKlTp3gALZPJIBKJ4O/vj6qqKlitVsTFxSEzMxPR0dHIycmBXq9HQ0MDdDodqqur4XQ6IZVKIZVK+Xusq6tDSEgIqqurYTAY0L9/f/z666+w2WwQiURwu90IDQ1FSUkJRowYgSNHjsDpdEKn00GtViMvLw8hISEoLi6GQqEAYwwXX3wx1q5di379+uH06dOw2+38NaOjo3Hq1ClIJBKIxWK43W6EhYWhtLQUYWFhyM7OhkKhgMPhgMvlglwuh7+/P0pKSsAYg06n498/q9UKqVSKuro6yOVyaLVaVFVVwWAwoL6+HiaTCYWFhRg5ciQyMzNhsViQlJSEkpIS/hkeP34caWlp2LdvH6qqqiCTyRAYGIjS0lJ+HImNjUVtbS1qamogl8shEolQV1cHhUKB5ORkHDp0CADgdDohk8n4d0k4LigUCr7/M8YQExODwsJC/h6FY6bBYEBFRQXfx9RqNd8PFyxYgDfeeAMikQiNjY1wuVxQqVSw2Wz8cQaDAS6Xix8z7HY7tFotLBYLZDIZ7HY7YmNjUVlZCbvdjrq6OiQlJeH06dOQSCT8XGi32xEREQGLxQLGGKxWK98Hnn/+eezatQuffPJJx0/+rBvMmTOHhYWFsalTpzK5XM4iIyOZQqFg/v7+TKFQMKVSyRQKBROJREwmkzGTycREIhETiUSsX79+TKPRMJlMxiQSCVMqlUypVLLExERmMBhYYGAg69+/P1Or1UwsFvMfk8nExGIxk0gkbNSoUSwhIYFFREQwsVjMpFIpk0gkLC0tjRkMBpacnMzkcjlTq9VMoVCw0NBQFh4ezgIDA5lKpWJyuZxJpVL+WKlUyuRyOROJREwsFjMATCaT8dcODAxkEomEhYSEsKCgICaRSNjIkSOZXq9nISEhzGQyscsuu4ylpqYykUjEYmJimFarZWKxmPn7+zO5XM5kMhl//xKJhInFYmY2m5lSqWQAmFwuZ0FBQXy7iMViplQqmZ+fH99OYrGYDRgwgMlkMqbVaplCoWB6vZ7JZDIWFBTEt49UKmVarZZJpVI2YMAAZjQamUgkYlqtloWEhDCNRsMA8PuLxWK+XSZNmsRMJhPTaDRMo9GwyMhIFhgYyLRaLdNqtUwulzOlUslEIhEDwIxGIwPApFIpA8AUCgVTKBRMJpMxPz8/ptFo+PaVy+VMLBazUaNGsZCQEAaASSQSfh+VSsWkUikbMWIEk0ql/DnMZjMTi8XMaDTybSKVSllUVBQTi8Vs6NChTCwW820ibC+9Xs9UKhWTSCTMYDAwvV7PxGIx8/PzYzqdjs2ZM4eJRCK+DYTPXiKRMJlMxgwGA7vkkktYUFAQ34ejo6P5/giAabVaBoBvP+E9q9VqJpPJGAAWFBTERCIRU6vV/H0qlUq+34rFYv7/CoWCaTQavs/4+fkxtVrNPzNhuyQkJDCRSMRSUlKYSCRiV1xxBdPpdCw5OZkBYGFhYSw0NJQ/ViQSMT8/P2YwGJhIJGLXXXcd0+l07Prrr2dyuZy99957TCaTscmTJzOFQsHMZjMLCAjg+7+wv6hUKqZSqZharWZarZZ/Z4T9QSKRMJFIxN+jTCbjP8J+LhKJWGBgIBOJRCw8PJx/Pmq1mj/eYDAwhULBALDBgwfzbSV854R9VyKRsHHjxvHPXbif8LkmJCQwuVzO9yHhOCT8LpFIWFBQEIuIiGDp6enMz8+PxcTEMKlUyo9T06ZNYwAYAKbX63l7ALBJkybxfU+j0fDvbUREBJNKpUyn0zG5XM4UCgVTq9X8NYXjj7ANhe+x8N3x3FbR0dH8OBUbG8v0ej1/bpPJxCQSCdPpdCwhIYFva4PBwP+WSCQsJSWFyeVyZjQa2fjx45lKpeL7ZUxMDN//FQoF+9vf/sYA8M9GeO9Ce2JjY5nRaGRisZhNmDCBBQYGMoPBwGQyGUtOTmZRUVH8OygSiVhQUBA/buh0OiaRSNhll13GNBoNi42N5fuNsC2E74jBYGARERFMJBKxgIAAptPpmFgsZpGRkXz7yeVy/rkI55uIiAh2+eWXM7FYzAwGA5swYQI/Dlx33XUsODiYH4/9/f35ZxYVFcVEIhELDg5mSUlJ/DucnJzMZDIZe+yxx5hYLGbTp09nCoWCbz/huUJDQ/lx32AwsPDwcKZWq1lMTAyLiopioaGh/L0Jrym8X6VSydLS0phSqeTnL8/zlVqt5u0R9o+bb76Z79fC8WjgwIH8nBcUFMRUKhVLTEzk52SlUslUKhXT6/VMqVSyp59+mt17771enf+7JSdDrVZjxowZWLVqFdLS0jBt2jSIRCKYzWZERETgxRdfhFarhcFgQGJiIgYMGACtVguFQoHCwkJotVrExsZCJpNBLpfDZrMhKysLNTU1qKmpQVZWFgwGA1QqFfz9/REbG4uEhATI5XJIJBIcPHgQWVlZ/AqmX79+UKvVvDszLy8PYrEY4eHhkEqlqKiogMvlwrRp0xAZGYmwsDDIZDKMHTsWU6dOhV6vR2JiIjQaDb+a7t+/P4KDg8EYQ2VlJdRqNWpra6FUKiGRSDB48GCEhIRAKpXyq9Ds7GxMmDCBR506nQ5vvfUWwsLCoFAoePt1Oh3kcjmqqqoQHh4Og8GAqKgoJCQkoH///nxFW6fTCaVSiWHDhiEwMBBqtZr3SIjFYmg0GgQEBMDlciExMRGxsbEYOXIkGGOw2+1gjCEvLw9WqxU6nQ4xMTGw2WyQyWS49dZb4efnB7VaDYVCwSPmo0eP8q7fxMREuN1u/l5CQ0Phdrv5VZdCoYBer0d8fDwCAwPh5+eH1NRU3m19+eWXY9SoUfD39+e9K0qlEmfOnEF9fT2MRiNOnDiBmJgY3uMlEolw9OhR6PV63ttSWVkJuVyOmpoayGQyDB8+HBKJBIWFhVCpVKioqICfnx+cTiemTp0KlUoFPz8/RERE4LLLLoNer0dsbCyCgoIgEol4b4bQIyX836OPPoqEhASMHTsW/v7+aGhowJYtW1BeXg6NRsN7zRQKBRISEjB8+HA+5HbfffehX79+MBqN0Gq1kEgk/CrJ7XZjyJAh/IpcoVAgJCQE/v7+CAsLw5gxYyASiWCz2XjvnVQqhVgshsPhQHBwMGQyGWQyGfR6PdRqNc6cOQOxWIycnBwAwK5du2A0GpGXlwedToeGhgb4+flh9uzZEIvFMJvNSE1Nhdvt5lesVqsVW7duhU6nwyOPPAKxWIxt27ZBLBajuroa1dXVuOGGG9DQ0MB7yMaNGweTyYSEhASMGjUKEyZMgEajgdlsxuDBgzF06FDMmTMHaWlpsNvt8PPzw8yZMzF27FhotVrMnz8fiYmJuOyyy2AwGBAbG4uYmBhMnDgR0dHREIvPHsLCw8NhNBqhVquRn5+PsLAwhISEwGaz4W9/+xsGDx7MqxJXV1dDLpfjvvvu472IGo0GSqUSBQUFcDgcuPXWW6FSqfD3v/8darUa/v7+AM4uDqXX61FZWYlTp06hpqYG1dXVCA0NhdPphFarxYgRI5CcnIz4+HhMnjwZTqcTERER6NevHx544AEolUqIxWIMHjwYN954IxobG+F2u6HX6/mVemBgIIKCgqBUKqFWq/m/wcHBCAkJ4Vfv119/PXQ6HT9GyWQyxMXFQafTISAgAA0NDQgNDYVWq0VqaiomT54MqVQKq9WKxsZGxMTEQC6Xw8/PDxaLBQqFAlKpFJmZmXA4HLBYLNi2bRvvpVMqlbjvvvsgEokgFovhcrl4j8IVV1wBnU6Hp59+GnK5HAaDAQqFAhqNBnV1dQgMDMT27dsRFBSEsLAw3vOm0WhgMpl4z0VAQABkMhlGjx7Nv1uFhYWIj4/nx5/bbrsNEydOhE6nQ1xcHC655BIYDAbU1dVhxIgRCAwM5D1MZrMZ0dHRSEpKQmBgIORyOeLi4hATE4OBAweisbERmZmZUCgUCA4OxtatW3nPVUlJCdRqNe+FSE5OhlKp5D0cIpEI5eXlyMjI4G0LCQnhPTb+/v7YvHkz/P39UVNTg+TkZAQGBkIsFqOoqIjv8zabDaWlpZDJZCgvL4dOp4PL5cItt9yCefPm4eabb8aMGTMwcOBAyOVy6PV65OXlwe12o6CgAEqlErW1tXC5XFAqlVCpVLDb7XA6nfw4uWvXLkilUqhUKlRXV0Ov1+PkyZOYPHkyampqYDQa+bYRzoUJCQkIDQ3FDTfcAAB48sknodFovDr/d8twSXZ2No4cOYIrrrgCt99+O/bu3YuKigpcffXVaGxshFqtRnFxMdLS0mA2m/Gf//wHa9euhVarBQDepVxeXo7s7GzExsbC398fR44cwUcffQSz2QyZTAapVAq1Wo2rr74aNpuNn7wWLFiAq6++GkajEcuWLcNbb70F4OxY7E8//YSLL76Y7yTHjx/H5s2b8fDDDyM+Ph4AcPDgQaSnp8PtdvMhgbKyMvj7+2Pp0qV4++23UVVVhQceeADXXXcdvvzyS2zcuBE6nQ4//fQTPwHExMTgoosuwtdff43hw4cjOzsbUqkUWq0WEyZMQFBQEGQyGRQKBTIyMrB161bExMTguuuuw6uvvoqcnBy89dZbGDhwIJYtW4bPPvsMN998MyorK7F7924EBATgnnvuQUhICEwmEw4dOoTQ0FAsX74cBw4cwOnTp2GxWDBy5EhMmjQJw4cPR0REBCoqKvDuu+9Cp9Pho48+wv3334+NGzfyk7bJZMITTzyBf/3rXwgICMAVV1wBmUyG7777Dvv378fVV1+N1NRULFy4EPPnz8fnn38Oq9WKxx57DI2NjbBarXysMyEhAUePHsWUKVMwd+5cTJkyBUuXLkVoaChmz56Nl156Ca+99hquvvpqzJ8/H9u2bUNNTQ1mzJgBxhgcDgcqKiqQm5uLAQMGwGq14vvvv8fDDz+M7777DsHBwZg9ezbq6+shkUgwb9486PV67Nq1C8888wwee+wxGAwG7N27F3a7HX/729+wfv16uFwuLFmyhA+95ObmYujQoYiIiMBvv/2GDRs2wN/fH+Hh4ZDL5SgqKsLixYuxatUqPProoygsLERJSQkef/xxJCYmwmQy4eTJk4iJiUFNTQ1uvPFGXHnllfj444+xYcMGPPzww6ioqMDSpUtRX18PrVaL+Ph4bNu2DSaTCXV1dZgyZQo++OADnu/jcrkQEBCAd999F19++SXef/995OXlQSKRwGaz8WGW77//Hvv374dMJkNISAjWr1+P6OhomM1mfPTRRzhx4gTPAdi7dy+ys7N5MFNRUYGrrroKBoMBZWVlaGxsRHZ2NtLS0rB3716enzR16lT4+flh9erVmDx5MrZv34577rkHEyZMwMaNG1FVVYXs7Gz88MMPGDZsGFatWoVBgwZBpVLhmmuuwbRp0/Dbb79hxIgR+Ne//gWj0chzXq644gq88MILOHXqFBITE5GRkYGEhAS8/fbbSE5Oxm+//YYHH3wQAHDRRRfhhRdewIgRI7B7924sWbIEU6ZMgd1uR1ZWFsRiMcaPH4+pU6fiiSeewKFDh6BSqRAeHo63334b33zzDVasWAG73Y7ly5cjLi4OQUFBqK+vR0NDAzQaDf7xj3/g9ddfR3V1NUpLS/Gvf/0L+/fvR0FBAebMmYMpU6Zg8+bN2L59OyQSCWJiYngSXUREBL755hsYDAY8+eSTuO6665CSkgK5XI7//Oc/ePbZZxETE4Pdu3ejvr4el112GQ4fPoyUlBQUFRVBLpejf//+sFqtWLduHRYvXoyKigokJCRAJpPhjTfewK5du/DQQw/h0KFDWLNmDYKDg/HMM8/g5ZdfRmZmJg4ePIjg4GDY7XbU1taCMYaEhAS43W588cUXuOeee3DDDTfgp59+wvTp03lbamtrsW3bNoSHh+Paa6/Fhg0bcOrUKezatQvvv/8+EhIS8Oyzz6K+vh79+/dHQEAANmzYgCeeeAKMMZw8eRK33norTCYTvvjiCzQ2NmL8+PGQy+UIDQ3F9ddfj+XLl6OsrAx6vR4ZGRn4z3/+g6VLl2LRokXYuHEjpkyZgnXr1iE1NRWDBw/G2LFj8c0336CoqAjV1dWwWq2IiYlBdXU1AgICMGnSJEyePBmZmZl45ZVXkJycjE8++QSJiYl4/fXXef5GQEAAxGIxgoKCcObMGXz11VeYPXs2tm/fjkmTJsFms0EsFkOn0+Htt9+G3W5HRUUFEhMT8Ze//AXHjh3D5Zdfjjlz5uBvf/sbHn30UbzyyisQiUS44447EBYWhocffhgBAQF477334HK5cPr0aQwfPhynT5/G5s2b8d133yEoKAhJSUm44oorcOTIERw7dgxxcXF8+Q5hSfVTp05hwYIFaGhoQHZ2NsxmM4qLi9GvXz+MHz8e06dPx88//8yHuS699FI8+OCDEIvFuOmmm1BXV4d33nkHMTExGDp0KGpqanD48GEYDAbExMRAKpWirKwMJ0+exLRp05CUlISJEydiyZIlmDt3LjZv3oxffvkFH3/8MUwmk1fn/27LyVi3bh2+//57OJ1OnDx5EhqNBtnZ2bDb7SgrK0NAQAAKCgoAnL3qttvtUCqVCA4O5gfhkJAQbNiwAW+88QaOHz+Or7/+GiEhIbwnQiwWo7GxESNGjMDBgwehVCpRVVUFt9vNx5zEYjEOHz6M2267DQcOHOC5EMnJyTh16hRqa2v5WPzs2bPx9ddfw+l04pJLLkFUVBTy8/MRHx+P/Px8HDt2DOnp6ZBKpTCbzcjKysLJkyd5Uturr76KcePGoV+/fjh48CDPtxg2bBgKCwuxYsUKDBgwgCeiyWQyXHTRRXj//fcBACdPnsSLL76It956C+Xl5Th9+jRCQ0OhVqtRWFgIu92O22+/HbW1tSgpKcHevXthNptx5MgRDBs2DNdeey3+/e9/Q6VSAQDy8/Nx2223YcuWLdBqtTh27BjCw8Nx5swZfhX04Ycf4sorr+Rj29HR0XjllVdQXl6ORYsWQS6XY9q0adiyZQssFgsWLFiA119/neeBCGOILpcLVVVVGDRoEG677TYsXLgQ4eHhvIcmMzMTs2fPxtq1azFq1CisWbMGgwYNglgs5ldswslWJpNBrVbj22+/hVwux/Hjx2Gz2RAUFMTHde12O5KSklBQUICqqirY7XaYzWYEBgaisLAQR48exQsvvIDXX38der0eVqsVer0e+fn5GDNmDHbu3Am5XA6VSoWwsDCcPHkSl19+OVasWMF7mkaOHIni4mJIpVJcffXVWLZsGYYMGYL8/Hx+Ja9QKCAWi1FSUgK5XI6xY8fi5MmTPO8oMDAQubm5mDVrFiIjI2E2m1FRUYHDhw/jmWeewX333YeCggI8/PDDyMzMRElJCWQyGXbt2oVbb70VV111FQ4ePAi3243a2lrs2rULoaGhuPjiizFkyBAUFBQgJycHH3zwAXbt2oXjx49DrVYDODcrq6amBkVFRfxkVVpailmzZuGdd97BggULYLPZsGXLFuTk5OCqq67CqlWr4HK5eC9RWFgYGhsbkZ6ejsbGRlgsFhw7dgxJSUmor6/HX/7yF7zzzjs8P0gY454wYQL279+P2NhY2Gw2ZGRkwO12w2q1IioqCg0NDaiqqkJ6ejqOHTuGxsZGREVFQa1Wo6qqCqGhoTwAZIzxnjp/f39YrVao1WqUlpbyMe8BAwZAKpXizJkzSEpKwq+//gqtVotx48ZhxIgRWL9+PTQaDU6cOIEzZ85AoVDAZDLx3AuFQoH58+fj73//O4KCglBTU4PQ0FCed3Ds2DEUFxcjJiYG27dvh0wmQ21tLQDA398fEREROHPmDCQSCRQKBe9tSU5OxkcffQTg7OwJp9MJk8kEq9WK/Px8zJ07F+PGjcN9992HhQsXwmKxYPfu3Th+/DgCAgJQX1+PO++8E2VlZTh+/Dj279+POXPm4Mcff8TEiROxa9cuuN1unqdms9nQ2NiI0aNHQ6lUIi8vD1KpFPn5+UhNTYW/vz927NiByspKGAwGXHrppfjtt99QVlYGnU7HZ8YYjUbceOONOHPmDH755RdYrVbExsbyiyWh11XII5swYQJ+/fVXmM1mKJVKbNu2jefwhIeHIzc3l+eLud1u/j2ePn06Nm7ciIaGBvzvf//DY489hsTERPznP//Bxx9/jMzMTBQVFWHLli2YMmUKjhw5ArvdDovFArfbjREjRmDnzp2QyWQ8V054fj8/P9TU1CAmJga33HIL1q5di4aGBuzfvx8ulwtBQUGoqqrivT0BAQFwOBz8vBAaGorw8HDMmjWL5xYqlUqsXLkSAQEBEIlECAwMxMGDBzFkyBCcOHECQ4cOxbp16xAQEIDs7GwAQGBgIBoaGmCxWBAXF4fIyEhYrVbs27cPQUFBKCoq4j3BBoMBmZmZfPLBgAEDsHfvXgQGBqK4uBhlZWWIiYlBbm4uDAYDGhoaUFtbi8bGRv65BAYGoqqqiu/fI0eO5DlPbrcb/fv3x6FDh9C/f38cOHAAwcHBKCkp4edi4bg4ZswYTJ48Gddff33HT/5dkXPRnr1797L4+Hg2a9YsZjKZ2MMPP8zH2oYMGcJ0Oh0LDw/n47vTp0/n43lBQUFMoVDw8TfhB7+P+wnjtXFxcUwmkzG5XM7Hj4S8hC+++ILp9Xrm5+fHx9GFccrg4GA+/i+MaQtjesL4ptAW4fWE8VVhfFzIxxDyBYS8EiG3QKFQsPT0dBYQEMCGDBnCxo4dyxYuXMgiIiKYTCZjgwYNYjqdjhkMBhYXF8eio6OZwWBgRqOR50oI7UpKSmLJycksISGBRUZGstDQUD6OKoztC2NycrmcmUwmPnYr5BckJCTwXAFhbFq4j/A+DQYDCwsLYwEBAU1yZ4Txb2GMUPh8hJyBwMBAlpyczIxGI0tISGA6nY4plUo+Ti+MFRoMBhYUFMRSUlJYZGQk0+l0PK9GKpXytgj/er62SqXiuStqtZrnWAhj0TNnzuT7gfB5DR48mA0ZMoRZrVZmNBpZaGgoz6EIDAxkGo2GzZw5k40fP56NGTOmSQ7BlClTmFgsZsOGDWMikYjndkydOpXpdDrm7+/PPv/8c2Y0GplcLmdJSUk8Z0DYB3U6HZNKpWzMmDFMp9OxkSNH8nHQ4cOHM71ez7RaLTMajSw8PJwFBwfz3IgZM2Ywk8nEx/ElEgkfW1coFMxoNDI/Pz8+xiuM4wv3mzp1Kn9+IZ/FYDDwfV4Yexe2fVhYGFOr1QwACwkJYXK5nEVHRzOtVsuCg4N5LlBwcDAfu/bME7jzzjuZSqViwcHBLDw8nPn5+TG5XM5uvPFGplar+ecnjEeLxWKWmJjIv0uxsbEsKiqKGY1GZjabWWxsLJszZw7PaRG2qbDvxsfHs9jYWHbttdfy9x4QEMBUKhWLiopicrmcqVQqJpPJmF6vZzNnzmTDhw9n/fr14+PdZrOZjRkzhk2fPp3JZDKWmJjIc16kUimLj49ner2eyeVy5u/vz+bNm8cuuugiZjKZ+Pi18BknJSXx44HnGLxarWZBQUE8T0bIRfE8pnju+2azmclkMjZ79myWkpLCxGIxi4qKYv7+/vzzjY6O5sdJIWfAbDazsLAwnisgfL5CfoxEImH+/v48r0A4/gjPL7R9/vz5TCQSsXnz5jGZTMbi4uKYVqtlYWFhTC6XM51Ox0QiEXv55ZeZRqNhYWFhLD4+nt100038OKPT6fjxCQBLSkpqclycNm0az0WLiYlhEomE+fn58Zwe4ZjtmRsj7Cc333wzUygUTKVSsYiICJ4TJhwHJ0+ezAwGA0tJSWEpKSlNcnmuvPJKptFo+PE1JCSEH2eEfBYhl0H4zgg5K9dddx276667WFpaGgsLC+PtEbah8F6FnDLhuYRjrLDfCvuGQqHgeW0qlYrFxsY2eYzwHQ0MDOTnFbPZzPedkSNH8n0eAM89DAoKYmq1mufXjB07lufexMfHM6lUyo8dwjYzmUxMrVazgIAAFh0dzSZMmMC0Wi2LiYlhr7zyCmOMsfnz53t1/u+WnIxrrrkGZrMZ//vf/1BVVYW9e/diypQpEIlEOHDgAOrr63lkarfb8csvv/CeCbvdjoCAALjdbhiNRiQlJeGWW27BrbfeCplMhuDgYAwePJhnMEskEjQ2NkIulyM2NhYTJ07E+PHj4XQ6UV1dzbuFQ0NDodFocNVVV/FcA6fTyccahSsSkUiE6Oho9OvXD9HR0VAoFLjqqqsQHByMsLAwBAQECMEaXC4X/10Y65XJZHC5XCgsLERlZSVOnDiBbdu2YdmyZaisrAQAZGVlwel08tkUwvi3xWKBXC6H0+nk8+ntdju/8qqvr+f5I2KxGMHBwYiMjIRSqURERARkMhlqamogkUhgt9shFovhdDp5drHQiyMSiSCVSvmMBGEMVZg1U1FRwfMqTCYThgwZArVaDaPRiHHjxvGpgsL4uJDJXVBQwLP6hfbcfPPNcDgcsFqtqKio4OOeISEhCAsLw6BBgyCRSBAVFQU/Pz+kp6dDqVTyLPPhw4cjJiYGEokEl1xyCR/LlEqluOqqq6DX6yGTyRAfH4/6+nqe43DixAnk5ORgxowZqKmp4d3+4eHhcLvdiIyMxPr163H48GEcOnQIDoeDP16YRipkyMfExIAxxmf/2O12/Otf/0JtbS3i4+NRWVmJcePGQaFQICgoCEFBQZgxYwbcbjcOHDjA84QqKipQVlaG3bt38/2ntrYW5eXlvLdFLpdj7dq1qKur47M5FAoFrFYrRCIRHy8Wst/dbjfvTRKG4kJDQ2G1WnmuBGOMz0oRpslefPHFSE5ORmpqKkaOHInhw4fDZDJBr9eDMYaUlBQoFAo0NDTwduh0OiQmJkKn0/F9UyaT4euvv+aZ8zabjY8Nr1y5EuHh4ejXrx/PkhfyUaqqqhAYGAidToeSkhJUV1fj6quvhsPhQHZ2NjZu3AiRSISUlBRcfPHFiI2NhUQigUwmw5kzZ1BaWooNGzZALBbzKYnCzBSlUonw8HA4nU6oVCoUFBRg//79vDdE+J6bTCY+7JSZmQnGGJ+xJJfL4XA4YLfbUVlZiS+++AInT57ks2mEWSlSqRQZGRn8sxkzZgxuv/12mM1mBAQEYOjQoQDO9nRIpVKMGDECYrGY59z069cPfn5+CAwMhMvlgsvlQlZWFk6fPg3GGEaPHo3IyEgEBwdDJBLxfUT4/o8cORLl5eUoLS1FeXk5iouL+eyo/v37Y+nSpfy4IMxsEK6Sg4ODMXbsWBgMBgQGBvKaL1u2bIHL5UJJSQnq6+ub5EMJPcNisRhWqxWnT5/Gb7/9xnPRQkJCMHDgQKSkpMBsNqO6uhrjx49HWFgY3G43oqOjAYAfk/z8/BAXF4dBgwYhKCiIzzjs378/UlJSEBISwoeVt27d2qQnZM6cORg6dCjsdjs/7jidTuTn5yMjIwOMMdTW1qKhoQFr1qwBAEyZMgXp6emYOXMmJkyYgAEDBiA+Ph4BAQFISkqCUqnkszlyc3PhdruxZ88erF69GvX19fw4KPS4CUMwwNmZgFqtFhEREbjllluazCoMDQ2FUqnks4fq6+uhVCqRkJAAtVoNmUyGQYMGISUlBf3794derwdwNp9I6KEXnq++vh5jxozB9OnTIZfLce2110IikfCeHblcDrfbjd27d6O2thY5OTnIycmBSCRCv379oNPpoNfrYTKZsGrVKojFYjQ0NEChUGDv3r2w2WxITExE//79sWbNGt4z3lHdMlxit9sxefJk5ObmoqCgADqdDiKRCHK5HEqlEo8//jjWrFmD1atXIzU1FRMmTEBBQQGGDRuGq6++Gm+++SZ27dqFuLg4lJeXY8aMGZg2bRpmzpwJqVSKgwcPon///ti+fTtMJhMCAgL4Sfurr77CSy+9hM2bN/MhgejoaISHh2PVqlUICAhAVFQUysrKoFQqodfrcfr0aXz//ff45ZdfMHv2bNxyyy144YUXEBgYiLvvvhsOhwMnTpyAUqlEfn4+7rvvPnz77beIi4vD6tWrERwczLtsH330UTz55JM8wcnPzw8mkwmZmZk80em+++5DaGgoQkND8c033/BkSuFDf+655/D999/DaDRi2LBhOHnyJObOnYsnn3ySTwG2WCz8ID9o0CAcP34cEydOhMPhwPDhw3HixAlERUXh1VdfRUxMDOrq6ngdiPLycgQHB2Po0KH45z//yV9j6tSpKC8vx7p16zB48GDs2LED8fHxmDZtGm6++WbMnj0beXl5MJlMPEh78sknsWbNGgQEBOCLL77gibBC17mwjaOjo7F7925cc8012Lx5MxITE7Fr1y4kJSXh6NGjMBqNsFqtSE1NxdGjR/lBPCAgAOXl5fzLCoBPCxROaiEhIUhLS8OJEydQVFSEuLg4ZGRk8JOkTqfjJw/gbJf1uHHjIJVKMXjwYHz//ffIyclBREQET9QtLS3FqFGjeAJldnY2IiIiUFBQALlczoM24GyQKSTvDh48mA/DWa1WDBkyBNu3b8eAAQNw6tQpniw5b948TJ48mQ/rRUVFITs7GzqdDgMHDsTWrVsxbNgw1NfXIyoqCps3b0ZFRQVEIhEiIyNRWlrKp2KPGjUKW7Zs4VPqhKEvp9OJo0ePYsSIEbwOx6ZNm1BbWwu9Xs+ndw4aNAg7d+7khZCUSiWfRltRUYGamhpERETAZDIhPz8fgwYNQl1dHR82SkpKwsmTJzFs2DDMnTsXW7duxQcffIBZs2ahqqoKq1evRkREBJKSkhAeHo7ly5fj8ssvx1VXXYV3330XGzZsQEBAAFJSUnD69GnU1tYiKioKIpEIoaGh8PPz49OEb7zxRsyePRsymQynT5+GUqlEXV0dz+eKi4vD8ePH+ect1MQRpggLSZczZszAypUr+bDQxx9/jKCgIEybNo1PKRSmn6empkKhUEAmk2HOnDl48MEHMWXKFEgkEmzbtg1SqRQXXXQRTp8+zadwajQaTJ48GSUlJVizZg1CQkJw/fXX8yD+wIEDaGxshFgsxkUXXYTvvvsOjz32GP75z38iMTERtbW1OH36NK688kqkpqYiICAA+/fvx4kTJ3jis0gk4vVZjh8/zj9P4aLn2muvxdtvv4277roLZWVlOHToEHbu3ImpU6fimmuuwWuvvcanOEdGRiIgIIBfbAnDYytXroTRaORDMY2NjTzB9PLLL8dPP/3EA2axWIyIiAhUV1fzxOorrrgC+/fvR25uLh588EHceeedfIiiuLgYcrkcQ4YMQU5ODnJzc5GSkoLw8HDcdtttePPNN+FwOJCfnw+LxcKTX4WkWGE7WywWTJw4Efv370dJSQlEIhEfAhemquv1egQHByM0NBTr16/nwyrCVGSlUomGhgZce+21WLduHdLS0iAWi5GXl4eysjI+JdRut2PIkCEYM2YM4uLiYDAYcPDgQRw+fBhZWVmYOXMmNm7cyAOoAwcOwGazITIykk87dTgcSE9Pxy+//IKXX34Zr7zyCtLS0nD48GE4nU7k5uZi4MCBKCoqQmFhIRQKBQIDA1FQUMDfm0gk4sGVcAwRCMG4VqtFVFQUKioqMHz4cISGhvKyBk899RQP2BoaGvi+3r9/fxw5coRfTAuBYkeKDgq6Jch4/vnnMXfuXDDGsHnzZjzzzDNoaGiAzWbjc5ijoqJw4MABxMfH83nxbrcbl19+Oerr63kWc3x8PGJjY/HBBx+guroa8fHxfIz0lVde4VdtwhezqKgIaWlp2LZtG1wuF5xOJ0+mMRqNPOHIYDBgyZIlkMvlePDBB1FTUwOr1Yr+/fvj6NGjqKurg0ajgcFgwE033YSFCxdi0aJFePbZZ7FkyRLs27cP1157LV544QXMmzcP//3vf3HXXXchJSUFGzduxPLly3lRk7fffht33HEHT+az2+04fvw4Jk2ahP/+97+45557cOutt2Lu3LlYtWoVFi1axGeJlJWV8foG6enpiImJwfHjx1FfX4/p06fDZDJh3bp1fL61xWLhNSL8/PzgcDh4drEwO2Dbtm08C18qlSImJgZqtRoSiQRZWVn8C/rdd9/hrrvu4oVhAPCiNcKV2ZAhQ7B27VpecKayshKlpaWIi4uD3W7Hnj17kJqayueq19TUwN/fHykpKfDz88Pf/vY3Plb773//GyKRCMuWLcOePXug1Wqxfft2fPrpp8jLy+MzSIQZPkJS1dChQyGTyVBdXY3a2lqewBgTE8PHUQHgL3/5C06cOIErr7wSzz//PMLCwiASiRAbG4sTJ07g1ltvRXFxMb9SMRqNeOqppzBz5kxs3boVoaGh2LFjB6KiojB79mxoNBo4nU689dZbKCgoQGNjI0wmE0pKSjBz5kxs2LABwcHBkEqlyM3NRXp6OiorKzFy5Ei8++67+Pvf/44333yTX6HMnDkTR44cgcFgQGFhIWQyGe99GzlyJH9vl1xyCTZs2AAASExMxEMPPQSn09nkwHn48GHccccdeOONN6BWq+FwOHgdgMjISNTX1/NZF8KV7qhRo1BbW4vDhw/z4Ly8vByNjY3w9/dH//79ebEtIcFVmH1SX1+PBQsW4LPPPoPD4UBhYSGfHXP55ZdDq9XipZdegsvlgl6vx7p163iBu6ioKGRlZfHZNUIewtdff41vv/0WH3zwAerq6pCamoqamhrk5eVBrVbDz88P1dXVMJlMUCgUqKys5AWw/v3vf+Ozzz4DYwyPPvoo9u3bh5MnT+KRRx7Brl278OijjyI/P58/b2BgIA4dOgSpVIrAwEAMGDAA+/btg9VqRUlJCfz8/Hh+TkBAAM8DEvKHysrKIJfL+UnN4XDAbDbDZrOhpqYGGo2Gf4dcLhemTp2KTZs2YdGiRfjggw9w7NgxzJ07F/7+/tiwYQOsVisKCgpwzz33YMWKFcjNzUVISAj+9a9/4f7778eAAQNw5MgRnDx5Eqmpqbj//vuxadMmBAUFYe3atWhsbITRaER2djasViuv45GcnIykpCQMHjwYr776KkaOHMlrvhw+fBhSqRQpKSkwGo1Yu3YthgwZgpiYGNx///144403sGHDBlRVVaG2tpYHHePHj8esWbOQlZUFvV6P7777DllZWaiqquInRKFHWSqVIigoCKNGjcKRI0d4PaSKigrI5XLMnz8fK1asQHBwMMxmMxISEvDJJ5/A6XTi1VdfRW1tLcaPH48777wT27dvR3x8PIKCgrBr1y5ea+n222/HJ598goaGBn7eEWoSCcd1f39/DBw4EF9//TWMRiOfVSckkIeHh2P16tWoq6vD559/DrvdjjNnzqCoqAgmkwlTp07FnXfeiQEDBqC8vBwikYjXU9LpdBCLxYiLi0NYWBhuvPFGfPXVV5g0aRKWLVuGqVOn4r333uPFv44dO8YvpoCzvWNxcXG8UNnBgwcxduxY3HvvvfjHP/4BrVYLq9WKRYsW4ZtvvoHRaMTbb7+N22+/HRs3buQ9MJWVlejXrx8KCgpgNBqRkpKC9PR0ZGRkYM+ePcjNzYVcLodOp+MzwoRzRUNDAz777DNERkZ6ff7vliBDONhcdtllWLduHUaPHs2Trvz8/HiSy5kzZ2AymVBeXg6ZTAbGGKKjo5GRkYGQkBCoVCqcOXMGUqkULpeLdxULJWGF7kXhii4iIgLFxcWYOXMmL5rjcDgQEBDAo2DPoY2GhgaIRCKEh4ejpqYGer0eubm50Gg0sFqt+Pjjj/HEE0/wbrstW7ZgzJgxuP/++/Hss89iz549KCwsREREBPz8/CAWi6HX63HkyBFs3LgRiYmJSEtLA2MMZ86cgV6vbzJ0I0SjOTk5SElJwZEjR/gBKjAwELW1tTx5aPr06Th27Bg0Gg0UCgXS09NRXFyMNWvW8IOtUqmERqPBa6+9hr/+9a9wuVx8+puQXDR16lQEBQXhl19+AXC2FHJpaSmAszt3eHg4tm3bhmHDhvEpTwaDAUajEWfOnEFiYiIyMzN5oTHhC1lTUwOpVMoLnjmdTgQFBfFkQ4vFAoPBgKKiIkyaNIlX55w6dSrWrl0LtVoNm82GMWPG8ATPt956C2PGjEFUVBTWr1+PMWPGoKqqCrm5ufzALRQoq6+v5916whW9RqPhV6/CUJBwsGO/J/vJ5XJER0fjwIEDCAkJQWlpKS/OFR4ezqvS7t69m3dbClONhe7juLg4HD16FHK5nHfBy2QylJWV4fbbb8e3336L6dOnQyQSYevWrVAoFNi3bx9SU1NRXFyMGTNm4ODBg4iOjobRaMTixYtx7bXXwu12Y/Lkyfjss894ULlz504+uyMlJQVRUVHIycnB8uXLIZfLUV1dzQtE7dmzB1deeSXcbjcGDBiA3bt3Y+rUqVAqlTh06BBv+8UXX4zFixdj1KhR+PHHH1FfX49HH30UK1euhFQq5VUqhZkKMTExsFgsEIlEKCsrw5133onvvvsOVqsVMpkMQ4cOxcqVKzFo0CCcOnUKJpOJB0EhISH8Oy0Md4rFYoSGhvITzpdffonPPvsMq1atwvLly3HFFVfwk6bFYsEll1yC7OxsHDt2DIMHD0ZkZCQfXhH2S6GXQBguEhIQPYtCAeAnAJFIxAsEAkBUVBQkEgkyMzMRFxfHk0mrq6tRVlYGsVgMPz8/NDQ08MJhAPiJ1G63Y8qUKaitreXFtoSAv6SkBP/3f/+HV155BTExMcjJycG3336L22+/HcDZUuyhoaGoqKhASEgICgoKMGPGDHzzzTeQyWSwWq18/xV6MwwGA09WFE6kDQ0NSExMxPHjxzFw4EBkZWXB7XYjODgY5eXlfD+uqKiA2+2GVCrls910Oh1P3t20aRNkMhnq6uogEokwbNgwZGRkIDAwEJWVlfz7xX4vdqdUKpGWloY9e/bAaDSiuroaWq2W9yYJQYper0dtbS2MRiPmzJmDL774gidgChc9Qq9aRkYG76EFwIsPymQypKWl4ciRI5gxYwYeffRRPP300/wkKgx/TJ48GadOnYJKpUJOTg7Cw8ORmZmJkJAQJCcn4/Dhw/z4IMx+NBqNfAhfOG8I7VMoFJg8eTJWrFiBDz74APPmzUNiYiIKCwt5UUKpVIqqqiqkpaUhJiYGer0eO3bsgNVqRVFREbRaLS699FLs27ePDwEJvTw5OTk84BV6w1544QWsXr0aUVFRsNvtqKmpQX19PYKCgtDQ0NDkAkyYUu5Z5EwIioUyAzabDTqdjn8GwsU9AF6ioDNl+7slyOjXrx8GDhyI06dP49ChQxg+fDi/uhTm6AcHB/O5+3K5HKNHj8aKFSv4hymTyaDT6XitiKKiIp4xGxgYiODgYF51UhgKESrayeVyKBQKfkL0HK8SKj8yxtDY2AiZTIYRI0YgPDwcP/74I39+YfaHMINCLpfzcrUXXXQR1qxZg6KiIlgsFj5OJ1Sl0+l0ePLJJzF9+nRcdNFFvCZBXl4eAPAqfsJUV4VCAQCora3l3WYTJ07E5s2bERISwqdSnTx5EjKZDC+++CLeeecdHDx4EFqtllcZVKlUKC8vxzXXXIOtW7eiqqqKvw9hWKKxsZFPY2WMwWaz8TwFof6BMPQgTDcOCwvjtUoeeOABLFmyBKmpqTh9+jSf8y5UnhRmANhsNj52LJFI+OcqXPUJ4+bC8+3atQvx8fG46qqroFAo8OOPP0Kn0/HsbLvdjsGDB6OgoAB6vR6BgYGIjY3Fjz/+iMbGRvTr1w/Hjx+Hw+HgeSaBgYFgjEGlUkGv18NgMODMmTOoqqrC+PHjsXPnTlx77bVYunQpnxZXXFyMjz76CLfeeituueUWfPnll5gzZw7ef/99Xo63oaEB4eHhvKs9NzeXB0mjR4/GkSNHEBsbi+3bt2P79u2YN28e7zkQhnySkpJQWFjIx1rT0tJQXFwMl8vF85dqa2tx8OBBlJSUYMKECTyvQ8g/GDFiBKRSKY4dO4ZDhw7x3CRh+qkQRAlX0MLJViwWQyQSYfz48bzSqjCmLfQghoeH856D48ePIyQkBC6XCzU1NQgLC8Phw4f5TAaj0Yi6ujoMHDgQe/bs4d8vIYhITk7GyZMneeVOsViMsLAwXhJb+H44nU6eJV9XVweXywWTyYTKykre2+NyuZCamopjx47huuuuw8qVK3lOUkZGBu/+TU9Px+HDh3mVxOuvvx7Dhw/HU089xSv96vV6REVFwWq1wuFwoKSkBI2NjYiNjUVWVhaSk5ORkZEBqVQKt9uNuLg4DB06FCtWrOBX6bGxsTwHSNi/dTodCgsLeZ6CkOsj5EEJJ12hVxMAPwmEhoby44QQwBcWFmLUqFHYunUr4uPjodPpcOzYMSQkJCA/P59PZ0xLS8OAAQPw/fffQ6PR8BOzMBNGmEEzePBg7N27FwD490UkEuG6667D2rVr4efnh2PHjvFqtmVlZQAAk8mE2tpayOVyHtQLlXGFIaZLL70UkZGRsNls2L59e5PPraioCAkJCcjMzERlZSVuvPFGfPrpp5g/fz4UCgXeeustfszVarV8+wk5XUI+lEwmQ2VlJe6//36sXLkSY8aMwXvvvcen+ZaUlPDhA6PRCLPZzC+QTp06heuvvx5Lly7lVTSFWWrFxcXQ6/WYP38+Xn31VWg0GkRFRcFisaCmpoZ/P8LDw5GdnQ2lUgmLxYJBgwbhxIkTGD58OHbs2IGBAwciNzcXdrsd5eXlPMA4evQo3x6S36tFW61WaDQaxMXF8SFbjUaD/fv38/L0DQ0N/PgsBLdCMFhaWgq9Xo+CggJoNBqEhobi9OnTvIdayPVLTk7GiRMncMstt/BcpqysLNx44404ceIEKioqcOzYMQBAcHAwLr74YjgcDjz99NNITEz06vzfLUHGnXfeiaVLl6K4uBhmsxkKhYJfOQjRkxCNR0RE8G4t4FzyWnFxMZ+CKnwgBoMBJpOJX03ExcWhpKQEiYmJsFgsqKioQGVlJUaMGIEpU6bgf//7H/Lz83k3mmdeiNBVLFxhBQYG8gQyhUKBrKwsSKVSBAcH853+5MmTPKlNiKKFrkDPLysAXiistLSU1zsoKSmBUqnkZWXlcjmP6IVEPSEJU5geNnjwYPz666+w2+18apbwGgD4lcJFF12Ew4cP86I7Wq2WT/HTaDR8ipJwtSa0X7jSEz4fobT1iBEjsHXrVixZsgRFRUU4ePAgNm3axL/kqampOHDgAPz9/WGz2VBfX88TjpKTk9HQ0IDTp0/z5FOj0Yh+/fph586dkEgkCA4O5kNUwpdduPoU2idcdarVat7TVFdXh9jYWF4yOTMzE3q9ng/xaLVaFBUV8ecUPi+hMJlKpUJ9fT0KCwuh0+kQHR2NEydO8OI7QkAkRPcWiwWhoaH8AHnmzBmo1WpeltmzXoXb7cZdd92Fb775BkuXLsX06dMRHR2NsrIyBAcHIzs7m7++UGROOOgIpaCFdgiEfUqpVMJqtfIhj+ZX58DZnj3hQCwkRApdq0LbFi9ejIiICADgQzJCUqZQbEmYAi6UVRcS1yZNmoSff/6Zl6cXksyE/T86Ohrp6elYvXo1D/CFKbExMTH84N/Y2Ijhw4fDaDRizZo1MJlMkMvlGDlyJH8/JSUlWL16NYYPH46dO3fCbDajrKysyUlZ6MmKiopC//798eCDD+K///0v1q9fj4CAAKjVaoSEhGDlypV8G6elpWH79u18nzcYDEhJScGuXbtgNpuRmZmJwMBABAYGIjs7mx+vhMJ3QiAufB5CUSkhWJw1axb27NkDi8WCYcOGYcaMGTwHq6Kigh/3hCJclZWVvJeJMQaTycR7RwDwE4xnnoHQYzho0CDs2bMHarWaD9UJ+69QBqChoQH19fW850gYOtBoNHyKsrAvpaen48SJE4iPj8exY8f49MeLL74Yv/76Ky9wJyTPjh8/Hlu3bsW1116LQYMG4f777+f7jjBEJxwrhaRToedFyAEQglEh50Gj0WD06NHYsmULP6Yyxvj6OhKJBImJibjllluwePFivuyB2WxGaWkp7732/A4JF51yuRwVFRUYNmwYz7UQi8W8t8DlciEsLIyfqIUAp7a2FqGhoaivr4fVaoVSqeTnKOEiMSQkBGazGfX19cjLy0NVVRXi4+Nx6tQpuN1u3sMlBJzC90apVPIigkJ58ICAAFRUVPBtJxT4E0qVazQayOVyREZGwuFwID4+Hl988QX/LttsNqSnpyMzM5MH1AaDAQMGDMDgwYN5PtG9996LvLw8OJ1OREZGYtiwYThx4gQyMjJ4yYC4uDiMHTsWL7zwQofP/90SZGzevBlvvvkm3G43jh49ivDwcPTv358PN3zwwQdIT09HdnY2vzqcPXs2Pv30U9xxxx0QiUR4/fXX+Q51zTXXYP369di0aRP8/Pwgl8thNpuxbt06+Pv7Q6FQoKqqiq+pERYWhoqKCvTv3x9yuRwDBw7E9u3bUVFRgdraWoSHh6O2thYGgwGnTp1CfX09Lr30UowdOxYZGRn44osvEBwczL/EQh5CcXEx75IcPnw4rrrqKixevBiLFi3CI488gpdffhkJCQl44YUXsGrVKoSFhaGkpARDhgzBzp07cckll6CsrAwWiwXp6ek4evQoFixYgI8++ghxcXGoqqpCZGQkamtrcebMGTgcDowcORLr1q3DvHnzcOjQIWRkZPCTs5CElZ+fD5VKBavVyk9iKpUKwcHBsNlsfI0DITFMWJ9AONFKpVJcd911OHnyJDZs2MCzqIWkSWHePXBuxoVUKsWgQYNQUlICf39/hIaGYt26ddDpdLj++uvx888/89UPDQYDLBYLAgIC8Oijj+LNN9+ESqVCfHw8r5YpJK8KFTcHDx7MZ0AsWrQIeXl5sNlsOHbsGLRaLSoqKvhQi0wmg9FoxIABA5CTk4MRI0Zg48aNmDx5MiZOnIgHH3yQz9YR6lcIJ2NhaEEIcoScAfnvixE5nU6edCoEq0I3pnD1XVJSwue2C931wlBRcHAwiouLkZKSgpycHISFhfH1JqKiongNkAceeACvvfYa7HY7UlNTed2Yw4cPw2w2856FjIwM3HvvvXjooYf4egrz589HRkYGli9fzlfKVSgUfLaLv78/du/ejVmzZvF9W6imKxRxs1qteP311/HCCy9ApVIhMTERN9xwA2w2Gx555BF+gvL394dKpYLZbEZ+fj5OnDjBezS0Wi2GDRuGQ4cOITIyks90YowhOzsbgYGBfMjA398fkZGRkMvlWLVqFZxOJ/z8/PjnVF9fz0+E//jHPxAWFoZnn30Wx48f58OqIpGIFxGrqqqCRqNBeno69u3bx2ePaLVaHDx4kK+HERISgpKSEoSGhvJ9Twj0Kisr+QlB9HtFXaEyMHB2BVVhzF7YfxITEyESiXDo0CE+PFFcXMx7ZwYOHIjNmzdj1KhR0Gq1vNrub7/9BrFYjLS0NL7fz5w5E59//jmvkHnixAkwxrBkyRL83//9H6qrq6FWq1FRUQGFQsHXqhDy2YTvpkwmg9PpxL333st7AVasWMGHO2prazFs2DDk5+dDp9MhKCgIJ06cQGlpKcRiMQwGAzQaDZ9xJZVKeRXR/fv3Q6/X8xoxwjEXAJ/tplarcfToUb49hYBs8uTJOH78OAYNGoRt27bx9TqsVitfTTY8PBwymQxZWVm46KKLcO+99+K5557jdZCE9ycE6o888gi+/PJLjBs3jtcKkUgkyMjIQG1tLZxOJ7KysqDRaPgFT3JyMu+dEHolhVlRwjFAuPhJT09HRUUFBgwYgKNHj0KpVGL06NH88xOSVVNSUngv64kTJ6DRaHDxxRfjww8/xJQpU1BZWQmbzYZDhw5h69atuOaaa3jSrTDzw5Mwk004XzU2NvKhb6FuzIQJE5CWlobExES88cYbKC4uRmRkJHQ6HZ+h99NPP/HcPGE4Uwgyq6ureQVYlUqFuro6lJWVISIiAgsXLsTo0aPx+eef46abbvIqN6Nbgoxvv/0Wzz77LJRKJY4cOYLp06cjOzsbJ0+e5EWFhJOdRCLhXW1CN7fD4YBWq8Xy5cvx7bffYt26daipqeFfLmFMXS6Xo7S0FCKRCEajkWeER0VFIS8vDwaDAaGhoTh27BjCwsJ4gqHFYsHll1+O1atX864r4Wq0traWzxrw7NkQulIB8INbdXU1j4KF4jp6vZ4XS8nMzORVSIXqoULgIST6CON3ERERqK2tRXZ2NvR6PS93fscdd2D58uX86v/EiRNITk7m44TCLJLCwkL4+fkhNjaWR8tZWVmYMmUKVq1aheDgYH7lqlQqodPpkJOTA51Ox3uM/Pz8UFJSwnsZvv76a0yfPh0RERH45JNPMGvWLIwaNQrl5eXIzMxEWFgYjh49ijFjxmD//v2wWq0Qi8Ww2WwIDg7GQw89hA8//BCnTp3i45jClZRQ/lYul/MZANHR0SgsLOS5IWPHjuVdtT/99BO/ihV6OzwXDFIqlRg0aBA2bdqE66+/Hj/++CPvmaipqYHdbofb7UZaWhqqqqr4lFaLxcK7bZ988km8//77vFvy7rvvxr333ou0tDSUl5ejoKCA5yQIGfEPPvggbrrpJvzlL39Bfn4+SkpKUFhYiLi4OFRXV/NkRAB82M7pdPIpo1u3bsX06dP5yaW2thYOhwNjx47F7t27kZycDLfbzXNFhEq1Qq+Ry+XiC3IJC0YJ47AXXXQRTp48yad5C3k1ntOYhZ4Y4ep05syZ+PHHH1FbWws/Pz9UVlZCq9UiISEBTz31FJYsWQIAfKhOqM4r9AgKB39hnxcONyaTiSczu91uXrSssLAQCxcuxBdffMF7BIQeKKE3ThiGDAkJQWFhIR/OE4YxFAoFLr30Uuzdu5f3QApXxkLvjpBkZ7fbUVpaisjISIwZM4YnhxoMBp53IpR8Dw8PR1ZWFvr374+MjAxe0v+BBx7AvHnzeJXX/v37Y8+ePVCpVLxNABASEoKUlBT8+OOPvNdQCEzXrFmDSy65BP/5z3+wYMEChIeHo7i4GOHh4byUfnFxMT7++GOsXLkSMpkMhYWFGDFiBK+wKZVK+UyLb775BitXrsR//vMfvvBbUlISX2zRYrHAz88P06dP56scC9VRheGXgoIC1NTUYOLEiaitreW9JEKZ8+XLl2PUqFH8inzAgAE4fPgw7xUSelqFIEcoVy/0MLpcLsTExODgwYNISkpCTU0NxGIxAgICkJmZifLycrzyyit48skn4e/vj3HjxiE/Px/79+/nPdAVFRWoqqqCWCzmxRKFXjelUsnzy4TjukKhQEREBBwOB6ZMmYIDBw4gOTkZX3zxBWw2G2JjY5vkWQ0YMAC7du3iOXLCrJn4+HhkZGQgOjoaBQUFPPgqKyvDPffcg3Xr1uHNN9/EM888g+DgYBw+fBinT5/mheaCg4NRVFQEp9OJSZMmoaSkBLm5uVAoFDw/JiUlBQcOHGjSiyuUBX/ggQfg5+eHBQsW8KEvYdpzVVUVgoKCeC+LMGxdVVWFW2+9Fa+++io/po0YMQJr1qzh511hXxUWfhN6lwIDA6FQKHDnnXdi7969+Prrrzt8/u+WOhkvv/wyRo8ejUcffRQulwsJCQkoKSlBUFAQX+figw8+4Gs3REZG8vnz6enpGDlyJEwmEy9XLVx1GY1GaDQa3H333fDz88Pw4cPh7++PxMREfpWhUCgwYcIEREdH4/LLL0dISAjPhI+KioLT6cRFF12EXbt2wc/PD4mJiTzhyul0Yvz48Zg/fz7UajWP+k0mE19KXqVSQS6X8/K2Dz74IB8jFw624eHhvJtMmAKk1Wp5JC0k5AjJNuHh4WCMISsrCyaTCTKZDMOGDWtSe6CxsZFfNR49ehRFRUW86z4/Px9arRZDhw7lGdsulwtDhgzB5MmT+XBVaGgoAECr1fI8goaGBj7WnpOTw5MWa2pqMGXKFABnV8+dNGkS8vLykJiYyJPghG7Mbdu2obS0lB/IhASmf/7znzhy5Ai/mhHWromKisKzzz6LxMREzJ8/n2foCyWehW5focaBcNVjMpn4GjjCsJMwxl9YWIiff/4ZUqkUy5cv5zkyQlB6zTXXQK/X85LmTqcTpaWlCA4O5mP+GzZsQHFxMbKysnD8+HE88MADPEs7Ly8PR44c4fkdKSkpqKur43krKpWK56LY7XY+Q8TlcvE6BH5+fnxqZnx8PK+FIJFIeDArlMc3m818tlBmZiby8/PhcDh4eeiZM2ciJCQEbrcbgwcP5pUwQ0NDMW7cOF4OferUqQgPD+dDTEajEX5+fry6rtANP2DAAKjVavz888/8al0mkyEmJgbBwcEoKCjArFmzcPz4cezYsYMPqxiNRiQmJvKDrkql4uuSCIF1QEAABg8e3GQcv66uDnV1dfj3v/+NzMxMVFVVoby8HG63u0lvhsVi4dMqhZoERUVFsNlsiI6ORkREBJ9aLvRQAMDEiRMRFhaGzz77DElJSTwAE9pZUFCATz/9FGq1GuHh4Rg+fDjCwsIQHR3Nkyjz8/Nhs9n4NERhiqSwgueJEydw2WWXoby8HOPHjwdjDPHx8Vi1ahWvRFtZWYmgoCCkp6fzZHNhWQCn04knnniCr0ehVqtx+vRpqFQqvsqpEFwIVV/XrVvHhz6EoU2tVovLL78cr7zyClwuF2JjYxEYGIisrCxYLBYEBQUhODgYERERfBVboarn5s2b8fXXX+P48eO8/sz27dv5Zywc54qKinD11VdDJBLhxhtvxM6dO6FSqSASifDuu+8iMTERqampCAoK4jMZFAoFVCoV7xEsKiriQUBycjLv5Xr44YcxefJkxMTE4JVXXoFCoUBdXR2fzqzX61FRUcGDpbi4ON7TaDKZMGPGDLz66qt8Fe9LL70UQ4cO5cfarKwsuFwu/Pzzz9i3bx8+/fRTTJ06FXa7nefxCOtWnTp1Ck6nE9nZ2Ty/rK6ujtd3ysjIQHl5OZxOJ18v65dffoFUKsW4ceOQnJzMK7mGh4fzWVBCD4GQDCqVSnHvvfeivr4ekZGRsNvtaGhogNFoxPjx4/nsPWHiQWlpKTZu3IiAgACkp6cjKCgIpaWl/EK3vLwckyZNQlpaGsaOHYvk5GRERUXh9ddf5+ddi8WCffv2YebMmaivr8fs2bORnZ2N06dPQ6/X8+NOeno6qqqqeK/u559/7l0AwLrJ3//+d3bxxRczkUjEV0Hs168fi4yMZFdccQX76aef2IIFC5jJZGIxMTHMZDIxvV7PZsyYwUJDQ5lSqWyy+qVQmVKosCiRSNiAAQNYamoqGzZsGIuNjeUr5gUFBfEqgWKxmMXHx/MKkp7PlZ6ezqZOncpuv/12FhkZybRaLZs2bRq77777eMXAsLAwFhERwVd8FB7r+SORSJhcLmcSiYQZjUZeaVCoTBoTE8OCgoKYTqdjV111FYuMjGQmk4mZTCZexU2oXCis5im897S0NCaVSllQUBAbMWIES0xMZDExMUylUvFV+EwmE399eKwQGxwczKKjo1lAQABLSEhgSqWSxcTEsOjoaL5Sq0ql4pUHTSYTMxqNbNiwYXz7JycnM71ez6sGmkwmdtVVV7EFCxawiRMnsttuu42vgOjv789XDBTa4llJT+yxmqvnbUKVPGF7CttY2C4hISG8CqxSqWSXXHIJX/1Qq9WyqKgoFhAQwFcWveSSS1i/fv2YVqtler2ehYaGsosvvphX3dPpdEyv17MxY8awcePGsfj4+CZVMIUVZqdPn86kUilLT09nYrGYzZo1i2m1WhYYGMjCw8OZUqnkqxsKFQ2FlVwNBgOveCqsxCu8V+F9C5+xUK1U+D/P/VT4VyqV/mFFWM/9Rq/XM41Gw6sQSn9faVeo1hofH88rtcrlcnbppZcyg8HAq4yKfq9QKRKJ+OcTGBjI95OEhARebXHOnDlMqVSyUaNGsUmTJrFXX32VabVaFhcXx6tg4vcVd2UyGQsJCWF6vZ75+/uzd999l1eEjY+PZzExMczPz49FRkbySqESiYSFh4ez0NBQtnz5chYYGMjS09PZ0KFD2YwZM5hWq2WjR49md911FwsPD2eRkZHMYDCw9PR0vopxQEAAk8lkTKPR8N/lcjm78sor2fjx43mFTaHiYVBQEIuLi+OfpWeVTsnvK4YqFApeEVepVPIqu8I21+v17LnnnmPjxo1jgYGBTKlUsgcffJD5+/vz7dL8cxRWvRS2tefnKuw/QuVOpVLJBg4cyG666SYWGhrK3nrrLTZp0iReNTQiIoIZDAYWEBDAIiIi2Lx589ioUaOY0WhkCoWCTZw4kel0OnbZZZex6OhoXgVZLpez22+/na9y/MADD7CoqCg2cOBAvk8B4MfXyMhIXslX+Cz9/PxYSEgIr6Isk8l4hUmxWMyrZ3quhCwcH+S/r4JrNpvZlVdeyeLi4lhgYCBfvVuoLDtgwABegVWoFBoaGsomTpzIfvnlFxYeHs6rfU6fPp1XvxSLxSwuLo6vdJuSksI2bNjAX1v8+2q3wnYU2h0SEsL8/f1ZUlISu+eee9jkyZNZcHAwCwsLYxqNhoWGhvJVdMViMbvpppuYUqlkY8eO5fsUgCarUnt+viqVimk0GpacnMwkEgkzm81Mo9Gw8PBwFhsbyyQSCUtKSmLx8fEsKSmJaTQaZjKZ2L/+9S9+vBD/Xl1Y8nsl3ICAAObn58fCw8PZrbfeyjQaDT93CecG4bMLDw/nqwErlUq+ErXJZGJms5mFhoayd955x+tzf7cMl/zvf//D3LlzsXDhQrz99tu8i95ms8FmsyEmJgbl5eWoqamByWRCcHAwjzaFGu82m43P2hg4cCDq6+uxbds2pKWl8Wllu3btQnp6Or/Sslgs/Apd6C2Qy+W49NJLsXr1amg0Gr6SpdvtRmNjI2699Vbk5ubyRZMCAwP5mLYwpCN0AQtX/sJVmtDlKCR4+vv7w2Kx8KqfwrjpO++8g+eeew4LFy5EYmIinnrqKVRUVMBoNPKKbFqtlndN19fX8+GjkJAQ/nojR47E4cOHERISwovnfP311zyaFaauWSwWPvuhqKgI7733HtasWYNRo0ahf//+ePzxx3H48GGeiKlQKJCcnIyKigpMnDgRy5Ytg9lsRnBwMNLT0/n0wOrqaqSnp/Pky4aGBvzzn//E888/j5qaGsyaNev/2zvvqKrOrA8/gAJWQDoqRXrR2LArYo0VkiCKBUw0WNFkbDGTWDKosUUTGwE1EgtGRQUrqBHRqGABFEUhSlNBunREvN8f5LwDSGbUxJT5zrNW1gp6vZx77jnn3e/ev/3beHp6il1TbGwsGhoaQvGtra0tXB6luQ7fffcdsbGxzJkzB319ffT19Vm3bh2nTp0iJSWFdevW0atXL86dO0dpaakoRUhdGpJASkrtS5kySQAmTdA0NjYW/g5nzpwRLoJubm6cPHlSTKStqKgQbYZS66XUedGkSRNRBpNKPNJ1JulO2rdvz+XLl1FXVxetyhkZGeTk5IjZMKWlpSxYsIBvvvlG+BhIs3q0tLQ4cOAAH374IXPnzmXhwoW89957xMXF4enpiZGREUuXLkVdXR0LCwu0tLTYvn07LVq04ObNm1hZWYmhSsOHD0ddXZ1Dhw6hpqZGYWGhKK2Zm5uTm5srds2NGjVi586duLq6imtPaoeTynOZmZlCw9KuXTsMDQ2JjY3l4cOH4vzk5+eL8y91CkjlIkBkCKWZIJLYVDLmkjJpktDNwsKCp0+fivZaIyMj7t+/T/fu3TEwMBBtnYpfBIKShsjGxoaWLVty6tQphg8fTl5eHufOnRODsPT09MREzzt37qCjo0NBQQGTJk3iq6++Aqp9ZhYsWMCaNWvo2LGjuA4UCgWpqamiDAjVWRZTU1PMzc1JS0tj+PDh7Nixg4kTJ/Ltt98Kb5j33nuP1atXk5aWhpmZmZjfNHr0aAoLC0WHXcOGDcUOtKKigq5du6Kjo4OKigoxMTHCE+add97h/PnzPHv2jHbt2pGZmYm7uzs3b94kODhYtPlLLYtKSkq0a9eOiooKEhISRNpdshGQvtcDBw6gq6uLk5MTVVVVZGVliY60CRMmsGLFClRVVSksLMTAwIDMzEyaNm0qnEWlUpl0DQEiayc9Ozt06EBycrJwV46Pjxf6GGdnZ9He6evry6hRo4iNjSU+Pl6Uv6RMmqQlUVVVxczMjKysLMaPH8/atWvFfJpdu3YxatQoWrVqRXZ2ttC1NW7cGA0NDVFWkp75UmeHjY0NFRUVYrJzZmYmZ8+epXnz5iJrWVFRIcrf9vb2Ytic5IpaWVkpyrrSfSIZ6yl+EcVK3SPSuWnUqBFVVVV0795dlMKTk5PFuiE1CAwePJg2bdoQEREhpgp/+OGHfP/995iYmAgjssuXL9cymZMErllZWTx58oScnBxRfpM6pySjR319ffbs2fPS6/8fEmTMnDmTr776irlz54qBT0lJSYwcOZK9e/eSnJxcS0Clr69P27ZtOXHihGirtLOz49mzZ6SkpNT64qHa1c/V1ZVTp04xadIkcaPv3r0bIyMjoqKiKC8vx9LSkh9//JEWLVpgZGQkBHlnz55lxYoVrF+/Hk1NTfT19UlJSRF90lBtPzt9+nRmzZqFvr4+ERERQojTvHlzUcpwcXEhJCSEJUuWsG7dOjQ1NdHR0RFj5aUWXRMTE44fP46bm5t4UEhWvs7OzkJ89+TJE1Ev3rZtG3369BFCn0ePHokJnADNmzcXC1tMTAxFRUXY2tqio6PD7NmzWbJkCXPmzGH37t2cPn2aRo0acfr0aWbNmiUcRh8+fCgcHyWtQ9OmTbGzswMgPj4eZ2dnrl27JjpkSktLycnJwd3dXbzOxMSEAwcO8Pz5c06dOiXS7VKApKGhIR5Skq1tcXGx8NWQdAJSACipz6XSlOS7IdV3vby8yM7OJjAwkObNmwsh7bhx49izZw/Pnz8XZaYLFy4wbNgwnJ2dOXfuHL179yYhIYEHDx6IGx+gV69eoqYfHR0tjknSAkgK85EjR3L69GkxGK1Xr178+OOPNGjQgFatWomOFS0tLVFOOnHiBB4eHkJroKqqKqYIS7oeyRxKas22tLQU5mhKv1hKS+UkaTCfurq6SEc3bNhQmO8UFxdjbm4ueuTNzc15+PAhRkZGXLp0CQcHByIjI7G1tSUhIQETExPy8/OF6ZSdnR03b95EW1sbZWVlunXrRnl5OQMHDuTWrVscPnyY9PR0pk6dip+fH3379iU7O5uUlBTatGnD48ePcXBwEK6x0kh1a2triouLSU9Px8jIiKysLOH0mZeXJ3QL6urqQvEvlaKkTjVdXV2uXbuGiYmJeJBLZnSSxumtt94iLS2N1NRU2rVrJ1r2zM3NmThxImpqavj4+IgOmjlz5lBWVoa/vz+5ublivHXNgWOSC6OknTAxMUGhqJ4+WlZWhq6uLgMHDiQyMlIERW5ubhw8eFC07TZq1Eh0GiQlJdG9e3du374tJrtqaGjQrVs3Ll68yN27d4U9/eXLl8nIyCAjI0MIQ9PT0xk4cCAxMTE8ePBAmIRJpYSmTZvi5OREWFiY6FpYtmwZW7Zs4ebNm7z99tvo6uoSGhpKTk4Ozs7OREZG0qpVK7KysujRo4doZZXa5CWx9KNHj7CysuLevXtCJCnpMCStlSQUluwD1NXVcXFxITg4WLSHN2vWjOfPnwsPkpKSEoyMjCgoKMDIyIj4+Hg2btzIypUruXDhApqammhoaJCamkqvXr1E2cbIyKiWKHL8+PEEBwezfv16FixYgLGxMXfv3qVXr17CfyQ8PBxra2ueP39OYmKi2DBIgt1r165RVVVVy01TEpACopV7xYoVrFmzhtmzZ3P58mUCAwMZOHCgCATz8/PR1tYW51Aa8S6VBqXgXPGLzgyqRbTPnz9nxIgRFBcX88UXXwixtOR+++jRI/T09NDV1eXy5cvY2Nigrq7O22+/zZ49e0R7dY8ePYiLixOu1RkZGWIju2zZMsLCwigrK+Pp06ckJiYKX4/Ro0fj4uLyyuv/H6LJUFZWZsSIEaL2GBoaSnx8PMuXL6d9+/ZERUVhampKly5dsLCwYPbs2Zw7dw6FQsFHH31EWlqauHClaY1S/fjJkyf07duXjh070qdPH06cOIGJiQlTp04VI8F1dXVRV1cnLi4OJycnIUSTamozZszgwYMHmJqaCkveyspKzMzM2LRpE+rq6sTExDBp0iRSU1O5cOECampq2NnZoaSkJBZHaXffqFEjgoODsbS0ZMOGDZiampKfn4+Ghgaurq40atRI+MBLLbGSsVHDhg25desWOTk54jMnJSURGBiIsrIyn3zyCbNmzRI2366urgwbNgx3d3dGjx6Ntra2ED6tX79e+HTMnDmT8vJy9u/fL8bIh4eH4+fnJ1qtpDkxUscGVN9Eq1at4smTJ3Tu3JnevXszefJknJ2dadmyJUuWLKF9+/a89957VFVVER8fj5+fH2FhYWIMuWSEJYno1NTUMDMzE10FgLDx1dHREeZFbdu2Fb3oUtvWZ599RseOHYWFb4cOHbCysiI3N5c7d+6I3X9FRQUuLi4cOnRI9KZLxlNSq6nkPOrl5UXv3r0ZMGAApqamVFRUkJeXR2pqKlAtTLS0tGTEiBH06dMHLy8vTE1NGTt2LPn5+Rw4cACFQsH3338vPm/jxo1xdnYWLWbSmO24uDgGDBjAmDFjRKdKXl6eMMExMzOja9euwvpayoJ17tyZtLQ0HBwcKC0tFYZqkg3+wIEDRZZFXV0dExMTSkpKMDMzw8LCAj8/P4qKiujTpw+pqamiXTInJ4eqqiq+/vprJk6ciLW1Ne7u7jx9+pTOnTtTVFRESUkJN27cEO146enp7Nu3j7CwMBYuXEhVVRWamppAtdIfEOMDGjduTL9+/ejbty9z585FX1+fu3fvUlRURHFxsdg5bd26lfz8fMzNzYWpkIqKCsbGxuKBW1lZiaOjIyoqKtjZ2fHo0SO++uornjx5Qp8+fcSEzKqqKhwdHWnXrp0QwklmTOXl5URHR3P9+nVUVVVJSkoiLCyM4OBgunXrJoLXlStXsmbNGoqKiti9ezfvv/++0A+ZmZlha2tLixYt6Ny5M4aGhsItMSkpSXTIJCcn4+/vj6GhIVeuXKG0tJRjx44JB97Hjx+Tn5/PuXPniI2N5enTp9y8eZOsrCw2bNhAUlKS8KrIy8sTfhVSEHnkyBGgulvL1NSUBg0acOXKFdLS0kRArqamxtChQwHE+0sZFlNTU7Zu3cro0aOFziwyMpK+ffvy9OlTTp8+DSDEnomJifTr14+33nqLLl26sH79euHZImUkACEe7tSpE6dPn2b48OHCxnvw4MFMmjQJNzc3GjduLEScUVFR2NjYYGdnR0BAAMbGxsyYMUOMqJ85cybJyck4ODiwatUq7t27J/RMUgDl6OiIp6cnGzdupGXLlhQWFqKpqYmRkRF5eXmoqqpiY2NDVVUVXl5eYmJtSkqKCEzU1NTIzs6md+/e6OnpMW3aNDHHycnJifHjxzNmzBjWr1/P/Pnz0dPTo2XLljx9+lQs8F988QUGBgacOHGCS5cu4eLiIpxBpXuipqZEoVAwZcoUTExMGD9+PAMGDODDDz9k1KhR9OzZkxYtWpCSkoK+vj5NmjQhPDycTZs2MXHiRCEylzZv2trajBgxAm1tbQoKCnj8+DFXr16lvLycUaNGkZiYyLFjxxg0aJDw/ZCujefPn+Pg4ICvry+6urqcOXOG/v37o6KiQkhICOvXr8fJyQlLS8tXW/9fOWJ4DZR/GRS2efNmvL296d+/P7q6uqxYsYLIyEi8vb3JysrC19eXq1evCgGcu7s7S5YsQVdXVyjLnZ2dgWrzorKyMoyMjNi9ezdffvklW7duZe/evdy+fZugoCDRnlZQUICtrS02Njbk5OQIkZyWlhaNGjUS9rdbt26lb9++aGhoCH8ChUIhWj8l4Z5kuypZ6Ur/aWpqkpqayltvvUVZWRl2dnZs2bKFoqIioqKi0NbW5vnz5/j4+Ah3x9LSUgoKCmjWrBk5OTnk5OSI3Yc04EdNTU2YSWVkZIiyyrJlyygsLOTw4cNC8FVcXMzUqVNrWTN37twZS0tLBg0aRFZWFgMGDBA7MH19fdzd3WndujW9e/dGSUlJmAJpaWmhpqbGjh07UFVV5fz582RkZLB48WIOHTrE4cOHCQgIICQkhH/+8588fPhQzJbYs2cPPXr0ICMjAzU1NcaOHYutrS26urooKytz48YNoYqWnE6lTAFAs2bNePjwIS1atBBtyU2bNuXHH3/EysqKgQMHMmjQIM6dO0dERAT+/v5oa2uLXXFcXBw//PADrVq1QllZmbi4OA4ePEhxcTG9e/emuLiYTZs20bhxYzZv3kxkZCQ3b94U5QHJA2HMmDGiDfSjjz5i3rx5FBcXk5qayv79+2ndujXGxsZkZ2czaNAg4QdSVlZGUlISenp6XLlyBT09PaysrGjUqJHoOpDcRaW0pJqaGomJieK4TE1Nadq0qeiCaNKkCc+fP0dXVxc9PT3Ky8tFoCF5rkjpXKlFWLIw/8c//iGyBE5OTjg6OjJ69GgyMzPp3r07a9asQU9Pj4sXL9KgQQOxi9TQ0MDGxgZlZWU6dOiAtrY2PXr0QKFQYGVlhaamJnp6ehQXF3PmzBmePn3KmjVraNiwochWnDx5kp9//pmRI0eir6/PiBEjxCwFyU3y+++/R01NjdjYWJ49e8a+ffvEOdHX1xfKeqg2LMrKyqJDhw4EBweLlm3p+6+qqqJJkyZcv35ddO+UlpbSsGFDbG1t8fDwoEmTJiKToa+vT2FhIceOHcPDw4OioiK6d++Op6cn48aN44svvsDY2Ji0tDSx2E+ePJm0tDQxhKxZs2ZERERQUFAgsmXSEC4/Pz8aNGjAlClTRGtlhw4d6NOnD7179xbZTjc3N8rKyvj888/55ptvMDQ0ZO3atSKjKQVn48ePp02bNmLYmrTRWrZsGUOGDBFzPKRgLSwsTBjw5efn895773Hr1i0GDBiAvb29KD1mZ2czdOhQjh49irW1NZ06daJDhw6MHz+eLl26UFBQwLFjx7h9+zZnzpxh06ZNlJeXU1JSwpMnT3jw4AHl5eV07txZCBH79u2LiooKgwcPFiUNSfRuYWFBWVmZGHNuZ2cnynBNmjTBy8sLBwcHka2Vsnampqb4+vqKoW56enrcv3+fiooKhg4dyty5c2uZVEkbR2VlZS5evMigQYNQV1cnNTUVb29vevbsyf3799HR0WHJkiUYGBhgaWmJoaGhyIK6uLigoqLC+fPnuX79uhgBkJ2dTVZWFm3atCE7O1sIevPy8ujSpQvvvvsuEydORElJifbt24syqXT/S/bze/fupbKykkuXLnHo0CFxjiS5wKxZsygqKiIzM5NRo0axYsUKfvjhBwIDA0lKSsLS0pLevXtTXl5Oeno6DRs2xNzcnOXLl+Pq6opCoaB///4MGDCAhg0bEh0dTXJyMgYGBpiYmODl5YWNjQ2hoaFiDouWlhbvvvsuH374Ib169aJjx46UlpayatWqV1r/G/xegcR/YvXq1QwcOJCFCxdSXFzM8OHDKS4uRkNDQ7gtPn78mFmzZjFu3Dhx0R8/fpzu3btTWFhIaWkpz5494+bNm4wYMYKSkhKRyrKysmLq1KlMnjwZgDlz5rBhwwYePnyIl5dXrWM5fvw4mzZtEj//4x//YOPGjbRq1YqtW7fi5uaGvb29mGoZEREhpnRKbUGSoZakBHZxceHOnTvMmDEDqK41btmyBX9/f3766Sd69uwJwOXLl1m7dm2tY8rMzKSsrAxvb2/Cw8Oxt7dHTU2NYcOG8f7772NnZ4eRkZGwiDU0NGTmzJlUVFTw7bffsmXLFhFwSa81MjLCycmJzZs3ExgYSEFBgRhqNGvWLKZMmSJ+/9mzZ/npp5/o0qULAIWFhaxdu5bjx48zdOhQzp07R0xMDAMGDGD16tVUVVXh7+/PsmXLcHBwECm7Hj16YGVlxddffy3eOy0tjb59+1JZWSnafocPH050dLRQ2ks1eskcLT09XQQdUmuzdE6h2jDK2toaCwsLHB0da3237777LomJiTRv3py4uDi0tLS4d+8ec+bMwc/PjxYtWgiHSqk919HRUXyfkjuslpYWQ4YMYc+ePdy6dQt7e3vU1dW5cOEC169fFx0/qampYgLwtGnTUCgUbN26lXv37tG0aVOhC3J2dkZPT0+oua9du4auri5paWncunULhUJBXFxcLSOiJ0+eCHfTZ8+ekZubCyBKTNI5efz4MQAPHjwAED9LrcGXLl0CqtP8lZWVbNy4kczMTFxcXIRNtBTIJicnY2pqyv3798UsDMkV98aNG5iYmDBt2jTCwsJo1KgRt2/fRktLi7CwMOGtoKSkRHR0tEjdSr4H2traBAYGEhYWRnx8vAhSpM8v+cVI51Wa1wDV+oTc3FyuXLki5hrV9Llo0KABI0eOpGHDhly4cIHi4mKuXbtG48aNadeuHWfPnhUlh3v37ongZ/jw4eTk5HDjxg1Rp09LS2PEiBEoFApOnDghfDM+++wz+vfvL/581KhRVFVV0bVrVzIyMoT25tmzZ5iZmZGcnCz8NKytrYWdfPPmzdHR0eHRo0fcu3cPOzs75syZQ1RUFMOGDSM9PV187nnz5rF7927u378PINpqfX19mTZtmrju09PT0dXVxdLSklGjRgkPjT179og2e4VCQWlpKQYGBuzbtw9jY2MeP37MiRMnMDY2xsPDQ9j8q6ioYGZmJsp0DRo0IDExEXNzc5EpTU5OJj8/n+LiYkaMGMHRo0dZvHgxs2bNIiYmBj09PUpKSoSmrUuXLhQXF3P79m0iIyMpKirC2NiYCRMmCFt7R0dHke2TurueP3/OkCFD+PTTT9mxYwfNmjUT2ScVFRVWrVpFZGSk0Ev5+vri4OAgTLEkB04pY3jz5k127NhB06ZNWbduHQ8fPqRPnz5cuXKF4OBggoKCKC8vZ9euXTRu3Bh9fX00NTW5cOECrVu3pnXr1qK7TZr/06xZM/Gdnj9/HhsbG3R1dWnfvj2enp4ALF++nFGjRomuJMUvxlsODg64uLjw5ZdfYm1tTXx8PMbGxuzZs0ecIykrkZ6eLkz/PDw8hPdLbm6umM0l6ZcUv7RoS2vNzp072blzJyYmJty+fRtzc3M8PDwYNmwYOTk53L17V7gFr1ixgqioKMLDwzE0NCQpKYlbt27h6urK6tWrRXnoZflDggzJT97V1ZUtW7awZ88e0tPTOXr0KO+88w79+vUTJYzk5GRSUlKwtbWlY8eOAFy4cEEIB6Ojo1FWVmbUqFEUFRXRv39/rl27RmpqqhixC+Dj4yMmhkpUVlbyww8/8MEHH4gaofTwjo2NJTQ0lNDQUJKSkoSR1f3799HV1cXKyopevXrRrVs3tm3bxtdff820adOwsbFh6tSpBAYGkpGRIX7XO++8AyACDKj205g7d26tc5OQkMDevXvp2bMnp0+fZvr06Xz33Xf07NmTVatWcf/+fZKTkykqKqJRo0ZkZGTg5OQE/Dvd2q1bN6ytrYmJiUFHR4fMzEzRburl5UXz5s0ZMWKEmGvx6aefCsc2W1tbrl+/zrBhwwgPD2fx4sV4eXlx5coVvLy8uHjxIjExMcyaNYuQkBB27tzJpEmTWLZsGdu2bWPAgAHC4vry5ct8/PHHpKenc+DAASwsLDh16hTW1tY4ODjQqVMnAgMDadmyJf369RM19kuXLqGtrS1aR1u0aCE0IlL9VlNTU1gWSw54urq6tc6ll5cXaWlpJCUlERUVxeTJk5k0aRLdu3dn6dKlHD58GF9fX8aMGUNmZibt27dnz549vP/++wCcOnWKiIgIlJSUePjwIe3atcPKygpdXV127dpFQkICWlpaxMfH061bN8aOHUtISAhQrVXx9PQUWbPQ0FDhHzBixAg8PT0pLy/HyMiIoqIinJ2dxRRFqLaWr6qqIjs7m4kTJ7Jv3z4hyouPjxc7Q2nAn+RmKM3nkXQk0i5W8qwoLy8nLy+PTp06oaKiwoQJE9i0aRMGBgbC6vjOnTsidZyYmMjo0aNxcnJi2rRpODg4UFFRwSeffEJ4eDgWFhYADB06lPHjxzNixIh67/kzZ84QHBzM5s2bxZ9FRkYyadIk/Pz8ROunlBG0trYmKSlJmI4FBARgZmbG/fv3adu2LZcvXyY5ORkjIyOsrKzE8CgdHR1GjhwpNhheXl48ffqUSZMmERERgaGhoZjX0aRJE0aOHMmhQ4cwNDTk0qVLaGhocPXqVZSUlMjIyOD58+ccOXKEK1euoKWlRVBQkCijtmnThvj4eABycnLIy8sjKCiIwsJCLl26hKqqKo8ePeLjjz9m3bp14nN37tyZvLw81qxZQ9OmTXF2dhZeILa2trRt21Y8PzQ0NESLoIWFBTY2NiIj8msUFBQwfPhwtLS0uHHjBhcuXMDAwIAjR47g6enJtWvXcHZ2plOnTly/fp2mTZvy+PFjunTpIkrUGzZs4OTJk9jZ2eHh4cG1a9fQ1tYmKioKqHYadXZ2xtHRkT179jBhwgQuXbqEiooKa9asoUGDBqxatQoVFRXGjRtHTEwM5eXlVFZWYmNjg42NjdD4aGlpCRFoRkaGuAcWLlzIzJkzefz4McrKyiQkJLB27VqmTJlCTk4O3t7e+Pv7M2DAAAYPHoy+vj6ffPKJCMoGDx5M165dxXmRBjLm5ubW6+vw2WefsXTpUpKTk+nSpYsIIq5fvw5Ur1tvv/027du3R0lJSWgV2rdvL+wCpBbk7OxsmjdvjpubG/379ycwMJDy8nL8/f3FfKSMjAySkpJwdnZm586duLu7Y2hoSEJCAuvWrcPX1xc3Nzehz5HOkeIX87oxY8aI4P2jjz4iOjoaIyMjunXrxpMnT0RGQxpJIF07il/mr0RHRwuR7NWrV7l8+TKdO3dGW1ub/Px84cKcnJxM27ZtxXo2e/ZsodmKjIxESUnplYSff0iQAbB27VoCAgJ49OgR48aNQ0VFhePHj2NqaoqXl1et3b2KigrDhg3j4MGDbNq0iTlz5lBaWoqtrS0XL16kb9++QLUwb926dcTHx7No0SIxXVWisrKSuXPn8vDhQ+zt7blz5w6mpqbs2rVLvGb69OkAtablSXXl/v37s3Xr1hc+S1ZWFpMmTaK0tJSpU6cCvJAxeVny8vKENuP8+fPcuXNH/BwaGkqXLl2ws7NDXV0dLS2tF86VlZUVAQEBYtzznDlzhB2zxI0bN1iyZAkpKSmoqqqydOlS8Xd1gxxJaJSVlcXp06fFQv7s2TPmzJlDx44d+f7774W19bVr14RbXrt27UhLSxMDoEpKSoiNjWX69Ol4eXlx8OBBwsPD8ff35+LFi1y6dIkWLVrg6OiIo6OjWJhNTU1JSUkRfeWSLuDmzZt8/vnnhIaGcubMGXGsNZEMhMLDw8nLy2P58uX4+PiIvnups2Xt2rUoKytz9epVvLy8WL16Nbt27WLbtm1UVFQQHR1NXFycCFxHjhxJQEAAJSUlVFRUsHbtWm7cuEFoaCiDBw/Gzs4OT09PJkyYwK5du8jOzmb79u307t1bHJu6ujqZmZl88MEHBAcH07NnT9q3b09cXBypqakUFBSwdOlSsds+cOAAgYGBtGvXDnNzc5o3b05+fr6YCty1a1fu3btHixYt6NOnD7m5uWLhHD58uFC+9+jRQ2hFCgoKmDNnDhkZGYwaNYrjx49jaGhIv379allC//DDD5iamnLjxg2h+jc1NSUzM5PCwkLOnj1LcnIyQUFB9T5wgoODOXXqFGPHjhWZl5CQEFxdXUlJSWHRokV88cUXdOnShUWLFnHw4EFhpDRy5EigOiiXArSTJ09ibm6OpqYmcXFxdOjQgVu3bjFx4sQXfreqqio7d+7ko48+4sSJEygpKTFz5kz2799Pfn4+6urqwgtn6NChLF++HE9PT4KDgzl79iyOjo5YWFjg7u4uruXg4GCCg4NJS0tj5syZJCYmitk0JSUljB49mpiYGHGv1MTHx4fc3FzWrFnDoEGDWL16NX369GHv3r3Y2dkRERGBj48PUN2JJ1FYWEi7du3ErhWqn2njx4+vJcCbP38+vr6+JCQkEBERgb29PZcuXaK0tBRTU1MiIyNZsGAB7u7uwrlUMuCC6vLT/Pnzad++vdilLl26lP3792NlZSUMA5WVlfHy8sLT0xMlJSV8fHx4/vw5S5cu5eTJk+zfvx9jY2O6devG9u3bGTx4MGFhYS98P/UxceLEWoFETfLz8wkPDycnJ4fw8HC8vLzYunUr27ZtIyQkBFNTU4B6RYnS91wfdZ/ZCQkJtG3bluzsbBITE7G3t68VLD548AB7e3vhqSS5Lffo0UNk72o+P2tmX7Zs2YKTkxNTpkxBT0+Prl27igA9KioKQ0ND2rZti4eHBwCDBg164Xg9PDx4+PAhp06dIjo6GldXV/bs2UNoaCht2rTh888/p3Hjxnh7exMYGAggAgXFL664KioqzJ8/n6+//lqUQq2trcXvkDawNXn8+DHz588X57vm61+GPyzIUFVVZcaMGSQkJDBjxgymTJlCaGiouLlqoqSkJOY8jBs3TqTSs7KyyMnJ4aeffgKq05Dh4eEMGjQIf39/hgwZIi5QhUJBUFAQlpaWBAUFMWTIEI4fP87s2bNr/S6pzuvj4yPqxmvXrsXMzKzezxEeHi6cShs2bMiKFSuEydXr8O6775KRkSHEQVIE6eLiwpYtWwgNDWX8+PG1Shw1CQwMZPv27eLnGTNmvBBk+Pr6sm7dOrS0tMjPz2f+/PkEBAQALwY5UH2BL1myhPDwcD755BOgepdQc1f6+PFjunbtKjowhg4dKnavo0eP5ueff0ZDQwNAPLikzwrV5724uJiCggI6d+7M8ePHKS4upn///igrK5Obm0tpaalQ80sOfFFRUS8ca01UVVVrndNdu3aRmZkpFg5DQ0P09PQICQmhWbNmYs6HJPKMjo4W12XNzFjN8zx9+nR27twpFs82bdqgrKzMmTNnhLjR3t6esrIycX3WPL6CggJ8fHw4ceIE7u7uopPk6dOnYucYERFBbm6usCOXatlPnjyhuLgYExMTUcaSOq709fVFl86DBw/IyckRAZuOjg52dnbigSEtMBEREURFRdGzZ0+cnZ155513CAsLEy3AUtp14sSJrFq1SnyWI0eOoKSkRHJyslgEawYbp06dAv5d5iotLWXevHnY29uzYMECoqOjcXR05N69e0yfPp2uXbvSvXt3EhMT8ff3f8FWOSMjg59//pkuXbpQUVFBfHy8sGr+NVavXk1eXh5nz57l/PnzeHt7ixkVn376KaGhofj5+WFpacmsWbP47rvvsLe3JyIiAn19fXbs2EGTJk2IjY1lx44dKBQKhg0bBsBXX33F8OHDUSgU3Lp1i9atW3PlyhVOnz4trikJLy8vwsPDUVJSYs2aNbRo0YJ//vOfHDt27IXSh5+fHwDl5eV888033Lhxg+Dg4Frv9+GHH9ZaUAMDA5k4cSJOTk5Mnz6dpKQkSkpKePvtt1m/fj3ffPMN+/btEx1gjRs35tSpU+K79PLyokOHDuzbt48vv/wSgMWLF7N48WIyMjLYtm0bYWFhxMTEcObMGRwdHUW3lZGRERkZGcTExGBlZYWysjKxsbHivnhZ6gYS8O97u+4zMiUlBfj3vTpr1qyX/j11kQKNiooKgoKC2LZtG02bNuXLL7+koqKi1rFIJcmff/5Z/HupRKGlpVXrmSSJ9+sGTVu2bCE1NZU7d+6wZs0aqqqq8PT0rPX56l77EkFBQUycOJGYmBi8vb2F3tDOzg4dHR0xIdXb2/uFAEqa9vz06VO6du0qdI59+vT5r+coLS0NeP3z/YcFGRJ1d8g1e+YlOnToAICDgwP+/v74+Pjw9ttvc+HCBVFWUVJSEqUBqE6b6unpYWNjIx5sGhoa3Lt3D39/fyorKwkICODmzZviRrl69apQRNfcQfwnMjIycHBwED/XrL2+DnUvhpo/u7u7s2jRIuGOV9/FJ2VdJOo+4KDa0VOyM9fS0hKdI/DiDSz9Dsl/X6LuLmHlypUMGTKEjh07kpKSwpgxY4iOjgaqF+FNmzaxYMEC4N/fp/TZpAW/Q4cOZGZmitkWaWlpHDx4EAsLC/Ly8tDV1SU9PV3UJgcOHIiysrJwHKzvfCh+GbInfb/W1tZ4enqKa+LZs2ecO3eO06dPC48C+O/XZc3znJaWJnrMw8PDefDgAQcPHiQgIED4vPTp06feY3R0dCQjI4NOnTqRnJwsnCHNzc2xtbUVn2/q1KlC3Pjo0SMqKytFLVtZWZmSkhKKi4u5ceMGBQUF3L59W7xPw4YNadmyJUlJSSQlJWFoaCjaRseNG1drgakZZEZFRREaGoqxsTGdOnXixo0brFy5kp49e+Ll5UVUVBSbN2/mypUrXLp0ifLycj7//HO6du36wv0zYMAAjIyMsLGxISgoiOjoaGF/bWtry4MHD/Dw8KCqqooFCxaIlklfX99axyeRmJgofBuys7Pp0aMHx44de+H7r/udff/99+Lev3XrFg4ODmRkZNChQwdCQ0M5fPgww4cPx8bGhrKyMnR0dFBVVcXf359hw4axcuVKZs2aVeu5AtXBYvPmzWnTpg2ampp8+umnPHnyhE6dOolrqiZSd8Hy5cuZPn06ixcvJj8/n7Fjx4oJqFC9cdq5cydHjhzBx8enViasvmtRoub5j4yMxMvLi3PnzvHdd9/RqlUrli9fLhxjCwsLa12XOjo6LFy4sNYGbO7cuZw+fRo3NzeOHj0qtC93797l4MGDODg4sHr1asaNG0fLli3p2bMnsbGxKCkpkZaWJu6Ll+XXnkPw4jPy2LFjL2RZX5fr16+zc+dOMVflvffeIyQkhISEBBYuXFjrWNLS0sjOzubBgwfidyoUChISEmjevHmt1/5a0GRhYUFpaakY5Ni2bdtXyoLXfN/KykqGDBlCRkYGiYmJtbKAdTE0NGTnzp1MmzaNwsJCkpKS6NWr10v9zvqy2q/CH+KTUZPbt28THh7O5MmTadq0KSEhIa/Ve1sfK1asYN68eWIo1ZUrV5g0aRLffvttrUXmzp073L59Gzs7OyZPnixGq//V0NPTY8mSJdjb2wPVgVXdyNPHxwdXV1exqB48eJCNGzfWeo2Li8sLotTDhw//pmPbuXMnly5dYvPmzaJc9ezZM0JDQzl9+jShoaHMmDGj3tSalMrbtWsXubm5GBkZ0bZtW/bu3YuGhgaampq1popK/29paYmSkhK9evUSgqq6PH36lICAgFf+fv/bdVnzPC9btoxr164xYcIE8fcv+6AIDAzkwoULQPXCKQk1pZZsSfujUChqva7muYiLixOfVQq6DQwMxPtIkznV1dU5e/Yss2fPpmPHjuzevZtx48ahpKQkzp/0XQB8/fXX4ruAat1BaWkp3377rTgnK1euxM3NjaysLK5fv46enh7x8fFs3bpVdDsA/Otf/2LDhg2Ym5tTWlqKpaUlqampogwhmXANGjSo1jEAtY5P4unTp3z88cfcvXuXFi1aiIzC65QpXVxcuHr1KsrKyhQXF2NgYEB+fj4rV65k+/btHDp0SOiCpGFwW7ZsqfUejo6OKCkpsXDhQmE3ffDgwZeyXLazs6N9+/bimZSamsrFixeBav1Gu3btcHd3FxnA7777rla5pF+/frWyH78VqZPk+vXrQgfXpEkT1NTUuHfvHq1btxabvQ0bNtT6tzXvm+Dg4FrvAa9fRv5P/J5riJmZGYsWLWL8+PHMnj27Vra2LtK9m5iYKDa3BgYG4p6t+Vl/7Zr29vbGw8OD7t27C5+nl8XDw0OIwauqqrCzs2P//v3s379feDb5+flx9OjRev99zWejqqoqX3755e/ybPxv/OFBxptEMgKSmDFjBvHx8YwbN67W67y9vf/oQ3stDA0NcXZ2xsnJSTxk6h77yyyqdS94eL2b//Hjx2zdupUHDx7QqlUr1NTUhJA1JycHHx8fgoKCcHNzY8OGDSxatEiUZerDx8eHlJQUdu/e/asB0l+F1w1e3gQtW7bEycmpVqmgvnLajBkzcHV1pWvXrkRHR3Po0KFanVV1mTZt2guLaV327dvH0aNHCQkJwdLSksuXL+Pj4/PCvzMzM2P8+PFi52VmZoa7u7soT0L9wcR/4sqVK+zfv59nz56xdu3aX00r/zcCAwN/tXuqrmjz448/ZuXKlSKYq/keNXmVzzJ9+nSxmD169AgDAwMRUNT3vpmZmS/UxOvLlrwukh9CTfr16ydE1wYGBri6uhIbG/sfF+G/I6GhoZSVlXHgwAESExMJCAgQnXZvAicnp9dej1atWvXCdRAUFMSiRYuA6g3I/v37hb9JXTIzM9mxYweHDx/Gzc3thSaEN8UfXi55k9R9EKioqAjF7N8xlkpNTeXw4cOcO3cOY2Nj5s+f/8JrJK3Lf+L32k3MmzePBQsWYGJiQlpaGitXrhR/p6OjI3Zx+vr6YgS4NCm17ncD1WLgLVu2sHDhQuzs7Fi7du3vcpxvgpc5z38UycnJHD58mMjISFq3bi3KUnVZt24dAQEBHD58GDs7O2GP/WvUbD/+Ndzd3XF3d+fYsWNisnL//v1rZVWgOhjZuXOncKwdM2YMx44de6XpjTWpKcasqyl4VX6tewrg/v37Ir0tqfrru3Z/yz21d+9eUeIqKSnh+fPn3Lt371ffd+bMmUBtvdDvSXBw8AtBxpAhQ1i2bBmjRo3i3XffFe2c/2ucPHmSzZs3ExERwVdffcWOHTveaJDxW9ajutoIHx8fqqqqhJGjQqEQLct1GTt2LK1atcLDw4PU1NQ/LMCA/7EgQ6FQvKC3MDIyeilxy18RyXv/6tWrIq3+Z6KioiJKN3Z2dvXWhgHRdaNQKJg6dSrHjh2r9/hVVVVfEOLK/HfqXhc1S0t1X/cqgVF9i+mvMWzYMIYNG8bkyZNxcnJi7NixtQIIqWNIcpkNCQl57QAD/r3Q1qcpeB1+rc5cU5wM/25F/z2RpsFOmTKFzz77DHd391c61vp0bL+Ful1AkltoQUEB3t7etWwA/teQ9CPp6ekkJCTUaoF9E/yW9ai+60AaGyHxa900HTt2JCYmhrNnz1JSUvJav/91+Z8ql9SX0pZumL8jdXdvUg37z+LcuXOi/KGkpMQHH3wgHFhrsmrVqlreG927dxetwjK/nT/zuqjp2aBQKNi4caOwt/478Sa1Yf8NBwcHMWdDEuvW7SD5I4+1ZpksPT2dHTt2cPXqVWbMmIGfn59o0/8znz1vit9S9nod6mb8XoX6roMhQ4a81PtdvnyZTp06cfXqVVHyftn24t/K/1SQ8b/GH30DvCrSpMC6vP/++8JQrKb3hszvw595Xfxe+p7/zzRv3hwNDQ0mTJjAqVOn0NLS+q+GW2+Sf/3rX9jY2BASEiJEvLdu3ar1mr/as0fm1airV/zggw9qWR+8Sf6nyiX/a/zVH94zZ86sVwj2a94bMr8Pf+Z18Ve/Jv8ObN++nZCQEIKCgmjZsuWfrkXavn07n3/+OTt27MDHx4fOnTvX6hSS+ftTN9tR08bgTSMHGTIvTadOnURLqkKhqNXfX5P/1PMuI/P/HTc3N9zc3PD29qZ3794sXbr0N+lVfiuSSPfs2bPCrv7vWmKWqZ/69Ip/FHK5ROalqZty++yzz/D19f0Tj0hG5u+HNE9iw4YNoqvlr5Dp+71EujJ/Pf7MFnw5yJCRkZH5A/mra61kZH5P5CBD5qXZvn07H3zwAaGhoQQEBNCnTx/mzZv3Zx+WjIyMjMxflFcbDC/z/xppBPKRI0c4cuSIsLiVkZGRkZGpDznIkHlpsrOz652uKiMjIyMjUx/yKiHz0kjTVSVLWmm6qoyMjIyMTH3IQYbMS1NZWUlVVRVPnjwBYNKkSX/yEcnIyMjI/JWRgwyZl8bPz4+FCxeyZs2aP/tQZGRkZGT+BshBhsxLU3e6qjRhVUZGRkZGpj7kFlaZl+b9999HSUlJTP38temqMjIyMjIyIGcyZF4BW1tbSktL6devH5WVlSxevPjPPiQZGRkZmb8w8uwSmZcmISGBvXv3ytNVZWRkZGReCjmTIfPS1J2u+meOp5aRkZGR+esjazJkXhp55oKMjIyMzKsgBxkyMjIyMjIybwS5XCIjIyMjIyPzRpCDDBkZGRkZGZk3ghxkyMjIyMjIyLwR5CBDRkZGRkZG5o0gBxkyMjIyMjIybwQ5yJCRkZGRkZF5I8hBhoyMjIyMjMwb4f8Ay5DPKqo76S0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scipy\n", + "\n", + "den = scipy.cluster.hierarchy.dendrogram(\n", + " clustermap.dendrogram_col.linkage, labels=distance_matrix.index, color_threshold=1.5\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "1902446f-8dcf-47fb-bd03-b3e31b40124c", + "metadata": {}, + "outputs": [], + "source": [ + "# extract clusters and perform gprofiler\n", + "from collections import defaultdict\n", + "\n", + "\n", + "def get_cluster_classes(den, label=\"ivl\"):\n", + " cluster_idxs = defaultdict(list)\n", + " for c, pi in zip(den[\"color_list\"], den[\"icoord\"]):\n", + " for leg in pi[1:3]:\n", + " i = (leg - 5.0) / 10.0\n", + " if abs(i - int(i)) < 1e-5:\n", + " cluster_idxs[c].append(int(i))\n", + " cluster_classes = {}\n", + " for c, l in cluster_idxs.items(): # noqa\n", + " i_l = [den[label][i] for i in l]\n", + " cluster_classes[c] = i_l\n", + " return cluster_classes\n", + "\n", + "\n", + "clusters = get_cluster_classes(den)\n", + "# extract functions for clusters\n", + "cluster_process = {}\n", + "for c in clusters:\n", + " cluster_df = pd.DataFrame(clusters[c], columns=[\"gene_symbol\"])\n", + " res = get_gprofiler(cluster_df)\n", + " cluster_process[c] = res[res[\"p_value\"] <= 0.05]" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "cdb473cb-93a3-4752-9612-5a58fc81cd30", + "metadata": {}, + "outputs": [], + "source": [ + "# save grpofiler results\n", + "with open(\n", + " \"figures/pert_embedding_cluster_gprofiler/scETM_replogle_pert_emb_gprofiler.pickle\",\n", + " \"wb\",\n", + ") as handle:\n", + " pickle.dump(cluster_process, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "markdown", + "id": "dc6d699c-ee76-487e-80ff-807f1c112995", + "metadata": {}, + "source": [ + "## PR Curve+AUC\n", + "- AUCPR using prior graph as binary label" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "62640fc7-412b-4a40-88da-bbd35fb23749", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " AUC\n", + "StringDB 0.252574\n", + "CORUM 0.240762\n", + " F1 Threshold\n", + "StringDB 0.278519 0.818003\n", + "CORUM 0.264378 0.839899\n" + ] + } + ], + "source": [ + "aucpr_df, f1_df, pr_dict = auprc(distance_matrix)\n", + "print(aucpr_df)\n", + "print(f1_df)\n", + "aucpr_df.to_csv(\"figures/pert_embedding_recall/scETM_replogle_aucpr.csv\")\n", + "f1_df.to_csv(\"figures/pert_embedding_recall/scETM_replogle_f1.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "8fdff66a-8f20-4268-8520-d33a0fa4969a", + "metadata": {}, + "source": [ + "# Interpretability of our learned latent space" + ] + }, + { + "cell_type": "markdown", + "id": "1ec54f80-8a0f-41f0-8c55-edd2b1fbfb3c", + "metadata": {}, + "source": [ + "## Factor Enrichment\n", + "- GSEA on log transformed latent-by-gene factors\n", + "- Then associate each perturbation to its top latent factors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35eb8169-15b1-4b5b-b926-d5b7238f372a", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "factor_to_go = factor_enrichment_gsea(adata, np.abs(adata.uns[\"gene_emb\"]), fdr=5e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "id": "814189ce-53f3-4716-834a-a4f0ea6efcf9", + "metadata": {}, + "outputs": [], + "source": [ + "# filter and add description to processes\n", + "go_df = read_aws_csv(\"s3://pert-spectra/references/GO_to_Description.txt\")\n", + "go_df.set_index(\"Term\", inplace=True)\n", + "go_dict = go_df.to_dict()[\"Description\"]\n", + "\n", + "filtered_factor_to_go = {}\n", + "for i in factor_to_go:\n", + " proc = factor_to_go[i]\n", + " proc[\"descr\"] = [go_dict[x] for x in proc[\"GO_ID\"]]\n", + " filtered_factor_to_go[i] = proc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a06b9724-d2a6-41e9-a38e-aac8d9f10818", + "metadata": {}, + "outputs": [], + "source": [ + "# save latent enrichment results\n", + "with open(\n", + " \"figures/factor_enrichments/scETM_replogle_factor_enrichment.pickle\", \"wb\"\n", + ") as handle:\n", + " pickle.dump(filtered_factor_to_go, handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47efd34e-e012-42b3-aa20-b5f7bc597832", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..b966356 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,20 @@ +anndata==0.10.9 +boto3==1.35.23 +botocore==1.35.23 +gprofiler-official==1.0.0 +gseapy==1.1.3 +matplotlib==3.8.4 +numpy==1.26.4 +opt_einsum==3.4.0 +pandas==1.5.3 +scanpy==1.10.3 +scETM +scipy==1.14.1 +scikit-learn==1.5.2 +statsmodels==0.14.2 +tqdm==4.66.5 +umap-learn==0.5.6 +--find-links https://download.pytorch.org/whl/torch_stable.html +torch==2.2.2+cu121 +tensorboard +plotly diff --git a/scETM/README.md b/scETM/README.md new file mode 100644 index 0000000..d13a743 --- /dev/null +++ b/scETM/README.md @@ -0,0 +1,8 @@ +# [scETM: single-cell Embedded Topic Model](https://github.com/hui2000ji/scETM/tree/master?tab=readme-ov-file#scetm-single-cell-embedded-topic-model) + +``` +Zhao, Y., Cai, H., Zhang, Z., and Li, Y. Learning interpretable cellular and gene signature embeddings from single-cell transcriptomic data. Nature Communications, 12(5261), 2021. +``` + +Training scripts for scETM to use as a benchmark. +Link to paper: [paper](https://www.biorxiv.org/content/10.1101/2021.01.13.426593v1) diff --git a/scETM/scetm_inhouse.ipynb b/scETM/scetm_inhouse.ipynb new file mode 100644 index 0000000..afe889c --- /dev/null +++ b/scETM/scetm_inhouse.ipynb @@ -0,0 +1,316 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "41d53f3e", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6e32fbd", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import anndata as ad\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "import torch\n", + "from scetm_utils import read_aws_h5ad\n", + "\n", + "from scETM import UnsupervisedTrainer, scETM\n", + "from scETM.batch_sampler import CellSampler\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " generate_k_fold,\n", + " write_adata_to_s3,\n", + ")\n", + "\n", + "sc.set_figure_params(\n", + " dpi=120, dpi_save=250, fontsize=10, figsize=(10, 10), facecolor=\"white\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca066698", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/inhouse_prior_graph_preprocessing.ipynb\n", + "unfilterd_adata = read_aws_h5ad(\"path to preprocessed h5ad\")\n", + "adata = filter_noisy_genes(unfilterd_adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "device = torch.device(\"cuda:0\")\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8fba4cc4-03d3-447a-924d-c878f9cd3c9d", + "metadata": {}, + "outputs": [], + "source": [ + "# powered perturbations\n", + "adata.obs[\"condition\"] = adata.obs[\"condition\"].astype(str)\n", + "adata.obs[\"Treatment\"] = adata.obs[\"Treatment\"].astype(str)\n", + "adata.obs[\"pert_treat\"] = adata.obs[\"condition\"] + \"+\" + adata.obs[\"Treatment\"]\n", + "obs_df = pd.DataFrame(adata.obs[\"pert_treat\"])\n", + "category_counts = obs_df[\"pert_treat\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"pert_treat\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cbb5ef4f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "View of AnnData object with n_obs × n_vars = 65648 × 4997\n", + " obs: 'num_features', 'feature_call', 'num_umis', 'target_gene_name', 'SampleIndex', 'ssid', 'Treatment', 'assigned_archetype', 'node_centrality', 'clusters', 'condition', 'control', 'pert_treat'\n", + " var: 'gene_symbol', 'feature_types', 'genome', 'gene_id', 'highly_variable', 'means', 'dispersions', 'dispersions_norm', 'gene_symbols'\n", + " uns: 'hvg', 'metadata', 'obsm_annot', 'sparse_gene_network', 'varm_annot'\n", + " obsm: 'ACTION', 'ACTION_B', 'ACTION_normalized', 'C_stacked', 'C_unified', 'H_stacked', 'H_unified', 'X_ACTIONet2D', 'X_ACTIONet3D', 'X_ACTIONred', 'X_denovo_color', 'archetype_footprint'\n", + " varm: 'ACTION_A', 'ACTION_V', 'unified_feature_profile', 'unified_feature_specificity'\n", + " layers: 'counts', 'logcounts'\n", + " obsp: 'ACTIONet'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adata" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb6a0457", + "metadata": {}, + "outputs": [], + "source": [ + "adata.X = adata.layers[\"counts\"].todense()\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "adata.X = np.array(adata.X)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "afef639c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_13522/996553587.py:1: ImplicitModificationWarning: Trying to modify attribute `.obs` of view, initializing view as actual.\n", + " adata.obs['cell_types'] = ['A549' for _ in range(adata.shape[0])]\n" + ] + } + ], + "source": [ + "adata.obs[\"cell_types\"] = [\"A549\" for _ in range(adata.shape[0])]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "e9d26f2a", + "metadata": {}, + "outputs": [], + "source": [ + "train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata, adata.X, adata.obs[\"condition\"], fold_idx=4\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "cc6ed3ff", + "metadata": {}, + "outputs": [], + "source": [ + "adata_train = ad.AnnData(np.array(adata[train_idx].X))\n", + "adata_train.obs[\"condition\"] = list(adata[train_idx].obs[\"condition\"])\n", + "adata_train.obs[\"Treatment\"] = list(adata[train_idx].obs[\"Treatment\"])\n", + "adata_train.obs[\"cell_types\"] = [\"A549\" for _ in range(adata_train.shape[0])]\n", + "adata_test = ad.AnnData(np.array(adata[test_idx].X))\n", + "adata_test.obs[\"condition\"] = list(adata[test_idx].obs[\"condition\"])\n", + "adata_test.obs[\"Treatment\"] = list(adata[test_idx].obs[\"Treatment\"])\n", + "adata_test.obs[\"cell_types\"] = [\"A549\" for _ in range(adata_test.shape[0])]\n", + "# for scETM, subset to TNFA+ for better signal\n", + "adata_train = adata_train[adata_train.obs[\"Treatment\"] == \"TNFA+\"]\n", + "adata_test = adata_test[adata_test.obs[\"Treatment\"] == \"TNFA+\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "019763d8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-11-13 00:25:06,897] INFO - scETM.src.scETM.logging_utils: scETM.__init__(4997, 151, n_topics = 200, trainable_gene_emb_dim = 400)\n", + "[2024-11-13 00:25:06,927] INFO - scETM.src.scETM.logging_utils: UnsupervisedTrainer.__init__(scETM(\n", + " (q_delta): Sequential(\n", + " (0): Linear(in_features=4997, out_features=128, bias=True)\n", + " (1): ReLU()\n", + " (2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (3): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (mu_q_delta): Linear(in_features=128, out_features=200, bias=True)\n", + " (logsigma_q_delta): Linear(in_features=128, out_features=200, bias=True)\n", + " (rho_trainable_emb): PartlyTrainableParameter2D(height=400, fixed=0, trainable=4997)\n", + "), View of AnnData object with n_obs × n_vars = 25701 × 4997\n", + " obs: 'condition', 'Treatment', 'cell_types', test_ratio = 0.2, seed = 0)\n", + "[2024-11-13 00:25:06,928] INFO - scETM.src.scETM.trainers.trainer_utils: Set seed to 0.\n", + "[2024-11-13 00:25:06,940] INFO - scETM.src.scETM.trainers.trainer_utils: Keeping 5140 cells (0.2) as test data.\n" + ] + } + ], + "source": [ + "inhouse_model = scETM(\n", + " adata_train.n_vars,\n", + " adata_train.obs.condition.nunique(),\n", + " n_topics=200,\n", + " trainable_gene_emb_dim=400,\n", + ")\n", + "trainer = UnsupervisedTrainer(inhouse_model, adata_train, test_ratio=0.2, seed=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4594136c", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "start = time.time()\n", + "trainer.train(\n", + " n_epochs=12000,\n", + " eval_every=2000,\n", + " batch_col=\"condition\",\n", + " eval_kwargs=dict(batch_col=\"condition\"),\n", + " save_model_ckpt=False,\n", + ")\n", + "end = time.time()\n", + "print(f\"Training time: {end-start}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe4981b6", + "metadata": {}, + "outputs": [], + "source": [ + "# retrieve reconstructed gene expression\n", + "recon = []\n", + "theta = []\n", + "for i in range(2):\n", + " adata_sub = adata_test[i * 10000 : min((i + 1) * 10000, len(adata))]\n", + " sampler = CellSampler(\n", + " adata_sub, 10000, sample_batch_id=True, n_epochs=1, batch_col=\"condition\"\n", + " )\n", + " dataloader = iter(sampler)\n", + " data_dict = {k: v.to(torch.device(\"cuda:0\")) for k, v in next(dataloader).items()}\n", + " out = inhouse_model.forward(data_dict=data_dict, hyper_param_dict={\"decode\": True})\n", + " recon.append(out[\"recon_log\"].clone().detach().cpu().numpy())\n", + " theta.append(out[\"theta\"].clone().detach().cpu().numpy())\n", + "all_recon = np.concatenate(recon)\n", + "all_theta = np.concatenate(theta)\n", + "assert len(adata_test) == all_recon.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "adff89de", + "metadata": {}, + "outputs": [], + "source": [ + "# save model parameters\n", + "adata_test.uns[\"topics\"] = inhouse_model.alpha.clone().detach().cpu().numpy()\n", + "adata_test.uns[\"gene_emb\"] = (\n", + " inhouse_model.rho_trainable_emb.trainable.clone().detach().cpu().numpy()\n", + ")\n", + "adata_test.uns[\"cell_emb\"] = all_theta\n", + "adata_test.uns[\"recon\"] = all_recon" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbade626", + "metadata": {}, + "outputs": [], + "source": [ + "# save to s3\n", + "write_adata_to_s3(\n", + " s3_url=\"s3://pert-spectra/scETM_checkpoints/scETM_inhouse/\",\n", + " adata_name=\"fold_4\",\n", + " adata=adata_test,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5dc11d8d-6e5b-4073-b923-f43c69bc22c0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scETM/scetm_norman.ipynb b/scETM/scetm_norman.ipynb new file mode 100644 index 0000000..07827ae --- /dev/null +++ b/scETM/scetm_norman.ipynb @@ -0,0 +1,269 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "41d53f3e", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6e32fbd", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import anndata as ad\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "import torch\n", + "from scetm_utils import read_aws_h5ad\n", + "\n", + "from scETM import UnsupervisedTrainer, scETM\n", + "from scETM.batch_sampler import CellSampler\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import (\n", + " filter_noisy_genes,\n", + " generate_k_fold,\n", + " write_adata_to_s3,\n", + ")\n", + "\n", + "sc.set_figure_params(\n", + " dpi=120, dpi_save=250, fontsize=10, figsize=(10, 10), facecolor=\"white\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca066698", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/norman_prior_graph_preprocessing.ipynb\n", + "unfiltered_adata = read_aws_h5ad(\"path to h5ad\")\n", + "adata = filter_noisy_genes(unfiltered_adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "device = torch.device(\"cuda:0\")\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "03d7f2d0", + "metadata": {}, + "outputs": [], + "source": [ + "# subset to powered perturbations\n", + "obs_df = pd.DataFrame(adata.obs[\"perturbation_name\"])\n", + "category_counts = obs_df[\"perturbation_name\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"perturbation_name\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eb6a0457", + "metadata": {}, + "outputs": [], + "source": [ + "adata.X = adata.layers[\"counts\"].todense()\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "adata.X = np.array(adata.X)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ad199270", + "metadata": {}, + "outputs": [], + "source": [ + "train_idx, val_idx, test_idx = generate_k_fold(\n", + " adata,\n", + " adata.X,\n", + " adata.obs[\"perturbation_name\"],\n", + " fold_idx=4,\n", + " perturbation_key=\"perturbation_name\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cf5abfb8", + "metadata": {}, + "outputs": [], + "source": [ + "adata_train = ad.AnnData(np.array(adata[train_idx].X))\n", + "adata_train.obs[\"perturbation_name\"] = list(adata[train_idx].obs[\"perturbation_name\"])\n", + "adata_train.obs[\"cell_types\"] = [\"K562\" for _ in range(adata_train.shape[0])]\n", + "adata_test = ad.AnnData(np.array(adata[test_idx].X))\n", + "adata_test.obs[\"perturbation_name\"] = list(adata[test_idx].obs[\"perturbation_name\"])\n", + "adata_test.obs[\"cell_types\"] = [\"K562\" for _ in range(adata_test.shape[0])]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "019763d8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-11-13 07:17:51,864] INFO - scETM.src.scETM.logging_utils: scETM.__init__(4990, 210, n_topics = 200, trainable_gene_emb_dim = 400)\n", + "[2024-11-13 07:17:52,037] INFO - scETM.src.scETM.logging_utils: UnsupervisedTrainer.__init__(scETM(\n", + " (q_delta): Sequential(\n", + " (0): Linear(in_features=4990, out_features=128, bias=True)\n", + " (1): ReLU()\n", + " (2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (3): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (mu_q_delta): Linear(in_features=128, out_features=200, bias=True)\n", + " (logsigma_q_delta): Linear(in_features=128, out_features=200, bias=True)\n", + " (rho_trainable_emb): PartlyTrainableParameter2D(height=400, fixed=0, trainable=4990)\n", + "), AnnData object with n_obs × n_vars = 64585 × 4990\n", + " obs: 'perturbation_name', 'cell_types', test_ratio = 0.1, seed = 0)\n", + "[2024-11-13 07:17:52,038] INFO - scETM.src.scETM.trainers.trainer_utils: Set seed to 0.\n", + "[2024-11-13 07:17:52,059] INFO - scETM.src.scETM.trainers.trainer_utils: Keeping 6458 cells (0.1) as test data.\n" + ] + } + ], + "source": [ + "norman_model = scETM(\n", + " adata_train.n_vars,\n", + " adata_train.obs.perturbation_name.nunique(),\n", + " n_topics=200,\n", + " trainable_gene_emb_dim=400,\n", + ")\n", + "trainer = UnsupervisedTrainer(norman_model, adata_train, test_ratio=0.1, seed=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4594136c", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "start = time.time()\n", + "trainer.train(\n", + " n_epochs=12000,\n", + " eval_every=2000,\n", + " batch_col=\"perturbation_name\",\n", + " eval_kwargs=dict(batch_col=\"perturbation_name\"),\n", + " save_model_ckpt=False,\n", + ")\n", + "end = time.time()\n", + "print(f\"Training time: {end-start}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5566fa6", + "metadata": {}, + "outputs": [], + "source": [ + "# retrieve reconstructed gene expression\n", + "recon = []\n", + "theta = []\n", + "for i in range(3):\n", + " adata_sub = adata_test[i * 10000 : min((i + 1) * 10000, len(adata))]\n", + " sampler = CellSampler(\n", + " adata_sub,\n", + " 10000,\n", + " sample_batch_id=True,\n", + " n_epochs=1,\n", + " batch_col=\"perturbation_name\",\n", + " )\n", + " dataloader = iter(sampler)\n", + " data_dict = {k: v.to(torch.device(\"cuda:0\")) for k, v in next(dataloader).items()}\n", + " out = norman_model.forward(data_dict=data_dict, hyper_param_dict={\"decode\": True})\n", + " recon.append(out[\"recon_log\"].clone().detach().cpu().numpy())\n", + " theta.append(out[\"theta\"].clone().detach().cpu().numpy())\n", + "all_recon = np.concatenate(recon)\n", + "all_theta = np.concatenate(theta)\n", + "assert len(adata_test) == all_recon.shape[0]\n", + "assert len(adata_test) == all_theta.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "adff89de", + "metadata": {}, + "outputs": [], + "source": [ + "# save model parameters\n", + "adata_test.uns[\"topics\"] = norman_model.alpha.clone().detach().cpu().numpy()\n", + "adata_test.uns[\"gene_emb\"] = (\n", + " norman_model.rho_trainable_emb.trainable.clone().detach().cpu().numpy()\n", + ")\n", + "adata_test.uns[\"cell_emb\"] = all_theta\n", + "adata_test.uns[\"recon\"] = all_recon\n", + "adata_test.X = np.array(adata_test.X)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "267de607", + "metadata": {}, + "outputs": [], + "source": [ + "# save to s3\n", + "write_adata_to_s3(\n", + " s3_url=\"s3://pert-spectra/scETM_checkpoints/scETM_norman/\",\n", + " adata_name=\"fold_4\",\n", + " adata=adata_test,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b84f007a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scETM/scetm_replogle.ipynb b/scETM/scetm_replogle.ipynb new file mode 100644 index 0000000..064fe88 --- /dev/null +++ b/scETM/scetm_replogle.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "41d53f3e", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6e32fbd", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "import anndata as ad\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scanpy as sc\n", + "import torch\n", + "from scetm_utils import read_aws_h5ad\n", + "\n", + "from scETM import UnsupervisedTrainer, scETM\n", + "from scETM.batch_sampler import CellSampler\n", + "\n", + "sys.path.append(\"..\")\n", + "from utils import filter_noisy_genes, split_data_by_cell, write_adata_to_s3\n", + "\n", + "sc.set_figure_params(\n", + " dpi=120, dpi_save=250, fontsize=10, figsize=(10, 10), facecolor=\"white\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca066698", + "metadata": {}, + "outputs": [], + "source": [ + "# use anndata generate by ..data_processing/replogle_prior_graph_preprocessing.ipynb\n", + "unfiltered_adata = read_aws_h5ad(\"path to h5ad\")\n", + "adata = filter_noisy_genes(unfiltered_adata)\n", + "adata.layers[\"logcounts\"] = adata.X.copy()\n", + "adata.X = adata.X.todense()\n", + "device = torch.device(\"cuda:0\")\n", + "gene_network = adata.uns[\"sparse_gene_network\"].todense()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "03d7f2d0", + "metadata": {}, + "outputs": [], + "source": [ + "# filter adata to perturbations with at least 50 samples\n", + "obs_df = pd.DataFrame(adata.obs[\"gene\"])\n", + "category_counts = obs_df[\"gene\"].value_counts()\n", + "filtered_categories = category_counts[category_counts >= 50].index\n", + "adata = adata[adata.obs[\"gene\"].isin(filtered_categories)]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0f15f5b5-aead-49bb-98ca-6926a3791ec4", + "metadata": {}, + "outputs": [], + "source": [ + "# reference the svae filtered replogle anndata to subset to those cells (see ../data for instructions on generating the anndata object)\n", + "filtered_replogle = read_aws_h5ad(\"path to svae filtered replogle h5ad\")\n", + "filtered_perts = set(filtered_replogle.obs[\"gene\"].unique()).union(\n", + " set([\"SKP2\", \"CUL1\", \"UBE2N\"])\n", + ")\n", + "adata = adata[adata.obs[\"gene\"].isin(filtered_perts)]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "eb6a0457", + "metadata": {}, + "outputs": [], + "source": [ + "adata.X = adata.layers[\"counts\"]\n", + "sc.pp.normalize_total(adata, target_sum=1e4)\n", + "adata.X = np.asarray(adata.X)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "281e46e2", + "metadata": {}, + "outputs": [], + "source": [ + "train_idx, val_idx, test_idx = split_data_by_cell(\n", + " adata.X, adata.obs[\"gene\"], test_size=0.2, val_size=0.2\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "038e5082", + "metadata": {}, + "outputs": [], + "source": [ + "adata_train = ad.AnnData(np.array(adata[train_idx].X))\n", + "adata_train.obs[\"gene\"] = list(adata[train_idx].obs[\"gene\"])\n", + "adata_train.obs[\"cell_types\"] = [\"K562\" for _ in range(adata_train.shape[0])]\n", + "adata_test = ad.AnnData(np.array(adata[test_idx].X))\n", + "adata_test.obs[\"gene\"] = list(adata[test_idx].obs[\"gene\"])\n", + "adata_test.obs[\"cell_types\"] = [\"K562\" for _ in range(adata_test.shape[0])]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "019763d8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-11-13 07:15:56,365] INFO - scETM.src.scETM.logging_utils: scETM.__init__(4935, 517, n_topics = 200, trainable_gene_emb_dim = 400)\n", + "[2024-11-13 07:15:57,358] INFO - scETM.src.scETM.logging_utils: UnsupervisedTrainer.__init__(scETM(\n", + " (q_delta): Sequential(\n", + " (0): Linear(in_features=4935, out_features=128, bias=True)\n", + " (1): ReLU()\n", + " (2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (3): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (mu_q_delta): Linear(in_features=128, out_features=200, bias=True)\n", + " (logsigma_q_delta): Linear(in_features=128, out_features=200, bias=True)\n", + " (rho_trainable_emb): PartlyTrainableParameter2D(height=400, fixed=0, trainable=4935)\n", + "), AnnData object with n_obs × n_vars = 67803 × 4935\n", + " obs: 'gene', 'cell_types', test_ratio = 0.1, seed = 0)\n", + "[2024-11-13 07:15:57,361] INFO - scETM.src.scETM.trainers.trainer_utils: Set seed to 0.\n", + "[2024-11-13 07:15:57,422] INFO - scETM.src.scETM.trainers.trainer_utils: Keeping 6780 cells (0.1) as test data.\n" + ] + } + ], + "source": [ + "model = scETM(\n", + " adata_train.n_vars,\n", + " adata_train.obs.gene.nunique(),\n", + " n_topics=200,\n", + " trainable_gene_emb_dim=400,\n", + ")\n", + "trainer = UnsupervisedTrainer(model, adata_train, test_ratio=0.1, seed=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e8b62a5-7a64-438b-aeec-6519faed6dbe", + "metadata": {}, + "outputs": [], + "source": [ + "trainer.train(\n", + " n_epochs=12000,\n", + " eval_every=2000,\n", + " batch_col=\"gene\",\n", + " eval_kwargs=dict(batch_col=\"gene\"),\n", + " save_model_ckpt=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "15d29ee4", + "metadata": {}, + "outputs": [], + "source": [ + "# retrieve reconstructed gene expression\n", + "recon = []\n", + "theta = []\n", + "for i in range(3):\n", + " adata_sub = adata_test[i * 10000 : min((i + 1) * 10000, len(adata))]\n", + " sampler = CellSampler(\n", + " adata_sub, 10000, sample_batch_id=True, n_epochs=1, batch_col=\"gene\"\n", + " )\n", + " dataloader = iter(sampler)\n", + " data_dict = {k: v.to(torch.device(\"cuda:0\")) for k, v in next(dataloader).items()}\n", + " out = model.forward(data_dict=data_dict, hyper_param_dict={\"decode\": True})\n", + " recon.append(out[\"recon_log\"].clone().detach().cpu().numpy())\n", + " theta.append(out[\"theta\"].clone().detach().cpu().numpy())\n", + "all_recon = np.concatenate(recon)\n", + "all_theta = np.concatenate(theta)\n", + "assert len(adata_test) == all_recon.shape[0]\n", + "assert len(adata_test) == all_theta.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "adff89de", + "metadata": {}, + "outputs": [], + "source": [ + "# save model parameters\n", + "adata_test.uns[\"topics\"] = model.alpha.clone().detach().cpu().numpy()\n", + "adata_test.uns[\"gene_emb\"] = (\n", + " model.rho_trainable_emb.trainable.clone().detach().cpu().numpy()\n", + ")\n", + "adata_test.uns[\"cell_emb\"] = all_theta\n", + "adata_test.uns[\"recon\"] = all_recon\n", + "adata_test.X = np.array(adata_test.X)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "267de607", + "metadata": {}, + "outputs": [], + "source": [ + "# save to s3\n", + "write_adata_to_s3(\n", + " s3_url=\"s3://pert-spectra/scETM_checkpoints/scETM_replogle/\",\n", + " adata_name=\"scETM_replogle\",\n", + " adata=adata_test,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b01b22c0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pertspectra", + "language": "python", + "name": "pertspectra" + }, + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scETM/scetm_utils.py b/scETM/scetm_utils.py new file mode 100644 index 0000000..49f704c --- /dev/null +++ b/scETM/scetm_utils.py @@ -0,0 +1,67 @@ +import os + +import anndata as ad +import boto3 +import botocore +import numpy as np +import pandas as pd + +SPECTRA_DEFAULT_DIR = os.path.join(os.path.expanduser("~"), "spectra_cache") + + +def read_aws_h5ad(s3_url): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + s3_object.download_file(save_path) + + adata = ad.read_h5ad(save_path) + return adata + + +def read_aws_csv(s3_url, sep=","): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(save_path) + df = pd.read_csv(save_path, sep=sep) + return df + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("object does not exist") + return None + return None + + +def read_aws_npz(s3_url, sep=","): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(save_path) + mtx = np.laod(save_path) + return mtx + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("object does not exist") + return None + return None diff --git a/src/README.md b/src/README.md new file mode 100644 index 0000000..090b397 --- /dev/null +++ b/src/README.md @@ -0,0 +1,7 @@ +# PertSpectra: Guided triplet factor analysis of perturb-seq data with a prior +Code for PertSpectra model. +This method is an extension on [Kunes, R. et al](https://doi.org/10.1101/2022.12.20.521311). +``` +Kunes, R. et al. Supervised discovery of interpretable gene programs from single-cell data. Nature Biotechnology, 42:1084—-1095, 2024. +``` +The codebase for the model is modified from [Spectra](https://github.com/dpeerlab/spectra/). diff --git a/src/Spectra/Spectra_Pert.py b/src/Spectra/Spectra_Pert.py new file mode 100644 index 0000000..9f1a929 --- /dev/null +++ b/src/Spectra/Spectra_Pert.py @@ -0,0 +1,1459 @@ +from collections import OrderedDict + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from opt_einsum import contract +from torch.distributions.normal import Normal +from torch.utils.data import DataLoader, TensorDataset +from tqdm import tqdm + +from . import Spectra_util # noqa +from .initialization import compute_init_scores, compute_init_scores_noct + + +class SPECTRA(nn.Module): + """ + + Parameters + ---------- + X : np.ndarray or torch.Tensor + the ``(n, p)`` -shaped matrix containing logged expression count data. Used + for initialization of + self.n and self.p but not stored as an attribute + labels : np.ndarray or NoneType + the ``(n, )`` -shaped array containing cell type labels. If use_cell_types == + False, then should + be set to None + + L : dict or OrderedDict [if use_cell_types == False, then int] + ``number of cell types + 1``-shaped dictionary. Must have "global" as a key, + indicating the number + of global factors + { + "global": 15, + "CD8": 5 + ... + } + > Format matches output of K_est.py to estimate the number of + > Must match cell type labels provided during training + > Recommended practice is to assign at minimum 2 factors per cell type + > Note that L contains the number of factors that describe the graph. + adj_matrix : dict or OrderedDict + ``a dictionary of adjacency matrices, one for every cell type + a "global" + { + "global": ``(p, p)``-shaped binary np.ndarray + "CD8": ... + + } + weights : dict or OrderedDict or NoneType [if use_cell_types == False, then + ``(p, p)``-shaped array] + the ``(p, p)``-shaped set of edge weights per . If weight[i,j] is non-zero + when adj_matrix[i,j] = 0 + this weight is ignored. + + if weights == None, no weights are used + lam : float + lambda parameter of the model, which controls the relative influence of the + graph vs expression + loss functions. This term multiplies the expression loss, so smaller values + of lambda upweight the prior information + delta : float + delta parameter of the model, which controls a lower bound for gene scaling + factors. If delta is small then the maximum ratio between gene scaling factors + is larger and lowly expressed genes can be put on the same scale as highly + expressed genes. + kappa : float or NoneType + kappa controls the background rate of edges in the graph. if kappa is a float, + kappa is fixed to the given float value. If kappa == None, then kappa is a + parameter that is estimated from the data. + rho : float or NoneType + rho controls the bakcground rate of non-edges in the graph. if rho is a float, + rho is fixed to + the given float value. If rho == None, then rho is a parameter that is estimated + from the data. + use_cell_types: bool + use_cell_types is a Boolean variable that determines whether cell type labels + are used to fit + the model. If False, then parameters are initialized as nn.Parameter rather + than as + nn.ParameterDict with cell type keys that index nn.Parameter values + determinant_penalty : float + determinant penalty affects the selection parameters that are fit when + L[cell_type] > + K[cell_type]. A determinantally regularized selection parameter is fit + with determinant + penalty that encourages sparsity and diversity. + Attributes + ---------- + model.delta : delta parameter of the model + + model.lam : lambda parameter of the model + + model.determinant_penalty : determinant penalty of the model + + model.L : L parameter, either int, dict or OrderedDict() + + model.p : number of genes + + model.n : number of cells + + model.use_cell_types : if True then cell types are considered, else cell types + ignored. Affects + the dimensions of the initialized parameters. + + model.kappa : if not kappa, nn.ParameterDict() if use_cell_types, else + nn.Parameter(). If + kappa is a float, it is fixed throughout training + + model.rho : if not rho, nn.ParamterDict() if use_cell_types, else + nn.Parameter. If rho is a + float it is fixed throughout training + + model.adj_matrix : adjacency matrix with diagonal removed. dict containing + torch.Tensors + + model.adj_matrix_1m : 1 - adjacency matrix with diagonal removed. dict + containing torch.Tensors + + model.weights : contains edge weights. format matches adj_matrix + + model.cell_types : np.ndarray containing array of unique cell types + + model.cell_type_counts : dict {key = cell type, values = number of cells} + + model.theta : nn.ParameterDict() or nn.Parameter() containing the factor + weights + + model.alpha : nn.ParameterDict() or nn.Parameter() containing the cell + loadings + + model.eta : nn.ParameterDict() or nn.Parameter() containing the + interaction matrix between + factors + + model.gene_scaling : nn.ParameterDict() or nn.Parameter() containing + the gene scale factors + + model.selection : nn.ParameterDict() or nn.Parameter() containing + the attention weights. + Only initialized when L[cell_type] > K[cell_type] for some cell type + or when L > K and + use_cell_types == False + + model.kgeql_flag : dict or bool. dictionary of boolean values indicating + whether K >= L. + When use_cell_types == False, it is a boolean value + + Methods + ---------- + + model.loss(self, X, labels) : called by fit if use_cell_types = True. + Evalutes the loss of + the model + + model.loss_no_cell_types(self,X) : called by fit if use_cell_types = + False. Evalutes the loss + of the model + + model.initialize(self, gene_sets,val) : initialize the model based + on given dictionary of gene + sets. val is a float that determines the strength of the initialization. + + model.initialize_no_celltypes(self, gs_list, val) : initialize the + model based on given list + of gene sets. val is a float that determines the strength of the + initialization. + + + To do: + __________ + + > Alternative initialization functions + + > comment SPECTRA-EM code + + > test lower bound constraint [see pyspade_global.py implementation] + + > Overlap threshold test statistic + + + """ + + def __init__( # noqa + self, + X, + labels, + adj_matrix, + L, + pert_idx, + pert_labels=None, + weights=None, + lam=0.01, + psi=0.01, + delta=0.001, + kappa=None, + rho=0.001, + use_cell_types=True, + device=torch.device("cuda:0"), + ): + super(SPECTRA, self).__init__() + + # hyperparameters + self.delta = delta + self.lam = lam + self.psi = psi + self.L = L + # for memory efficiency we don't store X in the object attributes, but require X + # dimensions to + # be known at initialization + self.p = X.shape[1] + self.n = X.shape[0] + self.use_cell_types = use_cell_types + self.device = device + + self.pert_idx = pert_idx + self.pert_labels = pert_labels + # add one dim for ctrl one-hot + self.n_p = len(pert_idx) + + if not use_cell_types: + # check that L is an int + assert isinstance(self.L, int) + + # trust the user to input a np.ndarray for adj_matrix + self.adj_matrix = torch.Tensor(adj_matrix).to(self.device) - torch.Tensor( + np.diag(np.diag(adj_matrix)) + ).to(self.device) + adj_matrix_1m = 1.0 - adj_matrix + self.adj_matrix_1m = torch.Tensor( + adj_matrix_1m - np.diag(np.diag(adj_matrix_1m)) + ).to(self.device) + if weights is not None: + self.weights = torch.Tensor(weights).to(self.device) - torch.Tensor( + np.diag(np.diag(adj_matrix)) + ).to(self.device) + else: + self.weights = self.adj_matrix + + self.theta = nn.Parameter(Normal(0.0, 1.0).sample([self.p, self.L])) + self.alpha = nn.Parameter(Normal(0.0, 1.0).sample([self.n_p, self.L])) + self.eta = nn.Parameter(Normal(0.0, 1.0).sample([self.L, self.L])) + self.gene_scaling = nn.Parameter(torch.zeros(self.p)) + + if kappa is None: + self.kappa = nn.Parameter(Normal(0.0, 1.0).sample()) + else: + self.kappa = torch.tensor(np.log(kappa / (1 - kappa))).to(self.device) + if rho is None: + self.rho = nn.Parameter(Normal(0.0, 1.0).sample()) + else: + self.rho = torch.tensor(np.log(rho / (1 - rho))).to(self.device) + + if use_cell_types: + # convert adjacency matrices to pytorch tensors to make optimization easier later + self.adj_matrix = { + cell_type: ( + torch.Tensor(adj_matrix[cell_type]).to(self.device) + - torch.Tensor(np.diag(np.diag(adj_matrix[cell_type]))).to( + self.device + ) + if len(adj_matrix[cell_type]) > 0 + else [] + ) + for cell_type in adj_matrix.keys() + } + # for convenience store 1 - adjacency matrix elements [except on diagonal, + # where we store 0] + adj_matrix_1m = { + cell_type: ( + 1.0 - adj_matrix[cell_type] + if len(adj_matrix[cell_type]) > 0 + else [] + ) + for cell_type in adj_matrix.keys() + } # one adj_matrix per cell type + self.adj_matrix_1m = { + cell_type: ( + torch.Tensor( + adj_matrix_1m[cell_type] + - np.diag(np.diag(adj_matrix_1m[cell_type])) + ).to(self.device) + if len(adj_matrix_1m[cell_type]) > 0 + else [] + ) + for cell_type in adj_matrix_1m.keys() + } # one adj_matrix per cell type + + # if weights are provided, convert these to tensors, else set weights = to + # adjacency matrices + if weights: + self.weights = { + cell_type: ( + torch.Tensor(weights[cell_type]).to(self.device) + - torch.Tensor(np.diag(np.diag(weights[cell_type]))).to( + self.device + ) + if len(weights[cell_type]) > 0 + else [] + ) + for cell_type in weights.keys() + } + else: + self.weights = self.adj_matrix + + self.cell_types = np.unique( + labels + ) # cell types are the unique labels, again require knowledge of labels at + # initialization + # but do not store them + + # store a dictionary containing the counts of each cell type + self.cell_type_counts = {} + for cell_type in self.cell_types: + n_c = sum(labels == cell_type) + self.cell_type_counts[cell_type] = n_c + + # initialize parameters randomly, we use torch's ParameterDict() for storage + # for intuitive + # accessing cell type specific parameters + self.theta = nn.ParameterDict() + self.alpha = nn.ParameterDict() + self.eta = nn.ParameterDict() + self.gene_scaling = nn.ParameterDict() + + if kappa is None: + self.kappa = nn.ParameterDict() + if rho is None: + self.rho = nn.ParameterDict() + # initialize global params + self.theta["global"] = nn.Parameter( + Normal(0.0, 1.0).sample([self.p, self.L["global"]]) + ) + self.eta["global"] = nn.Parameter( + Normal(0.0, 1.0).sample([self.L["global"], self.L["global"]]) + ) + self.gene_scaling["global"] = nn.Parameter( + Normal(0.0, 1.0).sample([self.p]) + ) + if kappa is None: + self.kappa["global"] = nn.Parameter(Normal(0.0, 1.0).sample()) + if rho is None: + self.rho["global"] = nn.Parameter(Normal(0.0, 1.0).sample()) + + # initialize all cell type specific params + for cell_type in self.cell_types: + self.theta[cell_type] = nn.Parameter( + Normal(0.0, 1.0).sample([self.p, self.L[cell_type]]) + ) + self.eta[cell_type] = nn.Parameter( + Normal(0.0, 1.0).sample([self.L[cell_type], self.L[cell_type]]) + ) + n_c = sum(labels == cell_type) + self.alpha[cell_type] = nn.Parameter( + Normal(0.0, 1.0).sample( + [self.n_p, self.L["global"] + self.L[cell_type]] + ) + ) + self.gene_scaling[cell_type] = nn.Parameter( + Normal(0.0, 1.0).sample([self.p]) + ) + + if kappa is None: + self.kappa[cell_type] = nn.Parameter(Normal(0.0, 1.0).sample()) + + if rho is None: + self.rho[cell_type] = nn.Parameter(Normal(0.0, 1.0).sample()) + + # if kappa and rho are provided, hold these fixed during training, else fit as + # free parameters + # to unify the cases, we put this in the same format + if kappa is not None: + self.kappa = {} + self.kappa["global"] = torch.tensor(np.log(kappa / (1 - kappa))) + for cell_type in self.cell_types: + self.kappa[cell_type] = torch.tensor(np.log(kappa / (1 - kappa))) + # self.kappa = nn.ParameterDict(self.kappa) + if rho is not None: + self.rho = {} + self.rho["global"] = torch.tensor(np.log(rho / (1 - rho))) + for cell_type in self.cell_types: + self.rho[cell_type] = torch.tensor(np.log(rho / (1 - rho))) + # self.rho = nn.ParameterDict(self.rho) + + def loss(self, X, labels, loss_weights, D=None, forward=False): + assert self.use_cell_types # if this is False, fail because model has not been initialized to use cell types + X = X.to(self.device) + D = D.to(self.device) + loss_weights = loss_weights.to(self.device) + + # initialize loss and fetch global parameters + loss = 0.0 + theta_global = torch.softmax(self.theta["global"], dim=1) + eta_global = (self.eta["global"]).exp() / (1.0 + (self.eta["global"]).exp()) + eta_global = 0.5 * (eta_global + eta_global.T) + gene_scaling_global = self.gene_scaling["global"].exp() / ( + 1.0 + self.gene_scaling["global"].exp() + ) + kappa_global = self.kappa["global"].exp() / (1 + self.kappa["global"].exp()) + rho_global = self.rho["global"].exp() / (1 + self.rho["global"].exp()) + + recon_dict = {} + term1_dict = {} + term2_dict = {} + term3_dict = {} + term4_dict = {} + + # loop through cell types and evaluate loss at every cell type + for cell_type in self.cell_types: + kappa = self.kappa[cell_type].exp() / (1 + self.kappa[cell_type].exp()) + rho = self.rho[cell_type].exp() / (1 + self.rho[cell_type].exp()) + gene_scaling_ct = self.gene_scaling[cell_type].exp() / ( + 1.0 + self.gene_scaling[cell_type].exp() + ) + X_c = X[labels == cell_type] + loss_weights_c = loss_weights[labels == cell_type] + adj_matrix = self.adj_matrix[cell_type] + weights = self.weights[cell_type] + adj_matrix_1m = self.adj_matrix_1m[cell_type] + theta_ct = torch.softmax(self.theta[cell_type], dim=1) + eta_ct = (self.eta[cell_type]).exp() / (1.0 + (self.eta[cell_type]).exp()) + eta_ct = 0.5 * (eta_ct + eta_ct.T) + theta_global_ = contract( + "jk,j->jk", theta_global, gene_scaling_global + self.delta + ) + theta_ct_ = contract("jk,j->jk", theta_ct, gene_scaling_ct + self.delta) + theta = torch.cat((theta_global_, theta_ct_), 1) + alpha = torch.exp(self.alpha[cell_type]) + + # terms for perturbation + if D.shape[0] > 0: + D_c = D[labels == cell_type] + + p_alpha = D_c @ alpha + recon = contract("ik,jk->ij", p_alpha, theta) + term1 = ( + -1.0 + * ((torch.xlogy(X_c, recon) - recon) * loss_weights_c[:, None]).sum() + ) + + if len(adj_matrix) > 0: + mat = contract("il,lj,kj->ik", theta_ct, eta_ct, theta_ct) + term2 = ( + -1.0 + * ( + torch.xlogy( + adj_matrix * weights, + (1.0 - rho) * (1.0 - kappa) * mat + (1.0 - rho) * kappa, + ) + ).sum() + ) + term3 = ( + -1.0 + * ( + torch.xlogy( + adj_matrix_1m, + (1.0 - kappa) * (1.0 - rho) * (1.0 - mat) + rho, + ) + ).sum() + ) + # perturbation autocorrelation term + # include only perturbations that are in the graph + if D.shape[0] > 0: + ctrl_indices = [i for i, x in enumerate(self.pert_idx) if x == -1] + pert_subset_idx = [ + i for i, x in enumerate(self.pert_idx) if x != -1 + ] + alpha_subset_idx = [ + i for i in range(alpha.shape[0]) if i not in ctrl_indices + ] + term4 = ( + -1 + * Spectra_util.geary_autocorrelation_multivariate( + mat[pert_subset_idx][:, pert_subset_idx], + alpha[alpha_subset_idx], + )["stat"] + ) + else: + term4 = 0.0 + else: + term2 = 0.0 + term3 = 0.0 + term4 = 0.0 + recon_dict[cell_type] = recon.clone() + term1_dict[cell_type] = term1 + term2_dict[cell_type] = term2 + term3_dict[cell_type] = term3 + term4_dict[cell_type] = term4 + loss = ( + loss + + self.lam * term1 + + (self.cell_type_counts[cell_type] / float(self.n)) * (term2 + term3) + ) + + # compute loss associated with global graph + adj_matrix = self.adj_matrix["global"] + adj_matrix_1m = self.adj_matrix_1m["global"] + weights = self.weights["global"] + + if len(adj_matrix) > 0: + mat = contract( + "il,lj,kj->ik", + theta_global, + eta_global, + theta_global, + ) + term2 = ( + -1.0 + * ( + torch.xlogy( + adj_matrix * weights, + (1.0 - rho_global) * (1.0 - kappa_global) * mat + + (1.0 - rho_global) * kappa_global, + ) + ).sum() + ) + term3 = ( + -1.0 + * ( + torch.xlogy( + adj_matrix_1m, + (1.0 - kappa_global) * (1.0 - rho_global) * (1.0 - mat) + + rho_global, + ) + ).sum() + ) + term2_dict["global"] = term2 + term3_dict["global"] = term3 + + loss = loss + term2 + term3 + + if forward: + return term1_dict, recon_dict + # returns loss, recon, graph likelihoods, and autocorr + return loss, term1_dict, term2_dict, term3_dict, term4_dict + + def loss_no_cell_types(self, X, loss_weights, D=None, forward=False): + assert not self.use_cell_types # if this is True, just fail + X = X.to(self.device) + D = D.to(self.device) + loss_weights = loss_weights.to(self.device) + + theta = torch.softmax(self.theta, dim=1) + eta = self.eta.exp() / (1.0 + (self.eta).exp()) + eta = 0.5 * (eta + eta.T) + gene_scaling = self.gene_scaling.exp() / (1.0 + self.gene_scaling.exp()) + kappa = self.kappa.exp() / (1 + self.kappa.exp()) + rho = (self.rho.exp() / (1 + self.rho.exp())).to(self.device) + alpha = torch.exp(self.alpha) + + adj_matrix = self.adj_matrix.to(self.device) + weights = self.weights.to(self.device) + adj_matrix_1m = self.adj_matrix_1m.to(self.device) + theta_ = contract("jk,j->jk", theta, gene_scaling + self.delta) + + p_alpha = D @ alpha + recon = contract("ik,jk->ij", p_alpha, theta_) + term1 = -1.0 * ((torch.xlogy(X, recon) - recon) * loss_weights[:, None]).sum() + + if len(adj_matrix) > 0: + mat = contract("il,lj,kj->ik", theta, eta, theta) + term2 = ( + -1.0 + * ( + torch.xlogy( + adj_matrix * weights, + (1.0 - rho) * (1.0 - kappa) * mat + (1.0 - rho) * kappa, + ) + ).sum() + ) + term3 = ( + -1.0 + * ( + torch.xlogy( + adj_matrix_1m, (1.0 - kappa) * (1.0 - rho) * (1.0 - mat) + rho + ) + ).sum() + ) + if D.shape[0] > 0: + # remove ctrl or pert not present + rm_indices = [] + for i, x in enumerate(self.pert_idx): + if x == -1: + rm_indices.append(i) + alpha_subset_idx = [ + i + for i in range(alpha.shape[0]) + if i not in rm_indices + [self.n_p - 1] + ] + pert_adj_idx = [i for i in self.pert_idx if i != -1] + term4 = ( + -1 + * Spectra_util.geary_autocorrelation_multivariate( + mat[pert_adj_idx][:, pert_adj_idx], alpha[alpha_subset_idx] + )["stat"] + ) + + else: + term2 = 0.0 + term3 = 0.0 + term4 = 0.0 + + loss = self.lam * term1 + term2 + term3 + if forward: + return term1, recon + return loss, term1, term2, term3, term4 + + def initialize(self, gene_sets, val): + """ + form of gene_sets: + + cell_type (inc. global) : set of sets of idxs + """ + + for ct in self.cell_types: + assert self.L[ct] >= len(gene_sets[ct]) + count = 0 + if self.L[ct] > 0: + if len(self.adj_matrix[ct]) > 0: + for gene_set in gene_sets[ct]: + self.theta[ct].data[:, count][gene_set] = val + count = count + 1 + for i in range(self.L[ct]): + self.eta[ct].data[i, -1] = -val + self.eta[ct].data[-1, i] = -val + self.theta[ct].data[:, -1][self.adj_matrix[ct].sum(axis=1) == 0] = ( + val + ) + self.theta[ct].data[:, -1][ + self.adj_matrix[ct].sum(axis=1) != 0 + ] = -val + + assert self.L["global"] >= len(gene_sets["global"]) + count = 0 + for gene_set in gene_sets["global"]: + self.theta["global"].data[:, count][gene_set] = val + count = count + 1 + for i in range(self.L["global"]): + self.eta["global"].data[i, -1] = -val + self.eta["global"].data[-1, i] = -val + self.theta["global"].data[:, -1][self.adj_matrix["global"].sum(axis=1) == 0] = ( + val + ) + self.theta["global"].data[:, -1][ + self.adj_matrix["global"].sum(axis=1) != 0 + ] = -val + + def initialize_no_geneset(self, gene_sets, val): + for ct in self.cell_types: + torch.nn.init.xavier_uniform_(self.theta[ct]) + torch.nn.init.xavier_uniform_(self.eta[ct]) + torch.nn.init.xavier_uniform_(self.theta["global"]) + torch.nn.init.xavier_uniform_(self.eta["global"]) + + def initialize_no_celltypes(self, gs_list, val): + assert self.L >= len(gs_list) + count = 0 + for gene_set in gs_list: + self.theta.data[:, count][gene_set] = val + count = count + 1 + for i in range(self.L): + self.eta.data[i, -1] = -val + self.eta.data[-1, i] = -val + self.theta.data[:, -1][self.adj_matrix.sum(axis=1) == 0] = val + self.theta.data[:, -1][self.adj_matrix.sum(axis=1) != 0] = -val + + def initialize_no_celltypes_no_geneset(self, gs_list, val): + torch.nn.init.xavier_uniform_(self.theta) + torch.nn.init.xavier_uniform_(self.eta) + + +class SPECTRA_Model: + """ + + Parameters + ---------- + X : np.ndarray or torch.Tensor + the ``(n, p)`` -shaped matrix containing logged expression count data. Used + for initialization + of self.n and self.p but not stored as an attribute + labels : np.ndarray or NoneType + the ``(n, )`` -shaped array containing cell type labels. If use_cell_types + == False, then + should be set to None + + L : dict or OrderedDict [if use_cell_types == False, then int] + ``number of cell types + 1``-shaped dictionary. Must have "global" as a key + , indicating the + number of global factors + { + "global": 15, + "CD8": 5 + ... + } + > Format matches output of K_est.py to estimate the number of + > Must match cell type labels provided during training + > Recommended practice is to assign at minimum 2 factors per cell type + > L contains the number of factors that describe the graph. + adj_matrix : dict or OrderedDict + ``a dictionary of adjacency matrices, one for every cell type + a "global" + { + "global": ``(p, p)``-shaped binary np.ndarray + "CD8": ... + + } + weights : dict or OrderedDict or NoneType [if use_cell_types == False, then + ``(p, p)``-shaped array] + the ``(p, p)``-shaped set of edge weights per . If weight[i,j] is + non-zero when adj_matrix[i,j] + = 0 this weight is ignored. + + if weights == None, no weights are used + lam : float + lambda parameter of the model, which controls the relative influence + of the graph vs expression + loss functions. This term multiplies the expression loss, so smaller + values of lambda upweight + the prior information + delta : float + delta parameter of the model, which controls a lower bound for gene + scaling factors. If delta + is small then the maximum ratio between gene scaling factors is + larger and lowly expressed + genes can be put on the same scale as highly expressed genes. + kappa : float or NoneType + kappa controls the background rate of edges in the graph. if kappa + is a float, kappa is fixed + to the given float value. If kappa == None, then kappa is a parameter + that is estimated from + the data. + rho : float or NoneType + rho controls the bakcground rate of non-edges in the graph. if rho + is a float, rho is fixed + to the given float value. If rho == None, then rho is a parameter + that is estimated from the + data. + use_cell_types: bool + use_cell_types is a Boolean variable that determines whether cell + type labels are used to + fit the model. If False, then parameters are initialized as + nn.Parameter rather than as + nn.ParameterDict with cell type keys that index nn.Parameter values + determinant_penalty : float + determinant penalty affects the selection parameters that are fit + when L[cell_type] > + K[cell_type]. A determinantally regularized selection parameter + is fit with determinant + penalty that encourages sparsity and diversity. + Attributes + ---------- + model.delta : delta parameter of the model + + model.lam : lambda parameter of the model + + model.determinant_penalty : determinant penalty of the model + + model.L : L parameter, either int, dict or OrderedDict() + + model.p : number of genes + + model.n : number of cells + + model.use_cell_types : if True then cell types are considered, else cell + types ignored. Affects + the dimensions of the initialized parameters. + + model.kappa : if not kappa, nn.ParameterDict() if use_cell_types, else + nn.Parameter(). If kappa + is a float, it is fixed throughout training + + model.rho : if not rho, nn.ParamterDict() if use_cell_types, else + nn.Parameter. If rho is a float + it is fixed throughout training + + model.adj_matrix : adjacency matrix with diagonal removed. dict + containing torch.Tensors + + model.adj_matrix_1m : 1 - adjacency matrix with diagonal removed. + dict containing torch.Tensors + + model.weights : contains edge weights. format matches adj_matrix + + model.cell_types : np.ndarray containing array of unique cell types + + model.cell_type_counts : dict {key = cell type, values = number of + cells} + + model.factors : nn.ParameterDict() or nn.Parameter() containing the + factor weights + + model.cell_scores : nn.ParameterDict() or nn.Parameter() containing + the cell loadings + + model.eta : nn.ParameterDict() or nn.Parameter() containing the + interaction matrix between + factors + + model.gene_scaling : nn.ParameterDict() or nn.Parameter() containing + the gene scale factors + + model.selection : nn.ParameterDict() or nn.Parameter() containing + the attention weights. + Only initialized when L[cell_type] > K[cell_type] for some cell + type or when L > K and + use_cell_types == False + + + + Methods + ---------- + + model.train(self, X, labels, lr_schedule,num_epochs, verbose) : + model.save() + model.load() + model.initialize + model.return_selection() + model.return_eta_diag() + model.return_cell_scores() + model.return_factors() + model.return_eta() + model.return_rho() + model.return_kappa() + model.return_gene_scalings() + model.return_graph(ct = "global") : + model.matching(markers, gene_names_dict, threshold = 0.4): + + """ + + def __init__( + self, + X, + labels, + L, + pert_idx, + pert_labels, + vocab=None, + gs_dict=None, + use_weights=True, + adj_matrix=None, + weights=None, + lam=0.01, + psi=0.01, + delta=0.001, + kappa=None, + rho=0.001, + use_cell_types=True, + ): + self.L = L + self.lam = lam + self.delta = delta + self.kappa = kappa + self.rho = rho + self.use_cell_types = use_cell_types + + # if gs_dict is provided instead of adj_matrix, convert to adj_matrix, overrides + # adj_matrix and weights + if gs_dict is not None: + gene2id = dict((v, idx) for idx, v in enumerate(vocab)) + + if use_cell_types: + adj_matrix, weights = Spectra_util.process_gene_sets( + gs_dict=gs_dict, gene2id=gene2id, weighted=use_weights + ) + else: + adj_matrix, weights = Spectra_util.process_gene_sets_no_celltypes( + gs_dict=gs_dict, gene2id=gene2id, weighted=use_weights + ) + + self.internal_model = SPECTRA( + X=X, + labels=labels, + pert_idx=pert_idx, + pert_labels=pert_labels, + adj_matrix=adj_matrix, + L=L, + weights=weights, + lam=lam, + psi=psi, + delta=delta, + kappa=kappa, + rho=rho, + use_cell_types=use_cell_types, + ) + + self.cell_scores = None + self.factors = None + self.B_diag = None + self.eta_matrices = None + self.gene_scalings = None + self.rho = None + self.kappa = None + + def train( + self, + X, + D, + loss_weights, + X_val, + D_val, + loss_weights_val, + labels=None, + labels_val=None, + lr_schedule=[1.0, 0.5, 0.1, 0.01, 0.001, 0.0001], + num_epochs=10000, + verbose=True, + ): + opt = torch.optim.AdamW( + self.internal_model.parameters(), lr=lr_schedule[0], weight_decay=0.001 + ) + counter = 0 + last = np.inf + train_losses = [] + val_losses = [] + + # batch if too large + X = torch.from_numpy(X) + D = torch.from_numpy(D) + X_val = torch.from_numpy(X_val) + D_val = torch.from_numpy(D_val) + loss_weights = torch.from_numpy(loss_weights) + loss_weights_val = torch.from_numpy(loss_weights_val) + if X.shape[0] > 2e5: + train_dataset = TensorDataset(X, D, loss_weights) + val_dataset = TensorDataset(X_val, D_val, loss_weights_val) + train_dataloader = DataLoader( + train_dataset, batch_size=int(5e4), num_workers=4, shuffle=True + ) + val_dataloader = DataLoader( + val_dataset, batch_size=int(5e4), num_workers=4, shuffle=False + ) + else: + train_dataloader = None + val_dataloader = None + + # train loop + for i in tqdm(range(num_epochs)): + train_epoch_loss = 0 + val_epoch_loss = 0 + # batch if data too large + if train_dataloader: + # train + for batch in train_dataloader: + X_batch = batch[0] + D_batch = batch[1] + loss_weights_batch = batch[2] + opt.zero_grad() + if self.internal_model.use_cell_types: + assert len(labels) == X.shape[0] + loss, term1_dict, term2_dict, term3_dict, term4_dict = ( + self.internal_model.loss( + X=X_batch, + D=D_batch, + loss_weights=loss_weights_batch, + labels=labels, + ) + ) + elif not self.internal_model.use_cell_types: + loss, term1, term2, term3, term4 = ( + self.internal_model.loss_no_cell_types( + X=X_batch, D=D_batch, loss_weights=loss_weights_batch + ) + ) + + loss.backward() + opt.step() + train_epoch_loss += loss.item() + train_epoch_loss = train_epoch_loss / len(train_dataloader) + + # val + with torch.no_grad(): + for batch in val_dataloader: + X_batch = batch[0] + D_batch = batch[1] + loss_weights_batch = batch[2] + if self.internal_model.use_cell_types: + assert len(labels) == X.shape[0] + loss, term1_dict, term2_dict, term3_dict, term4_dict = ( + self.internal_model.loss( + X=X_batch, + D=D_batch, + loss_weights=loss_weights_batch, + labels=labels, + ) + ) + elif not self.internal_model.use_cell_types: + loss, term1, term2, term3, term4 = ( + self.internal_model.loss_no_cell_types( + X=X_batch, + D=D_batch, + loss_weights=loss_weights_batch, + ) + ) + val_epoch_loss += loss.item() + val_epoch_loss = val_epoch_loss / len(val_dataloader) + else: + # train + opt.zero_grad() + if self.internal_model.use_cell_types: + assert len(labels) == X.shape[0] + loss, term1_dict, term2_dict, term3_dict, term4_dict = ( + self.internal_model.loss( + X=X, D=D, loss_weights=loss_weights, labels=labels + ) + ) + elif not self.internal_model.use_cell_types: + loss, term1, term2, term3, term4 = ( + self.internal_model.loss_no_cell_types( + X=X, D=D, loss_weights=loss_weights + ) + ) + loss.backward() + opt.step() + train_epoch_loss = loss.item() + + # val + with torch.no_grad(): + if self.internal_model.use_cell_types: + assert len(labels_val) == X_val.shape[0] + loss, term1_dict, term2_dict, term3_dict, term4_dict = ( + self.internal_model.loss( + X=X_val, + D=D_val, + loss_weights=loss_weights_val, + labels=labels_val, + ) + ) + elif not self.internal_model.use_cell_types: + loss, term1, term2, term3, term4 = ( + self.internal_model.loss_no_cell_types( + X=X_val, D=D_val, loss_weights=loss_weights_val + ) + ) + val_epoch_loss = loss.item() + + # lr adjustment + if train_epoch_loss >= last: + counter += 1 + if int(counter / 10) >= len(lr_schedule): + print("EARLY STOPPING") + break + if counter % 10 == 0: + opt = torch.optim.AdamW( + self.internal_model.parameters(), + lr=lr_schedule[int(counter / 10)], + ) + if verbose: + print("UPDATING LR TO " + str(lr_schedule[int(counter / 10)])) + + last = train_epoch_loss + train_losses.append(train_epoch_loss) + val_losses.append(val_epoch_loss) + + # add all model parameters as attributes + + if self.use_cell_types: + self.__store_parameters(labels) + else: + self.__store_parameters_no_celltypes() + return train_losses, val_losses + + def save(self, fp): + torch.save(self.internal_model.state_dict(), fp) + + def load(self, fp, labels=None): + self.internal_model.load_state_dict(torch.load(fp)) + if self.use_cell_types: + assert labels is not None + self.__store_parameters(labels) + else: + self.__store_parameters_no_celltypes() + + def __store_parameters(self, labels): + """ + Replaces __cell_scores() and __compute factors() and __compute_theta() + store parameters after fitting the model: + cell scores + factors + eta + scalings + gene scalings + kappa + rho + """ + + model = self.internal_model + + # compute the loading matrix + + k = sum(list(model.L.values())) + out = np.zeros((model.n_p, k)) + + global_idx = model.L["global"] + + tot = global_idx + f = ["global"] * model.L["global"] + for i, cell_type in enumerate(model.cell_types): + alpha = torch.exp(model.alpha[cell_type]).detach().cpu().numpy() + out[:, :global_idx] = alpha[:, :global_idx] + out[:, tot : tot + model.L[cell_type]] = alpha[:, global_idx:] + + tot += model.L[cell_type] + + f = f + [cell_type] * model.L[cell_type] + + out2 = np.zeros((k, model.p)) + + theta_ct = torch.softmax(model.theta["global"], dim=1) + theta = theta_ct.detach().cpu().numpy().T + tot = 0 + out2[0 : theta.shape[0], :] = theta + tot += theta.shape[0] + + for cell_type in model.cell_types: + theta_ct = torch.softmax(model.theta[cell_type], dim=1) + theta = theta_ct.detach().cpu().numpy().T + out2[tot : tot + theta.shape[0], :] = theta + tot += theta.shape[0] + + factors = out2 + lst = [] + for i in range(len(f)): + ct = f[i] + scaled = ( + factors[i, :] + * ( + model.gene_scaling[ct].exp().detach() + / (1.0 + model.gene_scaling[ct].exp().detach()) + + model.delta + ) + .cpu() + .numpy() + ) + + lst.append(scaled) + scaled = np.array(lst) + new_factors = scaled / (scaled.sum(axis=0, keepdims=True) + 1.0) + cell_scores = out * scaled.mean(axis=1).reshape(1, -1) + self.cell_scores = cell_scores + self.factors = new_factors + self.B_diag = self.__B_diag() + self.eta_matrices = self.__eta_matrices() + self.gene_scalings = { + ct: model.gene_scaling[ct].exp().detach().cpu().numpy() + / (1.0 + model.gene_scaling[ct].exp().cpu().detach().numpy()) + for ct in model.gene_scaling.keys() + } + self.rho = { + ct: model.rho[ct].exp().detach().cpu().numpy() + / (1.0 + model.rho[ct].exp().detach().cpu().numpy()) + for ct in model.rho.keys() + } + self.kappa = { + ct: model.kappa[ct].exp().detach().cpu().numpy() + / (1.0 + model.kappa[ct].exp().detach().cpu().numpy()) + for ct in model.kappa.keys() + } + + def __B_diag(self): + model = self.internal_model + k = sum(list(model.L.values())) + out = np.zeros(k) + + Bg = model.eta["global"].exp() / (1.0 + model.eta["global"].exp()) + Bg = 0.5 * (Bg + Bg.T) + B = torch.diag(Bg).detach().cpu().numpy() + tot = 0 + out[0 : B.shape[0]] = B + tot += B.shape[0] + + for cell_type in model.cell_types: + Bg = model.eta[cell_type].exp() / (1.0 + model.eta[cell_type].exp()) + Bg = 0.5 * (Bg + Bg.T) + B = torch.diag(Bg).detach().cpu().numpy() + out[tot : tot + B.shape[0]] = B + + tot += B.shape[0] + + return out + + def __eta_matrices(self): + model = self.internal_model + eta = OrderedDict() + Bg = model.eta["global"].exp() / (1.0 + model.eta["global"].exp()) + Bg = 0.5 * (Bg + Bg.T) + eta["global"] = Bg.detach().cpu().numpy() + + for cell_type in model.cell_types: + Bg = model.eta[cell_type].exp() / (1.0 + model.eta[cell_type].exp()) + Bg = 0.5 * (Bg + Bg.T) + eta[cell_type] = Bg.detach().cpu().numpy() + return eta + + def __store_parameters_no_celltypes(self): + """ + store parameters after fitting the model: + cell scores + factors + eta + scalings + gene scalings + kappa + rho + """ + model = self.internal_model + theta_ct = torch.softmax(model.theta, dim=1) + theta = theta_ct.detach().cpu().numpy().T + alpha = torch.exp(model.alpha).detach().cpu().numpy() + out = alpha + factors = theta + + scaled = factors * ( + model.gene_scaling.exp().detach().cpu() + / (1.0 + model.gene_scaling.exp().detach().cpu()) + + model.delta + ).numpy().reshape(1, -1) + new_factors = scaled / (scaled.sum(axis=0, keepdims=True) + 1.0) + + self.factors = new_factors + self.cell_scores = out * scaled.mean(axis=1).reshape(1, -1) + Bg = model.eta.exp() / (1.0 + model.eta.exp()) + Bg = 0.5 * (Bg + Bg.T) + self.B_diag = torch.diag(Bg).detach().cpu().numpy() + self.eta_matrices = Bg.detach().cpu().numpy() + self.gene_scalings = ( + model.gene_scaling.exp().detach().cpu() + / (1.0 + model.gene_scaling.exp().detach().cpu()) + ).numpy() + self.rho = ( + (model.rho.exp().detach() / (1.0 + model.rho.exp().detach())).cpu().numpy() + ) + self.kappa = ( + (model.kappa.exp().detach() / (1.0 + model.kappa.exp().detach())) + .cpu() + .numpy() + ) + + def initialize(self, annotations, word2id, W, init_scores, val=25): + """ + self.use_cell_types must be True + create form of gene_sets: + + cell_type (inc. global) : set of sets of idxs + + filter based on L_ct + """ + if self.use_cell_types: + if annotations: + if init_scores is None: + init_scores = compute_init_scores( + annotations, word2id, torch.Tensor(W) + ) # noqa + gs_dict = OrderedDict() + for ct in annotations.keys(): + mval = max(self.L[ct] - 1, 0) + sorted_init_scores = sorted( + init_scores[ct].items(), key=lambda x: x[1] + ) + sorted_init_scores = sorted_init_scores[-1 * mval :] + names = set([k[0] for k in sorted_init_scores]) + lst_ct = [] + for key in annotations[ct].keys(): + if key in names: + words = annotations[ct][key] + idxs = [] + for word in words: + if word in word2id: + idxs.append(word2id[word]) + lst_ct.append(idxs) + gs_dict[ct] = lst_ct + self.internal_model.initialize(gene_sets=gs_dict, val=val) + else: + self.internal_model.initialize_no_geneset(gene_sets=[], val=val) + else: + if annotations: + if init_scores is None: + init_scores = compute_init_scores_noct( + annotations, word2id, torch.Tensor(W) + ) # noqa + lst = [] + mval = max(self.L - 1, 0) + sorted_init_scores = sorted(init_scores.items(), key=lambda x: x[1]) + sorted_init_scores = sorted_init_scores[-1 * mval :] + names = set([k[0] for k in sorted_init_scores]) + for key in annotations.keys(): + if key in names: + words = annotations[key] + idxs = [] + for word in words: + if word in word2id: + idxs.append(word2id[word]) + lst.append(idxs) + self.internal_model.initialize_no_celltypes(gs_list=lst, val=val) + else: + self.internal_model.initialize_no_celltypes_no_geneset( + gs_list=[], val=val + ) + + def return_eta_diag(self): + return self.B_diag + + def return_cell_scores(self): + return self.cell_scores + + def return_factors(self): + return self.factors + + def return_eta(self): + return self.eta_matrices + + def return_rho(self): + return self.rho + + def return_kappa(self): + return self.kappa + + def return_gene_scalings(self): + return self.gene_scalings + + def return_graph(self, ct="global"): + model = self.internal_model + if self.use_cell_types: + eta = (model.eta[ct]).exp() / (1.0 + (model.eta[ct]).exp()) + eta = 0.5 * (eta + eta.T) + theta = torch.softmax(model.theta[ct].data, dim=1) + mat = contract("il,lj,kj->ik", theta, eta, theta).detach().cpu().numpy() + else: + eta = model.eta.exp() / (1.0 + model.eta.exp()) + eta = 0.5 * (eta + eta.T) + theta = torch.softmax(model.theta, dim=1) + mat = contract("il,lj,kj->ik", theta, eta, theta).detach().cpu().numpy() + + return mat + + def matching(self, markers, gene_names_dict, threshold=0.4): + """ + best match based on overlap coefficient + """ + markers = pd.DataFrame(markers) + if self.use_cell_types: + matches = [] + jaccards = [] + for i in range(markers.shape[0]): + max_jacc = 0.0 + best = "" + for key in gene_names_dict.keys(): + for gs in gene_names_dict[key].keys(): + t = gene_names_dict[key][gs] + + jacc = Spectra_util.overlap_coefficient( + list(markers.iloc[i, :]), t + ) + if jacc > max_jacc: + max_jacc = jacc + best = gs + matches.append(best) + jaccards.append(max_jacc) + + else: + matches = [] + jaccards = [] + for i in range(markers.shape[0]): + max_jacc = 0.0 + best = "" + for key in gene_names_dict.keys(): + t = gene_names_dict[key] + + jacc = Spectra_util.overlap_coefficient(list(markers.iloc[i, :]), t) + if jacc > max_jacc: + max_jacc = jacc + best = key + matches.append(best) + jaccards.append(max_jacc) + output = [] + for j in range(markers.shape[0]): + if jaccards[j] > threshold: + output.append(matches[j]) + else: + output.append("0") + return np.array(output) + + +def return_markers(factor_matrix, id2word, n_top_vals=100): + idx_matrix = np.argsort(factor_matrix, axis=1)[:, ::-1][:, :n_top_vals] + df = pd.DataFrame(np.zeros(idx_matrix.shape)) + for i in range(idx_matrix.shape[0]): + for j in range(idx_matrix.shape[1]): + df.iloc[i, j] = id2word[idx_matrix[i, j]] + return df.values + + +def vectorize_perts(adata, key, control_key): + """ + Vectorizing perturbation labels + + Returns: matrix of perturbation labels as vectors, labels for each column + """ + # create guide one hots (for encoding combos as superpositions) + perts = set() + for t in adata.obs[key]: + if t not in control_key: + guides = t.split("+") + guide1 = guides[0] + guide2 = None + if len(guides) == 2: + guide2 = guides[1] + perts.add(guide1) + if guide2: + perts.add(guide2) + for p in perts: + guides_p = [] + for t in adata.obs[key]: + if t == control_key: + guides_p.append(0) + else: + if p in t: + guides_p.append(1) + else: + guides_p.append(0) + adata.obs[f"guide_{p}"] = np.array(guides_p) + + guide_one_hot_cols = get_guide_one_hot_cols(adata.obs) + adata.obs["num_guides"] = adata.obs[guide_one_hot_cols].sum(1) + # combinations encoded as application of two individual guides + D = adata.obs[guide_one_hot_cols].to_numpy().astype(np.float32) + + return D, guide_one_hot_cols + + +def vectorize_perts_combinations(adata, key, control_key): + """ + Vectorizing perturbation labels, with combinations considered a unique perturbation + + Returns: matrix of perturbation labels as vectors, labels for each column + """ + # encode combinations as unique + D_df = pd.get_dummies(adata.obs[key]) + D_df = D_df.drop(columns=control_key) + # encode non-targeting as no perturbation for consistency with other encoding + d_var_info = np.array(D_df.T[[]].index) + + # get singletons-only binarization + for index, row in D_df.iterrows(): + pert_idx = np.where(row)[0] + if len(pert_idx) > 0: + pert_label = d_var_info[pert_idx][0].split("+") + single_idx = [list(d_var_info).index(i) for i in pert_label] + for i in single_idx: + row.iloc[i] = 1 + + return D_df.to_numpy().astype(np.float32), list(d_var_info) + + +def get_guide_one_hot_cols(obs: pd.DataFrame): + guide_one_hot_cols = [ + col + for col in obs.columns + if "guide_" in col and col not in ("guide_identity", "guide_ids") + ] + return guide_one_hot_cols diff --git a/src/Spectra/Spectra_util.py b/src/Spectra/Spectra_util.py new file mode 100644 index 0000000..2396cd6 --- /dev/null +++ b/src/Spectra/Spectra_util.py @@ -0,0 +1,433 @@ +### graph functions #### +from collections import OrderedDict + +import numpy as np +import pandas as pd +import scipy +import torch + +# from adjustText import adjust_text + + +def _compute_geary(L: torch.Tensor, Z: torch.Tensor): + """Compute Geary's C multivariate autocorrelation. + + Parameters + ---------- + L : np.ndarray + Graph Laplacian. + Z : np.ndarray + Feature matrix. + Returns + ------- + np.ndarray + Geary's C values. + """ + c = torch.linalg.multi_dot([Z.T, L, Z]).diagonal() + + return c + + +def geary_autocorrelation_multivariate( + G: torch.Tensor, + X: torch.Tensor, + max_z: int = 100, +): + """Compute Geary's C multivariate autocorrelation. + + Parameters + ---------- + G : torch.Tensor + Graph or adjacency matrix. + X : torch.Tensor + Feature matrix. + max_z : int + Maximum value for z score, by default 100 + + Returns + ------- + pd.Series + Geary's C values. + """ + + n, p = X.shape + d = torch.sum(G, dim=0) + D = torch.diag(d) + L = D - G + + Z = (X - X.mean(dim=0)) / X.std(dim=0) + Z = Z.nan_to_num() + + c_unnormalized = _compute_geary(L, Z) + c_normalized = c_unnormalized / d.sum() # per annotation + + out_dict = { + "stat": c_normalized.sum(), + "pval": 1, + "z": 0, + "stat_annotation": c_normalized, + } + + return out_dict + + +""" +methods +_______ + +amatrix(gene_set_list, gene2id) + +amatrix_weighted(gene_set_list, gene2id) + +unravel_dict(dict_) + +process_gene_sets() + +process_gene_sets_no_celltypes() + +overlap_coefficient() + +label_marker_genes() + + +""" + + +def overlap_coefficient(list1, list2): + """ + Computes overlap coefficient between two lists + """ + intersection = len(list(set(list1).intersection(set(list2)))) + union = min(len(list1), len(list2)) # + len(list2)) - intersection + return float(intersection) / union + + +def check_gene_set_dictionary( + adata, + annotations, + obs_key="cell_type_annotations", + global_key="global", + return_dict=True, + min_len=3, + use_cell_types=True, +): + """ + Filters annotations dictionary to contain only genes contained in the + adata. + Checks that annotations dictionary cell type keys and adata cell types + are identical. + Checks that all gene sets in annotations dictionary contain >2 genes + after filtering. + + + adata: AnnData , data to use with Spectra + annotations: dict , gene set annotations dictionary to use with Spectra + obs_key: str , column name for cell type annotations in adata.obs + global_key: str , key for global gene sests in gene set annotation + dictionary + return_dict: bool , return filtered gene set annotation dictionary + min_len: int, minimum length of gene sets + + returns: dict , filtered gene set annotation dictionary + + """ + # test if keys match + if use_cell_types: + adata_labels = list(set(adata.obs[obs_key])) + [ + global_key + ] # cell type labels in adata object + else: + annotations = {global_key: annotations} + adata_labels = [global_key] + annotation_labels = list(annotations.keys()) + # matching_celltype_labels = list(set(adata_labels).intersection(annotation_labels)) + if set(annotation_labels) != set(adata_labels): + missing_adata = set(adata_labels) - set(annotation_labels) + missing_dict = set(annotation_labels) - set(adata_labels) + raise ValueError( + "The following adata labels are missing in the gene set \ + annotation dictionary:", + missing_dict, + "The following gene set annotation dictionary keys are \ + missing in the adata labels:", + missing_adata, + ) + dict_keys_OK = False + else: + print( + "Cell type labels in gene set annotation dictionary and \ + AnnData object are identical" + ) + dict_keys_OK = True + + # check that gene sets in dictionary have len >2 + annotations_new = {} + for k, v in annotations.items(): + annotations_new[k] = {} + for k2, v2 in v.items(): + gs = [x for x in v2 if x in adata.var_names] + if len(gs) < min_len: + print( + "removing gene set", + k2, + "for cell type", + k, + "which is of length", + len(v2), + len(gs), + "genes are found in the data.", + "minimum length is", + min_len, + ) + else: + annotations_new[k][k2] = gs + + # raise error if no gene sets remain + if not use_cell_types and len(annotations_new[global_key]) == 0: + raise ValueError( + "No gene sets remain in the gene set annotation dictionary. \ + Please make sure that gene names correspond to names found \ + in `adata.var_names`. See: https://github.com/dpeerlab/spectra/issues/34." + ) + + if dict_keys_OK: + print("Your gene set annotation dictionary is now correctly formatted.") + if return_dict: + if not use_cell_types: + return annotations_new[global_key] + else: + return annotations_new + + +def label_marker_genes(marker_genes, gs_dict, threshold=0.4): + """ + label an array of marker genes using the gene_set_dictionary in est_spectra + returns a dataframe of overlap coefficients for each gene set annotation + and marker gene + marker_genes: array factors x marker genes or a KnowledgeBase object + label an array containing marker genes by its overlap with a dictionary of + gene sets from the knowledge base: + KnowledgeBase.celltype_process_dict + """ + + overlap_df = pd.DataFrame() + marker_set_len_dict = {} # len of gene sets to resolve ties + for i, v in pd.DataFrame(marker_genes).T.items(): + overlap_temp = [] + gs_names_temp = [] + + for gs_name, gs in gs_dict.items(): + marker_set_len_dict[gs_name] = len(gs) + overlap_temp.append(overlap_coefficient(set(gs), set(v))) + gs_names_temp.append(gs_name) + overlap_df_temp = pd.DataFrame(overlap_temp, columns=[i], index=gs_names_temp).T + overlap_df = pd.concat([overlap_df, overlap_df_temp]) + overlap_df.loc["gene_set_length"] = list( + overlap_df.columns.map(marker_set_len_dict) + ) + + # find maximum overlap coefficient gene set label for each factor, resolve + # ties by gene set length + marker_gene_labels = [] # gene sets + + marker_gene_list = list(overlap_df.index) + marker_gene_list.remove("gene_set_length") + for marker_set in marker_gene_list: + # resolve ties in overlap_coefficient by selecting the bigger gene set + max_overlap = ( + overlap_df.loc[[marker_set, "gene_set_length"]] + .T.sort_values(by="gene_set_length", ascending=True) + .sort_values(by=marker_set, ascending=True)[marker_set] + .index[-1] + ) + + if overlap_df.loc[marker_set].sort_values().values[-1] > threshold: + marker_gene_labels.append(max_overlap) + else: + marker_gene_labels.append(marker_set) + overlap_df = overlap_df.drop(index="gene_set_length") + overlap_df.index = marker_gene_labels + return overlap_df + + +def amatrix(gene_set_list, gene2id): + """ + creates adjacency matrix from gene set list + """ + n = len(gene2id) + adj_matrix = np.zeros((n, n)) + for gene_set in gene_set_list: + for i in range(len(gene_set)): + for j in range(len(gene_set)): + g1 = gene_set[i] + g2 = gene_set[j] + if (g1 in gene2id) & (g2 in gene2id): + adj_matrix[gene2id[g1], gene2id[g2]] = 1 + return adj_matrix + + +def amatrix_weighted(gene_set_list, gene2id): + """ + Creates weighted adjacency matrix from gene sets + uses 1/{n choose 2} as edge weights - edge weights accumulate additively + """ + n = len(gene2id) + adj_matrix = np.zeros((n, n)) + ws = [] + for gene_set in gene_set_list: + if len(gene_set) > 1: + w = 1.0 / (len(gene_set) * (len(gene_set) - 1) / 2.0) + else: + w = 1.0 + ws.append(w) + for i in range(len(gene_set)): + for j in range(len(gene_set)): + g1 = gene_set[i] + g2 = gene_set[j] + if (g1 in gene2id) & (g2 in gene2id): + adj_matrix[gene2id[g1], gene2id[g2]] += w + med = np.median(np.array(ws)) + return adj_matrix / float(med) + + +def unravel_dict(dict_): + lst = [] + for key in dict_.keys(): + lst.append(dict_[key]) + return lst + + +def process_gene_sets(gs_dict, gene2id, weighted=True): + """ + { "global": {"": [, , ...]} + } + """ + adict = OrderedDict() + adict["global"] = amatrix(unravel_dict(gs_dict["global"]), gene2id) + weights = None + + if weighted: + weights = OrderedDict() + weights["global"] = amatrix_weighted(unravel_dict(gs_dict["global"]), gene2id) + + for key in gs_dict.keys(): + if len(gs_dict[key]) > 0: + adict[key] = amatrix(unravel_dict(gs_dict[key]), gene2id) + if weighted: + weights[key] = amatrix_weighted(unravel_dict(gs_dict[key]), gene2id) + else: + adict[key] = [] + if weighted: + weights[key] = [] + + return adict, weights + + +def process_gene_sets_no_celltypes(gs_dict, gene2id, weighted=True): + """ + input: {"": [, , ...]} + } + gene2id {gene name: index in vocab} + + weighted: whether to return NoneType or weighted adjacency matrix + """ + adict = amatrix(unravel_dict(gs_dict), gene2id) + weights = None + if weighted: + weights = amatrix_weighted(unravel_dict(gs_dict), gene2id) + return adict, weights + + +def get_factor_celltypes(adata, obs_key, cellscore_obsm_key="SPECTRA_cell_scores"): + """ + Assigns Spectra factors to cell types by analyzing the factor cell scores. + Cell type specific factors will have zero cell scores except in their respective cell type + + adata: AnnData , object containing the Spectra output + obs_key: str , column name in adata.obs containing the cell type annotations + cellscore_obsm_key: str , key for adata.obsm containing the Spectra cell scores + + returns: dict , dictionary of {factor index : 'cell type'} + """ + + # get cellscores + import pandas as pd + + cell_scores_df = pd.DataFrame(adata.obsm[cellscore_obsm_key]) + cell_scores_df["celltype"] = list(adata.obs[obs_key]) + + # find global and cell type specific fators + global_factors_series = (cell_scores_df.groupby("celltype").mean() != 0).all() + global_factors = [ + factor + for factor in global_factors_series.index + if global_factors_series[factor] + ] + specific_cell_scores = ( + (cell_scores_df.groupby("celltype").mean()).T[~global_factors_series].T + ) + specific_factors = {} + + for i in set(cell_scores_df["celltype"]): + specific_factors[i] = [ + factor + for factor in specific_cell_scores.loc[i].index + if specific_cell_scores.loc[i, factor] + ] + + # inverse dict factor:celltype + factors_inv = {} + for i, v in specific_factors.items(): + for factor in v: + factors_inv[factor] = i + + # add global + + for factor in global_factors: + factors_inv[factor] = "global" + + return factors_inv + + +## importance and information score functions + + +def mimno_coherence_single(w1, w2, W): + # eps = 0.01 + dw1 = W[:, w1] > 0 + dw2 = W[:, w2] > 0 + # N = W.shape[0] + + dw1w2 = (dw1 & dw2).float().sum() + dw1 = dw1.float().sum() + dw2 = dw2.float().sum() + if (dw1 == 0) | (dw2 == 0): + return -0.1 * np.inf + return ((dw1w2 + 1) / (dw2)).log() + + +def mimno_coherence_2011(words, W): + score = 0 + V = len(words) + + for j1 in range(1, V): + for j2 in range(j1): + score += mimno_coherence_single(words[j1], words[j2], W) + denom = V * (V - 1) / 2 + return score / denom + + +def get_information_score(adata, idxs, cell_type): + if "spectra_vocab" not in adata.var.columns: + print("adata requires spectra_vocab attribute.") + return None + + idx_to_use = adata.var["spectra_vocab"] + X = adata.X[:, idx_to_use] + if X is scipy.sparse.csr.csr_matrix: + X = np.array(X.todense()) + X = torch.Tensor(X) + lst = [] + # for j in range(idxs.shape[0]): + # lst.append(mimno_coherence_2011(list(idxs[j,:]), X[labels == cell_type])) + return lst diff --git a/src/Spectra/__init__.py b/src/Spectra/__init__.py new file mode 100644 index 0000000..9f039d6 --- /dev/null +++ b/src/Spectra/__init__.py @@ -0,0 +1,13 @@ +# + +# from .load import default_gene_sets, sample_data +# from .Spectra import ( +# SPECTRA, +# SPECTRA_EM, +# SPECTRA_Model, +# est_spectra, +# gene_set_graph, +# get_factor_celltypes, +# graph_network, +# graph_network_multiple, +# load_from_pickle, +# ) diff --git a/src/Spectra/initialization.py b/src/Spectra/initialization.py new file mode 100644 index 0000000..2a3a206 --- /dev/null +++ b/src/Spectra/initialization.py @@ -0,0 +1,60 @@ +from collections import OrderedDict + + +def mimno_coherence_single(w1, w2, W): + dw1 = W[:, w1] > 0 + dw2 = W[:, w2] > 0 + + dw1w2 = (dw1 & dw2).float().sum() + dw1 = dw1.float().sum() + dw2 = dw2.float().sum() + + return ((dw1w2 + 1) / (dw2)).log() + + +def mimno_coherence_2011(words, W): + score = 0 + V = len(words) + + for j1 in range(1, V): + for j2 in range(j1): + score += mimno_coherence_single(words[j1], words[j2], W) + denom = V * (V - 1) / 2 + return score / denom + + +def compute_init_scores_noct(gs_dict, word2id, W): + init_scores = OrderedDict() + keys = list(gs_dict.keys()) + for key in keys: + gs = gs_dict[key] + idxs = [] + for word in gs: + if word in word2id: + idxs.append(word2id[word]) + # idxs = [word2id[word] for word in gs] + coh = mimno_coherence_2011(idxs, W) + init_scores[key] = coh.item() + return init_scores + + +def compute_init_scores(gs_dict, word2id, W): + keys = list(gs_dict.keys()) + init_scores = OrderedDict() + for key in keys: + if len(gs_dict[key]) > 0: + inner_keys = list(gs_dict[key].keys()) + init_scores[key] = OrderedDict() + for inner_key in inner_keys: + gs = gs_dict[key][inner_key] + idxs = [] + for word in gs: + if word in word2id: + idxs.append(word2id[word]) + # idxs = [word2id[word] for word in gs] + coh = mimno_coherence_2011(idxs, W) + init_scores[key][inner_key] = coh.item() + else: + init_scores[key] = {} + + return init_scores diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..96d58a5 --- /dev/null +++ b/utils.py @@ -0,0 +1,818 @@ +import itertools +import os +import pickle +import random +import re +from typing import Any, List + +import anndata as ad +import boto3 +import botocore +import numpy as np +import pandas as pd +import torch +from gprofiler import GProfiler +from scipy import sparse +from scipy.stats import false_discovery_control, hypergeom +from sklearn.metrics import auc, precision_recall_curve +from sklearn.model_selection import KFold, train_test_split + +SPECTRA_DEFAULT_DIR = os.path.join(os.path.expanduser("~"), "pertspectra_cache") +GSEA_COLUMN_DATATYPES_FOR_SERIALIZATION = { + "Name": "category", + "Term": "category", + "ES": "float32", + "NES": "float32", + "NOM p-val": "float32", + "FDR q-val": "float32", + "FWER p-val": "float32", + "Tag %": "str", + "Gene %": "str", + "Lead_genes": "str", + "gsea_weight": "category", + "pval": "float32", + "fdr_bh": "float32", + "fwer_bf": "float32", + "GO_ID": "category", + "Lead_g_id": "str", +} + + +def read_aws_h5ad(s3_url): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + s3_object.download_file(save_path) + + adata = ad.read_h5ad(save_path) + return adata + + +def read_aws_csv(s3_url, sep=",", zipped=False, header="infer"): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(save_path) + if not zipped: + df = pd.read_csv(save_path, sep=sep, header=header) + else: + df = pd.read_csv( + save_path, compression="gzip", delimiter="\t", header=header + ) + return df + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("object does not exist") + return None + return None + + +def read_aws_npz(s3_url, sep=","): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(save_path) + mtx = np.load(save_path) + return mtx + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("object does not exist") + return None + return None + + +def read_aws_pickle(s3_url, sep=","): + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(save_path) + with open(save_path, "rb") as f: + pickle_obj = pickle.load(f) + return pickle_obj + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("object does not exist") + return None + return None + + +def read_aws_json(s3_url): + import json + + save_path = os.path.join(SPECTRA_DEFAULT_DIR, s3_url.split("/")[-1]) + + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(save_path) + f = open(save_path) + data = json.load(f) + return data + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("object does not exist") + return None + return None + + +def write_model_pickle_to_s3(s3_url, model_name, model): + model_path = f"{model_name}.pickle" + temp_path = os.path.join(SPECTRA_DEFAULT_DIR, model_path) + + os.makedirs(os.path.dirname(temp_path), exist_ok=True) + s3 = boto3.resource("s3") + + with open(temp_path, "wb") as f: + pickle.dump(model, f, pickle.HIGHEST_PROTOCOL) + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + # Specify model version in key + key = key + model_path + # Write model to s3 + s3.Object(bucket_name=bucket_name, key=key).put(Body=open(temp_path, "rb")) + + +def write_adata_to_s3(s3_url, adata_name, adata): + adata_path = f"{adata_name}.h5ad" + temp_path = os.path.join(SPECTRA_DEFAULT_DIR, adata_path) + + os.makedirs(os.path.dirname(temp_path), exist_ok=True) + s3 = boto3.resource("s3") + + adata.write_h5ad(temp_path) + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + # Specify model version in key + key = key + adata_path + # Write model to s3 + s3.Object(bucket_name=bucket_name, key=key).put(Body=open(temp_path, "rb")) + + +def read_model_pickle_from_s3(s3_url, model_name): + model_path = f"{model_name}.pickle" + temp_path = os.path.join(SPECTRA_DEFAULT_DIR, model_path) + + os.makedirs(os.path.dirname(temp_path), exist_ok=True) + s3 = boto3.resource("s3") + + # Get the bucket name and key from the s3 url + bucket_name, key = s3_url.removeprefix("s3://").split("/", 1) + # Specify model version in key + key = key + model_path + + # Read model from s3 + s3_object = s3.Object(bucket_name=bucket_name, key=key) + try: + s3_object.download_file(temp_path) + except botocore.exceptions.ClientError as e: + if e.response["Error"]["Code"] == "404": + print("Model could not be found") + return None + + with open(temp_path, "rb") as f: + model = pickle.load(f) + return model + + +def load_model( + adata, + s3_dir, + experiment_name, + model_name, + use_cell_types=False, + cell_type_key="", +): + """ + Loads trained model + + adata: AnnData, data to store model results + s3_dir: str, directory where the model is stored + experiment_name: str, name of experiment (same as wandb name) + model_name: str, name of model + use_cell_types: bool, boolean if model used cell types + cell_type_key: str, cell type key is use_cell_types==True + + returns: + trained model: SPECTRA_Model instance + anndata with saved parameters: contains the following fields: + - + + """ + # load model from checkpoint + wrapper = read_model_pickle_from_s3(s3_dir + experiment_name, model_name) + + # initialize Spectra wrapper + if use_cell_types: + labels = np.array(adata.obs[cell_type_key]) + wrapper._SPECTRA_Model__store_parameters(labels) + else: + wrapper._SPECTRA_Model__store_parameters_no_celltypes() + + # save parameters + # vocab = adata.var_names + # id2word = dict((idx, v) for idx, v in enumerate(vocab)) + # word2id = dict((v, idx) for idx, v in enumerate(vocab)) + adata.uns["SPECTRA_factors"] = wrapper.factors + adata.uns["SPECTRA_L"] = wrapper.internal_model.L + adata.uns["SPECTRA_pert_scores"] = wrapper.cell_scores + + return wrapper, adata + + +# + +# preprocess perturbations for rna565 - leave intergenics as separate +# reformat guide gene naming conventions: ctrl for control, + delimiting the guides +def replace_ctrl_words(s): + # Define the regex pattern + pattern = r"\bCTRL00\w*\b" + + # Check if the string is 'nan' + if s == "nan": + return s + + else: + rep = re.sub(pattern, "ctrl", s) + return rep + + +def replace_intergenic_words(s): + # Define the regex pattern + pattern = r"\bINTERGENIC\w*\b" + + # Check if the string is 'nan' + if s == "nan": + return s + + else: + rep = re.sub(pattern, "intergenic", s) + return rep + + +def inhouse_preprocess(adata): + guides = np.array(adata.obs["target_gene_name"]) + # leave nans, reformat | as +, and replace CTRL as controls + # filtered_nan_guides = np.where(guides == "nan", "ctrl", guides) + filtered_delimiter_guides = np.array([x.replace("|", "+") for x in guides]) + v_replace_intergenic_words = np.vectorize(replace_intergenic_words) + filtered_delimiter_guides = v_replace_intergenic_words(filtered_delimiter_guides) + v_replace_ctrl_words = np.vectorize(replace_ctrl_words) + filtered_delimiter_guides = v_replace_ctrl_words(filtered_delimiter_guides) + adata.obs["condition"] = filtered_delimiter_guides + adata.obs["condition"] = np.where( + adata.obs["condition"] == "ctrl+ctrl", "ctrl", adata.obs["condition"] + ) + + # add control column + condition = np.array(adata.obs["condition"]) + controls = np.where(condition == "ctrl", 1, 0) + adata.obs["control"] = controls + + # # reformat singletons + for i, guide in enumerate(adata.obs["condition"]): + if ("ctrl" in guide) and (guide.count("+") == 1): + pert = guide.split("+") + if pert[0] == "ctrl": + adata.obs["condition"][i] = pert[1] + else: + adata.obs["condition"][i] = pert[0] + return adata + + +def filter_noisy_genes(adata): + """ + Filter noisy genes from anndata - both the expression and graph + """ + # filter noise genes + noise_prefixes = set(["RPL", "RPS", "MT-", "NEAT1", "MALAT1", "NDUF"]) + + def prefix_match(name, taglist): + taglist = tuple(taglist) + if name.startswith(taglist): + return name + return None + + relevant_gene_idx = [] + for i, x in enumerate(adata.var_names): + match = prefix_match(x, noise_prefixes) + if not match: + relevant_gene_idx.append(i) + + adata = adata[:, relevant_gene_idx] + adata.uns["sparse_gene_network"] = sparse.csr_matrix( + adata.uns["sparse_gene_network"].todense()[relevant_gene_idx][ + :, relevant_gene_idx + ] + ) + + return adata + + +def split_data_by_cell(X, D, test_size=0.2, val_size=0.2): + """ + Split data into train/val/test by cells (seeing all perturbations in training) + """ + data_idx = [i for i in range(X.shape[0])] + train_val_idx, test_idx, D_train_val, D_test = train_test_split( + data_idx, D, test_size=test_size, random_state=1, stratify=D + ) + train_idx, val_idx, D_train, D_val = train_test_split( + train_val_idx, + D_train_val, + test_size=val_size, + random_state=1, + stratify=D_train_val, + ) + + return train_idx, val_idx, test_idx + + +def split_data_by_combinations( + adata, + X, + D, + perturbation_key="condition", + intergenic="intergenic", + test_size=0.3, + val_size=0.2, +): + """ + Split data into train/val/test by perturbation (holdout some combinations) + """ + pert_list = list(adata.obs[perturbation_key].unique()) + combo_perts = [i for i in pert_list if ("+" in i) and (intergenic not in i)] + single_perts = [i for i in pert_list if ("+" not in i) or (intergenic in i)] + + single_idx = [ + i for i, x in enumerate(adata.obs[perturbation_key]) if x in single_perts + ] + D_single = D[single_idx] + + train_idx_single, val_idx_single, D_train_single, D_val_single = train_test_split( + single_idx, D_single, test_size=test_size, random_state=1, stratify=D_single + ) + train_val_combos, test_combos = train_test_split( + combo_perts, test_size=val_size, random_state=1 + ) + train_val_idx = [ + i for i, x in enumerate(adata.obs[perturbation_key]) if x in train_val_combos + ] + test_idx = [ + i for i, x in enumerate(adata.obs[perturbation_key]) if x in test_combos + ] + D_train_val = D[train_val_idx] + train_idx_c, val_idx_c, _, _ = train_test_split( + train_val_idx, D_train_val, test_size=0.2, random_state=1, stratify=D_train_val + ) + train_idx = train_idx_single + train_idx_c + val_idx = val_idx_single + val_idx_c + + return train_idx, val_idx, test_idx + + +def generate_k_fold( + adata, + X, + D, + perturbation_key="condition", + intergenic="intergenic", + folds=5, + fold_idx=0, + test_size=0.2, + val_size=0.2, +): + """ + Split data into folds + """ + pert_list = list(adata.obs[perturbation_key].unique()) + combo_perts = [i for i in pert_list if ("+" in i)] + single_perts = [i for i in pert_list if ("+" not in i)] + + # singletons + single_idx = [ + i for i, x in enumerate(adata.obs[perturbation_key]) if x in single_perts + ] + D_single = D[single_idx] + train_val_single_idx, test_single_idx, D_train_val_single, D_test_single = ( + train_test_split( + single_idx, D_single, test_size=test_size, random_state=1, stratify=D_single + ) + ) + train_single_idx, val_single_idx, _, _ = train_test_split( + train_val_single_idx, + D_train_val_single, + test_size=val_size, + random_state=1, + stratify=D_train_val_single, + ) + + # combos - kfold + kf = KFold(n_splits=folds, random_state=1, shuffle=True) + kf_splits = kf.split(combo_perts) + train_val_combos_idx, test_combos_idx = next( + itertools.islice(kf_splits, fold_idx, None) + ) + train_val_combos = np.array(combo_perts)[train_val_combos_idx] + test_combos = np.array(combo_perts)[test_combos_idx] + + train_val_combos_idx = [ + i for i, x in enumerate(adata.obs[perturbation_key]) if x in train_val_combos + ] + test_combos_idx = [ + i for i, x in enumerate(adata.obs[perturbation_key]) if x in test_combos + ] + D_train_val = D[train_val_combos_idx] + train_idx_c, val_idx_c, _, _ = train_test_split( + train_val_combos_idx, + D_train_val, + test_size=0.2, + random_state=1, + stratify=D_train_val, + ) + + train_idx = train_single_idx + train_idx_c + val_idx = val_single_idx + val_idx_c + test_idx = test_single_idx + test_combos_idx + + return train_idx, val_idx, test_idx + + +def set_seed(seed: int) -> None: + """Sets the random seed to seed. + + Args: + seed: the random seed. + """ + + torch.manual_seed(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + random.seed(seed) + np.random.seed(seed) + + +def generate_loss_weights(adata, perturbation_key): + """ + Generate loss weights for weighting based on fraction of perturbations + + Parameters: + - adata: full anndata + - perturbation_key: key for perturbation annotations + """ + # generate weights for losses - inverse of number of cells + loss_weights = {} + for x in adata.obs[perturbation_key].unique(): + weight = 1 / adata.obs[perturbation_key].value_counts()[x] + loss_weights[x] = weight + sample_weights = np.array([loss_weights[i] for i in adata.obs[perturbation_key]]) + return sample_weights + + +#### Interpretability Analyses #### +GPROFILER_SOURCES = [ + "GO:MF", + "GO:CC", + "GO:BP", + "REAC", + "WP", + "TF", + "MIRNA", + "HPA", + "CORUM", + "HP", +] + + +def get_gprofiler( + de_genes: pd.DataFrame, + organism: str = "hsapiens", + sources: List[str] = GPROFILER_SOURCES, + no_evidences: bool = False, +) -> pd.DataFrame: + """ + Perform gene set enrichment using gprofiler. + de_genes should have a column "gene_symbol" containing gene symbols. + """ + gp = GProfiler(return_dataframe=True) + result = gp.profile( + query=list(de_genes["gene_symbol"]), + organism=organism, + sources=sources, + no_evidences=no_evidences, + ) + go_to_gene = read_aws_pickle("s3://pert-spectra/references/GO_to_Gene.pickle") + filtered_goterms = list(go_to_gene.keys()) + result = result[result.native.isin(filtered_goterms)] + return result + + +def retrieve_stringdb_neighbors(genes: List = []): + """ + Use StringDB to retrieve functional neighbors for perturbations + """ + # retrieve stringdb + PERTSPECTRA_DEFAULT_DIR = os.path.join(os.path.expanduser("~"), "pertspectra_cache") + stringdb_s3_url = "s3://pert-spectra/references/StringDB.HQ.txt" + save_path = os.path.join(PERTSPECTRA_DEFAULT_DIR, stringdb_s3_url.split("/")[-1]) + os.makedirs(os.path.dirname(save_path), exist_ok=True) + s3 = boto3.resource("s3") + # Get the bucket name and key from the s3 url + bucket_name, key = stringdb_s3_url.removeprefix("s3://").split("/", 1) + s3_object = s3.Object(bucket_name=bucket_name, key=key) + s3_object.download_file(save_path) + stringdb_hq = pd.read_csv(save_path, sep="\t") + + perts = [x for x in genes if x not in ["ctrl", "intergenic", "basal"]] + pert_neighbors: dict[Any, Any] = {key: set() for key in perts} + for index, row in stringdb_hq.iterrows(): + if row["x"] > 0.8: + if row["i_genes"] in pert_neighbors.keys(): + pert_neighbors[row["i_genes"]].add(row["j_genes"]) + elif row["j_genes"] in pert_neighbors.keys(): + pert_neighbors[row["j_genes"]].add(row["i_genes"]) + return pert_neighbors + + +def run_gsea( + de_genes: pd.DataFrame, + min_size: int = 10, + max_size: int = 500, + weighted_score_type: int = 0, + permutation_num: int = 1000, + ascending: bool = False, + no_plot: bool = True, + processes: int = -1, + verbose: bool = True, + seed: int = 0, + gsea_name_col: str = "gene_symbol", +): + import gseapy as gp + from statsmodels.stats.multitest import multipletests + + gsea_inputs = de_genes[[gsea_name_col, "z"]].sort_values("z", ascending=False) + gene_sets = read_aws_pickle("s3://pert-spectra/references/GO_to_Gene.pickle") + + # Run prerank + pre_res = gp.prerank( + gsea_inputs, + gene_sets=gene_sets, + outdir=None, + min_size=min_size, + max_size=max_size, + weighted_score_type=weighted_score_type, + permutation_num=permutation_num, + ascending=ascending, + no_plot=no_plot, + verbose=verbose, + threads=processes, + seed=seed, + ) + result = pre_res.res2d + + # Adjust p-value + result["gsea_weight"] = weighted_score_type + + result["pval"] = (result["NOM p-val"] * permutation_num + 1) / (permutation_num + 1) + result["fdr_bh"] = multipletests(result["pval"], method="fdr_bh")[1] + result["fwer_bf"] = np.clip(result["pval"] * result.shape[0], 0, 1) + result["GO_ID"] = result["Term"] + # adjust data types to enable serialization to h5ad if gsea output is added to .uns + # attribute of anndata + columns_to_format = { + k: v + for (k, v) in GSEA_COLUMN_DATATYPES_FOR_SERIALIZATION.items() + if k in result.columns + } + result = result.astype(columns_to_format) + + return result, pre_res + + +def factor_enrichment_gsea(adata, latent, max_size=300, fdr=5e-3): + factor_to_go = {} + latent = latent + for i in range(len(latent)): + # rank by latent factor loadings + lvec = latent[i] + gsea_input = pd.DataFrame( + [adata.var_names, lvec], + index=["gene_symbol", "z"], + ).T + # run gsea + gsea_input["z"] = gsea_input["z"].astype("float") + res = run_gsea(gsea_input, max_size=max_size)[0] + # filter to BP + go_reference = read_aws_csv( + "s3://pert-spectra/references/GO_terms.txt.gz", zipped=True + ) + go_bp = go_reference[go_reference["go_category"] == "biological_process"] + go_bp_ids = set(go_bp["go_id"].values) + # filter on fdr and nes + res = res[res["fdr_bh"] <= fdr] + res = res[np.abs(res["NES"]) > 1] + res = res[res["GO_ID"].isin(go_bp_ids)] + factor_to_go[i] = res + return factor_to_go + + +def perturbation_signal_recovery( + pert_to_go, model_pert_to_go, filtered_go_terms, perturbations +): + """ + Returns p-value of bootstrapped hypergeoemtric test of the overlap between known processes + vs model identified processes + + Args: + pert_to_go (dict): dict of perturbations to GO terms from a prior + model_pert_to_go (dict): dict of perturbations to GO terms from the model + filtered_go_terms (list): list of all GO terms in the prior + perturbations (list): list of perturbations + + Return: + pvals (dict): dict of perturbation to corrected p-value + """ + set_seed(0) + pvals = {} + for pert in perturbations: + if pert in ["ctrl", "intergenic", "basal"]: + continue + groupA = pert_to_go[pert] + groupB = model_pert_to_go[pert] + # Total number of unique items + M = len(filtered_go_terms) + # Number of items in set1 + n = len(groupA) + # Number of items in set2 + k = len(groupB) + # Number of overlapping items (intersection of both sets) + N = len(groupA.intersection(groupB)) + + # only consider if there are >5 processes from researchdb + if n < 5: + continue + rv = hypergeom(M, n, k) + observed_p_value = rv.sf(N - 1) + + # Output the p-value + print(f"Overlap for {pert}: {N} out of {n} in researchDB") + print(f"P-value for {pert}: {observed_p_value}") + if N == 0: + pvals[pert] = 1 + else: + pvals[pert] = observed_p_value + + # pvalue correction + pval_list = list(pvals.values()) + pvals_corrected = false_discovery_control(pval_list) + for i, key in enumerate(pvals): + pvals[key] = pvals_corrected[i] + return pvals + + +### Precision-recall analysis ### +def auprc( + dist_matrix: pd.DataFrame, + benchmark_sources: list = ["StringDB", "CORUM"], + benchmark_data_dir: str = "s3://pert-spectra/references/recall_datasets/", + log_stats: bool = False, +): + """ + Return AUC and best F1 score+threshold of precision-recall curve + """ + # convert distance matrix to sim matrix + d_norm = (dist_matrix - dist_matrix.min()) / (dist_matrix.max() - dist_matrix.min()) + sim_matrix = 1 - d_norm + + # calculate pr metric + auc_metrics = {} + f1_metrics = {} + pr_metrics = {} + # inputs = {} + for s in benchmark_sources: + rels = get_benchmark_relationships(benchmark_data_dir, s) + rels = rels[ + rels.node_1.isin(sim_matrix.index) & rels.node_2.isin(sim_matrix.index) + ] + adj_true = np.array( + [ + [0 for _ in range(len(sim_matrix.index))] + for _ in range(len(sim_matrix.index)) + ] + ) + adj_labels = {x: i for i, x in enumerate(sim_matrix.index)} + for i in range(adj_true.shape[0]): + adj_true[i][i] = 1 + for i, row in rels.iterrows(): + n1, n2 = row["node_1"], row["node_2"] + adj_true[adj_labels[n1]][adj_labels[n2]] = 1 + adj_true[adj_labels[n2]][adj_labels[n1]] = 1 + fpr, tpr, thresholds = precision_recall_curve( + np.reshape(adj_true.flatten(), (-1, 1)), + np.reshape(sim_matrix.values.flatten(), (-1, 1)), + ) + # calculate auc + auc_metrics[s] = {auc(tpr, fpr)} + # calculate best f1 + f1_scores = 2 * tpr * fpr / (tpr + fpr) + f1_metrics[s] = [np.max(f1_scores), thresholds[np.argmax(f1_scores)]] + # record pr metrics + pr_metrics[s] = {"precision": fpr, "recall": tpr, "thresholds": thresholds} + # record inputs + # inputs[s] = {'adj_true':np.reshape(adj_true.flatten(), (-1, 1)), + #'sim_matrix':np.reshape(sim_matrix.values.flatten(), (-1, 1))} + + return ( + pd.DataFrame.from_dict(auc_metrics, orient="index", columns=["AUC"]), + pd.DataFrame.from_dict(f1_metrics, orient="index", columns=["F1", "Threshold"]), + pr_metrics, + ) + + +### Recall Analyses borrowed from EFAAR### +def get_benchmark_relationships(benchmark_data_dir: str, src: str, filter=True): + """ + Reads a CSV file containing benchmark data and returns a filtered DataFrame. + + Args: + benchmark_data_dir (str): The directory containing the benchmark data files. + src (str): The name of the source containing the benchmark data. + filter (bool, optional): Whether to filter the DataFrame. Defaults to True. + + Returns: + pd.DataFrame: A DataFrame containing the benchmark relationships. + """ + df = read_aws_csv(benchmark_data_dir + src + ".txt") + return filter_relationships(df) if filter else df + + +def convert_metrics_to_df(metrics: dict, source: str) -> pd.DataFrame: + """ + Convert metrics dictionary to dataframe to be used in summary. + + Args: + metrics (dict): metrics dictionary + source (str): benchmark source name + + Returns: + pd.DataFrame: a dataframe with metrics + """ + metrics_dict_with_list = {key: [value] for key, value in metrics.items()} + metrics_dict_with_list["source"] = [source] + return pd.DataFrame.from_dict(metrics_dict_with_list) + + +def filter_relationships(df: pd.DataFrame): + """ + Filters a DataFrame of relationships between entities, removing any rows with + self-relationships + , ie. where the same entity appears in both columns, and also removing any duplicate + relationships (A-B and B-A). + + Args: + df (pd.DataFrame): DataFrame containing columns 'entity1' and 'entity2', representing the + entities involved in + each relationship. + + Returns: + pd.DataFrame: DataFrame containing columns 'entity1' and 'entity2', representing + the entities + involved in + each relationship after removing any rows where the same entity appears in both columns. + """ + df["sorted_entities"] = df.apply( + lambda row: tuple(sorted([row.node_1, row.node_2])), axis=1 + ) + df["node_1"] = df.sorted_entities.apply(lambda x: x[0]) + df["node_2"] = df.sorted_entities.apply(lambda x: x[1]) + return df[["node_1", "node_2"]].query("node_1!=node_2").drop_duplicates()