Courses
AI & Data ScienceFree

Machine Learning Fundamentals

From "what is a label" to defending a deployed system — the forty-lesson path through modelling, evaluation, tuning, production and interviews

10 modules40 lessons13 hr 31 minIntermediate
Intermediate
40 lessons in 10 modules
13h 31m of material
40 challenges
English audio
English captions
Certificate on completion

What you'll get

  • Verifiable certificate

  • XP on the leaderboard

  • Capstone defence project

Your certificate

TTieEduCertificate of Completionawarded toyour nameMachine Learning FundamentalsProfessional Tier

Preview of the certificate this course issues. Yours will carry your name, score and a verifiable serial — signed, not editable.

What you will build

Defend an end-to-end ML system

Pick one problem with real (or realistic) tabular data and produce the full artefact set the course taught, then defend it. (1) The one-page decision spec: decision and decision-maker, unit, prediction time, label with timing rule, three features with availability timestamps, two deliberately banned features with reasons, capacity or cost constraint, offline metric, baselines (base rate, current rule, simple model), guardrails, and ship criteria — all written before your first training run and dated. (2) The leakage audit: the banned-feature list, the label-shuffle test result (shuffled labels must collapse to baseline), and the preprocessing order proving every data-dependent step fitted on the training fold inside a Pipeline. (3) The evaluation report: the split you chose and why (stratified / time-ordered / grouped), cross-validation with mean and spread, tuning with a stated budget and the selection-inflation arithmetic applied to your own search, final sealed-holdout numbers against the baselines, a disaggregated table with sample sizes (pre-registered slices with floors), calibration where probabilities matter, and a written error analysis of at least ten real mistakes. (4) The model card: all nine sections filled with real content, versioned to your model, including named out-of-scope uses and an expiry with retrain triggers. (5) The operations plan: monitoring layers with thresholds and owners (data quality, input and score PSI, slice metrics on label cadence, ops), the backfill-and-diff check for training-serving skew, release ladder (shadow/canary/ramp with rollback), and the fairness metrics for any group a reviewer would ask about, with the harm rationale for the metric you chose. (6) The rules-versus-ML justification: cost and capacity arithmetic showing why ML (or rules) wins your case, with payback. (7) The human-in-the-loop design: abstention band sized to review capacity and the measure you would use to prove human+model beats each alone. Close with a recorded ten-minute defence answering the standard attack sequence (leakage, split, skew, noise, drift, fairness) from your own work — every claim a reviewer could attack already has a procedure and a receipt.

You will submit: A public or shareable repository (or linked document) containing the spec, the notebooks or scripts with their outputs, the model card, the monitoring plan — plus a link to a recorded 10-minute defence (any screen-recording link works).

What Machine Learning Solves: Regression, Classification, Clustering, Ranking

The four task families every ML practitioner must recognise on sight, with the output type, evaluation metric, and real examples of each.

What you will learn
  • Classify any ML proposal as regression, classification, clustering, or ranking and state its output type
  • Name an appropriate evaluation metric for each of the four task families
  • Turn a vague business request into a concrete ML task specification
  • Explain why the task family determines the model family you may even consider

An interviewer slides a sheet of paper across the table: "We have click data from our shopping app. Build us AI." That is all. The correct next question is not "which algorithm?" — it is "do you want a number per user, a yes/no flag per session, hidden groups of users, or an ordered feed?" Four different answers, four different datasets, four different metrics, four different careers. Choosing the task family is the first technical decision in every ML project, and most bad projects die right here, before a single line of model code.

Every ML problem is one of four shapes. The field looks infinite in its applications and surprisingly narrow in its task types. Strip any ML project proposal down and you will almost always find one of four shapes underneath: predict a number (regression), predict a category (classification), discover hidden groups (clustering), or produce an ordered list (ranking). Learning to see the shape instantly is the single highest-leverage skill in the foundation stage — because the shape decides your label format, your loss function, your metrics, your model shortlist, and what "success" even means.

