भाषा का उपयोग करते हुए पायथन कोड को गति देना

कोई फर्क नहीं पड़ता कि पायथन कितना अच्छा है, यह सभी डेवलपर्स के लिए ज्ञात एक समस्या है - गति। इस विषय पर कई लेख लिखे गए, जिनमें हैबे भी शामिल है ।


सबसे अधिक बार, वे निम्नलिखित समाधान प्रदान करते हैं:

• मानस का प्रयोग करें
• पायथन सी एक्सटेंशन्स का उपयोग करते हुए सी प्रोग्राम का हिस्सा रीराइट करें
• ब्रेन एलगोरिदम बदलें

बेशक, फैसले सही हैं। लेकिन उनमें से प्रत्येक में इसकी कमियां हैं।
साइको एक अद्भुत मॉड्यूल है जो सैकड़ों प्रतिशत के कोड त्वरण को प्राप्त करता है, लेकिन: केवल 32-बिट पायथन संस्करण 2.6 से अधिक समर्थित नहीं हैं, उच्च मेमोरी खपत और तथ्य यह है कि मानस विकास हाल ही में धीमा हो गया है, साइट पर नवीनतम अद्यतन 16 जुलाई 2010 को दिनांकित है। शायद साइको वी 2 के रिलीज के साथ स्थिति बदल जाएगी, लेकिन अभी तक, यह मॉड्यूल हमेशा लागू नहीं होता है।
पायथन सी एक्सटेंशन्स (मैं रशमैन द्वारा एक उत्कृष्ट लेख की सिफारिश करता हूं। हम सी में पायथन के लिए एक विस्तार मॉड्यूल लिख रहे हैं ) - पायथन के रचनाकारों ने इस भाषा का उपयोग करने वाले सभी डेवलपर्स को एक अमूल्य उपहार दिया - पायथन / सी एपीआई, जो पायथन कार्यक्रमों में सी-कोड के अपेक्षाकृत पारदर्शी एकीकरण को सक्षम करता है। 'ई। इस समाधान में केवल दो कमियां हैं:

1. सी और पायथन / सी एपीआई के लिए "एंट्री थ्रेशोल्ड" अभी भी "नंगे" पायथन की तुलना में अधिक है, जो सी के साथ परिचित नहीं डेवलपर्स के लिए इस विकल्प को काट देता है।
2. पायथन की प्रमुख विशेषताओं में से एक विकास गति है। C प्रोग्राम का हिस्सा लिखना पूरे प्रोग्राम के लिए C में दोबारा लिखे गए कोड के हिस्से के अनुपात में इसे कम करता है

तो, यह विधि भी सभी के लिए उपयुक्त नहीं है।
एल्गोरिथ्म परिवर्तन हमेशा संभव नहीं होता है, स्थितियां अक्सर होती हैं कि सबसे तेज़ एल्गोरिथम निराशाजनक गति परिणाम उत्पन्न करता है।

तो क्या करें?

फिर, यदि उपरोक्त विधियां आपके प्रोजेक्ट के लिए काम नहीं करती हैं, तो मुझे क्या करना चाहिए? पायथन को दूसरी भाषा में बदलें? नहीं, आप हार नहीं मान सकते। हम कोड को ही ऑप्टिमाइज़ करेंगे। दिए गए आकार के पुनरावृत्तियों के साथ दिए गए आकार के मैंडेलब्रोट सेट के निर्माण के लिए एक कार्यक्रम से उदाहरण लिया जाएगा।
600 * 600 पिक्सेल, 100 पुनरावृत्तियों के साथ मूल संस्करण का ऑपरेटिंग समय 3.07 सेकंड था, हम इस मान को 100% के रूप में लेंगे

मैं पहले से कहूंगा कि अनुकूलन का हिस्सा इस तथ्य को जन्म देगा कि कोड कम पायथोनिक हो जाएगा, मुझे अजगर-तरह के अनुयायियों को माफ कर दें।

स्टेप 0. मुख्य प्रोग्राम कोड को अलग से हटाना

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

for Y in xrange(height): for X in xrange(width): #   (X,Y)   , itt  

