Convolutional Neural Networks Questions

Deep and practical expertise in convolutional neural networks and their architectures for spatial and visual data tasks. Candidates should understand convolution operations including filters and kernels, feature maps and receptive field, stride and padding, pooling operations, activation functions and normalization methods, and how these components combine to form a hierarchical representation of spatial features. Know architectural building blocks such as residual connections, dense connections, bottleneck layers, inception modules, squeeze and excitation blocks, depthwise separable and grouped convolutions, dilated convolutions, and attention augmented convolutions. Be familiar with canonical model families and examples such as AlexNet, VGG, ResNet, Inception, DenseNet, MobileNet, EfficientNet and modern hybrids that combine convolutional features with transformer based components, and be able to reason about design trade offs between depth and width, representational capacity, parameter counts, computational cost, latency and memory footprint. Understand training and regularization strategies including batch normalization and layer normalization, dropout, weight decay, data augmentation, optimizers and learning rate schedules, initialization, and techniques for training from scratch versus fine tuning pretrained models. Know transfer learning and domain adaptation approaches, and model compression and deployment techniques such as pruning, quantization, knowledge distillation and low rank factorization for mobile and edge systems. Be able to select and adapt architecture choices for specific vision tasks such as classification, object detection and instance segmentation, and to evaluate models using appropriate metrics such as classification accuracy and top k accuracy, intersection over union and mean average precision on standard benchmarks such as ImageNet and Common Objects in Context.

MediumTechnical

34 practiced

You are training a semantic segmentation CNN with highly imbalanced classes (tiny lesions vs large background). Propose loss functions and strategies such as class weighting, focal loss, dice or Tversky loss, oversampling, patch-based sampling and augmentation to improve learning for rare classes. Discuss trade-offs and implementation details.

Sample Answer

Start with the goal: maximize sensitivity for tiny lesion class while keeping false positives low and stable training.

Recommended loss functions & combinations- Weighted cross-entropy: simple baseline. Set weight = 1 / class-frequency or tuned via validation. Good for stable probabilities but struggles with tiny objects.- Focal Loss: down-weights easy/background pixels; use alpha to up-weight lesion class and gamma=1-2. Helps when background dominates.- Dice / Soft Dice Loss: directly optimizes overlap; very effective for imbalanced segmentation of small regions.- Tversky Loss: generalizes Dice with controllable false-negative vs false-positive trade-off (use β>α to penalize FN more for lesions).- Combined loss: BCE/Focal + Dice/Tversky often works best (pixel-wise + region overlap).

Implementation snippet (PyTorch):

python

import torch, torch.nn as nn
def combo_loss(pred, target, weight=None, alpha=0.25, gamma=1.0, smooth=1):
    bce = nn.BCEWithLogitsLoss(pos_weight=weight)(pred, target)
    prob = torch.sigmoid(pred)
    intersection = (prob * target).sum()
    dice = 1 - (2*intersection + smooth) / (prob.sum() + target.sum() + smooth)
    # optional focal modulation on bce
    p_t = prob*target + (1-prob)*(1-target)
    focal = (alpha * (1-p_t)**gamma * nn.BCEWithLogitsLoss(reduction='none')(pred, target)).mean()
    return 0.5*dice + 0.5*focal

Sampling & augmentation strategies- Patch-based sampling: sample patches with higher probability if they contain lesion (e.g., 50% lesion patches, 50% random). Preserves global context with multi-scale patches.- Oversampling: replicate rare-class examples or use weighted dataloader.- Hard example mining: mine patches where model currently fails.- Augmentation: heavy geometric (rotations, flips), elastic deformations, intensity scaling, mixup / CutMix (careful with tiny lesions), synthetic lesion insertion if available.

Practical trade-offs & tips- Overfitting risk: oversampling/patch sampling increases redundancy; use strong augmentation and validation on whole images.- Metric alignment: optimize loss aligned with evaluation metric (Dice/IoU) to avoid metric gap.- Stability: combine region (Dice/Tversky) and pixel (BCE/Focal) losses to stabilize gradients early and fine-tune overlap later.- Batch composition: ensure each batch contains at least some positive pixels to keep loss signal.- Efficiency: patch sampling reduces memory but may lose global context; use multi-scale or pyramid inference.- Calibration: focal/weighting can bias predicted probabilities—calibrate thresholds per validation ROC/PR.

