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