AI and Machine Learning Background Questions

import torch.nn as nn, torchvision.models as models
model = models.resnet50(pretrained=True)
for p in model.parameters(): p.requires_grad = False
model.fc = nn.Sequential(
    nn.Linear(model.fc.in_features, 256),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(256, 10)
)
# Phase 2: unfreeze layer4
for p in model.layer4.parameters(): p.requires_grad = True

# ingestion: read raw events, upsert into TS store (e.g., parquet in S3 or timeseries DB)
def ingest(stream):
    batch = read_stream(stream)
    # normalize timestamps, timezone
    batch.timestamp = pd.to_datetime(batch.timestamp).dt.tz_convert('UTC')
    upsert_to_store(batch)

# align and fill missing timestamps per series
def resample_and_impute(df, freq='1H'):
    # df: columns [series_id,timestamp,value,...]
    df = df.set_index('timestamp')
    df = df.groupby('series_id').apply(lambda g:
        g['value'].resample(freq).asfreq())  # create missing rows
    # impute with last-known or model-based (no peeking)
    df['value'] = df.groupby('series_id')['value'].ffill().fillna(method='bfill')
    return df.reset_index()

# feature pipeline that guarantees no leakage: accepts cutoff time
def compute_features(df, cutoff, lags=[1,24,168], agg_windows=[24,168]):
    # df filtered to timestamps < cutoff
    df_past = df[df.timestamp < cutoff]
    feats = []
    for lag in lags:
        feats.append(df_past.groupby('series_id')['value'].shift(lag).rename(f'lag_{lag}'))
    for w in agg_windows:
        feats.append(df_past.groupby('series_id')['value'].rolling(window=w).mean().reset_index(level=0, drop=True).rename(f'roll_mean_{w}'))
    X = pd.concat(feats, axis=1).loc[df_past.index]
    return X

# rolling-window backtest
def rolling_backtest(df, model_fn, start, end, step, horizon):
    results=[]
    t = start
    while t + horizon <= end:
        train_cutoff = t
        val_cutoff = t + step
        X_train = compute_features(df, cutoff=train_cutoff)
        y_train = df[(df.timestamp>=train_cutoff - horizon) & (df.timestamp<train_cutoff)]['value']  # aligned target window
        model = model_fn().fit(X_train, y_train)
        X_val = compute_features(df, cutoff=val_cutoff)
        y_val = df[(df.timestamp>=val_cutoff) & (df.timestamp<val_cutoff+horizon)]['value']
        preds = model.predict(X_val)
        results.append(metric(y_val, preds))
        t += step
    return aggregate_metrics(results)

# retraining strategy + orchestration
# - schedule daily/weekly retrain via Airflow/Kubernetes cron
# - trigger retrain when: time since last retrain > T OR drift detected (data or performance)
# - keep model registry with versions, validation gate, canary rollout
def orchestrate_retrain():
    if time_to_retrain() or drift_detected():
        train_full_model()
        validate_on_holdout()
        push_to_registry_if_ok()
        deploy_canary()
        monitor_canary_metrics -> promote/rollback

# serving considerations for multiple resolutions
# - maintain precomputed feature store at base resolution (e.g., 1min/1H)
# - on request, upsample/downsample features with deterministic aggregations
# - support batch and realtime: online features (Redis/Feast) + offline recompute
# - avoid leakage by computing prediction time = now_cutoff and only reading features timestamp < now