{"id":1535,"date":"2017-11-07T12:36:20","date_gmt":"2017-11-07T10:36:20","guid":{"rendered":"http:\/\/bioinfo2.ugr.es\/secuencias\/?page_id=1535"},"modified":"2017-11-08T21:07:55","modified_gmt":"2017-11-08T19:07:55","slug":"jupyter","status":"publish","type":"page","link":"https:\/\/bioinfo2.ugr.es\/secuencias\/jupyter\/","title":{"rendered":"Jupyter Notebook"},"content":{"rendered":"

Jupyter Notebook<\/em> es una aplicaci\u00f3n que permite crear y compartir documentos que contengan c\u00f3digos, ecuaciones, visualizaciones y textos narrativos a tiempo real. Es un entorno de edici\u00f3n de texto y programaci\u00f3n interactivo, que permite ejecutar l\u00edneas de c\u00f3digo e instant\u00e1neamente obtener su resultado. Permite trabajar con numerosos lenguajes de programaci\u00f3n como son Julia, Python o R. Sus usos son m\u00faltiples:\u00a0limpieza y transformaci\u00f3n de datos, simulaci\u00f3n num\u00e9rica, modelado estad\u00edstico, visualizaci\u00f3n de datos, machine learning<\/em> y mucho m\u00e1s.<\/p>\n

Recientemente, Gr\u00fcning y colaboradores han logrado integrar una herramienta tan \u00fatil como es Jupyter Notebook<\/em> en un entorno bastante familiar para los bioinform\u00e1ticos como es Galaxy.<\/em>\u00a0Esta integraci\u00f3n combina los an\u00e1lisis est\u00e1ndares de datos de Galaxy<\/em>, con la capacidad de explorar de forma interactiva estos datos que nos proporciona Jupyter Notebook<\/em>. Esto otorga al usuario la capacidad de obtener figuras destinadas a formar parte de una publicaci\u00f3n a partir de datos complejos.<\/p>\n

 <\/p>\n

Pr\u00e1ctica guiada: Jupyter + Galaxy<\/em>. Emulaci\u00f3n del programa Compseq<\/em> de EMBOSS<\/em><\/strong><\/span><\/p>\n

Con el uso de la integraci\u00f3n de Jupyter<\/em> en Galaxy<\/em>, vamos a reproducir el programa Compseq<\/em> de EMBOSS<\/em> para una secuencia de DNA determinada. Es decir, vamos a calcular la composici\u00f3n en dinucle\u00f3tidos de una secuencia de DNA, a comparar esta composici\u00f3n con la esperada estad\u00edsticamente y a obtener figuras que representen nuestros resultados.<\/p>\n

En primer lugar, debemos acceder a la p\u00e1gina de Galaxy<\/em> (https:\/\/usegalaxy.org\/<\/a>), realizar un log in<\/em> con nuestro usuario y contrase\u00f1a y crear una nueva historia. Seguidamente, usamos la herramienta USCS main table browser<\/em>, en el grupo Get data<\/em>, para obtener la secuencia de DNA problema. En esta pr\u00e1ctica usaremos la secuencia del gen FAM81A, que sit\u00faa su entorno gen\u00f3mico entre las posiciones\u00a059723573 y 59821999 del cromosoma 15 (chr15:59723573-59821999). Es importante que el fichero que obtengamos tenga formato FASTA simple, para ello seleccionamos como formato de salida sequence<\/em>.<\/p>\n

\"\"<\/a><\/p>\n

Esto nos llevar\u00e1 a un nuevo men\u00fa el que tenemos que indicar el tipo de secuencia para los genes RefSeq<\/em>, seleccionamos ‘genomic’<\/em> en nuestro caso.<\/p>\n

\"\"<\/a><\/p>\n

Por \u00faltimo se nos abre un men\u00fa que nos permite seleccionar la regi\u00f3n gen\u00f3mica que queremos obtener, esto es arbitrario, y el formato de secuencia. Seleccionamos ‘All upper case’<\/em>, para tener nuestra secuencia gen\u00f3mica en may\u00fasculas.<\/p>\n

\"\"<\/a><\/p>\n

Una vez cargada la secuencia en Galaxy debemos abrir el entorno de programaci\u00f3n Jupyter Notebook<\/em>. Para ello abrimos la pesta\u00f1a Visualizations del Men\u00fa superior de Galaxy<\/em> y seleccionamos la opci\u00f3n ‘Interactive Environment’.<\/p>\n

\"\"<\/a><\/p>\n

Seleccionamos Jupyter<\/em> como entorno, usamos su imagen por defecto y cargamos nuestro set de datos.<\/p>\n

\"\"<\/a><\/p>\n

Y as\u00ed obtendremos una pantalla como esta:<\/p>\n

\"\"<\/a><\/p>\n

Esta es la interfaz normal de Jupyter Notebook<\/em>, lo primero que vamos a realizar es seleccionar Python 3<\/em> como el lenguaje de programaci\u00f3n activo. Para ello abrimos la pesta\u00f1a ‘Kernel’<\/em>, seleccionamos ‘Change Kernel’<\/em> y escogemos Python 3<\/em>.<\/p>\n

El bot\u00f3n verde se\u00f1alado en la imagen es el que nos permite exportar nuestro Notebook a Galaxy para que aparezca en nuestra historia.<\/p>\n

Como podemos observar, en Jupyter Notebook<\/em> se trabaja con celdas. Estas celdas tienen asignado un tipo que podemos cambiar cuando queramos. Por ejemplo, las celdas destinadas a contener texto son del tipo markdown<\/em> y las que est\u00e1n destinadas a tener c\u00f3digo son del tipo code<\/em>. \u00a0Las celdas de tipo code<\/em> poseen a su izquierda una anotaci\u00f3n del tipo In [n]<\/em>. Esta anotaci\u00f3n indica el orden en que se est\u00e1n ejecutando las diferentes celdas, pues no tiene porqu\u00e9 ser de arriba a abajo.<\/p>\n

Para ejecutar el contenido de una celda code<\/em>\u00a0se puede abrir la pesta\u00f1a Cells<\/em> y seleccionar alguna de las opciones que contienen Run Cell<\/em>, o bien usar el atajo mayus + intro.<\/em><\/p>\n

\"\"<\/a><\/p>\n

Una vez entendido lo b\u00e1sico sobre Jupyter Notebook<\/em>, vamos a reproducir el programa Compseq.\u00a0<\/em><\/p>\n

Para ello debemos cargar nuestro archivo de Galaxy<\/em> en Jupyte<\/em>r. Lo realizamos con el siguiente comando:<\/p>\n

<\/tt><\/code><\/p>\n

f = open(get(n))\r\n<\/pre>\n
Donde n es el n\u00famero que posee el archivo en nuestra historia, deber\u00eda ser 1 en nuestro caso. B\u00e1sicamente vamos a usar una ventana m\u00f3vil de tama\u00f1o 2 que va a ir contando los dinucle\u00f3tidos de nuestra secuencia. Para ello existen dos factores que nos molestan en el formato FASTA<\/em> original:\u00a0 la l\u00ednea de cabecera, y la divisi\u00f3n de la secuencia en l\u00edneas. Para transformar nuestro fichero a un formato adecuado para el uso de la ventana m\u00f3vil usamos las siguientes l\u00edneas de comando:<\/p>\n
<\/tt><\/code><\/p>\n
seq = \"\"\r\nfor linea in f:\r\n    if not linea.startswith('>'):\r\n        seq += linea.strip()\r\nprint(seq)\r\n<\/pre>\n
 <\/p>\n
Este bucle a\u00f1ade todas las l\u00edneas que no empiezan por ‘>’ a la variable seq<\/em>. Adem\u00e1s, la funci\u00f3n strip()<\/em> elimina los saltos de l\u00ednea, por lo que obtenemos la secuencia de nucle\u00f3tidos en una sola l\u00ednea.<\/p>\n
A continuaci\u00f3n debemos contar los distintos dinucle\u00f3tidos. Para ello vamos a definir una variable tipo diccionario. La variable tipo diccionario, al igual que este \u00faltimo contiene palabra – significado, contiene datos tipo clave – valor. En nuestro caso cada clave ser\u00e1 un dinucle\u00f3tido (ej: ‘AA’ o ‘CG’) y su valor asignado deber\u00e1 ser la cantidad de ese tipo de dinucle\u00f3tido encontrada en nuestra secuencia. Usamos el siguiente c\u00f3digo:<\/p>\n
<\/tt><\/code><\/p>\n
obsrv = dict()\r\n\r\nfor n in range(len(seq)-1):\r\n    dinuc = seq[n:n+2]\r\n    if not dinuc in obsrv:\r\n        obsrv[dinuc] = 1\r\n    else:\r\n        obsrv[dinuc] += 1\r\n\r\nprint(obsrv)\r\n<\/pre>\n
Este bucle recorre todas las posiciones de la secuencia menos la \u00faltima (que no tendr\u00eda dinucle\u00f3tido asociado). La variable dinuc<\/em> toma como valor la letra de esa posici\u00f3n en la secuencia y y la letra de la posici\u00f3n contigua. Tomando as\u00ed como valor ‘GC’ por ejemplo. Si ‘GC’ no est\u00e1 como clave nuestro diccionario, entonces la toma como clave y le otorga el valor 1, si s\u00ed estaba, incrementa su valor en 1. De esta forma, cada vez que encontremos ‘GC’ sumaremos 1 a su valor en nuestro diccionario.<\/p>\n
As\u00ed obtenemos un diccionario que contiene el n\u00famero total de cada dinucle\u00f3tido en nuestra secuencia. Sin embargo, nuestro diccionario est\u00e1 desordenado, tendr\u00e1 el orden en que se han ido introduciendo las claves. Para solucionar esto usamos una funci\u00f3n de ordenado del paquete collections<\/em> de Python<\/em>. El comando ser\u00eda el siguiente:<\/p>\n
<\/tt><\/code><\/p>\n
import collections\r\nobsrv = collections.OrderedDict(sorted(obsrv.items()))\r\n<\/pre>\n
Una vez obtenidos los datos de los dinucle\u00f3tidos contenidos en la secuencia, procederemos a representarlos en un histograma. Para ello usaremos el paquete de Python matplotlib.pyplot.<\/em> El c\u00f3digo es el siguiente:<\/p>\n
<\/tt><\/code><\/p>\n
import matplotlib.pyplot as plt\r\n\r\nplt.bar(range(len(obsrv)), obsrv.values(), align='center')\r\nplt.xticks(range(len(obsrv)), obsrv.keys(), rotation=25)\r\nplt.show()\r\n<\/pre>\n
Por partes, plt.bar<\/em> va a dibujar las distintas barras del histograma. Para ello requiere un rango de n\u00fameros (para el eje x<\/em>) en los que va a ir cada barra. En nuestro caso este rango va de 1 a 16, uno por cada dinucle\u00f3tido. La funci\u00f3n range<\/em> genera un rango de n<\/em> n\u00fameros, n<\/em> en este caso es el tama\u00f1o de nuestro diccionario (16 claves). En segundo lugar requiere los valores del eje y<\/em> de cada barra, que no son otros que los valores asignados a nuestras claves en el diccionario. plt.xticks<\/em> nos permite establecer las etiquetas del eje x<\/em> del mismo modo que situamos las barras. Por \u00faltimo mostramos la figura con plt.show().<\/em><\/p>\n
As\u00ed si todo ha ido bien deber\u00edamos obtener lo siguiente:<\/p>\n
\"\"<\/a><\/p>\n
 <\/p>\n
A continuaci\u00f3n calcularemos los dinucle\u00f3tidos esperados estad\u00edsticamente. La frecuencia de aparici\u00f3n de un dinucle\u00f3tido puede calcularse como el producto de las frecuencias de los nucle\u00f3tidos que lo forman. As\u00ed la frecuencia del dinucle\u00f3tidos ‘CG’ por ejemplo, ser\u00e1 igual al producto entre la frecuencia de ‘C’\u00a0 y la frecuencia de ‘G’ en nuestra secuencia. Este valor obtenido deber\u00e1 multiplicarse por el total de dinucle\u00f3tidos en la secuencia, que ser\u00e1 el n\u00famero total de nucle\u00f3tidos menos uno, el \u00faltimo.<\/p>\n
\u00bfC\u00f3mo hallamos las frecuencias de nucle\u00f3tidos? Pues simplemente dividiendo el total de cada tipo de nucle\u00f3tido de nuestra sequencia, por el n\u00famero de nucle\u00f3tidos obtenidos en la misma.<\/p>\n
El c\u00f3digo para calcular los dinucle\u00f3tidos esperados y guardarlos en un diccionario como hicimos con los observados, es el siguiente:<\/p>\n
<\/tt><\/code><\/p>\n
import collections\r\n\r\ncount = dict()\r\ntotal_nuc=0\r\n\r\nfor n in range(len(seq)):\r\n    nuc = seq[n]\r\n    total_nuc += 1\r\n    if not nuc in count:\r\n        count[nuc] = 1\r\n    else:\r\n        count[nuc] += 1\r\n\r\nesper = dict()\r\n\r\nfor key in count:\r\n    for key2 in count:\r\n        esper[key+key2] = count[key] \/ total_nuc * count[key2] \/ total_nuc * (total_nuc - 1)\r\n\r\nesper = collections.OrderedDict(sorted(esper.items()))\r\n\r\nprint(esper)\r\n<\/pre>\n
Como podemos ver, nos servimos de un diccionario intermedio (count)<\/em> para obtener el n\u00famero de cada tipo de nucle\u00f3tido contenido en la secuencia. Para obtener el diccionario esper<\/em>, que contiene los dinucle\u00f3tidos esperados, realizamos un doble bucle que emparejar\u00e1 cada tipo de nucle\u00f3tido con los cuatro tipos de nucle\u00f3tidos para realizar la operaci\u00f3n anteriormente descrita.<\/p>\n
Seguidamente realizamos un plot<\/em> exactamente igual que para los observados:<\/p>\n
<\/tt><\/code><\/p>\n
import matplotlib.pyplot as plt\r\n\r\nplt.bar(range(len(esper)), esper.values(), align='center')\r\nplt.xticks(range(len(esper)), esper.keys(), rotation=25)\r\nplt.show()\r\n<\/pre>\n
Por \u00faltimo es interesante calcular y representar el ratio observados\/esperados de la muestra. Para ello usamos el siguiente c\u00f3digo:<\/p>\n
<\/tt><\/code><\/p>\n
ratio = dict()\r\n\r\nfor key in obsrv:\r\n    ratio[key] = obsrv[key] \/ esper[key]\r\n\r\nratio = collections.OrderedDict(sorted(ratio.items()))\r\nprint(ratio)\r\n<\/pre>\n
<\/tt><\/code><\/p>\n
import matplotlib.pyplot as plt\r\n\r\nplt.xticks(range(len(ratio)), ratio.keys(), rotation=25)\r\nplt.plot(range(len(ratio.keys())), list(ratio.values()))\r\nplt.show()\r\n<\/pre>\n
Como podemos observar, el bucle simplemente recorre los diccionarios por cada uno de los tipos de dinucle\u00f3tidos y divide el n\u00famero de dinucle\u00f3tidos observados por el de esperados. Realizamos un plot<\/em> de la misma forma que para obtener un histograma. En este caso, en vez de usar plt.bar<\/em> para generar barras, usamos plt.plot<\/em> para dibujar la gr\u00e1fica.<\/p>\n
Obtenemos as\u00ed nuestro resultado final:<\/p>\n
\"\"<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Jupyter Notebook es una aplicaci\u00f3n que permite crear y compartir documentos que contengan c\u00f3digos, ecuaciones, visualizaciones y textos narrativos a tiempo real. Es un entorno de edici\u00f3n de texto y programaci\u00f3n interactivo, que permite ejecutar l\u00edneas de c\u00f3digo e instant\u00e1neamente obtener su […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":[],"_links":{"self":[{"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/pages\/1535"}],"collection":[{"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/comments?post=1535"}],"version-history":[{"count":5,"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/pages\/1535\/revisions"}],"predecessor-version":[{"id":1579,"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/pages\/1535\/revisions\/1579"}],"wp:attachment":[{"href":"https:\/\/bioinfo2.ugr.es\/secuencias\/wp-json\/wp\/v2\/media?parent=1535"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}