Como kernelizar um perceptron simples?

Problemas de classificação com limites não lineares não podem ser resolvidos por um simples perceptron . O código R a seguir é para fins ilustrativos e baseia-se neste exemplo em 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

Agora, a idéia de um kernel e o chamado truque do kernel é projetar o espaço de entrada em um espaço dimensional mais alto, assim ( fontes de fotos ):

Minha pergunta
Como faço para usar o truque do kernel (por exemplo, com um simples kernel quadrático) para obter um perceptron do kernel , capaz de resolver o problema de classificação fornecido? Observe: Essa é principalmente uma questão conceitual, mas se você também puder fornecer a modificação de código necessária, isso seria ótimo

O que tentei até agora
, tentei o seguinte, que funciona bem, mas acho que esse não é o negócio real, porque se torna computacionalmente muito caro para problemas mais complexos (o "truque" por trás do "truque do kernel" não é apenas a idéia de um próprio kernel, mas que você não precisa calcular a projeção para todas as instâncias):

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)

Divulgação completa
Eu publiquei essa pergunta há uma semana no SO, mas ela não recebeu muita atenção. Suspeito que aqui seja um lugar melhor porque é mais uma questão conceitual do que uma questão de programação.

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

$M$

$M$$\alpha_i$$i$$\alpha_i$$\omega_i$

$X$