diff --git a/notebook/annotate_cell_types.ipynb b/notebook/annotate_cell_types.ipynb new file mode 100644 index 0000000..6155730 --- /dev/null +++ b/notebook/annotate_cell_types.ipynb @@ -0,0 +1,903 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial 2: Access single-cell datasets from `scRNAseq` collection and annotate cell types\n", + "\n", + "Welcome to this tutorial on annotating single-cell datasets with reference collections. The **scRNAseq** ([R/Bioc](https://bioconductor.org/packages/devel/data/experiment/html/scRNAseq.html), [Python](https://github.com/BiocPy/scrnaseq)) package provides access to public single-cell RNA-seq datasets for use by other Bioconductor/BiocPy packages and workflows. These datasets are stored in language-agnostic representations described in [ArtifactDB](https://github.com/artifactdb), enabling easy access to datasets and analysis results across multiple programming languages such as R and Python. We will showcase how to integrate and process single-cell datasets across languages, such as R and Python, and how to annotate cell types using reference datasets.\n", + "\n", + "## Outline\n", + "\n", + "In this tutorial, you will learn how to:\n", + "\n", + "1. Install and set up BiocPy packages in your Python environment.\n", + "2. Explore the `scrnaseq` package and access public single-cell RNA-seq datasets.\n", + "3. Perform basic operations on `SingleCellExperiment` objects, the core data structure for single-cell data.\n", + "4. Annotate cell types using reference datasets from the `celldex` package.\n", + "\n", + "## Prerequisites\n", + "\n", + "Before we begin, please ensure that you have the following prerequisites installed:\n", + "\n", + "- Python 3.8 or later with dependencies listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/requirements.txt).\n", + "- R 4.4.0 and Bioconductor packages listed [here](https://github.com/BiocPy/BiocWorkshop2024/blob/master/rpackages.R)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installation\n", + "\n", + "Let's start by installing the required packages." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "!pip install scrnaseq celldex singler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This will install the `scrnaseq`, `celldex`, `singler` packages from PyPI.\n", + "\n", + "#### R\n", + "```r\n", + "BiocManager::install(c(\"scRNAseq\", \"celldex\", \"SingleR\"), \n", + " repos='http://cran.us.r-project.org')\n", + "```\n", + "\n", + "This will install the `scRNAseq`, `celldex`, `SingleR`, packages from Bioconductor." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Accessing and Exploring Single-Cell Datasets\n", + "\n", + "Now that we have the necessary packages installed, let's explore the `scrnaseq` package and learn how to access public single-cell RNA-seq datasets. Datasets published to the `scrnaseq` package are decorated with metadata such as the study title, species, number of cells, etc., to facilitate discovery. Let's see how we can list and search for datasets.\n", + "\n", + "### 1.1 List All Datasets\n", + "\n", + "The `list_datasets()` function in Python or `surveyDatasets()` in R will display all available datasets published to the `scRNAseq` collection along with their metadata." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "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", + "
nametitleversion
0aztekin-tail-2019Identification of a regeneration-organizing ce...2023-12-14
1splicing-demonstration-2020[reprocessed, subset] The Mammalian Spermatoge...2023-12-20
2marques-brain-2016Oligodendrocyte heterogeneity in the mouse juv...2023-12-19
\n", + "
" + ], + "text/plain": [ + " name \\\n", + "0 aztekin-tail-2019 \n", + "1 splicing-demonstration-2020 \n", + "2 marques-brain-2016 \n", + "\n", + " title version \n", + "0 Identification of a regeneration-organizing ce... 2023-12-14 \n", + "1 [reprocessed, subset] The Mammalian Spermatoge... 2023-12-20 \n", + "2 Oligodendrocyte heterogeneity in the mouse juv... 2023-12-19 " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import scrnaseq\n", + "datasets = scrnaseq.list_datasets()\n", + "datasets[[\"name\", \"title\", \"version\"]].head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "```r\n", + "suppressMessages(library(scRNAseq))\n", + "all_ds <- surveyDatasets()\n", + "head(all_ds[, c(\"name\", \"title\", \"version\")], 3)\n", + "```\n", + "\n", + "This lists all available datasets in the `scrnaseq` package and displays their names, titles, and versions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Search for Datasets\n", + "\n", + "You can also search for datasets based on metadata using `search_datasets()` in Python or `searchDatasets()` in R. This supports both simple text queries and complex boolean expressions." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + "
nametitleversion
0grun-bone_marrow-2016De Novo Prediction of Stem Cell Identity using...2023-12-14
1muraro-pancreas-2016A Single-Cell Transcriptome Atlas of the Human...2023-12-19
2baron-pancreas-2016A Single-Cell Transcriptomic Map of the Human ...2023-12-14
\n", + "
" + ], + "text/plain": [ + " name title \\\n", + "0 grun-bone_marrow-2016 De Novo Prediction of Stem Cell Identity using... \n", + "1 muraro-pancreas-2016 A Single-Cell Transcriptome Atlas of the Human... \n", + "2 baron-pancreas-2016 A Single-Cell Transcriptomic Map of the Human ... \n", + "\n", + " version \n", + "0 2023-12-14 \n", + "1 2023-12-19 \n", + "2 2023-12-14 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import scrnaseq\n", + "\n", + "pancreas_datasets = scrnaseq.search_datasets(\"pancreas\")\n", + "pancreas_datasets[[\"name\", \"title\", \"version\"]].head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "```r\n", + "pancreas_ds <- searchDatasets(\"pancreas\")\n", + "head(pancreas_ds[, c(\"name\", \"title\", \"version\")], 3)\n", + "```\n", + "\n", + "This R|Python code searches for datasets containing the term \"pancreas\" and displays their names, titles, and versions.\n", + "\n", + "#### 1.2.1 Advanced Searches\n", + "\n", + "For more complex searches involving boolean operations, use `define_text_query()` in Python or `defineTextQuery()` in R. Here's an example to find datasets using the mouse reference genome (`GRCm38`) and containing the words `neuro` or `pancrea`.\n", + "\n", + "```{tip}\n", + "Check out the reference manual for more details and usage of these functions.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + "
nametitleversion
0grun-bone_marrow-2016De Novo Prediction of Stem Cell Identity using...2023-12-14
1campbell-brain-2017A molecular census of arcuate hypothalamus and...2023-12-14
2hu-cortex-2017Dissecting cell-type composition and activity-...2023-12-20
\n", + "
" + ], + "text/plain": [ + " name title \\\n", + "0 grun-bone_marrow-2016 De Novo Prediction of Stem Cell Identity using... \n", + "1 campbell-brain-2017 A molecular census of arcuate hypothalamus and... \n", + "2 hu-cortex-2017 Dissecting cell-type composition and activity-... \n", + "\n", + " version \n", + "0 2023-12-14 \n", + "1 2023-12-14 \n", + "2 2023-12-20 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from gypsum_client import define_text_query\n", + "import scrnaseq\n", + "\n", + "res = scrnaseq.search_datasets(\n", + " define_text_query(\"GRCm38\", field=\"genome\")\n", + " & (\n", + " define_text_query(\"neuro%\", partial=True)\n", + " | define_text_query(\"pancrea%\", partial=True)\n", + " )\n", + ")\n", + "res[[\"name\", \"title\", \"version\"]].head(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "\n", + "```r\n", + "suppressWarnings(library(gypsum))\n", + "res <- searchDatasets(\n", + " defineTextQuery(\"GRCm38\", field=\"genome\") &\n", + " (defineTextQuery(\"neuro%\", partial=TRUE) | \n", + " defineTextQuery(\"pancrea%\", partial=TRUE))\n", + ")\n", + "head(res[,c(\"name\", \"title\", \"version\")], 3)\n", + "```\n", + "\n", + "This performs a complex search to find datasets tagged as \"mouse\" in the reference genome field and containing the keywords \"neuro\" or \"pancrea\".\n", + "\n", + "```{important}\n", + "Once a dataset is identified, always list the name and version of the dataset in your scripts for reproducibility.\n", + "```\n", + "\n", + "## 2. Download dataset\n", + "\n", + "After identifying a dataset of interest, use `fetch_dataset()` in Python or `fetchDataset()` in R to download the dataset. This will load the dataset as a `SingleCellExperiment` object.\n", + "\n", + "```{note}\n", + "R/Bioconductor users might already be familiar with the [SingleCellExperiment](https://bioconductor.org/packages/release/bioc/html/SingleCellExperiment.html) class. BiocPy also provides the same implementation in the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) package.\n", + "```\n", + "\n", + "For this tutorial, let's download the `zeisel-brain` dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "class: SingleCellExperiment\n", + "dimensions: (20006, 3005)\n", + "assays(1): ['counts']\n", + "row_data columns(1): ['featureType']\n", + "row_names(20006): ['Tspan12', 'Tshz1', 'Fnbp1l', ..., 'mt-Rnr2', 'mt-Rnr1', 'mt-Nd4l']\n", + "column_data columns(9): ['tissue', 'group #', 'total mRNA mol', 'well', 'sex', 'age', 'diameter', 'level1class', 'level2class']\n", + "column_names(3005): ['1772071015_C02', '1772071017_G12', '1772071017_A05', ..., '1772063068_D01', '1772066098_A12', '1772058148_F03']\n", + "main_experiment_name: gene\n", + "reduced_dims(0): []\n", + "alternative_experiments(2): ['repeat', 'ERCC']\n", + "row_pairs(0): []\n", + "column_pairs(0): []\n", + "metadata(0): \n", + "\n" + ] + } + ], + "source": [ + "import scrnaseq\n", + "sce = scrnaseq.fetch_dataset(\"zeisel-brain-2015\", \"2023-12-14\")\n", + "print(sce)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "```r\n", + "sce <- fetchDataset(\"zeisel-brain-2015\", \"2023-12-14\")\n", + "sce\n", + "```\n", + "\n", + "### 2.1 Side-quest on `SingleCellExperiment` in Python\n", + "\n", + "The Python implementation of the `SingleCellExperiment` class adheres to Bioconductor's specification and offers similar interface and methods. Our goal is to make it simple for analysts to switch between R and Python. A key difference is the shift from functional to an object-oriented paradigm.\n", + "\n", + "```{note}\n", + "For more details on the design, refer to the [BiocPy developer guide](https://github.com/BiocPy/developer_guide) or the [singlecellexperiment](https://github.com/BiocPy/SingleCellExperiment) documentation.\n", + "```\n", + "\n", + "This Python code demonstrates basic operations on a `SingleCellExperiment` object, including retrieving assay names, column names, column metadata, accessing counts, and coercing to an `AnnData` object for interoperability with existing analysis ready eco-systems in Python." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "assays: ['counts']\n", + "column names: ['1772071015_C02', '1772071017_G12', '1772071017_A05', '1772071014_B06', '1772067065_H06', '1772071017_E02', '1772067065_B07', '1772067060_B09', '1772071014_E04', '1772071015_D04']\n", + "column metadata: BiocFrame with 3005 rows and 9 columns\n", + " tissue group # total mRNA mol well sex age diameter\n", + " \n", + "1772071015_C02 sscortex 1.0 21580.0 11.0 1.0 21.0 0.0\n", + "1772071017_G12 sscortex 1.0 21748.0 95.0 -1.0 20.0 9.56\n", + "1772071017_A05 sscortex 1.0 31642.0 33.0 -1.0 20.0 11.1\n", + " ... ... ... ... ... ... ...\n", + "1772063068_D01 sscortex 9.0 4015.0 4.0 1.0 26.0 8.63\n", + "1772066098_A12 ca1hippocampus 9.0 2896.0 89.0 -1.0 26.0 9.23\n", + "1772058148_F03 sscortex 9.0 4460.0 22.0 1.0 26.0 10.4\n", + " level1class level2class\n", + " \n", + "1772071015_C02 interneurons Int10\n", + "1772071017_G12 interneurons Int10\n", + "1772071017_A05 interneurons Int6\n", + " ... ...\n", + "1772063068_D01 endothelial-mural Vsmc\n", + "1772066098_A12 endothelial-mural Vsmc\n", + "1772058148_F03 endothelial-mural Vsmc\n", + "access counts: <20006 x 3005> sparse ReloadedArray object of type 'uint16'\n", + "[[ 0, 0, 0, ..., 0, 0, 1],\n", + " [ 3, 1, 0, ..., 0, 0, 1],\n", + " [ 3, 1, 6, ..., 0, 0, 0],\n", + " ...,\n", + " [158, 326, 209, ..., 193, 36, 359],\n", + " [ 31, 88, 97, ..., 50, 12, 52],\n", + " [ 13, 14, 9, ..., 18, 3, 13]]\n" + ] + } + ], + "source": [ + "print(\"assays: \", sce.get_assay_names()) # or sce.assay_names\n", + "\n", + "print(\"column names: \", sce.get_column_names()[:10]) # or sce.column_names\n", + "\n", + "print(\"column metadata: \", sce.get_column_data()) # or sce.column_data\n", + "\n", + "print(\"access counts: \", sce.assays[\"counts\"]) # or # sce.assay(\"counts\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{note}\n", + "The package uses [delayed arrays](https://github.com/biocpy/delayedarray), to load file-backed arrays and matrices. This reduces memory usage when loading large datasets. This package provides similar functionality to the R/Bioconductor's [DelayedArray](https://www.bioconductor.org/packages/release/bioc/html/DelayedArray.html) eco-system. \n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "counts as csr: \n", + "<20006x3005 sparse matrix of type ''\n", + "\twith 11349080 stored elements in Compressed Sparse Column format>\n" + ] + } + ], + "source": [ + "from delayedarray import to_scipy_sparse_matrix\n", + "print(\"counts as csr: \")\n", + "print(repr(to_scipy_sparse_matrix(sce.assays[\"counts\"], \"csc\")))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "or realize the entire matrix when loaded from disk," + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "class: SingleCellExperiment\n", + "dimensions: (20006, 3005)\n", + "assays(1): ['counts']\n", + "row_data columns(1): ['featureType']\n", + "row_names(20006): ['Tspan12', 'Tshz1', 'Fnbp1l', ..., 'mt-Rnr2', 'mt-Rnr1', 'mt-Nd4l']\n", + "column_data columns(9): ['tissue', 'group #', 'total mRNA mol', 'well', 'sex', 'age', 'diameter', 'level1class', 'level2class']\n", + "column_names(3005): ['1772071015_C02', '1772071017_G12', '1772071017_A05', ..., '1772063068_D01', '1772066098_A12', '1772058148_F03']\n", + "main_experiment_name: gene\n", + "reduced_dims(0): []\n", + "alternative_experiments(2): ['repeat', 'ERCC']\n", + "row_pairs(0): []\n", + "column_pairs(0): []\n", + "metadata(0): \n", + "\n" + ] + } + ], + "source": [ + "sce = scrnaseq.fetch_dataset(\n", + " \"zeisel-brain-2015\", \"2023-12-14\", \n", + " realize_assays=True)\n", + "print(sce)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also provide coercions to various package to take advantage of methods in the Python ecosystem, e.g. scverse and AnnData" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "coerce to AnnData: (AnnData object with n_obs × n_vars = 3005 × 20006\n", + " obs: 'tissue', 'group #', 'total mRNA mol', 'well', 'sex', 'age', 'diameter', 'level1class', 'level2class', 'rownames'\n", + " var: 'featureType', 'rownames'\n", + " layers: 'counts', None)\n" + ] + } + ], + "source": [ + "print(\"coerce to AnnData: \", sce.to_anndata())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Annotate Cell Types\n", + "\n", + "We can now annotate cell types by using reference datasets and matching cells based on their expression profiles. In this tutorial, we will use [singleR](https://github.com/SingleR-inc/SingleR) in R or its Python equivalent [singler](https://github.com/BiocPy/singler).\n", + "\n", + "Before running the `singler` algorithm, we need to download an appropriate reference dataset from the `celldex` package.\n", + "\n", + "### 3.1 Access Reference Datasets from `celldex`\n", + "\n", + "Similar to the `scRNAseq` package, the `celldex` package provides access to the collection of reference expression datasets with curated cell type labels, for use in procedures like automated annotation of single-cell data or deconvolution of bulk RNA-seq to reference datasets. These datasets are also stored in language-agnostic representations for use in downstream analyses.\n", + "\n", + "```{note}\n", + "The `celldex` package is available on [R/Bioconductor](https://bioconductor.org/packages/devel/data/experiment/html/celldex.html) and [PyPI](https://github.com/BiocPy/celldex).\n", + "```\n", + "\n", + "For this tutorial, let's download the [Mouse RNA-seq](https://www.immgen.org/) reference from `celldex` using `fetch_reference()` in Python or `fetchReference()` in R. This reference consists of a collection of mouse bulk RNA-seq data sets downloaded from the gene expression omnibus ([Benayoun et al. 2019](https://doi.org/10.1101/gr.240093.118)). A variety of cell types are available, again mostly from blood but also covering several other tissues." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "class: SummarizedExperiment\n", + "dimensions: (21214, 358)\n", + "assays(1): ['logcounts']\n", + "row_data columns(0): []\n", + "row_names(21214): ['Xkr4', 'Rp1', 'Sox17', ..., 'MGC107098', 'LOC100039574', 'LOC100039753']\n", + "column_data columns(3): ['label.main', 'label.fine', 'label.ont']\n", + "column_names(358): ['ERR525589Aligned', 'ERR525592Aligned', 'SRR275532Aligned', ..., 'SRR1044042Aligned', 'SRR1044043Aligned', 'SRR1044044Aligned']\n", + "metadata(0): \n", + "\n" + ] + } + ], + "source": [ + "import celldex\n", + "\n", + "mouse_rnaseq_ref = celldex.fetch_reference(\n", + " \"mouse_rnaseq\", \"2024-02-26\", \n", + " realize_assays=True)\n", + "print(mouse_rnaseq_ref)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "```r\n", + "suppressWarnings(library(celldex))\n", + "mouse_rnaseq_ref <- fetchReference(\"mouse_rnaseq\", \"2024-02-26\", realize.assays=TRUE)\n", + "mouse_rnaseq_ref\n", + "```\n", + "\n", + "Now, let's identify cells from the `zeisel-brain` dataset using the `mouse_rnaseq` reference dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/kancherj/miniforge3/envs/bioc2024/lib/python3.10/site-packages/biocframe/BiocFrame.py:591: UserWarning: Setting property 'metadata' is an in-place operation, use 'set_metadata' instead\n", + " warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "Neurons 1704\n", + "Oligodendrocytes 844\n", + "Astrocytes 180\n", + "Endothelial cells 177\n", + "Macrophages 45\n", + "Epithelial cells 20\n", + "Microglia 18\n", + "Fibroblasts 17\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import singler\n", + "\n", + "matches = singler.annotate_single(\n", + " test_data=sce, \n", + " ref_data = mouse_rnaseq_ref,\n", + " ref_labels = \"label.main\"\n", + ")\n", + "\n", + "import pandas as pd\n", + "\n", + "pd.Series(matches[\"best\"]).value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "```r\n", + "suppressWarnings(library(SingleR))\n", + "cell_labels <- SingleR(test = assay(sce, \"counts\"), ref = mouse_rnaseq_ref, labels = mouse_rnaseq_ref$label.main)\n", + "\n", + "table(cell_labels$labels)\n", + "```\n", + "\n", + "## 4. Analyze Single-cell RNA-seq datasets\n", + "\n", + "![single-cell-methods](../assets/single-cell-space.jpg)\n", + "\n", + "Aaron has implemented the single-cell methods from scran in C++. This allows us to reuse the same implementation in JS and develop applications for analyzing single-cell data ([Kana](https://github.com/kanaverse/kana)), or in Python through the [scranpy](https://github.com/BiocPy/scranpy) package. This avoids different interpretations of the analysis results by switching programming languages (Pachter et al, [The impact of package selection and versioning on single-cell RNA-seq analysis | bioRxiv](https://www.biorxiv.org/content/10.1101/2024.04.04.588111v1) )\n", + "\n", + "\n", + "To analyze the dataset," + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TsneEmbedding(x=array([23.78283174, 23.20692407, 23.99748307, ..., 16.43261279,\n", + " 12.91835402, 20.38262289]), y=array([-15.02586205, -15.00463774, -14.18924958, ..., -1.56177656,\n", + " 1.55240304, 3.51312435]))\n" + ] + } + ], + "source": [ + "import scranpy\n", + "\n", + "results = scranpy.analyze_sce(sce)\n", + "\n", + "# results is a complex object, lets explore the umap and tsne dimensions\n", + "print(results.tsne)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1 Seems like magic?\n", + "\n", + "Running the `analyze_sce()` function uses the default parameters to run the single-cell workflow. If you want to customize or want to have fine-grained control on the analysis steps, set the parameter `dry_run=True`.\n", + "\n", + "```{note}\n", + "This prints out the exact series of steps the function does under the hood to perform the analysis. You can then use this to customize the analysis to your specific dataset or use case.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(scranpy.analyze_sce(sce, dry_run=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{tip}\n", + "Users can also run individual steps from the analysis without having to perform the full analysis, e.g. compute log normalized counts or find markers, etc.\n", + "```\n", + "\n", + "## 5. Visualize Results\n", + "\n", + "I can't have a tutorial without a section on visualization or figures.\n", + "\n", + "We will use the seaborn and matplotlib packages in Python to create visualizations. We'll plot the t-SNE embedding and color the cells by their cluster assignments." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "sns.scatterplot(\n", + " x=results.tsne.x, y=results.tsne.y, \n", + " hue=results.clusters, palette=\"deep\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "or the UMAP embedding with the cell types we identified from `celldex`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "sns.scatterplot(\n", + " x=results.umap.x, y=results.umap.y, \n", + " hue=matches[\"best\"][:3002], palette=\"deep\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{caution}\n", + "During the QC step, some cells were filtered, hence we filter the matches and this is incorrect (since we don't know which cells were filtered). \n", + "\n", + "We'll leave this as an exercise for the reader to change the order of steps: 1) run the dataset through the QC step 2) filter cells, and then 3) annotate using singleR.\n", + "```\n", + "\n", + "## 6. Exercises\n", + "\n", + "1. Share or Upload your datasets to scrna-seq, Instructions to upload are available in their respective [R/Bioc](https://bioconductor.org/packages/release/data/experiment/html/scRNAseq.html) and [Python](https://github.com/BiocPy/scrnaseq) packages.\n", + "2. Explore top markers for each cluster identified by scranpy.\n", + "3. Perform multi-modal analysis (scranpy supports RNA, ADT, CRISPR).\n", + "4. save your results and explore in [Kana](https://github.com/kanaverse/kana).\n", + "\n", + "Congratulations! You have now completed the tutorial on accessing single-cell datasets using `scRNAseq` and `ArtifactDB`, and annotating cell types using reference datasets from `celldex`. For more detailed usage and advanced analyses, refer to the respective documentation of these packages.\n", + "\n", + "By integrating R and Python workflows, you can leverage the strengths of both languages and perform comprehensive single-cell analysis. Keep exploring and happy analyzing!" + ] + } + ], + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebook/genomic_ranges.ipynb b/notebook/genomic_ranges.ipynb new file mode 100644 index 0000000..3de0524 --- /dev/null +++ b/notebook/genomic_ranges.ipynb @@ -0,0 +1,1294 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial 1: `GenomicRanges` and range-based analyses\n", + "\n", + "Genomic range operations are fundamental to many bioinformatics analyses. They allow us to work with intervals of genomic coordinates, which is crucial for understanding the relationships between different genomic features such as genes, regulatory elements, and experimental data like ChIP-seq peaks. In this tutorial, we'll explore how to work with genomic interval data using BiocPy's [GenomicRanges](https://github.com/BiocPy/GenomicRanges/) package, which provides Python implementations similar to the R/Bioconductor [GenomicRanges package](https://github.com/Bioconductor/GenomicRanges).\n", + "\n", + "## Outline\n", + "\n", + "In this workshop, we'll walk through several key aspects of working with genomic ranges in Python:\n", + "\n", + "1. Reading Genomic Data: We'll start by reading in genomic data from RDS files, including exon positions grouped by transcripts.\n", + "2. Basic Genomic Operations: We'll cover fundamental operations like finding transcription start sites (TSS) and promoter regions.\n", + "3. Overlap Analysis: We'll learn how to find overlaps between different genomic features, a common task in many analyses.\n", + "4. Advanced Operations: We'll explore more complex operations like finding peaks within specific regions and resizing genomic intervals.\n", + "\n", + "## Prerequisites\n", + "\n", + "Before we begin, please ensure that you have the following packages installed:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation\n", + "\n", + "Let's start by installing the required packages for R and Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Python (shell)\n", + "\n", + "You can install the Python packages using pip:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: biocutils in /Users/kancherj/miniforge3/lib/python3.10/site-packages (0.1.5)\n", + "Requirement already satisfied: genomicranges in /Users/kancherj/miniforge3/lib/python3.10/site-packages (0.4.28)\n", + "Requirement already satisfied: rds2py in /Users/kancherj/miniforge3/lib/python3.10/site-packages (0.4.4)\n", + "Requirement already satisfied: numpy in /Users/kancherj/miniforge3/lib/python3.10/site-packages (1.26.4)\n", + "Collecting numpy\n", + " Using cached numpy-2.0.0-cp310-cp310-macosx_14_0_arm64.whl.metadata (60 kB)\n", + "Requirement already satisfied: pandas in /Users/kancherj/miniforge3/lib/python3.10/site-packages (2.2.2)\n", + "Requirement already satisfied: geniml in /Users/kancherj/miniforge3/lib/python3.10/site-packages (0.4.0)\n", + "Requirement already satisfied: biocframe>=0.5.11 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from genomicranges) (0.5.11)\n", + "Requirement already satisfied: iranges>=0.2.11 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from iranges[optional]>=0.2.11->genomicranges) (0.2.11)\n", + "Requirement already satisfied: Cython in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from rds2py) (3.0.10)\n", + "Requirement already satisfied: scipy in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from rds2py) (1.12.0)\n", + "Requirement already satisfied: singlecellexperiment>=0.4.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from rds2py) (0.4.6)\n", + "Requirement already satisfied: summarizedexperiment>=0.4.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from rds2py) (0.4.5)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pandas) (2024.1)\n", + "Requirement already satisfied: tzdata>=2022.7 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pandas) (2024.1)\n", + "Requirement already satisfied: anndata>0.9.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.10.8)\n", + "Requirement already satisfied: genimtools>=0.0.12 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.0.13)\n", + "Requirement already satisfied: fastembed>=0.2.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.3.4)\n", + "Requirement already satisfied: gensim in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (4.3.2)\n", + "Requirement already satisfied: huggingface-hub in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.23.5)\n", + "Requirement already satisfied: logmuse in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.2.8)\n", + "Requirement already satisfied: matplotlib in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (3.8.3)\n", + "Requirement already satisfied: hnswlib in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.8.0)\n", + "Requirement already satisfied: paramiko>=3.0.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (3.4.0)\n", + "Requirement already satisfied: peppy>=0.40.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.40.3)\n", + "Requirement already satisfied: pyBigWig in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.3.23)\n", + "Requirement already satisfied: qdrant-client in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (1.10.1)\n", + "Requirement already satisfied: requests>=2.31.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (2.31.0)\n", + "Requirement already satisfied: scanpy in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (1.10.2)\n", + "Requirement already satisfied: seaborn in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.13.2)\n", + "Requirement already satisfied: torch in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (2.3.1)\n", + "Requirement already satisfied: ubiquerg>=0.6.3 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.8.0)\n", + "Requirement already satisfied: pyarrow in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (15.0.2)\n", + "Requirement already satisfied: lightning in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (2.3.3)\n", + "Requirement already satisfied: langchain-huggingface==0.0.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.0.2)\n", + "Requirement already satisfied: botocore>=1.34.54 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (1.34.131)\n", + "Requirement already satisfied: boto3>=1.34.54 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (1.34.131)\n", + "Requirement already satisfied: pybiocfilecache>=0.4.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (0.4.0)\n", + "Requirement already satisfied: zarr>=2.17.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (2.18.2)\n", + "Requirement already satisfied: pyyaml>=6.0.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (6.0.1)\n", + "Requirement already satisfied: s3fs>=2024.3.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from geniml) (2024.6.1)\n", + "Requirement already satisfied: langchain-core<0.3,>=0.1.52 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-huggingface==0.0.2->geniml) (0.2.20)\n", + "Requirement already satisfied: sentence-transformers>=2.6.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-huggingface==0.0.2->geniml) (3.0.1)\n", + "Requirement already satisfied: text-generation<0.8.0,>=0.7.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-huggingface==0.0.2->geniml) (0.7.0)\n", + "Requirement already satisfied: tokenizers>=0.19.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-huggingface==0.0.2->geniml) (0.19.1)\n", + "Requirement already satisfied: transformers>=4.39.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-huggingface==0.0.2->geniml) (4.42.4)\n", + "Requirement already satisfied: array-api-compat!=1.5,>1.4 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from anndata>0.9.0->geniml) (1.7.1)\n", + "Requirement already satisfied: exceptiongroup in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from anndata>0.9.0->geniml) (1.2.1)\n", + "Requirement already satisfied: h5py>=3.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from anndata>0.9.0->geniml) (3.11.0)\n", + "Requirement already satisfied: natsort in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from anndata>0.9.0->geniml) (8.4.0)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from anndata>0.9.0->geniml) (23.2)\n", + "Requirement already satisfied: jmespath<2.0.0,>=0.7.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from boto3>=1.34.54->geniml) (1.0.1)\n", + "Requirement already satisfied: s3transfer<0.11.0,>=0.10.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from boto3>=1.34.54->geniml) (0.10.2)\n", + "Requirement already satisfied: urllib3!=2.2.0,<3,>=1.25.4 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from botocore>=1.34.54->geniml) (2.2.1)\n", + "Requirement already satisfied: PyStemmer<3.0.0,>=2.2.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (2.2.0.1)\n", + "Requirement already satisfied: loguru<0.8.0,>=0.7.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (0.7.2)\n", + "Requirement already satisfied: mmh3<5.0,>=4.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (4.1.0)\n", + "Requirement already satisfied: onnx<2.0.0,>=1.15.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (1.16.1)\n", + "Requirement already satisfied: onnxruntime<2.0.0,>=1.17.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (1.18.1)\n", + "Requirement already satisfied: pillow<11.0.0,>=10.3.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (10.4.0)\n", + "Requirement already satisfied: snowballstemmer<3.0.0,>=2.2.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (2.2.0)\n", + "Requirement already satisfied: tqdm<5.0,>=4.66 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from fastembed>=0.2.5->geniml) (4.66.2)\n", + "Requirement already satisfied: filelock in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from huggingface-hub->geniml) (3.15.4)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from huggingface-hub->geniml) (2024.6.1)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from huggingface-hub->geniml) (4.10.0)\n", + "Requirement already satisfied: ncls==0.0.68 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from iranges>=0.2.11->iranges[optional]>=0.2.11->genomicranges) (0.0.68)\n", + "Requirement already satisfied: polars in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from iranges[optional]>=0.2.11->genomicranges) (1.1.0)\n", + "Requirement already satisfied: bcrypt>=3.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from paramiko>=3.0.0->geniml) (4.1.3)\n", + "Requirement already satisfied: cryptography>=3.3 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from paramiko>=3.0.0->geniml) (42.0.8)\n", + "Requirement already satisfied: pynacl>=1.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from paramiko>=3.0.0->geniml) (1.5.0)\n", + "Requirement already satisfied: rich>=10.3.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from peppy>=0.40.1->geniml) (13.7.1)\n", + "Requirement already satisfied: pephubclient>=0.4.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from peppy>=0.40.1->geniml) (0.4.2)\n", + "Requirement already satisfied: sqlalchemy<2.1,>=2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pybiocfilecache>=0.4.0->geniml) (2.0.31)\n", + "Requirement already satisfied: six>=1.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from requests>=2.31.0->geniml) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from requests>=2.31.0->geniml) (3.6)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from requests>=2.31.0->geniml) (2024.2.2)\n", + "Requirement already satisfied: aiobotocore<3.0.0,>=2.5.4 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from s3fs>=2024.3.1->geniml) (2.13.1)\n", + "Requirement already satisfied: aiohttp!=4.0.0a0,!=4.0.0a1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from s3fs>=2024.3.1->geniml) (3.9.5)\n", + "Requirement already satisfied: asciitree in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from zarr>=2.17.2->geniml) (0.3.3)\n", + "Requirement already satisfied: numcodecs>=0.10.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from zarr>=2.17.2->geniml) (0.13.0)\n", + "Requirement already satisfied: fasteners in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from zarr>=2.17.2->geniml) (0.19)\n", + "Requirement already satisfied: smart-open>=1.8.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from gensim->geniml) (7.0.4)\n", + "Requirement already satisfied: lightning-utilities<2.0,>=0.10.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from lightning->geniml) (0.11.5)\n", + "Requirement already satisfied: torchmetrics<3.0,>=0.7.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from lightning->geniml) (1.4.0.post0)\n", + "Requirement already satisfied: pytorch-lightning in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from lightning->geniml) (2.3.3)\n", + "Requirement already satisfied: sympy in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from torch->geniml) (1.13.0)\n", + "Requirement already satisfied: networkx in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from torch->geniml) (3.3)\n", + "Requirement already satisfied: jinja2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from torch->geniml) (3.1.3)\n", + "Requirement already satisfied: setuptools in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from logmuse->geniml) (69.2.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from matplotlib->geniml) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from matplotlib->geniml) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from matplotlib->geniml) (4.50.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from matplotlib->geniml) (1.4.5)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from matplotlib->geniml) (3.1.2)\n", + "Requirement already satisfied: grpcio>=1.41.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from qdrant-client->geniml) (1.64.1)\n", + "Requirement already satisfied: grpcio-tools>=1.41.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from qdrant-client->geniml) (1.64.1)\n", + "Requirement already satisfied: httpx>=0.20.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from httpx[http2]>=0.20.0->qdrant-client->geniml) (0.27.0)\n", + "Requirement already satisfied: portalocker<3.0.0,>=2.7.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from qdrant-client->geniml) (2.10.1)\n", + "Requirement already satisfied: pydantic>=1.10.8 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from qdrant-client->geniml) (2.8.2)\n", + "Requirement already satisfied: joblib in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (1.4.2)\n", + "Requirement already satisfied: legacy-api-wrap>=1.4 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (1.4)\n", + "Requirement already satisfied: numba>=0.56 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (0.60.0)\n", + "Requirement already satisfied: patsy in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (0.5.6)\n", + "Requirement already satisfied: pynndescent>=0.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (0.5.13)\n", + "Requirement already satisfied: scikit-learn>=0.24 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (1.5.1)\n", + "Requirement already satisfied: session-info in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (1.0.0)\n", + "Requirement already satisfied: statsmodels>=0.13 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (0.14.2)\n", + "Requirement already satisfied: umap-learn!=0.5.0,>=0.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scanpy->geniml) (0.5.6)\n", + "Requirement already satisfied: wrapt<2.0.0,>=1.10.10 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiobotocore<3.0.0,>=2.5.4->s3fs>=2024.3.1->geniml) (1.16.0)\n", + "Requirement already satisfied: aioitertools<1.0.0,>=0.5.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiobotocore<3.0.0,>=2.5.4->s3fs>=2024.3.1->geniml) (0.11.0)\n", + "Requirement already satisfied: aiosignal>=1.1.2 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs>=2024.3.1->geniml) (1.3.1)\n", + "Requirement already satisfied: attrs>=17.3.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs>=2024.3.1->geniml) (23.2.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs>=2024.3.1->geniml) (1.4.1)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs>=2024.3.1->geniml) (6.0.5)\n", + "Requirement already satisfied: yarl<2.0,>=1.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs>=2024.3.1->geniml) (1.9.4)\n", + "Requirement already satisfied: async-timeout<5.0,>=4.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from aiohttp!=4.0.0a0,!=4.0.0a1->s3fs>=2024.3.1->geniml) (4.0.3)\n", + "Requirement already satisfied: cffi>=1.12 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from cryptography>=3.3->paramiko>=3.0.0->geniml) (1.16.0)\n", + "Requirement already satisfied: protobuf<6.0dev,>=5.26.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from grpcio-tools>=1.41.0->qdrant-client->geniml) (5.27.2)\n", + "Requirement already satisfied: anyio in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from httpx>=0.20.0->httpx[http2]>=0.20.0->qdrant-client->geniml) (4.4.0)\n", + "Requirement already satisfied: httpcore==1.* in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from httpx>=0.20.0->httpx[http2]>=0.20.0->qdrant-client->geniml) (1.0.5)\n", + "Requirement already satisfied: sniffio in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from httpx>=0.20.0->httpx[http2]>=0.20.0->qdrant-client->geniml) (1.3.1)\n", + "Requirement already satisfied: h11<0.15,>=0.13 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from httpcore==1.*->httpx>=0.20.0->httpx[http2]>=0.20.0->qdrant-client->geniml) (0.14.0)\n", + "Requirement already satisfied: h2<5,>=3 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from httpx[http2]>=0.20.0->qdrant-client->geniml) (4.1.0)\n", + "Requirement already satisfied: jsonpatch<2.0,>=1.33 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-core<0.3,>=0.1.52->langchain-huggingface==0.0.2->geniml) (1.33)\n", + "Requirement already satisfied: langsmith<0.2.0,>=0.1.75 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-core<0.3,>=0.1.52->langchain-huggingface==0.0.2->geniml) (0.1.88)\n", + "Requirement already satisfied: tenacity!=8.4.0,<9.0.0,>=8.1.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langchain-core<0.3,>=0.1.52->langchain-huggingface==0.0.2->geniml) (8.2.3)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from numba>=0.56->scanpy->geniml) (0.43.0)\n", + "Requirement already satisfied: coloredlogs in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from onnxruntime<2.0.0,>=1.17.0->fastembed>=0.2.5->geniml) (15.0.1)\n", + "Requirement already satisfied: flatbuffers in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from onnxruntime<2.0.0,>=1.17.0->fastembed>=0.2.5->geniml) (24.3.25)\n", + "Requirement already satisfied: typer>=0.7.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pephubclient>=0.4.2->peppy>=0.40.1->geniml) (0.12.3)\n", + "Requirement already satisfied: annotated-types>=0.4.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pydantic>=1.10.8->qdrant-client->geniml) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.20.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from pydantic>=1.10.8->qdrant-client->geniml) (2.20.1)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from rich>=10.3.0->peppy>=0.40.1->geniml) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from rich>=10.3.0->peppy>=0.40.1->geniml) (2.17.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from scikit-learn>=0.24->scanpy->geniml) (3.5.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from transformers>=4.39.0->langchain-huggingface==0.0.2->geniml) (2024.5.15)\n", + "Requirement already satisfied: safetensors>=0.4.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from transformers>=4.39.0->langchain-huggingface==0.0.2->geniml) (0.4.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from jinja2->torch->geniml) (2.1.5)\n", + "Requirement already satisfied: stdlib-list in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from session-info->scanpy->geniml) (0.10.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from sympy->torch->geniml) (1.3.0)\n", + "Requirement already satisfied: pycparser in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from cffi>=1.12->cryptography>=3.3->paramiko>=3.0.0->geniml) (2.21)\n", + "Requirement already satisfied: humanfriendly>=9.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from coloredlogs->onnxruntime<2.0.0,>=1.17.0->fastembed>=0.2.5->geniml) (10.0)\n", + "Requirement already satisfied: hyperframe<7,>=6.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from h2<5,>=3->httpx[http2]>=0.20.0->qdrant-client->geniml) (6.0.1)\n", + "Requirement already satisfied: hpack<5,>=4.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from h2<5,>=3->httpx[http2]>=0.20.0->qdrant-client->geniml) (4.0.0)\n", + "Requirement already satisfied: jsonpointer>=1.9 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from jsonpatch<2.0,>=1.33->langchain-core<0.3,>=0.1.52->langchain-huggingface==0.0.2->geniml) (2.4)\n", + "Requirement already satisfied: orjson<4.0.0,>=3.9.14 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from langsmith<0.2.0,>=0.1.75->langchain-core<0.3,>=0.1.52->langchain-huggingface==0.0.2->geniml) (3.10.6)\n", + "Requirement already satisfied: mdurl~=0.1 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from markdown-it-py>=2.2.0->rich>=10.3.0->peppy>=0.40.1->geniml) (0.1.2)\n", + "Requirement already satisfied: click>=8.0.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from typer>=0.7.0->pephubclient>=0.4.2->peppy>=0.40.1->geniml) (8.1.7)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /Users/kancherj/miniforge3/lib/python3.10/site-packages (from typer>=0.7.0->pephubclient>=0.4.2->peppy>=0.40.1->geniml) (1.5.4)\n" + ] + } + ], + "source": [ + "!pip install -U biocutils genomicranges rds2py numpy pandas geniml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### R\n", + "\n", + " ```r\n", + " BiocManager::install(c(\"AnnotationHub\"), \n", + " repos='http://cran.us.r-project.org')\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Save Annotations as RDS\n", + "\n", + "Let's download the human reference genome and save the exon positions grouped by transcripts. For the purpose of the tutorial, we'll limit the exons to chromosome 22.\n", + "\n", + "#### R\n", + "\n", + " ```r\n", + " suppressMessages(library(AnnotationHub))\n", + " \n", + " ah <- AnnotationHub()\n", + " ensdb <- query(ah, \"Ensembl 112 EnsDb for Homo sapiens\")[[1]]\n", + " exons_by_tx <- exonsBy(ensdb, \n", + " by = \"tx\", filter = SeqNameFilter(c(\"22\")), \n", + " columns= c(\"exon_id\", \"tx_name\", \"tx_id\", \"gene_name\", \"gene_id\"))\n", + " saveRDS(exons_by_tx, \"hg38_exons_by_tx.rds\")\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Reading RDS files in Python\n", + "\n", + "The [rds2py](https://github.com/biocpy/rds2py) Python package allows us to read RDS files and create equivalent Python representations of R objects. Key features include:\n", + "\n", + "- Parsing common R objects into Python equivalents (e.g., matrices to NumPy arrays, data frames to Pandas DataFrames).\n", + "- Ability to read S4 classes, enabling direct parsing of Bioconductor data types from R to Python.\n", + "\n", + "Reading an RDS file with rds2py involves two steps:\n", + "\n", + "1. Parse the RDS file into a Python dictionary containing data, its attributes, and associated metadata.\n", + "2. Convert this dictionary into a suitable Python object using specific parser functions.\n", + "\n", + "This process allows a seamless transition between R and Python for bioinformatics analyses." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exons by transcript:\n", + "GenomicRangesList with 5387 ranges and 0 metadata columns\n", + " \n", + "Name: ENST00000006251 \n", + "GenomicRanges with 9 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "[0] chr22 44677057 - 44677241 + | ENSE00001838743 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 1\n", + "[1] chr22 44702492 - 44702609 + | ENSE00003647870 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 2\n", + "[2] chr22 44714591 - 44714672 + | ENSE00003614159 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 3\n", + "[3] chr22 44725244 - 44725293 + | ENSE00003568825 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 4\n", + "[4] chr22 44726577 - 44726635 + | ENSE00003465556 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 5\n", + "[5] chr22 44731730 - 44731822 + | ENSE00003642381 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 6\n", + "[6] chr22 44732251 - 44732392 + | ENSE00003658491 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 7\n", + "[7] chr22 44735027 - 44735163 + | ENSE00003692865 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 8\n", + "[8] chr22 44736772 - 44737681 + | ENSE00001846334 ENST00000006251 ENST00000006251 PRR5 ENSG00000186654 9\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: ENST00000008876 \n", + "GenomicRanges with 10 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "[0] chr22 50603133 - 50603499 + | ENSE00003608148 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 1\n", + "[1] chr22 50603626 - 50603720 + | ENSE00003768317 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 2\n", + "[2] chr22 50603841 - 50605065 + | ENSE00003772801 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 3\n", + "[3] chr22 50605368 - 50605444 + | ENSE00003773674 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 4\n", + "[4] chr22 50605562 - 50605735 + | ENSE00003765641 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 5\n", + "[5] chr22 50605825 - 50605935 + | ENSE00003763622 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 6\n", + "[6] chr22 50606658 - 50606766 + | ENSE00003773228 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 7\n", + "[7] chr22 50606921 - 50606992 + | ENSE00003769486 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 8\n", + "[8] chr22 50610212 - 50610311 + | ENSE00003772161 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 9\n", + "[9] chr22 50610707 - 50613982 + | ENSE00003731955 ENST00000008876 ENST00000008876 MAPK8IP2 ENSG00000008735 10\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: ENST00000043402 \n", + "GenomicRanges with 2 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "[0] chr22 20268071 - 20268319 - | ENSE00001358408 ENST00000043402 ENST00000043402 RTN4R ENSG00000040608 1\n", + "[1] chr22 20241415 - 20243111 - | ENSE00001557601 ENST00000043402 ENST00000043402 RTN4R ENSG00000040608 2\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: \n", + "GenomicRanges with 15 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + " [0] chr22 33919995 - 33920477 - | LRG_856t1e1 LRG_856t2 LRG_856t2 LARGE1 LRG_856 1\n", + " [1] chr22 33761371 - 33761559 - | LRG_856t1e3 LRG_856t2 LRG_856t2 LARGE1 LRG_856 2\n", + " [2] chr22 33650367 - 33650669 - | LRG_856t1e4 LRG_856t2 LRG_856t2 LARGE1 LRG_856 3\n", + " ... ... ... | ... ... ... ... ... ...\n", + "[12] chr22 33283202 - 33283349 - | LRG_856t1e14 LRG_856t2 LRG_856t2 LARGE1 LRG_856 13\n", + "[13] chr22 33277060 - 33277256 - | LRG_856t1e15 LRG_856t2 LRG_856t2 LARGE1 LRG_856 14\n", + "[14] chr22 33272509 - 33274625 - | LRG_856t1e16 LRG_856t2 LRG_856t2 LARGE1 LRG_856 15\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: LRG_856t2 \n", + "GenomicRanges with 7 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "[0] chr22 37244114 - 37244266 - | LRG_97t1e1 LRG_97t1 LRG_97t1 RAC2 LRG_97 1\n", + "[1] chr22 37241587 - 37241659 - | LRG_97t1e2 LRG_97t1 LRG_97t1 RAC2 LRG_97 2\n", + "[2] chr22 37232801 - 37232919 - | LRG_97t1e3 LRG_97t1 LRG_97t1 RAC2 LRG_97 3\n", + "[3] chr22 37231932 - 37231995 - | LRG_97t1e4 LRG_97t1 LRG_97t1 RAC2 LRG_97 4\n", + "[4] chr22 37231231 - 37231391 - | LRG_97t1e5 LRG_97t1 LRG_97t1 RAC2 LRG_97 5\n", + "[5] chr22 37226671 - 37226804 - | LRG_97t1e6 LRG_97t1 LRG_97t1 RAC2 LRG_97 6\n", + "[6] chr22 37225270 - 37226040 - | LRG_97t1e7 LRG_97t1 LRG_97t1 RAC2 LRG_97 7\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: LRG_97t1 \n", + "GenomicRanges with 21 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + " [0] chr22 20982297 - 20982572 + | LRG_989t1e1 LRG_989t1 LRG_989t1 LZTR1 LRG_989 1\n", + " [1] chr22 20983027 - 20983090 + | LRG_989t1e2 LRG_989t1 LRG_989t1 LZTR1 LRG_989 2\n", + " [2] chr22 20985841 - 20985898 + | LRG_989t1e3 LRG_989t1 LRG_989t1 LZTR1 LRG_989 3\n", + " ... ... ... | ... ... ... ... ... ...\n", + "[18] chr22 20996696 - 20996802 + | LRG_989t1e19 LRG_989t1 LRG_989t1 LZTR1 LRG_989 19\n", + "[19] chr22 20996886 - 20996967 + | LRG_989t1e20 LRG_989t1 LRG_989t1 LZTR1 LRG_989 20\n", + "[20] chr22 20997232 - 20999033 + | LRG_989t1e21 LRG_989t1 LRG_989t1 LZTR1 LRG_989 21\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "\n" + ] + } + ], + "source": [ + "from rds2py import read_rds\n", + "hg38_robject = read_rds(\"./hg38_exons_by_tx.rds\")\n", + "\n", + "from rds2py.granges import as_granges_list\n", + "by_tx = as_granges_list(hg38_robject)\n", + "\n", + "print(\"Exons by transcript:\")\n", + "print(by_tx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Basic Genomic Operations\n", + "\n", + "Now, let's perform some basic operations like finding Transcription Start Sites (TSS) and promoter regions. These operations are fundamental in genomic analysis as they help us identify key regulatory regions of the genome.\n", + "\n", + "### 2.1 Create a `GenomicRangesList` by gene\n", + "\n", + "To identify TSS or define promoter regions, let's first reprocess the input to create a `GenomicRangesList` by gene symbols.\n", + "\n", + "To achieve this, we unlist the `GenomicRangesList` object. This is accomplished in Python using the `as_genomic_ranges()` method. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "all_ranges = by_tx.as_genomic_ranges()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we split the object using the `gene_name` metadata column in `mcols()`. \n", + "\n", + "```{important}\n", + "We provide accessors to get or set attributes of the class. Most folks in Python may be familiar with direct access to class members (via properties or @property), but this should generally be avoided, as it is too easy to perform modifications via one-liners with the class.property on the left-hand side of an assignment.\n", + "\n", + "For more information, please refer to our [developer guide](https://github.com/BiocPy/developer_guide).\n", + "```\n", + "\n", + "```{note}\n", + "While gene IDs are unique, gene symbols are not. In addition, this list has genes with no symbols.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exons by gene:\n", + "GenomicRangesList with 932 ranges and 0 metadata columns\n", + " \n", + "Name: \n", + "GenomicRanges with 1846 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000255890 chr22 23402361 - 23402568 - | ENSE00001754779 ENST00000255890 ENST00000255890 ENSG00000290920 1\n", + "ENST00000255890 chr22 23402037 - 23402156 - | ENSE00001700441 ENST00000255890 ENST00000255890 ENSG00000290920 2\n", + "ENST00000255890 chr22 23401841 - 23401954 - | ENSE00004028898 ENST00000255890 ENST00000255890 ENSG00000290920 3\n", + " ... ... ... | ... ... ... ... ... ...\n", + "ENST00000706202 chr22 21008247 - 21009450 - | ENSE00003995059 ENST00000706202 ENST00000706202 ENSG00000291240 7\n", + "ENST00000714325 chr22 18939446 - 18947693 + | ENSE00003802171 ENST00000714325 ENST00000714325 ENSG00000284294 1\n", + "ENST00000715281 chr22 35838583 - 35838658 - | ENSE00004026430 ENST00000715281 ENST00000715281 ENSG00000293594 1\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: 5_8S_rRNA \n", + "GenomicRanges with 1 range and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000612732 chr22 11249809 - 11249960 - | ENSE00003735240 ENST00000612732 ENST00000612732 5_8S_rRNA ENSG00000276871 1\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: A4GALT \n", + "GenomicRanges with 20 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000249005 chr22 42695491 - 42695634 - | ENSE00001109573 ENST00000249005 ENST00000249005 A4GALT ENSG00000128274 1\n", + "ENST00000249005 chr22 42692122 - 42693998 - | ENSE00000880583 ENST00000249005 ENST00000249005 A4GALT ENSG00000128274 2\n", + "ENST00000381278 chr22 42720797 - 42720820 - | ENSE00003818792 ENST00000381278 ENST00000381278 A4GALT ENSG00000128274 1\n", + " ... ... ... | ... ... ... ... ... ...\n", + " LRG_795t1 chr22 42720797 - 42720871 - | LRG_795t1e1 LRG_795t1 LRG_795t1 A4GALT LRG_795 1\n", + " LRG_795t1 chr22 42695491 - 42695632 - | LRG_795t1e2 LRG_795t1 LRG_795t1 A4GALT LRG_795 2\n", + " LRG_795t1 chr22 42692121 - 42693998 - | LRG_795t1e3 LRG_795t1 LRG_795t1 A4GALT LRG_795 3\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: \n", + "GenomicRanges with 26 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000402174 chr22 28917389 - 28917482 + | ENSE00001552635 ENST00000402174 ENST00000402174 ZNRF3 ENSG00000183579 1\n", + "ENST00000402174 chr22 28987076 - 28987202 + | ENSE00003547707 ENST00000402174 ENST00000402174 ZNRF3 ENSG00000183579 2\n", + "ENST00000402174 chr22 29042495 - 29042570 + | ENSE00001329477 ENST00000402174 ENST00000402174 ZNRF3 ENSG00000183579 3\n", + " ... ... ... | ... ... ... ... ... ...\n", + "ENST00000544604 chr22 29048389 - 29048492 + | ENSE00001325812 ENST00000544604 ENST00000544604 ZNRF3 ENSG00000183579 7\n", + "ENST00000544604 chr22 29049197 - 29050949 + | ENSE00001308098 ENST00000544604 ENST00000544604 ZNRF3 ENSG00000183579 8\n", + "ENST00000544604 chr22 29053579 - 29057489 + | ENSE00001427475 ENST00000544604 ENST00000544604 ZNRF3 ENSG00000183579 9\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: ZNRF3 \n", + "GenomicRanges with 3 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000325660 chr22 29031391 - 29031477 - | ENSE00001718965 ENST00000325660 ENST00000325660 ZNRF3-AS1 ENSG00000177993 1\n", + "ENST00000325660 chr22 29031084 - 29031157 - | ENSE00001643791 ENST00000325660 ENST00000325660 ZNRF3-AS1 ENSG00000177993 2\n", + "ENST00000325660 chr22 29024999 - 29027010 - | ENSE00001267818 ENST00000325660 ENST00000325660 ZNRF3-AS1 ENSG00000177993 3\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: ZNRF3-AS1 \n", + "GenomicRanges with 2 ranges and 6 metadata columns\n", + " seqnames ranges strand exon_id tx_name tx_id gene_name gene_id exon_rank\n", + " \n", + "ENST00000412798 chr22 28992721 - 28992938 + | ENSE00001659048 ENST00000412798 ENST00000412798 ZNRF3-IT1 ENSG00000235786 1\n", + "ENST00000412798 chr22 29018164 - 29018621 + | ENSE00001595182 ENST00000412798 ENST00000412798 ZNRF3-IT1 ENSG00000235786 2\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "\n" + ] + } + ], + "source": [ + "by_gene = all_ranges.split(\n", + " groups=all_ranges.get_mcols().get_column(\"gene_name\")\n", + ")\n", + "\n", + "print(\"Exons by gene:\")\n", + "print(by_gene)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 Finding Transcription Start Sites (TSS)\n", + "\n", + "Transcription Start Sites (TSS) are the locations where transcription of a gene begins. Identifying TSS is crucial for understanding gene regulation, as many regulatory elements are located near the TSS. \n", + "\n", + "Let's use the `range()` method to get the full extent of each gene." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gene ranges:\n", + "GenomicRangesList with 932 ranges and 0 metadata columns\n", + " \n", + "Name: \n", + "GenomicRanges with 2 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "[0] chr22 11066418 - 50674175 +\n", + "[1] chr22 15282557 - 50755435 -\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: 5_8S_rRNA \n", + "GenomicRanges with 1 range and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "[0] chr22 11249809 - 11249960 -\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: A4GALT \n", + "GenomicRanges with 1 range and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "[0] chr22 42692121 - 42721299 -\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: \n", + "GenomicRanges with 1 range and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "[0] chr22 28883572 - 29057489 +\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: ZNRF3 \n", + "GenomicRanges with 1 range and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "[0] chr22 29024999 - 29031477 -\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "Name: ZNRF3-AS1 \n", + "GenomicRanges with 1 range and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + "[0] chr22 28992721 - 29018621 +\n", + "------\n", + "seqinfo(1 sequences): chr22\n", + " \n", + "\n" + ] + } + ], + "source": [ + "ranges_by_gene = by_gene.range()\n", + "\n", + "print(\"Gene ranges:\")\n", + "print(ranges_by_gene)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We convert the list to a `GenomicRanges` object." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "as GenomicRanges:\n", + "GenomicRanges with 936 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " chr22 11066418 - 50674175 +\n", + " chr22 15282557 - 50755435 -\n", + "5_8S_rRNA chr22 11249809 - 11249960 -\n", + " ... ... ...\n", + " ZNRF3 chr22 28883572 - 29057489 +\n", + "ZNRF3-AS1 chr22 29024999 - 29031477 -\n", + "ZNRF3-IT1 chr22 28992721 - 29018621 +\n", + "------\n", + "seqinfo(1 sequences): chr22\n" + ] + } + ], + "source": [ + "gr_by_gene = ranges_by_gene.as_genomic_ranges()\n", + "\n", + "print(\"as GenomicRanges:\")\n", + "print(gr_by_gene)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we resize to a width of 1 base pair at the start of each range to pinpoint the TSS." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transcript Start Sites:\n", + "GenomicRanges with 936 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " chr22 11066418 - 50674175 +\n", + " chr22 15282557 - 50755435 -\n", + "5_8S_rRNA chr22 11249809 - 11249960 -\n", + " ... ... ...\n", + " ZNRF3 chr22 28883572 - 29057489 +\n", + "ZNRF3-AS1 chr22 29024999 - 29031477 -\n", + "ZNRF3-IT1 chr22 28992721 - 29018621 +\n", + "------\n", + "seqinfo(1 sequences): chr22\n" + ] + } + ], + "source": [ + "tss = gr_by_gene.resize(width=1, fix=\"start\")\n", + "\n", + "print(\"Transcript Start Sites:\")\n", + "print(gr_by_gene)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 Defining Promoter Regions\n", + "\n", + "Here, we're defining promoters as the region 2000 base pairs upstream to 200 base pairs downstream of each TSS. This definition can vary depending on the specific analysis, but this range often captures important regulatory elements." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Promoter Regions:\n", + "GenomicRanges with 936 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " chr22 11064418 - 11066618 +\n", + " chr22 50755235 - 50757435 -\n", + "5_8S_rRNA chr22 11249760 - 11251960 -\n", + " ... ... ...\n", + " ZNRF3 chr22 28881572 - 28883772 +\n", + "ZNRF3-AS1 chr22 29031277 - 29033477 -\n", + "ZNRF3-IT1 chr22 28990721 - 28992921 +\n", + "------\n", + "seqinfo(1 sequences): chr22\n" + ] + } + ], + "source": [ + "promoters = tss.promoters(upstream=2000, downstream=200)\n", + "\n", + "print(\"Promoter Regions:\")\n", + "print(promoters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{note}\n", + "Please be aware that because gene symbols may not be unique, this `GenomicRanges` object might contain duplicates. You might want to resolve duplicate symbols by making the symbols unique. We will leave this as an exercise for the reader.\n", + "```\n", + "\n", + "## 3. Overlap Analysis\n", + "\n", + "A common task in genomic analysis is finding overlaps between different genomic features. This helps us understand the relationships between various elements in the genome and can provide insights into gene regulation and function.\n", + "\n", + "### 3.1 Reading ChIP-seq Peaks\n", + "\n", + "ChIP-seq (Chromatin Immunoprecipitation followed by sequencing) is a method used to identify binding sites of DNA-associated proteins. The peaks represent regions where a protein of interest is likely bound to the DNA. We're focusing on chromosome 22 for this example to keep the dataset manageable.\n", + "\n", + "For the purpose of this tutorial, let's download a bed file containing peaks from a ChIP-seq experiment on \"Human B cells\" to identify \"EZH2\" binding sites (from ENCODE) and cataloged in [bedbase.org](https://bedbase.org/bed/be4054acf6e3feeb4dc490e6430e358e)." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GenomicRanges with 1441 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19766788 - 19767078 *\n", + " [1] chr22 17369888 - 17370178 *\n", + " [2] chr22 19756445 - 19756735 *\n", + " ... ... ...\n", + "[1438] chr22 27212058 - 27212348 *\n", + "[1439] chr22 49201359 - 49201649 *\n", + "[1440] chr22 49663362 - 49663652 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "from geniml.bbclient import BBClient\n", + "\n", + "bbclient = BBClient(cache_folder=\"cache\", bedbase_api=\"https://api.bedbase.org\")\n", + "bedfile_id = \"be4054acf6e3feeb4dc490e6430e358e\" \n", + "bedfile = bbclient.load_bed(bedfile_id)\n", + "peaks = bedfile.to_granges()\n", + "\n", + "filter_chr22 = [x == \"chr22\" for x in peaks.get_seqnames()]\n", + "peaks_chr22 = peaks[filter_chr22]\n", + "\n", + "print(peaks_chr22)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 Finding Overlaps with TSS\n", + "\n", + "Here, we're identifying ChIP-seq peaks that overlap with TSS. This analysis can help us understand if the protein of interest tends to bind near the start of genes, which could suggest a role in transcription initiation." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peak indices that overlap with first 10 TSS:\n", + "[[], [], [], [55], [217], [], [], [], [], []]\n" + ] + } + ], + "source": [ + "overlaps = peaks_chr22.find_overlaps(tss)\n", + "\n", + "print(\"Peak indices that overlap with first 10 TSS:\")\n", + "print(overlaps[:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{note}\n", + "`find_overlaps` returns a `list` with the same length as TSS, indicating which indices from peaks overlap with each of the TSS. Ideally, we would want to return a `Hits` object similar to the Bioconductor implementation.\n", + "\n", + "**TODO: Future plans to convert this into a `Hits` object.**\n", + "```\n", + "\n", + "Let's identify the peaks that overlap with TSS." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GenomicRanges with 35 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19756445 - 19756735 *\n", + " [1] chr22 38467935 - 38468225 *\n", + " [2] chr22 24952664 - 24952954 *\n", + " ... ... ...\n", + "[32] chr22 21032552 - 21032842 *\n", + "[33] chr22 50270553 - 50270843 *\n", + "[34] chr22 19131257 - 19131547 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "all_indices = list(set(itertools.chain.from_iterable(overlaps)))\n", + "peaks_by_tss = peaks_chr22[all_indices]\n", + "print(peaks_by_tss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead, one can subset peaks that overlap with TSS using the `subset_by_overlaps` method:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GenomicRanges with 35 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19756445 - 19756735 *\n", + " [1] chr22 38467935 - 38468225 *\n", + " [2] chr22 24952664 - 24952954 *\n", + " ... ... ...\n", + "[32] chr22 21032552 - 21032842 *\n", + "[33] chr22 50270553 - 50270843 *\n", + "[34] chr22 19131257 - 19131547 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "peaks_by_tss2 = peaks_chr22.subset_by_overlaps(tss)\n", + "print(peaks_by_tss2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Additionally, in some cases, we may want to ignore strand information (`ignore_strand=True`) when finding overlaps." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GenomicRanges with 35 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19756445 - 19756735 *\n", + " [1] chr22 38467935 - 38468225 *\n", + " [2] chr22 24952664 - 24952954 *\n", + " ... ... ...\n", + "[32] chr22 21032552 - 21032842 *\n", + "[33] chr22 50270553 - 50270843 *\n", + "[34] chr22 19131257 - 19131547 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "peaks_by_tss_ignoring_strand = peaks_chr22.subset_by_overlaps(tss, ignore_strand=True)\n", + "print(peaks_by_tss_ignoring_strand)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{note}\n", + "This yields the same results for this particular scenario, but may not if the 'peaks' contain strand information.\n", + "```\n", + "\n", + "### 3.3 Finding Overlaps with Promoters\n", + "\n", + "This operation finds ChIP-seq peaks that overlap with our defined promoter regions. If a significant number of peaks fall within promoters, it might suggest that the protein plays a role in gene regulation through promoter binding. This kind of analysis is often used to characterize the binding patterns of transcription factors or other regulatory proteins." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peaks Overlapping with Promoters:\n", + "GenomicRanges with 190 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19756445 - 19756735 *\n", + " [1] chr22 37427967 - 37428257 *\n", + " [2] chr22 22521942 - 22522232 *\n", + " ... ... ...\n", + "[187] chr22 39993439 - 39993729 *\n", + "[188] chr22 22338004 - 22338294 *\n", + "[189] chr22 19131257 - 19131547 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "peaks_by_promoters = peaks_chr22.subset_by_overlaps(promoters)\n", + "\n", + "print(\"Peaks Overlapping with Promoters:\")\n", + "print(peaks_by_promoters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.4 Finding Overlaps with Exons\n", + "\n", + "Another analysis is to look at overlaps with all exons. This can help identify potential roles of the ChIP-seq peaks in splicing. Let's modify our analysis to look at all exons:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peaks overlapping with exons:\n", + "GenomicRanges with 279 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19766788 - 19767078 *\n", + " [1] chr22 17369888 - 17370178 *\n", + " [2] chr22 29307104 - 29307394 *\n", + " ... ... ...\n", + "[276] chr22 16969920 - 16970210 *\n", + "[277] chr22 35552420 - 35552710 *\n", + "[278] chr22 37931897 - 37932187 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n", + "Percentage of peaks overlapping with exons: 19.36%\n" + ] + } + ], + "source": [ + "# Combine all exons into a single GenomicRanges object\n", + "all_exons = by_gene.as_granges()\n", + "\n", + "# Find peaks overlapping with any exon\n", + "peaks_by_exons = peaks_chr22.subset_by_overlaps(all_exons)\n", + "\n", + "print(\"Peaks overlapping with exons:\")\n", + "print(peaks_by_exons)\n", + "\n", + "# Calculate the percentage of peaks that overlap with exons\n", + "percent_overlapping = (len(peaks_by_exons) / len(peaks_chr22)) * 100\n", + "\n", + "print(f\"Percentage of peaks overlapping with exons: {percent_overlapping:.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This analysis can provide insights into whether the protein of interest (captured by the ChIP-seq: \"EZH2\") tends to bind within gene bodies, potentially influencing gene expression, splicing, or other co-transcriptional processes.\n", + "\n", + "## 4. Advanced Operations\n", + "\n", + "Let's explore some more complex operations that are often used in genomic analyses.\n", + "\n", + "### 4.1 Comparing Exonic vs. Intronic Binding\n", + "\n", + "Let's first identify intron regions. We will use the `by_gene` object we created that contains a `GenomicRangesList` split by gene." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Intron regions:\n", + "GenomicRanges with 1572 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " chr22 15282557 - 15550904 -\n", + " chr22 15552888 - 15553211 -\n", + " chr22 15553587 - 15553691 -\n", + " ... ... ...\n", + " ZNRF3 chr22 28883572 - 29057489 +\n", + "ZNRF3-AS1 chr22 29024999 - 29031477 -\n", + "ZNRF3-IT1 chr22 28992721 - 29018621 +\n", + "------\n", + "seqinfo(1 sequences): chr22\n" + ] + } + ], + "source": [ + "# Create intronic regions (regions within genes but not in exons)\n", + "gene_ranges = by_gene.range().as_genomic_ranges() # Get the full extent of each gene\n", + "introns = gene_ranges.subtract(all_exons).as_granges()\n", + "\n", + "print(\"Intron regions:\")\n", + "print(introns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To gain further insight, we can compare the proportion of peaks overlapping with exons to those overlapping with introns:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peaks overlapping with introns:\n", + "GenomicRanges with 1438 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19766788 - 19767078 *\n", + " [1] chr22 17369888 - 17370178 *\n", + " [2] chr22 19756445 - 19756735 *\n", + " ... ... ...\n", + "[1435] chr22 27212058 - 27212348 *\n", + "[1436] chr22 49201359 - 49201649 *\n", + "[1437] chr22 49663362 - 49663652 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n", + "Percentage of peaks overlapping with exons: 19.36%\n", + "Percentage of peaks overlapping with introns: 99.79%\n" + ] + } + ], + "source": [ + "# Find peaks overlapping with introns\n", + "peaks_by_introns = peaks_chr22.subset_by_overlaps(introns)\n", + "\n", + "print(\"Peaks overlapping with introns:\")\n", + "print(peaks_by_introns)\n", + "\n", + "# Calculate percentages\n", + "percent_exonic = (len(peaks_by_exons) / len(peaks_chr22)) * 100\n", + "percent_intronic = (len(peaks_by_introns) / len(peaks_chr22)) * 100\n", + "\n", + "print(f\"Percentage of peaks overlapping with exons: {percent_exonic:.2f}%\")\n", + "print(f\"Percentage of peaks overlapping with introns: {percent_intronic:.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{note}\n", + "These percentages add up to over 100% because some peaks overlap both introns and exons, depending on how wide the peaks are. Ideally, you may want to filter the peaks based on preference as you annotate them with TSS, promoters, etc.\n", + "```\n", + "\n", + "This comparison can help determine if the protein of interest shows a preference for binding in exonic or intronic regions, which could suggest different functional roles (e.g., splicing regulation for exonic binding vs. potential enhancer activity for intronic binding).\n", + "\n", + "### 4.2 Finding Overlaps with the first exon\n", + "\n", + "```{note}\n", + "- This analysis is performed by transcript.\n", + "- The rationale for this analysis may vary, but we are mostly showcasing complex genomic operations that are possible with the package.\n", + "```\n", + "\n", + "Let's first put together a `GenomicRanges` object containing the first exon for each transcript." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "all_first = []\n", + "for txid, grl in by_tx:\n", + " strand = grl.get_strand(as_type = \"list\")[0]\n", + " if strand == \"-\":\n", + " all_first.append(grl.sort()[-1])\n", + " else:\n", + " all_first.append(grl.sort()[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we combine all the individual genomic elements. The [biocutils](https://github.com/BiocPy/BiocUtils) package provides utilities for convenient aspects of R that aren't provided by base Python and generics. One of these generics is the `'combine'` operation that merges or concatenates various Bioconductor classes." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "from biocutils import combine_sequences\n", + "first_exons = combine_sequences(*all_first)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now subset peaks that overlap with the first exon" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GenomicRanges with 153 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 17369888 - 17370178 *\n", + " [1] chr22 19756445 - 19756735 *\n", + " [2] chr22 45975507 - 45975797 *\n", + " ... ... ...\n", + "[150] chr22 49500975 - 49501265 *\n", + "[151] chr22 19131257 - 19131547 *\n", + "[152] chr22 29307104 - 29307394 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "peaks_with_first_exons = peaks_chr22.subset_by_overlaps(first_exons)\n", + "print(peaks_with_first_exons)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.3 Resizing and Shifting Peaks" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Narrowed and Shifted Peaks:\n", + "GenomicRanges with 1441 ranges and 0 metadata columns\n", + " seqnames ranges strand\n", + " \n", + " [0] chr22 19766807 - 19766907 *\n", + " [1] chr22 17369907 - 17370007 *\n", + " [2] chr22 19756464 - 19756564 *\n", + " ... ... ...\n", + "[1438] chr22 27212077 - 27212177 *\n", + "[1439] chr22 49201378 - 49201478 *\n", + "[1440] chr22 49663381 - 49663481 *\n", + "------\n", + "seqinfo(46 sequences): chr1 chr10 chr11 ... chrUn_KI270750v1 chrUn_KI270752v1 chrX\n" + ] + } + ], + "source": [ + "narrow_peaks = peaks_chr22.narrow(start=10, width=100)\n", + "shifted_peaks = narrow_peaks.shift(10)\n", + "\n", + "print(\"Narrowed and Shifted Peaks:\")\n", + "print(shifted_peaks)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Resizing and shifting genomic ranges can be useful in various contexts. For example:\n", + "\n", + "- Narrowing peaks might help focus on the center of ChIP-seq binding sites.\n", + "- Shifting ranges can be used to look at regions adjacent to your features of interest. e.g. defining the predicted CRISPR cleavage site based on the position of the CRISPR gRNA sequence.\n", + "\n", + "These operations demonstrate the flexibility of genomic range manipulations, which can be useful for fine-tuning analyses or testing hypotheses about the spatial relationships between genomic features.\n", + "\n", + "## 5. Exercises\n", + "\n", + "1. Calculate the average width of the ChIP-seq peaks on chromosome 22.\n", + "2. Determine how many peaks overlap with CpG islands.\n", + "3. Compute the percentage of promoter regions that have at least one overlapping ChIP-seq peak.\n", + "\n", + "## Conclusion\n", + "\n", + "In this tutorial, we've explored how to use BiocPy's genomic ranges functionality to perform various genomic analyses. These tools and techniques provide a powerful way to work with genomic interval data in Python, mirroring the capabilities from Bioconductor. They form the foundation for many more complex genomic analyses and can be applied to a wide range of biological questions.\n", + "\n", + "```{note}\n", + "Refer to the [BiocPy documentation](https://biocpy.github.io/) for more detailed information on these packages and their functionalities.\n", + "```" + ] + } + ], + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebook/hg38_exons_by_tx.rds b/notebook/hg38_exons_by_tx.rds new file mode 100644 index 0000000..16ff55c Binary files /dev/null and b/notebook/hg38_exons_by_tx.rds differ