Artificial Intelligence Bootcamp

You can write modular, object-oriented Python scripts using modern syntax, manage isolated environments, and build structured CLI utilities for automated API ingestion.

1. Python for data and AI2 hrs
   • Python 3.12 match-case structural pattern matching
   • python -m venv environment isolation and activation scripts
   • pip freeze and deterministic dependency pinning in requirements.txt
   • pyproject.toml packaging configuration standards
   • PEP 8 formatting with ruff check and ruff format
2. Data types, control flow and functions2 hrs
   • List and dictionary comprehensions with nested conditionals
   • Generator functions and memory-bounded iteration with yield
   • functools.partial and closures for configurable transforms
   • Custom exception hierarchies inheriting from Exception
   • Type hinting with typing.Annotated, Union, and Optional
3. Object-oriented Python2 hrs
   • Class inheritance and method resolution order with super()
   • Dunder methods: __repr__, __call__, __eq__, and __hash__
   • dataclasses with frozen=True, slots=True, and field factories
   • Property decorators with @property, @setter, and validation logic
   • abc.ABC and @abstractmethod interfaces for pluggable components
4. Working with files, APIs and JSON2 hrs
   • pathlib.Path directory traversal, globbing, and atomic file writes
   • httpx.Client session management with connection pooling
   • Handling HTTP status codes: 401 Unauthorized, 429 Rate Limit, 500 Server Error
   • json.loads and json.dumps with custom Decimal/UUID encoders
   • os.environ and python-dotenv for secret injection via .env files
5. Your AI development environment (Jupyter, venv)2 hrs
   • JupyterLab installation, server launch, and token authentication
   • ipykernel registration with python -m ipykernel install --user
   • Jupyter magic commands: %timeit, %prun, and %load_ext
   • .gitignore templates tailored for AI checkpoints and virtual environments
   • Git commit hygiene, feature branching, and diffing notebooks with nbdime
6. Unit Testing & Code Quality for AI Scripts2 hrs
   • pytest test discovery and assertion syntax
   • pytest fixtures for mock payloads and temp filesystem sandboxes
   • unittest.mock.patch for intercepting HTTP client calls
   • Parametrized test suites using @pytest.mark.parametrize
   • Type auditing with mypy --strict on ingestion pipelines

Hands-on project: Build an asynchronous CLI ingestion utility using Python 3.12, httpx, and Pydantic v2. Acceptance criteria: fetch paginated items from a remote REST API with exponential backoff on HTTP 429/503 errors; parse and validate raw JSON into typed Pydantic models; write structured JSONL records to disk using pathlib while rotating log files when size exceeds 5MB.

You can calculate matrix operations, partial derivatives, loss functions, and probability distributions directly in vectorized NumPy code.

1. Linear algebra: vectors and matrices2 hrs
   • Vector dot product geometric interpretation and np.dot computation
   • Matrix multiplication rules, dimensions, and np.matmul / @ operator
   • Matrix transpose, inverse (np.linalg.inv), and condition numbers
   • Eigenvalues and eigenvectors with np.linalg.eig
   • Singular Value Decomposition (SVD) with np.linalg.svd for dimensionality reduction
2. Calculus and gradients intuitively2 hrs
   • Partial derivatives of multivariable loss functions
   • Vector calculus and calculating the Jacobian matrix
   • Multivariate chain rule for composite functions
   • Hessian matrix and second derivative curvature testing
   • Visualising loss landscapes and saddle points in 3D using Matplotlib
3. Probability and statistics essentials2 hrs
   • Discrete vs continuous distributions: Bernoulli, Binomial, and Gaussian
   • Expectation, sample variance, and standard deviation with np.var and np.std
   • Covariance matrices and Pearson correlation coefficient derivation
   • Bayes Theorem and posterior probability calculation
   • Maximum Likelihood Estimation (MLE) for estimating Gaussian parameters
4. Optimisation and gradient descent2 hrs
   • Objective functions, convex sets, and global vs local minima
   • Batch Gradient Descent iteration step formula: w := w - lr * grad
   • Stochastic Gradient Descent (SGD) and mini-batch sampling noise
   • Momentum accumulation to dampen oscillations across ravines
   • Learning rate scheduling: step decay and exponential decay formulations
5. How the maths shows up in models2 hrs
   • Formulating linear layers as affine transformations: y = Wx + b
   • Sigmoid activation derivation, numerical stability, and derivative identity
   • Binary Cross-Entropy loss mathematical derivation from log-likelihood
   • Backpropagation chain rule computation graph traversal
   • Vanishing gradient mechanisms caused by saturated Sigmoid/Tanh tails
