9 años de #!/perl/bioinfo

Hola,

ayer me dí cuenta de que este blog lleva en marcha ya más de 9 años, así que he hecho un rápido análisis de a quién y dónde llegan los 258 artículos publicados. A continuación muestro algunos datos de Google Analytics (GA), empezando por la gráfica de visitantes:

Usuarios entre el 31/05/2010 y el hasta el 11/11/2019 (GA)

En total hemos tenido 67.191 usuarios, que han visto un total de 111.806 páginas (263.069 según Blogger) en 86.288 sesiones, gastando cerca de un minuto por sesión.

Páginas vistas por países desde 2010 según Blogger.

País de los visitantes en los últimos 30 días (GA).

Artículos más leídos

Algunos comandos de R útiles en ciencia e investigación 15 jun. 2010	15860
Curso de Python para biólogos - Lección 1 10 feb. 2015, 5 comentarios	2611
Regresión lineal e intervalo de confianza 7 jun. 2010, 3 comentarios	2155
Buscar un elemento en un array de perl 8 nov. 2010, 2 comentarios	2152
Generar todas las posibles combinaciones posibles 19 ago. 2010, 9 comentarios	2016
Tutorial para escribir trabajos académicos y tesis 13 jun. 2010	1795
Secuenciación de amplicones y genotipado de alto rendimiento 14 sept. 2015, 1 comentario	1384
Matrices de sustitución y alineamiento de secuencias 4 jul. 2012	1179
DIAMOND as alternative to BLASTP 19 dic. 2016, 1 comentario	1094
Expresión regular de la familia de las O-fucosiltransferasas 13 feb. 2016, 1 comentario	1043

Lengua del navegador

1.	es-es	5.936	37,67 %
2.	en-us	3.326	21,11 %
3.	es	2.111	13,40 %
4.	es-419	1.461	9,27 %
5.	es-mx	439	2,79 %
6.	es-us	404	2,56 %
7.	pt-br	364	2,31 %
8.	en-gb	356	2,26 %

País

1.	Spain	5.008	31,87 %
2.	Mexico	2.345	14,92 %
3.	United States	1.640	10,44 %
4.	Colombia	1.178	7,50 %
5.	Chile	843	5,36 %
6.	Argentina	714	4,54 %
7.	Peru	638	4,06 %
8.	Brazil	525	3,34 %
9.	Ecuador	307	1,95 %
10.	United Kingdom	258	1,64 %

Ciudad

1.	(not set)	1.628	10,09 %
2.	Madrid	1.113	6,90 %
3.	Mexico City	684	4,24 %
4.	Chicago	635	3,94 %
5.	Santiago	576	3,57 %
6.	Bogota	535	3,32 %
7.	Barcelona	520	3,22 %
8.	Valencia	300	1,86 %
9.	Ashburn	286	1,77 %
10.	Buenos Aires	250	1,55 %

Sistema operativo

1.	Windows	9.508	60,59 %
2.	Linux	1.973	12,57 %
3.	Android	1.755	11,18 %
4.	Macintosh	1.527	9,73 %
5.	iOS	618	3,94 %

Hasta pronto,
Bruno

progreso en la predicción estructural de proteínas

Hola,
hace unos meses contaba aquí el algoritmo AlphaFold para plegar proteínas por predicción de distancias entre residuos, que había escuchado de boca de uno de sus creadores. Hoy me he encontrado con la evaluación oficial de estructura terciaria del experimento CASP13, donde AlphaFold se destacó como mejor grupo predictor. La conclusión se resume en esta figura:

Fuente: https://onlinelibrary.wiley.com/doi/10.1002/prot.25787

Parece seguro decir que en CASP13 ha habido un salto en la calidad de las predicciones respecto a ediciones previas, a pesar de que la dificultad en esta edición es comparable a la anterior (Tabla 1 del artículo de Abriata et al de la figura). Los evaluadores achacanla mejoría precisamente a que más allá de predecir contactos, algunos de los mejores predictores, como A7D (AlphaFold), MULTICOM o RaptorX han empezado a predecir directamente distancias entre residuos, algo para la cual hacen falta alineamientos múltiples de secuencia muy profundos. Hasta luego,
Bruno

Paralelizar procesos en perl con threads

Con los modernos ordenadores que tenemos con procesadores de 2, 4, 8 o más núcleos podemos pensar en paralelizar procesos fácilmente en Perl. ¿Qué significa esto? Básicamente que el tiempo que tardará en correr nuestro programa se reducirá proporcionalmente al número de núcleos, si a cada núcleo le mandamos tareas diferentes a realizar (threads)

