[Bioinformática] PEGAS: Paquete para Análisis Evolutivos y de Poblaciones con R

Ya sabemos hacer filogenias con R. Ahora os voy a mostrar a realizar algunos análisis de genética de poblaciones y evolución con el paquete PEGAS.

El primer paso es instalar el paquete PEGAS. Abrimos R y escribimos:

> install.packages(pegas)

Seguidamente cargamos el paquete y, como en el anterior manual, introducimos un alineamiento en formato Phylip:

> library(pegas)
> data <- read.dna("alignment_contig_phy.txt")

Ya podemos empezar los análisis. Estimamos los haplotipos del alineamiento y sacamos una red de haplotipos:

> haplotipos <- haplotype(data)
> red <- haploNet(haplotipos)
> plot(red, size = attr(red, "freq"), fast = TRUE) 

A partir del alineamiento podemos estimar parámetros como la diversidad nucleotídica o el test de neutralidad D de Tajima:

> nuc.div(data)
> tajima.test(data) 

Y esto es solo una parte, para aquellos que estén interesados en realizar otro tipo de análisis con este paquete como AMOVA, acudid al manual de PEGAS.

[Bioinformática] Seminario de Supercomputación y Secuenciación de Nueva Generación: Vídeos y presentaciones

Durante los días 17 y 18 de Marzo de 2011 tuvo lugar el Seminario Científico de Supercomputación y Secuenciación de Nueva Generación en el centro de Supercomputación y Bioinformática de la Universidad de Málaga. En su web han subido videos de las charlas durante los dos días de seminario, así como las presentaciones.

http://www.scbi.uma.es/bio/portal/index.php?option=com_content&view=article&id=70:seminariongs&catid=9:news&Itemid=1

Muy interesante información, espero que os sea de interés.

[Bioinformática] Convertir entre formatos de lecturas de secuenciación masiva: SRA, FASTQ y FASTA

Esta tarde me ha dado por curiosear cómo se utilizan ciertos programas para ensamblar lecturas de secuenciación masiva, concretamente obtenidas con Illumina y que se encuentran en bases de datos. Concretamente quería correr SOAPdenovo. No por nada, solo por curiosidad, pues la ejecución de software para este fin requiere de máquinas con muchos recursos. El caso es que como formato de entrada me pedía FASTQ y sin embargo me los descargué en SRA.

Es muy sencillo, si sabes cómo, realizar esta operación. Basta con ir a la página descargas de SRA Toolkit y obtener la versión para Ubuntu. Tras descomprimir, abrirmos un terminal en la carpeta y  ejecutamos fastq-dump de la siguiente manera (no es necesario instalar nada):

$ ./fastq-dump -A SRRxxxxxx -M 0 - -split-files /ruta/fichero/SRRxxxxxx.sra

Así, después de un rato de procesamiento, obtendremos un fichero FASTQ.

Este es un fichero que puedes abrir un cualquier editor de textos (por ejemplo gEdit), pero si quieres pasarlo a formato FASTA, puedes pedir que te ayude BioPython. Si no lo tienes instalado:

$ sudo aptitude install python-biopython

Ejecutamos el interprete python (o ipython mejor) y ejecutamos el comando para convertir el formato del fichero:

$ python
>>> from Bio import SeqIO
>>> SeqIO.convert("example.fastq", "fastq", "example.fasta", "fasta")


Con esto debería bastar. Hala, ya tenemos nuestros ficheros con gigas de información para ser analizados. Pero hoy ya estoy muy cansado…

————————————————————————————————-

ACTUALIZACIÓN 19/05/2011

Script Python para automatizar conversión FASTQ a FASTA a partir de una lista de ficheros.

from Bio import SeqIO

seq = open("files.txt", "r").readlines()

for line in seq:
    a = list(line)
    b = a[:-1]
    c = "".join(b)
    print "Empezando %s" % c
    SeqIO.convert(c, "fastq", c+".fas", "fasta")
    print "Terminado %s, a por el siguiente!!!" % c

print "TODO FINALIZADO"

Repositorios Bio-Linux para Ubuntu