6. Vectorized Numerical Implementations in NumPy2 hrs
   • Broadcasting semantics across multidimensional arrays
   • Vectorized operations vs Python loops benchmarked with %timeit
   • Log-sum-exp trick for numerically stable softmax calculation
   • L1 (Manhattan) and L2 (Euclidean) norm calculations with np.linalg.norm
   • Finite difference gradient checking to verify analytical derivative functions

Hands-on project: Implement a multivariate linear regression solver and a binary logistic regression classifier from scratch in NumPy without high-level ML libraries. Acceptance criteria: compute weight updates using explicit batch and stochastic gradient descent; vectorize loss calculation for Mean Squared Error and Binary Cross-Entropy; confirm convergence against an analytic normal equation solution within a tolerance of 1e-4.

You can clean, reshape, aggregate, and visualize high-dimensional tabular datasets using Pandas 2.2 and Seaborn to prepare clean model training inputs.

1. NumPy for numerical computing2 hrs
   • Memory layout of ndarray: striding, C-contiguous vs Fortran-contiguous
   • Data types (dtypes): int64, float32, and downcasting for memory optimization
   • Boolean masking and complex conditional indexing with np.where and np.select
   • Array aggregation along axes: sum, mean, std across axis=0 and axis=1
   • Random sampling and seeding with numpy.random.default_rng
2. Pandas for data manipulation2 hrs
   • Series vs DataFrame internal representations and indexing rules
   • Label-based vs position-based slicing: loc vs iloc gotchas
   • DataFrame.groupby with named aggregations (.agg(col_name=('source', 'metric')))
   • Combining datasets with pd.merge (inner, left, outer) and pd.concat
   • Date parsing, time zone conversion, and resampling with pd.to_datetime
3. Cleaning and preparing real datasets2 hrs
   • Identifying missing data patterns with df.isna().sum() and missingno
   • Imputation strategies: median, forward-fill, and iterative multivariate imputation
   • String normalization, whitespace trimming, and regex matching in df.str
   • Detecting outliers via Z-score and Interquartile Range (IQR) filtering
   • Memory optimization using df.astype('category') and pyarrow backend engines
4. Exploratory data analysis2 hrs
   • Generating summary statistics with df.describe(include='all')
   • Computing pairwise correlation matrices with method='pearson' and method='spearman'
   • Assessing distribution skewness and kurtosis with scipy.stats.skew
   • Cross-tabulation and contingency tables using pd.crosstab
   • Identifying Multicollinearity using Variance Inflation Factor (VIF)
5. Visualising data with Matplotlib/Seaborn2 hrs
   • Matplotlib object-oriented figure and axes creation: fig, ax = plt.subplots()
   • Univariate distribution inspection with sns.histplot(kde=True) and sns.boxplot
   • Bivariate relationship analysis using sns.scatterplot and sns.regplot
   • Correlation matrix heatmaps with sns.heatmap, annot=True, and mask arrays
   • Custom styling, palette configuration, and exporting vectors via plt.savefig
6. Feature Encoding & Preprocessing Pipelines2 hrs
   • One-Hot Encoding vs Ordinal Encoding and handling unseen test categories
   • Target encoding with smoothing to prevent overfitting on high-cardinality keys
   • Log and Box-Cox power transformations for right-skewed variables
   • StandardScaler vs RobustScaler vs MinMaxScaler tradeoffs
   • Writing modular data transformation functions adhering to functional signatures

Hands-on project: Build an end-to-end data preparation and Exploratory Data Analysis (EDA) pipeline for a customer transaction dataset of 500,000 records. Acceptance criteria: handle missing values using domain-specific imputation strategies without data leakage; detect and cap statistical outliers using IQR thresholds; generate an automated Seaborn correlation and distribution report exported as HTML.

You can engineer predictive pipelines, prevent data leakage, train ensemble models, and optimize hyperparameters using scikit-learn.

1. How learning from data works2 hrs
   • Supervised, unsupervised, and self-supervised paradigm boundaries
   • Splitting datasets with train_test_split, shuffle=True, and random_state
   • Stratified sampling for imbalanced classification targets
   • K-Fold and RepeatedStratifiedKFold validation strategies
   • Information leakage risks: pre-splitting normalization and target encoding pitfalls
2. Regression and classification2 hrs
   • Linear regression closed-form vs SGDRegressor updates
   • LogisticRegression multi-class strategies: one-vs-rest (ovr) and multinomial
   • Precision, Recall, F1-score, and precision_recall_curve analysis
   • ROC-AUC curves, false positive rates, and roc_auc_score computation
   • Calibration curves and probability calibration with CalibratedClassifierCV
3. Decision trees, random forests and boosting2 hrs
   • DecisionTreeClassifier splits: Gini Impurity vs Shannon Entropy formulas
   • RandomForestClassifier bagging mechanics, max_features, and oob_score_
   • Gradient boosting principles: fitting consecutive trees to pseudo-residuals
   • XGBoost core hyperparameters: n_estimators, max_depth, learning_rate, and subsample
   • LightGBM leaf-wise splitting and histogram binning for speed
