आईपीथॉन नोटबुक में सेल निष्पादन समय को मापने का सरल तरीका

Question

मैं सेल से मूल आउटपुट के अलावा सेल के निष्पादन पर लगने वाले समय को प्राप्त करना चाहूंगा।

यह अंत करने के लिए, मैंने कोशिश की %%timeit -r1 -n1लेकिन यह सेल के भीतर परिभाषित चर को उजागर नहीं करता है।

%%time सेल के लिए काम करता है जिसमें केवल 1 स्टेटमेंट होता है।

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

इसे करने का सबसे अच्छा तरीका क्या है?

अपडेट करें

मैं काफी समय से Nbextension में Execute Time का उपयोग कर रहा हूं । यह बहुत अच्छा है।

Comments

क्या आपको वास्तव में मूल्य के प्रदर्शन की आवश्यकता है? सिर्फ xअगली सेल में डिस्प्ले लाइन क्यों नहीं लगाई जाती?

— dbliss

एक उत्तर क्यों नहीं स्वीकार कर रहे हैं?

— रतीरु

Answer 1

फ़िलिप क्लाउड द्वारा सेल मैजिक और इस प्रोजेक्ट को गीथूब पर प्रयोग करें:

इसे अपनी नोटबुक के शीर्ष पर रखकर लोड करें या यदि आप इसे हमेशा डिफ़ॉल्ट रूप से लोड करना चाहते हैं, तो इसे अपनी कॉन्फ़िग फ़ाइल में रखें:

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

यदि लोड किया जाता है, तो बाद के सेल निष्पादन के प्रत्येक आउटपुट में न्यूनतम समय शामिल होगा और इसे निष्पादित करने के लिए लिया गया सेक।

Comments

यह अब काम नहीं करता है, क्योंकि% install_ext को पदावनत कर दिया गया है। क्या कोई विकल्प है?

— आंखों की रोशनी LLC

इस मुद्दे को pip install ipython-autotime

— स्वीकार

अब %%timeतब भी काम करता है जब अंतिम कथन नहीं होता है print।

— रोप्स ०

Answer 2

इस समस्या को दूर करने का एकमात्र तरीका मुझे प्रिंट के साथ अंतिम विवरण को निष्पादित करना है।

यह मत भूलो कि सेल मैजिक से शुरू होता है %%और लाइन मैजिक से शुरू होता है %।

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

ध्यान दें कि सेल के अंदर किए गए किसी भी परिवर्तन को अगली कोशिकाओं में ध्यान में नहीं रखा जाता है, कुछ ऐसा है जो एक पाइपलाइन होने पर सहज है।

Comments

अब %% समय तब भी काम करता है जब अंतिम विवरण प्रिंट नहीं होता है, जैसा कि @ reps0dy ने ऊपर बताया है।

— nealmcb

प्रदर्शन (रेस) भी काम करता है और एक पसंदीदा समाधान है जब एक पैंडास डेटाफ्रेम या कुछ और प्रदर्शित करने की कोशिश की जाती है जिसमें स्टाइल आउटपुट की आवश्यकता होती है।

— dshefman

@dshefman हाँ जो सही है और यह डेटाब्रीक / स्पार्क नोटबुक के लिए भी आसान पोर्टेबल बनाता है।

— टेक्नाज़ी

क्या यह कोई समस्या नहीं है जब हम 1 सेल को लागू करते हैं %%timeऔर a=1दूसरा सेल यह नहीं जानता है कि क्या aहै?

— जेसन

FYI करें। मैंने पाया कि परीक्षण किए गए सेल में चर अब अगली कोशिकाओं में विचार किए जाते हैं। (20/02/2020) - फी

— फी याओ

Answer 3

%timeऔर %timeitअब ipython के बिल्ट-इन मैजिक कमांड का हिस्सा आते हैं

Answer 4

एक आसान तरीका यह है कि jupyter_contrib_nbextensions पैकेज में ExecuteTime प्लगइन का उपयोग किया जाए।

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

Comments

यह सबसे कम जवाब है!

— डेवआर

किसी ने डाइविंग के माध्यम से जवाब दिया समुद्र: यह एक है, बस इसे स्थापित करें और फिर आप प्रत्येक सेल पर एक अच्छा प्रारूप में निष्पादन का समय देखेंगे

— एल पोचो ला पैन्टर

Answer 5

मैंने बस %%timeसेल की शुरुआत में जोड़ा और समय मिला। आप उसी का उपयोग करके ज्यूपिटर स्पार्क क्लस्टर / वर्चुअल वातावरण पर समान का उपयोग कर सकते हैं। बस %%timeसेल के शीर्ष पर जोड़ें और आपको आउटपुट मिलेगा। ज्यूपिटर का उपयोग करते हुए स्पार्क क्लस्टर पर, मैंने सेल के शीर्ष पर जोड़ा और मुझे नीचे जैसा आउटपुट मिला:

[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

Comments

क्या यह सेल कोड को डिफॉल्ट नं। समय और फिर औसत लेता है? और 'सेटअप कोड' के रूप में पहले बयान के बारे में क्या?

— amsquareb

Answer 6

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

Comments

उत्तम। यह %% समय से वस्तु को संरक्षित करने और अगले सेल में उपयोग करने के लिए बहुत अधिक परेशानी है

— पॉल

Answer 7

आप उसके लिए timeitमैजिक फंक्शन का उपयोग कर सकते हैं ।

%timeit CODE_LINE

या सेल पर

%%timeit 

SOME_CELL_CODE

Https://nbviewer.jupyter.org/github/ipython/ipython/blob/1.x/examples/notebooks/Cell%20Micics.ipynb पर अधिक IPython मैजिक फ़ंक्शन देखें

Answer 8

यह बिल्कुल सुंदर नहीं है, लेकिन अतिरिक्त सॉफ्टवेयर के बिना

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

तब आप इसे चला सकते हैं जैसे:

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

% 49999995000000
% runtime: 0:00:00.338492

Answer 9

कभी-कभी उपयोग करते समय एक सेल में स्वरूपण अलग होता है print(res), लेकिन ज्यूपिटर / आईपिथॉन एक के साथ आता है display। नीचे दिए गए पांडा के उपयोग से प्रारूपण अंतर का एक उदाहरण देखें।

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

displayबयान स्वरूपण रक्षा कर सकते हैं।

Comments

क्या यह सेल कोड को डिफॉल्ट नं। समय और फिर औसत लेता है? और 'सेटअप कोड' के रूप में पहले बयान के बारे में क्या?

— amsquareb

Answer 10

आप भी अजगर की प्रोफाइलिंग मैजिक कमांड को देखना चाह सकते हैं %prunजो कुछ इस तरह देता है -

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

फिर

%prun sum_of_lists(1000000)

वापस होगा

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}

कोड के बड़े हिस्से के साथ काम करने पर मुझे यह उपयोगी लगता है।

Answer 11

जब मुसीबत में क्या मतलब है:

?%timeit या ??timeit

विवरण प्राप्त करने के लिए:

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 12

यदि आप दीवार सेल निष्पादन समय प्रिंट करना चाहते हैं तो यहां एक चाल है, उपयोग करें

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

लेकिन यहाँ सुनिश्चित करें कि, %% समय एक जादू का कार्य है, इसलिए इसे अपने कोड में पहली पंक्ति में रखें ।

यदि आप इसे अपने कोड की कुछ लाइन के बाद डालते हैं, तो यह आपको उपयोग त्रुटि देने वाला है और काम नहीं करने वाला है।