Problemas a resolver: performance de modelo

Lo mejor que pude optimizar el modelo fue con los siguientes parametros:

logreg_model = LogisticRegression(penalty='l1', solver='liblinear', random_state=42, C=0.01)

Me dio las siguientes métricas:

Accuracy: 0.8105
Precision: 0.7692307692307693
Recall: 0.05089058524173028
ROC AUC: 0.5235784600135223

Yo creo que la regresión logística no es el modelo más eficiente en este caso en específico.

Recomiendo hacer un OneHot Encoding y un MinMax Scaling.

# Importamos las librerías necesarias 

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import make_column_transformer
from sklearn.preprocessing import MinMaxScaler

# Copiamos el dataset original
data_df=data.copy()

# Separamos la variable de respuesta de los datos que tenemos disponibles
y = data_df.pop(data_df.columns[-1])

# Realizamos edl OneHotEncoder sobre las variables categóricas

categorical_columns = data_df.select_dtypes(object).columns

categorical_transformer = make_column_transformer(
    (OneHotEncoder(), categorical_columns),
    remainder="passthrough"
)

transformed_df = (
    pd.DataFrame(
        categorical_transformer.fit_transform(data_df),
        columns = categorical_transformer.get_feature_names_out(),
        index = data_df.index
    )
    .rename_columns(
        function = lambda x: x.removeprefix("ordinalencoder__")
    )
    .rename_columns(
        function = lambda x: x.removeprefix("onehotencoder__")
    )
    .rename_columns(
        function = lambda x: x.removeprefix("remainder__")
    )
)

# Realizamos el MinMaxScaler para normalizar los datos

scaler=MinMaxScaler()
df_scaled=scaler.fit_transform(transformed_df)
df_scaled=pd.DataFrame(df_scaled,columns=transformed_df.columns)
df_scaled.head()

Una vez resuelto aquello, implementé una red neuronal sobre el modelo original.
Usé esta arquitectura:

Y los resultados fueron los siguientes:
‘accuracy’: 0.858,
‘precision’: 0.6981818181818182,
‘recall’: 0.48854961832061067,
‘f1score’: 0.5748502994011976.

Creo que podría encontrarse una mejor arquitectura y/o enriquecer más los datos. Cualquier comentario se agradece.

Bueno el primer cambio que implemente es crear una nueva columna de tipo binaria con 1 o 0 para saber si una persona tenia balance cero o no, esto debido que al graficar dichos datos previamente, habia una gran cantidad de personas con balance cero.# Eliminar las filas que contienen valores nulosdata\_cleaned = data.dropna()# Aplicar One Hot Encodingdata\_encoded = pd.get\_dummies(data, drop\_first=True)# Vamos a crear un modelo de regresion logisticafrom sklearn.model\_selection import train\_test\_splitfrom sklearn.linear\_model import LogisticRegression \# Convertir las columnas booleanas a 1 y 0data\_encoded = data\_encoded.astype(int) \# Verificar cuántas filas y columnas quedan después de la limpiezaprint(data\_cleaned.shape) ```js # Crear una nueva columna que indica si el cliente tiene saldo o no data['HasBalance'] = (data['Balance'] > 0).astype(int) # Mostrar la nueva columna para verificar print(data[['Balance', 'HasBalance']].head()) ```Luego elimine filas con valores nulos ```js # Eliminar las filas que contienen valores nulos data_cleaned = data.dropna() # Verificar cuántas filas y columnas quedan después de la limpieza print(data_cleaned.shape) ``` Siguiente a esto hice un One hot encoding ```js # Aplicar One Hot Encoding data_encoded = pd.get_dummies(data, drop_first=True) # Convertir las columnas booleanas a 1 y 0 data_encoded = data_encoded.astype(int) ```Viene la parte de crear el modelo y aca utilize XgeBoost como variante de arboles de decision ```js # Vamos a crear un modelo de regresion logistica from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression # Generar los datos para poder separar la variable de respuesta de los datos que tenemos disponibles X = data_encoded.copy() # Usamos los datos procesados (con One Hot Encoding) y = X.pop('Exited') # Extraemos la columna 'Exited' como variable objetivo # Separar los datos en datos de entrenamiento y testing X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) import xgboost as xgb from sklearn.metrics import confusion_matrix, classification_report # Crear el modelo de XGBoost clf_xgb = xgb.XGBClassifier(random_state=0, n_estimators=100, learning_rate=0.05, scale_pos_weight=2) # Entrenar el modelo clf_xgb.fit(X_train, y_train) # Predecir y_pred = clf_xgb.predict(X_test) # Evaluar print(confusion_matrix(y_test, y_pred)) print(classification_report(y_test, y_pred)) ```El resultado obtenido es el siguiente 

**Estos son mis números del modelo:** 

Hice un poco de trampa y ocupe autosklearn para tener un clasificador base y poder seguir mejorandolo o con mas datos porque estan desbalanceados o cambiarlo por una arquitectura de red neuronal. Ahora obtuve los siguientes metricas con mi ensamble de metodos:

Teniendo en cuenta que la variable target se encuentra desbalanceada, procedi a una SMOTEEN de imblearm para balancear los datos submuestreando la clase dominante y sobremuestreando la clase minoritaria. Luego procedi a realizar una validacion de estos nuevos datos para verificar que los datos sobremuestreados sean representativos de mi data original. Para ello use graficas de distribucion en todas mis variables. Una veza comprobado esto procedi a probar con algunos modelos como RandomForestClassifeer, XGBoost y ExtreTree. Realice varios entrenamientos usando la data original y la data balanceada para los modelos que usea, y ya que no se pueden contrastar usando la metrica de acuracy como referencia pues algunos modelos presentan una cantidad de datos de testeo diferentes por el sobremuestreo, opte por una la metria de AUC\_ROC y AUC\_PR para medir la adpatbilidad de mis modelos a nuevos datos. Teniendo los siguientes resultados: