पायथन (+ सुब्बा) सी से तेज है - वास्तव में?! भाग 1. सिद्धांत

लंबे समय से मैं सुंबा के बारे में और सी के साथ इसकी गति की तुलना के बारे में एक लेख लिखने जा रहा था। हास्केल लेख " सी ++ की तुलना में तेज़; PHP की तुलना में धीमी "कार्रवाई के लिए धक्का दिया। इस लेख की टिप्पणियों में, उन्होंने सुंबा पुस्तकालय का उल्लेख किया और यह कि यह अजगर में कोड निष्पादन की गति को जादुई रूप से अनुमानित कर सकता है। इस लेख में, सुम्बा (भाग 1) पर एक छोटी समीक्षा के बाद, इस स्थिति का थोड़ा और विस्तृत विश्लेषण ( भाग 2 )।

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

आज तक, अंतिम तीन सबसे अधिक मांग में हैं। Cython (cpython के साथ भ्रमित नहीं होना) - नियमित रूप से अजगर से काफी अलग है। वास्तव में, यह एक अलग भाषा है - सी और अजगर का एक संकर। जैसा कि pypy (jit संकलन का उपयोग करते हुए अजगर अनुवादक का एक वैकल्पिक कार्यान्वयन) और numba (llvm में कोड संकलन के लिए एक पुस्तकालय) के लिए, वे अलग-अलग तरीकों से गए। pypy ने शुरू में सभी अजगर निर्माणों के लिए समर्थन की घोषणा की। सुंबा में, वे इस तथ्य से आगे बढ़े कि इसे अक्सर सीपीयू बाउंड - गणितीय गणनाओं की आवश्यकता होती है, क्रमशः, उन्होंने गणनाओं से जुड़ी भाषा के हिस्से की पहचान की और इसे ओवरक्लॉक करना शुरू कर दिया, धीरे-धीरे "कवरेज" में वृद्धि हुई (उदाहरण के लिए, हाल ही में जब तक कोई लाइन समर्थन नहीं था। , अब वह प्रकट हुई है)। तदनुसार, पूरे कार्यक्रम को numba में ओवरक्लॉक नहीं किया numba , लेकिन अलग-अलग फ़ंक्शन हैं , इससे आपको उच्च गति और पिछड़े संगतता को पुस्तकालयों के साथ संयोजित करने की अनुमति numba है जो numba (अभी तक) समर्थन नहीं करता है। Numpy को pypy और numba दोनों में (मामूली प्रतिबंधों के साथ) समर्थित है।

अजगर में मैट्रिक्स गुणन की गति के बारे में स्टैकओवरफ्लो पर इस सवाल के साथ 2015 में मेरा परिचय शुरू हुआ: अजगर में कुशल बाहरी उत्पाद

तब से, प्रत्येक पुस्तकालयों में कई घटनाएं घटित हुई हैं, लेकिन numba / cython / pypy संबंध में तस्वीर numba नहीं बदली है: देशी प्रोसेसर निर्देश के उपयोग के माध्यम से cython हो जाना cython ( cython नहीं कर सकते हैं), और pypy - llvm bytecode के अधिक कुशल निष्पादन के कारण। ।

नंबा मेरे लिए काम पर आता है (हाइपरस्पेक्ट्रल इमेज प्रोसेसिंग करता है) और टीचिंग में (न्यूमेरिकल इंटीग्रेशन, डिफरेंशियल इक्वेशन को हल करना)।

कैसे सेट करें

कुछ साल पहले स्थापना के साथ समस्याएं थीं, अब सब कुछ हल हो गया था: यह pip install numba माध्यम से और conda install numba माध्यम से समान रूप से अच्छी तरह से conda install numba । llvm को कड़ा किया जाता है और स्वचालित रूप से स्थापित किया जाता है।

गति कैसे करें

किसी फ़ंक्शन को गति देने के लिए, आपको इसे परिभाषित करने से पहले एनजीटी डेकोरेटर में प्रवेश करना होगा:

 from numba import njit @njit def f(n): s = 0. for i in range(n): s += sqrt(i) return s 

40 बार का त्वरण।

