Analisis y comparacion de algoritmos de biclustering

1

ANÁLISIS Y COMPARACIÓN DE ALGORITMOS DE BICLUSTERING

OSCARA ALEJANDRO VELASCO MERA

CARLOS ANDRÉS MORALES GONZÁLEZ

UNIVERSIDAD AUTÓNOMA DE OCCIDENTE FACULTAD DE INGENIERÍA

DEPARTAMENTO DE OPERACIONES Y SISTEMAS PROGRAMA DE INGENIERÍA INFORMÁTICA

SANTIAGO DE CALI 2011

2

ANÁLISIS Y COMPARACIÓN DE ALGORITMOS DE BICLUSTERING

OSCARA ALEJANDRO VELASCO MERA

CARLOS ANDRÉS MORALES GONZÁLEZ

Proyecto de Grado para optar el título de

Ingeniero Informático

Directora

MSc.LYDA PEÑA PAZ

UNIVERSIDAD AUTÓNOMA DE OCCIDENTE FACULTAD DE INGENIERÍA

DEPARTAMENTO DE OPERACIONES Y SISTEMAS PROGRAMA DE INGENIERÍA INFORMÁTICA

SANTIAGO DE CALI 2011

3

Santiago de Cali, 21 de Febrero de 2011

Nota de aceptación:

Aprobado por el comité de Grado en

cumplimiento de los requisitos exigidos por

la Universidad Autónoma de Occidente para

optar al título de Ingeniero Informático.

Firma del presidente del jurado

4

TABLA DE CONTENIDO

1.0 INTRODUCCIÓN ............................................................................................... 9

1.1 Titulo ..................................................................................................................................10

1.2 Participantes ..........................................................................................................................10

2.0 PLANTEAMIENTO DEL PROBLEMA .................... ........................................ 11

3.0. JUSTIFICACIÓN ................................ ............................................................ 12

4.0. ANTECEDENTES ........................................................................................... 13

5.0 MARCO TEORICO .......................................................................................... 14

5.1 Microarreglos .........................................................................................................................14

5.2 Técnicas de Biclustering ....................................................................................................15

5.3 Tipos de Biclusters ...............................................................................................................15

5.4 Algoritmos de Biclustering ...................................................................................................16

5.5 Clasificación de los algoritmos de Biclustering. ...............................................................17

5.5.1 Divide y Vencerás. ........................................................................................................19

5.5.2 Combinación de Clustering sobre Filas y Columnas. ..............................................20

5.5.3 Búsqueda Voraz Iterativa. ............................................................................................22

5.5.4 Búsqueda Exhaustiva. ..................................................................................................27

5.5.5. Identificación De Parámetros De Distribución .........................................................30

5.5.6. Búsqueda Estocástica .................................................................................................33

6.0. OBJETIVOS .................................... ............................................................... 35

6.1 Objetivo General ...................................................................................................................35

6.2. Objetivos Específicos ..........................................................................................................35

7.0 METODOLOGÍA ................................... ........................................................... 36

8.0 DESARROLLO .................................... ............................................................ 37

8.1 Revisión de Algoritmos Existentes. ...................................................................................37

8.2 Definición de criterios de comparación ............................................................................38

8.3 Análisis de cada Algoritmo de Biclustering .......................................................................38

8.3.1 Cheng y Church .................................................................................................................38

8.3.1.2 Implementación ..........................................................................................................40

8.3.1.3 Problemas ...................................................................................................................43

5

8.3.1.4 Pruebas .......................................................................................................................46

8.3.1.5 Resultados ..................................................................................................................48

8.3.2 Samba .................................................................................................................................49

8.3.2.1 Diagrama de clases del algoritmo SAMBA ...........................................................49

Figura 4: UML de Samba .......................................................................................................49

8.3.2.2 Implementación .........................................................................................................50

8.3.2.3 Problemas ...................................................................................................................53

8.3.2.4 Pruebas .......................................................................................................................53

8.3.2.5 Resultados ..................................................................................................................54

8.3.3 Interrelated Two-Way Clustering (ITWC) ......................................................................55

8.3.3.1 Software ......................................................................................................................55

8.3.3.2 Funcionamiento .........................................................................................................55

8.3.3.3 Problemas ..................................................................................................................56

8.3.3.4 Resultados ..................................................................................................................56

8.4 Análisis ...................................................................................................................................57

8.4.1 Comparación de los Métodos de Acuerdo al Tiempo de Ejecución ......................59

8.4.2 Comparación De Los Métodos De Acuerdo Al Orden De Complejidad ...............62

8.4.3 Comparación de los resultados usando medida de calidad MSR .........................63

8.4.4 Comparación de los resultados usando medida de calidad Error Virtual. ...........65

9.0 RESULTADOS .................................... ............................................................ 66

10.0 CONCLUSIONES .......................................................................................... 67

11.0 RECOMENDACIONES .................................................................................. 68

12.0 BIBLIOGRAFÍA ................................. ............................................................ 69

13.0 ANEXOS ........................................................................................................ 71

6

LISTA DE TABLAS

Tabla N° 1 Clasificación de los Algoritmos de Biclu stering. 15

Tabla N° 2 Algoritmos Seleccionados. 38

Tabla N° 3 Bicluster introducidos en cada matriz. 48

Tabla N° 4 Resultados Cheng y Church . 49

Tabla N° 5 Resultados de Samba. 55

Tabla N° 6 Resultados de Interrelated Two-Way Clust ering. 56

Tabla N° 7 . Comparación algoritmos de Cheng y Chur ch,

SAMBA e Interrelated Two-Way clustering 57

Tabla N°8 Comparación Tiempo de Ejecución Cheng y Church. 59

Tabla N°9 Comparación Tiempo de Ejecución SAMBA. 59

Tabla N° 10 Tiempo Maquina de Ejecución Cheng y Chu rch. 60

Tabla N° 11. Tiempo Maquina de Ejecución SAMBA. 60

Tabla N° 12. Comparación Orden de Complejidad. 6 2 Tabla Nº 13 Evaluación de calidad de bicluster usando MSR. 64 Tabla Nº 14 Evaluación de calidad de bicluster usando Error Virtual. 65

7

LISTA DE FIGURAS

Figura Nº 1: Distintos tipos de biclusters 13

Figura Nº 2: Estructura De Los Tipos De Bicluster 16

Figura Nº 3: UML de Cheng y Church 40

Figura Nº 4: UML de Samba 50

Figura Nº 5: Grafo de ejemplo de Samba 51

8

LISTA DE ANEXOS

Anexo Nº1: Resultados Biclusters para cada matriz 71 Anexo Nº2: Funcionamiento Software BCCA 72 Anexo Nº 3 Calculos tiempo de ejecucion Cheng y Church 73 Anexo Nº 4 Calculos tiempo de ejecucion SAMBA 78

9

1.0 INTRODUCCIÓN

La Bioinformática, es la aplicación de tecnología de computadores a la gestión y análisis de datos biológicos. Los términos Bioinformática, Biología computacional y, en ocasiones, Biocomputación, utilizados en muchas situaciones como sinónimos, hacen referencia a campos de estudios interdisciplinarios muy vinculados, que requieren el uso o el desarrollo de diferentes técnicas que incluyen Informática, Matemática Aplicada, Estadística, Ciencias de la Computación, Inteligencia Artificial, Química y Bioquímica para solucionar problemas, analizar datos, o simular sistemas o mecanismos, todos ellos de índole biológica, y usualmente (pero no de forma exclusiva) en el nivel molecular. El núcleo principal de estas técnicas se encuentra en la utilización de recursos computacionales para solucionar o investigar problemas sobre escalas de tal magnitud que sobrepasan el discernimiento humano. Los avances en investigación en los campos de la biología molecular y la genómica, unidos a un imparable perfeccionamiento en los sistemas de información y almacenamiento, hacen posible la generación de ingentes cantidades de datos experimentales de gran dimensionalidad. Actualmente, los métodos de extracción de conocimiento se basan en diferentes paradigmas, tales como las técnicas de clustering, biclustering, generación de ontologías o el uso de redes genéticas. Este trabajo de investigación tiene como objetivo primordial realizar un análisis comparativo entre tres tipos de algoritmos de biclustering que existen, buscando así el más eficiente y el que mejor represente patrones de actividad similares bajo un subconjunto de condiciones experimentales. En el trabajo se desarrolla la revisión e implementación de tres algoritmos de biclustering, los cuales serán comparados por sus características como Tipo de biclustering, Estructura de los bicluster encontrados, Enfoque, Tiempo de ejecución y Orden de complejidad. Finalmente en el documento se muestra un análisis en el que se establece cual algoritmo es más eficiente para un determinado caso.

10

1.1 Titulo Análisis y comparación de algoritmos de Biclustering

1.2 Participantes Oscar Alejandro Velasco Mera código: 2045476 Carlos Andrés Morales González código: 2046178 Lyda Peña Paz Directora del programa de ingeniería informática

11

2.0 PLANTEAMIENTO DEL PROBLEMA

Uno de los problemas biológicos más importantes es el análisis de ADN para determinar la incidencia de los diferentes genes de un organismo en el comportamiento anormal del mismo; en este sentido, los experimentos con Microarreglos y especialmente el análisis de los datos obtenidos de ellos, se convierten en un problema computacional bastante interesante. Los Microarreglos están íntimamente ligados al desarrollo y miniaturización de las técnicas de afinidad que se conocen y que se han empleado desde hace años como una herramienta común en biología molecular. A partir de los Microarreglos se pueden realizar experimentos construyendo matrices numéricas que permitan el análisis computacional de los datos. Actualmente existen diferentes métodos para obtener información y conocimiento a partir de los datos de un Microarreglo , dependiendo de la aplicación que se utilice. La minería de datos es muy aplicable en estos casos ya que su objetivo es buscar patrones no conocidos sobre conjuntos de datos muy grandes y así obtener la información oculta en ellos. El Clustering y Biclustering son técnicas de minería de datos que permiten agrupar datos que contengan características comunes, y poder de esta manera extraer información relevante a partir de conjuntos de datos heterogéneos y en los que la extracción de conocimiento no es inmediata. Actualmente se conocen múltiples algoritmos que tienen por objetivo realizar biclustering de los datos obtenidos en experimentos de Microarreglos de ADN, cada algoritmo tiene ventajas y desventajas que los hacen más aplicables en ciertas situaciones que en otras y por ello se hace importante el análisis y comparación de estos algoritmos, buscando así el más eficiente, analizando su tiempo de ejecución y orden de complejidad.

12

3.0. JUSTIFICACIÓN Se selecciona este tema porque se quiere hacer un estudio mediante un análisis entre los diferentes tipos de algoritmos de Biclustering, ya que dentro del ámbito de la Bioinformática, las técnicas de Biclustering están cobrando gran importancia como herramientas de análisis de datos de expresión genética. Su objetivo principal consiste en obtener submatrices formadas por grupos de genes los cuales comparten patrones de comportamiento similares bajo un subgrupo de condiciones experimentales. Sus aplicaciones son variadas y de gran importancia: estudio de enfermedades de origen genético, relevancia de genes en proceso cancerígenos, estudio del comportamiento de las células bajo el efecto de ciertas drogas, etc. Actualmente existe un gran número de propuestas, que utilizan distintos algoritmos para la búsqueda de biclusters a partir de un conjunto de datos, y comúnmente los biólogos, que son los principales usuarios, no saben cuál podría ajustarse mejor a sus necesidades y que por ello se justifica desarrollar un proyecto donde se den algunas indicaciones al respecto.

13

4.0. ANTECEDENTES

Beatriz Pontes Balanza, en su documento “Técnicas de Evaluación en Algoritmos de Biclustering sobre datos de expresión genómica”19 realiza un compendio de diferentes técnicas de Biclustering, estableciendo una comparación entre ellas desde el punto de vista biológico utilizando Microarreglos. Y Mediante el estudio y análisis de los datos contenidos en un Microarreglo es posible detectar genes que se expresen en ciertos tejidos (incluyendo tejidos sanos y enfermos), como reacción frente a diferentes estímulos, reacciones ante distintos fármacos, o encontrar respuesta a otras muchas preguntas biológicas. Pero no se incluye la implementación de los mismos, ni comparación en términos del tiempo de ejecución o la complejidad de los mismos.

El trabajo de Amela Prelic, Stefan Bleuler, Philip Zimmermann, Anja Wille, Peter Buhlmann, Wilhelm Gruissem , Lars Hennig , Lothar Thiele y Eckart Zitzler , titulado "A systematic comparison and evaluation of biclustering methods for gene expression data" 20, Establece una metodología para comparar y validar métodos de biclustering, proponen una forma rápida de divide y vencerás de bajo consumo en tiempo llamado(Bimax). En segundo lugar, evalúan el desempeño de cinco sobresalientes algoritmos biclustering junto con el modelo de referencia y un método de agrupamiento jerárquico.

El trabajo de Amos Tanay, Roded Sharan, Ron Shamir llamado " Biclustering Algorithms: A Survey "21 describe el funcionamiento de seis algoritmos de biclustering y presenta una clasificación por su esquema de puntuación y por la forma de detectar biclusters.

19 Beatriz Pontes Balanza, Técnicas de Evaluación en Algoritmos de Biclustering sobre Datos de Expresión Genómica Op. Cit pag 17- 20 20 Amela Prelic, Stefan Bleuler, Philip Zimmermann, Anja Wille, Peter Buhlmann, Wilhelm Gruissem , Lars Hennig , Lothar Thiele y Eckart Zitzler, A systematic comparison and evaluation of biclustering methods for gene expression data, publicado 24 de febrero de 2004[Consultado 5 Mayo 2010]. 21 Amos Tanay, Roded Sharan, Ron Shamir, Biclustering Algorithms: A Survey, publicado en mayo de 2004 [Consultado 5 Mayo 2010]

14

5.0 MARCO TEORICO

5.1 Microarreglos "Los microarreglos (microarrays) de ADN, también conocidos como biochips, gene chips, DNA chips o gene array, son soportes sólidos en los que se encuentran inmovilizados miles o cientos de miles de genes en forma ordenada. Los soportes sólidos pueden ser láminas de vidrio para microscopio, láminas de silicona o membranas de nylon"1. "Para la creación de un Microarreglo en primer lugar se colocan trozos de ADN conocidos cuyos niveles de expresión pueden ser cuantificados en una micromatriz del biochip. Después se realizan experimentos bajo una serie de condiciones sobre células de distintos tejidos, extrayendo el ARN mensajero (Acido Ribonucleico, que contiene información genética procedente del ADN) generado por los genes de dichas células.

Estas moléculas de ARNm se marcan con fluidos fluorescentes o radiactividad y son transformadas a un tipo especial de ADN: ADNc, colocándose posteriormente en las micro matrices para comenzar el proceso de hibridación. La hibridación del ADN es el proceso más común para detectar un gen particular o un segmento de un ácido nucleico.

El objetivo es crear cadenas dobles de ADN a partir de cadenas simples a sondear ( las que fueron colocados inicialmente en las matrices) y otras cadenas simples marcadas ( las obtenidas a partir de los experimentos y que son llamadas sondas). Después del proceso de hibridación se eliminan todas las cadenas que no se han podido unir mediante lavados y se procede al revelado mediante un escáner óptico o con microscopío láser confocal. El resultado final es una matriz en la que cada una de las celdas está marcada con un determinado color, El color simboliza el grado de expresión genética de dicho gen frente a una determinada condición experimental"2

1 Peña paz Lyda , Estudio Comparativo De Algoritmos Para Análisis De Datos Provenientes De Microarrays

De Adn. [consultado 5 de Mayo de 2010] .

2 Rodríguez Baena Domingo, Análisis de datos de Expresión Genética Mediante técnicas de Biclustering [en

línea]. Madrid: ISIS, 2007. [consultado 20 de Abril de 2010] .

15

5.2 Técnicas de Biclustering Beatriz Pontes Balanza3 afirma que " las principales características comunes de las técnicas de Clustering se resumen en la búsqueda de conjuntos disjuntos de genes, de tal manera que aquellos genes que se encuentren en un mismo clúster presenten un comportamiento similar frente a todas las condiciones del Microarreglo además, cada uno de los genes debe pertenecer a un único clúster (y no a ninguno) al final del proceso. Las técnicas de Biclustering se presentan como una alternativa más flexible, ya que permiten que las agrupaciones se formen no solo en base a una dimensión, sino que sea posible formar biclusters que contengan genes que presenten un comportamiento similar frente a un subconjunto de condiciones del Microarreglo. Esta característica es muy importante, ya que aumenta la capacidad de extracción de información a partir de un mismo Microarreglo, pudiendo ignorar determinadas condiciones frente a las cuales un grupo de genes no se co-expresen. De la misma forma, también es posible hacer biclustering en el sentido inverso, esto es, seleccionando características en función de un subconjunto concreto de genes, aunque este punto de vista ha sido menos estudiado ya que resulta menos interesante desde el punto de vista biológico".

