Computer Vision

A dense layer gives every pixel its own weight, so its parameter count scales with image size. A conv layer learns one small kernel and reuses it at every position — cost depends only on kernel size and channels, and one feature is found anywhere.

The core building block of a CNN. It holds learnable filters (kernels); each filter spans ALL input channels and slides over the input, taking a dot product with each patch to produce one feature-map value. Multiple filters give multiple output channels.

Pooling downsamples a feature map: it splits the map into small w×h blocks and applies a fixed function per block — usually max or average. It has NO learnable parameters. Goals: enlarge later convolutions' receptive field, add invariance to small shifts, and speed up compute.

With that little data, first replace the head and train it alone with the backbone frozen. Then unfreeze top-down, deepest blocks first, at a much lower learning rate. Early layers hold generic edges worth keeping; late task-specific layers must adapt.

Each spatial side becomes floor((W − K + 2P)/S) + 1. Kernel size K sets how much context one output sees, padding P protects border pixels and can preserve the size, stride S downsamples. Output channels equal the filter count, independent of all three.

An augmentation is safe only if the label survives it under that task's semantics. Flips break digits, crops cut characters out of OCR targets, and colour jitter destroys diagnostic hue in medical images. Choose from the task, not a default list.

It is the input region that can influence one output activation. Depth grows it additively, stride and pooling multiply the growth of all layers above them, and dilation spreads a kernel's taps apart to widen it without extra weights.

It splits a standard convolution into a depthwise step — one k×k filter per input channel, no channel mixing — then a 1×1 pointwise convolution that mixes channels. Cost falls to roughly 1/N + 1/k², so a 3×3 layer gets about 8–9× cheaper.

The proposal stage filters a few hundred likely regions first, so the head sees a balanced, well-localized set — better accuracy on small or crowded objects. One-stage detectors score a dense anchor grid in one pass, for tight latency budgets.

Validation is drawn only from studio shots, so it never sees the deployment distribution, and the inference transform skips the normalization used in training. Fix both — match the serving transform to training and validate on real phone photos.

Both reach a 5×5 receptive field, but two 3×3 layers use 18C² weights against 25C² and insert a nonlinearity between them, so the composition is more expressive. The extra activation and smaller parameter budget are the gain, not field size.

It cuts the image into fixed patches, embeds each as a token, adds positional encodings and runs global self-attention, so patches interact from layer one. It has no locality or translation equivariance prior, so those come from huge data or pretraining.

Deep nets suffer vanishing/exploding gradients: chain-rule backprop multiplies many small (or large) factors, so the signal shrinks or blows up before reaching early layers. A residual block adds an identity skip that bypasses a couple of layers, computing F(x) + x — a gradient highway that lets ResNets go deep.

Two encoders map images and captions into one shared embedding space, trained contrastively — matched pairs in a batch pulled together, all other pairings pushed apart. Zero-shot follows by embedding class names as prompts and taking the nearest.

Convolution is equivariant — shift the input and the feature map shifts the same way. Pooling, especially global pooling, turns that into approximate invariance by discarding where the response fired. Flatten into a dense head destroys both.

Walk the layers front to back keeping a running jump, the product of the strides so far. Start with rf = 1 and jump = 1; for each layer do rf += (k − 1) × jump, then jump ×= s. Each layer adds k − 1 pixels scaled by the preceding downsampling.

Use Test-Time Augmentation (TTA): at inference run the model on several augmented views — crops, rotations, flips — and average the predictions. No retraining is needed; the cost is ≈N× forward passes, and augmentations must preserve the label.

A classifier collapses the map to one label. U-Net adds a decoder that upsamples back to full resolution, predicting a class per pixel. Skip connections carry high-resolution encoder features across, restoring boundaries downsampling destroyed.

Dilation spreads kernel taps apart, widening the field at unchanged parameters and resolution, but it samples sparsely and can cause gridding. Pooling or stride widen it cheaply while discarding detail. A bigger kernel keeps detail but costs grow quadratically.

It applies several kernel sizes in parallel (1×1, 3×3, 5×5) plus 3×3 max-pooling and concatenates the outputs, so one layer captures multi-scale features. The naive version explodes the channel count; the fix inserts 1×1 convolutions as a bottleneck to cut channels cheaply so the net can go deep.