Data Preparation

Track 1: Data quality profiling and schema discipline

Preparation errors are a top cause of downstream modeling failure and unstable results.

• - Validate column types, null patterns, duplicates, and unexpected value ranges first.
• - Define schema expectations early so ingestion and transformations remain auditable.
• - Check row counts and key integrity after each major transformation step.

Drill: Build a reusable data-quality checklist and run it at raw, intermediate, and final dataset stages.

Track 2: Missing data strategy

Imputation decisions can shift model behavior and metric conclusions.

• - Separate missingness mechanisms from imputation method choice.
• - Simple imputers are often strong baselines when paired with indicator features where appropriate.
• - Fit imputation logic only on training data to avoid leakage.

Drill: Compare median imputation, constant imputation, and row filtering on the same task and record validation impact.

Track 3: Encoding and data-type handling

Wrong encoding or type assumptions can inflate dimensionality and degrade performance.

• - Use encoding strategies that match cardinality and model class (for example one-hot vs ordinal).
• - Keep categorical and numeric pipelines explicit for repeatability.
• - In GPU workflows, verify cuDF data types and null semantics before heavy transformations.

Drill: Create a column-wise transformation plan and justify each encoding choice with model compatibility.

Track 4: Feature scaling and transformation

Scale-sensitive models and distance-based methods depend on consistent feature ranges.

• - Standardization and normalization solve different problems; choose by algorithm behavior.
• - Skewed distributions may require log or power transformations before scaling.
• - Fit all scaling parameters on training split only and reuse on validation/test.

Drill: Run a model with unscaled, standardized, and normalized features and explain metric differences.

Track 5: Outliers, imbalance, and robust preparation

Outliers and minority classes can dominate error patterns if untreated.

• - Use robust statistics and plots to detect outlier influence before clipping or transformation.
• - Address class imbalance with stratified splits and, when justified, resampling strategies.
• - Track every outlier or resampling rule so results remain reproducible.

Drill: Document one outlier policy and one imbalance policy, then compare with a no-adjustment baseline.

Track 6: I/O-aware preparation pipelines

Preparation throughput can bottleneck end-to-end training and iteration speed.

• - Parquet is typically preferred for columnar projection and predicate pushdown.
• - JSON Lines parsing should be configured for file-size profile and ingestion path.
• - Use repeatable pipeline orchestration and environment pinning for stable reruns.

Drill: Build one preparation pipeline that ingests raw data, applies transformations, and writes clean Parquet with audit metadata.

Exam Decision Hierarchy

Prioritize decisions in this order: safety and hardware integrity, baseline consistency, controlled validation, then optimization.

• - If integrity checks fail, stop optimization and remediate first.
• - Compare against known-good baseline before changing multiple variables.
• - Document rationale for each decision to support incident replay.

Operational Evidence Standard

Treat every key action as evidence-producing: command, output, timestamp, and expected vs observed behavior.

• - Evidence should be reproducible by another engineer.
• - Use stable command templates for repeated environments.
• - Keep concise but complete validation artifacts for exam-style reasoning.

Split-first preparation discipline

Preparation logic must be fit on training data only; anything else risks leakage and inflated metrics.

• - Perform train/validation/test split before fitting imputers, scalers, and encoders.
• - Reuse train-fitted transformers for validation/test and production inference.
• - Log transformation artifacts and version hashes for reproducibility.

Feature-type aware transformation design

Preparation quality improves when numeric and categorical paths are explicit and auditable.

• - Use separate pipelines per feature family with documented rationale.
• - Select encodings based on cardinality and model behavior, not habit.
• - Track dtype and null semantics through each transformation stage.

Robustness against outliers and imbalance

Preparation decisions should stabilize model behavior under skew, outliers, and minority-class scarcity.

• - Use robust stats to detect heavy tails before scaling decisions.
• - Prefer stratified splits for classification imbalance.
• - Validate outlier/imbalance treatments with before/after metric impact.

Scenario A: Validation score collapses after production deployment

A model looked strong in validation, but production quality dropped immediately. You need to assess preparation leakage or transformation mismatch.

[Raw Data] -> [Split] -> [Train-fitted Transformers] -> [Model]
                    |
          [Artifact Registry + Inference Reuse]

python - <<'PY'
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
X_train, X_valid, y_train, y_valid = train_test_split(X, y, stratify=y, test_size=0.2, random_state=42)
pipe = Pipeline([...])
pipe.fit(X_train, y_train)
print('valid_score=', pipe.score(X_valid, y_valid))
PY

valid_score= 0.812

Scenario B: Encoding choices cause training instability and huge memory use

One-hot encoding on high-cardinality fields produced feature explosion and unstable training runtime.

[Raw Categorical Features] -> [Cardinality Audit] -> [Encoding Policy]
                                            |
                              [Memory + Metric Validation]

Data quality contract runbook

Validate schema, missingness, and duplicate behavior before transformation.

