Bagaimana cara kernelisasi perceptron sederhana?

Masalah klasifikasi dengan batas nonlinier tidak dapat diselesaikan dengan perceptron sederhana . Kode R berikut adalah untuk tujuan ilustrasi dan didasarkan pada contoh ini dengan 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

Sekarang ide dari sebuah kernel dan trik yang disebut dengan kernel adalah memproyeksikan ruang input ke ruang dimensi yang lebih tinggi, seperti ( sumber foto ):

Pertanyaan saya
Bagaimana cara memanfaatkan trik kernel (mis. Dengan kernel kuadratik sederhana) sehingga saya mendapatkan kernel perceptron , yang mampu menyelesaikan masalah klasifikasi yang diberikan? Harap dicatat: Ini terutama pertanyaan konseptual tetapi jika Anda juga bisa memberikan modifikasi kode yang diperlukan ini akan bagus

Apa yang saya coba sejauh ini
saya mencoba yang berikut ini yang berfungsi dengan baik tetapi saya pikir ini bukan masalah yang sebenarnya karena menjadi terlalu mahal secara komputasi untuk masalah yang lebih kompleks ("trik" di balik "trik kernel" bukan hanya gagasan tentang kernel itu sendiri tetapi Anda tidak harus menghitung proyeksi untuk semua instance):

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)

Pengungkapan Penuh
Saya memposting pertanyaan ini seminggu yang lalu pada SO tetapi tidak mendapat banyak perhatian. Saya menduga bahwa ini adalah tempat yang lebih baik karena ini lebih merupakan pertanyaan konseptual daripada pertanyaan pemrograman.

Kita dapat membangun "kernel perceptron" dengan mengambil perceptron standar dan mengganti produk dalam dengan yang setara (karena "trik-kernel") dari K (X , X). Ini berfungsi karena kita memiliki bahwa produk dalam adalah peta , yang memiliki sifat identik dengan fungsi kernel . Seperti dalam kasus kernel fungsi dasar radial Gaussian umum (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}$

Seperti disebutkan di halaman Wikipedia pada kernel perceptron , kami memilih subset ukuran dari input dan menggunakan kombinasi linear dari mereka untuk menghasilkan output kami, $M$

Jika Anda telah melihat mesin vektor dukungan ( SVM ), Anda akan melihat dual identik. Untuk memilih subset dari ukuran untuk digunakan, kami mengoptimalkan lebih dari , yang mewakili apakah sampel adalah vektor basis / dukungan dari solusi kami. Dalam optimalisasi kami menyertakan bobot dari optimasi perceptron asli.$M$$\alpha_i$$i$$\alpha_i$$\omega_i$

Mengenai pertanyaan Anda tentang tidak harus menghitung proyeksi, Anda benar, matriks data input masih 2 dimensi. Dalam perhitungan output, kami mengganti produk titik dengan fungsi kernel, dan ini adalah tempat perhitungan 'implisit' dalam ruang fitur terjadi.$X$