Proyectos de Machine Learning con Ejemplos: Predicción de Deserción Estudiantil Paso a Paso

pip install scikit-learn pandas numpy matplotlib seaborn shap xgboost fastapi pydantic uvicorn

proyecto-desercion-estudiantil/
├── data/
│   └── student_dropout_uci.csv          # dataset UCI Student Dropout
├── models/
│   └── xgb_desercion.pkl                # modelo XGBoost guardado
├── notebooks/
│   ├── 01_eda.ipynb
│   ├── 02_feature_selection.ipynb
│   ├── 03_benchmarking.ipynb
│   ├── 04_shap_interpretabilidad.ipynb
│   └── 05_deploy.ipynb
├── src/
│   ├── preprocessing.py
│   └── model.py
├── api/
│   └── main.py                          # endpoint FastAPI
└── requirements.txt

import pandas as pd

df = pd.read_csv("data/student_dropout_uci.csv", sep=";")

# Filtrar solo Dropout y Graduate (excluir Enrolled)
df = df[df["Target"].isin(["Dropout", "Graduate"])].copy()

# Codificar la variable objetivo: 1 = Dropout, 0 = Graduate
df["desercion"] = (df["Target"] == "Dropout").astype(int)
df.drop("Target", axis=1, inplace=True)

print(df.shape)
print(df["desercion"].value_counts(normalize=True))

"student dropout prediction model"
AND "machine learning"
AND "feature importance"
AND "early intervention"

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv("data/student_dropout_uci.csv", sep=";")
df = df[df["Target"].isin(["Dropout", "Graduate"])].copy()
df["desercion"] = (df["Target"] == "Dropout").astype(int)
df.drop("Target", axis=1, inplace=True)

print(df.head())
print(df.info())
print(df["desercion"].value_counts(normalize=True))

# Correlación de features con la variable objetivo
corr_target = df.corr()["desercion"].sort_values(ascending=False)
print(corr_target.head(10))

# Visualizar desbalance de clases
df["desercion"].value_counts().plot.bar()
plt.title("Distribución de la variable objetivo")
plt.xticks([0, 1], ["Graduate (0)", "Dropout (1)"], rotation=0)
plt.ylabel("Número de estudiantes")
plt.tight_layout()
plt.show()

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X = df.drop("desercion", axis=1)
y = df["desercion"]

# Split: 80% train, 10% val, 10% test
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.2, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# Normalizar: media 0, varianza 1
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled   = scaler.transform(X_val)
X_test_scaled  = scaler.transform(X_test)

print(f"Train: {X_train_scaled.shape}")
print(f"Val:   {X_val_scaled.shape}")
print(f"Test:  {X_test_scaled.shape}")

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score

modelo_base = LogisticRegression(max_iter=1000, random_state=42)
modelo_base.fit(X_train_scaled, y_train)

y_pred  = modelo_base.predict(X_test_scaled)
y_proba = modelo_base.predict_proba(X_test_scaled)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC: {roc_auc_score(y_test, y_proba):.4f}")

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.model_selection import cross_val_score
import numpy as np
import pandas as pd

modelos = {
    "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
    "Random Forest":       RandomForestClassifier(random_state=42),
    "Gradient Boosting":   GradientBoostingClassifier(random_state=42),
    "XGBoost":             XGBClassifier(random_state=42, eval_metric="logloss"),
    "SVM":                 SVC(probability=True, random_state=42),
}

resultados = {}
for nombre, modelo in modelos.items():
    auc_scores = cross_val_score(modelo, X_train_scaled, y_train,
                                 scoring="roc_auc", cv=5)
    rec_scores = cross_val_score(modelo, X_train_scaled, y_train,
                                 scoring="recall", cv=5)
    resultados[nombre] = {
        "AUC":    auc_scores.mean(),
        "Recall": rec_scores.mean()
    }
    print(f"{nombre}: AUC={auc_scores.mean():.4f} | Recall={rec_scores.mean():.4f}")

df_resultados = pd.DataFrame(resultados).T
print(df_resultados.sort_values("AUC", ascending=False))