Monitoring & deployment- Track class-wise precision/recall, Dice, and false positive rate per image.- Use sliding-window inference with test-time augmentation and ensemble thresholds to reduce FP.This approach balances learning signal for tiny lesions while controlling FP and maintaining training stability.

HardTechnical

20 practiced

Describe hybrid architectures that combine convolutional layers with transformer blocks (for example a CNN frontend extracting local features followed by transformer blocks capturing global interactions). Explain how to integrate positional embeddings with convolutional feature maps, benefits in sample efficiency and trade-offs in compute and latency.

Sample Answer

Definition and goal:Hybrid CNN+Transformer architectures use convolutional layers to produce rich local feature maps and transformer blocks to model long-range, cross-region interactions. This leverages CNN inductive biases (translation equivariance, local connectivity) for sample efficiency and transformers’ flexibility for global context.

How to integrate positional information:- 2D learned positional embeddings: after CNN backbone produces H×W×C feature map, flatten spatial locations to N=H·W tokens and add a learnable positional vector per location (initialized sinusoidal or learned). Works well when H,W fixed.- Relative positional bias: compute attention biases based on pairwise relative offsets (Δx,Δy) — parameterize with small lookup table or MLP; more flexible to variable sizes and improves generalization.- Convolutional positional encoding: add shallow conv layers (e.g., depthwise conv with large kernels or CoordConv) to inject explicit spatial coordinates into features before tokenization.- Continuous coordinate embeddings: concatenate normalized (x/H, y/W) coordinates and project; useful for variable-resolution inputs.

Benefits in sample efficiency:- CNN front-end encodes locality and texture priors, requiring fewer labeled samples than pure ViT for comparable accuracy, especially on small/medium datasets.- Local feature pooling reduces token count, improving optimization and generalization early in training.

Compute and latency trade-offs:- Compute: convolutional encoder adds FLOPs but often reduces token length fed to transformer (downsampling), lowering transformer quadratic cost. Net compute depends on backbone depth and reduction ratio.- Memory: transformer attention scales O(N^2); reducing N via CNN downsampling cuts memory dramatically.- Latency: shallow CNNs add serial depth—can increase inference time compared to tiny ViTs if not parallelized. However, reduced transformer size often yields lower end-to-end latency.- Hardware considerations: convolutions map well to optimized kernels on edge GPUs/TPUs; attention benefits from optimized batched matmuls but suffers at large N.- Accuracy vs efficiency trade-off: stronger CNN reduces transformer capacity needs but may reintroduce locality bias limiting modeling of some global patterns. Design choice (where to split and how much downsampling) must balance accuracy, FLOPs, and latency.

Practical recommendations:- Downsample to keep token count manageable (e.g., 7×7–14×14 tokens).- Use relative positional bias for variable resolutions and robustness.- Profile on target hardware; prefer depthwise separable convs and linear attention variants if attention dominates latency.- Fine-tune positional modules when transferring to downstream tasks to recover spatial fidelity.

MediumTechnical

22 practiced

Implement a knowledge distillation training loop in PyTorch where a small student CNN learns from a large pretrained teacher. Show how to compute softened probabilities with temperature T, combine cross-entropy with labels and KL divergence between softened logits, and schedule alpha mixing between distillation and label loss.

Sample Answer

Approach: compute teacher and student logits, soften probabilities with temperature T (softmax(logits / T)), combine supervised CE with true labels and distillation loss as KL divergence between teacher and student softened distributions. Use alpha(t) schedule (e.g., linear warmup or cosine) to mix losses.

python

import torch
import torch.nn.functional as F
from torch import nn, optim

def soft_probs(logits, T):
    # logits: (B, C)
    return F.log_softmax(logits / T, dim=1), F.softmax(logits / T, dim=1)

def linear_alpha(step, total_steps, start=0.0, end=0.7):
    return start + (end - start) * min(1.0, step / total_steps)

