<jupyter_start><jupyter_text>EntscheidungsbäumeEntscheidungsbäume sind von zwei Haupttypen:-  Klassifikationsbäume: Vorhersage einer diskreten Klasse zu der die Daten gehören-  Regressionsbäume: Vorhersage einer realen Zahl (z.B. die Lieferzeit).Die CART-Analyse (CART = Classification And Regression Tree) ist ein Oberbegriff für die beiden oben genannten Verfahren, da die Verfahren einige Ähnlichkeiten aufweisen. Eine Alternative zur Anpassung eines einzelnen Baumes ist die Kombination mehrerer verschiedener Entscheidungsbäume. Diese Methoden werden Ensemble-Methoden genannt. Diese kombinierten Modelle führen zu einer höheren Vorhersagequalität, sind aber schwieriger zu interpretieren. Zwei Ansätze zur Kombination mehrerer Bäume sind bagging und boosting.<jupyter_code># Importieren der Pakete
import pandas as pd
import numpy as np
import sklearn

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import DecisionTreeRegressor
from sklearn import tree

import pip
#pip.main(['install', 'xgboost']) # Installation von Paketen, die nicht bereits installiert sind
# Für die Installation müssen sie einmalig das # vor dem pip.main entfernen
import xgboost as xgb # Danach kann man es dann importierne
from sklearn.metrics import mean_squared_error

# Setzen eines seeds für die folgenden Methoden (Reproduzierbarkeit)
np.random.seed(11)<jupyter_output><empty_output><jupyter_text>Regressionsbäume<jupyter_code># Laden des Datensatzs
auto = pd.read_csv(r"C:\Users\dormuth\Desktop\MSIND\02_Lehre\2021WiSe_Statistics_meets_Logistics\02_Übung\auto.csv")
print(auto.shape)
auto.head() # Der letzte Befehl in einem Jupyter Notebook muss nicht explizit geprintet werden um angezeigt zu werden

#mpg = Miles per gallon

auto = auto[auto.horsepower != '?'] #Entfernen der Zeilen mit fehlenden Werten, hier als ? codiert
print(auto.horsepower.dtype)

auto.horsepower = auto.horsepower.astype("int")
auto.shape
# Definieren von X und y
X = auto.drop(['mpg', 'car name'], axis=1) # Alle anderen Spalten ausser mpg und car name
# Regressionsbaeume funktionieren nicht mit kategoriellen Variablen dieser Art (car name), 
# entweder man muss sie codieren oder lässt sie außenvor
Y = auto['mpg']


# Aufteilen der Daten so, dass zufaellig 20% der Daten fuer die Testdaten zurück gelegt werden
X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2, random_state = 123) 
# Zwei Regressoren mit verschiedener Tiefe
regr_1 = DecisionTreeRegressor(max_depth = 2)
regr_2 = DecisionTreeRegressor(max_depth = 5)

# Die Modelle anpassen
reg1 = regr_1.fit(X_train, Y_train)
reg2 = regr_2.fit(X_train, Y_train)

# Den Baum graphisch darstellen
tree.plot_tree(reg1, feature_names=X_train.columns,
                   filled=True)
# Die Bäume zur eigentlichen Vorhersage verwenden
pred1 = regr_1.predict(X_test)
pred2 = regr_2.predict(X_test)
# Bestimmen Sie den MSE
mse1 = mean_squared_error(Y_test, pred1)
print("MSE: %f" % (mse1))
mse2 = mean_squared_error(Y_test, pred2)
print("MSE: %f" % (mse2))<jupyter_output>MSE: 11.294982<jupyter_text>Der Datensatz stammt von https://archive.ics.uci.edu/ml/datasets/Auto+MPG ------------ AufgabePassen sie einen Baum der Tiefe 7 an. Verbessert sich die Vorhersage? Wählen sie zufällig eine Beobachtung aus dem Testdatensatz aus und sagen sie die mpg mittels jedes der 3 Modelle vorher. Wie unterscheiden sich die Vorhersagen der 3 Modelle?<jupyter_code># Hier kann Ihre Lösung stehen<jupyter_output><empty_output><jupyter_text>-------- Klassifikationsbäume<jupyter_code># Laden der Daten
wine = pd.read_csv(r"C:\Users\dormuth\Desktop\MSIND\02_Lehre\2021WiSe_Statistics_meets_Logistics\02_Übung\wine.csv")
print(wine.shape)
wine.head()

