Contenido del curso
Funciones Kernel en la Clasificación de Datos Complejos
¿Qué es un Kernel y cómo se utiliza en machine learning?
En el mundo del machine learning, los Kernels juegan un papel crucial al ofrecer soluciones a problemas complejos de clasificación. Un Kernel es una función matemática que permite transformar datos de una dimensión a otra más alta, haciendo posible la clasificación de datos que no son linealmente separables en su espacio original. Este concepto es especialmente útil en modelos como las máquinas de soporte vectorial y se emplea frecuentemente en algoritmos como el de ayuda a clasificación en Scikit-learn.
¿Cómo funciona un Kernel?
El mecanismo subyacente de un Kernel es proyectar los datos a dimensiones superiores, donde puedan ser más fácilmente manipulables. Imagina un conjunto de datos en tres dimensiones. Un Kernel puede transformar los puntos de ese espacio a dimensiones más altas para facilitar su clasificación. Por ejemplo, datos que son difíciles de separar linealmente pueden ser clasificados aplicando una función de Kernel, que permite encontrar un plano o hiperplano que los separe adecuadamente.
Ejemplo visual de la aplicación de Kernels
Para visualizar cómo funciona un Kernel, considera un problema de clasificación con puntos rojos y verdes distribuidos de manera tan compleja que no se pueden separar mediante una línea simple. En lugar de esto, aplicando un Kernel, los datos se proyectan a una dimensión superior donde es posible separar los puntos mediante un plano o función lineal. Este proceso revela el poder de los Kernels en la simplificación de problemas complejos de clasificación.
Tipos de Kernels comunes
La elección del Kernel adecuado es crucial para el éxito en la clasificación de datos complejos. Entre los Kernels más comunes se encuentran:
Cómo implementar Kernels en Scikit-learn
La implementación de Kernels en Scikit-learn es sencilla y eficiente. A continuación, se describe cómo integrarlos en un proyecto de machine learning para la clasificación binaria de datos.
Preparación del entorno y librerías
Para comenzar, es necesario importar las librerías de Scikit-learn y preparar el entorno de desarrollo. Supongamos que se trabaja con datos de pacientes del corazón para decidir si tienen problemas cardíacos.
from sklearn.decomposition import KernelPCA from sklearn.linear_model import LogisticRegression from sklearn.model_selection import train_test_split from sklearn.datasets import load_iris # Carga de datos y preparación del conjunto de entrenamiento y prueba datos = load_iris() X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(datos.data, datos.target, test_size=0.2)
Aplicación de la función Kernel
Una vez preparado el conjunto de datos, se procede a declarar la variable KernelPCA. Este algoritmo permite seleccionar el Kernel y la cantidad de componentes principales a utilizar.
kpca = KernelPCA(n_components=4, kernel='polynomial') # Ajuste de datos X_entrenamiento_kpca = kpca.fit_transform(X_entrenamiento) X_prueba_kpca = kpca.transform(X_prueba)
Implementación de regresión logística
Después de reducir la dimensionalidad usando el Kernel, se puede aplicar un modelo de regresión logística para realizar la clasificación.
modelo = LogisticRegression(solver='lbfgs', multi_class='auto') # Entrenamiento del modelo modelo.fit(X_entrenamiento_kpca, y_entrenamiento) # Evaluación del modelo precision = modelo.score(X_prueba_kpca, y_prueba) print(f"Exactitud del modelo: {precision:.2f}")
Ejecución del modelo
Para asegurar que el modelo corre correctamente, es importante activar el entorno de desarrollo y ejecutar el script de Python.
# Activación del entorno virtual source venv/bin/activate # Ejecución del script python nombre_del_archivo.py
Una vez ejecutado exitosamente, el modelo debería lograr una precisión cercana al 80%, demostrando la eficacia del Kernel en este tipo de aplicaciones.
Consideraciones finales
La implementación de Kernels en machine learning es poderosa pero requiere una comprensión profunda de cuándo y cómo aplicarlos. Experimenta con diferentes tipos de Kernels para adaptar tus modelos a las necesidades específicas de tus datos. ¡Sigue explorando y aprendiendo a medida que te adentras en el apasionante mundo del machine learning!
Miguel Angel Velazquez Romero
Estudiante
Antony Rachit Vargas López
Estudiante
Julián Cárdenas
Estudiante
Kenny José Miranda Deluque
EstudianteJulián Cárdenas
EstudianteMiguel Angel Velazquez Romero
Estudiante
Nicolás Neira Navarrete
Estudiante
Juan R. Vergara M.
Estudiante
María Victoria Pérez Mejía
EstudianteJulián Cárdenas
Estudiante
Cesar Augusto Morales Godoy
EstudianteJuan R. Vergara M.
Estudiante
Carlos Daniel Pimentel Díaz
Estudiante
Camilo Andrés Hurtado Erasso
Estudiante
Said Jacobo
Estudiante
Sergio Rubiano
EstudianteSaid Jacobo
Estudiante
Jorge Andrés Robledo Ariza
Estudiante
Roger Christian Cansaya Olazabal
Estudiante
Christian Sanclemente
Estudiante
Antonio Demarco Bonino
Estudiante
Jhon Freddy Tavera Blandon
Estudiante
Mario Alexander Vargas Celis
Estudiante
Salvador Cardona Noriega
Estudiante
Cesar supo
Estudiante
Emanuel Daniel Yaselga Alvarado
EstudianteMiguel Angel Velazquez Romero
Estudiante
Ariel Sharpe
Estudiante
Daniel Moreno
Estudiante
Juan José Mamani Tarqui
Estudiante
Juan García Bauzá
EstudianteAhora que ya sabemos para el algoritmo de PCA, ¿que otras alternativas tenemos?
Bueno, una alternativa son los Kernels. Un Kernel es una función matemática que toma mediciones que se comportan de manera no lineal y las proyecta en un espacio dimensional más grande en donde sen linealmente separables.
Y, ¿esto para que puede servir?
Sirve para casos en donde no son linealmente separables. El la primera imagen no es posible separarlos con una linea y en la imagen 2 si lo podemos hacer mediante Kernels. Lo que hace la función de Kernels es proyectar los puntos en otra dimensión y así volver los datos linealmente separables.
¿Que tipo de funciones para Kernels nos podemos encontrar?
Ejemplos de funciones de Kernels en datasets aplicados a un clasificador:
Hola Miguel. Como punto importante, te cuento que el profesor explicó únicamente los kernels usados para el clasificador de Support Vector Machine. El kernel para el SVM ayuda para que los datos que antes no eran separables por una línea o un hiperplano, ahora si lo sean, pero en una dimensión mayor.
Ahora bien, ese fue el kernel que explicó el profesor. Pero no todos los kernels funcionan igual, por ejemplo, los kernels para las redes neuronales convolucionales funcionan de forma distinta y también los kernels para el clasificador de KNN también funcionan de otra manera. Es un punto importante a resaltar :)
Buen summary!
Rendimiento de cada una de las técnicas a partir de la cantidad de componentes con las que fueron entrenados vs el accuracy del modelo de regresión logística
Excelente!
Les dejo el código comentado por si no les corre:
# Importamos las bibliotecas generales import pandas as pd import sklearn import matplotlib.pyplot as plt # Importamos los módulos específicos from sklearn.decomposition import KernelPCA from sklearn.linear_model import LogisticRegression from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split if __name__ == "__main__": # Cargamos los datos del dataframe de pandas dt_heart = pd.read_csv('data/heart.csv') # Imprimimos un encabezado con los primeros 5 registros print(dt_heart.head(5)) # Guardamos nuestro dataset sin la columna de target dt_features = dt_heart.drop(['target'], axis=1) # Este será nuestro dataset, pero sin la columna dt_target = dt_heart['target'] # Normalizamos los datos dt_features = StandardScaler().fit_transform(dt_features) # Partimos el conjunto de entrenamiento y para añadir replicabilidad usamos el random state X_train, X_test, y_train, y_test = train_test_split(dt_features, dt_target, test_size=0.3, random_state=42) #Aplicamos la función de kernel de tipo polinomial kpca = KernelPCA(n_components=4, kernel='poly' ) #Vamos a ajustar los datos kpca.fit(X_train) #Aplicamos el algoritmo a nuestros datos de prueba y de entrenamiento dt_train = kpca.transform(X_train) dt_test = kpca.transform(X_test) #Aplicamos la regresión logística un vez que reducimos su dimensionalidad logistic = LogisticRegression(solver='lbfgs') #Entrenamos los datos logistic.fit(dt_train, y_train) #Imprimimos los resultados print("SCORE KPCA: ", logistic.score(dt_test, y_test))
Me ha sorprendido el curso, de los mejores de ML de Platzi. Qué gusto!
Oh sí, algo complejo pero interesante.
Excelente! todos los conceptos y hasta el código muy ordenado.
Así es!
Comparación entre los tres tipos de kernel con este ejercicio en particular
Excelente, gracias amigo.
Para los curiosos, en ésta página hay información sobre la Función de Base Radial (RBF) pero aplicada como una red nuronal.
Así se vel a RBF (Función de Base Radial en Geogebra)
Hola! Con que criterio deberíamos elegir entre un kernel lineal, polinomial o rbf? Experimentando y según los valores de la métrica?
Hola Said!
Si, para tener mas resultados a la hora de operar con ellos, también hay que tener en cuenta los nuevos datos entrantes, ya que por se diferentes kernel su comportamiento estará variando durante el proceso.
Hola Sergio! Muchas gracias por tu respuesta.
Cuando hablas de "nuevos datos entrantes" te referís al momento en que el modelo se pone en producción, o al momento de validar las métricas del modelo con los conjuntos de datos de test y validation?
Hasta el momento ha sido el mejor curso de Machine Learning que hay en la ruta, todo muy bien explicado y con aplicabilidad en código
Comparando los kernels
import pandas as pd import sklearn import matplotlib.pyplot as plt from sklearn.decomposition import KernelPCA from sklearn.linear_model import LogisticRegression from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split if __name__ == "__main__": dt_heart = pd.read_csv('./data/heart.csv') #print(dt_heart.head(5)) dt_features = dt_heart.drop(['target'],axis=1) # separamos los target del dataframe features dt_target = dt_heart['target'] # creamos otra dataframe unicamente con los target dt_features = StandardScaler().fit_transform(dt_features) # estandarizamos los datos X_train, X_test, y_train, y_test = train_test_split(dt_features, dt_target, test_size=0.3, random_state=42) # obtenemos datos de entrenamiento y datos de prueba logistic = LogisticRegression(solver='lbfgs') kernel = ['linear','poly','rbf'] for k in kernel: kpca = KernelPCA(n_components=4, kernel = k) # kernel = linear / poly / rbf kpca.fit(X_train) dt_train = kpca.transform(X_train) dt_test = kpca.transform(X_test) logistic.fit(dt_train, y_train) print("SCORE KPCA " + k + " : ", logistic.score(dt_test, y_test))
$py kpca .py SCORE KPCA linear : 0.8214285714285714 SCORE KPCA poly : 0.7987012987012987 SCORE KPCA rbf : 0.8181818181818182
Increíble forma de enseñar!
Para que quede más claro el tema de los Kernels dejo estas metáforas con Caperucita roja.:
Kernel PCA (KPCA):
Kernel PCA es una extensión del algoritmo de Análisis de Componentes Principales (PCA) que utiliza kernels para realizar una transformación no lineal de los datos. A diferencia del estándar PCA, que busca las direcciones de máxima variación en el espacio original, KPCA busca las direcciones de máxima variación en un espacio de mayor dimensionalidad después de la aplicación de un kernel.
import pandas as pd from sklearn.decomposition import KernelPCA from sklearn.preprocessing import StandardScaler import matplotlib.pyplot as plt # Carga del conjunto de datos data = pd.read_csv('heart.csv') # Separación de características y etiquetas X = data.drop(columns=['target']) y = data['target'] # Estandarización de características scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # Aplicación de Kernel PCA kpca = KernelPCA(n_components=2, kernel='rbf') # Elegimos 2 componentes principales y kernel radial (RBF) X_kpca = kpca.fit_transform(X_scaled) # Gráfica de resultados plt.scatter(X_kpca[:, 0], X_kpca[:, 1], c=y, cmap='viridis') plt.title('Kernel PCA') plt.xlabel('Componente Principal 1') plt.ylabel('Componente Principal 2') plt.show()
Las Funciones Kernel son fundamentales en máquinas de soporte vectorial (SVM) cuando se trata de clasificación de datos complejos que no son linealmente separables. Aquí te explico de forma clara:
🧠 ¿Qué es una Función Kernel?
Una función kernel es una técnica matemática que permite transformar datos de un espacio de entrada no lineal a un espacio de mayor dimensión donde sí pueden ser separados linealmente.
En lugar de transformar explícitamente los datos, el kernel calcula similitudes entre puntos como si estuvieran en ese espacio transformado.
🎯 ¿Por qué usar funciones kernel?
Porque muchos problemas reales (biología, medicina, imágenes, etc.) no pueden ser separados por una línea recta o un plano. El kernel proporciona la flexibilidad para encontrar fronteras de decisión curvas o más complejas.
🔧 Tipos de Funciones Kernel más comunes
KernelEcuación¿Cuándo usarlo?LinealK(x,x′)=x⋅x′K(x, x') = x \cdot x'Cuando los datos son linealmente separables.PolinómicoK(x,x′)=(x⋅x′+c)dK(x, x') = (x \cdot x' + c)^dCuando hay interacción entre características.RBF o GaussianoK(x,x′)=exp(−γ∥x−x′∥2)K(x, x') = \exp(-\gamma \|x - x'\|^2)Cuando los datos no son linealmente separables y se necesita una frontera curva.SigmoideK(x,x′)=tanh(αx⋅x′+c)K(x, x') = \tanh(\alpha x \cdot x' + c)Inspirado en redes neuronales, poco usado.
📦 Ejemplo con SVM y Kernel RBF en Scikit-learn
from sklearn.datasets import make_circles from sklearn.svm import SVC from sklearn.model_selection import train_test_split import matplotlib.pyplot as plt
# Generar datos no linealmente separables X, y = make_circles(n_samples=300, factor=0.5, noise=0.1)
# Dividir datos X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
# Clasificador con kernel RBF clf = SVC(kernel='rbf', gamma=1) clf.fit(X_train, y_train)
# Visualización import numpy as np
xx, yy = np.meshgrid(np.linspace(-1.5, 1.5, 300), np.linspace(-1.5, 1.5, 300)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.3) plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', edgecolors='k') plt.title("Clasificación con Kernel RBF") plt.show()
✅ Ventajas de usar Kernels
🧪 ¿Cuándo usar funciones kernel?
Usa funciones kernel si:
8:45 La implementación es fácil. El gran trabajo es identificar es cuándo debemos utilizar un kernel. ¿Cuál es el fundamento para saberlo?
Yo los utilizo si me dan mejores resultados que otros métodos así que paso mucho tiempo en esta parte de preparación de datos.
Osea el método de Kernel es lo contrario al PCA
No exactaente lo contrario, pero si son diferentes:
PCA: Básicamente cosiste en reducir la complejidad del problema:
1.- Seleccionando solamente las variables relevantes.
2.- Combinándolas en nuevas variables que mantengan la información más importante (varianza de los features).
Kernels:
Un Kernel es una función matemática que toma mediciones que se comportan de manera no lineal y las proyecta en un espacio dimensional más grande en donde son linealmente separables.
Podrías decir que si, al final con PCA disminuis las dimensiones y con Kernel las aumentas para poder resolver problemas no lineales con soluciones lineales.
¿Cuáles son algunos criterios que podríamos considerar al seleccionar el mejor tipo de kernel en Kernel Principal Component Analysis (KPCA)?
Seleccionar el mejor tipo de kernel en Kernel Principal Component Analysis (KPCA) puede depender de varios factores, como la naturaleza de los datos y el objetivo del análisis. Aquí hay algunos criterios que puedes considerar al elegir el tipo de kernel en KPCA:
En resumen, la selección del tipo de kernel en KPCA depende de factores como la naturaleza de los datos, la interpretabilidad del modelo, el rendimiento predictivo y la experimentación con diferentes opciones, respaldada por técnicas de validación cruzada, puede ayudarte a tomar la mejor decisión.
<u>Que son los Kernels?</u>
En el contexto del aprendizaje automático y especialmente en técnicas como el Análisis de Componentes Principales Kernelizado (Kernel PCA) y las Máquinas de Vectores de Soporte (SVM), un kernel es una función matemática que calcula la similitud entre pares de puntos de datos en un espacio dimensional superior o en un espacio de características ampliado.
Los kernels son fundamentales en el aprendizaje automático porque permiten realizar operaciones en un espacio de características de mayor dimensionalidad sin la necesidad de calcular explícitamente las coordenadas de esos puntos en el espacio de características de alta dimensión. En su lugar, los kernels calculan el producto interno entre los vectores de características en el espacio de características de alta dimensión sin la necesidad de representar explícitamente estos vectores.
Los kernels son especialmente útiles cuando los datos no son linealmente separables en el espacio de características original, ya que pueden transformar los datos en un espacio de características de mayor dimensión donde la separación lineal es posible.
Algunos ejemplos comunes de kernels incluyen:
En resumen, los kernels son funciones que permiten calcular la similitud entre pares de puntos de datos en un espacio dimensional superior, lo que es fundamental para muchas técnicas de aprendizaje automático.
Esta interesante hasta ahora el curso. Espero que al final del curso se llegue a una conclusión de las predicciones, cosas que le faltan a otros cursos de ML de Platzi.