4. Model evaluation, overfitting and validation2 hrs
   • Bias-variance tradeoff diagnosis through validation curves
   • L1 (Lasso) feature selection vs L2 (Ridge) weight decay regularization
   • ElasticNet balancing L1 and L2 penalties via l1_ratio parameter
   • Hyperparameter sweeps with GridSearchCV vs RandomizedSearchCV
   • Bayesian hyperparameter optimization using Optuna studies and trials
5. Feature engineering that improves models2 hrs
   • PolynomialFeatures for non-linear feature interaction generation
   • scikit-learn ColumnTransformer for heterogeneous column preprocessing
   • Assembling end-to-end scikit-learn Pipeline instances
   • Building custom transformers with BaseEstimator and TransformerMixin
   • Feature importance auditing: MDI vs Permutation Importance
6. Unsupervised Learning & Clustering2 hrs
   • K-Means clustering: centroid initialization and inertia metrics
   • Determining cluster counts using the Elbow Method and Silhouette Score
   • DBSCAN density clustering: eps and min_samples configuration
   • Principal Component Analysis (PCA): explained variance ratio and scree plots
   • t-SNE and UMAP for non-linear high-dimensional manifold visualization

Hands-on project: Build an enterprise credit risk assessment classifier on an imbalanced dataset of 250,000 rows. Acceptance criteria: structure transformations inside scikit-learn Pipeline and ColumnTransformer; handle class imbalance using SMOTE and class weights; run stratified K-Fold cross-validation; optimize XGBoost hyperparameters via Optuna; output ROC-AUC, Precision-Recall AUC, and confusion matrix reports.

You can construct, train, optimize, and debug custom feedforward neural network architectures in PyTorch with automated gradient tracking and GPU execution.

1. Neural networks from the ground up2 hrs
   • Artificial neuron formulation: linear combination and non-linear thresholding
   • Multi-Layer Perceptron (MLP) architecture and hidden representations
   • PyTorch Tensor creation, indexing, slicing, and memory sharing
   • PyTorch Autograd engine: requires_grad=True and backward() call
   • Computation graph dynamics: dynamic vs static DAG construction
2. Activation, loss and optimisation2 hrs
   • Activation functions: ReLU, LeakyReLU, GELU, and Sigmoid mechanics
   • Loss functions: nn.MSELoss, nn.BCEWithLogitsLoss, and nn.CrossEntropyLoss
   • Stochastic gradient descent with momentum in torch.optim.SGD
   • Adam and AdamW adaptive moment estimation and weight decay decoupled updates
   • Gradient clipping using torch.nn.utils.clip_grad_norm_ to stop exploding gradients
3. Training, batching and regularisation2 hrs
   • Subclassing torch.utils.data.Dataset: implementing __len__ and __getitem__
   • torch.utils.data.DataLoader: batch_size, shuffle, num_workers, and pin_memory
   • nn.Dropout layers: inverted dropout scaling and inference behavior
   • nn.BatchNorm1d and nn.BatchNorm2d: running mean/variance tracking and momentum
   • L2 regularization via optimizer weight_decay configuration
4. Building networks in PyTorch/TensorFlow2 hrs
   • Subclassing torch.nn.Module and overriding the forward() method
   • Using nn.Sequential, nn.ModuleList, and nn.ModuleDict for composite layers
   • Device placement: moving models and tensors with .to(device) for CUDA/MPS
   • Inspecting model parameters with model.named_parameters() and shapes
   • Keras Functional API vs PyTorch nn.Module structural differences
5. Debugging and improving models2 hrs
   • Training loop validation phases: model.train() vs model.eval() flags
   • Disabling gradient calculations during evaluation with torch.no_grad()
   • Learning rate scheduling with torch.optim.lr_scheduler.CosineAnnealingLR
   • Implementing Early Stopping logic based on validation loss divergence
   • Saving and restoring training state with torch.save and torch.load state_dict
6. Experiment Tracking & Metrics Logging2 hrs
   • Logging scalar loss curves and accuracy metrics using torch.utils.tensorboard
   • Visualizing activation distributions and gradient histograms in TensorBoard
   • Tracking hyperparameter trials and artifacts using Weights & Biases (wandb)
   • Diagnosing dead ReLUs and exploding activations across deep layers
   • Seeding for reproducibility: torch.manual_seed and torch.backends.cudnn.deterministic

Hands-on project: Build an end-to-end tabular deep learning regression system in PyTorch 2.3 for predicting equipment remaining useful life. Acceptance criteria: structure data using custom Dataset and DataLoader classes with multi-process workers; implement an MLP with residual skips, batch normalization, and dropout; train using AdamW with cosine annealing learning rate scheduler; save and reload checkpoints preserving model weights and optimizer state.

You can engineer convolutional neural networks, perform image augmentation, fine-tune pre-trained backbones via transfer learning, and deploy visual inspection inference pipelines.

1. Images as data2 hrs
   • Image representations: channels, height, width (CHW vs HWC formats)
   • Pixel normalization using ImageNet channel means and standard deviations
   • OpenCV fundamentals: cv2.imread, color space conversions (BGR to RGB)
   • Image augmentation libraries: Albumentations Compose, RandomCrop, and HorizontalFlip
   • Color jitter, affine rotations, and CutMix augmentation techniques
2. Convolutional neural networks (CNNs)2 hrs
   • Discrete 2D convolution kernel mechanics and edge detection filters
   • nn.Conv2d parameters: in_channels, out_channels, kernel_size, stride, and padding
   • Receptive field calculations across deep convolutional feature maps
   • Downsampling layers: nn.MaxPool2d vs strided convolutions
   • nn.AdaptiveAvgPool2d for spatial reduction prior to dense layers
3. Transfer learning with pre-trained models2 hrs
   • Residual connections and ResNet architectures solving vanishing gradients
   • Loading pre-trained backbones with torchvision.models.resnet50(weights='DEFAULT')
   • Freezing parameter gradients: for p in model.parameters(): p.requires_grad = False
   • Replacing classification heads with custom nn.Linear layers
   • Discriminative layer learning rates using parameter groups in optimizers
4. Image classification and detection2 hrs
   • Object detection framing: bounding box regression and class confidence
   • Intersection over Union (IoU) calculation formula and thresholding
   • Non-Maximum Suppression (NMS) to eliminate duplicate detection proposals
   • Single-stage vs two-stage detectors: YOLO concepts vs Faster R-CNN
   • Mean Average Precision ([email protected] and [email protected]:0.95) evaluation metrics
5. A hands-on vision project2 hrs
   • Structuring image directory datasets with torchvision.datasets.ImageFolder
   • Writing a modular training loop tracking epoch validation accuracy and loss
   • Generating and plotting multi-class confusion matrices with scikit-learn and Seaborn
   • Checkpointing top model weights with torch.save based on validation F1 score
   • Exporting trained CNN weights to ONNX format with torch.onnx.export
6. Vision Transformers (ViT) & Modern Architectures2 hrs
   • Vision Transformer (ViT) architecture: patch extraction and linear projection
   • Patch embeddings, classification tokens ([CLS]), and learnable position embeddings
   • Self-attention vs convolutions: global context modeling vs translation equivariance
   • Loading pre-trained ViT models from Hugging Face transformers
   • Benchmarking latency and throughput between ResNet50 and ViT-Base on GPU

Hands-on project: Fine-tune a ResNet50 model using PyTorch torchvision to classify industrial component defects across 10 defect classes. Acceptance criteria: configure dynamic data augmentations using Albumentations; freeze pre-trained backbone weights and train an updated classification head; fine-tune top convolutional blocks with a discriminative learning rate; achieve over 92% Macro F1-score on a held-out test split.

You can tokenize text, compute embeddings, build Transformer models, and fine-tune modern LLM encoders using Hugging Face Transformers.

1. Text preprocessing and tokenisation2 hrs
   • Text normalization: unicode normalization, lowercasing, and regex filtering
   • Subword tokenization algorithms: Byte-Pair Encoding (BPE) and WordPiece
   • Hugging Face AutoTokenizer: encode, decode, and batch_encode_plus methods
   • Handling sequence boundaries: padding, truncation, and max_length limits
   • Token tensor inputs: input_ids, attention_mask, and token_type_ids
2. Word embeddings2 hrs
   • Limitations of one-hot and TF-IDF bag-of-words representations
   • Word2Vec Skip-Gram vs Continuous Bag of Words (CBOW) objectives
   • nn.Embedding lookup tables in PyTorch and weight initialization
   • Semantic vector spaces and cosine similarity distance calculations
   • Extracting static sentence embeddings using average pooling over token vectors
3. The Transformer architecture2 hrs
   • Attention Is All You Need foundations: query, key, value matrix projections
   • Scaled dot-product attention formula: Softmax((QK^T) / sqrt(d_k)) * V
   • Multi-head self-attention and concatenated projection layers
   • Sinusoidal vs Rotary Positional Embeddings (RoPE)
   • LayerNorm vs RMSNorm and Feed-Forward Network (FFN) expansion layers
