MediumTechnical

94 practiced

Explain the bias-variance trade-off in supervised learning. Discuss how model complexity, dataset size, regularization, and ensemble methods affect bias and variance. Include a short description of techniques to empirically estimate bias and variance on a regression task.

Sample Answer

The bias–variance trade-off describes how prediction error decomposes: expected squared error = (bias)^2 + variance + irreducible noise. Bias measures systematic error from wrong assumptions (underfitting); variance measures sensitivity to training-set fluctuations (overfitting).

Model complexity:- Increasing complexity (more parameters, deeper nets) usually reduces bias but increases variance.- Simple models (linear) have high bias, low variance; very flexible models (deep trees, high-degree polynomials) have low bias, high variance.

Dataset size:- More data reduces variance (models see more examples of true signal) and can allow higher-complexity models with manageable variance.- Small datasets exacerbate variance and often require simpler models or stronger regularization.

Regularization:- L1/L2, dropout, early stopping add bias (shrink coefficients or constrain function class) and reduce variance—used to move a model toward the sweet spot on the trade-off.- Strength of regularization is tuned (e.g., via cross-validation) to balance loss of fit vs. stability.

Ensemble methods:- Bagging (e.g., random forests) reduces variance by averaging many high-variance learners; bias stays similar.- Boosting can reduce bias by sequentially correcting errors but may increase variance if overly complex; proper regularization (shrinkage, early stopping) helps.

Empirical estimation on regression:- Learning curves: plot train and validation error vs. training set size. High gap (low train, high val) → high variance; both high → high bias.- Cross-validation / repeated CV: estimate average error and variability; large variability across folds indicates high variance.- Bootstrap bias–variance decomposition: for input x, train many models on bootstrap samples, compute average prediction f̄(x); estimate bias^2 = (f̄(x) − y_true)^2, variance = E[(f̂(x) − f̄(x))^2], average over test points.Practical tip: combine learning curves with CV and bootstrap to choose model complexity and regularization appropriate for production.

MediumTechnical

66 practiced

Write a SQL query (Postgres-compatible) to compute rolling features per user: last_7_day_sum and last_7_day_count of transaction amounts. Given table 'transactions(transaction_id PK, user_id INT, amount NUMERIC, occurred_at TIMESTAMP)'. Use window functions to produce for every transaction row the sum and count over the previous 7 days (inclusive). Show sample SQL and explain assumptions about late-arriving events.

Sample Answer

Approach: use a time-based window frame partitioned by user_id and ordered by occurred_at, using RANGE with an interval of 6 days preceding to include the current day (i.e., a 7-day inclusive window). Ensure an index on (user_id, occurred_at) for performance.

SQL (Postgres-compatible):

sql

SELECT
  transaction_id,
  user_id,
  amount,
  occurred_at,
  SUM(amount) OVER (
    PARTITION BY user_id
    ORDER BY occurred_at
    RANGE BETWEEN INTERVAL '6 days' PRECEDING AND CURRENT ROW
  ) AS last_7_day_sum,
  COUNT(*) OVER (
    PARTITION BY user_id
    ORDER BY occurred_at
    RANGE BETWEEN INTERVAL '6 days' PRECEDING AND CURRENT ROW
  ) AS last_7_day_count
FROM transactions;

Key points / assumptions:- "7 days" here means the 7×24-hour window ending at the transaction's occurred_at (inclusive). If you want calendar days, adjust by truncating occurred_at to date and use INTERVAL '6 days' on dates.- RANGE works with timestamps in modern Postgres (ensure your version supports RANGE with interval).- For ties (multiple transactions at same timestamp) the frame includes them.

Late-arriving events:- If events can arrive late (ingestion time > occurred_at), computed features based on stored rows will change retroactively. Handle by: - Recomputing affected user's windowed features when late data is ingested (incremental upsert or materialized view refresh for that user and affected time range). - In streaming pipelines, use event-time processing with watermarks to decide allowed lateness; beyond that, treat as backfill and trigger recompute. - Maintain a materialized aggregate table keyed by (user_id, day) to reduce recompute scope and re-aggregate days when late events arrive.

Performance / production tips:- Index on (user_id, occurred_at) and consider batching or pre-aggregating by day/hour for high-volume users.

EasyTechnical

95 practiced

Explain precision, recall and F1-score for a binary classification problem. Provide the mathematical formulas (using TP, FP, TN, FN), discuss when F1 is more appropriate than accuracy, and describe when precision-recall curves are preferred over ROC curves (include a brief note about class imbalance). Provide a short example where precision matters more than recall.

MediumTechnical

78 practiced

Given an interactions log of (user_id, item_id, timestamp) for an implicit feedback recommender, implement a function generate_negative_samples(interactions: List[Tuple[int,int,int]], num_neg_per_pos: int=1, popularity_weighting: bool=True) -> List[Tuple[int,int,int,label]] that yields training triplets with label 1 for positives and 0 for negatives. Constraints: ensure negatives for a user are not items they've interacted with and scale to large datasets (discuss memory considerations).

Sample Answer

Approach: build a set of items each user has seen (to avoid false negatives), compute item popularity if weighting, then for each positive interaction sample num_neg_per_pos negative items (weighted or uniform) ensuring they’re not in the user’s interaction set. For large data return a generator or write to disk; avoid loading full expanded list into memory.