Pero hay que ser cuidadoso, no todos los programas son adecuados para ser paralelizados. Un programa paralelizable en threads requiere que sus procesos puedan ser independientes y una vez finalizados podamos recoger y unificar sus resultados sin problemas. Además paralelizar significa multiplicar las copias en memoria de las variables, por lo cual sólo podremos paralelizar procesos que no consuman grandes cantidades de memoria o el proceso de copia ralentizará los cálculos.

El código mostrado a continuación realiza una suma de números de tres formas diferentes:

1. De forma tradicional, con 3 procesos de suma en serie.
2. Usando 3 threads que calculan simultáneamente.
3. Usando un bucle con 3 threads que calculan simultáneamente.

La conclusión que podemos obtener de los resultados es que el proceso se realiza casi 3 veces más rápido que de la forma tradicional mediante el método de 3 threads. Pero que cuando se realiza la paralelización para cálculos más sencillos (bucle de threads), no sólo no se mejora el tiempo de cálculo, sino que se ralentiza enormemente el cálculo (5 veces más que el tradicional), esto se debe a que el coste de lanzar los threads no se compensa con el tiempo de cálculo de cada uno.

Resultado:

 Total = 300000000  
 Time taken by the traditional way (3 serial processes) was 26 wallclock secs (26.48 usr 0.00 sys + 0.00 cusr 0.00 csys = 26.48 CPU) seconds  
   
 Total = 300000000  
 Time taken by 3 parallel threads was 9 wallclock secs (25.94 usr 0.00 sys + 0.00 cusr 0.00 csys = 25.94 CPU) seconds  
   
 Total = 300000000  
 Time taken by a loop of 10000 times 3 threads was 104 wallclock secs (103.41 usr 1.01 sys + 0.00 cusr 0.00 csys = 104.42 CPU) seconds  
   

Código:

 use threads;  
 use Benchmark;  
 use Config;  
 $Config{useithreads} or die('Recompile Perl with threads to run this program.');  
   
 # Subroutine to test multithreading  
 sub calc {  
      my ($number) = @_;  
      my $i=0;  
      while ($i<$number) {  
           $i++;  
      }  
      return $i;  
 }  
   
 # Define a number to calculate  
 my $number = 100000000;  
   
 # Start timer  
 my $start = new Benchmark;  
   
 # Run subroutines in the traditional way  
 my $res1 = calc($number);  
 my $res2 = calc($number);  
 my $res3 = calc($number);  
 my $total = $res1 + $res2 + $res3;  
   
 # End timer  
 my $end = new Benchmark;  
   
 # Calculate difference of times  
 my $diff = timediff($end, $start);  
   
 # Print final result  
 print "\nTotal = $total\n";  
   
 # Report benchmark  
 print "Time taken by the traditional way (3 serial processes) was ", timestr($diff, 'all'), " seconds\n\n";  
   
 # Start timer  
 $start = new Benchmark;  
   
 # Create multiple threads running each one the subroutine  
 my $thr1 = threads->create(\&calc, $number);  
 my $thr2 = threads->create(\&calc, $number);  
 my $thr3 = threads->create(\&calc, $number);  
   
 # Check subroutines ending and retrieve results   
 $res1 = $thr1->join();  
 $res2 = $thr2->join();  
 $res3 = $thr3->join();  
 $total = $res1 + $res2 + $res3;  
   
 # End timer  
 $end = new Benchmark;  
   
 # Calculate difference of times  
 $diff = timediff($end, $start);  
   
 # Print final result  
 print "Total = $total\n";  
   
 # Report benchmark  
 print "Time taken by 3 parallel threads was ", timestr($diff, 'all'), " seconds\n\n";  
   
 # Start timer  
 $start = new Benchmark;  
   
 # Divide the process  
 $total = 0;  
 my $divide = 10000;  
 $number = $number / $divide;  
   
 # Create multiple threads running each one the subroutine  
 for (my $i=0; $i<$divide; $i++){  
      $thr1 = threads->create(\&calc, $number);  
      $thr2 = threads->create(\&calc, $number);  
      $thr3 = threads->create(\&calc, $number);  
      # Check subroutines ending and retrieve results   
      $res1 = $thr1->join();  
      $res2 = $thr2->join();  
      $res3 = $thr3->join();  
      $total += $res1 + $res2 + $res3;  
 }  
   
 # End timer  
 $end = new Benchmark;  
   
 # Calculate difference of times  
 $diff = timediff($end, $start);  
   
 # Print final result  
 print "Total = $total\n";  
   
 # Report benchmark  
 print "Time taken by a loop of 10000 times 3 threads was ", timestr($diff, 'all'), " seconds\n\n";