जड़ की जरूरत है, क्योंकि अन्यथा सुंबा अंकगणितीय प्रगति (!) के योग को पहचान लेगी और इसे निरंतर समय में गणना करेगी।

jit बनाम नजीत

पहले, सिर्फ @jit मोड ( @njit नहीं) प्रासंगिक था। मुद्दा यह है कि इस मोड में आप सुन्न द्वारा असमर्थित ऑपरेशन का उपयोग कर सकते हैं: उच्च गति पर सुब्बा पहले ऐसे ऑपरेशन तक पहुंचता है, फिर यह धीमा हो जाता है, और जब तक फ़ंक्शन निष्पादन का अंत सामान्य पायथन गति पर जारी रहता है, भले ही "निषिद्ध" फ़ंक्शन में कुछ भी नहीं मिला हो ( तथाकथित ऑब्जेक्ट मोड), जो स्पष्ट रूप से तर्कहीन है। अब @jit धीरे-धीरे @jit परित्याग @jit , यह हमेशा @njit (या पूर्ण रूप में @jit(nopython=True) ) का उपयोग करने की अनुशंसा की जाती है: इस मोड में, सुंबा ऐसे स्थानों पर अपवादों के साथ शपथ लेती है - उन्हें फिर से लिखना बेहतर होता है ताकि गति कम न हो।

क्या तेजी ला सकता है

ओवरक्लॉक किए गए कार्यों में, केवल अजगर और सुंबा कार्यक्षमता का हिस्सा इस्तेमाल किया जा सकता है। सभी ऑपरेटरों, कार्यों और वर्गों को सुंबा के संबंध में दो भागों में विभाजित किया गया है: वे जो सुब्बा "समझते हैं" और जो इसे "समझ में नहीं आता है।"

सुंबा प्रलेखन में दो ऐसी सूचियाँ हैं (उदाहरण के साथ):

• अजगर की एक सबसेट कार्यक्षमता सुन्न और करने के लिए परिचित
• सुन्न करने के लिए परिचित संख्यात्मक कार्यात्मक का एक सबसेट।

इन सूचियों में उल्लेखनीय है:

• एक सुन्न "समझता है" पायथन एक अंत के साथ एक त्वरित (परिशोधित ओ (1)) सूचियों के साथ है जो कि खस्ता "समझ में नहीं आता है" (हालांकि एक ही प्रकार के तत्वों से केवल सजातीय), "
• numy के एरे जो बेस पायथन में नहीं होते हैं। समझ में भी आता है
• tuples: वे कर सकते हैं, एक नियमित अजगर की तरह, विभिन्न प्रकार के तत्व होते हैं।
• शब्दकोशों: सुंबा का एक टाइप किए गए शब्दकोश का अपना कार्यान्वयन है। सभी कुंजियाँ समान प्रकार की होनी चाहिए, बिल्कुल मानों की तरह। एक अजगर को सुन्न करने के लिए पारित नहीं किया जा सकता है, लेकिन एक स्तब्ध सुन्न है। numba.typed.Dict में अजगर को बनाया जा सकता है और इसे सुब्बा से स्थानांतरित किया जा सकता है (जबकि अजगर में यह अजगर से थोड़ा धीमा काम करता है)।
• हाल ही में str और बाइट्स, हालांकि, केवल इनपुट मापदंडों के रूप में नहीं बनाया जा सकता है (अभी तक?)।

वह किसी भी अन्य पुस्तकालयों (विशेष रूप से, डरावना और पांडा) को बिल्कुल भी नहीं समझती है।

लेकिन यहां तक ​​कि भाषा का वह सबसेट जो वह समझता है कि वैज्ञानिक अनुप्रयोगों के लिए अधिकांश कोड को ओवरक्लॉक करने के लिए पर्याप्त है जो सुंबा मुख्य रूप से केंद्रित है।

महत्वपूर्ण!

ओवरक्लॉक किए गए कार्यों में से, केवल ओवरक्लॉक किए गए, ओवरक्लॉक नहीं किए गए, फ़ंक्शन कहे जा सकते हैं।
(हालांकि ओवरक्लॉक किए गए कार्यों को ओवरक्लॉक किया जा सकता है और ओवरक्लॉक नहीं किया जा सकता है)।

