Convolution (convolve) in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of 1D convolution with 'full' mode

What is the output of this code snippet using scipy.signal.convolve with mode='full'?

SciPy

import numpy as np
from scipy.signal import convolve

x = np.array([1, 2, 3])
h = np.array([0, 1, 0.5])
result = convolve(x, h, mode='full')
print(result)

A [1. 2. 3. 0.5 0. ]

B [0. 1. 2. 3. 1.5]

C [0. 1. 2.5 4. 1.5]

D [1. 2.5 4. 1.5 0. ]

💡 Hint

Remember that 'full' mode returns the complete convolution, including edges.

The convolution sums products of overlapping elements. With mode='full', the output length is len(x)+len(h)-1 = 5. The calculation yields [0, 1, 2.5, 4, 1.5].

❓ data_output

intermediate

Length of convolution result with 'valid' mode

Given two arrays a and b of lengths 7 and 3 respectively, what is the length of the result when convolving with mode='valid'?

SciPy

from scipy.signal import convolve

a = [1,2,3,4,5,6,7]
b = [0,1,0.5]
result = convolve(a, b, mode='valid')
print(len(result))

A 7

B 5

C 9

D 3

💡 Hint

Length in 'valid' mode is len(a) - len(b) + 1.

In 'valid' mode, convolution only includes points where arrays fully overlap, so length is 7 - 3 + 1 = 5.

🔧 Debug

advanced

Identify the error in convolution code

What error will this code raise when run?

SciPy

import numpy as np
from scipy.signal import convolve

x = np.array([1, 2, 3])
h = np.array([[0, 1], [0.5, 0]])
result = convolve(x, h)
print(result)

A ValueError: x and h must have the same number of dimensions

B TypeError: unsupported operand type(s) for *: 'int' and 'list'

C No error, prints a 2D convolution result

D IndexError: index out of bounds

💡 Hint

Check the shapes of the input arrays for convolution.

The 1D array x and 2D array h have different dimensions, so convolve raises a ValueError about dimension mismatch.

❓ visualization

advanced

Plotting convolution result of two signals

Which option correctly plots the convolution of two signals x and h using matplotlib?

SciPy

import numpy as np
from scipy.signal import convolve
import matplotlib.pyplot as plt

x = np.array([1, 2, 3, 4])
h = np.array([0, 1, 0.5])
result = convolve(x, h, mode='full')

# Plot code here

A plt.plot(result); plt.title('Convolution Result'); plt.show()

B plt.scatter(range(len(result)), result); plt.title('Convolution Result'); plt.show()

C plt.bar(range(len(result)), result); plt.title('Convolution Result'); plt.show()

D plt.stem(result); plt.title('Convolution Result'); plt.show()

💡 Hint

Use a line plot to show the convolution values clearly.

Using plt.plot shows the convolution as a continuous line, which is standard for signal visualization. Other plots are less clear or less common for this data.

🧠 Conceptual

expert

Effect of convolution mode on output size

Which statement correctly describes the relationship between input sizes and output size for scipy.signal.convolve modes?

A 'full' mode output length equals len(x); 'valid' mode output length equals len(h); 'same' mode output length equals len(x) - len(h) + 1

B 'full' mode output length equals max(len(x), len(h)); 'valid' mode output length equals min(len(x), len(h)); 'same' mode output length is len(x) + len(h) - 1

C 'full' mode output length is len(x) - len(h) + 1; 'valid' mode output length is len(x) + len(h) - 1; 'same' mode output length equals len(h)

D 'full' mode output length is len(x) + len(h) - 1; 'valid' mode output length is len(x) - len(h) + 1; 'same' mode output length equals len(x)

💡 Hint

Recall the definitions of convolution modes and their output sizes.

'full' mode returns the complete convolution with length len(x)+len(h)-1. 'valid' mode returns only points where arrays fully overlap, length len(x)-len(h)+1. 'same' mode returns output the same size as the first input.

Practice

1. What does the scipy.signal.convolve function do in data science?

easy

A. It sorts an array in ascending order.

B. It combines two arrays to analyze how one affects the other.

C. It finds the maximum value in an array.

D. It splits an array into equal parts.

Solution

1. Step 1: Understand convolution purpose

   Convolution combines two arrays to see how one modifies or overlaps with the other.

