import pandas as pd
df = pd.read_csv('base_ENIGH_lasso.csv')

# ── Estructura general ────────────────────────────────────────────────────
print(f"Observaciones : {df.shape[0]}")
print(f"Variables     : {df.shape[1]}  ({df.shape[1]-1} predictoras + 1 objetivo)")
print(f"\nTotal de nulos: {df.isnull().sum().sum()}")
print(f"\nTipos de dato:\n{df.dtypes.value_counts()}")

Observaciones : 3767
Variables     : 45  (44 predictoras + 1 objetivo)

Total de nulos: 0

Tipos de dato:
int64      43
float64     2
Name: count, dtype: int64

# ── Balance de clases ─────────────────────────────────────────────────────
import matplotlib.pyplot as plt

conteo = df['est_socio'].value_counts().sort_index()
proporcion = df['est_socio'].value_counts(normalize=True).sort_index() * 100

# Gráfica
etiquetas = ["Bajo\n(1)", "Medio-bajo\n(2)", "Medio-alto\n(3)", "Alto\n(4)"]
colores   = ['#d62728', '#1f77b4', '#2ca02c', '#9467bd']

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# Barras de proporción
bars = axes[0].bar(etiquetas, proporcion.values, color=colores, edgecolor='white')
axes[0].axhline(25, linestyle='--', color='gray', linewidth=1.2, label='Balance perfecto (25%)')
axes[0].set_ylabel("Proporción (%)")
axes[0].set_title("Distribución de clases — est_socio")
axes[0].legend()
for bar, val in zip(bars, proporcion.values):
    axes[0].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.5,
                 f"{val:.1f}%", ha='center', fontsize=10)

# Pie chart
axes[1].pie(
    conteo.values, labels=etiquetas, colors=colores,
    autopct='%1.1f%%', startangle=140,
    wedgeprops={'edgecolor': 'white'}
)
axes[1].set_title("Proporción relativa por estrato")

plt.tight_layout()
plt.show()

# ── Relación features–clase (heatmap de medias por estrato) ───────────────

num_cols = ['num_cuarto', 'num_cuarto', 'prop_muj',
            'bano_excus', 'bano_comp', 'bano_regad', 'estim_pago', 'tot_resid']

medias = df.groupby('est_socio')[num_cols].mean()

# Normalizar por columna para hacer comparables las escalas
medias_norm = (medias - medias.min()) / (medias.max() - medias.min())

import seaborn as sns
plt.figure(figsize=(10, 3))
sns.heatmap(medias_norm, annot=medias.round(1), fmt='g',
            cmap='YlOrRd', linewidths=0.5,
            yticklabels=["Bajo (1)", "Medio-bajo (2)", "Medio-alto (3)", "Alto (4)"])
plt.title("Media de variables numéricas por estrato socioeconómico\n(color normalizado por columna)")
plt.xlabel("")
plt.tight_layout()
plt.show()

# ── Prevalencia de dummies por clase ─────────────────────────────────────
df_dum = df.drop(columns=num_cols)

prev = df_dum.groupby('est_socio').mean() * 100

plt.figure(figsize=(22, 4))
sns.heatmap(prev, annot=True, fmt='.1f', cmap='Blues', linewidths=0.5,
            yticklabels=["Bajo (1)", "Medio-bajo (2)", "Medio-alto (3)", "Alto (4)"])
plt.title("Prevalencia (%) de variables dummy clave por estrato socioeconómico")
plt.tight_layout()
plt.show()

from sklearn.model_selection import train_test_split

X = df.drop(columns=["est_socio"])
y = df["est_socio"]

