Implementación de Boosting

Para este método de ensamble, jugue un poco con los estimators:

X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.35)

    estimators = range(10, 200, 10)
    total_accuracy = []
    for i in estimators:
        boost = GradientBoostingClassifier(n_estimators=i).fit(X_train, y_train)
        boost_pred = boost.predict(X_test)

        total_accuracy.append(accuracy_score(y_test, boost_pred))
    
    plt.plot(estimators, total_accuracy)
    plt.xlabel('Estimators')
    plt.ylabel('Accuracy')
    plt.show()
    plt.savefig('Boost.png')

    print(np.array(total_accuracy).max())

Accuracy = 0.9749303621169917

Configurando el boosting de esta manera:

boosting = GradientBoostingClassifier(loss='exponential',learning_rate=0.15, n_estimators=100, max_depth=5).fit(x_train, y_train)

Obtuve un score de:
0.9888579387186629

Para determinar el mejor n_estimator

estimators = range(10, 300, 10)
total_accuracy = []
best_result = {'result' : 0, 'n_estimator': 1}

for i in estimators:
    boost = GradientBoostingClassifier(n_estimators=i).fit(X_train, y_train)
    boost_pred = boost.predict(X_test)
    new_accuracy = accuracy_score(boost_pred, y_test)
    total_accuracy.append(new_accuracy)
    if new_accuracy > best_result['result']: 
        best_result['result'] = new_accuracy
        best_result['n_estimator'] = i

print(best_result)

investoge que es el cross validadtion para encontrar el n_estimators correcto, básicamente es dividir los datos en bloques y utilizar cada bloque como testing y el resto como training en cada iteration, con lo que se obtiene un valor de como se comporta el modelo con cualquier combinacion de los datos.

con este indicador se pueden compara modelos entre si o en este caso valores para un parametro, si quieren profundizar les recomiendo este video.

Les adjunto mi version del codigo:

import pandas as pd

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.model_selection import train_test_split
from sklearn.metrics import  accuracy_score

if __name__ == "__main__":
    
    path = './Boosting/data/heart.csv'
    dataset = pd.read_csv(path)

    print(dataset.head(5))
    print('')
    print(dataset['target'].describe())

    x = dataset.drop(['target'], axis=1, inplace=False)
    y = dataset['target']

    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.35, random_state=42)

    boost = GradientBoostingClassifier(n_estimators=50).fit(x_train, y_train)
    boost_pred = boost.predict(x_test)

    print('')
    #print('Accuracy GBC:', accuracy_score(y_test, boost_pred)) # este esta bien.
    print('Accuracy GBC:', accuracy_score(boost_pred, y_test)) # este me parece que esta mal.

Donde el output es el siguiente:

Accuracy GBC: 0.935933147632312

Me gusta mucho el código que lo que hace es iterar para buscar una mejor respuesta. Por esto es que les dejo este mismo para que lo prueben: ```python import pandas as pd from sklearn.ensemble import GradientBoostingClassifier from sklearn.model_selection import train_test_split, GridSearchCV from sklearn.metrics import accuracy_score if __name__ == "__main__": # Cargar los datos data = pd.read_csv('./data/heart.csv') # Preparar las variables predictoras y la variable objetivo X = data.drop(['target'], axis=1) Y = data['target'] # Dividir en conjunto de entrenamiento y prueba X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.35, random_state=42) # Definir el rango de valores a probar para los hiperparámetros param_grid = { 'n_estimators': [50, 100, 200], 'learning_rate': [0.01, 0.1, 0.2], 'max_depth': [3, 5, 7] } # Crear un modelo de Gradient Boosting gb_model = GradientBoostingClassifier(random_state=42) # Crear GridSearchCV para buscar la mejor combinación de parámetros grid_search = GridSearchCV(estimator=gb_model, param_grid=param_grid, cv=5, scoring='accuracy') # Entrenar el GridSearchCV grid_search.fit(X_train, Y_train) # Imprimir todos los resultados de las combinaciones results = grid_search.cv_results_ print("Resultados para cada combinación de hiperparámetros de Gradient Boosting:") for mean_score, params in zip(results['mean_test_score'], results['params']): print(f"Parámetros: {params}, Precisión promedio: {mean_score}") # Mejor modelo encontrado best_params = grid_search.best_params_ print(f"\nMejores parámetros encontrados: {best_params}") # Evaluar el mejor modelo en los datos de prueba best_model = grid_search.best_estimator_ Y_pred = best_model.predict(X_test) accuracy = accuracy_score(Y_test, Y_pred) print(f"\nPrecisión del mejor modelo en los datos de prueba: {accuracy}") ``` 