5.3 Tipos de Biclusters Un criterio muy interesante para evaluar los distintos tipos de algoritmos de Biclustering existente tiene que ver con el tipo de bicluster que dichos algoritmos son capaces de encontrar. Las principales clases de biclusters son las siguientes:

� Biclusters formados por valores constantes. � Biclusters con valores constantes en filas o columnas. � Biclusters con valores coherentes. � Biclusters con evolución coherente de sus valores.

3 Beatriz Pontes Balanza, Técnicas de Evaluación en Algoritmos de Biclustering sobre Datos de Expresión

Genómica [en línea]. Madrid: ISIS, 2007. [consultado 15 de octubre de 2008] . Disponible en internet: http://www.lsi.us.es/docs/doctorado/memorias/Pontes,%20Beatriz.pdf

16

Figura 1: Distintos tipos de biclusters. 3 Los algoritmos de Biclustering más simples identifican biclusters formados por valores constantes. En matrices de datos de expresión genética, estos biclusters representan grupos de genes con valores de expresión idénticos bajo un subconjunto de condiciones experimentales(véase figura 1). Un bicluster perfecto es una submatriz (I; J) en la que todos sus valores son iguales para todo y todo j : aij = µ. Aunque este bicluster ideal puede ser encontrado en algunas matrices de datos, normalmente está enmascarado por el ruido. Esto significa que los valores aij que podemos encontrar en los llamados biclusters constantes se presentan generalmente con esta forma: nij + µ, donde nij es el ruido asociado al valor real µ de aij. Cuando el objetivo es encontrar biclusters constantes, es natural el considerar formas de reordenar filas y columnas de la matriz de datos para agrupar aquellas que sean similares. También es común el utilizar, como función de calidad, la varianza o alguna medida relacionada con ella.

5.4 Algoritmos de Biclustering Los Algoritmos de biclustering pretenden encontrar en un conjunto de datos valores que tengan relación entre ellos, utilizando dos parámetros de agrupamiento (filas y columnas).

3 Beatriz Pontes Balanza, Análisis de datos de Expresión Genética Mediante técnicas de Biclustering [en línea]. Madrid: ISIS, 2007. [consultado 15 de octubre de 2008] . Disponible en internet:

www.lsi.us.es/docs/doctorado/memorias/Memoria-v2.pdf

17

Hay algunos métodos que se dedican a detectar un sólo bicluster en cada ejecución, otros métodos tienen como objetivo descubrir un determinado número de biclusters, siendo el número de elementos de dicho conjunto desconocido a priori o establecido de forma fija para una determinada ejecución. Existen métodos basados en aplicar de forma conjunta, técnicas de Clustering sobre filas y columnas, los cuales utilizan un algoritmo de Clustering jerárquico que genera clúster estables de filas y columnas en cada iteración y, consecuentemente, produce un conjunto de biclusters de forma simultánea. Generalmente se han realizado más trabajos en la construcción de algoritmos de clustering a diferencia de los de biclustering , que son más recientes, por lo que en muchos casos la base de estos algoritmos es un algoritmo de clustering.

5.5 Clasificación de los algoritmos de Biclustering . "Debido a la gran variedad de técnicas propuestas, es necesario hacer una clasificación para poder describir los algoritmos de Biclustering que han tenido mayor repercusión durante los últimos años. Esta clasificación está basada en el enfoque utilizado para encontrar submatrices en una matriz de datos:

� Divide y vencerás.

� Combinación de Clustering sobre filas y columnas.

� Búsqueda voraz iterativa.

� Búsqueda exhaustiva.

� Identificación de parámetros de distribución

� Búsqueda Estocástica." 4

4 Ibid Pagina 50- 80

18

Tabla #1 Clasificación de los Algoritmos de Biclust erin 4

5

En la Tabla N° 1 se encuentran clasificados los algoritmos de biclustering más representativos. En la primera columna se nombran los algoritmos, en la segunda se clasifican por su tipo (Evolución coherente, Columnas constantes, Valores coherentes, Valores constantes ), en la tercera columna se clasifica por estructura como encuentra los bicluster es decir si es (Bicluster único, Bicluster exclusivamente en filas, Bicluster exclusivamente en columnas, estructura completa, bicluster no únicos sin solapamientos, etc.), en la cuarta columna se clasifican por el enfoque, es decir la forma como los algoritmos descubre los biclustering en el microarreglo (simultáneamente o un conjunto a la vez) y en la quinta columna se clasifican por el enfoque el cual determina la manera de encontrar los bicluster(Búsqueda exhaustiva, Búsqueda estocástica, Divide y vencerás, Búsqueda estocástica, Búsqueda voraz iterativa).

5 Sara C. Madeira and Arlindo L. Oliveira, Biclustering Algorithms for Biological Data Analysis: A Survey*, pag 26

Algoritmo Tipo Estructura Descubrimiento Enfoque

Samba Evolución Coherente Biclusters Aleatorios Simultaneo Búsqueda exhaustiva

Coupled Two -way Clustering

Columnas Constantes Biclusters Aleatorios

Un conjunto a la vez.

Combinación de Clustering sobre filas y columnas.(Clust- comb)

Plaid Models Valores Coherentes Biclusters Aleatorios Simultaneo Identificación de parámetros de distribución(Dist-Ident)

Spectral Biclustering Valores Coherentes Bicluster de extructura

complete Simultaneo Búsqueda voraz iterativa(Greedy)

Interrelated Two-Way Clustering Valores Coherentes

Bicluster con filas exclusivas o bicluster con columnas

exclusivas


Combinación de Clustering sobre filas y columnas.(Clust- comb)

P-Cluster Valores Coherentes Bicluster no solapado y no exclusivo

Simultaneo Búsqueda exhaustiva

FLexible Overlapped biclustering Valores Coherentes Biclusters Aleatorios Simultaneo Búsqueda voraz iterativa(Greedy)

Block Clustering Valores Constante Bicluster no solapados con estructura de árbol

Un conjunto a la vez. Divide y vencerás.

OPSM Evolución Coherente Un solo Bicluster o Biclusters

Aleatorios Un conjunto a la

vez. Búsqueda voraz iterativa(Greedy)

OP-Clusters Evolución Coherente Biclusters Aleatorios Simultaneo Búsqueda exhaustiva

Gibbs Valores Constante Bicluster con filas exclusivas

o bicluster con columnas exclusivas


Identificación de parámetros de distribución(Dist-Ident)

OPSMs Evolución Coherente Un solo Bicluster o Biclusters Aleatorios


Búsqueda voraz iterativa(Greedy)

PRMs Valores Constante Biclusters Aleatorios Simultaneo Identificación de parámetros de

distribución(Dist-Ident) Cheng y Church Valores Constante Un solo Bicluster Búsqueda voraz iterativa (Greddy)

Simulated Annealing Búsqueda Estocástica

SEBI Búsqueda Estocástica

Direct Clustering Valores Constante Bicluster no solapados con estructura de árbol


Divide y vencerás.

19

Figura 2: Estructura De Los Tipos De Bicluster4

6

En la Figura #2 se representan las clases de estructuras de biclustering en forma gráfica. Existen, matriz con un solo biclustering, hasta matrices con varios biclustering solapados entre ellos.

5.5.1 Divide y Vencerás. Consiste en dividir un problema complejo en una serie de sub-problemas más sencillos. El proceso de división finaliza cuando ya no es posible aplicar ninguna división más. Una vez solucionados estos sub-problemas, las distintas soluciones son combinadas para obtener la solución al problema original. El algoritmo más relevante en esta clasificación es el siguiente:

DIRECT CLUSTERING 5

7 Este Algoritmo utiliza una estrategia top-down, en la cual, se parte de un sólo bicluster en el que se encuentran todos los datos, es decir, la matriz original A. Utilizando un proceso iterativo, se selecciona la fila o columna que produzca la mayor reducción de la varianza en el bloque (bicluster) de partida mediante la división de dicho bloque en dos trozos. 6 Ibid, pagina 16 7 J.A.Hartigan, Direct clustering of a data matrix. Journal of the American Statistical Association (JASA), 67(337):123 –129,1972.

20

Para encontrar la mejor división posible, las filas y columnas de la matriz son ordenadas en función de la media de las filas y la media de las columnas respectivamente. Una vez seleccionado el punto de división, se generan dos bloques a partir del original y comienza una nueva iteración, partiendo de cada uno de los bloques generados anteriormente.

5.5.2 Combinación de Clustering sobre Filas y Colum nas. Debido a que el Biclustering es una técnica derivada del Clustering. Lo que se hace aquí es generar una agrupación bidimensional de los datos de una matriz, es decir aplicar las técnicas originales de Clustering a cada una de las dimensiones, filas y columnas, para después combinar los resultados. Esta es una de las primeras formas utilizadas para obtener biclusters y conceptualmente la más sencilla u obvia.

COUPLED TWO-WAY CLUSTERING 8 Esta técnica, introducida por Tang et. al, también combina los resultados de aplicar técnicas de Clustering a las dos dimensiones de la matriz de entrada, el proceso comienza con un reprocesamiento de los datos. Los elementos de la matriz de entrada son normalizados. El objetivo principal que persigue este algoritmo es el de identificar parejas de pequeños subconjuntos de atributos (Fi) y objetos (Oj), pudiendo representar (Fi) y (Oj) tanto a filas como a columnas. Se parte de la suposición de que cuando sólo los atributos en Fi son utilizados para agruparse con los objetos de Oj, se crean particiones de datos estables y significativas. Al analizar este método, podemos observar que la existencia de múltiples combinaciones de posibles agrupaciones puede resultar un inconveniente. Para solventar esta dificultad, los autores utilizan un método heurístico para disminuir el espacio de búsqueda, considerando que sólo los subgrupos de filas o columnas identificados como clusters estables en iteraciones anteriores son candidatos para un cluster combinado de filas y columnas. Se consideran estables a aquellos clusters que son significativos, estadísticamente hablando, según un determinado criterio. 8 G.Getz, E.Levine, and E.Domany Coupled two-way clustering analysis of gene microarray data. In Proceedings of the Natural Academy of Sciences USA, paginas12079–12084, 2000.

21

INTERRELATED TWO-WAY CLUSTERING 9 Esta técnica, introducida por Tang et. al , también combina los resultados de aplicar técnicas de Clustering a las dos dimensiones de la matriz de entrada.

El proceso comienza con un preprocesamiento de los datos. Los elementos de la matriz de entrada son normalizados:

donde bij representa al valor normalizado para el valor del gen i bajo la condición j y µi es la media de todos los valores del gen i. Además de normalizar los datos, los autores pensaban que, entre tantos cientos de genes, no todos debían ser significativos a la hora de distinguir una actividad celular. Por lo cual, eliminan aquellos genes que reaccionan con escasa intensidad ante las condiciones experimentales. Para detectar estos genes se calcula el coseno del vector de cada gen i con un vector predefinido que representa un patrón de estabilidad. Después de la normalización, cada gen tiene un vector formado por los siguientes valores: gi = (bi1, . . . , bim). El vector E se define como: E = (e1, . . . , em), en el que todos los ei son iguales. Se define el coseno entre los dos vectores como:

Si los patrones de los dos vectores son muy similares, el coseno será cercano a 1 (igual a 1 si los vectores son paralelos). Si al contrario, los dos vectores son muy distintos, el coseno tendrá un valor próximo a cero (igual a cero si son vectores perpendiculares). A partir de un umbral, se eliminan aquellos genes cuyo valor del coseno con respecto al patrón E superen dicho umbral.

Una vez pre-procesados los datos, comienza una técnica combinada de Clustering sobre genes y columnas formada por una serie de iteraciones con una serie de pasos. El primer paso consiste en aplicar Clustering sobre la dimensión de las filas de la matriz de entrada.

9 Ibid, paginas 12086–12092.

22

El objetivo es dividir los n genes de entrada en k grupos exclusivos, denominados Gi, con 1 ≤ i ≤ k. Para este paso podemos utilizar cualquier tipo de algoritmo de Clustering que reciba como parámetro de entrada el número de clusters final (K-means o SOM ).

El segundo paso consiste en aplicar Clustering sobre la dimensión de las columnas, pero utilizando los cluster de genes generados en la fase anterior. Para facilitar la explicación supondremos que k = 2. A partir de cada grupo de genes, G1y G2, se generan dos clústeres de condiciones, Sia y Sib, con 1 ≤ i ≤ 2. El criterio por el que se crean los grupos de condiciones se basa en la búsqueda de las condiciones más populares. Para nuestro caso particular, se habrán generado cuatro grupos de condiciones. Una vez contamos con grupos de genes y de condiciones, se realiza la combinación de estos clusters para obtener una primera versión de los biclusters finales. Se forman conjuntos combinados de condiciones de tal forma que:

� C1, es la combinación de S1a y S2a. � C2, es la combinación de S1a y S2b. � C3, es la combinación de S1b y S2a. � C4, es la combinación de S1b y S2b .

El cuarto paso consiste en crear parejas heterogéneas de condiciones, (Cs, Ct) con s, t=1, . . . , 4. Los grupos heterogéneos son aquellos que no comparten los grupos de genes utilizados para realizar el agrupamiento. Es decir, (C1, C4) son grupos heterogéneos ya que para formar los grupos S1x se utilizaron distintos genes, y lo mismo para los grupos S2x. Por lo cual, (C2, C3) también forman un grupo de estas características. El resultado de este paso es la obtención de biclusters disjuntos, definidos por las condiciones existentes en (Cs, Ct) y los genes utilizados en el agrupamiento.

5.5.3 Búsqueda Voraz Iterativa. A estas clases de algoritmos (Greddy Algorithms) corresponden aquellos métodos que intentan obtener biclusters de la manera más rápida y simple posible. Para ello, aplican una meta-heurística basada en la maximización de criterios locales. Es decir, intentan simplificar la búsqueda tomando decisiones locales con la esperanza de encontrar la solución óptima global. Por ello se pierde calidad de resultados pero se gana sencillez y velocidad a la hora de resolver los problemas.

23

La mayoría de las técnicas voraces aplicadas a biclusters se basan en añadir y eliminar filas o columnas de una matriz para conseguir obtener la submatriz que mejor se adapte a unos criterios dados.

CHENG Y CHURCH 6

10 Esta técnica se basa en la optimización de un resultado que se obtiene inicialmente, dicho resultado parte de un subgrupo de genes y condiciones, los cuales evolucionan hasta llegar a los valores más aproximados. Esta característica está representada por un valor estadístico: Mean Squared Residue (MSR), el cual lo conoceremos a partir de la siguiente ecuación. Sea (I,J) un bicluster. El residuo R de un elemento eij del bicluster (I,J) es:

R(eij) = eij - eiJ - eIj + eIJ

Donde eIJ es la media de la fila i-ésima del bicluster, eIj la media de la columna j-ésima, y eIJ es la media de todos los elementos del bicluster. El MSR de un bicluster (I; J) se define como:

Este valor es considerado como un índice de calidad. El MSR es la varianza del conjunto de todos los valores del bicluster, más la varianza de fila y la varianza de columna. Es por ello que dicho valor mide el nivel de coherencia de los valores a lo largo de las filas y las columnas. A mayor valor del MSR, con menos coherencia evolucionan los valores de los genes a lo largo de las condiciones y, por consiguiente, menos calidad tendrá el bicluster. Partiendo de esta definición, los autores definieron al δ bicluster como aquel subconjunto de filas y columnas (I; J) cuyo valor de residuo no supera un determinado valor umbral: H(I; J) ≤ δ. Por consiguiente, el objetivo principal del primer algoritmo de Biclustering, propiamente dicho, es el de obtener una submatriz del mayor tamaño posible y con un residuo no superior a un determinado umbral. Haciendo uso de la teoría de grafos, Cheng y Church explican, que la búsqueda de un bicluster máximo se puede asemejar a la búsqueda de un subgrafo máximo en un grafo bipartito. Y dicho problema tiene una complejidad NP-completa. Este algoritmo toma como entrada a la matriz original de datos y un valor umbral de residuo. Su objetivo es encontrar un sólo bicluster en cada ejecución y para ello

10 Yizong Cheng and George M. Church . Biclustering of expression data . In Proceeding sof the the International Conference on Intelligent Systems for Molecular Biology (ISMB’00),pages93–103,2000.

24

