diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..e69de29
diff --git a/.github/workflows/deploy-space.yml b/.github/workflows/deploy-space.yml
new file mode 100644
index 0000000..20cf6e2
--- /dev/null
+++ b/.github/workflows/deploy-space.yml
@@ -0,0 +1,33 @@
+name: Deploy to HF Spaces
+
+on:
+ push:
+ branches: [main]
+ paths:
+ - "9.webapp/**"
+
+jobs:
+ deploy:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ lfs: true
+
+ - name: Install huggingface_hub
+ run: pip install huggingface_hub
+
+ - name: Push to HF Spaces
+ env:
+ HF_TOKEN: ${{ secrets.HF_TOKEN }}
+ run: |
+ cd 9.webapp
+ hf upload WayScience/gene-dependency-explorer . . \
+ --repo-type space \
+ --exclude ".venv/**" \
+ --exclude "**/__pycache__/**" \
+ --exclude "**/*.pyc" \
+ --exclude "**/*.egg-info/**" \
+ --exclude "data/CRISPRGeneEffect.parquet" \
+ --exclude "data/CRISPR_gene_dictionary.parquet" \
+ --commit-message "deploy from ${{ github.sha }}"
diff --git a/.gitignore b/.gitignore
index 78c2fae..c32ab88 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,7 @@
__pycache__
2.train-VAE/parameter_sweep
.DS_Store
+9.webapp/gene_dependency_webapp.egg-info
+9.webapp/data/CRISPRGeneEffect.parquet
+9.webapp/data/CRISPR_gene_dictionary.parquet
+*.pyc
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..af1066d
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,64 @@
+repos:
+- repo: https://gitlab.com/vojko.pribudic.foss/pre-commit-update
+ rev: v0.9.0 # Insert the latest tag here
+
+ hooks:
+ - id: pre-commit-update
+ args: [--exclude, black, --keep, isort]
+ # Formats import order
+- repo: https://github.com/pycqa/isort
+ rev: 5.12.0
+ hooks:
+ - id: isort
+ name: isort (python)
+ args: ["--profile", "black", "--filter-files"]
+
+ #Code formatter for both python files and jupyter notebooks
+- repo: https://github.com/astral-sh/ruff-pre-commit
+ # Ruff version.
+ rev: v0.15.17
+ hooks:
+ # Run the formatter.
+ - id: ruff-format
+
+- repo: https://github.com/nbQA-dev/nbQA
+ rev: 1.9.1
+ hooks:
+ - id: nbqa-isort
+ additional_dependencies: [isort==5.6.4]
+ args: [--profile=black]
+
+- repo: https://github.com/pre-commit/mirrors-prettier
+ rev: "v3.1.0"
+ hooks:
+ - id: prettier
+ types_or: [markdown, yaml, json, html, css, python, r]
+
+- repo: https://github.com/hadialqattan/pycln
+ rev: v2.6.0
+ hooks:
+ - id: pycln
+ args: [--config=pyproject.toml]
+ exclude: |
+ (?x)^(
+ 2\.segment_images/scripts/.*\.py$|
+ 3\.cellprofiling/scripts/.*\.py$
+ )$
+ # additional hooks found with in the pre-commit lib
+- repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v6.0.0
+ hooks:
+ - id: trailing-whitespace # removes trailing white spaces
+ - id: mixed-line-ending # removes mixed end of line
+ args:
+ - --fix=lf
+
+- repo: local
+ hooks:
+ - id: shellcheck
+ name: shellcheck
+ description: Test shell scripts with shellcheck
+ entry: shellcheck
+ language: python
+ types: [shell]
+ require_serial: true # shellcheck can detect sourcing this way
diff --git a/5.drug-dependency/9.precompute_webapp_pca_embeddings.ipynb b/5.drug-dependency/9.precompute_webapp_pca_embeddings.ipynb
new file mode 100644
index 0000000..6bfff51
--- /dev/null
+++ b/5.drug-dependency/9.precompute_webapp_pca_embeddings.ipynb
@@ -0,0 +1,238 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "notice-cell",
+ "metadata": {},
+ "source": [
+ "# Precompute PCA Embeddings for Webapp\n",
+ "\n",
+ "> **Note:** This notebook was a one-time preprocessing step run to generate the pre-computed PCA\n",
+ "> parquet files bundled with the `9.webapp/` Streamlit app. It is **not intended to be re-run**\n",
+ "> without modification.\n",
+ ">\n",
+ "> The helper functions below (`load_model_data`, `single_load_data`, `latent_load_data`) were\n",
+ "> originally defined in `9.webapp/app_utils.py` but were removed from the app once the pre-computed\n",
+ "> parquets replaced runtime PCA computation. They are reproduced here for provenance.\n",
+ ">\n",
+ "> **Dependencies that are no longer in the webapp environment:**\n",
+ "> - `CRISPRGeneEffect.parquet` and `CRISPR_gene_dictionary.parquet` (large gitignored DepMap files\n",
+ "> โ download via `0.data-download/` first)\n",
+ "> - `sklearn` (`scikit-learn`) โ not in `9.webapp/pyproject.toml`\n",
+ ">\n",
+ "> **Outputs** (written to `9.webapp/data/`):\n",
+ "> - `pca_embeddings_single_dependencies.parquet`\n",
+ "> - `pca_embeddings_latent_reactome.parquet`\n",
+ "> - `pca_embeddings_latent_corum.parquet`\n",
+ "> - `pca_embeddings_latent_drug.parquet`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6c08a8f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pathlib\n",
+ "\n",
+ "import pandas as pd\n",
+ "from sklearn.decomposition import PCA"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "paths-cell",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Paths โ run from repo root or adjust accordingly\n",
+ "REPO_ROOT = pathlib.Path().resolve().parent # goes up from 5.drug-dependency/ to repo root\n",
+ "WEBAPP_DIR = REPO_ROOT / \"9.webapp\"\n",
+ "DATA_DIR = WEBAPP_DIR / \"data\"\n",
+ "RESULTS_DIR = REPO_ROOT / \"5.drug-dependency\" / \"results\"\n",
+ "\n",
+ "print(f\"Repo root: {REPO_ROOT}\")\n",
+ "print(f\"Webapp data: {DATA_DIR}\")\n",
+ "print(f\"Results dir: {RESULTS_DIR}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "helpers-header",
+ "metadata": {},
+ "source": [
+ "## Helper functions\n",
+ "\n",
+ "Originally from `9.webapp/app_utils.py`, reproduced here for provenance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "load-model-data-cell",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def load_model_data(dependency_file, gene_dict_file):\n",
+ " \"\"\"Load and preprocess gene dependency data and gene dictionary.\"\"\"\n",
+ " dependency_df = pd.read_parquet(dependency_file)\n",
+ " print(dependency_df.shape)\n",
+ "\n",
+ " gene_dict_df = (\n",
+ " pd.read_parquet(gene_dict_file).query(\"qc_pass\").reset_index(drop=True)\n",
+ " )\n",
+ " gene_dict_df.entrez_id = gene_dict_df.entrez_id.astype(str)\n",
+ "\n",
+ " entrez_genes = [\n",
+ " x[1].strip(\")\").strip()\n",
+ " for x in dependency_df.iloc[:, 1:].columns.str.split(\"(\")\n",
+ " ]\n",
+ " entrez_intersection = list(\n",
+ " set(gene_dict_df.entrez_id).intersection(set(entrez_genes))\n",
+ " )\n",
+ " gene_dict_df = gene_dict_df.set_index(\"entrez_id\").reindex(entrez_intersection)\n",
+ "\n",
+ " dependency_df.columns = [\"ModelID\"] + entrez_genes\n",
+ " dependency_df = dependency_df.loc[:, [\"ModelID\"] + gene_dict_df.index.tolist()]\n",
+ " dependency_df.columns = [\"ModelID\"] + gene_dict_df.symbol_id.tolist()\n",
+ " dependency_df = dependency_df.dropna(axis=\"columns\")\n",
+ " return dependency_df, gene_dict_df"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "single-load-cell",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def single_load_data():\n",
+ " \"\"\"Load CRISPR gene dependency scores merged with cell line metadata.\"\"\"\n",
+ " dependency_file = DATA_DIR / \"CRISPRGeneEffect.parquet\"\n",
+ " gene_dict_file = DATA_DIR / \"CRISPR_gene_dictionary.parquet\"\n",
+ " cancer_type_input_file = DATA_DIR / \"Model.parquet\"\n",
+ "\n",
+ " dependency_df, _ = load_model_data(dependency_file, gene_dict_file)\n",
+ " dependency_df = dependency_df.set_index(\"ModelID\")\n",
+ " cancer_type_df = pd.read_parquet(cancer_type_input_file)\n",
+ " combined_df = dependency_df.merge(\n",
+ " cancer_type_df[[\"ModelID\", \"OncotreePrimaryDisease\"]], on=\"ModelID\", how=\"left\"\n",
+ " )\n",
+ " return combined_df"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "latent-load-cell",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def latent_load_data():\n",
+ " \"\"\"Load latent score parquets and pivot to wide format for PCA.\"\"\"\n",
+ " reactome_df = pd.read_parquet(RESULTS_DIR / \"all_reactome_results.parquet\")\n",
+ " corum_df = pd.read_parquet(RESULTS_DIR / \"all_corum_results.parquet\")\n",
+ " drug_df = pd.read_parquet(RESULTS_DIR / \"all_drug_results.parquet\")\n",
+ "\n",
+ " reactome_df[\"feature\"] = reactome_df[\"reactome_pathway\"]\n",
+ " reactome_df = reactome_df.drop(\n",
+ " columns=[\"model\", \"latent_dim_total\", \"init\", \"seed\", \"z\", \"reactome_pathway\"]\n",
+ " )\n",
+ " corum_df[\"feature\"] = corum_df[\"reactome_pathway\"]\n",
+ " corum_df = corum_df.drop(\n",
+ " columns=[\"model\", \"latent_dim_total\", \"init\", \"seed\", \"z\", \"reactome_pathway\"]\n",
+ " )\n",
+ " drug_df[\"feature\"] = drug_df[\"name\"]\n",
+ " drug_df = drug_df.drop(\n",
+ " columns=[\"model\", \"latent_dim_total\", \"init\", \"seed\", \"z\", \"name\"]\n",
+ " )\n",
+ "\n",
+ " meta_cols = [\"ModelID\", \"OncotreePrimaryDisease\"]\n",
+ " reactome_meta = reactome_df[meta_cols].drop_duplicates()\n",
+ " corum_meta = corum_df[meta_cols].drop_duplicates()\n",
+ " drug_meta = drug_df[meta_cols].drop_duplicates()\n",
+ "\n",
+ " reactome_matrix = reactome_df.pivot(\n",
+ " index=\"ModelID\", columns=\"feature\", values=\"latent_score\"\n",
+ " ).merge(reactome_meta, on=\"ModelID\", how=\"left\")\n",
+ " corum_matrix = corum_df.pivot(\n",
+ " index=\"ModelID\", columns=\"feature\", values=\"latent_score\"\n",
+ " ).merge(corum_meta, on=\"ModelID\", how=\"left\")\n",
+ " drug_matrix = drug_df.pivot(\n",
+ " index=\"ModelID\", columns=\"feature\", values=\"latent_score\"\n",
+ " ).merge(drug_meta, on=\"ModelID\", how=\"left\")\n",
+ "\n",
+ " return reactome_matrix, corum_matrix, drug_matrix"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "pca-header",
+ "metadata": {},
+ "source": [
+ "## Compute and save PCA embeddings"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6cdc8f80",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def compute_pca(df, metadata_columns) -> pd.DataFrame:\n",
+ " print(df.shape[0], \"rows before dropping NA\")\n",
+ " df = df.dropna()\n",
+ " print(df.shape[0], \"rows after dropping NA\")\n",
+ " metadata_df = df[metadata_columns].copy()\n",
+ " feat_cols = df.columns.drop(metadata_columns)\n",
+ " if \"source\" in feat_cols:\n",
+ " feat_cols = feat_cols.drop(\"source\")\n",
+ " pca_input = df[feat_cols].apply(pd.to_numeric, errors=\"coerce\")\n",
+ " pca = PCA(n_components=2, random_state=0)\n",
+ " pca_embedding = pca.fit_transform(pca_input)\n",
+ " metadata_df[\"PCA1\"] = pca_embedding[:, 0]\n",
+ " metadata_df[\"PCA2\"] = pca_embedding[:, 1]\n",
+ " return metadata_df"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "run-pca-cell",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "combined_df = single_load_data()\n",
+ "reactome_matrix, corum_matrix, drug_matrix = latent_load_data()\n",
+ "\n",
+ "pca_single_df = compute_pca(combined_df, [\"ModelID\", \"OncotreePrimaryDisease\"])\n",
+ "pca_latent_reactome_df = compute_pca(reactome_matrix, [\"OncotreePrimaryDisease\", \"ModelID\"])\n",
+ "pca_latent_corum_df = compute_pca(corum_matrix, [\"OncotreePrimaryDisease\", \"ModelID\"])\n",
+ "pca_latent_drug_df = compute_pca(drug_matrix, [\"OncotreePrimaryDisease\", \"ModelID\"])\n",
+ "\n",
+ "pca_single_df.to_parquet(DATA_DIR / \"pca_embeddings_single_dependencies.parquet\")\n",
+ "pca_latent_reactome_df.to_parquet(DATA_DIR / \"pca_embeddings_latent_reactome.parquet\")\n",
+ "pca_latent_corum_df.to_parquet(DATA_DIR / \"pca_embeddings_latent_corum.parquet\")\n",
+ "pca_latent_drug_df.to_parquet(DATA_DIR / \"pca_embeddings_latent_drug.parquet\")\n",
+ "\n",
+ "print(\"Done โ parquets written to\", DATA_DIR)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python",
+ "version": "3.12.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/5.drug-dependency/results/all_corum_results.parquet b/5.drug-dependency/results/all_corum_results.parquet
new file mode 100644
index 0000000..7ad6773
Binary files /dev/null and b/5.drug-dependency/results/all_corum_results.parquet differ
diff --git a/5.drug-dependency/results/all_drug_results.parquet b/5.drug-dependency/results/all_drug_results.parquet
new file mode 100644
index 0000000..6d9d660
Binary files /dev/null and b/5.drug-dependency/results/all_drug_results.parquet differ
diff --git a/5.drug-dependency/results/all_reactome_results.parquet b/5.drug-dependency/results/all_reactome_results.parquet
new file mode 100644
index 0000000..65d896e
Binary files /dev/null and b/5.drug-dependency/results/all_reactome_results.parquet differ
diff --git a/9.webapp/.hfignore b/9.webapp/.hfignore
new file mode 100644
index 0000000..910f6cf
--- /dev/null
+++ b/9.webapp/.hfignore
@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+*.egg-info/
+.DS_Store
diff --git a/9.webapp/.streamlit/config.toml b/9.webapp/.streamlit/config.toml
new file mode 100644
index 0000000..82fa436
--- /dev/null
+++ b/9.webapp/.streamlit/config.toml
@@ -0,0 +1,2 @@
+[server]
+fileWatcherType = "none"
diff --git a/9.webapp/Dockerfile b/9.webapp/Dockerfile
new file mode 100644
index 0000000..64fb36d
--- /dev/null
+++ b/9.webapp/Dockerfile
@@ -0,0 +1,18 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+COPY pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-dev
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uv", "run", "streamlit", "run", "app.py", \
+ "--server.address", "0.0.0.0", \
+ "--server.port", "7860", \
+ "--server.headless", "true", \
+ "--server.fileWatcherType", "none"]
diff --git a/9.webapp/README.md b/9.webapp/README.md
new file mode 100644
index 0000000..3f44643
--- /dev/null
+++ b/9.webapp/README.md
@@ -0,0 +1,116 @@
+---
+title: Gene Process Dependency Explorer
+emoji: ๐งฌ
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: true
+license: bsd-3-clause
+---
+
+# Gene Process Dependency Explorer
+
+An interactive Streamlit dashboard for exploring gene process dependencies across cancer types, built on [DepMap](https://depmap.org) data and latent representations learned by a Beta Variational Autoencoder (BVAE).
+
+This app accompanies the paper:
+
+> **Discovering multivariate gene vulnerability patterns in cancer using latent representations of gene dependencies**
+> WayScience ยท [GitHub](https://github.com/WayScience/gene_dependency_representations)
+
+---
+
+## What the app shows
+
+The dashboard has six tabs:
+
+| Tab | Description |
+| :-- | :---------- |
+| **Welcome** | Overview and links |
+| **Single dependency plots** | PCA of raw CRISPR gene dependency scores across all cell lines; filter by cancer type |
+| **Latent plots** | PCA of VAE latent representations for Reactome, CORUM, and Drug subsets |
+| **Spider plots** | Radar charts of biological process dependency profiles per cell line or cancer type |
+| **Top scores** | Heatmaps and bar charts of highest-scoring processes by cancer type and model ID |
+| **Data table** | Searchable table of all cell lines and their primary diseases |
+
+---
+
+## Running locally
+
+The webapp is self-contained with its own [`uv`](https://docs.astral.sh/uv/)-managed environment.
+
+### Prerequisites
+
+```sh
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+### Start the app
+
+```sh
+cd 9.webapp
+uv run streamlit run app.py
+```
+
+`uv` creates and populates the virtual environment automatically on first run. The app will be available at `http://localhost:8501`.
+
+### Deploy headless (e.g. on a server)
+
+```sh
+cd 9.webapp
+PORT=8501 uv run streamlit run app.py \
+ --server.address 0.0.0.0 \
+ --server.headless true \
+ --server.port "$PORT" \
+ --server.fileWatcherType none
+```
+
+---
+
+## Data
+
+All data files are committed to the repository โ no external downloads needed to run the app.
+
+| File | Size | Description |
+| :--- | ---: | :---------- |
+| `data/Model.parquet` | 188 KB | DepMap cell line metadata |
+| `data/pca_embeddings_single_dependencies.parquet` | 34 KB | Pre-computed PCA of raw gene dependency scores |
+| `data/pca_embeddings_latent_reactome.parquet` | 27 KB | Pre-computed PCA of Reactome latent scores |
+| `data/pca_embeddings_latent_corum.parquet` | 27 KB | Pre-computed PCA of CORUM latent scores |
+| `data/pca_embeddings_latent_drug.parquet` | 27 KB | Pre-computed PCA of drug latent scores |
+| `data/all_reactome_results.parquet` | 1.7 MB | Full Reactome latent scores (spider + heatmap tabs) |
+| `data/all_corum_results.parquet` | 1.7 MB | Full CORUM latent scores |
+| `data/all_drug_results.parquet` | 4.1 MB | Full drug latent scores |
+
+Raw DepMap files (`CRISPRGeneEffect.parquet` etc.) are **not** required by the webapp and are gitignored.
+Download them via [`0.data-download/`](../0.data-download/) if you need to re-run the full analysis pipeline.
+
+---
+
+## Deployment
+
+The Space at [WayScience/gene-dependency-explorer](https://huggingface.co/spaces/WayScience/gene-dependency-explorer) deploys automatically via GitHub Actions whenever changes to `9.webapp/` are merged into `main`.
+See [`../.github/workflows/deploy-space.yml`](../.github/workflows/deploy-space.yml).
+
+To deploy manually:
+
+```sh
+cd 9.webapp
+hf upload WayScience/gene-dependency-explorer . . \
+ --repo-type space \
+ --exclude ".venv/**" \
+ --exclude "**/__pycache__/**" \
+ --exclude "**/*.pyc" \
+ --exclude "**/*.egg-info/**" \
+ --exclude "data/CRISPRGeneEffect.parquet" \
+ --exclude "data/CRISPR_gene_dictionary.parquet" \
+ --commit-message "your message here"
+```
+
+Requires the `hf` CLI and login to the WayScience org (`hf auth login`).
+
+---
+
+## Repository structure
+
+This webapp lives in `9.webapp/` within the larger [gene_dependency_representations](https://github.com/WayScience/gene_dependency_representations) repository, which contains the full BioBombe analysis and interpretation pipeline.
diff --git a/9.webapp/app.py b/9.webapp/app.py
new file mode 100644
index 0000000..005810a
--- /dev/null
+++ b/9.webapp/app.py
@@ -0,0 +1,790 @@
+"""
+Gene Process Dependency Explorer
+"""
+
+import pathlib
+import textwrap
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+from app_utils import (
+ latent_load_data,
+ make_radar,
+ spider_load_data,
+)
+
+BASE_DIR = pathlib.Path(__file__).parent
+
+# โโ Page config โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+st.set_page_config(
+ page_title="Gene Process Dependency Explorer",
+ page_icon="๐งฌ",
+ layout="wide",
+ initial_sidebar_state="collapsed",
+)
+
+# โโ Styling โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+st.markdown(
+ """
+
+""",
+ unsafe_allow_html=True,
+)
+
+# โโ Header โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+st.markdown("# Gene Process Dependency Explorer")
+st.markdown(
+ 'DepMap ยท BioBombe ยท WayScience',
+ unsafe_allow_html=True,
+)
+
+# โโ Load only the tiny model metadata file at startup (188 KB) โโโโโโโโโโโโโโโโ
+_model_meta = pd.read_parquet(
+ BASE_DIR / "data" / "Model.parquet",
+ columns=["ModelID", "OncotreePrimaryDisease"],
+)
+ALL_DISEASES = sorted(_model_meta["OncotreePrimaryDisease"].dropna().unique().tolist())
+ALL_MODEL_IDS = sorted(_model_meta["ModelID"].dropna().unique().tolist())
+DEFAULT_MODEL_IDS = ["ACH-000323", "ACH-002083", "ACH-002228"]
+single_gene_pca_df = pd.read_parquet(
+ BASE_DIR / "data" / "pca_embeddings_single_dependencies.parquet"
+)
+latent_reactome_pca_df = pd.read_parquet(
+ BASE_DIR / "data" / "pca_embeddings_latent_reactome.parquet"
+)
+latent_corum_pca_df = pd.read_parquet(
+ BASE_DIR / "data" / "pca_embeddings_latent_corum.parquet"
+)
+latent_drug_pca_df = pd.read_parquet(
+ BASE_DIR / "data" / "pca_embeddings_latent_drug.parquet"
+)
+# โโ Tabs โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+(
+ tab_welcome,
+ tab_single,
+ tab_latent,
+ tab_spider,
+ tab_scores,
+ tab_table,
+) = st.tabs(
+ [
+ "๐ Welcome",
+ "๐ Single dependency plots",
+ "๐ Latent plots",
+ "๐ท Spider plots",
+ "๐ Top scores",
+ "๐ Data table",
+ ]
+)
+
+
+# โโ Helpers โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+def disease_controls(key_prefix: str, default_all: bool = True) -> list[str]:
+ """Render an All / None button pair + multiselect for disease filtering."""
+ st.markdown(
+ 'Primary diseases
', unsafe_allow_html=True
+ )
+ ca, cn = st.columns(2)
+ if ca.button("All", key=f"{key_prefix}_dis_all", use_container_width=True):
+ st.session_state[f"{key_prefix}_diseases"] = ALL_DISEASES
+ if cn.button("None", key=f"{key_prefix}_dis_none", use_container_width=True):
+ st.session_state[f"{key_prefix}_diseases"] = []
+ return st.multiselect(
+ "Primary diseases",
+ ALL_DISEASES,
+ default=st.session_state.get(
+ f"{key_prefix}_diseases", ALL_DISEASES if default_all else []
+ ),
+ label_visibility="collapsed",
+ key=f"{key_prefix}_diseases",
+ )
+
+
+def model_id_controls(key_prefix: str) -> list[str]:
+ """Render All / None / Default buttons + multiselect for ModelID filtering."""
+ st.markdown('Model IDs
', unsafe_allow_html=True)
+ ca, cn, cd = st.columns(3)
+ if ca.button("All", key=f"{key_prefix}_mod_all", use_container_width=True):
+ st.session_state[f"{key_prefix}_model_ids"] = ALL_MODEL_IDS
+ if cn.button("None", key=f"{key_prefix}_mod_none", use_container_width=True):
+ st.session_state[f"{key_prefix}_model_ids"] = []
+ if cd.button("Default", key=f"{key_prefix}_mod_default", use_container_width=True):
+ st.session_state[f"{key_prefix}_model_ids"] = DEFAULT_MODEL_IDS
+ return st.multiselect(
+ "Model IDs",
+ ALL_MODEL_IDS,
+ default=st.session_state.get(f"{key_prefix}_model_ids", DEFAULT_MODEL_IDS),
+ label_visibility="collapsed",
+ key=f"{key_prefix}_model_ids",
+ )
+
+
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+# TAB 0 โ Intro text
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+with tab_welcome:
+ st.markdown("## Welcome to the Gene Process Dependency Explorer")
+ st.markdown(
+ "This app allows you to explore gene process dependencies across different cancer types and model IDs."
+ )
+ st.markdown(
+ "We are visualizing latent representations of gene dependencies learned by a compression model trained on DepMap data, with biological processes as features."
+ )
+ st.markdown(
+ "For more details on the data and methods, please see our github repository: https://github.com/WayScience/gene-process-dependencies"
+ )
+ st.markdown(
+ "For more information about the group, please visit the WayScience website: https://wayscience.com"
+ )
+ st.markdown("---")
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+# TAB 1 โ Single dependency plots
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+with tab_single:
+ st.markdown("### Latent Space PCA โ single dependency")
+ st.markdown(
+ "PCA projection of raw gene dependency scores. "
+ "Each point is a cancer cell line; colour encodes primary disease."
+ )
+
+ with st.container():
+ st.markdown('', unsafe_allow_html=True)
+ selected_diseases_single = disease_controls("single")
+ st.markdown("
", unsafe_allow_html=True)
+
+ cancer_types = single_gene_pca_df["OncotreePrimaryDisease"].unique()
+ color_map = (
+ px.colors.qualitative.Plotly
+ + px.colors.qualitative.Light24
+ + px.colors.qualitative.Dark24
+ )
+ highlight_color_map = {
+ c: color_map[i % len(color_map)] for i, c in enumerate(cancer_types)
+ }
+
+ traces = []
+ for cancer in cancer_types:
+ df_sub = single_gene_pca_df[
+ single_gene_pca_df["OncotreePrimaryDisease"] == cancer
+ ]
+ is_selected = cancer in selected_diseases_single
+ traces.append(
+ go.Scatter(
+ x=df_sub["PCA1"],
+ y=df_sub["PCA2"],
+ mode="markers",
+ name=cancer,
+ marker=dict(
+ size=7,
+ color=highlight_color_map[cancer] if is_selected else "#3d444d",
+ opacity=1.0 if is_selected else 0.3,
+ ),
+ text=[f"{cancer} | {m}" for m in df_sub["ModelID"]],
+ hoverinfo="text" if is_selected else "skip",
+ showlegend=is_selected,
+ )
+ )
+
+ # Render grayed traces behind colored ones
+ traces.sort(key=lambda t: t.name in selected_diseases_single, reverse=True)
+
+ fig_single = go.Figure(data=traces)
+ fig_single.update_layout(
+ paper_bgcolor="#0d1117",
+ plot_bgcolor="#0d1117",
+ font=dict(color="#e6edf3"),
+ xaxis=dict(gridcolor="#21262d"),
+ yaxis=dict(gridcolor="#21262d"),
+ legend=dict(bgcolor="#161b22", bordercolor="#30363d", borderwidth=1),
+ height=1200,
+ margin=dict(l=40, r=40, t=40, b=40),
+ width=800,
+ )
+ st.plotly_chart(fig_single, use_container_width=True)
+
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+# TAB 2 โ Latent plots
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+with tab_latent:
+ st.markdown("### Latent Space PCA Projections")
+ st.markdown(
+ "PCA projection of latent representations learned by the selected compression model. "
+ "Each point is a cancer cell line; clusters indicate similar gene dependency profiles."
+ )
+
+ with st.container():
+ st.markdown('', unsafe_allow_html=True)
+ selected_diseases_latent = disease_controls("latent")
+ st.markdown("
", unsafe_allow_html=True)
+
+ for title, pca_df in [
+ ("Reactome", latent_reactome_pca_df),
+ ("CORUM", latent_corum_pca_df),
+ ("Drug", latent_drug_pca_df),
+ ]:
+ st.markdown(f"#### PCA: {title} Subset")
+
+ cancer_types = pca_df["OncotreePrimaryDisease"].unique()
+ color_map = (
+ px.colors.qualitative.Plotly
+ + px.colors.qualitative.Light24
+ + px.colors.qualitative.Dark24
+ )
+ highlight_color_map = {
+ c: color_map[i % len(color_map)] for i, c in enumerate(cancer_types)
+ }
+
+ traces = []
+ for cancer in cancer_types:
+ df_sub = pca_df[pca_df["OncotreePrimaryDisease"] == cancer]
+ is_selected = cancer in selected_diseases_latent
+ traces.append(
+ go.Scatter(
+ x=df_sub["PCA1"],
+ y=df_sub["PCA2"],
+ mode="markers",
+ name=cancer,
+ marker=dict(
+ size=7,
+ color=highlight_color_map[cancer] if is_selected else "#3d444d",
+ opacity=1.0 if is_selected else 0.3,
+ ),
+ text=[f"{cancer} | {m}" for m in df_sub["ModelID"]],
+ hoverinfo="text" if is_selected else "skip",
+ showlegend=is_selected,
+ )
+ )
+
+ traces.sort(key=lambda t: t.name in selected_diseases_latent, reverse=True)
+
+ fig = go.Figure(data=traces)
+ fig.update_layout(
+ paper_bgcolor="#0d1117",
+ plot_bgcolor="#0d1117",
+ font=dict(color="#e6edf3"),
+ xaxis=dict(gridcolor="#21262d"),
+ yaxis=dict(gridcolor="#21262d"),
+ legend=dict(bgcolor="#161b22", bordercolor="#30363d", borderwidth=1),
+ height=600,
+ margin=dict(l=40, r=40, t=40, b=40),
+ )
+ st.plotly_chart(fig, use_container_width=True)
+
+
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+# TAB 3 โ Spider plots
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+with tab_spider:
+ st.markdown("### Biological Process Dependency Profiles โ Spider Plots")
+ st.markdown(
+ "Mean dependency score per biological process category for selected cell lines. "
+ "Negative scores indicate stronger dependencies (essential genes)."
+ )
+
+ with st.container():
+ st.markdown('', unsafe_allow_html=True)
+ sp_c1, sp_c2, sp_c3 = st.columns(3)
+
+ with sp_c1:
+ spider_filter_mode = st.radio(
+ "Filter by",
+ ["Model IDs", "Cancer Types"],
+ horizontal=True,
+ key="spider_filter_mode",
+ )
+
+ with sp_c2:
+ if spider_filter_mode == "Model IDs":
+ st.markdown(
+ '
Model IDs (max 10)
',
+ unsafe_allow_html=True,
+ )
+ spider_model_ids = st.multiselect(
+ "Model IDs",
+ ALL_MODEL_IDS,
+ default=st.session_state.get("spider_model_ids", DEFAULT_MODEL_IDS),
+ max_selections=10,
+ label_visibility="collapsed",
+ key="spider_model_ids",
+ )
+ else:
+ st.markdown(
+ '
Cancer Types (max 5)
',
+ unsafe_allow_html=True,
+ )
+ spider_cancer_types = st.multiselect(
+ "Cancer Types",
+ ALL_DISEASES,
+ default=st.session_state.get(
+ "spider_cancer_types", ALL_DISEASES[:2]
+ ),
+ max_selections=5,
+ label_visibility="collapsed",
+ key="spider_cancer_types",
+ )
+ st.markdown(
+ '
Aggregation
',
+ unsafe_allow_html=True,
+ )
+ spider_agg = st.radio(
+ "Aggregation",
+ ["Mean", "Min", "Max"],
+ horizontal=True,
+ key="spider_agg",
+ label_visibility="collapsed",
+ )
+
+ with sp_c3:
+ st.markdown(
+ '
Process limit
', unsafe_allow_html=True
+ )
+ limit_processes = st.toggle(
+ "Limit axes", value=False, key="spider_limit_toggle"
+ )
+ if limit_processes:
+ max_processes = st.slider(
+ "Max processes per plot",
+ min_value=3,
+ max_value=50,
+ value=20,
+ step=1,
+ key="spider_max_proc",
+ label_visibility="collapsed",
+ )
+ else:
+ max_processes = None
+ st.markdown("
', unsafe_allow_html=True)
+ ctl1, ctl2, ctl3, ctl4, ctl5 = st.columns(5)
+ with ctl1:
+ selected_diseases_scores = disease_controls("scores")
+ with ctl2:
+ scores_dataset = st.selectbox(
+ "Dataset",
+ options=["Reactome", "CORUM", "Drug"],
+ key="scores_dataset",
+ )
+ with ctl3:
+ top_n_scores = st.slider(
+ "Top N processes",
+ min_value=3,
+ max_value=50,
+ value=15,
+ step=1,
+ key="scores_top_n",
+ )
+ with ctl4:
+ top_m_types = st.slider(
+ "Top M cancer types",
+ min_value=1,
+ max_value=len(selected_diseases_scores),
+ value=8,
+ step=1,
+ key="scores_top_m",
+ )
+ with ctl5:
+ top_i_models = st.slider(
+ "Top I model IDs",
+ min_value=1,
+ max_value=30,
+ value=8,
+ step=1,
+ key="scores_top_i",
+ )
+ st.markdown("
", unsafe_allow_html=True)
+
+ score_df = all_matrices[scores_dataset].copy()
+ score_df = score_df[
+ score_df["OncotreePrimaryDisease"].isin(selected_diseases_scores)
+ ]
+ meta_cols = ["ModelID", "OncotreePrimaryDisease"]
+ score_cols = [c for c in score_df.columns if c not in meta_cols]
+
+ # โโ Heatmap: cancer types โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ st.markdown("---")
+ st.markdown("#### By cancer type")
+ st.markdown(
+ "Mean dependency score per process averaged across all cell lines in each cancer type. "
+ "Top N processes by max mean score across shown cancer types."
+ )
+
+ disease_means = (
+ score_df.groupby("OncotreePrimaryDisease")[score_cols].mean().reset_index()
+ )
+ disease_means["_max"] = disease_means[score_cols].max(axis=1)
+ top_diseases = disease_means.nlargest(top_m_types, "_max")[
+ "OncotreePrimaryDisease"
+ ].tolist()
+ disease_means = disease_means[
+ disease_means["OncotreePrimaryDisease"].isin(top_diseases)
+ ].drop(columns=["_max"])
+ top_processes = (
+ disease_means[score_cols].max(axis=0).nlargest(top_n_scores).index.tolist()
+ )
+ heatmap_disease = disease_means.set_index("OncotreePrimaryDisease")[top_processes]
+
+ fig_disease = go.Figure(
+ go.Heatmap(
+ z=heatmap_disease.values,
+ x=[
+ textwrap.shorten(p, width=30, placeholder="โฆ")
+ for p in heatmap_disease.columns
+ ],
+ y=heatmap_disease.index.tolist(),
+ colorscale="Blues",
+ hovertemplate="Disease: %{y}
Process: %{x}
Score: %{z:.3f}",
+ colorbar=dict(title="Mean score", thickness=14, len=0.6),
+ )
+ )
+ fig_disease.update_layout(
+ height=max(300, top_m_types * 36 + 120),
+ margin=dict(l=20, r=20, t=30, b=120),
+ paper_bgcolor="#0d1117",
+ plot_bgcolor="#0d1117",
+ font=dict(color="#e6edf3", size=11),
+ xaxis=dict(tickangle=-40, gridcolor="#21262d"),
+ yaxis=dict(gridcolor="#21262d"),
+ )
+ st.plotly_chart(fig_disease, use_container_width=True)
+
+ # โโ Heatmap: model IDs โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ st.markdown("---")
+ st.markdown("#### By model ID")
+ st.markdown(
+ "Raw dependency score per process for individual cell lines ranked by peak score."
+ )
+
+ score_df["_max"] = score_df[score_cols].max(axis=1)
+ top_models = score_df.nlargest(top_i_models, "_max")["ModelID"].tolist()
+ score_df = score_df.drop(columns=["_max"])
+ model_df = score_df[score_df["ModelID"].isin(top_models)].set_index("ModelID")[
+ top_processes
+ ]
+
+ fig_model = go.Figure(
+ go.Heatmap(
+ z=model_df.values,
+ x=[
+ textwrap.shorten(p, width=30, placeholder="โฆ") for p in model_df.columns
+ ],
+ y=model_df.index.tolist(),
+ colorscale="Purples",
+ hovertemplate="Model: %{y}
Process: %{x}
Score: %{z:.3f}",
+ colorbar=dict(title="Score", thickness=14, len=0.6),
+ )
+ )
+ fig_model.update_layout(
+ height=max(300, top_i_models * 36 + 120),
+ margin=dict(l=20, r=20, t=30, b=120),
+ paper_bgcolor="#0d1117",
+ plot_bgcolor="#0d1117",
+ font=dict(color="#e6edf3", size=11),
+ xaxis=dict(tickangle=-40, gridcolor="#21262d"),
+ yaxis=dict(gridcolor="#21262d"),
+ )
+ st.plotly_chart(fig_model, use_container_width=True)
+
+ # โโ Bar charts โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ st.markdown("---")
+ st.markdown("#### Overall top processes")
+ st.markdown("Global mean score per process across all filtered cell lines, ranked.")
+
+ overall_means = score_df[score_cols].mean().nlargest(top_n_scores).reset_index()
+ overall_means.columns = ["Process", "Mean Score"]
+ overall_means["Process"] = overall_means["Process"].apply(
+ lambda p: textwrap.shorten(p, width=40, placeholder="โฆ")
+ )
+
+ bar1, bar2 = st.columns(2)
+
+ _bar_layout = dict(
+ margin=dict(l=10, r=10, t=40, b=20),
+ paper_bgcolor="#0d1117",
+ plot_bgcolor="#0d1117",
+ font=dict(color="#e6edf3", size=11),
+ yaxis=dict(autorange="reversed", gridcolor="#21262d"),
+ xaxis=dict(gridcolor="#21262d"),
+ coloraxis_showscale=False,
+ showlegend=False,
+ )
+
+ with bar1:
+ fig_bar_all = px.bar(
+ overall_means,
+ x="Mean Score",
+ y="Process",
+ orientation="h",
+ title="Top processes โ all cell lines",
+ color="Mean Score",
+ color_continuous_scale="Blues",
+ )
+ fig_bar_all.update_layout(
+ height=max(300, top_n_scores * 24 + 80), **_bar_layout
+ )
+ st.plotly_chart(fig_bar_all, use_container_width=True)
+
+ with bar2:
+ top_disease_means = (
+ score_df[score_df["OncotreePrimaryDisease"].isin(top_diseases)][score_cols]
+ .mean()
+ .nlargest(top_n_scores)
+ .reset_index()
+ )
+ top_disease_means.columns = ["Process", "Mean Score"]
+ top_disease_means["Process"] = top_disease_means["Process"].apply(
+ lambda p: textwrap.shorten(p, width=40, placeholder="โฆ")
+ )
+ fig_bar_top = px.bar(
+ top_disease_means,
+ x="Mean Score",
+ y="Process",
+ orientation="h",
+ title=f"Top processes โ top {top_m_types} cancer types",
+ color="Mean Score",
+ color_continuous_scale="Purples",
+ )
+ fig_bar_top.update_layout(
+ height=max(300, top_n_scores * 24 + 80), **_bar_layout
+ )
+ st.plotly_chart(fig_bar_top, use_container_width=True)
+
+
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+# TAB 5 โ Data table
+# โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+with tab_table:
+ st.markdown("### Cancer Types & Primary Diseases")
+ st.markdown("Summary of all cancer types and their associated primary diseases.")
+
+ with st.container():
+ st.markdown('', unsafe_allow_html=True)
+ selected_diseases_table = disease_controls("table")
+ st.markdown("
", unsafe_allow_html=True)
+
+ reactome_matrix, _, _ = latent_load_data()
+ full_df = reactome_matrix[
+ reactome_matrix["OncotreePrimaryDisease"].isin(selected_diseases_table)
+ ]
+
+ summary = (
+ full_df.groupby(["OncotreePrimaryDisease", "ModelID"], dropna=False)
+ .size()
+ .reset_index(name="_n")
+ .drop(columns=["_n"])
+ .drop_duplicates()
+ .rename(columns={"OncotreePrimaryDisease": "Primary Disease"})
+ .sort_values(["Primary Disease", "ModelID"])
+ )
+
+ m1, m2 = st.columns(2)
+ m1.markdown(
+ f'Primary diseases
{summary["Primary Disease"].nunique()}
Total cell lines
{int(summary["ModelID"].nunique())}