Класификация

Накратко: Класификацията предсказва клас, например „ще купи пак“ или не; логистичната регресия дава вероятност, а прагът разменя precision срещу recall според това кои грешки са по-скъпи.

Проблем

„Ще купи ли клиентът пак?“

Маркетингът иска да прати купон за отстъпка на клиентите, които иначе ще спрат да купуват. Купон за всички струва много, а повечето клиенти и без това се връщат. Въпросът е: на кого?

Нека се върнем във времето. Застани на 1 юли 2026: това е границата. За всеки клиент знаеш поръчките му до тази дата. Колко са, преди колко дни е последната, колко е средната кошница. Дали ще поръча пак, ще разбереш от юли до края на октомври:

Pythonданни: таблиците на магазина

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('клиенти преди 1 юли:', len(people))
print('върнаха се след това:', 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('клиенти преди 1 юли:', len(people)) print('върнаха се след това:', round(1 - people['lost'].mean(), 3)) people[['orders', 'days_since', 'basket', 'lost']].round(2).sort_values('orders').head()

▶ ИзпълниВърни кода

Преди 1 юли са купували 1 279 клиенти. След това 72,6% от тях са поръчали пак. Колоната lost е 1 за останалите: те не са поръчали нищо за 4 месеца. Това са хората, за които е купонът.

По-точно, за любопитните

Тук броим всяка поръчка, и отказаните: въпросът е дали клиентът идва, а не колко оборот носи. basket е средната стойност на кошницата му. ~people.index.isin(...) е маската „клиентът го няма след границата“: ~ обръща True и False.

Пробвай

Колко е даром?

Запиши в lost_share каква част от клиентите са загубени, а в baseline_acc колко често познава правилото „всички се връщат“, без никакъв модел.

Pythonданни: таблиците на магазина

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)

Провери▶ Изпълни

Идеята

Класификация: отговорът е клас

В регресията прогнозата е число: оборот за ден. Тук отговорът е „да“ или „не“: загубен ли е клиентът. Такава задача е класификация, а възможните отговори са класове. Пътят е същият: признаци X, етикет y, разделяне, fit, predict.

Първият модел е логистична регресия (LogisticRegression). Името е подвеждащо: тя класифицира. Като линейната регресия събира признаците с тегла, но после свива сумата в шанс между 0 и 1. Срещу нея слагаме DummyClassifier, който винаги казва най-честия клас:

Pythonданни: таблиците на магазина

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('клиенти за обучение и за тест:', len(X_train), len(X_test))
print('точност, „всички се връщат“:', round(baseline.score(X_test, y_test), 3))
print('точност, моделът:', 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('клиенти за обучение и за тест:', len(X_train), len(X_test)) print('точност, „всички се връщат“:', round(baseline.score(X_test, y_test), 3)) print('точност, моделът:', round(model.score(X_test, y_test), 3))

▶ ИзпълниВърни кода

Правилото „всички се връщат“ познава 72,5% от тестовите клиенти. Моделът познава 72,2%: по-малко от правилото. Точността (accuracy, делът на верните отговори) тук лъже. Когато загубените са около всеки четвърти, „всички остават“ е почти винаги вярно.

По-точно, за любопитните

stratify=y разделя така, че делът на загубените е еднакъв в обучението и в теста: 27,5%. Без него при неравни класове тестът може случайно да получи повече или по-малко загубени. Тук е честно да разделиш по клиенти на случаен принцип: признаците на всеки клиент са от преди границата, а етикетът е от след нея. max_iter=1000 дава на модела повече стъпки да намери теглата: признаците са в различен мащаб (поръчки до 77, дни до 240).

Идеята

Матрица на объркването

Точността е едно число за всички грешки. А грешките не са еднакви. Пропуснат загубен клиент е изгубен приход. Купон за клиент, който щеше да се върне, е подарена отстъпка. Таблицата, която ги брои поотделно, се казва матрица на объркването (confusion matrix):

Pythonданни: таблиците на магазина

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=['наистина остава', 'наистина загубен'],
             columns=['моделът: остава', 'моделът: загубен'])

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=['наистина остава', 'наистина загубен'], columns=['моделът: остава', 'моделът: загубен'])

▶ ИзпълниВърни кода

Редовете са истината, колоните са какво казва моделът. От 88 загубени клиенти моделът посочва 1. Останалите 87 ги изпуска. Затова е точен колкото правилото: и той почти винаги казва „остава“.

Идеята

Precision и recall: кой получава купон

Две числа описват купоните по-добре от точността:

• precision: от клиентите с купон колко наистина щяха да си тръгнат. Ниско значи много подарени отстъпки;
• recall: от всички, които щяха да си тръгнат, колко получават купон. Ниско значи много изпуснати клиенти.

Pythonданни: таблиците на магазина

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('купони:', pred.sum())
print('precision:', round(precision_score(y_test, pred), 3))
print('recall:', 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('купони:', pred.sum()) print('precision:', round(precision_score(y_test, pred), 3)) print('recall:', round(recall_score(y_test, pred), 3))

▶ ИзпълниВърни кода

Моделът дава 3 купона. Един отива при загубен клиент: precision е 0,333. От 88-те загубени хваща 1: recall е 0,011. Такъв модел не помага на маркетинга, каквато и да е точността му.

Идеята

Шансът и прагът

predict не е всичко, което моделът знае. predict_proba дава шанс за всеки клас. Колоните са в реда на model.classes_: първата е за 0 (остава), втората за 1 (загубен):

Pythonданни: таблиците на магазина

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('най-високият шанс за загуба:', proba.max().round(2))
print('над 0,5:', (proba >= 0.5).sum(), ' над 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('най-високият шанс за загуба:', proba.max().round(2)) print('над 0,5:', (proba >= 0.5).sum(), ' над 0,3:', (proba >= 0.3).sum())

▶ ИзпълниВърни кода

Най-високият шанс за загуба в теста е 0,56. predict дава купон само ако шансът е над 0,5, а такива клиенти са 3. Но 0,5 не е закон. Числото, над което казваш „да“, се казва праг (threshold), и ти го избираш. При праг 0,3 купоните са 160:

Pythonданни: таблиците на магазина

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('купони:', pred.sum())
print('precision:', round(precision_score(y_test, pred), 3))
print('recall:', 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('купони:', pred.sum()) print('precision:', round(precision_score(y_test, pred), 3)) print('recall:', round(recall_score(y_test, pred), 3))

▶ ИзпълниВърни кода

От 160 купона 63 отиват при загубени клиенти: precision е 39,4%. От 88-те загубени хващаш 63: recall е 71,6%. Точността пада, но моделът вече работи. За сравнение: 160 купона на случайни клиенти биха имали precision колкото дела на загубените, 27,5%. Моделът подрежда клиентите по-добре от случая, макар и далеч от идеално.

По-точно, за любопитните

Друг модел дава подобна картина. Дърво на решенията с дълбочина 3 също е точно колкото правилото, а при праг 0,3 има precision 38,8% и recall 64,8%:

Pythonданни: таблиците на магазина

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('точност:', round(tree.score(X_test, y_test), 3))
pred = (tree.predict_proba(X_test)[:, 1] >= 0.3).astype(int)
print('при праг 0,3: precision', round(precision_score(y_test, pred), 3), 'recall', 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('точност:', round(tree.score(X_test, y_test), 3)) pred = (tree.predict_proba(X_test)[:, 1] >= 0.3).astype(int) print('при праг 0,3: precision', round(precision_score(y_test, pred), 3), 'recall', round(recall_score(y_test, pred), 3))

▶ ИзпълниВърни кода

С тези три признака повече не се изкарва. Ако искаш по-добър модел, търси признаци, които казват повече за клиента: какви продукти купува, колко редовно поръчва.

Пробвай

Сметни ги сам

При праг 0,4 преброй fp (купон за клиент, който остава) и fn (загубен клиент без купон), после сметни precision и recall от tp, fp и fn, без sklearn.

Pythonданни: таблиците на магазина

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)

Провери▶ Изпълни

Идеята

Прагът мени едното за другото

Всеки праг дава различни купони. Ето всички прагове от 0,1 до 0,5:

Pythonданни: таблиците на магазина

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({'праг': t, 'купони': pred.sum(),
                 'precision': precision_score(y_test, pred, zero_division=0),
                 'recall': recall_score(y_test, pred)})
curve = pd.DataFrame(rows).set_index('праг').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('Прагът: повече купони или по-точни купони')
ax.set_xlabel('праг на шанса за загуба')
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({'праг': t, 'купони': pred.sum(), 'precision': precision_score(y_test, pred, zero_division=0), 'recall': recall_score(y_test, pred)}) curve = pd.DataFrame(rows).set_index('праг').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('Прагът: повече купони или по-точни купони') ax.set_xlabel('праг на шанса за загуба') ax.set_ylim(0, 1) ax.legend() fig.tight_layout()

▶ ИзпълниВърни кода

При праг 0,1 купоните са 262 и хващаш 96,6% от загубените, но precision е 32,4%: малко над 27,5%-те на случайните купони. При 0,4 купоните са 81 и precision е 45,7%, но изпускаш повече от половината загубени. При 0,5 купоните са само 3. Няма праг, който е най-добър сам по себе си. Изборът зависи от цената: колко струва купонът и колко струва изгубеният клиент.

Упражнение

Купоните на маркетинга

Маркетингът има 80 купона за клиентите в теста. Дай ги на 80-те с най-висок шанс за загуба: proba.argsort() дава позициите от най-малкия към най-големия шанс. Запиши в hits колко от тях са наистина загубени, в precision дела им сред 80-те, а в recall каква част от всички загубени в теста получават купон.

Pythonданни: таблиците на магазина

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)

Провери▶ Изпълни

Маркетингът казва: „Искаме да стигнем поне 80% от загубените.“ Намери в best най-високия праг от 0,05 до 0,5, при който recall е поне 0,8, а в best_precision precision при него.

Pythonданни: таблиците на магазина

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)

Провери▶ Изпълни

Тест

Провери се

1. Моделът познава 72,2% от клиентите в теста. Правилото „всички се връщат“ познава 72,5%. Какво казваш на маркетинга?

Моделът е добър: 72% е многоМоделът не е по-добър от правилото: от 88 загубени клиенти намира 1Моделът е малко по-слаб, но е модел, затова е по-надежден

2. Какво мери precision, когато даваш купони на клиентите, които моделът смята за загубени?

От всички, които щяха да си тръгнат, каква част получават купонКаква част от всички клиенти моделът познаваОт клиентите с купон каква част наистина щяха да си тръгнат

3. Сваляш прага от 0,4 на 0,25. Какво става?

Купоните стават повече, recall расте, precision пада или оставаКупоните стават по-малко и по-точниНищо: прагът не мени модела

4. Защо признаците се смятат само от поръчките преди 1 юли?

За да има по-малко данни и обучението да е бързоЗащото след 1 юли няма поръчкиКогато ползваш модела, знаеш само миналото: етикетът е от бъдещето и признаците не бива да го виждат

5. Купонът струва малко, а изгубен редовен клиент струва много. Към кое се навеждаш?

Към по-висок recall: по-нисък праг и повече купониКъм по-висок precision: по-висок праг и малко купониКъм по-висока точност

Провери

Започни урока отначало

Свързани уроци

• Нужно отпреди: Дати и времеви редове · Първата графика · Модел: учене от примери · Линейна регресия
• Продължава в: Изтичане на данни (data leakage) · Кръстосана проверка (cross-validation)
• Задачи по темата: Модели със scikit-learn