Deep Learning and Convolutional Neural Networks

Introduction and Context

Computer vision seeks to enable machines to interpret images and video. Earlier vision systems commonly depended on manually designed features, such as edges, corners, colour histograms, and texture descriptors. These features could be effective in restricted settings, but their design required substantial domain knowledge and often failed when illumination, viewpoint, scale, background, or object appearance changed.

Deep learning changed this practice by allowing models to learn hierarchical representations directly from data. In image classification, the earliest layers of a neural network may detect simple edges and colour transitions; intermediate layers may represent contours, textures, and parts; and deeper layers may encode object-level concepts. Convolutional neural networks (CNNs) became particularly important because their architecture reflects useful properties of images: local spatial structure, repeated patterns, and approximate translation invariance.

A CNN is not automatically reliable merely because it is deep. Its performance depends on data quality, architecture, optimization, regularization, evaluation design, and deployment conditions. This chapter develops the principles needed to design, train, analyze, and responsibly apply CNN-based vision systems.

Learning Objectives

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

• explain convolution, receptive fields, padding, stride, and parameter sharing;
• calculate the spatial dimensions and parameter count of common CNN layers;
• distinguish pooling, normalization, activation, residual, and attention mechanisms;
• describe the optimization process used to train CNNs;
• implement a basic CNN training pipeline;
• use data augmentation and transfer learning appropriately;
• evaluate CNNs critically, including their limitations, risks, and deployment requirements.

1. Images as Structured Data

A grayscale image can be represented as a matrix of intensity values. A colour image is commonly represented as a tensor of height H, width W, and channels C. For an RGB image, C = 3. Pixel values may be stored as integers from 0 to 255, but neural networks generally use floating-point values scaled to [0, 1] or standardized using a training-set mean and standard deviation.

Images contain strong local correlations: nearby pixels are more likely to describe the same edge, surface, or object part than distant pixels. They also contain repeated visual patterns. The same edge detector may be useful in many positions. CNNs exploit these properties through local connectivity and weight sharing.

A standard supervised image-classification dataset consists of pairs (x_i, y_i), where x_i is an image and y_i is a class label. A model f_theta maps an image to class scores or probabilities. The parameters theta are learned by minimizing a loss on training data while preserving performance on unseen validation and test data.

2. The Convolution Operation

2.1 Intuition

A convolutional layer applies a small learnable filter, or kernel, across an input. At each location, the filter computes a weighted combination of nearby values. The resulting feature map indicates where a learned pattern occurs.

In deep-learning libraries, the operation usually called convolution is technically cross-correlation because the kernel is not flipped. The distinction matters mathematically, but it does not change the learning capability: a network can learn the corresponding flipped weights. In this chapter, “convolution” follows common machine-learning usage.

For one input channel, a two-dimensional cross-correlation can be written as:

z(i,j) = b + sum over u=0 to K_h-1 and v=0 to K_w-1 of W(u,v) X(i+u,j+v),

where X is the input, W is a kernel of height K_h and width K_w, b is a bias, and z is the output before activation. For multiple input channels, the products are also summed over channels. A layer normally learns multiple kernels, producing multiple output channels.

The kernel parameters are shared across spatial positions. Consequently, a 3 × 3 filter has the same values whether it is detecting a corner near the top-left or near the centre. This greatly reduces parameter count compared with a fully connected layer and encourages the model to recognize patterns independently of exact location.

2.2 Output Size, Padding, and Stride

For an input dimension N, kernel size K, padding P on each side, and stride S, the corresponding output dimension is:

O = floor((N + 2P - K) / S) + 1.

This formula assumes a regular grid, symmetric padding, and integer-valued hyperparameters. It applies independently to height and width.

• Valid convolution uses P = 0 and reduces spatial dimensions when K > 1.
• Same-style convolution commonly uses stride 1 and padding chosen to preserve spatial size. For odd K, P = (K - 1)/2 preserves size when S = 1.
• Stride specifies how far the kernel moves. A stride greater than one performs learned downsampling.

The number of trainable parameters in a convolutional layer is:

K_h × K_w × C_in × C_out + C_out,

where C_in and C_out are the numbers of input and output channels. The final term represents one bias per output channel, if biases are used.

Worked Example: Spatial Size and Parameters

