Introducció
Ensemble Learning és una tècnica de Machine Learning que combina múltiples models per millorar la precisió i robustesa de les prediccions. La idea darrere de l'Ensemble Learning és que un conjunt de models, treballant junts, pot superar el rendiment d'un sol model.
Tipus d'Ensemble Learning
Hi ha diversos mètodes d'Ensemble Learning, però els més comuns són:
- Bagging (Bootstrap Aggregating)
- Boosting
- Stacking
Bagging (Bootstrap Aggregating)
Bagging és una tècnica que millora la precisió del model reduint la variància. Això es fa creant múltiples subconjunts de dades a partir del conjunt de dades original, amb reemplaçament, i entrenant un model separat en cada subconjunt. Les prediccions finals es fan mitjançant la mitjana (per a regressió) o la votació majoritària (per a classificació) de les prediccions de tots els models.
Exemple de Bagging amb Scikit-Learn
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Carregar el conjunt de dades
iris = load_iris()
X, y = iris.data, iris.target
# Dividir el conjunt de dades en entrenament i prova
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Crear el model base
base_model = DecisionTreeClassifier()
# Crear el model de Bagging
bagging_model = BaggingClassifier(base_model, n_estimators=50, random_state=42)
# Entrenar el model
bagging_model.fit(X_train, y_train)
# Fer prediccions
y_pred = bagging_model.predict(X_test)
# Avaluar el model
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy:.2f}')Boosting
Boosting és una tècnica que millora la precisió del model reduint el biaix. Això es fa entrenant models seqüencialment, on cada model intenta corregir els errors del model anterior. Els models més comuns de Boosting són AdaBoost, Gradient Boosting i XGBoost.
Exemple de AdaBoost amb Scikit-Learn
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Carregar el conjunt de dades
iris = load_iris()
X, y = iris.data, iris.target
# Dividir el conjunt de dades en entrenament i prova
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Crear el model base
base_model = DecisionTreeClassifier(max_depth=1)
# Crear el model de AdaBoost
adaboost_model = AdaBoostClassifier(base_model, n_estimators=50, random_state=42)
# Entrenar el model
adaboost_model.fit(X_train, y_train)
# Fer prediccions
y_pred = adaboost_model.predict(X_test)
# Avaluar el model
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy:.2f}')Stacking
Stacking és una tècnica que combina múltiples models utilitzant un model meta-aprenentatge. Els models base fan prediccions, i aquestes prediccions es converteixen en les característiques d'entrada per al model meta-aprenentatge, que fa la predicció final.
Exemple de Stacking amb Scikit-Learn
from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Carregar el conjunt de dades
iris = load_iris()
X, y = iris.data, iris.target
# Dividir el conjunt de dades en entrenament i prova
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Crear els models base
base_models = [
('decision_tree', DecisionTreeClassifier()),
('svm', SVC(probability=True))
]
# Crear el model meta-aprenentatge
meta_model = LogisticRegression()
# Crear el model de Stacking
stacking_model = StackingClassifier(estimators=base_models, final_estimator=meta_model)
# Entrenar el model
stacking_model.fit(X_train, y_train)
# Fer prediccions
y_pred = stacking_model.predict(X_test)
# Avaluar el model
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy:.2f}')Avantatges i Desavantatges de l'Ensemble Learning
Avantatges
- Millora de la Precisió: Els models d'ensemble sovint tenen una precisió més alta que els models individuals.
- Reducció de la Variància: Bagging ajuda a reduir la variància dels models.
- Reducció del Biaix: Boosting ajuda a reduir el biaix dels models.
- Robustesa: Els models d'ensemble són més robustos davant dades sorolloses i outliers.
Desavantatges
- Complexitat: Els models d'ensemble són més complexos i difícils d'interpretar.
- Temps de Càlcul: Entrenar múltiples models pot ser computacionalment costós.
- Risc d'Overfitting: Si no es controla adequadament, els models d'ensemble poden sobreajustar-se a les dades d'entrenament.
Exercici Pràctic
Exercici
- Carrega el conjunt de dades
breast_cancerde Scikit-Learn. - Divideix el conjunt de dades en entrenament i prova.
- Implementa un model de Bagging utilitzant
RandomForestClassifiercom a model base. - Implementa un model de Boosting utilitzant
GradientBoostingClassifier. - Implementa un model de Stacking utilitzant
RandomForestClassifieriGradientBoostingClassifiercom a models base, iLogisticRegressioncom a model meta-aprenentatge. - Compara les precisions dels tres models.
Solució
from sklearn.ensemble import BaggingClassifier, GradientBoostingClassifier, StackingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Carregar el conjunt de dades
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target
# Dividir el conjunt de dades en entrenament i prova
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Model de Bagging
bagging_model = BaggingClassifier(RandomForestClassifier(), n_estimators=50, random_state=42)
bagging_model.fit(X_train, y_train)
y_pred_bagging = bagging_model.predict(X_test)
accuracy_bagging = accuracy_score(y_test, y_pred_bagging)
# Model de Boosting
boosting_model = GradientBoostingClassifier(n_estimators=50, random_state=42)
boosting_model.fit(X_train, y_train)
y_pred_boosting = boosting_model.predict(X_test)
accuracy_boosting = accuracy_score(y_test, y_pred_boosting)
# Model de Stacking
base_models = [
('random_forest', RandomForestClassifier()),
('gradient_boosting', GradientBoostingClassifier())
]
meta_model = LogisticRegression()
stacking_model = StackingClassifier(estimators=base_models, final_estimator=meta_model)
stacking_model.fit(X_train, y_train)
y_pred_stacking = stacking_model.predict(X_test)
accuracy_stacking = accuracy_score(y_test, y_pred_stacking)
# Resultats
print(f'Accuracy Bagging: {accuracy_bagging:.2f}')
print(f'Accuracy Boosting: {accuracy_boosting:.2f}')
print(f'Accuracy Stacking: {accuracy_stacking:.2f}')Conclusió
Ensemble Learning és una tècnica poderosa que combina múltiples models per millorar la precisió i robustesa de les prediccions. Tot i que pot ser més complex i computacionalment costós, els beneficis en termes de precisió i robustesa sovint justifiquen el seu ús. En aquest mòdul, hem explorat tres mètodes principals d'Ensemble Learning: Bagging, Boosting i Stacking, i hem vist com implementar-los utilitzant Scikit-Learn.
Curs de Machine Learning
Mòdul 1: Introducció al Machine Learning
- Què és el Machine Learning?
- Història i evolució del Machine Learning
- Tipus de Machine Learning
- Aplicacions del Machine Learning
Mòdul 2: Fonaments d'Estadística i Probabilitat
- Conceptes bàsics d'estadística
- Distribucions de probabilitat
- Inferència estadística
- Teorema de Bayes
Mòdul 3: Preprocessament de Dades
Mòdul 4: Algoritmes de Machine Learning Supervisat
- Regressió lineal
- Regressió logística
- Arbres de decisió
- Màquines de suport vectorial (SVM)
- K-Veïns més propers (K-NN)
- Xarxes neuronals
Mòdul 5: Algoritmes de Machine Learning No Supervisat
- Clustering: K-means
- Clustering jeràrquic
- Anàlisi de components principals (PCA)
- Anàlisi d'agrupament DBSCAN
Mòdul 6: Avaluació i Validació de Models
Mòdul 7: Tècniques Avançades i Optimització
- Ensemble Learning
- Gradient Boosting
- Xarxes neuronals profundes (Deep Learning)
- Optimització d'hiperparàmetres
Mòdul 8: Implementació i Desplegament de Models
- Frameworks i biblioteques populars
- Implementació de models en producció
- Manteniment i monitoratge de models
- Consideracions ètiques i de privacitat
Mòdul 9: Projectes Pràctics
- Projecte 1: Predicció de preus d'habitatges
- Projecte 2: Classificació d'imatges
- Projecte 3: Anàlisi de sentiments a xarxes socials
- Projecte 4: Detecció de fraus