MODELLI PROBABILISTICI

Classificazione di un data set di proteine con Weka

SOFIA CIVIDINI

2

INTRODUZIONE Negli ultimi due decenni si è assistito ad un aumento esponenziale nella quantità

dell’informazione o dati che è stata immagazzinata in formato elettronico. Si è

stimato che la quantità di informazione nel mondo raddoppi ogni venti mesi e che

la grandezza ed il numero dei database aumentino in modo sempre più veloce.

Questo fatto si deve soprattutto:

� all’incremento del potere e della velocità di calcolo degli attuali computer

� alla possibilità che essi hanno acquisito di avere supporti molto grandi per

immagazzinare e memorizzare anche notevoli quantità di dati

� all’introduzione di nuove tecniche che si affiancano ai tradizionali metodi

di analisi statistica e di data retrieval e che permettono di estrarre

conoscenza, cioè informazioni significative (di valore), in seguito

all’esplorazione di questi enormi volumi di dati. L’insieme di queste

tecniche prende il nome di Knowledge Discovery in DataBases o Data

Mining (anche se con il termine data mining sarebbe meglio considerare

una tappa della Knowledge Discovery in DataBases).

La Knowledge Discovery in DataBases integra vari campi di ricerca (statistica,

“pattern recognition”, machine learning, ecc.) ed è un processo analitico che è

stato progettato per esplorare dati ed estrarne conoscenza in termini di

associazioni, patterns, regole o sequenze ripetute che sono nascoste nei dati

stessi e che non sono note a priori.

CLASSIFICAZIONE.

La classificazione è forse la tecnica di Data Mining più comunemente applicata e

viene utilizzata per analizzare grandi quantità di dati in modo automatico o semi-

automatico ed estrarne conoscenza; in particolare la classificazione estrae

conoscenza a livello di variabili categoriche o classi, mentre quando si hanno

variabili numeriche o continue si parla di Previsione.

Di solito, si ha a che fare con grandi quantità di dati (commerciali, finanziari,

scientifici, clinici, ecc.) che possono anche essere:

� INCOMPLETI→ mancano delle osservazioni

� RUMOROSI→ ci sono dei valori anomali

� INCONSISTENTI→ esistono codici differenti per lo stesso item

3

� RIDONDANTI→ presenza della medesima informazione

Quindi, i dati prima di essere sottoposti a Classificazione devono prima subire

una fase di PREPROCESSING che consiste di vari passaggi:

� Data Cleaning→ i dati originali che provengono da fonti differenti vengono

ripuliti per eliminare rumore e trattare i casi di dati mancanti

� Relevance Analysis→ serve per individuare quegli attributi che non sono

rilevanti per l’analisi oppure che sono ridondanti

� Data Transformation→ in questa fase, i dati vengono generalizzati a livelli

concettuali più elevati oppure trasformati in modo da assumere valori in

determinati intervalli (normalizzazione).

Esistono due tipi di classificazione e cioè:

� CLASSIFICAZIONE SUPERVISIONATA→ in questo tipo di approccio, il

valore di Class Label di ogni tupla di dati (training sample) è noto. Si parla

di Supervised Learning.

� CLASSIFICAZIONE NON-SUPERVISIONATA→ in questo altro tipo di

approccio invece non si dispone di casi etichettati e non si conosce

nemmeno quante sono le classi o categorie da apprendere. Si parla di

Unsupervised learning o Clustering.

Nell’ambito della Classificazione Supervisionata, il processo di Data Classification

viene diviso in due fasi:

1) LEARNING→ viene costruito un modello che descrive un determinato

insieme di classi in seguito all’analisi di tuple di dati secondo i loro attributi

2) CLASSIFICATION→ il modello costruito viene utilizzato per classificare

nuovi casi

Disponendo di un data set di cui è noto, per ogni tupla di dati, il valore della class

label, si può dividere questo data set in modo che una parte venga utilizzata come

Training Set nella fase di Learning e l’altra parte venga invece utilizzata come Test

Set per verificare l’accuratezza del classificatore prima di passare alla fase di

Classification con un data set nuovo. Infatti, utilizzare gli stessi dati sia nella fase

di apprendimento che nella fase di verifica della performance di un classificatore

è molto pericoloso, perché si rischia l’overfitting, cioè di avere stime troppo

