Deep Learning

Represent numbers, images, text, and batches as multidimensional arrays. Practice shapes, indexing, broadcasting, vectorization, data types, and device placement.

Use vectors, matrices, dot products, matrix multiplication, norms, projections, and eigenvalues to describe neural network computations. Connect each operation to transformations of real data.

Work with derivatives, partial derivatives, gradients, Jacobians, and the chain rule. Use these tools to reason about how changing a parameter affects a model’s loss.

Use random variables, common distributions, expectation, variance, sampling, conditional probability, and Bayes’ rule. Apply statistical reasoning to noisy data and uncertain predictions.

Connect entropy, cross-entropy, Kullback–Leibler divergence, and mutual information to classification, representation learning, and generative models.

Frame supervised, unsupervised, and reinforcement learning problems; create train, validation, and test splits; and recognize underfitting, overfitting, leakage, and distribution shift. Build classical baselines to judge whether deep learning is justified.

Trace the field from perceptrons and early connectionism through backpropagation, convolutional networks, ImageNet, GPUs, transformers, and foundation models. Relate each breakthrough to changes in data, computing, algorithms, and research culture.

Build perceptrons and multilayer networks from weighted sums, biases, activation functions, and stacked layers. Implement a forward pass and use a network for regression and classification.

Choose output layers and objectives for regression, binary classification, multiclass classification, multilabel prediction, ranking, and metric learning. Diagnose mismatches between a task, its labels, and its loss function.

Derive backpropagation with the chain rule, represent models as computational graphs, and use automatic differentiation. Check gradients numerically to catch implementation errors.

Train networks with stochastic gradient descent, momentum, Adam, learning-rate schedules, warmup, and gradient clipping. Read loss curves and respond to unstable, stalled, or inefficient training.

Control signal and gradient flow with principled weight initialization, residual connections, batch normalization, layer normalization, and related methods. Diagnose exploding, vanishing, and poorly scaled activations.

Improve generalization with weight decay, dropout, early stopping, label smoothing, data augmentation, and capacity control. Separate genuine improvement from memorization or leakage.

Select metrics that match the real cost of errors, compare models with controlled experiments, and inspect performance across subgroups and operating thresholds. Use error analysis rather than a single headline score.

Measure confidence with calibration curves, proper scoring rules, ensembles, Monte Carlo dropout, and uncertainty estimates. Design abstention or human-review paths when a model should not decide alone.

Collect, label, clean, split, version, batch, shuffle, and augment data while preserving provenance. Build efficient input pipelines and prevent duplicate, temporal, or identity leakage.

Implement and train models with current tensor frameworks such as PyTorch, TensorFlow, and JAX. Use modules, optimizers, data loaders, accelerators, mixed precision, and debugging tools while recognizing the shared concepts beneath each framework.

Track configurations, seeds, datasets, checkpoints, metrics, and environment details so results can be repeated. Plan ablations, tune hyperparameters, compare runs fairly, and report failed experiments honestly.

Use convolution, pooling, receptive fields, padding, stride, and channel hierarchies to process images and spatial data. Train and inspect a convolutional image classifier.

Locate and classify multiple objects using bounding boxes, anchors, region proposals, one-stage detectors, non-maximum suppression, and detection metrics. Build a small detection pipeline and analyze missed and duplicate detections.

Assign labels to pixels with encoder–decoder networks, skip connections, upsampling, and segmentation-specific losses. Evaluate semantic and instance segmentation with overlap-based metrics.

Map discrete items such as words, products, and categories into learned vector spaces. Inspect similarity, analogy, clustering, and the limits and biases of embedding geometry.

Model ordered data with recurrent neural networks, LSTMs, GRUs, teacher forcing, and sequence-to-sequence architectures. Handle variable-length batches and diagnose long-range dependency problems.

Compute queries, keys, values, attention scores, masks, and multi-head attention. Implement attention directly and show how it replaces or complements recurrence.

Build transformer encoders and decoders from attention, positional information, feed-forward layers, residual paths, and normalization. Train a compact transformer and reason about its computational costs.

Apply patch embeddings, class tokens, hierarchical attention, and image-specific augmentation to transformer-based vision models. Compare vision transformers with convolutional networks under different data and compute limits.

Reuse pretrained models through frozen features, gradual unfreezing, and discriminative learning rates. Adapt models across domains while detecting negative transfer and source-target mismatch.

Create training targets from unlabeled data using contrastive learning, masked prediction, teacher–student methods, and representation collapse prevention. Evaluate representations with linear probes and downstream tasks.

