Appunti presi a lezione di Modelli di e-business e business intelligence

ANALISI MODELLO

Quando vogliamo analizzare un modello con degli algoritmi, i passi da fare sono:

1) Togliere missing

2) Data Cleaning: quindi correggere valori strani

3) Data Selection and Data Preparation: correggere attributi numerici --> se sono presenti

è meglio discretizzarli (passar quindi da attributo numerico ad attributo categorico)

perchè in questa maniera è più facile far previsione per valori aggregati.

Nella nostra esercitazione, per generare l'albero, useremo l'algoritmo J48 (Classify-->Filter-

->Tree-->J48).

ALGORITMI

1) Se metto "Use training set" l'algoritmo prende tutti i parametri del DB e fa la previsione.

Con Use training set sto usando lo stesso dataset per fare training e validation. In generale lo

usiamo sotto le centinaia di dati.

2) Se metto "Supplied test set" per validare il modello uso un altro dataset quindi:

per il training uso quello che sta dentro (quello già caricato), per il validation uso un altro

che carico con "Set".

3) "Cross-validation" prende le istanze, le divide in folder e usa un pezzo di queste per

far training e un altro per far validation. Itera tutto finchè non usa tutte le cartelle. E' un

punto di vista statistico. In generale lo usiamo sopra le migliaia di dati.

4) "Percentage split" specifica la % della validazione.

Usa solo una parte della validazione (in questo caso 66% che è una buona percentuale

perchè la percentuale che si usa è tra il 50 e 66%).

Nel nostro caso il 66 viene usato per fare training, il resto per fare validation. Le istanze

le decide l'algoritmo, le prende casualmente lui. In generale lo usiamo sopra le centinaia.

OSS: Conviene usare questo modello di classificazione (Percentage split) quando ne ho tanti ma

non tanti da poter usare cross validation. Se ho un db troppo grande, meglio andar con cross

validation perchè è più affidabile. Se il DB è piccolo usiamo il training set.

ANALISI ALBERO WEKA

NB: quando parliamo di analisi di un albero weka, questa è possibile farla avendo un

albero dal punto di vista “grafico” e dal punto di vista “di codice o numerico”. Nel

nostro caso ora, faremo un’analisi albero weka da codice.

Nel mio esempio utilizzo come algoritmo J48 Pruned tree applicando il CROSS VALIDATION.

Albero restituito (output sotto forma di codice):

-----------------------------------------------------------------------------------------------------

tear-prod-rate = reduced: none (12.0)

tear-prod-rate = normal

| astigmatism = no: soft (6.0/1.0)

| astigmatism = yes

| | spectacle-prescrip = myope: hard (3.0)

| | spectacle-prescrip = hypermetrope: none (3.0/1.0)

Number of Leaves : 4

Size of the tree : 7

--------------------------------------------------------------

Time taken to build model: 0 seconds

=== Stratified cross-validation ===

=== Summary ===

Correctly Classified Instances 20 83.3333 %

Incorrectly Classified Instances 4 16.6667 %

Kappa statistic 0.71

Mean absolute error 0.15

Root mean squared error 0.3249

Relative absolute error 39.7059 %

Root relative squared error 74.3898 %

Total Number of Instances 24

-----------------------------------------------------------------------------------------------------

QUINDI cosa ci vuole dire il nostro albero? Analizziamo alcune voci:

4 → Indica il numero di foglie quindi numero di regole (e cioè 4: il

Number of Leaves: nostro albero ha 4 foglie e quindi 4 regole).

Il numero di foglie sono il numero di nodi terminali dell'albero e

sono uguali al numero di regole.

Indica la grandezza dell’albero.

Size of the tree: 7→ La grandezza dell'albero è pari alla somma delle foglie + nodi. In

questo caso è grande 7.

Parametri:

1) Correctly Classified Instances: 20 83.3333 % --> istanze classificate correttamente

(questa classificazione è una

classificazione globale)

2) Incorrectly Classified Instances: 4 16.6667 % --> istanze classificate non

correttamente

NB: i parametri di sopra 1) e 2) misurano un'accuratezza.

I 4 errori (Incorrectly Classified Instances) possono esser fatti in qualsiasi caso del

calcolo dell'algoritmo. Per capire quando sono stati fatti (e quindi quanto è stato

l’algoritmo), vado nella Confusion Matrix dov’ è possibile analizzare

preciso

correttamente i dati (mette in relazione i valori reali con quelli predetti).

-----------------------------------------------------------------------------------------------------

CONFUSION MATRIX:

=== Confusion Matrix ===

a b c <-- classified as

12 1 2 | a = none

0 5 0 | b = soft

1 0 3 | c = hard

-----------------------------------------------------------------------------------------------------

Cosa ci vuol dire questa confusion matrix?

I valori sulla diagonale sono i valori corrretti, mentre quelli fuori dalla diagonale sono quelli

sbagliati (1+2+1=4).

NB: se conto i valori sbagliati fuori dalla diagonale (1+2+1=4) sono il numero di Incorrectly

Classified Instances!

Le metriche di classificazione sono: none, soft, hard.

Cosa vuol dire questa matrice?

Se leggo dalle colonne, vedo che:

colonna a: 12 istanze classificate come none, quindi classificate correttamente perché sono sulla

diagonale principale e quindi non sono errore).

colonna b: 6 istanze classificate come soft (5 sono corrette e su una c’è errore).