ottimistiche riguardanti la sua prestazione a livello dei nuovi casi. Esistono dei

metodi (basati sulla randomizzazione) per dividere il data set di partenza e per

stimare così l’accuratezza di un classificatore. Sono i seguenti:

4

� Cross-validation→ con questa metodica, il data set viene diviso, in modo

casuale, in k-folds, cioè in k sottoinsiemi che in maniera esclusiva vengono

utilizzati come Test Set ; il ciclo viene quindi ripetuto k volte. L’accuratezza

complessiva viene ottenuta sommando il numero dei casi correttamente

classificati nelle k iterazioni e dividendo questa somma per il numero dei

casi dell’insieme di dati iniziale.

Esempio: se viene fatta una cross-validation a 10 folds, il data set viene

diviso in 10 parti; 9 parti vengono usate come Training Set ed 1 parte come

Test Set e tutto questo viene ripetuto per 10 volte con un fold diverso ogni

volta.

� Hold Out→ in questo caso, il data set iniziale viene di solito diviso in modo

tale che 2/3 di esso vengano usati come Training Set ed il resto come Test

Set; la stima che si ottiene è di solito pessimistica in quanto viene utilizzata

una porzione dei dati fissa per ottenere il classificatore.

Esempio: si può utilizzare il 66% del data set come Training set ed il restante

34% come Test Set.

Esistono anche schemi particolari che possono migliorare la performance di un

classificatore unendo tra di loro più classificatori in modo da ottenerne uno

composto. Questi sono:

� il Bagging→ combina le classificazioni predette da modelli multipli o dallo

stesso tipo di modello per differenti learning data.

� il Boosting→ vengono assegnati dei pesi ad ogni Training Set e si

apprendono i classificatori in sequenza; il Boosting genererà una sequenza

di classificatori dove ogni classificatore consecutivo nella sequenza diventa

un “esperto” nelle osservazioni da classificare che non sono state ben

classificate da quelli precedenti ad esso; le classificazioni fatte dai diversi

classificatori possono poi essere combinate per ricavare la miglior

classificazione in assoluto.

Un classificatore può essere valutato in base a diversi parametri:

a. Accuratezza nella classificazione

b. Velocità di costruzione

c. Velocità di esecuzione

d. Robustezza (accuratezza in presenza di rumore o dati mancanti)

5

L’Accuratezza di un classificatore rappresenta la percentuale di istanze

classificate correttamente (cioè la cui classe predetta coincide con la classe reale)

sul numero totale di istanze classificate.

Esistono altri parametri che permettono di valutare un classificatore. Vediamoli

in dettaglio.

=== Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.631 0.012 0.983 0.631 0.769 negativo 0.988 0.369 0.718 0.988 0.832 positivo === Confusion Matrix === a b

6

WEKA

Weka è un “open source software” che è stato ideato dall’ Università di Waikato in

Nuova Zelanda e rappresenta un’estesa collezione di algoritmi di Machine

Learning per lavori di Data Mining. Contiene strumenti per il pre-processing dei

dati, per la classificazione e la regressione, per il clustering, per le regole di

associazione e per la visualizzazione. Per il nostro

lavoro di classificazione, abbiamo utilizzato per la

maggior parte i classificatori presenti nella versione

vecchia di Weka (3-2), mentre della versione più

recente (3-4), abbiamo usato solo due classificatori e

cioè JRip e AODE. Per analizzare il data set a

disposizione, è stato usato l’ambiente Explorer di

Weka. Experimenter invece permette di mettere a

confronto più modelli a partire da uno o più data set.

Explorer possiede un set di pannelli, ognuno dei quali

può essere adoperato per condurre un certo tipo di

lavoro; questi sono elencati sotto:

� Preprocess→ serve per importare e preparare i

dati

� Classify→ serve per applicare ai dati gli algoritmi di classificazione o i

modelli per la regressione (entrambi sono chiamati classifiers in Weka)

� Cluster → serve per fare cluster analysis

� Associate→ serve per applicare algoritmi di apprendimento delle regole di

associazione

� Select Attributes→ serve per selezionare sottogruppi di attributi per l’analisi

� Visualize→ serve per visualizzare le proprietà grafiche dei dati

Attraverso Open File nel pannello Preprocess, abbiamo caricato il nostro data set

