Pytorch: आरएफसी: नियतात्मक एल्गोरिदम को बाध्य करने के लिए टॉर्च। नियतात्मक ध्वज जोड़ें

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

मैं इसके लिए तैयार हूं और मेरा दृष्टिकोण ऑप्स और त्रुटि को ध्वजांकित करना होगा जब नियतात्मक चालू हो और हम जानते हैं कि वे नहीं हैं।

मुझे लगता है कि गैर-नियतात्मक ऑप्स पर त्रुटि करना बहुत कठोर है। चेतावनी एक सहज अनुभव की तरह लगती है

मुझे लगता है कि डिफ़ॉल्ट फेंकना चाहिए, लेकिन मुझे लगता है कि हम वहां एक बहु-मूल्यवान संपत्ति का समर्थन कर सकते हैं (गैर-नियतात्मक ठीक है, चेतावनी दें, फेंक दें)।

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

त्रुटि, चेतावनी, उचित दस्तावेज़ीकरण...
बाद वाला जरूरी है।
चेतावनी या त्रुटि? मैं एक त्रुटि के साथ जाऊंगा।

फेंकना बहुत अच्छा लगता है। मैं एडम से सहमत हूं कि थ्रो के बजाय चेतावनी देने का विकल्प देना उचित लगता है।

वजन करने के लिए धन्यवाद। अंत में, टर्नरी ध्वज के लिए मुख्य प्रयास ध्वज ही है, और यह कठिन नहीं है।
मैं Context.h में एक ध्वज जोड़ूंगा और (एक उपयोगिता फ़ंक्शन के माध्यम से) AT_ERROR और AT_CHECK छिड़कूंगा।

नमस्ते,
इस झंडे की कोई खबर?
नियतिवाद महत्वपूर्ण है।
मेरे अनुभव से, वर्तमान संस्करण निश्चित बीजों का उपयोग करके, एक gpu पर, एक सटीक 1e-16 तक नियतत्ववाद की अनुमति देता है। ध्यान दें कि इनफिनिटसिमल अंतर को बढ़ाया जा सकता है और परिणामों को अलग किया जा सकता है।

कृपया, मल्टीजीपीयू के मामले पर भी विचार करें (कम से कम एक निश्चित K gpus के लिए, व्यवहार को नियतात्मक होना चाहिए। मैं किसी प्रकार का निर्धारण प्राप्त करने में सक्षम हूं जो समय-समय पर एक कारण से टूट जाता है I अभी के लिए समझ में नहीं आता (रात का निर्माण 1.2.0.dev20190616 का उपयोग करके)।) मैं अभी इससे जूझ रहा हूं ( 1 , 2 )।

आपको धन्यवाद!

@ t-vi क्या आप इस पर सक्रिय रूप से काम कर रहे हैं?

मैं आपको ऐसा करने से नहीं रोकना चाहता।

@ t-vi क्षमा करें यदि मैं स्पष्ट नहीं था, मैं इस पर काम करने की योजना नहीं बना रहा हूं :)। बस यह समझने की कोशिश कर रहा था कि क्या कोई सक्रिय रूप से ऐसा कर रहा है।

लगभग एक वर्ष के बाद भी, गैर-नियतात्मक प्रक्षेप की समस्या अभी भी हल नहीं हुई है।

आशा है कि समुदाय इस सुविधा को जोड़ेगा :)

हो सकता है कि एक नियतात्मक प्रक्षेप उपयोगकर्ताओं के लिए बहुत मददगार हो।

~ मैंने वास्तव में अभी तक इसका विज्ञापन नहीं किया था, लेकिन यह देखते हुए कि आवंटित डेवलपर संसाधनों की तुलना में अधिक उपयोगकर्ता रुचि प्रतीत होती है, मैंने इसे एक परियोजना के रूप में सूचीबद्ध किया है जिसे आप मेरे जीथब प्रायोजन पृष्ठ पर वोट कर सकते हैं जब मैं इसे सेट करता हूं।
मुझे पूरा यकीन है कि हम साल के अंत तक अच्छी प्रगति कर सकते हैं और इंटरपोलेशन निश्चित रूप से उन चीजों में से एक है जिन्हें मेरे पास ठीक करने की योजना है (गुना के लिए छद्म कोड के समान है कि मैं मुद्दों में कहीं हूं) लेकिन बस है मेरी अपनी प्राथमिकताओं की सूची में ऊपर नहीं है।~
दिलचस्प नहीं निकला।

एक नियतात्मक प्रक्षेप एक बड़ी मदद होगी। संपर्क

उपयोगकर्ता प्रतिक्रिया के आधार पर CUDA के लिए प्राथमिकता, विशेष रूप से बंपिंग

मुझे खुशी है कि इसे ठीक किया जा रहा है, धन्यवाद!

@ t-vi निष्पक्ष होने के लिए, मुझे नहीं लगता कि "बंपिंग प्राथमिकता" "इसे ठीक किया जा रहा है" के बराबर है :)।

समाधान के लिए तत्पर हैं

कोल्सबरी ने उल्लेख किया कि नियतात्मक एल्गोरिदम के लिए एक हत्यारा कारण यह नहीं है कि नियतत्ववाद वास्तव में समस्या है, लेकिन जब आप इसे चालू करते हैं तो आप इसे रद्द कर सकते हैं;)

torch.experimental.deterministic RNG बीज के साथ कैसे इंटरैक्ट करना चाहिए? यदि कोई मैन्युअल बीज सेट नहीं किया गया है तो क्या इसे एक डिफ़ॉल्ट बीज सेट करना चाहिए? यदि कोई मैन्युअल बीज सेट नहीं किया गया है तो क्या उसे चेतावनी जारी करनी चाहिए?

मैं सुझाव देता हूं कि यदि उपयोगकर्ता द्वारा कोई भी सेट नहीं किया गया है तो बीज सेट न करें। एक के लिए क्योंकि यह दो इंटरफेस जोड़ता है जिसकी आवश्यकता नहीं है (जो उपयोगकर्ता नियतत्ववाद की परवाह करते हैं वे आरएनजी को बहुत अच्छी तरह से समझेंगे जो मुझे लगता है)। इससे भी महत्वपूर्ण बात यह है कि मज़बूती से करना बहुत कठिन है; कोई बहु-प्रक्रिया/थ्रेडेड अनुप्रयोगों में एक आरएनजी का उपयोग कर सकता है, अन्य torch.Generator उपवर्ग हैं, numpy.random का भी उपयोग कर सकते हैं, आदि।

