<jupyter_start><jupyter_text>Übung: Ensemble Learning In diesem Notebook werden wir verschiedene Formen des "Ensemble Learning" einsetzen und einen einfachen Bagging-Algorithmus selbst implementieren.  Daten laden Für diese Übung nehmen nehmen wir den [Wein-Datensatz](https://archive.ics.uci.edu/ml/datasets/wine), welcher ebenfalls ein bekannter Datensatz in der ML-Welt ist.Die offizielle Beschreibung lautet:```These data are the results of a chemical analysis of wines grown in the same region in Italy but derived from three different cultivars. The analysis determined the quantities of 13 constituents found in each of the three types of wines.```Anhand dieser Merkmale soll die Qualität (`quality`) des Weins vorhergesagt werden.<jupyter_code>import numpy as np
np.random.seed(0)
import pandas as pd
df = pd.read_csv("wine.csv")
df.head()<jupyter_output><empty_output><jupyter_text>Bevor wir loslegen, schauen wir uns noch kurz die Verteilung des Labels an:<jupyter_code>df['quality'].hist()
from sklearn.model_selection import train_test_split
X = df.drop('quality', axis=1)
y = df['quality']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)<jupyter_output><empty_output><jupyter_text>Aufgabe 1: Decision Tree, Random Forest, GBTTrainieren Sie die folgenden Modelle und ermitteln Sie die Accuarcy auf den Testdaten. Geben Sie dabei jeweils den Paremeter `random_state=0` bei der Erstellung des Modells and und beschränken Sie die maximale Baumtiefe auf `max_depth=3`.- Einfacher Entscheidungsbaum (`DecisionTreeClassifier`)- Random Forest (`RandomForestClassifier`)- GBT (`GradientBoostingClassifier`)Hinweis: Für diese Modelle müssen wir die Daten nicht skalieren und kein One-hot-encoding durchführen. Einfacher Entscheidungsbaum<jupyter_code>from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(criterion="entropy", random_state=0, max_depth=3)
model.fit(X_train, y_train)
from sklearn.metrics import accuracy_score
predictions = model.predict(X_test)
accuracy_score(y_test, predictions)<jupyter_output><empty_output><jupyter_text>Random Forest<jupyter_code>from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=0, max_depth=3)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
accuracy_score(y_test, predictions)<jupyter_output><empty_output><jupyter_text>Gradient Boosting Tree<jupyter_code>from sklearn.ensemble import GradientBoostingClassifier
model = GradientBoostingClassifier(random_state=0)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
accuracy_score(y_test, predictions)<jupyter_output><empty_output><jupyter_text>Aufgabe 2: GBT TuningDas `GradientBoostingClassifier`-Modell hat als Hyperparameter u.a. die Anzahl der Bäume die trainiert werden (`n_estimators`) und die maximale Baumtiefe (`max_depth`), siehe [hier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html).- Führen Sie ein Cross-Validierung über diese Hyperparameter durch, betrachten Sie dabei folgende Werte:  $n\_estimators \in [60, 80, 100, 120, 140]$ und $max\_depth \in [2, 3, 4, 5]$. Nehmen Sie [dieses Code-Beispiel](https://chrisalbon.com/machine_learning/model_evaluation/cross_validation_parameter_tuning_grid_search/) als Vorlage. Hinweis: Der `import`-Befehl im Beispiel ist out-dated und heißt richtig: `from sklearn.model_selection import GridSearchCV`.- Welches sind die besten Parameter für `max_depth` und `n_estimators`?- Trainieren Sie einen neuen GBT mit diesen Parametern und machen Sie eine Vorhersage auf den Testdaten. Vergleichen Sie die Ergebnisse mit Aufgabe 1.<jupyter_code>from sklearn.model_selection import GridSearchCV
from sklearn import datasets, svm

parameter_candidates = [
    {'n_estimators': [60, 80, 100, 120, 140], 'max_depth': [2, 3, 4, 5]}
]
# Create a classifier object with the classifier and parameter candidates
gbt = GradientBoostingClassifier(random_state=0)
clf = GridSearchCV(estimator=gbt, param_grid=parameter_candidates, n_jobs=-1)

# Train the classifier on data1's feature and target data
clf.fit(X_train, y_train)
# View the accuracy score
print('Best score for X_Train:', clf.best_score_)
# View the best parameters for the model found using grid search
print('Best n_estimators:',clf.best_estimator_.n_estimators)
print('Best max_depth:',clf.best_estimator_.max_depth)
model = GradientBoostingClassifier(random_state=0, n_estimators=140, max_depth=5)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
accuracy_score(y_test, predictions)<jupyter_output><empty_output><jupyter_text>Aufgabe 3: Bagging-Modell  Implementieren sie einen Bagging-Modell von Hand (d.h. nicht die Sklearn-Library verwenden) und testen Sie es auf den Testdaten. Das Modell soll folgende Eigenschaften haben:- Das Modell soll 10 Basismodelle haben, welche einfache `DecisionTreeClassifier` sind.- Jeder dieser DecisionTrees soll auf 70% der Trainingsdaten trainiert werden (sampling mit zurücklegen). Tipp: Nutzen Sie `X_train.sample()`.- Bei der Vorhersage soll die am häufigsten vorhergesagte Klasse als Gesamtvorhersage dienen.- Testen Sie das Modell auf den Testdaten.<jupyter_code>from statistics import mode
percentage = int ( len(X_train) * 0.7 )

smol = X_train.sample(percentage)
smol

forest = []

for i in range(10):
    smol_X = X_train.sample(frac=percentage, replace=True, random_state=i)
    smol_y = y_train[smol_X.index]
    model = DecisionTreeClassifier(criterion="entropy", random_state=0, max_depth=3)
    model.fit(smol_X, smol_y)
    forest.append(model)

for tree in forest:
    tree_predictions = tree.predict(X_test)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08617058617058616, 'fraction_numerical': 0.012285012285012284, 'mean_word_length': 6.9929873772791025, 'pattern_counts': {'":': 0, '<': 29, '<?xml version=': 0, '>': 29, 'https://': 3, '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': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '311492', 'license': 'MIT', 'n_tokens_mistral': 1966, 'n_tokens_neox': 1897, 'n_words': 526, 'path': '6_Wine_Dataset_TreeModels.ipynb', 'repo_name': 'Lumi1070/ml-kurs', 'size': '5698'}