फिर, इसे बदलकर:

 def mandelbrot(height, itt, width): for Y in xrange(height): for X in xrange(width): #   (X,Y)   , itt  mandelbrot(height, itt, width) 

हमें 2.4 सेकंड का समय मिला, अर्थात मूल का 78% ।

चरण 1. प्रोफाइलिंग

पायथन मानक पुस्तकालय उपयोगी मॉड्यूल का सिर्फ क्लोंडाइक है। अब हम cProfile मॉड्यूल में रुचि रखते हैं, जिसके कारण, कोड को प्रोफाइल करना सरल और यहां तक ​​कि दिलचस्प हो जाता है।
इस मॉड्यूल पर पूर्ण दस्तावेज़ीकरण यहां पाया जा सकता है , हमारे लिए कुछ सरल कमांड पर्याप्त हैं।

python -m cProfile sample.py
-M दुभाषिया स्विच आपको मॉड्यूल को अलग-अलग कार्यक्रमों के रूप में चलाने की अनुमति देता है, यदि मॉड्यूल स्वयं ऐसा अवसर प्रदान करता है।
इस आदेश का परिणाम कार्यक्रम का "प्रोफाइल" प्राप्त करना होगा - एक तालिका, का
4613944 function calls (4613943 primitive calls) in 2.818 seconds

Ordered by: internal time

ncalls tottime percall cumtime percall filename:lineno(function)
1 2.309 2.309 2.766 2.766 mand_slow.py:22(mandelbrot)
...