4. Using pre-trained language models2 hrs
   • Encoder-only (BERT/RoBERTa), Decoder-only (GPT), and Encoder-Decoder (T5) archetypes
   • Masked Language Modeling (MLM) and Next Sentence Prediction (NSP) objectives
   • Loading models with AutoModelForSequenceClassification from Hugging Face Hub
   • Zero-shot classification pipelines using pipeline('zero-shot-classification')
   • Hugging Face Datasets library: load_dataset, map, filter, and train_test_split
5. Fine-tuning for your own tasks2 hrs
   • Hugging Face TrainingArguments: per_device_train_batch_size, learning_rate, epochs
   • Mixed-precision training with fp16=True and bf16=True
   • Gradient accumulation steps for simulating large batch sizes on constrained GPUs
   • Writing custom compute_metrics functions with evaluate.load('f1')
   • Hugging Face Trainer API lifecycle: train(), evaluate(), and save_model()
6. Sentence Transformers & Semantic Search2 hrs
   • Siamese network architectures and sentence-transformers library
   • Mean pooling vs CLS pooling over contextual token representations
   • Contrastive loss functions: MultipleNegativesRankingLoss and cosine loss
   • Generating dense vector embeddings using SentenceTransformer('all-MiniLM-L6-v2')
   • Building a dense passage retrieval benchmark using cosine similarity matrices

Hands-on project: Fine-tune a ModernBERT or RoBERTa encoder for enterprise multi-class customer intent classification. Acceptance criteria: preprocess text using Hugging Face AutoTokenizer with dynamic padding; write a custom Hugging Face Trainer script with compute_metrics tracking Macro F1; run gradient accumulation and mixed-precision (fp16) training; export the fine-tuned model and tokenizer artifacts to disk.

You can build Retrieval-Augmented Generation (RAG) applications, orchestrate multi-step chains, manage vector databases, and implement prompt security controls.

1. How large language models work2 hrs
   • Autoregressive next-token prediction mechanics and causal attention masking
   • Context windows, maximum context length limits, and KV caching
   • Decoding sampling strategies: temperature, top_k, top_p (nucleus sampling)
   • Tokenization mechanics with Tiktoken and inspecting token-to-word ratios
   • Token economics: prompt tokens vs completion tokens pricing calculation
2. Prompt engineering and controlling output2 hrs
   • Zero-shot vs few-shot in-context learning design patterns
   • System prompts, user prompts, and developer message roles
   • Chain-of-Thought (CoT) and ReAct (Reasoning + Acting) prompting patterns
   • Enforcing JSON Mode and Structured Outputs with OpenAI json_schema parameter
   • Pydantic schema binding to LLM outputs for guaranteed type validation
3. The Hugging Face and OpenAI ecosystems2 hrs
   • OpenAI Python SDK v1.x: openai.OpenAI client instantiation and async calling
   • Handling API exceptions: RateLimitError, APIConnectionError, and APIStatusError
   • Streaming completions using stream=True and async iteration over chunks
   • Hugging Face Inference Endpoints and local deployment with vLLM
   • Open-weights foundation models: Llama 3.1, Mistral, and Qwen architectures
4. Retrieval-augmented generation (RAG)2 hrs
   • RAG architecture: naive RAG failure modes and hallucination reduction
   • Text splitting strategies: CharacterTextSplitter vs RecursiveCharacterTextSplitter
   • Chunk size vs chunk overlap optimization to preserve semantic continuity
   • ChromaDB vector database operations: collection creation, adding embeddings, querying
   • Cosine similarity vs dot product vs Euclidean distance index searches
5. Building apps with LangChain2 hrs
   • LangChain Expression Language (LCEL): pipe (|) operator composition
   • ChatPromptTemplate and MessagesPlaceholder construction
   • Retrievers: VectorStoreRetriever with search_type='similarity' and k=4
   • RunnablePassthrough and RunnableParallel for dynamic context assembly
   • Tracing and debugging chain execution traces with LangSmith
6. Advanced Retrieval & Re-ranking Techniques2 hrs
   • BM25 keyword search combined with dense vector retrieval (Hybrid Search)
   • Reciprocal Rank Fusion (RRF) for combining multi-retriever rankings
   • Cross-encoder re-ranking using Cohere Rerank API or local BGE-Reranker
   • Contextual Compression and document filtering to reduce prompt bloat
   • Query rewriting and Multi-Query expansions to handle ambiguous user prompts

Hands-on project: Build an enterprise document question-answering RAG pipeline using LangChain, ChromaDB, and OpenAI models. Acceptance criteria: chunk PDF documentation using recursive character splitting with overlap; ingest into ChromaDB with metadata filtering; perform hybrid retrieval (keyword and dense vector similarity); inject relevant chunks into prompt templates with strict hallucination-prevention instructions; enforce JSON output validation using Pydantic.

You can wrap AI models and LLM chains into production-grade FastAPI microservices and deploy responsive Streamlit frontends.