Suppose an input has spatial size 32 × 32 and 3 channels. A layer uses 16 kernels of size 3 × 3, stride 1, and padding 1.

The output height and width are:

O = floor((32 + 2(1) - 3)/1) + 1 = 32.

Thus, the output is 32 × 32 × 16. The parameter count is:

3 × 3 × 3 × 16 + 16 = 432 + 16 = 448.

If the layer had no bias, the count would be 432. The output activation count is not the same as the parameter count: it contains 32 × 32 × 16 values for each input example.

2.3 Receptive Fields

A neuron's receptive field is the region of the original input that can influence its activation. A 3 × 3 convolution has a 3 × 3 local receptive field relative to its immediate input. Stacking two stride-1 3 × 3 layers gives an effective 5 × 5 receptive field, while using one 5 × 5 layer also gives a 5 × 5 field. The two 3 × 3 layers use fewer weights per input-output channel combination and introduce an additional nonlinearity.

For a sequence of layers, receptive field size can be tracked with two quantities: receptive field r and jump j, where j is the spacing between neighbouring features measured in input pixels. Initially r = 1 and j = 1. For a layer with kernel size k and stride s:

r_new = r + (k - 1)j,

j_new = j × s.

This calculation assumes dilation 1. Pooling and strided convolutions increase the jump, so deeper features summarize larger regions. A theoretical receptive field may exceed the image, but the effective receptive field—the region contributing most strongly in practice—can be smaller.

Large receptive fields are important for recognizing objects and contextual relationships. However, excessive downsampling can discard fine detail, which is especially harmful for small-object detection and image segmentation.

3. Pooling and Downsampling

Pooling summarizes local neighbourhoods and reduces spatial resolution. In max pooling, the largest activation in a window is retained. In average pooling, the mean is retained. For example, 2 × 2 max pooling with stride 2 reduces each spatial dimension approximately by half.

Pooling can reduce computation, increase the effective receptive field, and provide limited tolerance to small translations. It also discards information. Modern architectures often use strided convolutions, pooling, or both, depending on the task. Classification can tolerate substantial reduction in spatial detail, whereas segmentation and keypoint estimation require mechanisms to recover or preserve precise localization.

Global average pooling averages each feature map over all spatial positions. If the final feature tensor is H × W × C, global average pooling produces C values. It can replace a large fully connected layer, reduce parameters, and make the connection between feature maps and class scores more interpretable. It may, however, remove useful positional information.

4. Activation Functions

Without nonlinear activation functions, stacking linear convolutional layers would still produce a single linear transformation. Nonlinearities allow networks to represent complex decision boundaries.

ReLU

The rectified linear unit is:

ReLU(x) = max(0, x).

It is computationally simple and usually provides stronger gradient flow than saturating functions. A limitation is the “dying ReLU” problem: a unit receiving consistently negative inputs may output zero and receive zero gradient.

Leaky ReLU and Related Functions

Leaky ReLU uses a small positive slope for negative inputs:

f(x) = x if x >= 0; otherwise alpha x,

where alpha is a small fixed positive value. GELU and SiLU/Swish are smoother alternatives used in many modern architectures. The best choice depends on architecture, hardware, and empirical validation; no activation is universally optimal.

Output Activations

For mutually exclusive K classes, softmax converts logits z into probabilities:

p_k = exp(z_k) / sum over j=1 to K of exp(z_j).

Softmax probabilities sum to one. During numerical implementation, a stable version subtracts the maximum logit before exponentiation. For independent binary labels, sigmoid outputs are more appropriate:

sigmoid(z) = 1 / (1 + exp(-z)).

The output activation and loss must match the label structure. In many frameworks, cross-entropy loss accepts logits directly and applies a numerically stable internal operation.

5. Normalization and Internal Representations

Normalization can improve optimization by controlling the scale of intermediate activations. Batch normalization computes statistics over a mini-batch and, for a convolutional feature map, commonly uses statistics over batch and spatial positions for each channel. It then applies learned scale and shift parameters. During inference, running estimates rather than current batch statistics are typically used.

Batch normalization can make training less sensitive to initialization and learning rate, but it depends on reliable batch statistics. Very small batches can make these estimates noisy. Alternatives include layer normalization, group normalization, and instance normalization, each using different groups of dimensions. Group normalization is often useful when memory limits force small batch sizes.