X_train_val, X_test, y_train_val, y_test = train_test_split(
    X, y, test_size=0.15, random_state=42, stratify=y
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

from IPython.display import display

from sklearn.pipeline               import Pipeline
from sklearn.preprocessing          import StandardScaler
from sklearn.model_selection        import StratifiedKFold, RandomizedSearchCV, GridSearchCV
from sklearn.metrics                import classification_report, confusion_matrix, ConfusionMatrixDisplay

# ── Modelos
from sklearn.linear_model           import LogisticRegression
from sklearn.discriminant_analysis  import LinearDiscriminantAnalysis
from sklearn.ensemble               import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm                    import SVC
from sklearn.neural_network         import MLPClassifier

# ── Protocolo común
CV       = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
SCORING  = ['accuracy', 'f1_macro', 'f1_weighted', 'roc_auc_ovr']
REFIT    = 'f1_macro'
N_ITER   = 30
SEED     = 42

# Almacena resultados de todos los modelos
resumen = {}

def registrar(nombre, search_obj):
    """Extrae métricas CV del mejor estimador y las guarda en resumen."""
    res = search_obj.cv_results_
    idx = search_obj.best_index_
    resumen[nombre] = {
        'best_params'   : search_obj.best_params_,
        'accuracy_mean' : res['mean_test_accuracy'][idx],
        'accuracy_std'  : res['std_test_accuracy'][idx],
        'f1_macro_mean' : res['mean_test_f1_macro'][idx],
        'f1_macro_std'  : res['std_test_f1_macro'][idx],
        'f1_w_mean'     : res['mean_test_f1_weighted'][idx],
        'f1_w_std'      : res['std_test_f1_weighted'][idx],
        'auc_roc_mean'  : res['mean_test_roc_auc_ovr'][idx],
        'auc_roc_std'   : res['std_test_roc_auc_ovr'][idx],
        'estimator'     : search_obj.best_estimator_,
    }
    print(f"\n{'='*60}")
    print(f"  {nombre}")
    print(f"{'='*60}")
    print(f"  Mejores hiperparámetros : {search_obj.best_params_}")
    print(f"  Accuracy      (CV mean±std): {resumen[nombre]['accuracy_mean']:.4f} ± {resumen[nombre]['accuracy_std']:.4f}")
    print(f"  F1-macro      (CV mean±std): {resumen[nombre]['f1_macro_mean']:.4f} ± {resumen[nombre]['f1_macro_std']:.4f}")
    print(f"  F1-weighted   (CV mean±std): {resumen[nombre]['f1_w_mean']:.4f} ± {resumen[nombre]['f1_w_std']:.4f}")
    print(f"  AUC-ROC OvR   (CV mean±std): {resumen[nombre]['auc_roc_mean']:.4f} ± {resumen[nombre]['auc_roc_std']:.4f}")

pipe_lr = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(
        class_weight='balanced',
        max_iter=1000,
        random_state=SEED
    ))
])

param_grid_lr = {
    'clf__C'          : [0.01, 0.1, 1, 10, 100],
    'clf__penalty'    : ['l1', 'l2'],
    'clf__solver'     : ['saga'],
    'clf__multi_class': ['ovr', 'multinomial'],
}

search_lr = GridSearchCV(
    pipe_lr,
    param_grid_lr,
    cv=CV,
    scoring=SCORING,
    refit=REFIT,
    n_jobs=-1,
    verbose=0
)

search_lr.fit(X_train_val, y_train_val)
registrar('Logistic Regression', search_lr)

============================================================
  Logistic Regression
============================================================
  Mejores hiperparámetros : {'clf__C': 10, 'clf__multi_class': 'ovr', 'clf__penalty': 'l1', 'clf__solver': 'saga'}
  Accuracy      (CV mean±std): 0.6592 ± 0.0118
  F1-macro      (CV mean±std): 0.6397 ± 0.0132
  F1-weighted   (CV mean±std): 0.6688 ± 0.0110
  AUC-ROC OvR   (CV mean±std): 0.8812 ± 0.0056

pipe_lda = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LinearDiscriminantAnalysis())
])

param_grid_lda = [
    {'clf__solver': ['svd'],           'clf__shrinkage': [None]},
    {'clf__solver': ['lsqr', 'eigen'], 'clf__shrinkage': [None, 'auto', 0.1, 0.5, 0.9]},
]

search_lda = GridSearchCV(
    pipe_lda,
    param_grid_lda,
    cv=CV,
    scoring=SCORING,
    refit=REFIT,
    n_jobs=-1,
    verbose=0
)

search_lda.fit(X_train_val, y_train_val)
registrar('LDA', search_lda)

============================================================
  LDA
============================================================
  Mejores hiperparámetros : {'clf__shrinkage': None, 'clf__solver': 'svd'}
  Accuracy      (CV mean±std): 0.6932 ± 0.0119
  F1-macro      (CV mean±std): 0.6401 ± 0.0156
  F1-weighted   (CV mean±std): 0.6901 ± 0.0098
  AUC-ROC OvR   (CV mean±std): 0.8790 ± 0.0087