lleva a cabo dos fases principales. En la primera fase, el algoritmo elimina filas y columnas de la matriz original. En cada paso, en el que la submatriz en construcción consta de I filas y J columnas, el algoritmo estudia el conjunto de posibles movimientos. Para cada fila se calcula el valor de su residuo

y lo mismo para cada columna el

siguiente paso es seleccionar la fila o la columna. El proceso finaliza cuando el residuo de la submatriz sea H(I,J)<α. Para implementar este borrado masivo, los autores se basan en la teoría de que aquellas filas o columnas con un alto valor de residuo pueden ser eliminadas con la garantía de una mejora en el residuo total de la submatriz resultante. En la segunda fase del algoritmo, filas y columnas son añadidas a la submatriz resultante de la anterior fase. Para ello se sigue un esquema similar al anterior, pero esta vez buscando las filas y columnas de la matriz original con menores valores de residuo. El proceso finaliza cuando un posible aumento del tamaño de la submatriz hace que el valor de su residuo MSR cruce el umbral fijado en los parámetros de entrada. Así pues, el resultado final es la submatriz máxima que cumple la condición de no sobrepasar el valor umbral del MSR. Algoritmo de CHENG Y CHURCH Cheng – Church (U,V,E,µ) U: Condiciones . V:Genes E: Gene Expresión Matriz µ: Maximal mean Square residue score (MSR)

Define

Define

Define Define RSIJ(ij) = eij – eiJ-¡ eIj + eIJ

Define

Inicializa un bicluster (I,J) con I=U, J=V.

25

Fase de eliminación Mientras (H(I,J)>µ)haga

Compute para

Compute para

Si

Si No

Fase de Inserción asigne

Mientras haga

asigne

Compute para

Compute para

Si

Si No

Reporte I,J

FLEXIBLE OVERLAPPED BICLUSTERING 11 Este algoritmo es pensado por Yang et y busca superar los inconvenientes que suceden con el algoritmo de cheng y church en base al ruido, otros autores lo llaman: interferencia aleatoria. Para superar estos problemas, se generaliza la definición de bicluster. Se define un bicluster como un subconjunto de filas y columnas en las que los valores no nulos exhiben un comportamiento coherente. Es decir, para evitar sustituir estos huecos por ruido, el FLOC sólo tiene en cuenta los elementos no nulos de la matriz de datos. No obstante, esta consideración tiene una desventaja: es posible que el número de elementos no nulos de una submatriz no sea suficiente como para determinar la similitud de sus valores. Por este motivo se

11 Jiong Yang, Wei Wang, Haixun Wang, and Philip Yu, Enhanced biclustering on expression data In Proceeding sof the 3rd IEEE Conference on Bioinformatics and Bioengineering, pages321–327, 2003.

26

define un umbral de ocupación . Así pues, se define un bicluster con índice de ocupación α a aquella submatriz (I; J) en la que, para cada fila se cumple

qué y para cada columna se cumple que:

Siendo el número de elementos no nulos de la fila i y la columna j,

respectivamente. FLOC tiene dos fases. En la primera fase se crean k biclusters iniciales. Un parámetro de entrada p se utiliza para controlar el tamaño de estas submatrices. Para cada bicluster inicial, y de forma aleatoria, se decide si una fila o columna tiene que pasar a formar parte de esta submatriz. Cada fila o columna se añade a un bicluster con una probabilidad p. Así, con una matriz de entrada A formada por N filas y M columnas, se espera que cada bicluster cuente con N x p filas y M x p columnas. El proceso termina cuando se han generado k biclusters con un índice de ocupación α que satisfaga un cierto umbral µ. Este umbral es determinado mediante la siguiente ecuación:

siendo el volumen de elementos de la matriz A. De esta forma se asegura que los biclusters resultantes tengan al menos un porcentaje similar de valores nulos que la matriz de entrada. La segunda fase es un proceso iterativo cuyo objetivo es mejorar la calidad de los biclusters iníciales. En cada iteración se examina cada fila y columna, con respecto a un bicluster, para determinar qué acción hay que realizar, sobre dicha fila o columna, para obtener una mejora global del valor de su residuo medio. Es decir, si la fila o columna no pertenece al bicluster, la acción sería la adición. En cambio, si la fila o columna pertenecen ya al bicluster, la posible acción a tomar sería la eliminación.

OPSM12 Este algoritmo toma un camino totalmente diferente al de Cheng y Church, ya que basa su búsqueda en un tipo muy especial de submatriz, las OPSMs (Order-Preserving Submatrices). En este trabajo, se define un bicluster como una submatriz cuyos valores se encuentren ordenados, de manera que los genes contenidos en ella presenten un mismo orden frente a las condiciones del bicluster.

12 Amir Ben-Dor, Benny Chor, Richard Karp, and Zohar Yakhini Discovering local structure ingene expression data: Theorder preserving submatrix problem In Proceeding softhe th e International Conference on Computacional Biology (RECOMB’02),pages49–57,2002.

27

De esta forma, los autores intentan independizar el análisis de la matriz de entrada de los valores concretos de sus elementos, y centrarse sólo en la coherencia de su comportamiento. Para ello, se define también un modelo completo como un par

, donde J representa un subconjunto de s columnas, y π establece el orden linear existente entre ellas π = (j1; j2; :::; ja). Las características de la OPSM son muy estrictas y el tipo de bicluster que se encuentra muy específico. Los autores indican que uno de sus siguientes pasos en la investigación es pedir asesoramiento biológico para conocer si esas submatrices tienen alguna trascendencia desde el punto de vista de la genética. No obstante, los autores proponen una relajación de las propiedades de las OPSMs mediante la inclusión de una corrupción en la probabilidad: Pe, que no sea necesario que el orden se mantenga para todas las s columnas, etc.

5.5.4 Búsqueda Exhaustiva. Algunos autores prefieren basar su búsqueda de biclusters en una enumeración exhaustiva de todas las posibles sub-matrices existentes en la matriz de datos. Por supuesto, se encuentran mejores resultados que en los dos tipos anteriores ya que se revisan todos los posibles biclusters. A pesar de todo, existe una gran desventaja: el gran coste computacional que supone este tipo de métodos.

SAMBA 13 El algoritmo SAMBA se basa en identificar un determinado número de biclusters en una base de datos de expresión genética. Además usa el modelo probabilístico de datos y técnicas de teorías de gráficos para identificar los subconjuntos de genes que conjuntamente responden a través de un subconjunto de condiciones. En el marco de SAMBA, los datos de expresión son modelados como un grafo no dirigido (Grafo bipartito) cuyas dos partes corresponden a condiciones y genes, respectivamente, con bordes para cambios de expresión significativos. Los vértices en el gráfico son pesos asignados de acuerdo al modelo probabilístico, de modo que los subgrafos pesados correspondan a biclusters con alta probabilidad.

SAMBA realiza una fase de normalizado de los datos originales, de manera que cada gen pueda ser definido como activado (efecto positivo) o inhibido (efecto negativo). Después, se hace la búsqueda de los k subgrafos con mayor peso, haciendo uso de una tabla pre-calculada donde se almacenan los pesos de las aristas individuales, y se ignoran aquellos subgrafos que superen el límite

13 A.Tanay,R.Sharan, and R.Shamir,Discovering statistically significant biclusters Ingene expression data. Bioinformatics,18:136–144,2002.

28

establecido de genes. Por último, se ejecuta una fase de adición o borrado de vértices, de forma que se permita la eliminación de datos no relevantes, así como el poder fusionar biclusters similares (dos biclusters se consideran similares si sus conjuntos de vértices difieren ligeramente). Algoritmo de SAMBA U:condiciones. V: genes E:garp edges. W edg/non-edge weights, N1,N2: Condición establecida del limite del tamaño , K:maximo biclusters por gen/condition.

Do{

} while Mejora Almacene B

P- CLUSTER14 Este algoritmo surge con el fin de mejorar dificultades planteadas por otros algoritmos de biclustering. Entre esas dificultades tenemos las siguientes:

� En algunas técnicas se define la similitud entre distintos objetos midiendo la distancia entre ellos: p.e, distancia Euclídea, distancia Manhattan, etc. Sin embargo, existen fenómenos de escalado y desplazamiento que no son detectados al utilizar este tipo de medidas.

14 Haixun Wang, WeiWang, Jiong Yang, and PhilipS Yu, Clustering by pattern similarity in large data sets , In Proceeding softhe 2002 ACMSIGMOD International Conference on Management of Data, pagina 394–405, 2002.

29

� De la descripción que hacen Cheng y Church de su α -bicluster se deduce que: cualquier submatriz de un α -bicluster no tiene porque ser otro α -bicluster. Ello implica una mayor complejidad a la hora de diseñar un algoritmo eficiente de búsqueda.

� Siguiendo con el mismo trabajo, el MSR puede determinar que un bicluster

tenga una buena calidad incluso conteniendo algún outlier. Si se quiere eliminar ese outlier se tiene que disminuir el valor del residuo medio umbral α con el peligro de dejar a muchos genes fuera del bicluster.

� Finalmente, la utilización de valores aleatorios para sustituir los biclusters

obtenidos desvirtúa cualquier futuro resultado. Por este motivo, el objetivo básico de este algoritmo. Es el de encontrar todas las submatrices que sean α -pClusters. Por supuesto, está búsqueda exhaustiva ha de ser limitada para poder reducir así la gran complejidad de este algoritmo. Para ello se establecen 3 parámetros de usuario: el valor del umbral α, el mínimo número de genes permitido en un α -pClusters, nr, y el mínimo número de condiciones permitido en un α -pClusters, nc. Los valores de estos tres parámetros de usuario determinarán el resultado final. Pero como todo, esta técnica también tiene bastantes inconvenientes. En primer lugar, el número de estos fenómenos que será detectado está directamente determinado por el parámetro de entrada α que nos indicará la sensibilidad del rango de desplazamiento o de variación en el escalado que el algoritmo es capaz de detectar. Además, no se exponen criterios para determinar para cada matriz de entrada, cual podría ser un valor adecuado para este parámetro. Los parámetros nr y nc nos van a servir para restringir la generación de resultados, obviando también posible buenos biclusters. Para finalizar, En este algoritmo se habla de una búsqueda de unos MDS (Maximum DimensionSets) para cada par de filas y cada par de columnas, para lo cual es necesario seguir tres fases. En la primera fase se busca todos los posibles MDS para cada par de filas y columnas utilizando un método eficiente basado en la ordenación. En esta primera fase del algoritmo se aplicarán las restricciones de búsqueda, rechazándose aquellos MDS referentes a un par de filas cuyo número de columnas no supere el parámetro nc y lo mismo para los MDS referentes a los pares de columnas y el parámetro nr. La segunda fase del algoritmo es un proceso de depuración en el que se eliminarán aquellos MDS que no sean válidos. En la tercera y última fase los MDS resultantes del proceso de depuración anterior se almacenan en una estructura de árbol asumiendo un determinado orden existente entre las columnas de la matriz. Cada nodo está asociado con un conjunto de columnas T, dado por el camino desde la raíz hasta el nodo, y un

30

conjunto de filas O. El árbol se recorre en post-orden y se van formando biclusters, de acuerdo al siguiente criterio: Por cada nodo, conteniendo un conjunto de filas O y un conjunto de columnas T, se añaden las filas de O a aquellos nodos restantes del árbol cuyo conjunto de columnas cumpla que: T’ є T y ׀T ’׀ = ׀T 1- ׀. La estructura de árbol es un buen recurso para obtener todas las posibles submatrices. Sin embargo, dependiendo del número de columnas de la matriz, tanto el tiempo dedicado al recorrido como el número de biclusters generados puede llegar a ser exponencial.

5.5.5. Identificación De Parámetros De Distribución Existen técnicas que se ayudan de la estadística en determinadas fases de sus procesos de búsqueda. Sin embargo, hay algoritmos de Biclustering en los que la estadística es su arma principal. En este tipo de investigaciones se intenta aproximar el concepto de bicluster a partir de un modelo estadístico. Por consiguiente, el objetivo más importante será el encontrar los parámetros de distribución necesarios para generar las submatrices que se ajusten a dicho modelo estadístico. En la mayoría de los casos, será un proceso iterativo, en el que se intenta minimizar un determinado criterio, el encargado de encontrar el valor de esos parámetros. Son técnicas pues con un gran contenido matemático y se distinguen por las distintas caracterizaciones que llevan a cabo de los biclusters. El álgebra lineal y la teoría matricial son de las herramientas matemáticas más utilizadas a este respecto.

PLAID MODEL 15 Plaid Model es un acercamiento de modelado estadístico desarrollado por Lazzeroni y Owen para el análisis de datos de expresión genética. El algoritmo plaid model tiene como objetivo obtener un modelo de capas donde se describan las interacciones entre los distintos biclusters, de manera que se minimice una función objetivo que evalúe de forma global el conjunto de biclusters obtenidos a partir de la matriz original. Para ello, se hace uso de un proceso iterativo en el que se obtiene un bicluster cada vez hasta completar el modelo, de manera que en cada iteración se busca el bicluster que minimice la suma de los errores según la

15 Laura Lazzeroni and Art Owen, Plaid models forgene expression data, Technical report, Stanford University, 2000.

31

función objetivo global utilizada, utilizando para ello multiplicadores de Lagrange y un método de búsqueda voraz. Plaid model se basa en considerar a la matriz de genes y condiciones como una superposición de capas, siendo cada una de ellas un subconjunto de filas y columnas con unos valores de expresión concretos. Estos valores son representados en la matriz de entrada a partir de una determinada coloración en función del nivel de expresión, formándose así una matriz coloreada. (El orden de las filas y columnas de la matriz puede ser arbitrario.) Un orden ideal de la matriz produciría una imagen formada por un número K de bloques rectangulares en la diagonal, estando el resto de la matriz formada por una serie de bloques con un color de fondo. Cada uno de estos bloques de la diagonal tendría un color prácticamente uniforme y corresponderían a biclusters exhaustivos y mutuamente excluyentes, es decir, cada gen en un bloque k sólo se expresa en las condiciones de dicho bloque, lo anterior se puede representar por la siguiente ecuación:

Donde µ0 es un color de fondo general de la matriz, y θijk = µk + αik + βjk

representa al color de un determinado bloque k, con µk siendo el color de fondo del bloque k y α y β colores de cada fila y columna que se suman al color inicial. Así, la matriz de entrada se considera como una suma de capas, donde cada capa se considera como un bicluster. Los valores α ik y βjk determinarán el comportamiento de los genes y condiciones en dichas submatrices. Aquellos genes de la capa k en los que ׀µk + αik׀ tenga un valor alto se verán más afectados por las condiciones experimentales de dicha capa que otros genes. Así podemos concluir que el objetivo es encontrar los parámetros adecuados para que la matriz de entrada se ajuste lo mejor posible al modelo planteado. Es decir, en minimizar la siguiente ecuación: Donde Donde µo=θ ij0. Si αik o βjk son usadas, entonces las restricciones

se añaden para reducir el número de parámetros.

32

Note que el numero de parámetros es en la mayoría K+1 + Kn + Km para las variables θ, y Kn + Km para k y p variables. Esto es considerablemente más pequeño que las variables nm en los datos originales, si k<< max(n;m). Algoritmo Plaid Models U:condiciones. V: genes E: Matriz de Expresión genética. S: Cantidad de Ciclos maximos por iteracion. Set K = 0 Adicion de una nueva capa: K=K+1 Compute inicializar valores

While (s<S)do: Computer

Computer

Computer

If

If

Si la importancia de la capa K no es al azar entonces grabe y repita el procedimiento Else exit Reporte capa 1,…, K-1.

BICLUSTERING ESPECTRALES 16 En este algoritmo los datos de una matriz de expresión genética se reordenan hasta llegar a formar una estructura parecida a la de un tablero de ajedrez, es decir, un conjunto de bloques de tamaño similar que cubren de forma exhaustiva la matriz de entrada, siendo además excluyentes entre sí. Esto se debe a estudios realizados sobre diferentes tipos de tumores (cáncer). Lo que se hace por medio de esta técnica es agrupar en las bases de datos los valores de expresión en función del tipo de cáncer estudiado, por este motivo, es factible suponer una estructura formada por bloques o submatrices en las que un

16 Y. Klugar, R. Basri, J. Chang, and M. Gerstein Spectral biclustering of microarray Data coclustering genes and conditions, Genome Research,13:703–716, 2003.

33

grupo de genes presenten un comportamiento similar bajo un tipo concreto de tumor, el cual no tiene porque darse en otro tipo de tumor distinto. Cada tipo de tumor puede ser representado en estas matrices como un conjunto de condiciones experimentales.

