Natural Language Processing

Dashing Up Your Python Code with NumPy

August 12, 2024
roosho

Speeding Up Your Python Code with NumPyDashing Up Your Python Code with NumPyPicture by storyset on Freepik

 

NumPy is a Python bundle usually used for mathematical and statistical purposes. Nonetheless, some nonetheless didn’t know NumPy may assist pace up our Python code execution.

There are a number of the reason why NumPy may speed up the Python code execution, together with:

  • NumPy utilizing C Code as an alternative of Python throughout looping
  • The higher CPU caching course of
  • Environment friendly algorithms in mathematical operations
  • Ready to make use of parallel operations
  • Reminiscence-efficient in giant datasets and complicated computations

For a lot of causes, NumPy is efficient in bettering Python code execution. This tutorial will present examples of how NumPy quickens the code course of. Let’s soar into it.

 

NumPy in Speed up Python Code Execution

 
The primary instance compares Python listing and NumPy array numerical operations, which purchase the item with the meant worth consequence.

For instance, we would like a listing of numbers from two lists we add collectively so we carry out the vectorized operation. We will attempt the experiment with the next code:

import numpy as np
import time

pattern = 1000000

list_1 = vary(pattern)
list_2 = vary(pattern)
start_time = time.time()
consequence = [(x + y) for x, y in zip(list_1, list_2)]
print("Time taken utilizing Python lists:", time.time() - start_time)

array_1 = np.arange(pattern)
array_2 = np.arange(pattern)
start_time = time.time()
consequence = array_1 + array_2
print("Time taken utilizing NumPy arrays:", time.time() - start_time)

 

Output>>
Time taken utilizing Python lists: 0.18960118293762207
Time taken utilizing NumPy arrays: 0.02495265007019043

 

As you possibly can see within the above output, the execution of NumPy arrays is quicker than that of the Python listing in buying the identical consequence.

All through the instance, you’ll see that the NumPy execution is quicker. Let’s see if we need to carry out aggregation statistical evaluation.

array = np.arange(1000000)

start_time = time.time()
sum_rst = np.sum(array)
mean_rst = np.imply(array)
print("Time taken for aggregation features:", time.time() - start_time)

 

Output>> 
Time taken for aggregation features: 0.0029935836791992188

 

NumPy can course of the aggregation perform fairly quick. If we evaluate it with the Python execution, we will see the execution time variations.

list_1 = listing(vary(1000000))

start_time = time.time()
sum_rst = sum(list_1)
mean_rst = sum(list_1) / len(list_1)
print("Time taken for aggregation features (Python):", time.time() - start_time)

 

Output>>
Time taken for aggregation features (Python): 0.09979510307312012

 

With the identical consequence, Python’s in-built perform would take way more time than NumPy. If we had a a lot larger dataset, Python would take approach longer to complete the NumPy.

One other instance is once we attempt to carry out in-place operations, we will see that the NumPy can be a lot quicker than the Python instance.

array = np.arange(1000000)
start_time = time.time()
array += 1
print("Time taken for in-place operation:", time.time() - start_time)

 

list_1 = listing(vary(1000000))
start_time = time.time()
for i in vary(len(list_1)):
    list_1[i] += 1
print("Time taken for in-place listing operation:", time.time() - start_time)

 

Output>>
Time taken for in-place operation: 0.0010089874267578125
Time taken for in-place listing operation: 0.1937870979309082

 

The purpose of the instance is that if in case you have an choice to carry out with NumPy, then it’s a lot better as the method can be a lot quicker.

We will attempt a extra complicated implementation, utilizing matrix multiplication to see how briskly NumPy is in comparison with Python.

def python_matrix_multiply(A, B):
    consequence = [[0 for _ in range(len(B[0]))] for _ in vary(len(A))]
    for i in vary(len(A)):
        for j in vary(len(B[0])):
            for ok in vary(len(B)):
                consequence[i][j] += A[i][k] * B[k][j]
    return consequence

def numpy_matrix_multiply(A, B):
    return np.dot(A, B)

n = 200
A = [[np.random.rand() for _ in range(n)] for _ in vary(n)]
B = [[np.random.rand() for _ in range(n)] for _ in vary(n)]

A_np = np.array(A)
B_np = np.array(B)

start_time = time.time()
python_result = python_matrix_multiply(A, B)
print("Time taken for Python matrix multiplication:", time.time() - start_time)

start_time = time.time()
numpy_result = numpy_matrix_multiply(A_np, B_np)
print("Time taken for NumPy matrix multiplication:", time.time() - start_time)

 

Output>>
Time taken for Python matrix multiplication: 1.8010151386260986
Time taken for NumPy matrix multiplication: 0.008051872253417969

 

As you possibly can see, NumPy is even quicker in additional complicated actions, comparable to Matrix Multiplication, which makes use of commonplace Python code.

We will check out many extra examples, however NumPy must be quicker than Python’s built-in perform execution occasions.
 

Conclusion

 
NumPy is a strong bundle for mathematical and numerical processes. In comparison with the usual Python in-built perform, NumPy execution time can be quicker than the Python counterpart. That’s the reason, attempt to use NumPy if it’s relevant to hurry up our Python code.
 
 

Cornellius Yudha Wijaya is a knowledge science assistant supervisor and knowledge author. Whereas working full-time at Allianz Indonesia, he likes to share Python and knowledge suggestions by way of social media and writing media. Cornellius writes on quite a lot of AI and machine studying matters.