एक चेतावनी के बारे में निश्चित नहीं है, केवल अगर इसे सेट करने के लिए एक समझदार जगह है (उदाहरण के लिए आप उसी मॉड्यूल/फ़ंक्शन के बजाय determinism=True से पहले बीज करने के लिए मजबूर कर रहे हैं जहां एक आरएनजी का उपयोग किया जाता है?)

मैं बस उत्सुक हूं कि जब मैं torch.backends.cudnn.deterministic=True सेट करता हूं, तो इंटरपोलेशन ऑपरेटर अभी भी निर्धारक नहीं हो सकता है। क्या pytorch प्रक्षेप cudnn का उपयोग नहीं करता है?

यह नहीं हो सकता है। आप निश्चित रूप से जांच करने के लिए इंटरपोलेट के अपने रन को nvprof कर सकते हैं।

मैं सोच रहा हूं कि एक बार torch.experimental.deterministic लागू होने के बाद हमें फ़ंक्शन कॉल में deterministic तर्क प्रदान करना जारी रखना चाहिए या नहीं। शायद हमें चाहिए, क्योंकि एक उपयोगकर्ता कुछ कार्यों के लिए नियतत्ववाद और अन्य कार्यों के लिए गति को प्राथमिकता दे सकता है।

यदि हम तर्क रखते हैं, तो क्या होता है यदि torch.experimental.deterministic और एक फ़ंक्शन का deterministic ध्वज एक दूसरे का विरोध करता है। क्या torch.experimental.deterministic = True अर्थ है "सभी मामलों में नियतत्ववाद का उपयोग करें, चाहे कुछ भी हो", या इसका अर्थ होना चाहिए "निर्धारणवाद को डिफ़ॉल्ट मान के रूप में उपयोग करें, लेकिन यदि deterministic तर्क फ़ंक्शन कॉल में निर्दिष्ट है, तो उपयोग करें उस विशिष्ट फ़ंक्शन कॉल के लिए वह सेटिंग।" दूसरे शब्दों में, नीचे दिए गए कोड को कैसे संभाला जाना चाहिए? क्या कोई जानता है कि एक समान स्थिति में torch.backends.cudnn.deterministic ध्वज कैसे कार्य करता है?

torch.experimental.deterministic = True
torch.some_operation(deterministic=False)

@kurtaohler अच्छा सवाल है। मुझे लगता है कि इसे बनाना सबसे आसान उपाय है bool? deterministic=None , और फिर None का अर्थ "सम्मान torch.experimental.deterministic " के रूप में व्याख्या करना है, और अन्यथा उपयोगकर्ता द्वारा अनुरोध किए गए का उपयोग करें।

हमारे पास कनवल्शन के साथ एक समान स्थिति है, लेकिन जिस तरह से यह किया गया था वह यह था कि convolution बिना benchmark तर्क के, और फिर एक स्पष्ट के साथ _convolution तल चिह्न।

मुझे लगता है कि इनमें से कोई भी समाधान स्वीकार्य होगा; हालांकि, कनवल्शन दृष्टिकोण में आंतरिक deterministic ध्वज को उपयोगकर्ता-दृश्यमान एपीआई (जब तक कि वे एक आंतरिक एपीआई का उपयोग नहीं करते हैं) को लीक नहीं करने का एक अतिरिक्त लाभ है।

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

@apaszke , हाँ, मुझे लगता है कि आप सही हैं कि निर्धारणा को टॉगल करने के लिए संदर्भ प्रबंधकों का उपयोग करना बेहतर होगा। मैं यह नहीं कहूंगा कि हमें किसी भी ऑपरेटर को deterministic तर्क जोड़ना चाहिए, लेकिन कुछ ऑपरेटरों के पास पहले से ही है। क्या उन सभी को हटाना और BC को तोड़ना सबसे अच्छा होगा, या उन्हें अपने पास रखना और उन्हें torch.experimental.deterministic को ओवरराइड करने देना सबसे अच्छा होगा?

मैं कहूंगा कि हमें इसे हटा देना चाहिए या कम से कम इसे निजी बनाना चाहिए (अर्थात अंडरस्कोर उपसर्ग या sth)।

मैं सोच रहा हूं कि क्या इंटरपोलेट फ़ंक्शन के लिए नियतात्मक सुविधा बंद है और इसे लागू नहीं किया जाएगा?

नहीं, हम PyTorch . में सभी कार्यों के नियतात्मक संस्करणों के लिए उत्तरदायी हैं

@ezyang किस pytorch संस्करण में नियतात्मक F.interpolate फ़ंक्शन है? क्या यह pytorch 1.6 से शुरू हो रहा है? या यह नवीनतम स्थिर संस्करण (1.5) में उपलब्ध है? या क्या मुझे स्रोत से पाइटोरच को डाउनलोड और इंस्टॉल करना होगा?

मुझे इस पर काम शुरू करने में खुशी होगी

उपरोक्त प्रतिबद्धता केवल ध्वज जोड़ती है, यह अभी तक किसी भी संचालन को प्रभावित नहीं करती है। मैं आभारी रहूंगा यदि कोई इसे देखने के लिए कुछ मिनट ले सकता है और मुझे बता सकता है कि क्या मैंने कुछ गलत किया है या अब तक कुछ भी सुधार किया जा सकता है। मैं इस पर आधारित हूं कि torch.backends.cudnn.deterministic कैसे कार्यान्वित किया जाता है।

यह ठीक दिखता है लेकिन मुझे लगता है कि आंतरिक नामकरण में प्रयोगात्मक शामिल नहीं होना चाहिए (चूंकि, जाहिरा तौर पर, किसी दिन आप इसे प्रयोगात्मक नहीं बनाना चाहते हैं, और इसमें सभी कार्यान्वयन बिट्स का नाम बदलना शामिल नहीं होना चाहिए!)

@ezyang , हाँ यह समझ में आता है, मैं नाम बदल दूंगा।

मैंने एक torch.experimental.deterministic_error_level जोड़ा, जैसा कि @ t-vi ने इस मुद्दे पर अपने पिछले काम में किया था। deterministic_error_level त्रुटि/चेतावनी व्यवहार को नियंत्रित करता है यदि deterministic == True और किसी दिए गए फ़ंक्शन में नियतात्मक कार्यान्वयन नहीं है। इसे 2 (त्रुटि), 1 (चेतावनी), या 0 (चुप) पर सेट किया जा सकता है।