5.5.6. Búsqueda Estocástica Esta técnica se basa en la utilización de algoritmos evolutivos los cuales son guiados una búsqueda estocástica haciendo evolucionar a un conjunto de estructuras y seleccionando de modo iterativo las más adecuadas. Se define proceso estocástico como aquel proceso aleatorio que evoluciona con el tiempo. De esta manera, e imitando los procesos de selección natural de los seres vivos, estas técnicas utilizan procesos sencillos, fáciles de implementar e independientes de las distintas representaciones de datos, para encontrar un objetivo concreto, que en nuestro caso será el de encontrar biclusters válidos en una matriz de entrada. La búsqueda estocástica además es una manera de superar los problemas de localidad de ciertos algoritmos voraces, como el utilizado por Cheng y Church.

SEBI17 El algoritmo fue evolutivo de búsqueda de bicluster Sebi, fue desarrollado en al año 2006 por Divina y Aguilar, con el fin de obtener distintos biclusters a partir de una matriz de datos geonómicos, y basado en el uso del residuo cuadrático medio (MSR). Los autores defienden la utilización de un algoritmo evolutivo debido a su potencial para trabajar con problemas de gran complejidad, escapando de mínimos locales, y siendo capaz de encontrar soluciones en las que intervengan varios factores que interactúen entre ellos. El algoritmo SEBI es un proceso iterativo cuyo número de repeticiones viene dado por una condición de parada. En cada iteración se genera un bicluster máximo cuyo valor de residuo es menor que un umbral introducido como parámetro de entrada. Este bicluster es almacenado en una lista de resultados y el proceso comienza de nuevo. Al trabajar con algoritmos evolutivos se necesita una población formada por biclusters. Inicialmente, la población consiste un biclusters que contienen un solo elemento de la matriz de entrada, además de tener la propiedad de poseer un valor de residuo MSR = 0. En este proceso los individuos de la población evolucionan mediante un proceso de refinamiento hasta llegar a convertirse en las submatrices deseadas. La codificación de cada elemento vendrá dada por cadenas binarias de longitud N + M, donde N y M son el numero de filas (genes) y columnas (condiciones) de la matriz de entrada.

17 J. Aguilar and F. Divina, Evolutionary computation for biclustering of gene expression 20th Annual ACM Symposiumon Applied Computing ,pages959–960, 2005.

34

Al finalizar el proceso evolutivo, si el mejor individuo de la nueva generación es considerado como un bicluster válido, es decir, con un valor de residuo menor que un umbral, unos límites mínimos de tamaño establecidos y con un nivel de solapamiento aceptable, será devuelto como resultado por el algoritmo SEBI. Este proceso se repetirá un número máximo de veces.

SIMULATED ANNEALING 18 El algoritmo Simulated Annealing Algorithm (SAA) pertenece una clase de Algoritmos de búsqueda local (Local Search Algorithms – LSA) comúnmente llamada Algoritmos de Umbral (Threshold Algorithm - TA). El nombre e inspiración viene del proceso de recocido del acero, una técnica que consiste en calentar y luego enfriar controladamente un material para aumentar el tamaño de sus cristales y reducir sus defectos. El calor causa que los átomos se salgan de sus posiciones iníciales (un mínimo local de energía) y se muevan aleatoriamente; el enfriamiento lento les da mayores probabilidades de encontrar configuraciones con menor energía que la inicial. Simulated Annealing toma como referencia el algoritmo de Cheng y Church, ya que busca mejorar sus defectos y establecer comparaciones de rendimiento. Este algoritmo se basa en buscar la solución que más se acerque al objetivo deseado. Esta técnica se basa en un proceso que modela el enfriamiento y la cristalización de materiales como el vidrio y los metales. En el enfriamiento de un sólido cristalino, la probabilidad de aceptar cambios que conduzcan a un estado superior de energía es definida por la siguiente ecuación:

Donde es la diferencia de energía entre el viejo y el nuevo estado, y T es la cantidad de energía disponible.

18 K. Bryan, P. Cunningham, and N. Bolshakova, Biclustering of expression data using simúlated annealing, IEEE Conferenceon Computer Based Medical Systems, 2005.

35

6.0. OBJETIVOS

6.1 Objetivo General

� Realizar un estudio comparativo de algoritmos de biclustering existentes en la actualidad y definir cuáles son los más apropiados a utilizar en un tipo de situación específica.

6.2. Objetivos Específicos

� implementar 3 de los algoritmos de Biclustering existentes. � Realizar una toma de datos, observar y analizar el comportamiento

obtenido. � Establecer cuál es el mejor de los diferentes tipos de algoritmos de

Biclustering, basándonos en su tiempo de ejecución y orden de complejidad.

36

7.0 METODOLOGÍA

Para el desarrollo del proyecto se han definido actividades que permitan la comparación apropiada de los algoritmos, como son:

1. Realizar la revisión sobre los algoritmos existentes (buscando la

información que exista, características de cada algoritmo, etc.)

2. Definición de los parámetros de comparación (ya que se va a realizar una

comparación, es necesario establecer los criterios que se tendrán en

cuenta, tales como tiempo de ejecución, nivel de complejidad, etc.)

3. Simulaciones a gran escala donde se establezca el comportamiento de

cada algoritmo con una cantidad de datos significativa.

4. Realizar conclusiones de acuerdo a las ventajas y desventajas obtenidas

con la realización del paso anterior.

37

8.0 DESARROLLO

8.1 Revisión de Algoritmos Existentes. En el desarrollo de este proyecto el grupo realizó búsquedas en Internet y bibliotecas virtuales, en las cuales se encontró textos sobre Algoritmos de Biclustering en los que se han realzado clasificaciones de acuerdo a su enfoque de búsqueda, cantidad y estructura de biclusters encontrados (véase Marco Teórico). Además se encontró información sobre grupos de investigación y revistas que trabajan con el tema de biclustering como lo es BIOINFORMATICS en la cual el grupo de trabajo aclaró dudas sobre el uso y aplicabilidad de los Clustering y los Biclustering en la actualidad.

Selección de algoritmos: Una vez realizada la clasificación de los algoritmos el grupo de trabajo decide trabajar con tres algoritmos de biclustering de diferente enfoque, con la finalidad conocer mejor cada enfoque y poder generar conclusiones acerca de la eficiencia que cada enfoque puede proveer.

Algoritmo Enfoque

Samba � Búsqueda exhaustiva

OP-Clusters Búsqueda exhaustiva

P-Cluster Búsqueda exhaustiva

Plaid Models Identificación de parámetros de distribución(Dist-Ident)

Gibbs Identificación de parámetros de distribución(Dist-Ident)

PRMs Identificación de parámetros de distribución(Dist-Ident)

Cheng y Church � Búsqueda voraz iterativa (Greddy)

Spectral Biclustering Búsqueda voraz iterativa(Greedy)

OPSM Búsqueda voraz iterativa(Greedy)

Interrelated Two-Way Clustering � Combinación de Clustering sobre filas y columnas.(Clust- comb)

Block Clustering Divide y vencerás.

Direct Clustering Divide y vencerás.

Simulated Annealing Búsqueda Estocástica

SEBI Búsqueda Estocástica

Tabla N° 2 Algoritmos Seleccionados

38

Debido a la calidad y cantidad de información obtenida en la revisión de los algoritmos existentes, el grupo decide trabajar con el algoritmo de Cheng y Church, el algoritmo SAMBA y Interrelated Two-Way Clustering .

8.2 Definición de criterios de comparación

Los criterios de comparación seleccionados para analizar los algoritmos de biclustering presentados en este trabajo son : Tipo de Bicluster, Tipo de Estructura, Cantidad de Biclusters encontrados, Enfoque, Orden de Complejidad y Tiempo de Ejecución. Estos criterios fueron seleccionados debido a que estos permiten obtener diferente clasificación, teniendo en cuenta que se escogieron tres algoritmos de diferente enfoque y diferente tipo de bicluster lo que hace ,la investigación mucho más interesante a la hora de obtener resultados concretos sobre el funcionamiento y aplicaciones de estos. El orden de complejidad y tiempo de ejecución se escogieron como parámetros de comparación ya que gracias a ellos se puede saber cuál de los algoritmos es el más eficiente y el de mejor rendimiento, lo cual es de gran ayuda al momento evaluar en qué casos y para qué cantidad de datos es recomendable utilizar cada algoritmo.

8.3 Análisis de cada Algoritmo de Biclustering

En esta sección se explica la forma como se implementaron los algoritmos de Cheng y Church, SAMBA e información relacionada con el uso de una aplicación existente que implementa Plaid models.

8.3.1 Cheng y Church El algoritmo de Cheng y Church se fundamenta en la optimización de un resultado que se obtiene inicialmente calculando el MSR (Mean Squared Residue).

Para la optimización del (MSR) el algoritmo elimina y adiciona filas y columnas hasta encontrar el bicluster más representativo.

39

9.3.1.1 Diagrama de clases del Algoritmo Cheng y C hurch

Figura 3: UML de Cheng y Church

Para implementar el algoritmo de Cheng y Church se definieron las siguientes clases.

Principal: En esta clase se tiene métodos relacionados con la carga de los datos e impresión de la matriz en la ejecución den la aplicación

Cheng y Church: En esta clase se define el umbral recomendado para la ejecución de la aplicación, se tienen los métodos relacionados con las fases del algoritmo, como lo son CalcularResiduo, faseEliminacion, faseInsercion y es esta quien tiene el control de la ejecución de la aplicación.

Métodos: la clase métodos se define como una clase utilitaria para la ejecución de la clase Cheng y Church, ya que esta tiene como atributos dos pilas en las cuales se guardan las filas y columnas que se extraen de la matriz en la fase de eliminación.

Datos: Esta clase maneja los índices temporales de la matriz en el momento que se realizan las eliminaciones.

Celda: Esta clase contiene los índices originales y el valor, el cual es útil en la fase de inserción de los datos a la matriz.

40

8.3.1.2 Implementación Se decide implementar el algoritmo Cheng y Church con la herramienta JAVA ya que este lenguaje por su enfoque orientado a objetos, facilita la implementación del algoritmo; adicionalmente, los desarrolladores del proyecto tienen dominio sobre este lenguaje, lo que disminuye el tiempo de implementación del algoritmo. Debido a la complejidad del algoritmo Cheng y Church, se ha dividido la implementación en tres fases: Fase 1: Calculo del MSR

Este algoritmo se fundamenta en mejorar una medida estadística (MSR), la cual, permite establecer el nivel en el cual un grupo de datos varía de forma equivalente y se definen como:

Y son calculadas por medio de la siguiente ecuación:

Sea (I,J) un bicluster. El residuo R de un elemento eij del bicluster (I,J) es:

R(eij) = eij - eiJ - eIj + eIJ

Donde eiJ es la media de la fila i-ésima del bicluster, eIj la media de la columna j-ésima, y e IJ es la media de todos los elementos del bicluster.

Para representar el Microarreglo en memoria se decidió usar una lista dinámica (ArrayList ), de objetos de Tipo DATO el cual trabaja con la clase CELDA, y está formada con 3 atributos necesarios para poder realizar fase de inserción de la forma correcta y son:

(X) que hace referencia a la fila inicial,

(Y) que hace referencia a la Columna inicial y

(Valor) que hace referencia al contenido de dicha celda.

Para conocer el R(eij) en una posición particular, se crean los métodos ValorMedio_Fila, ValorMedio_Columna, Mediageneral

41

El siguiente paso es crear una matriz de residuos R(eij) esta será de la misma dimensión que la matriz original, ya que cada elemento de R(eij) es una transformación de la matriz original M(ij).

Con los datos obtenidos y otras operaciones matemáticas se calcula el valor de (Hij).

Se emplean datos de origen real, permitiendo un trabajo con decimales y alta precisión.

Fase2: Fase de eliminación.

Mientras (H(I,J)>µ)haga

Compute para

Compute para

Si

Si No

Para esta fase, se trabaja sobre la matriz de residuo, luego se procede a calcular el promedio de las filas y de las columnas, los que se guardan en vectores, seguidamente se busca el número mayor del vector de estas filas y de estas columnas, luego se comparan y se elimina el número mayor de la siguiente forma:

Se crea una pila de Filas y una pila de columnas, ya que esta estructura permite de una forma correcta, extraer posteriormente los elementos depositados.

Se carga la pila con objetos (W); estos objetos están conformados de un arreglo y de un índice, el cual establece la ubicación del arreglo en la matriz inicial M(ij), lo que facilitará posteriormente , en la etapa de inserción , volver a ubicar la fila o columna en su posición original.

Este paso realiza hasta cumplir la condición en la que: el MSR del bicluster sea menor que el umbral recomendado para este tipo de procesos que es de (α=0,01) .

Una vez que se deje de cumplir la condición se procede a la fase de inserción.

Fase 3: Fase de inserción

42

asigne Mientras haga

asigne

Compute para

Compute para

Si

Si No

Reporte I,J

La idea central de esta fase es preguntarse por: ¿Se podrá agregar una fila o columna sin qué se deje de cumplir la condición de MSR< umbral o límite permitido?. Lo que se hizo fue:

Se extrae el primer elemento u objeto W de la pila para extraer su índice y su vector.

Después se inicializa una nueva Matriz K, que será de un tamaño mayor que la anterior Matriz M con el fin de ingresar el objeto extraído de la pila.

Posteriormente se copian los datos de la Matriz M hacia Matriz K verificando que el índice del objeto X de la pila concuerde con la posición correcta en la nueva Matriz K

Luego se verifica que no hayan espacios en blancos en la Matriz K, de ser así, se debe extraer las coordenadas de las posiciones X,Y para poder copiar el objeto de la Matriz original M.

Después de hacer este procedimiento se continúa con el ingreso de una columna, Se realiza el procedimiento mencionado anteriormente intentando agregar una columna.

Luego se calcula el residuo de las filas y las columnas, se guardan en vectores buscando los mayores entre estos, después se comparan y se ingresa a la Matriz K entre los mayores el de menor valor.

Una vez finalizado el proceso, se asegura que se ha hallado el bicluster de mayor tamaño posible, que tiene un MSR menor al umbral definido.

43

8.3.1.3 Problemas

Uno de los problemas presentados hacía referencia a la forma de cómo se iban a manejar los datos de la matriz en el momento de disminuir el tamaño de filas y columnas, pues no se podía manejar las matrices típicas o estáticas sino estructura de datos dinámicas. Se consideró trabajar con múltiples archivos donde se generaran consecutivos a medida que se iban eliminando, para luego de ahí poder recuperar las columnas o filas eliminadas en la fase de inserción, Pero esta opción no se considero ya el tiempo de ejecución aumentaría debido a la necesidad de cargar múltiples veces los archivos en memoria en vez de su procesamiento. El grupo decide utilizar listas (ArrayList ) ya que esta estructura de datos se acopla de mejor forma al requerimiento de la aplicación. Se tiene problema en la fase de inserción inicialmente debido a que los datos que se manejaban en el ArrayList eran datos naturales y entonces se tenían casos donde no había forma de saber si un dato ingresado estaba en la posición correcta en la nueva matriz (problema sombrado en el ejemplo con Amarillo) y el otro problema fue que se presentaba casos en que los datos guardados en la pila no eran suficientes para llenar los espacios de la nueva matriz problema (sombreado con Rojo) en el siguiente ejemplo:

Considérese la siguiente matriz donde los valores presentados son los índices X, Y

0,0 0,1 0,2 0,3 1,0 1,1 1,2 1,3 2,0 2,1 2,2 2,3

FASE DE ELIMINACION

PASO 1 Columnas Apiladas Filas Apiladas

PASO2

0,0 0,1 0,2 0,3

1,0 1,1 1,2 1,3

2,0 2,1 2,2 2,3

0,2 1,2 2,2

44

PASO 2 Columnas Apiladas Filas Apiladas

PASO3 Columnas Apiladas Filas Apiladas

Matriz de referencia obtenida

FASE DE INSERCION PASO1 inserción fila x=1 Columnas Apiladas Filas Apiladas Problema 1. Saber Problema 1. Saber cual dato recuperar (el dato amarillo es el que no se recupera)

0,0 0,1 0,3

1,0 1,1 1,3

2,0 2,1 2,3

0,2 1,2 2,2

1,0 1,1 1,3

0,0 0,1 0,3

2,0 2,1 2,3

0,2 1,2 2,2

0,1 2,1

1,0 1,1 1,3

0,0 0,3

2,0 2,3

0,0 0,3

1,0 1,3

2,0 2,3

0,2 1,2 2,2

0,1 2,1

1,0 1,1 1,3

45

PASO2 inserción columna y= 1 Columnas Apiladas Filas Apiladas

Problema 2. Saber qué hacer para llenar la posición (1,1) ya que en blanco no se puede quedar porque nos altera el MSR.

