Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/numpy/vectorized-operations-in-numpy/ below:

Vectorization in NumPy with Practical Examples

Last Updated : 09 Jan, 2025

Vectorization in NumPy is a method of performing operations on entire arrays without explicit loops. This approach leverages NumPy's underlying C implementation for faster and more efficient computations. By replacing iterative processes with vectorized functions, you can significantly optimize performance in data analysis, machine learning, and scientific computing tasks. For example:

import numpy as np

a1 = np.array([2,4,6,8,10 ])
number= 2
result = a1 + number
print(result)

Here number 2 is added for each value in array without looping through each element manually.

Vectorization is significant because it:

• Improves Performance: Operations are faster due to pre-compiled C-based implementations.
• Simplifies Code: Eliminates explicit loops, making code cleaner and easier to read.
• Supports Scalability: Efficiently handles large datasets.

Let's imply different types of operations that can be vectorized in NumPy, along with practical examples.

Performing element-wise addition directly using NumPy’s built-in capabilities eliminating the need for explicit loops.

import numpy as np
a1 = np.array([1, 2, 3])
a2 = np.array([4, 5, 6])
result = a1 + a2
print(result)  

import numpy as np
a1 = np.array([1, 2, 3, 4])
result = a1 * 2
print(result)  

Logical operations such as comparisons can be applied directly to arrays.

import numpy as np
a1 = np.array([10, 20, 30])
result = a1 > 15
print(result)  

Each element is compared to the value 15, producing a boolean array indicating whether the condition is met (True or False).

NumPy supports vectorized matrix operations like dot products and matrix multiplications using functions such as np.dot and @.

import numpy as np
a1= np.array([[1, 2], [3, 4]])
a2 = np.array([[5, 6], [7, 8]])
result = np.dot(a1, a2) 
print(result)

Dot product is computed as the sum of element-wise products between two arrays. Essential for linear algebra computations and widely used in machine learning applications like matrix multiplication and vector projections.

np.vectorize function allows to apply custom scalar functions to entire arrays in a seamless and efficient manner, useful when working with user-defined logic that isn't inherently vectorized: Below we will understand with example where, A custom function custom_func is defined to compute x^2 +2x+1 directly applied to the array.

import numpy as np

def custom_func(x):
    return x**2 + 2*x + 1

a1 = np.array([1, 2, 3, 4])
result = custom_func(a1)
print(result) 

The result [4, 9, 16, 25] where:

x = 1: \quad 1^2 + 2(1) + 1 = 4 \\ x = 2: \quad 2^2 + 2(2) + 1 = 9 \\ x = 3: \quad 3^2 + 2(3) + 1 = 16 \\ x = 4: \quad 4^2 + 2(4) + 1 = 25

Operations like sum, mean, max are optimized with much faster than the traditional Python approach of looping through elements.

import numpy as np
a1 = np.array([1, 2, 3])
result_sum = a1.sum()
result_mean = a1.mean()
print(result_sum)   
print(result_mean)  

NumPy's aggregation methods operate efficiently on entire arrays to compute sums, averages, maximums, and other statistical metrics.

Here, we will calculate the sum of numbers from 0 to 14,999 using %timeit for benchmarking for showing performance differences. Let's compare the time required to execute a vectorized operation versus an equivalent loop-based operation.

import numpy as np
import time

start_time = time.time()
vectorized_sum = np.sum(np.arange(15000))
print("Vectorized sum:", vectorized_sum)
print("Time taken by vectorized sum:", time.time() - start_time)

start_time = time.time()
iterative_sum = sum(range(15000)) 
print("\nIterative sum:", iterative_sum)
print("Time taken by iterative sum:", time.time() - start_time)

Vectorized sum: 112492500
Time taken by vectorized sum: 0.06439447402954102

Iterative sum: 112492500
Time taken by iterative sum: 0.0006148815155029297

 NumPy's vectorization simplifies complex computations by allowing operations directly on arrays without explicit loops. From mathematical operations to logical comparisons and custom functions, vectorization ensures faster execution and cleaner code.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4