web-dev-qa-db-fra.com

Un 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 d'origine de la cellule.

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

%%time fonctionne pour une cellule qui ne contient qu'une 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?

Mise à jour

J'utilise Execute Time in Nbextension depuis un certain temps maintenant. C'est super.

pythonipythonipython-notebookjupyter
128
colinfang

Utilisez la magie des cellules et ce projet sur github de Phillip Cloud:

Chargez-le en le mettant en haut de votre bloc-notes ou 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

Si elle est chargée, chaque sortie de l’exécution de la cellule suivante inclura le temps en minutes et en secondes qu’il a fallu pour l’exécuter.

29
Philipp Schwarz

Le seul moyen que j'ai trouvé pour résoudre ce problème consiste à exécuter la dernière instruction avec print.

N'oubliez pas cela la magie des cellules 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 existe un pipeline: an example

342
Salvador Dali

%time et %timeit font maintenant partie de la commande intégrée d'ipython commandes magiques

48
ryanmc

Un moyen plus simple consiste à utiliser le plug-in ExecuteTime dans le package jupyter_contrib_nbextensions.

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

J'ai simplement ajouté %%time au début de la cellule et j'ai eu le temps. Vous pouvez utiliser le même système sur Jupyter Spark cluster/environnement virtuel. Ajoutez simplement %%time en haut de la cellule et vous obtiendrez la sortie. Sur le cluster spark 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
11
Harry_pb

Parfois, la mise en forme est différente dans une cellule lorsque vous utilisez print(res), mais jupyter/ipython est fourni avec un display. Voir un exemple de 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 préserver la mise en forme. screenshot

7
blehman

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 le lancer comme:

with timeit():
    # your code, e.g., 
    print(sum(range(int(1e7))))

% 49999995000000
% runtime: 0:00:00.338492
6
eafit
import time
start = time.time()
"the code you want to test stays here"
end = time.time()
print(end - start)
2
mina

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

ensuite

%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.

1
markroxor

Vous pouvez utiliser la fonction magique timeit 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

1
Mostafa Gazar

En cas de problème, qu'est-ce que 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.
0
prosti