Muitos classificadores de aprendizado de máquina (por exemplo, máquinas de vetores de suporte) permitem especificar um kernel. Qual seria uma maneira intuitiva de explicar o que é um kernel?

Um aspecto em que tenho pensado é a distinção entre núcleos lineares e não lineares. Em termos simples, eu poderia falar de 'funções de decisão lineares' e 'funções de decisão não lineares'. No entanto, não tenho certeza se chamar um kernel de 'função de decisão' é uma boa idéia.

Sugestões?

O kernel é uma maneira de calcular o produto escalar de dois vetores e em alguns espaços (possivelmente com dimensões muito altas), razão pela qual as funções do kernel são algumas vezes chamadas de "produto escalar generalizado".$\mathbf x$$\mathbf y$

Suponha que tenhamos um mapeamento que traga nossos vetores em para algum espaço de recurso . Em seguida, o produto escalar de e neste espaço é . Um kernel é uma função que corresponde a esse produto escalar, ou seja, .R n R m x y φ( x ) T φ( y )kk( x , y )=φ( x ) T φ( y$\varphi \, : \, \mathbb R^n \to \mathbb R^m$$\mathbb R^n$$\mathbb R^m$$\mathbf x$$\mathbf y$$\varphi(\mathbf x)^T \varphi(\mathbf y)$$k$$k(\mathbf x, \mathbf y) = \varphi(\mathbf x)^T \varphi(\mathbf y)$

Por que isso é útil? Os kernels permitem calcular produtos de ponto em algum espaço de recurso sem nem mesmo saber o que é esse espaço e o que é .$\varphi$

Por exemplo, considere um kernel polinomial simples com . Isso não parece corresponder a nenhuma função de mapeamento , é apenas uma função que retorna um número real. Supondo que e , vamos expandir esta expressão:x , y ∈ R 2 φ x = ( x 1 , x 2 ) y = ( Y 1 , Y 2$k(\mathbf x, \mathbf y) = (1 + \mathbf x^T \mathbf y)^2$$\mathbf x, \mathbf y \in \mathbb R^2$$\varphi$$\mathbf x = (x_1, x_2)$$\mathbf y = (y_1, y_2)$

$\begin{align} k(\mathbf x, \mathbf y) & = (1 + \mathbf x^T \mathbf y)^2 = (1 + x_1 \, y_1 + x_2 \, y_2)^2 = \\ & = 1 + x_1^2 y_1^2 + x_2^2 y_2^2 + 2 x_1 y_1 + 2 x_2 y_2 + 2 x_1 x_2 y_1 y_2 \end{align}$

Observe que isso nada mais é do que um produto escalar entre dois vetores e e . Portanto, o kernel calcula um produto de ponto em Espaço 6-dimensional sem visitar explicitamente este espaço.$(1, x_1^2, x_2^2, \sqrt{2} x_1, \sqrt{2} x_2, \sqrt{2} x_1 x_2)$$(1, y_1^2, y_2^2, \sqrt{2} y_1, \sqrt{2} y_2, \sqrt{2} y_1 y_2)$$\varphi(\mathbf x) = \varphi(x_1, x_2) = (1, x_1^2, x_2^2, \sqrt{2} x_1, \sqrt{2} x_2, \sqrt{2} x_1 x_2)$$k(\mathbf x, \mathbf y) = (1 + \mathbf x^T \mathbf y)^2 = \varphi(\mathbf x)^T \varphi(\mathbf y)$

Outro exemplo é o kernel gaussiano . Se expandirmos essa função por Taylor, veremos que ela corresponde a um codomain de dimensão infinita de .$k(\mathbf x, \mathbf y) = \exp\big(- \gamma \, \|\mathbf x - \mathbf y\|^2 \big)$$\varphi$

Por fim, eu recomendaria um curso on-line "Learning from Data", do professor Yaser Abu-Mostafa, como uma boa introdução aos métodos baseados em kernel. Especificamente, as palestras "Support Vector Machines" , "Kernel Methods" e "Radial Basis Functions" são sobre kernels.

Uma maneira muito simples e intuitiva de pensar sobre kernels (pelo menos para SVMs) é uma função de similaridade. Dados dois objetos, o kernel gera alguma pontuação de similaridade. Os objetos podem ser qualquer coisa, a partir de dois números inteiros, dois vetores com valor real, árvores o que for, desde que a função do kernel saiba como compará-los.

O exemplo sem dúvida mais simples é o kernel linear, também chamado de produto pontual. Dados dois vetores, a semelhança é o comprimento da projeção de um vetor em outro.

Outros exemplos interessantes de kernel são o kernel gaussiano. Dados dois vetores, a semelhança diminuirá com o raio de . A distância entre dois objetos é "re-ponderada" por este parâmetro de raio.$\sigma$

O sucesso do aprendizado com kernels (novamente, pelo menos para SVMs) depende muito fortemente da escolha do kernel. Você pode ver um kernel como uma representação compacta do conhecimento sobre seu problema de classificação. Muitas vezes, é específico do problema.

Eu não chamaria um kernel de função de decisão, pois o kernel é usado dentro da função de decisão. Dado um ponto de dados para classificar, a função de decisão faz uso do kernel comparando esse ponto de dados com vários vetores de suporte ponderados pelos parâmetros aprendidos . Os vetores de suporte estão no domínio desse ponto de dados e, ao longo dos parâmetros aprendidos são encontrados pelo algoritmo de aprendizado.$\alpha$$\alpha$

Um exemplo visual para ajudar a intuição

Considere o seguinte conjunto de dados em que os pontos amarelo e azul claramente não são separáveis ​​linearmente em duas dimensões.

Se pudéssemos encontrar um espaço dimensional mais alto no qual esses pontos fossem linearmente separáveis , poderíamos fazer o seguinte:

• Mapeie os recursos originais para o espaço superior do transformador (mapeamento de recursos)
• Realize SVM linear neste espaço superior
• Obter um conjunto de pesos correspondente ao hiperplano de limite de decisão
• Mapeie este hiperplano de volta ao espaço 2D original para obter um limite de decisão não linear

Existem muitos espaços dimensionais mais altos nos quais esses pontos são linearmente separáveis. Aqui está um exemplo

$$x_1, x_2 : \rightarrow z_1, z_2, z_3$$ $$z_1 = \sqrt{2}x_1x_2 \ \ z_2 = x_1^2 \ \ z_3 = x_2^2$$

É aqui que o truque do Kernel entra em cena. Citando as excelentes respostas acima

Suponha que tenhamos um mapeamento que traga nossos vetores em para algum espaço de recurso . Em seguida, o produto escalar de e neste espaço é . Um kernel é uma função que corresponde a esse produto escalar, ou seja,$\varphi \, : \, \mathbb R^n \to \mathbb R^m$$\mathbb R^n$$\mathbb R^m$$\mathbf x$$\mathbf y$$\varphi(\mathbf x)^T \varphi(\mathbf y)$$k$$k(\mathbf x, \mathbf y) = \varphi(\mathbf x)^T \varphi(\mathbf y)$

Se pudéssemos encontrar uma função do kernel equivalente ao mapa de recursos acima, poderíamos conectar a função do kernel no SVM linear e executar os cálculos com muita eficiência.

Kernel polinomial

Acontece que o mapa de recursos acima corresponde ao conhecido polinômio do kernel : . Seja e obtemos$K(\mathbf{x},\mathbf{x'}) = (\mathbf{x}^T\mathbf{x'})^d$$d = 2$$\mathbf{x} = (x_1, x_2)^T$

$$\begin{aligned} k(\begin{pmatrix} x_1 \\ x_2 \end{pmatrix}, \begin{pmatrix} x_1' \\ x_2' \end{pmatrix} ) & = (x_1x_2' + x_2x_2')^2 \\ & = 2x_1x_1'x_2x_2' + (x_1x_1')^2 + (x_2x_2')^2 \\ & = (\sqrt{2}x_1x_2 \ x_1^2 \ x_2^2) \ \begin{pmatrix} \sqrt{2}x_1'x_2' \\ x_1'^2 \\ x_2'^2 \end{pmatrix} \end{aligned}$$

$$k(\begin{pmatrix} x_1 \\ x_2 \end{pmatrix}, \begin{pmatrix} x_1' \\ x_2' \end{pmatrix} ) = \phi(\mathbf{x})^T \phi(\mathbf{x'})$$

$$\phi(\begin{pmatrix} x_1 \\ x_2 \end{pmatrix}) =\begin{pmatrix} \sqrt{2}x_1x_2 \\ x_1^2 \\ x_2^2 \end{pmatrix}$$

Visualizando o Mapa de Recursos e a Linha Limite Resultante

• O gráfico do lado esquerdo mostra os pontos plotados no espaço transformado, juntamente com o hiperplano de limite linear SVM
• O gráfico do lado direito mostra o resultado no espaço 2D original

---

Fonte

• Post completo e código python aqui
• https://disi.unitn.it/~passerini/teaching/2014-2015/MachineLearning/slides/17_kernel_machines/handouts.pdf

Muito simplesmente (mas com precisão) um núcleo é um fator de peso entre duas seqüências de dados. Esse fator de pesagem pode atribuir mais peso a um " ponto de dados " em um " ponto de tempo " que o outro " ponto de dados ", ou atribuir peso igual ou atribuir mais peso ao outro " ponto de dados " e assim por diante.

Dessa forma, a correlação ( produto escalar ) pode atribuir mais "importância" em alguns pontos do que outros e, assim, lidar com não linearidades (por exemplo , espaços não planos ), informações adicionais, suavização de dados e assim por diante.

Ainda de outra maneira, um kernel é uma maneira de alterar as dimensões relativas (ou unidades de dimensão ) de duas seqüências de dados para lidar com as coisas mencionadas acima.

De uma terceira maneira (relacionada às duas anteriores), um kernal é uma maneira de mapear ou projetar uma sequência de dados na outra de maneira 1 para 1, levando em consideração informações ou critérios fornecidos (por exemplo, espaço curvo, dados ausentes, dados reordenar e assim por diante). Assim, por exemplo, um dado núcleo pode esticar ou encolher ou colheita ou dobrar sequência de um dos dados, a fim de se encaixar ou mapa 1-para-um para o outro.

Um kernel pode agir como um Procrustes para " encaixar melhor "