PASO3 inserción columna y= 2 Columnas Apiladas Filas Apiladas

Resultado 0,0 0,1 0,2 0,3 1,0 1,2 1,3 2,0 2,1 2,2 2,3 Para solucionar estos inconvenientes se reformaron los tipos de datos que la Matriz (ArrayList) contenía, pasar de datos naturales a objetos de tipo DATO el cual contiene tres atributos Necesarios que son: X que hace referencia a la fila inicial, Y que hace referencia a la Columna inicial y Valor que hace referencia al contenido de dicha celda. Una vez teniendo estas herramientas la aplicación tiene la manera de preguntar en la matriz a una celda vecina el índice, y es así como se conoce cuál dato se debe copiar y cuales se desechan (Problema 1)

Para darle solución al problema2 de la fase de inserción, se trabaja con los atributos de la clase CELDA, y el procedimiento es: consultar a las celdas próximas que índice i tiene la fila y que índice j tiene la columna, luego se extrae exactamente la celda faltante de la matriz inicial y se copia a la matriz resultante.

0,0 0,1 0,3

1,0 1,3

2,0 2,1 2,3

0,2 1,2 2,2

0,1 2,1

0,0 0,1 0,2 0,3

1,0 1,2 1,3

2,0 2,1 2,2 2,3

0,2 1,2 2,2

46

8.3.1.4 Pruebas Para verificar la corrección dl algoritmo de Cheng y Church se desarrollo una prueba de escritorio empleando la matriz que se presenta a continuación

4 10 8 8 5 7 4 6 8 2 10 6

Al aplicar la prueba de escritorio sobre la matriz establecida, se halla el siguiente bicluster, el cual coincide con la respuesta entregada por el software 4 8 4 8 2 6 Para la realización de pruebas sobre datos reales se intentó cargar un Microarreglo de 120x80, pero el proceso se detuvo después de 10 minutos lo cual puede deberse al paradigma de programación empleado, las estructuras de datos empleadas para la implementación ó la capacidad de memoria y procesamiento de los equipos, por lo cual no se logró realizar pruebas con Microarreglos reales. Datos de Prueba

Considerando que las condiciones no permitían ejecutar el algoritmo sobre datos reales se construyeron otras matrices de diferentes dimensiones para probar el algoritmo. Para realizar las pruebas se construyeron diferentes matrices, de diferentes dimensiones (3x4, 4x4, 6x5, 5x7 y 8x6), y diferentes valores. Las matrices de 4x4, 5x8 se construyeron para que el bicluster fuera del tipo Filas Constantes.

La matriz de 6x5 se construyó para que el bicluster fuera de valores coherentes. Modelo multiplicativo.

La matriz de 5x7 y 3x4 se construyeron de forma que los datos tuvieran relación entre sí.

47

Los bicluster incluidos en cada matriz fueron los siguientes:

Matriz

Dimensión

Bicluster

4 10 8 8 5 7 4 6 8 2 10 6

.

3x4

4 8 7 8 4 8 2 6

.

2 5 6 8 4 7 7 9 2 3 5 6 1 5 9 6

.

4x4

5 6 7 7 5 6 5 6

9 2 3 5.5 11 13 2 4 1 3 21 33 4 8 2 6 41 55 3 6 1.5 4.5 67 78 4 6 2 5 27 98

.

6x5

2 4 1 3 4 8 2 6 3 6 1.5 4.5 4 6 2 5

2 4 6 7 8 3 5 7 2 9 4 6 8 10 1 1 3 5 2 7 8 2 10 12 10 2 6 12 10 9 1 4 8 7 3

.

5x7

4 6 4 6 10 12 12 10

2 5 6 8 6 4 7 7 9 2 2 3 5 2 9 1 5 9 6 3 2 8 5 6 5 4 0 9 8 4 6 2 4 5 2 7 2 5 6 6

.

5x8

6 6 7 7 5 6 5 6

Tabla N° 3 Bicluster introducidos en cada matriz

48

8.3.1.5 Resultados A continuación se presentan las matrices de entrada al algoritmo a si como los resultados obtenidos.

Matriz

Biclust er encontrado por Cheng y

Church Matriz

Bicluster encontrado por Cheng y Church

4 10 8 8 5 7 4 6 8 2 10 6

4 8 4 8 2 6

2 4 6 7 8 3 5 7 2 9 4 6 8 10 1 1 3 5 2 7 8 2 10 12 10 2 6 12 10 9 1 4 8 7 3

2 4 6 8 3 5 7 9 1 3 5 7

2 5 6 8 4 7 7 9 2 3 5 6 1 5 9 6

6 8 7 9

2 5 6 8 6 4 7 7 9 2 2 3 5 2 9 1 5 9 6 3 2 8 5 6 5 4 0 9 8 4 6 2 4 5 2 7 2 5 6 6

6 6 5 5

9 2 3 5.5 11 13 2 4 1 3 21 33 4 8 2 6 41 55 3 6 1.5 4.5 67 78 4 6 2 5 27 98

2 4 3 4 6 5

Tabla N° 4 Resultados Cheng y Church

El algoritmo de Cheng y Church encontró parte de los bicluster planteados, ya que el algoritmo trabaja con medida de calidad MSR, y es posible que muchos de los valores hayan superado esta medida, por lo que no se incluyen en el bicluster.

49

8.3.2 Samba El algoritmo Samba emplea la teoría de gafos intentando establecer el sub-grafo de mayor peso, el cual representaría el bicluster que contiene el subconjunto de genes que sometidos a una serie de condiciones experimentales utilizando como pruebas valores de una base de datos de expresión genética responden al mismo comportamiento.

8.3.2.1 Diagrama de clases del algoritmo SAMBA

Figura 4: UML de Samba

Para implementar el algoritmo Samba se definieron tres clases principales.

Grafo: Esta es la clase principal y contiene un ArrayList de vértices en el cual se van a almacenar y ordenar los objetos correspondientes a un grafo, además de tener los métodos necesarios para el funcionamiento del algoritmo, por ejemplo el método consultaRepeticion, que se utiliza para verificar que un vértice no haya sido visitado durante un recorrido, el método quicksort, se utiliza para ordenar los sub-grafos, el método procesoInterseccion, se utiliza para realizar la intersección entre los genes que componen una condición especifica, el método

50

mostrarcadena, se utiliza para mostrar el o los recorridos finales de los sub-grafos más pesados, con su respectivo valor.

Vértice: Esta clase está compuesta por un ArrayList de arcos, ya que un vértice puede tener muchos arcos, además está compuesta por un número que identifica el vértice.

Arco: Esta clase tiene los atributos que representan el origen, el destino y el peso del arco, incluye igualmente los métodos que permiten acceder a los datos de la clase.

Form1: Esta clase es en donde esta implementada la interfaz de usuario.

Program: Esta clase contiene el método main , el cual es el que se encarga de ejecutar las demás clases.

8.3.2.2 Implementación

Para la implementación del algoritmo Samba, se decidió utilizar C#, ya que al igual que java trabaja con enfoques orientados a objetos, por lo cual no hay mucha discrepancia en los datos, además presenta un rendimiento mucho mejor, permite utilizar punteros, soporta más tipos primitivos, lo cual ayuda bastante al momento de codificar el software.

Para explicar mejor el funcionamiento del algoritmo se va a utilizar como ejemplo el siguiente grafo

Figura 5: Grafo de ejemplo de Samba

El algoritmo Samba se divide en 5 fases en las que se explica su funcionamiento.

51

FASE 1: NORMALIZACION DE DATOS

La primera fase del algoritmo Samba comienza con la normalización de los datos, ya que inicialmente lo único que importa es que los datos de la matriz estén activos dependiendo de una determinada condición. Para la normalización se utilizo una media de 0 y una varianza de 1; de esta forma cada valor de la matriz indica si el gen esta activo o no, si su valor normalizado es mayor a 1 el gen se considera como activo, y no activo si es menor a -1. Esto se realiza con el fin de buscar un sub-grafo en el cual los genes tengan la misma tendencia o tendencias opuestas. Después de tener la información de la matriz de datos normalizada, se pasa a construir el grafo, en el cual un gen y un vértice van a quedar unidos por una arista, esto dependiendo del valor del gen al momento de ser normalizado, es decir, si el valor es superior a 1 se agrega la arista de lo contrario no. Después de esto se tiene que agregar un peso a las conexiones entre un gen y un vértice y vértice y una condición.

FASE 2: SUB-GRAFOS MÁS PESADOS La segunda fase corresponde a encontrar los K sub-grafos más pesados en el grafo (el valor de K es ingresado por el usuario). Después de tener los sub-grafos más pesados hay que obtener las condiciones que compone cada sub-grafo, y revisar a cuales genes conectan dichas condiciones para después realizar una intersección entre ellos.

Suponiendo que el sub-grafo más pesado es el siguiente:

B = sub1= {G1, U1, G2, U2} Donde G: genes U: condiciones

Del conjunto B, que es el sub-grafo más pesado hay que sacar qué condiciones lo componen, en este caso serían V’ = {U1} ∩ {U2}, para después revisar cuales genes conectan cada condición.

Para U1 = {G1, G2}, para U2= {G1, G2, G3}

Con dichos genes se debe realizar una intersección, que significa obtener los elementos en común {G1, G2} ∩ {G1, G2, G3}, lo cual daría lo siguiente: V’= {G1, G2}

Después de esto se debe tomar el conjunto B, que es el sub-grafo más pesado que se obtuvo inicialmente y se debe hacer una unión con el conjunto V’, Es decir:

B= {G1, U1, G2, U2} U V’= {G1, G2}

52

Esta unión genera como resultado el conjunto: S = {G1, U1, G2, U2}

Después de esto se pasa a la parte final del algoritmo la cual consiste en modificar cada bicluster mientras sea posible mejorar su peso.

FASE 3: ADICIONAR GEN O CONDICIÓN La tercera fase, consiste en revisar si el peso del grafo aumenta al agregar otro gen u otra condición. Es decir se toma el conjunto S, que es la unión del conjunto B y el conjunto V’, y se realiza una unión con cada uno de los genes y condiciones que componen el grafo inicialmente. De la siguiente forma:

W= {S U G1}, {S U G2}, {S U G3}, {S U U1}, {S U U2}

De estas uniones se obtiene diferentes resultados de los cuales se toma el sub-grafo con el mayor peso, para el caso ejemplo el sub-grafo de mayor peso es el de la unión de {S U G3} = 10.

FASE 4: ELIMINAR GEN O CONDICIÓN La cuarta fase, consiste en revisar si el peso del grafo aumenta al eliminar un gen o una condición. Es decir, se toma el conjunto S, y se realiza una resta con cada uno de los genes y condiciones que componen el conjunto B. Lo cual daría lo siguiente

W= {S – G1}, {S – G2}, {S – U1}, {S – U2}

De estas restas se obtiene diferentes resultados para lo cual al igual que en la fase 3 se debe tomar el sub-grafo con el mayor peso. Par el caso dado el mayor peso se logra con la resta de {S – U2}= 11 FASE 5: VALIDACIÓN La fase final, consiste en realizar una validación con los resultados obtenidos en las fases 3 y 4. Si el peso obtenido en la fase 3 es mayor al peso obtenido en la fase 4, se selecciona el conjunto obtenido en la fase 3, de otra forma se selecciona el conjunto obtenido en la fase 4. El sub grafo seleccionado corresponde al bicluster. El algoritmo Samba fue el primero en trabajar con grafos, ya que de esta forma se puede trabajar con dos partes que representan al conjunto de genes y condiciones de la matriz; Lo cual resulta mucho más fácil de analizar si se tiene en cuenta que

53

un gen y una condición se unen o se conectan mediante una arista, dependiendo de que un gen especifico haya variado de su estado normal frente a esa condición. En conclusión para la implementación se tiene que utilizar teoría de grafos, ya que este es el fundamento del algoritmo.

8.3.2.3 Problemas Los principales problemas al implementar el algoritmo Samba, fueron las condiciones de parada, ya que si no se ponía alguna , los recorridos que tenía que hacer el algoritmo se convertían en ciclos infinitos, por ejemplo cuando en el grafo un nodo era visitado no se debía pasar por ahí nuevamente. Para ello, en el algoritmo se construye una cadena para verificar si un vértice pertenece a la cadena, si es así, es porque ya pasó por ahí, entonces se marca como visitado y se pone una condición para que no se devuelva.

8.3.2.4 Pruebas Para verificar la corrección del algoritmo se empleó la misma matriz utilizada para el algoritmo de Cheng y Church:

4 10 8 8 5 7 4 6 8 2 10 6

Según el funcionamiento del algoritmo Samba la prueba de escritorio para esta matriz debería dar el siguiente resultado, que es igual al obtenido con el software. 4 8 5 6 8 6 Con el objetivo de probar todos los algoritmos bajo las mismas circunstancias, se utilizaron las matrices de prueba preparadas para el algoritmo de Cheng y Church y se desarrollaron las pruebas bajo las mismas condiciones (el mismo equipo de cómputo con los mismos procesos corriendo.)

54

8.3.2.5 Resultados A continuación se muestran las matrices con el bicluster encontrado por el algoritmo.

Matriz

Bicluster encontrado por SAMBA Matriz

Bicluster encontrado por

SAMBA

4 10 8 8 5 7 4 6 8 2 10 6

4 8 5 6 6 8

2 4 6 7 8 3 5 7 2 9 4 6 8 10 1 1 3 5 2 7 8 2 10 12 10 2 6 12 10 9 1 4 8 7 3

2 5 8 12 9 3

2 5 6 8 4 7 7 9 2 3 5 6 1 5 9 6

2 4 7 3 5 9 6 8

2 5 6 8 6 4 7 7 9 2 2 3 5 2 9 1 5 9 6 3 2 8 5 6 5 4 0 9 8 4 6 2 4 5 2 7 2 5 6 6

2 7 9 6 4 6

9 2 3 5.5 11 13 2 4 1 3 21 33 4 8 2 6 41 55 3 6 1.5 4.5 67 78 4 6 2 5 27 98

2 4 4 6 6 4.5

67 27

Tabla N° 5 Resultados de Samba

Como se puede observar los resultados variaron ya que los tres algoritmos pertenecen a enfoques diferentes, lo cual implica que los biclusters hallados no sean los mismos, esto debido a que la forma en que trabaja cada algoritmo, el tipo de estructura y la forma en la que encuentran el bicluster, es diferente.

55

8.3.3 Interrelated Two-Way Clustering (ITWC) ITWC es un algoritmo iterativo de biclustering basado en la combinación de los resultados obtenidos mediante la agrupación por clustering realizada sobre cada una de las dos dimensiones de la matriz de datos por separado. Dentro de cada iteración de ITWC hay cinco pasos principales. En el primer paso, la agrupación se realiza en la dimensión de fila de la matriz de datos. La técnica clustering utilizada puede ser cualquier método que recibe el número de clusters o de agrupaciones a realizar. En el segundo paso, la agrupación o clustering se realiza en la dimensión de la columna de la matriz de datos. El tercer paso combina los resultados de agrupamiento de los pasos anteriores dividiendo las columnas en cuatro grupos. El cuarto paso del ITWC consiste en tomar las combinaciones anteriores y unir distintos grupos de datos de forma que se produzcan biclusters. El quinto paso, consiste en ordenar todos los genes de forma descendente, para así poder representar el comportamiento de estos y escoger el determinado grupo de genes que formaran el bicluster. 8.3.3.1 Software El software utilizado para las pruebas del algoritmo Interrelated Two-Way Clustering , se llama BCCA, fue implementado por Dr. Rajat Kumar De. y está disponible en la pagina: http://www.isical.ac.in/~rajat/, de donde se puede descargar el software con licencia académica, la guía de usuario, y ejemplos de análisis reales. 8.3.3.2 Funcionamiento Para utilizar el software de Interrelated Two-Way Clustering , se debe realizar un archivo .txt, en el que los valores deben estar delimitados por <tab>, el primer campo de campo de cada fila debe contener el nombre del gen (por ejemplo , Gen1, Gen2, …,etc.), el resto de los campos son los valores de la muestra. Además cada fila debe contener el mismo número de campos y el archivo de entrada no debe contener ningún valor faltante. A continuación un ejemplo de una matriz válida para el funcionamiento del software.

56

El archivo .txt se carga en el software, se ingresan los datos correspondientes al número de genes, numero de muestras y el umbral de correlación (cuyo valor debe estar entre 0.1 y 0.84) y se selecciona si se quiere encontrar bicluster con solapamiento o no; los resultados se generan en un archivo txt. El funcionamiento detallado se puede ver en el Anexo Nº 2. Funcionamiento Software BCCA