di proteine. Il file che era in un formato .xls è stato trasformato in .csv (comma

separated values) affinchè potesse essere opportunamente riconosciuto da Weka,

che a sua volta lo trasforma in formato .arff. Inoltre, abbiamo trasformato la

classe da numerica in nominale per esigenze di software (come è spiegato

Figura 1; versione 3-2

7

successivamente nella sezione risultati). Non è stato necessario sottoporre il data

set a Preprocessing poiché non conteneva rumore o casi mancanti.

Come si può vedere dalla Figura 2, il data set ha 27 attributi di cui l’ultimo

rappresenta la classe e contiene 1746 istanze. Selezionando l’attributo PROTEIN,

nella finestra sulla destra si può notare che questa classe contiene due labels :

negativo con 895 istanze e positivo con 851 istanze; la classe è di tipo nominale

(Figura 3). Se invece selezioniamo un singolo attributo, per esempio Weight, nella

finestra sulla destra ci appaiono le informazioni statistiche che lo riguardano

come: minimo, massimo, media e deviazione standard (Figura 4).

Questo è il nostro data set con 27 attributi, l’ultimo dei quali rappresenta la classe. Il data set contiene 1746 istanze

Siamo nella sezione di Preprocess

Figura 2

8

Selezionando solamente l’attributo Proteine, che corrisponde alla classe, si vede che esistono due Labels : negativo con 895 istanze e positivo con 851 istanze.

Figura 3

Selezionando un attributo, a destra, si possono osservare le informazioni statistiche che lo riguardano come : massimo, minimo, media e deviazione standard.

Figura 4

9

Passiamo ora al pannello Classify. Weka possiede le implementazioni di tutte le

principali tecniche di learning per la classificazione e per la regressione come:

alberi di decisione, rule sets, classificatori Bayesiani, support vector machines,

logistic and linear regression, multi-layer perceptron e metodi nearest-neighbour;

contiene anche “meta-classificatori” per bagging e boosting.

In questa sezione possiamo scegliere il tipo di classificatore da utilizzare,

possiamo cambiarne eventualmente i parametri di default, applicare un certo tipo

di filtro, scegliere il tipo di metodo con cui vogliamo valutare la performance del

classificatore, ecc. (Figura 5).

Nella sezione Classify, possiamo scegliere il tipo di classificatore, cambiarne eventualmente i paramentri di default, applicare o meno un filtro, scegliere il tipo di metodo con cui vogliamo valutare la performance del classificatore, ecc.

Classificatore selezionato

Questi parametri di default di IBk possono essere variati. Noi abbiamo cambiato il valore di KNN da 1 a 2, 5 e 12.

Figura 5

10

Nella Figura 6, possiamo vedere il riquadro (Test options) dove scegliere il metodo

per valutare la performance del classificatore precedentemente selezionato. Dopo

avere fatto correre il programma per mezzo dell’opzione Start, nella finestra

grande a destra compare l’output completo del classificatore con tutti i dettagli

inerenti alla sua performance.

In Weka, esiste anche un’ulteriore opzione che permette di visualizzare gli alberi

di decisione costruiti dai classificatori che si basano su questo tipo di algoritmo

(Figura 7).

In questo riquadro, si possono selezionare i metodi con cui si vuole valutare la performance del classificatore in esame. Noi abbiamo usato la Cross-validation e il Percentage split (detto anche Hold-out).

Figura 6

11

COMMENTI AI RISULTATI WEKA

Il data set che abbiamo analizzato è di proteine ed è costituito da 27 attributi per

un totale di 1746 istanze complessive. I primi 26 attributi sono variabili che

rappresentano delle caratteristiche strutturali o chimico-fisiche delle proteine in

questione, mentre l’ultimo attributo corrisponde alla Classe nella quale possiamo

distinguere due “labels class” e cioè: -1 e +1. Per esigenze di software la classe è

stata trasformata da numerica in nominale convertendo -1 in negativo e +1 in

positivo. Inoltre, il file che contiene il data set è stato trasformato da file.xls a

file.csv (comma separated values) che è un formato riconosciuto da Weka, il quale

poi lo trasforma a sua volta in file.arff.

In Weka, esiste anche un’opzione che dà la possibilità di visualizzare l’albero di

