Prosty sposób pomiaru czasu wykonania komórki w notebooku ipython

Jedynym sposobem na rozwiązanie tego problemu jest wykonanie ostatniej instrukcji za pomocą print.

Nie zapominaj, że Magia komórek zaczyna się od %%, A magia linii zaczyna się od %.

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

%time i %timeit teraz dołącz do wbudowanych poleceń magicznych ipythona

Po prostu dodałem %%time na początku komórki i dostałem czas. Możesz użyć tego samego w klastrze / środowisku wirtualnym Jupyter Spark używając tego samego. Po prostu dodaj %%time na górze komórki, a otrzymasz wynik. Na klastrze spark używającym Jupyter, dodałem do górnej części komórki i dostałem wyjście jak poniżej: -

[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

Łatwiejszym sposobem jest użycie wtyczki ExecuteTime w pakiecie jupyter_contrib_nbextensions.

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

To nie jest do końca piękne, ale bez dodatkowego oprogramowania

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

Następnie można uruchomić go jak:

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

% 49999995000000
% runtime: 0:00:00.338492

Czasami formatowanie jest INNE w komórce przy użyciu print(res), ale jupyter / ipython jest wyposażony w display. Zobacz przykład różnicy formatowania przy użyciu pand poniżej.

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

Instrukcja display może zachować formatowanie.

Możesz również zajrzeć do magicznego polecenia profilowania Pythona %prun, które daje coś w rodzaju -

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

Wtedy

%prun sum_of_lists(1000000)

Powróci

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}

Uważam, że jest to przydatne podczas pracy z dużymi kawałkami kodu.