Getting everything ready for you…

Loading courses, problems and your progress. This takes just a moment.

0s

Roadmaps › Data & AI

Data Science & Machine Learning Roadmap

From Python and maths to machine learning, deep learning and deploying models — with projects that get you hired as a data scientist or ML engineer.

Level: Beginner → Advanced · Duration: 8–10 months

Step 1: Python for data

Every data science tool speaks Python. Get fluent before touching ML.

Python is the language of data science: pandas, scikit-learn, PyTorch and almost every tutorial use it. You need to write clean scripts and notebooks comfortably before learning models.

  • Core syntax, functions and comprehensions
  • Lists, dictionaries and sets
  • Classes, modules and virtual environments
  • Working in Jupyter or Google Colab

Resources: Python documentation · ▶ Python for Beginners

Python basics

Variables, loops, functions, comprehensions.

Start with the building blocks you will use in every notebook.

  • Variables, types and f-strings
  • if/else, for and while loops
  • Functions, default and keyword arguments
  • List and dict comprehensions

Resources: Notes: Python Basics

Data structures

Lists, dicts, sets and when to use each.

Choosing the right structure makes code shorter and faster — dicts for lookups, sets for uniqueness.

  • List slicing and sorting with key functions
  • Dict methods: get, items, setdefault
  • Sets for de-duplication and membership
  • Tuples and unpacking

Resources: Notes: Python Lists, Dicts and Sets

OOP & modules

Classes, files, virtual environments and packages.

Larger projects need structure: classes for models and helpers, modules to split code, and environments to pin library versions.

  • Classes, __init__ and methods
  • Importing your own modules
  • pip, venv and requirements.txt
  • Reading and writing files (CSV, JSON)

Resources: Notes: OOP in Python

Jupyter & Colab

Notebooks for exploring data step by step.

Notebooks mix code, output, charts and notes — perfect for exploring data. Colab gives you a free GPU for deep learning.

  • Cells, kernels and restarting
  • Markdown cells for explanations
  • Uploading data and mounting Drive in Colab
  • Turning a notebook into a clean script

Resources: Google Colab

Step 2: Maths for ML

Just enough maths to understand what models do.

You don't need a maths degree, but you must understand what a model optimises and why it works. Focus on intuition with small numeric examples.

  • Vectors and matrices
  • Derivatives and gradient descent
  • Probability distributions
  • Statistics for decisions

Resources: Khan Academy — Linear algebra

Linear algebra

Vectors, matrices, dot products.

Data is stored as matrices; models multiply them. Linear algebra explains features, weights and dimensionality reduction.

  • Vectors, dot product and norms
  • Matrix multiplication and transpose
  • Inverse and solving linear systems
  • Eigenvalues and eigenvectors (for PCA)

Calculus

Derivatives and gradients for optimisation.

Training a model means minimising a loss function — calculus tells you which direction reduces the loss.

  • Derivatives and the chain rule
  • Partial derivatives and gradients
  • Gradient descent and learning rate
  • Local vs global minima

Probability

Random variables, distributions, Bayes.

Models deal with uncertainty. Probability lets you reason about predictions, classifiers like Naive Bayes, and evaluation.

  • Conditional probability and Bayes' theorem
  • Discrete and continuous random variables
  • Normal, binomial and Poisson distributions
  • Expectation and variance

Resources: Notes: Probability Shortcuts

Statistics

Descriptive stats, hypothesis tests, confidence intervals.

Statistics tells you whether a pattern is real and how confident you can be — essential for A/B tests and model comparison.

  • Mean, median, variance, standard deviation
  • Sampling and the central limit theorem
  • Hypothesis testing and p-values
  • Confidence intervals and correlation

Resources: Data Analyst roadmap

Step 3: Data handling with NumPy & pandas

Load, clean, transform and summarise data.

Most of a data scientist's time goes into getting data into shape. NumPy and pandas are the tools for it.

  • Vectorised array operations
  • Selecting, filtering and grouping DataFrames
  • Cleaning messy data
  • Getting data out of SQL databases

Resources: Pandas & NumPy documentation · Pandas & NumPy cheat sheet · ▶ SQL Tutorial in Hindi

NumPy arrays

Vectorised maths and broadcasting.

NumPy arrays are fast, typed, n-dimensional arrays. Every ML library takes them as input.

  • Creating arrays, shapes and reshape
  • Indexing, slicing and boolean masks
  • Broadcasting and axis-wise operations
  • Random numbers with a fixed seed

pandas DataFrames

Select, filter, group, merge.

DataFrames are labelled tables — load a CSV and answer questions in a few lines.

  • read_csv, head, info, describe
  • loc, iloc and boolean filters
  • groupby, agg and pivot_table
  • merge and concat

Data cleaning

Missing values, types, duplicates, outliers.

Garbage in, garbage out. Clean data before trusting any model.

  • Handling missing values (drop, fill, impute)
  • Fixing types and parsing dates
  • Removing duplicates and outliers
  • Standardising text and categories

SQL for data

Most company data lives in databases.

