À propos de tout numpy

Veuillez vous référer au nouvel article créé en ** here ** en vous référant au commentaire de @ shiracamus.

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).

Le calcul à l'aide de numpy est très rapide, donc en gros, il est plus rapide de calculer avec numpy que de l'écrire directement avec python, mais je voulais vraiment accélérer cette partie et j'ai essayé diverses choses, des conditions limitées Si tel est le cas, j'ai pu le renverser, alors je voudrais le présenter.

Méthode

La méthode consiste à accéder à tous les éléments du tableau avec l'instruction for et à calculer dans l'ordre avec et. Comparez cela avec tout numpy. J'aimerais également connaître l'heure d'utilisation de numba.

Code source

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

#Utiliser tous
def func1(arr):
    return arr.all()

#Utiliser et avec pour
def func2(arr):
    tf = True
    for i in range(arr.size):
        tf = tf and arr[i]
    else:
        return tf

if __name__ == '__main__':
    if len(sys.argv) == 3:
        testsize, arr_size = map(int, sys.argv[1:])
    else:
        testsize = 10
        arr_size = 10
    #Nombre de tests,Taille du tableau
    print(testsize, arr_size)

    elapsed_time = []
    for i in range(testsize):
        #Tableau Vrai et Faux
        arr = np.random.randint(2, size=arr_size).astype(np.bool)
        start = time.time()

        func1(arr)

        end = time.time()
        elapsed_time.append((end - start) * 1e6)

    plt.plot(elapsed_time[1:], 'b', label='numpy all')

    elapsed_time = []
    for i in range(testsize):
        arr = np.random.randint(2, size=arr_size).astype(np.bool)
        start = time.time()

        func2(arr)

        end = time.time()
        elapsed_time.append((end - start) * 1e6)

    plt.plot(elapsed_time[1:], 'r', label='for')
    plt.xlabel('test size')
    plt.ylabel('elapsed time[us]')
    plt.legend()
    plt.show()

résultat

numba non utilisé

En supposant que la taille du tableau est de 10 et que le nombre de tests est de 10 fois, le résultat est comme indiqué dans la figure suivante. Il est plus rapide de faire et d'utiliser l'instruction for.

En supposant que la taille de la matrice est de 200 et que le nombre de tests est de 10, le résultat est comme indiqué dans la figure suivante. Tout est plus rapide.

L'instruction for devient plus lente à mesure que la taille du tableau augmente. Vous pouvez voir à quoi cela ressemble dans la figure suivante. On ne sait pas à quoi ressemble cette apparence d'impulsion. À partir de là, je pense que cela dépend de l'environnement, mais si la taille du tableau est de 100 ou moins, il est écrit tel quel en python S'est avéré être plus rapide.

Utilisez numba

Comme numba compile Just In Time (JIT), il faut beaucoup de temps pour accéder à la fonction au tout début. J'ai eu le résultat. Il semble que le deuxième accès prend aussi du temps. On peut dire qu'il n'y a pas de différence de temps d'exécution. Si le tableau est plus grand, il ressemblera à la figure suivante: numpy est plus rapide.

Conclusion

J'ai collé beaucoup de graphiques, mais j'aimerais dire les deux choses suivantes.

** Si la taille du tableau est petite, il est plus rapide d'utiliser l'instruction for si numba n'est pas utilisé **
** numba contribue à accélérer **

finalement

Quelle était l'impulsion apparaissant dans ce graphique?