python - <<'PY'
import pandas as pd
df = pd.read_parquet('raw.parquet')
print(df.isna().mean().sort_values(ascending=False).head(10))
print('dupes=', df.duplicated().sum())
PY

feature_x 0.23
feature_y 0.08
dupes= 1042

python - <<'PY'
expected = {'age':'int64','country':'object','target':'int64'}
for c,t in expected.items():
    print(c, t)
PY

age int64
country object
target int64

• - Run this before fitting any preprocessing pipeline.
• - Persist report artifacts for reproducibility.

Leakage-safe preprocessing runbook

Train and validate with split-safe transformations.

python - <<'PY'
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
num_pipe = Pipeline([('imputer', SimpleImputer(strategy='median')), ('scaler', StandardScaler())])
cat_pipe = Pipeline([('imputer', SimpleImputer(strategy='most_frequent')), ('enc', OneHotEncoder(handle_unknown='ignore'))])
pre = ColumnTransformer([('num', num_pipe, num_cols), ('cat', cat_pipe, cat_cols)])
print(pre)
PY

ColumnTransformer(...)

python - <<'PY'
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,stratify=y,test_size=0.2,random_state=42)
print(y_train.mean(), y_test.mean())
PY

0.184 0.185

• - If class proportions diverge strongly, revisit split strategy before training.
• - Keep fitted preprocessors versioned with model artifact.

Hidden leakage through preprocessing fitted on full dataset

Feature explosion from naive categorical encoding

Walkthrough A: Build a leakage-safe preprocessing pipeline

Construct and validate train-only fitted transforms with reproducible artifacts.

1. Run stratified split before any imputation or scaling.

   python - <<'PY'
   from sklearn.model_selection import train_test_split
   X_train, X_temp, y_train, y_temp = train_test_split(X, y, stratify=y, test_size=0.3, random_state=42)
   X_valid, X_test, y_valid, y_test = train_test_split(X_temp, y_temp, stratify=y_temp, test_size=0.5, random_state=42)
   print(len(X_train), len(X_valid), len(X_test))
   PY

   Expected: Split sizes and class ratio look consistent across partitions.

2. Fit preprocessing only on train, then transform validation/test.

   Expected: No fitting step consumes validation/test data.

3. Persist transformer artifact and attach version metadata.

   Expected: Inference path can load the same artifact without retraining.

Walkthrough B: Outlier and imbalance policy calibration

Compare robust preparation policies under skewed and imbalanced conditions.

1. Create baseline with no outlier/imbalance interventions.

   Expected: Reference metrics are captured for comparison.

2. Apply one outlier policy and one imbalance policy, then retrain.

   Expected: You measure changes in minority-class metrics and overall stability.

3. Select final policy using reproducible metric evidence.

   Expected: Policy decision includes tradeoff notes and deployment implications.

Lab A: Data quality contract

Formalize deterministic quality checks before feature engineering.

• - Implement checks for null thresholds, duplicates, and value-range violations.
• - Fail pipeline early when contract conditions are broken.
• - Record quality metrics for each data version.

python - <<'PY'
import pandas as pd
df = pd.read_parquet('raw.parquet')
print(df.isna().mean().sort_values(ascending=False).head(10))
print('dupes=', df.duplicated().sum())
PY

feature_x 0.23
feature_y 0.08
dupes= 1042

Lab B: Leakage-safe transformation pipeline

Build split-aware preprocessing flow with explicit train-only fitting.

• - Split data first, then fit imputers/scalers on train only.
• - Apply identical fitted transforms to validation/test.
• - Verify that no target-derived information leaks into features.

python - <<'PY'
expected = {'age':'int64','country':'object','target':'int64'}
for c,t in expected.items():
    print(c, t)
PY

age int64
country object
target int64

Lab C: Imbalance and outlier handling

Compare robust preparation strategies under skewed target distribution.

• - Run stratified split and establish baseline metrics.
• - Apply one imbalance strategy and one outlier strategy.
• - Evaluate whether changes improve minority-class behavior without overfitting.

python - <<'PY'
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
num_pipe = Pipeline([('imputer', SimpleImputer(strategy='median')), ('scaler', StandardScaler())])
cat_pipe = Pipeline([('imputer', SimpleImputer(strategy='most_frequent')), ('enc', OneHotEncoder(handle_unknown='ignore'))])
pre = ColumnTransformer([('num', num_pipe, num_cols), ('cat', cat_pipe, cat_cols)])
print(pre)
PY

ColumnTransformer(...)

Lab D: I/O and format optimization

Improve preprocessing throughput while preserving data fidelity.

• - Benchmark JSON Lines ingestion and Parquet read/write behavior.
• - Compare compression choices for storage and read performance tradeoffs.
• - Document preferred preparation storage format for your workload.

python - <<'PY'
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,stratify=y,test_size=0.2,random_state=42)
print(y_train.mean(), y_test.mean())
PY

0.184 0.185