decisione costruito dal classificatore.

Figura 7

12

Per l’analisi di classificazione sono stati utilizzati 18 classificatori presenti nella

versione 3-2 di Weka e 2 classificatori presenti nella versione 3-4 di Weka che

sono i seguenti:

Sono stati eseguiti 240 esperimenti in cui abbiamo analizzato la performance dei

vari classificatori attraverso due metodi principali e cioè:

� Cross-validation

� Hold-out

Per quanto riguarda la Cross-validation, abbiamo fatto per quasi tutti i

classificatori tre esperimenti a 10 (valore di default), 6 e 3 folds, senza e con

l’applicazione di un filtro di discretizzazione. Per l’ Hold-out, abbiamo fatto tre

esperimenti con un valore di training set pari al 66% (valore di default), all’80% e

al 50% senza il filtro di discretizzazione, mentre con l’applicazione del filtro

abbiamo fatto solo un esperimento con il valore di default. Inoltre, abbiamo fatto

prove con Cross-validation a 10 folds e Hold-out 66% aggiungendo il Bagging a

quasi tutti i classificatori considerati per cercare di migliorarne la performance.

Per DecisionStump, sono stati utilizzati anche due metaclassificatori per il

Boosting e cioè AdaBoost e LogitBoost. Altri parametri sono stati variati rispetto

a quelli di default anche per DecisionTable, IBk e NaiveBayes come verrà

spiegato poi. Qui di seguito, riportiamo solo gli esperimenti che hanno dato i

risultati migliori, mentre per gli output di tutti gli esperimenti fatti e i relativi

11. K-Star

12. Naive Bayes Simple

13. Naive Bayes

14. OneR

15. Prism

16. AODE

17. JRip

18. VFI

19. ADTree

20. SMO

1. ZeroR

2. DecisionStump

3. DecisionTable

4. HyperPipes

5. IB1

6. IBk

7. Id3

8. J48J48

9. J48Part

10. KernelDensity

13

commenti si rimanda al file “Risultati e commenti esperimenti eseguiti con Weka”

e alla Tabella riassuntiva.

ZeroR

Il Classificatore ZeroR assegna tutte le istanze alla classe di maggiore dimensione

presente nel training-set senza mai considerare gli attributi di ciascuna istanza.

Non ha molto senso usare questo schema per la classificazione, per cui gli

esperimenti eseguiti con ZeroR ci servono solo come parametro di riferimento per

la valutazione della performance dei classificatori considerati successivamente,

nel senso che non si deve mai andare sotto il valore trovato con questo

classificatore che dovrebbe rappresentare il peggior risultato possibile. Per questi

motivi viene anche detto classificatore “stupido”.

In tutti gli esperimenti eseguiti con ZeroR, questo classificatore assegna tutte le

istanze del data set (n° tot 1746) alla classe maggiormente rappresentata che nel

nostro caso è quella negativa (-1) con 895 istanze contro le 851 della positiva (+1).

La percentuale di istanze correttamente classificate da ZeroR è intorno al 51%

circa.

ZeroR cross-validation: 10 folds senza filtri Scheme: weka.classifiers.ZeroR Test mode: 10-fold cross-validation === Summary === Correctly Classified Instances 895 51.26 % Incorrectly Classified Instances 851 48.74 % Kappa statistic 0 Mean absolute error 0.4997 Root mean squared error 0.4998 Relative absolute error 100.0002 % Root relative squared error 100.0002 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 1 1 0.513 1 0.678 negativo 0 0 0 0 0 positivo === Confusion Matrix === a b

14

DecisionStump

Questa è una classe per la costruzione e l’uso di un semplice albero di decisione a

un livello binario (alberi di decisione a un livello) con un ramo extra per i valori

persi. Esso produce probabilità di classe. Fa fronte ai valori persi estendendo un

terzo ramo dall’ albero, in altre parole, trattando il valore perso come un attributo

separato. Di solito viene utilizzato insieme agli algoritmi di Boosting.

La miglior performance che abbiamo ottenuto con DecisionStump (88% di istanze

correttamente classificate) si è avuta utilizzando il metodo Hold-out 80% senza

filtro di discretizzazione ed associando il classificatore LogitBoost per il boosting.

