Accélérer votre code Python avec NumPy

NumPy est un package Python largement utilisé pour les applications mathématiques et statistiques. Cependant, beaucoup ignorent encore que NumPy peut considérablement accélérer l’exécution du code Python.

Plusieurs raisons expliquent pourquoi NumPy peut accélérer le code Python :

• NumPy utilise du code C au lieu de Python pour les boucles
• Meilleure mise en cache du processeur
• Algorithmes efficaces pour les opérations mathématiques
• Capacité à utiliser des opérations parallèles
• Efficacité en mémoire pour les grands ensembles de données et les calculs complexes

Pour ces raisons, NumPy est efficace pour améliorer l’exécution du code Python. Ce tutoriel montrera des exemples concrets de la manière dont NumPy accélère le processus de codage. Allons-y.

NumPy pour accélérer l’exécution du code Python

Le premier exemple compare les opérations numériques entre une liste Python et un tableau NumPy, en obtenant l’objet avec le résultat de valeur souhaité.

Par exemple, nous voulons une liste de nombres provenant de deux listes que nous additionnons pour effectuer une opération vectorisée. Nous pouvons essayer l’expérience avec le code suivant :

import numpy as np

import time



sample = 1000000



list_1 = range(sample)

list_2 = range(sample)

start_time = time.time()

result = [(x + y) for x, y in zip(list_1, list_2)]

print("Time taken using Python lists:", time.time() - start_time)



array_1 = np.arange(sample)

array_2 = np.arange(sample)

start_time = time.time()

result = array_1 + array_2

print("Time taken using NumPy arrays:", time.time() - start_time)

Output>>

Time taken using Python lists: 0.18960118293762207

Time taken using NumPy arrays: 0.02495265007019043

Comme vous pouvez le voir dans le résultat ci-dessus, l’exécution des tableaux NumPy est plus rapide que celle des listes Python pour obtenir le même résultat.

Tout au long de l’exemple, vous verrez que l’exécution de NumPy est plus rapide. Voyons maintenant une analyse statistique d’agrégation.

array = np.arange(1000000)



start_time = time.time()

sum_rst = np.sum(array)

mean_rst = np.mean(array)

print("Time taken for aggregation functions:", time.time() - start_time)

Output>> 

Time taken for aggregation functions: 0.0029935836791992188

NumPy peut traiter les fonctions d’agrégation très rapidement. Comparons cela avec l’exécution en Python pour voir les différences de temps d’exécution.

list_1 = list(range(1000000))



start_time = time.time()

sum_rst = sum(list_1)

mean_rst = sum(list_1) / len(list_1)

print("Time taken for aggregation functions (Python):", time.time() - start_time)

Output>>

Time taken for aggregation functions (Python): 0.09979510307312012

Avec le même résultat, la fonction intégrée de Python prendrait beaucoup plus de temps que NumPy. Avec un ensemble de données beaucoup plus volumineux, Python prendrait encore plus de temps pour terminer l’opération par rapport à NumPy.

Un autre exemple est lorsque nous essayons d’effectuer des opérations sur place. NumPy serait beaucoup plus rapide que l’exemple Python.

array = np.arange(1000000)

start_time = time.time()

array += 1

print("Time taken for in-place operation:", time.time() - start_time)

list_1 = list(range(1000000))

start_time = time.time()

for i in range(len(list_1)):

    list_1[i] += 1

print("Time taken for in-place list operation:", time.time() - start_time)

Output>>

Time taken for in-place operation: 0.0010089874267578125

Time taken for in-place list operation: 0.1937870979309082

Le point de cet exemple est que si vous avez la possibilité d’utiliser NumPy, c’est bien mieux car le processus serait beaucoup plus rapide.

Essayons une implémentation plus complexe, en utilisant la multiplication matricielle pour voir à quelle vitesse NumPy est comparé à Python.

def python_matrix_multiply(A, B):

    result = [[0 for _ in range(len(B[0]))] for _ in range(len(A))]

    for i in range(len(A)):

        for j in range(len(B[0])):

            for k in range(len(B)):

                result[i][j] += A[i][k] * B[k][j]

    return result



def numpy_matrix_multiply(A, B):

    return np.dot(A, B)



n = 200

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

B = [[np.random.rand() for _ in range(n)] for _ in range(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

Comme vous pouvez le constater, NumPy est encore plus rapide dans les activités plus complexes, telles que la multiplication matricielle, par rapport au code Python standard.

Nous pourrions essayer beaucoup plus d’exemples, mais NumPy devrait toujours être plus rapide que les fonctions intégrées de Python.

Conclusion

NumPy est un package puissant pour les processus mathématiques et numériques. Comparé aux fonctions intégrées de Python, le temps d’exécution de NumPy est généralement plus rapide. C’est pourquoi, essayez d’utiliser NumPy si cela est applicable pour accélérer votre code Python.

Cornellius Yudha Wijaya est directeur adjoint de la science des données et rédacteur de données. Tout en travaillant à temps plein chez Allianz Indonesia, il adore partager des conseils sur Python et les données via les réseaux sociaux et la rédaction. Cornellius écrit sur une variété de sujets liés à l’IA et à l’apprentissage automatique.