Compress data into latent variables with deterministic autoencoders and probabilistic variational autoencoders. Use reconstruction, regularized latent spaces, sampling, and interpolation to study learned structure.

Train generators and discriminators through adversarial objectives. Address mode collapse, unstable dynamics, evaluation difficulties, and responsible handling of synthetic media.

Model data through forward noising and learned reverse denoising processes. Implement a compact diffusion model, use conditional guidance, and compare sampling quality, diversity, and speed.

Represent entities and relationships as graphs, then apply message passing, graph convolution, attention, pooling, and link prediction. Work with node, edge, and whole-graph tasks while avoiding information leakage.

Model numerical and categorical columns with embeddings, multilayer networks, attention-based architectures, and strong regularization. Compare neural models against tree-based baselines on realistic structured datasets.

Prepare temporally ordered data, create rolling validation splits, and model forecasting with recurrent, convolutional, attention-based, and probabilistic networks. Handle seasonality, missing values, covariates, and forecast uncertainty.

Represent sound with waveforms, spectrograms, and learned audio features. Build models for speech recognition, audio classification, speaker tasks, and speech generation while accounting for noise and latency.

Use user–item embeddings, neural ranking, sequence models, and two-stage retrieval-and-ranking systems. Address cold starts, feedback loops, offline metrics, and online experimentation.

Combine neural networks with Markov decision processes, value functions, policy gradients, actor–critic methods, replay buffers, and exploration strategies. Train an agent in simulation and evaluate stability, safety, and sample efficiency.

Apply neural networks to differential equations, physical simulations, surrogate modeling, molecular data, and scientific inverse problems. Check whether predictions obey known constraints rather than relying only on benchmark error.

Use GPUs and other accelerators efficiently through batching, profiling, mixed precision, kernel-aware design, and memory management. Scale training with data, model, and pipeline parallelism while measuring communication costs.

Connect tokenization, next-token prediction, large-scale self-supervision, scaling behavior, emergent capabilities, and data curation. Examine how large language models and other foundation models are pretrained and evaluated.

Control language model outputs with decoding methods, structured prompts, few-shot examples, tool schemas, and context management. Measure quality, latency, cost, and sensitivity instead of treating prompting as guesswork.

Adapt pretrained models with supervised fine-tuning, instruction tuning, preference optimization, low-rank adaptation, adapters, and quantization-aware methods. Prepare training data and detect catastrophic forgetting or capability regression.

Build retrieval-augmented generation systems with document parsing, chunking, embeddings, indexes, hybrid search, reranking, citations, and grounded generation. Evaluate retrieval and answer quality separately and defend against poisoned or misleading sources.

Combine text, images, audio, video, and sensor data through modality-specific encoders, shared representations, cross-attention, and alignment objectives. Design and evaluate systems that reason or generate across more than one modality.

Reduce model size and latency with pruning, quantization, distillation, low-rank methods, efficient attention, and architecture changes. Benchmark accuracy, memory, throughput, energy use, and hardware compatibility.

Package models behind batch, streaming, or online interfaces; manage preprocessing and postprocessing; and choose serving hardware. Test throughput, tail latency, concurrency, rollback, and failure behavior before release.

Run neural networks on phones, browsers, embedded devices, and edge accelerators under strict memory, power, privacy, and latency constraints. Convert, profile, and validate a compact model on a constrained target.

Monitor input quality, drift, prediction distributions, calibration, latency, cost, and real-world outcomes after deployment. Set alerts, investigate regressions, collect feedback, and decide when to retrain or retire a model.

Inspect models with saliency methods, feature attribution, activation analysis, probes, counterfactuals, and example-based explanations. Match explanation methods to the audience and test whether an explanation is stable and faithful.

Test neural systems against adversarial examples, data poisoning, model theft, prompt injection, unsafe tool use, and dependency compromise. Apply threat modeling, access controls, red teaming, and layered defenses across the model lifecycle.

Protect sensitive training and inference data with minimization, de-identification, differential privacy, secure computation, and federated learning. Evaluate privacy leakage and the utility cost of protective measures.

Measure disparate performance, trace harms to data and design choices, document limitations, and plan human oversight and appeals. Apply model cards, dataset documentation, risk reviews, and relevant organizational or legal controls.

Carry a real problem from stakeholder request through task definition, data audit, baseline, model choice, training, validation, deployment, monitoring, documentation, and follow-up. Produce a reproducible repository, model card, evaluation report, and working demonstration.

Map the skills used in research, machine learning engineering, data work, applied science, safety, infrastructure, and product roles. Build proof-of-skill projects, assess optional certifications, contribute through open work or community problems, read papers critically, and maintain a practical system for staying current.