One-liner para calcular el N50 de un ensamblaje

Hola,
el estadístico N50 se usa a menudo para resumir a grosso modo un ensamblaje de secuencias, que generalmente es un fichero FASTA con una serie de contigs.
Modificando la definición de la wikipedia, N50 es la longitud de contigs tal que usando contigs de igual o mayor tamaño recuperamos la mitad de las bases de ese ensamblaje.

Figura tomada de http://bmpvieira.github.io/assembly14.

Hoy solamente quería compartir un comando one-liner de Perl que nos permite calcularlo:

$ perl -lne 'if(/^>(\S+)/){$h=$1} else {$l=length($_);$TL+=$l;$L{$h}+=$l} \

END{ foreach $s (sort {$L{$b}<=>$L{$a}} keys(%L)){ $t+=$L{$s}; \

if($t>$TL/2){ print "N50=$L{$s}";exit }}}' assembly.fasta

Cuidado al copiarlo al terminal desde el blog, mejor hacerlo línea a línea,
hasta pronto, Bruno

Las proteínas dúctiles

Hola,
ayer me regaló mi colega Inma Yruela una copia de su reciente libro "Las proteínas dúctiles". Es éste un libro de divulgación científica donde se explica de manera amena cómo las proteínas desordenadas, que Inma y yo estudiamos en las plantas (ver artículos 1 y 2), se salen del paradigma dominante "secuencia -> estructura 3D -> función", dado que desempeñan funciones importantes en los seres vivos, al parecer más en los eucariotas, sin tener una estructura definida en al menos una parte significativa de su secuencia.

Enlaces en CSIC y Amazon.

Desorden intrínseco de los extremos N y C terminal (en rojo) de la proteína supresora tumoral p53. Figura tomada de doi: 10.1146/annurev-biochem-072711-164947.

Si bien en la literatura está ya aceptado el término de desorden intrínseco (IDP en inglés) para definir a partes de estas proteínas, Inma propone reemplazarlo por proteínas dúctiles, que muestra de manera explícita que son regiones altamente moldeables en vez de destacar que carecen de órden. Os invito a que lo leáis porque es entretenido, por su exposición sencilla de las metodologías bioquímicas, biofísicas y bioinformáticas que se usan para estudiarlas, y por la descripción de los procesos biológicos en los que participan, por ejemplo su relación con el splicing. Lo más fascinante de estas proteínas es que seguramente nos falta mucho por saber de ellas,
un saludo,
Bruno

Cómo elegir software para simular reads

Hola,
si trabajas con cierta frecuencia con datos de ultrasecuenciación, es decir, con ficheros en formato FASTQ, a menudo te habrás encontrado con la situación de que te gustaría tener más datos para validar un programa publicado, o para diseñar tu propia tubería de análisis. Pues bien, una posibilidad real desde hace varios años es simular tus propios reads o lecturas a partir de secuencias genómicas del organismo en cuestión y parámetros como la tasa de error o la plataforma de secuenciación empleada. Como ocurre frecuentemente en Biología Computacional, hay una gran variedad de software publicado para esta tarea y elegir no es trivial. El diagrama a continuación es un árbol de decisión que os guiará para esta tarea:

Figura prestada de Escalona, Rocha & Posada (2016) doi:10.1038/nrg.2016.57 http://www.nature.com/nrg/journal/v17/n8/abs/nrg.2016.57.html

Buen finde,
Bruno

email desde servidor TLS con perl

Hola,
en la entrada de hoy muestro una manera de enviar correo electrónico desde un servidor seguro (STARTTLS) por medio de un script Perl. Hasta hace poco lo hacía con el vetusto módulo Net::SMTP::TLS, pero esta solución era muy frágil y se rompía cada vez que otros módulos (fundamentalmente IO::Socket::SSL) no iban a la par en sus versiones. De hecho, en un sistema Ubuntu 14 no he logrado hacerla funcionar actualizando esos módulos, pero cambio he descubierto que con el módulo Net::SMTPS es más sencillo. Aquí queda el código:

 use strict;  
 use MIME::Lite;  
 use Net::SMTPS;  
   
 my $HELLOIP   = 'xxx.xxx.xxx.xxx'; # your IP, must be allowed by $SECURESERVER  
 my $SECURESERVER = 'smtp.domain.com'; # can also be an IP address  
 my $SECUREPORT  = 587;  
 my $SECUREUSER  = 'secure_user';   # user login in secure server  
 my $SECUREPASSWD = 'zzzzzzzzzzz';   # user password, better read from safe file  
 my $SECURESENDER = 'user@domain.com'; # must be owned by $SECUREUSER  
     
 send_email(   
  $HELLOIP,$SECURESERVER,$SECUREPORT,  
  $SECUREUSER,$SECUREPASSWD,  
  $SECURESENDER,'recipient@test.domain.org',   
  'probando','texto de prueba'  
  );  
   
 sub send_email  
 {  
  my ($hello,$host,$port,$user,$pass,$sender,$recipient,$subject,$text) = @_;  
   
  # connect to server  
  my $smtp = new Net::SMTPS(  
   $host,  
   Hello  =>$hello,  
   Port  =>$port,  
   doSSL  =>'starttls',  
   Debug  =>0 # change to 1 to see behind the curtains  
  );  
   
  $smtp->auth($user,$pass); # login  
   
  # Create the multipart container  
  my $msg = MIME::Lite->new (  
   From  => $sender,  
   To   => $recipient,  
   Subject => $subject,  
   Type  =>'multipart/mixed'  
  ) or die "# send_email : error creating multipart container: $!\n";  
   
  # add main-text if required  
  if($text)  
  {  
   $msg->attach (  
    Type => 'text/plain',  
    Data => $text  
   ) or die "# send_email : error adding the text message part: $!\n";  
  }   
   
  # actually send email  
  $smtp->mail($sender);  
     
  if($smtp->to($recipient))  
  {   
   $smtp -> data();  
   $smtp -> datasend( $msg->as_string() );   
   $smtp -> dataend();  
  }  
  else{ print "# ERROR: ". $smtp->message() }   
   
    $smtp->quit();  
 }  
   
   

