4. Regresión Logística (Aprendizaje Supervisado)

-

Aplicación Práctica: Regresión Logística (Aprendizaje Supervisado)


Link del dataset:


La regresión logística es un algoritmo de aprendizaje supervisado utilizado principalmente para problemas de clasificación. Aunque su nombre incluye "regresión", se emplea para predecir la probabilidad de que una observación pertenezca a una categoría específica, no para predecir valores continuos como en la regresión lineal.

En esencia, la regresión logística modela la relación entre una variable dependiente categórica (la variable de respuesta o la clase a predecir) y una o más variables independientes (predictoras o características) mediante el uso de la función logística o sigmoide. Esta función transforma la salida de una combinación lineal de las variables independientes en un valor entre 0 y 1, que representa la probabilidad de que la observación pertenezca a una determinada clase.

El proceso de entrenamiento de un modelo de regresión logística implica ajustar los parámetros del modelo para minimizar la discrepancia entre las probabilidades predichas y las clases reales observadas en los datos de entrenamiento. Se utiliza la función de pérdida logarítmica (también conocida como entropía cruzada) para calcular la diferencia entre las probabilidades predichas y las clases reales y así actualizar los parámetros del modelo durante el entrenamiento.

Una vez entrenado, el modelo puede predecir la clase a la que pertenece una nueva observación basándose en las características proporcionadas. La evaluación de la eficacia de un modelo de regresión logística suele realizarse utilizando métricas como la precisión, el área bajo la curva ROC (Receiver Operating Characteristic), la sensibilidad, la especificidad, entre otras, dependiendo del contexto del problema de clasificación.

El entrenamiento de un modelo de regresión logística implica ajustar sus parámetros utilizando un conjunto de datos etiquetados. Aquí hay un resumen paso a paso de cómo se entrena:

1. Preparación de datos:

  • Datos etiquetados: Necesitas un conjunto de datos con características (variables independientes) y las etiquetas correspondientes (la variable dependiente que se quiere predecir).
  • División de datos: Por lo general, se divide el conjunto de datos en datos de entrenamiento y datos de prueba/validación para evaluar el rendimiento del modelo después del entrenamiento.

2. Selección de características:

  • Identifica las características relevantes que pueden ayudar al modelo a predecir con precisión la variable de respuesta.

3. Definición del modelo:

  • Establece el modelo de regresión logística. Este modelo asume una relación lineal entre las características y la probabilidad logarítmica de pertenecer a una clase.

4. Inicialización de parámetros:

  • Inicializa los parámetros del modelo, como los pesos para cada característica, con valores aleatorios o ceros.

5. Entrenamiento del modelo:

  • Propagación hacia adelante (forward propagation): Calcula la salida del modelo para las características de entrenamiento utilizando la función sigmoide aplicada a la combinación lineal de las características y los pesos.
  • Cálculo de la pérdida (loss): Utiliza una función de pérdida (como la entropía cruzada) para medir la discrepancia entre las probabilidades predichas y las etiquetas reales.
  • Propagación hacia atrás (backpropagation): Ajusta los pesos del modelo utilizando algoritmos de optimización (como el descenso de gradiente) para minimizar la función de pérdida. Se calculan las derivadas parciales de la función de pérdida con respecto a los parámetros y se actualizan los pesos en la dirección que minimiza la pérdida.
  • Iteración: Repite este proceso de ajuste de pesos durante múltiples épocas (iteraciones) hasta que el modelo converja o se alcance un criterio de detención.

6. Validación y Evaluación:

  • Una vez entrenado, se evalúa el modelo utilizando datos de prueba para medir su rendimiento en la clasificación de nuevas observaciones. Se calculan métricas como precisión, recall, F1-score, curvas ROC, etc.

7. Ajuste de hiperparámetros:

  • Opcionalmente, se puede realizar la búsqueda de hiperparámetros para encontrar la configuración óptima del modelo, como la tasa de aprendizaje, regularización, entre otros.

Este proceso iterativo de ajuste de parámetros mediante el descenso de gradiente se repite hasta que el modelo alcance un rendimiento satisfactorio en los datos de prueba.

Ejemplo 1:

Primero, aquí hay un ejemplo básico para crear un dataset de educación superior y entrenar un modelo de regresión logística:


import pandas as pd
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# Generar datos simulados de educación superior
np.random.seed(42)

# Simular datos de educación superior
data, target = make_classification(n_samples=1000, n_features=5, n_informative=3, n_classes=2)

# Convertir a DataFrame de Pandas
df = pd.DataFrame(data, columns=['Examen_1', 'Examen_2', 'Proyecto_1', 'Proyecto_2', 'Tareas'])
df['Aprobado'] = target

