S23L04 – Implementación de SVM usando Python

html
Implementación de Máquinas de Vectores de Soporte (SVM) en Python: Una Guía Integral

Bienvenido a nuestra guía detallada sobre la implementación de Máquinas de Vectores de Soporte (SVM) utilizando la biblioteca scikit-learn de Python. Ya seas un entusiasta de la ciencia de datos o un profesional experimentado, este artículo te guiará a través de todo el proceso, desde comprender los conceptos fundamentales de SVM hasta ejecutar una implementación completa usando un Notebook de Jupyter. ¡Vamos a empezar!

Tabla de Contenidos

    Introducción a las Máquinas de Vectores de Soporte (SVM)
    Configuración del Entorno
    Exploración y Preprocesamiento de Datos
        
            Manejo de Datos Faltantes
            Codificación de Variables Categóricas
            Selección de Características
        
    
    División del Conjunto de Datos
    Escalado de Características
    Construcción y Evaluación de Modelos
        
            K-Vecinos Más Cercanos (KNN)
            Regresión Logística
            Naive Bayes Gaussiano
            Máquina de Vectores de Soporte (SVM)
        
    
    Visualización de Regiones de Decisión
    Conclusión
    Referencias



1. Introducción a las Máquinas de Vectores de Soporte (SVM)

Las Máquinas de Vectores de Soporte (SVM) son poderosos modelos de aprendizaje supervisado utilizados para tareas de clasificación y regresión. Son particularmente efectivas en espacios de alta dimensión y versátiles, gracias al uso de diferentes funciones de kernel. Las SVM buscan encontrar el hiperplano óptimo que mejor separa los puntos de datos de diferentes clases con el margen máximo.

Características Clave de SVM:

    Optimización del Margen: Las SVM maximizan el margen entre clases para asegurar una mejor generalización.
    Truco del Kernel: Permite que las SVM funcionen bien en clasificación no lineal al transformar los datos a dimensiones superiores.
    Robustez: Efectivas en casos con un margen claro de separación e incluso en espacios de alta dimensión.



2. Configuración del Entorno

Antes de comenzar, asegúrate de tener instaladas las bibliotecas necesarias. Puedes instalarlas usando pip:





		
		
			
			
Java
			
			pip install pandas numpy scikit-learn seaborn matplotlib mlxtend
			
				
					
				
					1
				
						pip install pandas numpy scikit-learn seaborn matplotlib mlxtend
					
				
			
		



Nota: mlxtend se utiliza para visualizar regiones de decisión.


3. Exploración y Preprocesamiento de Datos

El preprocesamiento de datos es un paso crucial en cualquier pipeline de aprendizaje automático. Involucra la limpieza de los datos, el manejo de valores faltantes, la codificación de variables categóricas y la selección de características relevantes.

3.1 Manejo de Datos Faltantes

Los datos faltantes pueden afectar negativamente el rendimiento de los modelos de aprendizaje automático. Manejarremos los valores faltantes mediante:


    Características Numéricas: Imputando valores faltantes con la media.
    Características Categóricas: Imputando valores faltantes con el valor más frecuente.






		
		
			
			
Java
			
			import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer

# Load the dataset
data = pd.read_csv('weatherAUS.csv')

# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Handle numeric missing values
numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_numeric = SimpleImputer(strategy='mean')
X[numeric_cols] = imputer_numeric.fit_transform(X[numeric_cols])

# Handle categorical missing values
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_categorical = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_categorical.fit_transform(X[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
 
# Load the dataset
data = pd.read_csv('weatherAUS.csv')
 
# Separate features and target
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Handle numeric missing values
numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_numeric = SimpleImputer(strategy='mean')
X[numeric_cols] = imputer_numeric.fit_transform(X[numeric_cols])
 
# Handle categorical missing values
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_categorical = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_categorical.fit_transform(X[categorical_cols])
					
				
			
		



3.2 Codificación de Variables Categóricas

Los modelos de aprendizaje automático requieren entradas numéricas. Convertiremos las variables categóricas utilizando:


    Codificación de Etiquetas: Para categorías binarias o de alta cardinalidad.
    Codificación One-Hot: Para categorías con un número limitado de valores únicos.






		
		
			
			
Java
			
			from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

# Label Encoding function
def label_encode(series):
    le = LabelEncoder()
    return le.fit_transform(series)

# Apply Label Encoding to target variable
y = label_encode(y)

# Identify columns for encoding
def encoding_selection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_cols = [col for col in string_cols if X[col].nunique() &lt;= threshold]
    label_encode_cols = [col for col in string_cols if X[col].nunique() &gt; threshold]
    
    # Label Encode
    for col in label_encode_cols:
        X[col] = label_encode(X[col])
    
    # One-Hot Encode
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), one_hot_cols)], remainder='passthrough')
    X = ct.fit_transform(X)
    return X

