Machine vectorielle à double support – GeeksforGeeks

Prérequis: Séparer les hyperplans dans SVM

L’équation du multiplicateur de Lagrange pour la machine à vecteurs de support. L’équation de cela peut être donnée par :

\underset{\vec{w},b}{min} \underset{\vec{a}\geq 0}{max} \frac{1}{2}\left \|  w \right \|^{2} - \sum_{j}a_j\left [ \left ( \vec{w} \cdot \vec{x}_{j} \right )y_j - 1 \right ]

Maintenant, selon le principe de dualité, le problème d’optimisation ci-dessus peut être considéré à la fois comme primal (minimisation sur w et b) ou double (maximiser plus de un).

\underset{\vec{a}\geq 0}{max}\underset{\vec{w},b}{min} \frac{1}{2}\left \|  w \right \|^{2} - \sum_{j}a_j\left [ \left ( \vec{w} \cdot \vec{x}_{j} \right )y_j - 1 \right ]

La condition de Slater pour l’optimisation convexe garantit que ces deux problèmes sont égaux.

Pour obtenir le minimum par rapport à w et b, la dérivée partielle du premier ordre par rapport à ces variables doit être 0 :

\frac{\partial L}{\partial w} = w -\sum_j a_j y_j x_j =0 \\ w = \sum_j a_j y_j x_j \\ \\ \\ Wrt \, b \\ \\ \frac{\partial L}{\partial b} = -\sum_j a_j y_j =0 \\ \\ \sum_j a_j y_j =0

Maintenant, mettez l’équation ci-dessus dans l’équation du multiplicateur de Lagrange et simplifiez-la.

L = \frac{1}{2}\left ( \sum_i \alpha_i y_i x_i \right )\cdot\left ( \sum_j \alpha_j y_j x_j \right ) - \left ( \sum_i \alpha_i y_i x_i \right )\ cdot\left ( \sum_j \alpha_j y_j x_j \right ) - \sum_i\left ( \alpha_i y_i b \right ) + \sum_i\left ( \alpha_{i} \right ) \\

Dans l’équation ci-dessus, le terme

\sum_i\left ( \alpha_i y_i b \right ) = 0
car, b est juste une constante et le reste provient de l’équation ci-dessus “
L = \sum \alpha_i - \frac{1}{2}\sum_i \sum_j \alpha_{i} \alpha_{j} y_i y_j \left ( x_i \cdot x_j \right ) \alpha_j \geq 0 \forall j

Pour trouver b, nous pouvons également utiliser l’équation et la contrainte ci-dessus

quicklatex.com 32ee82dec3c26f3d448139e391f1cb85 l3 0 \,pour \,quelques\, j ” title=”Rendu par QuickLaTeX.com” height=”26″ width=”201″ style=”vertical-align:-8px”/>
:
quicklatex.com 86264a8d4170751a992148a2107d893b l3 0″ title=”Rendu par QuickLaTeX.com” height=”287″ width=”353″ style=”vertical-align:-5px”/>

Maintenant, la règle de décision peut être donnée par :

y_i = signe(\sum \alpha_{i} y_i \left ( \vec{x}_i \cdot \vec{x} \right ) +b )

Remarquez, nous pouvons observer à partir de la règle ci-dessus que le multiplicateur de Lagrange dépend uniquement du produit scalaire de xje avec variable inconnue x. Ce produit scalaire est défini comme la fonction noyau, et il est représenté par K

L = \sum \alpha_i - \frac{1}{2}\sum_i \sum_j \alpha_{i} \alpha_{j} y_i y_j K(x_i,x_j) \\ \\ où K = (x_i.x_j)

Maintenant, pour le cas linéairement inséparable, l’équation duale devient :

\underset{\alpha}{max} \sum_i \alpha_i - \sum_{i,j} \alpha_i \alpha_j y_i y_j x_i \cdot x_j \\ \\ for, \\ \\ \sum_i \alpha_i y_i =0 \\ \\ 0 \leq \alpha_i \leq C

Ici, nous avons ajouté une constante C, elle est requise pour les raisons suivantes :

  • Il empêche la valeur de
    \alpha
    de
    \alpha \à \infty
    .
  • Cela empêche également les modèles de sur-ajuster, ce qui signifie que certaines erreurs de classification peuvent être acceptées.
2d3dtransformation

Image illustrant la transformation

nous appliquons la transformation dans un autre espace tel que le suivant. Notez que nous n’avons pas besoin de calculer spécifiquement la fonction de transformation, nous avons juste besoin de trouver le produit scalaire de ceux-ci pour obtenir la fonction noyau, cependant, cette fonction de transformation peut être facilement établie.

K = \phi(i) \cdot \phi(j)

où,

\phi()
est la fonction de transformation.

L’intuition derrière le fait que souvent une donnée peut être séparée par un hyperplan dans une dimension supérieure. Regardons cela plus en détail :

Supposons que nous ayons un ensemble de données qui contient seulement 1 variable indépendante et 1 variable dépendante. Le graphique ci-dessous représente les données :

numberlineplot

Maintenant, dans le graphique ci-dessus, il est difficile de séparer un hyperplan 1D (point) qui sépare clairement les points de données de différentes classes. Mais lorsque cela est transformé en 2d en utilisant une transformation, il fournit des options pour séparer les classes.

2dtransfomation

Dans l’exemple ci-dessus, nous pouvons voir qu’une ligne SVM peut clairement séparer les deux classes du jeu de données.

Il existe un noyau célèbre qui est utilisé assez couramment :

  • Polynômes de degré =n

K(u,v) = (u \cdot v)^{n}

  • Polynômes de degré jusqu’à n

K(u,v) = (u \cdot v + 1)^{n}
K(\vec{u}, \vec{v}) = e^{-\frac{\left \|  \vec{u}-\vec{v} \right \|_{2}^{2}}{2 \sigma^2}}

Mise en œuvre

Python3

import numpy as np

import matplotlib.pyplot as plt

from sklearn import svm, datasets

 

cancer = datasets.load_breast_cancer()

X = cancer.data[:,:2]

Y = cancer.target

 

X.shape, Y.shape

 

h = .02

C=100

lin_svc = svm.LinearSVC(C=C)

svc = svm.SVC(kernel='linear', C=C)

rbf_svc = svm.SVC(kernel='rbf', gamma=0.7, C=C)

poly_svc = svm.SVC(kernel='poly', degree=3, C=C)

 

lin_svc.fit(X, Y)

svc.fit(X, Y)

rbf_svc.fit(X, Y)

poly_svc.fit(X, Y)

 

x_min, x_max = X[:, 0].min() - 1X[:, 0].max() + 1

y_min, y_max = X[:, 1].min() - 1X[:, 1].max() + 1

xx, yy = np.meshgrid(np.arange(x_min, x_max, h),np.arange(y_min, y_max, h))

 

titles = ['linear kernel',

          'LinearSVC (linear kernel)',

          'RBF kernel',

          'polynomial (degree 3) kernel']

 

plt.figure(figsize=(10,10))

 

for i, clf in enumerate((svc, lin_svc,rbf_svc, poly_svc )):

    

    plt.subplot(2, 2, i + 1)

    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

 

    

    Z = Z.reshape(xx.shape)

    plt.set_cmap(plt.cm.flag_r)

    plt.contourf(xx, yy, Z)

 

    

    plt.scatter(X[:, 0]X[:, 1]c=Y)

 

    plt.title(titles[i])

 

plt.show()

((569, 2), (569,))
svmresults

SVM utilisant différents noyaux.

Références:

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Aller en haut