Data scientists query production databases every day. SQL questions are also common in interviews.

  • SELECT, WHERE, GROUP BY, HAVING
  • JOINs
  • Window functions (ROW_NUMBER, RANK, running totals)
  • Loading query results into pandas

Resources: SQL practice · SQL documentation

Step 4: Visualisation & EDA

Exploratory data analysis: understand the data before modelling.

Exploratory data analysis finds patterns, errors and ideas for features before modelling. Good charts also explain results to non-technical people.

  • Choosing the right chart
  • Univariate and bivariate analysis
  • Spotting outliers and data issues
  • Communicating findings

Resources: Matplotlib · seaborn

Matplotlib & seaborn

Histograms, scatter, box and line plots.

Matplotlib draws any chart; seaborn makes statistical plots in one line.

  • Line, bar, histogram and scatter plots
  • Box plots and violin plots
  • Heatmaps of correlations
  • Titles, labels and subplots

EDA workflow

Questions → plots → findings.

A repeatable process keeps EDA focused instead of making random charts.

  • Write questions before plotting
  • Check distributions and missing values
  • Compare features against the target
  • Summarise insights in a short report

Dashboards (optional)

Power BI, Tableau or Streamlit apps.

Interactive dashboards let others explore data themselves.

  • Power BI or Tableau basics
  • Streamlit apps in Python
  • Filters and drill-downs

Step 5: Machine learning fundamentals

Supervised and unsupervised learning with scikit-learn.

Machine learning learns patterns from data to make predictions. Start with classic algorithms in scikit-learn — they solve most business problems.

  • Supervised vs unsupervised learning
  • Regression and classification algorithms
  • Tree-based ensembles
  • Clustering and dimensionality reduction

Resources: scikit-learn User Guide · ▶ 100 Days of Machine Learning

The ML workflow

Train/test split, fit, predict, evaluate.

Every project follows the same steps: define the problem, prepare data, train, evaluate, improve and deploy.

  • Train/validation/test splits
  • fit, predict and score in scikit-learn
  • Baselines to compare against
  • Pipelines that bundle preprocessing and model

Regression

Linear, polynomial, regularisation.

Regression predicts numbers — house prices, demand, delivery time.

  • Linear regression and its assumptions
  • Polynomial features
  • Ridge and Lasso regularisation
  • MAE, RMSE and R²

Classification

Logistic regression, KNN, SVM, decision trees.

Classification predicts categories — spam or not, churn or stay, disease or healthy.

  • Logistic regression and decision boundaries
  • K-nearest neighbours
  • Support vector machines
  • Decision trees and how they split

Ensembles

Random forest, gradient boosting, XGBoost.

Combining many trees gives the strongest models for tabular data — they win most Kaggle tabular competitions.

  • Bagging and random forests
  • Gradient boosting
  • XGBoost, LightGBM, CatBoost
  • Feature importance

Unsupervised learning

K-means, hierarchical clustering, PCA.

Without labels, find structure: customer segments, anomalies, compressed features.

  • K-means and choosing k (elbow, silhouette)
  • Hierarchical clustering
  • PCA for dimensionality reduction
  • Anomaly detection basics

Step 6: Model evaluation & feature engineering

Good features and honest evaluation matter more than fancy models.

A model that looks great on training data can fail in the real world. Honest evaluation and good features matter more than the algorithm.

  • Choosing the right metric
  • Cross-validation
  • Creating and transforming features
  • Tuning hyperparameters without leaking data

Metrics

Accuracy, precision, recall, F1, ROC-AUC, RMSE.

Accuracy misleads on imbalanced data (99% "not fraud" is useless). Pick metrics that match the business cost of errors.

  • Confusion matrix
  • Precision, recall and F1
  • ROC-AUC and PR curves
  • Regression metrics: MAE, RMSE, MAPE

Overfitting & validation

Cross-validation, bias–variance, regularisation.

Overfitting = memorising training data. Validation shows how the model behaves on unseen data.

  • Bias–variance trade-off
  • k-fold and stratified cross-validation
  • Learning curves
  • Regularisation and early stopping

Feature engineering

Encoding, scaling, new features, leakage.

Good features turn raw columns into signals the model can use.

  • One-hot and target encoding
  • Scaling and normalisation
  • Date, text and aggregate features
  • Avoiding data leakage

Hyperparameter tuning

Grid and random search, pipelines.

Hyperparameters (tree depth, learning rate) are set before training; tuning finds good values.

  • GridSearchCV and RandomizedSearchCV
  • Optuna / Bayesian optimisation
  • Tuning inside a pipeline
  • Keeping the test set untouched

Step 7: Deep learning

Neural networks for images, text and more.

Deep learning uses neural networks with many layers — the technology behind image recognition, speech and modern AI. Learn one framework well.

  • How neural networks learn
  • A framework: PyTorch or TensorFlow/Keras
  • Convolutional networks for images
  • Sequence models and attention

Resources: PyTorch Tutorials · TensorFlow Tutorials · ▶ 100 Days of Deep Learning

Neural network basics

Neurons, activations, loss, backpropagation.

A network is layers of weighted sums followed by non-linear activations, trained by backpropagation.

  • Perceptron, layers and activations (ReLU, sigmoid, softmax)
  • Loss functions (MSE, cross-entropy)
  • Backpropagation and optimisers (SGD, Adam)
  • Batch size, epochs, dropout