# Dividir en conjunto de entrenamiento y prueba
train, test = train_test_split(df, test_size=0.2, random_state=42)

# Guardar en CSV
train.to_csv('Education_train.csv', index=False)
test.to_csv('Education_test.csv', index=False)

# Entrenar el modelo de regresión logística
X_train = train.drop('Aprobado', axis=1)
y_train = train['Aprobado']

model = LogisticRegression()
model.fit(X_train, y_train)

# Predecir en datos de prueba
X_test = test.drop('Aprobado', axis=1)
y_test = test['Aprobado']

predictions = model.predict(X_test)

# Evaluar el modelo
accuracy = accuracy_score(y_test, predictions)
print(f'Precisión del modelo de regresión logística: {accuracy}')

# Descargar archivos
from google.colab import files

files.download('Education_train.csv')
files.download('Education_test.csv')


import matplotlib.pyplot as plt

# Gráfico de dispersión de Examen_1 y Examen_2
plt.figure(figsize=(8, 6))
plt.scatter(df[df['Aprobado'] == 0]['Examen_1'], df[df['Aprobado'] == 0]['Examen_2'], label='No Aprobado', marker='o')
plt.scatter(df[df['Aprobado'] == 1]['Examen_1'], df[df['Aprobado'] == 1]['Examen_2'], label='Aprobado', marker='x')
plt.xlabel('Examen 1')
plt.ylabel('Examen 2')
plt.title('Gráfico de dispersión de Examen_1 vs Examen_2')
plt.legend()
plt.show()

# Gráfico de barras de estudiantes aprobados y no aprobados
plt.figure(figsize=(8, 4))
df['Aprobado'].value_counts().plot(kind='bar', color=['skyblue', 'salmon'])
plt.xticks([0, 1], ['No Aprobado', 'Aprobado'], rotation='horizontal')
plt.ylabel('Cantidad de Estudiantes')
plt.title('Distribución de Estudiantes Aprobados/No Aprobados')
plt.show()


https://colab.research.google.com/drive/1a_O39OaaGWz5rOksDx21Efdbanbt1A-H?usp=sharing

Vamos a abordar un caso de estudio de clasificación binaria para diagnosticar el rendimiento académico de los estudiantes. Utilizaremos un conjunto de datos ficticio que contiene características de los estudiantes y su rendimiento académico (alta o baja categoría de rendimiento).

El objetivo es predecir si un estudiante tendrá un rendimiento académico alto o bajo basándose en características como horas de estudio, asistencia, participación, etc.

Primero, cargaremos los datos y realizaremos un análisis exploratorio:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, confusion_matrix

# Cargando el conjunto de datos
df = pd.read_csv('dataset_estudiantes.csv')

# Visualización general del conjunto de datos
print(df.info())
print(df.describe())

# Exploración de la variable objetivo
sns.countplot(x='categoria_rendimiento', data=df)
plt.title('Distribución de Categorías de Rendimiento')
plt.show()

# Correlaciones entre características y la variable objetivo
plt.figure(figsize=(10, 6))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.title('Correlaciones entre Características')
plt.show()

Después de explorar los datos, procederemos a entrenar un modelo de clasificación (usando un árbol de decisiones en este caso):


# División de los datos en características (X) y variable objetivo (y)
X = df.drop('categoria_rendimiento', axis=1)
y = df['categoria_rendimiento']

# División en conjunto de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Modelo de árbol de decisiones
model = DecisionTreeClassifier()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

# Evaluación del modelo
print(classification_report(y_test, predictions))
print(confusion_matrix(y_test, predictions))

Ejemplo completo ejecutable en Google Colab. Utilizaremos un conjunto de datos ficticio y lo guardaré como un archivo CSV.

Primero, generemos y guardemos el conjunto de datos:

import pandas as pd
import numpy as np

# Generar un conjunto de datos ficticio
np.random.seed(42)
num_students = 1000

# Simulación de características de los estudiantes y su rendimiento
hours_study_week = np.random.randint(1, 30, num_students)
attendance = np.random.uniform(0.6, 1, num_students)
participation = np.random.uniform(0.2, 1, num_students)
exam_scores = np.random.uniform(5, 10, num_students)
performance_category = np.random.choice(['Alto', 'Bajo'], num_students)

# Crear un DataFrame con los datos
data = pd.DataFrame({
    'Hours_Study_Week': hours_study_week,
    'Attendance': attendance,
    'Participation': participation,
    'Exam_Scores': exam_scores,
    'Performance_Category': performance_category
})

# Guardar el conjunto de datos como CSV
data.to_csv('student_performance_dataset.csv', index=False)

Ahora, para descargar el archivo CSV generado, puedes utilizar el siguiente código en Google Colab:


from google.colab import files

