Explicación del algoritmo de aprendizaje automático de SVM

De acuerdo con la "Introducción a las máquinas vectoriales de soporte" de OpenCV, una máquina vectorial de soporte (SVM):

... es un clasificador discriminativo formalmente definido por un hiperplano separador. En otras palabras, dados los datos de entrenamiento etiquetados (aprendizaje supervisado), el algoritmo genera un hiperplano óptimo que categoriza nuevos ejemplos.

Una función de costo de SVM busca aproximar la función logística con un lineal por partes. Este algoritmo de aprendizaje automático se utiliza para problemas de clasificación y es parte del subconjunto de algoritmos de aprendizaje supervisado.

La función de costo

La función de coste se utiliza para entrenar al SVM. Al minimizar el valor de J (theta), podemos asegurarnos de que la SVM sea lo más precisa posible. En la ecuación, las funciones cost1 y cost0 se refieren al costo de un ejemplo donde y = 1 y el costo de un ejemplo donde y = 0. Para las SVM, el costo está determinado por las funciones del kernel (similitud).

Granos

Las características polinomiales tienden a ser computacionalmente costosas y pueden aumentar el tiempo de ejecución con grandes conjuntos de datos. En lugar de agregar más entidades polinomiales, es mejor agregar puntos de referencia para probar la proximidad de otros puntos de datos. Cada miembro del conjunto de entrenamiento puede considerarse un punto de referencia, y un núcleo es la función de similitud que mide qué tan cerca está una entrada de dichos puntos de referencia.

Clasificador de margen grande

Una SVM encontrará la línea o hiperplano que divide los datos con el mayor margen posible. Aunque habrá valores atípicos que influyan en la línea en una dirección determinada, un valor C que sea lo suficientemente pequeño impondrá la regularización en todo momento.

El siguiente es un código escrito para entrenar, predecir y encontrar precisión para SVM en 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