1. Serving models behind an API2 hrs
   • FastAPI application setup: APIRouter, lifespans, and lifespan context managers
   • Pydantic BaseModel request and response schemas with Field validations
   • Dependency Injection in FastAPI using Depends for authentication and database sessions
   • Asynchronous request handlers with async def and threadpool offloading with run_in_threadpool
   • Interactive API documentation and OpenAPI schemas via /docs and /redoc
2. Building an interactive app with Streamlit2 hrs
   • Streamlit execution model: script rerun mechanics and layout widgets
   • Chat components: st.chat_message, st.chat_input, and displaying streaming text
   • State preservation across reruns with st.session_state dictionary
   • Optimizing heavy resource loading with @st.cache_resource and @st.cache_data
   • File uploader widgets: st.file_uploader handling CSV and PDF payloads
3. Connecting models to real data2 hrs
   • SQLAlchemy 2.0 async engine and declarative model definitions
   • Integrating LangChain SQLDatabase and SQL query generation chains
   • Managing chat conversation history using RedisChatMessageHistory
   • Setting key Time-To-Live (TTL) expiration on Redis session caches
   • Safeguarding database writes: read-only database roles and query whitelisting
4. Guardrails, evaluation and cost2 hrs
   • Input validation guardrails: regex scanning and PII masking
   • NeMo Guardrails or Llama Guard for content moderation and safety checks
   • Latency tracking per stage: time-to-first-token (TTFT) and token generation speed
   • Token usage tracking, spend budgeting, and hard spend caps per user key
   • Graceful degradation: fallback from premium models to lightweight local models
5. Responsible and safe AI use2 hrs
   • Hallucination mitigation via citation anchoring and strict prompt contracts
   • Data privacy compliance: anonymization techniques and zero-data-retention APIs
   • Preventing system prompt leakage using delimiter isolation and negative constraints
   • Human-in-the-loop (HITL) review hooks for high-consequence automated decisions
   • Audit logging of prompt inputs and model completions for traceability
6. Streaming Responses & Real-Time Inference2 hrs
   • Server-Sent Events (SSE) protocol mechanics vs WebSockets
   • fastapi.responses.StreamingResponse wrapping asynchronous generators
   • Consuming SSE streams in Python clients and frontends
   • Handling connection drops and client cancellations during generation
   • Buffered token flushing to prevent UI jitter in conversational interfaces

Hands-on project: Build an asynchronous full-stack AI service with a FastAPI backend and a Streamlit chat frontend. Acceptance criteria: expose a /chat/stream SSE endpoint streaming LLM tokens using AsyncIterator; authenticate requests using Bearer API keys; store conversational memory in Redis; implement Streamlit frontend with st.chat_input and st.chat_message preserving conversation history.

You can containerize AI applications with Docker, orchestrate deployments, and monitor models for latency and drift in production.

1. Packaging and versioning models2 hrs
   • Model serialization formats: joblib, safetensors, and ONNX runtime tradeoffs
   • Model registries: MLflow model registry concepts and stage transitions
   • Artifact storage: S3/Blob storage versioning and hash checking
   • Semantic versioning (SemVer) applied to machine learning artifacts
   • Dependency locks with pip-tools (pip-compile) to freeze operational environments
2. Containerising with Docker2 hrs
   • Writing efficient Dockerfiles for Python: python:3.12-slim base selection
   • Multi-stage Docker builds separating build wheels from runtime layers
   • Minimizing image size: avoiding build-essential residue and caching wheels
   • Security best practices: running under non-root USER and dropping capabilities
   • Configuring Docker HEALTHCHECK instructions targeting the /health endpoint
3. Deploying models to the cloud2 hrs
   • Cloud container runtimes: AWS ECS, GCP Cloud Run, and Azure Container Apps
   • Environment variable injection and secrets management via cloud parameter stores
   • Configuring CPU, memory limits, and request timeouts for inference pods
   • Horizontal auto-scaling triggers: CPU utilization vs concurrency limits
   • Deploying Docker Compose stacks locally for full microservice orchestration
4. Monitoring and detecting drift2 hrs
   • Data drift vs Concept drift: definitions, causes, and business impact
   • Evidently AI integration for generating data drift diagnostic reports
   • Statistical tests for drift: Kolmogorov-Smirnov (KS) test and Wasserstein Distance
   • Exposing Prometheus metrics: request_latency_seconds and inference_requests_total
   • Building Grafana dashboards to monitor latency percentiles (p50, p95, p99)
5. From notebook to product2 hrs
   • Refactoring Jupyter notebook prototypes into modular Python packages
   • Automated testing of ML code: testing for data shape mismatches and NaN outputs
   • GitHub Actions workflow automation: continuous integration on pull requests
   • Pre-commit hooks: enforcing ruff formatting and flake8 linting rules
   • Structured JSON logging in production using loguru or structlog
