Machine Learning Bootcamp

You can clean and manipulate messy real-world tabular datasets using core Python, NumPy arrays, and Pandas DataFrames.

1. Python for machine learning2 hrs
   • list comprehensions
   • generators
   • type hinting
   • virtual environments with venv
2. NumPy for numerical computing2 hrs
   • ndarray creation
   • vectorization
   • broadcasting rules
   • matrix slicing
3. Pandas for data manipulation2 hrs
   • DataFrame indexing
   • groupby aggregations
   • merge and join operations
   • datetime parsing
4. Exploratory data analysis2 hrs
   • Matplotlib histograms
   • Seaborn pairplots
   • correlation matrices
   • missing value visualization
5. Cleaning and preparing messy data2 hrs
   • imputation strategies
   • capping outliers
   • string cleaning with regex
   • duplicate removal

Hands-on project: Write a data cleaning script using Pandas that imputes missing values, handles outliers using interquartile ranges, and exports a validated CSV dataset.

You can apply fundamental statistical tests, probability distributions, and optimization intuition to diagnose model assumptions.

1. Descriptive statistics2 hrs
   • mean, median, mode
   • variance and standard deviation
   • skewness and kurtosis
   • percentiles
2. Probability and distributions2 hrs
   • Bayes theorem
   • normal distribution
   • binomial distribution
   • probability density functions
3. Hypothesis testing2 hrs
   • null and alternative hypotheses
   • p-values
   • t-tests
   • chi-squared tests
4. Correlation vs causation2 hrs
   • Pearson correlation
   • Spearman rank correlation
   • confounding variables
   • spurious correlations
5. Gradients and optimisation intuition2 hrs
   • partial derivatives
   • gradient descent mechanics
   • learning rate selection
   • convex cost functions

Hands-on project: Perform an A/B test analysis in Python using hypothesis testing, calculate p-values, and visualize confidence intervals for conversion rates.

You can design, train, and evaluate multi-layer neural networks from scratch using PyTorch tensors and autograd.

1. Neural network basics2 hrs
   • perceptrons
   • activation functions (ReLU, Sigmoid, Tanh)
   • forward propagation
   • weight initialization
2. Training and optimisation2 hrs
   • backpropagation algorithm
   • stochastic gradient descent
   • Adam optimizer
   • learning rate schedulers
3. A first neural network in PyTorch2 hrs
   • torch.Tensor operations
   • torch.nn.Module subclassing
   • autograd computation graphs
   • training loops
4. When to reach for deep learning2 hrs
   • tabular vs unstructured data limits
   • data scale requirements
   • hardware acceleration with CUDA
   • model complexity tradeoffs
5. Evaluating deep models2 hrs
   • dropout regularization
   • weight decay
   • validation loss monitoring
   • early stopping callbacks

Hands-on project: Train a multi-layer perceptron in PyTorch for binary classification, implementing custom Dataset classes, DataLoader batching, and cross-entropy loss tracking.

You can train, evaluate, and tune regression and classification models using scikit-learn while preventing overfitting.

1. How models learn from data4 hrs
   • hypothesis spaces
   • loss functions
   • empirical risk minimization
   • training vs test splits
2. Linear and logistic regression4 hrs
   • Ordinary Least Squares
   • Ridge and Lasso penalties
   • sigmoid function
   • decision boundaries
3. k-NN, SVM and Naive Bayes4 hrs
   • Euclidean distance metrics
   • kernel trick in SVM
   • maximum margin classifiers
   • conditional probability in Naive Bayes
4. Bias, variance and the fundamentals of fit4 hrs
   • bias-variance tradeoff
   • learning curves
   • overfitting detection
   • underfitting diagnosis
5. Cross-validation and evaluation metrics4 hrs
   • k-fold cross-validation
   • ROC-AUC curves
   • confusion matrices
   • F1-score calculations

Hands-on project: Train a logistic regression classifier on a binary target dataset, compute precision-recall curves, and tune regularization hyperparameters using 5-fold cross-validation.

You can build high-performance gradient boosting models and tune hyperparameter grids to maximize predictive accuracy on tabular data.

1. Decision trees2 hrs
   • Gini impurity
   • information gain
   • tree pruning
   • max depth constraints
