No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Regularizers

11/17
Recursos

Aportes 9

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

El notebook que se deja muestra lo mismo que se vio en las clases, no hay ninguna aplicación extra de como se usa un regularizador dentro de un modelo de regresión logística

import joblib

class Utils:

    def load_from_csv(self, path):
        return pd.read_csv(path)

    def load_from_mysql(self):
        pass

    def features_target(self, dataset, drop_cols, var_predict):
        X = dataset.drop(drop_cols, axis=1)
        y = dataset[var_predict]
        return X, y

    def model_export(self, clf, score):
        print(score)
        joblib.dump(clf, './models/best_model.pkl')
import numpy as np

from sklearn.model_selection import GridSearchCV


class Models:

    def __init__(self):
        # Grid for classifier
        self.reg_classifier = {
            'LogisticRegressionelasticnet': LogisticRegression(max_iter=100000),
        }

        self.params_classifier = {
            'LogisticRegressionelasticnet': {
                'penalty': ['elasticnet'],
                'solver': ['saga'],
                'l1_ratio': np.arange(0,1,0.01),
            },
        }

        # Grid for regression
        self.reg_regression = {}
        self.params_regression = {}

    def grid_training_classifier(self, X, y):

        best_score = 999
        best_model = None

        for name, reg in self.reg_classifier.items():

            grid_reg = GridSearchCV(reg, self.params_classifier[name], cv=3).fit(X, y.values.ravel())
            score = np.abs(grid_reg.best_score_)

            if score < best_score:
                best_score = score
                best_model = grid_reg.best_estimator_

        utils = Utils()
        utils.model_export(best_model, best_score)

models = Models()
models.grid_training_classifier(x_rsmote, y_rsmote)

Hola buena noche, quisiera dejar un link para comprender mejor el tema y profundizar en este:
https://www.cienciadedatos.net/documentos/py14-ridge-lasso-elastic-net-python.html

Recuerden, que para mejorar pueden investigar por su cuenta 💪💪💪💪💪💪💪.

**Coeficientes del Modelo:** * Son valores asignados a cada característica en un modelo de aprendizaje automático. * Ayudan a predecir el resultado objetivo. * Se ajustan durante el entrenamiento del modelo para minimizar la función de costo. **Regularización:** * Técnica para evitar el sobreajuste en modelos de aprendizaje automático. * Penaliza la complejidad del modelo durante el entrenamiento. * Ayuda a mejorar la generalización y la estabilidad del modelo. **Tipos de Regularización:** 1. **L1 (Lasso):** * Promueve la dispersión de los coeficientes. * Permite la selección automática de características importantes. 2. **L2 (Ridge):** * Reduce todos los coeficientes por igual. * Favorece modelos más suaves. 3. **ElasticNet:** * Combina las penalizaciones de L1 y L2. * Permite capturar las ventajas de ambas técnicas. 4. **Tikhonov (Ridge Regression):** * Controla la multicolinealidad en problemas de regresión lineal. 5. **Group Lasso:** * Agrupa características relacionadas y asigna un solo coeficiente. 6. **ElasticNet de grupo:** * Combina las ideas de ElasticNet y Group Lasso. * Permite la selección de grupos de características. **Elección de la Técnica de Regularización:** * Depende del tipo de datos y el objetivo del modelado. * Fundamental para mejorar la generalización y la estabilidad del modelo de aprendizaje automático.

La regularización L1 y L2 son los modelos Lasso y Ridge, respectivamente, para disminuir la complejidad del modelo y eliminar variables. En el Curso Profesional de Machine Learning con Scikit-Learn con Ariel Ortiz se presentan estos conceptos y otros adicionales como ElasticNet.