def train_one_epoch(student, teacher, dataloader, optimizer, device, T=4.0, alpha_final=0.7, alpha_warmup_steps=10000):
    student.train()
    teacher.eval()
    total_loss = 0.0
    step = 0
    for x, y in dataloader:
        x, y = x.to(device), y.to(device)
        optimizer.zero_grad()

        with torch.no_grad():
            t_logits = teacher(x)             # (B, C)

        s_logits = student(x)                 # (B, C)

        # Supervised CE with hard labels
        ce_loss = F.cross_entropy(s_logits, y)

        # Distillation loss: KL(student_soft || teacher_soft)
        s_logprob, _ = soft_probs(s_logits, T)   # log probs for student
        _, t_prob = soft_probs(t_logits, T)      # probs for teacher

        # KLDivLoss expects input = log_prob, target = prob
        kd_loss = F.kl_div(s_logprob, t_prob, reduction='batchmean') * (T * T)

        # alpha schedule
        alpha = linear_alpha(step, alpha_warmup_steps, start=0.0, end=alpha_final)

        loss = (1.0 - alpha) * ce_loss + alpha * kd_loss
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        step += 1

    return total_loss / len(dataloader)

Key points:- Softening by T spreads probability mass; multiply KL by T^2 to account for gradient scaling.- Use log_softmax for student and softmax for teacher; KLDiv expects log-probs input.- Alpha schedule lets training transition from label supervision to teacher guidance.- Monitor accuracy on validation; consider weighting classes, temperature tuning, and avoiding teacher gradients (teacher.eval() + no_grad()). Edge cases: small batch sizes, mismatched class counts, or frozen student batchnorm handling.

HardTechnical

21 practiced

Explain dilated (atrous) convolutions and how they increase receptive field without pooling. Describe common use cases such as semantic segmentation and audio models, and implement a small PyTorch dilated conv block showing how to set dilation and compute the effective receptive field and output size.

Sample Answer

Dilated (atrous) convolutions insert spaces ("holes") between kernel elements so a k×k kernel with dilation d covers an effective kernel size k_eff = k + (k-1)*(d-1). This increases the receptive field without downsampling (no pooling/stride), preserving spatial resolution — useful for tasks needing dense prediction like semantic segmentation and for temporal models in audio where long context matters (e.g., WaveNet, temporal conv nets).

Key intuition:- Dilation stretches the kernel's coverage: same params, larger field.- Keeps output resolution (if stride=1 and padding adjusted).- Good for multi-scale context via stacked dilations (exponential dilation factors) or atrous spatial pyramid pooling (ASPP).

Use cases:- Semantic segmentation: capture global context while keeping pixel-aligned outputs (DeepLab family).- Audio/time series: model long-range dependencies with 1D dilated conv stacks (WaveNet).

PyTorch dilated conv block and utilities:

python

import torch
import torch.nn as nn
import math

class DilatedConvBlock(nn.Module):
    def __init__(self, in_ch, out_ch, kernel_size=3, dilation=1, padding=None):
        super().__init__()
        self.k = kernel_size
        self.d = dilation
        # if padding not provided, choose 'same' padding
        if padding is None:
            padding = ((self.k - 1) * self.d) // 2
        self.conv = nn.Conv2d(in_ch, out_ch, kernel_size=self.k, dilation=self.d, padding=padding, bias=False)
        self.bn = nn.BatchNorm2d(out_ch)
        self.act = nn.ReLU(inplace=True)

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

def effective_kernel_size(k, d):
    return k + (k - 1) * (d - 1)

def output_size(input_size, kernel_size, padding, dilation, stride=1):
    # for one spatial dim
    k_eff = effective_kernel_size(kernel_size, dilation)
    return math.floor((input_size + 2*padding - k_eff) / stride) + 1