En los albores del blog, publiqué una entrada sobre distribuciones GNU/Linux para bioinformática. Una de ellas era Bio-Linux, cuya versión 6.0 está basada en Ubuntu 10.04 y presenta múltiples herramientas informáticas con aplicaciones biológicas, entre las que ahora se incluye software para trabajar con salidas de secuenciación masiva.

Si no quieres instalar la distribución, puede serte de utilidad instalar algún paquete desde sus repositorios. Aún no he explorado mucho, solamente he instalado el genial visor de árboles filogenéticos Dendroscope, pero tiene muy buena pinta. Este es un simple tutorial sobre cómo instalar los repositorios de Bio-Linux.

En primer lugar, debemos abrir el fichero /etc/apt/sources.list y añadir la siguiente línea:

$ sudo gedit /etc/apt/sources.list

# Bio-Linux
deb http://nebc.nerc.ac.uk/bio-linux/ unstable bio-linux

Seguidamente actualizamos los repositorios:

$ sudo aptitude update

Esta operación nos dará un mensaje de advertencia por no tener la firma GPG. No es un problema, pero si no queremos que aparezca esta advertencia, instalamos el siguiente paquete de los repositorios Bio-Linux:

$ sudo aptitude install bio-linux-keyring

Tal vez nos pregunte si nos fiamos de la fuente de repositorios, a lo que respondemos con un “Sí” (con mayúscula y tilde).

Y ya está todo listo para instalar desde el centro de software, aptitude, apt-get o synaptic los paquetes que incluye esta distribución. Si hacéis una búsqueda del topic “bio-linux” a parecerán la lista de paquetes que podemos instalar desde el repositorio. Por ejemplo, si queréis instalar Dendroscope, escribís:

$ sudo aptitude install bio-linux-dendroscope

Al finalizar la instalación está listo para utilizar.

Además, si queréis actualizar el menú de aplicaciones, haced:

$ update-menus

Así de fácil, así de libre.

Más información | Bio-Linux

Python-getopt: Script para ser ejecutado con argumentos

Aquí va otro post sobre las cosillas que últimamente he ido aprendiendo. Esta vez toca desarrollar un script para ser ejecutado con argumentos. Resulta que estoy poniendo a punto un script para luego crear una interfaz web con Python-Django donde quiero que el usuario seleccione unas funciones sí y otras no. Para testear esto decidí implentar selección e argumentos para que fuera ejecutado tal que así:

$ python myscript.py -a -t

$ python my script.py -t -z

Me he ayudado de la librería getopt. Sé que es un poco rudimientario de momento, pero me ha hecho el apaño. Parece ser que argparse es un módulo mejorado, aunque no le he metido mano. No obstante, si alguien conoce otra manera o tiene alguna sugerencia, por favor, que avise.

Bien, en primer lugar debemos importar los módulos necesarios:

import sys, getopt, os

Después definimos una función donde describiremos los argumentos:

try:
	opts, args = getopt.getopt(sys.argv[1:], "abc:dh", ["funcion1", "funcion2", "funcion3", "funcion4", "help"])
except getopt.GetoptError, err:
	# print help information and exit:
	print str(err) # will print something like "option -a not recognized"
	usage()
	sys.exit(2)

En este caso a,b,c,d y e son nuestros argumentos y seguidamente aparece el nombre de la función a la que hacen la llamada conocadas en el mismo orden que los argumentos. Los “:” que aparecen despues de “c” significan que reguiere un argumento adicional para llamar a la función como puede ser el nombre de un fichero. En estas líneas además, vemos que si no se introduce ningún argumento, salta un mensaje de error (definido por usage()) y se corta el script. Dicho mensaje se puede definir de esta forma:

