Middleware per la bioinformatica: implementazione dell ...home.deib.polimi.it/chicco/davide_chicco_relazione_prova_finale... · 2.3 Integrazione del grafico ... l'approccio divisivo

24 luglio 2007 Anno Accademico 2006 2007

Universita' di GenovaFacolta' di Scienze Matematiche Fisiche Naturali

Corso di Laurea in Informatica

Middleware per la bioinformatica: implementazione dell'Algoritmo dei

Distanti per il clustering dei dati nell'ambiente OpenAdap.net

Prova finale di laurea triennale

Candidato: Davide CHICCO ( [email protected] )

Relatori: Francesco MASULLI (Disi – Dipartimento d'Informatica e Scienze dell'Informazione, Universita' di Genova)

Stefano ROVETTA (Disi – Dipartimento d'Informatica e Scienze dell'Informazione, Universita' di Genova)

Correlatori: Javier IGLESIAS (Universita' di Losanna, Svizzera)

AlessandroVILLA (Universita' di Grenoble, Francia)

1


Indice

1. Abstract..................................................................................pagina 32. Introduzione.......................................................................................4

2.1 L'algoritmo dei distanti...........................................................42.2 Integrazione dei grafici delle distanze

tra i punti in output.................................................................42.3 Integrazione del grafico del dendrogramma

del cluster in output...............................................................52.4 OpenAdap.net.......................................................................62.5 Tipi di dato.............................................................................7

3. Soluzioni e scelte effettuate..............................................................83.1 Xml e XY Viewer......................................................................83.2 Graphviz..................................................................................8

4. Organizzazione e costi......................................................................85. Lavoro svolto.....................................................................................9

5.1 Stato dell'arte...........................................................................95.1.1 Il clustering gerarchico.................................................105.1.2 L'algoritmo dei distanti.................................................10

5.2 Implementazione del programma...........................................125.2.1 I grafici delle distanze tra i punti in output...................125.2.2 Il grafico del dendrogramma del cluster in output.......165.2.3 L'uso del programma su OpenAdap.net.....................22

5.3 Breve studio sui tipi di dato....................................................265.3.1 Xml......................................................................275.3.2 Sqlite...................................................................275.3.3 Miame.................................................................28

6. Conclusioni e sviluppi futuri.............................................................286.1 OpenAdap.net, un progetto solo all'inizio...............................28

7. Bibliografia.......................................................................................288. Ringraziamenti.................................................................................29

2


1. Abstract

Il presente lavoro si propone di studiare, analizzare ed integrare nel middleware OpenAdap.net il programma "Farthest Shared Neighbor approach to data clustering" (Algoritmo dei Distanti per il clustering dei dati) sviluppato da Francesco Masulli e Stefano Rovetta e pubblicato su Pattern Recognition nel 2006. [1]Il programma, chiamato FncPortable, e' stato esteso con la possibilita' di stampare in output i dati in formato xml, in modo da creare un documento visualizzabile attraverso NHRG XYViewer, un software disponibile sul portale NeuralCoding.org (all'interno del progetto OpenAdap.net). La scelta di questo sofware e' stata consigliata dai Alessandro Villa (Universita' di Grenoble, Francia) e Javier Iglesias (Universita' di Losanna, Svizzera), ideatori e gestori del portale OpenAdap.net. E' stata inoltre aggiunta la possibilita' di stampare in output il grafico del dendrogramma generato dal programma, ossia un documento .dot utilizzabile con Graphviz [http://www.graphviz.org], un software open source consigliato da Javier Iglesias.

Il programma e' stato poi inserito sul portale Disi.OpenAdap.net [http://disi.openadap.net], la versione del Disi di OpenAdap.net,, e successivamente sara' inserito anche su Inns Sig on Bioinformatics (International Neural Network Society Special Interest Group on Bioinformatics) [http://bioinformatics.disi.unige.it], la versione dedicata alla bioinformatica di OpenAdap.net,Il suddetto portale potra' essere arricchito in futuro con altri programmi dedicati alla bioinformatica.

Oltre al lavoro sull'algoritmo, vi e' stata anche un'approfondita analisi dei tipi di dato utilizzati nella comunita' bioinformatica internazionale, con particolare riguardo alle parti riguardanti il clustering, di cui qui vengono riportate le parti piu' importanti.

3


2. Introduzione

2.1 L'algoritmo dei distanti

Gli algoritmi di clustering (lett.: "raggruppamento") sono strumenti fondamentali nella bioinformatica, e si dividono principalmente in due categorie: quelli di tipo "partitivo" e quelli di tipo "gerarchico agglomerativo", ognuno di essi con i suoi derivati. [2]Questi due differenti approcci posseggono comunque alcuni svantaggi di tipo pratico nelle loro caratteristiche: l'approccio divisivo non e' utilizzabile nei casi di dati di grandi dimensioni, mentre l'approccio gerarichico agglomerativo spesso presenta alcuni problemi a causa della sua struttura "bottomup".

Per superare questi ostacoli, l'Algoritmo dei Distanti si basa sulla possibilita' d'analizzare "il punto vicino condiviso piu' lontano", ossia nel considerare due punti come "simili" se il punto piu' distante dal primo e' lo stesso piu' distante dal secondo.

2.2 Integrazione dei grafici delle distanze tra i punti in output

Il programma fornito dai relatori e' stato modificato in modo da creare, in esecuzione, un file in formato .xml visualizzabile con il software XY Viewer [http://jiglesia.alawa.ch/wormhole/xyviewer/ ], un'applicazione java disponibile sul sito NeuralCoding.org che, preso in input un file xml con un'apposita formattazione, genera grafici bidimensionali (XY).

Il file in output puo' essere aperto con XY Viewer e permette di visualizzare, per ogni punto in input, le distanze dagli altri punti.

4


Fig.1 Esempio di distanze del punto 1 rispetto agli altri (i punti sono etichettati con le lettere dell'alfabeto in ordine crescente, A=1, B=2, ecc)

2.3 Integrazione del grafico del dendrogramma del cluster in output

E' stata inoltre aggiunta la possibilita' di generare in output un documento .dot che contiene i dati per la visualizzazione del dendrogramma generato dal clusterizzazione dei punti con Graphviz, un programma open source.

Fig. 2 Il sito di Graphviz.org

5


Fig.3 Il dendrogramma risultante dal raggruppamento dei punti in un esempio

2.4 OpenAdap.net

Il programma realizzato e' stato poi inserito su Disi.OpenAdap.net, la versione del portale OpenAdap del Disi, e successivamente sara' poi anche inserito nel portale Inns Sig on Bioinformatics, portale dedicato alla bioinformatica all'interno del progetto OpenAdap.NetOpenAdap.net e' un socialware open source con lo scopo di rompere le barriere esistenti nel flusso dei dati. L'infrastruttura rende possibile la condivisione di risorse quali conoscenza, strumenti o dati, e la loro esposizione alla valutazione in modi che potrebbero essere imprevisti, e quindi supportare lo sviluppo di comunita' d'utenti intorno ad uno specifico tema o dominio [3].

Con il termine inglese "middleware" si intende un insieme di programmi informatici che fungono da intermediari tra diverse applicazioni. Sono spesso utilizzati come supporto per applicazioni distribuite complesse. I software utilizzati possono anche essere più di uno.Nel caso di OpenAdap, un programma viene implementato e poi messo come middleware su un broker, che fungera' da tramite tra utente e server dove saranno custoditi i dati.In informatica, per broker s'intende in un software che serve da “ponte” tra due oggetti, tipicamente un client ed un server.

L'utente si connettera' al portale, selezionera' un programma tra quelli disponibili, immettera' i dati in input, attendera' che il server processi il job del suo programma, ed infine salvera' i dati in output.

6


Fig.4 Uno schema dell'architettura di OpenAdap

L'architettura e' progettata in analogia con un sistema operativo distribuito virtuale nel quale le risorse dinamiche sono presentate come files in un file system strutturato virtualmente, che consente la possibilita' d'inserire ownership e permessi d'accesso.

I broker di OpenAdap sono responsabili per quanto riguarda la decomposizione dinamica e l'instradamento delle operazioni dell'utente finale verso approppriati spazi condivisori di risorse che s'occuperanno dell'esecuzione. La comunicazione interbroker ha lo scopo d'essere adattabile a se stessa attraverso processi d'apprendimento che possono dare vita alla specializzazione modificabile di connessioni brokerbroker o alla generalizzazione del comportamento del broker, ecc.Le dinamiche nonlineari che emergono dall'approccio scelto dal Neuroheuristic Research Group rendono OpenAdap.net piu' vicino alla complessita' d'un organismo vivente ed il socialware beneficiera' della completa gamma di avanzamenti realizzati nei campi del calcolo cognitivo e dell'intelligenza computazionale.

2.5 Tipi di dato

Per quanto riguarda il formato di dati standard usato in bioinformatica, la situazione al giorno oggi e' ancora molto variegata e non esiste un unico formato identificabile come scelta obbligata. Nella comunita' internazionale sono spesso diffusi formati molto mal definiti e basati su plaintext, anche se molto lentamente negli ultimi anni si stanno facendo sforzi per passare ad xml. Inoltre, a volte capita che perfino i database piu' importanti siano pieni di file che non rispettano gli stessi standard in cui dovrebbero essere espressi.

In questo lavoro, s'e' concentrata l'attenzione su 3 scelte possibili abbastanza diffuse:● xml (eXtensible Markup Language); [http://xml.html.it/]● Sqlite (una libreria C che implementa un Database Management System Sql che puo' essere

incluso all'interno di varie applicazioni); [http://www.sqlite.org/]● Miame (Minimum Information About a Microarray Experiments tipo di dato molto diffuso per

gli esperimenti sui microarray); [http://www.mged.org/Workgroups/MIAME/miame.html]

7


Per quanto concerne le tecnice di raggruppamento gerarchico per la costruzione d'alberi filogenetici, il discorso si fa piu' lungo e complesso. Tuttavia si puo' concentrare l'attenzione su:

● Fasta (formato tra i piu' diffusi per le sequenze di Dna/Rna o proteiche); [http://www.ebi.ac.uk/fasta/]

● Embl e Genbank (formati che servono per descrivere informazioni su geni) [http://www.bioperl.org/wiki/EMBL_sequence_format]

● Phypip [http://evolution.genetics.washington.edu/phylip.html] e Clustal [http://www.ebi.ac.uk/clustalw/ ] (formati per gli allineamenti di piu' sequenze);

3. Soluzioni e scelte effettuate

3.1 Xml e XY Viewer

Il programma FncPortable permette, tra le altre cose, di stampare a video tutti i dati del calcolo delle distanze di ogni punto rispetto agli altri, attraverso una matrice che descrive le distanze tra di essi e una matrice che indica, per ogni punto, l'elenco dei punti in ordine di raggruppamento secondo l'algoritmo dei distanti.

Il bisogno di poter visualizzare i risultati di tipo non prettamente testuale generati dal programma FncPortable ha portato alla necessita' d'integrare il programma originale con una parte dedicata alla stampa in output d'un file in formato xml, che possa essere aperto e visualizzabile con il software XY Viewer.La scelta di questo programma e' stata consigliata dai professori Alessandro Villa e Javier Iglesias, a causa della sua disponibilita' sul portale NeuralCoding.org, la versione del portale OpenAdap.net dedicata alle neuroscienze.

3.1 Graphviz

Usando il comando “grep cluster” nel lancio di FncPortable, e' possibile visualizzare l'albero un albero di tipo testuale che rappresenta il dendrogramma dei clusters usati nel raggruppamento dei punti. Tuttavia questa rappresentazione ad albero non rende bene l'idea del dendrogramma generato dall'algorirmo.Per la rappresentazione del dendrogramma in questione non e' stato possibile utilizzare XY Viewer, perche' l'implementazione d'un plotter per i dendrogrammi in xml sarebbe stata un processo troppo complesso e lungo da implementare. Il professor Javier Iglesias ha cosi' consigliato d'utilizzare il programma Graphviz (Graph Visualization Software), un software open source creato apposta per la rappresentazione di alberi, diagrammi, reti e molto altro che usa un linguaggio di programmazione proprio e molto semplice e permette di realizzare grafici molto precisi.

4. Organizzazione e costi

8


I costi e l'organizzazione del lavoro svolto per questo progetto di laurea triennale si possono suddiviere (in base alle ore ed alla fatica per le parti svolte) nel seguente modo:

A) Studio del formato, del funzionamento ed estensione per XY Viewer 30%B) Studio del formato, del funzionamento ed estensione per Graphviz 43%C) Studio del funzionamento di OpenAdap.net 17%D) Scrittura documetazione 10%

Totale: 100%

Sia per XY Viewer, sia per Graphviz, e' stato necessario prima un attento studio del formato dei documenti per il programma in questione, poi uno studio del funzionamento ed infine l'estensione nel programma originale della parte relativa alla stampa in output del documento per la visualizzazione grafica dei risultati.

5. Lavoro svolto

L'entita' del lavoro svolto per questa elaborazione mi ha obbligato ad una lunga parte di studio e comprensione della teoria e delle tecniche usate in bioinformatica, in particolare quelle riguardanti il clustering (gerarchico, non gerarchico, divisivo, agglomerativo, supervisionato, non supervisionato).Queste tecniche riguardano il cosiddetto “stato dell'arte” al momento in cui ho iniziato a lavorare su questo progetto.Dopo questa attenta analisi, ho svolto la parte d'implementazione del codice per la rappresentazione grafica dei dati in output.Infine c'e' stata la descrizione e lo studio dei risultati ottenuti

5.1 Stato dell'arte

9

XY ViewerGraphvizOpenAdapDocumentazione


5.1.1 Il clustering gerarchico

Il clustering (lett.: “raggruppamento”) e' una tecnica molto usata in bioinformatica che permette di raggruppare punti (o geni, o qualsiasi altro elemento) con simili caratteristiche in gruppi (“cluster”).Piu' precisamente, clustering significa partizionare un insieme di dati in piu' sottoinsiemi tali che i dati in ogni sottoinsieme condividono certi tratti comuni (ad esempio la vicinanza, in accordo con delle misurazioni di distanze definite).Un algoritmo di clustering puo' essere gerarchico oppure partizionale.Lo schema gerarchico trova i cluster successivi utilizzando le informazioni di raggruppamento precedentemente salvate; lo schema partizionale invece permette di determinare tutti i cluster in un operazione sola.

Un algoritmo di clustering puo' essere altresi' agglomerativo o partizionale.Il modello agglomerativo parte dall'analisi d'ogni singolo elemento considerandolo all'inizio come un cluster per poi unirlo ad altri elementi / cluster per arrivare alla fine ad avere un unico raggruppamento (approccio bottomup).Il modello divisivo invece parte da un unico cluster d'elementi per poi dividerlo in successivi cluster / sottoinsiemi di dimensioni piu' piccole.

5.1.2 L'algoritmo dei distanti

I due differenti approcci (agglomerativo e divisivo) posseggono comunque alcuni svantaggi di tipo pratico nelle loro caratteristiche: l'approccio divisivo non e' utilizzabile nei casi di dati di grandi dimensioni, mentre l'approccio gerarichico agglomerativo spesso presenta alcuni problemi a causa della sua struttura "bottomup".

Per superare questi ostacoli, l'Algoritmo dei Distanti si basa sulla possibilita' d'analizzare "il punto vicino condiviso piu' lontano", ossia nel considerare due punti come "simili" se il punto piu' distante dal primo e' lo stesso piu' distante dal secondo. Definiamo questo come il principio dei “punti in prospettiva”, dato che questi punti sono esaminati senza alcun riferimento alla loro vicinanza locale, bensi' in riferimento ai punti lontani nel sottoinsieme, e quindi in prospettiva.

Ecco un esempio chiarificatore.Abbiamo 4 punti:(1) 1.2 3.7(2) 2.9 3.5(3) 0.5 3.7(4) 2.6 0.6

10


Fig.5 La rappresentazione cartesiana dei punti

Data points | 1 | 2 | 3 | 4 |

1st neighbor | 3 | 1 | 1 | 2 |2nd neighbor| 2 | 3 | 2 | 3 |3rd neighbor | 4 | 4 | 4 | 1 |

Raggruppando i punti secondo il principio dei “punti in prospettiva” , tutti i punti che condividono lo stesso punto piu' lontano sono messi nel cluster di livello 1. Cosi' un cluster al primo livello e' definito come l'insieme dei punti che, nella tabella qui sopra, hanno lo stesso valore nell'ultima riga (ad es.: punto 1, punto 2 e punto 3.

Si procede poi salendo di livello nella matrice e guardando sempre i punti all'interno del cluster che hanno lo stesso valore (in questo caso i punti 1 e 3 all'interno del primo cluster hanno lo stesso valore 2 come punto piu' lontano condiviso, e saranno quindi raggruppati.La procedura viene cosi' ripetuta all'interno della matrice fino a quando i punti all'interno del cluster non hanno piu' valori in comune.

Fig.6 Immagine dei cluster dell'esempio sovracitato rappresentati mediante insiemi

11


5.2 Implementazione del programma e ricerca sui tipi di dato

5.2.1 I grafici delle distanze tra i punti in output

Il programma FncPortable permette, tra le altre cose, di stampare a video tutti i dati del calcolo delle distanze di ogni punto rispetto agli altri, attraverso una matrice che descrive le distanze tra di essi e una matrice che indica, per ogni punto, l'elenco dei punti in ordine di raggruppamento secondo l'algoritmo dei distanti.

Fig. 7 Matrice che descrive le distanze d'un punto rispetto agli altri

Fig. 8 Matrice che descrive, per ogni punto, l'elenco dei punti vicini in ordine di distanza

Il bisogno di poter visualizzare i risultati di tipo non prettamente testuale generati dal programma FncPortable ha portato alla necessita' d'integrare il programma originale con una parte dedicata alla stampa in output d'un file in formato xml, che possa essere aperto e visualizzabile con il software XY Viewer.E' stato quindi necessario un attento studio del formato in Xml adatto per la rappresentazione dei grafici con XY Viewer. Questo software e' disponibile su NeuralCoding.org

L'idea di base del formato di XY Viewer e' quella di assegnare ad ogni figura o grafico da visualizzare una “classe” di attributi e caratteristiche che ne definiscano le proprieta'.Lo schema di base e' il seguente:

[...]<figures> <figure>

<attributes> <attribute name="class">nome_qualsiasi</attribute>

[...]

12


</attribute>[...]

</attributes><plots>

<plot><data>[data] [data] [data] [data] </data>

</plot>[...]

</plots>[...] </figure>[...] </figures>[...]

Ossia, dopo aver definito le opzioni iniziali del documento xml, si definiscono via via le figure che si vogliono disegnare (<figure>). All'interno d'ognuna di esse si definiscono gli attributi, per poi descrivere all'interno del tag <plot> l'elenco dei dati (i punti) da visualizzare sul grafico.

Per far tutto questo e' stato necessario all'interno del codice di FncPortable aggiungere la stampa in output verso il file “graphics.xyvz” di tutte le parti necessarie a rendere il documento formattato per XY Viewer.La parte “standard” uguale per tutti, quella che fungera' da header del documento, viene stampata sempre. Poi per ogni punto viene fatto un cliclo for() che permette di stampare per ogni punto X un grafico contenente i segmenti rappresentanti le distanze del punto X dagli altri punti:

// START TO BUILD THE XML FILE

FILE* fp1 = fopen("graphics.xyvz", "w");

fprintf(fp1,"<?xml version=\"1.0\" encoding=\"ISO88591\" standalone=\"yes\"?>\n<gallery version=\"1.0\">\n <frames>\n<frame>\n<attributes>\n<attribute name=\"title\">intervals</attribute>\n</attributes>\n<figures>\n");

int q = 1;int g = 1;

for(k=1;k<=np;k++){ // NUMERO DI PUNTI FIGURE

fprintf(fp1,"<figure>\n<attributes>\n<attribute name=\"title\">distanze del punto %d rispetto agli altri punti</attribute>\n<attribute name=\"class\">nhrg:returnintervals</attribute>\n</attributes>\n<axes>\n<axis name=\"1\">\n<attributes>\n<attribute name=\"title\">asse x</attribute>\n<attribute name=\"unit\"></attribute>\n</attributes>\n</axis>\n<axis name=\"2\">\n<attributes>\n<attribute

13


name=\"title\">asse y</attribute>\n<attribute name=\"unit\"></attribute>\n </attributes>\n</axis>\n</axes>\n<plots>\n<plot>\n<data tuple=\"2\" axes=\"1 2 \">\n", k);

for(i=1;i<=ni;i++) fprintf(fp1,"%lf ",(x[k][i])); // STAMPA LE DUE COORDINATE DEL PUNTO

// SCORRIAMO SUI PUNTI ADIACENTI for(q=1;q<=np;q++){

// SE PER IL PUNTO CHE STIAMO ESAMINANDO NON E' X SE STESSO, E' UN ADIACENTE AD X

if(q!=k) { for(i=1;i<=ni;i++) fprintf(fp1,"%lf ",(x[q][i])); }// STAMPA LE DUE COORDINATE DEL PUNTO ADIACENTE }fprintf(fp1,"</data>\n</plot>\n</plots>\n</figure>\n");}fprintf(fp1,"\n</figures>\n</frame>\n</frames>\n</gallery>\n"); fclose(fp1);

// END OF THE XML FILE

Il risultante file, chiamato “graphics.xyvz”, sara' a questo punto pronto per essere visualizzato con XY Viewer.Per fare questo, e' sufficiente collegarsi al sito NeuralCoding.org, visitare la sezione “Spike train analysis”, visitare la sezione “Tools” e a questo punto scegliere l'applicazione NHRG XY Viewer nella lista d'applicazioni.

Fig 9 XY Viewer

14


A questo punto e' sufficiente lanciare il programma cliccando su “Launch now”. Una volta lanciato, dal menu di XY Viewer occorrera' aprire il nostro file “graphics.xyvz”.Il file verra' aperto pero' con la formattazione standard, e quindi visualizzera' i nostri grafici come segmenti collegati l'uno all'altro. Dovremo a questo punto caricare la lo stile di “Star plotter” per poter visualizzare i segmenti come distanze da un punto.Per fare questo, bisognera' cliccare con il tasto destro su un grafico, dal menu' a tendina selezionare la voce “null” plot, e successivamnte “Edit Style”.Dal menu a finestra successivo, occorre selezlionare la voce “Star Plotter” come mostrato in figura:

Fig. 10 Star plotter

A questo punto il grafico risultante sara' esattamente quello desiderato perche' mostrera' le distanze del punto in questione rispetto agli altri punti:

15


Fig.11 Le distanze del primo punto dell'esempio precente rispetto agli altri punti (le etichette sono assegnate ai punti in ordine alfabetico crescente, A=1, B=2, ecc)

5.2.2 Il grafico del dendrogramma del cluster in output

Il programma FncPortable permette, tra le altre cose, di stampare a video l'albero dei cluster risultanti dal raggruppamento dei punti secondo l'algoritmo utilizzato.Usando comando grep cluster, e' possibile visualizzare il suddetto albero in modo testuale.Un esempio e' visualizzato in figura.

Fig 12 I cluster in questo caso sono stati rappresentati come nodi etichettati da cifre che corrispondono con la prima lettera al cluster del livello superiore (1.1.1 ed 1.1.2 faranno parte di 1.1)

Il bisogno di poter visualizzare il dendrogramma dei cluster generato dal programma FncPortable ha

16


portato alla necessita' d'integrare il programma originale con una parte dedicata alla stampa in output d'un file che potesse rappresentarle la figura desiderata in un linguaggio relativamente semplice.

Su consiglio del professore Javier Iglesias dell'Universita' di Losanna, s'e' scelto d'utilizzare Graphviz, un software open source molto diffuso nella comunita' internazionale per il disegno di dendrogrammi e grafici di svariati tipi attraverso documenti in formato .dot

L'idea di base del formato di Graphviz e' quella di contenere dentro ad un campo “digraph A {....}” tutte le opzioni (con i relativi parametri) e tutti i nodi del cluster.Lo schema di base e' il seguente:

digraph nome_grafo{

[opzioni;]

// ELENCO NODI PRESENTIprimo_nodo [opzioni];secondo_nodo [opzioni];terzo_nodo [opzioni];[...]

// ELENCO ARCHI TRA NODIprimo_nodo > secondo_nodo [opzioni_arco];primo_nodo > terzo_nodo [opzioni_arco];terzo_nodo > ottavo_nodo [opzioni_arco];[...]

}

Dopo aver definito le opzioni iniziali del grafico (come ad esmpio l'ordine di scrittura da sinista a destra oppure dall'alto verso il basso, la posizione all'interno del documento, ecc), si definiscono via via i nodi chesi vogliono disegnare uniti alle opzioni proprie del nodo (come ad esempio il tipo di rappresentazione per il nodo, ecc). Infine vengono elencati gli archi tra i nodi scrivendo i nomi dei due nodi coinvolti nell'arco uniti dall'operatore “>”, seguiti ognuno dalle opzioni dell'arco (ad esempio lo spessore, il punto di partenza all'interno dell'arco, ecc).

Per far tutto questo e' stato necessario all'interno del codice di FncPortable aggiungere la stampa in output verso il file “graphics.dot” di tutte le parti necessarie a rendere il documento formattato per Graphviz, in modo che potesse rappresentare il dendrogramma risultante dalle operazioni di clustering effettuate sui dati in input secondo l'algoritmo dei distanti.

La creazione del dendrograma a partire dall'albero di tipo testuale generato dal programma s'e' rivelata decisamente complessa ed impegnativa. Alla fine una soluzione funzionale e' stata trovata anche se forse non puo' essere considerata ottimale a livello di costo computazionale.Per comodita', s'e' scelto di dare il nome “cluster 0” al nodo radice.

17


Prima di tutto e' stato necessario salvare i dati provenienti dai nomi dei nodi coinvolti in una matrice d'interi che permettesse la diversificazione dei diversi livelli di raggruppamento. Ad esempio la stampa in output del nome 1.1.2, ci da' l'informazione che il suddetto nodo dovra' essere collegato al nodo 1.1 che a sua volta verra' collegato al nodo 1.

La matrice d'interi generata di dati utilizzati per l'albero nella figura 11 sara' la seguente:

Fig 13

Gli zeri sono da interpretare come assenza di nodo oppure “fine di nome di nodo”.La matrice conterra' nella parte sinistra tutte i nodi dell'albero del cluster secondo la seguente modalita':– la prima colonna sara' sempre di zeri;– la seconda colonna conterra' i nodi d'altezza 1, riconoscibili perche' separati da zeri (quindi 1, 2,

3); – la terza colonna conterra' i nodi d'altezza 2, riconoscibili perche' separati da zeri (quindi 1.1 ed

1.2)– la quarta colonna conterra' i nodi d'altezza 3, riconoscibili perche' separati da zeri (quindi 1.1.2 ed

1.1.2)

Lo schema ovviamente puo' contenere piu' livelli di questo esempio. E quindi in generale:– la ennesima colonna conterra' i nodi d'altezza n1, riconoscibili perche' separati da zeri.

A partire dall'analisi di queste colonne, potremmo ottenenere diverse informazioni sul grado di profondita' dell'albero e sulla quantita' di figli per ogni nodo.Guardando la matrice dell'esempio, si nota subito che la quarta colonna e' l'ultima a contenere nodi. La profondita' massima dell'albero risultante sara' allora 3.

Inoltre, per ogni colonna, contando il numero di stringhe d'interi separate da stringhe di zeri o caratteri

18


zero, e' possibile identificare il numero di nodi che saranno presenti ad ogni livello. Analizando il nome del nodo infine, sara' possibile capire di chi sara' figlio (ad esempio 1.1.2 sara' figlio di 1.1 che ha sua vola sara' figlio di 1).

La prima necessita' fondamentale diventa allora quella di capire la profondita' a cui si trovano i nodi foglia. Per fare questo abbiamo bisogno di alcune iterazioni atte a capire quale sia, all'interno della matrice “mat” vista in Fig.12, la prima colonna da sinistra verso destra a non contenere alcun nodo. Il numero della colonna sara' la profondita' del nostro albero.

for(q2=1; q2<DIM && count_col==0; q2++) { // COLONNE for(w=1; w<DIM; w++){ // RIGHE

if(mat[w][q2]==0 && count_col != 1) count_col = q2; else if(mat[w][q2]!=0) count_col = 1;

}if(count_col==q2) break; // count_col CONTERRA' LA PROFONDITA'else count_col = 0;

}

In base poi al grado di profondita' dell'albero, s'e' deciso per comodita' di salvare i dati dei nodi in base alla loro etichetta come numeri interi rappresentanti l'etichetta stessa.Dato che il livello di profondita' in questo caso era 3, Il nodo 1.1.2 ad esempio, e' stato salvato come 112 (centododici), mentre il nodo 2 come 200.Se il livello di profondita' fosse stato 4, avremmo rappresentato il nodo 1 come 1000, il nodo 1.2 come 1200, il nodo 2.1.2 come 2120 ed il nodo 1.2.1.2 come 1212.

Per fare questo, a seconda del numero di colonna in cui si trova un elemento (che come dimostrato e' anche l'altezza del nodo in questione), s'e' moltiplicato per una potenza di 10 corrispondente all'altezza.

for(q2=0; q2<DIM; q2++) {for(w=0; w<DIM; w++)

{ if(mat[w][q2]!=0)

{ pot = count_col q2 1;// pot = q2 ;var2 = pow(10.0, pot);var=mat[w][q2]*var2;//printf(" %d ", var);

res[cont] = var;cont++;

}

19


}

}

A questo punto, con tutti i dati salvati nel vettore “res[]”, e' stato necessario discriminare all'interno di quest'ultimo i vari nodi attraverso il loro valore, per cosi' capire quale sia il livello d'ognuno di loro.Questa informazione e' gia' immagazzinata all'interno del nodo stesso in base al suo valore, dato che in base a come e' stato salvato il vettore dei nodi ad esempio il nodo 200 sara' di livello 1, mentre il nodo 120 di livello 2, ed il nodo 111 di livello 3.

I valori contenuti all'interno del vettore res[] saranno quindi salvati in altri vettori contenenti nodi dello stesso livello:

for(w=0; w<DIM; w++){// MIGLIAIA (COME AD ES. 1000, 2000, 3000)if( (res[w]%1000) == 0 && (res[w]!=1)) { mi[count_pos_ce] = res[w]; count_pos_mi++; }

// CENTINAIA (COME AD ES. 100, 200, 300)else if( (res[w]%100) == 0 && (res[w]!=1)) { ce[count_pos_ce] = res[w]; count_pos_ce++; }

// DECINE (COME AD ES. 10, 20, 30)else if( (res[w]%10) == 0 && (res[w]!=1)) { de[count_pos_de] = res[w]; count_pos_de++; }

// UNITA' (COME AD ES. 1, 2, 3)else if( (res[w]!=1)) { un[count_pos_un] = res[w]; count_pos_un++; }}

Nel caso in cui non vi siano elementi di livello piu' alto, vengono promossi d'un livello gli elementi del livello successivo. Ad esempio, nel caso non ci siano migliaia, come nell'esempio che stiamo seguendo nella Fig. 12, le centinaia vengono promosse a livello 1.

Successivamente vanno sistemati i valori da assegnare ai nodi per la rappresentazione nel dendrogramma: gli elementi di livello piu' alto, come nell'esempio i nodi 100, 200, 300, sono gia' pronti per rappresentare dei nodi; mentre i valori contenuti nel vettore delle decine devono ancora essere trasformate per rappresentare i nodi come centinaia. Lo stesso per le unita'.

Nel nostro caso ad esempio, ìl vettore delle decine conterra':10 10 10 20che, per rappresentare i nodi 1.1 ed 1.2, andranno trasformati in 110 e 120.

A questo punto, sistemati i valori da stampare nel vettore tot[], possiamo finalmente stampare il documento “graphics.dot”, che ci permettera' di visualizzare il dendrogramma dell'albero dei clusters.

20


All'inizio del documento, dovremo dichiarare i nodi con le realtive opzioni.Dato che i valori come multipli di 10 servono limitatamente ai calcoli per la costruzione del dendrogramma, sul documento sciveremo le etichette dei nodi come 1, 11, 112.

fprintf(fp7," 0 [shape=box, label=\"cluster 0\"];\n\n");for(w=0; w<DIM; w++){if(tot[w]!=1){

// MIGLIAIAif(tot[w] %1000 == 0) fprintf(fp7," %d [shape=box, label=\"cluster %d\"];\n\n", tot[w]/1000,

tot[w]/1000); // CENTINAIAelse if(tot[w] %100 == 0) fprintf(fp7," %d [shape=box, label=\"cluster %d\"];\n\n", tot[w]/100,

tot[w]/100); // DECINEelse if(tot[w] %10 == 0) fprintf(fp7," %d [shape=box, label=\"cluster %d\"];\n\n", tot[w]/10,

tot[w]/10); // UNITA'else fprintf(fp7," %d [shape=box, label=\"cluster %d\"];\n\n", tot[w], tot[w]);

}}

Dopo le dichiarazioni, occorre stampare i restanti nodi, uniti dal simbolo “>” che' esprime il collegamento tra i due nodi. Ogni nodo dovra' quindi essere collegato ai suoi figli, ossia ai nodi di livello piu' basso rispetto a lui e, a livello x, aventi i caratteri iniziali da 1 ad x1 della sua etichetta uguali.Ad esempio, al ivello 2 il nodo 100 sara' connesso ai nodi 110 e 120 che hanno il primo carattere (in questo caso 1) uguali al nodo 100.Al livello 3 invece, il nodo 110 sara' connesso ai nodi 111 e 112 che hanno i primo ed il secondo carattere (1 ed 1) uguali al nodo 110.

Cosi' i valori memorizzati come centinaia, vengono connessi a quelli memorizzari come decine oppurtunamente divisi per potenze di 10:

[...]for(w=0; w<DIM; w++){if((tot[w] % 1000 != 0) && (tot[w] % 100 == 0) && (tot[w]!=1))

{for(q2=0; q2<DIM; q2++)

{

if( (tot[q2]!= tot[w]) && (tot[q2] % 1000 != 0) && (tot[q2] % 100 != 0) && tot[q2]>tot[w] && tot[q2]<tot[w]+100)

{

21


fprintf(fp7," %d > %d [arrowsize=0.0];\n\n", tot[w]/100, tot[q2]/10);}

}}

}[...]

Lo stesso viene fatto per le migliaia (se ce ne sono), per le decine e per le unita'.

A questo punto il file “graphics.dot” e' pronto per essere processato con Graphviz e creare il dendrogramma desiderato.Per usare Graphviz con il nostro file, occorre digitare da shell console il comando:

$> dot Tps graphics.dot o graphics.ps

Il quale generera' un dcumento in postScript, che potra' essere aperto con qualsiasi postScript reader, come ad esempio kpdf su Kubuntu.Il risultato sara' il seguente:

Fig 14

5.2.3 L'uso del programma su OpenAdap.net

OpenAdap, come gia' detto, e' un progetto che si propone di creare e gestire dei portali dedicati alla scienza congnitiva dove siano disponibili software, programmi e tool pronti all'utilizzo da parte di utenti qualsiasi e di utenti specializzati.L'idea di base e' quella d'implementare un middleware che viene messo su un broker che collega un server all'utente finale. In questo modo l'utente puo' connettersi al portale, selezionare il programma

22


che gli serve, immettere i dati e salvare i risultati.

Il programma qui trattato, FncPortable, e' stao integrato sul portale Disi.OpenAdap.net, ovvero la versione di OpenAdap dedicata al Disi.Per accedere al programma, e' sufficiente collegarrsi al sito Disi.OpenAdap.net:

Fig 15

Nel menu a sinistra, possiamo leggere le voci “Manage jobs”, che servira' a seguire lo status online del processo che ci interessa, e “Submit a job”, dove invieremo i dati per il nostro processo.Clicchiamo dunque su “Submit a job”:

23


Fig 16

Successivamente, dopo aver inserito il file .trn contenente i punti da analizzare, aver settato i valori della profondita' , il numero di connessioni ed tipo di distanza, potremo cliccaresu “Submit and manage” per permettere al middleware d'inziare il processo.Da qui verremo portati ad un'altra pagina che ci informera' sullo status del job che abbiamo lanciato:

24


Fig 17

Una volta completato il processo (flag dello status con la V verde, come in Fig 17), possiamo finalmente scaricare i file in output e analizzarne i dati.Per scaricare i file in output, dovremo cliccare sulla cartella sotto la voce “Actions”;

25


Fig 18

A questo punto sara' possibile scaricare i file “graphics.xyvz” e “graphics.dot”.Il file “graphics.xyvz” sara' visualizzabile con XY Viewer, come descritto nella sezione 5.2.1Il file “graphics.dot” sara' visualizzabile con Graphviz, come descritto nella sezione 5.2.2

Una pagina web contenente le spiegazioni ed un caso d'esempio e' stata messa online all'indirizzo http://bioinformatics.disi.unige.it

5.3 Breve studio sui tipi di dato

Per quanto riguarda il formato di dati standard usato in bioinformatica, la situazione al giorno oggi e' ancora molto variegata e non esite un unico formato identificabile come scelta obbligata. Nella comunita' internazionale sono spesso diffusi formati molto mal definiti e basati su plaintext, anche se molto lentamente negli ultimi anni si stanno facendo sforzi per passare ad xml. Inoltre, a volte capita che perfino i database piu' importanti siano pieni di file che non rispettano gli stessi standard in cui sono messi.

In questo lavoro, s'e' concentrata l'attenzione su 3 scelte possibili abbastanza diffuse:a) xml (eXtensible Markup Language), un linguaggio di programmazione simile all'Html che si sta

molto diffondendo tra gli standard internazionalib) Sqlite (una libreria C che implementa un Database Management System Sql che puo' essere

incluso all'interno di varie applicazioni);

26


c) Miame (Minimum Information About a Microarray Experiments tipo di dato molto diffuso per gli esperimenti sui microarray);

5.3.1 Xml

L'uso del linguaggio di programmazione Xml nella bioinformatica e' forse la strada piu' promettente per trovare uno standard applicabile in generale.Come abbiamo visto nel “file graphics.xyvz” nella sezione 5.2.2, scritto in xml, questo linguaggio si puo' rivelare molto versatile e pronto all'applicazione in molti campi.Molto simile all'Html, Xml rimane un linguaggio molto semplice da utilizare e studiare: si possono definire strutture dati aprendo con un tag contenuto tra parentesi acute (<nome_tag>) una serie di altri tag che conterranno dati relativi alla struttura dati in questione.Una volta terminato l'elenco dei campi della struttura dati, occorre chiudere il tag aggiungendo il carattere / (nell'esempio, </nome_tag>).La semplicita' e l'intuitivita' di Xml ha portato ad una sua grande diffusioneanche nel'ambiente dì bioinformatico.

5.3.2 Sqlite

SQLite e' un Database Management System relazionale contenuto in una libreria C abbastanza piccola. [http://www.sqlite.org/]A differenza dei database management systems di tipo clientserver, Sqlite non e' un processo standalone con il quale il programma in questione comunica: la libreria Sqlite e' linkata ad esso e cosi' diventa una parte integrante del programma, Il programma usa le funzionalita' di Sqlite attraverso semplici chiamate di funzione. Questo riduce la latenza dell'accesso al database perche' le chiamate di funzione sono piu' efficienti rispetto alla comunicazione tra processi..

L'intera base di dati (definizioni, tabelle, indici, ed i dati) sono immagazzinati come una singola piattaforma in un host. Questo semplice design e' realizzato bloccando il file dell'intero database all'inizio della tarnsazione

Fig. 19

La libreria Sqlite e' molto usata in bioinformatica soprattutto a causa delle sue dimensioni molto piccole (il pacchetto e' circa 250 KB) e della velocita' con cui puo' essere utilizzata.Inoltre e' molto apprezzati perche', a differenza di Dbms come MySql, non richiede installazione ed e' molto semplice da usare (Un esempio: [http://www.shigen.nig.ac.jp/] ).