यदि उपयोगकर्ता इसे किसी अन्य मान पर सेट करता है, तो मैं एक पकड़ने योग्य पायथन रनटाइम अपवाद फेंकना चाहता हूं। आम तौर पर, मैं उस तरह के व्यवहार के लिए TORCH_CHECK() उपयोग करता हूं, लेकिन इस मामले में, अपवाद पकड़ने योग्य नहीं है और मुझे यकीन नहीं है कि क्यों। यहां TORCH_CHECK() कॉल है: लिंक

यह तब होता है जब वह चेक विफल हो जाता है:

>>> import torch
>>> try:
...     torch.experimental.deterministic_error_level=50
... except:
...     print('exception caught')
... 
terminate called after throwing an instance of 'c10::Error'
  what():  error level 50 is invalid, must be one of 0: None, 1: Warn, or 2: Error
Exception raised from longToErrorLevel at ../aten/src/ATen/Context.cpp:85 (most recent call first):
frame #0: c10::Error::Error(c10::SourceLocation, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) + 0x58 (0x7f53e2cc0878 in /work/kurtamohler/development/pytorch-deterministic-flag/torch/lib/libc10.so)
frame #1: at::Context::longToErrorLevel(long) + 0x122 (0x7f53f6d61a82 in /work/kurtamohler/development/pytorch-deterministic-flag/torch/lib/libtorch_cpu.so)
frame #2: THPModule_setDeterministicErrorLevel(_object*, _object*) + 0x31 (0x7f53fb5625d1 in /work/kurtamohler/development/pytorch-deterministic-flag/torch/lib/libtorch_python.so)
<omitting python frames>
frame #23: __libc_start_main + 0xe7 (0x7f5432d62b97 in /lib/x86_64-linux-gnu/libc.so.6)

Aborted (core dumped)

अगर कोई जानता है कि मैं इसे कैसे ठीक कर सकता हूं तो कृपया मुझे बताएं।

@kurtaohler के पास THPModule_setDeterministicErrorLevel HANDLE_TH_ERRORS / END_ HANDLE_TH_ERRORS मैक्रो नहीं हैं? उन्हें सी ++ अपवाद को पकड़ने और इसे पायथन त्रुटि रिटर्न में अनुवाद करने की आवश्यकता है।

आह वह था, धन्यवाद @colesbury!

मैं atomicAdd सभी कॉलर्स के लिए गैर-नियतात्मक अलर्ट जोड़ना शुरू कर रहा हूं। मैंने देखा कि कुछ कॉल करने वाले कुछ मामलों में केवल atomicAdd का उपयोग करते हैं। उदाहरण के लिए, adaptive_avg_pool3d_backward केवल तभी उपयोग करता है जब (isizeW%osizeW != 0) || (isizeH%osizeH != 0) || (isizeT%osizeT != 0) सत्य हो। क्या मुझे केवल इन मामलों में सतर्क रहना चाहिए और उन्हें त्रुटि संदेश में व्यक्त करने का प्रयास करना चाहिए, या जब भी इन कार्यों को कॉल किया जाता है, तो क्या यह ठीक होगा कि atomicAdd उपयोग किया जा रहा है या नहीं?

यदि आप बिना शर्त सचेत करते हैं तो इसे लागू करना शायद आसान और समझने में आसान है।

@ngimel , मैं इस बारे में सोच रहा हूं कि नियतात्मक स्ट्रीम उपयोग सुनिश्चित करने के लिए CUBLAS_WORKSPACE_CONFIG का उपयोग कैसे करें, और मुझे लगता है कि दो मुख्य दृष्टिकोण हैं जिन पर विचार किया जाना चाहिए।

यदि कोई प्रभावित CUDA संस्करणों में से एक का उपयोग कर रहा है (इस समय 10.2 या उच्चतर), और torch.set_deterministic(True) कहा जाता है, तो यह सुनिश्चित करने के लिए std::getenv का उपयोग करें कि CUBLAS_WORKSPACE_CONFIG या तो :16:8 या :4096:8 । यदि नहीं, तो (1) या (2) में से कोई एक करें:

1. उपयोगकर्ता को चर को उचित रूप से सेट करने के लिए कहने में त्रुटि फेंको।

2. putenv ( _putenv विंडोज़ पर) के साथ चर को स्वचालित रूप से सेट करें। हालाँकि, इससे जुड़े कुछ और डिज़ाइन निर्णय हैं। क्या हमें :16:8 (कम प्रदर्शन, लेकिन कम मेमोरी उपयोग) या :4096:8 (उच्च प्रदर्शन, लेकिन अधिक मेमोरी उपयोग) चुनना चाहिए? साथ ही, यदि उपयोगकर्ता चर को किसी अन्य गैर-निर्धारक मान पर सेट करता है, तो हमें या तो मूल मान का ट्रैक रखना होगा और इसे पुनर्स्थापित करना होगा यदि torch.set_deterministic(False) कहा जाता है, या हम उपयोगकर्ता को यह बताते हुए एक त्रुटि फेंक सकते हैं कि उन्हें चर, या किसी अन्य योजना को अनसेट करने की आवश्यकता है।

साथ ही, मुझे नहीं पता कि एप्लिकेशन पहले से चल रहा है, जबकि वैरिएबल सेट करना वास्तव में कोई प्रभाव डालेगा, इसलिए मुझे निश्चित रूप से पता नहीं है कि विकल्प (2) भी संभव है या नहीं। वेरिएबल को केवल एक बार चेक किया जा सकता है, जब CUDA रनटाइम शुरू होता है या जब cuBLAS हैंडल बनाया जाता है। मुझे इसके बारे में जानकारी नहीं मिली, इसलिए मुझे शायद प्रयोगात्मक रूप से पता लगाना होगा (मुझे किसी भी तरह से एक परीक्षण लिखने के लिए एक गैर-नियतात्मक स्ट्रीम उपयोग पुनरुत्पादक का उपयोग करना होगा, इसलिए मैं इसे देख लूंगा) . मैंने पर्यावरण चर का उपयोग करने के बजाय एक एपीआई कॉल की भी तलाश की, लेकिन सीयूडीए एक की पेशकश नहीं कर रहा है।

क्या आपके पास एक मजबूत राय है कि कौन सा विकल्प बेहतर होगा? विकल्प (2) शायद अधिक उपयोगकर्ता के अनुकूल होगा, लेकिन संभवतः विकल्प (1) से कम पारदर्शी होगा।

मुझे नहीं पता कि एप्लिकेशन के पहले से चल रहे वेरिएबल को सेट करने से वास्तव में कोई प्रभाव पड़ेगा