def usage():
	print """
NOMBRE
\t MyScript - Es la leche\n
MODO DE EMPLEO
\t python caipyranha.py [-a] [-b] [-c] [-d] [-h]\n
\t Los nombres de los ficheros y carpetas deben ir sin espacios.\n
\t Se debe respetar el orden marcado arriba excepto para la opción -b, pudiéndose saltar alguna
\t opción excepto -e.\n
\t Debe indicar la pareja de primers utilizada para amplificar el producto.\n
\t Debe indicar el intervalo de la etiqueta que quiere utilizar para hacer comparaciones.\n
OPCIONES
\t -a \t Realiza la función 1
\t -b \t Realiza la función 2
\t -c \t Realiza la función 3
\t -d \t Realiza la función 4
\t -e \t Abre esta guía de ayuda
"""

Ahora que tenemos esto definido, vamos a indicar las funciones que ejecuta cada argumento:

for o, a in opts:
	if o in ("-h", "--help"):
		usage()
		sys.exit()
	elif o in ("-a", "--afuncion"):
		for sequencia in lista_files:
			funcion1(str(sequencia))
		print "\n\n Función 1 realizada"
	elif o in ("-b", "--bfuncion"):
		funcion2()
		print "\n\n Función 2 realizada"
	elif o in ("-c", "--cfuncion"):
		funcion3()
	elif o in ("-d", "--dfuncion"):
		funcion4()
	else:
		assert False, "error"

Y con estoy bastará para que tengamos a punto nuestro script para que se ejecute con argumentos.

Más información | getopt y argparse

[Bioinformática] Introducción a las Filogenias con el paquete R

Llevo un tiempecillo haciendo mis primeros pinitos con R. ¡Por fin! No sé si han sido 2 los años que llevo queriendo aprender y no ha sido hasta hace poco tiempo cuando ha llegado la hora (aprovecho la ocasión para recomendar la superguía The R book). Y una de las primeras cosillas que he hecho han sido filogenias. A través del libro “Analysis of Phylogenetics and Evolution with R ” he aprendido mucho sobre análisis filogenético, más allá de su realización mediante el paquete R, recomendadísimo por tanto. Este es un brevísimo tutorial para estimar árboles filogenéticos. Dedicado a Copepodo, espero que te sirva.

Una vez tenemos instalado R, lo ejecutamos desde consola escribiendo:

$ R

Seguidamente debemos de instalar los paquetes necesarios:

> install.packages(ape)
> install.packages(phangorn)
> install.packages(multicore)

y cargarlos:

> library(ape)
> library(phangorn)
> library(multicore)

Ahora cargamos nuestra secuencia en formato phylip y la convertimos a un formato idóneo para que R pueda trabajar con ella.

> data <- read.dna("alignment_contig_phy.txt")
> data <- as.phyDat(data)

Creamos matriz de distancias, escogiendo el modelo de Jukes & Cantor:

> dm <- dist.dna(as.DNAbin(data), model = "JC69")

Realizamos el análisis filogenético por un método de distancias.

> treeUPGMA <- upgma(dm)
> treeNJ <- nj(dm)
> treeFME = fastme.bal(dm)

Y dibujamos los árboles:

> par(mfrow = c(2, 2), mar = c(2, 2, 4,2))
> plot(treeUPGMA)
> title("UPGMA")
> plot(treeUPGMA, type = "fan")
> title("UPGMA (fan)")
> plot(treeNJ, type = "unrooted", main = "NJ")
> title("NJ")
> plot(treeFME, type = "unrooted", main = "fastME")
> title("fastME")

¡Ya tenemos nuestros arbolitos!

Otro truco es exportar nuestros árboles a un fichero que se guarde en nuestro disco duro. Para ello, tipeamos:

> png()
> plot(treeUPGMA, type = "unrooted")
> dev.off()

Así de fácil.

También soporta análisis por Máxima verosimilitud, Máxima Parsimonia, Bootstrapping, modelTest,… y muchas más funciones. Pero eso ya será otro día. Si la impresión es superior a tu paciencia, puedes empezar a explorar el manual de los paquetes ape y phangorn.

Instalar Mahotas en Ubuntu: Librería para análisis de imagen en Python

Estoy co-escribiendo una aplicación para análisis de imagen con Python. Para ello hemos necesitado implementar el método de umbralización de Otsu.

Gracias a un tutorial, hemos descubierto la librería “mahotas” que realiza esto con gran rapidez. Sin embargo el proceso de instalación ha sido un poco complicado, por eso realizo aquí un breve manual de instalación.

