Warum Klassifikation?
Du unterscheidest Zahlenvorhersagen von Ja/Nein-Entscheidungen und spürst sofort, warum lineare Regression hier nicht reicht.
Alltagsszene
Stell dir vor, du arbeitest bei der Post. Vor dir landen Sendungen auf dem Tisch: Brief oder Paket? Du musst nicht den exakten Wert ausrechnen, sondern eine Kategorie vergeben. Genau so arbeitet ein Klassifikationsmodell.
ML-Sprache
Bei Regression ist die Zielvariable eine Zahl, etwa ein Hauspreis. Bei Klassifikation ist die Zielvariable eine Klasse, zum Beispiel Spam oder kein Spam. Für binäre Klassifikation gilt oft y ∈ {0, 1}.
Die logistische Regression sagt nicht direkt „Ja“ oder „Nein“, sondern zuerst eine Wahrscheinlichkeit für Klasse 1. Erst danach wird diese Wahrscheinlichkeit über einen Schwellenwert in eine Entscheidung übersetzt.
Code-Beispiel
# Zwei Probleme klar unterscheiden
temperature_tomorrow = 18.7 # Regression: Zahl vorhersagen
will_rain = 1 # Klassifikation: Klasse 0 oder 1
print("Regression:", temperature_tomorrow)
print("Klassifikation:", will_rain)Interaktion: Sortiere die Probleme
Ordne die Situationen der passenden Problemart zu. So spürst du sofort den Unterschied zwischen „Zahl schätzen“ und „Klasse entscheiden“.
🗣️ Übersetze den Output in Alltagssprache
Was ist gemessen? In unserem Fall keine freie Zahl, sondern eine Klassenentscheidung: etwa „Brief oder Paket“ beziehungsweise 0 oder 1.
So liest man den Wert: Eine 1 heißt in unserem Fall nicht „mehr“, sondern einfach: Das Modell ordnet den Fall der Zielklasse zu.
Was ist hier der schlimmste Fehler? Den Fall in die falsche Schublade zu legen, obwohl die eigentliche Aufgabe nur eine klare Kategorie war.
✅ Mini-Check (30 Sekunden)
- Was ist „positiv“ (=1) in deinem aktuellen Beispiel?
- Was wäre ein True Positive hier als ganzer Satz?
- Ab welcher Wahrscheinlichkeit würdest du aus einem Bauchgefühl eine harte Ja/Nein-Entscheidung machen?
Was nimmst du mit? Wenn du nur zwischen Klassen unterscheiden willst, ist eine saubere Wahrscheinlichkeit oft hilfreicher als eine freie Zahl.
Die Sigmoid-Funktion
Du verstehst, wie aus einem beliebigen Score eine Wahrscheinlichkeit zwischen 0 und 1 wird.
Alltagsszene
Ein normaler Lichtschalter kennt nur an oder aus. Ein Dimmer kennt viele Zwischenstufen. Die Sigmoid-Funktion ist der Dimmer des Modells: Sie übersetzt jeden Rohwert in eine Wahrscheinlichkeit zwischen 0 % und 100 %.
ML-Sprache
Das Modell berechnet zunächst einen Score t = b₀ + b₁x₁ + .... Dieser Score kann jede Zahl annehmen. Erst die Sigmoid-Funktion macht daraus eine sinnvolle Wahrscheinlichkeit.
\sigma(t) = \frac{1}{1 + e^{-t}}
Für sehr kleine Werte geht die Kurve gegen 0. Für sehr große Werte geht sie gegen 1. Bei t = 0 liegt sie genau bei 0,5.
Code-Beispiel aus dem Notebook
from scipy.special import expit
score = -1.2 # Rohwert des Modells
probability = expit(score) # Sigmoid macht daraus 0 bis 1
print(round(probability, 3)) # 0.231expit ist die Sigmoid-Funktion aus dem Notebook. Ein negativer Score führt zu einer kleinen Wahrscheinlichkeit.Interaktive Demo: Ziehe am Dimmer
🗣️ Übersetze die Zahl in Alltagssprache
Was ist gemessen? In unserem Fall die Wahrscheinlichkeit für Klasse 1, also für „Ja“ oder „rein“.
So liest man den Wert: Wenn hier zum Beispiel 0.731 steht, heißt das: In unserem Fall sieht das Modell etwa 73 % Wahrscheinlichkeit für Klasse 1.
Was ist hier der schlimmste Fehler? Eine mittlere Wahrscheinlichkeit wie eine sichere Wahrheit zu behandeln, obwohl das Modell noch deutlich unsicher ist.
✅ Mini-Check (30 Sekunden)
- Was ist „positiv“ (=1) in unserem Türsteher-Beispiel?
- Was bedeutet ein True Positive hier als ganzer Satz?
- Würdest du bei 0.52 schon „Ja“ sagen oder lieber einen strengeren Threshold setzen?
🏋️ Übung: Sigmoid-Werte prüfen
Übertrage die Sigmoid-Idee in ein minimales Python-Beispiel. Ergänze genau die eine Zeile, die den Score in eine Wahrscheinlichkeit umwandelt.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from math import exp
def sigmoid(t):
return # ??? DEINE LÖSUNG ???
score = 1.0
print(round(sigmoid(score), 3))💡 Tipp anzeigen
In Python schreibst du die Formel mit exp(-t), also zum Beispiel 1 / (1 + exp(-t)).
✅ Lösung anzeigen
from math import exp
def sigmoid(t):
return 1 / (1 + exp(-t))
score = 1.0
print(round(sigmoid(score), 3))Erwartete Ausgabe: 0.731
Was nimmst du mit? Die Sigmoid-Funktion ist keine Deko, sondern der entscheidende Schritt, der eine freie Rechenwelt in eine Wahrscheinlichkeitswelt übersetzt.
Entscheidungsgrenze
Du siehst geometrisch, wie aus Wahrscheinlichkeiten eine Ja/Nein-Grenze wird.
Alltagsszene
Stell dir einen Türsteher vor. Wenn sein Bauchgefühl mindestens 50 % sagt, darf jemand rein. Sonst nicht. Diese unsichtbare Linie zwischen „rein“ und „nicht rein“ ist die Entscheidungsgrenze.
ML-Sprache
Mit zwei Merkmalen ist die eine Gerade. Sie hängt nur von den Modellparametern ab, nicht von einer einzelnen Beobachtung. Die Grenze liegt also nicht fertig in den Daten, sondern entsteht erst durch die gelernten Gewichte.
b₀ + b₁x₁ + b₂x₂ = 0
Genau auf dieser Linie ist der Score null. Die Sigmoid-Funktion liefert dort 0,5. Damit liegt genau dort die Grenze zwischen beiden Klassen.
Code-Beispiel aus dem Notebook
# Wahrscheinlichkeiten statt nur harter Klassen
proba = lr.predict_proba(X_test)[:, 1]
# Ab 0.5 wird Klasse 1 vorhergesagt
y_pred = (proba >= 0.5).astype(int)
print(proba[:3])
print(y_pred[:3])predict_proba liefert die Wahrscheinlichkeit für Klasse 1. Erst der gewählte Threshold macht daraus eine 0 oder 1. Wichtig: Das Modell selbst bleibt dabei gleich, nur die Entscheidungsregel danach ändert sich.Interaktive Demo: Grenze verschieben
Bewege Achsenabschnitt und Steigungen. Du siehst sofort, wie viele Beispiele auf der falschen Seite landen.
🗣️ Übersetze Grenze und Klassen in Alltagssprache
Was ist gemessen? In unserem Fall, auf welcher Seite der Entscheidungsgrenze ein Punkt landet und damit, ob er Klasse 0 oder 1 bekommt.
So liest man den Wert: Alles auf der „Ja“-Seite der Grenze wird in unserem Fall zu Klasse 1. Alles auf der anderen Seite bleibt Klasse 0.
Was ist hier der schlimmste Fehler? Eine Person auf die falsche Seite zu schieben, etwa jemanden hereinzulassen, der in unserem Fall nicht hereinsollte.
✅ Mini-Check (30 Sekunden)
- Was ist „positiv“ (=1) in diesem Grenz-Beispiel?
- Was wäre ein True Positive hier als ganzer Satz?
- Würdest du den Threshold strenger machen, wenn dir falsches Hereinlassen wichtiger erscheint als falsches Abweisen?
🏋️ Übung: Threshold anwenden
Im Notebook taucht predict_proba auf. Ergänze die Zeile, die aus Wahrscheinlichkeiten mit einem Threshold von 0,5 harte Klassen macht.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
import numpy as np
proba = np.array([0.18, 0.52, 0.77, 0.41])
y_pred = # ??? DEINE LÖSUNG ???
print(y_pred.tolist())💡 Tipp anzeigen
Alles ab 0,5 wird zu Klasse 1, alles darunter zu Klasse 0.
✅ Lösung anzeigen
import numpy as np
proba = np.array([0.18, 0.52, 0.77, 0.41])
y_pred = (proba >= 0.5).astype(int)
print(y_pred.tolist())Erwartete Ausgabe: [0, 1, 1, 0]
Was nimmst du mit? Die Grenze liegt nicht „in den Daten“, sondern im Modell. Ein anderer Threshold oder andere Gewichte verschieben sie sofort.
Kostenfunktion: Log-Loss
Du verstehst, warum falsche Selbstsicherheit härter bestraft wird als vorsichtige Unsicherheit.
Alltagsszene
Ein Wettermoderator sagt mit 99 % Sicherheit Sonne voraus. Dann regnet es. Das ist peinlicher als eine ehrliche 55:45-Vorhersage. Genau dieses Verhalten modelliert Log-Loss.
ML-Sprache
Bei der logistischen Regression wollen wir Wahrscheinlichkeiten lernen, die zu den echten Klassen passen. Ein Modell soll besonders dann hohe Strafen bekommen, wenn es mit großer Sicherheit falsch liegt. Log-Loss bewertet also nicht nur richtig oder falsch, sondern auch, wie selbstsicher die Vorhersage war.
J(b) = -\frac{1}{n}\sum [y_i \ln(p_i) + (1-y_i)\ln(1-p_i)]
Für y = 1 zählt nur -ln(p). Für y = 0 zählt nur -ln(1-p). Wenn die falsche Wahrscheinlichkeit extrem wird, explodiert der Verlust.
Code-Beispiel
import numpy as np
p = 0.91 # Modell ist sehr sicher
y = 1 # echte Klasse
log_loss = -(y * np.log(p) + (1 - y) * np.log(1 - p))
print(round(log_loss, 3))Interaktive Demo: Strafzettel für falsche Sicherheit
🗣️ Übersetze die Zahl in Alltagssprache
Was ist gemessen? In unserem Fall, wie teuer eine Wahrscheinlichkeitsaussage war, nachdem man sie mit der echten Klasse vergleicht.
So liest man den Wert: Ein kleiner Log-Loss heißt: Das Modell lag passend und nicht peinlich selbstsicher daneben. Ein großer Log-Loss heißt: sicher falsch war hier besonders schlimm.
Was ist hier der schlimmste Fehler? Mit fast voller Sicherheit die falsche Klasse vorherzusagen.
✅ Mini-Check (30 Sekunden)
- Was ist „positiv“ (=1) in deinem aktuellen Beispiel?
- Was wäre ein True Positive hier als ganzer Satz?
- Würdest du bei sehr unsicherem p lieber einen vorsichtigeren Threshold wählen als bei p nahe 0.99?
Was nimmst du mit? Nicht jeder Fehler ist gleich schlimm. Log-Loss gewichtet vor allem die gefährliche Mischung aus „sicher“ und „falsch“.
Training mit Gradient Descent
Du siehst live, wie Gewichte angepasst werden, damit der Log-Loss sinkt und die Sigmoid-Kurve besser zu den Daten passt.
Alltagsszene
Stell dir vor, du wanderst im Nebel bergab. Du siehst nicht das ganze Tal, aber du spürst in jeder Runde die lokale Steigung. Genau so justiert Gradient Descent die Parameter des Modells.
ML-Sprache
Für logistische Regression gibt es keine bequeme geschlossene OLS-Lösung. Deshalb wird der Log-Loss Schritt für Schritt minimiert, bis die Gewichte eine gute Trennkurve ergeben.
b_j := b_j - \alpha \cdot \frac{\partial J(b)}{\partial b_j}
Die Lernrate \alpha steuert, wie groß ein Schritt ist. Zu klein ist langsam, zu groß kann über das Ziel hinausschießen.
Code-Beispiel
score = b0 + b1 * x
p = 1 / (1 + np.exp(-score))
gradient_b1 = (p - y) * x
b1 = b1 - alpha * gradient_b1Interaktive Demo: Bergab auf dem Log-Loss-Berg
🗣️ Übersetze den Verlauf in Alltagssprache
Was ist gemessen? In unserem Fall, wie sich der Log-Loss über viele kleine Trainingsschritte verändert.
So liest man den Wert: Wenn der Log-Loss sinkt, lernt das Modell gerade so, dass seine Wahrscheinlichkeiten besser zu den echten Klassen passen.
Was ist hier der schlimmste Fehler? Nicht nur ein einzelner Fehlgriff, sondern ein Training, das gar nicht besser wird oder wegen zu großer Schritte hin und her springt.
✅ Mini-Check (30 Sekunden)
- Was ist hier überhaupt „besser“: ein höherer oder ein niedrigerer Loss?
- Was wäre ein praktischer Satz für einen True Positive im Trainingsdatensatz?
- Würdest du zuerst die Lernrate oder den Threshold anfassen, wenn der Loss kaum sinkt?
Was nimmst du mit? Das Modell wird nicht magisch „klug“, sondern tastet sich in kleinen Updates zu besseren Gewichten vor.
Der sklearn-Workflow
Du verbindest Daten, Modell, Vorhersage und Konfusionsmatrix zu einem vollständigen Praxisablauf.
Alltagsszene
Eine Hochschule bewertet Bewerbungen. GMAT, GPA und Berufserfahrung fließen in die Frage ein: Zulassen oder ablehnen? Das ist ein typisches binäres Klassifikationsproblem.
ML-Sprache
Im Workflow trennst du zuerst Merkmale und Zielvariable, teilst in Train und Test, trainierst das Modell und prüfst anschließend die Ergebnisse mit einer Konfusionsmatrix. Merkmale sind hier die Eingangsspalten in X, die Zielvariable ist die Ja/Nein-Spalte in y.
Daten → X und y → train_test_split → LogisticRegression().fit() → predict() → confusion_matrix()
Code-Beispiel aus dem Notebook
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix
df = pd.DataFrame({
"gmat": [520, 540, 560, 580, 600, 620, 640, 660, 680, 700, 720, 740, 530, 610, 690, 750],
"gpa": [2.2, 2.4, 2.5, 2.7, 2.9, 3.0, 3.1, 3.3, 3.4, 3.6, 3.7, 3.9, 2.3, 3.0, 3.5, 4.0],
"work_experience": [0, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 0, 2, 3, 5],
"admitted": [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1]
})
X = df[["gmat", "gpa", "work_experience"]]
y = df["admitted"]
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42, stratify=y
)
model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(confusion_matrix(y_test, y_pred, labels=[0, 1]))fit() lernt die Gewichte auf dem Trainingssatz, predict() wendet sie auf neue Zeilen an.Interaktive Demo: Workflow zum Anklicken
Gehe den Ablauf in der richtigen Reihenfolge durch. Nach dem letzten Schritt baut sich die Konfusionsmatrix auf.
Konfusionsmatrix
| Vorhersage 0 | Vorhersage 1 | |
|---|---|---|
| Tatsächlich 0 | - | - |
| Tatsächlich 1 | - | - |
🗣️ Übersetze die Matrix in Alltagssprache
Was ist gemessen? In unserem Fall, wie oft Bewerbungen korrekt zugelassen oder abgelehnt wurden und welche Fehlerarten dabei entstehen.
So liest man den Wert: Die Konfusionsmatrix zeigt in unserem Fall, wie viele echte Zulassungen das Modell gefunden hat und wo es zu streng oder zu locker war.
Was ist hier der schlimmste Fehler? Das hängt am Fall. Für die Hochschule kann ein fälschlich abgelehnter guter Bewerber genauso kritisch sein wie eine unpassende Zulassung.
✅ Mini-Check (30 Sekunden)
- Was ist „positiv“ (=1) in unserem Zulassungs-Beispiel?
- Was bedeutet ein True Positive hier als ganzer Satz?
- Würdest du den Threshold eher senken oder erhöhen, wenn du lieber mehr passende Kandidaten zulassen möchtest?
🏋️ Übung: Kompletter Workflow
Hier ist der sklearn-Ablauf aus dem Notebook stark vereinfacht. Ergänze die Modellzeile so, dass Training und Vorhersage möglich werden.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
import pandas as pd
from sklearn.linear_model import LogisticRegression
df = pd.DataFrame({
"gmat": [580, 620, 690, 710, 520, 640],
"gpa": [2.8, 3.1, 3.6, 3.8, 2.4, 3.2],
"work_experience": [1, 2, 4, 5, 0, 3],
"admitted": [0, 0, 1, 1, 0, 1]
})
X = df[["gmat", "gpa", "work_experience"]]
y = df["admitted"]
model = # ??? DEINE LÖSUNG ???
model.fit(X, y)
print(model.predict(X).tolist())💡 Tipp anzeigen
Das Modell stammt direkt aus sklearn und trägt denselben Namen wie das Kapitel.
✅ Lösung anzeigen
import pandas as pd
from sklearn.linear_model import LogisticRegression
df = pd.DataFrame({
"gmat": [580, 620, 690, 710, 520, 640],
"gpa": [2.8, 3.1, 3.6, 3.8, 2.4, 3.2],
"work_experience": [1, 2, 4, 5, 0, 3],
"admitted": [0, 0, 1, 1, 0, 1]
})
X = df[["gmat", "gpa", "work_experience"]]
y = df["admitted"]
model = LogisticRegression()
model.fit(X, y)
print(model.predict(X).tolist())Erwartete Ausgabe: [0, 0, 1, 1, 0, 1]
Was nimmst du mit? Ein gutes Verständnis von X, y und der Trennung zwischen Training und Test ist oft wichtiger als tausend Parameteroptionen.
Threshold und Metriken
Du lernst, dass der Threshold ein Geschäftsentscheid ist und Metriken immer vom Kontext abhängen.
Alltagsszene
Ein Rauchmelder kann empfindlich oder streng eingestellt werden. Bei einem sehr niedrigen Threshold löst er oft Alarm aus. Bei einem hohen Threshold übersieht er eher echte Brände.
ML-Sprache
Threshold senken erhöht meist den Recall, weil mehr echte Positivfälle gefunden werden. Dafür steigen oft die False Positives. Threshold erhöhen macht häufig das Gegenteil.
ist kein Naturgesetz. Er ist eine Entscheidung darüber, welche Art von Fehler im jeweiligen Geschäftsfall teurer ist.
Code-Beispiel
proba = model.predict_proba(X_test)[:, 1]
threshold = 0.30
y_pred = (proba >= threshold).astype(int)
print(confusion_matrix(y_test, y_pred))Interaktive Demo: Alarmanlage justieren
Konfusionsmatrix
| Vorhersage 0 | Vorhersage 1 | |
|---|---|---|
| Tatsächlich 0 | 0 | 0 |
| Tatsächlich 1 | 0 | 0 |
🗣️ Übersetze die Kennzahlen in Alltagssprache
Was ist gemessen? In unserem Fall, wie sich Precision, Recall, F1 und Accuracy verändern, wenn du den Alarm-Regler verschiebst.
So liest man den Wert: Precision heißt: „Wenn das Modell 1 sagt, stimmt das in X % der Fälle.“ Recall heißt: „Von allen echten 1-Fällen findet das Modell X %.“
Was ist hier der schlimmste Fehler? In unserem Rauchmelder-Beispiel ein echter Brand, der nicht gemeldet wird. Das ist ein False Negative.
✅ Mini-Check (30 Sekunden)
- Was ist „positiv“ (=1) in unserem Fall?
- Was wäre ein True Positive hier als ganzer Satz?
- Würdest du den Threshold senken oder erhöhen, wenn du lieber einen Fehlalarm mehr akzeptierst als einen Brand zu übersehen?
🏋️ Übung: Threshold ändern
Erzeuge harte Vorhersagen mit einem niedrigeren Threshold. So siehst du direkt, wie mehr Fälle positiv werden.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
import numpy as np
proba = np.array([0.18, 0.33, 0.44, 0.76, 0.91])
threshold = 0.40
y_pred = # ??? DEINE LÖSUNG ???
print(y_pred.tolist())💡 Tipp anzeigen
Wieder gilt: Alles ab dem Threshold wird zu 1.
✅ Lösung anzeigen
import numpy as np
proba = np.array([0.18, 0.33, 0.44, 0.76, 0.91])
threshold = 0.40
y_pred = (proba >= threshold).astype(int)
print(y_pred.tolist())Erwartete Ausgabe: [0, 0, 1, 1, 1]
Was nimmst du mit? Der beste Threshold hängt vom Schadenprofil ab. In Medizin, Betrugserkennung oder Bewerbungsfiltern kann dieselbe Metrik zu ganz anderen Entscheidungen führen.
Multiclass-Klassifikation
Du siehst, wie aus vielen binären Entscheidungen ein Modell für drei Klassen wird.
Alltagsszene
Der Türsteher entscheidet nicht nur über „rein“ oder „nicht rein“. Auf dem Wochenmarkt sortiert er jetzt Äpfel, Birnen und Bananen. Dafür braucht er mehrere kleine Ja/Nein-Modelle.
ML-Sprache
Bei One-vs-Rest bekommt jede Klasse ihr eigenes binäres Modell. Alle Modelle liefern Wahrscheinlichkeiten. Gewonnen hat die Klasse mit dem höchsten Wert. Für drei Klassen heißt das praktisch: drei getrennte Ja/Nein-Fragen und am Ende ein Vergleich der drei Scores.
zerlegt ein Problem mit vielen Klassen in mehrere binäre Fragen: „Ist es meine Klasse oder nicht?“
Code-Beispiel aus dem Notebook
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
data = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
data.data, data.target, test_size=0.3, stratify=data.target, random_state=42
)
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))Interaktive Demo: Drei Klassen auf einen Blick
🗣️ Übersetze die Scores in Alltagssprache
Was ist gemessen? In unserem Fall drei konkurrierende Klassen-Scores, aus denen am Ende genau eine Klasse gewinnt.
So liest man den Wert: Der höchste Score gewinnt. In unserem Fall heißt das: Die Blume wird der Klasse mit dem stärksten Ja-Signal zugeordnet.
Was ist hier der schlimmste Fehler? Nicht nur „falsch“, sondern falsch mit scheinbar großem Abstand, obwohl die falsche Klasse in Wahrheit nur knapp vorne lag.
✅ Mini-Check (30 Sekunden)
- Was ist hier „positiv“ nicht mehr nur als 0 oder 1, sondern als Gewinnerklasse?
- Was wäre ein richtiger Treffer hier als ganzer Satz?
- Welche Klasse würdest du wählen, wenn zwei Scores fast gleichauf liegen und warum?
🏋️ Übung: Iris klassifizieren
Hier übernimmst du den Kern aus dem Multiclass-Notebook. Ergänze die Datenlade-Zeile und trainiere anschließend das Modell.
📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
data = # ??? DEINE LÖSUNG ???
X = data.data
y = data.target
model = LogisticRegression(max_iter=200)
model.fit(X, y)
print(model.predict(X[:3]).tolist())💡 Tipp anzeigen
Die Funktion heißt genauso wie der Datensatz.
✅ Lösung anzeigen
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
data = load_iris()
X = data.data
y = data.target
model = LogisticRegression(max_iter=200)
model.fit(X, y)
print(model.predict(X[:3]).tolist())Erwartete Ausgabe: [0, 0, 0]
Was nimmst du mit? Multiclass bedeutet nicht automatisch ein völlig neues Modell. Oft ist es dieselbe Grundidee, nur mehrfach parallel gestellt.