Conform OpenCV „Introducere în suportul mașinilor vectoriale”, o mașină vectorială de suport (SVM):

… este un clasificator discriminativ definit formal de un hiperplan de separare. Cu alte cuvinte, date date de antrenament etichetate (învățare supravegheată), algoritmul produce un hiperplan optim care clasifică noi exemple.

Algoritmul de invatare automata SVM

O funcție de cost SVM caută să aproximeze funcția logistică cu o linie parțială. Acest algoritm de învățare automată este utilizat pentru probleme de clasificare și face parte din subsetul de algoritmi de învățare supravegheați.

Funcția Cost

1611967925 274 Algoritmul de invatare automata SVM

Funcția Cost este utilizată pentru instruirea SVM. Prin minimizarea valorii lui J (theta), ne putem asigura că SVM este cât mai exact posibil. În ecuație, funcțiile cost1 și cost0 se referă la costul unui exemplu în care y = 1 și costul unui exemplu în care y = 0. Pentru SVM-uri, costul este determinat de funcțiile kernel (similaritate).

Miezul

Caracteristicile polinomiale tind să fie costisitoare din punct de vedere al calculului și pot crește timpul de rulare cu seturi de date mari. În loc să adăugați mai multe caracteristici polinomiale, este mai bine să adăugați repere pentru a testa proximitatea altor puncte de date împotriva. Fiecare membru al setului de instruire poate fi considerat un reper, iar un nucleu este funcția de similaritate care măsoară cât de aproape este o intrare de reperele menționate.

Clasificator de marjă mare

Un SVM va găsi linia sau hiperplanul care împarte datele cu cea mai mare marjă posibilă. Deși vor exista valori aberante care influențează linia într-o anumită direcție, o valoare C suficient de mică va impune regularizarea pe tot parcursul.

Următorul este un cod scris pentru antrenament, predicție și găsirea preciziei pentru SVM în Python:

import numpy as np


class Svm (object):
    """" Svm classifier """

    def __init__ (self, inputDim, outputDim):
        self.W = None
       
        # - Generate a random svm weight matrix to compute loss                 #
        #   with standard normal distribution and Standard deviation = 0.01.    #
       
        sigma =0.01
        self.W = sigma * np.random.randn(inputDim,outputDim)
   
  

    def calLoss (self, x, y, reg):
        """
        Svm loss function
        D: Input dimension.
        C: Number of Classes.
        N: Number of example.
        Inputs:
        - x: A numpy array of shape (batchSize, D).
        - y: A numpy array of shape (N,) where value < C.
        - reg: (float) regularization strength.
        Returns a tuple of:
        - loss as single float.
        - gradient with respect to weights self.W (dW) with the same shape of self.W.
        """
        loss = 0.0
        dW = np.zeros_like(self.W)
        
        # - Compute the svm loss and store to loss variable.                        #
        # - Compute gradient and store to dW variable.                              #
        # - Use L2 regularization                                                  #
       
        #Calculating score matrix
        s = x.dot(self.W)
        #Score with yi
        s_yi = s[np.arange(x.shape[0]),y]
        #finding the delta
        delta = s- s_yi[:,np.newaxis]+1
        #loss for samples
        loss_i = np.maximum(0,delta)
        loss_i[np.arange(x.shape[0]),y]=0
        loss = np.sum(loss_i)/x.shape[0]
        #Loss with regularization
        loss += reg*np.sum(self.W*self.W)
        #Calculating ds
        ds = np.zeros_like(delta)
        ds[delta > 0] = 1
        ds[np.arange(x.shape[0]),y] = 0
        ds[np.arange(x.shape[0]),y] = -np.sum(ds, axis=1)

        dW = (1/x.shape[0]) * (x.T).dot(ds)
        dW = dW + (2* reg* self.W)
        

        return loss, dW

    def train (self, x, y, lr=1e-3, reg=1e-5, iter=100, batchSize=200, verbose=False):
        """
        Train this Svm classifier using stochastic gradient descent.
        D: Input dimension.
        C: Number of Classes.
        N: Number of example.
        Inputs:
        - x: training data of shape (N, D)
        - y: output data of shape (N, ) where value < C
        - lr: (float) learning rate for optimization.
        - reg: (float) regularization strength.
        - iter: (integer) total number of iterations.
        - batchSize: (integer) number of example in each batch running.
        - verbose: (boolean) Print log of loss and training accuracy.
        Outputs:
        A list containing the value of the loss at each training iteration.
        """

        # Run stochastic gradient descent to optimize W.
        lossHistory = []
        for i in range(iter):
            xBatch = None
            yBatch = None
            
            # - Sample batchSize from training data and save to xBatch and yBatch   #
            # - After sampling xBatch should have shape (batchSize, D)              #
            #                  yBatch (batchSize, )                                 #
            # - Use that sample for gradient decent optimization.                   #
            # - Update the weights using the gradient and the learning rate.        #
            
            #creating batch
            num_train = np.random.choice(x.shape[0], batchSize)
            xBatch = x[num_train]
            yBatch = y[num_train]
            loss, dW = self.calLoss(xBatch,yBatch,reg)
            self.W= self.W - lr * dW
            lossHistory.append(loss)

            # Print loss for every 100 iterations
            if verbose and i % 100 == 0 and len(lossHistory) is not 0:
                print ('Loop {0} loss {1}'.format(i, lossHistory[i]))

        return lossHistory

    def predict (self, x,):
        """
        Predict the y output.
        Inputs:
        - x: training data of shape (N, D)
        Returns:
        - yPred: output data of shape (N, ) where value < C
        """
        yPred = np.zeros(x.shape[0])
       
        # -  Store the predict output in yPred                                    #
        
        s = x.dot(self.W)
        yPred = np.argmax(s, axis=1)
        return yPred


    def calAccuracy (self, x, y):
        acc = 0
        
        # -  Calculate accuracy of the predict value and store to acc variable    
        yPred = self.predict(x)
        acc = np.mean(y == yPred)*100
        return acc