# ── Random Forest ──────────────────────────────────────────────
pipe_rf = Pipeline([
    ('clf', RandomForestClassifier(
        class_weight='balanced',
        random_state=SEED,
        n_jobs=-1
    ))
])

param_dist_rf = {
    'clf__n_estimators'     : [100, 200, 300, 500],
    'clf__max_depth'        : [None, 5, 10, 20, 30],
    'clf__min_samples_split': [2, 5, 10],
    'clf__min_samples_leaf' : [1, 2, 4],
    'clf__max_features'     : ['sqrt', 'log2', 0.5],
}

search_rf = RandomizedSearchCV(
    pipe_rf,
    param_dist_rf,
    n_iter=N_ITER,
    cv=CV,
    scoring=SCORING,
    refit=REFIT,
    n_jobs=-1,
    verbose=0,
    random_state=SEED
)

search_rf.fit(X_train_val, y_train_val)
registrar('Random Forest', search_rf)

============================================================
  Random Forest
============================================================
  Mejores hiperparámetros : {'clf__n_estimators': 500, 'clf__min_samples_split': 10, 'clf__min_samples_leaf': 1, 'clf__max_features': 'log2', 'clf__max_depth': 30}
  Accuracy      (CV mean±std): 0.6963 ± 0.0153
  F1-macro      (CV mean±std): 0.6612 ± 0.0174
  F1-weighted   (CV mean±std): 0.7026 ± 0.0146
  AUC-ROC OvR   (CV mean±std): 0.8908 ± 0.0088

# ── Gradient Boosting ──────────────────────────────────────────
pipe_gb = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', GradientBoostingClassifier(random_state=SEED))
])

param_dist_gb = {
    'clf__n_estimators' : [100, 200, 300],
    'clf__learning_rate': [0.01, 0.05, 0.1, 0.2],
    'clf__max_depth'    : [3, 5, 7],
    'clf__subsample'    : [0.7, 0.8, 1.0],
    'clf__max_features' : ['sqrt', 'log2', None],
}

search_gb = RandomizedSearchCV(
    pipe_gb,
    param_dist_gb,
    n_iter=N_ITER,
    cv=CV,
    scoring=SCORING,
    refit=REFIT,
    n_jobs=-1,
    verbose=0,
    random_state=SEED
)

search_gb.fit(X_train_val, y_train_val)
registrar('Gradient Boosting', search_gb)

============================================================
  Gradient Boosting
============================================================
  Mejores hiperparámetros : {'clf__subsample': 0.7, 'clf__n_estimators': 100, 'clf__max_features': None, 'clf__max_depth': 5, 'clf__learning_rate': 0.05}
  Accuracy      (CV mean±std): 0.7276 ± 0.0051
  F1-macro      (CV mean±std): 0.6653 ± 0.0127
  F1-weighted   (CV mean±std): 0.7212 ± 0.0064
  AUC-ROC OvR   (CV mean±std): 0.8920 ± 0.0077

pipe_svm = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', SVC(
        class_weight='balanced',
        probability=True,
        random_state=SEED
    ))
])

param_dist_svm = {
    'clf__C'     : [0.1, 1, 10, 100, 1000],
    'clf__kernel': ['rbf', 'poly', 'sigmoid'],
    'clf__gamma' : ['scale', 'auto', 0.001, 0.01, 0.1],
    'clf__degree': [2, 3, 4],
}

search_svm = RandomizedSearchCV(
    pipe_svm,
    param_dist_svm,
    n_iter=N_ITER,
    cv=CV,
    scoring=SCORING,
    refit=REFIT,
    n_jobs=-1,
    verbose=0,
    random_state=SEED
)

search_svm.fit(X_train_val, y_train_val)
registrar('SVM', search_svm)

============================================================
  SVM
============================================================
  Mejores hiperparámetros : {'clf__kernel': 'rbf', 'clf__gamma': 'scale', 'clf__degree': 2, 'clf__C': 1}
  Accuracy      (CV mean±std): 0.6276 ± 0.0078
  F1-macro      (CV mean±std): 0.6215 ± 0.0077
  F1-weighted   (CV mean±std): 0.6404 ± 0.0081
  AUC-ROC OvR   (CV mean±std): 0.8828 ± 0.0089

pipe_mlp = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', MLPClassifier(
        max_iter=500,
        early_stopping=True,
        random_state=SEED
    ))
])

param_dist_mlp = {
    'clf__hidden_layer_sizes': [(64,), (128,), (64, 32), (128, 64), (128, 64, 32)],
    'clf__activation'        : ['relu', 'tanh'],
    'clf__alpha'             : [0.0001, 0.001, 0.01],
    'clf__learning_rate_init': [0.001, 0.01],
    'clf__batch_size'        : [32, 64, 'auto'],
}

search_mlp = RandomizedSearchCV(
    pipe_mlp,
    param_dist_mlp,
    n_iter=N_ITER,
    cv=CV,
    scoring=SCORING,
    refit=REFIT,
    n_jobs=-1,
    verbose=0,
    random_state=SEED
)

search_mlp.fit(X_train_val, y_train_val)
registrar('MLP (Red Neuronal)', search_mlp)

============================================================
  MLP (Red Neuronal)
============================================================
  Mejores hiperparámetros : {'clf__learning_rate_init': 0.01, 'clf__hidden_layer_sizes': (64, 32), 'clf__batch_size': 64, 'clf__alpha': 0.001, 'clf__activation': 'relu'}
  Accuracy      (CV mean±std): 0.7173 ± 0.0143
  F1-macro      (CV mean±std): 0.6488 ± 0.0243
  F1-weighted   (CV mean±std): 0.7088 ± 0.0136
  AUC-ROC OvR   (CV mean±std): 0.8872 ± 0.0074

# ── Tabla comparativa ─────────────────────────────────────────────────────────
filas = []
for nombre, r in resumen.items():
    filas.append({
        'Modelo'            : nombre,
        'Accuracy (μ±σ)'   : f"{r['accuracy_mean']:.4f} ± {r['accuracy_std']:.4f}",
        'F1-macro (μ±σ)'   : f"{r['f1_macro_mean']:.4f} ± {r['f1_macro_std']:.4f}",
        'F1-weighted (μ±σ)': f"{r['f1_w_mean']:.4f} ± {r['f1_w_std']:.4f}",
        'AUC-ROC (μ±σ)': f"{r['auc_roc_mean']:.4f} ± {r['auc_roc_std']:.4f}",
    })

df_res = pd.DataFrame(filas).set_index('Modelo')
print(df_res.to_string())

# ── Gráfica comparativa ────────────────────────────────────────────────────────
nombres     = list(resumen.keys())
f1_macro_m  = [resumen[n]['f1_macro_mean']  for n in nombres]
f1_macro_s  = [resumen[n]['f1_macro_std']   for n in nombres]
acc_m       = [resumen[n]['accuracy_mean']  for n in nombres]
f1_w_m      = [resumen[n]['f1_w_mean']      for n in nombres]
auc_roc     = [resumen[n]['auc_roc_mean']   for n in nombres]

x     = np.arange(len(nombres))
width = 0.18
fig, ax = plt.subplots(figsize=(20, 5))

b1 = ax.bar(x - width, acc_m,      width, label='Accuracy',     color='#4C72B0', alpha=0.85)
b2 = ax.bar(x,          f1_macro_m, width, label='F1-macro',     color='#DD8452', alpha=0.85,
            yerr=f1_macro_s, capsize=4, error_kw={'elinewidth':1.2})
b3 = ax.bar(x + width,  f1_w_m,    width, label='F1-weighted',  color='#55A868', alpha=0.85)
b4 = ax.bar(x + width * 2,  auc_roc,    width, label='AUC-ROC',  color='#B4A7D6', alpha=0.85)

ax.set_xticks(x)
ax.set_xticklabels(nombres)
ax.set_ylim(0, 1.05)
ax.set_ylabel('Score (CV 5-fold)')
ax.set_title('Comparación de modelos — métricas de validación cruzada\n(barras de error = ±1 std en F1-macro)')
ax.legend()
ax.axhline(0.5, linestyle='--', color='gray', linewidth=0.8, alpha=0.6)
plt.tight_layout()
plt.show()

# Destacar el mejor por F1-macro
mejor_modelo = max(resumen, key=lambda n: resumen[n]['f1_macro_mean'])
print(f"\n✓ Mejor modelo por F1-macro (CV): {mejor_modelo}  "      f"({resumen[mejor_modelo]['f1_macro_mean']:.4f})")

                      Accuracy (μ±σ)   F1-macro (μ±σ) F1-weighted (μ±σ)    AUC-ROC (μ±σ)