Hasta la próxima,
Bruno

pseudoalineamientos y conteos de tránscritos

Hola,
durante el análisis de unos experimentos de RNAseq mi colega Carlos Cantalapiedra y yo nos desesperábamos al calcular los valores de expresión de cada transcrito en una serie de condiciones, dado que para cada una de ellas era necesario alinear las lecturas/reads originales (en formato FASTQ) contra los transcritos ensamblados. Al menos éste era el protocolo habitual antes de aparecer el algoritmo genérico de pseudoalineamiento, que se describe en la siguiente figura:

Pseudoalineamiento de reads a partir de su composición en k-meros (k=3 en el ejemplo) y un  vector de sufijos de un transcriptoma. Figura tomada de http://bioinformatics.oxfordjournals.org/content/32/12/i192.full.  

Este tipo de algoritmos, implementados en software como kalllisto o RapMap (éste último con licencia GPL), permiten estimar de manera muy eficiente y precisa con qué transcritos son compatibles las lecturas de un archivo FASTQ, es decir, a qué secuencias de un transcriptoma mapean, sin necesidad de alinear base a base los reads. Los alineamientos se pueden calcular, si fuera preciso, después del mapeo. 

Hasta la fecha se han propuesto al menos dos implementaciones del algoritmo genérico de pseudoalineamiento, que se diferencian fundamentalmente en las estructuras de datos utilizadas, como se explica en estos blogs (1 , 2) [en el segundo se hace un repaso a la evolución de este tipo de algoritmos y a su nomenclatura].

En los próximos párrafos muestro dos aplicaciones usando ejecutables de RapMap y como datos un fichero (tr.fna) con 67K transcritos de Arabidopsis thaliana, ensamblados de novo con trinity, y otro (1.f1) con 89M de lecturas Illumina SE en formato FASTQ.

1. Mapeo de reads (20 cores, fichero de salida SAM)

          operación   tiempo   comando      

BWAmem       índice    1m28s   bwa-0.7.12/bwa index tr.fna    

BWAmem        mapeo    9m57s   bwa-0.7.12/bwa mem -t 20 tr.fna 1.fq > 1.sam 

RapMap       índice      58s   RapMap-0.2.2/bin/rapmap quasiindex -t tr.fna -i ./ 

RapMap        mapeo    5m56s   RapMap-0.2.2/bin/rapmap quasimap -t 20 -i ./ -r 1.fq \

                                 -o 1.sam 

Por comparación con BWA queda claro que incluso generando alineamientos SAM estos algoritmos son mucho más rápidos. 


2. Conteo de transcritos (20 cores, implementación Sailfish)

          operación   tiempo   comando      

Sailfish     índice    1m06s   SailfishBeta-0.10.0/bin/sailfish index -t tr.fna -o qindex \

                                  -p 20   

Sailfish      mapeo    1m09s   SailfishBeta-0.10.0/bin/sailfish quant -i qindex/ -r 1.fq \

                                  -p 20 -o 1.bur-0.sf --auxDir tmpsf --dumpEq --libType SF
  

Como se muestra en la tabla, la estimación de valores de expresión de transcritos por pseudoalineamiento y conteo de reads es muy eficiente. En este ejemplo se genera un archivo de salida (quant.sf) con este contenido:

Name      Length EffectiveLength TPM NumReads
TR1|c0_g1_i1 517 316.623      5.3984 214.782
TR2|c0_g1_i1 390 191.501     3.36608     81
TR3|c0_g1_i1 699 498.611      10.502 658
...

Entre las opciones del program está la posibilidad de calcular los conteos con bootstraping, como hace kallisto, aunque en la versión que yo he probado es experimental.

En la siguiente entrada veremos más aplicaciones,
un saludo,
Bruno