Everyone is now expected to work alongside AI, almost nobody was taught what it actually is, and the gap between the two is where bad grades, bad hires and bad decisions happen. This course closes that gap in ten modules and forty lessons: first the honest technical foundation — what AI, machine learning and deep learning really mean, how a neural network learns, how a large language model reads text and predicts tokens, and how a frontier model is built from internet-scale pretraining through supervised fine-tuning to RLHF. Then the practical half: prompting that works (structure, system instructions, few-shot examples, step-by-step reasoning, iteration like debugging), the tools landscape (chat vs coding vs search, media generation, free vs paid vs local), and the everyday uses that matter — research, learning code, drafts, exam prep and resumes — each welded to a verification routine rather than a leap of faith.

The last stretch is the part most courses skip: limits and safety (hallucination, bias, privacy, academic integrity, deepfakes, the honest jobs picture) and then your own practice — workflows with humans placed where the stakes are, a prompt library you reuse, rubrics for judging output, and a short ethics code you wrote yourself. It ends with a capstone that is a real artifact, not a quiz: five AI use-cases you actually ran, ten prompts with before/after evidence, your verification checklist, one hallucination you caught, and the rules you will keep. The certificate is issued for that document, not for notes about it.

**Who this is for:** any student — any branch, technical or not — who uses (or is expected to use) AI tools and wants to know what they are doing when they do; placement-prep students who need AI literacy for aptitude rounds and interviews; working professionals who must supervise AI output rather than be supervised by it.

**What you need:** no mathematics, no programming, no prior AI course. A browser, and — for the practice lessons — access to any free AI chat tool. Everything else is taught here from first principles.

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

AI Literacy for Everyone

Every AI course starts by assuming you already speak Python. This one does not. It is the complete zero-to-first-model path in ten modules: the language itself (variables, strings, structures, functions, control flow, errors), the two libraries AI work actually runs on (NumPy at array speed, pandas on real tables), how to look at data without lying to yourself (honest charts, file and API workflows, a re-runnable cleaning pipeline), the statistics every model sits on (mean, variance, distributions, correlation versus causation), and finally scikit-learn — where you split honestly, beat a baseline, and read your first LinearRegression and DecisionTree with the numbers they deserve.

Every lesson follows the same nine steps (objective, hook, concept, worked example, practice task, common mistakes, exam/interview angle, four-question quiz, summary), so the format never becomes another thing to learn. The course ends with a capstone: one notebook, a stranger can run it top to bottom, and it goes from raw data to a defensible model verdict — the artifact you show, not the notes you took.

**Who this is for:** any student — any branch — who was told to "learn Python for AI" and wants one honest course that finishes with a real pipeline, not a certificate for watching videos.

**What you need:** a browser (Google Colab needs zero install) or any machine that can install Python 3.9+. No prior programming assumed.

Forty lessons from your first print() to a shipped end-to-end notebook — Python, NumPy, pandas, honest charts, core statistics and your first scikit-learn models

Python for AI

Most GenAI courses stop at the demo: a prompt that worked once, a slide about transformers, a list of tools. This one starts where those end. Forty lessons, ten modules, one exam bank and a capstone that forces the whole thing into a single defensible document — the spec you would actually put in front of a team.

It runs from the generative landscape (GANs, VAEs, diffusion, the transformer, foundation models) down into LLM mechanics — tokenization, embeddings, the sampling pipeline, the KV cache — then out to the decisions engineers actually make: open versus closed weights, small models versus frontier APIs, context windows, image/audio/video pipelines. From there it is reliability (hallucination, grounding, structured outputs, guardrails, evals), cost engineering (token arithmetic, caching, routing, quality-per-rupee), applied patterns (summarization that keeps the numbers, extraction, classification, code generation with tests as the oracle), safety and compliance (memorisation, copyright, data governance, DPDP and the EU AI Act), and a capstone that assembles all of it into a spec with a cost model, a failure register and a rollout plan.