X = encoding_selection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer
 
# Label Encoding function
def label_encode(series):
    le = LabelEncoder()
    return le.fit_transform(series)
 
# Apply Label Encoding to target variable
y = label_encode(y)
 
# Identify columns for encoding
def encoding_selection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_cols = [col for col in string_cols if X[col].nunique() &lt;= threshold]
    label_encode_cols = [col for col in string_cols if X[col].nunique() &gt; threshold]
    
    # Label Encode
    for col in label_encode_cols:
        X[col] = label_encode(X[col])
    
    # One-Hot Encode
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), one_hot_cols)], remainder='passthrough')
    X = ct.fit_transform(X)
    return X
 
X = encoding_selection(X)
					
				
			
		



3.3 Selección de Características

Seleccionar características relevantes puede mejorar el rendimiento del modelo y reducir la complejidad computacional. Usaremos SelectKBest con la estadística Chi-Cuadrado.





		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Select top 2 features
selector = SelectKBest(score_func=chi2, k=2)
X_selected = selector.fit_transform(X_scaled, y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# Select top 2 features
selector = SelectKBest(score_func=chi2, k=2)
X_selected = selector.fit_transform(X_scaled, y)
					
				
			
		




4. División del Conjunto de Datos

Dividiremos el conjunto de datos en conjuntos de entrenamiento y prueba para evaluar el rendimiento del modelo en datos no vistos.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)
			
				
					
				
					1
2
3
				
						from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1)
					
				
			
		




5. Escalado de Características

El escalado de características asegura que todas las características contribuyan por igual al rendimiento del modelo.





		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.preprocessing import StandardScaler
 
scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)
 
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		




6. Construcción y Evaluación de Modelos

Construiremos cuatro modelos diferentes para comparar su rendimiento:


    K-Vecinos Más Cercanos (KNN)
    Regresión Logística
    Naive Bayes Gaussiano
    Máquina de Vectores de Soporte (SVM)


6.1 K-Vecinos Más Cercanos (KNN)





		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
accuracy_knn = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {accuracy_knn:.4f}')
					
				
			
		



Salida:




		
		
			
			
Java
			
			KNN Accuracy: 0.8003
			
				
					
				
					1
				
						KNN Accuracy: 0.8003
					
				
			
		



6.2 Regresión Logística





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.linear_model import LogisticRegression
 
log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
accuracy_lr = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {accuracy_lr:.4f}')
					
				
			
		



Salida:




		
		
			
			
Java
			
			Logistic Regression Accuracy: 0.8297
			
				
					
				
					1
				
						Logistic Regression Accuracy: 0.8297
					
				
			
		



6.3 Naive Bayes Gaussiano





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.naive_bayes import GaussianNB
 
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
accuracy_gnb = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {accuracy_gnb:.4f}')
					
				
			
		



Salida:




		
		
			
			
Java
			
			Gaussian Naive Bayes Accuracy: 0.7960
			
				
					
				
					1
				
						Gaussian Naive Bayes Accuracy: 0.7960
					
				
			
		



6.4 Máquina de Vectores de Soporte (SVM)





		
		
			
			
Java
			
			from sklearn.svm import SVC

svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.svm import SVC
 
svc = SVC()
svc.fit(X_train, y_train)
y_pred_svc = svc.predict(X_test)
accuracy_svc = accuracy_score(y_pred_svc, y_test)
print(f'SVM Accuracy: {accuracy_svc:.4f}')
					
				
			
		



Salida:




		
		
			
			
Java
			
			SVM Accuracy: 0.8282
			
				
					
				
					1
				
						SVM Accuracy: 0.8282
					
				
			
		



Resumen de Precisión de los Modelos:

    
        Modelo
        Precisión
    
    
        KNN
        80.03%
    
    
        Regresión Logística
        82.97%
    
    
        Gaussian Naive Bayes
        79.60%
    
    
        SVM
        82.82%
    


Entre los modelos evaluados, Regresión Logística supera ligeramente a SVM, seguida de cerca por SVM.



7. Visualización de Regiones de Decisión

Visualizar las fronteras de decisión ayuda a entender cómo diferentes modelos clasifican los datos.





		
		
			
			
Java
			
			from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets

# Load Iris dataset for visualization
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target

# Initialize models
knn_vis = KNeighborsClassifier(n_neighbors=3)
log_reg_vis = LogisticRegression(random_state=0, max_iter=200)
gnb_vis = GaussianNB()
svc_vis = SVC()

# Fit models
knn_vis.fit(X_vis, y_vis)
log_reg_vis.fit(X_vis, y_vis)
gnb_vis.fit(X_vis, y_vis)
svc_vis.fit(X_vis, y_vis)

# Visualization function
def visualize_decision_regions(X, y, model, title):
    plot_decision_regions(X, y, clf=model, legend=2)
    plt.title(title)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()

# Plot decision regions for each model
visualize_decision_regions(X_vis, y_vis, knn_vis, 'K-Nearest Neighbors Decision Regions')
visualize_decision_regions(X_vis, y_vis, log_reg_vis, 'Logistic Regression Decision Regions')
visualize_decision_regions(X_vis, y_vis, gnb_vis, 'Gaussian Naive Bayes Decision Regions')
visualize_decision_regions(X_vis, y_vis, svc_vis, 'SVM Decision Regions')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
				
						from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
 
# Load Iris dataset for visualization
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target
 
# Initialize models
knn_vis = KNeighborsClassifier(n_neighbors=3)
log_reg_vis = LogisticRegression(random_state=0, max_iter=200)
gnb_vis = GaussianNB()
svc_vis = SVC()
 
# Fit models
knn_vis.fit(X_vis, y_vis)
log_reg_vis.fit(X_vis, y_vis)
gnb_vis.fit(X_vis, y_vis)
svc_vis.fit(X_vis, y_vis)
 
# Visualization function
def visualize_decision_regions(X, y, model, title):
    plot_decision_regions(X, y, clf=model, legend=2)
    plt.title(title)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()
 
# Plot decision regions for each model
visualize_decision_regions(X_vis, y_vis, knn_vis, 'K-Nearest Neighbors Decision Regions')
visualize_decision_regions(X_vis, y_vis, log_reg_vis, 'Logistic Regression Decision Regions')
visualize_decision_regions(X_vis, y_vis, gnb_vis, 'Gaussian Naive Bayes Decision Regions')
visualize_decision_regions(X_vis, y_vis, svc_vis, 'SVM Decision Regions')
					
				
			
		



Visualizaciones:

Las fronteras de decisión de cada modelo se mostrarán en gráficos separados, ilustrando cómo clasifican diferentes regiones en el espacio de características.


8. Conclusión

En esta guía, hemos explorado la implementación de Máquinas de Vectores de Soporte (SVM) utilizando la biblioteca scikit-learn de Python. Desde el preprocesamiento de datos hasta la construcción y evaluación de varios modelos, incluyendo SVM, hemos cubierto pasos esenciales en un pipeline típico de aprendizaje automático. Además, la visualización de regiones de decisión proporcionó una comprensión más profunda de cómo diferentes algoritmos realizan tareas de clasificación.

Puntos Clave:

    Preprocesamiento de Datos: Crucial para limpiar y preparar los datos para el modelado.
    Selección y Escalado de Características: Mejoran el rendimiento y la eficiencia del modelo.
    Comparación de Modelos: Evaluar múltiples algoritmos ayuda a seleccionar el mejor desempeño para tu conjunto de datos.
    Visualización: Una herramienta poderosa para entender el comportamiento del modelo y los procesos de toma de decisiones.


Siguiendo este enfoque integral, puedes implementar eficazmente SVM y otros algoritmos de clasificación para resolver problemas del mundo real.


9. Referencias


    Documentación de Scikit-Learn
    Máquinas de Vectores de Soporte - Wikipedia
    MLxtend: Extensiones de Aprendizaje Automático




¡Gracias por leer! Si tienes alguna pregunta o comentario, no dudes en dejar un comentario a continuación.
Modelo	Precisión
KNN	80.03%
Regresión Logística	82.97%
Gaussian Naive Bayes	79.60%
SVM	82.82%