8.3.3.3 Problemas Los principales problemas al momento de utilizar el software del algoritmo Interrelated Two-Way Clustering, fueron que no se encontró la información suficiente sobre el manejo del software, el manual que se encontró no contaba con la claridad necesaria para la interpretación de los resultados arrojados por el software. 8.3.3.4 Resultados

A continuación se presentan las matrices de entrada al algoritmo Interrelated Two-Way Clustering a si como los resultados obtenidos.

Matriz


Interrelated Two-Way

Clustering Matriz


Interrelated Two-Way Clustering

4 10 8 8 5 7 4 6 8 2 10 6

4 8 7 8 4 8 2 6

2 4 6 7 8 3 5 7 2 9 4 6 8 10 1 1 3 5 2 7 8 2 10 12 10 2 6 12 10 9 1 4 8 7 3

4 6 4 6 10 12 12 10

2 5 6 8 4 7 7 9 2 3 5 6 1 5 9 6

5 6 7 7 5 6 5 6

2 5 6 8 6 4 7 7 9 2 2 3 5 2 9 1 5 9 6 3 2 8 5 6 5 4 0 9 8 4 6 2 4 5 2 7 2 5 6 6

6 6 7 7 5 6 5 6

9 2 3 5.5 11 13

2 4 1 3 4 8 2 6

57

2 4 1 3 21 33 4 8 2 6 41 55 3 6 1.5 4.5 67 78 4 6 2 5 27 98

3 6 1.5 4.5 4 6 2 5

Tabla N° 6 Resultados de Interrelated Two-Way Clustering

Los resultados obtenidos por el software BCCA fueron adecuados, ya que encontró los biclusters que fueron planteados en cada matriz.

8.4 Análisis En este trabajo se han mostrado diferentes algoritmos de biclustering que se utilizan para descubrir subgrupos de genes que reaccionan de manera similar ante un subgrupo de condiciones. Para compararlos entre sí se han seleccionado seis criterios : Tipo de Bicluster, Tipo de Estructura, Cantidad de Bicluster, Enfoque, orden de complejidad y tiempo de ejecución. La siguiente Tabla presenta los valores de estos seis criterios para cada uno de los algoritmos estudiados:

Método Tipo de

Bicluster Tipo de Estructura Cantidad de Biclusters Enfoque

Permitir superposición Complejidad

Cheng and Church

Valores Constantes

un solo Bicluster

one set at a time Greddy

si (rara vez)

O(MN) or O(MlogN)

SAMBA Evolución Coherente Biclusters Aleatorios simultaneous EXH-Enum Si O(N2d)


Valores Coherente

Bicluster con filas exclusivas o bicluster

con columnas exclusivas

one set at a time (Clust- comb) Si 0(n5)

Tabla N° 7. Comparación algoritmos de Cheng y Churc h, SAMBA e Interrelated Two-Way clustering En la Tabla N° 7, la primera columna hace referen cia a los algoritmos de biclustering seleccionados. En la segunda columna se muestra la clasificación de acuerdo al tipo de bicluster al cual pertenece cada algoritmo, ya sea: valores constantes, evolución coherente, columnas constantes o filas constates. En la tercera columna se clasifica los algoritmos de acuerdo al tipo de estructura que pueden producir. En las columnas 4 y 5 mostramos la clasificación de los diferentes algoritmos de acuerdo a la forma en que encuentran el bicluster y el enfoque que utilizan para lograr sus objetivos.

58

La notación utilizada para la columna 5 es la siguiente: búsqueda voraz iterativa (Greedy), enumeración exhaustiva del bicluster (EXH-Enum) y la Combinación de Clustering sobre filas y columnas. (Clust- comb). En la columna 6 (permitir superposición) se indica si los algoritmos pueden obtener un modelo de capas donde se describan las interacciones entre los distintos biclusters, de manera que se minimice una función objetivo que evalúe de forma global el conjunto de biclusters obtenidos a partir de la matriz original. En la columna N° 7 se muestra el orden de complejidad del algoritmo, el cual permite establecer la cantidad de recursos empleados por cada algoritmo21. Los tres algoritmos Cheng y Church, SAMBA y Interrelated Two-Way Clustering estudiados en la realización del proyecto, encuentran tipos diferentes de Bicluster: Valores Constantes, evolución coherente, valores coherentes respectivamente, lo cual hace que su comparación Tenga más contraste por encontrar diferentes tipos de Bicluster. De acuerdo a la investigación realizada podemos concluir que el algoritmo SAMBA e Interrelated Two-Way Clustering son más adecuados para casos donde se requiera encontrar N cantidad de biclusters, a diferencia de Cheng y Church , ya que este encuentra el bicluster más representativo. Cheng y Church al utilizar como enfoque la búsqueda voraz iterativa, tiene ventaja computacional, ya que este intenta simplificar la búsqueda tomando decisiones locales con la esperanza de encontrar la solución óptima global, mientras que SAMBA utiliza búsqueda exhaustiva de todas las posibles sub-matrices existentes en la matriz de datos. Por otra parte al grupo le parece de gran importancia la estructura de agrupamiento que utiliza ITWC que es filas y columnas exclusivas ya que desde el punto de vista biológico sería de gran importancia conocer qué grupo de genes se ven afectados a una condición en particular. Referente al orden de complejidad más adelante se muestra una tabla en la cual se comparan los tres algoritmos y se comenta cual puede ser el más eficiente en cuanto a esta característica.

21

Jesús S. Aguilar-Ruiz ,Computer Science Department, University of Seville, SPAIN, BICLUSTERING OF GENE EXPRESSION DATA. Disponible en internet: www.cs.wayne.edu/~shiyong/csc7710/assignments/bicluster.ppt

59

8.4.1 Comparación de los Métodos de Acuerdo al Tiem po de Ejecución El tiempo de ejecución de los algoritmos de Cheng y Church y Samba, se calculó a partir de las implementaciones realizadas por el grupo de trabajo, para la realización de este se tiene en cuenta los métodos críticos de cada algoritmo, es decir, los métodos que realizan el bicluster. A continuación se presentan los resultados: Cheng y Church T(n)=36+6n-4m+23nm Samba T(n)= 40n2 +4m2+12mn2+3mn+2md+21n-8m-16+2(n-1)(na+n*log*nb) NOTA: los cálculos de la forma como se obtuvo los tiempos de ejecución se encuentran en el anexo 3 y el anexo 4

En la siguiente tabla se operará el tiempo de ejecución de cada algoritmo para los Microarreglos creados por el grupo de trabajo.

Tamaño Matriz NxM

Tiempo de Ejecución Cheng y Church

Nro de instrucciones

4x4 T(n)=36+6(4)-4(4)+23(4x4) 412 8x4 T(n)=36+6(8)-4(4)+23(8x4) 804 7x5 T(n)=36+6(7)-4(5)+23(7x5) 863 9x5 T(n)=36+6(9)-4(5)+23(9x5) 1.105 10x6 T(n)=36+6(10)-4(6)+23(10x6) 1.452

Tabla N°8 Comparación Tiempo de Ejecución Cheng y Church

Tamaño Matriz NxM

Tiempo de Ejecución Samba

Nro de Instruc.

4x4 T(n)= 40n2 +4m2+12mn2+3mn+2md+21n-8m-16+2((n-1)(na+n*log*nb)) 1.626 8x4 T(n)= 40(8)2+4(4)2+12(4)(8)2+3(4)(8)+2(4)(1)+21(8)+2((7)(8+8log8)) 6.069 7x5 T(n)= 40(7)2+4(5)2+12(5)(7)2+3(5)(7)+2(5)(1)+21(7)+2((6)(7+7log7)) 5.332 9x5 T(n)= 40(9)2+4(5)2+12(5)(9)2+3(5)(9)+2(5)(1)+21(9)+2((8)(9+9log9)) 8.671

10x6 T(n) =40(10)2+4(6)2+12(6)(10)2+3(6)(10)+2(6)(1)+21(10)+2((9)(10+10log10)) 11.926 Tabla N°9 Comparación Tiempo de Ejecución SAMBA

60

En las tablas N°8 y N°9 se obtuvieron el numeró de líneas ejecutadas a partir del tiempo de ejecución de cada Algoritmo, y se observo que para la implementación de Cheng y Chuch, el crecimiento del tamaño de la matriz con respecto al número de líneas, se hace de manera lineal y con respecto al algoritmo SAMBA, el crecimiento se hace de manera exponencial.

El grupo de trabajo implementó dos algoritmos SAMBA y Cheng y Church, la implementación del algoritmo de ITWC fue obtenida de internet, por lo cual no tenemos la manera de obtener el tiempo que este algoritmo tarda en procesar los datos. Las siguientes tablas presentan los resultados de los tiempos Maquina de ejecución para los algoritmos de SAMBA y Cheng y Church. Cheng y Church

Tamaño Matriz

Tiempo de Ejecución Cargando los datos

Tiempo de Ejecución al procesar los datos

4x4 =16 datos 107788 ns 706056 ns 8x4=32 datos 103809 ns 795671 ns 7x5 =35 datos 125225 ns 830473 ns 9x5=45 datos 222403 ns 814495 ns

10x6=60 datos 223289 ns 843221 ns Tabla N°10 Tiempo Maquina de Ejecución Cheng y Chu ch

SAMBA

Tamaño Matriz

Tiempo de Ejecución Cargando los datos

Tiempo de Ejecución al procesar los datos

4x4 =16 datos 20961199 ns 570032 ns 8x4=32 datos 23021317 ns 50422884 ns 7x5 =35 datos 21721242 ns 133847656 ns 9x5=45 datos 23291332 ns 540800932 ns

10x6=60 datos 24281134 ns 548901021 ns Tabla N°11. Tiempo Maquina de Ejecución SAMBA

Primero se ejecutó el software correspondiente a cada algoritmo (Cheng y Church, SAMBA), se cargó la misma matriz para ambos, lo que se obtuvo fue el tiempo maquina de ejecución al momento de cargar los datos, y al momento de ejecutarlos, estos resultados fueron tomados para determinar cuál de los dos se tardaba más. Para realizar estas pruebas cabe aclarar que se probaron bajo las

61

mismas circunstancias, es decir se utilizaron las mismas matrices y el mismo computador con los mismos procesos en ejecución. De acuerdo a los resultados obtenidos en las tablas N°10 y N°11 se puede observar que el tiempo maquina de ejecución de los algoritmos, depende básicamente de la cantidad de datos a analizar y de la forma en que estos se encuentren. El tiempo de ejecución es un reflejo o consecuencia del orden de complejidad por consiguiente el tiempo de ejecución de Cheng y Church es mucho menor que el de SAMBA. En la tabla N°11 se observa un crecimiento exponencial el tiempo de ejecución del algoritmo SAMBA al momento de aumentar la cantidad de datos a procesar. En la tabla N°10 el crecimiento de tiempo de ejecución de Cheng y Church a medida que se aumenta la cantidad de datos es menor, por ser esta de orden logarítmico o en el peor de los casos de orden Lineal. Un aspecto que puede afectar la ejecución del algoritmo es el pre-procesamiento de los datos, el cual permite transformar los datos de entrada y haciendo más evidentes los patrones de interés, de manera que en la ejecución del algoritmo se obtengan resultados de mejor calidad. El pre procesamiento de los datos debe ser robusto, en cuanto al método que se utilice, ya sea para ordenar o normalizar los datos, con el fin de minimizar el coste computacional del método de biclustering, de no hacerse, el algoritmo debe ser más robusto, pues esta carga recaerá sobre él. A este respecto se tienen dos posibilidades por una parte, se puede no aplicar pre-procesamiento a los datos de entrada, lo cual puede generar más datos erróneos o demorar más la convergencia del algoritmo, pero no modifica los datos originales de la matriz; la segunda opción es normalizar los datos de entrada para poder estudiar todos los valores de expresión dentro del mismo rango, dicha técnica es la utilizada por el algoritmo SAMBA con el fin de eliminar aquellos genes poco significativos e Interrelated Two-Way Clustering con el fin de eliminar aquellos genes que reaccionen con escasa intensidad ante las condiciones experimentales.

62

8.4.2 Comparación De Los Métodos De Acuerdo Al Orde n De Complejidad

Cheng y Church

SAMBA Interrelated Two -Way Clustering

Tamaño Matriz

O(NlogM) OR O(NM)

O(N2d)log(2d)

0(n)5

4x4 4log4= 2,408239 4x4=16

(16x22) log(2 x2) = 12,2300631

165= 1.048.576

8x4 8log4= 4,816479 8x4=32

(32x22) log(2 x2)= 18,5637972 325= 33.554.432

7x5 7log6= 5,447058 7x5=35

(35x22) log(2 x2)= 19,5928596 355= 52.521.875

9x5 9log5= 6,290730 9x5=45

(45x22) log(2 x2)= 22,7934122 455=184.528.125

10x6 10log6= 7,781512 10x6=6

0

(60x22) log(2 x2)= 27,103786 605=777.600.000

Tabla N° 12. Comparación Orden de Complejidad

Los órdenes de complejidad expuestos en la tabla anterior, fueron obtenidos de la trabajo realizado por Kevin.Yip22, en su documento Biclustering Methods for Microarray Data Analysis, donde se presentan características de algunos algoritmos de biclustering, entre los cuales se encuentran los algoritmos implementados en este proyecto. Las pruebas con estos se realizaron con los valores de las matrices de prueba, es decir, de acuerdo a la cantidad de filas y columnas que presenta cada matriz.

• Para hallar el orden de complejidad de Cheng y Church O(NM) se remplaza N, por la cantidad de filas y M por la cantidad de columnas, es decir para la matriz de 7x5, se debe hacer de la siguiente forma: 7*5.

• Para el orden de complejidad del algoritmo SAMBA las variables son:

N: cantidad de filas por columnas. D: cantidad de sub-grafos a encontrar

• Para el algoritmo Interrelated Two-Way Clustering las variables utilizadas

son: N: cantidad de filas x cantidad de columnas

22

Kevin.Yip,DB Seminar Series: Biclustering Methods for Microarray Data Analysis.[en línea]. Septiembre 2003.[Consultado 16 de octubre de 2010]. Disponible en internet: www.cs.wayne.edu/~shiyong/csc7710/assignments/bicluster.ppt

63

Teniendo en cuenta los datos obtenidos a partir de dichos parámetros, se observa que el algoritmo Cheng y Church visto desde el punto de vista de orden de complejidad es el más eficiente o el de mejor rendimiento, es decir que es el más aconsejable para trabajar con matrices de gran cantidad de datos, ya que presenta un orden de complejidad más bajo que los otros algoritmos. Aunque el hecho de que un algoritmo sea más eficiente que otro en función de orden de complejidad o tiempos de ejecución, no quiere decir que sea el mejor, los algoritmos pueden ser usados dependiendo del contexto o de los resultados que se requieran, es decir si se requiere encontrar más de un bicluster , no se podría utilizar el algoritmo de cheng y church, ya que este sólo encuentra un bicluster a la vez, en cambio los algoritmos SAMBA e Interrelated Two-Way Clustering encuentran más de un bicluster, lo cual puede ser más significativo si se requiere analizar más a fondo el comportamiento de los genes. Por otra parte como se observa en la tabla Nº11 , el algoritmo de Cheng y Church sólo puede hallar un bicluster de valores constantes, lo cual desde el punto de vista biológico, no sería de gran ayuda, si se tiene en cuenta que es mucho más difícil encontrar biclusters de Evolución Coherente.

El principal problema del algoritmo de Interrelated Two-Way Clustering radica en que su orden de complejidad es de orden polinómico, lo cual es una desventaja si se tiene en cuenta que no son adecuados para trabajar con datos que tiendan a crecer. Es decir este algoritmo es adecuado si se garantiza que se va a trabajar sobre datos pequeños (valores bajos de N). El algoritmo SAMBA utiliza una combinación de teoría de grafos y de análisis estadístico, lo cual es utilizado para la identificación de un determinado número de biclusters significativos en una base de datos de expresión genética. Es un algoritmo complejo de analizar e implementar ya que consta de muchas etapas en las cuales hay que realizar varias operaciones de manejo de conjuntos y teoría de grafos, pero de igual modo es de gran utilidad ya que puede hallar diferentes biclusters de forma simultánea y de tipo evolución coherente que son los más difíciles de encontrar.

8.4.3 Comparación de los resultados usando medida d e calidad MSR

El MSR es utilizado para encontrar biclusters significativos, es decir cuando alguno de los algoritmos encuentra biclusters interesantes, agrupando genes con comportamientos similares y manteniendo residuos cuadráticos medios (MSR) muy bajos, se dice que el bicluster es de calidad y cuando el residuo cuadrático es alto es porque no es de calidad o no es confiable. Sin embargo,