Normalization is not a substitute for sound preprocessing. Input normalization must be computed without using information from the test set. Data leakage can result if statistics or augmentation decisions are derived from held-out data.

6. Residual Connections and Architectural Design

Very deep plain networks can be difficult to optimize because gradients may vanish or explode and because each layer must learn a complete transformation. A residual block instead learns a residual function:

y = F(x, W) + x,

where x is the block input and F is a sequence of learned operations. If the dimensions differ, a projection, often a 1 × 1 convolution, transforms x before addition.

The identity shortcut creates a direct path for information and gradients. ResNet-style architectures demonstrated that depth could be increased substantially without the same degradation observed in plain networks. Residual connections are now common beyond image classification, including detection, segmentation, and multimodal models.

A 1 × 1 convolution does not combine neighbouring spatial positions, but it mixes channels. It can reduce or expand channel count and is therefore useful in bottleneck residual blocks. A bottleneck may use 1 × 1, 3 × 3, and 1 × 1 convolutions to reduce computation while maintaining expressive capacity.

Architecture design involves trade-offs among accuracy, computational cost, memory, latency, and robustness. Increasing depth or width may improve accuracy but can make deployment more expensive. Efficient architectures use depthwise-separable convolutions, bottlenecks, pruning, quantization, or knowledge distillation.

7. Attention in Vision Networks

Convolution emphasizes local, fixed-grid interactions. Attention allows a feature to assign different weights to other features based on their content. In self-attention, queries, keys, and values are computed from features. A common formulation is:

Attention(Q,K,V) = softmax(QK^T / sqrt(d_k)) V,

where Q, K, and V are query, key, and value matrices and d_k is the key dimension. The scaling factor helps control the magnitude of dot products.

Self-attention can model long-range dependencies more directly than a small convolution. Vision Transformers divide images into patches and process patch embeddings with transformer layers. Hybrid CNN-attention systems retain convolutional inductive biases while adding global interaction. Attention can improve context reasoning, but its computational and memory costs may be substantial, particularly when the number of tokens is large. Windowed or sparse attention reduces these costs.

Attention maps should not automatically be interpreted as faithful explanations of model decisions. Explanation requires additional analysis, such as perturbation tests, counterfactual evaluation, or attribution methods.

8. Training and Optimization

8.1 Loss and Gradient Descent

For a K-class problem with one correct label y, cross-entropy loss is:

L = -log(p_y),

where p_y is the predicted probability assigned to the correct class. For a dataset, the empirical loss is usually the mean of individual losses. Training seeks parameters that reduce this loss on the training data while generalizing to new examples.

Gradient descent updates parameters according to:

W_(t+1) = W_t - eta grad_W L,

where eta is the learning rate and the gradient is computed with respect to the current parameters. In mini-batch stochastic gradient descent, each update uses a subset of training examples. Momentum adds a running direction, while Adam maintains adaptive estimates of first and second moments of gradients. Adam often converges quickly; SGD with momentum can provide strong final generalization in many vision tasks. Learning-rate schedules, such as cosine decay or step decay, are often as important as optimizer selection.

8.2 Initialization and Training Practices

Weights should be initialized in a manner compatible with the activation function. He/Kaiming initialization is commonly used with ReLU-like activations, while Xavier/Glorot initialization is associated with maintaining variance for certain symmetric activations. Poor initialization can cause unstable activations or gradients.

A typical training workflow includes:

1. define train, validation, and test splits before tuning;

2. inspect class balance, label quality, and image provenance;

3. normalize inputs using training-set statistics;

4. select an architecture and loss appropriate to the task;

5. train using mini-batches and monitor training and validation metrics;

6. use early stopping or checkpoint selection based only on validation data;

7. evaluate once on the untouched test set;

8. inspect errors by class, subgroup, image condition, and confidence.

Overfitting occurs when a model memorizes training-specific patterns that do not generalize. Regularization methods include weight decay, dropout, label smoothing, augmentation, reduced model capacity, and early stopping. Dropout randomly removes activations during training and rescales or otherwise compensates during inference according to the implementation. It is not always beneficial when batch normalization and strong augmentation already provide regularization.

9. Data Augmentation

Augmentation creates label-preserving variations of training images. Common transformations include random crops, horizontal flips, mild rotations, colour perturbations, blur, noise, and random erasing. The transformation must be consistent with the task. Horizontal flipping may be appropriate for many natural-object datasets but invalid for text recognition or left-right medical anatomy.

