À propos de tout numpy (2e)

Cet article est basé sur le commentaire de @ shiracamus dans Article précédemment écrit.

introduction

numpy all est une fonction qui renvoie True si tous les éléments du tableau numpy sont True, False sinon. La documentation est ici (https://docs.scipy.org/doc/numpy/reference) /generated/numpy.ndarray.all.html#numpy.ndarray.all). Ici, nous faisons référence à ndarray.all () ''. Comme le dit la documentation, np. All () a la même signification, et il semble y avoir une fonction appelée np.alltrue (), mais code source github En regardant /blob/master/numpy/core/fromnumeric.py), il semble que ces deux fonctions appellent `` ndarray.all () '' après tout, donc je ne les utiliserai pas cette fois.

Comme le calcul utilisant numpy est très rapide, il est fondamentalement plus rapide de calculer avec numpy que de l'écrire directement avec python.Cependant, je voudrais l'introduire car je pourrais le renverser dans des conditions limitées. Je pense.

En outre, numba est une bibliothèque qui effectue la compilation Just In Time (JIT) pour accélérer. Par conséquent, la compilation peut prendre un certain temps lors de l'accès à la fonction pour la première fois. Plus précisément, un indice ( @ numba.jit (numba.b1 (numba.b1 [:])) `) ne prend presque pas de temps de compilation, mais pas (` `@ numba.jit (Quand `) peut prendre quelques secondes. Il n'y a pas de grande différence dans le temps d'exécution après la compilation.

Méthode

Comparez les trois suivants lorsque numba n'a pas été utilisé pour la première fois.

Accédez aux éléments du tableau dans l'ordre avec l'instruction for
Fonctions intégrées all (Documents ici)
tout engourdir À première vue, 1 et 2 sont identiques, mais vous pouvez voir à partir des résultats qu'ils sont différents. J'aimerais également connaître l'heure à laquelle vous utilisez numba.

Code source

Si vous n'utilisez pas numba, commentez simplement la partie `` @ numba.jit ''.

`test.py`


import numpy as np
import numba
import time
import matplotlib.pyplot as plt

#Utiliser les fonctions intégrées
@numba.jit(numba.b1(numba.b1[:]))
def builtin(arr):
    return all(arr)

#Décrivez avec une déclaration
@numba.jit(numba.b1(numba.b1[:]))
def use_for(arr):
    for element in arr:
        if not element:
            return False
    else:
        return True

#Utilisez tout numpy
@numba.jit(numba.b1(numba.b1[:]))
def np_all(arr):
    return arr.all()

#Tester la fonction comme argument
def test(func):
    elapsed_time = []
    for arr_size in range(1000):
        arr = np.ones(arr_size).astype(np.bool)
        start = time.time()
        func(arr)
        end = time.time()
        elapsed_time.append((end - start) * 1e6)

    return elapsed_time[1:]

if __name__ == '__main__':
    plt.plot(test(use_for), 'g', label='for')
    plt.plot(test(builtin), 'r', label='built-in')
    plt.plot(test(np_all), 'b', label='numpy')
    plt.legend()
    plt.xlabel('array size')
    plt.ylabel('elapsed time[us]')
    plt.show()

Méthode d'exécution

python test.py

résultat

numba non utilisé

Le temps d'exécution lorsque la taille du tableau est de 1 000 ou moins est comme indiqué dans la figure. De là, vous pouvez voir que numpy est plus utile à mesure que la taille du tableau augmente. De plus, la fonction intégrée est meilleure que l'instruction for. Je pense qu'être rapide est une propriété de Python. Si c'est 200 ou moins, j'ai trouvé que les deux autres méthodes sont plus rapides que numpy. Ce nombre de 200 peut dépendre de l'environnement. il y a.

Utilisez numba

Le tracé est fait sauf pour le temps écoulé nécessaire pour le tout premier accès. Le résultat est comme indiqué sur la figure. La fonction intégrée ne semble pas être accélérée par numba, mais les instructions all et for de numpy sont accélérées. De plus, il est intéressant de noter que * les fonctions intégrées sont plus lentes que lorsque numba n'était pas utilisé. * D'un autre côté, lorsqu'elles sont écrites dans l'instruction for, elles sont plus rapides et la vitesse est plus rapide que numpy.

Si le tableau est plus grand, il ressemble à la figure suivante. En excluant les fonctions intégrées. L'instruction for semble toujours plus rapide.

Conclusion

numba non utilisé

** Lorsque la taille du tableau est petite, il est plus rapide d'utiliser la fonction intégrée tout **
** Lorsque la taille du tableau est grande, il est plus rapide d'utiliser tout numpy **

Utilisez numba

Quelle que soit la taille du tableau, il est bon de le décrire avec ** for statement **, mais compte tenu du temps et de l'effort de description et du nombre d'appels, numpy peut être utilisé. Cependant, les ** fonctions intégrées sont inutiles **
** numba contribue grandement à accélérer **

J'ai réalisé que je n'avais pas fait attention à l'utilisation du processeur après avoir écrit jusqu'à présent, et encore

taskset -c 0 python test.py

J'ai obtenu un graphique similaire lorsque je l'ai exécuté, donc il n'y a pas eu de problème.

finalement

Merci à @shiracamus.