Objašnjen SVM algoritam strojnog učenja

Prema OpenCV-ovom "Uvodu u podršku vektorskim strojevima", stroju za vektorske potpore (SVM):

... je diskriminacijski klasifikator koji je formalno definiran hiperravninom koja razdvaja. Drugim riječima, s obzirom na označene podatke o treningu (nadzirano učenje), algoritam daje optimalnu hiperravninu koja kategorizira nove primjere.

SVM funkcija troška nastoji aproksimirati logističku funkciju komadno linearno. Ovaj algoritam strojnog učenja koristi se za probleme klasifikacije i dio je podskupine nadziranih algoritama učenja.

Funkcija troškova

Funkcija troška koristi se za obuku SVM-a. Minimiziranjem vrijednosti J (theta) možemo osigurati da SVM bude što precizniji. U jednadžbi se funkcije cost1 i cost0 odnose na trošak za primjer gdje je y = 1 i trošak za primjer gdje je y = 0. Za SVM-ove trošak određuje funkcija jezgre (sličnosti).

Zrnca

Polinomske značajke obično su računski skupe i mogu povećati vrijeme izvođenja s velikim skupovima podataka. Umjesto dodavanja više polinomskih značajki, bolje je dodati orijentire kako biste testirali blizinu drugih točaka podataka. Svaki član skupa treninga može se smatrati orijentirom, a jezgra je funkcija sličnosti koja mjeri koliko je ulaz približen spomenutim orijentirima.

Klasifikator velike marže

SVM će pronaći liniju ili hiperravninu koja dijeli podatke s najvećom mogućom marginom. Iako će postojati outlieri koji njišu crtu u određenom smjeru, C vrijednost koja je dovoljno mala provest će regularizaciju u cijelosti.

Slijedi kôd napisan za obuku, predviđanje i pronalaženje preciznosti za SVM u Pythonu:

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