Codebasics Statistical ML Build Framework

// When should you use the Codebasics Statistical ML Build Framework?

Use this skill whenever you have a labelled dataset and need a lightweight, fast, cost-effective prediction solution — especially when generative AI is overkill and a statistical model (regression, classification) will do the job. Ideal for numeric tabular data with clear input features and a defined target variable.

// What do you need before you start building a statistical ML model?

• Problem statementrequired
  What are you trying to predict? State the business context clearly (e.g. 'predict delivery time for a food platform').
• Dataset descriptionrequired
  What columns/features are available? What is the target (dependent) variable? Is it continuous (regression) or categorical (classification)?
• Task typerequired
  Is this regression, binary classification, or multiclass classification?
• Data quality notes
  Known issues: missing values, inconsistent formats, outliers, non-numeric columns that need encoding.
• Evaluation priority
  Which matters more — overall accuracy, precision, or recall? (e.g. fraud detection demands high recall)

// What core principles guide statistical machine learning with scikit-learn?

// How do you build and evaluate a production-ready ML model step by step?

1. 1

   Define the ML task type

   Ask: Is the target variable a continuous number (regression) or a category (classification)? If classification, is it binary (2 classes) or multiclass (3+)? This determines which algorithm family to use. Examples: predicting delivery time → regression; predicting spam/not-spam → binary classification; predicting flower species → multiclass classification.

2. 2

   Identify independent variables (features) and the dependent variable (target)

   Features = independent variables = the inputs your model will learn from. Target = dependent variable = what you are predicting. In code: X = df[feature_columns] (DataFrame, capital X because it can be multi-column). y = df[target_column] (Series, lowercase y). Confirm feature relevance to the prediction task before proceeding.

3. 3

   Audit and clean the data

   Scroll the raw data with your eyeballs first — you will immediately spot patterns. Then programmatically check for: (a) missing values / NaN, (b) inconsistent category labels (e.g. 'Male', 'M', 'm', 'MALE' all meaning the same thing), (c) outliers that are physically impossible (e.g. age = 200), (d) columns that are numeric but stored as strings (need type conversion), (e) question marks or placeholder values masking nulls. Fix these before splitting. Remember: data matters more than the model.

4. 4

   Split data into training set and test set using train_test_split

   Use sklearn.model_selection.train_test_split(X, y, test_size=0.2, random_state=42). A common split is 80% train / 20% test. Set random_state for reproducibility — without it, each run produces a different split, making benchmarking unreliable. Never touch the test set during training or feature engineering decisions.

5. 5

   Select and instantiate the correct algorithm

   Regression problems → LinearRegression (start here, especially for continuous numeric targets with linear relationships). Binary classification → LogisticRegression (despite the name, it is a classifier; applies a sigmoid/logit function on top of a linear model). Multiclass classification → LogisticRegression also handles this natively. Later in the course: Decision Trees, Random Forest, XGBoost, SVM, KNN, K-Means (unsupervised). Rule of thumb: start simple (linear/logistic), then upgrade if performance is insufficient.

6. 6

   Train the model by calling model.fit(X_train, y_train)

   This single call is where training happens. For LinearRegression it finds the best-fitting line by minimising Mean Squared Error (MSE) using gradient descent — an iterative mathematical technique that adjusts slope (m) and intercept (b) until error is minimised. For LogisticRegression it fits a linear model then applies the sigmoid function to squash output to [0, 1]. After fitting, inspect model.coef_ (the learned slopes/weights) and model.intercept_ to understand what the model learned.

7. 7

   Run inference using model.predict(X_new)

   Always pass a 2D array or DataFrame — sklearn expects this format even for a single prediction. For regression: output is a continuous number. For classification: output is the predicted class label. For probability scores in classification: use model.predict_proba(X_new) — returns probability per class, which is more informative than a hard label.

8. 8

   Evaluate model performance on the test set

   For regression: use model.score(X_test, y_test) → returns R² score (0 to 1; closer to 1 is better). Also compare train R² vs test R² — a large gap signals overfitting. For classification: (a) model.score(X_test, y_test) → overall accuracy, but do not stop here. (b) Print classification_report(y_test, y_pred) → shows precision, recall, and F1 per class. (c) Plot confusion_matrix(y_test, y_pred) → diagonal = correct predictions; off-diagonal = mistakes. Understand which type of error matters most for your use case before declaring the model ready.

9. 9

   Interpret precision, recall, and F1 against the business objective

   Precision (for a class): of all records the model labelled as this class, what fraction were truly that class? Start from predictions. Recall (for a class): of all records that truly belong to this class, what fraction did the model correctly identify? Start from ground truth. F1 = 2 × (precision × recall) / (precision + recall) — a single number balancing both. For fraud/medical/safety use cases, recall is typically more important (you cannot afford to miss true positives). For spam filtering, precision may matter more (false positives annoy users).

10. 10

    Iterate and practice with exercises before declaring completion

    Do not just watch — practice on a new dataset with a fresh problem statement. Watching without coding is like watching a pickleball coaching video and expecting to become an expert. Write the code yourself. Only submit your model to production once you have a test-set benchmark you are confident in.

// What are real examples of applying this ML framework?

