¿Cómo kernelize un perceptrón simple?

Los problemas de clasificación con límites no lineales no se pueden resolver con un simple perceptrón . El siguiente código R tiene fines ilustrativos y se basa en este ejemplo en 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

Ahora, la idea de un kernel y el llamado truco del kernel es proyectar el espacio de entrada en un espacio dimensional más alto, de esta manera ( fuentes de fotos ):

Mi pregunta
¿Cómo hago uso del truco del núcleo (p. Ej., Con un núcleo cuadrático simple) para obtener un perceptrón del núcleo , que puede resolver el problema de clasificación dado? Tenga en cuenta: esta es principalmente una pregunta conceptual, pero si también pudiera dar la modificación de código necesaria, sería genial

Lo que probé hasta ahora
probé lo siguiente, que funciona bien, pero creo que este no es el verdadero negocio porque se vuelve computacionalmente demasiado costoso para problemas más complejos (el "truco" detrás del "truco del núcleo" no es solo la idea de un kernel en sí, pero que no tiene que calcular la proyección para todas las instancias):

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)

Divulgación completa Publiqué
esta pregunta hace una semana en SO, pero no recibió mucha atención. Sospecho que este es un lugar mejor porque es más una pregunta conceptual que una pregunta de programación.

$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}$

Como se menciona en la página de Wikipedia sobre el perceptrón del núcleo , seleccionamos un subconjunto de tamaño de las entradas y usamos una combinación lineal de ellas para producir nuestra salida, $M$

Si ha visto la máquina de vectores de soporte ( SVM ), notará el doble idéntico. Para seleccionar el subconjunto de tamaño a utilizar, optimizamos sobre , que representa si la muestra es un vector de soporte / base de nuestra solución. En la optimización de incluimos los pesos de la optimización original de perceptrón.$M$$\alpha_i$$i$$\alpha_i$$\omega_i$

En cuanto a su pregunta sobre no tener que calcular la proyección, tiene razón, su matriz de datos de entrada todavía es bidimensional. En el cálculo de la salida, reemplazamos un producto de puntos con la función del núcleo, y aquí es donde ocurre el cálculo 'implícito' en el espacio de características.$X$