Per gli altri esperimenti condotti con l’uso di LogitBoost, la percentuale di istanze

correttamente classificate si è mantenuta compresa tra circa l’85 e l’86%.

Usando invece AdaBoost come algoritmo di boosting, abbiamo ottenuto delle

percentuali di istanze classificate in modo corretto un po’ inferiori rispetto a

LogitBoost e cioè in media intorno all’82%, tranne nel caso di Hold-out 50% senza

filtro dove si è raggiunto il valore di 84.19%. Senza l’uso degli algoritmi di

boosting, i risultati ottenuti nei rimanenti esperimenti sono compresi tra circa

l’80.50% e l’81.90%. In linea generale, DecisionStump tende a commettere più

errori nel classificare le istanze della classe positiva. Non c’è un’ equa ripartizione

delle istanze non correttamente classificate tra le due classi negativa e positiva.

Vedi il file “Risultati e commenti esperimenti eseguiti con Weka” e la Tabella

riassuntiva.

DecisionStump+LogitBoost Hold-out: 80 % senza filtri Scheme: weka.classifiers.LogitBoost -P 100 -I 10 -W weka.classifiers.DecisionStump -- Test mode: split 80% train, remainder test === Summary === Correctly Classified Instances 308 88 % Incorrectly Classified Instances 42 12 % Kappa statistic 0.7612 Mean absolute error 0.188 Root mean squared error 0.3068 Relative absolute error 37.644 % Root relative squared error 61.4004 % Total Number of Instances 350 ______________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

15

=== Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.809 0.042 0.955 0.809 0.876 negativo 0.958 0.191 0.821 0.958 0.884 positivo === Confusion Matrix === a b

16

non correttamente classificate è stata equa tra le due classi negativa e positiva, il

che ci indica che il classificatore commette la stessa percentuale di errore nel

classificare entrambi i due tipi di proteine.

DecisionTable Hold-out: 66% con useIBk=True Scheme: weka.classifiers.DecisionTable -X 1 -S 5 -I Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 517 87.037 % Incorrectly Classified Instances 77 12.963 % Kappa statistic 0.7406 Mean absolute error 0.1822 Root mean squared error 0.3221 Relative absolute error 36.4561 % Root relative squared error 64.4549 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.864 0.122 0.884 0.864 0.874 negativo 0.878 0.136 0.857 0.878 0.867 positivo === Confusion Matrix === a b

17

HyperPipes +Bagging Hold-out: 66% senza filtro Scheme: weka.classifiers.Bagging -S 1 -I 10 -P 100 -W weka.classifiers.HyperPipes -- Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 374 62.963 % Incorrectly Classified Instances 220 37.037 % Kappa statistic 0.2385 Mean absolute error 0.4881 Root mean squared error 0.4885 Relative absolute error 97.6956 % Root relative squared error 97.752 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.981 0.748 0.585 0.981 0.733 negativo 0.252 0.019 0.923 0.252 0.396 positivo === Confusion Matrix === a b

18

IB1 cross-validation: 10 folds senza filtro Scheme: weka.classifiers.IB1 Test mode: 10-fold cross-validation === Summary === Correctly Classified Instances 1640 93.929 % Incorrectly Classified Instances 106 6.071 % Kappa statistic 0.8785 Mean absolute error 0.0607 Root mean squared error 0.2464 Relative absolute error 12.1497 % Root relative squared error 49.2945 % Total Number of Instances 1746 __________________________________________ === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.942 0.063 0.94 0.942 0.941 negativo 0.937 0.058 0.939 0.937 0.938 positivo === Confusion Matrix === a b

19

restanti esperimenti le percentuali di classificazioni corrette si mantengono

sempre superiori all’88.89%. Per questo classificatore, abbiamo provato a variare

anche il valore dei k-nearest neighbour portandolo da 1 a 2, 5 e 12; la

percentuale delle istanze correttamente classificate però è stata inferiore a quella

dei corrispondenti esperimenti con i parametri di default (tra 88.89% e 91.81%).

Anche in questo caso, l’aggiunta del Bagging non ha migliorato il risultato.

IBk cross-validation: 10 folds senza filtro