वैश्विक

ओवरक्लॉक किए गए कार्यों में, वैश्विक चर स्थिर हो जाते हैं: उनका मूल्य उस समय निर्धारित किया जाता है जब फ़ंक्शन संकलित किया जाता है ( उदाहरण )। => ओवरक्लॉक किए गए कार्यों (स्थिरांक को छोड़कर) में वैश्विक चर का उपयोग न करें।

हस्ताक्षर

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

• "कैश वार्म अप" छोटे आकार के इनपुट सरणियों के साथ लॉन्च करके, या
• बाद के प्रोग्राम लॉन्च के दौरान अपने स्वचालित लोडिंग के साथ संकलित कोड को डिस्क पर सहेजने के लिए तर्क @jit(cache=True) को निर्दिष्ट करें (हालांकि व्यवहार में आज यह पहला लॉन्च अभी भी बाद वाले की तुलना में थोड़ा धीमा है, लेकिन cache=True बिना तेजी से cache=True ) ।

एक तीसरा तरीका है। हस्ताक्षर मैन्युअल रूप से सेट किए जा सकते हैं:

 from numba import int16, int32 @njit(int32(int16, int16)) def f(x, y): return x + y >>> f.signatures [(int16, int16)] 

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

चेतावनी: यह अंतिम तरीका भविष्य सुरक्षित नहीं है। सुंबा के लेखकों ने चेतावनी दी है कि भविष्य में निर्दिष्ट प्रकारों के लिए वाक्यविन्यास बदल सकता है, हस्ताक्षर के बिना @jit / @njit इस संबंध में एक सुरक्षित विकल्प है।

f.signatures केवल तभी हस्ताक्षर दिखाना शुरू करता है जब अजगर को उनके बारे में पता चलता है, अर्थात, पहले फ़ंक्शन कॉल के बाद, या यदि वे मैन्युअल रूप से सेट होते हैं।

f.signatures अलावा f.signatures हस्ताक्षर f.inspect_types() माध्यम से देखे जा सकते हैं - इनपुट मापदंडों के प्रकारों के अलावा, यह फ़ंक्शन आउटपुट मापदंडों के प्रकारों के साथ-साथ सभी स्थानीय चर के प्रकार भी दिखाएगा।

इनपुट और आउटपुट मापदंडों के प्रकारों के अलावा, स्थानीय चर के प्रकारों को मैन्युअल रूप से निर्दिष्ट करना संभव है:

 from numba import int16, int32 @njit(int32(int16, int16), locals={'z': int32}) def f(x, y): z = y + 10 return x + z 

पूर्णांक

सुंबा में, पूर्णांक में "साधारण" अजगर के रूप में लंबे अंकगणित नहीं होते हैं, लेकिन int8 से int64 (दस्तावेज़ में प्रकार तालिका ) में विभिन्न प्रकार की मानक चौड़ाई होती है। वहाँ भी हैं int_ (साथ ही float_ ), जिसके उपयोग से आप सुंबा को इष्टतम (उसके दृष्टिकोण से) फ़ील्ड की चौड़ाई चुनने का अवसर देते हैं।

कक्षाएं

आम तौर पर कक्षाओं (@jitclass) के लिए समर्थन है, लेकिन अभी तक यह प्रयोगात्मक है, इसलिए उन्हें अभी के लिए उपयोग करने से बचना बेहतर है (फिलहाल, मेरे अनुभव में, यह उनके बिना की तुलना में उनके साथ बहुत धीमा है)।

कस्टम dtypes

