<jupyter_start><jupyter_text>1. VorbereitungDer letzte Schritt, der uns noch fehlt, ist das *Trainieren* eines Modells. Bislang sind wir stets von fertigen Modellen ausgegangen, die uns aus zum Teil unbekannter Quelle zugekommen sind. Wir sind davon ausgegangen, dass diese Modelle angemessen funktionieren und habe diese evaluiert und zur Vorhersage genutzt.Wir beschäftigen uns wieder mit den Daten der vorherigen Lektionen, das heißt `house_location_data.csv` und `house_location_new_data_with_labels.csv`.<jupyter_code># TODO: Importieren der Daten mit Pandas
import pandas as pd

data = pd.read_csv("../data/house_location/house_location_data.csv")
data_new = pd.read_csv("../data/house_location/house_location_new_data_with_labels.csv")
data
data_new<jupyter_output><empty_output><jupyter_text>2. Modell trainierenZuvor haben wir ein fertiges Modell benutzt, nun wollen wir dieses selbstständig *trainieren*, das heißt an die Daten anpassen, sodass dieses hoffentlich korrekte Vorhersagen trifft. 2.1. Dummy ModellWir trainieren zunächst ein Modell auf Grundlage einer äußerst simplen Annahme: wir identifizieren einfach dasjenige Feature im Datensatz, das sich zwischen den Klassen (*New York* vs *San Francisco*) am stärksten unterscheidet. Für dieses Feature bestimmen wir einen Schwellenwert anhand dessen wir jeweils entscheiden wollen, ob ein Datenpunkt der Klasse *New York* oder *San Francisco* angehört.<jupyter_code># TODO: Dummy-Modell trainieren
data_in_sf = data.loc[data.in_sf.values == 1, :]
data_in_ny = data.loc[data.in_sf.values == 0, :]
data_in_ny
data_in_sf
feature = "elevation"

import matplotlib.pyplot as plt

ax = data_in_sf.hist(feature, figsize=(10, 8), bins=50, alpha=0.7, label="San Francisco")
data_in_ny.hist(feature, bins=50, ax=ax, alpha=0.7, label="New York")
plt.legend()
average_elevation_sf = data_in_sf[feature].mean()
average_elevation_ny = data_in_ny[feature].mean()

print(average_elevation_sf)
print(average_elevation_ny)
decision_value = (average_elevation_ny + average_elevation_sf) / 2
decision_value<jupyter_output><empty_output><jupyter_text>2.2. Scikit-LearnIm vorherigen Teil haben wir ein sehr einfaches Modell sebst programmiert. Trotz dessen Schlichtheit erfüllt dieses alle Kriterien eines Machine Learning Modells.Wir können aber natürlich einen Schritt weiter gehen. In den allermeisten Fällen programmieren wir Modelle nicht selbst, sondern greifen auf eine Bibliothek zurück. Diese heißt **Scikit-Learn** und stellt bereits die allermeisten Arten von Modellen zur Verfügung, die uns interessieren (alle außer Neuronale Netzwerke).Jedes dieser möglichen Modelle funktioniert anders und basiert auf anderen theoretischen Annahmen. Wir werden viele dieser Modelle ausführlich kennenlernen und deren Vorteile, Nachteile und Anwendungsmöglichkeiten diskutieren. Für den Moment benutzen wir schlicht ein bereits bekanntes Modell - den `DecisionTreeClassifier`.<jupyter_code># TODO: DecisionTreeClassifier aus Scikit-Learn importieren
# TODO: DecisionTreeClassifier auf den Daten trainieren
from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()

# Features
X = data.drop(columns=["id", "in_sf"])
# Labels
y = data.in_sf

# Fit
# - X muss ein array-like mit 2 Achsen (Zeilen und Spalten) sein
# - y muss ein array-like mit 1 Achse sein, quasi ein Vektor,
#   gleiche Länge wie die Anzahl der Zeilen in X
model.fit(X, y)<jupyter_output><empty_output><jupyter_text>3. Vorhersagen treffenWir treffen eine Vorhersage auf den Daten des Datensatzes `house_location_new_data_with_labels.csv`.  3.1. Dummy-Modell<jupyter_code># TODO: Vorhersagen treffen
in_sf_predicted = (data_new[feature].values > decision_value).astype(int)
in_sf_predicted<jupyter_output><empty_output><jupyter_text>3.2. Scikit-Learn<jupyter_code>X_new = data_new.drop(columns=["id", "in_sf"])

in_sf_predicted_sklearn = model.predict(X_new)
in_sf_predicted_sklearn<jupyter_output><empty_output><jupyter_text>4. Modell evaluierenDa wir wiederum für alle Datenpunkte des Datensatzes `house_location_new_data_with_labels.csv` die richtige Antwort kennen, können wir die Vorhersage des Modells mit diesen richtigen Antworten abgleichen und so eine Einschätzung gewinnen, ob das Modell funktioniert. Die dafür verwendete Metrik ist wieder die *Genaugikeit* oder *Accuracy* oder *Korrekte-Klassifikations-Rate* und soll den Prozentsatz erfassen, zu dem das Modell korrekte Vorhersagen liefert.<jupyter_code># TODO: Vorhersage mit der richtigen Antwort abgleichen
in_sf_true = data_new.in_sf.values
in_sf_true
accuracy = (in_sf_predicted == in_sf_true).sum() / len(in_sf_true)
accuracy
accuracy_sklearn = (in_sf_predicted_sklearn == in_sf_true).sum() / len(in_sf_true)
accuracy_sklearn<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07339642481598317, 'fraction_numerical': 0.005888538380651945, 'mean_word_length': 6.848184818481848, 'pattern_counts': {'":': 0, '<': 25, '<?xml version=': 0, '>': 26, 'https://': 0, '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': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '63447', 'license': 'MIT', 'n_tokens_mistral': 1661, 'n_tokens_neox': 1663, 'n_words': 466, 'path': '1_7_modelle_trainieren/Tutorial - Modelle trainieren - completed.ipynb', 'repo_name': 'layerwise/training', 'size': '4755'}