Python somme vs NumPy de numpy.somme

[...] mes [...] la question ici est, serait à l'aide d' numpy.sum sur une liste de Python entiers plus rapidement qu'à l'aide de Python propre sum?

La réponse à cette question est: Non.

Pythons somme sera plus rapide sur les listes, alors que NumPys somme sera plus rapide sur les tableaux. J'ai fait un test pour montrer les timings (Python 3.6, NumPy 1.14):

import random
import numpy as np
import matplotlib.pyplot as plt

from simple_benchmark import benchmark

%matplotlib notebook

def numpy_sum(it):
    return np.sum(it)

def python_sum(it):
    return sum(it)

def numpy_sum_method(arr):
    return arr.sum()

b_array = benchmark(
    [numpy_sum, numpy_sum_method, python_sum],
    arguments={2**i: np.random.randint(0, 10, 2**i) for i in range(2, 21)},
    argument_name='array size',
    function_aliases={numpy_sum: 'numpy.sum(<array>)', numpy_sum_method: '<array>.sum()', python_sum: "sum(<array>)"}
)

b_list = benchmark(
    [numpy_sum, python_sum],
    arguments={2**i: [random.randint(0, 10) for _ in range(2**i)] for i in range(2, 21)},
    argument_name='list size',
    function_aliases={numpy_sum: 'numpy.sum(<list>)', python_sum: "sum(<list>)"}
)

Avec ces résultats:

f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
b_array.plot(ax=ax1)
b_list.plot(ax=ax2)

Gauche: sur un tableau NumPy; à Droite: sur une liste Python.
Notez que c'est un graphe log-log, car l'indice de référence couvre une très large plage de valeurs. Cependant, pour des résultats qualitatifs: la Baisse des moyens de mieux.

Qui montre que pour les listes de Pythons sum est toujours plus rapide tout en np.sum ou la sum méthode de la matrice sera plus rapide (sauf pour de très courts tableaux où les Pythons sum est plus rapide).

Juste au cas où vous êtes intéressé par la comparaison de ces uns contre les autres, j'ai également fait un complot, y compris tous:

f, ax = plt.subplots(1)
b_array.plot(ax=ax)
b_list.plot(ax=ax)
ax.grid(which='both')

Il est intéressant de noter le point de numpy peut rivaliser sur les tableaux en Python et listes est à peu près à près de 200 éléments! Notez que ce nombre peut dépendre de beaucoup de facteurs, tels que Python/NumPy version, ... Ne le prenez pas trop à la lettre.

