Az SVM gépi tanulási algoritmusának magyarázata

Az OpenCV "Bevezetés a vektorgépek támogatásába" szerint egy támogató vektorgép (SVM):

... egy megkülönböztető osztályozó, amelyet formálisan egy elválasztó hipersík határoz meg. Más szavakkal, megadva a címkézett képzési adatokat (felügyelt tanulás), az algoritmus optimális hipersíkot ad ki, amely új példákat kategorizál.

Az SVM költségfüggvény darabonkénti lineárisral igyekszik közelíteni a logisztikai függvényt. Ezt a gépi tanulási algoritmust osztályozási problémákra használják, és része a felügyelt tanulási algoritmusok részhalmazának.

A költség funkció

A költségfunkció az SVM képzésére szolgál. A J (theta) értékének minimalizálásával biztosíthatjuk, hogy az SVM a lehető legpontosabb legyen. Az egyenletben a cost1 és a cost0 függvények utalnak a költségekre egy példánál, ahol y = 1, és a költségre egy példánál, ahol y = 0. Az SVM-eknél a költségeket a kernel (hasonlóság) függvények határozzák meg.

Kernelek

A polinom jellemzői általában számítási szempontból drágák, és nagy adatkészletek mellett növelhetik a futási időt. Ahelyett, hogy több polinom tulajdonságot adna hozzá, jobb, ha tereptárgyakat ad hozzá, hogy tesztelje a többi adatpont közelségét. A képzési készlet minden tagja mérföldkőnek tekinthető, és a kernel a hasonlóságfüggvény, amely azt méri, hogy egy bemenet milyen közel van az említett tereptárgyakhoz.

Nagy árrés osztályozó

Az SVM megtalálja azt a vonalat vagy hipersíkot, amely a lehető legnagyobb margóval osztja fel az adatokat. Habár lesznek olyan kiugró értékek, amelyek egy bizonyos irányba ingatják a vonalat, egy elég kicsi C-érték végig érvényesíteni fogja a szabályozást.

Az alábbiakban kódot írtunk az SVM képzéséhez, előrejelzéséhez és pontosságának megtalálásához a Pythonban:

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