1 data structures and algorithms for nearest neighbor search in general metric spaces peter n....

1

Data Structures and Algorithms Data Structures and Algorithms for Nearest Neighbor Search in for Nearest Neighbor Search in

General Metric SpacesGeneral Metric SpacesPeter N. Yanilos

Presentazione di:

Medri MatteoMedri Matteo

Tronconi FedericaTronconi Federica

Vassura AnnalisaVassura Annalisa

Sistemi informativi per le decisioni LS

2

SommarioSommario

Obiettivo: ricerca del Nearest Neighbor in un generico spazio metrico.

Come ridurre il tempo di ricerca? Ordinando opportunamente i dati.

Data Structures and Algorithms for Nearest Neighbor Search in General Metric Spaces

• Descrizione teorica dei VP-Tree

• Un algoritmo di ricerca del NN

• Risultati sperimentali: confronto con i KD-Tree nello spazio Euclideo

3

VP-treeVP-tree(Vantage Point)

• Sviluppato da Peter N. Yanilos nel 1986/87• Albero binario• Partizione ricorsiva dello spazio ad ogni

nodo tramite una funzione distanza (“tagli sferici” con centro in VP)

• Ordinano gli oggetti in modo da rendere più efficiente la ricerca del NN

• Tempi di costruzione: O(n log(n))• Tempo di ricerca: O(log(n))


4

Definizioni preliminariDefinizioni preliminari

• Spazio metrico (S,d)

• Database SD S

• Query q S

• Ricerca del Nearest Neighbor NN(q, SD)

• Distanza soglia

Per semplicità il range della funzione distanza verrà ristretto all’intervallo [0,1].


Ricerca “ristretta” del NN NN|NN|(q,S(q,SDD))

5

Definizioni (2)Definizioni (2)

p : S [0,1] / p(a) = d(a,p)

• dp : SxS [0,1] / dp(a,b) = |p (a)-p(b)|

Siano (S,d) uno spazio metrico limitato in [0,1] e p un elemento di S;per ogni a, b di S:

dp è una pseudo-metrica perché non soddisfa l’assioma di positività.

d(a,b) |d(a,p)-d(b,p)| = dp(a,b)

d domina dP!

y

x

q

Trovato y / d(q,y)

dp(q,x) d(q,x)


p

dp(q,x)

6

Split dei nodiSplit dei nodi

Dato p SD, definiamo p(SD) l’immagine di SD in [0,1].

La mediana µ di p(SD) divide l’intervallo in

• [0, µ [ punti interni alla sfera di centro p (SpL)

• [ µ,1 ] punti esterni e sulla superficie (SpR)

Generalmente pochi elementi sono sulla superficie, perciò avremo NR NL. SD

SpLSpR

p


7

Condizioni di pruningCondizioni di pruning

Data una query q:

Se p(q) µ + allora si può non considerare SpL nella ricerca del NN.

Se p(q) µ - allora si può non considerare SpR.

Se µ - < p(q) < µ + non è possibile alcuna esclusione.

SD

SpL

SpR

p


8

Formulazione probabilisticaFormulazione probabilistica


Sia x[0,1]. La probabilità della superficie della sfera S(p,x) è P(-1(x)). Per brevità indicheremo P(x).

Uno spazio metrico (S,d,P) ha Zero Probability Spheres (ZPS) property se:

P(SS(x,r)) = 0 xS, r0

dove: SS(x,r) = yS / d(y,x) = r

Assumiamo sia valida (semplificazione non banale!)Assumiamo sia valida (semplificazione non banale!)

Dato >0, N / [0,1] è divisibile in N parti ognuna di probabilità P<.

9

Due teoremiDue teoremi

1. Sia (S,d,P) uno spazio metrico in cui vale la ZPS. Ogni database SDS di dimensione n può essere organizzato in un albero binario. Dati M>0 e q, allora 0 / NN|(q,S) richiede al più MMloglog22(n) + 1(n) + 1 valutazioni.

2. Sia (S,d,P) uno spazio metrico in cui vale la ZPS. Dati la dimensione n e M>1, allora 0 / NN|(q,S) richiede al più MMloglog22(n) + 1(n) + 1 valutazioni.


10

Scelta del Vantage PointScelta del Vantage Point• Si vuole più grande possibile. dipende da p, quindi da p va scelto un VP “buono”

• 3 scelte naturali per il VP (pc, pm, pe)

La lunghezza b del confine tra i due sottospazi è

proporzionale alla probabilità di non-pruning


I VP migliori sono negli “angoli”

pc

pm pe

1

10

11

Algoritmi di costruzione: VP-TreeAlgoritmi di costruzione: VP-Tree• Select_vp sceglie il VP migliore

tra un insieme di candidati P• Ogni candidato è confrontato

con un campione di punti D• Si sceglie il VP con Deviazione

Standard (della distanza) maggiore

• Tempi di ricerca del NN inferiori (rispetto alla selezione random)

Function Make_vp_tree(S) if S=0 then return 0 new(node); node.p := Select_vp(S);

node.mu := MediansS d(p,s); L := sS-p | d(p,s)mu; R := sS-p | d(p,s)mu; node.left := Make_vp_tree(L); node.right := Make_vp_tree(R); return node;Function Select_vp(S) P := Random sample of S; best_spread := 0; for pP D := Random sample of S;

mu := MediandD d(p,d);

spread := 2nd-MomentdD (d(p,d) – mu); if spread > best_spread best_spread := spread; best_p := p; return best_p;

VP IDmu

leftright


12

VPVPss-Tree-Tree• Ad ogni elemento sono associati un

identificatore id e una lista hist• hist contiene le distanze

dell’elemento da ogni VP che lo precede

• Quando splitta un nodo, divide la lista list in L e R e aggiorna la hist di ogni elemento

• Ogni nodo contiene lower e upper bounds del suo sottospazio, riferiti a tutti i VP precedenti

Function Make_vps_tree(S) list = 0; for sS new(item); item.id := s; item.hist := 0; add item to list; return Recurse_vps_tree(list);Function Recurse_vps_tree(list) if list := 0 then return 0 new(node); node.p := Select_vp(list); delete node.p from list; for item list append d(p. item.id) to item.hist;

mu := Medianitemlist tail(item.hist); L := 0; R := 0; for item list if tail(item.hist) < mu then add item to L, delete from list; else add item to R, delete from list; node.left := Recurse_vps_tree(L); node.right := Recurse_vps_tree®; node.bnds := Merge(node.left.bnds, node.right.bnds, node.p.hist); return node;Function Merge(range_list1,range_list2,value_list)


13

VPVPss-Tree-Tree• Ad ogni elemento sono associati un

identificatore id e una lista hist• hist contiene le distanze

dell’elemento da ogni VP che lo precede

• Quando splitta un nodo, divide la lista list in L e R e aggiorna la hist di ogni elemento

• Ogni nodo contiene lower e upper bounds del suo sottospazio, riferiti a tutti i VP precedenti

Function Make_vps_tree(S) list = 0; for sS new(item); item.id := s; item.hist := 0; add item to list; return Recurse_vps_tree(list);Function Recurse_vps_tree(list) if list := 0 then return 0 new(node); node.p := Select_vp(list); delete node.p from list; for item list append d(p. item.id) to item.hist;

mu := Medianitemlist tail(item.hist); L := 0; R := 0; for item list if tail(item.hist) < mu then add item to L, delete from list; else add item to R, delete from list; node.left := Recurse_vps_tree(L); node.right := Recurse_vps_tree®; node.bnds := Merge(node.left.bnds, node.right.bnds, node.p.hist); return node;Function Merge(range_list1,range_list2,value_list)

right

left

Lower/upper

VP ID

Lower/upper

Lower/upper


14

VPVPsbsb-Tree-Tree• Crea buckets di foglie per risparmiare spazio

• Ogni bucket contiene nb records

• Ogni record si riferisce a un elemento e per questo specifica identificatore e le distanze dai VP precedenti

VP IDNb d(x,c)d(x,b)d(x,a) VP ID

a

c

b

Record dell’elemento x


15

Algoritmo di ricercaAlgoritmo di ricerca

• Ricerca il NN in VP-Tree in cui ogni nodo contiene bounds dei sottospazi figli

tiene traccia della distanza del NN già incontrato

• Il confronto con il valore middle determina l’ordine di esplorazione

• IL è l’intervallo compreso tra n.left_bnd[low]- e n.left_bnd[high]+

• Analogamente è definito IR

• Ha complessità O(log(n))


Procedure Search(n) if n = 0 then return; x := d(q,n.id); if x < tau then tau := x; best := n.id; middle := (n.left_bnd[high] + n.right_bnd[low]) / 2; if x < middle then

if x IL then Search(n.left);

if x IR then Search(n.right); else

if x IR then Search(n.right);

if x IL then Search(n.left);

16

Risultati sperimentaliRisultati sperimentaliSono state confrontate le performances di VP-Tree e KD-Tree, utilizzando diverse metriche (L1, L2, L)


• Introdotti da Friedman e Bentley nel 1977• Dividono ricorsivamente il database con tagli

monodimensionali (su una sola coordinata)• Per lo split si sceglie l’attributo sul quale la

distribuzione è più “larga”• Funzionano bene in spazi Euclidei di moderate

dimensioni

KD-TreeKD-Tree

17

Risultati sperimentaliRisultati sperimentali


In 8 dimensioni, KD_Tree ha performance intermedie a quelle dei due tipi di VP-Tree

1

10

100

1000

10000

100000

2 4 6 8 10 12 14

Dimensioni

Nu

me

ro m

ed

io d

i no

di

vis

ita

ti VP-Tree

KD-Tree

In 12 dimensioni, per dimensioni del database sopra i 30000 elementi, KD-Tree si dimostra il migliore (nonostante la sua performance non sia comunque buona: viene visitato il 25% dei nodi)

In L1 al crescere delle dimensioni, VPs-Tree e VP-Tree scalano meglio di KD-Tree

Mentre in L2 le prestazioni sono confrontabili

0200400600800

100012001400160018002000

Dimensioni

Nu

me

ro m

ed

io d

i n

od

i vi

sita

ti VPS-Tree

VP-Tree

KD-TreeNonostante i VP-Trees ignorino la struttura a Nonostante i VP-Trees ignorino la struttura a

coordinate dello spazio sono confrontabili nei tempi coordinate dello spazio sono confrontabili nei tempi di ricerca con i KD-Tree.di ricerca con i KD-Tree.

18

Risultati sperimentaliRisultati sperimentali• Attraverso matrici di rotazione lineare mappiamo database

definiti in Rm in Rn, dove n>m.• Dai risultati sperimentali in tabella si evince che i VP-Tree

rappresentano l’approccio migliore per la ricerca del NN quando non si conosce la struttura interna del database.


KD

R2 R2R10 R10

21 3833 816

VP 15 279 1048

VPS 12 246 698

19

Ricerca del NN di immaginiRicerca del NN di immagini

• Query presenti nel database visita d nodi• Query “vicine” a elementi del DB visita 5% dei nodi• Query “lontane” da elementi del DB visita 15% dei nodi

• Similar (simile ad almeno una di ogni VP-Tree)• General (immagini diverse da quelle della libreria )

Libreria di 16 immagini, ognuna 604x486 pixels.Uso della metrica Euclidea.

4 VP-Tree di 4 immagini ognuno; 2 fonti di query:


Queries 4x4 8x8 16x16 32x32 50x50

Similar 1.0% 3.4% 4.5% 4.5% 5.2%

General 1.4% 5.7% 10.7% 15.7% 19.3%

20

Ricerca del NN di immagini (2)Ricerca del NN di immagini (2)• I KD-Tree danno performances pessime• L’uso di VPsb-Tree permette miglioramenti del 15-30% (rispetto

ai VP-Tree)• Riducendo si riduce significativamente il tempo della VP-Tree

Search…………ma ne risente l’efficacia!

Per molte queries non trovo Per molte queries non trovo alcun Nearest Neighboralcun Nearest Neighbor

TrovareTrovare il NN e ProvareProvare che è il NN sono cose

diverse


La seconda fase è spesso la più onerosa (in termini

di complessità computazionale) !

21

ConclusioniConclusioni


Spazi vettorialie metrici

Complessità diRicerca O(log(n))

Puntidi

forza

Usa solo unafunzione distanza

VP e “buoni”Alta probabilità

di pruning

Ma le prestazioni di VP-Tree degradano alcrescere del numero di elementi del database!

22

Spazi metriciSpazi metrici

• d(x,y) 0, d(x,y) = 0 x = y (positivity)• d(x,y) = d(y,x) (simmetry)• d(x,y) d(x,z) + d(z,y) (triangle inequality)

Uno spazio metrico M = (U,d) è una coppia, dove U è il dominio dei valori e d è una funzione distanza che, x, y, z U, soddisfa gli assiomi metrici:

Infatti, dp(a,b) = 0 anche se a e b sono punti

distinti equidistanti da p


23

N-ary VP-TreeN-ary VP-Tree

• Trova le distanze tra VP e gli altri elementi del database

• In base alle distanze il database è diviso in N sottospazi, “più o meno” di uguali dimensioni

xSi, i-1 d(x,p) i

• Data una query q, saranno esplorati i sottospazi Si t.c. i - < d(q,p) i+1+


Si-1 Si Si+1d(x,p)

i-2 i-1 i i+1

1 data structures and algorithms for nearest neighbor search in general metric spaces peter n....

Documents

x slide

general metric spaces

general metric spaces

general metric spaces

query q

nnnn q

nearest neighbornnq

generico spazio metrico