Problemas a resolver: performance de modelo

Laboratorio de Machine Learning: Optimización de Modelos

Contenido del curso

Bienvenida al laboratorio

Exploración de modelo de machine learning desde API

Mejora de performance de modelo de machine learning

Cierre del laboratorio

8
¿Cómo continuar tu proyecto de machine learning?
01:01 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:001:06

Problemas a resolver: performance de modelo

Laboratorio de Machine Learning: Optimización de Modelos

Clase 5 de 8

Clase 5 / 8

Comentarios (6)6 comentarios

Fernando Chavez Caracas

Hace 3 años

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

Profesor

Hace 3 años

Gracias por compartir!

Felipe Sebastián Zepeda González

Hace 3 años

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.

Ricardo Alanis

Profesor

Hace 3 años

Gracias por compartir!

Julián Cárdenas

Hace 3 años

Wow que bueen aporte!

Diego Alexander Chero Olazabal

Hace 2 años

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

Hace 2 años

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

![](https://static.platzi.com/media/user_upload/image-1ac3c506-befc-4122-b253-7858ec327863.jpg)

Angelo Augusto Gallici Aquino

Hace 2 años

[[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

Hace 2 años

Estos son mis números del modelo:

Rodrigo Martinez

Hace 2 años

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:

# 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()

# 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)

# 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

![](https://static.platzi.com/media/user_upload/image-1ac3c506-befc-4122-b253-7858ec327863.jpg)

Bienvenida al laboratorio

Instrucciones generales

Laboratorios de ML: practica tus habilidades en proyectos profesionales

Exploración de modelo de machine learning desde API

Problemas a resolver: documentación, carga y prueba de modelo

Troubleshooting: carga y prueba del modelo

Mejora de performance de modelo de machine learning

Problemas a resolver: performance de modelo

Troubleshooting: performance de modelo

Revisión de resultados

Cierre del laboratorio

¿Cómo continuar tu proyecto de machine learning?

Problemas a resolver: performance de modelo

Progreso del curso

Bienvenida al laboratorio

Exploración de modelo de machine learning desde API

Mejora de performance de modelo de machine learning

Cierre del laboratorio