Modelo                                                                                  
Logistic Regression  0.6592 ± 0.0118  0.6397 ± 0.0132   0.6688 ± 0.0110  0.8812 ± 0.0056
LDA                  0.6932 ± 0.0119  0.6401 ± 0.0156   0.6901 ± 0.0098  0.8790 ± 0.0087
Random Forest        0.6963 ± 0.0153  0.6612 ± 0.0174   0.7026 ± 0.0146  0.8908 ± 0.0088
Gradient Boosting    0.7276 ± 0.0051  0.6653 ± 0.0127   0.7212 ± 0.0064  0.8920 ± 0.0077
SVM                  0.6276 ± 0.0078  0.6215 ± 0.0077   0.6404 ± 0.0081  0.8828 ± 0.0089
MLP (Red Neuronal)   0.7173 ± 0.0143  0.6488 ± 0.0243   0.7088 ± 0.0136  0.8872 ± 0.0074

✓ Mejor modelo por F1-macro (CV): Gradient Boosting  (0.6653)

# ── Evaluación final en test: Gradient Boosting ───────────────────────────────
from sklearn.metrics import (
    accuracy_score,
    f1_score,
    f1_score,
    roc_auc_score,
    classification_report,
    confusion_matrix,
    ConfusionMatrixDisplay
)

# 1) Mejor modelo encontrado en la búsqueda
best_gb = search_gb.best_estimator_

print("Mejores hiperparámetros encontrados:")
print(search_gb.best_params_)

# 2) Predicciones en test
y_pred = best_gb.predict(X_test)

# 3) Probabilidades para AUC-ROC multiclase
y_proba = best_gb.predict_proba(X_test)

# 4) Métricas de desempeño en test
acc_test       = accuracy_score(y_test, y_pred)
f1_macro_test  = f1_score(y_test, y_pred, average='macro')
f1_weight_test = f1_score(y_test, y_pred, average='weighted')

auc_roc_test = roc_auc_score(
    y_test,
    y_proba,
    multi_class='ovr',
    average='macro'
)

# 5) Resumen numérico
res_test = pd.DataFrame({
    'Métrica': ['Accuracy', 'F1-macro', 'F1-weighted', 'AUC-ROC OvR (macro)'],
    'Valor':   [acc_test, f1_macro_test, f1_weight_test, auc_roc_test]
})

print("\nDesempeño en test:")
print(res_test.to_string(index=False))

# 6) Nombres de clases
mapa_clases = {
    1: 'Bajo',
    2: 'Medio-bajo',
    3: 'Medio-alto',
    4: 'Alto'
}

# Orden real de clases aprendido por el modelo
classes = best_gb.classes_
labels_texto = [mapa_clases[c] for c in classes]

# 7) Reporte de clasificación por clase
print("\nClassification report en test:")
print(classification_report(
    y_test,
    y_pred,
    labels=classes,
    target_names=labels_texto,
    digits=4
))

# 8) Matriz de confusión con nombres en ejes
fig, ax = plt.subplots(figsize=(7, 6))
ConfusionMatrixDisplay.from_predictions(
    y_test,
    y_pred,
    labels=classes,
    display_labels=labels_texto,
    cmap='Blues',
    ax=ax,
    colorbar=False
)
ax.set_title('Matriz de confusión - Gradient Boosting (test)')
ax.set_xlabel('Etiqueta predicha')
ax.set_ylabel('Etiqueta real')
plt.tight_layout()
plt.show()

Mejores hiperparámetros encontrados:
{'clf__subsample': 0.7, 'clf__n_estimators': 100, 'clf__max_features': None, 'clf__max_depth': 5, 'clf__learning_rate': 0.05}

Desempeño en test:
            Métrica    Valor
           Accuracy 0.715548
           F1-macro 0.655515
        F1-weighted 0.711248
AUC-ROC OvR (macro) 0.895803

Classification report en test:
              precision    recall  f1-score   support

        Bajo     0.7234    0.6182    0.6667        55
  Medio-bajo     0.7849    0.8411    0.8120       321
  Medio-alto     0.4904    0.4554    0.4722       112
        Alto     0.7042    0.6410    0.6711        78

    accuracy                         0.7155       566
   macro avg     0.6757    0.6389    0.6555       566
weighted avg     0.7095    0.7155    0.7112       566