Ce qui n'a pas été mentionné, c'est la raison de cette différence (je parle de la grande différence d'échelle pas la différence pour de courtes listes/tableaux où les fonctions n'ont tout simplement différents constant, les frais généraux). En supposant Disponible une liste Python est un wrapper autour d'une C (le langage C) tableau de pointeurs vers des objets Python (dans ce cas, Python entiers). Ces entiers peuvent être considérés comme des wrappers autour d'un entier C (et non pas correcte parce que Python entiers peut être arbitrairement grand, de sorte qu'il ne peut pas simplement utiliser un C entier, mais il est assez proche).

Par exemple une liste comme [1, 2, 3] serait (schématiquement, j'en ai laissé un peu de détails) stockés comme ceci:

Un tableau NumPy, cependant, est un wrapper autour d'une C tableau contenant les valeurs de C (dans ce cas int ou long selon 32 ou 64 bits et selon le système d'exploitation).

Donc un tableau NumPy comme np.array([1, 2, 3]) devrait ressembler à ceci:

La prochaine chose à comprendre, c'est comment ces fonctions de travail:

• Pythons sum parcourt la itérable (dans ce cas, la liste ou le tableau) et ajoute tous les éléments.
• NumPys sum méthode parcourt la stockées C tableau et ajoute ces valeurs de C et enfin enveloppe la valeur dans un Python de type (dans ce cas numpy.int32 (ou numpy.int64) et le renvoie.
• NumPys sum fonction convertit l'entrée d'une array (au moins si ce n'est pas un tableau déjà), puis utilise le NumPy sum méthode.

Clairement en ajoutant les valeurs de C à partir d'un C tableau est beaucoup plus rapide que d'ajouter des objets Python, qui est pourquoi les fonctions de NumPy peut être beaucoup plus rapide (voir le deuxième graphique ci-dessus, le NumPy fonctions sur les tableaux battre le Python somme, de loin, pour de grands tableaux).

Mais la conversion d'une liste Python à un tableau NumPy est relativement lente et alors vous avez encore d'ajouter les valeurs de C. C'est la raison pourquoi listes le Python sum sera plus rapide.

La seule question est: pourquoi est-Pythons sum sur un array si lent (c'est le plus lent de tous comparé les fonctions). Et en fait ça a à voir avec le fait que les Pythons somme simplement itère sur tout ce que vous transmettez. Dans le cas d'une liste, on obtient le stockés objet Python mais dans le cas d'un 1D tableau NumPy il n'y a pas stockés des objets Python, juste les valeurs de C, de sorte Python&NumPy devez créer un objet Python (un numpy.int32 ou numpy.int64) pour chaque élément, puis de ces objets Python doivent être ajoutés. La création de l'emballage pour la valeur C est ce qui le rend vraiment très lent.

En outre, quelles sont les conséquences (y compris le rendement) de l'aide d'un Python entier par rapport à un scalaire numpy.int32? Par exemple, pour un += 1, est-il un comportement ou les performances de la différence si le type de a est un Python entier ou d'une numpy.int32?

J'ai fait quelques tests et pour l'addition et soustractions de scalaires vous devriez certainement bâton avec Python entiers. Même si il peut y avoir des mise en cache de passe ce qui signifie que les tests suivants peuvent ne pas être tout à fait représentatif:

from itertools import repeat

python_integer = 1000
numpy_integer_32 = np.int32(1000)
numpy_integer_64 = np.int64(1000)

def repeatedly_add_one(val):
    for _ in repeat(None, 100000):
        _ = val + 1

%timeit repeatedly_add_one(python_integer)
3.7 ms ± 71.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit repeatedly_add_one(numpy_integer_32)
14.3 ms ± 162 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit repeatedly_add_one(numpy_integer_64)
18.5 ms ± 494 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)


def repeatedly_sub_one(val):
    for _ in repeat(None, 100000):
        _ = val - 1

%timeit repeatedly_sub_one(python_integer)
3.75 ms ± 236 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_sub_one(numpy_integer_32)
15.7 ms ± 437 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_sub_one(numpy_integer_64)
19 ms ± 834 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

C'est 3 à 6 fois plus rapide à faire scalaire opérations avec Python entiers qu'avec NumPy scalaires. Je n'ai pas vérifié, pourquoi c'est le cas, mais ma conjecture est que NumPy scalaires sont rarement utilisés, et probablement pas optimisée pour la performance.

La différence devient un peu moins si vous avez réellement effectuer des opérations arithmétiques où les deux opérandes sont des numpy scalaires:

def repeatedly_add_one(val):
    one = type(val)(1)  # create a 1 with the same type as the input
    for _ in repeat(None, 100000):
        _ = val + one

%timeit repeatedly_add_one(python_integer)
3.88 ms ± 273 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_add_one(numpy_integer_32)
6.12 ms ± 324 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_add_one(numpy_integer_64)
6.49 ms ± 265 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Ensuite, c'est seulement 2 fois plus lent.

---

Dans le cas où vous vous demandiez pourquoi j'ai utilisé itertools.repeat ici alors que je pourrais tout simplement utilisé for _ in range(...) à la place. La raison en est que repeat est plus rapide et donc subit moins de frais généraux par boucle. Parce que je suis seulement intéressé par l'addition/soustraction de temps, il est effectivement préférable de ne pas avoir de la boucle de la surcharge de jouer avec les horaires (du moins, pas tant que ça).

Noter que Python somme sur multidimensionnelle des tableaux numpy effectuera uniquement une somme le long du premier axe:

sum(np.array([[[2,3,4],[4,5,6]],[[7,8,9],[10,11,12]]]))
Out[47]: 
array([[ 9, 11, 13],
       [14, 16, 18]])

np.sum(np.array([[[2,3,4],[4,5,6]],[[7,8,9],[10,11,12]]]), axis=0)
Out[48]: 
array([[ 9, 11, 13],
       [14, 16, 18]])

np.sum(np.array([[[2,3,4],[4,5,6]],[[7,8,9],[10,11,12]]]))
Out[49]: 81