2. Random forests and bagging2 hrs
   • bootstrap aggregating
   • feature subsampling
   • out-of-bag error
   • ensemble averaging
3. Gradient boosting (XGBoost / LightGBM)2 hrs
   • residual fitting
   • shrinkage parameters
   • histogram-based splitting
   • learning rate tuning
4. Hyperparameter tuning2 hrs
   • GridSearchCV
   • RandomizedSearchCV
   • Bayesian optimization
   • hyperparameter search spaces
5. Handling imbalanced data2 hrs
   • class weight adjustment
   • SMOTE oversampling
   • undersampling majorities
   • precision-recall optimization

Hands-on project: Implement an XGBoost classifier with early stopping on a customer churn dataset and achieve a target ROC-AUC above 0.85.

You can construct robust, leak-free scikit-learn preprocessing pipelines that combine feature encoding, scaling, and transformation.

1. Encoding and scaling features2 hrs
   • StandardScaler
   • MinMaxScaler
   • OneHotEncoder
   • OrdinalEncoder
2. Creating features that matter2 hrs
   • polynomial features
   • interaction terms
   • binning continuous variables
   • domain-driven feature extraction
3. Feature selection2 hrs
   • variance thresholds
   • recursive feature elimination
   • feature importances from trees
   • multicollinearity checks
4. Avoiding data leakage2 hrs
   • train-test separation before scaling
   • cross-validation pitfalls
   • target encoding leakage
   • proper pipeline encapsulation
5. Reproducible scikit-learn pipelines2 hrs
   • Pipeline class
   • ColumnTransformer
   • custom transformer classes
   • joblib model serialization

Hands-on project: Build an end-to-end scikit-learn Pipeline incorporating custom transformers for feature creation, OneHotEncoder, and StandardScaler without introducing data leakage.

You can cluster unlabeled data, reduce dimensionality, and detect anomalies using unsupervised algorithms.

1. k-means and hierarchical clustering2 hrs
   • Lloyd's algorithm
   • elbow method
   • silhouette analysis
   • agglomerative clustering dendrograms
2. Dimensionality reduction with PCA2 hrs
   • eigenvalues and eigenvectors
   • explained variance ratio
   • projection matrices
   • noise reduction
3. Anomaly detection2 hrs
   • Isolation Forest
   • One-Class SVM
   • Mahalanobis distance
   • outlier scoring
4. Recommender-system basics2 hrs
   • collaborative filtering
   • cosine similarity
   • user-item matrices
   • matrix factorization
5. Choosing the right technique2 hrs
   • density-based clustering with DBSCAN
   • t-SNE visualization
   • computational complexity
   • unsupervised evaluation

Hands-on project: Cluster customer segmentation data using k-means, determine the optimal cluster count with the silhouette score, and visualize principal components using PCA.

You can ingest, query, and structure multi-source datasets including relational SQL databases and time-series feeds.

1. SQL for machine learning2 hrs
   • window functions
   • CTEs and subqueries
   • aggregating feature stores
   • SQLAlchemy integration
2. Time-series fundamentals2 hrs
   • resampling
   • rolling windows
   • lag features
   • stationarity checks
3. Text features and an NLP intro2 hrs
   • Bag-of-Words
   • TF-IDF vectorization
   • tokenization basics
   • text cleaning pipelines
4. Combining multiple data sources2 hrs
   • relational joins across tables
   • handling mismatched timestamps
   • feature merging strategies
   • data serialization formats (Parquet)
5. Reproducibility and experiment hygiene2 hrs
   • random seed setting across libraries
   • configuration management with YAML
   • logging with Python logging module
   • artifact organization

Hands-on project: Query a PostgreSQL database using Python to extract time-series feature aggregates, construct rolling window statistics, and format data for model ingestion.

You can perform rigorous error analysis and explain black-box model predictions using SHAP values.

1. Validation strategies2 hrs
   • stratified splitting
   • time-series split validation
   • nested cross-validation
   • group k-fold validation
2. Error analysis2 hrs
   • residual plots
   • slice-based evaluation
   • false positive/negative investigation
   • model failure modes
3. Explainability with SHAP2 hrs
   • Shapley values intuition
   • TreeExplainer
   • summary plots
   • force plots for local interpretation