64

estudios han demostrado que esta medida no es del todo válida ya que no es tan buena cuando se aplica a distintos tipos de biclusters. El algoritmo de Cheng y Church utiliza el MSR como medida de calidad, lo cual ayuda a que se encuentren biclusters confiables, aunque Samba e Interrelated Two-Way Clustering, no empleen de este tipo de medidas para evaluar la calidad de un bicluster, se considera interesante verificar el MSR de los biclusters hallados por los algoritmos. En la siguiente tabla se muestra los resultados para un grupo de matrices de diferente tamaño, en las cuales se calculó el índice de calidad MSR el cual mide la correlación entre los distintos resultados ejecutando diferentes algoritmos de biclustering.

Matriz Cheng & Church Samba Interrelated Two-Way Clustering 3x4 0 0,38888889 0,421875 4x4 0 2,25 0,046 6x5 0 2,34722222 2,01038 7x5 0 5,05555556 0,75 8x5 0 2,72222222 0,0625

Tabla No 13 Evaluación de calidad de bicluster usando MSR

De acuerdo al valor del MSR hallado para la ejecución de cada algoritmo, se puede observar que el algoritmo de Cheng y Church encuentra un bicluster perfecto, es decir de los tres algoritmos es el que arroja un bicluster más confiable, con mayor coherencia en los datos que lo integran, al momento de realizar el análisis del comportamiento, cambio o reacción de los genes cuando se someten a diferentes condiciones experimentales. No obstante el algoritmo SAMBA encuentra biclusters de tipo Evolución Coherente, de estructura aleatoria, con enfoque de búsqueda exhaustiva y la forma de encontrar bicluster es simultánea, es decir que puede encontrar más de un bicluster en un conjunto de datos. El algoritmo de Interrelated Two-Way Clustering, también maneja un nivel de error bajo en los biclusters que encuentra, y al igual que el Algoritmo SAMBA pueden encontrar más de un bicluster, lo cual es una ventaja si se mira desde el punto de vista biológico, ya que se tienen más conjuntos de datos relacionados que se pueden analizar para hallar su significado biológico.

65

8.4.4 Comparación de los resultados usando medida d e calidad Error Virtual. Error Virtual (VE), es una técnica basada en patrones de comportamiento que se utiliza con el fin de evaluar y establecer un valor indicativo para así comprobar la validez de un bicluster,23 El error virtual permite medir las similitudes entre los genes, comparando sus comportamientos con los de un patrón que se crea a partir de ellos y al igual que con el MSR, los biclusters con valores de Error Virtual bajos son considerados como biclusters de buena calidad. La siguiente tabla muestra los resultados para un grupo de matrices de diferente tamaño, en las cuales se calculó el índice de calidad Error Virtual (VE) el cual al igual que el MSR mide la calidad de un bicluster.

Matriz Cheng & Church SAMBA Interrelated Two-Way Clustering

3x4 -1,42994148 -1,914484187 -1,948559019

4x4 0,05943791 -1,738691057 -4,504698264

6x5 -2,04275292 0,107790905 -8,04479425

7x5 -3,350699 -0,365210221 -0,577350269

8x5 0,65353256 -1,019029411 -4,767071655

Tabla No 14 Evaluación de calidad de bicluster usando Error Virtual. De acuerdo a los resultados obtenidos al momento de aplicar la técnica de Error Virtual (VE) a cada bicluster hallado por cada algoritmo, se puede observar que el algoritmo de Cheng y Church, es el que encuentra biclusters de mayor confiabilidad. El algoritmo SAMBA también encuentra bicluster de buena calidad, ya que también presenta valores de VE bajos, y en algunos casos como se observa en la Tabla, presenta valores más bajos a los de Cheng y Church El algoritmo de Interrelated Two-Way Clustering para este caso con el Error Virtual en la mayoría de los casos presento valores mucho más altos que los otros dos algoritmos, lo que indica que a pesar de encontrar diferentes biclusters de forma simultánea, no son tan confiables, como se esperaría, en análisis biológicos.

23 Beatriz Pontes Balanza, Técnicas de Evaluación en Algoritmos de Biclustering sobre Datos de Expresión Genómica Op. Cit pag 17- 20

66

9.0 RESULTADOS

No se puede deducir con certeza cual algoritmo es mejor que otro, ya que esto depende de los parámetros de comparación o del punto de vista desde el que se miren, por ejemplo en términos de orden de complejidad el algoritmo más adecuado es el de Cheng y Church, pero si se habla en términos del tipo de bicluster que encuentran , el de Cheng Church ya dejaría de ser el mejor, ya que este encuentra biclusters de tipo Valores Constantes, los cuales son más sencillos de encontrar y de analizar visualmente que los hallados por SAMBA (Evolución Coherente), que además de hallar biclusters que podrían ser de más ayuda para futuros análisis biológicos, también encuentra más de un bicluster, cosa que no hace el de Cheng y Church.

Los algoritmos de Samba e Interrelated Two-Way Clustering, desde el punto de vista biológico son mejores que el algoritmo de Cheng y Church, ya que este solo encuentra un bicluster, y en la mayoría de casos es mucho mejor encontrar más de un bicluster para poder realizar diferentes análisis y estudiar más a fondo el comportamiento de los genes, y así poder llegar a mejores conclusiones. Los algoritmos de Samba e Interrelated Two-Way Clustering, no son aconsejables, para trabajar con matrices con grandes cantidades de datos, ya que cuentan con un orden complejidad exponencial, lo cual no suele ser muy útil en la práctica por el elevado tiempo de ejecución que puedan presentar, en otras palabras este tipo de algoritmos se deberían utilizar para casos en los que se necesite ejecutar datos pequeños pocas veces. Por ende, el algoritmo de Cheng y Church es el más adecuado si se requiere trabajar de forma más rápida o con grandes cantidades de datos, debido a que su orden de complejidad es el más eficiente.

67

10.0 CONCLUSIONES

Los procesos de comparación de los algoritmos de biclustering son de gran importancia ya que permiten clasificarlos, para así poder seleccionar, cuál de los algoritmos utilizar para un determinado estudio de análisis genético. Con la realización de la implementación, se logró comprender el nivel de complejidad que contienen los algoritmos de biclustering, lo cual motiva a los ingenieros a desear aprender nuevas técnicas de programación y así ofrecer mejores soluciones a los grandes retos que presenta la Bioinformática.

Para la ejecución de los algoritmos se requieren computadores más robustos, y con un procesador de buen rendimiento y alto desempeño, memoria rápida y confiable.

Se comprendió que estos algoritmos se pueden utilizar para realizar análisis de matrices con gran cantidad de datos, de las cuales se puede conseguir información útil y novedosa, como por ejemplo la identificación de distintos genes que muestren el mismo comportamiento frente a determinadas condiciones experimentales, también se pueden utilizar para establecer relaciones entre los diferentes comportamientos presentados por un mismo gen dependiendo de distintas situaciones.

Es importante definir qué criterios se van a establecer para la comparación de los algoritmos, ya que de ellos depende que resultados y conclusiones se pueda obtener, es decir, si se requiere saber qué algoritmo es el más eficiente, se debería elegir el criterio Orden de complejidad, pero esto a su vez no indica que sea el más adecuado para trabajar desde el punto de vista biológico.

68

11.0 RECOMENDACIONES Para futuros trabajos se recomienda que en la implementación de algoritmos de biclustering como SAMBA y Cheng y Chuch no se utilicen las técnicas de programación tradicionales, sino que se piense en una programación distribuida ya que esta permite optimizar los recursos como la memoria y procesamiento de la computadora, que son los que más se ven afectados en la ejecución de este tipo de aplicaciones. En tanto sea posible, no utilizar métodos recursivos ya que estos necesitan más recursos de máquina, lo que conlleva a gastar más memoria y elevar exponencialmente los tiempos de ejecución. Se recomienda no utilizar matrices de objetos ya que estos necesitan más recursos de memoria debido a que un objeto ocupa más espacio que un número. Para la implementación y ejecución de este tipo de algoritmos, se debe disponer de los equipos adecuados (computadores de alto rendimiento, procesamiento de datos y de alta capacidad de memoria, o grillas de computadores) para realizar las pruebas correspondientes. Se recomienda para próximos trabajos implementar otros algoritmos de biclustering y realizar la comparación con los ya expuestos y así determinar nuevas conclusiones, basadas en los parámetros de comparación utilizados en el documento.

69

12.0 BIBLIOGRAFÍA

� Beatriz Pontes Balanza, Técnicas de Evaluación en Algoritmos de

Biclustering sobre Datos de Expresión Genómica [en línea]. Madrid: ISIS, 2007. [consultado 15 de octubre de 2008] . Disponible en internet: http://www.lsi.us.es/docs/doctorado/memorias/Pontes,%20Beatriz.pdf

� Beatriz Pontes Balanza, Análisis de datos de Expresión Genética Mediante técnicas de Biclustering [en línea]. Madrid: ISIS, 2007. [consultado 15 de octubre de 2008] . Disponible en internet: www.lsi.us.es/docs/doctorado/memorias/Memoria-v2.pdf

� D. Domingo Savio Rodríguez Baena, Análisis de datos de Expresión

Genética mediante técnicas de Biclustering: [en línea] No.1 (2006) < http://www.lsi.us.es/docs/doctorado/memorias/Memoria-v2.pdf> [citado en mayo de 2006]

� Gregory A Grothaus, Algorithms for Molecular Biology: Automatic Layout and visualization of biclusters: [en línea] No. 1 (2006) <http://viaclinica.com/article.php?pmc_id=1624833> [citado en 2006]

� Pedro Carmona-Saez, BMC Bioinformatics: Biclustering datos de la

expresión génica: [en línea] No.1 (2006) < http://viaclinica.com/article.php?pmc_id=1434777 > [citado en 2006]

� Y.Cheng and G.M.Church.Biclustering of expression data, InProc ISMB’00,

pages93–103.AAAIPress,2000.

� J.A.Hartigan, Direct clustering of a data matrix. Journal of the American Statistical Association (JASA).

� G.Getz, E.Levine, and E.Domany Coupled two-way clustering analysis of gene microarray data. In Proceedings of the Natural Academy of Sciences USA, paginas12079–12084, 2000.

� Jiong Yang, Wei Wang, Haixun Wang, and Philip Yu, Enhanced biclustering on expression data In Proceeding sof the 3rd IEEE Conference on Bioinformatics and Bioengineering, pages321–327, 2003.

� Amir Ben-Dor, Benny Chor, Richard Karp, and Zohar Yakhini Discovering local structure ingene expression data: Theorder preserving submatrix problem In Proceeding softhe th e International Conference on Computacional Biology (RECOMB’02),pages49–57,2002.

70

� A.Tanay,R.Sharan, and R.Shamir,Discovering statistically significant

biclusters Ingene expression data. Bioinformatics,18:136–144,2002.

� Haixun Wang, WeiWang, Jiong Yang, and PhilipS Yu, Clustering by pattern similarity in large data sets , In Proceeding softhe 2002 ACMSIGMOD International Conference on Management of Data, pagina 394–405, 2002.

� Laura Lazzeroni and Art Owen, Plaid models forgene expression data, Technical report, Stanford University, 2000.

� Y. Klugar, R. Basri, J. Chang, and M. Gerstein Spectral biclustering of microarray Data coclustering genes and conditions, Genome Research,13:703–716, 2003.

� J. Aguilar and F. Divina, Evolutionary computation for biclustering of gene expression 20th Annual ACM Symposiumon Applied Computing ,pages959–960, 2005.

� K. Bryan, P. Cunningham, and N. Bolshakova, Biclustering of expression data using simúlated annealing, IEEE Conferenceon Computer Based Medical Systems, 2005.

� Kevin.Yip,DB Seminar Series: Biclustering Methods for Microarray Data Analysis.[en linea]. Septiembre 2003.[Consultado 16 de octubre de 2010]. Disponible en internet: www.cs.wayne.edu/~shiyong/csc7710/assignments/bicluster.ppt

71

13.0 ANEXOS

Anexo Nº 1 Resultados Biclusters para cada matriz Estas son las matrices con la cual el grupo realizo las pruebas para comparar su tiempo de ejecucion y las dimenciones para comparar su orden de complejidad. A continuacion se presenta un cuadro con el bicluster encontrado por cada algoritmo.

Matriz

Bicluster encontrado por Cheng y Church

Bicluster encontrado por Samba

Bicluster encontrado


4 10 8 8 5 7 4 6 8 2 10 6

4 8 4 8 2 6

4 8 5 6 6 8

4 8 7 8 4 8 2 6

2 5 6 8 4 7 7 9 2 3 5 6 1 5 9 6

6 8 7 9

2 4 7 3 5 9 6 8

5 6 7 7 5 6 5 6

9 2 3 5.5 11 13 2 4 1 3 21 33 4 8 2 6 41 55 3 6 1.5 4.5 67 78 4 6 2 5 27 98

2 4 3 4 6 5

2 4 4 6 6 4.5

67 27

2 4 1 3 4 8 2 6 3 6 1.5 4.5 4 6 2 5

2 4 6 7 8 3 5 7 2 9 4 6 8 10 1 1 3 5 2 7 8 2 10 12 10 2 6 12 10 9

2 4 6 8 3 5 7 9 1 3 5 7

2 5 8 12 9 3

4 6 4 6 10 12 12 10

72

1 4 8 7 3

2 5 6 8 6 4 7 7 9 2 2 3 5 2 9 1 5 9 6 3 2 8 5 6 5 4 0 9 8 4 6 2 4 5 2 7 2 5 6 6

6 6 5 5

2 7 9 6 4 6

6 6 7 7 5 6 5 6

Anexo Nº 2 Funcionamiento Software BCCA Para lograr el funcionamiento del software de Interrelated Two-Way Clustering , se debe realizar un archivo .txt (los valores del archivo deben estar delimitados por TAB),en el que en el primer campo de cada fila debe contener el nombre del gen (por ejemplo , Gen1, Gen2, …,etc.), el resto de los campos son los valores de la muestra. Además cada fila debe contener el mismo número de campos y el ar chivo de entrada no debe contener ningún valor faltante. Después de tener la matriz de datos lista se debe ir al software y presionar el botón Seleccionar archivo de entrada (Select Input File)

y se escoge el archivo txt que se acabo de realizar. Luego se da clic en el botón Ingresar descripción de entrada (Enter Input Description),

73

y ahí se debe colocar el número de genes que hay en el archivo de entrada y el numero de muestras y el valor del umbral con el que se va a trabajar( El valor del umbral debe estar entre 0.1 y 0.84).

Después de esto se da clic en el botón Ingresar nombre para el archivo de salida (es decir el nombre con el que se quiere que se genere el archivo con los resultados y la ruta en la que se generará),

Después se da clic en Empezar Biclustering (Start Biclustering)

74

y allí se escoge si se quiere realizar el bicluster con solapamiento o no.

Por último se da clic en Exit y vamos a la ruta en la que se generó el archivo de salida, para observar los resultados obtenidos.

Anexo Nº 3 Calculos tiempo de ejecucion Cheng y Church public Celda [][] faseEliminacion(Celda [][]matrix){

double matResiduo[][]=null;//1

double H =0;//1

do{

H =0;//1

matResiduo= new double[matrix.length][matrix[0].length];//1

for ( int i = 0; i < matResiduo.length; i++ ){//1, 1, n-1, n-1

for ( int j = 0; j < matResiduo [ 0 ].length; j++){//n-1, n-1, n-1(m-1), n-1( m-1)

matResiduo[i][j]= calcularResiduo(i, j, matrix);//1, n*m

H += matResiduo[i][j]*matResiduo[i][j];//1,n*m

}

}

double dse = matrix.length*matrix[0].length;//1

double ds = 1/dse;//1

75

H = H* ds;//1

if (H>UMBRAL){//1

double [] vetF = new double [matrix.length];//1

double [] vetC = new double [matrix[0].length];//1

for ( int i = 0; i < vetF.length; i++){//1, 1, n-1, n-1

double suma =0;//1

for ( int j = 0; j < vetC.length; j++){//n-1, n- 1, n-1(m-1), n-1( m-1)

suma += matResiduo[i][j]*matResiduo[i][j];//1, n*m

}

vetF[i]=suma /vetC.length;//n-1

}

for ( int j = 0; j < vetC.length; j++){//1, 1, m-1, m-1

double suma =0;//1

for ( int i = 0; i < vetF.length; i++){//m-1, m-1, m-1(n-1), m-1(n-1)

suma += matResiduo[i][j]*matResiduo[i][j];//1, n*m

}

vetC[j]=suma /vetF.length;//m-1

}

int indI = indMayor(vetF);//1

int indJ = indMayor(vetC);//1

if(vetF[indI]>vetC[indJ])//1

matrix = mt.borrarFila(indI, matrix);//1

else

matrix = mt.borrarColumna(indJ, matrix);//1

}

}while(H>UMBRAL);//1

for (int x=0;x<matrix.length;x++){//1,1, n-1, n-1

for (int y=0; y<matrix[0].length;y++){//n-1, n-1, n-1( m-1), n-1(m-1)

cad1 += ""+(matrix[x][y])+" ";//1 n*m

}

cad1 +="\n";//1

}

return matrix;//1

}

