<jupyter_start><jupyter_text>Ejercicios ensemblingEn este ejercicio vas a realizar prediciones sobre un dataset de ciudadanos indios diabéticos. Se trata de un problema de clasificación en el que intentaremos predecir 1 (diabético) o 0 (no diabético). Para facilitarnos las cosas, vamos a coger un dataset donde todas las variables son numércias.  1. Carga las librerías que consideres comunes al notebook<jupyter_code>import pandas as pd
import numpy as np<jupyter_output><empty_output><jupyter_text>2. Lee los datos de esta [dirección](https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv)Los nombres de columnas son:```Pythonnames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']```<jupyter_code>url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

df = pd.read_csv(url, header=None)
df.columns = names
df[df.columns[:-1]]
# Definimos un diccionario para llevar los scores:
scores = {}<jupyter_output><empty_output><jupyter_text>3. BaggingPara este apartado tendrás que crear un ensemble utilizando la técnica de bagging ([BaggingClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingClassifier.html)), mediante la cual combinarás 100 [DecisionTreeClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html). Recuerda utilizar también [cross validation](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html) con 10 kfolds.**Para este apartado y siguientes, no hace falta que dividas en train/test**, por hacerlo más sencillo. Simplemente divide tus datos en features y target.Además, para poder reproducir el algoritmo numerosas veces, establece una semilla.<jupyter_code>array = df.values
X = array[:, 0:8]
Y = array[:, 8]
seed = 42

np.random.seed(seed)
# from sklearn.pipeline import Pipeline
# from sklearn.model_selection import GridSearchCV, cross_val_score
# from sklearn.preprocessing import StandardScaler
# from sklearn.feature_selection import SelectKBest
# from sklearn.ensemble import BaggingClassifier
# from sklearn.tree import DecisionTreeClassifier

# bag_clf = BaggingClassifier(
#     base_estimator=DecisionTreeClassifier(random_state=42),
#     max_samples=1.0,
#     bootstrap=True,
#     random_state=42)

# pipe = Pipeline([('scaler', StandardScaler()), ('selector', SelectKBest()), ('bag', bag_clf)])

# params = {
#     'selector__k': np.arange(5, 10),
#     'bag__n_estimators': [100, 250, 500, 750, 1000]
# }

# gs_pipe = GridSearchCV(pipe,
#                       params,
#                       cv = 10,
#                       scoring='accuracy',
#                       n_jobs=-1,
#                       verbose=1)
# gs_pipe.fit(X, Y)
# gs_pipe.best_estimator_.score(X_test, y_test)
# cross_val_score(
#     BaggingClassifier(
#         base_estimator=DecisionTreeClassifier(random_state=42),
#         n_estimators=750,
#         bootstrap=True, 
#         random_state=42),
#     X_train, y_train, cv=10, scoring='accuracy').mean()
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

model = BaggingClassifier(base_estimator=DecisionTreeClassifier(), n_estimators=100)

cross_val_score(model, X, Y, cv=10).mean()
scores.update({'Bagging': cross_val_score(model, X, Y, cv=10).mean()})<jupyter_output><empty_output><jupyter_text>4. Random ForestEn este caso entrena un [RandomForestClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html) con 100 árboles y un `max_features` de 3. También con validación cruzada<jupyter_code>from sklearn.ensemble import RandomForestClassifier

# Esta forma es más rápida, es como lo anterior, pero más rápido (sin hacer el bagging).
model = RandomForestClassifier(n_estimators=100, max_features=3, random_state=42)

model.fit(X, Y)

cross_val_score(model, X, Y, cv=10, scoring ='accuracy').mean()
scores.update({'Random Forest': cross_val_score(model, X, Y, cv=10).mean()})<jupyter_output><empty_output><jupyter_text>5. AdaBoostImplementa un [AdaBoostClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) con 30 árboles.<jupyter_code>from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier(n_estimators=30)

cross_val_score(model, X, Y, cv=10).mean()
scores.update({'AdaBoost': cross_val_score(model, X, Y, cv=10).mean()})<jupyter_output><empty_output><jupyter_text>6. GradientBoostingImplementa un [GradientBoostingClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html) con 100 estimadores<jupyter_code>from sklearn.ensemble import GradientBoostingClassifier

model = GradientBoostingClassifier(n_estimators=100)

cross_val_score(model, X, Y, cv=10).mean()
scores.update({'GradientBoosting': cross_val_score(model, X, Y, cv=10).mean()})<jupyter_output><empty_output><jupyter_text>7. XGBoostPara este apartado utiliza un [XGBoostClassifier](https://docs.getml.com/latest/api/getml.predictors.XGBoostClassifier.html) con 100 estimadores. XGBoost no forma parte de la suite de modelos de sklearn, por lo que tendrás que instalarlo con pip install<jupyter_code># from xgboost import XGBClassifier

# model = XGBClassifier(use_label_encoder=False, eval_metric='logloss', n_estimators=100)

# cross_val_score(model, X, Y, cv=10).mean()
import xgboost

model = xgboost.XGBClassifier(use_label_encoder=False, eval_metric='logloss', n_estimators=100)

cross_val_score(model, X, Y, cv=10).mean()
scores.update({'XGBoost': cross_val_score(model, X, Y, cv=10).mean()})<jupyter_output><empty_output><jupyter_text>8. ResultadosCrea un series con los resultados y sus algoritmos, ordenándolos de mayor a menor<jupyter_code>df = pd.DataFrame({'models': list(scores.keys()), 'score': list(scores.values())})

df.sort_values("score", ascending=False)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1206811855248076, 'fraction_numerical': 0.018503356803667922, 'mean_word_length': 6.020689655172414, 'pattern_counts': {'":': 0, '<': 33, '<?xml version=': 0, '>': 33, 'https://': 9, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '267251', 'license': 'MIT', 'n_tokens_mistral': 2206, 'n_tokens_neox': 2111, 'n_words': 446, 'path': 'Bloque 3 - Machine Learning/01_Supervisado/9-Ensemble/02_Ejercicio_Ensemble.ipynb', 'repo_name': 'franciscocanon-thebridge/bootcamp_thebridge_PTSep20', 'size': '6107'}