Deep Learning with PyTorch

Configure a PyTorch development environment and verify computation on the Apple MPS device.

Create PyTorch tensors with controlled shapes, data types, and devices.

Transform tensor dimensions using indexing, reshaping, transposition, and broadcasting.

Express batched linear transformations with matrix multiplication and Einstein summation.

Compute derivatives through a small computational graph using the chain rule.

Calculate probabilities, log-likelihood, and cross-entropy for a classification example.

Use PyTorch autograd to compute gradients and inspect the resulting computation graph.

Validate an autograd result against a manually calculated gradient.

Define a neural network by subclassing PyTorch nn.Module.

Initialize model parameters and inspect the registered parameter tree.

Construct a Dataset and DataLoader for mini-batch training.

Implement a complete mini-batch training loop with forward, backward, and optimization steps.

Implement an evaluation loop that disables gradient tracking and reports held-out metrics.

Save and restore model, optimizer, and training state from checkpoints.

Make a training run reproducible by controlling random seeds and deterministic settings.

Write shape and gradient checks that catch common training-loop defects.

Compare the update rules of stochastic gradient descent, momentum, and AdamW.

Select a learning rate by interpreting short-run training and validation curves.

Apply a learning-rate warmup and decay schedule in PyTorch.

Choose activation functions by analyzing their gradient behavior.

Choose parameter initialization based on layer width and activation function.

Compare Layer Normalization and RMS Normalization for stabilizing decoder-only transformers.

Apply weight decay and dropout to reduce overfitting.

Diagnose vanishing, exploding, and noisy gradients from logged statistics.

Formulate next-token prediction as a maximum-likelihood objective.

Compare character, word, and subword tokenization trade-offs.

Train a byte-pair encoding tokenizer on a small text corpus.

Encode and decode text while correctly handling special tokens.

Construct fixed-length causal language-modeling examples from token streams.

Create shifted input-target batches for next-token prediction.

Build causal and padding masks with correct tensor dimensions.

Compute token-level cross-entropy and perplexity while ignoring padded positions.

Derive scaled dot-product attention from query-key similarity and value aggregation.

Implement single-head causal self-attention using basic tensor operations.

Implement multi-head self-attention with projection and head reshaping.

Compare learned, sinusoidal, and rotary positional representations.

Trace the flow of residual connections and normalization through a pre-norm transformer block.

Implement a feed-forward sublayer used in decoder-only transformers.

Calculate the time and memory complexity of self-attention for a given sequence length.

Estimate parameter, activation, optimizer-state, and gradient memory costs.

Implement a decoder-only transformer block as a reusable PyTorch module.

Assemble token embeddings, positional information, transformer blocks, normalization, and an output head into a GPT-style model.

Tie input embedding and output projection weights correctly.

Verify the model by overfitting a single mini-batch.

Implement gradient accumulation with correct loss scaling to reach a target effective batch size.

Train a small causal language model on a prepared text corpus.

Generate text with greedy, temperature, top-k, and nucleus sampling.

Track training loss, validation perplexity, gradient norms, and tokens per second.

Create a leakage-resistant train-validation-test split for text data.

Evaluate a language model with perplexity under a fixed tokenization and context policy.

Construct a small task-based evaluation set for generated text.

Assess generated responses with explicit quality and safety criteria.

Run an ablation experiment that isolates one architectural or training choice.

Diagnose underfitting, overfitting, and optimization failure from experiment evidence.

Document an experiment so another practitioner can reproduce its result.

Read a deep-learning paper by extracting its claim, method, assumptions, and evidence.

Load a pretrained causal language model and matching tokenizer with Hugging Face Transformers.

Inspect a pretrained model configuration and map it to the transformer components implemented earlier.

Format prompts using the model's expected chat template.

Control generation behavior with decoding parameters and stopping criteria.

Batch and pad variable-length prompts correctly for causal generation.

Measure the runtime and memory footprint of pretrained-model inference.

Use the Hugging Face Datasets library to load and transform a text dataset.

Implement an evaluation baseline for a pretrained model before fine-tuning.

Curate training examples to reduce duplication, leakage, and low-quality responses.

Convert raw examples into instruction-response records suitable for supervised fine-tuning.

Mask prompt tokens when computing response-only supervised fine-tuning loss.

Run full-parameter supervised fine-tuning on a small model.

Choose LoRA target modules, rank, scaling, and dropout by estimating trainable-parameter and memory costs.

Fine-tune a pretrained language model with LoRA using the PEFT library.

Run quantized LoRA fine-tuning on a compatible cloud GPU.

Save, load, and optionally merge a trained adapter with its base model.

Design held-out evaluations that measure the behavior targeted by fine-tuning.

Compare the base and fine-tuned models using identical prompts and decoding settings.

Detect catastrophic forgetting and response-format overfitting.

Diagnose a fine-tuning run from loss curves and sampled outputs.

Explain how preference data differs from supervised instruction data.

Compute the Bradley-Terry loss for a pair of candidate responses and interpret its role in reward-model training.

Explain how a KL penalty constrains policy updates in PPO-based RLHF.

Formulate the Direct Preference Optimization objective and compare its optimization process with reward-model-plus-PPO RLHF.

Calculate training throughput, latency, speedup, and scaling efficiency.

Explain how GPU compute, memory hierarchy, and interconnect bandwidth constrain training.

Trace ring all-reduce across workers for a distributed gradient update.

Distinguish data, tensor, pipeline, and expert parallelism by what each partitions.

Explain how DistributedDataParallel synchronizes gradients across processes.

Launch a multi-process PyTorch job with torchrun and initialize a process group.

Train a model with DistributedDataParallel and a DistributedSampler.

Save and restore distributed checkpoints without corrupting shared state.

Explain how parameter, gradient, and optimizer-state sharding reduce per-device memory.

Configure a small FullyShardedDataParallel training run on cloud GPUs.

Measure communication overhead and scaling efficiency in a multi-GPU experiment.

Debug a distributed hang using rank-aware logs and collective-operation checks.

Design a controlled experiment that tests one claim about language-model training or fine-tuning.

Integrate the previously developed components into a reproducible pipeline for training and logging a small GPT-style model.

Integrate the fine-tuning and evaluation components into a reproducible pretrained-LLM adaptation pipeline.

Defend the capstone's architecture, optimization, evaluation, and distributed-systems choices in a technical-interview format.