Numba सुन्न - संरचित सरणियों से कक्षाओं के लिए एक निश्चित विकल्प का समर्थन करता है, या, दूसरे शब्दों में, कस्टम dtype है। वे नियमित रूप से सुन्न सरणियों के समान गति पर काम करते हैं, वे सूचकांक के लिए थोड़ा अधिक सुविधाजनक हैं (उदाहरण के लिए, a['y2'] a[3] तुलना a['y2'] अधिक पठनीय है। दिलचस्प बात यह है कि, सुंबा में, सुन्न के विपरीत, सामान्य वाक्य रचना a['y2'] के साथ एक अधिक संक्षिप्त a.y2 अनुमति है। लेकिन सामान्य तौर पर, सुब्बा में उनका समर्थन वांछित होने के लिए बहुत कुछ छोड़ देता है, और कुछ ऑपरेशन, जो सुन्न में भी स्पष्ट होते हैं, उनके साथ सुब्बा में काफी गैर-तुच्छ रूप से दर्ज किया जाता है।

GPU

यह GPU पर ओवरक्लॉक किए गए कोड को निष्पादित करने में सक्षम है, और एक ही के विपरीत, उदाहरण के लिए, pycuda या pytorch, न केवल एनवीडिया पर, बल्कि amd के anhnyh कार्ड पर भी। इसके साथ, अब तक बहुत कम डील हुई है। यहां 2016 हब पर एक लेख है वहाँ, C के लिए तुलनीय गति प्राप्त की गई थी।

आगे-आगे संकलन

सुंबा में सामान्य (अर्थात, जीट नहीं) संकलन ( प्रलेखन ) की एक विधा है, लेकिन यह विधा मुख्य नहीं है, मुझे यह समझ में नहीं आया।

स्वचालित समतलीकरण

कुछ कार्य (उदाहरण के लिए, मैट्रिक्स को एक संख्या से गुणा करना) को स्वाभाविक रूप से समानांतर किया जाता है। लेकिन ऐसे कार्य हैं जिनके कार्यान्वयन को समानांतर नहीं किया जा सकता है। @njit(parallel=True) डेकोरेटर @njit(parallel=True) सुंबा ओवरक्लॉक किए गए फ़ंक्शन के कोड का विश्लेषण करता है, ऐसे खंडों को ढूंढता है, जिनमें से प्रत्येक को स्वयं द्वारा समानांतर नहीं किया जा सकता है, और उन्हें अलग-अलग सीपीयू कोर ( प्रलेखन ) पर एक साथ चलाता है। पहले, आप केवल @vectorize ( प्रलेखन ) का उपयोग करके मैन्युअल रूप से फ़ंक्शंस को समानांतर कर सकते थे, जिसके लिए कोड परिवर्तन आवश्यक थे।

व्यवहार में, यह इस तरह दिखता है: parallel=True जोड़ें parallel=True , गति को मापें, अगर हम भाग्यशाली हैं और यह तेजी से निकला - हम इसे छोड़ देते हैं, धीमा - हम इसे हटा देते हैं। (** लेख के दूसरे भाग की टिप्पणी के अनुसार, इस ध्वज में कई खुले बग हैं)

GIL जारी

@jit(nogil=True) साथ सजाए गए और विभिन्न थ्रेड में चल रहे कार्यों को समानांतर में निष्पादित किया जा सकता है। दौड़ की स्थिति से बचने के लिए, आपको थ्रेड सिंक्रोनाइज़ेशन का उपयोग करना चाहिए।

प्रलेखन

नंबे में अभी भी समझदार प्रलेखन का अभाव है। वह है, लेकिन सब कुछ उसके अंदर नहीं है।

अनुकूलन

मैन्युअल रूप से कोड का अनुकूलन करते समय कुछ अप्रत्याशितता होती है: unpythonic कोड अक्सर पायथोनिक की तुलना में तेजी से चलता है।

विषय में रुचि रखने वालों के लिए, मैं 2017 के सम्मेलन से एक स्तब्ध मास्टर वर्ग के वीडियो की सिफारिश कर सकता हूं (गीथूब पर स्रोत कोड हैं)। यह वास्तव में लंबा और आंशिक रूप से पुराना है (उदाहरण के लिए, तार पहले से ही समर्थित हैं), लेकिन यह एक सामान्य विचार प्राप्त करने में मदद करता है: इसमें विशेष रूप से, पायथोनिक / अनीफॉथोनिक, जीट (समानांतर = सच), आदि शामिल हैं।

दूसरे भाग में, हम लेख की शुरुआत में उल्लिखित लेख से कोड का उपयोग करके सुंबा के उपयोग पर विचार करेंगे।