Truco del kernel

Cuando los datos no son linealmente separables, es necesario aplicar técnicas avanzadas para poder clasificarlos correctamente. En este caso, se pueden crear combinaciones no lineales de las características originales y proyectarlas en un espacio de mayor dimensión mediante una función de mapeo, utilizando el truco del kernel. Este concepto es esencial en el aprendizaje automático, especialmente en algoritmos como las Máquinas de Soporte Vectorial (SVM).

El truco del kernel permite resolver problemas no lineales al transformar los datos al mencionado espacio de mayor dimensión sin necesidad de calcular explícitamente dicha transformación. Esto hace posible encontrar fronteras de decisión en este nuevo espacio que no serían evidentes en el espacio original. Es una técnica poderosa y versátil que se diferencia de otros modelos clásicos como la regresión logística, el perceptrón o la red ADALINE, los cuales se limitan principalmente a datos linealmente separables o requieren transformaciones explícitas.

El truco del kernel es una técnica utilizada en algoritmos de aprendizaje automático que calcula productos escalares en un espacio de mayor dimensión (llamado espacio de características) sin realizar explícitamente la transformación de los datos. Esto se logra mediante funciones de kernel, que son funciones matemáticas diseñadas para operar en el espacio original de los datos.

En términos simples, el truco del kernel permite resolver problemas no lineales en el espacio original al transformarlos en problemas lineales en un espacio de mayor dimensión.

El truco del kernel es especialmente útil en tareas donde los datos no son separables linealmente. Al utilizar funciones de kernel, los algoritmos pueden:

1. Encontrar fronteras de decisión más complejas: Transformando los datos a un espacio de mayor dimensión, los algoritmos pueden clasificar mejor los datos.
2. Resolver problemas no lineales: Hace que algoritmos lineales, como las SVM, sean capaces de manejar relaciones no lineales entre variables.
3. Optimizar recursos computacionales: Permite trabajar en espacios de mayor dimensión sin calcular explícitamente las coordenadas, ahorrando tiempo y memoria.
4. Para la detección de caras: Identifica patrones faciales en fotografías o videos utilizando algoritmos avanzados.
5. Para el spam de los correos electrónicos: Clasifica correos como spam o no spam, mejorando la experiencia del usuario.
6. Para reconocer caracteres: Interpreta texto en imágenes o documentos mediante sistemas de aprendizaje automático.

El truco del kernel utiliza una función de kernel K(xi,xj) para calcular el producto escalar entre dos puntos (x_i​, x_j​) en el espacio transformado (de mayor dimensión) sin necesidad de realizar la transformación explícita. Los pasos básicos son:

1. Seleccionar una función de kernel: Algunas funciones comunes son:
   • Kernel lineal: Ideal para datos linealmente separables.
   • Kernel polinómico: Introduce relaciones polinómicas entre características.
   • Kernel gaussiano (RBF): Popular para problemas complejos y no lineales.
2. Calcular productos escalares: En lugar de transformar cada dato al espacio de mayor dimensión, el kernel realiza operaciones directamente en el espacio original.
3. Ajustar el modelo: Utilizando el kernel, algoritmos como las SVM ajustan el modelo en el espacio transformado para encontrar una frontera de decisión que maximice el margen.

Por ejemplo si tenemos el siguiente conjunto de datos en donde no es posible encontrar un límite de decisión lineal:

1. Capacidad de manejar datos no lineales: Hace posible resolver problemas que no tienen una separación lineal en el espacio original.
2. Flexibilidad: Ofrece múltiples funciones de kernel que se pueden adaptar a diferentes tipos de datos y problemas.
3. Optimización computacional: Permite trabajar en espacios de alta dimensionalidad sin calcular explícitamente las coordenadas.

1. Dificultad para elegir el kernel adecuado: Seleccionar la función de kernel correcta puede ser un desafío y requiere pruebas.
2. Mayor complejidad computacional: Aunque ahorra cálculos explícitos, trabajar con kernels en grandes conjuntos de datos puede ser costoso.
3. Riesgo de sobreajuste: Si se usa un kernel demasiado complejo, el modelo puede ajustarse demasiado a los datos de entrenamiento, perdiendo capacidad de generalización.

Por ejemplo, si tenemos el siguiente conjunto de datos:

El gráfico muestra un conjunto de datos donde las clases (representadas por puntos rojos y azules) no son linealmente separables. Para abordar este problema, utilizamos un clasificador SVM kernelizado configurado con los siguientes parámetros:

svm = SVC(kernel='rbf', gamma=1.0, C=100.0, random_state=1)

Explicación del clasificador SVM kernelizado:

1. Kernel RBF (Radial Basis Function):

