Updated April 3, 2023

## Introduction to NumPy Convolve

In this article, convolve is a method in Python in the NumPy module which is defined for performing a mathematical operation that results in a function by computing any two functions, and it also defines the process taken to compute these functions. This convolve() method returns the linear convolution of two single-dimensional arrays or vectors, and this mathematical operator is generally used in signal processing as in this case, the numpy deals with array and arrays act as a signal was using two different signals (each of one dimensional) to obtain discrete linear convolution result.

### Working of NumPy Convolve() method in Python

This article will discuss the Python’s NumPy module’s method known as convolve() to compute the convolution of two one dimensional arrays resulting in discrete and linear convolution arrays. So, in general, we can define the convolution of two arrays as obtained by integrating the first array, reverse it and then convolve onto the second array and then multiply at those points where arrays overlap, which will yield a discrete and linear convolution array. So, in general, the convolution operation is performed on an image to extract some features or can also be often used in signal processing.

Now let us see in the below section the syntax and examples of the convolve() method in the NumPy module in Python.

**Syntax:**

`NumPy.convolve(a1, a2, mode)`

In the above syntax, we have 3 parameters passed to the convolve method, which are defined as

**a1 –**this parameter is used to define or declare the first input array of one dimension.**a2 –**this parameter is used to define or declare the second input array of one dimension.**mode –**this parameter is used to specify the different mode values such as full, same, and valid, where full is a default mode value. This parameter is optional. Now let see these modes description.**full –**this mode is used to return the convolution of an input array a1 shape + array shape 2 -1 which obtained at the point of overlap and boundary effects at the endpoint of convolution where there is no overlap.**same –**this mode is used to return the maximum length of both the input array a1 and a2’ s shape.**valid –**this mode is used to return the elements that are not relying on zero paddings and should note that in this mode, either of the input arrays must be larger than the other input array in every dimension.

This method convolve() in the numpy module returns the discrete linear convolution of two one dimensional vectors.

Let us see an example of using the convolve() method with 3 different modes and its demonstration in the below section.

### Examples

Let us see the convolution of two one-dimensional arrays using all 3 modes (full, same, valid).

```
import numpy as np
print("program to demonstrate the convolve with full mode")
print("\n")
a1 = [9, 5]
print("The first input array is as follows:")
print(a1)
print("\n")
a2 = [6, 9, 1, 7]
print("The second input array is as follows:")
print(a2)
print("\n")
con_res1 = np.convolve(a1, a2, "full")
print("The resulted convolution of the above two given array with full mode is as follows:")
print(con_res1)
print("\n")
con_res2 = np.convolve(a1, a2, "same")
print("The resulted convolution of the above two given array with same mode is as follows:")
print(con_res2)
print("\n")
con_res3 = np.convolve(a1, a2, "valid")
print("The resulted convolution of the above two given array with valid mode is as follows:")
print(con_res3)
```

**Output:**

In the above program, we can see we have the first imported NumPy module, and then we have declared two one dimensional arrays for input to the convolve() method. So we obtain the output array with the shape that is calculated as the number of elements in the array a1 + number of elements in the array a2 – 1 = shape of the convolution output array. So the shape of the output array would be 2 + 4 – 1 = 5. Therefore in the above screenshot, we can see the resulted convolution of the given two arrays will result in an output array with 5 elements. So now we will see how to compute the element values in the output array as follows:

The first array a1 = [9, 5] is reversed as [5, 9], and then we will perform multiplication using the second array [6, 9, 1, 7], and we will obtain the resulting output array as follows:

First element: 5*0 + 9*6 = 54

Second element: 5*6 + 9*9 = 111

Third element: 5*9 + 9*1 = 54

Forth element: 5*1 + 9*7 = 68

Fifth element: 5*7 + 9*0 = 35

Therefore the output array is [54, 111, 54, 68, 35]

Now in the above example of computing convolve() method by specifying the mode as “same” and the computation is as follows:

The shape of the convolution of the above two given arrays results in output array = max(total number of elements in array a1, the total number of elements in array a2 ).

Shape = max(2, 4) = 4.

Now to compute the convolution for each element we need to first reverse the 1st array i.e. a1 = [9, 5] as [5, 9]. Now multiply with the 2nd array a2 = [6, 9, 1, 7] elements as follows:

1st element = 5*0 + 9*6 = 54

2nd element = 5*6 + 9*9 = 111

3rd element = 5*9 + 9*1 = 54

4th element = 5*1 + 9*7 = 68

Therefore the output array would have 4 elements as per the shape calculated and the elements as

[54, 111, 54, 68].Similarly, for the valid mode, we compute the shape of the output array as max(total number of elements of array a1, the total number of elements in array a2) – min(total number of elements of array a1, the total number of elements in array a2) + 1.

Shape = max(2,4) – min(2,4) + 1 = 4 – 2 + 1 = 3.

Now the computation of each element in the output array is as follows:

First reverse the 1st array as [9, 5] as [5, 9] and compute multiplication with second array [6, 9, 1, 7]

1st element = 5*6 + 9*9 = 111

2nd element = 5*9 + 9*1 = 54

3rd element = 5*1 + 9*7 = 68

Therefore the output array is as follows: [111, 54, 68]

### Conclusion

In this article, we conclude that the NumPy module in the Python programming language provides a function called convolve() to compute the convolution of two arrays of one dimensional. In this article, we saw its syntax and modes, along with the example and explanation of how to compute the convolutions according to three different modes: full, same, and valid modes.

### Recommended Articles

This is a guide to NumPy Convolve. Here we discuss the Working of the NumPy Convolve() method in Python and examples with the outputs. You may also have a look at the following articles to learn more –