If there is a lot of noise in an image, it is hard to detect the edges of an object directly. As a solution, we first preprocess using Gaussian filters to blur the image. After the Gaussian blurring, the edge detection will be more effective.

Preprocessing Before Boundary (Edge) Detection Using Convolution Operation

We can apply different filters to detect edges in different directions.

Visualization of Boundary (Edge) Detection Using Convolution Operation

Convolution Edge Detection in Positive vs. Negative OR Light to Dark vs. Dark to Light Edge Transitions

For detecting edges in some complicated images, it is proposed to use back-propagation when training the Deep learning model to find the optimal weights for the filter (kernel), rather than handpicking the weights. The objective is to find. the optimal values for these weights as parameters so that it appropriately detects the edges.
It may even learn to detect edges that are at 45 degrees or 73 degrees.

Setting Convolution-based Edge Detection Filter (Kernel) Weights Using Backpropagation

A convolution kernel can act as a finite difference operator to locate pixel changes for edge detection. For example, a $$1 \times 2$$ kernel like $$[1, -1]$$ computes the difference between horizontally adjacent pixels, $$x_{i,j} - x_{(i+1),j}$$. This cross-correlation operation serves as a discrete approximation of the first derivative in the horizontal direction. Mathematically, for an image function $$f(i,j)$$, its derivative is $$-\partial_i f(i,j) = \lim_{\epsilon \to 0} \frac{f(i,j) - f(i+\epsilon,j)}{\epsilon}$$. By applying this kernel, the output is zero where adjacent pixels are identical and non-zero at boundaries, effectively detecting edges.

Convolution Kernel as a Finite Difference Operator

To illustrate vertical edge detection, consider a $$6 \times 8$$ pixel image where the middle columns are black ($$0$$) and the outer columns are white ($$1$$). Applying a $$1 \times 2$$ kernel of $$[1, -1]$$ via cross-correlation outputs $$0$$ when horizontally adjacent pixels are the same. At the boundaries, it detects the pixel change, outputting $$1$$ for a white-to-black edge and $$-1$$ for a black-to-white edge. If this same kernel is applied to the transposed image—where the edges are now horizontal—the output vanishes, confirming that this specific kernel exclusively detects vertical edges.

Example of Vertical Edge Detection Using Convolution

Max-pooling can provide translation invariance to features extracted by convolutional layers. For instance, in edge detection, passing the output of a convolutional layer through a $$2	imes 2$$ max-pooling layer ensures that the detected edge pattern will still be recognized even if the input shifts by one element in height or width. As long as the high activation value remains within the pooling window, the pooling layer will consistently output the same maximum value.

Edge Detection Translation Invariance via Max-Pooling

Edge detection is a fundamental image processing application of convolutional layers. It involves locating the boundaries of an object within an image by finding the precise locations of pixel changes. By performing a cross-correlation or convolution operation with a specifically constructed filter matrix, or kernel, the layer can successfully detect distinct kinds of boundaries, such as vertical or horizontal edges.

University of Michigan - Ann Arbor

Claude

One of the most popular introductory applications of CNN is image recognition, specifically sorting through images and classifying them as either cat or not cat.

Using Convolutional Neural Network for Image Recognition

A convolutional layer performs a cross-correlation operation between its input and a kernel, and subsequently adds a scalar bias to the result to generate an output. During model training, the convolutional layer learns two key parameters: the kernel (weights) and the scalar bias. Prior to training, these kernel weights are generally initialized with random values, analogous to the initialization process in fully connected layers.

Convolutional Layer

Dive into Deep Learning

- **Parameters Sharing**: a feature that is detected as useful in part of the image is probably useful in other parts as well.
- **Sparsity of Connections**: in each layer, each output value depends only on a small number of inputs, rather than considering all the pixel inputs.

Advantages of Using Convolutional Neural Networks for Image Recognition

Object Edge Detection Using Convolution

For a convolutional layer $$l$$, the output dimensions and number of parameters are calculated as follows:

Input Size: $$n_h^{[l-1]} 	imes n_w^{[l-1]} 	imes n_c^{[l-1]}$$
Filter (Kernel) Size: $$k_h^{[l]} 	imes k_w^{[l]} 	imes n_c^{[l-1]}$$
*(Note: $$n_c^{[l]}$$ is the number of filters in layer $$l$$, matching the number of output channels.)
Stride: $$s_h^{[l]} 	imes s_w^{[l]}$$
Padding: $$p_h^{[l]} 	imes p_w^{[l]}$$