# Der Datensatz stammt von https://gist.github.com/tijptjik/9408623
# Definieren von X und y
X = wine.loc[:, wine.columns != 'Wine'] # Alle anderen Spalten ausser Wine
Y = wine['Wine']

# Aufteilen der Daten so, dass zufaellig 20% der Daten fuer die Testdaten zurück gelegt werden
X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2, random_state = 123) 
# Zwei Classifier mit verschiedener Tiefe
class_1 = DecisionTreeClassifier(max_depth = 2)
class_2 = DecisionTreeClassifier(max_depth = 5)

# Die Modelle anpassen
clf1 = class_1.fit(X_train, Y_train)
clf2 = class_2.fit(X_train, Y_train)
# Den Baum graphisch darstellen
tree.plot_tree(clf1, feature_names=X_train.columns,
                   class_names=["Wine 1", "Wine 2", "Wine 3"],
                   filled=True)
tree.plot_tree(clf2, feature_names=X_train.columns,
                   class_names=["Wine 1", "Wine 2", "Wine 3"],
                   filled=True)
# Die Bäume zur eigentlichen Vorhersage verwenden
pred1 = class_1.predict(X_test)
pred2 = class_2.predict(X_test)
# Bestimme die accuracy 
accuracy1 = sklearn.metrics.accuracy_score(pred1,Y_test)
print("The accuracy of the tree with depth 2: ", '%.2f'% (accuracy1*100),"%")
accuracy2 = sklearn.metrics.accuracy_score(pred2,Y_test)
print("The accuracy of the tree with depth 5: ", '%.2f'% (accuracy2*100),"%")<jupyter_output>The accuracy of the tree with depth 5:  91.67 %<jupyter_text>Zusätzlich können wir die accuracy hinsichtlich der Kreuzvalidierung betrachten. Dies hat den Vorteil, dass wir gleichzeitig verschiedene Test- und Trainingsdatensätze erzeugen, sodass die Genauigkeit weniger von der Wahl des seeds, also dem Zufall abhängt.<jupyter_code>from sklearn.model_selection import cross_val_score
scores1 = cross_val_score(class_1, X_test, Y_test, cv=6)
print("The corssvalidated accuracy of the tree with depth 2: %0.2f (+/- %0.2f)" % (scores1.mean()*100, scores1.std() * 200), "%")
scores2 = cross_val_score(class_2, X_test, Y_test, cv=6)
print("The corssvalidated accuracy of the tree with depth 5: %0.2f (+/- %0.2f)" % (scores2.mean()*100, scores2.std() * 200),"%")<jupyter_output>The corssvalidated accuracy of the tree with depth 5: 88.89 (+/- 31.43) %<jupyter_text>--------- AufgabeIn der Vorlesung haben sie gesehen, dass Accuracy kein gutes Maß für die Qualität eines Modelles ist, wenn die Gruppengrößen sehr ungleich sind. Überprüfen sie, wie sich die Gruppengrößen für diese Daten verhalten. Was könnten sie tun, falls die Gruppengrößen sehr unterschiedlich sind?Wenn wir die Accuracy mittels Kreuzvalidierung betrachten haben wir auch Intervalle angegeben, warum könnte die Accuracy so großen Schwankungen unterliegen?<jupyter_code># Hier kann Ihre Lösung stehen<jupyter_output><empty_output><jupyter_text>-------------- Random ForestRandom forest ist eine Ensemble-Lernmethode für Klassifikations- und Regressionsmodelle. Dabei werden mehrere Entscheidungsbäume konstruiert, welche dann kombiniert werden um die Qualität der Entscheidung zu verbessern. Die einzelnen Bäume werden nach einem Zufallsprinzip unkorreliert erstellt. Jeder dieser Bäum trifft wie im Beispiel zuvor individuelle Entscheidungen. Diese werden dann zu einer globalen Entscheidung zusammengefasst. Die Kombination der einzelnen Bäume beruht auf dem sogenannten Bagging, die Entscheidungen der einzelnen Bäume gehen also mit einer vorgegebenen Gewichtung ein.<jupyter_code># Importiere die RF Funktion
from sklearn.ensemble import RandomForestClassifier#
# Wir verwenden den gleichen Datensatz wie zuvor, mal sehen, ob wir die accuracy noch weiter verbessern können
class_rf = RandomForestClassifier(n_estimators = 100, # Die Anzahl Bäume für einen Wald
                                  max_depth=3, # Maximale Tiefe jedes Baumes
                                  criterion = "gini", # Funktion zur Beurteilung der Qualität eines Splits
                                  max_features="auto" # Das bedeutet die Anzahl Features die für 
                                                      # einen Split berücksichtigt wird ist sqrt(n_features)
                                 ) 

