Tecniche di base II: Insiemi di regole e Tecniche instance based

Classificazione II
Prof. Matteo Golfarelli
Alma Mater Studiorum - Università di Bologna
Classificazione: Definizione
Data una collezione di record (training set )
Ogni record è composto da un insieme di attributi, di cui uno
esprime la classe di appartenenza del record.
Trova un modello per l’attributo di classe che esprima il valore
dell’attributo in funzione dei valori degli altri attributi.
Obiettivo: record non noti devono essere assegnati a una
classe nel modo più accurato possibile
Viene utilizzato un test set per determinare l’accuratezza del
modello. Normalmente, il data set fornito è suddiviso in training
set e test set. Il primo è utilizzato per costruire il modello, il
secondo per validarlo.
I classificatori possono essere utilizzati sia a scopo descrittivo
sia a scopo predittivo
Sono più adatti ad attributi nominali (binari o discreti) poichè
faticano a sfruttare le relazioni implicite presenti negli attributi
ordinali, numerici o in presenza di gerarchie di concetti (es.
scimmie e uomini sono primati)
2
Classificazione: un esempio
Tid
Attrib1
1
Yes
Large
Attrib2
125K
Attrib3
No
Class
2
No
Medium
100K
No
3
No
Small
70K
No
4
Yes
Medium
120K
No
5
No
Large
95K
Yes
6
No
Medium
60K
No
7
Yes
Large
220K
No
8
No
Small
85K
Yes
9
No
Medium
75K
No
10
No
Small
90K
Yes
Tid
Attrib1
11
No
Small
55K
?
12
Yes
Medium
80K
?
13
Yes
Large
110K
?
14
No
Small
95K
?
15
No
Large
67K
?
Learn
Model
10
Attrib2
Attrib3
Class
Apply
Model
10
3
Applicazioni
Predire se una cellula tumorale è benigna o maligna in
base alle sue caratteristiche
Classificare se una transazione con
carta di credito sia o meno fraudolenta
Classificare le strutture proteiche secondarie in alphahelix, beta-sheet, or random
coil
Classificare le news in base
all’argomento:finanza, meteo, sport,
intrattenimento, ecc.
4
Tecniche di classificazione
Alberi decisionali o Decision Tree
Regole di decisione
Nearest-neighbor
Reti Bayesiane
Reti neurali
Support Vector Machines
5
Classificatori basati su regole
Classificano i record utilizzando insiemi di regole del tipo
“if…then…”
Una regola ha la forma: (Condizione) → y
dove
• Condizione è una congiunzione di predicati su attributi
• y è l’etichetta di classe
LHS: antecedente o condizione
RHS: conseguente o etichetta della classe
Esempi di regole:
• (Blood Type=Warm) ∧ (Lay Eggs=Yes) → Birds
• (Taxable Income < 50K) ∧ (Refund=Yes) → Evade=No
Costruire un modello significa identificare un insieme di regole
6
Vantaggi e svantaggi
Espressivi quanto un Decision Tree
Facili da interpretare
Facili da generare
Rapidi nella classificazione di nuove istanze
Il costo di costruzione non scala al crescere
del training set
Risentono fortemente del rumore sui dati
7
Classificatori basati su regole
Name
human
python
salmon
whale
frog
komodo
bat
pigeon
cat
leopard shark
turtle
penguin
porcupine
eel
salamander
gila monster
platypus
owl
dolphin
eagle
Blood Type
warm
cold
cold
warm
cold
cold
warm
warm
warm
cold
cold
warm
warm
cold
cold
cold
warm
warm
warm
warm
Give Birth
yes
no
no
yes
no
no
yes
no
yes
yes
no
no
yes
no
no
no
no
no
yes
no
Can Fly
no
no
no
no
no
no
yes
yes
no
no
no
no
no
no
no
no
no
yes
no
yes
Live in Water
no
no
yes
yes
sometimes
no
no
no
no
yes
sometimes
sometimes
no
yes
sometimes
no
no
no
yes
no
Class
mammals
reptiles
fishes
mammals
amphibians
reptiles
mammals
birds
mammals
fishes
reptiles
birds
mammals
fishes
amphibians
reptiles
mammals
birds
mammals
birds
r1: (Give Birth = no) ∧ (Can Fly = yes) → Birds
r2: (Give Birth = no) ∧ (Live in Water = yes) → Fishes
r3: (Give Birth = yes) ∧ (Blood Type = warm) → Mammals
r4: (Give Birth = no) ∧ (Can Fly = no) → Reptiles
r5: (Live in Water = sometimes) → Amphibians
8
Classificatori basati su regole
Una regola r copre una istanza x se i valori di
x soddisfano l’antecedente di r
r1: (Give Birth = no) ∧ (Can Fly = yes) → Birds
r2: (Give Birth = no) ∧ (Live in Water = yes) → Fishes
r3: (Give Birth = yes) ∧ (Blood Type = warm) → Mammals
r4: (Give Birth = no) ∧ (Can Fly = no) → Reptiles
r5: (Live in Water = sometimes) → Amphibians
Name
hawk
grizzly bear
Blood Type
Give Birth
Can Fly
Live in Water
Class
no
yes
yes
no
no
no
?
?
warm
warm
La regola r1 copre hawk => Bird
La regola r3 copre grizzly bear => Mammal
9
Copertura e accuratezza
Dato un dataset D e una regola di classificazione A→y
definiamo
RTi Refund Marital
Taxable
Copertura:
d
Frazione dei record che
soddisfano l’antecedente
della regola
| A|
Coverage(r ) =
|D|
Accuratezza:
Frazione dei record che,
soddisfando l’antecedente,
soddisfano anche il
conseguente della regola
Accuracy(r ) =
| A∩ y |
| A|
Status
Income
Class
1
Yes
Single
125K
No
2
No
Married
100K
No
3
No
Single
70K
No
4
Yes
Married
120K
No
5
No
Divorced 95K
Yes
6
No
Married
No
7
Yes
Divorced 220K
No
8
No
Single
85K
Yes
9
No
Married
75K
No
10
No
Single
90K
Yes
60K
10
r = (Status=Single) → No
Coverage(r) = 40%, Accuracy(r) = 50%10
Come funziona un classificatore
basato su regole?
r1: (Give Birth = no) ∧ (Can Fly = yes) → Birds
r2: (Give Birth = no) ∧ (Live in Water = yes) → Fishes
r3: (Give Birth = yes) ∧ (Blood Type = warm) → Mammals
r4: (Give Birth = no) ∧ (Can Fly = no) → Reptiles
r5: (Live in Water = sometimes) → Amphibians
Name
lemur
turtle
dogfish shark
Blood Type
warm
cold
cold
Give Birth
Can Fly
Live in Water
Class
yes
no
yes
no
no
no
no
sometimes
yes
?
?
?
Un lemure attiva la regola r3, quindi è classificato come mammifero
Una tartaruga attiva sia r4 sia r5 che determinano classi diverse!
Uno squalo non attiva nessuna regola!!
11
Proprietà dei classificatori
basati su regole
Regole mutuamente esclusive: un insieme di regole R
è detto mutuamente esclusivo se nessuna coppia di
regole può essere attivata dallo stesso record
Ogni record è coperto da al più una regola
Regole esaustive: un insieme di regole R ha una copertura
esaustiva se esiste una regola per ogni combinazione di valori
degli attributi
Ogni record è coperto da almeno una regola
12
Proprietà dei classificatori
basati su regole
Non sempre è possibile determinare un insieme di regole
esaustive e mutualmente esclusive
Mancanza di mutua esclusività
Un record può attivare più regole dando vita a classificazioni
discordanti
Soluzione
• Definire un ordine di attivazione delle regole. Si parla in questo caso di
liste di decisione
• Assegnare il record alla classe per la quale vengono attivate più regole
(voto)
Mancanza di esaustività
Un record può non attivare nessuna regola
Soluzione
• Utilizzare una classe di default (“altro”) a cui il record viene associato in
caso di non attivazione delle regole
13
Modalità di ordinamento
Ordinamento Rule-based
Le singole regole sono ordinate in base alla loro qualità
Ordinamento Class-based
Gruppi di regole che determinano la stessa classe compaiono di seguito nella
lista. L’ordinamento rilevante diventa quello tra le classi che può dipendere
dall’importanza della classe o dalla gravità di commettere un errore di
classificazione per quella classe
Il rischio con questa soluzione è che una regola di buona qualità sia superata
da una regola di qualità inferiore ma appartenente a una classe importante
Soluzione utilizzata dai principali algoritmi di costruzione delle
regole(RIPPER, C4.5rules)
14
Esercizio
Attributi e valori
Air Conditioner = {Working, Broken}
Engine = {Good, Bad}
Mileage = {High, Medium, Low}
Rust = {Yes, No}
Insieme di regole
Mileage = High → Value = Low
Mileage = Low → Value = High
Air Conditioner = Working, Engine = Good → Value = High
Air Conditioner = Working, Engine = Bad → Value = Low
Air Conditioner = Broken → Value = Low
Quesiti
Le regole sono esaustive?
Le regole sono mutualmente esclusive?
E’ necessario un ordinamento?
E’ necessaria una classe di default?
15
Costruzione delle regole
Metodi diretti
Estraggono le regole direttamente dai dati (es. RIPPER, CN2,
Holte’s 1R)
Metodi indiretti
Estraggono le regole dal risultato di altri metodi di
classificazione come per esempio i decision tree (C4.5rules)
16
Metodi diretti: sequential covering
Let E be the training set, A={(Aj,vj)} the set of attribute-value pairs
and Y0={y1 … yk} the set of classes where yk is the default class
set R = Ø
for each class y ∈ Y0 – {yk} do
stop=FALSE;
while !stop do
r = Learn-One-Rule(E,A,y)
remove from E training records that are covered by r
If Quality(r,E) < Threshold then
stop=TRUE;
else
R = R ∪ r // Add r at the bottom of the rule list
end while
end for
R = R ∪ {{}->yk}// Add the default rule at the bottom of the rule list
PostPruning(R);
L’ordinamento delle regole è determinato da quello delle classi
Punti di attenzione
Modalità di creazione delle regole (Learn-One-Rule)
Eliminazione delle istanze
17
Criterio di stop
Sequential covering: esempio
(ii) Step 1
Chiameremo esempi positivi (+) tutte le tuple del training set che
appartengono alla classe y. Sono esempi negativi (-) tutti gli altri.
18
Sequential covering: esempio
R1
R1
R2
(iii) Step 2
(iv) Step 3
19
Eliminazione delle istanze dal
training set
L’eliminazione delle istanze dal training set serve a:
Istanze classificate correttamente: evitare di generare sempre
la stessa regola, evitare di sovrastimare l’accuracy della
prossima regola
Istanze classificate non correttamente: a evitare di sottostimare
l’accuracy della prossima regola
• Le istanze negative conteggiate per la regola 1 non devono essere
conteggiate anche per la regola 3
Accuracy(R1)=12/15 (80%)
Accuracy(R2)=7/10 (70%)
Accuracy(R3)=8/12 (66.7%)
Dopo aver scelto R1
Accuracy(R2)=7/10
Accuracy(R3)=6/8
(70%)
(75%)
Learn-One-Rule
L’obiettivo dell’algoritmo è trovare una regola che copra quanti più
possibili esempi positivi e quanto meno possibili (o nessun)
esempio negativo
Il problema è complesso dato che lo spazio di ricerca è esponenziale
nel numero di possibili combinazioni dei predicati
Le regole sono costruite considerando progressivamente un nuovo
possibile predicato ossia una possibile coppia (Attributo,Valore)
Learn-One-Rule
E’ necessario un criterio per scegliere quale predicato aggiungere
• n : numero di istanze coperte dalla regola
• nr : numero di istanze correttamente classificate dalla regola
• k : numero di classi
Accuratezza: limitata applicabilità poiché non considera la coverage
della regola
Accuracy (r ) =
nr
n
– r1: copre 50 esempi positivi e 5 esempi negativi → Accuracy(r1) = 90.9%
– r2: copre 2 esempi positivi e 0 esempi negativi → Accuracy(r2) = 100%
Metriche che considerano la coverage: pesano l’accuracy in base
alla coverage
Laplace(r ) =
nr + 1
n+k
• Se la coverage è 0 (nr=n=0) e assumendo distribuzione uniforme dei dati , l’indice si
riduce alla probabilità a priori della classe (1/k)
n
• Se la coverage è alta l’indice tende asintoticamente al valore dell’accuracy r
n
• Per valori bassi di coverage k tende a ridurre il valore dell’indice
22
Learn-One-Rule
Metriche che considerano il supporto della regola ossia il numero di
esempi positivi coperti dalla regola