# Descargar el archivo CSV
files.download('student_performance_dataset.csv')

Estos códigos generan un conjunto de datos ficticio con características de estudiantes y su rendimiento, y luego descargan el archivo CSV generado. Puedes ejecutarlos en Google Colab para obtener el archivo CSV y usarlo en tu análisis o proyecto.

Vamos a visualizar algunas relaciones entre las variables del conjunto de datos simulado y la categoría de rendimiento académico utilizando gráficos. En este caso, utilizaremos Regresión Logística para la clasificación y luego graficaremos algunas de las relaciones con la variable objetivo.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix

# Cargar el conjunto de datos generado anteriormente
data = pd.read_csv('student_performance_dataset.csv')

# División de los datos en características (X) y variable objetivo (y)
X = data.drop('Performance_Category', axis=1)
y = data['Performance_Category']

# División en conjunto de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Modelo de Regresión Logística
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

# Gráfico: Relación entre horas de estudio y rendimiento académico
sns.boxplot(x='Performance_Category', y='Hours_Study_Week', data=data)
plt.title('Relación entre Horas de Estudio y Rendimiento Académico')
plt.show()

# Gráfico: Relación entre asistencia y rendimiento académico
sns.violinplot(x='Performance_Category', y='Attendance', data=data)
plt.title('Relación entre Asistencia y Rendimiento Académico')
plt.show()

# Matriz de Confusión y Reporte de Clasificación
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))

Resultado


Estos gráficos, como el de caja para las horas de estudio y el de violín para la asistencia, ayudarán a visualizar cómo se relacionan estas variables con la categoría de rendimiento académico. Además, la matriz de confusión y el reporte de clasificación ofrecen información sobre el desempeño del modelo de Regresión Logística en la predicción de las categorías de rendimiento académico.

https://colab.research.google.com/drive/1a_O39OaaGWz5rOksDx21Efdbanbt1A-H?usp=sharing

Para evaluar el modelo, observamos la matriz de confusión y las métricas de clasificación como precisión, recall y F1-score. Veamos cómo se interpretan los coeficientes y evaluemos el modelo en base a las predicciones:


# Entrenamiento del modelo de Regresión Logística
model = LogisticRegression()
model.fit(X_train, y_train)

# Coeficientes de las características
coefficients = pd.DataFrame(model.coef_, columns=X.columns)
print("Coeficientes del modelo:")
print(coefficients)

# Predicciones del modelo
predictions = model.predict(X_test)

# Matriz de confusión y reporte de clasificación
print("\nMatriz de Confusión:")
print(confusion_matrix(y_test, predictions))
print("\nReporte de Clasificación:")
print(classification_report(y_test, predictions))

Resultados

Coeficientes del modelo: Hours_Study_Week Attendance Participation Exam_Scores 0 0.006336 0.876166 -0.259625 -0.059302 Matriz de Confusión: [[54 46] [59 41]] Reporte de Clasificación: precision recall f1-score support Alto 0.48 0.54 0.51 100 Bajo 0.47 0.41 0.44 100 accuracy 0.48 200 macro avg 0.47 0.47 0.47 200 weighted avg 0.47 0.47 0.47 200

Los coeficientes mostrados representan la relación de cada característica con la variable objetivo (rendimiento académico) en términos de log-odds. Un coeficiente positivo indica que a medida que la característica aumenta, aumenta la probabilidad logarítmica de pertenecer a la categoría predeterminada, y viceversa para coeficientes negativos.

La matriz de confusión y el reporte de clasificación nos proporcionan información sobre el rendimiento del modelo, como la precisión (proporción de predicciones correctas), recall (proporción de positivos reales que se identificaron correctamente) y F1-score (media harmónica entre precisión y recall).


Comentarios

Publicar un comentario

Entradas populares de este blog

5. Árboles de Decisión

-
Imagen
  Aplicación Práctica: Árboles de Decisión (Aprendizaje Supervisado) Enlace a Google Colab  para ver nuestro código  Los árboles de decisión son modelos de aprendizaje automático utilizados tanto para problemas de clasificación como de regresión. Se llaman así debido a su estructura similar a un árbol, compuesta por nodos, ramas y hojas. Nodos: Representan características o atributos en los datos. En un árbol de decisión, cada nodo representa una pregunta o prueba sobre alguna característica. Ramas: Conectan los nodos y representan el resultado de una prueba o una decisión tomada basada en una característica. Nodos Hoja: Son los nodos terminales del árbol y representan una etiqueta o valor de salida, ya sea la clasificación en problemas de clasificación o el valor predicho en problemas de regresión. El árbol se construye a partir de los datos de entrenamiento, donde el modelo busca la mejor característica para dividir los datos en subconjuntos más puros en términos de ...
Leer más