***<u>Bagging vs Boosting </u>*** Tanto el bagging (agregación por bootstrap) como el boosting son técnicas de aprendizaje ensemble usadas en machine learning para mejorar el rendimiento de un modelo al combinar las predicciones de múltiples modelos más débiles (también llamados estimadores base). Si bien comparten el mismo objetivo, lo logran de formas diferentes: **Bagging (Agregación por Bootstrap):** * **Diversidad a través del muestreo aleatorio:** El bagging se centra en crear diversidad entre los estimadores base. Logra esto entrenando a cada estimador base en una muestra **bootstrap** diferente de los datos de entrenamiento. El bootstrap implica crear un nuevo conjunto de datos mediante el muestreo aleatorio (con reemplazo) de los datos de entrenamiento originales. Esto significa que algunos puntos de datos pueden aparecer varias veces en una muestra bootstrap, mientras que otros pueden no incluirse en absoluto. * **Entrenamiento independiente:** Cada estimador base en el bagging se entrena independientemente de los demás. No se "comunican" ni aprenden de los errores de los otros. * **Agregación de predicciones:** Finalmente, el bagging agrega las predicciones de todos los estimadores base utilizando técnicas como la votación por mayoría para clasificación o el promedio para regresión. **Boosting (Boosting de gradiente):** * **Aprendizaje secuencial:** El boosting toma un enfoque más secuencial. Entrena a los estimadores base uno tras otro, donde cada estimador posterior se enfoca en mejorar los errores cometidos por los anteriores. * **Corrección de errores:** El boosting utiliza una técnica llamada descenso del gradiente para ajustar los pesos de los estimadores base. Los pesos determinan la influencia de cada estimador en la predicción final. A los estimadores que cometen más errores se les asignan pesos más bajos, mientras que a los que cometen menos errores se les aumentan los pesos. * **Aprendizaje adaptativo:** Este proceso de enfocarse en corregir errores pasados permite que el boosting cree un ensemble más poderoso que pueda aprender patrones más complejos en los datos. **Diferencias clave y cuándo elegir cuál:** ![](<"C:\Users\USER\Documents\Platzi\Diplomas Platzi\Escuela de Data Science e Inteligencia Artificial\Pdfs e images\Scki-Learn_Professional\Bagging vs Boosting (Precision del modelo y eliminacion, coreccion de valores atipicos).png">) **Aquí algunas pautas generales para elegir entre bagging y boosting:** * **Usa bagging:** Si te preocupa principalmente reducir la varianza y tus estimadores base ya son relativamente buenos, el bagging es una opción más simple y rápida. También es más fácil interpretar los modelos individuales en un ensemble de bagging. * **Usa boosting:** Si deseas un modelo potencialmente más poderoso que pueda reducir tanto la varianza como el sesgo, especialmente para problemas complejos, el boosting es una buena opción. Sin embargo, los algoritmos de boosting pueden ser más costosos computacionalmente y menos interpretables. En última instancia, la mejor opción depende de las características específicas de tus datos y tu problema. Es posible que desees experimentar con bagging y boosting para ver cuál funciona mejor en tu conjunto de datos.

LinearSVC
Accuracy: 0.8133704735376045
====================================================================
SVC
Accuracy: 0.6880222841225627
====================================================================
SGDClassifier
Accuracy: 0.6796657381615598
====================================================================
DecisionTreeClassifier
Accuracy: 0.9554317548746518
====================================================================
GradientBoostingClassifier
Accuracy: 0.9331476323119777

24. Implementación de Boosting

import pandas as pd

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import BaggingClassifier

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