Cómo Instalar

En primer lugar es necesario instalar las dependencias que se encuentran en los repositorios. En un terminal escribimos:

$ sudo aptitude install python-numpy ipython python-matplotlib python-scipy python-dev python-setuptools python-all python-all-dev python-pip

Método sencillo

Instalamos “pymorph” y “mahotas”.

$ sudo pip install pymorph
$ sudo pip install mahotas

Método complicado

Después instalamos “pymorph” descargando desde esta página e instalando como sigue:

$ sudo python setup.py install

Por último, instalamos “mahotas” de igual modo al anterior, descargamos y ejecutamos:

$ sudo python setup.py install

(Luego he ejecutado “python -v”, pero no sé si es en realidad necesario)

Script de comprobación

import mahotas

import scipy

dna = scipy.misc.pilutil.imread(‘./foto.tif’)

T = mahotas.thresholding.otsu(dna)

print T

—————————————————————

Si el script no da error, está instalado correctamente. Para explorar nuevas posibilidades de estas librerías,  visitad este tutorial.

Instalar última versión de EMBOSS en Ubuntu: Paquete bioinformático

Hace algo más de un año hable un poquito sobre EMBOSS, una suite de bioinformática libre, que en la actualidad se encuentra en su versión estable 6.3.1. En Ubuntu puede instalarse fácilmento mediante aptitude o Synaptic, pero se trata de una version más antigua y con algunas funcionalidades menos.

Si necesitas algunas de estas funcionalidades nuevas o simplemente te encanta ir a la última, no te pierdas el siguiente tutorial.

En caso de que tengamos instalada la versión de repositorios, la desinstalamos tecleando:

$ sudo aptitude purge emboss

Instalamos algunas dependencias:

$ sudo aptitude install csh dialign libajax6 libnucleus6

Hecho esto, descargamos la versión estable más reciente
y descomprimimos el fichero. Mediante consola, nos dirigimos a la carpeta que se ha creado y compilamos e instalamos escribiendo esta secuencia de comandos:

$ ./configure
$ make
$ sudo make install

Y nada más, tenemos preparada para funcionar la versión más reciente de EMBOSS. Si no queréis intalarla, recordaos que existen servidores de libre acceso a través de la web donde podemos correr aplicaciones de esta suite.

Instalar MAFFT en Ubuntu: Alineamiento múltiple de secuencias de aminoácidos o nucleótidos

Si trabajas con la bioinformática, conocerás un el algoritmo MAFFT, destinado al alineamiento múltiple de secuencias aminoacídicas o nucleotídicas. Tiene la misma función que el Clustal pero está optimizado para secuencias con esas molestas indels.

La instalación en Ubuntu es simple. Descargamos el código fuente de MAFFT y descomprimimos el fichero. Indicar que existe una versión con extensiones para alinear ARN de forma extructural y otra sin estas extensiones.

Seguidamente, desde consola abrimos la carpeta “core” dentro de la carpeta “EMBOSS” recientemente creada para compilar y después instalar de este modo:

$ cd core

$ make clean

$ make

$ sudo make install

Para instalar las extensiones, realizamos lo mismo pero en la carpeta “extensions”

Si necesitas más información, lee el fichero “README” aportado en el comprimido.

Instalar nuevos módulos en python

El otro día conocí una página llamada Beginning Python for Bioinformatics, donde aparecen una serie de manuales e ideas para desarrollar programas bioinformáticos basados en Python. Concretamente me interesó uno para unir distintos archivos de secuencias en formato *.fasta.

Consiste en un simple programa que invoca un módulo de python que ellos mismos te dan. Así, para instalarlo, nos descargamos dicho módulo y lo copiamos en esta dirección:

$ cd /usr/lib/pymodules/python2.6

Seguidamente, para que Python reconozca el nuevo módulo, tecleamos:

$ python -v

Ahora ya podemos utilizar el programa que nos proporcionan en la misma página y hacerlo funcionar de la siguiente forma:

python merge.py '*.fas' merged.fas

Espero que os sea útil.