For detection, segmentation, and keypoint tasks, geometric transformations must also be applied to bounding boxes, masks, or coordinates. Augmentation should reflect plausible deployment variation rather than create unrealistic images. Excessive augmentation can remove class-defining features or introduce a train-test mismatch.

Advanced methods include MixUp, which combines pairs of images and labels, and CutMix, which replaces a region with content from another image while adjusting labels according to area. These methods can improve calibration and generalization but require careful implementation and may be inappropriate for certain spatially precise tasks.

10. Transfer Learning

Training a deep CNN from scratch requires substantial labelled data and computation. Transfer learning begins with a model pretrained on a large dataset, replaces or adapts its task-specific head, and fine-tunes it on the target dataset.

Two common strategies are:

• Feature extraction: freeze most or all backbone layers and train a new classification head.
• Fine-tuning: unfreeze some or all backbone layers and update them using a relatively small learning rate.

A practical sequence is to train the new head first, then gradually unfreeze deeper layers if validation performance supports it. The target preprocessing should be compatible with the pretrained model. If source and target domains differ greatly, early visual features may transfer less effectively, and substantial fine-tuning or domain-specific pretraining may be necessary.

Transfer learning reduces data and time requirements but can transfer undesirable biases, spurious correlations, or source-domain artefacts. A pretrained model is not automatically suitable for a safety-critical application.

11. Implementation Pattern

The following PyTorch-style pseudocode illustrates a compact classifier. It is a conceptual implementation; exact APIs may vary by library version.

```python

class SmallCNN(nn.Module):

def __init__(self, num_classes):

super().__init__()

self.features = nn.Sequential(

nn.Conv2d(3, 32, kernel_size=3, padding=1),

nn.BatchNorm2d(32),

nn.ReLU(),

nn.MaxPool2d(2),

nn.Conv2d(32, 64, kernel_size=3, padding=1),

nn.BatchNorm2d(64),

nn.ReLU(),

nn.MaxPool2d(2),

nn.AdaptiveAvgPool2d((1, 1))

)

self.classifier = nn.Linear(64, num_classes)

def forward(self, x):

x = self.features(x)

x = torch.flatten(x, 1)

return self.classifier(x) # logits

```

The model should return logits when using a loss such as cross-entropy that internally applies a stable log-softmax operation. A simplified training loop is:

```python

for images, labels in train_loader:

optimizer.zero_grad()

logits = model(images)

loss = criterion(logits, labels)

loss.backward()

optimizer.step()

```

Validation should use evaluation mode so that layers such as batch normalization and dropout behave appropriately:

```python

model.eval()

with torch.no_grad():

logits = model(images)

```

A production implementation also needs reproducibility controls, checkpointing, device management, logging, metric computation, and tests for preprocessing consistency.

12. Evaluation and Professional Use

Accuracy is the fraction of correctly classified examples, but it can be misleading under class imbalance. Precision measures the proportion of predicted positives that are correct, while recall measures the proportion of actual positives that are detected. The F1 score is the harmonic mean of precision and recall when both are nonzero:

F1 = 2PR/(P + R).

Confusion matrices reveal class-specific errors. ROC-AUC and precision-recall curves can help evaluate ranking behaviour, but metric selection must reflect the operational cost of false positives and false negatives. Calibration measures whether predicted probabilities correspond to observed frequencies; a confident wrong prediction can be more dangerous than a less confident error.

For deployment, measure latency, memory, throughput, energy use, failure modes, and robustness to changes in cameras, environments, and populations. Monitor data drift and performance after release. A model card or system documentation should record intended use, limitations, training data characteristics, evaluation conditions, and known risks.

Illustrative Case: Defect Detection in a Manufacturing Line

Background

A manufacturer wants to detect surface defects on metal components using camera images. Defects are rare, and lighting varies between production shifts.

Problem

A CNN trained on randomly split images achieves high accuracy but misses many defects on a newly installed camera. Investigation shows that near-duplicate images from the same production batch were present in both training and test sets, and the model learned lighting and background cues.

Analysis and Approach

