[PYTHON] J'ai essayé de comprendre attentivement la machine vectorielle de support (Partie 1: J'ai essayé le noyau polynomial / RBF en utilisant MakeMoons comme exemple).

introduction

Cette fois, je voudrais résumer un modèle d'apprentissage automatique utilisant une machine vectorielle de support. Le contour est ci-dessous.

• Comprendre le concept de machines vectorielles de support
• Essayez un classificateur SVM non linéaire basé sur le jeu de données MakeMoons
• Essayez le noyau Gauss RBF

Comprendre le concept de machines vectorielles de support

La Suppurt Vector Machine est l'un des algorithmes d'apprentissage automatique qui optimise le modèle en fonction d'un critère appelé «maximisation des marges». Il est essentiellement utilisé pour les problèmes de classification et de régression. Les algorithmes typiques (que je connais) qui résolvent ces problèmes de classification / régression sont les suivants.

• Système d'arbre de décision (arbre de décision / forêt aléatoire / LightGBM etc.)
• Système de réseau neuronal
• ** (Cette fois) Support Vector Machine **
• k méthode de voisinage
• Retour logistique

Outre la régression logistique, elle a la particularité qu'une représentation non linéaire est possible. Cette machine vectorielle de support est un algorithme populaire (comme) car il est pratique et facile à manipuler.

Dans certains cas, il est traduit par support ** vector ** machine. Ceci est probablement dû à la différence de traduction de Vector par «vecteur» ou «vecteur».

Qu'est-ce que le vecteur de support et la maximisation des marges?

Maintenant, laissez-moi vous expliquer les mots. La marge est la distance entre l'élément (△, ▲) le plus proche du séparateur (format de ligne: $ w ^ Tx + b $) qui s'identifie comme indiqué dans la figure ci-dessous. Et cet élément avec la distance la plus proche est appelé un vecteur de support.

La maximisation de la distance de cette marge est l'optimisation de cette machine à vecteurs de support (ci-après abrégée SVM).

Essayez un classificateur SVM non linéaire basé sur le jeu de données MakeMoons

Les classificateurs linéaires fonctionnent bien pour les données avec des fonctionnalités faciles à séparer telles que celles mentionnées ci-dessus, mais en pratique, ils nécessitent souvent des divisions très complexes. Dans ce cas, vous devez utiliser un classificateur non linéaire. En utilisant SVM, il est possible de créer et d'utiliser facilement un classificateur non linéaire.

Le jeu de données MakeMoons est un exemple d'analyse SVM. Il s'agit d'un module qui peut être importé à partir du jeu de données d'apprentissage scicit illustré ci-dessous. Vous pouvez dessiner des données dites en forme de lune. Classifions cela par SVM non linéaire.

SVM.ipynb

from sklearn.datasets import make_moons
X, y = make_moons(n_samples=100, noise=0.15, random_state=42)

def plot_dataset(X, y, axes):
    plt.plot(X[:, 0][y==0], X[:, 1][y==0], "bs")
    plt.plot(X[:, 0][y==1], X[:, 1][y==1], "g^")
    plt.axis(axes)
    plt.grid(True, which='both')
    plt.xlabel(r"$x_1$", fontsize=20)
    plt.ylabel(r"$x_2$", fontsize=20, rotation=0)

plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.show()

Classificateur SVM avec noyaux polymorphes de différentes dimensions

Dans SVM, la valeur de degré représente une dimension et les performances du classificateur changent en fonction de cette valeur de dimension.

SVM.ipynb

from sklearn.datasets import make_moons
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.svm import SVC

poly_kernel_svm_clf = Pipeline([
        ("scaler", StandardScaler()),
        ("svm_clf", SVC(kernel="poly", degree=3, coef0=1, C=5))
    ])
poly_kernel_svm_clf.fit(X, y)

poly100_kernel_svm_clf = Pipeline([
        ("scaler", StandardScaler()),
        ("svm_clf", SVC(kernel="poly", degree=12, coef0=100, C=5))
    ])
poly100_kernel_svm_clf.fit(X, y)

plt.figure(figsize=(11, 4))

plt.subplot(121)
plot_predictions(poly_kernel_svm_clf, [-1.5, 2.5, -1, 1.5])
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.title(r"$d=3, r=1, C=5$", fontsize=18)

plt.subplot(122)
plot_predictions(poly100_kernel_svm_clf, [-1.5, 2.5, -1, 1.5])
plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
plt.title(r"$d=12, r=100, C=5$", fontsize=18)

plt.show()

Dans l'exemple ci-dessus, la figure de gauche montre un exemple en 3 dimensions et la figure de droite un exemple en 12 dimensions. Dans le cas de 12 dimensions, il est en état de surapprentissage. Par conséquent, dans ce cas, il est nécessaire d'abaisser l'ordre du modèle. Au contraire, si vous l'abaissez à 2 dimensions, vous pouvez voir qu'il ne peut pas être classé comme le montre la figure ci-dessous.

