Come creare un kernel perceptron semplice?

I problemi di classificazione con confini non lineari non possono essere risolti da un semplice percettrone . Il seguente codice R è a scopo illustrativo e si basa su questo esempio in Python):

nonlin <- function(x, deriv = F) {
  if (deriv) x*(1-x)
  else 1/(1+exp(-x))
}

X <- matrix(c(-3,1,
              -2,1,
              -1,1,
               0,1,
               1,1,
               2,1,
               3,1), ncol=2, byrow=T)

y <- c(0,0,1,1,1,0,0)

syn0 <- runif(2,-1,1)

for (iter in 1:100000) {
  l1 <- nonlin(X %*% syn0)
  l1_error <- y - l1
  l1_delta <- l1_error * nonlin(l1,T)
  syn0 <- syn0 + t(X) %*% l1_delta
}

print("Output After Training:")
## [1] "Output After Training:"
round(l1,3)
##       [,1]
## [1,] 0.488
## [2,] 0.468
## [3,] 0.449
## [4,] 0.429
## [5,] 0.410
## [6,] 0.391
## [7,] 0.373

Ora l'idea di un kernel e il cosiddetto trucco del kernel è di proiettare lo spazio di input in uno spazio dimensionale superiore, in questo modo ( fonti di immagini ):

La mia domanda
Come posso utilizzare il trucco del kernel (ad esempio con un semplice kernel quadratico) in modo da ottenere un perceptron del kernel , in grado di risolvere il problema di classificazione dato? Nota: questa è principalmente una domanda concettuale, ma se anche tu potessi dare la necessaria modifica del codice sarebbe fantastico

Quello che ho provato finora
ho provato quanto segue che funziona bene, ma penso che questo non sia un vero affare perché diventa computazionalmente troppo costoso per problemi più complessi (il "trucco" dietro il "trucco del kernel" non è solo l'idea di un kernel stesso ma che non è necessario calcolare la proiezione per tutte le istanze):

X <- matrix(c(-3,9,1,
              -2,4,1,
              -1,1,1,
               0,0,1,
               1,1,1,
               2,4,1,
               3,9,1), ncol=3, byrow=T)

y <- c(0,0,1,1,1,0,0)

syn0 <- runif(3,-1,1)

Full Disclosure
Ho pubblicato questa domanda una settimana fa su SO ma non ha ottenuto molta attenzione. Sospetto che qui sia un posto migliore perché è più una domanda concettuale che una domanda di programmazione.

— vonjd
fonte

$X^\intercal X=\left<X,X\right>$ $<\cdot,\cdot>:\mathbb{R}^p\times\mathbb{R}^p\to\mathbb{R}$ $k:\mathbb{R}^p\times\mathbb{R}^p\to\mathbb{R}$

K (x_{i}, x_{j}) = \exp (- \frac{{| | x_{i} - x_{j} | |}^{2}}{2 σ^{2}})

$K(x_i,x_j)=\exp\left(-\frac{{\left|\left|x_i-x_j\right|\right|}^2}{2\sigma^2}\right)$

Come menzionato nella pagina di Wikipedia sul perceptron del kernel , selezioniamo un sottoinsieme di dimensioni degli input e usiamo una loro combinazione lineare per produrre il nostro output, $M$

f (x) = \sum_{i}^{M} α_{i} y_{i} K (x, x_{i})

$f(x) = \sum\limits_i^M \alpha_i y_i K(x,x_i)$

Se hai visto la macchina vettoriale di supporto ( SVM ), noterai il doppio identico. Per selezionare il sottoinsieme di dimensioni da utilizzare, ottimizziamo su , che rappresenta se il campione è un vettore supporto / base della nostra soluzione. Nell'ottimizzazione di includiamo i pesi dell'ottimizzazione percettiva originale. $M$ $\alpha_i$ $i$ $\alpha_i$ $\omega_i$

Per quanto riguarda la tua domanda sul non dover calcolare la proiezione, hai ragione, la tua matrice di dati di input è ancora bidimensionale. Nel calcolo dell'uscita abbiamo sostituito un prodotto scalare con la funzione di kernel, e questo è dove avviene il calcolo 'implicito' nello spazio delle caratteristiche. $X$

— Kellan Fluette
fonte

Kernel di funzione base radiale gaussiana , Support vector machine (SVM)

— Kellan Fluette,

Grazie - Potresti forse rendere la tua risposta più concreta, nel senso che dichiari quali righe nel codice dall'alto devono essere modificate in che modo. Se non si conosce R, le modifiche possono ovviamente essere dichiarate in pseudocodice. Accetterei quindi felicemente la tua risposta :-)

— vonjd

Il mio post su cui hai basato il tuo codice è, a mio avviso, una cattiva presentazione di percetroni e back-propagation, anche se sicuramente è conciso. Sai come funziona la propagazione della schiena e la teoria del percettrone generale?

— Kellan Fluette,

Beh, fino a un certo punto, spero. Cosa stai ottenendo esattamente? Come modificheresti il codice sopra per usare il trucco del kernel con un kernel quadratico?

— vonjd,

Non esiste un $ \ vec {x} ^ \ intercal \ vec {x) $ nel doppio lagrangiano del criterio di percezione? È in particolare che sostituisci il prodotto interno con la valutazione della funzione del kernel.

— Kellan Fluette,