Clasificación

En resumen: Una clasificación predice una clase, por ejemplo «volverá a comprar» o no; la regresión logística da una probabilidad, y el umbral cambia precisión por exhaustividad según qué errores cuesten más.

Problema

«¿Volverá a comprar el cliente?»

Marketing quiere mandar un cupón de descuento a los clientes que de otro modo dejarían de comprar. Un cupón para todos cuesta mucho, y la mayoría de los clientes vuelve de todos modos. La pregunta es: ¿a quién?

Volvamos atrás en el tiempo. Ponte en el 1 de julio de 2026: es la fecha de corte. De cada cliente conoces sus pedidos hasta esa fecha. Cuántos, hace cuántos días fue el último, de cuánto es la cesta media. Si vuelve a pedir lo sabes de julio a finales de octubre:

Pythondatos: las tablas de la tienda

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('clientes antes del 1 de julio:', len(people))
print('volvieron a pedir después:', 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('clientes antes del 1 de julio:', len(people)) print('volvieron a pedir después:', round(1 - people['lost'].mean(), 3)) people[['orders', 'days_since', 'basket', 'lost']].round(2).sort_values('orders').head()

▶ EjecutarRestaurar el código

Antes del 1 de julio, 1279 clientes compraron algo. Después, el 72,6 % de ellos volvió a pedir. La columna lost es 1 para el resto: no pidieron nada durante 4 meses. Para esas personas es el cupón.

Más precisamente, para curiosos

Aquí contamos todos los pedidos, también los cancelados: la pregunta es si el cliente viene, no cuántos ingresos aporta. basket es el valor medio de su cesta. ~people.index.isin(...) es la máscara «el cliente falta después de la fecha de corte»: ~ invierte True y False.

Pruébalo

¿Cuánto sale gratis?

Guarda en lost_share qué proporción de los clientes está perdida, y en baseline_acc con qué frecuencia acierta la regla «todos vuelven», sin ningún modelo.

Pythondatos: las tablas de la tienda

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)

Comprobar▶ Ejecutar

La idea

Clasificación: la respuesta es una clase

En la regresión la predicción es un número: los ingresos de un día. Aquí la respuesta es «sí» o «no»: ¿está el cliente perdido? Una tarea así es una clasificación, y las respuestas posibles son clases. El camino es el mismo: características X, etiqueta y, división, fit, predict.

El primer modelo es la regresión logística (LogisticRegression). El nombre engaña: clasifica. Como la regresión lineal, suma las características con pesos, pero luego comprime la suma hasta una probabilidad entre 0 y 1. Frente a ella ponemos DummyClassifier, que siempre dice la clase más frecuente:

Pythondatos: las tablas de la tienda

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('clientes para entrenamiento y para prueba:', len(X_train), len(X_test))
print('exactitud, «todos vuelven»:', round(baseline.score(X_test, y_test), 3))
print('exactitud, el modelo:', 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('clientes para entrenamiento y para prueba:', len(X_train), len(X_test)) print('exactitud, «todos vuelven»:', round(baseline.score(X_test, y_test), 3)) print('exactitud, el modelo:', round(model.score(X_test, y_test), 3))

▶ EjecutarRestaurar el código

La regla «todos vuelven» acierta con el 72,5 % de los clientes de prueba. El modelo acierta con el 72,2 %: menos que la regla. La exactitud (la proporción de respuestas correctas) engaña aquí. Cuando más o menos uno de cada cuatro clientes está perdido, «todos se quedan» casi siempre es verdad.

Más precisamente, para curiosos

stratify=y divide de modo que la proporción de clientes perdidos sea la misma en el entrenamiento y en la prueba: 27,5 %. Sin él, con clases desiguales, la prueba puede recibir por casualidad más o menos clientes perdidos. Aquí es justo dividir a los clientes al azar: las características de cada cliente son de antes de la fecha de corte, y la etiqueta es de después. max_iter=1000 le da al modelo más pasos para encontrar los pesos: las características tienen escalas distintas (pedidos hasta 77, días hasta 240).

La idea

La matriz de confusión

La exactitud es un número para todos los errores. Pero los errores no son iguales. Un cliente perdido que se escapa es un ingreso perdido. Un cupón para un cliente que habría vuelto es un descuento regalado. La tabla que los cuenta por separado se llama matriz de confusión:

Pythondatos: las tablas de la tienda

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=['se queda de verdad', 'perdido de verdad'],
             columns=['modelo: se queda', 'modelo: perdido'])

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=['se queda de verdad', 'perdido de verdad'], columns=['modelo: se queda', 'modelo: perdido'])