Regression — predict a continuous quantity. The label is a number on a continuous scale, and you want a number out. How much will this house sell for? How many minutes until the courier arrives? What will tomorrow's peak electricity demand be? The model outputs ŷ ∈ ℝ, and evaluation compares prediction to truth with error measures in the original units: MAE (mean absolute error — average rupee-sized miss, robust to outliers), MSE/RMSE (squared error — punishes big misses harder; RMSE puts the penalty back in original units), and R² (what fraction of the target's variance your model explains; 0 means no better than predicting the mean). Regression models the magnitude of an outcome. A classic beginner mistake is treating a discrete-count target ("how many complaints next month?") as either trivially regression or trivially classification — counts are their own family (Poisson-flavoured), but plain regression is a defensible first baseline when counts are large.

Classification — predict a discrete label. The label is one of a small set of categories. Binary: spam or not, default or not, tumor malignant or not. Multiclass: which digit (0–9), which department will this ticket go to, which disease. The model outputs either a hard label or a probability per class, and evaluation uses accuracy (only when classes are balanced — more on the trap in Module 2), precision/recall/F1 (the workhorses when costs are asymmetric), and ROC-AUC / PR-AUC (threshold-free ranking quality). Note the tight relationship: a binary classifier that outputs probabilities is really producing a continuous score, and you threshold it to a label. That threshold is a business decision — catching fraud at 0.5 versus 0.1 catches different amounts of fraud and generates different amounts of false alarms.

Clustering — discover structure without labels. No one hands you the answer; the goal is to find groups that are internally similar and externally different. Customer segmentation by purchase behaviour, grouping sensor faults into failure types, organising documents into topics before anyone has a taxonomy. The output is a partition (or soft membership) of your data, and evaluation is the field's eternal pain: there is usually no ground truth to score against. Practitioners use internal measures (silhouette — how much closer points are to their own cluster than to the nearest other one), stability checks (does the clustering survive resampling?), and, most importantly, domain usefulness — does a human look at the segments and say "yes, these are real, actionable groups?" Clustering is a lens for human decision-making, not an answer machine.

Ranking — order items by relevance. The task is not "is this relevant?" in isolation but "given a query and a pool of candidates, produce the best order". Search results, recommender feeds, document retrieval, ad ordering. Ranking is built from classification-like relevance judgements but evaluated as sequences: precision@k (of the top k shown, how many are relevant), MAP (mean average precision across queries), NDCG (discounted gain — early positions matter more, graded relevance allowed). A system can be excellent at classifying each item independently and terrible at ranking if it does not calibrate scores across items. Ranking deserves its own lesson (and often its own engineer) precisely because the unit of quality is the list, not the item.

How to decide, in practice. Ask the stakeholder one question: "what will you do differently, per what unit?" A price on each house → regression per house. A red flag on each transaction → classification per transaction. A segment for a marketing campaign → clustering per customer cohort. A reordered home feed → ranking per session. Then write the one-sentence spec: predict [label] from [features available at prediction time] for [unit], evaluated by [metric] on [held-out data]. If you cannot fill in that sentence, you do not yet have an ML problem — you have a conversation you have not finished.

The four task families at a glance
FamilyOutputClassic metricsReal examples
RegressionA continuous numberMAE, RMSE, R²House price, ETA in minutes, demand forecast
ClassificationA category (or probability per category)F1, precision/recall, ROC-AUCSpam, fraud, disease, ticket routing
ClusteringGroup assignments / membershipsSilhouette, stability, domain usefulnessCustomer segments, document topics, fault types
RankingAn ordered listprecision@k, MAP, NDCGSearch results, recommender feed, ad order
Recommendation is usually ranking

When someone says "build a recommender", the ML core is almost always a ranking problem: score candidate items for a user, then order them. The scoring model may be collaborative filtering, a gradient booster, or an LLM — the evaluation unit is still the ordered list.

Write the spec sentence before touching data

Predict [label] from [features available at prediction time] for [unit], evaluated by [metric] on [held-out data]. Every blank you cannot fill is a decision you are postponing — and postponed decisions become leaky pipelines.

