Tutorial de aprendizaje automático de SVM: ¿Qué es el algoritmo de máquina de vectores de soporte, explicado con ejemplos de código?

Programación

La mayoría de las tareas que maneja el aprendizaje automático en este momento incluyen cosas como clasificar imágenes, traducir idiomas, manejar grandes cantidades de datos de sensores y predecir valores futuros basados ​​en valores actuales. Puede elegir diferentes estrategias para adaptarse al problema que está tratando de resolver.

¿Las buenas noticias? Existe un algoritmo en el aprendizaje automático que manejará casi cualquier dato que pueda arrojarle. Pero llegaremos en un minuto.

Aprendizaje supervisado vs no supervisado

Dos de las estrategias más utilizadas en el aprendizaje automático incluyen el aprendizaje supervisado y el aprendizaje no supervisado.

¿Qué es el aprendizaje supervisado?

El aprendizaje supervisado es cuando entrena un modelo de aprendizaje automático utilizando datos etiquetados. Significa que tiene datos que ya tienen la clasificación correcta asociada. Un uso común del aprendizaje supervisado es ayudarlo a predecir valores para nuevos datos.

Con el aprendizaje supervisado, deberá reconstruir sus modelos a medida que obtenga nuevos datos para asegurarse de que las predicciones devueltas sigan siendo precisas. Un ejemplo de aprendizaje supervisado sería etiquetar imágenes de alimentos. Podría tener un conjunto de datos dedicado solo a imágenes de pizza para enseñarle a su modelo qué es la pizza.

¿Qué es el aprendizaje no supervisado?

El aprendizaje no supervisado es cuando entrena un modelo con datos sin etiquetar. Esto significa que el modelo tendrá que encontrar sus propias características y hacer predicciones basadas en cómo clasifica los datos.

Un ejemplo de aprendizaje no supervisado sería darle a su modelo imágenes de varios tipos de alimentos sin etiquetas. El conjunto de datos tendría imágenes de pizza, papas fritas y otros alimentos, y podrías usar diferentes algoritmos para que el modelo identifique solo las imágenes de pizza sin etiquetas.

Entonces, ¿qué es un algoritmo?

Cuando escuche a la gente hablar sobre algoritmos de aprendizaje automático, recuerde que están hablando de diferentes ecuaciones matemáticas.

Un algoritmo es solo una función matemática personalizable. Es por eso que la mayoría de los algoritmos tienen funciones de costo, valores de peso y funciones de parámetros que puede intercambiar según los datos con los que está trabajando. En esencia, el aprendizaje automático es solo un grupo de ecuaciones matemáticas que deben resolverse muy rápido.

Es por eso que hay tantos algoritmos diferentes para manejar diferentes tipos de datos. Un algoritmo en particular es la máquina de vectores de soporte (SVM) y eso es lo que este artículo cubrirá en detalle.

¿Qué es una SVM?

Las máquinas de vectores de soporte son un conjunto de métodos de aprendizaje supervisado que se utilizan para la clasificación, regresión y detección de valores atípicos. Todas estas son tareas comunes en el aprendizaje automático.

Puede usarlos para detectar células cancerosas basándose en millones de imágenes o puede usarlos para predecir futuras rutas de conducción con un modelo de regresión bien ajustado.

Hay tipos específicos de SVM que puede usar para problemas particulares de aprendizaje automático, como la regresión de vectores de soporte (SVR), que es una extensión de la clasificación de vectores de soporte (SVC).

Lo principal a tener en cuenta aquí es que estas son solo ecuaciones matemáticas ajustadas para brindarle la respuesta más precisa posible lo más rápido posible.

Las SVM son diferentes de otros algoritmos de clasificación debido a la forma en que eligen el límite de decisión que maximiza la distancia desde los puntos de datos más cercanos de todas las clases. El límite de decisión creado por las SVM se denomina clasificador de margen máximo o hiperplano de margen máximo.

Cómo funciona una SVM

Un clasificador SVM lineal simple funciona haciendo una línea recta entre dos clases. Eso significa que todos los puntos de datos en un lado de la línea representarán una categoría y los puntos de datos en el otro lado de la línea se colocarán en una categoría diferente. Esto significa que puede haber un número infinito de líneas para elegir.

