Machine à vecteurs de support (SVM)

Nov 25 2022

Introduction Support Vector Machine est l'un des algorithmes d'apprentissage automatique les plus populaires. Il n'est pas seulement utilisé pour la classification, mais aussi pour les problèmes de régression.

SVM (Réf. geospasialis.com)

Introduction

Support Vector Machine est l'un des algorithmes d'apprentissage automatique les plus populaires. Il n'est pas seulement utilisé pour la classification, mais aussi pour les problèmes de régression. Mais surtout, son utilisation a été observée dans les problèmes de classification dans le domaine de l'apprentissage automatique. De nombreuses personnes préfèrent la machine à vecteurs de support car elle offre une précision remarquable tout en utilisant moins de puissance de traitement. La machine à vecteurs de support sépare les données via un hyperplan et le nouveau point de données est placé dans la catégorie la mieux adaptée. C'est l'objectif fondamental de Support Vector Machine. Cet hyperplan est également appelé frontière de décision de Support Vector Machine. Il existe une variété d'hyperplans différents qui pourraient être utilisés pour diviser les deux classes de points de données. Trouver un avion avec la plus grande marge - c'est-à-dire,

Exemple

Si nous voulons un modèle capable de distinguer correctement un chat d'un chien, disons que nous observons un chat inhabituel qui ressemble également à un chien. Nous pouvons construire un tel modèle en utilisant l'algorithme SVM. Avant de le tester avec cet animal étrange, nous allons d'abord former notre modèle avec plusieurs photographies de chats et de chiens afin qu'il puisse se familiariser avec les différents attributs des chats et des chiens. En cas de résultat, les cas extrêmes de chats et de chiens seront vus par le vecteur de support car il trace une frontière de jugement entre ces deux ensembles de données (chat et chien). Les vecteurs de support seront utilisés pour le catégoriser en tant que chat.

Fig. Exemple de SVM (réf : www.javatpoint.com )

Types de SVM

SVM linéaire : Le terme « données séparables linéairement » fait référence à des données qui peuvent être divisées en deux groupes à l'aide d'une seule ligne droite. Le SVM linéaire est utilisé pour classer ces données, et le classificateur utilisé est connu sous le nom de classificateur SVM linéaire.

Fig. SVM linéaire (Réf. www.javatpoint.com)

SVM non linéaire : le SVM non linéaire est utilisé pour les données séparées de manière non linéaire, ce qui signifie que si un ensemble de données ne peut pas être classé à l'aide d'une ligne droite, ces données sont appelées données non linéaires et le classificateur utilisé est appelé non. -classificateur SVM linéaire.

Fig. SVM non linéaire (Réf. www.javatpoint.com)

Travail

SVM catégorise les points de données même lorsqu'ils ne sont pas autrement séparables linéairement en mappant les données à un espace de caractéristiques de grande dimension. Une fois qu'un séparateur entre les catégories est identifié, les données sont converties pour permettre la représentation hyperplan du séparateur. Le groupe auquel un nouvel enregistrement doit appartenir peut alors être prédit à l'aide des caractéristiques des nouvelles données.

Mises à jour de la fonction de coût et du gradient

Le but de la méthode SVM est d'augmenter la distance entre les points de données et l'hyperplan. La perte articulée est la fonction de perte qui aide à maximiser la marge.

Fig. Fonction de perte de charnière (la fonction à gauche peut être représentée comme une fonction à droite)

Si la valeur projetée et la valeur réelle ont le même signe, il n'y a aucun coût. Sinon, nous déterminons ensuite la valeur de la perte. La fonction de coût reçoit également un paramètre de régularisation de notre part. L'objectif du paramètre de régularisation est de trouver un équilibre entre la maximisation de la marge et la perte. Les fonctions de coût apparaissent comme suit après l'ajout du paramètre de régularisation.

Figue. Fonction de perte pour SVM

Maintenant que nous avons la fonction de perte, nous pouvons trouver les gradients en prenant des dérivées partielles par rapport aux poids. Nous pouvons modifier nos poids en utilisant les gradients.

Fig. Dégradés

Nous n'avons besoin de mettre à jour le gradient à partir du paramètre de régularisation que lorsqu'il n'y a pas d'erreur de classification, c'est-à-dire lorsque notre modèle prédit correctement la classe de notre point de données.

Fig. Gradient Update - Aucune erreur de classification

Afin d'effectuer une mise à jour du gradient en cas d'erreur de classification ou lorsque notre modèle prédit de manière incorrecte la classe d'un point de données, nous incluons la perte avec le paramètre de régularisation.

Fig. Gradient Update - Mauvaise classification

Exemple d'extrait de programme

Importation de bibliothèques

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split