**Who this is for:** anyone who has taken a basics GenAI course — or watched a demo — and wants the engineering underneath it. Developers shipping features, students preparing for AI rounds, product people who must evaluate a vendor's claim, and anyone tired of "the model said so".

**What you need:** basic AI literacy (you know what an LLM is and have used a chat assistant). No coding required — the Python snippets are read-only worked examples. You will write, not code, for the capstone.

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

Generative AI Essentials

Most people meet machine learning as a library call: fit, predict, submit. This course treats it as a discipline of decisions — which problem shape you have, which metric your errors actually cost, which split your data allows, when the number you are quoting is noise, and what happens to the model on the Tuesday after it ships. Forty lessons, ten modules, one level: intermediate, with Python and basic statistics assumed and nothing else waved through.

Modules 1 to 5 build the modelling core. Module 1 fixes vocabulary and honesty — the four task families, the three paradigms, features versus labels with prediction-time availability, the leakage taxonomy and the baseline you must beat. Module 2 is data work in service of a model: EDA with a purpose, missing data without leakage, encoding and scaling with the reasoning that explains why trees shrug, and surviving 99:1 datasets with splits that do not lie. Modules 3, 4 and 5 carry the classical toolkit — linear and logistic regression with hand-computed gradient steps and odds ratios, decision trees with Gini arithmetic, random forests and boosting, then k-nearest neighbours, naive Bayes, support vector machines and PCA.

Modules 6 and 7 turn modelling into evidence. Module 6 derives every metric from the cost of errors — the confusion matrix and its prices, PR versus ROC at rare base rates, MAE versus RMSE, cross-validation against baselines. Module 7 names the two failure modes and their levers (bias and variance, learning curves), the regularisation dial across model families, the three species of hyperparameter search with their budget arithmetic, and the honest reading of feature importance. Module 8 works without labels — k-means and choosing k honestly, hierarchical dendrograms, anomaly detection under an alert budget, and the strict list of sentences a t-SNE plot is allowed to claim. Module 9 is production: drift with PSI arithmetic and root-cause-first repair, the monitoring stack including slices and training-serving skew, fairness with its incompatibility limits, and the judgement of when rules beat models. Module 10 closes with the lifecycle itself, experimentation hygiene, the model card, and a capstone where you defend an end-to-end system under attack.

Every lesson runs the same nine steps — objective, hook, concept, worked example with real arithmetic, practice task, common mistakes, exam/interview angle, a four-question quiz, and a revision summary — and every module feeds a 30-question final-exam bank drawn as a balanced 15-question paper. You finish with a certificate gated on defending a real project, and with the classic interview questions answered from memory with numbers behind them.

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

Machine Learning Fundamentals

Deep learning is not a bag of architectures — it is one chain of ideas: the chain rule makes layers learn, scale makes gradient descent survive depth, convolutions and attention are two answers to the same locality-and-relationship problem, and every training run since 2015 is the same loop with better bookkeeping.

This advanced course walks that chain end to end in forty lessons across ten modules. Modules 1–5 build the foundations and the vision/sequence/transformer stack with hand-computable arithmetic at every step. Modules 6–10 go where most courses stop: embeddings and contrastive learning, the full LLM training pipeline (data, tokenizer, scaling laws, post-training), decoding and diffusion, PyTorch as an engineering system (autograd, data loops, AMP, checkpointing), and finally the economics — compression, serving, honest evaluation, and a capstone design document with every number attached.

**Who this is for:** final-year students and engineers who can already train a model with a tutorial and now want to know exactly what happens inside it — and to pass the interviews that ask.

Forty lessons from the perceptron to shipped transformers — backprop by hand, attention arithmetic, LLM training pipelines, PyTorch debugging, and a capstone you can defend line by line

Courses for AI-DS students

AI Literacy for Everyone

Python for AI

Generative AI Essentials

Machine Learning Fundamentals

Deep Learning with Neural Networks