इस प्रश्न पर अनुवर्ती कार्रवाई करने के लिए, एक पाइटोरच स्क्रिप्ट के अंदर पर्यावरण चर सेट करना CUDA स्ट्रीम के नियतत्ववाद को प्रभावित नहीं करता है। मैंने स्क्रिप्ट को https://github.com/pytorch/pytorch/issues/39849 से कई बार चलाने और गैर-नियतात्मक व्यवहार की जांच के लिए प्रशिक्षण आँकड़ों की तुलना करने के लिए संशोधित किया। यह नियतात्मक स्ट्रीम उपयोग सुनिश्चित करने के लिए CUBLAS_WORKSPACE_CONFIG=:4096:8 सेट करने का प्रयास करता है: https://github.com/kurtaohler/pytorch-perf-test-scripts/blob/master/nondeterministic_alert/cuda_stream_nondeterminism.py

इसे चलाने से पता चलता है कि स्क्रिप्ट के अंदर वेरिएबल सेट करने से हमें नियतात्मक व्यवहार नहीं मिलता है:

$ python cuda_stream_nondeterminism.py 
Before setting var: not deterministic
After setting var: not deterministic
After restoring old var: not deterministic

लेकिन इसे स्क्रिप्ट के बाहर पर्यावरण चर सेट के साथ चलाना इसे नियतात्मक बनाता है:

$ CUBLAS_WORKSPACE_CONFIG=:4096:8 python cuda_stream_nondeterminism.py 
Before setting var: possibly deterministic
After setting var: possibly deterministic
After restoring old var: possibly deterministic

ध्यान दें, यह "संभवतः नियतात्मक" प्रिंट करता है क्योंकि मैं केवल 5 बार प्रशिक्षण कार्य चलाता हूं, और भाग्यशाली होना संभव है, भले ही व्यवहार वास्तव में नियतात्मक न हो।

हो सकता है कि अगर मैं क्यूडा स्ट्रीम को फिर से शुरू कर सकता हूं, तो यह बदले गए CUBLAS_WORKSPACE_CONFIG चर का सम्मान करने के लिए मजबूर करेगा। मैं यह कोशिश करना चाहता हूं, लेकिन मुझे नहीं पता कि रनटाइम पर ऐसा करना कैसे संभव है या नहीं। अगर किसी को पता है तो कृपया मुझे बताएं।

मुझे पता चला कि मैं इसके साथ एक नई स्ट्रीम बना और उपयोग कर सकता हूं:

with  torch.cuda.stream(torch.cuda.Stream()):

लेकिन नई धारा बदली हुई पर्यावरण चर सेटिंग का सम्मान नहीं करती है। मुझे torch.cuda.init() भी मिला, लेकिन दुर्भाग्य से, यह एक नो-ऑप है अगर कूडा पहले ही शुरू हो चुका है।

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

हां, cuda संदर्भ प्रारंभ होने के बाद पर्यावरण चर सेट करने का कोई प्रभाव नहीं पड़ता है, इसलिए दुर्भाग्य से यह सब कुछ या कुछ भी समाधान नहीं है। उपयोगकर्ता को इसे सेट करने के लिए कहने में त्रुटि फेंकना उचित लगता है।

वर्तमान में, ऐसा नहीं लगता है कि गैर-एनवीसीसी संकलित फ़ाइल से CUDA संस्करण की जांच करना संभव है, इसलिए मेरा मानना ​​​​है कि मुझे इसे aten/src/ATen/cuda/detail/CUDAHooks.h जोड़ना होगा (cuDNN संस्करण की जाँच करना उस इंटरफ़ेस का हिस्सा है) . अगर कोई बेहतर जानता है तो कृपया मुझे बताएं।

उपरोक्त प्रतिबद्धता त्रुटि जोड़ती है। लेकिन मुझे यह पता लगाने की जरूरत है कि अब यूनिट परीक्षणों के साथ क्या करना है। दो समस्याएं हैं:

• यह जांचने के लिए कि त्रुटि सही स्थिति में डाली जा रही है (cuda >= 10.2 और CUBLAS_WORKSPACE_CONFIG ठीक से सेट नहीं है), परीक्षण बुनियादी ढांचे को परीक्षण चलाने से पहले पर्यावरण चर को स्वचालित रूप से बदलने में सक्षम होना चाहिए।
• यह सुनिश्चित करने के लिए कि मौजूदा torch.set_deterministic परीक्षण टूट न जाएं, हमें स्वचालित रूप से CUBLAS_WORKSPACE_CONFIG ठीक से सेट करने की आवश्यकता होगी। हम संभावित रूप से इस चर को डिफ़ॉल्ट रूप से सभी सीआई नौकरियों में सेट कर सकते हैं जो क्यूडा> = 10.2.2 का उपयोग करते हैं।

मुझे पता चला कि मैं एक पायथन लिपि से पर्यावरण चर सेट करने में सक्षम हूं, फिर इसे नए मान का सम्मान करने के लिए मशाल मॉड्यूल को पुनः लोड करें:

>>> import torch
>>> torch.set_deterministic(True)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/work/kurtamohler/development/pytorch-deterministic-flag-cuda-env-var/torch/__init__.py", line 306, in set_deterministic
    _C._set_deterministic(d)
RuntimeError: To enable deterministic behavior with CUDA >= 10.2, you must set environment variable CUBLAS_WORKSPACE_CONFIG=:4096:8 or CUBLAS_WORKSPACE_CONFIG=:16:8. For more information, go to https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility
>>> import os
>>> os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'
>>> from importlib import reload
>>> torch = reload(torch)
>>> torch.set_deterministic(True)

मुझे नहीं पता कि मशाल को फिर से लोड करने से CUDA भी इस बदलाव का सम्मान करेगा, लेकिन कम से कम यह हमें त्रुटि संदेश के लिए इकाई परीक्षण का एक तरीका देता है। हालांकि मुझे पूछना है, क्या यूनिट टेस्ट के अंदर टॉर्च मॉड्यूल को फिर से लोड करने में कोई समस्या हो सकती है?

संपादित करें: पता चला है कि मुझे बदले हुए पर्यावरण चर को देखने के लिए मशाल को फिर से लोड करने की आवश्यकता नहीं है। साथ ही, चर बदलने के बाद पुनः लोड करना CUDA रनटाइम को प्रभावित नहीं करता है।