6. Continuous Delivery & Canary Deployments2 hrs
   • Blue/Green deployment patterns for zero-downtime model switches
   • Canary releases: routing 5% traffic to a candidate model using reverse proxies
   • Feature flags for instant rollback without rebuilding containers
   • Automated rollback triggers when 5xx error spikes or latency breaches SLO
   • Post-deployment verification scripts and smoke testing pipelines

Hands-on project: Package an AI inference service into a production Docker image and set up an automated CI/CD pipeline. Acceptance criteria: write a multi-stage Dockerfile keeping final image size under 350MB; enforce a non-root user and include a health check; configure GitHub Actions workflow running pytest and docker build; implement Prometheus latency metrics and an /health endpoint.

You can translate ambiguous business challenges into AI architectures, establish measurable ROI baselines, and assess compliance and algorithmic fairness.

1. Framing a business problem as an AI task2 hrs
   • Deconstructing business objectives into regression, ranking, or generation tasks
   • Establishing baseline benchmarks: heuristic rules vs classical ML vs deep models
   • Cost-benefit modeling: measuring false positives vs false negatives in currency
   • Feasibility screening: data availability, labeling latency, and sample size requirements
   • Defining Service Level Objectives (SLOs): 95th percentile latency and availability targets
2. Data ethics, bias and fairness2 hrs
   • Algorithmic fairness definitions: Demographic Parity vs Equalized Odds
   • Measuring disparate impact and group fairness metrics using Fairlearn
   • Mitigating historical dataset bias: re-weighing samples and adversarial debiasing
   • Regulatory frameworks: EU AI Act risk tiers and India's DPDP Act compliance
   • Data provenance, licensing terms (MIT, Apache 2.0, Llama Community), and consent
3. Choosing the right approach2 hrs
   • Heuristic rule engines vs classical scikit-learn vs fine-tuned LLMs decision tree
   • Build vs Buy decisions: commercial SaaS APIs vs open-weights self-hosted models
   • Hardware requirements: CPU vs GPU (T4, A10G, H100) operational costs
   • Latency vs accuracy trade-offs across edge devices and cloud clusters
   • Maintenance overhead: model retraining cadences and data labeling budgets
4. Measuring impact2 hrs
   • Designing randomized controlled trials (A/B testing) for AI system features
   • Offline metrics (F1, NDCG, BLEU) vs Online business KPIs (CTR, retention, conversion)
   • Addressing feedback loops: self-fulfilling model predictions and data contamination
   • Shadow deployments (dark launching) to measure real production load without user impact
   • Interpreting uplift modeling and causal inference baselines
5. Case studies across industries2 hrs
   • Fraud detection pipelines: handling extreme 0.01% class imbalances in banking
   • Recommendation systems: two-tower retrieval architectures and collaborative filtering
   • Intelligent Document Processing (IDP): OCR extraction and table parsing
   • Customer support conversational AI: tier-1 triage and agent-assist workflows
   • Predictive maintenance: IoT sensor time-series anomaly detection
6. System Architecture & Capacity Planning2 hrs
   • Architectural diagrams with Mermaid.js documenting end-to-end data pipelines
   • Throughput calculation: estimating QPS and GPU VRAM footprint for batch inference
   • Load testing AI endpoints under high concurrent user load with Locust
   • Designing asynchronous task queues with Celery and Redis for long-running jobs
   • Disaster recovery, cross-region failover, and cold-start mitigations

Hands-on project: Author a comprehensive System Architecture and Business Case Document for an AI initiative in a regulated domain. Acceptance criteria: calculate expected cloud inference compute and token costs across 100k daily queries; define offline benchmark and online A/B testing metrics; outline demographic parity checks and regulatory compliance mitigations under EU AI Act and India DPDP regulations.

You can rigorously evaluate generative models against task benchmarks, red-team systems for security vulnerabilities, and document operational limits in standardized model cards.

1. Evaluation that is not a vibe check90 min
   • Building curated, ground-truth golden evaluation datasets
   • RAG evaluation metrics: Faithfulness, Answer Relevancy, and Context Precision via Ragas
   • LLM-as-a-Judge methodologies and mitigating judge position/verbosity bias
   • Integrating DeepEval or Giskard test suites into CI/CD build gates
   • Setting strict non-regression thresholds for model upgrades in production
2. Red-teaming an AI feature90 min
   • Direct prompt injection: system override exploits ('Ignore all previous instructions')
   • Indirect prompt injection through malicious external data payloads (webpages/PDFs)
   • Jailbreak archetypes: fictional scenarios, roleplay simulation, and encoded payloads
   • Automating adversarial fuzzing using Promptfoo test matrices
   • Documenting successful exploit proofs-of-concept and tracking remediation