Classify five proposals into task families
A campus tech club receives five project proposals. For each, decide the family, the output unit, and a sensible primary metric.
  1. 1

    (a) "Estimate each delivery rider's remaining time, in minutes"

    Regression — output is continuous minutes per delivery. Metric: MAE (easy to explain: "off by 6.2 minutes on average") or RMSE if large misses are extra costly.

  2. 2

    (b) "Flag each payment as fraud or not fraud, for the review queue"

    Binary classification per transaction — but note the output used operationally is a score sorted into a queue, so PR-AUC and precision@queue-length matter more than raw accuracy (fraud is rare).

  3. 3

    (c) "Group our 40,000 members into behaviourally distinct clusters for a newsletter test"

    Clustering — no labels exist; output is group memberships per member. Metric: silhouette plus human validation that segments are actionable.

  4. 4

    (d) "Order job-internship matches on each student's home screen"

    Ranking — each student session gets an ordered list of internship cards. Metric: NDCG@10 or click-based precision@5.

  5. 5

    (e) "Predict how many lab-session no-shows the department will have next month"

    Regression on a count (or a dedicated count model later). Unit: no-shows per month. Metric: MAE on held-out months. Count-specific: Poisson deviance is the specialised upgrade — know it exists, start with MAE.

Solution

(a) regression · (b) classification · (c) clustering · (d) ranking · (e) regression (count-flavoured). Notice how each answer immediately implies a different label format, a different metric, and a different failure conversation with the stakeholder — the algorithm was never the deciding factor.

Decompose three real requests

Find three data-ish requests in your own life or campus ("predict exam results", "improve our club's Instagram", "reduce canteen queues"). For each: write the spec sentence, name the family, and state one metric you would argue for in the meeting. If a request is not ML-shaped at all, say so — "just average last year's numbers" is often the winning answer.

Hint: If there is no label and no evaluation story, it may be a dashboard, an A/B test, or a rule — not an ML problem.

Common mistakes
  • Jumping to algorithms before fixing the task family

    The family determines the loss, metric, and shortlist. "Use a neural net" is never the first decision; "regression on minutes, MAE, features from trip history" is.

  • Using accuracy for a rare-event classification problem

    99% accuracy by always predicting "not fraud" on 1% fraud data is worthless. Use precision/recall/F1 or PR-AUC, and state the business cost of each error type.

  • Treating clustering output as ground truth

    Clusters are hypotheses for humans to validate. If no downstream decision changes based on the segments, the clustering has zero value regardless of its silhouette score.

  • Framing ranking as per-item classification and evaluating with accuracy

    The quality unit is the ordered list (precision@k, NDCG). Two systems with identical per-item AUC can differ hugely in top-of-list quality — that difference is the product.

Exam / interview angle

A telecom company wants to "use AI to reduce customer churn". Rewrite this as an ML task specification: name the family, the unit, the label, and a primary metric — and name one non-ML alternative that should be considered first.

Family: binary classification (churn / no-churn) per subscriber per month; operationally a risk score sorted into a retention-call queue. Label: cancelled within the next billing cycle (defined before modelling, from historical records). Features: usage trends, complaints, tenure, plan, payment delays — all available at scoring time. Primary metric: PR-AUC or precision@top-N-call-list (churn is rare, and the call list is finite), plus the business metric of retained revenue. Non-ML alternative: a rule like "call everyone with two consecutive late payments" — your model must beat that rule on the same cost basis, or it is decoration.

Source: Standard product-sense + ML framing question in analyst and ML-engineer screens.

Lesson summary
  • Four shapes cover almost all applied ML: regression (number), classification (label), clustering (groups), ranking (ordered list).
  • The shape fixes the label format, the loss, the metric, and the model shortlist — decide it first.
  • Regression uses MAE/RMSE/R²; classification uses F1/AUC; clustering uses internal measures plus human usefulness; ranking uses precision@k/MAP/NDCG.
  • Rare-event classification makes accuracy a trap; choose metrics that price false alarms and misses.
  • Write the spec sentence (predict X from Y for Z, evaluated by M) before touching a dataset.

