GenomeProtSC: an integrated proteogenomics analysis platform for long-read single-cell data

Note: To prevent misuse of computing resources, the public instance of GenomeProtSC imposes an upload file size limit of 500 MB, and FLAMES can only be run with one CPU thread.

Contents

• Installation
• General usage
  • 1. Proteome database generation
  • 2. Proteomics
  • 3. Integration
  • 4. Visualization
• Detailed input and output descriptions
  • 1a. FLAMES
  • 1b. Seurat
  • 1c. Proteome database generation
  • 2. Proteomics
  • 3. Integration
  • 4. Visualization

Installation

Note: Option 1 is under development and not yet available.

Option 1 (recommended): Run the R Shiny application with Docker

Make sure you have Docker installed and the application running in the background before you begin.

Open your terminal application and run:

docker run --rm -p 3838:3838 josieg/genomeprotsc:v1

This will take approximately 10-20 minutes to download the Docker image the first time the app is run. The –rm removes the container after it’s stopped and the -p 3838:3838 maps your local port 3838 to the same port inside the container.

To access the local R Shiny application, navigate to this link on your web browser http://0.0.0.0:3838.

You can now upload all files and run the steps in your web browser. Although the app is running through a web browser, no files are being uploaded to the internet and everything will be run locally.

To stop the container, close the web browser tab and head back to the terminal where Docker is running and press ctrl+c.

Option 2 (recommmended for downstream analysis only): Access GenomeProtSC online

https://genomeprotsc.unimelb-genomeprot.cloud.edu.au/

Option 3: Install and run the R Shiny application locally

Ensure your operating system is up to date:

sudo apt update
sudo apt install software-properties-common

Install R:

Click the following link and download the version for your operating system (Windows, macOS or Linux): https://cran.r-project.org/index.html

Install RStudio:

Click the following link and download RStudio for Desktop: https://posit.co/download/rstudio-desktop/

Install Python and cd-hit:

# if you don't already have python3
sudo apt install python
sudo apt install python3-pip

pip install biopython
pip install py-cdhit
pip install peptides

# install cd-hit
sudo apt install cd-hit

If you do not have sudo permissions, you can instead use a package manager such as Conda or compile the dependencies from source.

Install the required R and Bioconductor packages:

# either run the following commands with 'sudo' or open RStudio and install
# install Bioconductor and FLAMES (replace '3.22' with the latest Bioconductor version)

sudo R -e 'install.packages("BiocManager")'
sudo R -e 'BiocManager::install(version = "3.22")'
sudo R -e 'BiocManager::install("FLAMES")'

# install base R packages
sudo R -e 'install.packages(c("shiny", "shinyjs", "shinythemes", "shinydashboard", "data.table", "dplyr", "tidyr", "readr", "tibble", "purrr", "forcats", "phylotools", "markdown", "rmarkdown", "ggplot2", "ggrepel", "devtools", "optparse", "reshape2", "stringr", "stringi", "RColorBrewer", "scales", "gplots", "Seurat"))'

# install other Bioconductor packages
sudo R -e 'BiocManager::install(c("rtracklayer", "ORFik", "GenomicAlignments", "GenomicFeatures", "GenomicRanges", "Biostrings", "mygene", "ORFik", "patchwork", "Rsamtools", "SummarizedExperiment", "tximport", "patchwork", "vsn"), ask = F)'

# install required genomes from Bioconductor
sudo R -e 'BiocManager::install(c("BSgenome.Hsapiens.UCSC.hg38", "BSgenome.Mmusculus.UCSC.mm39"))'

Note that FLAMES takes a significant amount of time to install.

Export genome files:

# in R or R studio, export BSGenome objects as FASTA files
library(BSgenome.Hsapiens.UCSC.hg38)
library(BSgenome.Mmusculus.UCSC.mm39)

# files need to be saved in the GenomeProtSC/refs directory for FLAMES

# human
genomedb <- BSgenome.Hsapiens.UCSC.hg38
export(genomedb, "path/to/GenomeProtSC/refs/human.fasta", verbose = T, compress = F, format = "fasta")

# mouse
genomedb <- BSgenome.Mmusculus.UCSC.mm39
export(genomedb, "path/to/GenomeProtSC/refs/mouse.fasta", verbose = T, compress = F, format = "fasta")

Add a GENCODE genome annotation GTF file:

Choose a genome annotation GTF file from the GENCODE website (https://www.gencodegenes.org) and put it in the GenomeProtSC/refs directory. The annotation file used in the source code is gencode.v47.annotation.gtf from the human GENCODE v47 release (https://ftp.ebi.ac.uk/pub/databases/gencode/Gencode_human/release_47/gencode.v47.annotation.gtf.gz), but users can choose to use a different GTF file to suit their needs.

Clone this repository:

git clone https://github.com/ClarkLaboratory/GenomeProtSC.git

Decompress the UniProt + OpenProt reference files:

cd GenomeProtSC/data
gunzip openprot_uniprotDb_hs.txt.gz
gunzip openprot_uniprotDb_mm.txt.gz

Run the GenomeProtSC app:

If using RStudio:

• Open either the server.R file or the ui.R file inside the GenomeProtSC folder in RStudio
• Click the ‘Run App’ button in the top right corner

If using the command line:

# provide the path to the GenomeProtSC app
Rscript -e "shiny::runApp('/path/to/app/GenomeProtSC/', host = '0.0.0.0', port = 3838)"

General usage

GenomeProtSC is an integrated proteogenomics platform. The application consists of four components: 1) proteome database generation, 2) proteomics (performed partially externally to GenomeProtSC), 3) integration, and 4) visualization. The proteome database generation component is split into three modules: 1a) FLAMES long-read scRNA-seq module, 1b) Seurat module, and 1c) Proteome database generation module.

1. Proteome database generation

The first module processes long-read single-cell data with FLAMES and generates a custom proteome database to perform proteomics searches. The module accepts RNA sequencing FASTQ files from 10X single-cell long-read sequencing. The main outputs from this module are the results from FLAMES (single-cell transcriptomics), a FASTA file with candidate protein sequences and a metadata file with details of each candidate protein.

GenomeProtSC currently supports open reading frame (ORF) identification and database generation for human and mouse data. Users can specify an option to include short upstream ORF (uORF) and downstream ORF (dORF) protein sequences > 10 amino acids (AA). Protein sequences are generated based on a user defined minimum length set to > 30 AA by default.

1a. Run FLAMES on long-read single-cell FASTQ data

Inputs:

• FASTQ file(s) containing sequencing reads (one per sample; can be gzipped)
• Expected number of cells per sample (approximate)
• Bambu NDR (novel discovery rate; affects the threshold where novel transcripts are called)
• Reference annotation GTF file (automatically supplied by GenomeProtSC; currently limited to GENCODE/Ensembl human and mouse GTFs)

Outputs (zipped):

• Isoform annotation GTF file containing all isoforms found to be expressed in the samples
• Quantification files (one gene count CSV & one transcript count CSV per sample)

1b. Use Seurat to filter, integrate and cluster scRNA-seq samples

Inputs:

• Gene count CSV(s) from the FLAMES module; one per sample
• Transcript count CSV(s) from the FLAMES module; one per sample
• Various parameters

Outputs (zipped):

• Text file containing statistics of the sample being investigated
• Figures (in PDF format) for each plot generated by GenomeProtSC, including violin plots of the number of genes and molecules detected per cell; a scatter plot showing the number of genes per cell against the number of molecules per cell; and a UMAP plot showing cell clusters (if quality control or sample integration were performed).
• Seurat R object
• If quality control filtering and/or sample integration were performed, a tab-separated text file showing the sample, cell barcode and cluster name of each cell in the Seurat object is included in the output.
• If marker genes were calculated, a CSV file containing marker gene information is included in the output.

1c. Generate the proteome database

Inputs:

• Isoform annotation GTF file from the FLAMES module
• The species the long-read scRNA-seq data came from (currently limited to human and mouse)
• ORF length (the minimum number of amino acids ORFs should have)
• Whether to look for ORFs present in the 5’ and/or 3’ untranslated regions of reference transcripts

Outputs (zipped):

• The generated proteome database (a FASTA file containing the amino acid sequences of all ORFs found in the isoform annotation GTF file)
• A metadata file (contains information on each ORF found)
• A GTF annotation of all transcripts used to generate the proteome database

2. Proteomics

The matching of peptides to ORFs is currently performed externally to GenomeProtSC using the database produced by module 1c. It is recommended to use FragPipe to process the proteomics data with the generated proteome database.

Apply variance stabilizing normalization to peptide counts

Input:

A peptide counts file obtained from peptide quantification with FragPipe

Output:

A normalized peptide counts CSV file

3. Integration

This module integrates proteomics and transcriptomics data and consists of two steps. The first step involves associating peptides back to transcript isoforms and mapping them to spliced genomic coordinates for downstream visualization, with the main output being a GTF annotation file containing the integration of identified transcripts, peptides and ORFs. The second (optional) step is to integrate marker gene information into the GTF annotation file outputted in the first step.

Inputs:

• Proteomics results from FragPipe
• All 3 output files from the proteome database generation module (module 1c)
• Seurat R object from the Seurat module (module 1b)
• Integrated combined GTF annotation (generated by the first step and required for the optional second step)
• Marker gene CSV file (module 1b, optional)

Outputs (zipped):

• An integrated combined GTF annotation of identified transcripts, peptides and ORFs
• A CSV file containing peptide-to-transcript mappings with spliced genomic coordinates
• BED12 files for visualizing transcripts, peptides and ORFs in the UCSC Genome Browser
• A GTF file for visualizing transcripts and ORFs in IsoVis
• An HTML report summarizing the identified transcripts, peptides and ORFs
• A transcript expression information file (CSV) showing, for each transcript, the cell clusters it is expressed in and the level of evidence supporting its translation

4. Visualization

The visualization module uses IsoVis to generate peptide mapping plots along transcript isoforms with quantitative peptide intensities and uses Seurat to create UMAP plots of the expression of selected genes and isoforms in cell clusters. This allows users to visualize transcript and peptide abundance across different experimental conditions. This module requires the combined GTF annotation file generated in the integration module, and optionally the Seurat R object from module 1b, the peptide intensities from external proteomics analysis, and the transcript expression information CSV file from the integration module. Inside IsoVis, we have included gene filtering options to quickly search for features of interest, such as genes with unknown functions.

Inputs (in IsoVis):

• The combined GTF annotation file from the integration module (required)
• Peptide intensities (optional)

Inputs (in GenomeProtSC):

• The transcript expression information CSV file from the integration module (optional)
• Seurat R object from the Seurat module (required if transcript expression information is uploaded)

Outputs (zipped):

• Figures (in PDF format) for each plot generated in GenomeProtSC, including a UMAP plot showing cell cluster annotations, and plots of gene and transcript expression levels at the cell / cluster level

Detailed input and output descriptions

1a. FLAMES

1b. Seurat

1c. Proteome database generation

Proteome FASTA examples (unannotated ORFs are denoted by “ORF_”):

>protein_accession|CO=genomic_coordinates GA=gene_accession GN=gene_name TA=transcript_accession
MCGNNMSAPMPAVVPAARKATAAVIFLHGLGDTGHGWAEAFAGIKSPHIKYICPHAPVMPVTLNMNMAMPSWFDIVGLSPDSQEDESGIKQAAETVKALIDQEVKNGIPSNRIILGGFSQGPINSANRDISVLQCHGDCDPLVPLMFGSLTVERLKALINPANVTFKIYEGMMHSSCQQEMMDVKHFIDKLLPPID
>P10711|CO=chr1:4928137-4966584 GA=ENSMUSG00000033813.16 GN=Tcea1 TA=ENSMUST00000081551.14
MEDEVVRIAKKMDKMVQKKNAAGALDLLKELKNIPMTLELLQSTRIGMSVNALRKQSTDEEVTSLAKSLIKSWKKLLDGPSTDKDPEEKKKEPAISSQNSPEAREESSSSSNVSSRKDETNARDTYVSSFPRAPSTSDSVRLKCREMLAAALRTGDDYVAIGADEEELGSQIEEAIYQEIRNTDMKYKNRVRSRISNLKDAKNPNLRKNVLCGNIPPDLFARMTAEEMASDELKEMRKNLTKEAIREHQMAKTGGTQTDLFTCGKCKKKNCTYTQVQTRSADEPMTTFVVCNECGNRWKFC
>ORF_3|CO=chr2:53029193-53081430 GA=ENSMUSG00000061136.17 GN=Prpf40a TA=ENSMUST00000209364.3
MQATPSEAGGESPQSCLSVSRSDWTVGKPVSLLAPLIPPRSSGQPLPFGPGGRQPLRSLLVGMCSGSGRRRSSLSPTMRPGTGAERGGLMMGHPGMHYAPMGMHPMGQRANMPPVPHGMMPQMMPPMGG

Note: UniProt or RefSeq accessions are retained for annotated proteins.

Open reading frame (ORF) category definitions:

2. Proteomics

We recommend installing and running FragPipe for analysing mass spectrometry-based proteomics data.

Peptide detection and quantification with FragPipe:

The FragPipe output file generated should be either peptides.txt or peptide.tsv. Additionally, if FragPipe were configured to perform peptide quantification, report.pr_matrix.tsv would also be output.

Applying variance stabilizing normalization to peptide counts:

3. Integration

Integration of transcriptomics and proteomics data:

Integration of combined annotations and marker genes:

Description of peptides_info.csv output:

Description of transcript_expression_info.csv output:

4. Visualization