Datetime and cyclical features

Almost every team gets the first lane. Most get the second. The third is where the signal usually hides.

• Calendar parts answer where in the cycle this event sits: year, month, day of week, hour, quarter. Cheap to compute, immediately interpretable, and the raw material for the cyclical encoding in Part 2.
• Boolean flags answer what kind of moment this was: weekend, public holiday, business hours, month end, promo window. A flag is a human judgement compressed into one bit, which is exactly what Rule #20 means by "human-understandable ways."
• Relative quantities answer how far from now: tenure (prediction time minus signup), recency (prediction time minus last event), time to event. These are the ones teams forget, and they are usually the strongest, because behaviour depends far more on "signed up nine days ago" than on "signed up in November."

The workbench keeps this deliberately small - two features, one from each of the last two lanes - so you can see the lift attributable to each idea rather than to a pile of columns.

Two features, +0.021 held-out AUC. Note what that is not: it is not a new algorithm, a bigger dataset, or a tuning run. It is one column that was already in the table, read properly.

Map the cycle onto a circle and read off both coordinates. Any periodic part works the same way - just change the period.

import numpy as np

hour = df["signup_date"].dt.hour
df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
df["hour_cos"] = np.cos(2 * np.pi * hour / 24)

month = df["signup_date"].dt.month
df["month_sin"] = np.sin(2 * np.pi * month / 12)
df["month_cos"] = np.cos(2 * np.pi * month / 12)

Why two columns and not one. Sine is symmetric about its peak, so hour 6 and hour 18 both give a sine value that cannot be told apart by sign alone, and hours either side of noon collide the same way. One column collapses two distinct moments into one number. The cosine breaks the tie: together the pair gives every hour a unique position on the circle, and hours that are close in time end up close in feature space.

The sine-cosine pair is not the only honest option, and sklearn ships both of the others.

from sklearn.preprocessing import SplineTransformer, KBinsDiscretizer

# smooth, periodic basis - the ends of the cycle join up
SplineTransformer(degree=3, n_knots=13, extrapolation="periodic")

# coarse time-of-day buckets - the model learns a weight per bucket
KBinsDiscretizer(n_bins=4, strategy="uniform", encode="onehot-dense")

• Splines with periodic extrapolation give a smooth basis that wraps, and the docs prefer splines over polynomials generally because they avoid "oscillatory behaviour at the boundaries... known as Runge's phenomenon" and extrapolate better. Worth knowing: "The SplineTransformer treats each feature separately, i.e. it won't give you interaction terms."
• Binning is the blunt, readable option: night, morning, afternoon, evening. Google's guidance on when to bin fits time of day well - bin when "the overall linear relationship between the feature and the label is weak or nonexistent" or when "feature values are clustered", and remember "the model learns separate weights for each bin." A degree-0 spline is exactly a KBinsDiscretizer(encode='onehot-dense') with n_bins = n_knots - 1.

The wrong version is shorter, which is part of why it keeps happening.

# WRONG - "now" is the moment you ran the cell, not the moment
# the prediction would have been made
df["tenure_days"] = (pd.Timestamp.now() - df["signup_date"]).dt.days

# RIGHT - every row carries the timestamp of its own decision point
ref = df["prediction_ts"]
df["tenure_days"] = (ref - df["signup_date"]).dt.days
df["days_since_last_order"] = (ref - df["last_order_ts"]).dt.days

The damage is subtle. Both versions produce plausible numbers, both train fine, and the broken one often scores better on the held-out set, because "now minus signup" is partly encoding how old the row is, and row age correlates with the outcome distribution in most datasets. That is the sklearn definition arriving on schedule: "information that would not be available at prediction time is used when building the model."

• b5, Leakage: the session. Temporal leakage is one of the four families, and this is its cleanest example. b5 also gives you the three rules that prevent all four, and sklearn's worked result where a leaked step scored 0.76 accuracy on pure noise against an honest 0.50.
• b6, aggregations. The same rule with a bigger blast radius: a group aggregate computed over the whole table leaks the future into every row of the group.
• Leader session a4, feature governance. Doing this correctly at scale has a name - point-in-time correctness - and it is one of the stated reasons feature stores exist. Feast's own docs put it in the value list: "Avoid data leakage by generating point-in-time correct feature sets."
• Not this course. Lag and rolling-window features for forecasting are a related but separate craft, and they live in learn-timeseries-forecasting-with-phoebe.