La différence de performance entre numpy et matlab

Il serait faux de dire que "Matlab est toujours plus rapide que NumPy" ou vice
versa. Souvent, leurs performances sont comparables. Lors de l'utilisation de NumPy, pour obtenir de bons
la performance que vous devez garder à l'esprit que NumPy la vitesse vient d'appeler
sous-jacent de fonctions écrites en C/C++/Fortran. Il fonctionne bien lorsque vous appliquez
ces fonctions pour l'ensemble des tableaux. En général, vous obtenez la dégradation des performances lorsque vous appelez ces NumPy fonction sur les petits groupes ou les scalaires dans une boucle Python.

Quel est le problème avec une boucle Python vous demandez-vous? Chaque itération de la boucle Python est
un appel à une next méthode. Chaque utilisation de [] l'indexation est un appel à une
__getitem__ méthode. Chaque += est un appel à __iadd__. Tous les pointillés de l'attribut
de recherche (par exemple comme dans le np.dot) implique des appels de fonction. Ces appels de fonction
ajouter jusqu'à une importante hinderance à la vitesse. Ces crochets donner Python
la puissance expressive -- indexation pour les chaînes signifie quelque chose de différent que l'indexation
pour les dicts par exemple. Même syntaxe, des significations différentes. La magie est accompli en donnant les objets différents __getitem__ méthodes.

Mais que la puissance expressive arrive à un coût de vitesse. Ainsi, lorsque vous n'avez pas besoin de toutes les
cette dynamique de l'expressivité, pour obtenir de meilleures performances, essayez de vous limiter à
NumPy appels de fonction sur l'ensemble des tableaux.

Retirez la boucle for; utiliser "vectorisé" équations lorsque cela est possible. Par exemple, au lieu de

for i in range(m):
    delta3 = -(x[i,:]-a3[i,:])*a3[i,:]* (1 - a3[i,:])    

vous pouvez calculer delta3 pour chaque i tout à la fois:

delta3 = -(x-a3)*a3*(1-a3)

Alors que dans le for-loop delta3 est un vecteur, à l'aide de la vectorisé équation delta3 est une matrice.

---

Certains des calculs dans le for-loop ne dépendent pas de i et, par conséquent, doit être soulevée à l'extérieur de la boucle. Par exemple, sum2 ressemble à une constante:

sum2 = sparse.beta*(-float(sparse.rho)/rhoest + float(1.0 - sparse.rho) / (1.0 - rhoest) )

---

Ici est un exécutable exemple avec une variante de mise en œuvre (alt) de votre code (orig).

Mon timeit de référence montre une 6.8 x amélioration de la vitesse:

In [52]: %timeit orig()
1 loops, best of 3: 495 ms per loop

In [53]: %timeit alt()
10 loops, best of 3: 72.6 ms per loop

---

import numpy as np
class Bunch(object):
""" http://code.activestate.com/recipes/52308 """
def __init__(self, **kwds):
self.__dict__.update(kwds)
m, n, p = 10 ** 4, 64, 25
sparse = Bunch(
theta1=np.random.random((p, n)),
theta2=np.random.random((n, p)),
b1=np.random.random((p, 1)),
b2=np.random.random((n, 1)),
)
x = np.random.random((m, n))
a3 = np.random.random((m, n))
a2 = np.random.random((m, p))
a1 = np.random.random((m, n))
sum2 = np.random.random((p, ))
sum2 = sum2[:, np.newaxis]
def orig():
partial_j1 = np.zeros(sparse.theta1.shape)
partial_j2 = np.zeros(sparse.theta2.shape)
partial_b1 = np.zeros(sparse.b1.shape)
partial_b2 = np.zeros(sparse.b2.shape)
delta3t = (-(x - a3) * a3 * (1 - a3)).T
for i in range(m):
delta3 = delta3t[:, i:(i + 1)]
sum1 = np.dot(sparse.theta2.T, delta3)
delta2 = (sum1 + sum2) * a2[i:(i + 1), :].T * (1 - a2[i:(i + 1), :].T)
partial_j1 += np.dot(delta2, a1[i:(i + 1), :])
partial_j2 += np.dot(delta3, a2[i:(i + 1), :])
partial_b1 += delta2
partial_b2 += delta3
# delta3: (64, 1)
# sum1: (25, 1)
# delta2: (25, 1)
# a1[i:(i+1),:]: (1, 64)
# partial_j1: (25, 64)
# partial_j2: (64, 25)
# partial_b1: (25, 1)
# partial_b2: (64, 1)
# a2[i:(i+1),:]: (1, 25)
return partial_j1, partial_j2, partial_b1, partial_b2
def alt():
delta3 = (-(x - a3) * a3 * (1 - a3)).T
sum1 = np.dot(sparse.theta2.T, delta3)
delta2 = (sum1 + sum2) * a2.T * (1 - a2.T)
# delta3: (64, 10000)
# sum1: (25, 10000)
# delta2: (25, 10000)
# a1: (10000, 64)
# a2: (10000, 25)
partial_j1 = np.dot(delta2, a1)
partial_j2 = np.dot(delta3, a2)
partial_b1 = delta2.sum(axis=1)
partial_b2 = delta3.sum(axis=1)
return partial_j1, partial_j2, partial_b1, partial_b2
answer = orig()
result = alt()
for a, r in zip(answer, result):
try:
assert np.allclose(np.squeeze(a), r)
except AssertionError:
print(a.shape)
print(r.shape)
raise