Lo que hace que el algoritmo SVM lineal sea mejor que algunos de los otros algoritmos, como los k vecinos más cercanos, es que elige la mejor línea para clasificar sus puntos de datos. Elige la línea que separa los datos y está lo más alejada posible de los puntos de datos del armario.

Un ejemplo de 2-D ayuda a entender toda la jerga del aprendizaje automático. Básicamente, tiene algunos puntos de datos en una cuadrícula. Está intentando separar estos puntos de datos por la categoría en la que deberían encajar, pero no quiere tener ningún dato en la categoría incorrecta. Eso significa que está tratando de encontrar la línea entre los dos puntos más cercanos que mantiene separados los otros puntos de datos.

Entonces, los dos puntos de datos más cercanos le brindan los vectores de soporte que usará para encontrar esa línea. Esa línea se llama límite de decisión.

El límite de decisión no tiene por qué ser una línea. También se lo conoce como hiperplano porque puede encontrar el límite de decisión con cualquier cantidad de características, no solo con dos.

Tipos de SVM

Hay dos tipos diferentes de SVM, cada uno usado para diferentes cosas:

  • SVM simple: se utiliza normalmente para problemas de clasificación y regresión lineal.
  • Kernel SVM: tiene más flexibilidad para datos no lineales porque puede agregar más características para adaptarse a un hiperplano en lugar de un espacio bidimensional.

Por qué se utilizan las SVM en el aprendizaje automático

Las SVM se utilizan en aplicaciones como reconocimiento de escritura a mano, detección de intrusos, detección de rostros, clasificación de correo electrónico, clasificación de genes y en páginas web. Esta es una de las razones por las que usamos SVM en el aprendizaje automático. Puede manejar tanto la clasificación como la regresión en datos lineales y no lineales.

Otra razón por la que usamos SVM es porque pueden encontrar relaciones complejas entre sus datos sin que tenga que hacer muchas transformaciones por su cuenta. Es una gran opción cuando trabaja con conjuntos de datos más pequeños que tienen decenas a cientos de miles de características. Por lo general, encuentran resultados más precisos en comparación con otros algoritmos debido a su capacidad para manejar conjuntos de datos pequeños y complejos.

Estos son algunos de los pros y los contras del uso de SVM.

Pros

  • Efectivo en conjuntos de datos con múltiples características, como datos médicos o financieros.
  • Efectivo en casos donde el número de características es mayor que el número de puntos de datos.
  • Utiliza un subconjunto de puntos de entrenamiento en la función de decisión llamados vectores de soporte que lo hacen eficiente en la memoria.
  • Se pueden especificar diferentes funciones del kernel para la función de decisión. Puede usar kernels comunes, pero también es posible especificar kernels personalizados.

Contras

  • Si la cantidad de características es mucho mayor que la cantidad de puntos de datos, es crucial evitar el ajuste excesivo al elegir las funciones del kernel y el término de regularización.
  • Las SVM no proporcionan estimaciones de probabilidad directamente. Estos se calculan mediante una costosa validación cruzada de cinco veces.
  • Funciona mejor en conjuntos de muestra pequeños debido a su alto tiempo de entrenamiento.

Dado que las SVM pueden utilizar cualquier número de kernels, es importante que conozca algunos de ellos.

Funciones del kernel

Lineal

Estos se recomiendan comúnmente para la clasificación de texto porque la mayoría de estos tipos de problemas de clasificación son linealmente separables.

El kernel lineal funciona muy bien cuando hay muchas características y los problemas de clasificación de texto tienen muchas características. Las funciones lineales del kernel son más rápidas que la mayoría de las demás y tiene menos parámetros para optimizar.

Aquí está la función que define el kernel lineal:

f(X) = w^T * X + b

En esta ecuación, w es el vector de peso que desea minimizar, X son los datos que está tratando de clasificar y b es el coeficiente lineal estimado a partir de los datos de entrenamiento. Esta ecuación define el límite de decisión que devuelve la SVM.

Polinomio

El núcleo polinomial no se usa en la práctica con mucha frecuencia porque no es tan eficiente computacionalmente como otros núcleos y sus predicciones no son tan precisas.

Aquí está la función para un núcleo polinomial:

f(X1, X2) = (a + X1^T * X2) ^ b

Esta es una de las ecuaciones de núcleo polinomial más simples que puede usar. f (X1, X2) representa el límite de decisión polinomial que separará sus datos. X1 y X2 representan sus datos.

Función de base radial gaussiana (RBF)

Uno de los kernels más potentes y más utilizados en SVM. Por lo general, la elección para datos no lineales.

Aquí está la ecuación para un kernel RBF:

f(X1, X2) = exp(-gamma * ||X1 - X2||^2)

En esta ecuación, gamma especifica cuánto tiene un solo punto de entrenamiento en los otros puntos de datos a su alrededor. || X1 - X2 || es el producto escalar entre sus funciones.

Sigmoideo

Más útil en redes neuronales que en máquinas de vectores de soporte, pero hay casos de uso específicos ocasionales.

Aquí está la función para un kernel sigmoide:

f(X, y) = tanh(alpha * X^T * y + C)

In this function, alpha is a weight vector and C is an offset value to account for some mis-classification of data that can happen.

Others

There are plenty of other kernels you can use for your project. This might be a decision to make when you need to meet certain error constraints, you want to try and speed up the training time, or you want to super tune parameters.

Some other kernels include: ANOVA radial basis, hyperbolic tangent, and Laplace RBF.

Now that you know a bit about how the kernels work under the hood, let's go through a couple of examples.

Examples with datasets

To show you how SVMs work in practice, we'll go through the process of training a model with it using the Python Scikit-learn library. This is commonly used on all kinds of machine learning problems and works well with other Python libraries.

Here are the steps regularly found in machine learning projects:

  • Import the dataset
  • Explore the data to figure out what they look like
  • Pre-process the data
  • Split the data into attributes and labels
  • Divide the data into training and testing sets
  • Train the SVM algorithm
  • Make some predictions
  • Evaluate the results of the algorithm

Some of these steps can be combined depending on how you handle your data. We'll do an example with a linear SVM and a non-linear SVM. You can find the code for these examples here.

Linear SVM Example

We'll start by importing a few libraries that will make it easy to work with most machine learning projects.

import matplotlib.pyplot as plt import numpy as np from sklearn import svm

For a simple linear example, we'll just make some dummy data and that will act in the place of importing a dataset.

# linear data X = np.array([1, 5, 1.5, 8, 1, 9, 7, 8.7, 2.3, 5.5, 7.7, 6.1]) y = np.array([2, 8, 1.8, 8, 0.6, 11, 10, 9.4, 4, 3, 8.8, 7.5])

The reason we're working with numpy arrays is to make the matrix operations faster because they use less memory than Python lists. You could also take advantage of typing the contents of the arrays. Now let's take a look at what the data look like in a plot:

# show unclassified data plt.scatter(X, y) plt.show()

Once you see what the data look like, you can take a better guess at which algorithm will work best for you. Keep in mind that this is a really simple dataset, so most of the time you'll need to do some work on your data to get it to a usable state.

We'll do a bit of pre-processing on the already structured code. This will put the raw data into a format that we can use to train the SVM model.

# shaping data for training the model training_X = np.vstack((X, y)).T training_y = [0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1]

Now we can create the SVM model using a linear kernel.

# define the model clf = svm.SVC(kernel='linear', C=1.0)

That one line of code just created an entire machine learning model. Now we just have to train it with the data we pre-processed.

# train the model clf.fit(training_X, training_y)

That's how you can build a model for any machine learning project. The dataset we have might be small, but if you encounter a real-world dataset that can be classified with a linear boundary this model still works.

With your model trained, you can make predictions on how a new data point will be classified and you can make a plot of the decision boundary. Let's plot the decision boundary.

# get the weight values for the linear equation from the trained SVM model w = clf.coef_[0] # get the y-offset for the linear equation a = -w[0] / w[1] # make the x-axis space for the data points XX = np.linspace(0, 13) # get the y-values to plot the decision boundary yy = a * XX - clf.intercept_[0] / w[1] # plot the decision boundary plt.plot(XX, yy, 'k-') # show the plot visually plt.scatter(training_X[:, 0], training_X[:, 1], c=training_y) plt.legend() plt.show()

