SVM-Algorithmus für maschinelles Lernen erklärt

Laut OpenCVs "Einführung in Support Vector Machines", einem Support Vector Machine (SVM):

... ist ein diskriminativer Klassifikator, der formal durch eine trennende Hyperebene definiert ist. Mit anderen Worten, bei beschrifteten Trainingsdaten (überwachtes Lernen) gibt der Algorithmus eine optimale Hyperebene aus, die neue Beispiele kategorisiert.

Eine SVM-Kostenfunktion versucht, die logistische Funktion stückweise linear zu approximieren. Dieser Algorithmus für maschinelles Lernen wird für Klassifizierungsprobleme verwendet und ist Teil der Teilmenge der überwachten Lernalgorithmen.

Die Kostenfunktion

Die Kostenfunktion wird verwendet, um die SVM zu trainieren. Durch Minimieren des Wertes von J (Theta) können wir sicherstellen, dass die SVM so genau wie möglich ist. In der Gleichung beziehen sich die Funktionen cost1 und cost0 auf die Kosten für ein Beispiel mit y = 1 und die Kosten für ein Beispiel mit y = 0. Bei SVMs werden die Kosten durch Kernelfunktionen (Ähnlichkeitsfunktionen) bestimmt.

Kernel

Polynomfunktionen sind in der Regel rechenintensiv und können die Laufzeit bei großen Datenmengen erhöhen. Anstatt mehr Polynommerkmale hinzuzufügen, ist es besser, Orientierungspunkte hinzuzufügen , um die Nähe anderer Datenpunkte zu testen. Jedes Mitglied des Trainingssatzes kann als Orientierungspunkt betrachtet werden, und ein Kernel ist die Ähnlichkeitsfunktion, die misst, wie nahe eine Eingabe an diesen Orientierungspunkten liegt.

Large Margin Classifier

Eine SVM findet die Linie oder Hyperebene, die die Daten mit dem größtmöglichen Rand aufteilt. Obwohl es Ausreißer gibt, die die Linie in eine bestimmte Richtung beeinflussen, wird ein C-Wert, der klein genug ist, die Regularisierung durchgehend erzwingen.

Der folgende Code wurde zum Trainieren, Vorhersagen und Finden der Genauigkeit von SVM in Python geschrieben:

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