class SVM:
    def __init__(self, learning_rate=0.0001, lambda_param=0.001, n_iters=10000):
        self.weights = None
        self.bias =  None
        self.lr = learning_rate
        self.lambda_param = lambda_param
        self.n_iters = n_iters
    def fit(self,X,y):
        n_samples, n_features = X.shape
        
        y1 = np.where(y <= 0, -1, 1)
        
        self.weights = np.zeros(n_features)
        self.bias = 0
        for i in range(self.n_iters):
            for idx, x_i in enumerate(X):
                condition = y1[idx] * (np.dot(x_i, self.weights) - self.bias) >= 1
                if condition:
                    self.weights -= self.lr * (2 * self.lambda_param * self.weights)
                else:
                    self.weights -= self.lr * (2 * self.lambda_param * self.weights - np.dot(x_i, y1[idx]))
                    self.bias -= self.lr * y1[idx]
        
    def predict(self, X):
        approx = np.dot(X, self.weights) - self.bias
        return np.sign(approx)

def accuracy(y_true,y_pred):
    acc = np.sum(y_true == y_pred)/len(y_true)
    return acc
X, y =  datasets.make_blobs(n_samples=10, n_features=2, centers=2, cluster_std=1.05, random_state=40)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=42)
y = np.where(y == 0, -1, 1)
clf = SVM()
clf.fit(X_train,y_train)
predict = clf.predict(X_test)
svm_acc = accuracy(y_test,predict)
print('Accuracy:',svm_acc)
print(f'''
     Final Weight:{clf.weights}
     Final Bias:{clf.bias}
     ''')

Poids final : [0,34494241 0,1443094 ]
Biais final : -0,012899999999999977

Visualisation

def visualize_svm():
    def get_hyperplane_value(x, w, b, offset):
        return (-w[0] * x + b + offset) / w[1]
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    plt.scatter(X[:,0], X[:,1], marker='x',c=y)

    x0_1 = np.amin(X[:,0])
    x0_2 = np.amax(X[:,0])

    x1_1 = get_hyperplane_value(x0_1, clf.weights, clf.bias, 0)
    x1_2 = get_hyperplane_value(x0_2, clf.weights, clf.bias, 0)

    x1_1_m = get_hyperplane_value(x0_1, clf.weights, clf.bias, -1)
    x1_2_m = get_hyperplane_value(x0_2, clf.weights, clf.bias, -1)

    x1_1_p = get_hyperplane_value(x0_1, clf.weights, clf.bias, 1)
    x1_2_p = get_hyperplane_value(x0_2, clf.weights, clf.bias, 1)

    ax.plot([x0_1, x0_2],[x1_1, x1_2], 'b--')
    ax.plot([x0_1, x0_2],[x1_1_m, x1_2_m], 'k')
    ax.plot([x0_1, x0_2],[x1_1_p, x1_2_p], 'k')

    x1_min = np.amin(X[:,1])
    x1_max = np.amax(X[:,1])
    ax.set_ylim([x1_min-3,x1_max+3])

    plt.show()

visualize_svm()

      
                
                    
                    
       Fig. Output of SVM

Détection de visage - SVMc classe les parties de l'image en tant que visage et non-visage et crée une limite carrée autour du visage.

Catégorisation de texte et d'hypertexte — Les SVM prennent en charge les modèles inductifs et transductifs pour la classification de texte et d'hypertexte. Pour classer les articles en groupes distincts, ils ont besoin de données d'entraînement. Il classe en fonction du score obtenu puis contraste avec la valeur seuil.
Classification des images — Les SVM améliorent la précision de la recherche pour la classification des images. Comparé aux stratégies de recherche classiques basées sur des requêtes, il offre une plus grande précision.
La classification des protéines et la classification du cancer sont deux exemples de bioinformatique. SVM est utilisé pour classer les gènes, les patients en fonction de leurs gènes et d'autres problèmes biologiques.
Appliquez des algorithmes SVM pour la détection d'homologie à distance des protéines et la détection du repliement des protéines.

Conclusion

Support Vector Machine est un puissant algorithme de classification en Machine Learning. Bien qu'il puisse également être utilisé pour les problèmes de régression, nous suggérons de l'utiliser principalement à des fins de classification. Il peut être utilisé pour des données linéaires ou non linéaires et cela fonctionne très bien. Cependant, il s'agit d'un algorithme d'apprentissage supervisé, il a donc besoin de données étiquetées. Cela fonctionne mieux sur des ensembles de données plus petits que sur des ensembles complexes.

Les références

Soutenir la machine vectorielle

Un devoir à domicile pour l'inférence statistique (SI) par des étudiants en intelligence artificielle et en science des données (AI&DS), Vishwakarma Institute of Technology, Pune.