STEP 01
Live session
A working session with your mentor — not a recording. You ask questions as you hit them, and leave with the week's problem defined.
01
Live, not recorded
Become an ML Engineer
ML Engineering Mentorship Program
PrimrIQ AI Services LLP runs this programme from Noida, India. Train, evaluate, explain, and deploy machine learning models across 13 real Indian business problems. From data preparation and classical ML through deep learning, NLP, MLOps, and production monitoring.
8 months13 Projects + 2 CapstonesMentor-reviewed
Tools covered
PythonScikit-learnXGBoostLightGBMTensorFlowPyTorchBERTMLflowFastAPIDockerEvidently AI
Roles you’ll be ready for
ML EngineerData ScientistAI/ML DeveloperApplied Scientist
ML ENGINEERINGTrain it, tune it, defend the number.
Duration
8 months
Modules
12
Projects
13 Projects + 2 Capstones
Format
Live + labs
Level
Beginner to intermediate
The lab
This is the environment you work in.
Real consoles, a live brief, and a mentor reading what you submit. Not a video you watch.
SageMaker
ML ENGINEERINGTrain it, tune it, defend the number.
What a week actually looks like
Practice-first is easy to claim. Here's the machinery behind it.
STEP 02
Lab work
You open the browser lab and work on real, messy data. No setup, no environment config. Just the problem.
02
Real, messy data
STEP 03
Submit
You push your work — notebook, query, pipeline, dashboard — for review. Every submission, every week.
03
Every week
STEP 04
Mentor review
Your mentor reads it, grades it, and tells you what a senior would have done differently. That feedback is the actual product.
04
The actual product
12 modules. Every one ends in a project.
Each module includes a hands-on project. The final module contains your capstone assignments.
🚀 Opening weeksOpening Weeks — Python & Mathematics Foundations26 topics
No prior Python or mathematics assumed. These four weeks build the foundation every module runs on — Python from zero through the mathematical intuitions behind every ML algorithm.
Installing Python, Anaconda, and Jupyter Lab; virtual environments
Variables — integer, float, string, boolean — and why data types matter for data work
if, elif, else — conditional logic; comparison and logical operators
for loop, while loop, range(), break, continue
Defining functions — def, parameters, return, default argument values
Lists — indexing, slicing, append(), remove(), len(), list comprehensions
Dictionaries — key-value access, nested dicts, iteration
NumPy arrays — what they are and why Python lists are too slow for ML
Creating arrays — 1D (vector), 2D (matrix), shape, reshape, dtype
NumPy operations — element-wise arithmetic, boolean indexing, statistical functions
Pandas basics — reading a CSV, .head(), .info(), .describe(), .groupby()
pip install, import, try/except; Joblib — saving and loading trained models
What a function is: input → output — plotting y = mx + b
What slope is: rate of change — interpreting it in a business context
The idea of optimisation: finding the minimum of a cost curve
Gradient descent — the marble rolling down a hill; learning rate (too small vs too large)
Visualising gradient descent on a 2D loss curve; implementing from scratch in NumPy
Probability as a fraction; independent vs dependent events
Conditional probability — the most important concept in business ML
What a distribution is: shape of all possible outcomes; normal distribution
What a matrix is: a grid of numbers — your dataset is a matrix
Matrix addition, scalar multiplication, dot product — the fundamental ML operation
Mean Squared Error — squaring errors penalises big mistakes more
Cross-entropy loss — the loss function for classification problems
Bias: model too simple, misses the pattern; Variance: model memorised training data
The bias-variance tradeoff visualised: underfitting vs overfitting
Module 01Python for ML
Python proficiency tuned for ML work — NumPy broadcasting, Pandas for feature engineering, and the scikit-learn interface that all ML tools share.
What you cover
NumPy — ndarray creation, shape, reshape, transpose, broadcasting rules
NumPy operations — arithmetic, boolean indexing, np.where(), np.argmax(), np.argsort()
NumPy statistics — mean(), std(), var(), percentile(), corrcoef(), np.linalg for linear algebra
Pandas for ML — read_csv, read_excel, info(), describe(), value_counts(), isnull()
Pandas data manipulation — loc, iloc, merge, groupby, pivot_table, apply
Pandas for ML preprocessing — encoding categoricals, handling dates, feature extraction from strings
Matplotlib and Seaborn — histograms, boxplots, scatter plots, pairplots, heatmaps for EDA
Scikit-learn interface — fit(), transform(), predict() contract
train_test_split — why you must never train and test on the same data
The data leakage concept — fitting a scaler on the full dataset before splitting is wrong
Joblib — parallel processing for CPU-bound ML tasks, saving and loading models
Structured logging for ML experiments — tracking runs and errors
Module 02Mathematics for ML
The linear algebra, calculus, and probability that every ML algorithm is built on — taught with code alongside theory so concepts connect directly to implementation.
What you cover
Scalars, vectors, matrices, tensors — notation, shapes, dimensionality
Vector operations — addition, subtraction, dot product, cross product
Matrix multiplication — rules, shapes, computational complexity O(n³)
Identity matrix, inverse matrix — np.linalg.inv()
Eigenvalues and eigenvectors — Av = λv, np.linalg.eig(), geometric interpretation
Singular Value Decomposition (SVD) — U, Σ, Vᵀ decomposition, use in PCA
Norms — L1, L2, Frobenius — applications in regularisation
Cosine similarity — dot product / (norm × norm), use in text similarity
Derivatives, partial derivatives, gradient — vector pointing in direction of steepest ascent
Chain rule — derivative of composite functions, the basis of backpropagation
Gradient descent — learning rate, minima vs saddle points
Automatic differentiation — what autograd does, why we don't compute gradients manually
MLE, MAP, Bayes' theorem in ML — P(class | features) ∝ P(features | class) × P(class)
Entropy — H = −Σ p(x) log p(x), used in decision trees
Cross-entropy loss, KL divergence, bias-variance tradeoff
Module 03Data Preparation & Feature Engineering
Feature engineering is where most ML performance is won or lost — covers imputation, class imbalance, scaling, selection, and scikit-learn Pipeline construction.
What you cover
What missing data is and why it breaks models — choosing the right imputation strategy
SimpleImputer — strategy parameter, fit_transform, separate train/test imputation
IterativeImputer — multivariate imputation using other features as predictors
Outlier handling — IQR clipping, z-score removal, Isolation Forest
Class imbalance — why accuracy is misleading with skewed classes
SMOTE — synthetic minority oversampling, imblearn.over_sampling, SMOTE-NC for categorical
ADASYN — adaptive synthetic sampling
Undersampling — RandomUnderSampler, TomekLinks, EditedNearestNeighbours
Feature creation — domain-driven features, PolynomialFeatures, interaction terms
Binning — pd.cut() for equal-width, pd.qcut() for equal-frequency
Date/time features — hour, day, month, quarter, day of week, is_weekend
Aggregation features, lag features, log transformation, Box-Cox transformation
StandardScaler, MinMaxScaler, RobustScaler — when each is appropriate
When not to scale — tree-based models are scale-invariant
RFE, SelectFromModel, SelectKBest, mutual information, chi-squared
PCA — explained variance, scree plot, choosing n_components
Variance Inflation Factor (VIF) — detecting multicollinearity
scikit-learn Pipeline — chaining imputer → scaler → feature selector → model, preventing data leakage
Module 04Classical ML — Regression & Classification
Classical ML is not outdated — it is what most Indian companies use in production. Every major algorithm with proper evaluation and business-oriented metric selection.
What you cover
Linear regression — OLS, feature assumptions, normal equation, gradient descent
Ridge (L2), Lasso (L1), ElasticNet — penalties, when each applies
Polynomial regression — extending linear with polynomial features, overfitting risk
Regression metrics — MAE, MSE, RMSE, MAPE, R-squared, adjusted R-squared
Residual analysis — residuals vs fitted, Q-Q plot, Durbin-Watson
Logistic regression — sigmoid function, log-odds, decision boundary
Decision Trees — Gini impurity vs entropy, max_depth, min_samples_split
K-Nearest Neighbours — distance metrics, k selection, curse of dimensionality
Naive Bayes — Gaussian, Multinomial, Bernoulli variants
Support Vector Machines — maximum margin, C parameter, linear/polynomial/RBF kernels
Classification metrics — accuracy, precision, recall, F1, ROC-AUC, PR-AUC
When to use which metric — imbalanced data (use F1, PR-AUC)
Confusion matrix — TP, TN, FP, FN; threshold tuning based on business error cost
Cross-validation — k-fold, stratified k-fold, TimeSeriesSplit
GridSearchCV, RandomizedSearchCV, Optuna — hyperparameter optimisation
Learning curves — diagnosing bias vs variance
Module 05Clustering & Dimensionality Reduction
Unsupervised methods for customer segmentation, anomaly detection setup, and dimensionality reduction — with proper cluster evaluation, not just eyeballing.
What you cover
Why clustering exists — finding groups the business did not define in advance
K-Means — centroid algorithm, inertia, K-Means++ smarter initialisation
Selecting k — elbow method, silhouette score (range −1 to 1)
DBSCAN — density-based, arbitrary cluster shapes, eps, min_samples
Hierarchical clustering — agglomerative, linkage methods, dendrogram
Gaussian Mixture Models (GMM) — soft assignments, BIC for model selection
Cluster evaluation — silhouette, Davies-Bouldin index, Calinski-Harabasz index
PCA — principal components, explained variance ratio, scree plot
PCA for visualisation — projecting to 2D/3D for scatter plots
t-SNE — non-linear embedding, perplexity parameter, not for inference
UMAP — faster than t-SNE, preserves more global structure
Linear Discriminant Analysis (LDA) — supervised dimensionality reduction
Autoencoders — encoder/decoder neural network for unsupervised representation
Module 06Ensemble Methods & Boosting
Gradient boosting wins most tabular ML tasks. SHAP explains every prediction. Together they produce models that can be deployed and defended to business stakeholders.
What you cover
Why ensembles work — independence of errors, wisdom of crowds
Random Forest — n_estimators, max_features; feature importance (MDI, permutation)
Voting Classifier — hard/soft voting; StackingClassifier — meta-learner on out-of-fold predictions
XGBoost — regularised objective, n_estimators, max_depth, learning_rate; early stopping
XGBoost regularisation — lambda (L2), alpha (L1), min_child_weight, gamma
LightGBM — leaf-wise growth, histogram binning, native categorical support
CatBoost — ordered boosting, best out-of-box for tabular data
Optuna — Bayesian hyperparameter search for XGBoost and LightGBM
SHAP values — SHapley Additive exPlanations, feature attribution for any model
Global summary plot — which features matter most across all predictions
Waterfall plot — explaining a single prediction step by step
Dependence plot — how one feature's value affects the prediction
Using SHAP to defend model decisions to a risk committee in plain language
Module 07Deep Learning Fundamentals (TensorFlow)
Neural networks from foundations to CNNs and LSTMs — knowing when to use deep learning and how to train it properly is the skill.
What you cover
Artificial neuron — weighted sum + bias + activation function
Activation functions — ReLU, sigmoid, softmax, tanh, LeakyReLU, ELU, GELU
Forward pass, loss computation, backward pass (chain rule)
Adam optimiser — adaptive learning rates; learning rate schedules
Weight initialisation — Xavier/Glorot (sigmoid/tanh), He/Kaiming (ReLU)
Keras Sequential API and Functional API — model.compile(), model.fit()
Callbacks — ModelCheckpoint, EarlyStopping, ReduceLROnPlateau, TensorBoard
Regularisation — Dropout(rate), BatchNormalization, L1/L2 kernel_regularizer
Conv2D — filters, kernel_size, strides, padding; MaxPooling2D; GlobalAveragePooling2D
Transfer learning from EfficientNet and ResNet — freezing base layers, fine-tuning
Data augmentation — ImageDataGenerator, Keras image layers
LSTM — long short-term memory, cell state, forget/input/output gates
GRU, Bidirectional RNNs — return_sequences=True; time series with sliding window
Module 08Advanced Deep Learning & NLP (PyTorch)
PyTorch is the dominant framework at research and product companies. BERT fine-tuning is a baseline expectation for NLP roles in Indian tech.
What you cover
torch.Tensor — creation, dtype, device; arithmetic, matmul, reshape, view, transpose
Autograd — requires_grad=True, .backward(), .grad, zero_grad()
torch.nn.Module — __init__, forward(), parameters(), state_dict()
Optimisers — SGD, Adam, AdamW, lr_scheduler
Training loop — zero_grad → forward → loss → backward → optimizer.step()
Validation loop — model.eval(), torch.no_grad(); GPU training — .to(device)
DataLoader — Dataset class, __len__, __getitem__, batch_size, shuffle, num_workers
Attention mechanism — query, key, value, dot-product attention, scaling by √d_k
Self-attention, multi-head attention, positional encoding
BERT — bidirectional encoder, masked language modelling, [CLS] token for classification
Hugging Face pipeline() — text-classification, token-classification, summarization
AutoTokenizer — from_pretrained(), encode(), batch_encode_plus(), attention_mask, padding
Fine-tuning BERT — AutoModelForSequenceClassification, adding classification head
Trainer API — TrainingArguments, compute_metrics, train(), evaluate()
NER — AutoModelForTokenClassification, BIO tagging scheme
Semantic similarity — sentence-transformers, cosine similarity for sentence pairs
Module 09MLOps & Experiment Tracking
Reproducible experiments, versioned data, and registered models are the difference between a data science project and an ML Engineering practice.
What you cover
Why experiment tracking — reproducibility, comparing runs, auditability
mlflow.start_run(), log_param(), log_metric(), log_artifact(); autologging
MLflow UI — comparing runs, filtering; run naming, tagging, nested runs
MLflow Registry — stage transitions (None → Staging → Production → Archived)
DVC — dvc init, dvc add, dvc push/pull, dvc.yaml pipelines, data lineage
Weights & Biases — wandb.init(), wandb.log(), wandb.watch(), artifact lineage
Feast — local feature store, feature views, point-in-time correctness
Training vs serving skew — the risk when feature computation differs between environments
Great Expectations — data quality checks, expectations, validation results
pytest for ML — fixtures, parameterised tests; CI for ML — tests on every commit
Module 10Model Deployment
A model that is not deployed produces no value. A deployed model that is not monitored degrades silently. Both are covered.
What you cover
Online vs batch vs edge inference — when each is appropriate
Model loading at startup — lifespan context manager, loading once into memory
Pydantic input validation — feature schema, range checks, type enforcement
POST /predict — input features → model output → response schema
Batch prediction endpoint — vectorised inference; async serving, model warm-up
Response time logging — p50/p95/p99 latency metrics
BentoML — @bentoml.service, @bentoml.api, bentoml build, bentoml containerize
MLflow models serve — REST API from registered MLflow model
ML-specific Dockerfile — python:3.11-slim base, CUDA base for GPU models
Multi-stage builds, health checks, environment variables
Data drift — detecting when input feature distributions shift over time
Concept drift — model accuracy degrading because the relationship changed
Evidently AI — drift detection reports, data quality reports, model performance monitoring
Statistical tests — KS test (continuous), chi-squared (categorical), PSI
Feature monitoring — min, max, mean, null rate per feature per time window
Alerting — threshold-based triggers for drift severity
Module 11Capstone Projects
Two end-to-end systems demonstrating the full lifecycle from messy raw data to a deployed, monitored production endpoint.
What you cover
Capstone 1 — Replacing the Rulebook — An Explainable ML Credit Model an NBFC Risk Committee Can Actually Defend
Capstone 2 — Reading 500,000 Reviews So the Category Team Doesn't Have To — Sentiment, Aspects, and Auto-Responses
Both capstones produce a Docker container running locally
Model cards documenting intended use, performance, and known limitations
What you will learn
01Build end-to-end ML pipelines with scikit-learn Pipeline, preventing data leakage throughout
02Train and tune XGBoost, LightGBM, and CatBoost with Optuna hyperparameter search
03Explain every model prediction with global and local SHAP analysis
04Train CNNs with TensorFlow and fine-tune BERT with PyTorch for NLP tasks
05Track experiments reproducibly with MLflow and register models to Model Registry
06Deploy prediction endpoints as FastAPI applications containerised with Docker
07Monitor deployed models for data drift and concept drift using Evidently AI
08Handle class imbalance, evaluate with PR-AUC, and tune thresholds for real business costs
The questions people actually ask
Do I need a mathematics background?
Module 2 builds the necessary mathematics from scratch with code alongside every concept. A strong Class 12 maths foundation is sufficient — you do not need a statistics or engineering degree.
Is Python experience required before joining?
Basic Python familiarity is required — variables, loops, functions, and working in Jupyter notebooks. Module 1 builds the ML-specific proficiency from that foundation.
Will I actually deploy models or just train them?
Both capstones and two dedicated projects produce running FastAPI endpoints in Docker containers. Module 10 covers deployment and production monitoring as a full module.
How is this different from a Kaggle competition focus?
Kaggle focuses on leaderboard scores. This track focuses on production ML — feature pipelines that prevent data leakage, models tracked in MLflow, SHAP explanations for business stakeholders, and deployed endpoints with drift monitoring.
Is there a refund policy?
Yes. Attend the onboarding session and apply for a full refund within 7 days of purchase if you are not satisfied. No questions asked.
Published 14 August 2026 · Last updated 14 August 2026 · Written by Rishu Dwivedi, Founder, PrimrIQ
Do I need to know how to code before I start?
Every track opens with four weeks of Python and SQL foundations that assume nothing. If you have written code before, those weeks go quickly; if you have not, they are the reason the rest of the programme is reachable.
How much time should I plan for each week?
Eight to ten hours: one live session, lab work on your own schedule, and a submission your mentor reviews. Labs stay open, so a heavy week at college or work does not reset your progress.
What happens if I am not satisfied?
Attend, try the labs, and if it is not what you expected, apply for a full refund within seven days of purchase. No conditions beyond that.
Is the certificate worth anything to an employer?
The certificate is verifiable and states what you completed. What carries weight in an interview is the portfolio behind it — which is why every module ends in a project you can walk a hiring manager through line by line.
Do you guarantee a job at the end?
No, and we will not pretend otherwise. You get resume work, mock interviews and career guidance, plus real projects you can talk through in detail. Interviews are still yours to win.
Course fee
₹17,999 + GST
One-time · includes all projects, live sessions and mentor reviews
Attended and not satisfied? Apply for a full refund within 7 days of purchase.
Industry range
₹6–12 LPA
Fresher, India — market benchmark, not a guarantee
Ready to start your ML Engineering journey?
13 Projects + 2 Capstones to build, a mentor on every submission, and 8 months of live sessions.
See the curriculum
7-day full refund · No setup required · Career prep included