NumPy Vectorize

In the above syntax, vectorize_function is a function name, np.vectorize is a numpy class, and function is a user-defined function with parameters. The parameters which we are using in the numpy vector as below.

Different Parameters of Numpy vectorize are as follows.

1. pyfunc: It is used to define the function of python as well as the method, and it must be required. Therefore, it is a callable parameter.

2. otypes: The otypes mean output data type, and it is optional. In otypes, it should be specified as either a list of data types specified or a string of type code characters. For each output, there must be one data specified.

3. doc: The doc is an optional parameter to the docstring. If there is none in doc, then docstring will be pyfunc_doc_str.

4. excluded: This is an optional parameter. This parameter consists of either a set of strings or integers representing the positional or keyword arguments for the functions that will not be vectorized. A set of strings or integers will be passed directly to pyfunc unmodified.

5. cache: The cache is an optional parameter. It will cache the first function call, which generally determines the number of outputs if True and otypes are not given.

6. Signature: It is an optional parameter. It is a generalized universal function. For example, (a, b), (b) -> (a) it is used for vectorized matrix-vector function multiplication. At whatever point it is given, pyfunc will be called with (and it must returned) array with shapes given by the size of looking at focus estimations. By default, Pyfunc is expected to accept scalars as input as well as output.

How does the vectorize function work in NumPy?

Let’s see how we can implement a numpy vectorize function on an array. But, first, we see what is the difference between vectorizing and non-vectorize implementation.

1. Vectorize Implementation

It is mainly related to matrices. In vectorize implementation, we execute huge algorithms like machine learning algorithms and neural language algorithms.

Example

import numpy as np
import time
no = 100000
x = np.random.random(no)
y = np.random.random(no)
start = time.time()
z = np.dot(x,y)
end = time.time()
print("Vectorize :" + str((end-start)*1000)+ 'ms')

Explanation

In the above example, we implemented the numpy vectorize function using an array. In this program, we used two arrays, x, and y, with random numbers, and then we used dot product means the multiplication of x and y arrays. Also, we have calculated the total execution time of the x and y array using vectorize. Thus, the vectorize function takes minimum time for execution. Illustrate the end result of the above declaration by using the use of the following snapshot.

2. Non-Vectorize Implementation

In this implementation, we use a loop for implementation purposes non-vectorize implementation takes more time to execute as compared to vectorize implementation.

Example:

import numpy as np
import time
no= 100000
x=np.random.random(no)
y=np.random.random(no)
start = time.time()
for i in range(no):
    z += x[i] + y[i]
    end=time.time()
print("Loop :" + str((end-start)*1000)+ 'ms')

Explanation

In the above example, we implemented a non-vectorize numpy. In this example, we used a loop for implementation. Here we have used Loop instead of Vectorize. As a result, the non-vectorize takes more time. Illustrate the end result of the above declaration by using the use of the following snapshot.

Example: numpy vectorize function

import numpy as np
def func1(c, d):
    if c > d:
        return c - d
    else:
        return c + d
vfun = np.vectorize(func1)
z=vfun([4, 3, 5, 2], 1)
print(z)

Explanation:

In this example, we have implemented numpy vectorization. We have defined a vectorize function in which m and n are arguments. The Vectorize function used in the above example reduces the length of code. In this example, vfun directly performs the operation on arrays. Illustrate the end result of the above declaration by using the use of the following snapshot.

Example: numpy vectorize docstring

import numpy as np
def func1(p, q):
    vecfunc.__doc__
vecfunc = np.vectorize(func1, doc="welcome to python")
a=vecfunc.__doc__
print(a)

import numpy as np
def pval(x, y):
    _x = list(x)
    res = _x.pop(0)
    while _x:
        res = res*y + _x.pop(0)
    return res
vect_pval = np.vectorize(pval, excluded=['x'])
z=vect_pval(x=[2, 4, 5], y=[1, 2])
print(z)