Generative
AI
Advanced
5-6 Hours
Agentic Multi-Document RAG System with LangChain,
LlamaIndex & ChromaDB
Develop an enterprise-grade Retrieval-Augmented Generation (RAG) agent capable of
parsing heterogeneous documents (PDFs, spreadsheets, technical manuals), generating
dense contextual embeddings, and storing them in ChromaDB. Implement hybrid semantic
search combining BM25 keyword matching with dense cosine similarity, followed by a
cross-encoder reranking stage and self-reflective query routing via LangGraph to
eliminate LLM hallucinations.
Key Learning Outcomes:
- Chunking strategies with parent-document retrievers and hierarchical vector
indexing.
- Cross-encoder semantic reranking to boost context precision and recall.
- Building multi-agent state machines with LangGraph for validation loops.
Stack: LangChain, LlamaIndex, ChromaDB,
HuggingFace, FastAPI
Computer
Vision
Intermediate
3-4 Hours
Real-Time Multi-Object Tracking and Anomaly Detection
with YOLOv11 & DeepSORT
Implement high-framerate object detection and multi-camera trajectory tracking on
surveillance video feeds using the latest Ultralytics YOLOv11 model coupled with
DeepSORT (Kalman filtering and appearance embedding extraction). Add a spatial velocity
analytics module to flag anomalous movement patterns such as wrong-way driving,
perimeter breaches, and sudden overcrowding.
Key Learning Outcomes:
- Fine-tuning YOLOv11 on custom annotated datasets (COCO format) with
Albumentations.
- Object association across frame occlusions using cosine distance embeddings.
- Exporting PyTorch weights to TensorRT and ONNX for 60+ FPS edge execution.
Stack: YOLOv11, OpenCV, PyTorch,
DeepSORT, ONNX Runtime
Medical
AI & PyTorch
Advanced
6-8 Hours
Medical Image Segmentation for Brain Tumor MRI with 3D
U-Net in PyTorch
Construct an automated volumetric segmentation pipeline for multi-modal brain MRI scans
(T1, T1Gd, T2, FLAIR) from the BraTS benchmark dataset. Build a custom 3D U-Net with
residual skip connections, deep supervision, and generalized Dice-Focal hybrid loss to
isolate necrotic cores, peritumoral edema, and active enhancing tumor boundaries.
Key Learning Outcomes:
- Preprocessing 3D NIfTI volumes: skull stripping, z-score intensity
normalization, and patch extraction.
- Mitigating class imbalance using compound Dice and Cross-Entropy loss
formulations.
- Quantitative evaluation using Dice Similarity Coefficient (DSC) and 95%
Hausdorff Distance.
Stack: PyTorch, MONAI, SimpleITK,
Nibabel, Matplotlib
FinTech
& RL
Advanced
5-6 Hours
Algorithmic Trading & Portfolio Optimization with Deep
Reinforcement Learning (PPO)
Create a custom OpenAI Gymnasium trading environment that streams historical
tick-by-tick equity and crypto data with realistic transaction slippage and commission
fees. Train a Proximal Policy Optimization (PPO) agent with custom Sharpe-ratio reward
formulations, comparing risk-adjusted returns against standard Buy & Hold and Markowitz
Mean-Variance baselines.
Key Learning Outcomes:
- Building custom Gym environments with continuous and discrete action spaces.
- Designing multi-feature state representations (RSI, MACD, Bollinger Bands, Order
Book Imbalance).
- Evaluating backtests with Maximum Drawdown, Calmar Ratio, and Monte Carlo stress
tests.
Stack: Gymnasium, Stable-Baselines3,
Polars, TA-Lib, Backtrader
Cybersecurity
& GNN
Advanced
5 Hours
Real-Time Network Intrusion Detection with Graph
Neural Networks (PyG)
Model network packet traffic as directed graph topologies where IP addresses serve as
nodes and communication flows serve as attributed edges on the CSE-CIC-IDS2018 dataset.
Train Graph Convolutional Networks (GCN) and Graph Attention Networks (GAT) in PyTorch
Geometric to detect distributed Denial of Service (DDoS) and lateral movement attacks
with high precision.
Key Learning Outcomes:
- Converting tabular network flow captures into relational PyG Graph Data objects.
- Implementing multi-head attention mechanisms to weight suspicious IP edge
interactions.
- Comparing GNN performance against Random Forests, XGBoost, and MLP baselines.
Stack: PyTorch Geometric, NetworkX,
Scikit-Learn, Scapy, Pandas
NLP
& Multimodal AI
Intermediate
4 Hours
Multimodal Emotion and Sentiment Recognition from
Video & Audio with Transformers
Build an end-to-end multimodal classification system that ingests interview videos and
extracts synchronized text transcripts (via Whisper), acoustic pitch and spectrogram
features (via Wav2Vec 2.0), and facial expression dynamics (via ViT). Fuse
cross-attention embeddings using a transformer fusion layer to classify subtle emotional
states with 91%+ accuracy.
Key Learning Outcomes:
- Feature extraction pipelines for text tokens, MFCC acoustic frames, and visual
bounding boxes.
- Cross-modal attention fusion mechanisms to align temporal speech and facial
cues.
- Evaluating models with weighted F1-scores and confusion matrices on the
CMU-MOSEI dataset.
Stack: PyTorch, Hugging Face
Transformers, Torchaudio, Librosa, OpenCV
Edge AI
& Vision
Beginner
2-3 Hours
Automated Plant Leaf Disease Diagnosis with Edge AI
Deployment using FastAPI & ONNX
Train an EfficientNet-V2 convolutional architecture on 54,000+ leaf images from the
PlantVillage dataset to classify 38 distinct crop disease categories. Quantize the
trained PyTorch model into ONNX format with 8-bit integer quantization (INT8) and deploy
an asynchronous FastAPI prediction endpoint with interactive Streamlit UI.
Key Learning Outcomes:
- Transfer learning, learning rate warmups, and cosine annealing schedulers in
PyTorch.
- Model size reduction by 75% using ONNX Runtime quantization without loss of
accuracy.
- Building production REST endpoints with Pydantic schema validation and Swagger
docs.
Stack: PyTorch, EfficientNet, ONNX
Runtime, FastAPI, Streamlit
Robotics
& Control
Advanced
6 Hours
Autonomous Vehicle Trajectory Planning & Obstacle
Avoidance using MPC & Hybrid A*
Implement a complete kinematic and dynamic motion planning stack for autonomous ground
vehicles. Use a kinodynamic Hybrid A* pathfinder to compute continuous collision-free
dubins curves through cluttered obstacle fields, followed by a non-linear Model
Predictive Controller (MPC) formulated in CasADi to track the generated path while
obeying tire steering and acceleration constraints.
Key Learning Outcomes:
- Bicycle kinematic model formulation with non-holonomic vehicle constraints.
- Formulating constrained quadratic optimization problems (QP) using CasADi and
OSQP.
- Visualizing real-time tracking trajectories and tracking error metrics with
Pygame and Matplotlib.
Stack: Python, CasADi, OSQP, NumPy,
SciPy, Matplotlib
Time
Series & Energy
Intermediate
4 Hours
Renewable Grid Load & Solar Forecasting with Temporal
Fusion Transformers (TFT)
Build an interpretable multi-horizon time series forecasting model using Temporal Fusion
Transformers on real-world electricity consumption and weather irradiance datasets.
Handle static metadata (location, station capacity), known future inputs (calendar days,
forecasted solar angles), and past observed loads to output calibrated quantile
forecasts (P10, P50, P90).
Key Learning Outcomes:
- Multi-horizon probabilistic forecasting and quantile loss metric calculations.
- Self-attention weight extraction to interpret feature importance across
forecasting horizons.
- Comparing TFT against ARIMA, Prophet, and LSTM baselines via Mean Absolute
Scaled Error (MASE).
Stack: PyTorch Forecasting, PyTorch
Lightning, Polars, Plotly
Speech
AI & Audio
Advanced
5 Hours
Zero-Shot Voice Cloning & Low-Latency Speech Synthesis
with Whisper & FastSpeech2
Develop an end-to-end zero-shot neural voice cloning pipeline. Extract speaker acoustic
identity vectors from a 5-second reference audio sample using a pre-trained speaker
encoder, synthesize phoneme duration-controlled Mel-spectrograms via FastSpeech2, and
reconstruct natural audio waveforms using HiFi-GAN vocoders.
Key Learning Outcomes:
- Audio signal representation: Short-Time Fourier Transforms (STFT), Mel-scale
filters, and vocoders.
- Non-autoregressive speech synthesis for deterministic inference speeds without
recurrent latency.
- Measuring subjective Mean Opinion Score (MOS) and objective Mel-Cepstral
Distortion (MCD).
Stack: PyTorch, Torchaudio, FastSpeech2,
HiFi-GAN, Librosa
Bioinformatics
& GNN
Advanced
6 Hours
Molecular Property Prediction & Drug-Target
Interaction with Graph Convolutional Networks
Build a molecular graph neural network using RDKit and PyTorch Geometric to predict
biochemical properties (solubility, toxicity, and blood-brain barrier permeability) from
SMILES chemical strings on the MoleculeNet benchmark. Implement Graph Isomorphism
Networks (GIN) with edge features representing chemical bond orders and atomic
hybridization states.
Key Learning Outcomes:
- Parsing SMILES strings into molecular graphs with atom and bond feature vectors.
- Weisfeiler-Lehman graph isomorphism tests and message-passing pooling layers.
- Evaluating ROC-AUC scores for multi-task quantitative structure-activity
relationship (QSAR) models.
Stack: RDKit, PyTorch Geometric,
DeepChem, Scikit-Learn, Pandas
Recommendation
Systems
Intermediate
4 Hours
High-Throughput E-Commerce Recommendation Engine using
Two-Tower PyTorch Models & Redis
Design a two-tower deep retrieval and ranking recommendation architecture on the
MovieLens-25M dataset. Train user and item embedding encoders in PyTorch using in-batch
negative sampling and cross-entropy loss. Index item embeddings inside Redis Vector
Search for sub-10ms Approximate Nearest Neighbor (ANN) candidate retrieval.
Key Learning Outcomes:
- Two-tower neural architecture: separate query (user context) and candidate (item
metadata) towers.
- Sub-millisecond vector similarity search using HNSW indexes in Redis.
- Evaluating Recall@K, NDCG@K, and Mean Reciprocal Rank (MRR) metrics.
Stack: PyTorch, Redis, Polars,
Scikit-Learn, FastAPI
FinTech
& Anomaly Detection
Intermediate
3-4 Hours
Real-Time Credit Card Fraud Detection with Isolation
Forests & Autoencoders
Tackle severe class imbalance (0.17% fraud rate) on European credit card transaction
data. Implement unsupervised deep autoencoders to learn latent representations of
legitimate spending patterns, flagging transactions with high reconstruction loss
errors. Combine autoencoder embeddings with an ensemble of Isolation Forests and
LightGBM for robust classification.
Key Learning Outcomes:
- Data preprocessing under extreme class imbalance with SMOTE and focal loss.
- Unsupervised anomaly detection via autoencoder reconstruction error thresholds.
- Optimizing Precision-Recall AUC (PR-AUC) and minimizing false positive customer
declines.
Stack: PyTorch, Scikit-Learn, LightGBM,
Imbalanced-Learn, Matplotlib
Data
Science & XAI
Beginner
2 Hours
Customer Churn Prediction and Explainable AI (XAI)
using XGBoost & SHAP
Predict subscription customer churn on telecom datasets using an optimized
gradient-boosted tree model (XGBoost). Leverage SHAP (Shapley Additive Explanations) and
LIME to generate individual local customer explanations and global feature impact plots,
converting black-box predictions into actionable business retention strategies.
Key Learning Outcomes:
- Automated hyperparameter tuning with Optuna cross-validation loops.
- Game-theoretic feature attribution using TreeSHAP summary and waterfall plots.
- Building an interactive Streamlit customer risk dashboard with decision
triggers.
Stack: XGBoost, SHAP, Optuna,
Scikit-Learn, Streamlit
Robotics
& RL
Advanced
6 Hours
Sim-to-Real Robotic Manipulator Pick-and-Place Control
with Gymnasium & Stable-Baselines3
Train a 7-DOF Franka Emika robotic manipulator arm in a PyBullet / MuJoCo physics
simulator using Soft Actor-Critic (SAC) reinforcement learning. Implement domain
randomization (varying friction coefficients, link masses, and camera noise) to enable
robust zero-shot sim-to-real transfer for grasping multi-shaped objects under uncertain
lighting.
Key Learning Outcomes:
- Physics simulation modeling in MuJoCo and Gymnasium Robotics environments.
- Continuous action-space policy optimization with Soft Actor-Critic (SAC).
- Domain randomization strategies for resilient real-world hardware deployment.
Stack: Gymnasium, MuJoCo,
Stable-Baselines3, PyBullet, PyTorch