Four-Month Applied Machine Learning Blueprint

Complete a 10–15 line NumPy exercise using indexing, boolean masks, reshaping, and broadcasting.

Complete a 10–15 line Pandas exercise that loads a table, selects and filters rows, sorts values, and creates a derived column.

Correct missing values, duplicate rows, incorrect data types, and malformed dates in a small Pandas DataFrame.

Aggregate tabular data by grouping categories and applying appropriate summary functions with Pandas groupby.

Combine related datasets by key columns and distinguish the results of inner, left, and outer Pandas merges.

Implement mean squared error from its mathematical definition using pure NumPy.

Implement a numerically stable sigmoid activation function using pure NumPy and test it on extreme inputs.

Implement a pure NumPy gradient-descent loop for a simple linear model and verify that it reduces mean squared error on synthetic data.

Load the UCI Online Retail dataset into a reproducible notebook and create a data dictionary for its fields.

Profile the dataset by quantifying missingness, duplicates, invalid types, cancelled orders, and implausible values.

Apply and justify a reproducible cleaning policy without silently discarding problematic records.

Calculate univariate summaries and flag numerical outliers using an explicitly stated rule.

Create at least six correctly labelled plots covering distributions, categories, time trends, and customer or product concentration.

Measure and visualize at least three relationships that could support a business hypothesis.

Write three evidence-backed findings while distinguishing associations from causal claims.

Produce an EDA report that reruns without errors, documents every cleaning decision, contains at least six plots and three validated findings, and leaves no unexplained schema errors.

Given a tabular business brief, create a compact problem specification identifying the features, target, prediction type, prediction time, and primary evaluation metric.

Create reproducible train, validation, and test partitions while preserving class proportions when appropriate.

Implement standard scaling from training-set means and standard deviations in a 10–15 line NumPy exercise, then apply the learned values to validation data.

Implement min–max scaling from training-set extrema in a 10–15 line NumPy exercise, then apply the learned values to validation data.

Build a compact scikit-learn Pipeline and ColumnTransformer exercise that prevents preprocessing leakage across data splits.

Compute precision, recall, and F1 from confusion-matrix counts without metric helper functions.

Compute MAE and R² from their formulas and contrast their behavior with the previously implemented MSE on the same predictions.

Construct ROC points across classification thresholds and approximate ROC-AUC with the trapezoidal rule.

Fit a scikit-learn linear regression model and interpret its predictions, coefficients, and residuals.

Construct a logistic-regression design matrix and generate class probabilities with pure NumPy matrix operations.

Implement binary cross-entropy and its vectorized parameter gradients using pure NumPy.

Fit a logistic regression model with a pure NumPy gradient-descent loop and verify that its loss decreases.

Convert logistic probabilities into class labels and compare the from-scratch model with scikit-learn on held-out data.

Train a decision tree and trace one prediction through its learned split rules.

Explain how an SVM’s margin, C parameter, and kernel affect its decision boundary.

Train linear and kernel SVM classifiers inside leakage-safe preprocessing pipelines.

Define leakage-safe targets, data splits, baselines, and success metrics for Ames Housing regression and Adult Income classification.

Build reusable numeric and categorical preprocessing with imputation, encoding, and scaling for both datasets.

Create and document at least three defensible derived features for the Ames Housing task.

Create and document at least two defensible derived features for the Adult Income task.

Compare at least two regression estimators against a DummyRegressor using identical validation folds.

Compare logistic regression, a decision tree, and an SVM against a DummyClassifier using identical stratified folds.

Refit each selected model using the available training data and evaluate it exactly once on its untouched test set.

Pass the checkpoint by improving regression MAE over the dummy by at least 15% and achieving classification ROC-AUC of at least 0.75, with every raw feature processed or explicitly excluded and justified.

Calculate Gini impurity and weighted split impurity for a candidate decision-tree split in a 10–15 line exercise.

Generate a bootstrap sample and identify its out-of-bag observations using NumPy.

Assign observations to their nearest K-Means centroid using vectorized distance calculations.

Update K-Means centroids from cluster assignments, calculate inertia, and detect convergence.

Standardize a matrix and compute its principal directions from the covariance matrix.

Calculate PCA explained-variance ratios, select the smallest component count meeting a variance target, and project standardized records onto those components.