इसकी मदद से, उन स्थानों को निर्धारित करना आसान है, जिनके लिए अनुकूलन की आवश्यकता है (ncalls के उच्चतम मूल्यों के साथ लाइनें (फ़ंक्शन कॉल की संख्या), टाइमटाइम और पर्कॉल (इस फ़ंक्शन के लिए सभी कॉल का संचालन समय और प्रत्येक व्यक्ति, क्रमशः)।

सुविधा के लिए, आप -s time को जोड़ सकते हैं, रनटाइम द्वारा प्रोफाइलर आउटपुट को सॉर्ट कर सकते हैं।

मेरे मामले में, आउटपुट का दिलचस्प हिस्सा था (निष्पादन समय ऊपर बताए गए एक से भिन्न होता है, क्योंकि प्रोफाइलर अपने स्वयं के माथे को जोड़ता है):
4613944 function calls (4613943 primitive calls) in 2.818 seconds

Ordered by: internal time

ncalls tottime percall cumtime percall filename:lineno(function)
1 2.309 2.309 2.766 2.766 mand_slow.py:22(mandelbrot)
3533224 0.296 0.000 0.296 0.000 {abs}
360000 0.081 0.000 0.081 0.000 {math.atan2}
360000 0.044 0.000 0.044 0.000 {math.cos}
360000 0.036 0.000 0.036 0.000 {math.sqrt}
...
इसलिए, प्रोफ़ाइल प्राप्त हुई है, अब हम निकटता से अनुकूलन में लगे रहेंगे।

चरण 2. प्रोफ़ाइल विश्लेषण

हम देखते हैं कि समय में पहली जगह हमारा मुख्य कार्य मैंडेलब्रोट है, इसके बाद सिस्टम फ़ंक्शन अनुपस्थित है, इसके बाद गणित मॉड्यूल से कई फ़ंक्शन हैं, फिर न्यूनतम समय की लागत वाले कार्यों के लिए एकल कॉल, हम उनमें रुचि नहीं रखते हैं।

इसलिए, हम समुदाय द्वारा "पाला" जाने वाले सिस्टम फ़ंक्शंस में सुधार करने में सक्षम होने की संभावना नहीं रखते हैं, तो चलिए अपने स्वयं के कोड पर चलते हैं:

चरण 3. मठ

अब, कोड इस तरह दिखता है:

 pix = img.load() #   def mandelbrot(height, itt, width): step_x = (2 - width / 1.29) / (width / 2.6) - (1 - width / 1.29) / (width / 2.6) #    for Y in xrange(height): y = (Y - height / 2) / (width / 2.6) # Y        ,       x = - (width / 1.29) / (width / 2.6) for X in xrange(width): x += step_x z = complex(x, y) phi = math.atan2(y, x - 0.25) p = math.sqrt((x - 0.25) ** 2 + y ** 2) pc = 0.5 - 0.5 * math.cos(phi) if p <= pc: #     -  pix[X, Y] = (255, 255, 255) continue Z_i = 0j for i in xrange(itt): #    " " Z_i = Z_i ** 2 + z if abs(Z_i) > 2: color = (i * 255) // itt pix[X, Y] = (color, color, color) break else: pix[X, Y] = (255, 255, 255) print("\r%d/%d" % (Y, height)), 

ध्यान दें कि घातांक ऑपरेटर ** काफी "सामान्य" है, लेकिन हमें केवल घातांक की आवश्यकता है, अर्थात प्रपत्र x ** 2 के सभी निर्माणों को x * x द्वारा प्रतिस्थापित किया जा सकता है, इस प्रकार थोड़ा और समय प्राप्त किया जा सकता है। आइए समय पर देखें:
1.9 सेकंड , या मूल समय का 62% , केवल दो लाइनों की जगह द्वारा प्राप्त किया जाता है:

 p = math.sqrt((x - 0.25) ** 2 + y ** 2) ... Z_i = Z_i **2 + z 

पर:

 p = math.sqrt((x - 0.25) * (x - 0.25) + y * y) ... Z_i = Z_i * Z_i + z 

चरण 5, 6 और 7. छोटे लेकिन महत्वपूर्ण

सभी पायथन प्रोग्रामर को जो सामान्य सत्य पता है, वह यह है कि वैश्विक चर के साथ काम करना स्थानीय चर के साथ काम करने की तुलना में धीमा है। लेकिन यह तथ्य कि यह न केवल चर के लिए, बल्कि सामान्य रूप से सभी वस्तुओं के लिए भी सच है, अक्सर भुला दिया जाता है। फ़ंक्शन कोड गणित मॉड्यूल से कई कार्यों को कॉल करता है। तो क्यों उन्हें समारोह में ही आयात न करें? द्वारा निर्मित:

 def mandelbrot(height, itt, width): from math import atan2, cos, sqrt pix = img.load() #   

एक और 0.1 सेकंड।
याद रखें कि एब्स (x) कई प्रकार के फ्लोट लौटाएगा। तो यह फ्लोट के साथ तुलना करने के लायक है और इंट नहीं:

 if abs(Z_i) > 2: ------> if abs(Z_i) > 2.0: 

एक और 0.15 सेकेंड। प्रारंभिक समय का 53% ।

और अंत में, एक गंदा हैक।
इस विशेष कार्य में, यह समझा जा सकता है कि छवि का निचला आधा ऊपरी के बराबर है, अर्थात। गणना की संख्या को आधा किया जा सकता है, जिसके परिणामस्वरूप कुल 0.84 सेकंड या मूल समय का 27% है।

निष्कर्ष

रूपरेखा। समय का सदुपयोग करें। अनुकूलन। पायथन एक शक्तिशाली भाषा है, और इस पर कार्यक्रम सबकुछ समझने और चमकाने की आपकी इच्छा के समानुपाती गति से काम करेंगे :)
इस लेख का उद्देश्य यह दिखाना है कि छोटे और छोटे बदलावों के कारण, जैसे कि ** के साथ ** की जगह, आप C, या मानस शैमैनवाद के रूप में भारी तोपखाने के उपयोग के बिना हरे सांप को दो गुना तेजी से क्रॉल कर सकते हैं।
इसके अलावा, आप विभिन्न उपकरणों को जोड़ सकते हैं, जैसे कि उपरोक्त अनुकूलन और मानस मॉड्यूल, यह खराब नहीं होगा :)

अंत तक पढ़ने वाले सभी के लिए धन्यवाद, मुझे आपकी राय और टिप्पणियों को सुनने में खुशी होगी!

यूपीडी कवक द्वारा उद्धृत टिप्पणियों में उपयोगी लिंक ।