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.
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:
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)
# 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
# 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:
Fernando Chavez Caracas
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.
Ricardo Alanis
ProfesorGracias por compartir!
Felipe Sebastián Zepeda González
Ricardo Alanis
ProfesorGracias por compartir!
Julián Cárdenas
Wow que bueen aporte!
Diego Alexander Chero Olazabal
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:
Angelo Augusto Gallici Aquino
Angelo Augusto Gallici Aquino
[[2436 221] [ 248 395]] precision recall f1-score support
0 0.91 0.92 0.91 2657 1 0.64 0.61 0.63 643
accuracy 0.86 3300 macro avg 0.77 0.77 0.77 3300 weighted avg 0.86 0.86 0.86 3300
Antonio Demarco Bonino
Estos son mis números del modelo:
Rodrigo Martinez
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:
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)
# 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
# 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 