Klassifikation

Kurz gesagt: Eine Klassifikation sagt eine Klasse voraus, zum Beispiel „kauft wieder“ oder nicht; die logistische Regression liefert eine Wahrscheinlichkeit, und der Schwellenwert tauscht Präzision gegen Trefferquote, je nachdem, welche Fehler mehr kosten.

Problem

„Kauft der Kunde wieder?“

Das Marketing will einen Rabattgutschein an die Kunden schicken, die sonst aufhören würden zu kaufen. Ein Gutschein für alle kostet viel, und die meisten Kunden kommen ohnehin wieder. Die Frage ist: Wem?

Gehen wir in der Zeit zurück. Stell dich auf den 1. Juli 2026: Das ist der Stichtag. Von jedem Kunden kennst du die Bestellungen bis zu diesem Datum. Wie viele, wie viele Tage her die letzte war, wie groß der durchschnittliche Warenkorb ist. Ob er wieder bestellt, erfährst du von Juli bis Ende Oktober:

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

print('Kunden vor dem 1. Juli:', len(people))
print('danach wieder bestellt:', round(1 - people['lost'].mean(), 3))
people[['orders', 'days_since', 'basket', 'lost']].round(2).sort_values('orders').head()

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) print('Kunden vor dem 1. Juli:', len(people)) print('danach wieder bestellt:', round(1 - people['lost'].mean(), 3)) people[['orders', 'days_since', 'basket', 'lost']].round(2).sort_values('orders').head()

▶ AusführenCode zurücksetzen

Vor dem 1. Juli haben 1.279 Kunden etwas gekauft. Danach haben 72,6 % von ihnen wieder bestellt. Die Spalte lost ist 1 für die übrigen: Sie haben 4 Monate lang nichts bestellt. Für diese Leute ist der Gutschein.

Genauer, für Neugierige

Hier zählen wir jede Bestellung, auch die stornierten: Die Frage ist, ob der Kunde kommt, nicht wie viel Umsatz er bringt. basket ist der durchschnittliche Wert seines Warenkorbs. ~people.index.isin(...) ist die Maske „der Kunde fehlt nach dem Stichtag“: ~ kehrt True und False um.

Probier es aus

Wie viel ist geschenkt?

Lege in lost_share ab, welcher Anteil der Kunden verloren ist, und in baseline_acc, wie oft die Regel „alle kommen wieder“ ohne jedes Modell richtig liegt.

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

lost_share = ...
baseline_acc = ...
print(lost_share, baseline_acc)

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) lost_share = ... baseline_acc = ... print(lost_share, baseline_acc)

Prüfen▶ Ausführen

Die Idee

Klassifikation: Die Antwort ist eine Klasse

Bei der Regression ist die Vorhersage eine Zahl: der Umsatz eines Tages. Hier ist die Antwort „ja“ oder „nein“: Ist der Kunde verloren? Eine solche Aufgabe heißt Klassifikation, und die möglichen Antworten sind Klassen. Der Weg ist derselbe: Merkmale X, Label y, Aufteilung, fit, predict.

Das erste Modell ist die logistische Regression (LogisticRegression). Der Name führt in die Irre: Sie klassifiziert. Wie die lineare Regression addiert sie die Merkmale mit Gewichten, drückt die Summe dann aber zu einer Wahrscheinlichkeit zwischen 0 und 1 zusammen. Dagegen stellen wir DummyClassifier, der immer die häufigste Klasse sagt:

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.dummy import DummyClassifier

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y)

baseline = DummyClassifier(strategy='most_frequent').fit(X_train, y_train)
model = LogisticRegression(max_iter=1000).fit(X_train, y_train)
print('Kunden für Training und Test:', len(X_train), len(X_test))
print('Genauigkeit, „alle kommen wieder“:', round(baseline.score(X_test, y_test), 3))
print('Genauigkeit, das Modell:', round(model.score(X_test, y_test), 3))

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression from sklearn.dummy import DummyClassifier X = people[['orders', 'days_since', 'basket']] y = people['lost'] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, random_state=42, stratify=y) baseline = DummyClassifier(strategy='most_frequent').fit(X_train, y_train) model = LogisticRegression(max_iter=1000).fit(X_train, y_train) print('Kunden für Training und Test:', len(X_train), len(X_test)) print('Genauigkeit, „alle kommen wieder“:', round(baseline.score(X_test, y_test), 3)) print('Genauigkeit, das Modell:', round(model.score(X_test, y_test), 3))

▶ AusführenCode zurücksetzen

Die Regel „alle kommen wieder“ liegt bei 72,5 % der Testkunden richtig. Das Modell liegt bei 72,2 % richtig: weniger als die Regel. Die Genauigkeit (der Anteil richtiger Antworten) täuscht hier. Wenn etwa jeder vierte Kunde verloren ist, stimmt „alle bleiben“ fast immer.

Genauer, für Neugierige

stratify=y teilt so auf, dass der Anteil der verlorenen Kunden im Training und im Test gleich ist: 27,5 %. Ohne das kann der Test bei ungleichen Klassen zufällig mehr oder weniger verlorene Kunden bekommen. Hier ist es fair, die Kunden zufällig aufzuteilen: Die Merkmale jedes Kunden stammen aus der Zeit vor dem Stichtag und das Label aus der Zeit danach. max_iter=1000 gibt dem Modell mehr Schritte, um die Gewichte zu finden: Die Merkmale haben unterschiedliche Größenordnungen (Bestellungen bis 77, Tage bis 240).

Die Idee

Die Konfusionsmatrix

Die Genauigkeit ist eine Zahl für alle Fehler. Aber die Fehler sind nicht gleich. Ein verpasster verlorener Kunde ist entgangenes Einkommen. Ein Gutschein für einen Kunden, der wiedergekommen wäre, ist ein verschenkter Rabatt. Die Tabelle, die sie getrennt zählt, heißt Konfusionsmatrix:

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
from sklearn.metrics import confusion_matrix

pred = model.predict(X_test)
table = confusion_matrix(y_test, pred)
pd.DataFrame(table, index=['wirklich geblieben', 'wirklich verloren'],
             columns=['Modell: bleibt', 'Modell: verloren'])

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) from sklearn.metrics import confusion_matrix pred = model.predict(X_test) table = confusion_matrix(y_test, pred) pd.DataFrame(table, index=['wirklich geblieben', 'wirklich verloren'], columns=['Modell: bleibt', 'Modell: verloren'])

▶ AusführenCode zurücksetzen

Die Zeilen sind die Wahrheit, die Spalten das, was das Modell sagt. Von 88 verlorenen Kunden zeigt das Modell auf 1. Die anderen 87 verpasst es. Deshalb ist es so genau wie die Regel: Auch es sagt fast immer „bleibt“.

Die Idee

Präzision und Trefferquote: Wer bekommt einen Gutschein

Zwei Zahlen beschreiben die Gutscheine besser als die Genauigkeit:

• Präzision: von den Kunden mit Gutschein, wie viele wirklich gegangen wären. Niedrig heißt viele verschenkte Rabatte;
• Trefferquote: von allen, die gegangen wären, wie viele einen Gutschein bekommen. Niedrig heißt viele verpasste Kunden.

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
from sklearn.metrics import precision_score, recall_score

pred = model.predict(X_test)
print('Gutscheine:', pred.sum())
print('Präzision:', round(precision_score(y_test, pred), 3))
print('Trefferquote:', round(recall_score(y_test, pred), 3))

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) from sklearn.metrics import precision_score, recall_score pred = model.predict(X_test) print('Gutscheine:', pred.sum()) print('Präzision:', round(precision_score(y_test, pred), 3)) print('Trefferquote:', round(recall_score(y_test, pred), 3))

▶ AusführenCode zurücksetzen

Das Modell gibt 3 Gutscheine. Einer geht an einen verlorenen Kunden: Die Präzision ist 0,333. Von den 88 verlorenen erwischt es 1: Die Trefferquote ist 0,011. Ein solches Modell hilft dem Marketing nicht, egal wie genau es ist.

Die Idee

Die Wahrscheinlichkeit und der Schwellenwert

predict ist nicht alles, was das Modell weiß. predict_proba gibt für jede Klasse eine Wahrscheinlichkeit. Die Spalten folgen der Reihenfolge von model.classes_: die erste für 0 (bleibt), die zweite für 1 (verloren):

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]

print(model.classes_)
print(model.predict_proba(X_test)[:3].round(2))
print('höchste Abwanderungswahrscheinlichkeit:', proba.max().round(2))
print('ab 0.5:', (proba >= 0.5).sum(), ' ab 0.3:', (proba >= 0.3).sum())

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) proba = model.predict_proba(X_test)[:, 1] print(model.classes_) print(model.predict_proba(X_test)[:3].round(2)) print('höchste Abwanderungswahrscheinlichkeit:', proba.max().round(2)) print('ab 0.5:', (proba >= 0.5).sum(), ' ab 0.3:', (proba >= 0.3).sum())

▶ AusführenCode zurücksetzen

Die höchste Abwanderungswahrscheinlichkeit im Test ist 0,56. predict gibt nur dann einen Gutschein, wenn die Wahrscheinlichkeit über 0,5 liegt, und das sind 3 Kunden. Aber 0,5 ist kein Gesetz. Die Zahl, ab der du „ja“ sagst, heißt Schwellenwert, und du wählst sie. Bei einem Schwellenwert von 0,3 gibt es 160 Gutscheine:

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]
from sklearn.metrics import confusion_matrix, precision_score, recall_score

pred = (proba >= 0.3).astype(int)
print(confusion_matrix(y_test, pred))
print('Gutscheine:', pred.sum())
print('Präzision:', round(precision_score(y_test, pred), 3))
print('Trefferquote:', round(recall_score(y_test, pred), 3))

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) proba = model.predict_proba(X_test)[:, 1] from sklearn.metrics import confusion_matrix, precision_score, recall_score pred = (proba >= 0.3).astype(int) print(confusion_matrix(y_test, pred)) print('Gutscheine:', pred.sum()) print('Präzision:', round(precision_score(y_test, pred), 3)) print('Trefferquote:', round(recall_score(y_test, pred), 3))

▶ AusführenCode zurücksetzen

Von 160 Gutscheinen gehen 63 an verlorene Kunden: Die Präzision ist 39,4 %. Von den 88 verlorenen erwischst du 63: Die Trefferquote ist 71,6 %. Die Genauigkeit sinkt, aber jetzt arbeitet das Modell. Zum Vergleich: 160 Gutscheine an zufällige Kunden hätten eine Präzision gleich dem Anteil der verlorenen, 27,5 %. Das Modell ordnet die Kunden besser als der Zufall, wenn auch weit von perfekt.

Genauer, für Neugierige

Ein anderes Modell zeigt ein ähnliches Bild. Ein Entscheidungsbaum mit Tiefe 3 ist ebenfalls genau so genau wie die Regel, und bei einem Schwellenwert von 0,3 hat er eine Präzision von 38,8 % und eine Trefferquote von 64,8 %:

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import recall_score, precision_score

tree = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X_train, y_train)
print('Genauigkeit:', round(tree.score(X_test, y_test), 3))
pred = (tree.predict_proba(X_test)[:, 1] >= 0.3).astype(int)
print('bei Schwellenwert 0.3: Präzision', round(precision_score(y_test, pred), 3), 'Trefferquote', round(recall_score(y_test, pred), 3))

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import recall_score, precision_score tree = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X_train, y_train) print('Genauigkeit:', round(tree.score(X_test, y_test), 3)) pred = (tree.predict_proba(X_test)[:, 1] >= 0.3).astype(int) print('bei Schwellenwert 0.3: Präzision', round(precision_score(y_test, pred), 3), 'Trefferquote', round(recall_score(y_test, pred), 3))

▶ AusführenCode zurücksetzen

Mit diesen drei Merkmalen ist nicht viel mehr drin. Willst du ein besseres Modell, such Merkmale, die mehr über den Kunden sagen: welche Produkte er kauft, wie regelmäßig er bestellt.

Probier es aus

Zähl selbst

Zähle beim Schwellenwert 0,4 fp (ein Gutschein für einen Kunden, der bleibt) und fn (ein verlorener Kunde ohne Gutschein), und berechne dann Präzision und Trefferquote aus tp, fp und fn, ohne sklearn.

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]

pred = (proba >= 0.4).astype(int)
truth = y_test.to_numpy()
tp = ((pred == 1) & (truth == 1)).sum()
fp = ...
fn = ...
precision = ...
recall = ...
print(tp, fp, fn, precision, recall)

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) proba = model.predict_proba(X_test)[:, 1] pred = (proba >= 0.4).astype(int) truth = y_test.to_numpy() tp = ((pred == 1) & (truth == 1)).sum() fp = ... fn = ... precision = ... recall = ... print(tp, fp, fn, precision, recall)

Prüfen▶ Ausführen

Die Idee

Der Schwellenwert tauscht das eine gegen das andere

Jeder Schwellenwert gibt andere Gutscheine. Hier sind alle Schwellenwerte von 0,1 bis 0,5:

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import precision_score, recall_score

rows = []
for t in np.arange(0.10, 0.51, 0.05).round(2):
    pred = (proba >= t).astype(int)
    rows.append({'threshold': t, 'coupons': pred.sum(),
                 'precision': precision_score(y_test, pred, zero_division=0),
                 'recall': recall_score(y_test, pred)})
curve = pd.DataFrame(rows).set_index('threshold').round(3)
print(curve)

fig, ax = plt.subplots(figsize=(7, 3.5))
ax.plot(curve.index, curve['precision'], marker='o', label='precision')
ax.plot(curve.index, curve['recall'], marker='o', label='recall')
ax.set_title('Der Schwellenwert: mehr Gutscheine oder treffsicherere Gutscheine')
ax.set_xlabel('Schwellenwert für die Abwanderungswahrscheinlichkeit')
ax.set_ylim(0, 1)
ax.legend()
fig.tight_layout()

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) proba = model.predict_proba(X_test)[:, 1] import numpy as np import matplotlib.pyplot as plt from sklearn.metrics import precision_score, recall_score rows = [] for t in np.arange(0.10, 0.51, 0.05).round(2): pred = (proba >= t).astype(int) rows.append({'threshold': t, 'coupons': pred.sum(), 'precision': precision_score(y_test, pred, zero_division=0), 'recall': recall_score(y_test, pred)}) curve = pd.DataFrame(rows).set_index('threshold').round(3) print(curve) fig, ax = plt.subplots(figsize=(7, 3.5)) ax.plot(curve.index, curve['precision'], marker='o', label='precision') ax.plot(curve.index, curve['recall'], marker='o', label='recall') ax.set_title('Der Schwellenwert: mehr Gutscheine oder treffsicherere Gutscheine') ax.set_xlabel('Schwellenwert für die Abwanderungswahrscheinlichkeit') ax.set_ylim(0, 1) ax.legend() fig.tight_layout()

▶ AusführenCode zurücksetzen

Bei einem Schwellenwert von 0,1 gibt es 262 Gutscheine, und du erwischst 96,6 % der verlorenen Kunden, aber die Präzision ist 32,4 %: ein wenig über den 27,5 % zufälliger Gutscheine. Bei 0,4 gibt es 81 Gutscheine, und die Präzision ist 45,7 %, aber du verpasst mehr als die Hälfte der verlorenen Kunden. Bei 0,5 sind es nur 3 Gutscheine. Kein Schwellenwert ist für sich allein der beste. Die Wahl hängt von den Kosten ab: was ein Gutschein kostet und was ein verlorener Kunde kostet.

Übung

Die Gutscheine des Marketings

Das Marketing hat 80 Gutscheine für die Kunden im Test. Gib sie den 80 mit der höchsten Abwanderungswahrscheinlichkeit: proba.argsort() gibt die Positionen von der kleinsten zur größten Wahrscheinlichkeit. Lege in hits ab, wie viele von ihnen wirklich verloren sind, in precision ihren Anteil unter den 80 und in recall, welcher Anteil aller verlorenen Kunden im Test einen Gutschein bekommt.

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]

top = ...
hits = ...
precision = ...
recall = ...
print(hits, precision, recall)

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) proba = model.predict_proba(X_test)[:, 1] top = ... hits = ... precision = ... recall = ... print(hits, precision, recall)

Prüfen▶ Ausführen

Das Marketing sagt: „Wir wollen mindestens 80 % der verlorenen Kunden erreichen.“ Finde in best den höchsten Schwellenwert von 0,05 bis 0,5, bei dem die Trefferquote mindestens 0,8 beträgt, und in best_precision die Präzision dort.

PythonDaten: die Tabellen des Shops

import pandas as pd

orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at'])
items = pd.read_csv('year_items.csv')
items['value'] = items['quantity'] * items['unit_price']
orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum())

cutoff = pd.Timestamp('2026-07-01')
before = orders[orders['ordered_at'] < cutoff]
after = orders[orders['ordered_at'] >= cutoff]

people = before.groupby('customer_id').agg(
    orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean'))
people['days_since'] = (cutoff - people['last']).dt.days
people['lost'] = (~people.index.isin(after['customer_id'])).astype(int)

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = people[['orders', 'days_since', 'basket']]
y = people['lost']
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).fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]
import numpy as np
from sklearn.metrics import precision_score, recall_score

best = None
for t in np.arange(0.05, 0.51, 0.05).round(2):
    pred = (proba >= t).astype(int)
    ...
best_precision = ...
print(best, best_precision)

import pandas as pd orders = pd.read_csv('year_orders.csv', parse_dates=['ordered_at']) items = pd.read_csv('year_items.csv') items['value'] = items['quantity'] * items['unit_price'] orders['basket'] = orders['id'].map(items.groupby('order_id')['value'].sum()) cutoff = pd.Timestamp('2026-07-01') before = orders[orders['ordered_at'] < cutoff] after = orders[orders['ordered_at'] >= cutoff] people = before.groupby('customer_id').agg( orders=('id', 'size'), last=('ordered_at', 'max'), basket=('basket', 'mean')) people['days_since'] = (cutoff - people['last']).dt.days people['lost'] = (~people.index.isin(after['customer_id'])).astype(int) from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression X = people[['orders', 'days_since', 'basket']] y = people['lost'] 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).fit(X_train, y_train) proba = model.predict_proba(X_test)[:, 1] import numpy as np from sklearn.metrics import precision_score, recall_score best = None for t in np.arange(0.05, 0.51, 0.05).round(2): pred = (proba >= t).astype(int) ... best_precision = ... print(best, best_precision)

Prüfen▶ Ausführen

Test

Teste dich

1. Das Modell liegt bei etwa 72,2 % der Testkunden richtig. Die Regel „alle kommen wieder“ liegt bei 72,5 % richtig. Was sagst du dem Marketing?

Das Modell ist etwas schwächer, aber es ist ein Modell, also verlässlicherDas Modell ist gut: 72 % ist vielDas Modell ist nicht besser als die Regel: Von 88 verlorenen Kunden findet es 1

2. Was misst die Präzision, wenn du Gutscheine an die Kunden gibst, die das Modell für verloren hält?

Welchen Anteil aller Kunden das Modell richtig hatVon den Kunden mit Gutschein, welcher Anteil wirklich gegangen wäreVon allen, die gegangen wären, welcher Anteil einen Gutschein bekommt

3. Du senkst den Schwellenwert von 0,4 auf 0,25. Was passiert?

Nichts: Der Schwellenwert ändert das Modell nichtEs gibt mehr Gutscheine, die Trefferquote steigt, die Präzision sinkt oder bleibtEs gibt weniger und treffsicherere Gutscheine

4. Warum werden die Merkmale nur aus Bestellungen vor dem 1. Juli berechnet?

Damit es weniger Daten gibt und das Training schnell istWeil es nach dem 1. Juli keine Bestellungen gibtWenn du das Modell einsetzt, kennst du nur die Vergangenheit: Das Label stammt aus der Zukunft, und die Merkmale dürfen es nicht sehen

5. Ein Gutschein kostet wenig, und ein verlorener Stammkunde kostet viel. Wohin neigst du?

Zu einer höheren GenauigkeitZu einer höheren Trefferquote: ein niedrigerer Schwellenwert und mehr GutscheineZu einer höheren Präzision: ein höherer Schwellenwert und wenige Gutscheine

Prüfen

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Datumswerte und Zeitreihen · Das erste Diagramm · Modelle: aus Beispielen lernen · Lineare Regression
• Geht weiter in: Datenleck · Kreuzvalidierung
• Aufgaben zum Thema: Modelle mit scikit-learn