From 0873e4696ed804eada227971e5b70e0d6c472d98 Mon Sep 17 00:00:00 2001 From: silask Date: Wed, 25 Oct 2023 13:46:29 +0200 Subject: [PATCH] start translating genen catalog --- Python/Genecatalog.ipynb | 374 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 366 insertions(+), 8 deletions(-) diff --git a/Python/Genecatalog.ipynb b/Python/Genecatalog.ipynb index 350fc5e..4fa5702 100644 --- a/Python/Genecatalog.ipynb +++ b/Python/Genecatalog.ipynb @@ -23,12 +23,15 @@ "import matplotlib.pylab as plt\n", "import seaborn as sns\n", "from pathlib import Path\n", - "import h5py" + "import h5py\n", + "\n", + "import yaml\n", + "import os" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -44,14 +47,369 @@ } ], "source": [ - "atlas_dir= Path(\"../DiarrheaExample/\")\n", "\n", - "gene_abundance_file= atlas_dir/\"Genecatalog/counts/median_coverage.h5\"\n", "\n", - "with h5py.File(gene_abundance_file, 'r') as hdf_file:\n", + "data_dir = \"../DiarrheaExample/\"\n", + "atlas_version = \"v2.17\"\n", + "\n", + "# Load the YAML configuration file\n", + "with open(\"../atlas_output_files.yaml\", 'r') as yaml_file:\n", + " config = yaml.load(yaml_file, Loader=yaml.FullLoader)\n", + "\n", + "# Access the specified version in the configuration\n", + "files = config[atlas_version]\n", + "\n", + "# Function to update file paths in the nested dictionary\n", + "def update_paths(value, data_dir):\n", + " if isinstance(value, str):\n", + " return os.path.join(data_dir, value)\n", + " elif isinstance(value, dict):\n", + " return {key: update_paths(subvalue, data_dir) for key, subvalue in value.items()}\n", + "\n", + "# Update file paths in the configuration\n", + "files = update_paths(files, data_dir)\n", + "\n", + "# Access the \"abundance_file\" from the updated configuration\n", + "genecatalog_files = files[\"genecatalog\"]\n", + "abundance_file = genecatalog_files[\"coverage\"]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Look at the gene stats\n", + "\n", + "Let's have a look at the dimension of the data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "\"Unable to synchronously open object (object 'dim' doesn't exist)\"", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/silas/Documents/GitHub/Tutorial/Python/Genecatalog.ipynb Cell 3\u001b[0m line \u001b[0;36m4\n\u001b[1;32m 1\u001b[0m \u001b[39m# Open the HDF5 file\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[39mwith\u001b[39;00m h5py\u001b[39m.\u001b[39mFile(abundance_file, \u001b[39m'\u001b[39m\u001b[39mr\u001b[39m\u001b[39m'\u001b[39m) \u001b[39mas\u001b[39;00m h5file:\n\u001b[1;32m 3\u001b[0m \u001b[39m# Get the dimensions\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m dim \u001b[39m=\u001b[39m h5file[\u001b[39m'\u001b[39;49m\u001b[39mdim\u001b[39;49m\u001b[39m'\u001b[39;49m][:]\n\u001b[1;32m 5\u001b[0m Ngenes, Nsamples \u001b[39m=\u001b[39m dim\n\u001b[1;32m 7\u001b[0m \u001b[39m# Print the dimensions\u001b[39;00m\n", + "File \u001b[0;32mh5py/_objects.pyx:54\u001b[0m, in \u001b[0;36mh5py._objects.with_phil.wrapper\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mh5py/_objects.pyx:55\u001b[0m, in \u001b[0;36mh5py._objects.with_phil.wrapper\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/h5py/_hl/group.py:357\u001b[0m, in \u001b[0;36mGroup.__getitem__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 355\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mInvalid HDF5 object reference\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 356\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(name, (\u001b[39mbytes\u001b[39m, \u001b[39mstr\u001b[39m)):\n\u001b[0;32m--> 357\u001b[0m oid \u001b[39m=\u001b[39m h5o\u001b[39m.\u001b[39;49mopen(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mid, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_e(name), lapl\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_lapl)\n\u001b[1;32m 358\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 359\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mAccessing a group is done with bytes or str, \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 360\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mnot \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\u001b[39mtype\u001b[39m(name)))\n", + "File \u001b[0;32mh5py/_objects.pyx:54\u001b[0m, in \u001b[0;36mh5py._objects.with_phil.wrapper\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mh5py/_objects.pyx:55\u001b[0m, in \u001b[0;36mh5py._objects.with_phil.wrapper\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mh5py/h5o.pyx:189\u001b[0m, in \u001b[0;36mh5py.h5o.open\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: \"Unable to synchronously open object (object 'dim' doesn't exist)\"" + ] + } + ], + "source": [ + "\n", + "\n", + "# Open the HDF5 file\n", + "with h5py.File(abundance_file, 'r') as h5file:\n", + " # Get the dimensions\n", + " dim = h5file['dim'][:]\n", + " Ngenes, Nsamples = dim\n", + "\n", + "# Print the dimensions\n", + "print(f\"The genecatalog contains {Ngenes} genes and {Nsamples} samples.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Because the dimensions of the genecatalog are huge (even more so with more samples) but\n", + "many genes are detected only in a subset of samples,\n", + "I optimized the file format to allow for fast loading of a subset of the data.\n", + "\n", + "However we still want information from all the genes.\n", + "The file `r genecatalog_files$sample_stats` contains stats per sample of the genecatalog.\n", + "Especially the number of genes that are detected in each sample and the total coverage which we will use for normalization.\n", + "\n", + "Similarly the file `r gene_catalog_files$gene_stats` contains stats per gene, e.g. the number of samples in which the gene is detected.\n", + "\n", + "Let's first look at the stats per sample.\n", + "\n", + "### Gene stats per sample" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 589, + "width": 1183 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a subplot with two axes\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Plot \"Total coverage\" on the first axis\n", + "sns.swarmplot(y=\"Sum_coverage\", data=sample_stats, ax=axes[0])\n", + "axes[0].set_ylabel(\"\",visible=False)\n", + "axes[0].set_title(\"Total coverage\")\n", + "\n", + "# Plot \"N detected genes\" on the second axis\n", + "sns.swarmplot(y=\"Genes_nz_coverage\", data=sample_stats, ax=axes[1])\n", + "axes[1].set_ylabel(\"\",visible=False)\n", + "axes[1].set_title(\"N detected genes\")\n", + "\n", + "# Set a common title for both axes\n", + "fig.suptitle(\"Gene stats per sample\", fontsize=16)\n", + "\n", + "# Adjust spacing between subplots\n", + "plt.tight_layout(rect=[0, 0, 1, 0.95])\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stats per gene\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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", + "
GeneNameLengthGCSamples_nz_coverageSamples_nz_countsSum_coverageMax_coverage
0Gene0000015310.386117302093900
1Gene0000027230.4716101939994
2Gene0000039510.5047818771273
3Gene0000045370.4646585022
4Gene0000054050.5210610168
\n", + "
" + ], + "text/plain": [ + " GeneName Length GC Samples_nz_coverage Samples_nz_counts \\\n", + "0 Gene000001 531 0.3861 17 30 \n", + "1 Gene000002 723 0.4716 10 19 \n", + "2 Gene000003 951 0.5047 8 18 \n", + "3 Gene000004 537 0.4646 5 8 \n", + "4 Gene000005 405 0.5210 6 10 \n", + "\n", + " Sum_coverage Max_coverage \n", + "0 2093 900 \n", + "1 399 94 \n", + "2 771 273 \n", + "3 50 22 \n", + "4 16 8 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "gene_stats_file = genecatalog_files[\"coverage_stats\"]\n", + "gene_stats = pd.read_parquet(gene_stats_file)\n", + "\n", + "\n", + "gene_stats.head()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Samples_nz_coverage: Number of samples in which the gene has a non-zero coverage\n", + "Samples_nz_counts: Number of samples in which the gene has a non-zero counts\n", + "Sum_coverage: Sum of the coverage of the gene in all samples\n", + "\n", + "The values for `Samples_nz_coverage` and `Samples_nz_counts` are not the same\n", + "because if there are only a view reads mapped to a gene but less than halve of the gene is covered the median coverage is zero.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/Users/silas/miniforge3/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/silas/Documents/GitHub/Tutorial/Python/Genecatalog.ipynb Cell 10\u001b[0m line \u001b[0;36m3\n\u001b[1;32m 1\u001b[0m \u001b[39m# Create a histogram for log10(Sum_coverage)\u001b[39;00m\n\u001b[1;32m 2\u001b[0m plt\u001b[39m.\u001b[39mfigure(figsize\u001b[39m=\u001b[39m(\u001b[39m8\u001b[39m, \u001b[39m4\u001b[39m))\n\u001b[0;32m----> 3\u001b[0m sns\u001b[39m.\u001b[39;49mhistplot(gene_stats[\u001b[39m\"\u001b[39;49m\u001b[39mSum_coverage\u001b[39;49m\u001b[39m\"\u001b[39;49m], binwidth\u001b[39m=\u001b[39;49m\u001b[39m0.2\u001b[39;49m, color\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mblue\u001b[39;49m\u001b[39m\"\u001b[39;49m, kde\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n\u001b[1;32m 4\u001b[0m plt\u001b[39m.\u001b[39mtitle(\u001b[39m\"\u001b[39m\u001b[39mHistogram of log10(Sum_coverage)\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 5\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m\"\u001b[39m\u001b[39mlog10(Sum_coverage)\u001b[39m\u001b[39m\"\u001b[39m)\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/seaborn/distributions.py:1432\u001b[0m, in \u001b[0;36mhistplot\u001b[0;34m(data, x, y, hue, weights, stat, bins, binwidth, binrange, discrete, cumulative, common_bins, common_norm, multiple, element, fill, shrink, kde, kde_kws, line_kws, thresh, pthresh, pmax, cbar, cbar_ax, cbar_kws, palette, hue_order, hue_norm, color, log_scale, legend, ax, **kwargs)\u001b[0m\n\u001b[1;32m 1421\u001b[0m estimate_kws \u001b[39m=\u001b[39m \u001b[39mdict\u001b[39m(\n\u001b[1;32m 1422\u001b[0m stat\u001b[39m=\u001b[39mstat,\n\u001b[1;32m 1423\u001b[0m bins\u001b[39m=\u001b[39mbins,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1427\u001b[0m cumulative\u001b[39m=\u001b[39mcumulative,\n\u001b[1;32m 1428\u001b[0m )\n\u001b[1;32m 1430\u001b[0m \u001b[39mif\u001b[39;00m p\u001b[39m.\u001b[39munivariate:\n\u001b[0;32m-> 1432\u001b[0m p\u001b[39m.\u001b[39;49mplot_univariate_histogram(\n\u001b[1;32m 1433\u001b[0m multiple\u001b[39m=\u001b[39;49mmultiple,\n\u001b[1;32m 1434\u001b[0m element\u001b[39m=\u001b[39;49melement,\n\u001b[1;32m 1435\u001b[0m fill\u001b[39m=\u001b[39;49mfill,\n\u001b[1;32m 1436\u001b[0m shrink\u001b[39m=\u001b[39;49mshrink,\n\u001b[1;32m 1437\u001b[0m common_norm\u001b[39m=\u001b[39;49mcommon_norm,\n\u001b[1;32m 1438\u001b[0m common_bins\u001b[39m=\u001b[39;49mcommon_bins,\n\u001b[1;32m 1439\u001b[0m kde\u001b[39m=\u001b[39;49mkde,\n\u001b[1;32m 1440\u001b[0m kde_kws\u001b[39m=\u001b[39;49mkde_kws,\n\u001b[1;32m 1441\u001b[0m color\u001b[39m=\u001b[39;49mcolor,\n\u001b[1;32m 1442\u001b[0m legend\u001b[39m=\u001b[39;49mlegend,\n\u001b[1;32m 1443\u001b[0m estimate_kws\u001b[39m=\u001b[39;49mestimate_kws,\n\u001b[1;32m 1444\u001b[0m line_kws\u001b[39m=\u001b[39;49mline_kws,\n\u001b[1;32m 1445\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs,\n\u001b[1;32m 1446\u001b[0m )\n\u001b[1;32m 1448\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 1450\u001b[0m p\u001b[39m.\u001b[39mplot_bivariate_histogram(\n\u001b[1;32m 1451\u001b[0m common_bins\u001b[39m=\u001b[39mcommon_bins,\n\u001b[1;32m 1452\u001b[0m common_norm\u001b[39m=\u001b[39mcommon_norm,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1462\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs,\n\u001b[1;32m 1463\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/seaborn/distributions.py:575\u001b[0m, in \u001b[0;36m_DistributionPlotter.plot_univariate_histogram\u001b[0;34m(self, multiple, element, fill, common_norm, common_bins, shrink, kde, kde_kws, color, legend, line_kws, estimate_kws, **plot_kws)\u001b[0m\n\u001b[1;32m 570\u001b[0m \u001b[39mif\u001b[39;00m element \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mbars\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m 571\u001b[0m \n\u001b[1;32m 572\u001b[0m \u001b[39m# Use matplotlib bar plotting\u001b[39;00m\n\u001b[1;32m 574\u001b[0m plot_func \u001b[39m=\u001b[39m ax\u001b[39m.\u001b[39mbar \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdata_variable \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mx\u001b[39m\u001b[39m\"\u001b[39m \u001b[39melse\u001b[39;00m ax\u001b[39m.\u001b[39mbarh\n\u001b[0;32m--> 575\u001b[0m artists \u001b[39m=\u001b[39m plot_func(\n\u001b[1;32m 576\u001b[0m hist[\u001b[39m\"\u001b[39;49m\u001b[39medges\u001b[39;49m\u001b[39m\"\u001b[39;49m],\n\u001b[1;32m 577\u001b[0m hist[\u001b[39m\"\u001b[39;49m\u001b[39mheights\u001b[39;49m\u001b[39m\"\u001b[39;49m] \u001b[39m-\u001b[39;49m bottom,\n\u001b[1;32m 578\u001b[0m hist[\u001b[39m\"\u001b[39;49m\u001b[39mwidths\u001b[39;49m\u001b[39m\"\u001b[39;49m],\n\u001b[1;32m 579\u001b[0m bottom,\n\u001b[1;32m 580\u001b[0m align\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39medge\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m 581\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49martist_kws,\n\u001b[1;32m 582\u001b[0m )\n\u001b[1;32m 584\u001b[0m \u001b[39mfor\u001b[39;00m bar \u001b[39min\u001b[39;00m artists:\n\u001b[1;32m 585\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdata_variable \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mx\u001b[39m\u001b[39m\"\u001b[39m:\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/__init__.py:1465\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1462\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m 1463\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minner\u001b[39m(ax, \u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 1464\u001b[0m \u001b[39mif\u001b[39;00m data \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m-> 1465\u001b[0m \u001b[39mreturn\u001b[39;00m func(ax, \u001b[39m*\u001b[39;49m\u001b[39mmap\u001b[39;49m(sanitize_sequence, args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1467\u001b[0m bound \u001b[39m=\u001b[39m new_sig\u001b[39m.\u001b[39mbind(ax, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 1468\u001b[0m auto_label \u001b[39m=\u001b[39m (bound\u001b[39m.\u001b[39marguments\u001b[39m.\u001b[39mget(label_namer)\n\u001b[1;32m 1469\u001b[0m \u001b[39mor\u001b[39;00m bound\u001b[39m.\u001b[39mkwargs\u001b[39m.\u001b[39mget(label_namer))\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/axes/_axes.py:2534\u001b[0m, in \u001b[0;36mAxes.bar\u001b[0;34m(self, x, height, width, bottom, align, **kwargs)\u001b[0m\n\u001b[1;32m 2532\u001b[0m \u001b[39melse\u001b[39;00m: \u001b[39m# horizontal\u001b[39;00m\n\u001b[1;32m 2533\u001b[0m r\u001b[39m.\u001b[39msticky_edges\u001b[39m.\u001b[39mx\u001b[39m.\u001b[39mappend(l)\n\u001b[0;32m-> 2534\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49madd_patch(r)\n\u001b[1;32m 2535\u001b[0m patches\u001b[39m.\u001b[39mappend(r)\n\u001b[1;32m 2537\u001b[0m \u001b[39mif\u001b[39;00m xerr \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mor\u001b[39;00m yerr \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/axes/_base.py:2384\u001b[0m, in \u001b[0;36m_AxesBase.add_patch\u001b[0;34m(self, p)\u001b[0m\n\u001b[1;32m 2382\u001b[0m \u001b[39mif\u001b[39;00m p\u001b[39m.\u001b[39mget_clip_path() \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 2383\u001b[0m p\u001b[39m.\u001b[39mset_clip_path(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mpatch)\n\u001b[0;32m-> 2384\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_update_patch_limits(p)\n\u001b[1;32m 2385\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_children\u001b[39m.\u001b[39mappend(p)\n\u001b[1;32m 2386\u001b[0m p\u001b[39m.\u001b[39m_remove_method \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_children\u001b[39m.\u001b[39mremove\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/axes/_base.py:2406\u001b[0m, in \u001b[0;36m_AxesBase._update_patch_limits\u001b[0;34m(self, patch)\u001b[0m\n\u001b[1;32m 2403\u001b[0m \u001b[39m# Get all vertices on the path\u001b[39;00m\n\u001b[1;32m 2404\u001b[0m \u001b[39m# Loop through each segment to get extrema for Bezier curve sections\u001b[39;00m\n\u001b[1;32m 2405\u001b[0m vertices \u001b[39m=\u001b[39m []\n\u001b[0;32m-> 2406\u001b[0m \u001b[39mfor\u001b[39;00m curve, code \u001b[39min\u001b[39;00m p\u001b[39m.\u001b[39miter_bezier(simplify\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m):\n\u001b[1;32m 2407\u001b[0m \u001b[39m# Get distance along the curve of any extrema\u001b[39;00m\n\u001b[1;32m 2408\u001b[0m _, dzeros \u001b[39m=\u001b[39m curve\u001b[39m.\u001b[39maxis_aligned_extrema()\n\u001b[1;32m 2409\u001b[0m \u001b[39m# Calculate vertices of start, end and any extrema in between\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/path.py:445\u001b[0m, in \u001b[0;36mPath.iter_bezier\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 443\u001b[0m \u001b[39myield\u001b[39;00m BezierSegment(np\u001b[39m.\u001b[39marray([first_vert])), code\n\u001b[1;32m 444\u001b[0m \u001b[39melif\u001b[39;00m code \u001b[39m==\u001b[39m Path\u001b[39m.\u001b[39mLINETO: \u001b[39m# \"CURVE2\"\u001b[39;00m\n\u001b[0;32m--> 445\u001b[0m \u001b[39myield\u001b[39;00m BezierSegment(np\u001b[39m.\u001b[39;49marray([prev_vert, verts])), code\n\u001b[1;32m 446\u001b[0m \u001b[39melif\u001b[39;00m code \u001b[39m==\u001b[39m Path\u001b[39m.\u001b[39mCURVE3:\n\u001b[1;32m 447\u001b[0m \u001b[39myield\u001b[39;00m BezierSegment(np\u001b[39m.\u001b[39marray([prev_vert, verts[:\u001b[39m2\u001b[39m],\n\u001b[1;32m 448\u001b[0m verts[\u001b[39m2\u001b[39m:]])), code\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/bezier.py:195\u001b[0m, in \u001b[0;36mBezierSegment.__init__\u001b[0;34m(self, control_points)\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_d \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_cpoints\u001b[39m.\u001b[39mshape\n\u001b[1;32m 194\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_orders \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marange(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N)\n\u001b[0;32m--> 195\u001b[0m coeff \u001b[39m=\u001b[39m [math\u001b[39m.\u001b[39mfactorial(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m)\n\u001b[1;32m 196\u001b[0m \u001b[39m/\u001b[39m\u001b[39m/\u001b[39m (math\u001b[39m.\u001b[39mfactorial(i) \u001b[39m*\u001b[39m math\u001b[39m.\u001b[39mfactorial(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m i))\n\u001b[1;32m 197\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N)]\n\u001b[1;32m 198\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_px \u001b[39m=\u001b[39m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_cpoints\u001b[39m.\u001b[39mT \u001b[39m*\u001b[39m coeff)\u001b[39m.\u001b[39mT\n", + "File \u001b[0;32m~/miniforge3/lib/python3.10/site-packages/matplotlib/bezier.py:195\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_d \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_cpoints\u001b[39m.\u001b[39mshape\n\u001b[1;32m 194\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_orders \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marange(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N)\n\u001b[0;32m--> 195\u001b[0m coeff \u001b[39m=\u001b[39m [math\u001b[39m.\u001b[39mfactorial(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m)\n\u001b[1;32m 196\u001b[0m \u001b[39m/\u001b[39m\u001b[39m/\u001b[39m (math\u001b[39m.\u001b[39mfactorial(i) \u001b[39m*\u001b[39m math\u001b[39m.\u001b[39mfactorial(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m i))\n\u001b[1;32m 197\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_N)]\n\u001b[1;32m 198\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_px \u001b[39m=\u001b[39m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_cpoints\u001b[39m.\u001b[39mT \u001b[39m*\u001b[39m coeff)\u001b[39m.\u001b[39mT\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "\n", + "\n", + "# Create a histogram for log10(Sum_coverage)\n", + "plt.figure(figsize=(8, 4))\n", + "sns.histplot(gene_stats[\"Sum_coverage\"], binwidth=0.2, color=\"blue\", kde=True)\n", + "plt.title(\"Histogram of log10(Sum_coverage)\")\n", + "plt.xlabel(\"log10(Sum_coverage)\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()\n", "\n", - " # data_matrix = hdf_file['data'][:]\n", - " sample_names = hdf_file['data'].attrs['sample_names'].astype(str)" + "# Create a histogram for Samples_nz_coverage\n", + "plt.figure(figsize=(8, 4))\n", + "sns.histplot(gene_stats[\"Samples_nz_coverage\"], binwidth=10, color=\"green\", kde=True)\n", + "plt.title(\"Histogram of Samples_nz_coverage\")\n", + "plt.xlabel(\"Samples_nz_coverage\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.show()\n" ] }, { @@ -78,7 +436,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.10.12" }, "orig_nbformat": 4 },