Scheme: weka.classifiers.IBk -K 1 -W 0 Test mode: 10-fold cross-validation === Summary === Correctly Classified Instances 1640 93.929 % Incorrectly Classified Instances 106 6.071 % Kappa statistic 0.8785 Mean absolute error 0.0613 Root mean squared error 0.2462 Relative absolute error 12.2615 % Root relative squared error 49.2634 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.942 0.063 0.94 0.942 0.941 negativo 0.937 0.058 0.939 0.937 0.938 positivo === Confusion Matrix === a b

20

Id3 cross-validation: 10 folds con filtro di discretizzazione Scheme: weka.classifiers.FilteredClassifier -B weka.classifiers.Id3 -F "weka.filters.DiscretizeFilter -B 10 -R first-last" Test mode: 10-fold cross-validation === Summary === Correctly Classified Instances 1392 79.7251 % Incorrectly Classified Instances 267 15.2921 % Kappa statistic 0.6773 Mean absolute error 0.1529 Root mean squared error 0.3911 Relative absolute error 32.2198 % Root relative squared error 80.2885 % UnClassified Instances 87 4.9828 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.858 0.182 0.836 0.858 0.847 negativo 0.818 0.142 0.842 0.818 0.83 positivo === Confusion Matrix === a b

21

J48J48+Bagging Hold-out: 66 % senza filtro Scheme: weka.classifiers.Bagging -S 1 -I 10 -P 100 -W weka.classifiers.j48.J48 -- -C 0.25 -M 2 Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 539 90.7407 % Incorrectly Classified Instances 55 9.2593 % Kappa statistic 0.8146 Mean absolute error 0.1558 Root mean squared error 0.2675 Relative absolute error 31.1819 % Root relative squared error 53.5343 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.906 0.091 0.915 0.906 0.91 negativo 0.909 0.094 0.9 0.909 0.904 positivo === Confusion Matrix === a b

22

Root mean squared error 0.2455 Relative absolute error 27.8759 % Root relative squared error 49.1278 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.919 0.042 0.959 0.919 0.939 negativo 0.958 0.081 0.916 0.958 0.937 positivo === Confusion Matrix === a b

23

=== Confusion Matrix === a b

24

Naive Bayes Simple

E’ un semplice classificatore Naive Bayes. Gli attributi numerici sono modellati

attraverso una distribuzione normale. Questo classificatore ha dato percentuali di

classificazioni corrette comprese tra circa l’82% e l’84%. La sua performance

migliore è pari a 84.34% ed è stata ottenuta con Hold-out 66% e filtro di

discretizzazione. In linea generale, prevalgono gli errori di classificazione a carico

delle istanze della classe positiva.

Naive Bayes Simple Hold-out: 66 % con filtro di discretizzazione Scheme: weka.classifiers.FilteredClassifier -B weka.classifiers.NaiveBayesSimple -F "weka.filters.DiscretizeFilter -R first-last" Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 501 84.3434 % Incorrectly Classified Instances 93 15.6566 % Kappa statistic 0.6896 Mean absolute error 0.158 Root mean squared error 0.3902 Relative absolute error 31.6255 % Root relative squared error 78.0727 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.718 0.021 0.974 0.718 0.826 negativo 0.979 0.282 0.763 0.979 0.858 positivo === Confusion Matrix === a b

25

solo circa 7.000-record dei data set di training e di test. Il tempo di esecuzione

dell’esperimento con l’opzione k è più lungo di quello con la distribuzione

normale, ma la correttezza è maggiore. Per quanto riguarda il classificatore Naive

Bayes, le percentuali di classificazione sono state comprese tra circa l’82 e l’84%.

La miglior performance si è ottenuta con il metodo Hold-out 66% con applicato

un filtro di discretizzazione ed è stata pari a 84.34%. Anche con il settaggio

dell’opzione Use Kernel Estimator uguale a true, i risultati non hanno mai

superato l’84%. Come per in NBS, vengono commessi più errori nel classificare le

istanze della class label positiva.

Naive Bayes Hold-out: 66 % con filtro di discretizzazione Scheme: weka.classifiers.FilteredClassifier -B "weka.classifiers.NaiveBayes " -F "weka.filters.DiscretizeFilter -R first-last" Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 501 84.3434 % Incorrectly Classified Instances 93 15.6566 % Kappa statistic 0.6896 Mean absolute error 0.158 Root mean squared error 0.3902 Relative absolute error 31.6255 % Root relative squared error 78.0727 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.718 0.021 0.974 0.718 0.826 negativo 0.979 0.282 0.763 0.979 0.858 positivo === Confusion Matrix === a b