2. Step 2: Compare with other options

   Sorting, finding max, or splitting are different operations unrelated to convolution.

3. Final Answer:

   It combines two arrays to analyze how one affects the other. -> Option B

4. Quick Check:

   Convolution = combine arrays [OK]

Hint: Convolution means combining arrays to see effect [OK]

Common Mistakes:

• Confusing convolution with sorting or max functions
• Thinking convolution splits arrays
• Assuming convolution only finds max values

2. Which of the following is the correct way to import the convolution function from scipy?

easy

A. from scipy.signal import convolve

B. import scipy.convolve

C. from scipy import convolve

D. import convolve from scipy.signal

Solution

1. Step 1: Recall scipy import syntax

   The convolution function is inside the signal module, so import from scipy.signal.

2. Step 2: Check syntax correctness

   Correct syntax is from scipy.signal import convolve. Other options have wrong module or import style.

3. Final Answer:

   from scipy.signal import convolve -> Option A

4. Quick Check:

   Import convolve from scipy.signal [OK]

Hint: Import convolve from scipy.signal module [OK]

Common Mistakes:

• Trying to import convolve directly from scipy
• Using wrong import syntax like 'import convolve from ...'
• Missing the signal submodule in import

3. What is the output of this code?

import numpy as np
from scipy.signal import convolve
x = np.array([1, 2, 3])
k = np.array([0, 1])
result = convolve(x, k, mode='full')
print(result)

medium

A. [0 1 2 3]

B. [1 2 3 0]

C. [0 1 2 3 3]

D. [0 1 2 3 0]

Solution

1. Step 1: Understand convolution with arrays

   Convolving [1,2,3] with [0,1] in 'full' mode gives length 3+2-1=4 elements.

2. Step 2: Calculate convolution manually

   y[0] = 1*0 = 0
   y[1] = 1*1 + 2*0 = 1
   y[2] = 2*1 + 3*0 = 2
   y[3] = 3*1 = 3
   Result is [0, 1, 2, 3].

3. Final Answer:

   [0 1 2 3] -> Option A

4. Quick Check:

   Full convolution length = len(x)+len(k)-1 [OK]

Hint: Full mode length = sum lengths minus 1 [OK]

Common Mistakes:

• Confusing 'full' with 'same' mode length
• Ignoring zero padding in convolution
• Misaligning kernel during calculation

4. Identify the error in this code snippet:

from scipy.signal import convolve
x = np.array([1, 2, 3])
k = [1, 0]
result = convolve(x, k, mode='same')
print(result)

medium

A. Lists cannot be used; inputs must be numpy arrays.

B. The mode 'same' is invalid for convolve.

C. Kernel length must be odd for convolution.

D. Missing import for numpy.

Solution

1. Step 1: Check for undefined variables

   The code uses np.array but numpy (as np) is not imported, causing NameError.

2. Step 2: Validate other parts

   Mode 'same' is valid, kernel length can be even, and lists are acceptable (as used for k).

3. Final Answer:

   Missing import for numpy. -> Option D

4. Quick Check:

   Import numpy as np [OK]

Hint: Import numpy as np before using np.array [OK]

Common Mistakes:

• Forgetting to import numpy before using np.array
• Thinking 'same' mode is invalid
• Assuming kernel length must be odd

5. You have two signals: signal = np.array([1, 2, 3, 4]) and kernel = np.array([1, 0, -1]). You want to detect edges by convolving and keep the output the same size as the signal. Which code snippet correctly does this?

hard

A. result = convolve(signal, kernel, mode='valid')

B. result = convolve(signal, kernel, mode='full')

C. result = convolve(signal, kernel, mode='same')

D. result = convolve(signal, kernel, mode='trim')

Solution

1. Step 1: Understand mode effects on output size

   'full' mode gives largest output, 'valid' smaller, 'same' keeps output size equal to first input.

2. Step 2: Choose mode to keep output size same as signal

   Using mode='same' returns output with same length as signal, ideal for edge detection.

3. Final Answer:

   result = convolve(signal, kernel, mode='same') -> Option C

4. Quick Check:

   Use mode='same' for output size match [OK]

Hint: Use mode='same' to keep output size equal input [OK]

Common Mistakes:

• Using 'full' mode and getting larger output
• Using invalid mode like 'trim'
• Using 'valid' mode and losing edges