4. Fairness and bias2 hrs
   • demographic parity
   • equalized odds
   • detecting proxy variables
   • mitigating algorithmic bias
5. Selecting a model for production2 hrs
   • latency vs accuracy tradeoffs
   • model size constraints
   • interpretability requirements
   • robustness testing

Hands-on project: Generate SHAP summary and dependence plots for a trained gradient boosting model to explain feature impact on individual predictions to stakeholders.

You can serve trained models as low-latency REST APIs, track experiments with MLflow, and containerize applications with Docker.

1. Serving models as APIs with FastAPI4 hrs
   • FastAPI endpoint routing
   • Pydantic request validation
   • joblib model loading at startup
   • asynchronous prediction handlers
2. Containerising with Docker4 hrs
   • Dockerfile creation
   • multi-stage builds
   • image optimization
   • docker run and port mapping
3. Experiment tracking with MLflow4 hrs
   • mlflow.log_param and log_metric
   • tracking server setup
   • model registry management
   • artifact storage
4. Monitoring and drift detection4 hrs
   • data drift vs concept drift
   • population stability index
   • logging inference requests
   • alerting thresholds
5. Continuous integration for ML4 hrs
   • GitHub Actions workflows
   • automated model unit testing
   • linting with flake8
   • CI container builds

Hands-on project: Package a trained scikit-learn model inside a FastAPI container, track parameters with MLflow, and containerize the service using a multi-stage Dockerfile.

You can design scalable, end-to-end machine learning system architectures addressing latency, storage, and reliability requirements.

1. Framing an ML problem2 hrs
   • translating business goals to ML tasks
   • defining success metrics
   • baseline model establishment
   • feasibility assessment
2. Data and feature pipelines2 hrs
   • batch vs streaming data engineering
   • feature store architecture
   • preventing training-serving skew
   • data validation checks
3. Batch vs online inference2 hrs
   • offline batch scoring pipelines
   • low-latency online inference services
   • caching prediction results
   • fallback mechanisms
4. Scaling and reliability2 hrs
   • load balancing inference APIs
   • horizontal scaling with Kubernetes
   • handling traffic spikes
   • graceful degradation
5. Cost and trade-offs2 hrs
   • cloud infrastructure cost estimation
   • GPU vs CPU inference costs
   • model quantization tradeoffs
   • maintenance overhead

Hands-on project: Draft a production system architecture document for a real-time recommendation engine, detailing data ingestion, feature store design, and online inference scaling.

You can tell when a deployed model has gone stale and retrain it on evidence.

1. What to monitor on a live model90 min
   • Input drift
   • Prediction drift
   • Delayed ground truth
2. Detecting drift90 min
   • Reference windows
   • PSI and KS tests
   • Alert thresholds that are not noisy
3. Retraining safely90 min
   • Scheduled vs triggered
   • Champion-challenger
   • Shadow evaluation
4. Promotion and rollback90 min
   • Model registry stages
   • Canary a model
   • Rolling back a bad model

Hands-on project: Instrument the deployed capstone model with input and prediction distribution monitoring against a reference window, trigger an alert from injected drift, then run a retraining pipeline and compare the challenger with the champion before promoting.

You can build, deploy, and present an end-to-end production machine learning system while clearing technical interview loops.

1. End-to-end capstone project4 hrs
   • problem scoping and dataset selection
   • pipeline implementation
   • model optimization
   • cloud deployment
2. Portfolio and GitHub review4 hrs
   • README documentation best practices
   • clean code standards
   • repository structuring
   • portfolio presentation
3. Communicating results to stakeholders4 hrs
   • translating metrics to business value
   • presenting model limitations
   • visualization dashboards with Streamlit
   • technical storytelling
4. ML mock interviews4 hrs
   • system design interview questions
   • coding round preparation
   • behavioral interview structuring
   • feedback and iteration
5. Certification and next steps4 hrs
   • resume tailoring for ML roles
   • job search strategies
   • continuing education pathways
   • Squarebrackets certificate issuance

Hands-on project: Deploy a complete churn prediction pipeline with a FastAPI backend and Streamlit frontend to a cloud environment, and present the system architecture in a mock technical interview.