We developed corto (Correlation Tool), a simple package to infer gene regulatory networks from gene expression data using DPI (Data Processing Inequality) and bootstrapping to recover edges.
Supplementary Material containing all gene networks generated during corto benchmarking:
https://www.dropbox.com/sh/qzl8vjeoa7mqxfp/AACEfLQpAzUz7rqqEHEjMrhQa?dl=0
CRAN stable package: https://cran.r-project.org/package=corto
Github developmental version: https://github.com/federicogiorgi/corto
Since SNOW is being discontinued, today I worked a bit on finding new solutions to have a progress bar in R for jobs running in parallel. In this example, I run 10,000 times a simple function to calculate logarithms, using 2 threads and monitoring the progress of the 10,000 calculations.
The following are the three parameters needed for any parallel job: number of threads, number of replicates (jobs) and a function:
nthreads<-2
nreps<-10000
funrep<-function(i){
res<-c(log2(i),log10(i))
}
This was my old solution in SNOW, but CRAN is flagging all packages using SNOW with a warning “superseded packages” so we have to change it:
library(doSNOW)
cl<-makeCluster(nthreads)
registerDoSNOW(cl)
pb<-txtProgressBar(0,nreps,style=3)
progress<-function(n){
setTxtProgressBar(pb,n)
}
opts<-list(progress=progress)
i<-0
output<-foreach(i=icount(nreps),.combine=c,.options.snow=opts) %dopar% {
s<-funrep(i)
return(s)
}
close(pb)
stopCluster(cl)
Unfortunately, Parallel doesn’t have a .options in foreach, and running it like this won’t work, as the combine function is run only at the end:
library(doParallel)
cl<-makeCluster(nthreads)
registerDoParallel(cl)
pb<-txtProgressBar(0,nreps,style=3)
output<-foreach(i=icount(nreps),.combine=c) %dopar% {
funrep(i)
setTxtProgressBar(pb,i)
}
stopCluster(cl)
After many tears, I finally found a solution that could work. Essentially, instead of c() I am running a progcombine() that contains c() and also updates a progress bar. Luckily, it works on both Windows and Linux:
library(doParallel)
progcombine<-function(){
pb <- txtProgressBar(min=1, max=nreps-1,style=3)
count <- 0
function(…) {
count <<- count + length(list(…)) – 1
setTxtProgressBar(pb,count)
flush.console()
c(…)
}
}
cl <- makeCluster(nthreads)
registerDoParallel(cl)
output<-foreach(i = icount(nreps),.combine=progcombine()) %dopar% {
funrep(i)
}
stopCluster(cl)
library(pbapply)
cl<-parallel::makeCluster(nthreads)
invisible(parallel::clusterExport(cl=cl,varlist=c(“nreps”)))
invisible(parallel::clusterEvalQ(cl=cl,library(utils)))
result<-pblapply(cl=cl,
X=1:nreps,
FUN=funrep)
parallel::stopCluster(cl)
Silencing a single gene in Kelly Neuroblastoma Cells with CRISPR-Cas9. Cells are not synchronized so the Cell Cycle can be a confounding effect:
3:21am, fifth coffee. Late hour inspired a nested 7-way Venn Diagram, a blob of shared miRNAs targeting E2F genes. A thing of terrible beauty, inside every human cell. Code below, a simple list rendered with the venn package.
mirnas<-list(mirnas_e2f1,mirnas_e2f2,mirnas_e2f3,mirnas_e2f6,mirnas_e2f7,mirnas_e2f8,mirnas_mycn)
names(mirnas) <- c("E2F1","E2F2","E2F3","E2F6","E2F7","E2F8","MYCN")
png("plots/075_mirnas_7way.png",w=1000,h=1000,p=30)
venn(mirnas,ilab=TRUE,zcolor="style")
dev.off()
University of Bologna
Genomics Course
Bioinformatics Lab
Teacher: Prof. Federico M. Giorgi
Teaching Assistant: Dr. Chiara Cabrelle
Duration: 60 hours (15 modules of ~4 hours + optional extras)
Exam: Oral
The course aims at giving a practical overview of all the useful tools, approaches and techniques necessary for a competitive bioinformatician in 2019.
Module 1: Introduction to and testing of the working environment
Module 2: Phylogenetic Sequence Analysis
Module 3: Remote Homology Detection
Module 4: Introduction to Next Generation Sequencing
Module 5: NGS Alignment
Module 6: Calling Mutations
Module 7: RNA-Seq
Module 8: ChIP-Seq
Module 9 (Short): Assembly
*** end of R-free course ***
Module 10 (Long): (re)introduction to R
Module 11: Differential Expression Analysis
Module 12: Microarrays
Module 13: Single Cell RNA-Seq
Module 14: Differential Binding Analysis
Module 15: Pathway Enrichment Analysis
*** Extra Modules ***
Module 16: Coexpression Analysis in R
Module 17: Alternative Transcript Counters
Module 18: Detect gene Fusions
Module 19: Simple Machine Learning
Module 20: Survival Analsyis
Module 21: Building an R plot with lattice
Module 22: Clustering analysis in R
Module 23: DNA shape prediction in R
We have come a long way from the original simple p-value integration methods of Fisher and Stouffer. Hong Zhang, a talented grad student from the Worcester Polytechnic
Institute, and his colleagues have developed a novel method, called TFisher, for dealing with p-value integration in a wide range of test scenarios.
I quote from their abstract, available here: https://arxiv.org/abs/1801.04309
For testing a group of hypotheses, tremendous p-value combination methods have been developed and widely applied since 1930’s. Some methods (e.g., the minimal p-value) are optimal for sparse signals, and some others (e.g., Fisher’s combination) are optimal for dense signals. To address a wide spectrum of signal patterns, this paper proposes a unifying family of statistics, called TFisher, with general p-value truncation and weighting schemes. Analytical calculations for the p-value and the statistical power of TFisher under general hypotheses are given. Optimal truncation and weighting parameters are studied based on Bahadur Efficiency (BE) and the proposed Asymptotic Power Efficiency (APE), which is superior to BE for studying the signal detection problem. A soft-thresholding scheme is shown to be optimal for signal detection in a large space of signal patterns. When prior information of signal pattern is unavailable, an omnibus test, oTFisher, can adapt to the given data. Simulations evidenced the accuracy of calculations and validated the theoretical properties. The TFisher tests were applied to analyzing a whole exome sequencing data of amyotrophic lateral sclerosis. Relevant tests and calculations have been implemented into an R package TFisher and published on the CRAN.
The methods are implemented in R and available on CRAN:
