S20L03 – Regresión logística en Python

html
Implementación de Regresión Logística en Python: Una Guía Integral

Desbloquea el poder de la Regresión Logística con la biblioteca Scikit-Learn de Python. Aprende cómo preprocesar datos, manejar valores faltantes, realizar selección de características y construir modelos de clasificación eficientes. Mejora tus habilidades en aprendizaje automático con este tutorial paso a paso.



Introducción a la Regresión Logística

La Regresión Logística es un algoritmo fundamental en el aprendizaje automático, utilizado principalmente para tareas de clasificación binaria. A diferencia de la regresión lineal, que predice resultados continuos, la regresión logística estima la probabilidad de un resultado binario basado en una o más variables predictoras.

En esta guía integral, recorreremos la implementación de un modelo de Regresión Logística en Python utilizando Scikit-Learn. Cubriremos el preprocesamiento de datos, manejo de valores faltantes, codificación de variables categóricas, selección de características, escalado y evaluación del modelo. Además, compararemos el rendimiento de la Regresión Logística con el clasificador K-Vecinos Más Cercanos (KNN).

Tabla de Contenidos

    Comprendiendo la Regresión Logística
    Configurando el Entorno
    Exploración y Preprocesamiento de Datos
    Manejo de Datos Faltantes
    Codificación de Variables Categóricas
    Selección de Características
    Escalado de Características
    Entrenando los Modelos
    Evaluando el Rendimiento del Modelo
    Ajuste de Hiperparámetros
    Conclusión


Comprendiendo la Regresión Logística

La Regresión Logística es un modelo lineal utilizado para tareas de clasificación. Predice la probabilidad de que una entrada dada pertenezca a una clase particular. La salida se transforma utilizando la función logística (sigmoide), que asegura que los valores de salida estén entre 0 y 1.

Características Clave:

    Clasificación Binaria: Ideal para escenarios donde la variable objetivo tiene dos clases.
    Estimaciones de Probabilidad: Proporciona probabilidades para las pertenencias a clases.
    Línea de Decisión Lineal: Asume una relación lineal entre las características de entrada y los log-odds del resultado.


Configurando el Entorno

Antes de sumergirnos en la codificación, asegúrate de tener las bibliotecas necesarias instaladas. Utilizaremos Pandas para la manipulación de datos, NumPy para operaciones numéricas, Scikit-Learn para algoritmos de aprendizaje automático y Seaborn para la visualización de datos.





		
		
			
			
Java
			
			import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
					
				
			
		



Exploración y Preprocesamiento de Datos

Para este tutorial, utilizaremos el Conjunto de Datos Weather Australia. Este conjunto de datos contiene registros de observaciones meteorológicas en varias ciudades australianas.

Cargando los Datos





		
		
			
			
Java
			
			# Cargar el conjunto de datos
data = pd.read_csv('weatherAUS.csv')
			
				
					
				
					1
2
				
						# Cargar el conjunto de datos
data = pd.read_csv('weatherAUS.csv')
					
				
			
		



Echemos un vistazo a las últimas filas para entender la estructura de los datos:





		
		
			
			
Java
			
			data.tail()
			
				
					
				
					1
				
						data.tail()
					
				
			
		



Salida de Muestra:


    
        Fecha
        Ubicación
        TempMin
        TempMax
        Lluvia
        Evaporación
        ...
        LluviaHoy
        RIESGO_MM
        LluviaMañana
    
    
        2017-06-20
        Uluru
        3.5
        21.8
        0.0
        NaN
        ...
        No
        0.0
        No
    
    
        2017-06-21
        Uluru
        2.8
        23.4
        0.0
        NaN
        ...
        No
        0.0
        No
    
    
        2017-06-22
        Uluru
        3.6
        25.3
        0.0
        NaN
        ...
        No
        0.0
        No
    
    
        2017-06-23
        Uluru
        5.4
        26.9
        0.0
        NaN
        ...
        No
        0.0
        No
    
    
        2017-06-24
        Uluru
        7.8
        27.0
        0.0
        NaN
        ...
        No
        0.0
        No
    


Separando Características y Variable Objetivo





		
		
			
			
Java
			
			# Características
X = data.iloc[:, :-1]

