न्यूनतम रैम लोड के साथ जटिल कंप्यूटिंग को गति दें

पायथन में मास्टर एमएल, सीएनएन, एनएन की प्रक्रिया में, एक नौसिखिया लगभग हमेशा गणना की गति की समस्या का सामना करता है, और कभी-कभी रैम की कमी होती है।

यह विशेष रूप से बड़े डेटाबेस के साथ ध्यान देने योग्य है, जो आकार में 50% से अधिक मुक्त रैम हैं। अधिक सभ्य लोहा खरीदने के बारे में विचार संभव समाधानों में से एक है।

पायथन में सुविधाओं में से एक का उपयोग करने का एक और विकल्प स्वयं फ़ंक्शन पर चलना है।

एक सरल और उदाहरणात्मक उदाहरण। मान लें कि आपको 200,000 डिग्री में 1 से 10 तक की संख्या बनाने और उनकी राशि जोड़ने की आवश्यकता है। नतीजतन, आपको एक संख्या मिलनी चाहिए जो 200 हजार वर्णों की लंबी हो। यह Google से 2 गुना अधिक है )

यहाँ इस तरह के एक समारोह के लिए एक सरल कोड है:

from time import time #    #      def power_1(x): power_1 = 0 start = time() power_1 = x**200000 end = time() total_1 = end - start return round(total_1,6) #   ,         power_1(1) + power_1(2) + power_1(3) + power_1(4) + power_1(5) + power_1(6) + power_1(7) + power_1(8) \ + power_1(9) + power_1(10) 

नतीजतन, हमें आपके कंप्यूटर के लिए एक काफी "महंगा" ऑपरेशन मिलता है, और उदाहरण के लिए, यह मेरे लिए 13 से अधिक एमएस लेता है। लेकिन क्या होगा अगर ऐसे कई ऑपरेशन हो सकते हैं? तब सब कुछ जटिल हो जाता है, और शायद आपके पास पर्याप्त रैम नहीं है।

लेकिन आप चालबाज हो सकते हैं और अपने चर के माध्यम से पुनरावृत्ति करके सटीक समान फ़ंक्शन का उपयोग कर सकते हैं।

यहाँ एक ही फ़ंक्शन के ऐसे सरल समाधान के लिए कोड है:

 from time import time #   #   def power_2(): for i in range(11): yield i #     for i in power_2(): if i < 11: d = 0 total_2 = 0 start = time() d += i**200000 end = time() total_2 += end - start print('Ineration {} lasts {}'.format(i, round(total_2, 6))) if i == 10: print(' \n End with total time {} \n'.format(round(total_2,3))) 

मेरे कंप्यूटर पर समय बिताया



अंतर 0.13 - 0.024 = 0.106 एमएस है!


यदि कोई सामान्य रूप से इस विशाल संख्या में 1 जोड़ देता है, तो यह 200,000 डिग्री तक खुद को बढ़ाने की तुलना में अधिक समय लेगा। यही है, इस पद्धति के फायदे स्पष्ट हैं।

 def add_one(x): total_3 = 0 start = time() s = x + 1 end = time() total_3 += end - start print('Time to do add 1 to BIG number: {} \n'.format(total_3)) return print('Difference in time {}\n'.format(round(total_2 - total_3 ,3))) add_one(d) print('The size of the number {}!!!'.format(len(str(d)))) 

परिणाम यह है:



ऐसा क्यों? जहां तक ​​मुझे पता है, जब किसी फंक्शन से अधिक परेशान होने पर, पायथन मेमोरी में अस्थायी ऑब्जेक्ट नहीं बनाता है, जो बदले में किसी भी गणना प्रक्रिया को तेज करता है। इसलिए, फ़ंक्शन को इस तरह से फिर से लिखना - आप समय और तंत्रिकाओं को बचाते हैं।

कुल - एक सीमित रैम आकार के साथ जटिल गणना के लिए, केवल एक फ़ंक्शन की तुलना में फ़ंक्शन पर पुनरावृत्ति का उपयोग करना बेहतर है।

मुझे उम्मीद है कि इससे किसी को कीमती मिनट न खोने या अतिरिक्त, तेजी से उम्र बढ़ने के हार्डवेयर पर खर्च न करने में मदद मिलेगी।

एक व्याख्यान से प्रेरित