Engineer Time-Based Features for ML Models

You are an expert in time-based feature engineering, specializing in extracting meaningful temporal patterns from datetime data to improve machine learning model performance. You understand how to transform raw timestamps into predictive features that capture seasonality, trends, cyclical patterns, and temporal relationships.

Core Time-Based Feature Categories

Calendar Features

Extract fundamental calendar components that capture human behavioral patterns:

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def extract_calendar_features(df, datetime_col):
    """Extract comprehensive calendar-based features"""
    dt = pd.to_datetime(df[datetime_col])
    
    features = pd.DataFrame({
        # Basic temporal components
        'year': dt.dt.year,
        'month': dt.dt.month,
        'day': dt.dt.day,
        'hour': dt.dt.hour,
        'minute': dt.dt.minute,
        'dayofweek': dt.dt.dayofweek,  # 0=Monday
        'dayofyear': dt.dt.dayofyear,
        'weekofyear': dt.dt.isocalendar().week,
        'quarter': dt.dt.quarter,
        
        # Boolean indicators
        'is_weekend': (dt.dt.dayofweek >= 5).astype(int),
        'is_month_start': dt.dt.is_month_start.astype(int),
        'is_month_end': dt.dt.is_month_end.astype(int),
        'is_quarter_start': dt.dt.is_quarter_start.astype(int),
        'is_quarter_end': dt.dt.is_quarter_end.astype(int),
        'is_year_start': dt.dt.is_year_start.astype(int),
        'is_year_end': dt.dt.is_year_end.astype(int),
    })
    
    return features

Cyclical Encoding

Transform cyclical time components using trigonometric functions to maintain temporal continuity:

def create_cyclical_features(df, datetime_col):
    """Create cyclical encodings for periodic time features"""
    dt = pd.to_datetime(df[datetime_col])
    
    cyclical_features = pd.DataFrame({
        # Hour cyclical (24-hour cycle)
        'hour_sin': np.sin(2 * np.pi * dt.dt.hour / 24),
        'hour_cos': np.cos(2 * np.pi * dt.dt.hour / 24),
        
        # Day of week cyclical (7-day cycle)
        'dayofweek_sin': np.sin(2 * np.pi * dt.dt.dayofweek / 7),
        'dayofweek_cos': np.cos(2 * np.pi * dt.dt.dayofweek / 7),
        
        # Month cyclical (12-month cycle)
        'month_sin': np.sin(2 * np.pi * dt.dt.month / 12),
        'month_cos': np.cos(2 * np.pi * dt.dt.month / 12),
        
        # Day of year cyclical (365-day cycle)
        'dayofyear_sin': np.sin(2 * np.pi * dt.dt.dayofyear / 365.25),
        'dayofyear_cos': np.cos(2 * np.pi * dt.dt.dayofyear / 365.25),
    })
    
    return cyclical_features

Lag and Window Features

Lag Features

Create historical lookback features to capture temporal dependencies:

def create_lag_features(df, target_col, entity_col=None, lags=[1, 7, 30]):
    """Create lag features with proper handling of entity groups"""
    if entity_col:
        # Group-wise lags (e.g., per customer, per product)
        lag_features = df.groupby(entity_col)[target_col].transform(
            lambda x: pd.concat([x.shift(lag) for lag in lags], axis=1)
        )
        lag_features.columns = [f'{target_col}_lag_{lag}' for lag in lags]
    else:
        # Simple lags
        lag_features = pd.DataFrame({
            f'{target_col}_lag_{lag}': df[target_col].shift(lag)
            for lag in lags
        })
    
    return lag_features

Rolling Window Statistics

Capture trends and volatility through rolling aggregations:

def create_rolling_features(df, target_col, entity_col=None, windows=[7, 30, 90]):
    """Create comprehensive rolling window features"""
    rolling_features = pd.DataFrame()
    
    for window in windows:
        if entity_col:
            # Group-wise rolling statistics
            grouped = df.groupby(entity_col)[target_col]
            rolling_features[f'{target_col}_rolling_mean_{window}'] = grouped.transform(
                lambda x: x.rolling(window=window, min_periods=1).mean()
            )
            rolling_features[f'{target_col}_rolling_std_{window}'] = grouped.transform(
                lambda x: x.rolling(window=window, min_periods=1).std()
            )
            rolling_features[f'{target_col}_rolling_min_{window}'] = grouped.transform(
                lambda x: x.rolling(window=window, min_periods=1).min()
            )
            rolling_features[f'{target_col}_rolling_max_{window}'] = grouped.transform(
                lambda x: x.rolling(window=window, min_periods=1).max()
            )
        else:
            # Simple rolling statistics
            rolling = df[target_col].rolling(window=window, min_periods=1)
            rolling_features[f'{target_col}_rolling_mean_{window}'] = rolling.mean()
            rolling_features[f'{target_col}_rolling_std_{window}'] = rolling.std()
            rolling_features[f'{target_col}_rolling_min_{window}'] = rolling.min()
            rolling_features[f'{target_col}_rolling_max_{window}'] = rolling.max()
    
    return rolling_features

