25 de febrero de 2011

Rendimiento de estructuras de datos en Perl

Buenas,
recientemente, tratando de resolver las dudas de un principiante en Perl, he podido volver a constatar la dificultad que suponen para los novatos los vectores (@arrays) y las tablas asociativas (%hashes). Sin embargo, estas estructuras de datos son muy empleadas por usuarios experimentados, puesto que permiten guardar y modelar datos complejos de manera relativamente sencilla. No obstante, después de tanto tiempo usando estas estructuras, creo que nunca me he puesto a medir el coste de un vector y de un hash para guardar los mismos datos en un programita Perl. Este coste es especialmente relevante para manejar volúmenes de datos grandes, como averiguaremos con ayuda de los módulos Benchmark y Devel::Size.

Si además invocamos el módulo GraphViz::Data::Grapher, podremos dibujar ambos tipos de estructuras de datos, lo cual puede ayudar a los más principiantes:




 #!/usr/bin/perl -w  
   
 use strict;  
 use Benchmark;    
 use Devel::Size;   
 use Scalar::Util;  
 #use GraphViz::Data::Grapher;   
   
   
 my $MUESTRAS = 100;   
   
 # 1) mide tiempo de creacion de estructura de datos  
 print "# construyendo estructuras de datos:\n";  
 print "> hash :\n";  
 timethis( $MUESTRAS, "crea_estructura_datos('hash')" );  
 print "> array:\n";  
 timethis( $MUESTRAS, "crea_estructura_datos('array')" );  
   
 # 2) mide memoria que necesita cada estructura  
 print "\n# memoria RAM usada (KB):\n";  
 my $ref_hash = crea_estructura_datos('hash');  
 printf("\n> hash: %1.1f\n",  
    Devel::Size::total_size($ref_hash)/1024);  
   
 my $ref_array = crea_estructura_datos('array');  
 printf("> array: %1.1f\n",  
    Devel::Size::total_size($ref_array)/1024);  
      
 # 3) mide tiempo de consulta de estructura de datos  
 print "\n# consultando estructuras de datos:\n";  
 print "> hash:\n";  
 timethis( $MUESTRAS, sub{ consulta_estructura_datos($ref_hash) } );  
 print "> array:\n";  
 timethis( $MUESTRAS, sub{ consulta_estructura_datos($ref_array) } );     
   
 ############################################  
   
 sub crea_estructura_datos  
 {  
    my ($hash_o_array) = @_;   
   
     my $referencia;  
      
    if($hash_o_array eq 'hash')  
    {  
        foreach my $n (1..100_000)   
        {  
          # las llaves ocupan menos como cadenas de caracteres  
          # http://codenode.com/perl-memory-usage  
          $referencia->{"$n"} = $n * 10;         #7165.6KB en CPU 64bits  
         #$referencia->{sprintf("%01.3f",$n)} = $n * 10; #7556.2KB "  
          #$referencia->{$n/0.3} = $n * 10;        #7914.3KB "  
        }  
         
       #descomenta para generar grafo de estructura como el del blog  
       # OJO: mejor que sea una estructura no muy grande  
       #my $grafo = GraphViz::Data::Grapher->new($referencia);  
       #print $grafo->as_png("hash.png");  
     }  
    else  
    {  
       foreach my $n (1..100_000)   
        {  
         push(@{$referencia}, $n * 10);  # 3367.9KB           
          #$referencia->[$n-1] = $n * 10; # lo mismo  
        }  
         
       #my $grafo = GraphViz::Data::Grapher->new($referencia);  
       #print $grafo->as_png("array.png");  
    }  
   
    return $referencia;  
 }   
      
 sub consulta_estructura_datos  
 {  
    my ($referencia) = @_;   
      
    my $index;  
      
    if(Scalar::Util::reftype($referencia) eq "HASH")  
    {  
        foreach my $n (1..100_000)   
        {  
          $index = int(rand(100_000));  
          $referencia->{$index} += 1;   
        }  
     }  
    else  
    {  
       foreach my $n (1..100_000)   
        {  
         $index = int(rand(100_000));  
          $referencia->[$index] += 1;   
        }  
    }  
   
    return $referencia;  
 }   
   

Mediante este código, ejecutado en mi máquina de 64 bits, podemos ver que un hash sencillo ocupa un poco más del doble que un array para guardar una lista de enteros, y que su tamaño varía según el tipo de llave que usemos. Además, tardamos el triple de tiempo en llenar el hash que el array equivalente. Finalmente, este pequeño experimento muestra que el acceso y modificación de datos dentro un hash es al menos dos veces más lento que en un array:

# construyendo estructuras de datos:
> hash :
timethis 100: 10 wallclock secs (10.45 usr +  0.01 sys = 10.46 CPU) @  9.56/s (n=100)
> array:
timethis 100:  3 wallclock secs ( 2.17 usr +  0.00 sys =  2.17 CPU) @ 46.08/s (n=100)

# memoria RAM usada (KB):

> hash: 7165.6
> array: 3367.9

# consultando estructuras de datos:
> hash:
timethis 100:  6 wallclock secs ( 6.08 usr +  0.01 sys =  6.09 CPU) @ 16.42/s (n=100)
> array:
timethis 100:  3 wallclock secs ( 2.61 usr +  0.00 sys =  2.61 CPU) @ 38.31/s (n=100)

Un saludo,
Bruno

11 de febrero de 2011

Cómo insertar una molécula interactiva en una página web con Jmol

Jmol es un visor de estructuras químicas y moléculas en 3D, está programado en Java y su código es libre.

Jmol se puede descargar aquí, es aconsejable descargar la última versión estable y existen 2 opciones, descargar todo el código (sólo para programadores) o descargar sólo los archivos binarios para ejecutarlo.

Una vez descargado, hay que descomprimirlo (si se ha descargado el archivo .tar.gz, ejecutar: tar -xzf archivo.tar.gz). Jmol se inicia ejecutando jmol.bat si usamos Windows y jmol.sh si usamos  Linux. Ni que decir que Jmol necesita que tengamos una versión de Java Runtime instalada en nuestro sistema operativo.

Una vez iniciado Jmol, el programa nos ofrece un interfaz gráfico donde podemos abrir archivos de moléculas fácilmente y visualizarlas. En el siguiente enlace hay diversos tutoriales para manejar Jmol: http://wiki.jmol.org/index.php/Jmol_Tutorials.

Jmol ofrece una interesante característica, nos permite insertar fácilmente estructuras de moléculas en páginas web y visualizarlas de forma interactiva.
Para ello hay que copiar la carpeta de Jmol en nuestro servidor e insertar el siguiente código dentro de nuestra web:
 <html>  
      <head>  
           <script type="text/javascript" src="./jmol/Jmol.js"></script>  
      </head>  
      <body>  
           <script type="text/javascript">  
                jmolInitialize("./jmol", "JmolAppletSigned.jar");  
                jmolApplet(800, "load 1je8_AB.pdb; spacefill off; wireframe off; select all; cartoon; color structure;");  
           </script>  
      </body>  
 </html>  

En primer lugar se indica en la sección <head> de la página web la ruta a la librería JavaScript de Jmol: "<script type="text/javascript" src="./jmol/Jmol.js"></script>", en nuestro caso la librería está en el directorio 'jmol' en la misma ruta que nuestra página web.

En segundo lugar se inicializala librería anterior (dentro de la sección </body> de la página web): "jmolInitialize("./jmol", "JmolAppletSigned.jar");". El segundo parámetro (JmolAppletSigned.jar) sólo es necesario si el servidor web es nuestro propio ordenador.

Finalmente se ejecuta la miniaplicación (applet) indicando el tamaño de la molécula y los comandos de Jmol que queremos ejecutar antes de mostrar la molécula: "jmolApplet(800, "load 1je8_AB.pdb; spacefill off; wireframe off; select all; cartoon; color structure;");". En este caso se ha borrado la visualización previa de la molécula y se ha representado en modo 'cartoon' (utilizado para visualizar fácilmente estructuras secundarias de proteínas).

Así es como se vería en nuestro navegador:

8 de febrero de 2011

oferta FPI 2011

Hola,
ahora publico nuestra oferta, el plazo termina el 21 de Febrero, como explica en detalle la convocatoria.

Buscamos un candidato/a para una beca predoctoral (2 años beca, seguida de un contrato de 2 años), asociada al Proyecto de Investigación "Descubrimiento de nueva variabilidad para la mejora de cebada en España" (AGL2010-21929), que ha comenzado en enero de 2011.

El trabajo se centrará en la búsqueda de diversidad genética en cebadas españolas, en concreto en las variedades tradicionales reunidas en la Colección Nuclear de Cebadas Españolas. Resultados obtenidos hasta la fecha han puesto de manifiesto una gran diversidad en esta colección, aparentemente relacionada con las condiciones agroclimáticas que se observan en la península ibérica.

En este trabajo se plantea la resecuenciación de genes candidato que intervienen en la tolerancia a estreses abióticos y en el control genético de la floración. Una vez identificados los mismos, se procederá a su análisis genético, empleando nuevas técnicas de secuenciación masiva en paralelo (NGS), utilizando amplicones de ADN de mezclas de individuos agrupados por su similitud genética. Para la realización de este trabajo se desarrollarán y utilizarán herramientas bioinformáticas, genómicas y análisis genéticos clásicos.

Se requiere expediente académico superior a 1.5 y se valorará positivamente la experiencia previa en técnicas de Biología Molecular y en programación, y el haber terminado un Master oficial.

La convocatoria especifica 2007 como fecha límite de terminación de los estudios de  licenciatura/grado/ingeniería. Si hay alguien interesado que se ponga en contacto conmigo o con Ana M. Casas.

Ofertas de trabajo en Bioinformática

Hola, 
cuelgo un par de ofertas de trabajo en Bioinformática, ambas en España, que me han llegado entre ayer y hoy:

"A postdoctoral position is available immediately in the laboratory of Computational Cell Biology, led by Dr. Ana Rojas, at the Institute of Predictive and Personalized Medicine of Cancer, Badalona, Barcelona, Spain.
We are interested in the computational characterization and evolution of the molecular pathways involved in Human Disease, and how to apply this knowledge to generate new methods for diagnosis and prognosis.
The projects focus on the development of methods for dissecting gene-disease relations based on network topology analysis.
We are looking for a highly motivated postdoctoral fellow with significant experience in system biology ad bioinformatics techniques, and interest in cancer biology. The successful candidate should have a PHD in molecular biology, bioinformatics, computing science, or related fields, and an excellent publication record.

We offer a one-year contract with a competitive salary according to experience.Interested applicants should submit a CV (which lists at least 2references) and a brief letter (1 page) outlining prior research experience and personal research interests to Dr. Ana Rojas (
arojas@imppc.org) and rrhh@imppc.org" (http://www.imppc.org)

La otra oferta, que en realidad son dos:

"Subject: Open Positions in Computational Structural Biology
Dear colleagues and friends,
We currently have openings for a postdoctoral fellow and a bioinformatician in Computational Structural Biology: 
http://sgu.bioinfo.cipf.es/home/?page=jobs
Could you please forward this announcement to whom you may think could be of interest.  Thanks!
Marc A. Marti-Renom"



Saludos,
Bruno

3 de febrero de 2011

footprintDB - online database of transcription factors and DNA binding motifs

I want to introduce you the new bioinformatic contribution of our lab to the science world: footprintDB (http://floresta.eead.csic.es/footprintdb/)

footprintDB is a database with 2905 unique DNA-binding proteins (mostly transcription factors, TFs) and 4001 DNA-binding motifs extracted from the literature and other repositories.

The binding interfaces of (most) proteins in the database are inferred from the collection of protein-DNA complexes described in 3D-footprint.

footprintDB predicts:
  1. Transcription factors which bind a specific DNA site or motif
  2. DNA motifs likely to recognised by a specific DNA-binding protein
 As summarized in the schema:


We encourage you to register in footprintDB and test it by yourself: http://floresta.eead.csic.es/footprintdb/index.php?user_register