{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "84cd686a", "metadata": {}, "outputs": [], "source": [ "import os\n", "output_dir = \"output/batch_benchmark\"\n", "os.makedirs(output_dir, exist_ok=True)\n" ] }, { "cell_type": "markdown", "id": "cb8d0321", "metadata": {}, "source": [ "# Batch Effect Benchmark" ] }, { "cell_type": "markdown", "id": "43fdcb1d", "metadata": {}, "source": [ "## HVG" ] }, { "cell_type": "code", "execution_count": 2, "id": "71fdbcb5", "metadata": {}, "outputs": [], "source": [ "# Initialize \n", "source_path = \"../REVISE/results\"\n", "task = \"spot\"\n", "patient_id = \"P2CRC\"\n", "\n", "result_path = f\"{source_path}/{task}/{patient_id}\"\n", "data_path = f\"../REVISE/data/{task}/{patient_id}\"\n", "\n", "parts = [\"part3\", \"part1\", \"part2\"]\n", "batch_nums = [1, 2, 3, 4]\n", "metrics = [\"PCC\", \"SSIM\", \"MSE\"]\n", "spot_sizes = [50, 100, 150, 200]\n", "\n", "gene_type = \"HVG\"\n", "gene_num = 50" ] }, { "cell_type": "code", "execution_count": null, "id": "ff5a7ed9", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import scanpy as sc\n", "from tqdm import tqdm\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "def get_genes(result_path, data_path, part, spot_size, batch_num, gene_type = \"HVG\", gene_num = 50, test_genes = None): \n", " ## Get HVG or HEG or ALL\n", " spot_path = os.path.join(data_path, f\"cut_{part}\", f\"spot_{spot_size}\")\n", " save_path = os.path.join(result_path, part, f\"{spot_size}_{batch_num}\", \"select_gene\")\n", " os.makedirs(save_path, exist_ok=True)\n", "\n", " gene_file = f\"{save_path}/{gene_type}_{batch_num}_genes_{gene_num}.txt\"\n", " if os.path.exists(gene_file):\n", " # print(f\"Find {gene_type} genes in {gene_file}\")\n", " with open(gene_file, \"r\") as f:\n", " genes = f.read().splitlines()\n", " return genes\n", "\n", " st_path = f\"{spot_path}/xenium_spot.h5ad\"\n", " adata = sc.read(st_path)\n", " if test_genes is not None:\n", " overlap_genes = [gene for gene in test_genes if gene in adata.var_names]\n", " adata = adata[:, overlap_genes]\n", " \n", " if gene_type == \"HVG\":\n", " sc.pp.filter_genes(adata, min_cells=1)\n", " sc.pp.normalize_total(adata, target_sum=1e4)\n", " sc.pp.highly_variable_genes(adata, flavor='seurat_v3', n_top_genes=gene_num)\n", " genes = adata.var[adata.var['highly_variable']].index.tolist()\n", " elif gene_type == \"HEG\":\n", " adata.var['sum'] = adata.X.toarray().sum(axis=0)\n", " adata.var.sort_values('sum', ascending=True, inplace=True)\n", " genes = adata.var.head(gene_num).index.tolist()\n", " else:\n", " genes = adata.var_names\n", " \n", " with open(gene_file, \"w\") as f:\n", " f.write(\"\\n\".join(genes))\n", " # print(f\"Save {gene_type} genes to {gene_file}\")\n", "\n", " return genes\n", "\n", "def get_merge_df(result_path, data_path, part, metric, spot_sizes, batch_nums):\n", "\n", " merge_df = pd.DataFrame()\n", " for spot_size in tqdm(spot_sizes, desc=\"spot_sizes\"): \n", " for batch_num in batch_nums:\n", " metric_file = f\"{result_path}/{part}/{spot_size}_{batch_num}/metrics_normalized.csv\"\n", " df = pd.read_csv(metric_file, index_col=0)\n", " genes = get_genes(result_path, data_path, part, spot_size, batch_num, gene_type = gene_type, gene_num = gene_num, test_genes = df.index)\n", " df = df.loc[genes]\n", "\n", " df = pd.DataFrame({\n", " 'Method': batch_num,\n", " 'Value': df[metric].values,\n", " 'Spot_size': spot_size,\n", " 'Part': part,\n", " 'Metric': metric,\n", " })\n", " \n", " merge_df = pd.concat([merge_df, df])\n", " merge_df.reset_index(drop=True, inplace=True)\n", " return merge_df\n", "\n", "def plot_comp_seg(merge_df, metric, part, ax):\n", " \n", " spot_size_order = [50, 100, 150, 200]\n", " method_order = [1,2,3,4]\n", " custom_palette = {\n", " 1: '#80a9c8',\n", " 2: '#e89786',\n", " 3: '#8ccfd9',\n", " 4: '#b39a94',\n", " }\n", " # boxplot\n", " sns.boxplot(\n", " data=merge_df,\n", " x='Spot_size',\n", " y='Value',\n", " hue='Method',\n", " order=spot_size_order,\n", " hue_order=method_order,\n", " palette=[custom_palette[m] for m in method_order],\n", " width=0.6,\n", " fliersize=2,\n", " showfliers=False,\n", " ax=ax\n", " )\n", " # ax.set_title(f'{part}', fontsize=11, pad=8)\n", " # ax.set_xlabel('Spot Size', fontsize=10)\n", " ax.set_ylabel(metric, fontsize=10)\n", " ax.xaxis.set_visible(False)\n", "\n", " if metric == \"PCC\":\n", " ax.set_ylim(0, 1.02)\n", " elif metric == \"SSIM\":\n", " ax.set_ylim(0.5, 1.02)\n", " elif metric == \"MSE\":\n", " ax.set_ylim(1e-5, 1e-2)\n", " ax.set_yscale('log')\n", "\n", " if ax.get_legend() is not None:\n", " ax.legend_.remove()\n", " ax.set_aspect('auto')" ] }, { "cell_type": "code", "execution_count": null, "id": "7aab2ea3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "spot_sizes: 100%|██████████| 4/4 [00:01<00:00, 3.70it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 36.14it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 18.12it/s]\n", "parts: 100%|██████████| 3/3 [00:01<00:00, 2.11it/s]\n" ] } ], "source": [ "# compute mean\n", "parts = [\"part3\", \"part1\", \"part2\"]\n", "metrics = [\"PCC\", \"SSIM\", \"MSE\"]\n", "spot_sizes = [50, 100, 150, 200]\n", "\n", "\n", "save_dir = f\"{output_dir}/{gene_type}_mean\"\n", "os.makedirs(save_dir, exist_ok=True)\n", "for part in tqdm(parts, desc=\"parts\"):\n", " for spot_size in tqdm(spot_sizes, desc=\"spot_sizes\"): \n", " merge_df = pd.DataFrame()\n", " for batch_num in batch_nums:\n", " metric_file = f\"{result_path}/{part}/{spot_size}_{batch_num}/metrics_normalized.csv\"\n", " df = pd.read_csv(metric_file, index_col=0)\n", " genes = get_genes(result_path, data_path, part, spot_size, batch_num, gene_type = gene_type, gene_num = gene_num, test_genes = df.index)\n", " df = df.loc[genes]\n", " \n", " df = df[metrics].mean(axis=0)\n", " \n", " merge_df = pd.concat([merge_df, df], axis=1)\n", " merge_df.reset_index(drop=True, inplace=True)\n", " merge_df.index = metrics\n", " merge_df.columns = [\"Batch_1\", \"Batch_2\", \"Batch_3\", \"Batch_4\"]\n", " merge_df.T.to_csv(f\"{save_dir}/{part}_{spot_size}_{gene_type}_{gene_num}.csv\")\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "5c4aaeb8", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "spot_sizes: 0%| | 0/4 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(3, 3, figsize=(12, 9))\n", "\n", "for i, part in enumerate(parts):\n", " for j, metric in enumerate(metrics):\n", "\n", " merge_df = get_merge_df(result_path, data_path, part, metric, spot_sizes, batch_nums)\n", " \n", " ax = axes[j, i]\n", " plot_comp_seg(merge_df, metric, part, ax)\n", "\n", "plt.tight_layout()\n", "plt.savefig(f\"{output_dir}/batch_effect_{gene_type}_{gene_num}.pdf\", dpi=300)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "2cca605e", "metadata": {}, "source": [ "## All genes" ] }, { "cell_type": "code", "execution_count": 33, "id": "542fd3cf", "metadata": {}, "outputs": [], "source": [ "gene_type = \"ALL\"\n", "def plot_comp_seg(merge_df, metric, part, ax):\n", " \n", " spot_size_order = [50, 100, 150, 200]\n", " method_order = [1,2,3,4]\n", " custom_palette = {\n", " 1: '#80a9c8',\n", " 2: '#b39a94',\n", " 3: '#8ccfd9',\n", " 4: '#e89786',\n", " }\n", " # Plot boxplots\n", " sns.boxplot(\n", " data=merge_df,\n", " x='Spot_size',\n", " y='Value',\n", " hue='Method',\n", " order=spot_size_order,\n", " hue_order=method_order,\n", " palette=[custom_palette[m] for m in method_order],\n", " width=0.6,\n", " fliersize=2,\n", " showfliers=False,\n", " ax=ax\n", " )\n", " # ax.set_title(f'{part}', fontsize=11, pad=8)\n", " # ax.set_xlabel('Spot Size', fontsize=10)\n", " ax.set_ylabel(metric, fontsize=10)\n", " ax.xaxis.set_visible(False)\n", "\n", " if metric == \"PCC\":\n", " ax.set_ylim(-0.02, 1.02)\n", " elif metric == \"SSIM\":\n", " ax.set_ylim(0, 1.02)\n", " elif metric == \"MSE\":\n", " ax.set_ylim(1e-5, 1e-1)\n", " ax.set_yscale('log')\n", "\n", " if ax.get_legend() is not None:\n", " ax.legend_.remove()\n", " ax.set_aspect('auto')" ] }, { "cell_type": "code", "execution_count": null, "id": "ddae65cb", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 77.87it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 153.81it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 145.06it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 149.87it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 150.76it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 149.96it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 151.82it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 152.39it/s]\n", "spot_sizes: 100%|██████████| 4/4 [00:00<00:00, 151.33it/s]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(3, 3, figsize=(12, 9))\n", "\n", "for i, part in enumerate(parts):\n", " for j, metric in enumerate(metrics):\n", "\n", " merge_df = get_merge_df(result_path, data_path, part, metric, spot_sizes, batch_nums)\n", " \n", " ax = axes[j, i]\n", " plot_comp_seg(merge_df, metric, part, ax)\n", "\n", "plt.tight_layout()\n", "plt.savefig(f\"{output_dir}/batch_effect_{gene_type}_{gene_num}.pdf\", dpi=300)\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "python3.10", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.14" } }, "nbformat": 4, "nbformat_minor": 5 }