Moyen Simple de mesurer le temps d'exécution des cellules dans IPython notebook
Je voudrais obtenir le temps passé sur l'exécution de la cellule en plus de la sortie originale de la cellule.
À cette fin, j'ai essayé %%timeit -r1 -n1 mais cela n'expose pas la variable définie dans la cellule.
%%time fonctionne pour la cellule qui ne contient que 1 instruction.
In[1]: %%time
1
CPU times: user 4 µs, sys: 0 ns, total: 4 µs
Wall time: 5.96 µs
Out[1]: 1
In[2]: %%time
# Notice there is no out result in this case.
x = 1
x
CPU times: user 3 µs, sys: 0 ns, total: 3 µs
Wall time: 5.96 µs
Quelle est la meilleure façon de le faire?
Mettre à jour
J'utilise Execute Time dans Nbextension depuis un certain temps maintenant. Il est grand.
8 réponses
Utilisez cell magic et ce projet sur Github par Phillip Cloud:
Charge de la mettre en haut de votre ordinateur portable ou de le mettre dans votre fichier de configuration, si vous souhaitez toujours le charger par défaut:
%install_ext https://raw.github.com/cpcloud/ipython-autotime/master/autotime.py
%load_ext autotime
Si elle est chargée, chaque sortie de l'exécution de la cellule suivante inclura le temps en min et sec nécessaire pour l'exécuter.
La seule façon que j'ai trouvée pour surmonter ce problème est d'exécuter la dernière instruction avec print.
N'oubliez pas que cellule magie commence avec %% et ligne magie commence avec %.
%%time
clf = tree.DecisionTreeRegressor().fit(X_train, y_train)
res = clf.predict(X_test)
print(res)
J'ai simplement ajouté %%time au début de la cellule et le temps. Vous pouvez utiliser la même chose sur Jupyter Spark cluster / environnement virtuel en utilisant la même chose. Juste ajouter %%time en haut de la cellule et vous obtiendrez la sortie. Sur spark cluster en utilisant Jupyter, j'ai ajouté au sommet de la cellule et j'ai obtenu une sortie comme ci - dessous: -
[1] %%time
import pandas as pd
from pyspark.ml import Pipeline
from pyspark.ml.classification import LogisticRegression
import numpy as np
.... code ....
Output :-
CPU times: user 59.8 s, sys: 4.97 s, total: 1min 4s
Wall time: 1min 18s
Un moyen plus simple est d'utiliser le plugin ExecuteTime dans le paquet jupyter_contrib_nbextensions.
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
jupyter nbextension enable execute_time/ExecuteTime
Ce n'est pas exactement beau mais sans logiciel supplémentaire
class timeit():
from datetime import datetime
def __enter__(self):
self.tic = self.datetime.now()
def __exit__(self, *args, **kwargs):
print('runtime: {}'.format(self.datetime.now() - self.tic))
Ensuite, vous pouvez l'exécuter comme:
with timeit():
# your code, e.g.,
print(sum(range(int(1e7))))
% 49999995000000
% runtime: 0:00:00.338492
Parfois, le formatage est différent dans une cellule lors de l'utilisation de print(res), mais jupyter/ipython est livré avec un display. Voir un exemple de la différence de formatage en utilisant pandas ci-dessous.
%%time
import pandas as pd
from IPython.display import display
df = pd.DataFrame({"col0":{"a":0,"b":0}
,"col1":{"a":1,"b":1}
,"col2":{"a":2,"b":2}
})
#compare the following
print(df)
display(df)
L'instruction display peut conserver la mise en forme.
Vous pouvez également regarder dans la commande magique de profilage de python %prun qui donne quelque chose comme -
def sum_of_lists(N):
total = 0
for i in range(5):
L = [j ^ (j >> i) for j in range(N)]
total += sum(L)
return total
Alors
%prun sum_of_lists(1000000)
Retourne
14 function calls in 0.714 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
5 0.599 0.120 0.599 0.120 <ipython-input-19>:4(<listcomp>)
5 0.064 0.013 0.064 0.013 {built-in method sum}
1 0.036 0.036 0.699 0.699 <ipython-input-19>:1(sum_of_lists)
1 0.014 0.014 0.714 0.714 <string>:1(<module>)
1 0.000 0.000 0.714 0.714 {built-in method exec}
Je trouve cela utile lorsque je travaille avec de gros morceaux de code.