3. Bias and fairness90 min
   • Quantifying bias in text generation across protected demographic attributes
   • Stereotyping benchmarks and toxic generation detection classifiers
   • Assessing representation imbalances in pre-training and fine-tuning datasets
   • Trade-off decisions between model conservatism and conversational utility
   • Evaluating safety filter false positive rates on benign user queries
4. Publishing honest limits90 min
   • Writing industry-standard Model Cards following the Mitchell et al. framework
   • Specifying intended use cases, out-of-scope tasks, and known failure modes
   • Designing human-in-the-loop fallback mechanisms for low-confidence outputs
   • Documenting training data provenance, cutoff dates, and hardware compute footprints
   • Establishing incident response procedures for deployed AI safety breaches
5. Data Poisoning & Extraction Attacks90 min
   • Training data poisoning vectors and backdoor trigger insertions
   • Training data extraction and model inversion attack mechanics
   • Mitigating membership inference attacks through differential privacy
   • Defending vector databases against contaminated knowledge chunk injection
   • Verifying input integrity with cryptographic hashing across data pipelines
6. Defensive Architecture & Guardrail Deployment90 min
   • Layered defense-in-depth architecture for generative AI systems
   • Implementing deterministic regex input scrubbers and LLM guardrails
   • Output filtering: scanning model completions for leaked credentials and PII
   • Rate-limiting and anomaly detection for malicious repetitive user probing
   • Conducting automated security regression reviews on updated system prompts

Hands-on project: Build an automated evaluation and adversarial testing suite for an enterprise LLM assistant. Acceptance criteria: run automated benchmark evaluations across a golden test set using RAGAS; execute 20+ red-team attacks including direct prompt injections, jailbreaks, and indirect injection payloads; publish a Model Card documenting observed failure modes, residual risks, and operational boundaries.

You can architect, build, evaluate, containerize, and deploy a production-grade multimodal or RAG AI system, while mastering technical interview rounds.

1. Scoping an end-to-end AI project2 hrs
   • Defining production MVP specifications and technical deliverables
   • Decomposing architectures into microservices: ingestion, vector store, API, and UI
   • Setting milestone timelines, risk registers, and fallback plans
   • Creating architecture blueprints using Mermaid.js and system design templates
   • Selecting appropriate evaluation metrics and building validation datasets
2. Building and deploying your capstone2 hrs
   • Integrating machine learning models behind async FastAPI endpoints
   • Deploying multi-container architectures via Docker Compose on cloud VMs
   • Writing end-to-end integration tests validating inference API pipelines
   • Securing cloud endpoints with TLS/SSL certificates and environment variables
   • Configuring continuous health checks and production error logging
3. Portfolio and GitHub review2 hrs
   • Structuring professional GitHub READMEs: quickstart, architecture, and live links
   • Demonstrating clean Git commit hygiene and meaningful pull request documentation
   • Creating interactive live demos and recording concise architectural walkthrough videos
   • Curating an engineering portfolio showcasing measurable model metrics and business impact
   • Publishing reproducible benchmarks and code examples for technical recruiters
4. AI/ML mock interviews2 hrs
   • Deconstructing machine learning system design interview questions
   • Live Python and NumPy coding round problem patterns and optimization strategies
   • Answering deep-dive questions on gradient descent, transformers, and regularization
   • Behavioral STAR method preparation tailored for cross-functional engineering teams
   • Live 1-on-1 mock interview simulation with comprehensive technical feedback
5. Certification and next steps2 hrs
   • Verifying Squarebrackets course certification credentials and LinkedIn integration
   • Targeting AI Engineer, ML Engineer, and Data Scientist job boards and recruiters
   • Networking tactics: engaging with open-source AI projects and engineering forums
   • Continuous self-directed learning paths: staying current with arXiv research and releases
   • Formulating an ongoing technical growth roadmap for the first 90 days on the job
6. AI System Design Defense & Technical Presentation2 hrs
   • Structuring a formal 15-minute engineering design walkthrough
   • Defending architectural trade-offs: latency vs accuracy vs operational cost
   • Handling adversarial technical questions from interviewing lead engineers
   • Presenting error analysis and telemetry data from live capstone deployments
   • Post-presentation reflection, code review remediation, and project sign-off

Hands-on project: Build, deploy, and defend an enterprise-grade AI Capstone system. Acceptance criteria: train or fine-tune a model and integrate it into a production backend with FastAPI; incorporate a vector search RAG pipeline or deep learning inference component; package the complete system with Docker and deploy to cloud infrastructure with live URLs; publish a polished GitHub repository with full architecture diagrams, unit tests, and performance benchmarks; clear a mock technical interview loop.