# ── Curvas ROC multiclase por clase con nombres correctos ─────────────────────
from sklearn.preprocessing import label_binarize
from sklearn.metrics import roc_curve, auc
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Probabilidades del mejor modelo
y_proba = best_gb.predict_proba(X_test)

# Clases reales aprendidas por el modelo
classes = np.array(best_gb.classes_)

# Ajusta este diccionario si tu codificación real fuera distinta
mapa_clases = {
    1: 'Bajo',
    2: 'Medio-bajo',
    3: 'Medio-alto',
    4: 'Alto'
}

# Nombres en el mismo orden de classes
class_names = [mapa_clases.get(c, f'Clase {c}') for c in classes]

# Binarizar etiquetas reales
y_test_bin = label_binarize(y_test, classes=classes)

# Seguridad para binario
if y_test_bin.ndim == 1:
    y_test_bin = np.column_stack([1 - y_test_bin, y_test_bin])

# ROC y AUC por clase
fpr = {}
tpr = {}
roc_auc = {}

for i, class_name in enumerate(class_names):
    if np.unique(y_test_bin[:, i]).size < 2:
        print(f"Advertencia: la clase '{class_name}' no tiene suficientes ejemplos en y_test para calcular ROC.")
        continue

    fpr[class_name], tpr[class_name], _ = roc_curve(y_test_bin[:, i], y_proba[:, i])
    roc_auc[class_name] = auc(fpr[class_name], tpr[class_name])

# Macro-average
all_fpr = np.unique(np.concatenate([fpr[c] for c in roc_auc.keys()]))
mean_tpr = np.zeros_like(all_fpr)

for c in roc_auc.keys():
    mean_tpr += np.interp(all_fpr, fpr[c], tpr[c])

mean_tpr /= len(roc_auc)
fpr_macro = all_fpr
tpr_macro = mean_tpr
auc_macro = auc(fpr_macro, tpr_macro)

# Tabla de AUC por clase
df_auc = pd.DataFrame({
    'Clase': list(roc_auc.keys()),
    'AUC-ROC': list(roc_auc.values())
})
print(df_auc.to_string(index=False))
print(f"\nAUC-ROC macro-promedio: {auc_macro:.4f}")

# Gráfica
plt.figure(figsize=(8, 6))

for c in roc_auc.keys():
    plt.plot(
        fpr[c],
        tpr[c],
        linewidth=2,
        label=f'{c} (AUC = {roc_auc[c]:.4f})'
    )

plt.plot(
    fpr_macro,
    tpr_macro,
    linewidth=3,
    linestyle='--',
    label=f'Macro-average (AUC = {auc_macro:.4f})'
)

plt.plot([0, 1], [0, 1], linestyle=':', linewidth=1.5, label='Azar')