p'
p 

FoilGain( r , r ' ) = t  log 2
− log 2
p '+ n'
p + n 

•
•
•
•
•
r / r': regola prima / dopo l’inserimento del nuovo predicato
t: numero di esempi positivi coperti sia da r sia da r'
p / p' : numero di esempi positivi coperti da r / r'
n / n' : numero di esempi negativi coperti da r / r'
L’indice è proporzionale a t e a (p')/(p'+n') quindi tende a favorire regole
che hanno elevato coverage e accuracy
Training set composto da 100 esempi positivi e 400 negativi
R1: A → + (copertura: 4 esempi positivi e 1 negativo)
R2: A → + (copertura: 30 esempi positivi e 10 negativi)
R3: A → + (copertura: 100 esempi positivi e 90 negativi)
Determinare quale è la regola migliore sulla base dell’accuracy e del FoilGain
23
Learn-One-Rule
Criterio di stop nell’estensione di una regola
Calcola il gain
Se il gain non è significativo stop!
Rule Pruning: ha l’obiettivo di semplificare le regole per migliorare
l’errore di generalizzazione delle regole, può essere utile visto che
l’approccio di costruzione è greedy
Possono essere utilizzate le tecniche viste per gli alberi decisionali
• Minimum Description Length
• Approccio pessimistico
• Utilizzo del validation set
Esempio (Reduced error pruning):
• Rimuovi a turno uno dei predicati dalla regola
• Elimina il predicato la cui rimozione comporta il massimo miglioramento
dell’error rate sul validation set
• Ripeti i passi precedenti sino a che continuano a determinare un
miglioramento
24
Metodi diretti: RIPPER
Approccio basato sul sequential covering
Una sua versione denominata JRip è implementata in WEKA
Per problemi a 2 classi, scegli una delle classi come classe
positiva e l’altra come classe negativa
Impara le regole per la classe positiva
La classe negativa sarà la classe di default
Per problemi multi-classe
Ordina le classi in base a un criterio di rilevanza della classe
(frazione delle istanze che appartengono alla classe)
Impara le regole a partire dalla classe più piccola e considerando il
resto delle istanze come classe negativa
Ripeti l’operazione con le classi successive
Dopo l’aggiunta di una regola calcola il description length
Interrompi la costruzione di nuove regole quando il nuovo valore di
description length è superiore di d bits rispetto a quello precedente
25
Metodi diretti: RIPPER
Learn-one-rule:
Inizia con una regola vuota
Aggiungi predicati finchè determinano un miglioramento del
FoilGain
Esegui il pruning utilizzando la tecnica dell’incremental
reduced error pruning
• Esegue il pruning dopo ogni passo di growing
Metodo di pruning: elimina dalla regola i predicati la cui
rimozione massimizza: v = (p-n)/(p+n)
• p: numero di esempi positivi coperti dalla regola nel validation set
• n: numero di esempi negativi coperti dalla regola nel validation set
26
Metodi indiretti
E’ possibile trasformare un decision tree in un insieme di regole
(vedi C4.5rules)
Ad ogni percorso radice-foglia corrisponderà una regola
Saranno poi applicati opportune tecniche di pruninig
27
Alberi decisionali vs regole
Sebbene l’espressivatà delle due tecniche sia similare l’insieme
delle regole prodotte è generalmente diverso
La differenza fondamentale tra le due tecniche consiste nel fatto
che nel procedimento di costruzione:
la bontà del criterio di split scelto in ogni nodo dell’albero
cosidera la qualità di tutti i figli generati
il criterio con cui viene aggiunto un predicato alla regola valuta
solo la bontà della classe che si viene a determinare
A1<20
R1: A1<20
R1: A1<20 and A2>60
Yes
A1
No
??
A2>60
Yes
No
??
A2
Classificatori Instance-Based
Non costruiscono modelli ma classificano i nuovi record sulla
base della loro somiglianza rispetto agli esempi nel training set
Sono per questo detti lazy -pigri- learners in contrapposizione agli
eager –diligenti, impazienti- learners (rule based, alberi
decisionali, reti neurali, ecc.)
Rote-learner: classifica un record solo se coincide con uno del
training set
Nearest-Neighbor: classifica il record in base ai più simili del training
set
Se t o f Sto re d C a se s
A tr1
… … ...
A trN
C la s s
A
B
B
C
A
U n se e n C a se
A tr1
… … ...
A trN
C
29
B
Classificatori Nearest Neighbor
Utilizzano i k punti “più vicini” (nearest neighbors) per
effettuare la classificazione
Idea di base:
If it walks like a duck, quacks like a duck, then it’s probably a
duck
Calcola la
distanza
Training
Record
Test
Record
Scegli i k record
“più vicini”
30
Classificatori Nearest Neighbor
Record da classificare
l
Richiedono:
– Un taining set
– Una metrica per calcolare la
distanza tra i record
– Il valore di k, ossia il numero
di vicini da utilizzare
l
Il processo di classificazione:
– Calcola la distanza rispetto ai
record nel traing set
– Identifica k nearest neighbors
– Utilizza le label delle classi
dei nearest neighbor per
determinare la classe del
record sconosciuto (es.
scegliendo quella che
compare con maggiore
31
frequenza)
Definizione di Nearest Neighbor
X
(a) 1-nearest neighbor
X
X
(b) 2-nearest neighbor
(c) 3-nearest neighbor
I k nearest neighbors di un record x sono i record del
training set che hanno le più piccole k distance da x
32
K-Nearest Neighbor
La classificazione di un record z è ottenuta con un
processo di majority voting tra i k elementi Dz del
training set D più vicini (o simili) a z
y = arg max
y∈Y
∑ I ( yi = y )
( x i , yi )∈Dz
Y è l’insieme delle label di classe
I() restituisce 1 se il suo argomento è TRUE, 0 altrimenti
Tutti i vicini hanno lo stesso peso
L’algoritmo è molto sensibile al valore di k
Questo rischio può essere ridotto pesando il contributo dei
vicini in base alla distanza w = 1/d(z,xi)
y = arg max
y∈Y
∑ w × I ( yi = y )
( x i , yi )∈Dz
33
K-Nearest Neighbor
La scelta di k è importante perchè:
Se k è troppo piccolo, l’approccio è sensibile
al rumore
Se k è troppo grande, l’intorno può includere
esempi appartenenti ad altre classi
Per operare correttamente gli attributi devono avere la stessa
scala di valori e vanno quindi normalizzati in fase di preprocessing
Esempio: su quale attributo una differenza di 0.5 vale di più?
• l’altezza di un adulto varia 1.5m to 2.1m
• il peso di un adulto varia da 40kg a 150kg
• Lo stipendio di una persona varia da 10K€ to 1M€
Normalizzare la scala può non essere sufficiente in presenza di
diverse distribuzioni dei dati
Mahalanobis distance
34
K-Nearest Neighbor: Pro &
Contro
Pro
Non richiedono la costruzione di un modello
Rispetto ai sistemi basati su regole o decision tree permettono di
costruire “contorni” delle classi non lineari e sono quindi più flessibili
Contro
Richiedono una misura di similarità o distanza per valutare la
vicinanza
Richiedono una fase di pre-processing per normalizzare il range di
variazione degli attributi
La classe è determinata localmente e quindi è suscettibile al rumore
dei dati
Sono molto sensibili alla presenza di attributi irrilevanti o correlati che
falseranno le distanze tra gli oggetti
Il costo di classificazione può essere elevato e dipende linearmente
dalla dimensione del training set in mancanza di opportune strutture
ad indice
35
Utilizzo di indici per query spaziali
Dati n attributi A1,…,An e in assenza di strutture dati specifiche si
potrebbe pensare di costruire un B+-tree multi-attributo, che
organizzi (ordini) le tuple in base ai valori di A1,A2,…,An
Considerando i nodi foglia del B+-tree: N1→N2→N3 →…
La prima foglia, N1, conterrà le tuple con i più piccoli valori di A1 in
base alla capacità della foglia stessa
La seconda foglia inizierà con i valori seguenti, e così via
Qualsiasi ordinamento si scelga, la ricerca di un k-NN di un punto
richiederà l’accesso a molti nodi poichè questa soluzione non
cattura il concetto di distanza spaziale
20
N2
A2
15
10
N1
5
Punti “vicini” potrebbero essere qui
0
0
5
10
A1
15
20
36
Un’altra soluzione basata sui B+-tree
Assumiamo di conoscere, per esempio mediante le statisiche del DB,
che i k-NN di un punto q stiano nell’(iper) rettangolo con lati [l1,h1] x
[l2,h2] x…
Allora possiamo utilizzare n query di range indipendenti Ai BETWEEN li
AND hi su n indici distinti A1,A2,…,An e intersecare il risultato
Oltre a richiedere di conoscere i valori dei range questa tecnica
richiederebbe comunque molto lavoro poichè leggerà una quantità di tuple
proporzionale all’unione degli n risultati a meno della loro intersezione
[l1,h1]
20
Il risultato è in questa area
[l2,h2]
A2
15
10
5
0
0
5
10
A1
15
20
37
Indici multi-dimensionali (spaziali)
Il B+-tree multi-attributo mappa punti di A ⊆ ℜD in punti di ℜ
Questa “linearizzazione” forzatamente favorisce uno degli attributi in
base al modo in cui questi sono organizzati nel B+-tree
Un B+-tree su (X,Y) favorisce query su X, e non può essere utilizzato per
query che non specifichino il valore di X
Per questo motivo, dobbiamo utilizzare un modo che al contrario preservi
la “prossimità spaziale”
Il tema dello “spatial indexing” è stato studiato a partire dagli anni ’70 a
causa della sua importanza (cartografia, GIS, VLSI, CAD)
Più recentemente (anni ‘90), è tornato di “moda” grazie a nuove tipologie
di applicazioni come quelle multimediali
38
Gli R-tree (Guttman, 1984)
Gli R-tree sono estensioni dei B+-tree a spazi multi-dimensionali
I B+-tree organizzano gli oggetti in
Un insieme di intervalli mono-dimensionali non sovrapposti
Applicano questo prinicipio ricorsivamente dalle foglie alla radice
Gli R-tree organizzano gli oggetti in
Un insieme di intervalli multi-dimensionali sovrapposti (iper-rettangoli)
Applicano questo principio ricorsivamente dalle foglie alla radice
Gli R-tree sono oggi disponibili in alcuni DBMS commerciali quali
Oracle9i
39
R-tree: intuizione
B
A
L
E
D
H
F
G
I
M J
Aggregazione ricorsiva di
oggetti basata sul MBR
Le regioni possono
sovrapporsi
Nella slide è mostrata
una 2-D range query che
utilizza L2
K
ABC
N
P
O
A
DE F GH
C
D
B
C
I J K LM NO P
…………………………...
P
40
R-tree: proprietà di base
Gli R-tree sono alberi dinamici, bilanciati e paginati
Ogni nodo memorizza un numero variabile di elementi
Nodi foglia:
• Un elemento E ha la forma E=(tuple-key,TID), dove tuple-key è la “spatial
key” (posizione) della tupla il cui indirizzo è TID (puntatore a pagina dati)
Nodi interni:
• Un elemento E ha la forma E=(MBR,PID), dove MBR è il “Minimum
Bounding Rectangle” (con lati paralleli agli assi) di tutti i punti raggiungibili
dai suoi nodi figli memorizzati nel nodo punto da PID (PID = page
identifier)
E=(MBR,PID)
D
A
DE F GH
ABC
B
I J K LM
E=(tuple-key,TID)
41
R-tree: proprietà di base
Il numero di elementi in un nodo varia da c a C, dove c ≤ 0.5*C è
un parametro di progettazione dell’R-tree, mentre C dipende dalla
dimensione del nodo e dalla dimensione di un elmento che è a
sua volta determinato dalla dimensionalità dello spazio
La radice fa eccezione dato che può avere due soli figli
Un iper rettangolo in ℜD con lati paralleli agli assi può essere
rappresentato con 2*D numeri floating point che codificano le
coordinate di due vertici opposti
42
Ricerca: query di range
Consideriamo dapprima query di range
Range Query
Dato un punto q, una relazione R, un raggio di
ricerca r ≥ 0, e una funzione distanza d,
Determinare tutte le tuple t in R tali che d(t,q) ≤ r
La regione di ℜD definita come Reg(q) = {p: p ∈ℜD , d(p,q) ≤ r} è
detta query region (il risultato è sempre contenuto nella query
region)
In letteratura sono studiate molte varianti del problema
Point query: quando r = 0 (si cerca un match perfetto)
Window query: quando la query region è un iper-rettangolo (una
window)
43
Ricerca: query di range
L’algoritmo per eseguire una query di range è estremamente semplice:
Per ogni elemento E nella radice, si verifica che
E.key intersects Reg(q):
se Req(q) ∩ E.key ≠ ∅:
si accede al nodo figlio N puntato da E.ptr
se Req(q) ∩ E.key = ∅:
si scarta il nodo N
Quando si arriva a un nodo foglia si verifica per ogni elemento E se
E.key ∈ Reg(q), ossia che d(E.key,q) ≤ r.
•
In questo caso si aggiunge E al risultato della ricerca
RangeQuery(q,r,N)
{ if N is a leaf then: for each E in N:
if d(E.key,q) ≤ r then add E to the result
else: for each E in N:
if Req(q) ∩ E.key ≠ ∅ then
RangeQuery(q,r,*(E.ptr) }
La ricorsione parte dalla radice dell’R-tree
La notazione N = *(E.ptr) indica che “N è il nodo puntato da E.ptr”
In alcuni casi scriveremo alternativamente ptr(N) al posto di E.ptr
44
Ricerca: query di range
B
A
L
E
D
H
F
G
I
La navigazione segue un
percorso depth-first
Questo assicura che, ad ogni
passo, il numero massimo di
nodi in memoria è pari
all’altezza dell’R-tree
Questi nodi sono gestiti
tramite uno stack
M J
K
ABC
N
P
O
DE F GH
C
I J K LM …
…
…
45
Ricerca: k-NN query
Dato un nodo N = *(E.ptr) dell’R-tree la sua regione può essere definita come:
Reg(*(E.ptr)) = Reg(N) = {p: p ∈ℜD , p ∈ E.key=E.MBR}
Allora, possiamo accedere al nodo N se e solo se (iff) Req(q) ∩ Reg(N) ≠ ∅
Definiamo dMIN(q,Reg(N)) = infp{d(q,p) | p ∈ Reg(N)}, ossia la distanza minima tra
q e un punto di Reg(N)
“MinDist” dMIN(q,Reg(N)) è un lower bound delle distanze da q a qualsiasi punto
dell’indice raggiungibile da N
Valgono le seguenti osservazioni
Req(q) ∩ Reg(N) ≠ ∅
⇔
dMIN(q,Reg(N)) ≤ r
N3
r d (q,Reg(N1))
MIN
dMIN(q,Reg(N3))
dMIN(q,Reg(N2))
N2
N1
46
Ricerca: k-NN query
Presentiamo ora l’algoritmo kNNOptimal, per risolvere k-NN query con un R-tree
Consideriamo dapprima il caso k=1
Per un punto q, sia tNN(q) il 1nearest neighbor (1-NN = NN) di q in R, e denotiamo
con rNN = d(q, tNN(q)) la sua distanza da q
Ovviamnente , rNN sarà noto solo al termine dell’algoritmo
Teorema
Qualsiasi algoritmo utilizzato per 1-NN query deve visitare almeno i
nodi N la cui MinDist è inferiore a rNN
Prova (per assurdo): Assumiamo che un algoritmo ALG si fermi e restituisca
come NN di q un punto t e che ALG non legga il nodo N tale che
dMIN(q,Reg(N)) < d(q,t);
allora Reg(N) potrebbe contenere un punto t’ tale che d(q,t’) < d(q,t), ciò
contraddice l’ipotesi che t sia NN di q
47
L’algoritmo kNNOptimal
L’algoritmo kNNOptimal utilizza una coda di priorità PQ, i cui elementi
sono coppie [ptr(N), dMIN(q,Reg(N))]
PQ è ordinata in base a valori crescenti di dMIN(q,Reg(N))
DEQUEUE(PQ) estrae da PQ la coppia con MinDist minima
ENQUEUE(PQ, [ptr(N), dMIN(q,Reg(N))]) esegue un inserimento ordinato
della coppia nella coda
Il pruning dei nodi si basa sulla seguente osservazione:
Se, in un certo istante dell’esecuzione, è stato trovato un punto t tale che
d(q,t) = r,
Allora, tutti i nodi N con dMIN(q,Reg(N)) ≥ r possono essere esclusi dalla
ricerca poichè non possono portare a un miglioramento del risultato
Nella descrizione dell’algoritmo, il pruning delle coppie di PQ basato sul
criterio appena introdotto è denotato sinteticamente con UPDATE(PQ)
Con la dicitura “the node N is in PQ” intendiamo che la coppia [ptr(N),
dMIN(q,Reg(N))] è in PQ
Intuitivamente, kNNOptimal esegue un “range search con un raggio di
ricerca variabile e che si riduce progressivamente” fino a che non è
possibile ottenere ulteriori miglioramenti del risultato
48
L’algoritmo kNNOptimal (k=1)
Input: query point q, index tree with root node RN
Output: tNN(q), the nearest neighbor of q, and rNN = d(q, tNN(q))
1. Initialize PQ with [ptr(RN),0];
// starts from the root node
2. rNN := ∞;
// this is the initial “search radius”
3. while PQ ≠ ∅:
// until the queue is not empty…
4.
[ptr(N), dMIN(q,Reg(N))] := DEQUEUE(PQ);
// … get the closest pair…
5.
Read(N);
// … and reads the node
6.
if N is a leaf then: for each point t in N:
7.
if d(q,t) < rNN then: {tNN(q) := t; rNN := d(q,t); UPDATE(PQ)}
// reduces the search radius and prunes nodes
8.
else: for each child node Nc of N:
9.
if dMIN(q,Reg(Nc)) < rNN then:
10.
ENQUEUE(PQ,[ptr(Nc), dMIN(q,Reg(Nc))]);
11. return tNN(q) and rNN;
12. end.
49
L’algoritmo kNNOptimal
RN
N4
N7
N2
N3
q
t2
N6
N5
I nodi sono numerati in
base all’ordine di
accesso
Gli oggetti sono numerati
solo quando migliorano
(riducono) il raggio di
ricerca
Le foglie visitate sono
mostrate in grassetto
t1
N1
50
Correttezza e ottimalità di kNNOptimal
L’algoritmo kNNOptimal è chiaramente corretto
Per mostrare che è anche ottimale, ossia che legge il numero minimo di
nodi, è sufficiente provare che:
non legge mai nodi N tali che dMIN(q,Reg(N)) > rNN
Dimostrazione:
N è letto solo se, ad un certo passo di esecuzione, esso diventa il
1°elemento nella coda di priorità PQ
Sia N1 il nodo contenente tNN(q) , N2 il suo padre, N3 il padre di N2, e così
via fino a Nh = RN (h = altezza dell’albero)
Si nota che, per definizione di MinDist:
rNN ≥ dMIN(q,Reg(N1)) ≥ dMIN(q,Reg(N2)) ≥ … ≥ dMIN(q,Reg(Nh))
A ogni passo di esecuzione prima di trovare tNN(q), uno (e uno solo) dei
nodi N1,N2,…,Nh appartiene alla coda di priorità
Da ciò segue che N non può mai diventare il primo elemento della lista
51
L’algoritmo kNNOptimal (k ≥ 1)
L’algoritmo si estende in modo semplice al caso k ≥ 1 introducendo:
Una struttura dati, che chimeremo ResultList, dove sono memorizzati i k
oggetti più vicini trovati fino a questo momento, assieme alle loro distanze da
q
Il “raggio di ricerca corrente” ossia la distanza, rk-NN, del k-esimo NN di q,
ossia, il k-esimo elemento della ResultList
ResultList
ObjectID
distance
t15
4
t24
8
t18
9
t4
12
t2
15
k=5
Non è necessario leggere
nodi con distanza ≥ 15
Il resto dell’algoritmo rimane invariato
52
L’algoritmo kNNOptimal (k ≥ 1)
Input: query point q, integer k ≥ 1, index tree with root node RN
Output: the k nearest neighbors of q, together with their distances
1. Initialize PQ with [ptr(RN),0];
2. for i=1 to k: ResultList(i) := [null,∞]; rk-NN := ResultList(k).dist;
3. while PQ ≠ ∅:
4.
[ptr(N), dMIN(q,Reg(N))] := DEQUEUE(PQ);
5.
Read(N);
6.
if N is a leaf then: for each point t in N:
7.
if d(q,t) < rk-NN then: { remove the element in ResultList(k);
8.
insert [t,d(q,t)] in ResultList;
9.
rk-NN := ResultList(k).dist; UPDATE(PQ)}
10.
else: for each child node Nc of N:
11.
if dMIN(q,Reg(Nc)) < rk-NN then:
12.
ENQUEUE(PQ,[ptr(Nc), dMIN(q,Reg(Nc))]);
13. return ResultList;
14. end.
53
R-tree: come si presentano
B
A
L
E
D
H
F
G
I
M J
Aggregazione ricorsiva
bottom-up di oggetti basata
sulla MBR (minimum
bounding region)
Le regioni possono
sovrapporsi
Ogni nodi può contenere fino
a C oggetti, ma non meno di
c ≤ 0.5*C
La radice fa eccezione
K
ABC
N
P
O
C
D
A
DE F GH
B
C
I J K LM NO P
……………………………
P
54
R-tree: inserimento di un
oggetto
Partendo dalla radice discendiamo nell’albero cercando di trovare un “buon
punto” dove inserire il nuovo oggetto p
Per semplicità, assumiamo che gli oggetti indicizzati siano punti, considerazioni
similari si applicano se gli oggetti indicizzati sono (iper)rettangoli (MBR)
Ad ogni passo dobbiamo rispondere a una domanda:
Quale nodo figlio è più adatto
per l’inserimento di p?
B
A
B
A
p
p
E qui?
C
C
55
R-tree: il metodo ChooseSubtree
L’algoritmo ricorsivo che discende l’albero per inserire p è chiamato
ChooseSubtree
ChooseSubtree(Ep=(p,TID),ptr(N))
1.
Read(N);
2.
If N is a leaf
then:
return N
// we are done
3.
else:
{ choose among the entries Ec in N
the one, Ec*, for which Penalty(Ep,Ec*) is minimum;
4.
return ChooseSubtree(Ep,Ec*.ptr) } // recursive call
5.
end.
Si invoca il metodo sul nodo root
Lo specifico criterio utilizzatto per decidere “quanto è buono/cattivo” un
elemento, e se dobbiamo utilizzarlo per inserire p, è incapsulata nel
metodo Penalty
Le varianti dell’ R-tree differiscono nel modo in cui è implementato Penalty
56
R-tree: il metodo Penalty
Se il punto p è all’interno della regione di una entry Ec, allora la penalità
è0
Altrimenti, Penalty può èssere calcolato come l’incremento del volume
(area) del MBR
Tuttavia, se Ec punta a un nodo foglia, è dimostrabile che è meglio
considerare l’incremento della regione di overlap con altre entry
Entrambi I criteri mirano a ottenere un albero che massimizzi le
prestazioni:
Aree grandi: aumenta il numero di nodi da visitare per rispondere a una query
Sovrapposizioni ampie: riducono le performace perchè alcune regioni sono
visitate più volte
A
B
B è meglio di A
p
57
R-tree: splitting di un nodo foglia
Quando p viene inserito in un nodo foglia che contiene già C elementi si verifica
un overflow e N deve essere splittato
L’obiettivo è quello di separare l’insieme di C+1 punti in 2 sottoinsiemi, ognuno
dei quali contenga almeno c e al più C punti
Tra le diverse possibiltà, si potrebbe considerare quella che determina la minima
area complessiva
Tuttavia questo è un problea NP-Hard, quindi è necessario adottare delle euristiche
N
p
p
N1
N1 p
N2
?
N2
C = 16
c=6
58
R-tree: splitting di un nodo non foglia
Come nei B+-trees, gli split si propagano verso l’alto e possono
ricorsivamente attivare split ai livelli più alti dell’albero
Il problema da affrontare è come separare un insieme di C+1 (iper)rettangoli
Si noti che questo problema si evidenzia anche nei nodi foglia nel caso in cui
memorizzino MBR
L’algoritmo originale era finalizzato a minimizzare la somma delle aree
risultanti
L’R*-tree utilizza un criterio più evoluto che considera le aree, l’overlap, e il
perimetro della regione risultante
N1
N
N1
?
C=7 c=3
N2
N2
59
R-tree: Curse of dimensionality
Le performance dell’R-tree si riducono al crescere della dimensionalità dei
dati. Questo perchè, come già evidenziato, le distanze tra gli oggetti tendono
ad omogeneizzarsi
• 500 punti generati in modo
casuale
• Il grafico mostra una misura della
differenza tra la distanza minima e
la distanza massima di ogni
coppia di punti
Soluzioni alternative sono:
R*-Tree variante dell’R-tree che utilizza tecniche di inserimento più evolute e permette di
ottenere regioni maggiormente ottimizzate in termini di volume e overlap
X-Tree: minimizzano l’overlap
VA-file: utilizzano una scansione sequenziale indicizzata
60
X-tree
Struttura basata su R-tree
Evita l’overlap tra i nodi utilizzando:
una strategia di split senza overlap
il concetto di super-nodi
Idea: ricerca sequenziale all’interno dei nodi
In caso di overflow di un nodo:
Prova lo split stile R*-tree
Se l’overlap è eccessivo, prova lo split senza overlap
Se i nodi sono troppo sbilanciati, aumenta il nodo (super-nodo)
Esempio: la presenza dei super nodi evita di avere più nodi sovrapposti
super-nodo
nodo normale
foglia
61
X-tree: valutazione delle performance
62
Vector Approximation - VA file
Idea: dal momento che la ricerca sequenziale è l’unica soluzione
per D > 16, velocizzare la scansione dei punti indicizzati
Utilizzo di una rappresentazione “compressa” dei dati come
approssimazione
Utilizzando bi bit per ogni dimensione i è possibile individuare 2bi suddivisioni
per ogni dimensione
Avendo in totale b=b1+…+bn bit si possono costruire 2b1×…×2bn=2b celle
In pratica, si adotta un partizionamento space-based del data-set
ed ogni punto viene rappresentato con la regione in cui esso si
trova
Si sostituisce ogni punto con la sua rappresentazione compressa
e approssimata
In fase di ricerca si mantengono lower- e upper-bound sulle
distanze per tagliare o meno i punti che vengono visitati
Dopo il passo di filtraggio, occorre accedere alla
rappresentazione reale dei punti per vedere se questi verificano o
meno la query
63
VA file
Esempio: D = 2, bi = 3, query 1-NN
δ = distanza del kth NN trovato
∀Approssimazione ai
If lb(q,ai) < δ then
Calcola r = dist(q,vi)
If r < δ then
Aggiungi vi a NNs
Aggiorna δ
query point
q
dMAX
dMIN
nearest neighbor
candidate points
dMAX
excluded points
dMIN
Il VA file ha la stessa cardinalità dei dati ed è sempre scandito
completamente (sequenzialmente)
Per ogni punto vi del VA file, si accede ai dati veri e propri solo se la
distanza minima della regione approssimata ai a cui vi appartiene è
inferiore a δ attuale distanza del k-esimo NN
64
Combinazione di classificatori
Idea: costruire più classificatori di base e predire la classe di
appartenza di un record aggregando le classificazioni ottenute
Il risultato del classificatore composto è definito per mezzo di una funzione
che, per esempio, assegna il record alla classe che è stata “votata” dal
maggior numero di classificatori
65
Principio di funzionamento
Supponiamo di avere 25 classificatori semplici
Ogni classificatore ha un error-rate pari a ε = 0.35
Si assuma che i classificatori siamo indipendenti
• Non c’è correlazione tra gli error-rate dei classificatori
La probabilità che il classificatore composto dia un risultato errato è:
 25 
25
∑  i ε (1 − ε )
i =13


i
25−i
= 0.06
Error rate
1
0,9
0,8
0,7
0,6
0,5
0,4
0,3
0,2
0,1
0
0,0
0,1
0,2
0,3 0,4 0,5 0,6 0,7 0,8 0,9
Error rate del classificatore di base
Composto
Base
1,0
Condizioni necessarie perchè il classificatore composto dia risultati
migliori dei classificatori semplici sono:
Che i classificatori siano indipendenti
Che l’error-rate del singolo classificatore sia inferiore a 0.5
66
Come costruire classificatori composti
Cambiando il training set: si costruiscono più training set a partire dal
data set dato
Cambiando gli attributi utilizzati: i singoli classificatori sono basati su un
sottoinsieme degli attributi
Bagging e Boosting
Utile quando gli attributi sono fortemente ridondanti
• Random Forest
Cambiando le classi considerate:
Si partizionano le classi in due gruppi A0 e A1 e si trasforma il problema dato in un
problema binario. Le classi che appartengono ad A0 sono classificate come 0 le
rimanenti come 1.
I diversi classificatori sono costruiti risuddividendo le classi in sottoinsiemi diversi
La classificazione del classificatore composto si ottiene incrementando di 1 il punteggio
delle classi che appartengono al sottoinsieme scelto.
Il record è infine assegnato alla classe che ottiene il punteggio maggiore
• Error-Correcting Output Coding
Cambiando i parametri dell’algoritmo di learning:
Topologia e pesi di una rete neurale
Alberi decisionali con politiche di scelta random degli attributi da utilizzare
67
Decomposizione Bias-Variance-Noise
Un modello formale per analizzare l’errore commesso da un
classificatore
L’errore commesso da un classificatore dipende da:
Probabilità che un classificatore sbagli la sua previsione
BIAS: capacità del classificatore scelto nel modellare gli eventi e nell’estendere
la previsione agli eventi non presenti nel training set
• Tipi di classificatori diversi hanno capacità diverse nel definire i decision boundary tra le
classi
• Per esempio decision tree diversi possono avere capacità diverse
VARIANCE: capacità del training set nel rappresentare il data set reale
• Training set diversi possono determinare decision boundary diversi
NOISE: non-determinismo delle delle classi da determinare
• Istanze set con gli stessi valori degli attributi possono determinare classi diverse
68
Decomposizione Bias-Variance-Noise
Tipi di classificatori diversi hanno capacità intrinsecamente
diverse nel modellare i margini delle regioni
100 training set ognuno contenente 100 esempi ottenuti a partire da una
suddivisione in regioni predefinita (linea trattegiata)
La linea nera rappresenta la media della linea di separazione media ottenuta
dai 100 classificatori
La differenza tra la vera linea di separazione e quella media
rappresenta il bias del classificatore
Il bias del 1-NN è inferiore
Tuttavia i k-NN sono maggiormente sensibili alla composizione del training set
e quindi presenteranno un maggiore variance
69
Multi-classificatori
Si utilizzano classificatori diversi (es. Alberi decisionali + k-nearest
neighbor) per ridurre il bias dell’errore
I classificatori devono essere inidipendenti: non c’è correlazione (o ce
ne è poca) tra gli errori commessi tra due classificatori
Classificatori diversi possono operare su sottoinsiemi distinti di attributi
su cui hanno performance ideali
La classe di appartenenza è decisa mediante un meccanismo di
voting
Classe votata dal maggior numero di classificatori
Il voto può essere pesato in base alla confidenza del classificatori nel
caso in cui questo la fornisca
• Es. Es il classificatore C1 vota per la classe X. In fase di addestramento C1
ha commesso 25 su 100 errori per la classe X. Il classificatore C2 vota per
la classe Y. In fase di addestramento C2 ha commesso 10 su 100 errori
per la classe Y.
Il record è assegnato alla classe Y
70
Bagging
Permette di costruire classificatori composti che associano un
evento alla classe più votata dai classificatori base
Ogni classificatore è costruito mediante bootstrap di un medesimo
trainining set
// k = numero di cicli di bootstrap N = card. del training set
// δ()=1 se l’argomento della funzione è TRUE, 0 altrimenti
for i=1 to k do
Crea un training set Di di dimensione N
Allena un classificatore Ci sul training set Di
end for
C*(x) = argmax∑δ (Ci (x) = y)
y
i
Il bagging migliora l’errore di generalizzazione riducendo la
componente variance
Il bagging sarà quindi particolarmente utile per quei tipi di
classificatori sensibili alle variazioni del training set
71
Bagging: un esempio
Classificatore di base: albero decisionale binario a un livello
Può solo fare scelte del tipo x≤s →0 x>s →1 dove s è lo split point
Il data set
x
y
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
1
1
1
-1
-1
-1
-1
1
1
1
1
L’accuratezza del classificatore base non può superare 70%
x≤0.3 →0 x>0.3 →1
x≤0.7 →0 x>0.7 →1
72
Bagging: le sessioni
73
Bagging: i risultati
Il bagging permette di ottenere il comportamento di un albero
decisionale a due livelli
Disegnare l’albero decisionale a due livelli
corrispondente al risultato del bagging
74
Boosting
Un approccio iterativo che permette di adattare progressivamente
la composizione del training set al fine di concentrarsi sui record
classificati in modo incorretto
Inizialmente, tutti gli N record hanno lo stesso peso (1/N)
Diversamente dal bagging, i pesi possono cambiare alla fine del round
di boosting in modo da aumentare la probailità del record di essere
selezionato nel training set
• Vengono aumentate le probabilità dei record che sono difficili da
classificare ossia che nel precedente round di boosting sono stati
classificati in modo incorretto
Il risultato finale si ottiene combinando il risultato le predizioni fatte dai
diversi classificatori
Le tecniche di boosting si differenziano in base a come:
sono aggiornati i pesi dei record del training set
sono combinate le predizioni dei classificatori
AdaBoost è una delle tecniche di boosting più utilizzate
75
AdaBoost
Siano C1, C2, …, CT i T classificatori di base ognuno utilizzato a un
ciclo di boost j ∈ [1,T]. Sia εj l’error rate:
εj =
1 N
∑ w i δ (C j (x i ) ≠ y i )
N i =1
(xi,yi) i=1..N record del training set
wi è il peso del i-esimo elemento del training set
δ()=1 se l’argomento è TRUE, 0 altrimenti
L’importanza di un classificatore è definita come:
1 1− ε j
2  ε j
α j = ln




αj assume valori positivi quando
l’error rate è prossimo a 0
αj assume valori negativi quando
l’error rate è prossimo a 1
AdaBoost
La regola per l’aggiornamento dei pesi del record i ad ogni ciclo di
boost j è:
−α
wi
( j +1)
=
w ij
Zj
e j
 αj
 e
if C j ( xi ) = y i
if C j ( x i ) ≠ y i
Zj è un fattore di normalizzazione per assicurare che
i
Il peso dei record classificati in modo corretto
si riduce, quello dei pesi classificati
in modo incorretto aumenta
∑ wij +1 = 1
25
20
15
10
eα
e-α
5
3
2
2.
5
1
1.
5
-0
0.
5
-1
-0
.5
-2
-1
.5
-3
-2
.5
0
Se un ciclo di boost produce un classificatore con error rate
maggiore di 50%, i pesi sono riportati 1/n
Il record è assegnato alla classe che massimizza la somma pesata:
C* ( x ) = arg max ∑ α j sign(C j ( x ) = y )
T
y
j =1
77
AdaBoost
1. w={wi=1/N i=1..N}
2. for j=1 to T do // numero dei cicli di boost
Crea un tr. set Dj campionando con replacement in base a w
3.
Allena un classificatore Cj utilizzando Dj
4.
Applica Cj a tutti gli esempi contenuti in D
5.
εj=1/N Σi wi δ(Cj(xi)≠yi) // Calcola l’errore pesato
6.
if εj > 0.5 then
7.
w={wi=1/N|i=1,2,…,N}; // reset!
8.
else
9.
αj=1/2 ln((1-εj)/εj);
10.
Aggiorna i pesi w;
11.
end if;
12.
13. end for;
T
14. C* (x) = arg max ∑ α j sign(C j ( x ) = y ) // sign restituisce 1/-1 se la
y
j =1
classificazione
è corretta/sbagliata
78
AdaBoost: un esempio
Classificatore di base: albero decisionale binario a un livello
Può solo fare scelte del tipo x≤s →0 x>s →1 dove s è lo split point
Il data set
x
y
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
1
1
1
-1
-1
-1
-1
1
1
1
1
L’accuratezza del classificatore base non può superare 70%
x≤0.3 →0 x>0.3 →1
x≤0.7 →0 x>0.7 →1
79
AdaBoost: un esempio
Split point: 0.75
ε1 =0.03
α1=1.738
Split point: 0.05
ε2 =0.004
α2=2.7784
Split point: 0.30
ε3 =0.00027
α3=4.1195
80
AdaBoost: un esempio
Il dataset
x
y
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
1
1
1
-1
-1
-1
-1
1
1
1
1
Il risultato
α1=1.738
α2=2.7784
α3=4.1195
5.16 = -1.738 + 2.7784 + 4.1195
Il classificatore non commette errori ed ha un comportamento ottenibile
con un albero a due livelli
81