// What mistakes should you avoid when building statistical ML models?

• Evaluating your model on training data instead of a held-out test set — this measures memorisation, not generalisation. Always use train_test_split and evaluate on X_test, y_test only.
• Relying on accuracy alone for imbalanced datasets. A dummy model that always predicts the majority class can score 99%+ accuracy while being completely useless. Always check precision, recall, F1, and confusion matrix.
• Passing a 1D array to model.predict() — sklearn expects a 2D array. Wrap single predictions in a list-of-lists or a DataFrame.
• Using LinearRegression for binary classification targets. The straight best-fit line is vulnerable to outliers that skew the decision boundary. Use LogisticRegression (sigmoid function) for classification tasks.
• Skipping data cleaning before training. Real-world data will have inconsistent category labels, impossible values, missing entries, and wrong types. Feeding messy data to a model produces unreliable output regardless of algorithm quality.
• Treating the model as more important than the data. 80% of time in real ML projects is data cleaning and preparation; model training is a small fraction. Underinvesting in data quality is the primary source of poor model performance in practice.
• Not setting random_state in train_test_split — without it, each run produces a different split, making benchmark comparisons meaningless and results non-reproducible.
• Confusing the two phases: training (model.fit) must always precede inference (model.predict). Never call predict before fit.
• Applying only Simple Linear Regression when multiple factors affect the target. Real-world problems almost always require Multiple Linear Regression with several features (independent variables) simultaneously.

// What are the key terms in statistical machine learning?

Statistical Machine Learning

The discipline of training machines on labelled data using mathematical/statistical algorithms (linear regression, logistic regression, decision trees, SVM, etc.) so they can make predictions without explicit programming. Lightweight, cheap to train, and highly relevant alongside generative AI.

Ground Truth / Labelled Dataset

A dataset where each record has both input features and the correct output label already assigned. This is what you feed to a supervised ML algorithm during training.

Training

The phase where you run model.fit(X_train, y_train) — the algorithm finds the best-fitting parameters (e.g. slope m and intercept b) by minimising error across the labelled dataset.

Inference

The phase where you call model.predict(X_new) on a trained model to produce predictions for unseen data.

Independent Variable (Feature)

An input variable used to make a prediction. Called a 'feature' in ML contexts. There can be many features simultaneously (Multiple Linear Regression). Represented as capital X — a DataFrame.

Dependent Variable (Target)

The variable you are trying to predict. It 'depends on' the features. Represented as lowercase y — a Series.

Gradient Descent

The core mathematical optimisation technique used during training to iteratively adjust model parameters (m and b) until the Mean Squared Error is minimised and the best-fitting line or boundary is found.

Mean Squared Error (MSE)

The loss function used in linear regression: average of squared differences between actual values (y) and predicted values (ŷ). Squaring prevents positive and negative errors from cancelling out and penalises large errors more heavily than Mean Absolute Error (MAE).

R² Score

The evaluation metric for regression models, ranging 0 to 1. Closer to 1 means the model explains the variance in the target variable well. Used via model.score(X_test, y_test).

Train-Test Split

The practice of dividing a labelled dataset into a training portion (e.g. 80%) used to fit the model, and a test portion (e.g. 20%) held out for unbiased evaluation. Implemented via sklearn's train_test_split.

Sigmoid / Logit Function

The mathematical function applied in logistic regression: f(x) = 1 / (1 + e^(-x)). It compresses any input number into a probability between 0 and 1, enabling classification. Makes the decision boundary robust to outliers that would skew a straight linear regression line.

Binary Classification

A classification task where the output has exactly two categories (e.g. fraud / not fraud, spam / not spam, has insurance / no insurance).

Multiclass Classification

A classification task where the output has three or more categories (e.g. flower species: setosa, versicolor, virginica; news categories: business, technology, entertainment).

Precision

Of all records the model predicted as a given class, what fraction were truly that class? Start from predictions. High precision means few false positives.

Recall

Of all records that truly belong to a given class, what fraction did the model correctly identify? Start from ground truth. High recall means few false negatives — critical for fraud, medical, or safety use cases.

F1 Score

A single metric combining precision and recall: F1 = 2 × (precision × recall) / (precision + recall). Useful when you need one number that balances both concerns.

Confusion Matrix

A grid showing correct and incorrect predictions per class. Diagonal entries = correct predictions; off-diagonal entries = mistakes. Gives an immediate visual clue about which types of errors the model is making.

Classification Report

The sklearn output from classification_report(y_true, y_pred) showing precision, recall, F1, and support for every class plus overall accuracy. Always use this instead of accuracy alone.

Multiple Linear Regression

Linear regression with more than one independent variable: y = m1*x1 + m2*x2 + ... + mn*xn + b. This is what real-world regression models look like — a single feature is rarely sufficient.

Coefficient (model.coef_)

The learned slope values (m) for each feature after training. Represents the contribution of each feature to the prediction — e.g. extra minutes per kilometre in a delivery time model.

Intercept (model.intercept_)

The learned constant (b) after training. Represents the baseline prediction when all features are zero — e.g. the fixed preparation time before a delivery driver even leaves.

// FREQUENTLY ASKED QUESTIONS