# Variable objetivo
y = data.iloc[:, -1]
			
				
					
				
					1
2
3
4
5
				
						# Características
X = data.iloc[:, :-1]
 
# Variable objetivo
y = data.iloc[:, -1]
					
				
			
		



Manejo de un Requisito Específico del Conjunto de Datos:

Si estás trabajando exclusivamente con el conjunto de datos Weather Australia, es posible que necesites eliminar columnas específicas:





		
		
			
			
Java
			
			X.drop('RISK_MM', axis=1, inplace=True)
			
				
					
				
					1
				
						X.drop('RISK_MM', axis=1, inplace=True)
					
				
			
		



Manejo de Datos Faltantes

Los conjuntos de datos del mundo real a menudo contienen valores faltantes. El manejo adecuado es crucial para asegurar la precisión del modelo.

Manejo de Datos Numéricos

Utilizaremos el SimpleImputer de Scikit-Learn para reemplazar los valores numéricos faltantes con la media de cada columna.





		
		
			
			
Java
			
			from sklearn.impute import SimpleImputer

# Identificar columnas numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns

# Inicializar el imputador
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Ajustar y transformar los datos
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.impute import SimpleImputer
 
# Identificar columnas numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
 
# Inicializar el imputador
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Ajustar y transformar los datos
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
					
				
			
		



Manejo de Datos Categóricos

Para las variables categóricas, reemplazaremos los valores faltantes con la categoría más frecuente.





		
		
			
			
Java
			
			# Identificar columnas de texto
string_cols = X.select_dtypes(include=['object']).columns

# Inicializar el imputador
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Ajustar y transformar los datos
X[string_cols] = imp_mode.fit_transform(X[string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Identificar columnas de texto
string_cols = X.select_dtypes(include=['object']).columns
 
# Inicializar el imputador
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Ajustar y transformar los datos
X[string_cols] = imp_mode.fit_transform(X[string_cols])
					
				
			
		



Codificación de Variables Categóricas

Los modelos de aprendizaje automático requieren entradas numéricas. Transformaremos las variables categóricas utilizando Codificación One-Hot y Codificación de Etiquetas en función del número de categorías únicas.

Codificación One-Hot

Ideal para variables categóricas con un número pequeño de categorías únicas.





		
		
			
			
Java
			
			def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        transformers=[('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)

one_hot_indices = [X.columns.get_loc(col) for col in string_cols if X[col].nunique() &lt;= 10]
X = OneHotEncoderMethod(one_hot_indices, X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        transformers=[('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
 
one_hot_indices = [X.columns.get_loc(col) for col in string_cols if X[col].nunique() &lt;= 10]
X = OneHotEncoderMethod(one_hot_indices, X)
					
				
			
		



Codificación de Etiquetas

Adecuada para variables categóricas binarias.





		
		
			
			
Java
			
			def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)

binary_cols = [col for col in string_cols if X[col].nunique() == 2]
for col in binary_cols:
    X[col] = LabelEncoderMethod(X[col])
			
				
					
				
					1
2
3
4
5
6
7
				
						def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)
 
binary_cols = [col for col in string_cols if X[col].nunique() == 2]
for col in binary_cols:
    X[col] = LabelEncoderMethod(X[col])
					
				
			
		



Selección de Codificación para X

Para variables categóricas con más de dos categorías (y por encima de un cierto umbral), utilizaremos Codificación de Etiquetas. De lo contrario, aplicaremos Codificación One-Hot.





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_count = X[col].nunique()
        if unique_count == 2 or unique_count &gt; threshold:
            X[col] = LabelEncoderMethod(X[col])
        else:
            one_hot_encoding_indices.append(X.columns.get_loc(col))
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

X = EncodingSelection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						def EncodingSelection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_count = X[col].nunique()
        if unique_count == 2 or unique_count &gt; threshold:
            X[col] = LabelEncoderMethod(X[col])
        else:
            one_hot_encoding_indices.append(X.columns.get_loc(col))
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
X = EncodingSelection(X)
					
				
			
		



Selección de Características

Para mejorar el rendimiento del modelo y reducir el sobreajuste, seleccionaremos las principales características utilizando la prueba Chi-Cuadrado.





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

# Inicializar SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)

# Escalar características
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Ajustar SelectKBest
kbest.fit(X_scaled, y)

# Obtener las mejores características
best_features = np.argsort(kbest.scores_)[-2:]  # Seleccionando las 2 mejores características
features_to_delete = np.argsort(kbest.scores_)[:-2]
X = np.delete(X, features_to_delete, axis=1)

print(f"Forma después de la selección de características: {X.shape}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Inicializar SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
 
# Escalar características
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# Ajustar SelectKBest
kbest.fit(X_scaled, y)
 
# Obtener las mejores características
best_features = np.argsort(kbest.scores_)[-2:]  # Seleccionando las 2 mejores características
features_to_delete = np.argsort(kbest.scores_)[:-2]
X = np.delete(X, features_to_delete, axis=1)
 
print(f"Forma después de la selección de características: {X.shape}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Forma después de la selección de características: (142193, 2)
			
				
					
				
					1
				
						Forma después de la selección de características: (142193, 2)
					
				
			
		



Escalado de Características

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

Estandarización

Transforma los datos para que tengan una media de cero y una desviación estándar de uno.





		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

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

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



Entrenando los Modelos

Compararemos dos modelos de clasificación: K-Vecinos Más Cercanos (KNN) y Regresión Logística.

División de Entrenamiento y Prueba

Dividir los datos en conjuntos de entrenamiento y prueba asegura que podamos evaluar el rendimiento del modelo de manera efectiva.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)

print(f"Forma del conjunto de entrenamiento: {X_train.shape}")
print(f"Forma del conjunto de prueba: {X_test.shape}")
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
 
print(f"Forma del conjunto de entrenamiento: {X_train.shape}")
print(f"Forma del conjunto de prueba: {X_test.shape}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Forma del conjunto de entrenamiento: (113754, 2)
Forma del conjunto de prueba: (28439, 2)
			
				
					
				
					1
2
				
						Forma del conjunto de entrenamiento: (113754, 2)
Forma del conjunto de prueba: (28439, 2)
					
				
			
		



K-Vecinos Más Cercanos (KNN)

KNN es un algoritmo de aprendizaje simple, basado en instancias, utilizado para clasificación y regresión.





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

# Inicializar KNN con 3 vecinos
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)

# Predecir y evaluar
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"Precisión de KNN: {knn_accuracy:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
# Inicializar KNN con 3 vecinos
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
 
# Predecir y evaluar
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"Precisión de KNN: {knn_accuracy:.2%}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Precisión de KNN: 80.03%
			
				
					
				
					1
				
						Precisión de KNN: 80.03%
					
				
			
		



Regresión Logística

Un algoritmo potente para tareas de clasificación binaria, la Regresión Logística estima la probabilidad de un resultado binario.





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Inicializar Regresión Logística
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)

# Predecir y evaluar
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Precisión de Regresión Logística: {lr_accuracy:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.linear_model import LogisticRegression
 
# Inicializar Regresión Logística
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)
 
# Predecir y evaluar
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Precisión de Regresión Logística: {lr_accuracy:.2%}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Precisión de Regresión Logística: 82.97%
			
				
					
				
					1
				
						Precisión de Regresión Logística: 82.97%
					
				
			
		



Evaluando el Rendimiento del Modelo

Tanto KNN como la Regresión Logística proporcionan una precisión sustancial en el conjunto de datos, pero la Regresión Logística supera a KNN en este escenario.


    
        Modelo
        Precisión
    
    
        K-Vecinos Más Cercanos
        80.03%
    
    
        Regresión Logística
        82.97%
    


Ajuste de Hiperparámetros

Optimizar los hiperparámetros puede mejorar aún más el rendimiento del modelo. Para la Regresión Logística, parámetros como C (inverso de la fuerza de regularización) y solver pueden ajustarse. De manera similar, el n_neighbors de KNN puede variar.

Ejemplo: GridSearchCV para Regresión Logística





		
		
			
			
Java
			
			from sklearn.model_selection import GridSearchCV

# Definir la cuadrícula de parámetros
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],
    'solver': ['liblinear', 'lbfgs']
}

# Inicializar GridSearchCV
grid = GridSearchCV(LogisticRegression(max_iter=200), param_grid, cv=5)
grid.fit(X_train, y_train)

print(f"Mejores Parámetros: {grid.best_params_}")
print(f"Mejor Precisión de Validación Cruzada: {grid.best_score_:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.model_selection import GridSearchCV
 
# Definir la cuadrícula de parámetros
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],
    'solver': ['liblinear', 'lbfgs']
}
 
# Inicializar GridSearchCV
grid = GridSearchCV(LogisticRegression(max_iter=200), param_grid, cv=5)
grid.fit(X_train, y_train)
 
print(f"Mejores Parámetros: {grid.best_params_}")
print(f"Mejor Precisión de Validación Cruzada: {grid.best_score_:.2%}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Mejores Parámetros: {'C': 1, 'solver': 'lbfgs'}
Mejor Precisión de Validación Cruzada: 83.25%
			
				
					
				
					1
2
				
						Mejores Parámetros: {'C': 1, 'solver': 'lbfgs'}
Mejor Precisión de Validación Cruzada: 83.25%
					
				
			
		



Implementando los Mejores Parámetros:





		
		
			
			
Java
			
			# Inicializar Regresión Logística con los mejores parámetros
best_lr = grid.best_estimator_
best_lr.fit(X_train, y_train)

# Predecir y evaluar
y_pred_best_lr = best_lr.predict(X_test)
best_lr_accuracy = accuracy_score(y_pred_best_lr, y_test)
print(f"Precisión de Regresión Logística Optimizada: {best_lr_accuracy:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Inicializar Regresión Logística con los mejores parámetros
best_lr = grid.best_estimator_
best_lr.fit(X_train, y_train)
 
# Predecir y evaluar
y_pred_best_lr = best_lr.predict(X_test)
best_lr_accuracy = accuracy_score(y_pred_best_lr, y_test)
print(f"Precisión de Regresión Logística Optimizada: {best_lr_accuracy:.2%}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Precisión de Regresión Logística Optimizada: 83.00%
			
				
					
				
					1
				
						Precisión de Regresión Logística Optimizada: 83.00%
					
				
			
		



Conclusión

En esta guía, hemos implementado con éxito un modelo de Regresión Logística en Python, demostrando todo el pipeline de aprendizaje automático desde el preprocesamiento de datos hasta la evaluación del modelo. Al manejar datos faltantes, codificar variables categóricas, seleccionar características relevantes y escalar, hemos optimizado el conjunto de datos para un rendimiento superior del modelo. Además, al comparar la Regresión Logística con KNN, resaltamos las fortalezas de cada algoritmo, con la Regresión Logística superando ligeramente en este contexto.

Conclusiones Clave:

    Preprocesamiento de Datos: Crucial para lograr una alta precisión del modelo.
    Selección de Características: Ayuda a reducir el sobreajuste y mejorar el rendimiento.
    Comparación de Modelos: Siempre compara múltiples modelos para identificar el mejor desempeño.
    Ajuste de Hiperparámetros: Esencial para optimizar el rendimiento del modelo.


Adopta estas técnicas para construir modelos de clasificación robustos y eficientes adaptados a tus conjuntos de datos y requerimientos específicos.



Palabras Clave: Regresión Logística, Python, Scikit-Learn, Aprendizaje Automático, Preprocesamiento de Datos, Modelos de Clasificación, K-Vecinos Más Cercanos, Selección de Características, Ajuste de Hiperparámetros, Tutorial de Ciencia de Datos

Meta Descripción: Aprende cómo implementar Regresión Logística en Python con Scikit-Learn. Esta guía integral cubre el preprocesamiento de datos, manejo de valores faltantes, selección de características y evaluación del modelo, comparando la Regresión Logística con KNN para un rendimiento óptimo.
Fecha	Ubicación	TempMin	TempMax	Evaporación	...	LluviaHoy	LluviaMañana
2017-06-20	Uluru	3.5	21.8	NaN	...	No	No
2017-06-21	Uluru	2.8	23.4	NaN	...	No	No
2017-06-22	Uluru	3.6	25.3	NaN	...	No	No
2017-06-23	Uluru	5.4	26.9	NaN	...	No	No
2017-06-24	Uluru	7.8	27.0	NaN	...	No	No