27


5.3.3 Miame

Miame (trad.: Informazione Minima Su un Esperimento su Microarray) e' un tipo di dato standard per la registrazione dei dati degli esperimenti su microarray. [http://www.mged.org/Workgroups/MIAME/miame.html]Miame nasce con l'intento di specificare tutte le informazioni necessarie per interpretare i risultati dell'esperimento in modo disambiguo e (potenzialmente) per poter riprodurre lo stesso esperimento in differenti laboratori.

L'ultima versione, la 2.0, offre notevoli vantaggi, tra cui le informazioni relative a:1. I dati finali processati per la l'insieme di ibridizzazioni nell'esperimento2. L'annotazione essenziale che include i fattori dell'esperimento ed i loro valori3. Il design sperimentale che inlcude le relazioni tra i dati4. I protocolli essenziali per il processamento dei dati

6. Conclusioni e sviluppi futuri

6.1 OpenAdap.net, un progetto solo all'inizio

Il portale OpenAdap.net, descritto brevemente in questa relazione, e' un progetto che sta muovendo i suoi primi passi in questi anni. L'idea di base di questo progetto e' quella di rendere sicure, accessibili ed efficienti il numero piu' alto possibile di risorse software per ricercatori, professori studenti e chiunque ne abbia bisogno.OpenAdap.net si propone anche come modello per la realizzazione di portali dedicati alle piu' svariate comunita' di scienziati. Oggi e' gia' possibile visualizzare la versione per le neuroscienze, ossia NeuralCoding.org, che dispone al suo interno tools ed applicazioni pronte all'uso.