What you will be able to do

  • Classify any prediction request into the right task family, paradigm and metric before writing a line of code
  • Build leakage-safe preprocessing (imputation, encoding, scaling, resampling) inside pipelines fitted on training folds only
  • Choose splits that match the data — stratified, time-ordered, grouped — and defend them with the label-shuffle test
  • Fit and interpret linear and logistic regression, from coefficients and odds ratios to the threshold that becomes a decision
  • Grow, regularise and ensemble trees: bootstrap and OOB, boosting residuals, and the extrapolation limit trees cannot cross
  • Select metrics from the cost of errors — confusion matrix, PR versus ROC at rare bases, MAE versus RMSE, calibration and cross-validated baselines
  • Diagnose bias and variance from learning curves and apply only the correct levers; tune with grid, random and Bayesian search without overfitting validation
  • Run k-means, hierarchical clustering, anomaly detection and PCA — choosing k, reading dendrograms, and stating what a 2-D embedding may claim
  • Monitor a deployed model for drift, skew and slice collapse, and reason about fairness metrics with their incompatibility limits
  • Scope, experiment, document (model card) and defend an end-to-end ML system — and answer the classic ten interview questions with arithmetic

About this course

Machine learning is a chain of decisions, and this course teaches the chain in order — forty lessons where every worked example has numbers you can check and every interview angle has a procedure behind it.

Module 1 — ML Foundations: Problems, Paradigms, and Honest Evaluation. The four task families matched to output types and metrics; supervised, unsupervised and reinforcement learning distinguished by feedback; features and labels with the prediction-time availability audit; the leakage taxonomy (target, contamination, temporal, entity) with the label-shuffle test and the baseline-first workflow.

Module 2 — Data Prep and EDA for ML. Target-first exploratory analysis in service of the model; missing-data mechanisms and imputation that fits on train only; one-hot, ordinal and target encoding with the leakage footgun, plus scaling and why distance models need it while trees do not; imbalance remedies with their bills, and stratified, time-ordered and group splits that match the data rather than the habit.

Modules 3 to 5 — the classical toolkit. Least-squares regression by hand and library, coefficient interpretation with multicollinearity caveats, squared-error loss and gradient descent walked step by step; ridge and lasso with standardisation, coefficient paths and the one-standard-error rule; logistic regression as log-odds modelling with sigmoid outputs, cross-entropy and thresholding. Then trees: greedy impurity reduction with Gini computed by hand, pruning, scale invariance and the extrapolation wall, bagging with feature randomness and out-of-bag scoring, boosting's residual chase with shrinkage. Finally k-nearest neighbours with the curse of dimensionality, naive Bayes with Laplace smoothing, SVM margins and kernels, and PCA as variance-maximising projection.

Module 6 — Evaluation: Choosing the Metric from the Cost of Errors. Precision, recall and F1 with a fraud example priced in rupees; ROC-AUC versus PR-AUC with the 100/9,900 arithmetic; MAE, MSE, RMSE and MAPE computed on the same residuals; cross-validation against baselines with group leakage exposed by honest folds.

Module 7 — Overfitting, Regularisation and Hyperparameter Tuning. Bias-squared plus variance plus noise as a computable decomposition; learning curves that decide whether to buy data or capacity; every regularisation lever across model families with the one-standard-error rule; grid, random and Bayesian search (Optuna) with budget arithmetic and selection inflation; permutation versus impurity importance and a leakage re-audit under tuning pressure.

Module 8 — Unsupervised Learning. Lloyd's algorithm by hand, scaling as a prerequisite, elbow/silhouette/downstream-lift for choosing k; hierarchical clustering with linkage failure modes and dendrogram cuts; anomaly detection with median/MAD robust statistics, isolation forests and thresholds set by alert budgets; PCA budgets with the trace check, and the strict claim list for t-SNE and UMAP.

