Comment amorcer un perceptron simple?

Les problèmes de classification avec des limites non linéaires ne peuvent pas être résolus par un simple perceptron . Le code R suivant est à des fins d'illustration et est basé sur cet exemple 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

Maintenant, l'idée d'un noyau et la soi-disant astuce du noyau est de projeter l'espace d'entrée dans un espace de dimension supérieure, comme ceci ( sources de photos ):

Ma question
Comment utiliser l'astuce du noyau (par exemple avec un noyau quadratique simple) pour obtenir un perceptron du noyau , capable de résoudre le problème de classification donné? Remarque: il s'agit principalement d'une question conceptuelle, mais si vous pouviez également apporter la modification de code nécessaire, ce serait parfait

Ce que j'ai essayé jusqu'à présent,
j'ai essayé ce qui suit, mais je pense que ce n'est pas la vraie affaire car cela devient trop coûteux en calcul pour des problèmes plus complexes (le "truc" derrière le "truc du noyau" n'est pas seulement l'idée d'un noyau lui-même mais que vous n'avez pas à calculer la projection pour toutes les instances):

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)

Divulgation complète
J'ai posté cette question il y a une semaine sur SO mais cela n'a pas attiré beaucoup d'attention. Je soupçonne que c'est un meilleur endroit parce que c'est plus une question conceptuelle qu'une question de programmation.

Nous pouvons construire un "perceptron noyau" en prenant le perceptron standard et en remplaçant le produit interne par l'équivalent (en raison du "kernel-trick") de la forme K (X ,X). Cela fonctionne car nous avons que le produit interne est une carte , qui a des propriétés identiques à la fonction du noyau . Comme dans le cas du noyau de fonction de base radiale gaussienne (RBF) : $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}$

Comme mentionné dans la page Wikipedia sur le perceptron du noyau , nous sélectionnons un sous-ensemble de taille des entrées et utilisons une combinaison linéaire d'entre eux pour produire notre sortie, $M$

Si vous avez vu la machine à vecteur de support ( SVM ), vous remarquerez le double identique. Pour sélectionner le sous-ensemble de taille à utiliser, nous optimisons sur , qui représentent si l'échantillon est un vecteur support / base de notre solution. Dans l'optimisation du nous incluons les poids de l'optimisation originale du perceptron.$M$$\alpha_i$$i$$\alpha_i$$\omega_i$

Quant à votre question sur le fait de ne pas avoir à calculer la projection, vous avez raison, votre matrice de données d'entrée est toujours bidimensionnelle. Dans le calcul de la sortie , nous avons remplacé un produit scalaire avec la fonction du noyau, et c'est là que le calcul « implicite » dans l'espace de représentation se produit.$X$