FastICA

FastICA è un popolare algoritmo per l'analisi delle componenti indipendenti, sviluppato da Aapo Hyvärinen presso la Helsinki University of Technology. L'algoritmo è basato su un punto fisso, schema iterativo per massimizzare la non-gaussianità di una misura statistica di indipendenza. L'algoritmo può anche essere derivato dall'iterazione approssimata di Newton.

Algoritmo

FastICA per una componente

L'algoritmo iterativo trova la direzione per il vettore di pesi $𝐰$ massimizzando la non-gaussianità della proiezione ${𝐰}^T𝐱$ per $𝐱$. La funzione $g(\cdot )$ è la derivata di una funzione nonquadrata.

1. Scegliere un vettori pesi iniziale $𝐰$
2. Sia ${𝐰}^{+}\leftarrow E\{𝐱g({𝐰}^T𝐱)\}-E\{g^{\prime }({𝐰}^T𝐱)\}𝐰$
3. Sia $𝐰\leftarrow {𝐰}^{+}/\Vert {𝐰}^{+}\Vert$
4. se non converge, torna al punto 2

In questo caso, come convergenza si intende il verificarsi della situazione per cui i valori di $𝐰$ riferiti a 2 iterazioni successive puntano nella stessa direzione.

Alcuni esempi di funzioni $g(\cdot )$ sono:

• $g(u)=\tanh (au)$
• $g(u)=uexp\left(\frac{-u^2}{2}\right)$

I massimi relativi all'approssimazione della negentropia di ${𝐰}^T𝐱$ sono ottenuti in corrispondenza di alcuni risultati dell'ottimizzazione della funzione $E\{G({𝐰}^T𝐱)\}$; in accordo con le condizioni di Karush-Kuhn-Tucker, gli ottimi della funzione $E\{G({𝐰}^T𝐱)\}$ con il vincolo $E\{({𝐰}^T𝐱{)}^2\}=||{𝐰}^2||=1$ sono ottenuti nei punti in cui si verifica: $E\{𝐱g({𝐰}^T𝐱)\}-\beta 𝐰=0$

Risolvendo l'equazione con il metodo di Newton e definendo la parte sinistra dell'equazione con F, si ottiene la matrice Jacobiana JF(w) come: $JF(𝐰)=E\{𝐱{𝐱}^T{g}^{\prime }({𝐰}^T𝐱)\}-\beta 𝐈$ Per semplificare l'inversione di questa matrice, risulta utile approssimare il primo termine; se i dati sono centrati (valore medio nullo) e sbiancati (whitening), si può approssimare così: $E\{𝐱{𝐱}^T{g}^{\prime }({𝐰}^T𝐱)\}=E\{𝐱{𝐱}^T)\}E\{g^{\prime }({𝐰}^T𝐱)\}=E\{g^{\prime }({𝐰}^T𝐱)\}𝐈$

Applicandola, la matrice jacobiana diventa una matrice diagonale, e può quindi essere facilmente invertibile. Si ottiene quindi un'iterazione di Newton approssimata:

${𝐰}^{+}=𝐰-\frac{[E\{𝐱g({𝐰}^T𝐱)\}-\beta 𝐰]}{[E\{g^{\prime }({𝐰}^T𝐱)\}-\beta ]}$

L'algoritmo può essere ulteriormente semplificato moltiplicando entrambe le parti per $\beta -E\{g^{\prime }({𝐰}^T𝐱)\}$, dando origine al vero e proprio algoritmo FastICA.

(L'algoritmo usa un'approssimazione della negentropia, che fa uso della curtosi).

FastICA per più componenti

L'algoritmo descritto per una componente permette di ricavare una sola delle componenti indipendenti. Per poterne stimare di più è necessario applicare l'algoritmo ad un insieme di n unità, caratterizzati da vettori di pesi ${𝐰}_1,...,{𝐰}_n$.

L'applicazione dell'algoritmo è la stessa, ma bisogna impedire che più neuroni presentino una convergenza nei confronti dello stesso massimo, ovvero bisogna scorrelare le uscite della rete ${𝐰}_1^T𝐱,...,{𝐰}_n^T𝐱$ alla fine di ciascuna iterazione. Per fare questo esistono almeno tre metodi in letteratura.

Caratteristiche dell'algoritmo

• la convergenza è cubica assumendo un modello ICA, rendendo quindi l'algoritmo più veloce rispetto ai classici metodi basati sulla discesa del gradiente, che sono caratterizzati da convergenza lineare.
• l'algoritmo gode di una grande facilità d'uso, anche perché non vi sono troppi parametri da impostare.
• FastICA riesce a trovare le componenti indipendenti di quasi tutte le distribuzioni gaussiane mediante qualsiasi funzione non lineare g, a differenza di altre tecniche che necessitano di informazioni a priori sulle distribuzioni.
• Le componenti indipendenti possono essere stimate una per una, facendo di questo strumento uno strumento importante per l'analisi esplorativa dei dati e riducendo l'onere computazionale.
• L'algoritmo condivide con gli approcci neurali le caratteristiche desiderabili: è parallelo, distribuito, computazionalmente flessibile e poco esigente in termini di memoria utilizzata.

Voci correlate

• analisi delle componenti indipendenti

Collegamenti esterni

• Template:Cita web
• pacchetto fastICA in linguaggio di programmazione R