SVM Machine Learning Algorithm Explained

I henhold til OpenCVs "Introduction to Support Vector Machines", en Support Vector Machine (SVM):

... er en diskriminerende klassifikator, der formelt er defineret af et adskillende hyperplan. Med andre ord, givet mærket træningsdata (overvåget læring), udsender algoritmen et optimalt hyperplan, der kategoriserer nye eksempler.

En SVM-omkostningsfunktion søger at tilnærme den logistiske funktion med en stykkevis lineær. Denne maskinlæringsalgoritme bruges til klassificeringsproblemer og er en del af delmængden af ​​overvågede læringsalgoritmer.

Omkostningsfunktionen

Omkostningsfunktionen bruges til at træne SVM. Ved at minimere værdien af ​​J (theta) kan vi sikre, at SVM er så nøjagtig som muligt. I ligningen henviser funktionerne cost1 og cost0 til prisen for et eksempel, hvor y = 1 og prisen for et eksempel, hvor y = 0. For SVM'er bestemmes omkostningerne af kernefunktioner (lighed).

Kerner

Polynomiske funktioner har tendens til at være beregningsmæssigt dyre og kan øge driftstiden med store datasæt. I stedet for at tilføje flere polynomiske funktioner er det bedre at tilføje vartegn for at teste nærheden af ​​andre datapunkter mod. Hvert medlem af træningssættet kan betragtes som et vartegn, og en kerne er lighedsfunktionen, der måler, hvor tæt et input er på nævnte vartegn.

Stor margen klassifikator

En SVM finder den linje eller hyperplan, der opdeler dataene med den størst mulige margin. Selvom der vil være afvigende, der svinger linjen i en bestemt retning, vil en C-værdi, der er lille nok, gennemføre regulering igennem.

Følgende er kode skrevet til træning, forudsigelse og finde nøjagtighed for SVM i 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  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