Machine Learning (Math + Models)
Derive core models. Evaluate correctly. Build strong baselines on real datasets.
Objective
Build mathematical and statistical foundations to derive classical ML models and apply them with correct evaluation discipline on real datasets.
View full curriculum
Who should take it
- B.Tech / BCA / MCA students starting ML the right way
- Professionals transitioning into ML engineering
- Learners who want derivations + reasoning, not API memorization
Prerequisites
- Basic Python programming
- High school-level algebra (comfortable with equations)
- Willingness to learn probability + linear algebra fundamentals
Mathematics covered
- Vectors, matrices, projections (ML geometry)
- Probability distributions, expectation, variance
- Maximum likelihood, MAP, regularization
- Bias–variance and generalization
- Convexity intuition, gradient-based optimization basics
Tools & technologies
- Python
- NumPy
- pandas
- scikit-learn
- Matplotlib
- Git/GitHub
Module-wise curriculum
Module 1 — ML foundations and evaluation discipline
- Train/validation/test splitting correctly
- Leakage detection, baselines, and sanity checks
- Metrics: accuracy, precision/recall, ROC-AUC, PR-AUC, calibration
Module 2 — Linear models (derivation-first)
- Linear regression: objective, normal equation, GD
- Regularization: ridge, lasso (intuition + effect)
- Logistic regression: likelihood, loss, decision boundary
Module 3 — Probabilistic view of ML
- MLE and MAP viewpoint
- Naive Bayes derivation and when it works
- Generative vs discriminative modeling mindset
Module 4 — Nonlinear classical ML
- kNN and geometry of similarity
- Decision trees: impurity, splits, overfitting control
- Ensembles: bagging, random forests, boosting intuition
Module 5 — Feature engineering + model diagnosis
- Scaling, encoding, missingness handling
- Error analysis: confusion regions, class imbalance strategies
- Ablations and controlled comparisons
Projects you will build
Project 1 — Real-world classification pipeline
- Dataset: tabular classification (real imbalance)
- Baselines + proper metrics + calibration
- Final report: model choice + failure modes
Project 2 — Regression + regularization study
- Bias–variance experiment
- Ridge vs Lasso analysis
- Ablation and report
Career roles unlocked
ML Intern (foundations)Data Analyst → ML transitionJunior ML Engineer (classical ML focus)
Deep Learning (Backprop from Scratch)
Understand gradients, training stability, and build modern neural systems.
Objective
Learn deep learning from first principles: backprop, optimization, regularization, and modern architectures with reproducible training practice.
View full curriculum
Who should take it
- Learners aiming for research internships or DL-heavy roles
- Students who want real understanding of backprop and training dynamics
- Engineers moving from classical ML to deep learning systems
Prerequisites
- Comfort with basic calculus (derivatives)
- Linear algebra basics (vectors/matrices)
- Python + NumPy (comfortable)
Mathematics covered
- Chain rule and computational graphs
- Gradient descent variants and stability intuition
- Regularization, dropout intuition, normalization
- Loss functions and decision surfaces
Tools & technologies
- Python
- PyTorch
- NumPy
- TensorBoard (basic)
- Git/GitHub
Module-wise curriculum
Module 1 — Backprop and optimization from scratch
- Neurons, activations, loss functions
- Backprop derivation with computational graph thinking
- GD, momentum, Adam: when/why they work
Module 2 — Training discipline
- Initialization, learning rate schedules
- Overfitting control: dropout, weight decay
- Debugging: exploding/vanishing gradients, saturation
Module 3 — CNNs (vision fundamentals)
- Convolutions, pooling, receptive fields
- Practical training recipes
- Transfer learning correctly
Module 4 — Sequence models
- RNN/LSTM intuition
- Attention basics
- Why Transformers dominate
Module 5 — Reproducible experiments
- Seeds, logging, comparisons
- Ablations
- Report writing with metrics
Projects you will build
Project 1 — CNN image classifier with rigorous evaluation
- Dataset with class imbalance
- Ablation: augmentations
- Error analysis + report
Project 2 — Attention-based text classifier
- Tokenization basics
- Metrics and failure cases
- Reproducible training logs
Career roles unlocked
Deep Learning InternComputer Vision / NLP Intern (foundations)ML Engineer (DL track)
Generative AI (Transformers, Diffusion, LLMs)
Mechanics-first GenAI: attention, transformers, diffusion intuition, and pipeline design.
Objective
Understand modern GenAI from the mechanics up: attention, transformers, LLM workflows, diffusion basics, and robust evaluation.
View full curriculum
Who should take it
- Advanced learners targeting GenAI roles or research
- Engineers who want to stop treating GenAI as a black box
- Students building serious GenAI portfolios
Prerequisites
- Deep Learning basics (training & backprop comfort)
- Linear algebra (matrices) + probability basics
- Python + PyTorch basics
Mathematics covered
- Attention as weighted aggregation (matrix view)
- Softmax geometry + stability
- Likelihood view of language modeling
- Diffusion intuition: noise schedules (high-level math)
Tools & technologies
- Python
- PyTorch
- Transformers ecosystem (usage)
- Vector search basics (conceptual)
- Git/GitHub
Module-wise curriculum
Module 1 — Attention and Transformers
- Self-attention (Q/K/V) mechanics
- Positional encoding intuition
- Transformer blocks and training signals
Module 2 — LLM workflows (engineering view)
- Prompting: structure and failure modes
- RAG: retrieval + grounding logic
- Evaluation: hallucination checks and test sets
Module 3 — Diffusion fundamentals (high-level mechanics)
- Noise intuition and denoising
- Schedulers (conceptual)
- Quality evaluation mindset
Module 4 — Safety and reliability (practical)
- Guardrails mindset
- Data + prompt risks
- Test-driven evaluation approach
Module 5 — Portfolio-grade GenAI pipelines
- Reproducible experiments
- Metrics + qualitative analysis
- Documentation discipline
Projects you will build
Project 1 — RAG QA system with evaluation
- Create a small eval set
- Measure groundedness
- Failure analysis + iteration log
Project 2 — Text generation quality study
- Prompt templates
- Error categories
- Report with examples + limits
Career roles unlocked
GenAI InternApplied LLM Engineer (junior)Research Intern (GenAI track foundations)
Data Science (Stats-first Approach)
Evidence-first decision making: statistics, experimentation, interpretation, and reporting.
Objective
Build a statistics-first foundation for data science: clean analysis, experimental thinking, interpretable modeling, and honest reporting.
View full curriculum
Who should take it
- Students aiming for DS internships and research-style analysis
- Professionals using data for decisions
- Learners who want statistics, not dashboards-only DS
Prerequisites
- Basic Python
- Comfort with algebra
- Willingness to learn probability/statistics properly
Mathematics covered
- Descriptive stats and distributions
- Confidence intervals and hypothesis testing (intuition + use)
- Correlation/causation discipline
- Sampling and bias
Tools & technologies
- Python
- pandas
- NumPy
- Matplotlib
- scikit-learn (light)
- Git/GitHub
Module-wise curriculum
Module 1 — Data cleaning and EDA (real discipline)
- Missingness, outliers, leakage
- EDA structure
- Assumption tracking
Module 2 — Statistics for DS
- Distributions and sampling
- CI and hypothesis testing
- Effect size thinking
Module 3 — Experimentation mindset
- A/B testing basics
- Confounders and pitfalls
- Interpreting results honestly
Module 4 — Interpretable models
- Linear/logistic models for interpretability
- Diagnostics
- Communication of uncertainty
Module 5 — Reporting and decision docs
- Write-up structure
- Plots that explain
- Decision-ready summaries
Projects you will build
Project 1 — EDA + evidence report on real dataset
- Structured notebook + report
- Assumptions + caveats
- Decision recommendations
Project 2 — Simple A/B analysis simulation
- Power intuition
- Pitfalls checklist
- Interpretation notes
Career roles unlocked
Data AnalystData Science Intern (foundations)Product/Business Analyst (rigorous)
Python for AI Engineers
Write reusable, testable, engineer-grade Python for ML systems.
Objective
Move from notebook-style coding to engineering-grade Python: structure, testing, reproducibility, and maintainable ML tooling.
View full curriculum
Who should take it
- Beginners who want a strong Python base for AI/ML
- Students building serious projects and GitHub portfolios
- Professionals who want clean, scalable code practices
Prerequisites
- Basic programming basics (variables, loops)
- Laptop + willingness to practice
Mathematics covered
- No heavy math required (engineering focus)
Tools & technologies
- Python
- Virtual envs
- pytest basics
- Git/GitHub
- Code organization patterns
Module-wise curriculum
Module 1 — Python foundations (fast, correct)
- Data types, functions
- File I/O
- Error handling
Module 2 — Clean code for ML projects
- Project structure
- Config patterns
- Logging discipline
Module 3 — Data work essentials
- NumPy basics
- pandas fundamentals
- Plotting basics
Module 4 — Testing + reliability
- pytest basics
- Edge cases
- Reproducible runs
Module 5 — Packaging mindset
- Reusable modules
- CLI basics (optional)
- Git workflow
Projects you will build
Project 1 — Reusable data processing package
- Clean modules
- Unit tests
- CLI-style runner (optional)
Project 2 — Small ML utility toolkit
- Metrics helpers
- Split utilities
- Logging + config
Career roles unlocked
Python Developer (ML track)ML Engineer (junior, tooling focus)Freelance automation + data work
Mathematics for Machine Learning
Linear Algebra, Probability, Calculus, Optimization — taught for ML use, not for exams.
Objective
Build ML-relevant mathematics with intuition-first explanations and direct links to models, objectives, and optimization.
View full curriculum
Who should take it
- Learners blocked by derivations and equations
- Students aiming for research/ML engineering roles
- Anyone who wants mathematical confidence for ML
Prerequisites
- High-school algebra
- Comfort with practice (this course is rigorous)
Mathematics covered
- Linear algebra for representations
- Probability for uncertainty
- Calculus for learning signals
- Optimization for training
Tools & technologies
- Python (light)
- NumPy (for intuition demos)
- Desmos-style plotting mindset (optional)
Module-wise curriculum
Module 1 — Linear Algebra for ML
- Vectors/matrices
- Projections
- Eigen/SVD intuition
Module 2 — Probability for ML
- Random variables
- Expectation/variance
- Common distributions
Module 3 — Calculus for ML
- Derivatives
- Gradients
- Chain rule intuition
Module 4 — Optimization fundamentals
- Gradient descent
- Regularization
- Constraints intuition
Module 5 — Connecting math to models
- Loss functions
- Likelihood view
- Stability/failure modes mindset
Projects you will build
Project 1 — Math-to-ML mini notebook series
- Each topic linked to an ML model
- Plots + intuition notes
- Clean explanations
Career roles unlocked
ML learner with strong foundationsResearch internship readiness (math base)Better performance in ML/DL courses
Choose the right starting point.
We’ll assess your background and recommend the path. If you want shortcuts, this is not the right fit.