The engineering team restructures the split by production batch and camera, preventing near-duplicate leakage. They collect additional examples across lighting conditions, use controlled photometric augmentation, and apply transfer learning from an image-pretrained backbone. Because missed defects are costly, recall and the precision-recall curve receive greater emphasis than accuracy alone. The team examines confusion matrices by defect type and uses threshold selection on a validation set. A human review queue is retained for uncertain cases.

The model is tested on a temporally later batch and evaluated for calibration. It is deployed with monitoring for image brightness, camera identity, prediction distributions, and confirmed defect rates. When drift exceeds agreed limits, the system is reviewed rather than silently retrained.

Outcome and Learning Points

The revised evaluation gives a more realistic estimate of generalization. Performance is lower than the original random-split result but more useful operationally. The case demonstrates that architecture is only one part of computer-vision quality. Data splitting, augmentation validity, cost-sensitive metrics, domain shift, human oversight, and post-deployment monitoring are equally important.

Challenges, Ethics, and Governance

CNNs may encode demographic, geographic, or socioeconomic biases present in their data. In applications involving employment, education, policing, insurance, healthcare, or access to services, errors can have unequal consequences. Teams should assess subgroup performance, document data provenance, obtain appropriate consent or legal authorization, and minimize collection of personally identifiable information.

Image systems can also create privacy risks through facial recognition, biometric inference, or unintended retention of sensitive scenes. Security threats include adversarial perturbations, data poisoning, model extraction, and misuse outside the intended context. Governance should define accountability, access controls, audit logs, incident response, human review, and procedures for contesting automated decisions.

Regulatory obligations vary by jurisdiction and application. Technical teams should not treat compliance as a final documentation task; risk assessment and impact analysis should influence design from the beginning. Explainability aids oversight, but explanations should not be used to claim certainty or fairness without empirical validation.

Contemporary Developments and Best Practices

Current vision systems increasingly combine convolution, attention, self-supervised pretraining, multimodal learning, and efficient deployment techniques. Self-supervised methods learn representations from unlabelled images, reducing dependence on manual annotation. Vision-language models connect images with text but may inherit large-scale data biases and can be difficult to evaluate for factual reliability.

Best practices include:

• establish a leakage-resistant dataset split and a meaningful baseline;
• match augmentation and metrics to the task and deployment conditions;
• use transfer learning when data or compute are limited;
• track experiments, random seeds, preprocessing, and model versions;
• inspect errors rather than relying on one aggregate metric;
• test robustness, calibration, subgroup performance, and distribution shift;
• optimize for latency and energy only after confirming correctness;
• document intended use, limitations, and human responsibilities;
• monitor the system continuously after deployment.

Chapter Summary

CNNs learn hierarchical image representations through local connectivity, parameter sharing, and nonlinear transformations. Convolutional output size depends on kernel size, padding, stride, and input dimensions, while receptive fields grow through stacked layers and downsampling. Pooling and strided convolutions reduce resolution but may discard detail. ReLU-like activations provide nonlinearity, normalization supports optimization, and residual connections enable effective training of deep networks. Attention adds content-dependent long-range interaction and complements convolution in modern architectures.

Training requires an appropriate loss, initialization, optimizer, learning-rate schedule, regularization, and disciplined validation. Data augmentation improves robustness only when transformations preserve task semantics. Transfer learning is an efficient strategy for limited labelled data but may transfer bias and domain-specific artefacts. Reliable professional systems require leakage-resistant evaluation, suitable metrics, calibration, robustness analysis, monitoring, privacy protection, and human accountability.

Key Terms

Convolution: A local weighted operation applied across an image or feature map.

Kernel/filter: Learnable weights used to detect a visual pattern.

Parameter sharing: Reusing the same kernel weights at different spatial positions.

Feature map: The spatial activations produced by a filter or layer.

Padding: Values added around an input boundary before convolution.

Stride: The spatial step by which a kernel or pooling window moves.

Receptive field: The input region that can influence a unit’s activation.

Pooling: Local aggregation used to summarize and often downsample features.

Activation function: A nonlinear function applied to a layer’s pre-activation.

ReLU: The function max(0, x), widely used in CNNs.

Normalization: Rescaling intermediate representations to support stable optimization.

Residual connection: A shortcut that adds an input to a learned transformation.

Attention: A mechanism that weights interactions according to feature content.

Logit: An unnormalized class score produced before a probability transformation.