Compare a majority-class baseline with ROC-AUC and precision–recall metrics on an imbalanced label set.

Generate stratified cross-validation folds and verify the class proportion in every fold.

Implement a decision stump that searches candidate thresholds using weighted Gini impurity.

Implement prediction logic for the fitted decision stump and test it on boundary and unseen-value cases.

Implement hard voting over predictions from multiple fitted classifiers.

Implement soft voting over aligned class-probability outputs from multiple fitted classifiers.

Train a random forest and compare its validation performance and stability with a single decision tree.

Explain how sequential error correction distinguishes gradient boosting from bagging and independent voting.

Train an XGBoost classifier with an explicit evaluation metric, controlled random seed, and bounded computational settings.

Train a LightGBM classifier with an explicit evaluation metric, controlled random seed, and bounded computational settings.

Frame prediction on the UCI Bank Marketing dataset at campaign-planning time, create a stratified holdout set, and exclude duration or other fields unavailable at that prediction time.

Establish class-frequency, logistic-regression, and random-forest baselines using stratified five-fold cross-validation.

Configure class weights or scale_pos_weight without altering the validation folds’ natural class distribution.

Define compact, computationally bounded search spaces for XGBoost and LightGBM hyperparameters.

Tune XGBoost and LightGBM with the same stratified folds and average-precision scoring.

Compare cross-validated average precision, ROC-AUC, recall, training time, and score variability for all candidates.

Choose a decision threshold from out-of-fold training predictions and evaluate the final model exactly once on the untouched holdout set.

Pass the checkpoint with no resampling or temporal leakage, complete five-fold results, holdout ROC-AUC of at least 0.80, and average precision at least twice the positive-class prevalence.

Complete a compact exercise that serializes and reloads a fitted pipeline with Joblib, then verifies prediction parity on fixed records.

Complete a compact exercise that serializes and reloads a small Python object with Pickle and identifies its security and versioning limitations.

Define a Pydantic request model with required fields, numerical ranges, allowed categories, and optional values.

Validate correct and incorrect JSON payloads and interpret Pydantic’s structured error output.

Route missing feature values through the fitted preprocessing pipeline without introducing training-serving inconsistency.

Build the request-parsing portion of a bare-bones POST handler with Python’s standard-library HTTP server.

Complete and test the standard-library handler so it returns either a model prediction or a structured client error.

Implement and test a FastAPI prediction endpoint that returns a typed response and appropriate HTTP status codes.

Frame default prediction on the German Credit dataset with a documented target, prediction time, error costs, and acceptance metrics.

Audit feature meanings and construct a leakage-safe stratified train-test split.

Build a single serialized preprocessing-and-model pipeline that accepts raw credit-applicant fields.

Compare logistic regression, random forest, and one boosted model using identical stratified cross-validation folds.

Select a classification threshold from out-of-fold training predictions using an explicit false-negative versus false-positive cost assumption.

Evaluate discrimination, calibration, confusion-matrix metrics, and expected cost exactly once on the untouched test set.

Expose credit-risk probability and risk class through a validated FastAPI endpoint with structured error handling.

Pass the project checkpoint with test ROC-AUC of at least 0.70, documented threshold costs, identical pre- and post-serialization predictions, and successful tests for valid, missing, out-of-range, and malformed requests.

Frame churn prediction on the IBM Telco Customer Churn dataset and define a transparent revenue-impact assumption.

Audit the data and create a leakage-safe stratified train-test split with a documented customer-identifier policy.

Build a serialized preprocessing-and-model pipeline that accepts raw customer account fields.

Compare logistic regression, random forest, XGBoost, and LightGBM using identical stratified folds.

Select a churn threshold using out-of-fold training predictions and a stated retention-capacity constraint.

Estimate revenue at risk and potential retained revenue from churn probabilities using documented assumptions.

Expose churn probability, churn class, and estimated revenue impact through a validated endpoint in the same local FastAPI application as the credit-risk service.

Pass the final checkpoint with test ROC-AUC of at least 0.80, recall of at least 0.70 at the chosen threshold, serialization parity, both portfolio endpoints available in one locally runnable application, generated API documentation, startup instructions, and successful valid and invalid request tests.