26

Root relative squared error 77.6467 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.718 0.028 0.965 0.718 0.823 negativo 0.972 0.282 0.762 0.972 0.854 positivo === Confusion Matrix === a b

27

PRISM

Per usare Prism è sempre necessario utilizzare il filtro di discretizzazione;

considera solo attributi numerici. Gli esperimenti condotti con Prism senza

l’applicazione del Bagging hanno dato tutti pessimi risultati in quanto questo

classificatore non è mai stato in grado di classificare tutte le istanze (dal 4.50 al

5.61% di istanze non classificate). Questo problema è stato risulto con l’uso del

Bagging che ha migliorato notevolmente la performance di Prism permettendogli

di classificare tutte le istanze del data set con una percentuale di istanze

correttamente classificate pari all’85.39% come massimo valore raggiunto con la

Cross-validation a 10 folds e filtro di discretizzazione. Prism commette una

percentuale di errore maggiore nel classificare le istanze della class label negativa.

Prism cross-validation: 10 folds con filtro di discretizzazione Scheme: weka.classifiers.FilteredClassifier -B weka.classifiers.Prism -F "weka.filters.DiscretizeFilter -R first-last" Test mode: 10-fold cross-validation === Summary === Correctly Classified Instances 1447 82.8751 % Incorrectly Classified Instances 217 12.4284 % Kappa statistic 0.7385 Mean absolute error 0.1243 Root mean squared error 0.3525 Relative absolute error 26.0936 % Root relative squared error 72.2342 % UnClassified Instances 82 4.6964 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.937 0.201 0.829 0.937 0.88 negativo 0.799 0.063 0.925 0.799 0.858 positivo === Confusion Matrix === a b

28

=== Summary === Correctly Classified Instances 1491 85.3952 % Incorrectly Classified Instances 255 14.6048 % Kappa statistic 0.7062 Mean absolute error 0.1639 Root mean squared error 0.3243 Relative absolute error 32.7929 % Root relative squared error 64.8739 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.955 0.253 0.799 0.955 0.87 negativo 0.747 0.045 0.941 0.747 0.833 positivo === Confusion Matrix === a b

29

Root relative squared error 64.4837 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.783 0.04 0.954 0.783 0.86 negativo 0.96 0.217 0.808 0.96 0.878 positivo === Confusion Matrix === a b

30

VFI

Classificazione attraverso voting feature intervals. Gli intervalli sono costruiti

intorno a ciascuna classe per ciascun attributo. I calcoli della classe sono

registrati per ogni intervallo su ogni attributo. La classificazione avviene

attraverso votazione. E’ stato aggiunto un semplice schema per pesare gli

attributi. Il peso maggiore è assegnato agli intervalli più confidenti, dove la

confidenza è una funzione dell’entropia. I valori percentuali della performance di

VFI nel classificare le istanze in modo corretto sono compresi tra un minimo di

circa 77% ed un massimo di 84%; quest’ultimo valore è stato ottenuto con il

metodo Hold-out 66% più filtro di discretizzazione e Bagging. Il Bagging ha

migliorato solo dello 0.5% la performance di VFI rispetto al corrispondente

esperimento senza, quindi il miglioramento della performance è dovuto più che

altro al filtro di discretizzazione (negli esperimenti con Hold-out 66% senza e con

filtro, l’uso del filtro migliora la performance di VFI del 4.55%).

VFI+Bagging Hold-out: 66 % con filtro di discretizzazione Scheme: weka.classifiers.FilteredClassifier -B "weka.classifiers.Bagging -S 1 -I 10 -P 100 -W weka.classifiers.VFI -- -B 0.6" -F "weka.filters.DiscretizeFilter -R first-last" Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 499 84.0067 % Incorrectly Classified Instances 95 15.9933 % Kappa statistic 0.6823 Mean absolute error 0.3465 Root mean squared error 0.3873 Relative absolute error 69.3435 % Root relative squared error 77.4918 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.74 0.052 0.938 0.74 0.828 negativo 0.948 0.26 0.772 0.948 0.851 positivo === Confusion Matrix === a b

31

ADTree