class_rf.fit(X_train,Y_train)
pred_rf = class_rf.predict(X_test)
accuracy_rf = sklearn.metrics.accuracy_score(pred_rf,Y_test)
print("The accuracy of the random forest approach: ", '%.2f'% (accuracy_rf*100),"%")<jupyter_output>The accuracy of the random forest approach:  100.00 %<jupyter_text>Mit einer Accuracy von 100% scheint unser Modell hier perfekte Vorhersagen zu treffen. Das kommt sehr selten vor. Sollte ihr Klassifikationsmodell eine Accuracy im Bereich von 90% haben handelt es sich bereits um ein sehr gutes Modell. ------------------ AufgabeNachdem sie für die Daten bereits betrachtet haben ob die Gruppenaufteilung gleichmäßig ist, finden sie für die Funktion RandomForestClassifier eine Einstellung, die es ermöglicht den Algorithmus daran anzupassen? https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html<jupyter_code># Hier kann Ihre Lösung stehen<jupyter_output><empty_output><jupyter_text>-------------------- XGBoostXGBoost basiert wie die anderen Methoden dieses Abschnitts auch auf einem Entscheidungsbaum. Da es sich um den Zusammenschluss mehrere Bäume handelt gehört auch XGBoost zu den Ensemble-Algorithmen für maschinelles Lernen. Der Name XGBoost ist von den Begriffen e**X**treme **G**radient **Boost**ing abgeleitet. Bei Vorhersageproblemen mit unstrukturierten Daten (Bilder, Text usw.) performen neuronale Netze oft am besten. Im Falle kleinerer und strukturierter Datensätze sind die baumbasierten Ansätze oft performanter. Einer der kritischen Punkte bei der Verwendung von XGBoost ist die Wahl der Hyperparameter hier eine kleine Auswahl der wichtigsten im Paket xgboost in Python:- *objective*: Definiert das Lernziel (default = reg:squarederror)- *learning_rate*: Lernrate (default = 0.3)- *max_depth*: Maximale Tiefe der Bäume (default = 6)- *n_estimator*: Anzahl Bäume (default = 100)<jupyter_code>X = auto.drop(['mpg', 'car name'], axis=1) # Alle anderen Spalten ausser mpg und car name
# Regressionsbaeume funktionieren nicht mit kategoriellen Variablen dieser Art, 
# entweder man muss sie codieren oder lässt sie außenvor
Y = auto['mpg']
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=234)
xg_reg = xgb.XGBRegressor(learning_rate = 0.1, max_depth = 5, n_estimators = 10)
xg_reg.fit(X_train,y_train)

preds = xg_reg.predict(X_test)
mse = mean_squared_error(y_test, preds)
print("MSE: %f" % (mse))<jupyter_output>MSE: 103.732598<jupyter_text>Der MSE des XGBoost Modells zeigt, dass eine komplizierte Methode nicht unbedingt zu besseren Ergebnissen führen muss. Komplexere Methoden bieten auch mehr Spielraum für eine nicht so gute Wahl der Hyperparameter. Deshalb ist es sinnvoll auch Hyperparameter sinnvoll zu tunen. Hier wäre es zum Beispiel möglich gesewen  --------------- AufgabenVersuchen sie durch Hyperparametertuning oder die Verwendung anderer Parameter den MSE des XGBRegressors zu verbessern. Informationen zu der Funktion und den möglichen Parametern finden sie unter:https://xgboost.readthedocs.io/en/latest/parameter.html<jupyter_code># Hier kann Ihre Lösung stehen<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08261225976864923, 'fraction_numerical': 0.017852263411968303, 'mean_word_length': 5.046255506607929, 'pattern_counts': {'":': 0, '<': 36, '<?xml version=': 0, '>': 36, 'https://': 4, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '578952', 'license': 'MIT', 'n_tokens_mistral': 3861, 'n_tokens_neox': 3757, 'n_words': 1125, 'path': 'prep-material-moodle/Python_trees.ipynb', 'repo_name': 'luiul/statistics-meets-logistics', 'size': '10979'}