Cross-entropy: A loss commonly used for probabilistic classification.

Data augmentation: Label-preserving transformation of training examples.

Transfer learning: Reusing a model or representation learned on another dataset.

Overfitting: Strong training performance accompanied by poor generalization.

Calibration: Agreement between predicted probabilities and observed frequencies.

Data drift: Change in input or target distributions after deployment.

Review Questions

Short Answer Questions

1. Why does parameter sharing make CNNs more efficient than a fully connected image classifier?

2. What are the effects of increasing convolutional stride?

3. Define a receptive field and explain why it matters in vision tasks.

4. Why must logits and output labels be matched to an appropriate loss function?

5. Give two examples of augmentation that may be invalid for a particular computer-vision task.

Long Answer Questions

1. Explain the operation of a CNN from input image to classification output, including convolution, activation, pooling, and a final prediction layer.

2. Compare batch normalization, group normalization, and the use of residual connections in deep CNNs.

3. Describe a complete training workflow for a CNN, including data splitting, optimization, regularization, validation, and testing.

4. Explain transfer learning and discuss circumstances in which fine-tuning may fail to transfer effectively.

5. Discuss how attention mechanisms complement convolutional architectures and identify their computational trade-offs.

Analytical / Application Questions

1. A 64 × 64 RGB image is passed through a convolution with 32 filters of size 5 × 5, stride 2, and padding 2. Calculate the output spatial dimensions and the number of trainable parameters, assuming one bias per filter.

2. Design an evaluation plan for a medical-image classifier in which false negatives are substantially more costly than false positives. Specify data splitting, metrics, threshold selection, calibration, and human oversight.

3. A factory CNN performs well on validation images but poorly after a camera replacement. Analyze at least four possible causes and propose an ordered diagnostic and remediation plan.

Multiple Choice Questions with Answers

Question 1

An input of size 32 × 32 is processed by a 3 × 3 convolution with stride 1 and padding 1. What is the output spatial size?

A. 30 × 30

B. 31 × 31

C. 32 × 32

D. 34 × 34

Correct Answer: C. 32 × 32

Question 2

How many trainable parameters are in a convolutional layer with 3 input channels, 16 output channels, 3 × 3 kernels, and one bias per output channel?

A. 144

B. 432

C. 448

D. 496

Correct Answer: C. 448

Question 3

Which mechanism directly provides a shortcut for information and gradient flow in a deep network?

A. Max pooling

B. Residual connection

C. Softmax

D. Data normalization

Correct Answer: B. Residual connection

Question 4

What is the principal purpose of a convolutional kernel’s parameter sharing?

A. To ensure every image has the same size

B. To use the same detector at different spatial locations

C. To eliminate the need for nonlinear activations

D. To guarantee perfect translation invariance

Correct Answer: B. To use the same detector at different spatial locations

Question 5

Which output formulation is generally appropriate for a problem with mutually exclusive classes?

A. Independent sigmoid outputs only

B. Softmax probabilities over class logits

C. Max pooling over labels

D. Batch-normalized pixel intensities

Correct Answer: B. Softmax probabilities over class logits

Question 6

A convolution uses input size 64, kernel size 5, stride 2, and padding 2. What is the output size along that dimension?

A. 30

B. 31

C. 32

D. 33

Correct Answer: C. 32

Question 7

Which practice best prevents near-duplicate images from producing an overly optimistic test result?

A. Increasing the batch size

B. Splitting data by relevant subject, batch, or acquisition group

C. Adding more dropout after testing

D. Using a larger softmax temperature

Correct Answer: B. Splitting data by relevant subject, batch, or acquisition group

Question 8

What is the main advantage of global average pooling over a large fully connected layer?

A. It increases the number of spatial coordinates

B. It removes all nonlinearities

C. It can substantially reduce parameters

D. It guarantees higher accuracy

Correct Answer: C. It can substantially reduce parameters

Question 9

Which statement about transfer learning is correct?

A. It always eliminates domain shift

B. It reuses representations learned from another dataset

C. It requires training without labelled target data

D. It prevents source-domain bias from transferring

Correct Answer: B. It reuses representations learned from another dataset

Question 10

If precision P = 0.8 and recall R = 0.5, what is the F1 score?

A. 0.40

B. 0. fifty

C. 0.615

D. 1.30

Correct Answer: C. 0.615