Lag Features

# Import pandas and numpy
import pandas as pd
import numpy as np

# Create a daily sales DataFrame — 10 rows
sales_df = pd.DataFrame({
    'date':        pd.date_range(start='2024-06-01', periods=10, freq='D'),  # 10 consecutive days
    'units_sold':  [200, 210, 195, 220, 230, 250, 240, 260, 270, 255]        # daily units sold
})

# Sort by date — always required before shift operations
sales_df = sales_df.sort_values('date').reset_index(drop=True)

# lag_1: yesterday's units sold — shift the column DOWN by 1 row
# The first row gets NaN because there is no "yesterday" for it
sales_df['lag_1'] = sales_df['units_sold'].shift(1)

# lag_3: units sold 3 days ago — shift down by 3 rows
# First 3 rows get NaN
sales_df['lag_3'] = sales_df['units_sold'].shift(3)

# lag_7: units sold same day last week — shift down by 7 rows
# First 7 rows get NaN — this is expected and normal
sales_df['lag_7'] = sales_df['units_sold'].shift(7)

# Derived feature: delta vs yesterday — how much did sales change since lag_1?
# This is often more predictive than the raw lag value itself
sales_df['delta_lag_1'] = sales_df['units_sold'] - sales_df['lag_1']

# Round for display
sales_df = sales_df.round(1)

# Print results
print(sales_df.to_string(index=False))

# Import pandas and numpy
import pandas as pd
import numpy as np

# Create a weekly login DataFrame — 2 users, 5 weeks each, all in one flat table
churn_df = pd.DataFrame({
    'user_id': ['U1','U1','U1','U1','U1', 'U2','U2','U2','U2','U2'],   # two users
    'week':    [1, 2, 3, 4, 5,  1, 2, 3, 4, 5],                       # week number
    'logins':  [12, 14, 13, 3, 2,   8, 9, 10, 11, 10]                  # U1 drops off; U2 is stable
})

# Sort by user then week — required so shift operates in correct time order
churn_df = churn_df.sort_values(['user_id', 'week']).reset_index(drop=True)

# Compute lag_1 PER USER: last week's logins for each user
# groupby + shift keeps the shift operation isolated within each user's rows
churn_df['lag_1'] = churn_df.groupby('user_id')['logins'].shift(1)

# Compute lag_2 PER USER: logins from two weeks ago
churn_df['lag_2'] = churn_df.groupby('user_id')['logins'].shift(2)

# Compute week-over-week change: current logins minus last week's logins
churn_df['wow_change'] = churn_df['logins'] - churn_df['lag_1']

# Compute percentage change vs lag_1 — normalises the delta by baseline activity
# Multiply by 100 to express as a percentage
churn_df['wow_pct_change'] = (churn_df['wow_change'] / (churn_df['lag_1'] + 1e-9)) * 100

# Round for clean display
churn_df = churn_df.round(1)

# Print results
print(churn_df.to_string(index=False))

# Import pandas and numpy
import pandas as pd
import numpy as np

# Create a daily power consumption DataFrame — 10 rows (MWh)
energy_df = pd.DataFrame({
    'date':        pd.date_range(start='2024-09-01', periods=10, freq='D'),   # 10 days
    'consumption': [310, 315, 308, 320, 490, 485, 480, 312, 318, 310]         # MWh; spike on days 5-7
})

# Sort by date — always required
energy_df = energy_df.sort_values('date').reset_index(drop=True)

# Lag features: specific historical reference points
energy_df['lag_1'] = energy_df['consumption'].shift(1)   # yesterday's consumption
energy_df['lag_7'] = energy_df['consumption'].shift(7)   # same day last week

# Rolling feature: 3-day smoothed average — reduces day-to-day noise
energy_df['roll_mean_3d'] = energy_df['consumption'].rolling(window=3, min_periods=1).mean()

# Derived feature: today vs rolling mean — how far is today from the recent smooth baseline?
energy_df['deviation_from_trend'] = energy_df['consumption'] - energy_df['roll_mean_3d']

# Derived feature: today vs lag_1 — raw day-over-day delta
energy_df['delta_vs_yesterday'] = energy_df['consumption'] - energy_df['lag_1']

# Round everything to 1 decimal place
energy_df = energy_df.round(1)

# Print selected columns for clarity
print(energy_df[['date','consumption','lag_1','roll_mean_3d','deviation_from_trend','delta_vs_yesterday']].to_string(index=False))