python

import random
from collections import defaultdict
from typing import List, Tuple, Iterable
import numpy as np

def generate_negative_samples(interactions: List[Tuple[int,int,int]],
                              num_neg_per_pos: int = 1,
                              popularity_weighting: bool = True) -> Iterable[Tuple[int,int,int,int]]:
    """
    Yields (user_id, item_id, timestamp, label) where label=1 for positives and 0 for negatives.
    interactions: list of (user_id, item_id, timestamp)
    """
    # Build user -> set(items) and item popularity
    user_items = defaultdict(set)
    item_counts = defaultdict(int)
    all_items = set()
    for u, i, t in interactions:
        user_items[u].add(i)
        item_counts[i] += 1
        all_items.add(i)
    item_list = np.array(list(all_items))
    if popularity_weighting:
        counts = np.array([item_counts[i] for i in item_list], dtype=float)
        probs = counts / counts.sum()
    else:
        probs = None  # uniform sampling from item_list

    # Precompute alias sampler only if popularity weighting (optional for huge item sets)
    # For simplicity use numpy.choice when probs provided; fallback to random.choice for uniform.
    for (u, i_pos, t) in interactions:
        # yield positive
        yield (u, i_pos, t, 1)
        negs = 0
        attempts = 0
        # sample negatives until we have num_neg_per_pos valid ones
        while negs < num_neg_per_pos:
            attempts += 1
            if popularity_weighting:
                i_neg = int(np.random.choice(item_list, p=probs))
            else:
                i_neg = random.choice(list(all_items))
            if i_neg in user_items[u]:
                # avoid items user already interacted with
                if attempts > 10 * num_neg_per_pos:
                    # if user interacted with most items, fall back to scanning for a valid item
                    for cand in item_list:
                        if cand not in user_items[u]:
                            i_neg = int(cand); break
                else:
                    continue
            yield (u, i_neg, t, 0)
            negs += 1

Key points:- Time: O(N * num_neg_per_pos) sampling steps; building maps O(N).- Space: storing user->items can be large (O(N) uniques). For very large datasets: - stream interactions and write negatives to disk (avoid building full output list). - store user-item sets in compressed form (sorted lists, bitsets) or use Bloom filters to test membership (probabilistic false positives -> fewer negatives). - sample items with an alias table or sharded sampling service for scale.- Edge cases: users who've interacted with nearly all items (handle fallback), empty interactions, num_neg_per_pos=0.- Improvements: build an alias sampler for weighted O(1) draws, use reservoir sampling for streaming, or generate negatives offline in distributed jobs (Spark).

MediumTechnical

74 practiced

Using scikit-learn, construct a Pipeline that imputes missing values for numeric columns, scales them, selects top-k features by mutual information with the target, and fits a RandomForestClassifier. Provide the Python code to build this Pipeline with ColumnTransformer handling different column sets. Explain how you would integrate this into cross-validation safely.

Sample Answer

Approach: build a sklearn Pipeline that (1) imputes numeric columns, (2) scales them, (3) applies SelectKBest(mutual_info_classif) to pick top-k features, and (4) fits a RandomForestClassifier. Use ColumnTransformer to apply numeric transforms only; pass other columns through or drop. Always keep feature selection inside the pipeline to avoid data leakage. Use GridSearchCV / cross_val_score with a CV splitter (StratifiedKFold) or nested CV for hyperparameter tuning.

python

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, mutual_info_classif
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, GridSearchCV, cross_val_score

# Example selectors: auto-detect numeric columns
num_selector = make_column_selector(dtype_include="number")

# Numeric preprocessing: impute -> scale
numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
    # feature selection applied later in overall pipeline (after ColumnTransformer)
])

# ColumnTransformer applies numeric pipeline; passthrough non-numeric or drop
preprocessor = ColumnTransformer([
    ("num", numeric_pipeline, num_selector),
], remainder="passthrough")  # or 'drop' if you don't want non-numeric

# Full pipeline: preprocessing -> feature selection -> classifier
pipe = Pipeline([
    ("preproc", preprocessor),
    ("selectk", SelectKBest(score_func=mutual_info_classif, k=10)),
    ("clf", RandomForestClassifier(n_estimators=100, random_state=42)),
])

# Safe cross-validation: use StratifiedKFold and GridSearchCV (feature selection inside pipeline)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
param_grid = {
    "selectk__k": [5, 10, 20],
    "clf__n_estimators": [100, 300],
    "clf__max_depth": [None, 10, 20],
}
grid = GridSearchCV(pipe, param_grid, cv=cv, scoring="roc_auc", n_jobs=-1)
# Fit:
# grid.fit(X_train, y_train)
# Evaluate with cross_val_score or nested CV for unbiased performance estimate:
# nested_scores = cross_val_score(grid, X, y, cv=StratifiedKFold(5), scoring="roc_auc")

Key points:- Put imputation, scaling, and feature selection inside the Pipeline to avoid leakage during CV.- Use SelectKBest(mutual_info_classif) because it handles non-linear relationships for classification.- For hyperparameter tuning, use GridSearchCV or RandomizedSearchCV with a proper CV splitter; for final unbiased estimate, use nested CV.

ML Domain-Specific Coding Challenges Questions

Sample Answer

Sample Answer

Sample Answer

Sample Answer

Sample Answer

Unlock Full Question Bank