1. • También conocido como kernel Gaussiano, es ideal para resolver problemas no lineales. Este kernel proyecta los datos en un espacio de mayor dimensión, donde es más probable encontrar una separación lineal.
   • Ayuda a modelar relaciones complejas entre los datos al medir la similitud entre puntos en el espacio original.

2. Parámetro gamma:

1. • Gamma = 1.0 controla la influencia de un punto de entrenamiento en la determinación de la frontera de decisión.
   • Un valor de gamma mayor enfoca la separación en puntos más cercanos, mientras que un valor menor tiene en cuenta puntos más alejados.

3. Parámetro C:

1. • C = 100.0 determina la importancia del margen de separación entre las clases.
   • Un valor alto de CCC penaliza más los errores de clasificación, buscando maximizar la precisión del modelo en el conjunto de entrenamiento.

4. random_state:

1. • Este parámetro asegura reproducibilidad al establecer una semilla fija para los cálculos.

Donde el kernel con una función de base radial o función de kernel Gaussiana está definida por:

Para ello vamos a generar una matriz aleatoria de 200 filas y dos columnas, donde después creamos una puerta XOR con los datos, hacemos la división de los datos, normalizamos, entrenamos el modelo, hacemos el test y llamamos al método getMetricas (y _ predic,y _ test):

El siguiente algoritmo nos va a mostrar el número de datos que clasifica, la exactitud del modelo y su matriz de confusión:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
from sklearn import datasets
def getDatos():
    np.random.seed(1)
    #Genera una matriz aleatoria de 200 filas x 2 columnas
    matriz= np.random.randn(200, 2)
    A=matriz[:, 0] > 0
    B=matriz[:, 1] > 0
    y_xor = np.logical_xor(A,B)                   
    y_xor = np.where(y_xor, 1, -1)     
    return matriz,y_xor    
def divisionDatos(X, Y):
    X_train, X_test, y_train, y_test = train_test_split(
    X, Y, test_size=0.3, random_state=1, stratify=Y)
    return X_train, X_test, y_train, y_test
def normalizacion(X_train,X_test):
    #Normalizamos los datos
    normalizar = StandardScaler()
    X_train_std = normalizar.fit_transform(X_train)
    X_test_std = normalizar.transform(X_test)
    return X_train_std, X_test_std    
def getMetricas(Y_predic,Y_test):
    print("Numero de datos mal clasificados: ")
    print((Y_predic != Y_test).sum())
    exactitud = accuracy_score(Y_test,Y_predic)
    print("Exactitud del modelo:")
    print(exactitud) 
    print('La matriz de confusion es: ')
    print(confusion_matrix(Y_test,Y_predic))        
X,Y = getDatos()
X_train, X_test, y_train, y_test = divisionDatos(X, Y)
X_train_std, X_test_std=normalizacion(X_train,X_test)
svm = SVC(kernel='rbf', gamma=1.0, C=100.0, random_state=1)
svm.fit(X_train_std,y_train)
y_predic=svm.predict(X_test_std)
getMetricas(y_predic,y_test)

Numero de datos mal clasificados:

3

Exactitud del modelo:

0.95

La matriz de confusion es:

[[29  1] [ 2 28]]

 

1. Regresión logística:
   • Función de decisión: Basada en probabilidad, utiliza una función sigmoide.
   • Limitación: Solo separa datos linealmente, a menos que se transformen las características.
   • Ventaja: Generaliza bien y es robusta frente a valores atípicos.
2. Perceptrón:
   • Función de decisión: Usa una función escalón para clasificar.
   • Limitación: No funciona bien con datos no linealmente separables y no minimiza un error global.
3. ADALINE:
   • Función de decisión: Minimiza el error cuadrático medio (MSE) en lugar de errores de clasificación directa.
   • Limitación: Es lineal y no puede manejar problemas no lineales sin transformaciones.
4. Truco del kernel (en SVM):
   • Función de decisión: Encuentra un hiperplano en un espacio transformado utilizando kernels.
   • Ventaja: Resuelve problemas no lineales con fronteras de decisión complejas.
   • Limitación: Requiere más recursos computacionales y cuidado en la selección del kernel.

El truco del kernel es una técnica clave en aprendizaje automático que permite resolver problemas no lineales de manera eficiente y elegante. Su capacidad para transformar los datos y encontrar fronteras complejas lo hace indispensable en algoritmos como las SVM. Aunque tiene limitaciones como el riesgo de sobreajuste y la selección del kernel adecuado, su flexibilidad y potencia lo convierten en una herramienta valiosa para problemas de clasificación y regresión complejos. Comparado con modelos más básicos como la regresión logística, el perceptrón y ADALINE, el truco del kernel sobresale en escenarios donde los datos no son lineales.