6. Deep Learning Architectures and Optimization

Introduction and Context

Deep learning has become a principal methodology for constructing artificial intelligence systems that learn hierarchical representations from data. Unlike conventional machine-learning pipelines, in which domain experts manually design most input features, deep neural networks learn multiple levels of representation through successive transformations. Early layers may detect local or low-level regularities, intermediate layers may encode parts or patterns, and later layers may represent objects, events, linguistic meaning, or decision-relevant abstractions.

The practical success of deep learning is not explained by depth alone. Effective systems depend on a relationship among architecture, objective function, optimization algorithm, data quality, computational resources, and deployment constraints. A convolutional network may be appropriate for spatially structured signals, while an attention-based architecture may be preferable when relationships between distant elements are important. Similarly, a large model can achieve excellent training performance yet generalize poorly, consume unacceptable resources, or fail under distribution shift.

This chapter examines the design and optimization of modern deep-learning systems. It connects multilayer perceptrons, convolutional neural networks, recurrent ideas, attention mechanisms, transformers, normalization, regularization, distributed training, hyperparameter optimization, and model compression. The emphasis is not merely on describing architectures, but on explaining why particular design choices work, how they interact, and how they should be evaluated in research and professional settings.

Learning Objectives

By the end of this chapter, the reader should be able to:

1. Explain how multilayer neural networks learn hierarchical representations.

2. Select and modify convolutional, attention-based, and transformer architectures for different data structures.

3. Analyze the effects of activation functions, initialization, normalization, regularization, and optimization algorithms.

4. Design a reproducible training strategy, including distributed execution and hyperparameter search.

5. Evaluate trade-offs among accuracy, computational cost, robustness, fairness, privacy, and deployability.

6. Apply pruning, quantization, knowledge distillation, and related compression methods.

7. Critically assess deep-learning systems in research and organizational contexts.

From Layered Functions to Learned Representations

A neural network can be viewed as a parameterized function. For an input vector \(x\), a single layer computes

\[

z = Wx+b, \qquad h=\phi(z),

\]

where \(W\) is a matrix of weights, \(b\) is a bias vector, and \(\phi\) is an activation function. A multilayer perceptron (MLP) composes such transformations:

\[

f(x)=f_L(f_{L-1}(...f_2(f_1(x)))) .

\]

The network parameters are learned by minimizing a loss function over a dataset. For supervised classification, cross-entropy is commonly used; for regression, squared error, absolute error, or task-specific objectives may be appropriate. Training uses backpropagation to calculate gradients of the loss with respect to parameters, followed by an optimization update.

Depth permits compositional representation. A function that is difficult to express with one broad transformation may be represented efficiently as a sequence of simpler transformations. However, increasing depth introduces optimization difficulties. Gradients may become very small or very large as they pass through many layers. Saturating activations, unsuitable initialization, poorly scaled inputs, and ill-conditioned loss surfaces can all slow or destabilize learning.

The rectified linear unit, \(\phi(z)=\max(0,z)\), became influential because it provides a simple nonlinearity and avoids saturation on positive inputs. Variants such as leaky ReLU, GELU, and SiLU provide nonzero or smoother behavior for negative inputs. No activation is universally best: the choice interacts with initialization, normalization, architecture, and hardware implementation.

Important terminology

A parameter is a learned quantity such as a weight or bias. A hyperparameter is selected externally, such as learning rate, batch size, depth, or dropout probability. An epoch is one complete pass through the training data, whereas an iteration generally denotes one parameter update. A logit is an unnormalized output score, often converted into probabilities by softmax or sigmoid functions. Representation learning refers to learning useful internal features rather than specifying them manually.

The universal approximation result establishes that sufficiently wide networks can approximate broad classes of functions under suitable conditions. It does not imply that any particular network will learn efficiently, generalize well, or be computationally feasible. In practice, architectural inductive biases are essential. They constrain the hypothesis space in ways that reflect the structure of the problem.

Architectural Inductive Biases

An architecture encodes assumptions about how information is organized. An MLP treats input dimensions as a general vector. This is useful for tabular data, but it ignores spatial locality in images and sequential relations in language. A convolutional architecture assumes that local patterns recur across positions. A recurrent architecture processes an ordered sequence through a state, while an attention mechanism directly models relationships among elements. A transformer uses attention and position information to construct context-sensitive representations.