Module 9 — ML in Production. Covariate, prior and concept drift with PSI computed by hand and a root-cause-first playbook; the six-layer monitoring stack, slice arithmetic that shows how averages hide collapse, and training-serving skew found by backfill-and-diff; fairness metrics computed per group with the incompatibility theorem and the harm-first selection rule; when rules beat ML, with cost and capacity arithmetic, and human-in-the-loop designed and measured.

Module 10 — The ML Lifecycle, Experimentation and Defending Your Work. Eight lifecycle gates with their artefacts, a churn problem framed end to end, experiment hygiene (pre-registration, SRM, power, guardrails and the best-of-N arithmetic), the nine-section model card, and the capstone: a ten-minute defence of your system under the standard attack sequence, closed by the classic ten interview questions.

The interview and exam angle runs through every lesson — "why does this split leak", "which metric and why", "your offline score is 0.95 and production is not, explain it" — the questions placement panels and semester exams actually ask, answerable from first principles rather than from flashcards.

Who this course is for

  • CSE / AIML / data-science students who need modelling fluency rather than API familiarity
  • Placement-prep students: ML interview rounds test exactly these forty lessons
  • Working analysts and engineers moving from dashboards and queries to deployed models
  • Career switchers who can code in Python and want a defensible machine-learning foundation

What you should know before you start

Anything here is assumed, not taught. If it is not on the list, the course explains it.

  • Python for AI (or equivalent): functions, pandas basics and running a scikit-learn script end to end
  • Basic statistics: mean, standard deviation, percentiles and simple probability
  • A tabular dataset you care about — the practice tasks run on real data, not toy arrays

Questions before you start

How much time does Machine Learning Fundamentals take?

The course is 10 modules and 40 lessons — about 13 hr 31 min of material in total. Lessons unlock in order, so the time it takes you depends on how much of each lesson you actually read.

Do I get a certificate?

Yes. Finish every lesson and a certificate is issued automatically. Its serial is public: anyone can check it at https://tieedu.com/verify without an account, and a revoked certificate stops verifying.

Is it really free?

Yes — this course is free, and there is nothing to buy to start it.

How is my progress tracked?

On the server, lesson by lesson. Time is credited at real-time speed and capped, so a lesson cannot be marked complete faster than it can be read. That is why the percentage survives a new device.

How do ratings work?

Only learners who finished the course can rate it, and the average shown is calculated from those ratings alone. A course nobody has finished yet carries no rating rather than a default one.

See all

Building Apps with LLMs

Intermediate · AI & Data Science

Architecture, API engineering, UX, context, tools, extraction, evaluation, safety and cost — forty lessons to shipping an LLM feature that survives production

10 modules40 lessons11 hr
FreeNew

Generative AI Essentials

Intermediate · AI & Data Science

Forty deep lessons from generative foundations to a production GenAI spec — mechanics, models, reliability, cost, applied pipelines, safety and compliance

10 modules40 lessons12 hr 30 min
FreeNew

Prompt Engineering Masterclass

Intermediate · AI & Data Science

From first principles to production: structure, few-shot teaching, reasoning, structured outputs, code, long context, agents, evaluation and a prompt pack you can defend

10 modules40 lessons10 hr 31 min
FreeNew

AI Literacy for Everyone

Beginner · AI & Data Science

From "what is AI" to a toolkit you actually run — how the models work, how to prompt them, how to verify what comes back, and how to keep your name on work you can defend

10 modules40 lessons10 hr 31 min
FreeNew

Free · lifetime access

Candidate Verified

Real interview questions verified by candidates placed at top tech firms.

View-Only PDF Security

Watermarked licensed PDFs, server-side unlock checks — no raw download paths.

Honest, Server-Driven

Pricing, coupons and unlocks are verified by the backend — no bypasses.

TieEdu — Learn, Evolve, Develop

© 2026 TieEdu Technologies. All rights reserved.

Built for placement season within India

Visitors who arrive through an email link are remembered with a first-party cookie so we can see which pages that mail led them to — never the other way round, never on login or admin pages, and never for anonymous visitors. Every email carries a one-click unsubscribe that stops both mailings and tracking.