Un moyen simple de mesurer le temps d'exécution des cellules dans le notebook ipython

Je voudrais obtenir le temps passé sur l'exécution de la cellule en plus de la sortie d'origine de la cellule.

À cette fin, j'ai essayé %%timeit -r1 -n1mais cela n'expose pas la variable définie dans la cellule.

%%time fonctionne pour la cellule qui ne contient qu'une seule 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. C'est super.

Utilisez la magie cellulaire et ce projet sur github par Phillip Cloud:

Chargez-le en le mettant en haut de votre notebook ou mettez-le dans votre fichier de configuration si vous voulez toujours le charger par défaut:

%install_ext https://raw.github.com/cpcloud/ipython-autotime/master/autotime.py
%load_ext autotime

S'il est chargé, chaque sortie de l'exécution de cellule suivante inclura le temps en minutes et en secondes nécessaire pour l'exécuter.

Le seul moyen que j'ai trouvé pour surmonter ce problème est d'exécuter la dernière instruction avec print.

N'oubliez pas que la magie cellulaire commence par %%et la magie des lignes commence par %.

%%time
clf = tree.DecisionTreeRegressor().fit(X_train, y_train)
res = clf.predict(X_test)
print(res)

Notez que les modifications effectuées à l'intérieur de la cellule ne sont pas prises en compte dans les cellules suivantes, ce qui est contre-intuitif lorsqu'il y a un pipeline:

%timeet %timeitmaintenant font partie des commandes magiques intégrées d'ipython

Un moyen plus simple consiste à utiliser le plugin ExecuteTime dans le package jupyter_contrib_nbextensions.

pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
jupyter nbextension enable execute_time/ExecuteTime

J'ai simplement ajouté %%timeau début de la cellule et j'ai obtenu l'heure. Vous pouvez utiliser le même sur le cluster Jupyter Spark / l'environnement virtuel en utilisant le même. Ajoutez simplement %%timeen haut de la cellule et vous obtiendrez la sortie. Sur le cluster d'étincelles utilisant Jupyter, j'ai ajouté en haut 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

import time
start = time.time()
"the code you want to test stays here"
end = time.time()
print(end - start)

Vous pouvez utiliser timeitla fonction magique pour cela.

%timeit CODE_LINE

Ou sur la cellule

%%timeit 

SOME_CELL_CODE

Vérifiez plus de fonctions magiques IPython sur https://nbviewer.jupyter.org/github/ipython/ipython/blob/1.x/examples/notebooks/Cell%20Magics.ipynb

Ce n'est pas vraiment 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 print(res), mais jupyter / ipython est livré avec un fichier display. Voir un exemple de la différence de formatage à l'aide de 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' displayinstruction peut conserver la mise en forme.

vous pouvez également consulter la commande magique de profilage de python %prunqui 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

puis

%prun sum_of_lists(1000000)

reviendra

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 vous travaillez avec de gros morceaux de code.

En cas de problème, ce qui signifie quoi:

?%timeit ou ??timeit

Pour obtenir les détails:

Usage, in line mode:
  %timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] statement
or in cell mode:
  %%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] setup_code
  code
  code...

Time execution of a Python statement or expression using the timeit
module.  This function can be used both as a line and cell magic:

- In line mode you can time a single-line statement (though multiple
  ones can be chained with using semicolons).

- In cell mode, the statement in the first line is used as setup code
  (executed but not timed) and the body of the cell is timed.  The cell
  body has access to any variables created in the setup code.

Si vous souhaitez imprimer le temps d'exécution de la cellule murale, voici une astuce, utilisez

%%time
<--code goes here-->

mais ici assurez-vous que le temps %% est une fonction magique, alors mettez-le en première ligne dans votre code .

si vous le mettez après une ligne de votre code, cela vous donnera une erreur d'utilisation et ne fonctionnera pas.