Convert read counts to transcripts per million (TPM).

counts_to_tpm.R

#' Convert counts to transcripts per million (TPM).
#' 
#' Convert a numeric matrix of features (rows) and conditions (columns) with
#' raw feature counts to transcripts per million.
#' 
#'    Lior Pachter. Models for transcript quantification from RNA-Seq.
#'    arXiv:1104.3889v2 
#'    
#'    Wagner, et al. Measurement of mRNA abundance using RNA-seq data:
#'    RPKM measure is inconsistent among samples. Theory Biosci. 24 July 2012.
#'    doi:10.1007/s12064-012-0162-3
#'    
#' @param counts A numeric matrix of raw feature counts i.e.
#'  fragments assigned to each gene.
#' @param featureLength A numeric vector with feature lengths.
#' @param meanFragmentLength A numeric vector with mean fragment lengths.
#' @return tpm A numeric matrix normalized by library size and feature length.
counts_to_tpm <- function(counts, featureLength, meanFragmentLength) {
  
  # Ensure valid arguments.
  stopifnot(length(featureLength) == nrow(counts))
  stopifnot(length(meanFragmentLength) == ncol(counts))
  
  # Compute effective lengths of features in each library.
  effLen <- do.call(cbind, lapply(1:ncol(counts), function(i) {
    featureLength - meanFragmentLength[i] + 1
  }))
  
  # Exclude genes with length less than the mean fragment length.
  idx <- apply(effLen, 1, function(x) min(x) > 1)
  counts <- counts[idx,]
  effLen <- effLen[idx,]
  featureLength <- featureLength[idx]
  
  # Process one column at a time.
  tpm <- do.call(cbind, lapply(1:ncol(counts), function(i) {
    rate = log(counts[,i]) - log(effLen[,i])
    denom = log(sum(exp(rate)))
    exp(rate - denom + log(1e6))
  }))

  # Copy the row and column names from the original matrix.
  colnames(tpm) <- colnames(counts)
  rownames(tpm) <- rownames(counts)
  return(tpm)
}

@mostafaBio In order to convert TPM to counts, you need the total number of assigned reads in each sample.

Hi,
I found this a useful script while looking for a tool to calculate TPM from read counts. However, I fail to understand how to get the 'meanFragmentLength A numeric vector with mean fragment lengths'. All I have is gene_id and its read_counts from HTSeq-count. So, how do I go about getting a 'meanFragmentLength'-- my data set is single end reads from illumina.
Thanks.
SD

@sdash-github For paired-end sequencing data, the mean fragment length can be obtained from Picard using InsertSizeMetrics.

It is not possible to estimate fragment length from single-end sequencing data.

Here's a fragment (molecule of cDNA):

fragment      -----------------------
read1         ====
read2                            ====
insert            ===============

              |---------------------|

     fragment length = read1 + insert + read2

Here are simpler functions for RPKM and TPM:

rpkm <- function(counts, lengths) {
  rate <- counts / lengths 
  rate / sum(counts) * 1e6
}

tpm <- function(counts, lengths) {
  rate <- counts / lengths
  rate / sum(rate) * 1e6
}

See here for a demonstration of how they work: https://gist.github.com/slowkow/6e34ccb4d1311b8fe62e

For more details, see: http://blog.nextgenetics.net/?e=51

Thank you very much. Almost a life saver for me.
Being not an expert in R:
The two functions along with their use in https://gist.github.com/slowkow/6e34ccb4d1311b8fe62e helped me understand how to put things together to make it work.
You already are or would make a great teacher.
SD

@slowkow Shouldn't Line 44 be:

 rownames(tpm) <- rownames(counts)

and not

  rownames(tpm) <- rownames(counts)[idx]

Thanks for catching that! My mistake.

Thank you for this function!

I have a question, I am trying to estimate TPM from HTSEQ counts. I just cannot estimate fragment length. I was wondering if you I am confused as the bam outputted by HTSEQ are unusable for picard ( negative fragment length). Did anyone have this probem?

