[PYTHON] Support Vector Machine (pour les débutants) -Code Edition-

Cette fois, nous résumerons l'implémentation des machines vectorielles support (classification).

Ci-après, il peut être abrégé en SVM.

■ Procédure de machine vectorielle de soutien

Passez aux 7 étapes suivantes.

Préparation du module
Préparation des données
Visualisation des données
Créez un modèle
Diagramme du modèle
Classification des prédictions
Évaluation du modèle

1. Préparation du module

Tout d'abord, importez les modules requis.


import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#Module pour lire le jeu de données
from sklearn.datasets import load_iris

#Module de normalisation (normalisation distribuée)
from sklearn.preprocessing import StandardScaler

#Module qui sépare les données d'entraînement et les données de test
from sklearn.model_selection import train_test_split

#Vecteur de support Un module qui exécute une machine
from sklearn.svm import SVC

#Module pour évaluer la classification
from sklearn.metrics import classification_report

2. Préparation des données

Cette fois, nous utiliserons le jeu de données iris pour la classification binaire.

Commencez par récupérer les données, normalisez-les, puis divisez-les.


#Chargement du jeu de données iris
iris = load_iris()

#Diviser en variable objective et variable explicative
X, y = iris.data[:100, [0, 2]], iris.target[:100]

#Standardisation (normalisation distribuée)
std = StandardScaler()
X = std.fit_transform(X)

#Divisez en données d'entraînement et en données de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

Afin d'effectuer une classification binaire, l'ensemble de données est spécifié jusqu'à la 100e ligne (Setosa / Versicolor uniquement). Nous avons également réduit les variables explicatives à deux pour faciliter le tracé. (Longueur sépale / Longueur pétale uniquement)

En normalisation, par exemple, lorsqu'il y a des quantités de caractéristiques à 2 et 4 chiffres (variables explicatives), l'influence de ces dernières devient grande. L'échelle est alignée en définissant la moyenne sur 0 et la variance sur 1 pour toutes les quantités d'entités.

3. Visualisation des données

Tracons les données avant de les classer par SVM.


#Création d'objets de dessin et de sous-tracés
fig, ax = plt.subplots()

#Graphique de Setosa
ax.scatter(X_train[y_train == 0, 0], X_train[y_train == 0, 1], 
           marker = 'o', label = 'Setosa')

#Parcelle Versicolor
ax.scatter(X_train[y_train == 1, 0], X_train[y_train == 1, 1],
           marker = 'x', label = 'Versicolor')

#Paramètres d'étiquette d'axe
ax.set_xlabel('Sepal Length')
ax.set_ylabel('Petal Length')

#Paramètres de la légende
ax.legend(loc = 'best')

plt.show()

Tracé avec des entités correspondant à Setosa (y_train == 0) (0: Sepal Length sur l'axe horizontal, 1: Petal Length sur l'axe vertical) Tracé avec des entités (0: Sepal Lengh sur l'axe horizontal, 1: Petal Length sur l'axe vertical) correspondant à Versicolor (y_train == 1)

Résultat de sortie

4. Créez un modèle

Tout d'abord, créez une fonction d'exécution SVM (instance) et appliquez-la aux données d'apprentissage.


#Créer une instance
svc = SVC(kernel = 'linear', C = 1e6)
    
#Créer un modèle à partir des données d'entraînement
svc.fit(X_train, y_train)

Cette fois, la séparation linéaire est déjà possible (séparée par une ligne droite), donc l'argument est défini sur kernel = 'linear'.

C est un hyper paramètre que vous ajustez vous-même tout en regardant les valeurs de sortie et les graphiques.

5. Diagramme du modèle

Depuis que j'ai pu créer un modèle de la machine à vecteurs de support à partir des données d'entraînement Tracez et vérifiez comment la classification est effectuée.

La première moitié est exactement la même que le code du diagramme de dispersion ci-dessus.


#Création d'objets de dessin et de sous-tracés
fig, ax = plt.subplots()

#Graphique de Setosa
ax.scatter(X_train[y_train == 0, 0], X_train[y_train == 0, 1], 
           marker = 'o', label = 'Setosa')

#Parcelle Versicolor
ax.scatter(X_train[y_train == 1, 0], X_train[y_train == 1, 1],
           marker = 'x', label = 'Versicolor')

ax.set_xlabel('Sepal Length')
ax.set_ylabel('Petal Length')
    
ax.legend(loc = 'upper left')

#À partir de maintenant, vous pouvez le coller tel quel et l'utiliser à chaque fois, même s'il s'agit d'autres données. (Un ajustement fin de la valeur numérique est nécessaire)

#Spécifiez la plage de tracé de la limite de décision (ligne droite)
xmin = -2.0
xmax = 2.5
ymin = -1.5
ymax = 1.8

#Tracer les limites et les marges de décision
xx, yy = np.meshgrid(np.linspace(xmin, xmax, 100), np.linspace(ymin, ymax, 100))
xy = np.vstack([xx.ravel(), yy.ravel()]).T
p = svc.decision_function(xy).reshape(100, 100)  
ax.contour(xx, yy, p, colors = 'k', levels = [-1, 0, 1], alpha = 1, 
           linestyles = ['--', '-', '--'])

#Vecteur de support de tracé
ax.scatter(svc.support_vectors_[:, 0], svc.support_vectors_[:, 1],
           s = 250, facecolors = 'none', edgecolors = 'black')
    
plt.show()

alpha: densité de ligne droite s: Taille du vecteur de support (○)

Résultat de sortie

6. Classification des prédictions

Maintenant que le modèle est complet, prédisons la classification.

#Prédire les résultats de la classification
y_pred = svc.predict(X_test)

#Sortie de la valeur prédite et de la valeur de réponse correcte
print(y_pred)
print(y_test)

Résultat de sortie


#Comparez la valeur prévue avec la valeur de réponse correcte
y_pred: [0 1 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0 0 1 1 1 1]
y_test: [0 1 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0 0 1 1 1 1]

0：Setosa　1：Versicolor

Dans ce cas, vous pouvez voir qu'ils correspondent tous (bonne réponse).

7. Évaluation du modèle

Comme il s'agira cette fois d'une classification (classification binaire), nous l'évaluerons par le taux de précision, le taux de rappel et la valeur F à l'aide d'une matrice de confusion.


#Affiche le taux de précision, le taux de rappel et la valeur F
print(classification_report(y_test, y_pred))

Résultat de sortie

À partir de ce qui précède, nous avons pu évaluer la classification à Setosa et Versicolor.

■ Enfin

Dans SVM, nous allons créer et évaluer le modèle en fonction des étapes 1 à 7 ci-dessus.

Cette fois, pour les débutants, je n'ai résumé que l'implémentation (code). En regardant le timing dans le futur, je voudrais écrire un article sur la théorie (formule mathématique).

Merci pour la lecture.

Références: Nouveau manuel d'analyse de données utilisant Python (Matériel pédagogique principal de test d'analyse des données de certification d'ingénieur Python 3)