colonna c: 5 istanze classificate come hard (3 corrette e su due c’è errore).

Se abbiamo 100% di accuratezza (100% classificazione corretta) avremo più regole più precise.

In generale quello che ho è un bilanciamento tra il n°regole e l'accuratezza. Più regole ho, più sarà

accurato il mio sistema.

L'ideale è avere il 100% di accuratezza ma così avrò molte più regole.

l’accuratezza,

L'effetto è che se aumento creo delle regole che magari valgono solo per uno due

casi.

Quindi: la cosa migliore non è aver sempre il 100% di accuratezza.

Cosa si fa?

Devo spingere l'algoritmo a raggiungere l'accuratezza massima (e raggiungo max un valore),

raggiunta questa accuratezza avrò un sacco di parametri; una volta arrivato qui devo cercar di

ridurre le regole.

Come procedo?

La prima cosa da fare è aumentare l'accuratezza.

Per far questo uso "training set" dove ho accuratezza 91%.

Qui ho lo stesso numero di regole ma con un'accuratezza maggiore.

Quando ottengo lo stesso albero ma con accuratezza diversa (usando due algoritmi diversi) significa

che alcune volte trovo corrispondenza e altre volte no.

MODIFICHE POSSIBILI:

1) La prima cosa che posso modificare è il tipo di albero

a) "binarySplits" (tipo di albero binario) è come se riduco le regole e quindi posso commettere

degli errori. Se setto su TRUE dividerò un nodo al massimo in 2 rami, se setto su FALSE un nodo

sarà diviso in quanti rami vuoi (puoi specificarlo).

b) "Multisplits" significa che aumento le regole. Quindi albero più grande ma con meno

errori.

2) La seconda cosa è "confidenceFactor": metrica per capire quanto è valida/estendibile

una regola.

Se una confidenza di una regola è alta, significa che quella regola vale per tante

istanza. Più è alta la confidenza (valore che pongo per la generazione di una regola) più

istanze staranno utilizzando quella regola.

3) minNumObj è il numero minimo di istanze per una foglia, se lo aumento, diminuirà la

dimensione dell’albero e anche l’accuratezza; provo a settarlo su 1 (in precedenza era 2).

4) "unprunded": è un algoritmo automatico per potare l'albero (può essere true/false).

Se è false l'albero si riduce e quindi si riduce l'accuratezza. Provo a settarlo su true!

Vedo che l’accuratezza è salita al 100% ma le regole sono aumentate a 9 e questo NON VA BENE!

QUINDI: quando lancio un modello, la prima cosa che devo vedere è l'accuratezza

Globale ma nello stesso tempo non aumentare le regole che ho trovato (trade off).

Devo andar nelle righe === Detailed Accuracy By Class === e vedere la riga

della performance che a noi interessa.

Per ogni valore di target classe (nell'esempio delle lenti a contatto è la lacrimazione) la variabile

classe può assumere diversi valori.

Per capire quanto sono bravo sui singoli valori devo andare sulla matrice di confusione (Confusion

Matrix).

In questa matrice, le righe sono i valori reali delle istanze e le colonne le predizioni.

Se ho una matrice 3x3 ho diversi valori.

Perchè faccio la matrice di confusione?

devo cercar di rendere (specialmente quando opero con dataset di grosse dimensioni) indipendenti e

accurati e più casuali possibili i miei dati.

Prendo come esempio la confusion matrix di prima:

=== Confusion Matrix ===

a b c <-- classified as

12 1 2 | a = none

0 5 0 | b = soft

1 0 3 | c = hard

Per capire, come esempio prendiamo come esempio la prima riga che mi dice:

sono classificati giusti (12 perché è l’elemento che fa parte

12 su 15 (12+1+2=15) (intersezione a-a)

della diagonale). è classificato sbagliato; com’è classificato sbagliato?

1 su 15 (intersezione a-b) dei 15 che non

hanno le lenti, 1 lo sto prendendo in modo errato; quindi su 15 uno è sbagliato e lo prendo come se

ha le lenti b=soft; l’intersezione è 2 perché sui 15, 2 che hanno le lenti hard ma in realtà

2 su 15 (intesezione a-c)

fanno parte del campione di quelli che non indossano proprio le lenti.

Albero restituito (output sotto forma grafica):

Avrò:

1) 4 regole (quelle di forma rettangolari):

none(12,0), soft(6.0/1.0), hard(3.0), none(3.0/1.0)

2) 7 size (dimensione) foglie + regole. Lezione: 23 Maggio 2018

Nella lezione precedente (22 Maggio 2018) abbiamo approcciato il problema di

classificazione utilizzando weka.

Abbiamo visto che arrivati al massimo di accuratezza, si iniziano a modificare i parametri

in direzione opposta (abbassa confidenze factor, aumenta numero minimo di oggetti) si

cerca quindi quel trade-off tra dimensione e accuratezza.

Ora, usando sempre “training set”, si può capire come intervenire per ridurre le

dimensioni dell'albero. Come fare?

La prima cosa da capire è che se da un nodo ci sono due binary split.

Come seconda cosa posso vedere il numero minimo di oggetti che finisce nel nodo per

generarlo.

Se voglio ridurre le regole, setto “binarySplits” da Option a “true”. Quindi che ho fatto: dal

multisplits sono passato al binary. Come conseguenza di questa operazione ho che si

sono ridotte