plt.xlim([0, 1])
plt.ylim([0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Curvas ROC multiclase por clase - Gradient Boosting (test)')
plt.legend(loc='lower right')
plt.grid(alpha=0.25)
plt.tight_layout()
plt.show()

     Clase  AUC-ROC
      Bajo 0.972318
Medio-bajo 0.854460
Medio-alto 0.808439
      Alto 0.947995

AUC-ROC macro-promedio: 0.8967

Grupo	Variables	Tipo	Posible relación con la salida
Binarias originales codificadas por catálogo	`cocina`, `cocina_dor`	Enteras categóricas binarias (codificadas con claves 1–2)	La presencia de cocina y, sobre todo, el uso de la cocina como dormitorio pueden reflejar condiciones de hacinamiento o menor calidad habitacional, por lo que potencialmente ayudan a distinguir estratos bajos de altos.
Variables de conteo de infraestructura	`num_cuarto`, `bano_comp`, `bano_excus`, `bano_regad`, `tot_resid`	Enteras discretas	Un mayor número de cuartos y de baños completos suele asociarse con mejores condiciones materiales y, por tanto, con estratos más altos. En cambio, una mayor cantidad de residentes por vivienda puede reflejar presión habitacional y relacionarse con estratos más bajos.
Variable económica continua	`estim_pago`	Continua (`float64`)	Es una de las variables con relación más directa con el nivel socioeconómico, ya que aproxima la capacidad de pago por vivienda o renta. En términos descriptivos, su media aumenta marcadamente conforme sube el estrato.
Variable demográfica derivada	`prop_muj`	Continua (`float64`)	Su relación con el estrato no parece fuerte ni monotónica en la exploración inicial, por lo que puede aportar información complementaria, aunque probablemente con menor poder discriminante que las variables de vivienda y servicios.
Dummies de tipo de vivienda y materiales	`tipo_viv_4`, `mat_pared_7`, `mat_pared_8`, `mat_techos_3`, `mat_techos_4`, `mat_techos_6`, `mat_techos_8`, `mat_pisos_3`	Binarias 0/1	Estas variables capturan calidades estructurales de la vivienda. En general, ciertos materiales se concentran en estratos altos y otros en estratos bajos, por lo que son atributos muy relevantes para separar clases.
Dummies de cocina, agua y saneamiento	`lugar_coc_4`, `lugar_coc_5`, `lugar_coc_6`, `ab_agua_5`, `ab_agua_6`, `ab_agua_7`, `dotac_agua_2`, `dotac_agua_4`, `dotac_agua_5`, `excusado_2`, `excusado_3`, `drenaje_2`, `drenaje_5`	Binarias 0/1	Reflejan acceso a servicios básicos y condiciones sanitarias. Este grupo suele ser altamente informativo porque la disponibilidad y calidad de agua, excusado y drenaje son variables muy asociadas al bienestar material del hogar.
Dummies de electricidad, combustible y manejo de residuos	`disp_elect_4`, `disp_elect_5`, `combus_3`, `combus_4`, `combus_7`, `eli_basura_2`, `eli_basura_4`, `eli_basura_5`, `eli_basura_6`	Binarias 0/1	Permiten identificar diferencias de equipamiento e infraestructura doméstica. El tipo de combustible y la forma de eliminar la basura pueden funcionar como marcadores indirectos de urbanización, formalidad y calidad de servicios.
Dummies de tenencia y documentos de vivienda	`tenencia_2`, `tenencia_4`, `tenencia_5`, `escrituras_4`, `escrituras_5`	Binarias 0/1	La forma de tenencia y la disponibilidad de escrituras pueden estar asociadas con estabilidad patrimonial, formalidad legal y consolidación de la vivienda, aspectos que suelen diferenciar estratos socioeconómicos.

Proyecto Final - Unidad 2¶

1. Planteamiento del problema y contexto de los datos¶

2. Exploración y comprensión del conjunto de datos¶

2.1 Significado de las variables numéricas y binarias originales¶

2.2 Significado de las variables dummy de la base final¶

2.3 Tipos de variables disponibles y su posible relación con `est_socio`¶

2.4 Discusión sobre el balance entre clases¶

3. Preparación y tratamiento de los datos¶

4. Construcción y comparación de modelos¶

4.1 Regresión Logística¶

4.2 Linear Discriminant Analysis (LDA)¶

4.3 Métodos de Ensamble — Random Forest y Gradient Boosting¶

4.4 Support Vector Machines (SVM)¶

4.5 Red Neuronal (MLP)¶

4.6 Tabla comparativa de modelos¶

5. Selección del modelo final¶

6. Evaluación del desempeño del modelo¶

7. Conclusión y reflexión final¶

7.1 Aprendizajes¶

7.2 Modelo seleccionado¶

7.3 Limitaciones¶

7.4 Áreas de mejora¶

7.5 Conexión con la problemática original¶

8. Referencias¶

Proyecto Final - Unidad 2¶

1. Planteamiento del problema y contexto de los datos¶

2. Exploración y comprensión del conjunto de datos¶

2.1 Significado de las variables numéricas y binarias originales¶

2.2 Significado de las variables dummy de la base final¶

2.3 Tipos de variables disponibles y su posible relación con est_socio¶

2.4 Discusión sobre el balance entre clases¶

3. Preparación y tratamiento de los datos¶

4. Construcción y comparación de modelos¶

4.1 Regresión Logística¶

4.2 Linear Discriminant Analysis (LDA)¶

4.3 Métodos de Ensamble — Random Forest y Gradient Boosting¶

4.4 Support Vector Machines (SVM)¶

4.5 Red Neuronal (MLP)¶

4.6 Tabla comparativa de modelos¶

5. Selección del modelo final¶

6. Evaluación del desempeño del modelo¶

7. Conclusión y reflexión final¶

7.1 Aprendizajes¶

7.2 Modelo seleccionado¶

7.3 Limitaciones¶

7.4 Áreas de mejora¶

7.5 Conexión con la problemática original¶

8. Referencias¶

2.3 Tipos de variables disponibles y su posible relación con `est_socio`¶