Comprendre le pipeline de scikit-learn

Une méthode appelée Pipeline qui est sortie dans le programme ci-dessus est sortie, je vais donc la décrire brièvement. Un prétraitement détaillé, tel que le traitement des valeurs manquantes et la normalisation des valeurs, est nécessaire pour effectuer la prédiction de modèle dans l'apprentissage automatique. À l'heure actuelle, le pipeline de sklearn est une méthode qui peut résoudre ces problèmes dans une certaine mesure. 　 Dans ce cas, le traitement suivant est effectué.

"scaler", StandardScaler()#Standardiser la valeur (= soustraire par moyenne et diviser par variance)
"svm_clf", SVC(kernel="poly", degree=3, coef0=1, C=5)#Définir le classificateur SVM

Je comprends que cela implique le traitement que je souhaite compiler comme modèle,

Essayez le noyau Gauss RBF

Maintenant, nous allons utiliser l'une des méthodes de classification SVM appelée méthode du noyau Gauss RBF. Tous les mots étaient difficiles à comprendre, alors j'aimerais comprendre le sens de chaque mot.

Qu'est-ce qu'une fonction noyau

Tout d'abord, à propos des fonctions du noyau. C'est une fonction très importante pour la représentation non linéaire, que j'ai utilisée légèrement dans l'exemple MakeMoons plus tôt. En résumé, comme le montre la figure ci-dessous, le processus qui peut avoir un plan qui peut être séparé linéairement en augmentant les dimensions (en pratique, il est appelé un super plan car il a 3 dimensions ou plus) ** est appelé une fonction noyau. J'appelle.

Et la régression utilisant cette fonction du noyau est appelée régression du noyau. La formule qui exprime la régression du noyau est la suivante.

f({\bf x}) = \sum_{i=1}^{N} \alpha_i k({\bf x}^{(i)}, {\bf x})

$ \ Alpha_i $ est le coefficient que vous voulez optimiser, et $ k ({\ bf x} ^ {(i)}, {\ bf x}) $ est appelée la fonction noyau. Il existe plusieurs types de cette fonction noyau utilisée. Ce qui suit est l'un d'eux, une fonction de noyau appelée noyau gaussien.

k({\bf x}, {\bf x}') = exp(-\beta \|{\bf x} - {\bf x}'\|^2)

||x-x'||Est la norme: indique la distance.\betaEst\beta>0C'est un véritable hyperparamètre qui satisfait et est déterminé par la personne utilisant le modèle.

Qu'est-ce que RBF

Elle s'appelle la fonction de base radiale et en japonais, elle s'appelle la fonction de base radiale. Il semble y avoir diverses fonctions qui deviennent ce RBF, mais la plus utilisée est appelée la fonction de Gauss.

φ(\bf x)=(\bf x - \bf c)^T \frac {(\bf x - \bf c)}{2σ^2}

$ \ Bf x $ est la fonction d'entrée et $ \ bf c $ est le centre de la fonction gaussienne.

Implémentons

SVM.ipynb

from sklearn.svm import SVC

gamma1, gamma2 = 0.1, 5
C1, C2 = 0.001, 1000
hyperparams = (gamma1, C1), (gamma1, C2), (gamma2, C1), (gamma2, C2)

svm_clfs = []
for gamma, C in hyperparams:
    rbf_kernel_svm_clf = Pipeline([
            ("scaler", StandardScaler()),
            ("svm_clf", SVC(kernel="rbf", gamma=gamma, C=C))
        ])
    rbf_kernel_svm_clf.fit(X, y)
    svm_clfs.append(rbf_kernel_svm_clf)

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

for i, svm_clf in enumerate(svm_clfs):
    plt.subplot(221 + i)
    plot_predictions(svm_clf, [-1.5, 2.5, -1, 1.5])
    plot_dataset(X, y, [-1.5, 2.5, -1, 1.5])
    gamma, C = hyperparams[i]
    plt.title(r"$\gamma = {}, C = {}$".format(gamma, C), fontsize=16)

plt.show()

Il est nécessaire de déterminer à la fois γ et C comme hyper paramètres, mais on peut voir qu'un surapprentissage se produira si les valeurs sont trop grandes pour chacun.

À la fin

Alors que SVM est un modèle très facile à utiliser, la théorie mathématique qui le sous-tend est très profonde.

J'ai fait référence à cet article cette fois.

Méthode linéaire et méthode du noyau (analyse de régression) https://qiita.com/wsuzume/items/09a59036c8944fd563ff

Le programme complet est stocké ici. https://github.com/Fumio-eisan/SVM_20200417