उपरोक्त प्रतिबद्धता उन सभी चिंताओं को दूर करती है जिनका मैंने अपनी पिछली टिप्पणी में उल्लेख किया था। मैंने किसी भी एपीआई परीक्षण को लपेटने के लिए एक डेकोरेटर जोड़ा जो torch.set_deterministic() कॉल करता है, अस्थायी रूप से CUBLAS_WORKSPACE_CONFIG=:4096:8 केवल जरूरत पड़ने पर सेट करता है। यह नियतात्मक ध्वज और CUBLAS_WORKSPACE_CONFIG सेटिंग्स को भी पुनर्स्थापित करता है जो परीक्षण चलाने से पहले थे।

मुझे एहसास हुआ कि प्रतिलिपि प्रस्तुत करने योग्यता दस्तावेज़ का उल्लेख है कि नियतात्मक CuDNN व्यवहार की आवश्यकता है:

torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

क्या इस सूत्र पर कोई जानता है कि benchmark वास्तव में क्या है, और क्यों torch.backends.cudnn.deterministic = True अपने आप में पर्याप्त नहीं है?

हम benchmark को बंद करने के लिए बाध्य कर सकते हैं यदि torch.is_deterministic() == True । दूसरे शब्दों में, ctx.benchmarkCuDNN() सीधे at::_convolution() में पास करने के बजाय, शायद यह इस लाइन पर ctx.benchmarkCuDNN() && !ctx.deterministic() होना चाहिए: https://github.com/pytorch/pytorch/blob/ मास्टर/एटेन/src/ATen/native/Convolution.cpp#L602

यदि हम यह परिवर्तन नहीं करते हैं, तो ऐसा लगता है कि set_deterministic और CuDNN का उपयोग करने वाले लोगों को यह करना होगा:

torch.set_deterministic(True)
torch.backends.cudnn.benchmark = False

मतलब कि set_deterministic() अकेले सब कुछ कवर नहीं करेगा, जो मेरी राय में भ्रमित करने वाला है।

cc @ezyang @colesbury @t-vi @ngimel

एक नए कनवल्शन कॉन्फ़िगरेशन का सामना करते समय, benchmark=True सभी उपलब्ध cudnn कार्यान्वयन को चलाता है और सबसे तेज़ एक को चुनता है, जो कि इसके द्वारा चुने गए कार्यान्वयन को कैश करता है, इसलिए समान मापदंडों के साथ कनवल्शन के लिए बाद की सभी कॉल्स इसका उपयोग करेंगी। इसलिए, यदि deterministic को भी True सेट किया जाता है, तो परिणाम तब तक नियतात्मक होंगे जब तक यह कैश बना रहता है, अर्थात जब तक आप उसी प्रक्रिया में हैं। यदि करीब रनटाइम के साथ कार्यान्वयन हैं, तो अगली बार जब आप प्रक्रिया शुरू करते हैं और बेंचमार्किंग फिर से चलाते हैं, तो एक और कार्यान्वयन जीत सकता है, और परिणाम (जबकि ऊपर वर्णित अर्थ में अभी भी नियतात्मक) पिछले रन से अलग होंगे। इसलिए, रनों के बीच नियतत्ववाद की गारंटी के लिए आपको बेंचमार्किंग को बंद करना होगा।

समझा। तो शायद केवल इन-प्रोसेस नियतत्ववाद, क्रॉस-प्रोसेस नियतत्ववाद नहीं, कुछ अनुप्रयोगों के लिए मायने रखता है, इसलिए अगर लोग torch.set_deterministic(True) सेट करते हैं तो लोग बेंचमार्किंग का उपयोग करने में सक्षम होने के लिए इसे उपयोगी पा सकते हैं। उस स्थिति में, मुझे वर्तमान व्यवहार को नहीं बदलना चाहिए। जब तक मैं इसे स्पष्ट करने के लिए डॉक्स को अपडेट करता हूं, मुझे इसमें कोई समस्या नहीं दिखती।

मैंने PyTorch योगदानकर्ताओं को torch.set_deterministic() लिए समर्थन जोड़ने में मदद करने के लिए एक विकी पेज बनाया: https://github.com/pytorch/pytorch/wiki/How-to-support-%60torch.set_deterministic ()%60-in- PyTorch-संचालकों

किसी भी सुधार का स्वागत है।

साथ ही, मुझे यकीन नहीं था कि "वर्तमान में असमर्थित कार्य" खंड इस विकी में होना चाहिए या यदि यह एक नए जीथब मुद्दे के रूप में बेहतर होगा (विकी पृष्ठ इससे लिंक हो सकता है)। क्या किसी की कोई प्राथमिकता है?

नमस्ते, मैं torch.deterministic लिए आगे की योजना के बारे में बात करना चाहता हूं। कुछ उच्च-स्तरीय प्रश्न हैं जिनका हमें उत्तर देना है:

1. torch.deterministic के शब्दार्थ क्या हैं? उपयोगकर्ता क्या उम्मीद करता है? क्या सर्वोत्तम प्रयास वास्तव में उपयोगकर्ता के लिए उपयोगी है? यदि यह उपयोगी नहीं है, तो क्या torch.deterministic को यह परिभाषित करना बेहतर है कि यह
2. अब जब हमारे पास torch.deterministic ध्वज है, तो क्या यह पूरी तरह से सार्वजनिक सामना करने वाले एपीआई ( bmm , मैं आपको देख रहा हूं) से deterministic= कीवर्ड तर्क को खत्म करने का कोई मतलब है।
3. इस काम के लिए अंतिम खेल क्या है? आप इसमें से कितने पर (@kurtaohler) काम करने जा रहे हैं, बनाम सामान्य समुदाय, और जब हम यहां आपके कार्यकाल के अंत तक पहुंचते हैं, तो एक उचित राज्य कैसा दिखता है?

