k-NN complessità computazionale

Qual è la complessità temporale dell'algoritmo k -NN con approccio di ricerca ingenuo (nessun albero kd o simili)?

Sono interessato alla sua complessità temporale considerando anche l'iperparametro k . Ho trovato risposte contraddittorie:

1. O (nd + kn), dove n è la cardinalità dell'insieme formazione e d la dimensione di ogni campione. [1]

2. O (NDK), dove ancora una volta n è la cardinalità dell'insieme formazione e d la dimensione di ogni campione. [2]

[1] http://www.csd.uwo.ca/courses/CS9840a/Lecture2_knn.pdf (Pag. 18/20)

[2] http://www.cs.haifa.ac.il/~rita/ml_course/lectures/KNN.pdf (Pag. 18/31)

Supponendo che sia fisso (come fanno entrambe le lezioni collegate), le tue scelte algoritmiche determineranno se il tuo calcolo richiede runtime O ( n d + k n ) o runtime O ( n d k ) .$k$$O(nd+kn)$$O(ndk)$

Innanzitutto, consideriamo un algoritmo di runtime :$O(nd+kn)$

• Inizializza per tutte le osservazioni i nel set di addestramento$selected_i = 0$$i$
• Per ogni osservazione del set di allenamento , calcolare d i s t i , la distanza dalla nuova osservazione all'osservazione del set di allenamento $i$$dist_i$$i$
• Per a k : scorrere tutte le osservazioni del set di allenamento, selezionando l'indice i con il valore d i s t i più piccolo e per il quale s e l e c t e d i = 0 . Seleziona questa osservazione impostando s e l e c t e d i = 1 .$j=1$$k$$i$$dist_i$$selected_i=0$$selected_i=1$
• Restituisce i indici selezionati$k$

Ogni calcolo della distanza richiede il runtime , quindi il secondo passo richiede il runtime O ( n d ) . Per ogni iterazione nel terzo passaggio, eseguiamo il lavoro O ( n ) eseguendo il ciclo attraverso le osservazioni del set di addestramento, quindi il passaggio richiede in generale il lavoro O ( n k ) . Il primo e il quarto passaggio richiedono solo il lavoro O ( n ) , quindi otteniamo un runtime O ( n d + k n ) .$O(d)$$O(nd)$$O(n)$$O(nk)$$O(n)$$O(nd+kn)$

Consideriamo ora un algoritmo di runtime :$O(ndk)$

• Inizializza per tutte le osservazioni i nel set di addestramento$selected_i = 0$$i$
• Per a k : scorrere tutte le osservazioni del set di allenamento e calcolare la distanza d tra l'osservazione del set di allenamento selezionata e la nuova osservazione. Seleziona l'indice i con il valore d più piccolo per il quale s e l e c t e d i = 0 . Seleziona questa osservazione impostando s e l e c t e d i = 1 .$j=1$$k$$d$$i$$d$$selected_i=0$$selected_i=1$
• Restituisce i indici selezionati$k$

Per ogni iterazione nella seconda fase, calcoliamo la distanza tra la nuova osservazione e ciascuna osservazione del set di addestramento, richiedendo lavoro per un'iterazione e quindi O ( n d k ) nel complesso.$O(nd)$$O(ndk)$

La differenza tra i due algoritmi è che il primo precompute e memorizza le distanze (richiedendo memoria aggiuntiva), mentre il secondo no. Tuttavia, dato che memorizziamo già l'intero set di training, richiedendo memoria O ( n d ) , nonché il vettore s e l e c t e d , che richiede archiviazione O ( n ) , la memorizzazione dei due algoritmi è asintoticamente il stesso. Di conseguenza, il miglior tempo di esecuzione asintotico per k > 1 rende il primo algoritmo più attraente.$O(n)$$O(nd)$$selected$$O(n)$$k > 1$

Vale la pena notare che è possibile ottenere un runtime usando un miglioramento algoritmico:$O(nd)$

• Per ogni osservazione del set di allenamento , calcolare d i s t i , la distanza dalla nuova osservazione all'osservazione del set di allenamento $i$$dist_i$$i$
• Eseguire l' algoritmo di QuickSelect per calcolare la più piccola distanza in O ( n ) runtime$k^{th}$$O(n)$
• Restituire tutti gli indici di dimensioni non superiori alla calcolata piccola distanza$k^{th}$

Questo approccio sfrutta il fatto che gli approcci efficaci esistono per trovare il valore più piccolo in un array non ordinato.$k^{th}$