///////////////////////////////////////////////////////////////////////////////// public void faseInsercion(Celda[][] matrix) {

double matResiduo[][] = null;//1

double H = 0;//1

76

do {

matResiduo = new double[matrix.length][matrix[0].length];//1

for (int i = 0; i < matResiduo.length; i++) {//1, 1, n-1, n-1

for (int j = 0; j < matResiduo[ 0].length - 1; j++) {//n-1, n-1, n-1(m-1), n-1(m-1)

matResiduo[i][j] = calcularResiduo(i, j, matrix);//n*m

H += matResiduo[i][j] * matResiduo[i][j];//1, n*m

}

}

double dse = matrix.length * matrix[0].length;//1

double ds = 1 / dse;//1

H = H * ds;//1

if (H < UMBRAL) {

double[] vetF = new double[matrix.length];//1

double[] vetC = new double[matrix[0].length];//1

for (int i = 0; i < vetF.length; i++) {//1, 1, n-1, n-1

double suma = 0;//1

for (int j = 0; j < vetC.length; j++) {//n-1, n-1, n-1(m-1), n-1(m-1)

suma += matResiduo[i][j] * matResiduo[i][j];//1, n*m

}

vetF[i] = suma / vetC.length;//(n-1)

}

for (int j = 0; j < vetC.length; j++) {//1, 1, m-1, m-1

double suma = 0;//1

for (int i = 0; i < vetF.length; i++) {//m-1, m-1, m-1(n-1), m-1(n-1)

suma += matResiduo[i][j] * matResiduo[i][j];//1, n*m

}

vetC[j] = suma / vetF.length;//(m-1)

}

int indI = indMayor(vetF);//1

int indJ = indMayor(vetC);//1

if (vetF[indI] < vetC[indJ]) {

matrix = mt.insertarFila(matrix);//1

} else {

matrix = mt.insertarColumna(matrix);//1

}

}

mostrarMatriz(matrix, H);//1

} while (H < UMBRAL);

}

El tiempo de ejecución para el método faseInsercion es: T(n)= 28+ 13(n-1)+ 5(m-1)+ 5(n*m)+ 8(nm-n-m+1)

77

El tiempo de ejecución para el método faseInsercion es: T(n)= 24+ 7(n-1)+ 5(m-1)+ 4(n*m)+ 6(nm-n-m+1) El tiempo de ejecución de los métodos o faces críticas de la aplicación T(n)=52+20(n-1)+ 10(m-1)+ 9(n*m)+ 14(nm-n-m+1) T(n)= 52+20(n-1)+ 10(m-1)+ 9nm+ 14(nm-n-m+1) T(n)= 52+20n-20+10m-10+9nm+14nm-14n-14m+14 T(n)=36+6n-4m+23nm Para calcular el orden de complejidad partiendo del tiempo de ejecución, sabemos que por la regla de la de suma esta dado por:

O(n)=O(1)+O(n)+O(m)+O(n*m) Finalmente el orden es: O(n)= O(n*m)

Anexo Nº 4 Calculos tiempo de ejecucion SAMBA

public void agregarItem(ArrayList arr ,string cadena)

{

string agregar = ""; //1

for (int i = 0; i < arr.Count; i++) //1,1,n-1,n-1

{

if(agregar!=""){//1

agregar += " ; {" + (string)arr[i] + "}";//n-1

}else{

agregar += "{" + (string)arr[i] + "}";

}

}

listBox1.Items.Add(cadena+agregar);//1

}

El tiempo de ejecución del método agregarItem es:

T(n)= 5+3(n-1)=5+3n-3

T(n) = 3n+2

//////////////////////////////////////////////////////////////////////////////

public ArrayList metodoUnion(ArrayList arr, ArrayList b){

ArrayList retorno = new ArrayList();//1

78

ArrayList list; //1

for (int i = 0; i < b.Count; i++)//1,1,n-1,n-1

{

list = new ArrayList();//1

for (int j = 0; j < arr.Count; j++)//1*(n-1), 1*(n-1), (n-1)(m-1), (n-1)(m-1)

{

Vertice vert = (Vertice)arr[j];//m-1

if (((string)b[i]).Contains(vert.get_numero()))//(n-1)*1= (n-1)

{

list.Add(grafo.retornaTotal((string)b[i]));// 1*(6+n+2mn)(n-1)

}else{

list.Add(grafo.retornaTotal((string)b[i] + "-" + vert.get_numero()));

}

}

grafo.quicksort(list, 0, list.Count - 1);//(n-1)*(na+n*log*nb)

retorno.Add(list[list.Count - 1]);//1

}

return retorno;//1

}

El tiempo de ejecución de metodoUnion:

T(n)= 7+5(n-1)+(m-1)+ 2(mn-m-n+1)+ (6+n+2mn)(n-1)+(n-1) * (na+n*log*nb)

T(n)= 2mn2 +n2+8n+2+(n-1) * (na+n*log*nb)

//////////////////////////////////////////////////////////////////////////////

public ArrayList UnionFinal(ArrayList arr, ArrayList b)

{

ArrayList retorno = new ArrayList(); //1

for (int i = 0; i < b.Count; i++) //1,1,n-1,n-1

{

string sp = ((string)arr[i]).Split('=')[0]; //n-1

string [] split = ((string)sp).Split('-'); //1

string g =(string) b[i]; //n-1

for (int j = 0; j < split.Length; j++)//1*(n-1), 1*(n-1), (n-1)(m-1), (n-1)(m-1)

{

string vert = split[j];//m-1

if (!(((string)b[i]).Contains(vert)))//n-1

{

if (g != "")//n-1

{

g += vert;//n-1

}

else

{

79

g += "-" + vert;

}

}

}

retorno.Add(g);//n-1

}

return retorno;//1

}

Tiempo de ejecución del método UnionFinal:

T(n)=5+9(n-1)+ (m-1)+2(mn-m-n+1)

T (n) = 7n-m+2mn-3

//////////////////////////////////////////////////////////////////////////////

public ArrayList metodoResta(ArrayList b)

{

ArrayList retorno = new ArrayList();//1

ArrayList list; //1

for (int i = 0; i < b.Count; i++)//1,1,n-1,n-1

{

list = new ArrayList();//1

string []cadenaB = ((string)b[i]).Split('-');//n-1

for (int j = 0; j < cadenaB.Length; j++)//(n-1),(n-1),(n-1)(m-1),(n-1)(m-1)

{

string cadena = "";//1

for (int k = 0; k < cadenaB.Length; k++ )// (m-1), (m-1), (m-1)(d-1),

(m-1)(d-1) {

if(k!=j){//(m-1)(d-1)

if(cadena!=""){//1

cadena += "-"+cadenaB[k];//d-1

}else{ //La opción else no se hace , porque el peor caso es que entre al IF, ya

que tendría que ejecutar mas sentencias

cadena +=cadenaB[k];

}

}

}

list.Add(grafo.retornaTotal(cadena));//(m-1)(3n+4m+4)=3mn+4m2+4m-3n-4m-

4= 4m2+3mn-3n-4

}

grafo.quicksort(list, 0, list.Count - 1);//(n-1)(na+n*log*nb)

retorno.Add(list[list.Count - 1]);//1

}

return retorno;//1

}

El tiempo de ejecución de metodoResta:

T(n)=9+5(n-1)+2mn-2m-2n+2+2md-2m-d+1+(d-1)+4m2+3mn-3n-4+(n-1)(na+n*log*nb)

80

T(n)=9+5n-5+2mn-2m-2n+2+2md-2m-d+1+d-1+4m2+3mn-3n-4+(n-1)(na+n*log*nb)

T(n)=4m2+5mn-4m+2md+2+(n-1)(na+n*log*nb)

//////////////////////////////////////////////////////////////////////////////

Métodos involucrados de la clase grafo

public ArrayList grafosMasPesados(int cantidad, ArrayList grafoW)

{

ArrayList retorno=new ArrayList(); //1

quicksort(grafoW, 0, grafoW.Count - 1); //1,

for (int i = 0; i < cantidad; i++) // 1,1,n-1,n-1

{

retorno.Add(grafoW[grafoW.Count - 1 - i]);//n-1

}

return retorno;//1

}

El tiempo de ejecución para el método grafosMasPesados es:

T(n)=5+3(n-1)= 5+3n-3

T(n)=3n+2

//////////////////////////////////////////////////////////////////////////////

public Vertice buscarVertice(string vertice)

{

for (int i = 0; i < vertices.Count; i++)// 1,1,n-1,n-1

{

Vertice vert=(Vertice)vertices[i]; //n-1

if(vert.get_numero()==vertice){ //1*1=1

return vert; // 1

}

}

return null; //1

}

El tiempo de ejecución para el método buscarVertice es:

T(n)=4+ 3(n-1)=4+3n-3

T(n)=3n+1

//////////////////////////////////////////////////////////////////////////////

public string procesoInterseccion(string [] arr)

{

ArrayList comunes = new ArrayList();//1

for (int i = 0; i < arr.Length; i++)//1,1,n-1,n-1

{

string cadena="";//1

81

if(arr[i].Contains('c')){//n-1

Vertice vertice=buscarVertice(arr[i]);//n-1

ArrayList arcos = vertice.get_arc();//1*1=1

for (int j = 0; j < arcos.Count; j++)//(n-1),(n-1),(n-1)(m-1),(n-1)(m-1)

{

Vertice destino = ((Arco)arcos[j]).getDestino();//(m-1)*1 =m-1

if (cadena=="")//1

{

cadena +=destino.get_numero();//m-1*1=m-1

}else{

cadena+="-"+destino.get_numero();

}

}

if (cadena != "")//1

{

comunes.Add(cadena);//1

}

}

}

string v = retornarV(comunes);//1*(6+5n-m+2mn)= 6+5n-m+2mn

return v;//1

}

El tiempo de ejecución porcesoInterseccion es:

T(n)=10+6(n-1)+2(m-1)+ 2(mn-m-n+1)

T(n)= 10+6n-6+2m-2+2mn-2m-2n+2

T(n)=4+4n+2mn

/////////////////////////////////////////////////////////////////////////////

public string retornarV(ArrayList list){

string retorno = "";//1

if(list.Count>=2){//1

string []vertices=((string)list[0]).Split('-'); //1

for (int i = 0; i < vertices.Length; i++ )//1,1,n-1,n-1

{

string evaluar = vertices[i];//n-1

bool intersecta = false; //1

for (int j = 1; j < list.Count; j++)//(n-1),(n-1),(n-1)(m-1),(n-1)(m-1) {

string evaluarOtro=(string)list[j];//m-1

if (evaluarOtro.Contains(evaluar))//n-1

{

intersecta = true; //1

}

else

{

82

intersecta = false;

}

}

if(intersecta){//1

if(retorno==""){//1

retorno += evaluar;//n-1

}else{

retorno += "-" + evaluar;

}

}

}

}

return retorno; //1

}

El tiempo de ejecución del método retornarV es: T(n)=12+7(n-1)+(m-1)+2(mn-m-n+1) T(n)= 6+5n-m+2mn

//////////////////////////////////////////////////////////////////////////////

public string [] retornaVertices(string cadena)

{

string retorno = cadena.Split('=')[0]; //1

return retorno.Split('-'); //1

}

El tiempo de ejecución del método retornaVertices es : 2

/////////////////////////////////////////////////////////////////////////////

public ArrayList CalcularV(ArrayList list)

{

ArrayList b = new ArrayList();//1

for (int i = 0; i < list.Count; i++)//1,1,n-1,n-1

{

string s = ((string)list[i]).Split('=')[0];//n-1

string valor = ((string)list[i]).Split('=')[1];//n-1

string v = procesoInterseccion(retornaVertices((string)list[i]));//(4+4n+2mn)(2)(n-

1)= 8n2+4mn2-4mn-8

if (v != "")//8n2+4mn2-4mn-8

{

string[] ve = v.Split('-');//1

for (int j = 0; j < ve.Length; j++)//(n-1),(n-1), (n-1)(m-1), (n-1)(m-1)

{

if (!s.Contains(ve[j]))//m-1

{

s += "-" + v;//1

83

}

}

}

b.Add(s);//1

}

return b;//1

}

El tiempo de ejecución método CalcularV es:

T(n)= 7+4(n-1)+(m-1)+2(8n2+4mn2-4mn-8)+ 2(mn-m-n+1)

T(n)= 16n2+4mn2+2n-m-12

//////////////////////////////////////////////////////////////////////////////

public ArrayList CalcularVA(ArrayList list){

ArrayList b = new ArrayList();//1

for (int i = 0; i < list.Count; i++)//1,1,,n-1,n-1

{

string s= ((string)list[i]).Split('=')[0];//n-1

string valor = ((string)list[i]).Split('=')[1];//n-1

string v = procesoInterseccion(retornaVertices((string)list[i]));//(4+4n+2mn)(2)(n-

1)= 8n2+4mn2-4mn-8

if (v != "")

{//8n2+4mn2-4mn-8

string [] ve=v.Split('-');//1

for (int j = 0; j < ve.Length; j++ ) //(n-1),(n-1), (n-1)(m-1), (n-1)(m-1)

{

if (!s.Contains(ve[j]))//m-1

{

s += "-" + v;//1

}

}

}

s +="="+valor;//1

b.Add(s);//1

}

return b;//1

}

El tiempo de ejecución metodo CalcularVA es:

T(n)=8+5(n-1)+(m-1)+2(mn-m-n+1)+2(8n2+4mn2-4mn-8) T(n)=16n2+8n2+8mn2-6mn+3n-m-7

///////////////////////////////////////////////////////////////////////////////

Métodos involucrados de la clase arco

84

public double getPeso()

{

return peso; //1

}

El tiempo de ejecución del método getPeso es: 1

////////////////////////////////////////////////////////////////////////

Métodos involucrados de la clase Vertice

public Vertice(string numero)

{

this.numero = numero; //1

}

public ArrayList get_arc()

{

return arcos; //1

}

public string get_numero()

{

return numero; //1

}

public void agregarrArco(Vertice destino, double peso){

arcos.Add(new Arco(this, destino, peso)); //1

}

}

}

T(n) del método agregarItem: T(n)= 5+3(n-1)=5+3n-3= 3n+2 T(n) del método metodoUnion: T(n)= 2mn2 +n2+8n+2+(n-1) * (na+n*log*nb) T(n) del método UnionFinal: T(n)=7n-m+2mn-3 T(n) del método metodoResta: T(n)= 4m2+5mn-4m+2md+2+(n-1)(na+n*log*nb) T(n) del método CalcularV: T(n)= 16n2+4mn2+2n-m-12 T(n) del método CalcularVA: T(n)= 16n2+8n2+8mn2-6mn+3n-m-7 Nota: los métodos; metodoUnion y metodoResta realizan llamados al método quicksort, a continuación presentamos la forma como se calculo el tiempo de ejecución para dicho método. El tiempo de ejecución del método quicksort es: T(n)= 2T(n/2)+bn Por lo tanto: n=2 � 2a+2b n=4 �4a+4b+4b= 4a+8b n=8 � 8a+6b+8b= 8a + 24b Donde:

85

8a= d=n 24b= c

� c= nr1

� c= nlog2n

n=

r1= log2n T(n)= na + n*log2*nb Por lo tanto el orden de complejidad seria: O(nlog2n) Finalmente para obtener el tiempo de ejecución total, se realiza la suma de los tiempos de ejecución de cada método: T(n)= 3n+2+16n2+4mn2+2n-m-12+16n2+8n2+8mn2-6mn+3n-m-7+2mn2 +n2+8n+2+(n-1) * (na+n*log*nb) +4m2+5mn-4m+2md+2+(n-1)(na+n*log*nb)+7n-m+2mn-3 Sumando los valores obtenemos: T(n)= 40n2 +4m2+12mn2+3mn+2md+21n-8m-16+2(n-1)(na+n*log*nb)

N c r1= c/n 1 0 0 2 2 1 4 8 2 8 24 3

Analisis y comparacion de algoritmos de biclustering

Documents

Transcript of Analisis y comparacion de algoritmos de biclustering