# Example:
if __name__ == "__main__":
    x = torch.randn(1, 3, 128, 128)
    block = DilatedConvBlock(3, 16, kernel_size=3, dilation=4)
    y = block(x)
    print("Input:", x.shape, "Output:", y.shape)
    print("Effective kernel:", effective_kernel_size(3,4))
    print("Output H:", output_size(128, 3, ((3-1)*4)//2, 4))

Complexity and notes:- Parameter count unchanged versus non-dilated kernel size; FLOPs similar per output position but more context covered.- Stacking large dilations risks gridding artifacts; mitigate via mixed dilation rates, hybrid pooling, or ASPP.- For 1D audio convs, same formulas apply with 1D conv layers.

HardTechnical

22 practiced

A CNN training run behaves normally for 3 epochs then suddenly the training loss diverges and validation accuracy collapses. Provide a systematic debugging checklist covering data corruption, label noise or leakage, optimizer and LR schedule issues, exploding gradients, BatchNorm running stats, random seed problems and hardware faults. Propose remediation steps and how to reproduce and isolate the failure.

Sample Answer

Start with a hypothesis-driven checklist: detect, isolate, fix, and reproduce. For each failure mode below: what to check, how to confirm, remediation, and reproducible test.

1) Quick triage- Save training state (model, optimizer, RNG states, batch indices, a few input/label batches) at epoch 3 checkpoint.- Record GPU temps, memory, driver logs, nondeterministic warnings.

2) Data corruption- Check sample-level statistics (mean/std), image shape/dtype, value ranges over time (before/after epoch 3).- Confirm DataLoader shuffling/caching not returning empty/constant tensors.- Repro: load batches used in epoch 4 standalone and visualize / assert invariants.- Fix: re-generate dataset, validate pipeline, add input sanity asserts.

3) Label noise / leakage- Compute label distribution and per-sample loss; inspect samples with sudden high loss.- Check unintended label overwrites (in-place ops), augmentation pipeline not mixing labels (e.g., CutMix without label update).- Repro: freeze RNG and feed same indices; inject/repair labels.- Fix: correct loader, add unit tests for augment-label alignment.

4) Optimizer / LR schedule- Log LR and momentum per step. Look for sudden LR spikes (scheduler bug at epoch boundary).- Check mixed precision scaling (GradScaler) overflow/underflow.- Repro: run with fixed small LR, disable scheduler, or stepwise LR logging.- Fix: clip LR jumps, use conservative schedulers, fix scaler settings.

5) Exploding gradients- Track gradient norms per layer. Look for sudden jump before divergence.- Repro: run with gradient clipping (norm or value), reduced LR, or smaller batch size.- Fix: gradient clipping, weight decay, smaller initial LR, normalize inputs.

6) BatchNorm running stats- If batch size small or model switches eval/train incorrectly, running_mean/var can blow up.- Check model.train()/eval() calls, verify momentum values, inspect running stats distributions.- Repro: replace BatchNorm with GroupNorm or SyncBN; run with larger batch or accumulate grads.- Fix: correct mode toggling, use GN or synchronized BN, adjust momentum.

7) Random seed / non-determinism- Ensure reproducible seeds for dataset workers, CUDA, cuDNN determinism flags.- Repro: rerun with saved checkpoint and the same seeds; if failure disappears, track RNG-dependent op (augmentations, sampler).- Fix: set deterministic flags, fix worker seeding, avoid nondeterministic ops.

8) Hardware / drivers- Inspect dmesg, CUDA errors, ECC, GPU thermal throttling, power spikes.- Repro: run on different machine/GPU, or CPU run for short test.- Fix: update drivers, replace GPU, run memory tests.

General remediation & isolation strategy- Add intensive logging: per-batch loss, LR, grad norms, BN stats, sample hashes.- Narrow search by binary search over epochs/checkpoints to find first failing step.- Create minimal reproducible script that loads checkpoint at epoch 3 and runs one epoch deterministically while toggling one factor at a time (data, optimizer, BN, mixed precision, hardware).- Temporary mitigations: enable gradient clipping, lower LR, switch off complex augmentations, replace BN → GN.- Long-term: unit tests for data/loader, CI training run smoke tests, monitoring alerts for sudden metric shifts.

When presenting findings: include exact logs, diffs of pipeline code around epoch boundary, and a reproducible script demonstrating the fix.

Unlock Full Question Bank

Get access to hundreds of Convolutional Neural Networks interview questions and detailed answers.

Join thousands of developers preparing for their dream job.