---

Astuce: Avis que j'ai laissé dans les commentaires de la forme de tous les tableaux intermédiaires. Connaissant la forme de tableaux m'ont aidé à comprendre ce que votre code a été fait. La forme de tableaux peut aider à vous guider vers la droite NumPy les fonctions à utiliser. Ou au moins, de payer l'attention sur les formes peuvent vous aider à savoir si une opération est sensible. Par exemple, lorsque vous calculez

np.dot(A, B)

et A.shape = (n, m) et B.shape = (m, p), puis np.dot(A, B) sera un tableau de la forme (n, p).

---

Il peut aider à construire les tableaux de C_CONTIGUOUS ordre (au moins, si l'utilisation de np.dot). Il pourrait être l'un de 3x la vitesse par le faire:

Ci-dessous, x est le même que xf sauf que x est C_CONTIGUOUS et
xf est F_CONTIGUOUS -- et la même relation pour y et yf.

import numpy as np
m, n, p = 10 ** 4, 64, 25
x = np.random.random((n, m))
xf = np.asarray(x, order='F')
y = np.random.random((m, n))
yf = np.asarray(y, order='F')
assert np.allclose(x, xf)
assert np.allclose(y, yf)
assert np.allclose(np.dot(x, y), np.dot(xf, y))
assert np.allclose(np.dot(x, y), np.dot(xf, yf))

%timeit benchmarks montrent la différence de vitesse:

In [50]: %timeit np.dot(x, y)
100 loops, best of 3: 12.9 ms per loop
In [51]: %timeit np.dot(xf, y)
10 loops, best of 3: 27.7 ms per loop
In [56]: %timeit np.dot(x, yf)
10 loops, best of 3: 21.8 ms per loop
In [53]: %timeit np.dot(xf, yf)
10 loops, best of 3: 33.3 ms per loop

---

Concernant l'analyse comparative en Python:

Il peut être trompeur à utiliser la différence de paires de time.time() appels à l'indice de référence de la vitesse de code en Python.
Vous devez répéter la mesure à de nombreuses reprises. Il est préférable de désactiver le système automatique de garbage collector. Il est également important de mesurer de grandes périodes de temps (au moins 10 secondes de répétitions) pour éviter des erreurs dues à la mauvaise résolution de l'horloge, de la minuterie et afin de réduire l'importance de time.time appel de surcharge. Au lieu d'écrire tout ce que le code vous-même, Python vous offre la module timeit. Je suis essentiellement en temps les morceaux de code, sauf que je suis en l'appelant par l'intermédiaire d'un IPython terminal pour des raisons de commodité.

Je ne suis pas sûr si cela est touchant tes repères, mais il faut être conscient qu'il pourrait faire une différence. Dans le question j'ai relié à, selon time.time deux morceaux de code diffèrent d'un facteur de 1,7 x alors que les tests utilisant le timeit a montré les morceaux de code a couru pour l'essentiel, les mêmes quantités de temps.

Différence de performance entre les numpy et matlab ont toujours frustré moi. Ils sont souvent dans la fin se résument à la sous-jacentes lapack bibliothèques. Autant que je sache, matlab utilise l'intégralité de l'atlas lapack comme un défaut, tandis que numpy utilise un lapack la lumière. Matlab estime que les gens ne se soucient de l'espace et en vrac, tandis que numpy estime des gens. Question similaire avec une bonne réponse.