programar - Manera simple de medir el tiempo de ejecución de la celda en el cuaderno de ipython

manual de python en jupyter notebook

Question

Me gustaría obtener el tiempo dedicado a la ejecución de la celda además de la salida original de la celda.

Con este fin, probé %%timeit -r1 -n1 pero no expone la variable definida dentro de la celda.

%%time funciona para la celda que solo contiene 1 declaración.

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

¿Cuál es la mejor manera de hacerlo?

Actualizar

He estado usando Execute Time en Nbextension desde hace bastante tiempo. Eso es genial.

Answer 1

A veces, el formato es diferente en una celda cuando se usa print(res) , pero jupyter / ipython viene con una display . Vea un ejemplo de la diferencia de formato usando pandas a continuación.

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

La declaración de display puede preservar el formato.

Answer 2

Cuando está en problemas, qué significa qué:

?%timeit o ??timeit

Para obtener los detalles:

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.

Answer 3

Esto no es exactamente hermoso pero sin software adicional

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

Entonces puedes ejecutarlo como:

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

% 49999995000000
% runtime: 0:00:00.338492

Answer 4

La única forma en que encontré superar este problema es ejecutando la última declaración con print.

No olvides que la magia celular comienza con %% y la magia de línea comienza con % .

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

Tenga en cuenta que los cambios realizados dentro de la celda no se tienen en cuenta en las siguientes celdas, algo que es contrario a la intuición cuando hay una tubería:

Answer 5

Puedes usar la función mágica timeit para eso.

%timeit CODE_LINE

O en la celda

%%timeit SOME_CELL_CODE

Verifique más funciones mágicas de IPython en https://nbviewer.jupyter.org/github/ipython/ipython/blob/1.x/examples/notebooks/Cell%20Magics.ipynb

Answer 6

Simplemente agregué %%time al comienzo de la celda y obtuve el tiempo. Puede usar lo mismo en el clúster Jupyter Spark / entorno virtual con el mismo. Simplemente agregue %%time en la parte superior de la celda y obtendrá el resultado. En el grupo de chispas con Jupyter, agregué a la parte superior de la celda y obtuve la salida como a continuación: -

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

Una forma más fácil es usar el complemento ExecuteTime en el paquete jupyter_contrib_nbextensions.

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

Answer 8

Usa la magia celular y este proyecto en github por Phillip Cloud:

Cárguelo poniéndolo en la parte superior de su computadora portátil o póngalo en su archivo de configuración si siempre desea cargarlo de manera predeterminada:

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

Si se carga, cada salida de la ejecución posterior de la celda incluirá el tiempo en minutos y segundos que tardó en ejecutarse.

Answer 9

también es posible que desee ver el comando mágico de perfil de python %prun que da algo como:

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

entonces

%prun sum_of_lists(1000000)

volverá

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}

Me resulta útil cuando trabajo con grandes fragmentos de código.

Answer 10

%time y %timeit ahora forman parte de los comandos mágicos incorporados de ipython

Answer 11

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