@Idutoit - Your problem is actually pretty unclear to me. You calculated negative fragment lengths from your alignment files? Maybe don't use HTSEQ for alignments. I've used HTSEQ for counts, but it is SO SLOW. Use Subread featureCount instead maybe. There are lots of good aligners available. STAR, HISAT2, etc...

@slowkow - Thanks a lot for posting this code. And... good job on that name. 'slowkow'. haha.

What advantage does this have over ignoring meanfragmentlenth estimates as I've seen in some TPM implementations:
https://haroldpimentel.wordpress.com/2014/05/08/what-the-fpkm-a-review-rna-seq-expression-units/

Cheers,
Paul

Hi,

Why do you exclude genes with negative effective length ? RSEM implements a model that always find a positive effective length. In my case, I prefer set the effective length to 1. Negative effective length is a quite common for genome of pathogens with small genes as effectors. The bias of negative effective length is largely due to missing UTR in annotation files that reduce transcript to the CDS part. I think that it is important to keep these genes. The way you count the reads and estimate the effective length influences the TPM value. So, if you want to compare libraries with TPM metrics, you must compute your TPM in the same way. Finally, I am not sure that TPM is the most reliable metric to compare libraries, especially if different tools were used for computation.
+
nico

@nlapalu Thanks for the comments! I think you're probably right about the effective length.

Indeed, TPM may not be reliable when comparing multiple different libraries. One should check to see if libraries are comparable and perform normalization that is appropriate for the research question.

Hi, I tried your scripts to convert featureCounts results from counts to TPM. Thanks.

But I wonder why the TPM results are not the same as RSEM generated..as the raw counts are same for both RSEM and featureCounts generated.

Is it because in the script you used the "effLen" instead of gene length?

p.s: Why don't you just wrote the equation without "log" and "exp", it might be easier to read and understand :)

flyboyleo - I tried the featureCounts script also and found it didn't produce columns that summed to 1e6 (which is what is required imo to be able to compare transcripts across samples)
fwiw, the rpkms didn't compute correctly either
So I wrote an Rscript based on the calculations shown in http://www.rna-seqblog.com/rpkm-fpkm-and-tpm-clearly-explained/

https://github.com/andysaurin/tpm_rpkm

Hi @slowkow

This code is very useful!!!

By the way, I try to calculate mean fragment length with Picard and it is turn to be around 617.
I think 617 is relatively large length to exclude the genes.
Do you know any good idea to adjust this situation?
(ex. using original gene length for effective length?)

Thanks.

@maromato Could I ask you to please consider asking for additional help at Biostars? That is a better place to ask for help than GitHub Gist comments.

This is the Python version:

import pandas as pd
import numpy as np

def read_counts2tpm(df, sample_name):
    """
    convert read counts to TPM (transcripts per million)
    :param df: a dataFrame contains the result coming from featureCounts
    :param sample_name: a list, all sample names, same as the result of featureCounts
    :return: TPM
    """
    result = df
    sample_reads = result.loc[:, sample_name].copy()
    gene_len = result.loc[:, ['Length']]
    rate = sample_reads.values / gene_len.values
    tpm = rate / np.sum(rate, axis=0).reshape(1, -1) * 1e6
    return pd.DataFrame(data=tpm, columns=sample_name)

a = pd.DataFrame(data = {
    'Gene': ("A","B","C","D","E"),
    'Length': (100, 50, 25, 5, 1),
     'S1': (80, 10,  6,  3,   1),
     'S2': (20, 20, 10, 50, 400)
})

read_counts2tpm(a, ['S1', 'S2'])

The sad thing is i was using your "tpm_rpkm_from_featureCount.R" code years ago, and could not find the place how to cite it. cry......

hi @slowkow just wonder if I can use expected (estimated) counts (RSEM result) for this script?
(or is its use restricted to raw counts only?)