Trabajo: Modelo sencillo mediante árboles de clasificación en Python

Goal

The main objective of this project is for the student to apply one or more classification algorithms to predict the response variable in the target data set, evaluate said algorithm and interpret the results.

In these blocks I install some dependencies needed for the next analysis.

!pip install --upgrade pip -q

!pip install ipywidgets==8.1.5 -q

In this block the modules needed to run this notebook are imported.

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

El siguiente bloque de código hace que todas las columnas que se muestran en un df.head() sean visibles y no hayan ocultas.

pd.set_option('display.max_columns', None)

En este bloque cargamos el dataset a analizar.

df = pd.read_csv('Admission_Predict.csv') df.head()

df.drop(columns=['Serial No.'], inplace=True)

ProfileReport(df, title="Reporte de Análisis de Datos")

%matplotlib inline

# Si quieres personalizar más el pairplot, puedes usar: sns.pairplot( data=df, hue="University Rating", # Para colorear según una variable categórica diag_kind="hist", # Tipo de gráfico en la diagonal ('hist' o 'kde') plot_kws={"alpha": 0.6}, # Transparencia de los puntos height=2.5, palette="RdYlGn" ) # Tamaño de cada subgráfico plt.show()

df.columns

fig, axes = plt.subplots(2, 3, figsize=(15, 10)) variables = [['GRE Score', 'TOEFL Score', 'CGPA'],['SOP','LOR ','Research']] for i in range(2): for j in range(3): sns.scatterplot( data=df, x=variables[i][j], y='Chance of Admit ', hue='University Rating', ax=axes[i,j], palette="RdYlGn" ) axes[i,j].set_title(f'{variables[i][j]} vs Chance of Admit') plt.tight_layout() plt.show()

El siguiente bloque hace un proceso de escalación de los datos para que entrenando el modelo no se sesgue por las dimensiones de cada magnitud. Además guarda el escalador para que pueda ser usado en posteriores llamados del modelo para predecir usándolo.

from sklearn.preprocessing import StandardScaler from joblib import dump # Crear el scaler scaler = StandardScaler() # Seleccionar las columnas numéricas para escalar columnas_numericas = ['GRE Score', 'TOEFL Score', 'University Rating', 'SOP', 'LOR ', 'CGPA', 'Research'] # Ajustar el scaler con los datos scaler.fit(df[columnas_numericas]) # Guardar el scaler en un archivo .pkl dump(scaler, 'scaler.pkl') # Para verificar que funciona, podemos cargarlo y usarlo from joblib import load scaler_cargado = load('scaler.pkl') # Aplicar el escalado df_scaled = df.copy() df_scaled[columnas_numericas] = scaler_cargado.transform(df[columnas_numericas]) # Verificar el resultado print("Datos originales:") print(df[columnas_numericas].head()) print("\nDatos escalados:") print(df_scaled[columnas_numericas].head())

En esta parte del código lo que se hace es dividir el conjunto de datos en X y Y, es que separa la variable target, ademas también saca un conjunto de entrenamiento, un 80% y uno de pruebas con el restante.

# Crear X (matriz de características) X = df_scaled # Convertir 'Chance of Admit' en variable categórica (0 o 1) # Usaremos un umbral de 0.75 para la clasificación y = (df['Chance of Admit '] >= 0.75).astype(int) # Dividir los datos en conjuntos de entrenamiento y prueba X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, # 20% para prueba random_state=42 # Para reproducibilidad ) # Verificar las dimensiones print("Dimensiones de X_train:", X_train.shape) print("Dimensiones de X_test:", X_test.shape) print("Dimensiones de y_train:", y_train.shape) print("Dimensiones de y_test:", y_test.shape) # Verificar la distribución de clases print("\nDistribución de clases en el conjunto de entrenamiento:") print(pd.Series(y_train).value_counts(normalize=True))

En este bloque se crea el modelo usando el clasificador de decisiones de árbol, luego se hacen las predicciones al conjunto de pruebas y se calcula una matriz de confusión para validar Falsos Positivos, Falsos Negativos, Verdaderos Positivos y Verdaderos Negativos, con los cuales se calcularán las métricas accuracy, precision, recall y f1 score.

# Create the model dt_model = DecisionTreeClassifier( max_depth=5, # Max depth of the tree min_samples_split=5, # Minimum number of samples to split min_samples_leaf=2, # Minimum number of samples in a leaf random_state=42 # For reproducibility ) # Train the model dt_model.fit(X_train, y_train) # Make predictions y_pred = dt_model.predict(X_test) # Evaluate the model print("Classification Report:") print(classification_report(y_test, y_pred)) # Create the confusion matrix plt.figure(figsize=(8, 6)) sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues') plt.title('Confusion Matrix') plt.ylabel('Real Value') plt.xlabel('Predicted Value') plt.show()

# Mostrar importancia de características importancias = pd.DataFrame({ 'caracteristica': X_columns, 'importancia': dt_model.feature_importances_ }) importancias = importancias.sort_values('importancia', ascending=False) plt.figure(figsize=(10, 6)) sns.barplot(x='importancia', y='caracteristica', data=importancias) plt.title('Importancia de Características') plt.show()

Guardamos el modelo.

# Guardar el modelo entrenado dump(dt_model, 'dt_model.joblib')

Podemos cargar de nuevo el modelo

# Cargar el modelo guardado dt_model = load('dt_model.joblib') # Verificar que el modelo se cargó correctamente print("Modelo cargado exitosamente") print("Tipo de modelo:", type(dt_model)) print("Parámetros del modelo:", dt_model.get_params())

Podemos cargar también el scaler

scaler_cargado = load('scaler.pkl') # Verificar que el scaler se cargó correctamente type(scaler_cargado)

Se simulan algunos datos que llegan a través de una API y ver como podemos llamar al modelo para usarlo.

df.head()

# Datos de prueba en formato JSON datos_prueba = { "estudiantes": [ { "GRE Score": 330, "TOEFL Score": 117, "University Rating": 4, "SOP": 4.5, "LOR ": 4.2, "CGPA": 9.8, "Research": 1 }, { "GRE Score": 310, "TOEFL Score": 105, "University Rating": 3, "SOP": 3.5, "LOR ": 3.0, "CGPA": 8.2, "Research": 1 }, { "GRE Score": 330, "TOEFL Score": 115, "University Rating": 5, "SOP": 5.0, "LOR ": 4.5, "CGPA": 9.0, "Research": 1 } ] }

# Convertir a DataFrame df_prueba = pd.DataFrame(datos_prueba['estudiantes']) df_prueba

Escalamos los datos de prueba.

df_scaled = scaler_cargado.transform(df_prueba) df_scaled

Realizamos las predicciones

# Predecir utilizando el modelo cargado para los datos escalados y_pred_scaled = dt_model.predict(df_scaled) y_pred_scaled

df_prueba['predicción'] = y_pred_scaled df_prueba

plt.figure(figsize=(20, 10)) plot_tree(dt_model, feature_names=X_columns, class_names=['No Admit', 'Admit'], filled=True) plt.title('Árbol de Decisión') plt.show()

Adjunto se podrá encontrar este notebook en un formato comprimido junto con el dataset.

.css-15w88e5{color:var(--chakra-colors-fg-neutral-primary);font-weight:inherit;letter-spacing:-0.09px;}Goal

Goal