from sklearn.model_selection import GridSearchCV
from xgboost import XGBClassifier

param_grid = {
    "n_estimators":   [100, 200, 300],
    "max_depth":      [3, 5, 7],
    "learning_rate":  [0.05, 0.1, 0.2],
    "subsample":      [0.8, 1.0],
    "colsample_bytree": [0.8, 1.0],
}

grid_search = GridSearchCV(
    XGBClassifier(random_state=42, eval_metric="logloss"),
    param_grid,
    cv=5,
    scoring="roc_auc",
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X_train_scaled, y_train)

print(f"Mejores parámetros: {grid_search.best_params_}")
print(f"Mejor AUC CV: {grid_search.best_score_:.4f}")

import pickle

# Entrenar el modelo final con todos los datos de entrenamiento
XGB_final = XGBClassifier(**grid_search.best_params_, random_state=42, eval_metric="logloss")
XGB_final.fit(X_train_scaled, y_train)

# Guardar modelo y scaler
with open("models/xgb_desercion.pkl", "wb") as f:
    pickle.dump(XGB_final, f)

with open("models/scaler_desercion.pkl", "wb") as f:
    pickle.dump(scaler, f)

print("Modelo y scaler guardados correctamente.")

from sklearn.metrics import (classification_report, roc_auc_score,
                             ConfusionMatrixDisplay)
import matplotlib.pyplot as plt

mejor_modelo = grid_search.best_estimator_

y_pred  = mejor_modelo.predict(X_test_scaled)
y_proba = mejor_modelo.predict_proba(X_test_scaled)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC: {roc_auc_score(y_test, y_proba):.4f}")

# Matriz de confusión
fig, ax = plt.subplots(figsize=(6, 5))
ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred,
    display_labels=["Graduate", "Dropout"],
    ax=ax, colorbar=False
)
plt.title("Matriz de confusión — XGBoost sintonizado")
plt.tight_layout()
plt.show()

import shap

explicador   = shap.Explainer(mejor_modelo, X_train_scaled)
shap_values = explicador(X_test_scaled)

# Summary plot — importancia global de características
shap.summary_plot(shap_values, X_test_scaled,
                  feature_names=X.columns.tolist())

# Explicación individual de una predicción
shap.waterfall_plot(shap_values[0])

from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import numpy as np

# Cargar modelo y scaler al arrancar
with open("models/xgb_desercion.pkl", "rb") as f:
    modelo = pickle.load(f)

with open("models/scaler_desercion.pkl", "rb") as f:
    scaler = pickle.load(f)

app = FastAPI(title="API — Sistema de Alerta Temprana de Deserción Estudiantil")

class Estudiante(BaseModel):
    unidades_aprobadas_1sem: float
    unidades_aprobadas_2sem: float
    calificacion_promedio_1sem: float
    calificacion_promedio_2sem: float
    deudor: int           # 0 = No, 1 = Sí
    beca: int             # 0 = No, 1 = Sí
    al_corriente_pago: int  # 0 = No, 1 = Sí
    # ... resto de variables

@app.post("/predecir")
def predecir(estudiante: Estudiante):
    datos = np.array([[
        estudiante.unidades_aprobadas_1sem,
        estudiante.unidades_aprobadas_2sem,
        estudiante.calificacion_promedio_1sem,
        estudiante.calificacion_promedio_2sem,
        estudiante.deudor,
        estudiante.beca,
        estudiante.al_corriente_pago,
    ]])
    datos_norm    = scaler.transform(datos)
    probabilidad  = modelo.predict_proba(datos_norm)[0][1]
    nivel_riesgo  = "Alto" if probabilidad >= 0.6 else "Medio" if probabilidad >= 0.4 else "Bajo"
    return {
        "probabilidad_desercion": round(float(probabilidad), 4),
        "nivel_riesgo": nivel_riesgo,
        "accion_recomendada": "Intervención inmediata" if nivel_riesgo == "Alto" else "Monitoreo"
    }

# Ejecutar: uvicorn api.main:app --reload