Convolution modes
Contents
3.4. Convolution modes#
As we saw in the first section of this chapter, the first few samples produced by a convolution \(y = x*h\) depend on negative sample indices \(x[nk]\) where \(n < k\). To ensure that the convolution is welldefined for these indices, we assume \(x[nk]=0\) for \(n<k < K\) (the length of the filter), which we may also think of as padding the signal with zeros on the left. This means that we can think of the first \(k\) samples of \(y\) as depending on these additional zeros. Any sample \(n \geq k\) will not depend on this padding.
Depending on how you want to use convolution, it may or may not be appropriate to include these first few samples. In this section, we’ll describe different commonly used modes of convolution, which can all be implemented by some combination of padding and trimming the inputs and outputs. Note that these modes do not fundamentally alter how convolution works: all that changes is which outputs are retained in the output signal.
Throughout this section, we will assume that \(x\) and \(h\) have \(N\) and \(K\) samples, respectively, and that \(N \geq K\). This latter assumption is for convenience, and as we’ll see in the next section, it is not necessary.
3.4.1. Full mode#
Full mode convolution is implemented by padding the input on both the left and the right by \(K1\) samples each. A full mode convolution will have \(N + K  1\) output samples.
The intuition for this is that it captures both a warm up phase (\(n < K\)), as well as a ringing out phase (\(N \leq n < N + K\)). The warm up phase contains all outputs which depend on some (but not only) prepended silence, the ringing out phase similarly contains outputs which depend on some (but not only) appended silence.
These effects can be seen in the example below, where we compute a full convolution between an increasing sequence \([5, 6, 7, 8, 9]\) and a differencing filter \([1, 0, 1]\). With this example, we’ll have \(y[n] = x[n]  x[n2]\) in general, which will be the constant 2 for this sequence. However, at the beginning and end, you can see the effects of left and rightpadding by zeros.
# Full mode example
x = np.arange(5, 10)
# This is a differencing filter:
# y[n] = x[n]  x[n2]
h = np.array([1, 0, 1])
y = np.convolve(x, h, mode='full')
print('Input :\t', x)
print('Filter :\t', h)
print('Full convolution:\t', y)
Input : [5 6 7 8 9]
Filter : [ 1 0 1]
Full convolution: [ 5 6 2 2 2 8 9]
3.4.2. Valid mode#
Valid mode convolution eliminates any outputs that depend on padding at all. If we start from the full mode convolution described above, the valid outputs are the middle 3, because they depend only on values explicitly observed in the input: \(75\), \(86\), and \(97\).
A valid mode convolution will have \(N  K + 1\) output samples.
y = np.convolve(x, h, mode='valid')
print('Input :\t', x)
print('Filter :\t', h)
print('Valid convolution:\t', y)
Input : [5 6 7 8 9]
Filter : [ 1 0 1]
Valid convolution: [2 2 2]
3.4.3. Same mode#
Same mode is derived from full mode by extracting \(N\) samples from the full convolution, so that the output \(y\) has the same length \(N\) as \(x\). Most implementations of same mode extract the middle of the output, so that both the first and last \(K/2\) samples depend on zero padding, as demonstrated below:
y = np.convolve(x, h, mode='same')
print('Input :\t', x)
print('Filter :\t', h)
print('Same convolution:\t', y)
Input : [5 6 7 8 9]
Filter : [ 1 0 1]
Same convolution: [ 6 2 2 2 8]
Sometimes, you may want a leftaligned (or rightaligned) samemode convolution, including the warmup but not ringout (or vice versa). These can be helpful if you want to introduce a delay effect to a signal, but retain its length. While the standard implementation used above does not do this, it’s easy enough to construct by trimming the full mode convolution differently:
# Include only the warmup phase
N = len(x)
y = np.convolve(x, h, mode='full')
y = y[:N] # Truncate to the first N samples
print('Input :\t', x)
print('Filter :\t', h)
print('Same (leftalign):\t', y)
Input : [5 6 7 8 9]
Filter : [ 1 0 1]
Same (leftalign): [5 6 2 2 2]
# Discard the warmup, but include the ringout
N = len(x)
y = np.convolve(x, h, mode='full')
y = y[N:] # Truncate to the last N samples
print('Input :\t', x)
print('Filter :\t', h)
print('Same (rightalign):\t', y)
Input : [5 6 7 8 9]
Filter : [ 1 0 1]
Same (rightalign): [ 2 2 2 8 9]
3.4.4. Summary#
The different convolution modes are summarized visually below, with \(h\) as the differencing filter used above, and \(x\) now as a square wave over 25 samples.
The shaded regions of the bottom subplot correspond to those which depend on zeropadding.
The table below provides a rubric for deriving the different convolution modes from full mode in Python.
For each mode, the length of the output signal is listed, as well as the slice notation for finding the different mode outputs within the full
convolution.
In this table, we’ve assumed that \(N \geq K \geq 1\).
Mode 
Length 
Slice 
Code 

Full 
\({N+K1}\) 


Valid 
\({NK+1}\) 


Same (left) 
\(N\) 


Same (centered) 
\(N\) 


Same (right) 
\(N\) 


Remember that array slices in Python do not include the upper limit.
For example, x[K:N]
denotes indices x[K], x[K+1], x[K+2], … x[N1]
.