if __name__ == '__main__':
    # Load the dataset
    df = pd.read_csv('./data/heart.csv')
    print(df['target'].describe())

    # Split the dataset into features (X) and target (y)
    X = df.drop(['target'], axis=1)
    y = df['target']

    # Split the dataset into training and testing sets
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.35, random_state=42)

    # Fit a Gradient Boosting classifier to the training data and evaluate its performance on the testing data
    boost = GradientBoostingClassifier(n_estimators=50).fit(X_train, y_train)
    boost_pred = boost.predict(X_test)
    print('=' * 64)
    print('Gradient Boosting Accuracy: ', accuracy_score(y_test, boost_pred))

Epero este aporte les sirva. Estan implementados tanto sin metodo ensamble como con bagging y boosting como resultado

import pandas as pd 

from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import BaggingClassifier

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.svm import LinearSVC
from sklearn.linear_model import SGDClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

import warnings
warnings.filterwarnings("ignore")

if __name__ == '__main__':
    #dt_heart = pd.read_csv('./datasets/heart.csv')
    dt_heart = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/platzi/datas/heart.csv')
    #print(dt_heart['target'].describe())

    x = dt_heart.drop(['target'], axis=1)
    y = dt_heart['target']

    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.35, random_state=1)



    estimators = {
        'LogisticRegression' : LogisticRegression(),
        'SVC' : SVC(),
        'LinearSVC' : LinearSVC(),
        'SGD' : SGDClassifier(loss="hinge", penalty="l2", max_iter=5),
        'KNN' : KNeighborsClassifier(),
        'DecisionTreeClf' : DecisionTreeClassifier(),
        'RandomTreeForest' : RandomForestClassifier(random_state=0)
    }

    for name, estimator in estimators.items():

        estimator_class = estimator.fit(x_train, y_train)
        estimator_prediction = estimator.predict(x_test)
        print('='*64)
        print('SCORE no bagging {} : {}'.format(name, accuracy_score(knn_prediction, y_test))  )

        bag_class = BaggingClassifier(base_estimator=estimator, n_estimators=50).fit(x_train, y_train)
        bag_predict = bag_class.predict(x_test)
        print('SCORE Bagging with {} : {}'.format(name, accuracy_score(bag_predict, y_test)))

        boost = GradientBoostingClassifier(n_estimators=50).fit(x_train, y_train)
        boost_pred = boost.predict(x_test)
        print('SCORE Boosting with {} : {}'.format(name, accuracy_score(boost_pred, y_test)))

resultado :

===============================================
SCORE no bagging LogisticRegression : 0.7270194986072424
SCORE Bagging with LogisticRegression : 0.8133704735376045
SCORE Boosting with LogisticRegression : 0.924791086350975
===============================================
SCORE no bagging SVC : 0.7270194986072424
SCORE Bagging with SVC : 0.6629526462395543
SCORE Boosting with SVC : 0.924791086350975
===============================================
SCORE no bagging LinearSVC : 0.7270194986072424
SCORE Bagging with LinearSVC : 0.8245125348189415
SCORE Boosting with LinearSVC : 0.924791086350975
===============================================
SCORE no bagging SGD : 0.7270194986072424
SCORE Bagging with SGD : 0.6685236768802229
SCORE Boosting with SGD : 0.924791086350975
===============================================
SCORE no bagging KNN : 0.7270194986072424
SCORE Bagging with KNN : 0.766016713091922
SCORE Boosting with KNN : 0.924791086350975
===============================================
SCORE no bagging DecisionTreeClf : 0.7270194986072424
SCORE Bagging with DecisionTreeClf : 0.9721448467966574
SCORE Boosting with DecisionTreeClf : 0.924791086350975
===============================================
SCORE no bagging RandomTreeForest : 0.7270194986072424
SCORE Bagging with RandomTreeForest : 0.9805013927576601
SCORE Boosting with RandomTreeForest : 0.924791086350975

KNeighborsClassifier 0.711038961038961

BaggingClassifier 0.7727272727272727

RanfomForestClassifier: 1.0

GradientBoostingClassifier: 0.9448051948051948