Negli esperimenti condotti con il classificatore ADTree, fin tanto che non abbiamo

usato il Bagging, abbiamo ottenuto dei valori percentuali di istanze classificate

correttamente compresi tra 81.71% e 85.86%. Con l’utilizzo del Bagging invece, la

performance di questo classificatore ha raggiunto un valore massimo di 88.05%

con il metodo Hold-out 66% senza filtro di discretizzazione; in questo esperimento

diminuisce anche la percentuale degli errori commessi nel classificare le istanze

della class label positiva.

ADTree+Bagging Hold-out: 66 % senza filtro Scheme: weka.classifiers.Bagging -S 1 -I 10 -P 100 -W weka.classifiers.adtree.ADTree -- -B 10 -E -3 Test mode: split 66% train, remainder test === Summary === Correctly Classified Instances 523 88.0471 % Incorrectly Classified Instances 71 11.9529 % Kappa statistic 0.762 Mean absolute error 0.2279 Root mean squared error 0.3082 Relative absolute error 45.6139 % Root relative squared error 61.6669 % Total Number of Instances 594 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.808 0.042 0.954 0.808 0.875 negativo 0.958 0.192 0.823 0.958 0.885 positivo === Confusion Matrix === a b

32

Cross-validatione 3 folds e filtro di discretizzazione. Anche per questo

classificatore non c’è una distribuzione omogenea delle istanze non classificate

correttamente tra le due class labels.

SMO cross-validation: 3 folds con filtro di discretizzazione Scheme: weka.classifiers.FilteredClassifier -B "weka.classifiers.SMO -C 1.0 -E 1.0 -A 1000003 -T 0.0010 -P 1.0E-12" -F "weka.filters.DiscretizeFilter -R first-last" Test mode: 3-fold cross-validation === Summary === Correctly Classified Instances 1517 86.8843 % Incorrectly Classified Instances 229 13.1157 % Kappa statistic 0.738 Mean absolute error 0.2117 Root mean squared error 0.3159 Relative absolute error 42.3746 % Root relative squared error 63.1943 % Total Number of Instances 1746 === Detailed Accuracy By Class === TP Rate FP Rate Precision Recall F-Measure Class 0.839 0.1 0.898 0.839 0.868 negativo 0.9 0.161 0.842 0.9 0.87 positivo === Confusion Matrix === a b

33

� ogni istanza corrisponde ad un punto n-dimensionale

� il “vicinato” di una nuova istanza (punto) è costituito dalle k-istanze (punti)

del training set che sono meno distanzi da essa

� dipende dalla funzione di distanza che è stata scelta, per esempio distanza

Euclidea

� sempre per quanto riguarda la distanza, se gli attributi sono nominali, si

assegna 0 se i valori sono uguali, 1 se i valori sono differenti, mentre se gli

attributi sono numerici, si fa

una differenza

� l’apprendimento è veloce in

quanto il Training set è solo

memorizzato; sono detti anche

classificatori “lazy” in Weka.

Tabella che mostra le migliori performance di classificazione di tutti i classificatori considerati e il modo con cui sono state ottenute.

CLASSIFICATORE Metodo usato Percentuale di istanze correttamente classificate

IB1 C.V. 10folds 93.93% IBk C.V. 10folds 93.93% J48Part Hold Out 66%+Bagging 93.77% KernelDensity C.V. 10folds 93.64% K-Star C.V. 10folds 93.07% J48J48 Hold Out 66%+Bagging 90.74% ADTree Hold Out 66%+Bagging 88.05% DecisionStump Hold Out 80%+LogitBoost 88% JRip Hold Out 66% 87.20% DecisionTable Hold Out 66% ; Use IBk True 87.04% AODE C.V. 10folds+Bagging+Filtro 86.94% SMO C.V. 3folds+Filtro 86.88% Prism C.V. 10folds+Bagging+Filtro 85.39% Naive Bayes Simple Hold Out 66%+Filtro Discretize 84.34% Naive Bayes Hold Out 66%+Filtro Discretize 84.34% VFI Hold Out 66%+Bagging+Filtro 84% OneR Hold Out 50% 81.21% HyperPipes Hold Out 66%+Bagging 62.96% ZeroR Hold Out 66% 51.85% Id3 - presenza di istanze non classificate