के साथ शुरू (1), के लिए मौजूदा दस्तावेज टॉर्च। नियतात्मक कहते हैं:

     r"""Sets a global flag to force all operations to use a deterministic
    implementation if available. If an operation that does not have a
    deterministic implementation is called while this setting is True, the
    operation will throw a RuntimeError.

    Note that deterministic operations tend to have worse performance than
    non-deterministic operations.

हालांकि यह एक अंतिम अंत स्थिति के लिए सही हो सकता है, यह गलत तरीके से वर्तमान स्थिति का प्रतिनिधित्व करता है, जहां बहुत सारे संचालन का ऑडिट नहीं किया गया है और किसी दिए गए मॉडल के लिए, हम नहीं जानते कि torch.deterministic वास्तव में क्या करेगा टिन पर कहते हैं और अपने मॉडल को नियतात्मक बनाते हैं / जब आप नोडेट हिट करते हैं तो एक त्रुटि उत्पन्न करते हैं। तो मूल रूप से, हमारा कार्यान्वयन इन शब्दार्थों के संबंध में छोटी है, और निकट भविष्य के लिए छोटी गाड़ी बनी रहेगी। यह रहने के लिए एक महान राज्य नहीं है।

हम इसे सुधारने के लिए टॉर्च.डेर्मिनिस्टिक के दस्तावेज़ीकरण को बदल सकते हैं। कुछ संभावित बदलाव:

• Torch.deterministic सबसे अच्छा प्रयास है , लेकिन कृपया बग की रिपोर्ट करें यदि आप देखते हैं कि यह कुछ गैर-नियतात्मकता को नहीं पकड़ता है
• Torch.deterministic इन ऑपरेटरों के व्यवहार को टॉगल करता है (और फिर इसे टॉगल करने वाले ऑपरेटरों की एक विस्तृत सूची दें)

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

तुम क्या सोचते हो? मुझे लगता है कि स्थायी रास्ते पर आने के लिए डॉक्स को बदलना शायद सबसे आसान तरीका है। कुछ अन्य विवरण हैं, जैसे कि संपूर्ण सूची को कैसे पॉप्युलेट किया जाए, लेकिन ये शब्दार्थ शायद "आदर्श" शब्दार्थों की तुलना में अधिक समझ में आता है जो वास्तव में सच नहीं होने वाले हैं।

cc @gchanan @mruberry

@zou3519 क्यू के साथ https://github.com/pytorch/pytorch/pull/38683#issuecomment -662590937 पर भी प्रतिच्छेदित है

मुझे खुशी है कि आपने @ezyang , @zou3519 और @mruberry जैसे सवालों को उठाया। मैं सहमत हूं कि मैंने जो दस्तावेज लिखा है वह वर्तमान स्थिति का झूठा प्रतिनिधित्व है।

मुझे उन सभी कार्यों को विस्तृत रूप से सूचीबद्ध करने का विचार पसंद है जो torch.set_deterministic() प्रभावित करते हैं, ताकि हम उपयोगकर्ता से झूठ न बोलें। इसे 1.6.0, @zou3519 में जोड़ने के लिए धन्यवाद।

मैं सहमत हूं कि हमें deterministic सेटिंग को प्रत्यक्ष कार्य तर्क के रूप में पेश नहीं करना चाहिए।

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

लंबे समय में, मुझे लगता है कि प्रभावित कार्यों की एक विस्तृत सूची प्रदान करना एक वैध निर्णय है, लेकिन मुझे नहीं लगता कि अकेले रणनीति नियतात्मक ध्वज की उपयोगिता को अधिकतम करेगी। हम इस तरह के कार्यों (एक विशिष्ट वातावरण में) को वर्गीकृत कर सकते हैं:

1. नियतात्मक
2. डिफ़ॉल्ट रूप से नॉनडेटर्मिनिस्टिक, लेकिन नियतात्मक ध्वज के लिए समर्थन है (या तो त्रुटि या वैकल्पिक कार्यान्वयन)
3. गैर नियतात्मक और नियतात्मक ध्वज के लिए समर्थन नहीं है

बेशक आदर्श मामला श्रेणी 3 को पूरी तरह से समाप्त करना है, और फिर श्रेणी 2 के कार्यों की सूची पर्याप्त होगी। हालांकि, श्रेणी 3 के कार्य अभी भी एक महत्वपूर्ण अवधि के लिए मौजूद रहेंगे (या शायद हमेशा के लिए, यदि सभी योगदानकर्ताओं को नियतत्ववाद के प्रश्न के बारे में पता नहीं है, या एक प्रतिबद्धता गलती से किसी फ़ंक्शन के लिए नियतत्ववाद को हटा देती है, आदि)। तो भले ही हमारे पास सभी श्रेणी 2 कार्यों की एक विस्तृत सूची है, उपयोगकर्ता के पास यह जानने का कोई आसान तरीका नहीं है कि सूची में प्रकट नहीं होने वाला फ़ंक्शन नियतात्मक है या नहीं (श्रेणी 1 या 3 हो सकता है)। उदाहरण के लिए, torch.add सूची में प्रकट नहीं होता है, तो उपयोगकर्ता कैसे जानता है कि यह नियतात्मक है?

शायद हम श्रेणी 3 के कार्यों की सूची बनाए रखने के बारे में भी सोच सकते हैं। लेकिन इन सूचियों को मैन्युअल रूप से बनाए रखना कई कारणों से बहुत मुश्किल होगा, इसलिए मुझे आश्चर्य है कि क्या हम इसे कुछ हद तक स्वचालित कर सकते हैं। हम संभावित रूप से एक सीआई नौकरी स्थापित कर सकते हैं जो सभी कार्यों पर निर्धारणा परीक्षण चलाता है। यह संभव नहीं है कि 100% आगमनात्मक रूप से साबित करें कि एक फ़ंक्शन नियतात्मक है, और एक गैर-नियतात्मक फ़ंक्शन कभी-कभी एक ही परिणाम को कई बार दे सकता है यदि हम बदकिस्मत हैं। लेकिन जितनी बार हम इन परीक्षणों को चलाते हैं, उतना ही अधिक हम इस बारे में आश्वस्त हो सकते हैं कि प्रत्येक फ़ंक्शन किस श्रेणी का हिस्सा है।

एक प्रश्न यह भी है कि उपयोगकर्ता को प्रत्येक फ़ंक्शन और प्रत्येक प्लेटफ़ॉर्म के बारे में जो कुछ भी हम जानते हैं और नहीं जानते हैं, उसे सबसे कुशलता से कैसे व्यक्त किया जाए। हो सकता है कि हम प्रत्येक प्लेटफॉर्म पर श्रेणी 2 और 3 के सभी कार्यों की एक तालिका बना सकें। यह अच्छा होगा यदि नियतत्ववाद परीक्षण स्वचालित रूप से सत्यापित कर सके कि यह तालिका सही है।

बस विचार-मंथन, हो सकता है कि ये विचार उनके लायक होने से कहीं अधिक कठिन हों। एक अधिक व्यावहारिक योजना काफी अधिक टिकाऊ हो सकती है, भले ही कम आदर्श हो।

क्या torch.add नियतात्मक है?

import torch
n = 512
device = 'cuda'
a = torch.arange(n**3, device=device, dtype=torch.float32)
a = a.reshape((n, n, n))
b = torch.arange(n**3, device=device, dtype=torch.float32)
b = b.reshape((n, n, n))
out_zero = torch.zeros((n, n, n), device=device)
out_zero = out_zero.set_(out_zero.storage(), storage_offset=0, size=a.size(), stride=(1,1,1))
out_one = torch.zeros((n, n, n), device=device)
out_one = out_one.set_(out_one.storage(), storage_offset=0, size=a.size(), stride=(1,1,1))

torch.add(a, b, out=out_zero)
torch.add(a, b, out=out_one)
(out_zero == out_one).all()
: tensor(False, device='cuda:0')

हमें शायद यह दस्तावेज करना चाहिए कि ओवरलैप किए गए टेंसर जो भी नियतत्ववाद अनुबंध के लिए जा रहे हैं उसका उल्लंघन करते हैं।

"नियतत्ववाद" ध्वज से प्रभावित कार्यों को सूचीबद्ध करना अच्छा लगता है। हालांकि, थोड़ा पीछे हटने पर, ऐसा लगता है कि हम वास्तव में दो चीजों के बारे में बात कर रहे हैं:

• यदि उपलब्ध हो तो संचालन के नियतात्मक संस्करणों का अनुरोध करना ( use_deterministic ?)
• चेतावनी अगर कोई ऑपरेशन नॉनडेटर्मिनिस्टिक है

पहली बात के लिए एक झंडा सीधा लगता है। हालाँकि, दूसरा थोड़ा पेचीदा है। मुझे चिंता है कि यह बताना कठिन है कि क्या गणित पुस्तकालयों जैसे oneDNN, cuDNN, और MAGMA का संचालन नियतात्मक है, विशेष रूप से संस्करणों और हार्डवेयर में। क्या आपके पास कोई विचार है कि इसे कैसे संबोधित किया जाए, @kurtaohler? हो सकता है कि हम सभी मूल गैर-नियतात्मक संचालन पर चेतावनी दे सकें और यह भी चेतावनी दे सकें कि गणित पुस्तकालय कॉल कब किए गए थे? प्रति प्रक्रिया एक बार चेतावनी इतनी दखल देने वाली नहीं होनी चाहिए।

चेतावनियों के लिए इस दृष्टिकोण के लिए लाइव होने से पहले बहुत सारे एल्गोरिदम और कॉल साइटों की समीक्षा करने की आवश्यकता होगी, लेकिन यदि वे उपलब्ध हैं तो निर्धारिती एल्गोरिदम का चयन करने के लिए ध्वज को अवरुद्ध करने की आवश्यकता नहीं है।

(चर्चा के तहत एक तीसरी बात नियतात्मक एल्गो चयन (वैश्विक ध्वज के माध्यम से या कार्यों पर kwargs के रूप में) प्रस्तुत करने का सबसे अच्छा तरीका है, लेकिन मुझे लगता है कि हम उस चर्चा में देरी कर सकते हैं जब तक हम ध्वज के लिए एक योजना निर्धारित नहीं करते?)

मुझे लगता है कि हमें यहां परफेक्ट को अच्छाई का दुश्मन नहीं बनने देना चाहिए। मुझे नहीं पता कि PyTorch के साथ सेल्फ-ओवरलैपिंग टेंसर का उपयोग करना कब 100% सुरक्षित था, और मेरी धारणा यह है कि ऐसा नहीं है कि आम लोग उनका उपयोग करते हैं।

मंचों से मेरी धारणा यह है कि ज्यादातर लोग आश्चर्यचकित हैं कि वे दो बार कुछ चलाते हैं और इससे अलग-अलग ग्रेडियेंट प्राप्त करते हैं, अक्सर इसलिए क्योंकि PyTorch के मूल कार्यों में से एक परमाणु का उपयोग करता है।
अगर हमें इसके लिए चेतावनियां मिलती हैं, तो हमने ज्यादातर मामलों को कवर कर लिया है जिनके बारे में लोग सोच रहे हैं। कुछ ऐसा लगता है कि इसका आधा हिस्सा वास्तव में पीछे की ओर बढ़ने से है।

मुझे लगता है कि हमें स्पष्ट रूप से यह बताना चाहिए कि जहां तक ​​​​बाहरी कामों का संबंध है, यह सबसे अच्छा प्रयास है और जब हम मुद्दों को जानते हैं तो हम चेतावनियां जोड़ते हैं, लेकिन मेरी धारणा यह है कि हमारे मूल कर्नेल वास्तव में सबसे ज्यादा मायने रखते हैं।

मुझे नहीं पता कि PyTorch के साथ सेल्फ-ओवरलैपिंग टेंसर का उपयोग करना कब 100% सुरक्षित था, और मेरी धारणा यह है कि ऐसा नहीं है कि आम लोग उनका उपयोग करते हैं।

हां, और कोई भी प्रोग्राम जो यथोचित रूप से त्रुटि के रूप में वर्गीकृत किया जा सकता है। मेरा मतलब सिर्फ इतना था कि इन झंडों के लिए हम जो भी अनुबंध लेकर आए हैं, उसका दस्तावेजीकरण करने में हमें सावधानी बरतनी चाहिए।

मुझे लगता है कि हमें स्पष्ट रूप से यह बताना चाहिए कि जहां तक ​​बाहरी कामों का संबंध है, यह सबसे अच्छा प्रयास है और जब हम मुद्दों को जानते हैं तो हम चेतावनियां जोड़ते हैं ...

डॉक्टर कुछ ऐसा कह सकता है, "गणित पुस्तकालय कॉल जिन्हें नोडेटर्मिनिस्टिक माना जाता है ..."?

मैं @ t-vi से सहमत हूं (और मुझे वास्तव में यह अवलोकन पसंद है कि रिपोर्ट किए गए नोडेटर्मिनिज्म का आधा हिस्सा पिछड़ा हुआ है)। विशेष रूप से, मुझे लगता है कि एक ऐसा राज्य जहां हमारे पास आंशिक रूप से दस्तावेज किए गए कार्य हैं जिन्हें नोडेटर्मिनिस्टिक (या आंशिक रूप से कुछ कार्यों को नियतात्मक होने के लिए दस्तावेज किया गया है) के रूप में जाना जाता है, जहां हम कोई संकेत नहीं देते हैं - मुख्य बात उन चीजों का समर्थन करने का दावा नहीं करना है जो हम नहीं करते हैं! मैं मानता हूं कि यह सोचने के लिए एक उपयोगी गतिविधि है कि कोई नियतत्ववाद के परीक्षण के बारे में कैसे जा सकता है, लेकिन मुझे लगता है कि यह एपीआई को फ़्लैग करने के लिए एक ऑर्थोगोनल गतिविधि के रूप में है जो स्पष्ट रूप से गैर-निर्धारक हैं।

चूंकि बहुत सारे विचार इधर-उधर तैर रहे हैं, उनमें से कुछ के बारे में अपने विशिष्ट विचारों के साथ मैं केवल झंकार करूंगा:

1. "शायद हम श्रेणी 3 कार्यों की सूची बनाए रखने के बारे में भी सोच सकते हैं।" यह बहुत काम की तरह लगता है। मुझे लगता है कि यह शायद केवल उन कार्यों के लिए लायक है जहां हमने स्पष्ट रूप से नियतत्ववाद के लिए कुछ आवास बनाए हैं (सबसे अधिक संभावना है, ऐसे कार्य जो नियतात्मक ध्वज का समर्थन करते हैं)
2. "हम संभावित रूप से एक सीआई नौकरी स्थापित कर सकते हैं जो सभी कार्यों पर नियतत्ववाद परीक्षण चलाता है।" मुझे लगता है कि ऐसा कुछ बहुत सावधानी से किया जाना चाहिए, क्योंकि इसकी प्रकृति से यह किसी ऐसी चीज के लिए परीक्षण कर रहा है जो नोडेटर्मिनिस्टिक है, और इसका मतलब है कि नियतत्ववाद परीक्षण स्वयं "परतदार" है (कभी-कभी पास होगा और दूसरों को विफल करेगा) . हमारे सीआई रिपोर्टिंग टूल इस तरह की स्थितियों को अच्छी तरह से हैंडल नहीं करते हैं।
3. "दूसरा, हालांकि, थोड़ा पेचीदा है। मुझे चिंता है कि यह बताना मुश्किल है कि क्या oneDNN, cuDNN, और MAGMA जैसे गणित पुस्तकालयों के संचालन नियतात्मक हैं, खासकर संस्करणों और हार्डवेयर में।" हमें इसका सर्वोत्तम प्रयास करना चाहिए। कई मामलों में गणित पुस्तकालय स्पष्ट रूप से उनके दस्तावेज़ीकरण में निर्दिष्ट करता है कि वे नियतात्मक हैं या नहीं, और हमें केवल ईमानदारी से रिपोर्ट करना चाहिए कि दस्तावेज़ क्या कहते हैं
4. "शायद हम सभी मूल गैर-नियतात्मक संचालन पर चेतावनी दे सकते हैं और यह भी चेतावनी दे सकते हैं कि गणित पुस्तकालय कॉल कब किए गए थे?" मुझे नहीं लगता कि हमें ऐसा करना चाहिए। जब हम गैर-निर्धारणवाद के बारे में चेतावनी देते हैं, तो ऐसा इसलिए होना चाहिए क्योंकि गैर-निर्धारणवाद हो रहा है, न कि यह हो रहा है। यदि आप अधिक चेतावनी देते हैं, तो लोग चेतावनियों को अनदेखा करना शुरू कर देंगे।

मुझे नहीं लगता कि हमें क्रॉस वर्जन/हार्डवेयर नियतत्ववाद के बारे में चिंता करनी चाहिए - इसके साथ शुभकामनाएँ।

जब हम गैर-निर्धारणवाद के बारे में चेतावनी देते हैं, तो ऐसा इसलिए होना चाहिए क्योंकि गैर-निर्धारणवाद हो रहा है, न कि यह हो रहा है। यदि आप अधिक चेतावनी देते हैं, तो लोग चेतावनियों को अनदेखा करना शुरू कर देंगे।

यह मुश्किल लगता है। उदाहरण के लिए क्या होगा यदि मैं कुछ सेशन चला रहा हूं और PyTorch कार्यान्वयन नियतात्मक है, लेकिन कुछ एक्सटेंशन ने कुछ ओवरराइड किया है (प्रेषण कुंजी, मशाल फ़ंक्शन, या अन्य के माध्यम से) और अब मुझे नहीं पता। अगर यह वास्तव में मेरे गैर-नियतत्ववाद का स्रोत है, तो ऐसा लगता है कि चेतावनी नहीं दी जानी चाहिए।

अगर यह वास्तव में मेरे गैर-नियतत्ववाद का स्रोत है, तो ऐसा लगता है कि चेतावनी नहीं दी जानी चाहिए।

निश्चित रूप से, लेकिन उपयोगकर्ता हमें अपने गैर-निर्धारक शेंगेनियों में भी शामिल नहीं कर सका, और फिर निश्चित रूप से आपको चेतावनी दी जाने की उम्मीद नहीं होगी;)

मेरा मानना ​​है कि अब हम इस मुद्दे को बंद कर सकते हैं क्योंकि फ्लैग एपीआई मौजूद है और अच्छी तरह से प्रलेखित है।

@kurtaohler बहुत बढ़िया काम। शुक्रिया।

क्या इसका मतलब यह है कि, हम torch.manual_seed(111) का उपयोग interpolation ऑपरेशन सहित सभी नियतात्मक सेट करने के लिए कर सकते हैं?

नहीं, प्रतिलिपि प्रस्तुत करने योग्यता/यादृच्छिकता नोट पर एक नज़र डालें।
अब तक, हमारे पास बुनियादी ढांचा है, गैर-नियतात्मकता पर ज्ञात स्रोतों को चिह्नित किया गया है और बहुत बेहतर दस्तावेज़ीकरण किया गया है ताकि आप जान सकें कि क्या हो रहा है।
यदि आप गैर-नियतात्मक संचालन हिट करते हैं, तो आप अभी भी भाग्य से बाहर हैं, लेकिन अब इस पर काम करना अधिक उचित है।

विशेष रूप से प्रक्षेप कुछ ऐसा लगता है जिसे पिछड़े के लिए जटिल कर्नेल लिखकर नियतात्मक बनाया जा सकता है।

@ t-vi हाय, अब जब pytorch 1.7 जारी किया गया है, तो क्या इंटरपोलेशन बैकवर्ड कर्नेल को अपडेट किया गया है?

तो CUDA अपसैंपलिंग कर्नेल और पीछे की ओर झूठ बोलते हैं aten/src/ATen/native/cuda/UpSample* । एक grep से पता चलता है कि रैखिक, बिलिनियर, क्यूबिक में नॉनडेटर्मिनिस्टिक बैकवर्ड है (उनके पास एक चेतावनी मार्कर है), लेकिन निकटतम नहीं है।
हालांकि, पूछने के लिए @kurtaohler बेहतर व्यक्ति होगा।