▶ EjecutarRestaurar el código

Las filas son la verdad, las columnas lo que dice el modelo. De 88 clientes perdidos el modelo señala a 1. Los otros 87 se le escapan. Por eso es tan exacto como la regla: también él casi siempre dice «se queda».

La idea

Precisión y exhaustividad: quién recibe un cupón

Dos números describen los cupones mejor que la exactitud:

• precisión: de los clientes con cupón, cuántos realmente se habrían ido. Baja significa muchos descuentos regalados;
• exhaustividad: de todos los que se habrían ido, cuántos reciben un cupón. Baja significa muchos clientes que se escapan.

Pythondatos: las tablas de la tienda

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('cupones:', pred.sum())
print('precisión:', round(precision_score(y_test, pred), 3))
print('exhaustividad:', 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('cupones:', pred.sum()) print('precisión:', round(precision_score(y_test, pred), 3)) print('exhaustividad:', round(recall_score(y_test, pred), 3))

▶ EjecutarRestaurar el código

El modelo da 3 cupones. Uno va a un cliente perdido: la precisión es 0,333. De los 88 perdidos atrapa 1: la exhaustividad es 0,011. Un modelo así no ayuda a marketing, sea cual sea su exactitud.

La idea

La probabilidad y el umbral

predict no es todo lo que sabe el modelo. predict_proba da una probabilidad para cada clase. Las columnas siguen el orden de model.classes_: la primera es para 0 (se queda), la segunda para 1 (perdido):

Pythondatos: las tablas de la tienda

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('mayor probabilidad de pérdida:', proba.max().round(2))
print('desde 0.5:', (proba >= 0.5).sum(), ' desde 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('mayor probabilidad de pérdida:', proba.max().round(2)) print('desde 0.5:', (proba >= 0.5).sum(), ' desde 0.3:', (proba >= 0.3).sum())

▶ EjecutarRestaurar el código

La mayor probabilidad de pérdida en la prueba es 0,56. predict da un cupón solo si la probabilidad supera 0,5, y hay 3 clientes así. Pero 0,5 no es una ley. El número a partir del cual dices «sí» se llama umbral, y lo eliges tú. Con un umbral de 0,3 hay 160 cupones:

Pythondatos: las tablas de la tienda

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('cupones:', pred.sum())
print('precisión:', round(precision_score(y_test, pred), 3))
print('exhaustividad:', 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('cupones:', pred.sum()) print('precisión:', round(precision_score(y_test, pred), 3)) print('exhaustividad:', round(recall_score(y_test, pred), 3))

▶ EjecutarRestaurar el código

De 160 cupones, 63 van a clientes perdidos: la precisión es del 39,4 %. De los 88 perdidos atrapas 63: la exhaustividad es del 71,6 %. La exactitud baja, pero ahora el modelo funciona. Como comparación: 160 cupones a clientes al azar tendrían una precisión igual a la proporción de perdidos, 27,5 %. El modelo ordena a los clientes mejor que el azar, aunque lejos de ser perfecto.

Más precisamente, para curiosos

Otro modelo da un cuadro parecido. Un árbol de decisión de profundidad 3 también es exactamente tan exacto como la regla, y con un umbral de 0,3 tiene una precisión del 38,8 % y una exhaustividad del 64,8 %:

Pythondatos: las tablas de la tienda

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('exactitud:', round(tree.score(X_test, y_test), 3))
pred = (tree.predict_proba(X_test)[:, 1] >= 0.3).astype(int)
print('con umbral 0.3: precisión', round(precision_score(y_test, pred), 3), 'exhaustividad', 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('exactitud:', round(tree.score(X_test, y_test), 3)) pred = (tree.predict_proba(X_test)[:, 1] >= 0.3).astype(int) print('con umbral 0.3: precisión', round(precision_score(y_test, pred), 3), 'exhaustividad', round(recall_score(y_test, pred), 3))

▶ EjecutarRestaurar el código

Con estas tres características no se puede sacar mucho más. Si quieres un modelo mejor, busca características que digan más del cliente: qué productos compra, con qué regularidad pide.

Pruébalo

Cuéntalos tú

Con un umbral de 0,4, cuenta fp (un cupón para un cliente que se queda) y fn (un cliente perdido sin cupón), y luego calcula la precisión y la exhaustividad a partir de tp, fp y fn, sin sklearn.

Pythondatos: las tablas de la tienda

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)

Comprobar▶ Ejecutar

La idea

El umbral cambia una por otra

Cada umbral da cupones distintos. Aquí están todos los umbrales de 0,1 a 0,5:

Pythondatos: las tablas de la tienda

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('El umbral: más cupones o cupones más certeros')
ax.set_xlabel('umbral de la probabilidad de pérdida')
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('El umbral: más cupones o cupones más certeros') ax.set_xlabel('umbral de la probabilidad de pérdida') ax.set_ylim(0, 1) ax.legend() fig.tight_layout()

▶ EjecutarRestaurar el código

Con un umbral de 0,1 hay 262 cupones y atrapas al 96,6 % de los clientes perdidos, pero la precisión es del 32,4 %: un poco por encima del 27,5 % de los cupones al azar. Con 0,4 hay 81 cupones y la precisión es del 45,7 %, pero se te escapan más de la mitad de los clientes perdidos. Con 0,5 solo hay 3 cupones. Ningún umbral es el mejor por sí solo. La elección depende del coste: cuánto cuesta un cupón y cuánto cuesta un cliente perdido.

Ejercicio

Los cupones de marketing

Marketing tiene 80 cupones para los clientes de la prueba. Dalos a los 80 con mayor probabilidad de pérdida: proba.argsort() da las posiciones de la menor a la mayor probabilidad. Guarda en hits cuántos de ellos están realmente perdidos, en precision su proporción entre los 80, y en recall qué proporción de todos los clientes perdidos de la prueba recibe un cupón.

Pythondatos: las tablas de la tienda

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)

Comprobar▶ Ejecutar

Marketing dice: «Queremos llegar al menos al 80 % de los clientes perdidos». Encuentra en best el umbral más alto de 0,05 a 0,5 en el que la exhaustividad es al menos 0,8, y en best_precision la precisión en él.

Pythondatos: las tablas de la tienda

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)

Comprobar▶ Ejecutar

Test

Ponte a prueba

1. El modelo acierta con cerca del 72,2 % de los clientes de prueba. La regla «todos vuelven» acierta con el 72,5 %. ¿Qué le dices a marketing?

El modelo es bueno: el 72 % es muchoEl modelo no es mejor que la regla: de 88 clientes perdidos encuentra 1El modelo es un poco peor, pero es un modelo, así que es más fiable

2. ¿Qué mide la precisión cuando das cupones a los clientes que el modelo cree perdidos?

Qué proporción de todos los clientes acierta el modeloDe todos los que se habrían ido, qué proporción recibe un cupónDe los clientes con cupón, qué proporción realmente se habría ido

3. Bajas el umbral de 0,4 a 0,25. ¿Qué pasa?

Hay más cupones, la exhaustividad sube, la precisión baja o se queda igualHay menos cupones y más certerosNada: el umbral no cambia el modelo

4. ¿Por qué las características se calculan solo con pedidos anteriores al 1 de julio?

Porque después del 1 de julio no hay pedidosCuando uses el modelo, solo conocerás el pasado: la etiqueta es del futuro y las características no deben verlaPara que haya menos datos y el entrenamiento sea rápido

5. Un cupón cuesta poco y un cliente habitual perdido cuesta mucho. ¿Hacia dónde te inclinas?

Hacia una mayor exactitudHacia una mayor precisión: un umbral más alto y pocos cuponesHacia una mayor exhaustividad: un umbral más bajo y más cupones

Comprobar

Empezar la lección de nuevo

Lecciones relacionadas

• Se basa en: Fechas y series temporales · El primer gráfico · Modelos: aprender de ejemplos · Regresión lineal
• Continúa en: Fuga de datos · Validación cruzada
• Ejercicios sobre el tema: Modelos con scikit-learn