The choice of architecture should therefore follow the data-generating structure, not fashion. A doctoral-level design question is: which dependencies must the model represent, which invariances should it possess, and what computation is affordable during training and inference?

Convolutional Architectures for Structured Signals

A convolution applies a learned kernel across local regions. In a one-dimensional signal, it can detect local temporal patterns; in an image, a two-dimensional kernel can respond to edges, textures, or shapes. Weight sharing means that the same detector is applied at multiple locations, reducing parameter count and encouraging translation-related generalization.

A typical convolutional network alternates convolution, nonlinear transformation, and sometimes downsampling. Pooling or strided convolution reduces spatial resolution and increases the effective receptive field. As depth increases, later units can integrate information from larger regions. Padding controls output size and boundary treatment, while the stride controls how far the kernel moves.

Residual networks address the difficulty of optimizing very deep networks through skip connections. Instead of learning a direct mapping \(H(x)\), a residual block learns \(F(x)\) and produces \(x+F(x)\). The identity path allows gradients and information to propagate more directly. Dense connectivity, depthwise separable convolution, dilated convolution, and multi-scale feature fusion offer additional ways to balance expressiveness and efficiency.

Convolutional design remains valuable in image classification, detection, segmentation, medical imaging, remote sensing, audio analysis, and industrial inspection. Yet convolution is not inherently sufficient. Global relationships may require large receptive fields, hierarchical aggregation, or attention. A common hybrid strategy uses convolution for efficient local feature extraction and attention for long-range interaction.

Attention and Transformer Architectures

Attention computes a weighted combination of value vectors, where weights reflect the relevance of keys to a query. In scaled dot-product attention,