PyTorch or TensorFlow

Tensors, training loops, GPUs.

Pick one; the concepts transfer. PyTorch is the most popular in research and industry today.

  • Tensors and autograd
  • Datasets and DataLoaders
  • Writing a training loop
  • Training on a GPU

CNNs for images

Convolutions, pooling, transfer learning.

Convolutional neural networks learn visual features — edges, shapes, objects.

  • Convolutions, filters and pooling
  • Classic architectures (ResNet)
  • Data augmentation
  • Transfer learning with pretrained models

Sequence models

RNN/LSTM basics → attention.

Text, audio and time series are sequences; order matters.

  • RNNs and the vanishing gradient
  • LSTM and GRU
  • Attention mechanism
  • Time-series forecasting basics

Step 8: NLP & generative AI

Transformers and large language models power modern AI products.

Natural language processing and large language models are the fastest-growing part of AI jobs. Learn how transformers work and how to build apps on top of them.

  • Text representation
  • The transformer architecture
  • Building LLM-powered applications
  • Fine-tuning and evaluation

Resources: Hugging Face Course · ▶ Generative AI & Agentic AI

Text preprocessing

Tokenisation, embeddings.

Models need numbers, not words. Tokenisation and embeddings turn text into vectors.

  • Tokenisation (words, subwords, BPE)
  • Bag of words and TF-IDF
  • Word embeddings (word2vec, GloVe)
  • Sentence embeddings

Transformers

Attention, BERT, GPT-style models.

Transformers use self-attention to look at all words at once; BERT and GPT are built on them.

  • Self-attention and multi-head attention
  • Encoder (BERT) vs decoder (GPT) models
  • Hugging Face transformers library
  • Text classification with a pretrained model

LLM apps

Prompting, APIs, RAG with vector databases.

Most AI products call an LLM API and add your own data with retrieval-augmented generation (RAG).

  • Prompt design and structured outputs
  • Calling LLM APIs safely (keys, limits, costs)
  • Embeddings and vector databases
  • RAG: retrieve, then generate with sources

Fine-tuning (optional)

LoRA and evaluation of LLMs.

Fine-tuning adapts a model to your task or style when prompting is not enough.

  • Full fine-tuning vs LoRA/QLoRA
  • Preparing instruction datasets
  • Evaluating LLM outputs

Step 9: MLOps & deployment

A model only creates value when people can use it.

MLOps brings software engineering practices to ML: reproducible training, deployment, and monitoring in production.

  • Serving predictions through an API
  • Docker and cloud deployment
  • Tracking experiments and versions
  • Monitoring models after release

Resources: Flask documentation · Docker documentation

Serve a model as an API

Flask/FastAPI endpoint for predictions.

Wrap a trained model in a small web service so apps can request predictions.

  • Saving models with joblib / torch.save
  • A /predict endpoint with Flask or FastAPI
  • Input validation
  • Batch vs real-time prediction

Containers

Package with Docker, deploy to the cloud.

Docker makes your model service run identically on any machine or cloud.

  • Writing a Dockerfile for a Python service
  • Deploying to Render, AWS or GCP
  • Environment variables and secrets

Resources: AWS documentation

Experiment tracking

MLflow / Weights & Biases, versioning data and models.

Record every experiment so you know which data and parameters produced which model.

  • MLflow or Weights & Biases
  • Versioning data (DVC) and models
  • Reproducible training scripts

Monitoring (optional)

Data drift and retraining.

Real-world data changes; models silently get worse. Monitor and retrain.

  • Data and concept drift
  • Logging predictions and outcomes
  • Retraining triggers

Step 10: Projects & portfolio

Three projects with clean notebooks and a deployed demo.

Employers hire on proof. Three end-to-end projects with clear READMEs beat ten tutorial notebooks.

  • One deployed end-to-end project
  • Kaggle practice
  • Clear write-ups of your work
  • Interview preparation

Resources: Git documentation

End-to-end ML project

Real dataset → model → API → demo.

Pick a real problem with real data — then collect, clean, model, evaluate, deploy and explain it.

  • Choosing a problem and dataset
  • Clean, documented notebooks
  • A deployed demo (Streamlit / API)
  • Explaining results and limitations

Kaggle competitions

Learn from public notebooks and leaderboards.

Kaggle teaches practical tricks from the best practitioners.

  • Start with Getting Started competitions
  • Read top public notebooks
  • Submit, iterate, write up what you learned

Resources: Kaggle

Write about your work

GitHub README, blog post, LinkedIn.

Writing shows you understand your work and helps recruiters find you.

  • A strong GitHub README with results
  • Short blog posts or LinkedIn articles
  • Highlight impact with numbers

Interview prep (optional)

ML theory, statistics, SQL and a coding round.

Data science interviews mix statistics, ML theory, SQL, Python coding and case studies.

  • Explaining algorithms simply
  • SQL and pandas problems
  • Statistics and probability questions
  • Case study: how would you approach this business problem?

Resources: SQL practice · Mock interview