Machine Learning Fundamentals Roadmap

Objectives: Explain what a virtual environment is and why it is needed for machine learning projects.; Create and activate a virtual environment using venv.; Install packages with pip inside the isolated environment.; De

Objectives: Understand the difference between mutable and immutable data types in Python.; Explain how variables store references to objects in memory.; Predict the outcome of operations on lists, tuples, and strings bas

Objectives: Explain what control flow structures are and why they are essential in programming.; Differentiate between conditional branching and loops, and when to use each.; Choose between for and while loops based on w

Design pure functions with typed signatures and docstrings that transform tabular data, then trace variable resolution through local, enclosing, global, and built-in scopes.

Construct nested dictionaries and list comprehensions to represent a labeled dataset, then evaluate time-complexity trade-offs of lookup versus insertion operations.

Parse CSV and JSON files into native structures using the standard library, then defend error-handling strategies for missing values and malformed records.

Synthesize prior lessons into a single script that loads, cleans, summarizes, and visualizes a small CSV dataset with ASCII plots, producing a reusable template for Phase 2.

Articulate the distinction between numerical, categorical, and ordinal data types and explain how their inherent structure dictates the choice of visualization and preprocessing technique.

Derive and interpret measures of central tendency and dispersion from first principles to quantify the 'typical' value and spread of a dataset without relying on library black boxes.

Identify skewness, kurtosis, and multimodality in histograms and density plots to diagnose violations of normality assumptions before model selection.

Calculate Pearson and Spearman coefficients manually on a toy dataset to distinguish linear monotonic relationships from spurious correlations caused by outliers or non-linear dynamics.

Classify missingness as MCAR, MAR, or MNAR by visualizing nullity matrices and correlation heatmaps to justify an imputation strategy rather than defaulting to mean filling.

Apply the IQR method and Z-score thresholds on multivariate data to decide whether an extreme point represents noise, a data entry error, or a critical rare event worth preserving.

Synthesize profiling summaries, pair plots, and interactive widgets into a single reproducible notebook that communicates actionable insights and preprocessing decisions to a non-technical stakeholder.

Articulate why a straight line is a reasonable first model for predicting a continuous target from one feature, using the analogy of drawing a trend line through a scatter plot.

Explain the concept of a residual as the vertical gap between a data point and the prediction line, and describe how the pattern of residuals reveals whether the line captures the underlying trend.

Derive the sum of squared residuals as a single scalar loss function, and justify why squaring errors (rather than absolute values) leads to a unique, analytically solvable best-fit line.

Compute the optimal slope and intercept for simple linear regression using the normal equations, and interpret each term as a ratio of covariances to variances.

Implement batch gradient descent to minimize mean squared error, visualize the loss surface as a bowl, and articulate how the learning rate controls step size and convergence stability.

Evaluate fitted models using R-squared, residual plots, and hypothesis tests on coefficients, and diagnose violations of linearity, homoscedasticity, and independence assumptions.

Build an end-to-end linear regression pipeline that loads a housing dataset, engineers a single predictive feature, trains via both closed-form and gradient descent, validates assumptions, and exports predictions for uns

Visualize the loss surface as terrain and articulate why gradient descent follows the steepest downhill direction to minimize error.

Derive the gradient of mean squared error with respect to model parameters and explain how partial derivatives quantify parameter sensitivity.

Experiment with learning rate values to observe convergence, oscillation, and divergence, then formulate guidelines for rate selection.

Implement batch gradient descent from scratch using vectorized operations and verify parameter updates match analytical expectations.

Contrast stochastic updates with batch updates by plotting loss trajectories and explaining the noise-convergence trade-off.

Add momentum to the optimizer, visualize its dampening effect on oscillations, and justify why velocity terms escape shallow local minima.

Build a complete training pipeline that learns linear regression weights via gradient descent, logs loss curves, and exports the trained model for Phase 5.

Articulate how classification differs from regression by examining discrete label assignment through visual decision boundary diagrams before formalizing the categorical prediction task.

Derive the sigmoid function from linear regression outputs to explain probability calibration, then implement binary classification from scratch using gradient descent to surface why linear models require non-linear acti

Plot decision regions for logistic regression on synthetic 2D datasets to visually distinguish linear separability limits, then hypothesize how feature engineering or model complexity could resolve non-linear cases.

Calculate accuracy, precision, recall, and F1-score from a confusion matrix by manually tracing predictions on an imbalanced dataset, then justify metric selection for specific business contexts like medical diagnosis ve

Implement KNN from scratch using Euclidean distance to classify points by majority vote, then experiment with k values to articulate the bias-variance tradeoff through visual boundary smoothness changes.

Construct a decision tree by hand using entropy and information gain splits on a small dataset, then train sklearn's DecisionTreeClassifier to compare greedy splitting behavior against optimal boundaries.

Build an end-to-end classification system: preprocess a real dataset (e.g., breast cancer or iris), train logistic regression, KNN, and decision tree models, evaluate with cross-validation, and deploy the best model as a

Articulate why a model's performance on training data diverges from its performance on unseen data by analyzing the tension between memorization and pattern extraction.

Implement a train-test split protocol and justify the necessity of strict data separation to prevent information leakage during performance estimation.

Compare k-fold and stratified cross-validation approaches by reasoning through how each manages variance-bias tradeoffs in small-data regimes.

Select and compute precision, recall, F1-score, and ROC-AUC for a binary classifier, defending each metric choice against specific business cost asymmetries.

Interpret residual plots, MAE, RMSE, and R-squared to diagnose systematic prediction errors and quantify unexplained variance in continuous targets.

Diagnose high bias versus high variance by plotting training and validation error against dataset size, then prescribe data augmentation or model complexity adjustments.

Build a reusable evaluation module that automates cross-validated metric computation, statistical significance testing, and visual report generation for any scikit-learn estimator.

Articulate how axis-aligned splits partition feature space by tracing classification regions on a 2D scatter plot.

Compare Gini impurity and entropy on a toy dataset to explain why each quantifies node homogeneity differently.

Implement a greedy best-split search from scratch that recursively builds a tree until a stopping condition is met.

Visualize overfitting by plotting training versus validation accuracy across increasing max_depth values.

Design a one-hot versus ordinal encoding experiment to show how split logic changes for nominal features.

Implement surrogate splits and compare their predictions against mean imputation on a dataset with 20% missing entries.

Build a complete decision-tree pipeline — preprocessing, training, pruning, and rule extraction — that outputs human-readable if-then rules for a real-world dataset.

Articulate why combining diverse predictions reduces error, using a visual analogy of averaged guesses converging on a true value.

Explain how sampling with replacement and parallel training decorrelates base learners, then implement a bagged decision tree ensemble from scratch.

Analyze how restricting split candidates at each node increases tree diversity, and extend the bagging implementation into a Random Forest.

Contrast boosting's weighted re-training with bagging's independence, then build a simple AdaBoost loop that updates sample weights iteratively.

Derive the pseudo-residual gradient for a differentiable loss function and implement a gradient boosting decision tree step-by-step.

Design a stacking architecture where base model predictions become features for a meta-learner, and implement cross-validated prediction blending.

Integrate bagging, boosting, and stacking into a single pipeline that outperforms any individual model on a structured tabular dataset.