Los regularizadores son técnicas utilizadas en modelos de regresión logística para reducir la complejidad del modelo y minimizar el overfitting. Su función principal es agregar una penalización a la función de costo del modelo. Existen principalmente dos tipos: 1. **L1 (Lasso)**: Penaliza la suma de los valores absolutos de los pesos, lo que puede llevar a que algunos pesos se conviertan en cero, permitiendo una selección de características. 2. **L2 (Ridge)**: Penaliza la suma de los cuadrados de los pesos, ayudando a mantener todos los pesos pero reduciendo su magnitud. Ambos tipos ayudan a mejorar la generalización del modelo al evitar que se ajuste demasiado a los datos de entrenamiento.
Una metáfora de Caperucita roja y los regularizadores es esta: *Imagina que **Caperucita Roja** está caminando por el bosque y tiene que elegir un camino para llegar a la casa de su abuela (**encontrar el mejor modelo**). El problema es que el bosque está lleno de obstáculos y distracciones (**ruido y sobreajuste**). Si no tiene cuidado, Caperucita puede tomar un camino demasiado complicado y terminar en el bosque profundo (**sobreajuste**), donde está el lobo (**modelo que no generaliza bien**).* *Aquí es donde entran los **regularizadores**: son como los **carteles del bosque** que le indican a Caperucita que debe evitar los caminos que son demasiado complejos. Estos carteles (L1 y L2) la guían para que tome un camino más directo y seguro, manteniéndose en el camino correcto sin desviarse demasiado. Así, llega a la casa de su abuela (un modelo bien ajustado que generaliza bien).*
Hay algunas mejoras que podemos implementar para el entrenamiento del modelo: \- Calcular los pesos de las clases para entrenar el modelo. Recordemos que es un dataset que no esta balanceado, y si le damos pesos a cada clase, esto ayudara a entrenar mejor al modelo. - Usar unicamente los features que tengan un peso significativo en el entrenamiento del modelo. Para ello definimos un umbral para los pesos de las features. Este valor es discrecional, asi que pueden experimentar para mejorar los resultados.- Cambiar el valor de C. C es un valor inverso a la regularizacion que le apliquemos al modelo, por lo que al reducir su valor incrementamos la regularizacion del modelo. Basado en esto, les dejo mi implementacion del entrenamiento del modelo: ```python # We obtain the weights of the features weights = pd.Series( model.coef_[0], index=df_processing_scaled.drop("Churn", axis=1).columns.values ) # We only pull the features with weights above 0.2 or below -0.2 # This is discretional, a different value may work better useful_features = weights[(weights >= 0.2) | (weights <= -0.2)].index.tolist() useful_features.extend(["Churn"]) df = df_processing_scaled[useful_features] # Separate the values into train and test sets X = df_processing_scaled.drop("Churn", axis=1) y = df_processing_scaled["Churn"].values x_train, x_test, y_train, y_test = train_test_split( X, y, test_size=0.3, random_state=42 ) # Since the dataset is inbalanced, lets calculate the weights for each # class using the `compute_class_weight` function class_weight = compute_class_weight( class_weight="balanced", classes=df_processing_scaled["Churn"].unique(), y=df_processing_scaled["Churn"], ) class_weight_dict = {0: class_weight[0], 1: class_weight[1]} # Train the model with a different regularizer # Keep in mind that C is the inverse of the regularization strenght model = LogisticRegression( solver="lbfgs", penalty="l2", C=0.75, class_weight=class_weight_dict, max_iter=250, n_jobs=-1, ) model.fit(x_train, y_train) # Evaluate the model preds = model.predict(x_test) accuracy_score = metrics.accuracy_score(y_test, preds) f1_value_score = metrics.f1_score(y_test, preds) precision_score = metrics.precision_score(y_test, preds) recall_score = metrics.recall_score(y_test, preds) confusion_matrix = metrics.confusion_matrix(y_test, preds, labels=model.classes_) figure = plt.figure(figsize=(10, 10)) print( f"""Accuracy: {accuracy_score:.4f} Recall: {recall_score:.4f} Precision: {precision_score:.4f} F1 Score: {f1_value_score:.4f}""" ) cm = metrics.ConfusionMatrixDisplay( confusion_matrix=confusion_matrix, display_labels=model.classes_ ) cm.plot() plt.show() ```

También se pueden llevar sa numérico usando LabelEncoder