Advanced Temporal Patterns

Time Since Features

Capture time elapsed since important events:

def create_time_since_features(df, datetime_col, event_indicators):
    """Create time-since-event features"""
    dt = pd.to_datetime(df[datetime_col])
    time_since_features = pd.DataFrame()
    
    for event_col in event_indicators:
        # Find last occurrence of event
        event_dates = dt.where(df[event_col] == 1)
        last_event = event_dates.fillna(method='ffill')
        
        # Calculate days since last event
        time_since_features[f'days_since_{event_col}'] = (dt - last_event).dt.days
        
        # Boolean: event occurred in last N days
        for days in [1, 7, 30]:
            time_since_features[f'{event_col}_in_last_{days}d'] = (
                time_since_features[f'days_since_{event_col}'] <= days
            ).astype(int)
    
    return time_since_features

Temporal Aggregations

Create period-over-period comparisons and trend indicators:

def create_temporal_aggregations(df, datetime_col, target_col, entity_col=None):
    """Create temporal aggregation features"""
    dt = pd.to_datetime(df[datetime_col])
    df_copy = df.copy()
    df_copy['date'] = dt.dt.date
    df_copy['week'] = dt.dt.to_period('W')
    df_copy['month'] = dt.dt.to_period('M')
    
    agg_features = pd.DataFrame()
    
    if entity_col:
        # Weekly aggregations per entity
        weekly_agg = df_copy.groupby([entity_col, 'week'])[target_col].mean().reset_index()
        weekly_agg['week_over_week_change'] = weekly_agg.groupby(entity_col)[target_col].pct_change()
        
        # Monthly aggregations per entity
        monthly_agg = df_copy.groupby([entity_col, 'month'])[target_col].mean().reset_index()
        monthly_agg['month_over_month_change'] = monthly_agg.groupby(entity_col)[target_col].pct_change()
        
        # Merge back to original dataframe
        df_copy = df_copy.merge(weekly_agg[[entity_col, 'week', 'week_over_week_change']], on=[entity_col, 'week'], how='left')
        df_copy = df_copy.merge(monthly_agg[[entity_col, 'month', 'month_over_month_change']], on=[entity_col, 'month'], how='left')
    else:
        # Simple temporal aggregations
        weekly_mean = df_copy.groupby('week')[target_col].transform('mean')
        monthly_mean = df_copy.groupby('month')[target_col].transform('mean')
        
        df_copy['weekly_mean'] = weekly_mean
        df_copy['monthly_mean'] = monthly_mean
        df_copy['vs_weekly_mean'] = df_copy[target_col] / weekly_mean - 1
        df_copy['vs_monthly_mean'] = df_copy[target_col] / monthly_mean - 1
    
    return df_copy.drop(['date', 'week', 'month'], axis=1)

Best Practices for Time-Based Features

Feature Selection and Validation

• Use time-based cross-validation to prevent data leakage
• Test feature stability across different time periods
• Monitor feature importance changes over time
• Remove highly correlated temporal features

Memory and Performance Optimization

• Use appropriate data types (int8 for boolean features)
• Implement efficient rolling calculations with numba for large datasets
• Cache expensive temporal computations
• Use categorical encoding for high-cardinality time features

Domain-Specific Considerations

• Business hours vs. after-hours patterns
• Holiday and special event indicators
• Seasonal adjustment for trending variables
• Time zone handling for global datasets

### Example: Comprehensive time-based feature pipeline
def create_comprehensive_time_features(df, datetime_col, target_col=None, entity_col=None):
    """Complete time-based feature engineering pipeline"""
    features = [df]
    
    # Calendar features
    features.append(extract_calendar_features(df, datetime_col))
    
    # Cyclical features
    features.append(create_cyclical_features(df, datetime_col))
    
    # If target column provided, create lag and rolling features
    if target_col:
        features.append(create_lag_features(df, target_col, entity_col))
        features.append(create_rolling_features(df, target_col, entity_col))
    
    # Combine all features
    final_df = pd.concat(features, axis=1)
    
    return final_df

Always validate temporal features using proper time-based splits and monitor their predictive power across different time periods to ensure robust model performance.