Output (Activations $$a^{[l]}$$) Size: $$n_h^{[l]} 	imes n_w^{[l]} 	imes n_c^{[l]}$$
$$n_h^{[l]} = \left \lfloor \frac{n_h^{[l-1]} + 2p_h^{[l]} - k_h^{[l]}}{s_h^{[l]}} ight floor + 1$$
$$n_w^{[l]} = \left \lfloor \frac{n_w^{[l-1]} + 2p_w^{[l]} - k_w^{[l]}}{s_w^{[l]}} ight floor + 1$$

Number of Parameters:
 Weights: $$k_h^{[l]} 	imes k_w^{[l]} 	imes n_c^{[l-1]} 	imes n_c^{[l]}$$
* Biases: $$n_c^{[l]}$$

Convolution Layer Output Size and Parameter Formulas

While it is possible to manually design simple convolution kernels for specific tasks—such as using a $$1 \times 2$$ finite difference operator like $$[1, -1]$$ for basic edge detection—this approach does not scale to complex problems. As deep learning models utilize larger kernels and incorporate successive layers of convolutions, it becomes practically impossible to manually specify the precise weights and the specific function of every individual filter.

Limitation of Manually Designed Convolutional Kernels

In deep learning, operations labeled as convolutions are technically cross-correlations. A strict two-dimensional discrete convolution uses index differences to sum elements, effectively flipping the kernel: $$(f * g)(i, j) = \sum_a \sum_b f(a, b) g(i-a, j-b)$$. In contrast, cross-correlation uses index additions: $$(i+a, j+b)$$. Because kernels are learned from data, a network using cross-correlation will simply learn a flipped version of the kernel matrix $$\mathbf{K}'$$ that a strict convolution would learn as $$\mathbf{K}$$, producing identical outputs. This cosmetic distinction justifies the standard terminology of calling cross-correlation a convolution.

Equivalence of Strict Convolution and Cross-Correlation

In the context of convolutional neural networks, a feature map is the output produced by a convolutional layer. It acts as a learned representation, capturing specific spatial features—such as patterns across height and width dimensions—that are then passed forward as input to subsequent layers in the network.

Feature Map

A two-dimensional convolutional layer can be implemented programmatically by defining a class that encapsulates its two core parameters: the kernel weights and the scalar bias. In the class constructor, these parameters are declared and initialized (e.g., initializing weights randomly and bias to zero). The layer's forward propagation method then computes the output by executing a two-dimensional cross-correlation between the input and the kernel weights, and subsequently adding the scalar bias to the result.

Two-Dimensional Convolutional Layer Code Implementation

The dimensions of a convolution kernel are defined by its height ($$h$$) and width ($$w$$), commonly referred to as an $$h 	imes w$$ convolution kernel. Accordingly, the operation utilizing this kernel is known as an $$h 	imes w$$ convolution. Furthermore, a convolutional layer that employs an $$h 	imes w$$ convolution kernel is simply denoted as an $$h 	imes w$$ convolutional layer.

Convolution Kernel and Layer Size Notation

A practical illustration of a convolutional layer is a Waldo detector, which scans across an image to locate the character Waldo. The layer extracts small, localized windows from the input image and weights the pixel intensities using a specifically trained convolution filter, denoted as $$\mathsf{V}$$. The objective is to learn a filter such that locations in the image with the highest 'waldoness'—meaning they closely match the target pattern—result in peak activation values in the corresponding spatial locations of the hidden representation.

Waldo Detector Convolution Example

The fundamental computation of a convolutional layer—typically implemented as a cross-correlation operation—is highly local, meaning that each output element depends only on a small, contiguous region of the input. This structural locality allows for significant hardware optimization, as chip designers can prioritize fast computation units over large memory capacity or bandwidth when designing accelerators for convolutions. While this specialized hardware design might not be optimal for all types of algorithms, it provides the computational efficiency necessary for affordable and ubiquitous computer vision applications.

Locality and Hardware Optimization of Convolutions

In modern convolutional neural network architectures, it is essential to utilize multiple channels at each layer. As data propagates deeper into the network, the channel dimension is typically increased. This architectural design explicitly trades off spatial resolution, which is usually downsampled, for greater channel depth, allowing the network to capture increasingly complex and jointly optimized feature representations.

Learn Before

Related

Learn After