\[

\operatorname{Attention}(Q,K,V)=\operatorname{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V.

\]

The scaling factor reduces the risk that dot products become so large that the softmax produces extremely concentrated gradients. Multi-head attention performs several attention operations in parallel, allowing different heads to model different relational patterns.

Self-attention permits every element in a sequence or set to interact with other elements. In language, a token can incorporate information from distant words; in vision, image patches can exchange global context. Because attention itself does not encode order, positional information must be introduced through fixed positional functions, learned embeddings, relative positions, or rotary representations.

A transformer layer generally contains attention, a position-wise feed-forward network, residual connections, and normalization. Encoder-style transformers produce contextual representations, decoder-style transformers generate outputs autoregressively, and encoder-decoder systems map one sequence or modality to another. Causal masking prevents a decoder from using future tokens during generation.

Transformers offer flexible global interaction but may have substantial memory and computational costs, especially for long sequences, because standard self-attention scales quadratically with sequence length. Research has therefore explored sparse attention, linearized attention, local windows, low-rank approximations, recurrent memory, state-space alternatives, and retrieval mechanisms. These approaches illustrate a continuing architectural trade-off between expressive interaction and computational scalability.

Optimization as a Design Problem

Training minimizes an empirical objective, often augmented with regularization:

\[

\min_\theta \frac{1}{n}\sum_{i=1}^{n}\mathcal{L}(f_\theta(x_i),y_i)+\lambda\Omega(\theta).

\]

Stochastic gradient descent estimates the gradient from a mini-batch and updates parameters as \(\theta_{t+1}=\theta_t-\eta g_t\). Momentum accumulates a direction from previous gradients and can accelerate progress through noisy or poorly conditioned regions. Adaptive methods such as Adam maintain estimates of first and second moments of gradients. AdamW separates weight decay from the adaptive gradient update, making the regularization interpretation more transparent in many settings.

The learning rate is often the most influential training hyperparameter. A rate that is too high causes instability or divergence; one that is too low produces slow learning or poor local progress. Warm-up can prevent large early updates when parameters and gradients are not yet well calibrated. Cosine decay, step decay, one-cycle schedules, and plateau-based schedules are common alternatives. The appropriate schedule depends on model scale, data volume, optimizer, and transfer-learning setting.

Batch size affects gradient variance, memory use, throughput, and sometimes generalization. Gradient accumulation simulates a larger batch when memory is limited. Mixed-precision training represents selected computations in lower precision while retaining sufficient precision for sensitive operations and parameter updates. It can improve throughput and reduce memory consumption, but numerical underflow and overflow must be controlled through loss scaling or appropriate hardware support.

Initialization is another optimization mechanism. Xavier or Glorot initialization is suited to certain symmetric activations, while He initialization is often used with rectified activations. Poor initialization can produce dead units, exploding activations, or vanishing gradients before meaningful learning begins.

Normalization and Regularization

Normalization controls the scale of intermediate representations. Batch normalization estimates statistics across examples in a mini-batch and introduces learned scale and shift parameters. It often accelerates optimization and may provide a regularizing effect, but its behavior can be problematic with very small or non-independent batches. Layer normalization computes statistics within an individual example across feature dimensions and is consequently common in transformers. Group normalization is useful when batch sizes are small, particularly in visual tasks.

Normalization is not merely a cosmetic preprocessing operation. It changes the geometry of optimization and the interaction between layers. Pre-normalization and post-normalization transformer blocks can exhibit different stability properties, especially in deep networks. Researchers should report the exact placement and implementation because apparently similar architectures may train differently.

Regularization aims to improve generalization rather than merely reduce training loss. Weight decay penalizes parameter magnitude; dropout randomly removes activations during training; stochastic depth randomly bypasses complete residual blocks; data augmentation alters inputs while preserving labels. Label smoothing prevents the model from assigning excessive confidence to the observed class. Early stopping uses validation performance to halt training before overfitting becomes severe.

Regularization must be matched to the data and objective. Aggressive augmentation may destroy medically meaningful signals or alter the label semantics. Dropout can be unnecessary or harmful in some large pretrained models. Weight decay should not automatically be applied to every parameter; for example, normalization parameters and biases may be treated separately. Generalization is also influenced by dataset size, architecture, optimization trajectory, augmentation, and data duplication.

A Reproducible Training Workflow

A credible deep-learning project begins with a precise task definition and a data audit. The audit should examine label quality, missingness, class imbalance, duplication, temporal leakage, subgroup representation, and the relationship between training and deployment distributions. Random splitting is inappropriate when observations from the same person, device, location, or future period can occur in both training and test sets.

The next step is to establish a baseline. A simple model, a frozen pretrained model, or a non-neural method provides a reference for judging whether added complexity is justified. The experimental protocol should specify datasets, preprocessing, random seeds, evaluation metrics, stopping rules, hardware, software versions, and the number of tuning trials.

During training, monitor training and validation loss, task metrics, learning rate, gradient norms, throughput, memory, and failure indicators. A falling training loss with stagnant validation performance suggests overfitting, distribution mismatch, label noise, or an inadequate metric. Poor performance on both sets may indicate undercapacity, optimization failure, or insufficiently informative data. Experiments should be tracked using immutable configuration files and stored checkpoints rather than informal manual notes.

Evaluation must reflect deployment. For imbalanced classification, accuracy can be misleading; precision-recall curves, class-specific recall, calibration, and cost-sensitive measures may be more useful. For generative systems, automatic scores should be complemented by human or expert assessment, robustness testing, and factuality analysis. Confidence estimates should be evaluated for calibration rather than assumed to be reliable.

Distributed Training and Systems Considerations

When a model or dataset exceeds the capacity of one accelerator, distributed training becomes necessary. Data parallelism replicates the model across workers, partitions mini-batches, and synchronizes gradients. Synchronous all-reduce provides consistent updates but may be limited by communication latency and the slowest worker. Asynchronous approaches reduce waiting but can introduce stale gradients and convergence complications.

Model parallelism partitions layers or tensor operations across devices. Pipeline parallelism divides a model into stages and processes micro-batches through those stages. Sharding methods distribute parameters, gradients, and optimizer states, reducing per-device memory. These approaches can be combined, but their complexity increases substantially.

Distributed training is not simply a faster version of single-device training. Effective batch size, communication topology, random-number handling, checkpoint consistency, fault tolerance, and data ordering all affect results. Scaling the batch size may require learning-rate adjustment and warm-up. Reproducibility can be difficult because nondeterministic kernels, reduction order, and hardware differences produce small numerical changes that may accumulate.

Hyperparameter Optimization and Experimental Design

Hyperparameter optimization should be treated as an experimental-design problem. Grid search is inefficient when only a few parameters are influential. Random search often explores important dimensions more effectively. Bayesian optimization uses prior trial results to select promising configurations, while multi-fidelity methods terminate weak trials early by allocating more resources to promising ones.

Important search dimensions may include learning rate, weight decay, batch size, architecture depth, width, dropout, augmentation strength, sequence length, warm-up duration, and optimizer choice. Search spaces should be expressed in meaningful scales; learning rates and weight decay commonly benefit from logarithmic ranges. Tuning must use a validation protocol that prevents test-set overfitting. Repeated runs are appropriate when stochastic variation is large.

A doctoral researcher should distinguish optimization improvement from scientific discovery. A better validation score after extensive tuning may reflect exploitation of a benchmark rather than a general architectural principle. Ablation studies, confidence intervals, multiple datasets, compute accounting, and transparent negative results strengthen the evidence. Comparisons should control training budget, data access, preprocessing, and parameter count where these factors materially affect conclusions.

Efficient Model Compression

Deployment on mobile, embedded, or high-throughput systems often requires reducing latency, memory, and energy consumption. Pruning removes weights, channels, heads, or structures judged to be redundant. Unstructured pruning can achieve high sparsity but may not accelerate inference unless hardware and software exploit irregular sparsity. Structured pruning removes complete components and is usually easier to deploy, although it may reduce accuracy more sharply.

Quantization represents weights and activations with fewer bits. Post-training quantization is convenient for a trained model, whereas quantization-aware training simulates quantization during learning and can preserve accuracy more effectively. Calibration data must represent deployment conditions, and sensitive layers may require higher precision.

Knowledge distillation trains a smaller student model to imitate a larger teacher. The student can learn from hard labels and teacher probability distributions, often using a temperature parameter to soften class relationships. Distillation can transfer useful behavior but may also transfer teacher errors, bias, or undesired confidence.

Other techniques include low-rank factorization, parameter sharing, efficient architecture design, token pruning, caching, and retrieval of reusable representations. Compression should be evaluated on the actual target device. A smaller parameter count does not automatically produce lower latency if the resulting operations are poorly supported by the hardware.

Applied Case: Illustrative Clinical Imaging Deployment

Background

Consider an illustrative hospital consortium developing a system to prioritize chest radiographs for review. The objective is not to replace clinicians but to identify studies that may require rapid attention. Images originate from different hospitals, scanners, and acquisition protocols.

Situation and problem

An initial convolutional classifier achieves strong performance on a randomly split internal dataset. However, its sensitivity falls at a partner hospital. Investigation reveals that images from the same patient appear in both training and validation sets, and that the two institutions use different imaging equipment. The model has also learned correlations with acquisition artifacts that do not represent disease.

Analysis

The problem is partly architectural but primarily methodological. A deeper network cannot correct leakage or institutional shift. The team redesigns the evaluation around patient-level and hospital-level splits. It reports sensitivity at a clinically meaningful operating point, calibration, subgroup performance, and false-negative cases. Saliency visualizations are treated as diagnostic evidence rather than proof of causal reasoning.

Approach and solution

The team compares a residual convolutional baseline with a convolution-attention hybrid. Augmentation is selected with radiologist review so that transformations do not alter clinically relevant findings. Training uses AdamW, a warm-up period, cosine decay, mixed precision, and early stopping based on a hospital-held-out validation set. Group normalization is tested because the deployment batch size is small. The final model is distilled into a smaller student and quantized for the hospital’s inference servers.

The governance plan includes human review, audit logs, model-version control, drift monitoring, periodic recalibration, and a process for suspending the system when performance deteriorates. The model output is presented as a prioritization score with uncertainty information, not as an autonomous diagnosis.

Outcome

In this illustrative scenario, the important outcome is not a single benchmark number but a more credible deployment claim. The revised evaluation reveals lower but more realistic performance, while the compressed model meets latency requirements. Subgroup and external-site testing expose limitations that would have remained hidden under random splitting.

Learning points

The case demonstrates that architecture selection, optimization, evaluation, and governance are inseparable. Data leakage can make an excellent model appear better than it is; compression can alter calibration; and clinical usefulness depends on workflow, accountability, and monitoring as much as on predictive accuracy.

Challenges, Risks, and Common Errors

Several recurring mistakes undermine deep-learning projects. The first is treating architecture size as a substitute for data quality. Large models can memorize duplicated, noisy, or biased data. The second is tuning on the test set, which converts an ostensibly independent benchmark into a development resource. The third is reporting only mean accuracy without uncertainty, subgroup analysis, calibration, or computational cost.

Another error is assuming that attention maps or saliency maps provide definitive explanations. These tools can support investigation, but they do not establish that the model used a human-plausible causal rationale. Researchers should use counterfactual tests, occlusion studies, feature perturbations, and domain-expert review where interpretation matters.

Distribution shift is a central operational risk. Changes in sensors, user behavior, language, prevalence, policy, or adversarial behavior can reduce performance. Monitoring should therefore include input statistics, prediction distributions, error samples, subgroup outcomes, and delayed ground-truth feedback. Privacy risks arise when data contain identifiable or sensitive information; model inversion, membership inference, and unintended memorization deserve attention in high-risk settings.

Fairness cannot be guaranteed by a single aggregate metric. Different definitions of fairness may conflict, and performance disparities may reflect data collection, label processes, prevalence, or deployment context. Teams should specify the relevant harms, consult affected stakeholders, document trade-offs, and establish remediation procedures.

Emerging Directions and Best Practices

Current research is moving toward multimodal foundation models, parameter-efficient adaptation, retrieval-augmented systems, sparse and mixture-of-experts architectures, efficient long-context modeling, and hardware-aware neural architecture search. These developments expand capability but also increase concerns about data provenance, evaluation contamination, energy use, interpretability, and concentration of computational resources.

Parameter-efficient methods such as adapters, low-rank updates, and prompt-based adaptation can specialize a pretrained model without updating all parameters. They reduce storage and training cost, but their safety and performance still depend on the quality and representativeness of adaptation data. Continual learning seeks to update models without catastrophic forgetting, while federated learning moves training toward decentralized data; both introduce challenges involving communication, privacy, heterogeneity, and verification.

Sound practice includes the following principles:

• Begin with the data-generating process and deployment requirement, not the preferred architecture.
• Establish leakage-resistant baselines before increasing model complexity.
• Separate training, validation, and final testing, with external evaluation when possible.
• Log configurations, code, data versions, compute budgets, and failed experiments.
• Tune learning rate and regularization systematically rather than changing many variables informally.
• Report accuracy together with calibration, robustness, subgroup performance, latency, memory, and energy where relevant.
• Test compressed models on target hardware and re-evaluate their errors after compression.
• Treat explanations as evidence requiring validation, not as automatic proof of reasoning.
• Build monitoring, human oversight, rollback, and incident response into deployment plans.

Chapter Summary

Deep learning systems are compositions of parameterized transformations whose effectiveness depends on architecture, optimization, data, and operational context. MLPs provide general-purpose layered computation; convolutions encode locality and shared structure; attention represents flexible relationships; and transformers provide powerful context modeling through self-attention, positional information, residual pathways, and normalization. Optimization requires informed choices about initialization, activation, learning rate, batch size, optimizer, precision, and regularization. Distributed training and hyperparameter optimization extend the scale of experimentation but introduce communication, reproducibility, and validation concerns. Pruning, quantization, distillation, and efficient architectures enable deployment under resource constraints. Across all settings, credible evaluation requires leakage control, external or shift-aware testing, uncertainty analysis, fairness assessment, and governance appropriate to the consequences of error.

Key Terms

Activation function: Nonlinear function applied to a layer’s pre-activation values.

Attention: Mechanism that weights information according to query–key relevance.

Batch normalization: Normalization using statistics computed over a mini-batch.

Backpropagation: Efficient computation of gradients through a composed network.

Convolution: Local, weight-sharing operation that detects patterns across structured inputs.

Distillation: Training a student model to reproduce information from a teacher model.

Embedding: Dense vector representation of an object, token, category, or signal.

Gradient descent: Iterative parameter optimization using loss gradients.

Hyperparameter: Training or architectural setting selected outside gradient learning.

Layer normalization: Normalization across feature dimensions within an individual example.

Mixed precision: Use of multiple numerical precisions to improve efficiency.

Pruning: Removal of parameters or structural components judged unnecessary.

Quantization: Representation of values with reduced numerical precision.

Residual connection: Shortcut that adds an input to a transformed output.

Regularization: Method that discourages overfitting and improves generalization.

Self-attention: Attention in which queries, keys, and values come from the same representation.

Stochastic gradient descent: Gradient optimization using randomly sampled mini-batches.

Transformer: Architecture built principally from attention, feed-forward layers, residual paths, and normalization.

Weight decay: Optimization regularizer that discourages excessive parameter magnitude.

Review Questions

Short Answer Questions

1. Why are architectural inductive biases important in deep learning?

2. What problem do residual connections address?

3. Distinguish a parameter from a hyperparameter.

4. Why is positional information required in a standard transformer?

5. What is the purpose of knowledge distillation?

Long Answer Questions

1. Explain how convolutional networks encode locality and translation-related structure, and discuss circumstances in which attention may complement convolution.

2. Compare batch normalization, layer normalization, and group normalization in terms of statistics, training conditions, and practical use.

3. Discuss learning-rate selection, initialization, optimizer choice, batch size, and mixed precision as interdependent optimization decisions.

4. Explain data parallelism, model parallelism, pipeline parallelism, and sharding, including their principal systems trade-offs.

5. Analyze pruning, quantization, and distillation as model-compression methods, including their effects on accuracy and deployment performance.

Analytical / Application Questions

1. A model performs well on a random split but poorly at a new hospital. Design an evaluation and training investigation that distinguishes leakage, domain shift, and optimization failure.

2. You must deploy a transformer on a memory-constrained device with a strict latency limit. Propose an architecture and compression strategy, and identify the measurements needed to validate the design.

3. A training run has low training loss, stagnant validation loss, and large subgroup performance differences. Formulate a diagnosis and an experimental plan addressing generalization, data quality, fairness, and calibration.

22. Multiple Choice Questions with Answers

Question 1

Which architectural property most directly explains why convolutional networks are efficient for images?

A. They apply the same local filters across spatial positions.

B. They remove the need for nonlinear activation functions.

C. They ensure that every pixel attends to every other pixel at every layer.

D. They use no learned parameters in early layers.

Correct Answer: A. They apply the same local filters across spatial positions.

Question 2

In scaled dot-product attention, why is the query-key product divided by the square root of the key dimension?

A. To reduce the number of attention heads

B. To prevent logits from becoming excessively large and producing poorly behaved softmax gradients

C. To convert attention weights into binary decisions

D. To eliminate the need for positional information

Correct Answer: B. To prevent logits from becoming excessively large and producing poorly behaved softmax gradients

Question 3

A practitioner has very small batches because of high-resolution images. Which normalization method is generally more suitable to test than batch normalization?

A. Group normalization

B. Token masking

C. Weight pruning

D. Causal normalization

Correct Answer: A. Group normalization

Question 4

Which observation most strongly suggests overfitting during training?

A. Training and validation losses both decrease steadily

B. Training loss decreases while validation performance stops improving

C. Both training and validation losses are initially high

D. The learning rate is reduced according to schedule

Correct Answer: B. Training loss decreases while validation performance stops improving

Question 5

What is the principal risk of evaluating a model using a random split when multiple records belong to the same patient?

A. The model cannot use batch normalization

B. The split may place related records in both training and test sets, causing leakage

C. The optimizer will always diverge

D. The model will necessarily underfit

Correct Answer: B. The split may place related records in both training and test sets, causing leakage

Question 6

Which statement best characterizes structured pruning?

A. It removes complete channels, heads, or other units that hardware can often exploit directly.

B. It changes all weights to floating-point values.

C. It trains a teacher to imitate a student.

D. It increases model size to improve calibration.

Correct Answer: A. It removes complete channels, heads, or other units that hardware can often exploit directly.

Question 7

Why might a large effective batch size require changes to the learning-rate strategy?

A. It changes gradient statistics and optimization dynamics.

B. It removes all model parameters.

C. It prevents the use of residual connections.

D. It guarantees that validation data become unnecessary.

Correct Answer: A. It changes gradient statistics and optimization dynamics.

Question 8

Which practice provides the strongest protection against test-set overfitting during hyperparameter tuning?

A. Repeatedly selecting configurations using final test performance

B. Using a validation protocol for tuning and reserving the test set for final evaluation

C. Increasing the number of model layers after every trial

D. Reporting only the best run without its configuration

Correct Answer: B. Using a validation protocol for tuning and reserving the test set for final evaluation

Question 9

A quantized model is faster on a workstation but slower on the target embedded device. What is the most plausible explanation?

A. Parameter count alone does not guarantee that the target hardware efficiently supports the resulting operations.

B. Quantization always increases numerical precision.

C. Embedded devices cannot execute neural networks.

D. The model must have used causal masking.

Correct Answer: A. Parameter count alone does not guarantee that the target hardware efficiently supports the resulting operations.

Question 10

In the clinical imaging case, why was the model output presented as a prioritization score rather than an autonomous diagnosis?

A. Because convolutional models cannot produce probabilities

B. Because deployment required human oversight, accountability, and recognition of uncertainty and distribution shift

C. Because quantized models cannot classify images

D. Because external validation makes prediction impossible

Correct Answer: B. Because deployment required human oversight, accountability, and recognition of uncertainty and distribution shift