Machine Learning – Grundlagen und Supervised Learning

Fach: Data Science & Artificial Intelligence
Schulstufe: 12. Schulstufe – HTL Informatik
Voraussetzungen: Python, C, JavaScript, HTML/CSS
Autor: HTL Pinkafeld – IF/IT

1. Was ist Machine Learning?

Machine Learning (ML) ist ein Teilgebiet der Künstlichen Intelligenz (KI). Anstatt einem Computer explizite Regeln zu programmieren, lernt er aus Daten, Muster zu erkennen und Entscheidungen zu treffen.

Klassische Programmierung vs. Machine Learning

Anwendungsbeispiele im Alltag

• Spam-Filter: E-Mails werden automatisch als Spam erkannt
• Bilderkennug: Gesichtserkennung auf dem Smartphone
• Empfehlungssysteme: Netflix schlägt Serien vor, die dir gefallen könnten
• Sprachassistenten: Siri, Alexa, Google Assistant verstehen natürliche Sprache
• Medizin: Erkennung von Tumoren auf Röntgenbildern

💡 Kernidee: Machine Learning ist kein Zauberei – es ist Statistik und Optimierung auf großen Datenmengen.

2. Arten des Maschinellen Lernens

Es gibt drei grundlegende Lernparadigmen:

2.1 Supervised Learning (Überwachtes Lernen)

Das Modell lernt aus gelabelten Daten – jedes Trainingsbeispiel hat eine bekannte Antwort (Label).

Eingabe (Feature):  Wohnfläche, Zimmeranzahl, Lage
Ausgabe (Label):    Preis der Wohnung

→ Das Modell lernt die Abbildung f(X) → y

Typische Aufgaben:

• Klassifikation: Eingabe einer Kategorie zuordnen (z.B. Spam / kein Spam)
• Regression: Einen kontinuierlichen Wert vorhersagen (z.B. Wohnungspreis)

2.2 Unsupervised Learning (Unüberwachtes Lernen)

Es gibt keine Labels. Das Modell sucht selbstständig nach Strukturen und Mustern in den Daten.

Typische Aufgaben:

• Clustering: Ähnliche Datenpunkte gruppieren (z.B. Kundensegmentierung)
• Dimensionsreduktion: Daten vereinfachen (z.B. PCA)

2.3 Reinforcement Learning (Bestärkendes Lernen)

Ein Agent lernt durch Versuch und Irrtum in einer Umgebung. Er erhält Belohnungen für gute Aktionen.

Beispiele: Schach-KI (AlphaZero), autonomes Fahren, Robotersteuerung

3. Der ML-Workflow

Jedes ML-Projekt folgt einem typischen Ablauf:

1. Problem definieren
        ↓
2. Daten sammeln & verstehen
        ↓
3. Daten aufbereiten (Preprocessing)
        ↓
4. Modell wählen & trainieren
        ↓
5. Modell evaluieren
        ↓
6. Modell optimieren (Hyperparameter-Tuning)
        ↓
7. Modell deployen & überwachen

Wichtige Bibliotheken in Python

4. Daten – das Herzstück des ML

4.1 Begriffe

• Feature (Merkmal): Eine Eingabevariable (z.B. Alter, Größe, Farbe)
• Label (Zielgröße): Der gesuchte Ausgabewert
• Datensatz (Dataset): Menge aller Beispiele
• Feature Matrix X: Tabelle mit allen Eingabemerkmalen (Zeilen = Beispiele, Spalten = Features)
• Label-Vektor y: Spalte mit den Zielwerten

4.2 Daten aufteilen

Damit wir beurteilen können, wie gut unser Modell auf unbekannte Daten reagiert, teilen wir den Datensatz auf:

In scikit-learn:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

⚠️ Wichtig: Testdaten dürfen das Modell niemals während des Trainings sehen!

4.3 Preprocessing – Daten vorbereiten

Rohdaten sind selten perfekt. Typische Probleme:

• Fehlende Werte: Zeilen mit NaN entfernen oder auffüllen
• Kategorische Variablen: Text in Zahlen umwandeln (One-Hot-Encoding)
• Skalierung: Features auf gleiche Größenordnung bringen (Normalisierung)

import pandas as pd
from sklearn.preprocessing import StandardScaler

df = pd.read_csv('daten.csv')

# Fehlende Werte auffüllen mit Mittelwert
df['alter'].fillna(df['alter'].mean(), inplace=True)

# Normalisierung (Mittelwert 0, Standardabweichung 1)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

5. Supervised Learning – Grundkonzepte

5.1 Klassifikation vs. Regression

Klassifikation:  "Welche Kategorie?"
  Eingabe → diskrete Klasse (0/1, Spam/kein Spam, Tier A/B/C)

Regression:      "Welcher Wert?"
  Eingabe → kontinuierlicher Wert (€, °C, kg)

5.2 Lernprozess

Beim Supervised Learning minimiert das Modell eine Verlustfunktion (Loss Function), die misst, wie groß der Fehler zwischen Vorhersage und tatsächlichem Label ist.

• Regression: Mittlerer quadratischer Fehler (MSE)
• Klassifikation: Cross-Entropy, Accuracy

6. Algorithmus: k-Nearest Neighbors (kNN)

6.1 Grundidee

„Sage mir, wer deine Nachbarn sind, und ich sage dir, wer du bist."

kNN klassifiziert einen neuen Datenpunkt anhand der k ähnlichsten Trainingsbeispiele. Die Klasse der Mehrheit der k Nachbarn wird als Vorhersage verwendet.

6.2 Distanzmaße

Die „Ähnlichkeit" wird durch eine Distanz gemessen. Am häufigsten: Euklidische Distanz:

d(A, B) = √( (x₁-x₂)² + (y₁-y₂)² )

6.3 Wahl von k

Faustregel: k = √n (wobei n = Anzahl Trainingsbeispiele), gerade Zahlen vermeiden bei binärer Klassifikation.

6.4 Praktisches Beispiel: Iris-Datensatz

Der Iris-Datensatz enthält 150 Blüten von 3 Schwertlilien-Arten mit je 4 Merkmalen (Kelch-/Kronblattlänge und -breite).

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 1. Daten laden
iris = load_iris()
X, y = iris.data, iris.target

# 2. Aufteilen
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Modell erstellen und trainieren
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

# 4. Vorhersagen
y_pred = model.predict(X_test)

# 5. Bewerten
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2%}")

6.5 Stärken und Schwächen

7. Algorithmus: Decision Tree

7.1 Grundidee

Ein Entscheidungsbaum teilt die Daten rekursiv anhand von Bedingungen (Splits) auf, bis eindeutige Klassen entstehen. Jeder innere Knoten ist eine Frage, jedes Blatt eine Vorhersage.

Beispiel: Werde ich Tennis spielen?

        Wetter?
       /       \
   sonnig     Regen
     |           |
  Luftfeuchtigkeit?   NEIN
    /        \
  <70%      ≥70%
   JA        NEIN

7.2 Splitting-Kriterien

Wie wählt der Algorithmus den besten Split?

• Gini-Impurity: Maß für Unreinheit eines Knotens (0 = rein, 0.5 = maximal gemischt)
• Informationsgewinn (Entropy): Basiert auf dem Konzept der Entropie aus der Informationstheorie

Gini(t) = 1 - Σ p(i|t)²

7.3 Praktisches Beispiel

from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# Modell erstellen (max_depth begrenzt die Tiefe → verhindert Overfitting)
dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(X_train, y_train)

# Baum als Text ausgeben
print(export_text(dt, feature_names=iris.feature_names))

print(f"Accuracy: {dt.score(X_test, y_test):.2%}")

7.4 Feature Importance

Ein großer Vorteil von Decision Trees: Interpretierbarkeit. Man sieht, welche Features wichtig sind.

import pandas as pd

importance = pd.Series(
    dt.feature_importances_,
    index=iris.feature_names
).sort_values(ascending=False)

print(importance)

7.5 Stärken und Schwächen

💡 Hinweis: In der Praxis verwendet man oft Random Forests – viele Bäume kombiniert, die gemeinsam bessere Ergebnisse liefern.

8. Algorithmus: Lineare Regression

8.1 Grundidee

Lineare Regression modelliert den Zusammenhang zwischen einem oder mehreren Features und einer kontinuierlichen Zielvariable durch eine Gerade (oder Hyperebene).

Einfache lineare Regression (1 Feature):

ŷ = w₀ + w₁ · x

Multiple lineare Regression (mehrere Features):

ŷ = w₀ + w₁·x₁ + w₂·x₂ + ... + wₙ·xₙ

Die Parameter w (Gewichte/Koeffizienten) werden so gelernt, dass der mittlere quadratische Fehler (MSE) minimiert wird:

MSE = (1/n) · Σ (yᵢ - ŷᵢ)²

8.2 Praktisches Beispiel: Wohnungspreise

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Synthetische Daten: Wohnfläche (m²) → Preis (€1000)
np.random.seed(42)
flaeche = np.random.uniform(40, 150, 100).reshape(-1, 1)
preis = 1.5 * flaeche.flatten() + np.random.normal(0, 15, 100) + 50

# Modell trainieren
model = LinearRegression()
model.fit(flaeche, preis)

# Koeffizienten
print(f"Steigung (w₁): {model.coef_[0]:.2f}")
print(f"y-Achsenabschnitt (w₀): {model.intercept_:.2f}")
print(f"R²-Score: {r2_score(preis, model.predict(flaeche)):.3f}")

# Visualisierung
plt.scatter(flaeche, preis, alpha=0.5, label='Datenpunkte')
plt.plot(flaeche, model.predict(flaeche), color='red', label='Regressionsgerade')
plt.xlabel('Wohnfläche (m²)')
plt.ylabel('Preis (€1000)')
plt.legend()
plt.title('Lineare Regression: Wohnungspreise')
plt.show()

8.3 Der R²-Score

Der R²-Score (Bestimmtheitsmaß) gibt an, wie viel Varianz der Daten durch das Modell erklärt wird:

• R² = 1.0 → perfektes Modell
• R² = 0.0 → Modell ist so gut wie der Mittelwert
• R² < 0 → Modell schlechter als der Mittelwert

8.4 Stärken und Schwächen

9. Algorithmus: Logistische Regression

9.1 Grundidee

Trotz des Namens ist die logistische Regression ein Klassifikationsalgorithmus. Sie sagt die Wahrscheinlichkeit voraus, dass ein Datenpunkt einer Klasse angehört.

Die Ausgabe der linearen Regression (ein beliebiger Wert) wird durch die Sigmoid-Funktion auf den Bereich [0, 1] abgebildet:

σ(z) = 1 / (1 + e⁻ᶻ)

Ab einem Schwellenwert (meist 0.5) wird klassifiziert:

• P(y=1) ≥ 0.5 → Klasse 1
• P(y=1) < 0.5 → Klasse 0

9.2 Praktisches Beispiel: Titanic-Datensatz

import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Vereinfachter Titanic-Datensatz
data = {
    'alter': [22, 38, 26, 35, 28, 54, 2, 27, 14, 4],
    'klasse': [3, 1, 3, 1, 3, 1, 3, 3, 2, 3],
    'geschlecht': [0, 1, 1, 1, 0, 0, 0, 1, 1, 1],  # 0=männlich, 1=weiblich
    'ueberlebt': [0, 1, 1, 1, 0, 0, 0, 0, 1, 1]
}
df = pd.DataFrame(data)

X = df[['alter', 'klasse', 'geschlecht']]
y = df['ueberlebt']

# Auf wenige Daten: kein train/test-split für dieses Beispiel
model = LogisticRegression()
model.fit(X, y)

# Vorhersage für eine neue Person
neue_person = [[30, 2, 1]]  # 30 Jahre, 2. Klasse, weiblich
prob = model.predict_proba(neue_person)[0]
print(f"Überlebenswahrscheinlichkeit: {prob[1]:.1%}")

9.3 Entscheidungsgrenze

Die logistische Regression lernt eine lineare Entscheidungsgrenze im Feature-Raum. Datenpunkte auf einer Seite werden als Klasse 0, auf der anderen als Klasse 1 klassifiziert.

9.4 Stärken und Schwächen

10. Modellbewertung und Metriken

10.1 Klassifikationsmetriken

Confusion Matrix

Wichtige Metriken

Accuracy  = (TP + TN) / (TP + TN + FP + FN)
Precision = TP / (TP + FP)
Recall    = TP / (TP + FN)
F1-Score  = 2 · (Precision · Recall) / (Precision + Recall)

Wann welche Metrik?

• Accuracy: Ausgeglichene Klassen, allgemeine Beurteilung
• Precision: Wenn False Positives teuer sind (z.B. Spam-Filter: seriöse E-Mails nicht löschen)
• Recall: Wenn False Negatives teuer sind (z.B. Krebsdiagnose: keine Kranken übersehen)
• F1-Score: Ausgewogenes Maß zwischen Precision und Recall

from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Nach dem Predict...
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Confusion Matrix visualisieren
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=iris.target_names,
            yticklabels=iris.target_names)
plt.title('Confusion Matrix')
plt.show()

10.2 Regressionsmetriken

10.3 Cross-Validation

Um das Modell robuster zu evaluieren, verwendet man k-fold Cross-Validation: Die Daten werden in k Teile geteilt, das Modell k-mal trainiert und evaluiert.

from sklearn.model_selection import cross_val_score

scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"CV Accuracy: {scores.mean():.2%} ± {scores.std():.2%}")

11. Overfitting und Underfitting

11.1 Das Bias-Variance-Tradeoff

Ein zentrales Problem im Machine Learning:

Underfitting:           Gutes Modell:          Overfitting:
Zu einfach              Ausgewogen             Zu komplex

Training: schlecht      Training: gut          Training: perfekt
Test:     schlecht      Test:     gut          Test:     schlecht

Hoher Bias              Balance                Hohe Varianz

11.2 Ursachen und Lösungen

11.3 Regularisierung

Regularisierung bestraft komplexe Modelle, um Overfitting zu reduzieren:

• L1 (Lasso): Setzt unwichtige Koeffizienten auf 0 → Feature Selection
• L2 (Ridge): Verkleinert alle Koeffizienten gleichmäßig

from sklearn.linear_model import Ridge, Lasso

ridge = Ridge(alpha=1.0)  # alpha = Regularisierungsstärke
lasso = Lasso(alpha=0.1)

11.4 Lernkurven

Lernkurven zeigen, ob ein Modell unter- oder überangepasst ist:

from sklearn.model_selection import learning_curve
import numpy as np
import matplotlib.pyplot as plt

train_sizes, train_scores, val_scores = learning_curve(
    model, X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)

plt.plot(train_sizes, train_scores.mean(axis=1), label='Training')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validierung')
plt.xlabel('Trainingsgröße')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Lernkurven')
plt.show()

12. Zusammenfassung und Ausblick

Überblick der behandelten Algorithmen

Wahl des richtigen Algorithmus

Ist das Zielmerkmal kontinuierlich?
    → JA: Regression (Lineare Regression, ...)
    → NEIN: Klassifikation

Wie viele Daten sind vorhanden?
    → Wenig Daten: kNN, Logistische Regression
    → Viele Daten: Decision Trees, Random Forest, Neural Networks

Muss das Modell interpretierbar sein?
    → JA: Decision Tree, Lineare/Logistische Regression
    → NEIN: Alle Algorithmen möglich

Ausblick: Nächste Themen

• Ensemble-Methoden: Random Forest, Gradient Boosting (XGBoost)
• Unsupervised Learning: K-Means Clustering, PCA
• Deep Learning: Neuronale Netze, CNNs, RNNs
• Natural Language Processing: Textklassifikation, Transformer-Modelle
• MLOps: Modelle in Produktion bringen und überwachen

Anhang: Schnellreferenz scikit-learn

# Einheitliches API-Muster für alle scikit-learn Modelle:
from sklearn.XXX import YYYModel

model = YYYModel(hyperparameter1=wert1)   # 1. Erstellen
model.fit(X_train, y_train)               # 2. Trainieren
y_pred = model.predict(X_test)            # 3. Vorhersagen
score = model.score(X_test, y_test)       # 4. Bewerten

Wichtige Importe

# Daten
from sklearn.datasets import load_iris, load_diabetes, make_classification
from sklearn.model_selection import train_test_split, cross_val_score

# Preprocessing
from sklearn.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder
from sklearn.impute import SimpleImputer

# Algorithmen
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
from sklearn.linear_model import LinearRegression, LogisticRegression, Ridge, Lasso

# Metriken
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    confusion_matrix, classification_report,
    mean_squared_error, mean_absolute_error, r2_score
)

HTL Pinkafeld – IF/IT | Data Science & AI | 12. Schulstufe