Easy way to measure cell runtime in ipython laptop

Question

I would like to get the time spent executing the cell, in addition to the original output from the cell.

To this end, I tried %%timeit -r1 -n1 , but did not find a variable defined inside the cell.

%%time works for a cell that contains only 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 

What is the best way to do this?

Update

I have been using Run Time at Nbextension for quite some time now. It's great.

Answer 1

Use cell magic and this Phillip Cloud github project:

Download it by placing it on the top of your laptop, or put it in your configuration file if you always want to download it by default:

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

When loading, each output of the subsequent execution of the cell will include the time in min and second that it takes to complete it.

Answer 2

The only way I found to overcome this problem is to execute the last statement with print.

Remember that cell magic starts with %% and row magic starts with % .

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

Please note that any changes made inside the cell are not taken into account in the following cells, which is counterintuitive if there is a pipeline:

Answer 3

%time and %timeit now part of the ipython built-in magic commands

Answer 4

An easier way is to use the ExecuteTime plugin in the jupyter_contrib_nbextensions package.

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

Answer 5

I just added %%time at the beginning of the cell and got the time. You can use the same in Jupyter Spark cluster / Virtual environment using the same. Just add %%time at the top of the cell and you will get the result. On a spark cluster using Jupyter I added to the top of the cell and I got the output as shown below: -

 [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 

Answer 6

Sometimes cell formatting is different when using print(res) , but jupyter / ipython comes with display . See an example of the difference in formatting using pandas below.

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

The display statement can save formatting.

Answer 7

It is not quite beautiful, but without additional software

 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)) 

Then you can run it like:

 with timeit(): # your code, eg, print(sum(range(int(1e7)))) % 49999995000000 % runtime: 0:00:00.338492 

Answer 8

For this you can use the magic function timeit .

 %timeit CODE_LINE 

Or in camera

 %%timeit SOME_CELL_CODE 

Check out more IPython magic features at https://nbviewer.jupyter.org/github/ipython/ipython/blob/1.x/examples/notebooks/Cell%20Magics.ipynb

Answer 9

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

Answer 10

you might also want to take a look at python profiling magic command %prun which gives something like:

 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 

then

 %prun sum_of_lists(1000000) 

will be back

 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} 

I find this useful when working with large chunks of code.

Answer 11

When in trouble, which means that:

?%timeit or ??timeit

For details:

 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.