EDIT:
Je exécutez à nouveau le code sous Windows 7 64 bits (Intel Core i7 930 @ 3.8 GHz).
Encore une fois, le code est:
from datetime import datetime
import numpy as np
START_TIME = datetime.now()
# one of the following lines is uncommented before execution
#s = np.float64(1)
#s = np.float32(1)
#s = 1.0
for i in range(10000000):
s = (s + 8) * s % 2399232
print(s)
print('Runtime:', datetime.now() - START_TIME)
Les horaires sont les suivants:
- float64: 16,1 s
- float32: 16,1 s
- float: 3,2 s
Maintenant, les deux np flotteurs (64 ou 32) sont 5 fois plus lente que dans le haut- float. Encore, une différence significative. Je suis à essayer de comprendre d'où il vient.
EDIT:
Merci pour les réponses, elles m'aident à comprendre la façon de traiter ce problème.
Mais j'aimerais connaître la raison précise (basé sur le code source peut-être) pourquoi le code ci-dessous fonctionne 10 fois plus lent avec float64 qu'avec float.
EDIT:
numpy.float64 est 10 fois plus lent que flotter dans les calculs arithmétiques. C'est tellement mauvais que même la conversion de flotter et revenir avant que les calculs rend le programme tourne 3 fois plus vite. Pourquoi? Est-ce que je peux faire pour le réparer?
Je tiens à souligner que mes timings ne sont pas pour les raisons suivantes:
- les appels de fonction
- la conversion entre les numpy et python flotteur
- la création d'objets
J'ai mis à jour mon code pour le rendre plus clair où se trouve le problème. Avec le nouveau code, il semblerait que je vois un dix fois plus de performances de l'utilisation de numpy types de données:
from datetime import datetime
import numpy as np
START_TIME = datetime.now()
# one of the following lines is uncommented before execution
#s = np.float64(1)
#s = np.float32(1)
#s = 1.0
for i in range(10000000):
s = (s + 8) * s % 2399232
print(s)
print('Runtime:', datetime.now() - START_TIME)
Les horaires sont les suivants:
- float64: 34.56 s
- float32: 35.11 s
- float: 3.53 s
Juste pour l'enfer de celui-ci, j'ai aussi essayé:
de datetime import datetime import numpy comme np
START_TIME = datetime.now()
s = np.float64(1)
for i in range(10000000):
s = float(s)
s = (s + 8) * s % 2399232
s = np.float64(s)
print(s)
print('Runtime:', datetime.now() - START_TIME)
Le temps d'exécution est 13.28 s; c'est en fait 3 fois plus rapide pour convertir l' float64 de float et à l'arrière que de l'utiliser comme est. Encore, la conversion prend son péage, de sorte que globalement, c'est plus de 3 fois plus lent par rapport à la pure python float.
Ma machine est:
- Intel Core 2 Duo T9300 (2.5 GHz)
- Windows xp Professionnel (32 bits)
- ActiveState Python 3.1.3.5
- Numpy 1.5.1
FIN DE L'EDIT
QUESTION DE DÉPART:
Je suis vraiment bizarre les horaires pour le code suivant:
import numpy as np
s = 0
for i in range(10000000):
s += np.float64(1) # replace with np.float32 and built-in float
- built-in float: 4.9 s
- float64: 10,5 s
- float32: 45.0 s
Pourquoi est - float64 deux fois plus lent que l' float? Et pourquoi est - float32 5 fois plus lent que float64?
Est-il un moyen d'éviter la sanction de l'utilisation de np.float64, et ont numpy retour des fonctions intégrées en float au lieu de float64?
J'ai trouvé que l'utilisation d' numpy.float64 est beaucoup plus lent que Python flottant, et numpy.float32 est encore plus lente (même si je suis sur une machine 32 bits).
numpy.float32 sur ma machine 32 bits. Par conséquent, chaque fois que je utiliser diverses fonctions de numpy comme numpy.random.uniform,- je convertir le résultat en float32 (ainsi que d'autres opérations pourraient être effectuées à 32 bits de précision).
Est-il possible de définir une variable unique, quelque part dans le programme ou dans la ligne de commande, et de faire toutes les fonctions de numpy retour float32 au lieu de float64?