I progetti Bioinformatics.disi.unige.it e Disi.OpenAdap.net sono invece agli inizi, e vedranno la propria evoluzione ed il proprio sviluppo nei prossimi anni.

7. Bibliografia

[1] F.Masulli, S.Rovetta, “The shared farthest neighbor approach to clustering of high dimensionality, low cardinality data”, 2006, Pattern Recognition 39 (2006) 2415 2425

[2] A.Jain, M.Murty, P.Flynn, Data clustering: a review, ACM Comput. Sur. 31 (3) – (1999) 264323

[3] A.Villa, J.Iglesias, “OpenAdap.net: evolvable information processing environment”, 2007, Wilf 2007 International Workshop on Fuzzy Logic and Applications.

28


8. Ringraziamenti

Si desidera ringraziare il Neuroheuristic Research Group del prof Alessandro Villa, per l' importante e gentilissima collaborazione

Un ringraziamento speciale al dr Javier Iglesias, per l'aiuto, il supporto e la pazienza durante questi ultimi mesi e soprattutto per il lavoro svolto nella gestione di OpenAdap.

29

Documents

Middleware per la bioinformatica: implementazione dell ...home.deib.polimi.it/chicco/davide_chicco_relazione_prova_finale... · 2.3 Integrazione del grafico ... l'approccio divisivo