Non-Linear SVM Example

For this example, we'll use a slightly more complicated dataset to show one of the areas SVMs shine in. Let's import some packages.

import matplotlib.pyplot as plt import numpy as np from sklearn import datasets from sklearn import svm

This set of imports is similar to those in the linear example, except it imports one more thing. Now we can use a dataset directly from the Scikit-learn library.

# non-linear data circle_X, circle_y = datasets.make_circles(n_samples=300, noise=0.05)

The next step is to take a look at what this raw data looks like with a plot.

# show raw non-linear data plt.scatter(circle_X[:, 0], circle_X[:, 1], c=circle_y, marker=".") plt.show()

Now that you can see how the data are separated, we can choose a non-linear SVM to start with. This dataset doesn't need any pre-processing before we use it to train the model, so we can skip that step. Here's how the SVM model will look for this:

# make non-linear algorithm for model nonlinear_clf = svm.SVC(kernel='rbf', C=1.0)

In this case, we'll go with an RBF (Gaussian Radial Basis Function) kernel to classify this data. You could also try the polynomial kernel to see the difference between the results you get. Now it's time to train the model.

# training non-linear model nonlinear_clf.fit(circle_X, circle_y)

You can start labeling new data in the correct category based on this model. To see what the decision boundary looks like, we'll have to make a custom function to plot it.

# Plot the decision boundary for a non-linear SVM problem def plot_decision_boundary(model, ax=None): if ax is None: ax = plt.gca() xlim = ax.get_xlim() ylim = ax.get_ylim() # create grid to evaluate model x = np.linspace(xlim[0], xlim[1], 30) y = np.linspace(ylim[0], ylim[1], 30) Y, X = np.meshgrid(y, x) # shape data xy = np.vstack([X.ravel(), Y.ravel()]).T # get the decision boundary based on the model P = model.decision_function(xy).reshape(X.shape) # plot decision boundary ax.contour(X, Y, P, levels=[0], alpha=0.5, linestyles=['-'])

You have everything you need to plot the decision boundary for this non-linear data. We can do that with a few lines of code that use the Matlibplot library, just like the other plots.

# plot data and decision boundary plt.scatter(circle_X[:, 0], circle_X[:, 1], c=circle_y, s=50) plot_decision_boundary(nonlinear_clf) plt.scatter(nonlinear_clf.support_vectors_[:, 0], nonlinear_clf.support_vectors_[:, 1], s=50, lw=1, facecolors="none") plt.show()

When you have your data and you know the problem you're trying to solve, it really can be this simple.

You can change your training model completely, you can choose different algorithms and features to work with, and you can fine tune your results based on multiple parameters. There are libraries and packages for all of this now so there's not a lot of math you have to deal with.

Tips for real world problems

Real world datasets have some common issues because of how large they can be, the varying data types they hold, and how much computing power they can need to train a model.

There are a few things you should watch out for with SVMs in particular:

  • Make sure that your data are in numeric form instead of categorical form. SVMs expect numbers instead of other kinds of labels.
  • Avoid copying data as much as possible. Some Python libraries will make duplicates of your data if they aren't in a specific format. Copying data will also slow down your training time and skew the way your model assigns the weights to a specific feature.
  • Watch your kernel cache size because it uses your RAM. If you have a really large dataset, this could cause problems for your system.
  • Scale your data because SVM algorithms aren't scale invariant. That means you can convert all of your data to be within the ranges of [0, 1] or [-1, 1].

Other thoughts

You might wonder why I didn't go into the deep details of the math here. It's mainly because I don't want to scare people away from learning more about machine learning.

It's fun to learn about those long, complicated math equations and their derivations, but it's rare you'll be writing your own algorithms and writing proofs on real projects.

It's like using most of the other stuff you do every day, like your phone or your computer. You can do everything you need to do without knowing the how the processors are built.

Machine learning is like any other software engineering application. There are a ton of packages that make it easier for you to get the results you need without a deep background in statistics.

Once you get some practice with the different packages and libraries available, you'll find out that the hardest part about machine learning is getting and labeling your data.

I'm working on a neuroscience, machine learning, web-based thing! You should follow me on Twitter to learn more about it and other cool tech stuff.