मुझे लगता है कि हम जटिल टेंसर के लिए वैकल्पिक समर्थन जोड़ने में रुचि रखते हैं। torch/lib में सी पुस्तकालयों पर कांटा और काम करने का सबसे अच्छा तरीका होगा। यह गुरु के साथ संघर्ष-मुक्त होना चाहिए, ताकि आप इसे लंबे समय तक कर सकें। एक बार जब आप उपयोग करने योग्य स्थिति में libs प्राप्त कर लेते हैं, तो आप बाइंडिंग लिखना शुरू कर सकते हैं, और यह वह जगह है जहां हम उस समय संघर्ष से बचने के बारे में कुछ मार्गदर्शन प्रदान कर सकते हैं।

मुझे जटिल प्रकार के संकलन के साथ TH मिला है। पायथन एकीकरण के लिए मुझे क्या जोड़ने की आवश्यकता है?

@PhilippPelz क्या आपका मतलब है: https://github.com/facebook/ztorch/tree/master/lib/THZ ? या आपने TH का अपना कांटा बनाया है जो जटिल प्रकारों को सक्षम बनाता है?

@किलेंट के पास कुछ नोट्स हैं कि TH पायथन से कैसे जुड़ा हुआ है, वह उनको साझा कर सकता है।

सामान्य तौर पर, जटिल टेंसर प्राप्त करने के लिए, मैं THZ पसंद करूंगा, क्योंकि इसमें परीक्षण आदि हैं।

हालांकि, जटिल टेंसर के लिए CUDA बैकएंड बनाना एक बहुत बड़ा प्रयास है, हमने उस पर अभी शुरुआत भी नहीं की है।

मैंने कुछ समय पहले z-cutorch (https://github.com/PhilippPelz/z-cutorch) लिखा है। यह CudaHalfTensor (अभी तक हार्डवेयर नहीं है) के लिए रिफैक्टरिंग से पहले एक कांटा बंद कटोरच है।

यह भी खूब रही। मुझे लगता है कि आपने पहले ही उस दिशा में एक बड़ा प्रयास किया है :)

@soumith मैंने जटिल प्रकारों के साथ TH का कांटा किया। मूल रूप से एक THGenerateComplexTypes.h + जोड़ा गया BLAS + LAPACK रूटीन बाकी लगभग मुफ्त था। THZ के कौन से हिस्से संगत हैं और फिर कॉपी पेस्ट करना, यह जाँचने की तुलना में यह मेरे लिए बहुत कम काम लग रहा था।

मैं अभी THPP को संकलित करने में फंस गया हूँ, जैसे संकलक संदेशों का पता लगा रहा हूँ

/home/philipp/projects/pytorch/torch/lib/tmp_install/include/TH/generic/THBlas.h:6:40: त्रुटि: '*' टोकन से पहले अपेक्षित ',' या '...'
TH_API शून्य THBlas_ (स्वैप) (लंबा n, वास्तविक *, लंबा incx, वास्तविक *, लंबा incy);

थोड़ा पेचीदा है।

मैं पाइथन एकीकरण को सक्षम करने के तरीके पर सहायता की सराहना करता हूं। CUDA बैकएंड ज्यादातर z-cutorch से कॉपी पेस्ट होना चाहिए।

@PhilippPelz यहाँ PyTorch रैप्स TH के बारे में कुछ नोट्स दिए गए हैं: https://gist.github.com/killeent/4675635b40b61a45cac2f95a285ce3c0

@killient धन्यवाद, बहुत मददगार लग रहा है। lib/build_all.sh अब संकलन कर रहा है, मुझे लगता है कि मैं csrc निर्देशिका को देख सकता हूं।

यह अब चलता है:

मशाल के रूप में आयात करें
np . के रूप में numpy आयात करें

a = np.array([1+1j,2+2j])
बी = एनपी.एरे ([3+3j,4+4j])
एथ = वें.from_numpy(ए)
bth = th.from_numpy(b)
ath_cuda = ath.cuda ()
ath_cuda += bth.cuda ()
एथ = ath_cuda.cpu ()
प्रिंट (ath.numpy ())

आउट: [4.+4.j 6.+6.j]

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

@PhilippPelz आपकी टिप्पणियों के लिए धन्यवाद। मैं आपके कार्यान्वयन की जांच कर रहा हूं। और सबसे पहले, मैं आपके ger कार्यान्वयन के बारे में निश्चित नहीं हूँ। आपके THBlas.c में कुछ जटिल blas फ़ंक्शन शामिल नहीं हैं, जैसे आपने GER को zger_ और cger_ के रूप में जेनरेट हेडर में परिभाषित किया है, लेकिन जेनेरिक/THBlas.c में cger_ के साथ कोई blas फ़ंक्शन नहीं है। . हालांकि, मैं आपके जेएमवी और कुछ अन्य कार्यों का उपयोग कर सकता हूं। और आईएमओ शायद आपको .gch को .gitignore में जोड़ना चाहिए? क्या आपने अपने सभी एक्सटेंशन को अपने कांटे पर धकेल दिया है? मैं पहले आपके कार्यान्वयन के आधार पर आपके गुरु से कुछ पुल अनुरोध कर सकता हूं।

और DOT के लिए मुझे लगता है कि शायद जटिल वैक्टर के लिए, dotc डॉट के लिए रूटीन अधिक सामान्य हैं?

और हाँ, अगर केवल real का उपयोग करना कार्यान्वयन के लिए आसान होगा, तो मुझे बस अजीब लग रहा था जब real वास्तव में एक जटिल है ...

और परीक्षणों के लिए, मैंने TH के लिए कोई पिछला परीक्षण नहीं देखा। मुझे उन परीक्षणों को कहाँ लिखना चाहिए? या हम सिर्फ कुछ अजगर परीक्षण लिखते हैं

हां, क्षमा करें, मैं देख रहा हूं कि मैंने हर उस चीज को आगे नहीं बढ़ाया, जिसकी जरूरत है। मैं सोमवार को फिर से इसकी जांच करूंगा। कुछ घोषणाएं गायब हैं, उदा। ज़गर और सीगर

डीओटी के लिए मैं cdotc और zdotc का उपयोग कर रहा हूं, वे गायब प्रतीत होते हैं, मैं अगले सप्ताह अपडेट करूंगा।

पाइटोरच अनुरक्षकों के साथ जाँच करें कि वे वास्तविक के लिए कौन सा नामकरण पसंद करते हैं। मुझे आपका संस्करण अधिक पसंद है, मैंने अभी तक प्रयास नहीं किया है।

हाँ, गणित के सामान के लिए अजगर परीक्षण। कॉम्पलेक्स नंबर चेक को शामिल करने के लिए अधिकांश कार्यों के लिए आसानी से बदला जाना चाहिए।

अच्छा है कि आप भी इसमें देख रहे हैं!

ठीक है, मैंने कुछ बदलावों को आगे बढ़ाया। TH blas रूटीन अब कॉम्प्लेक्स के लिए उपलब्ध हैं

@PhilippPelz मैंने अभी आपके रेपो के लिए एक पुल अनुरोध किया है। और जटिल रैखिक परतों और कुछ अन्य ऑपरेटरों के लिए। बहुत सारे हर्मिटियन ऑपरेशन हो सकते हैं (जैसे जटिल रैखिक परत के लिए बीपी)। शायद टेंसर के लिए कुछ फ़ंक्शन जोड़ें? क्या आपने THNN भाग की जाँच की है?

हाँ हर्मिटियन उपयोगी है। कूडा एफएफटी अब काम कर रहा है। सीपीयू एफएफटी को numpy से लपेटा जा सकता है। मैंने अभी तक THNN या THCUNN को नहीं छुआ है।

@PhilippPelz मैंने पीआर में एक साधारण उपदेशक जोड़ा है। और क्या आप इसकी समीक्षा कर सकते हैं। इसलिए हम देख सकते हैं कि क्या वे परिवर्तन उपयुक्त हैं और अगले चरण पर जाएँ। धन्यवाद! पुनश्च. ऐसा लगता है कि आपने कुछ शीर्षलेखों को याद किया है, मैंने इसे और कुछ अन्य चेतावनियों को भी सही किया है। वास्तविक आउटपुट के साथ जटिल कार्य के लिए, क्या हमें जटिल टेंसर के बजाय वास्तविक टेंसर वापस करना चाहिए? मैंने जटिल और वास्तविक प्रकारों के बीच प्रतिलिपि विधियों को लागू किया है, इसलिए यह संभव है।

मैं आपकी समीक्षा के बाद सभी कमिट्स को रिबेस कर दूंगा।

@PhilippPelz हाय, मैं आपके द्वारा कार्यान्वित THPP भाग के बारे में काफी उलझन में हूं। Traits.hpp में जोर पर निर्भरता क्यों है? क्यूडा के बिना संकलन करते समय यह त्रुटि उत्पन्न करेगा। क्या केवल लाइक का उपयोग करना संभव हैयाTraits.hpp में? मैंने इसका पता नहीं लगाया है। शायद आप कुछ सुराग दे सकते हैं?

@ रोजर-लुओ हां, मुझे इसके साथ कहीं और भी समस्या हो रही है। हम जिस जटिल प्रकार का उपयोग कर रहे हैं वह या तो complex.h या std::complex से होना चाहिए। चूंकि टीएचपीपी सी ++ रैपर है, शायद std::complex अधिक उपयुक्त है। क्या आप कृपया इसे बदल सकते हैं?

सीएफआई एक्सटेंशन बनाने का प्रयास करते समय जोर भी उसी कारण से समस्याएं पैदा कर रहा है। अभी मैं वर्कअराउंड कर रहा हूं, लेकिन THC में जटिल प्रकार को cuFloatComplex/cuDoubleComplex में बदलने का उचित तरीका होगा। ताकि cffi कंपाइलर शिकायत न करे। मैं अभी अनुसंधान के साथ आगे बढ़ना चाहता हूं, इसमें मुझसे बहुत अधिक समय लग रहा है :(। यदि आपके पास समय है, तो कृपया इसे करें।

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

@PhilippPelz शायद reinterpret_cast एक समाधान हो सकता है? मुझे लगता है कि इसे cuComplex में बदला जाना चाहिए, और THPP में reinterpret_cast का उपयोग करना चाहिए। मैं पहले एक कोशिश करूँगा ...

हां, मुझे लगता है कि यदि आप चाहते हैं कि THPP बिना cuda स्थापित किए भी बनाए, तो reinterpret_cast के अलावा और कोई तरीका नहीं है।

@PhilippPelz मैं मदद करना चाहता हूँ। क्या कहीं कोई टूडू लिस्ट है?

जटिल प्रकारों के लिए THNN और THCUNN को सक्षम करने की आवश्यकता है। क्या आप @ roger-luo के साथ समन्वय कर सकते हैं? इसके अलावा, अगर हम मास्टर के साथ एकीकरण का लक्ष्य रखते हैं, तो सभी जटिल तरीकों के लिए यूनिट परीक्षणों को लिखा जाना चाहिए।

@elbamos THNN में अधिकांश काम प्रत्येक मौजूदा परत के लिए नई जटिल बैकप्रॉपैगशन विधियों को लागू करने के बारे में होगा। फिलिप के कांटे में WIP PR है। मैंने कुछ संदर्भ सूचीबद्ध किए हैं।

@apaszke @soumith @PhilippPelz और दो प्रश्न हैं:

• क्या किसी को पता है कि $#$ THS $#$ में एक और GenerateXXXTypes.h फ़ाइल क्यों है? यह TH में उन लोगों के साथ समान दिखता है।

• byte_order.cpp में निम्नलिखित कोड क्या है?

void THP_decodeFloatBuffer(float* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint32_t x; float f; };
    x = (order == THP_BIG_ENDIAN ? decodeUInt32BE(src) : decodeUInt32LE(src));
    dst[i] = f;
    src += sizeof(float);
  }
}

void THP_decodeDoubleBuffer(double* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint64_t x; double d; };
    x = (order == THP_BIG_ENDIAN ? decodeUInt64BE(src) : decodeUInt64LE(src));
    dst[i] = d;
    src += sizeof(double);
  }
}

इसके संबंधित जटिल संस्करण को लागू करने पर कोई सुझाव? मुझे यकीन नहीं है कि निम्नलिखित कार्यान्वयन सही है ...

void THP_decodeZFloatBuffer(std::complex<float>* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint64_t x; std::complex<float> cf;};
    x = (order == THP_BIG_ENDIAN ? decodeUInt64BE(src) : decodeUInt64LE(src));
    dst[i] = cf;
    src += sizeof(std::complex<float>);
  }
}

void THP_decodeDoubleBuffer(std::complex<double>* dst, const uint8_t* src, THPByteOrder order, size_t len)
{
  for (size_t i = 0; i < len; i++) {
    union { uint128_t x; std::complex<double> df;};
    x = (order == THP_BIG_ENDIAN ? decodeUInt128BE(src) : decodeUInt128LE(src));
    dst[i] = df;
    src += sizeof(std::complex<double>);
  }
}

पिछला decodeUInt128XE घोषित किया गया है

static inline uint128_t decodeUInt128LE(const uint8_t *data) {
  return (((uint128_t)data[ 0])<<  0) | (((uint128_t)data[ 1])<<  8)|
         (((uint128_t)data[ 2])<< 16) | (((uint128_t)data[ 3])<< 24)|
         (((uint128_t)data[ 4])<< 32) | (((uint128_t)data[ 5])<< 40)|
         (((uint128_t)data[ 6])<< 48) | (((uint128_t)data[ 7])<< 56)|
         (((uint128_t)data[ 8])<< 64) | (((uint128_t)data[ 9])<< 72)|
         (((uint128_t)data[10])<< 80) | (((uint128_t)data[11])<< 88)|
         (((uint128_t)data[12])<< 96) | (((uint128_t)data[13])<<104)|
         (((uint128_t)data[14])<<112) | (((uint128_t)data[15])<<120);
}

static inline uint128_t decodeUInt128BE(const uint8_t *data) {
  return (((uint128_t)data[15])<<  0) | (((uint128_t)data[14])<<  8)|
         (((uint128_t)data[13])<< 16) | (((uint128_t)data[12])<< 24)|
         (((uint128_t)data[11])<< 32) | (((uint128_t)data[10])<< 40)|
         (((uint128_t)data[ 9])<< 48) | (((uint128_t)data[ 8])<< 56)|
         (((uint128_t)data[ 7])<< 64) | (((uint128_t)data[ 6])<< 72)|
         (((uint128_t)data[ 5])<< 80) | (((uint128_t)data[ 4])<< 88)|
         (((uint128_t)data[ 3])<< 96) | (((uint128_t)data[ 2])<<104)|
         (((uint128_t)data[ 1])<<112) | (((uint128_t)data[ 0])<<120);
}

मैं वर्तमान में THPP $ में T _Complex $ के बजाय std::complex<T> का उपयोग कर रहा हूं। मुझे यकीन नहीं है कि इसका उपयोग अभी तक पायथन द्वारा किया जा सकता है। या केवल c प्रकार T _Complex अजगर के लिए प्रयोग करने योग्य है। तो यहाँ dst का प्रकार है std::complex<T> ।

और अगर मैं इस कार्यान्वयन के लिए सही हूं, तो शायद हमें uint128_t कार्यान्वयन की आवश्यकता है, जैसे https://github.com/calccrypto/uint128_t ? चूंकि ऐसा लगता है कि सभी अनुपालनकर्ता 128-बिट पूर्णांक का समर्थन नहीं करते हैं (जीसीसी में int128_t और uint128_t है)।

@PhilippPelz मैंने देखा कि आपके कांटे में समस्याएँ सक्षम नहीं हैं - आपकी परियोजना की स्थिति क्या है? मैं थोड़ा निराश हूं कि जटिल टेंसर पाइटोरच के रोडमैप पर नहीं हैं

@ el3ment मैंने सीपीयू के लिए एक जटिल बैकएंड जोड़ा है https://github.com/pytorch/pytorch/pull/4899 लेकिन इसकी अभी तक समीक्षा नहीं की गई है ... और मुझे अपने पीआर के लिए कोई टिप्पणी नहीं मिली है, इस प्रकार मैंने उपयोग करना शुरू कर दिया है हाल ही में जूलिया प्रोग्रामिंग लैंग्वेज...

मैंने पिछली बार @PhilippPelz को ईमेल किया था, मुझे लगता है कि उसका रेपो अभी भी v0.1 के तहत है और वह सितंबर तक थीसिस के लिए व्यस्त है? और मैं हालांकि v0.3 के नए CUDA बैकएंड पर काम कर रहा था, लेकिन मेरे पास अकेले इन सभी बाइंडिंग को पूरा करने का समय नहीं है। नक्शा/घटाने के कार्य कुछ अनुकूलन के साथ v0.1 से भिन्न होते हैं लेकिन जटिल संख्याओं का समर्थन करने के लिए उन्हें तुच्छ रूप से परिवर्तित नहीं किया जा सकता है। मुझे खुशी होगी अगर कोई है जो मदद करने को तैयार है ...

मैं मदद करने को तैयार हूं।

10 अप्रैल, 2018 को रात 10:52 बजे, Rogerluo [email protected] ने लिखा:

@ el3ment मैंने CPU #4899 . के लिए एक जटिल बैकएंड जोड़ा है

मैंने पिछली बार @PhilippPelz को ईमेल किया था, मुझे लगता है कि उसका रेपो अभी भी v0.1 के तहत है और वह सितंबर तक थीसिस के लिए व्यस्त है? और मैं हालांकि v0.3 के नए CUDA बैकएंड पर काम कर रहा था, लेकिन मेरे पास अकेले इन सभी बाइंडिंग को पूरा करने का समय नहीं है। नक्शा/घटाने के कार्य कुछ अनुकूलन के साथ v0.1 से भिन्न होते हैं लेकिन जटिल संख्याओं का समर्थन करने के लिए उन्हें तुच्छ रूप से परिवर्तित नहीं किया जा सकता है। मुझे खुशी होगी अगर कोई है जो मदद करने को तैयार है ...

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें, या थ्रेड को म्यूट करें।

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

नमस्ते, मेरा कोड v0.2 . के बाद कुछ कमिट पर है

मैंने देखा था कि सभी टेंसर कोड को एटेन में ले जाने वाला एक बहुत बड़ा रिफ्लेक्टर था। इसका मतलब है कि कोई भी मेरे कांटे को वर्तमान संस्करण में आसानी से विलय नहीं कर सकता है और इसमें कुछ और काम शामिल हो सकते हैं।

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

@elbamos यदि आप चाहते हैं कि आप मेरे कांटे में सामान जोड़ना शुरू कर सकते हैं, तो मैं इसे मर्ज कर दूंगा। आपके स्थान पर, मैं आपको जो भी प्रोजेक्ट कर रहा हूं उसके लिए आपको जो चाहिए वह लागू कर दूंगा। TH(CU)NN एक बहुत बड़ा इंटरफ़ेस है और यह एक बहुत बड़ा कार्यभार होगा।

@el3ment मेरे पास दूसरों के मुद्दों पर काम करने का समय नहीं है। हालांकि, अगर आपको कुछ ऐसा लागू करने की ज़रूरत है जो वहां नहीं है तो मैं सामान को मर्ज कर दूंगा।

यदि आप कुछ ऐसा चाहते हैं जो जटिल संख्याओं के साथ काम करता हो तो मैं अत्यधिक टेंसरफ़्लो की अनुशंसा करता हूं।

संकलन समस्याएं होने पर मैं भी मदद करूंगा।

अगर मैं पोस्टडॉक के साथ जारी रखता हूं तो मैं इन सभी चीजों को किसी बिंदु पर वर्तमान संस्करण में बंद कर दूंगा। यह वास्तव में दुखद है कि फेसबुक इसका समर्थन नहीं करना चाहता। :((

@PhilippPelz सहमत, यह वास्तव में दुखद है और वास्तव में tensorflow क्वांटम भौतिकी में सभी ऑपरेटरों का समर्थन नहीं करता है ... मैंने जूलिया का उपयोग करना शुरू कर दिया है और अजगर को छोड़ दिया है।

@ रोजर-लुओ दिलचस्प, क्या आप एक विशिष्ट जूलिया पैकेज का उपयोग कर रहे हैं या यह सब स्वयं लिखित कोड है?

@PhilippPelz मैं जूलिया (उस PyTorch PR के बाद से) में एक क्वांटम कई-बॉडी टूलकिट विकसित कर रहा हूं, इसमें जटिल तंत्रिका नेटवर्क के बारे में कुछ पिछले कागजात के आधार पर एक जटिल/वास्तविक तंत्रिका नेटवर्क कार्यान्वयन शामिल है, और मैंने पाया कि जूलिया के साथ विकसित करना इतना आसान है मेटाप्रोग्रामिंग। मैंने अभी इसे QMTK.jl में रखा है, यह अभी भी प्रगति पर काम कर रहा है और मैंने वह सब पूरा नहीं किया है जो मैं चाहता हूँ। PyTorch मुझे वास्तव में बहुत प्रेरित करता है, लेकिन वास्तव में जटिल समर्थन के लिए खेद है ...

लेकिन मेरे पास भविष्य में इसे एक तंत्रिका नेटवर्क एकल पैकेज में अलग करने की योजना है (बस इस समय कई रेपो को बनाए रखना नहीं चाहते हैं)। और इंस्टिट्यूट ऑफ फिजिक्स, CAS से विकास में और भी लोग शामिल होंगे। मैं इसके पहले टैग किए गए संस्करण के बाद पीआर स्वीकार करूंगा (जो कुछ हफ्तों में होगा)।

यदि आप इसके विकास में रुचि रखते हैं तो आप इसे देख सकते हैं।

यदि भविष्य में PyTorch टीम के पास अभी भी जटिल समर्थन की योजना है, तो मैं मदद करने के लिए तैयार हूँ।

बढ़िया, मैं इस पर नज़र रखूँगा!

हे दोस्तों, खेद है कि हमने इस मुद्दे पर इसके खुलने के बाद से कोई प्रतिक्रिया नहीं दी है।

यहाँ दो तथ्य हैं:

1. हम पूरी तरह से सहमत हैं कि PyTorch को जटिल समर्थन की आवश्यकता है, और
2. हमारे पास उस लंबी पूंछ को पर्याप्त रूप से भरने के लिए जनशक्ति नहीं है जिसकी सभी जटिल परिचालनों की आवश्यकता होगी। (इस बात के प्रमाण के लिए, विरल समर्थन को देखें, जो मास्टर में है और साथ में लंगड़ा रहा है।)

चूंकि इस मुद्दे को 2017 में वापस खोला गया था, कुछ महत्वपूर्ण चीजें बदल गई हैं जो जटिल समर्थन को लागू करना थोड़ा आसान बना सकती हैं। पहला यह है कि अब हमारे पास एटेन है, जो टेंसर में हेरफेर करने के लिए एक एर्गोनोमिक सी ++ लाइब्रेरी है। इसका मतलब यह है कि आपको TH/THC कोड के बड़े पैमाने पर पेस्ट को कॉपी करने की आवश्यकता नहीं है और आशा है कि आपने सभी मैन्युअल रीकाउंटिंग को सही तरीके से प्राप्त कर लिया है, आप C++ कोड को इस तरह लिख सकते हैं जैसे कि यह Python था और यह तेजी से चलेगा। दूसरा यह है कि हम एटीईएन के एक नए संस्करण पर काम कर रहे हैं, जिसे सी10 कहा जाता है, जो एटेन (जो एक बंद चीज है) की तुलना में खुले बैकएंड होने के बारे में अधिक गंभीर है, जिससे जटिल समर्थन पर काम करना आसान हो जाएगा, क्योंकि यह ' t वास्तव में PyTorch को फोर्क करना है, बस कोड की एक नई निर्देशिका जोड़ना है।

इसलिए, @Roger-luo और @PhilippPelz , हम जटिल बैकएंड को एक वास्तविकता बनाने में आपकी मदद करना पसंद करेंगे, लेकिन हम वास्तव में ऐसा करने का एक तरीका निकालना चाहेंगे जो हमें भविष्य में इसे बनाए रखने में मदद करे। मुझे बताओ कि आप क्या सोचते हो।

@ezyang यदि आपके पास जनशक्ति की कमी है, तो मैं भविष्य में जटिल टेंसर भाग को बनाए रखने की कोशिश कर सकता हूं, मैंने अभी अपनी पीएचडी शुरू की है (और यह वास्तव में मेरा अंतराल वर्ष है), और इसलिए मुझे अपनी थीसिस लिखने में समस्या नहीं होगी हाल के वर्षों में कम से कम। लेकिन मैं वास्तव में pytorch टीम से किसी भी प्रतिक्रिया के बिना योगदान देना जारी नहीं रख सकता। मुझे लगता है कि इस बड़े विस्तार के लिए एक रोडमैप होना चाहिए। और हम जटिल समर्थन को सुचारू रूप से जोड़ सकते हैं ताकि आपके लोगों को एक बड़े पीआर की समीक्षा करने की आवश्यकता न हो और यह मास्टर शाखा को ट्रैक करने के लिए डेवलपर्स के प्रयासों को आसान बनाएगा।

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

1. CUDA भाग में cuComplex जैसे एकल जटिल मान का अनुकरण करने के लिए float2 आदि का उपयोग करें।
2. ATen के C++ भाग में एक जटिल टेंसर का अनुकरण करने के लिए मौजूदा FloatTensor और DoubleTensor का उपयोग करें।

दूसरे दृष्टिकोण का कारण यह है कि THC में, पाइटोरच मानचित्र में तेजी लाने/संचालन को कम करने के लिए कुछ तरकीबों का उपयोग करता है और यह cuComplex के लिए तुच्छ रूप से उपयुक्त नहीं है क्योंकि cuComplex वास्तव में float2 है __shfl_xxx फ़ंक्शन मूल रूप से float2 समर्थन नहीं करते हैं। मुझे यकीन नहीं है कि इस समय float2 के लिए इस तरह के फ़ंक्शन को कुशलतापूर्वक अनुकरण कैसे करें।

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

इसके अलावा, मैंने पाया कि जटिल संख्या को एटीईएन में एकीकृत करने के लिए, हमें चार अलग-अलग प्रकारों को संभालना पड़ सकता है जो वास्तव में हार्डवेयर पर समान हैं: std::complex , thrust::complex , cuComplex , float2 जो कभी-कभी खतरनाक हो सकता है। (वास्तव में, मैं पिछले साल इस समस्या से मिला था, और reinterpreter_cast समाधान था)।

हालांकि मैं व्यक्तिगत रूप से सब कुछ अधिक देशी लिखना पसंद करूंगा।

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

एक चेंजलॉग था जब मैं सीपीयू बैकएंड को लागू करने की कोशिश कर रहा था, मैंने वर्गीकृत कार्यों को लॉग में जटिल संख्याओं के लिए संशोधित करने की आवश्यकता है। हम इस लॉग के आधार पर एक रोड मैप लिख सकते हैं।

इसके अलावा, चूंकि मेरा वीज़ा अभी (ऑस्ट्रेलिया द्वारा) अस्वीकार कर दिया गया था, मुझे एक अंतराल वर्ष शुरू करना है, अगर आप चाहते हैं कि कोई इस पर काम करता रहे, तो मैं इंटर्नशिप के लिए आवेदन कर सकता था।

मैंने पिछले दिन इस बारे में बहुत सोचा। यह थोड़ा दुख की बात है कि हम रोजर के प्रयास को वैसे ही मर्ज नहीं कर सके, लेकिन मैंने मन ही मन सोचा

"कम रखरखाव ओवरहेड्स रखते हुए, हम जटिल टेन्सर समर्थन कैसे बना सकते हैं?"

उपरोक्त लक्ष्य से एक प्रभावी योजना के रूप में मैं यही बता रहा हूँ:

• कॉम्प्लेक्स टेंसर एक मौलिक नया टेंसर प्रकार नहीं होना चाहिए, जैसे sparse टेंसर। एक मौलिक प्रकार जोड़ने से बहुत सारे रखरखाव ओवरहेड और क्रॉस-कटिंग परिवर्तन होते हैं। रखरखाव ओवरहेड "जटिल बिट्स को कौन बनाए रखता है?" के बारे में नहीं है, लेकिन "अब सभी कोर-देवों को इस जटिल प्रकार के बारे में पता होना चाहिए जब कोई मौलिक परिवर्तन, कोई एटीईएन परिवर्तन, आदि।"
  
  
  
  • इसके बजाय, उन्हें हमेशा [टेंसर शेप x 2] या [2 x TensorShape] होना चाहिए, यानी टेंसर का आकार 2 के साथ एक अतिरिक्त आयाम होना चाहिए।
  
  
• कॉम्प्लेक्स टेंसर सरल सी ++ की ~ 2k लाइनों की एक छोटी फ़ाइल / फ़ोल्डर होना चाहिए जो एटेन टेन्सर एपीआई के शीर्ष पर बनाया गया हो।
  
  
  
  • उदाहरण के लिए, जैसा कि https://github.com/pytorch/pytorch/issues/6514 से पता चलता है, जटिल गुणन को torch.stack([real1 * real2 - imag1 * imag2, real1 * imag2 + imag1 * real2], dim = -1) के रूप में लागू किया जाना चाहिए जहां real1 = input1[:, :, :, ..., 0]
  
  
  • यह प्रदर्शन को नुकसान पहुंचाता है: हाँ, हम उतने पूर्ण नहीं होंगे जितना कि हम सब कुछ इनलाइन करते हैं। हालांकि, सवाल यह है: "कितने से?"। मुझे लगता है कि हमें स्वस्थ और पूर्ण विशेषताओं वाले + बनाए रखा जटिल समर्थन के बदले में 20% कम प्रदर्शन का लक्ष्य रखना चाहिए।
  
  
  • सबसे अधिक उपयोग किए जाने वाले जटिल फ़ंक्शन समर्पित कर्नेल प्राप्त करना शुरू कर सकते हैं, ताकि जहां प्रदर्शन अक्सर उपयोग किए जाने वाले फ़ंक्शन पर 20% से अधिक हिट ले रहा हो, हम इसमें कदम रखते हैं।
  
  

इसे [टेन्सर शेप x 2] होना चाहिए क्योंकि बीएलएएस, क्यूबला और मैग्मा सभी अपने स्वयं के जटिल प्रकारों की अपेक्षा करते हैं जो फ्लोट 2 के लिए बाइट-संगत हैं। इसके अलावा blas, cublas और magma कॉल को अजगर स्तर पर नियंत्रित नहीं किया जा सकता है।
मुझे नहीं लगता कि यह जटिल गुणा के लिए केवल 20% होगा, क्या आपके पास वास्तविक और कल्पना भाग के लिए गणना के शीर्ष पर 4 पूर्ण प्रतिलिपि संचालन नहीं हैं?
वैसे भी, मुझे तब भी खुशी होगी अगर मुझे लगातार मास्टर से परिवर्तनों में विलय नहीं करना है।

@PhilippPelz से सहमत हैं, हम बहुत अधिक प्रदर्शन खो सकते हैं क्योंकि हम BLAS, cublas और MAGMA से जटिल समर्थन खो देंगे। लेकिन मैं इसके बारे में निश्चित नहीं हूं। हालांकि, स्पष्ट होने के लिए, जटिल टेंसर स्पैस टेंसर से पूरी तरह से अलग है , अधिकांश पुस्तकालय जैसे scipy.sparse , और जूलिया के SparseArrays मौलिक बहु-आयामी सरणी की संरचना के रूप में स्पैस सरणी का इलाज करते हैं। लेकिन कोई भी मिश्रित दो वास्तविक सरणियों द्वारा जटिल प्रकार के साथ एक बहु-आयामी सरणी का इलाज नहीं करता है ... (यहां कोई भी मेरा मतलब टेंसरफ्लो, सरणीफायर, numpy और जूलिया नहीं है)। हालांकि एमएक्सनेट में, एफएफटी वास्तव में दो वास्तविक टेंसरों की एक संरचना द्वारा पूरा किया जाता है, वे जटिल का समर्थन नहीं करते हैं ... ऐसा लगता है कि टेंसरफ्लो ने डेटाटाइप को complex64 और complex128 सहित विभिन्न प्रकारों के चारों ओर एक रैपर के रूप में कार्यान्वित किया है। प्रकार देखें।प्रोटो

प्रदर्शन हानि के बारे में

सबसे पहले, तत्व-वार फ़ंक्शंस (फ़ंक्शन कॉल मैप/कम) में बड़ा प्रदर्शन हानि नहीं होगी (कम से कम, इन परिचालनों के लिए स्मृति संगत होगी)। लेकिन मुझे लगता है कि हमें पहले कुछ बीएलएएस कार्यों को बेंचमार्क करने का प्रयास करना चाहिए, यह देखने के लिए कि FloatTensor की संरचना का GPU पर Complex64Tensor के समान प्रदर्शन है, और हम प्रदर्शन पर कितना खो देंगे मसौदा कार्यान्वयन, जैसे:

• gemm
• gemv

एक मिश्रित जटिल टेंसर कुछ ऐसा दिखता है (या बस shared_ptr का उपयोग करें):

class ComplexTensor {
    FloatTensor *real;
    FloatTensor *imag;
};

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

वर्तमान में torch.fft आकार का एकल फ्लोट टेंसर देता है [dim1, ..., dimN, 2]

@ezyang C10 रिलीज़ की समय-सीमा क्या है? मास्टर शाखा में कॉम्प्लेक्स का समर्थन शुरू करने के लिए यह एक बहुत ही उचित बिंदु की तरह लगता है।

@PhilippPelz निश्चित रूप से 0.4 के लिए नहीं। हम आंतरिक रूप से जून को लक्षित कर रहे हैं, आशा है कि यह प्रतीक्षा करने में बहुत लंबा नहीं है।

@ezyang आपने जून का उल्लेख किया है, क्या आपने PyTorch में जटिल संख्याओं के लिए समर्थन जोड़ने का प्रबंधन किया है?

मुझे लगता है कि उनका मतलब सी 10 था, जटिल समर्थन नहीं। C10 जटिल जोड़ने को आसान बनाने जा रहा है। इस तरह मैंने इसे समझा।

हाँ, C10 में Tensor प्रकार और फ़ंक्शन दोनों का खुला पंजीकरण होगा। तो एक जटिल प्रकार को एक अलग पैकेज के रूप में जोड़ना बहुत आसान होगा।

क्या सम्मिश्र संख्याओं पर कोई ईटीए है? क्या "बहुत आसान" का अर्थ है "शायद जल्दी से किया जाएगा"?

@themightyoarfish बहुत आसान से, मेरा मतलब है कि हम उस पर अवरुद्ध नहीं होंगे जिसे पाइटोरच मास्टर को धक्का दिया जा सकता है। हमने कोई ईटीए सेट नहीं किया है। एक बार जब हम PyTorch में खुला पंजीकरण प्राप्त कर लेंगे, तो मैं काम का दायरा बढ़ा दूंगा।

@ सौमिथ क्या आपको अभी भी इस (जटिल संख्या) पर काम करने के लिए लोगों की आवश्यकता है? PyTorch टीम जटिल संख्याओं का समर्थन करेगी? यदि आप सितंबर में चाहें तो मैं इस पर कुछ समय काम कर सकता हूं, क्योंकि मैं QuCumber को बनाए रखूंगा (यह जटिल संख्या का भारी उपयोग करेगा)

@ रोजर-लुओ हाँ। एक बार जब हमारे पास PyTorch बैकएंड में ओपन-रजिस्ट्रेशन उपलब्ध हो, तो मैं आपसे संपर्क करना चाहता था, और हम विवरण तैयार कर सकते हैं।
@ezyang क्या सितंबर तक हमारे पास ओपन टाइप रजिस्ट्रेशन होगा?

@ सौमिथ कूल, आपकी सेवा में।

आपके द्वारा यह संभव बनाया जा सकता है। (हमारे पास "पूर्ण" नई प्रणाली नहीं होगी, लेकिन जब तक हम चीजों को सेट करते हैं ताकि यह पुन: सक्रिय हो, हम इसे नए विकास के रूप में आगे बढ़ा सकते हैं। यह नए खुले के लिए एक अच्छा परीक्षण मामला होगा। पंजीकरण। मैं यह सुनिश्चित कर सकता हूं कि ऐसा हो।)

@ezyang अब तक कोई नोट? हालांकि इस पर काम करने से पहले मैं इसे पढ़ सकता था। ऐसा लगता है कि पिछली बार से चीजें बहुत बदल गई हैं।

@ रोजर-लुओ @PhilippPelz मैं जटिल टेंसर के कार्यान्वयन में भी आपकी मदद करना चाहूंगा। मुझे अपनी पीएचडी जांच के लिए भी इसकी आवश्यकता है ..

@alexgomezalanis शायद हमारे पास स्लैक पर चर्चा करने के लिए एक चैनल हो सकता है, मैंने अभी एक चैनल कॉल #complex-numbers बनाया है। लेकिन मैं सितंबर तक इस पर काम करना शुरू नहीं करूंगा (अभी भी मेरे कुछ जूलिया कोड पर काम करने की जरूरत है ...)

BTW, ऐसा लगता है कि पिछली बार से बहुत कुछ बदल गया है। इससे पहले कि मैं इस पर हाथ रखूं, मैं पकड़ने के लिए कुछ समय का उपयोग करूंगा।

@alexgomezalanis मैं नहीं कर सकता। आपको पहले पाइटोरच के कार्यक्षेत्र में स्लैक पर शामिल होना होगा। मैं तुम्हें नहीं ढूंढ सकता। निमंत्रण प्राप्त करने के लिए कृपया पते पर एक ईमेल भेजें: [email protected] ।

@ रोजर-लुओ @alexgomezalanis जटिल टेंसर मुद्दे पर जीवन को फिर से देखने के लिए बहुत अच्छा है। मैं भी शामिल होने की पेशकश कर सकता हूं, लेकिन वास्तव में यह सितंबर के अंत/अक्टूबर की शुरुआत तक नहीं होगा। इस मुद्दे पर कुछ टिप्पणीकारों के लिए, मेरे पीएचडी प्रोजेक्ट के लिए जटिल टेंसर समर्थन बहुत उपयोगी होगा।

मैं पिछले साल भी अपने शोध को बचाने की कोशिश कर रहा था … लेकिन अब मैं अपने पुराने 1w+ लोक कोड को फिर से जीवंत करना चाहता हूं। चलो सुस्त पर चैट करें!

:) हाँ, चलो सुस्त पर चैट करें। अभी मेल फोल्डर में आमंत्रण मिला है।

कार्य प्रगति प्लगइन (केवल अल्पावधि में CPU के लिए) यहाँ है: https://github.com/Roger-luo/pytorch-complex

कृपया मुझे मुद्दा और पीआर देने के लिए स्वतंत्र महसूस करें।

मैंने इस बारे में नोट्स पोस्ट किए हैं कि इस मुद्दे के शीर्ष पर जटिल कार्यान्वयन कैसे किया जाएगा।

मैंने हाल ही में PyTorch का उपयोग करना शुरू किया है और मुझे यह बिल्कुल पसंद है - यह TensorFlow की तुलना में उपयोग करने के लिए बहुत अच्छा है। हालांकि, मेरे शोध (ऑप्टिकल न्यूरल नेटवर्क) के लिए जटिल टेंसर समर्थन बहुत महत्वपूर्ण है। क्या इस पर अभी भी सक्रिय रूप से काम किया जा रहा है? यदि हां, तो क्या किसी को जटिल टेंसर समर्थन के लिए एक (ढीली) समय सीमा पता है?

मुझे इस पर काम करने में मदद करने में खुशी होगी जहां मैं कर सकता हूं, लेकिन मैं PyTorch के लिए अपेक्षाकृत नया हूं, इसलिए मुझे अभी तक इस बात का अच्छा अंदाजा नहीं है कि यह सुविधा कितनी बड़ी है। मेरे कुछ लैबमेट्स ने जटिल टेंसर समर्थन में भी गहरी दिलचस्पी व्यक्त की है (भौतिकी में, इसे जोड़ने से मशाल लगभग एक ड्रॉप-इन जीपीयू-त्वरित प्रतिस्थापन NumPy के लिए हो सकता है) और अगर इसका मतलब जटिल समर्थन प्राप्त करना है तो भी मदद करने के लिए तैयार हो सकता है निकट भविष्य।

नमस्ते @benchbartlett

मैं अभी भी इस पर धीरे-धीरे काम करने की कोशिश कर रहा हूं... लेकिन मैं अभी सिर्फ एक छात्र हूं (काफी अस्थिर स्थिति के साथ), जिसका मतलब है कि मैं इस पूरे समय पर काम नहीं कर सकता, लेकिन केवल खाली समय में। (मैं पिछले साल से जूलिया में अपने शोध से संबंधित कोड को लागू करता हूं, जिसका अर्थ है कि केवल हमारे विरासत पैकेज को मशाल से बेहतर जटिल संख्या समर्थन की आवश्यकता है।)

यदि सम्मिश्र संख्या आपके लिए महत्वपूर्ण है और टॉर्च में होना अत्यावश्यक है, तो मेरा सुझाव है कि यह प्रयास करें:

https://github.com/PIQuIL/QuCumber/blob/master/qucumber/utils/cplx.py

यह बहुत धीमा है... लेकिन यह कम से कम काम करता है। या मेरे पास पुरानी TH शैली में C संस्करण था।

यह कोई छोटा प्रोजेक्ट नहीं होगा जिसे कुछ दिनों में पूरा किया जा सके। इसलिए मैं CPU या CUDA पर जटिल मूल्य के साथ पूर्ण कार्यात्मक समर्थन के लिए किसी विशिष्ट समय सीमा की गारंटी नहीं दे सकता।

हालांकि मुझे इस पर मेरे साथ मिलकर काम करने में आपकी मदद करना अच्छा लगेगा। मैं आपको विस्तार रेपो में पोस्ट किए गए मुद्दों को हल करने के प्रयास के साथ शुरुआत करने का सुझाव दूंगा। और कृपया बेझिझक मुझसे स्लैक या ईमेल या समस्या के माध्यम से पूछें यदि आपके कोई प्रश्न हैं (क्योंकि अभी तक बहुत अधिक दस्तावेज़ नहीं हैं)।

दुर्भाग्य से, मेरे पास अभी तक PyTorch Slack तक पहुंच नहीं है। (मैंने आमंत्रण मांगने के लिए दो बार ईमेल किया, लेकिन कोई जवाब नहीं आया।) क्या कोई मुझे आमंत्रित कर सकता है? ([email protected])

@ रोजर-लुओ मैं निश्चित रूप से आपके कांटे को देख लूंगा, लेकिन मैं वादा नहीं कर सकता कि मैं बहुत मदद करूंगा - मेरा सी ++ जंग खा रहा है और जैसा कि आपने बताया, इस पर काम करने के लिए समय निकालना मुश्किल है। छात्र। QuCumber उपयोगिताएँ अच्छी हैं, लेकिन दुर्भाग्य से वे मेरे लिए बहुत मददगार नहीं होंगी: जब तक जटिल टेंसर GPU-समर्थित नहीं होते हैं या ऑटोग्राड और टॉर्च द्वारा समर्थित होते हैं।

@soumith @ezyang PyTorch टीम से इस पर अधिक ध्यान आकर्षित करना बहुत अच्छा होगा! जटिल समर्थन एक सामान्य टेंसर पुस्तकालय के लिए एक महत्वपूर्ण विशेषता की तरह लगता है, यह भौतिकी में लगभग आवश्यक है, और विशेष रूप से पिछले कुछ वर्षों में एमएल के भीतर, जटिल-मूल्यवान मॉडल में तेजी से बढ़ती रुचि रही है।

@benchbartlett QuCumber के दृष्टिकोण का उपयोग AD के साथ GPU पर किया जा सकता है ... यह बहुत धीमा है ... मेरा मतलब है कि यदि आप केवल वह AD चाहते हैं, तो आप इसका उपयोग करने में सक्षम हो सकते हैं।

हाँ, स्पष्ट रूप से, मैं https://github.com/FluxML/Flux.jl के थोड़ा संशोधित संस्करण का उपयोग कर रहा हूं और शोध के लिए जूलिया में अपने कुछ पैकेज (मुझे कुछ परिस्थितियों में भी टेंसर के साथ GPU पर जटिल AD की आवश्यकता है) ) Source2source AD ​​पैकेज Zygote.jl जटिल टेंसर पर AD कर सकता है, लेकिन यह बहुत प्रारंभिक चरण में है जिसमें खंड दोष हो सकते हैं। पारिस्थितिकी तंत्र इतना स्थिर नहीं है फिर भी मशाल की तुलना में, मुझे कभी-कभी उन कार्यान्वयन को स्वयं-उपयोग के लिए थोड़ा सा हैक करना पड़ता है ... लेकिन यह मूल रूप से क्वांटम भौतिकी में शोध के लिए आवश्यक चीज़ों के लिए काम करता है। मेरे पास GPU पर भी जटिल टेंसर हो सकते हैं।

मुझे नहीं लगता कि torch.nn के लिए जटिल मूल्य समर्थन की आवश्यकता है, जटिल टेंसर के काम करने के बाद हमें autograd के लिए कुछ परिभाषाओं को जोड़ने की आवश्यकता हो सकती है, क्योंकि रैखिक परतों जैसी चीजें समान रह सकती हैं . और कुछ सक्रियण फ़ंक्शन का हिल्बर्ट स्पेस में मानक विस्तार नहीं हो सकता है ... (आप मेरे सहयोगी @GiggleLiu के ब्लॉग पोस्ट की जांच कर सकते हैं)

पाइटोरच-कॉम्प्लेक्स एक्सटेंशन के लिए, मुझे यकीन नहीं है कि हमें GPU पर AD के साथ पूर्ण समर्थन कब मिल सकता है ... यह अभी भी मुझे बहुत दूर लगता है। मैं कहूंगा कि सीपीयू कार्यान्वयन कुछ अवधि के माध्यम से जाएगा जिसके लिए मुख्य पेड़ में पैच की आवश्यकता होती है (उदाहरण के लिए प्रचार, सिम समर्थन, इत्यादि), यह सी ++ में आने वाले एटीईएन कार्यान्वयन से भी संबंधित हो सकता है और टीएच, आदि से छुटकारा पा सकता है। और फिर हम जटिल टेंसरों के लिए ऑपरेटरों को तेजी से जोड़ पाएंगे।

मैं स्प्रिंग में इंटर्नशिप के लिए आवेदन कर सकता हूं (जिसके बारे में मैंने अभी @ezyang से पूछा था)। इसलिए मैं अपनी पीएचडी शुरू करने से पहले कई महीनों तक इस पूर्णकालिक पर काम करने में सक्षम हो सकता हूं। आइए देखते हैं।

इस बीच, मैंने जटिल गुणन का अपना संस्करण लागू किया। हालांकि, जब मैं इसे प्रोफाइल करता हूं, तो ऐसा होता है कि इसमें काफी समय लगता है: टॉर्च._C_._cuda_isDriverSufficient

क्या आपके पास कोई विचार है क्यों? यदि आप जटिल गुणन के बेहतर कार्यान्वयन के बारे में जानते हैं तो कृपया मुझे बताएं। किसी भी तरह, मेरा संस्करण (भले ही गुणन की संख्या के लिए अनुकूलित: 4 के बजाय 3) अपेक्षाकृत धीमा प्रतीत होता है, उदाहरण के लिए आउट टेंसर का irfft मेरे तत्व-वार गुणा से 10X तेज है। क्या जटिल गुणन PyTorch के C++ स्तर पर समर्थित है?

def complex_mul(x, y, out):
    uavc = x[..., 0] * (y[..., 0] + y[..., 1])
    out[..., 0] = uavc - (x[..., 0] + x[..., 1]) * y[..., 1]
    out[..., 1] = (x[..., 1] - x[..., 0]) * y[..., 0] + uavc

def test_complex_mul_out_tensor(self):
        N, C, H, W, I = 128, 3, 32, 32, 2
        K = 16  # number of filter banks
        repetitions = 1000
        dtype = torch.float
        if torch.cuda.is_available():
            device = torch.device("cuda")
        else:
            device = torch.device("cpu")
        x = torch.randn(N, 1, C, H, W, I, dtype=dtype, device=device)
        y = torch.randn(K, C, H, W, I, dtype=dtype, device=device)
        start_mul_time = time.time()
        out = torch.empty(N, K, C, H, W, I, dtype=dtype, device=device)
        for _ in range(repetitions):
            complex_mul(x, y, out)
        print("multiplication time: ", time.time() - start_mul_time)

हम इसे C++ से सपोर्ट करने की कोशिश कर रहे हैं। शीर्ष पर पोस्ट देखें। यदि आप एक्सटेंशन को संकलित कर सकते हैं, तो इसे कम से कम इस समय स्केलर गुणा के लिए काम करना चाहिए ....

आपका कार्यान्वयन वैसा ही है जैसा हमारे पास QuCumber में है। यदि आप जटिल संख्या के लिए सही क्यूडा कर्नेल को कॉल नहीं करते हैं तो यह बहुत अधिक GPU थ्रेड्स को कॉल कर सकता है। और यदि आपके पास Python में समर्थन के रूप में C++ बैकएंड नहीं है, तो आप SIMD खो सकते हैं।

मेरा सुझाव है कि आप अधिक विवरण प्राप्त करने के लिए nvprof चलाएं।

@ रोजर-लुओ @apaszke @soumith इस धागे बीटीडब्ल्यू के लिए धन्यवाद। मैंने सबक्लासिंग टॉर्च से एक साथ हैक किया गया एक बुनियादी जटिल टेंसर लागू किया। टेंसर।

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

मैंने Tensorflow और numpy के विरुद्ध सत्यापन किया। मेरे द्वारा लागू किए गए ग्रेडिएंट और सभी ऑप्स उनके आउटपुट से मेल खाते हैं!

यह सिर्फ एक होल्डओवर के रूप में अभिप्रेत है जब तक कि पीटी पूरी तरह से जटिल टेंसर का समर्थन नहीं करता है।

विशेषताएं:

1. परीक्षण लागू किए गए।
2. पीपीआई समर्थित (यानी: पाइप स्थापित करें)

pip install pytorch-complex-tensor

https://github.com/williamFalcon/pytorch-complex-tensor

धन्यवाद @williamFalcon !

यह कोई अपडेट? बस सोच रहा था कि क्या पाइटोरच में जटिल प्रकार के समर्थन को एकीकृत करने की योजना होगी।

नमस्ते, @whmrtm

@ezyang https://github.com/Roger-luo/pytorch-complex/issues/4 पर काम कर रहा है या जो कोई भी इसमें रुचि रखता है वह इसे चलाने में हमारी मदद कर सकता है। यह समस्या कुछ बुनियादी प्रसारण समस्या को हल करेगी (तब आप इसे हल करने के बाद बहुत सारे कार्यों का उपयोग कर सकते हैं)। कृपया कोई भी पीआर करने के लिए स्वतंत्र महसूस करें या मुझे आपको सहयोगी के रूप में जोड़ने के लिए कहें।

मैं गर्मियों तक कुछ भी काम नहीं कर पाऊंगा, अपने पैकेज के लिए एक नई रिलीज खत्म करनी होगी।

नमस्ते, @whmrtm

@ezyang Roger-luo/pytorch-complex#4 पर काम कर रहा है या जो कोई भी इसमें दिलचस्पी रखता है वह इसे चलाने में हमारी मदद कर सकता है। यह समस्या कुछ बुनियादी प्रसारण समस्या को हल करेगी (तब आप इसे हल करने के बाद बहुत सारे कार्यों का उपयोग कर सकते हैं)। कृपया कोई भी पीआर करने के लिए स्वतंत्र महसूस करें या मुझे आपको सहयोगी के रूप में जोड़ने के लिए कहें।

मैं गर्मियों तक कुछ भी काम नहीं कर पाऊंगा, अपने पैकेज के लिए एक नई रिलीज खत्म करनी होगी।

अपडेट के लिए धन्यवाद, मैं देखूंगा कि मैं क्या कर सकता हूं।

हाय @ रोजर-लुओ

क्या मैं जटिल टेंसर समर्थन विषय ([email protected]) से संबंधित स्लैक चैनल तक पहुंच सकता हूं? मैंने आमंत्रण के लिए ईमेल किया लेकिन अभी तक कुछ नहीं हुआ। अभी मैं यह पता लगाने की कोशिश कर रहा हूं कि इस मुद्दे पर कहां से योगदान देना शुरू किया जाए। मुझे लगता है कि https://github.com/Roger-luo/pytorch-complex/issues/4 अब एक वर्तमान प्रवेश बिंदु है?

@beconstant हाँ, यह प्रारंभ बिंदु है, इससे कुछ प्रसारण फ़ंक्शन काम करना चाहिए, लेकिन मुझे नहीं पता कि यह क्यूडा पर टाइप प्रमोशन त्रुटि क्यों फेंकता है, यह सीपीयू पर काम कर रहा था। (हालांकि हम पहली बार में कूडा का समर्थन करने का इरादा नहीं रखते हैं, इससे बिल्ड विफलता होगी)

मैं आपको आमंत्रण ईमेल नहीं भेज सकता (मेरे पास पहुंच नहीं है)। मुझे लगता है कि स्लैक में शामिल होने के लिए आपको पाइटोरच आधिकारिक गाइड का पालन करना चाहिए। लेकिन हम हमेशा मुद्दे/पीआर में चर्चा कर सकते हैं।

@ रोजर-लुओ ठीक है, समझ गया :)

अगर आप लोगों को किसी मदद की जरूरत हो तो बताएं। मैं निर्दिष्ट pytorch संस्करण का निर्माण करके शुरू करूंगा। पाइटोरच-कॉम्प्लेक्स/मुद्दों/4 पर कोई प्रगति?

अगर आप लोगों को किसी मदद की जरूरत हो तो बताएं। मैं निर्दिष्ट pytorch संस्करण का निर्माण करके शुरू करूंगा। पाइटोरच-कॉम्प्लेक्स/मुद्दों/4 पर कोई प्रगति?

@dylanbespalko हाय, मुझे तत्काल जटिल-मूल्यवान संस्करण में लागू pytorch की आवश्यकता है।
आपके योगदान के लिए बहुत-बहुत धन्यवाद।

सादर,
ज़ेलर209

हाय @ ज़ेलर209 ,

मुझे लग रहा है कि @ezyang बड़े मुद्दों में से एक पर कड़ी मेहनत कर रहा है ( pytorch-complex/issues/4 )। मेरे पास अब एक AMD सिस्टम है और 3 सप्ताह में एक Nvidia सिस्टम है जिसका उपयोग मैं GPU समर्थन को बढ़ाने के लिए कर सकता हूं।

मुझे लगता है कि समस्या मूल प्रकार के प्रचार परिवर्तन के बारे में है, CUDA को तोड़ता है, जब तक कि पीआर हल हो जाता है, कम से कम कुछ ऑपरेटर CPU पर काम करते हैं, हमारे पास अभी तक CUDA समर्थन नहीं है ...

आईएमएचओ मुझे लगता है कि हमें सीपीयू पर ध्यान देना चाहिए और चीजों को पहले काम करना चाहिए, फिर बाद में जीपीयू पर विचार करना चाहिए।

सीपीयू केवल समर्थन ठीक है। क्या इस प्रकार की पदोन्नति समस्या है ( पाइटोरच-कॉम्प्लेक्स/मुद्दों/4 को एफबी द्वारा आंतरिक रूप से नियंत्रित किया जा रहा है? क्या बाहरी रूप से इस पर काम करना ठीक है?

हाय @dylanbespalko; मैंने रोजर-लुओ को बताया था कि मैं इस पर गौर करने जा रहा था (क्योंकि मैं शायद यह पता लगाने के लिए सबसे अच्छी स्थिति में था कि समस्या क्या है), लेकिन मेरे पास अभी तक इसे देखने का समय नहीं है। यदि आप समस्या को ठीक करने के तरीके के बारे में जानना चाहते हैं, तो मुझे सलाह देने में खुशी होगी।

हाय @ ज़ेलर209 ,

मुझे लग रहा है कि @ezyang बड़े मुद्दों में से एक पर कड़ी मेहनत कर रहा है ( pytorch-complex/issues/4 )। मेरे पास अब एक AMD सिस्टम है और 3 सप्ताह में एक Nvidia सिस्टम है जिसका उपयोग मैं GPU समर्थन को बढ़ाने के लिए कर सकता हूं।

हाँ, मुझे अब किसी GPU की आवश्यकता नहीं है, मैं MAC सिस्टम का उपयोग कर रहा हूँ। लेकिन इस परियोजना को बनाते समय मुझे कुछ त्रुटियां हुई हैं।

हाय @ ज़ेलर 209 , क्या आप पोस्ट कर सकते हैं जो आपको पाइटोरच-कॉम्प्लेक्स के मुद्दे में मिलता है? मुझे लगता है कि मैक के नए एक्सकोड में कुछ गड़बड़ है, जिससे इसे बनाना मुश्किल हो जाता है। लेकिन लोगों को यह पता लगाने के लिए कुछ और त्रुटि संदेश की आवश्यकता होगी कि क्यों।

मैंने ओएस और त्रुटि संदेश के बारे में पूछा, लेकिन आपने जवाब नहीं दिया ...

हाय @dylanbespalko; मैंने रोजर-लुओ को बताया था कि मैं इस पर गौर करने जा रहा था (क्योंकि मैं शायद यह पता लगाने के लिए सबसे अच्छी स्थिति में था कि समस्या क्या है), लेकिन मेरे पास अभी तक इसे देखने का समय नहीं है। यदि आप समस्या को ठीक करने के तरीके के बारे में जानना चाहते हैं, तो मुझे सलाह देने में खुशी होगी।

आपके शीघ्र उत्तर के लिए धन्यवाद।

1. जब मैं gcc (डिफ़ॉल्ट) का उपयोग करके "python setup.py install" चलाता हूं, तो मुझे इस तरह की त्रुटियां मिलती हैं:

'torch_complex.cpp' एक्सटेंशन का निर्माण
जीसीसी-अप्रयुक्त-अप्रयुक्त-परिणाम-साइन-तुलना-अयोग्य-कोड-डीएनडीईबीयूजी-जी-fwrapv-O3-दीवार-सख्त-प्रोटोटाइप-आई/एनाकोंडा3/शामिल-आर्क x86_64-आई/एनाकोंडा3/शामिल-आर्च x86_64-I/ anaconda3/lib/python3.6/site-packages/torch/include -I/anaconda3/lib/python3.6/site-packages/torch/include/torch/csrc/api/include -I/anaconda3/lib/python3. 6/साइट-पैकेज/टॉर्च/शामिल/TH-I/anaconda3/lib/python3.6/साइट-पैकेज/टॉर्च/शामिल/THC-I/anaconda3/include/python3.6m -c src/module.cpp -o build/temp.macosx-10.7-x86_64-3.6/src/module.o -g -stdlib=libc++ -std=c++11 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=cpp
जीसीसी: त्रुटि: अपरिचित कमांड लाइन विकल्प '-stdlib=libc++'

त्रुटि: आदेश 'gcc' बाहर निकलने की स्थिति के साथ विफल रहा 1

2. जब मैं इसे संकलित करने के लिए क्लैंग का उपयोग करता हूं, तो त्रुटियां हैं:

फ़ाइल में src/module से शामिल है। सीपीपी:2 :
src/CPUComplexType.h:60 से शामिल फ़ाइल में:
src/CPUComplexTypeImpl.h:102:105: चेतावनी: 'IntList' पदावनत है [-Wdeprecated-declarations]
Tensor & CPUComplexType::set_(Tensor & self, Storage Source, int64_t storage_offset, IntList Size, IntList स्ट्राइड्स) const {
^
/anaconda3/lib/python3.6/site-packages/torch/include/c10/util/ArrayRef.h:273:7: नोट: 'IntList' को यहां स्पष्ट रूप से पदावनत चिह्नित किया गया है
IntList C10_DEPRECATED_USING = ArrayRef . का उपयोग करना;
^
फ़ाइल में src/module से शामिल है। सीपीपी:2 :
src/CPUComplexType.h:60 से शामिल फ़ाइल में:
src/CPUComplexTypeImpl.h:105:76: त्रुटि: 'पर' नाम स्थान में 'scalarTypeToDataType' नाम का कोई सदस्य नहीं
auto source_ = check_storage(source,"source",2, DeviceType::CPU, at::scalarTypeToDataType(CPUComplexTypeInfo::scalar_type));
~~~~^
7 चेतावनियाँ और 2 त्रुटियाँ उत्पन्न हुईं।

त्रुटि: कमांड 'क्लैंग' बाहर निकलने की स्थिति के साथ विफल रहा 1

मैं इसे ठीक नहीं कर सकता। मुझे वाकई उम्मीद है कि आप मेरी मदद कर सकते हैं!

हे लोगों,

आपकी प्रतिक्रिया के लिए धन्यवाद। मुझे लगता है कि मैं इसे देखते हुए सप्ताह बिता सकता हूं। अब तक मैंने संकलित किया है @ रोजर-लुओ के पाइटोरच-कॉम्प्लेक्स को निम्नानुसार संकलित किया है:

@ Zellar209 : मैंने macOS 10.13.1 पर चलने वाले अपने पर्यावरण चर संलग्न किए हैं।

1. मौजूदा pytorch वितरण को निम्नानुसार हटाएं
   कोंडा अनइंस्टॉल पाइटोरच
   पाइप अनइंस्टॉल मशाल
   पाइप अनइंस्टॉल टॉर्च # इस कमांड को दो बार चलाएं
   अजगर setup.py स्वच्छ
   यदि मौजूद है तो पायथन साइट-पैकेज फ़ोल्डर में मशाल फ़ोल्डर हटाएं।
   पिछले pytorch स्रोत फ़ोल्डर का नाम बदलें (या हटाएं) (कुछ इसका जिक्र कर रहा था)।

2. PyTorch संशोधन 6cb593b88cb0c411690b4957850058329526d87b स्थापित करें।

    git clone [email protected]:pytorch/pytorch.git
    git checkout 6cb593b88cb0c411690b4957850058329526d87b
    git submodule update --init —recursive
    export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../“}
    MACOSX_DEPLOYMENT_TARGET=10.13 CC=clang CXX=clang++ python setup.py develop
    python

>>> import torch

1. पाइटोरच-कॉम्प्लेक्स स्थापित करें

    python setup.py install
    python setup.py build
    python setup.py test
    # ERROR: test (unittest.loader._FailedTest)
    # ERROR: test_scalar_binary_op (tests.test_tensor.TestComplexTensor)

1. एक जटिल टेंसर बनाएं

   from torch_complex import torch
   a = torch.ones(3, dtype=torch.complex128)
   a*a  
   RuntimeError: promoteTypes with complex numbers is not handled yet; figure out what the correct rules should be

@ezyang , @ रोजर-लुओ:

टेन्सर ऑपरेशंस के लिए टाइप प्रमोशन के लिए सब कुछ c10/core/ScalarType.h में किया जाता है
मुझे त्रुटि मिली है AT_ERROR("promoteTypes with complex numbers is not handled yet; figure out what the correct rules should be”);
ऐसा लगता है कि मुझे इस तालिका के अंदर c8 और c16 के लिए एक प्रविष्टि जोड़नी है।
क्या इसका 9515 से कोई लेना-देना है? मुझे लगता है कि यह सिर्फ numpy कार्यों को कॉल करने के लिए है।
क्या यह शुरू करने के लिए एक अच्छी जगह है?

9515 असंबंधित है। हालांकि, ScalarType.h में इस कोडपथ को ठीक करना शुरू करने के लिए एक अच्छी जगह है।

मैंने ScalarType.h . में कोडपथ तय किया है
बाइनरीऑप्स (ऐड, सब, मल, डिव) काम कर रहे हैं, लेकिन केवल तभी जब दोनों तर्क टेंसर हों।
कुछ अन्य अजीब मुद्दे, लेकिन मुझे इसे और देखने की जरूरत है।

@dylanbespalko मैंने यहां प्रकार के प्रचार जोड़े हैं: https://github.com/pytorch/pytorch/pull/11641

आप बस इसे कॉपी कर सकते हैं, लेकिन समस्या यह है कि यह किसी भी तरह CUDA को तोड़ देता है।

आईआईआरसी, जीसीसी संस्करण के कारण एक तार बग था। मेरे पास वहां कुछ कामकाज थे।

आह, धन्यवाद @ रोजर-लुओ। मैं #11641 की टिप्पणियों को देख रहा था। मैं कल कोड को कॉपी करने का बेहतर काम करूंगा।

जब मेरे पास CUDA डिवाइस नहीं है तो मुझे कैसे पता चलेगा कि मैंने CUDA को तोड़ा है? मुझे लगता है कि सीआई मुझे बताएगा?

हां, जैसे ही आप एक पीआर जमा करते हैं, यह आपको बताएगा कि कौन सा टूटा हुआ है। और अगर सब कुछ बस बीत जाता है, तो हम बस उसे मर्ज कर सकते हैं और काम कर सकते हैं।

ठीक है, तो मैं पीआर जमा करना शुरू कर दूंगा ताकि मुझे पता चले कि यह कब होगा।

@dylanbespalko हाय, अभी भी आपके वातावरण में कुछ त्रुटियां हैं?
यदि आप इसे ठीक करते हैं, तो कृपया हमारे साथ साझा करें। बहुत - बहुत धन्यवाद।

हे लोगों,

मैंने रोजर-लुओ के कई कामों की नकल करने के बाद कई पीआर करने की कोशिश की। दुर्भाग्य से, मेरे पास अभी CUDA GPU नहीं है और CUDA वाली CI मशीनें प्रारंभ नहीं हो रही हैं। मैं अभी CUDA परीक्षण विफलता को फिर से नहीं बना सकता, इसलिए मैं कुछ हफ्तों में इस पर वापस आऊंगा जब मैं स्थानीय रूप से उस GPU पर चल सकता हूं। आशाजनक लग रहा है, कम से कम।

@ezyang , @Roger-luo

मैंने रोजर के पीआर #11641 पर एक नज़र डाली है:

• यह मेरी CUDA 9.0 मशीन पर बनाता है और चलता है
• यह CI मशीनों पर निर्माण करने में विफल रहता है जो CUDA 9.0 . चला रहे हैं

मैंने हाल के कुछ PyTorch विकासों पर भी एक नज़र डाली है:

• @ezyang की एक प्रस्तुति यह बताती है कि C++/CUDA एक्सटेंशन कैसे लिखना है जो एक कस्टम डिवाइस/लेआउट/dtype को परिभाषित कर सकता है।
  
  
  
  • एक और हालिया पीआर #21964 जो "ComplexHooksInterface को हटाता है", लेकिन pytorch/test/cpp_extensions/complex_registration_extension.cpp पर स्थित एक जटिल संख्या C++ एक्सटेंशन को परिभाषित करता है।
  
  

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

1. AVX के बिना कॉम्प्लेक्स CPU सपोर्ट को परिभाषित करें।
2. थ्रस्ट का उपयोग करके कॉम्प्लेक्स CUDA सपोर्ट को परिभाषित करें।

@ezyang
क्या आप इस आउट-ऑफ-ट्री डिवाइस/लेआउट/डीटाइप एक्सटेंशन के लिए अपेक्षित समयरेखा प्रदान कर सकते हैं जिसे आपने प्रस्तुत किया था? क्या हम अगले 3 महीनों में इस सुविधा की उम्मीद कर सकते हैं?

@ezyang

क्या आप AVX/SSE सपोर्ट के बिना CPU पर कॉम्प्लेक्स नंबर सपोर्ट को मर्ज करने में सक्षम हैं? मैं अलग मर्ज-अनुरोधों में निम्नलिखित जमा करने की योजना बना रहा हूं:

• [ ] सीपीयू बाइनरीऑप कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] CPU TensorFactories का जटिल समर्थन जोड़ा गया
• [] सीपीयू फिल कर्नेल का जटिल समर्थन जोड़ा गया
• [] सीपीयू रेंज कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] सीपीयू यूनरी कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] सीपीयू का जोड़ा जटिल समर्थन गुठली की तुलना करें
• [ ] CPU Tensor का जटिल समर्थन जोड़ा गया गुठली की तुलना करें
• [ ] CPU ReduceOp कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] CPU PointwiseOps कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] CPU learpOps कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] CPU LinearAlgebraOps कर्नेल का जटिल समर्थन जोड़ा गया
• [ ] सीपीयू स्पेक्ट्रलऑप्स कर्नेल का जटिल समर्थन जोड़ा गया

मेरी योजना अगले कुछ दिनों में इंटेल/आर्म सीपीयू में इसका परीक्षण करने की है।

@ezyang ,

मैं fft() और var() जैसे संचालन में देख रहा हूं जहां जटिल संख्या कार्यान्वयन को टेंसर डेटा को आकार के डबल टेंसर में परिवर्तित करना होगा: (complex_shape, 2) । यह किसी भी मौजूदा टेंसर विधियों के साथ काम नहीं करता है:

1. 'tensor.to(torch.float64): केवल वास्तविक भाग रखता है, और उसी आकार के साथ एक टेंसर देता है।
2. 'tensor.view(new_shape): नए आकार में तत्वों की संख्या समान होनी चाहिए।

जाहिर है मैं कुछ अक्षम कर सकता हूँ जैसे:

def to_float(tensor):
    return th.stack((tensor.real().type(th.float64), tensor.imag().type(th.float64)), -1)

def to_complex(tensor):
    tensor = tensor.type(th.complex128) 
    return tensor[..., 0] + 1j*tensor[..., 1]

जाहिर है कि प्रतियां बना रहा है, जब मुझे केवल static_cast<double> की जरूरत है और टेंसर के आकार को (old_shape, 2) में बदलना है। क्या आपके पास ऐसा करने के बारे में कोई सुझाव है?

इसके अलावा, numpy में एक हैक है जो आपको ऐसा करने की अनुमति देता है:

a = np.array([1 + 1j], dtype=np.complex128)
a.dtype = np.float64  ## This works

a = torch.tensor([1 + 1j], dtype=torch.complex128)
a.dtype = torch.float64  ## This does not work

इस स्थिति में dtype सेट करने की क्षमता वास्तव में काम करती है, हालांकि यह अप्रत्याशित हो सकता है।

किसी सम्मिश्र संख्या को वास्तविक संख्याओं की लंबाई-2 सरणी के रूप में व्याख्या करने के संबंध में कुछ अतिरिक्त जानकारी। निम्नलिखित सी ++ 11 में मान्य है।

किसी भी सूचक के लिए जटिल संख्या p और किसी भी मान्य सरणी अनुक्रमणिका के एक तत्व के लिए i, reinterpret_cast(p)[2 i] सम्मिश्र संख्या p[i] का वास्तविक भाग है, और reinterpret_cast(पी) [2 i + 1] सम्मिश्र संख्या p[i] का काल्पनिक भाग है। (सी ++ 11 के बाद से)

मुझे लगता है कि इसका मतलब है कि एक कॉम्प्लेक्स_टेन्सर को एक वास्तविक_टेन्सर को आकार (कॉम्प्लेक्स_शेप, 2) के साथ परिवर्तित करना संभव है और फिर real() और imag() को कॉल किए बिना एक ऑपरेशन करना संभव है जो नई मेमोरी आवंटित करता है।

@dylanbespalko मुझे डर था कि आप इस बारे में कब पूछेंगे :) std::complex गारंटी का मतलब है कि यदि आपके पास डेटा पॉइंटर std::complex<float>* है, तो आप इसे सुरक्षित रूप से float* में डाल सकते हैं (मम्बल सख्त अलियासिंग) और फिर इसे जो भी fft चीज आप उपयोग कर रहे हैं उसे पास करें। यदि आपको केवल fft/var लागू करने की आवश्यकता है जहां आप इस निम्न स्तर के प्रतिनिधि को पास कर सकते हैं, तो यह सबसे आसान होगा।

हालाँकि, यदि आपको एक जटिल टेंसर को फ्लोट टेंसर के रूप में सचमुच फिर से देखने की आवश्यकता है, तो हम थोड़ा अचार में हैं, क्योंकि आज PyTorch में इसके लिए कोई मिसाल नहीं है। Storage dtype हमेशा Tensor dtype से सहमत होता है। इसलिए यदि आप एक जटिल भंडारण बनाते हैं तो इसे फ्लोट स्टोरेज के रूप में समीक्षा करने का कोई तरीका नहीं है।

एक ने सोचा कि मेरे पास है शायद हमें इस अपरिवर्तनीय को आराम देना चाहिए। विचार है:

1. हम हमेशा स्टोरेज को "अन-वेक्टराइज्ड" प्रकार के रूप में आवंटित करते हैं। तो एक परिसर के लिएहम एक फ्लोट टेंसर आवंटित करते हैं।
2. Tensor dtype को स्टोरेज dtype से असहमत होने की अनुमति है, लेकिन केवल अंतर्निहित प्रकार के वेक्टरकृत संस्करण के रूप में

मुझे यकीन नहीं है कि इस अपरिवर्तनीय को बनाने के लिए हमें कितना कोड बदलना होगा।

@ezyang ,

हाँ यह अपरिहार्य था ...

यदि आपको केवल fft/var लागू करने की आवश्यकता है जहां आप इस निम्न स्तर के प्रतिनिधि को पास कर सकते हैं, तो यह सबसे आसान होगा।

हाँ यह कई मामलों में संभव है। क्या आप टेंसर डेटा को std::vector के रूप में व्याख्या करने का एक कोड-स्निपेट प्रदान करने में सक्षम हैं?

हालांकि, अगर आपको एक जटिल टेंसर को फ्लोट टेंसर के रूप में सचमुच फिर से देखने की ज़रूरत है, ....

मुझे लगता है कि किसी अन्य प्रकार के टेन्सर को देखना दुर्लभ है। मैंने set_dtype() के लिए Tensor $ विधि लागू की, लेकिन मुझे कुछ त्रुटियां मिलीं। मैंने आकार में बदलावों को दर्शाने के लिए प्रगति को भी अपडेट नहीं किया। मुझे यकीन नहीं है कि क्यों dtype numpy में काम करता है (क्या यह एक संयोग है?), हालांकि जब आप डिजिटल-से-एनालॉग कनवर्टर (डीएसी) पर डेटा अपलोड करते हैं तो यह अक्सर वास्तविक/काल्पनिक डेटा को इंटरलीव किए जाने की अपेक्षा करता है। जैसा कि आपने सुझाव दिया है, शायद यह स्टोरेज डीटाइप से टेंसर डीटाइप को डिकूप करने की आवश्यकता को प्रेरित करेगा।

मैं अभी के लिए ऐसा करने से बचूंगा। मुझे यकीन है कि मेरे लिए अन्य प्रदर्शन बाधाएं हैं।

हाँ यह कई मामलों में संभव है। क्या आप टेंसर डेटा को std::vector के रूप में व्याख्या करने का एक कोड-स्निपेट प्रदान करने में सक्षम हैं?

बिल्कुल नहीं एक एसटीडी :: वेक्टर, लेकिन मैं कुछ इस तरह की कल्पना कर रहा हूँ:

Tensor complex_tensor;
assert(complex_tensor.is_contiguous());
std::complex<float>* cp = complex_tensor.data_ptr<std::complex<float>>();
float* fp = reinterpret_cast<float*>(cp);
auto num_floats = complex_tensor.numel() * 2;

मैंने टेंसर के लिए एक set_dtype() विधि लागू की, लेकिन मुझे कुछ त्रुटियां मिलीं। मैंने आकार में बदलावों को दर्शाने के लिए प्रगति को भी अपडेट नहीं किया।

हाँ, यह शायद एक बुरा विचार है यदि आप भी प्रगति को ठीक नहीं करते हैं। इसके अलावा, मैं अन्य dtypes में ट्रांसमिटिंग टेंसर का बहुत बड़ा प्रशंसक नहीं हूं; यह सब जगह से बाहर करने के लिए बेहतर है :)

हालांकि जब आप डिजिटल-से-एनालॉग कनवर्टर (डीएसी) पर डेटा अपलोड करते हैं तो यह अक्सर वास्तविक/काल्पनिक डेटा को इंटरलीव किए जाने की अपेक्षा करता है। जैसा कि आपने सुझाव दिया है, शायद यह स्टोरेज डीटाइप से टेंसर डीटाइप को डिकूप करने की आवश्यकता को प्रेरित करेगा।

हां, आखिरकार यह करना सही है, लेकिन मैं मानता हूं कि अब ऐसा नहीं करना आसान हो गया है।

@ezyang ,

मैं जटिल संख्या CUDA समर्थन के साथ गड़बड़ करना शुरू कर रहा हूं।

दो द्विआधारी संगत विकल्प हैं:

1. cuComplex : बहुत ही बेसिक ऐड, सब, mul, div, रियल, इमेज सपोर्ट।
2. थ्रस्ट :: कॉम्प्लेक्स : std::complex के प्रतिस्थापन में ड्रॉप जो होस्ट और डिवाइस मेमोरी आवंटन का समर्थन करता है।

जोर :: जटिल कंटेनर जाने का रास्ता प्रतीत होता है। थ्रस्ट :: कॉम्प्लेक्स एपीआई का सुझाव है कि thrust::complex<T> कंटेनरों को होस्ट और डिवाइस मेमोरी पर आवंटित किया जा सकता है, जबकि std::complex<T> केवल होस्ट मेमोरी पर आवंटित किया जा सकता है:

__host__ __device__     thrust::complex< T >::complex (const complex< T > &z)  //thrust container
__host__    thrust::complex< T >::complex (const std::complex< T > &z) //stl container.

1. क्या यह सुझाव दे रहा है कि AT_DISPATCH_COMPLEX_TYPES को $#$ using scalar_t = std::complex<double> $#$ के बजाय using scalar_t = thrust::complex<double> सेट करना चाहिए?

2. वास्तविक डेटा प्रकारों के लिए Pytorch स्वचालित रूप से std::log के CUDA समकक्षों को कैसे कॉल करता है? मुझे कैसे पता चलेगा कि गणित कर्नेल के बराबर CUDA है?

1. मुझे लगता है कि सीपीयू और सीयूडीए के लिए सार्वभौमिक रूप से thrust::complex<double> का उपयोग करने में कठिनाई यह है कि यदि आप केवल सीपीयू बनाते हैं तो हम वास्तव में जोर के खिलाफ निर्माण नहीं करते हैं। मुझे लगता है कि विकल्पों का एक गुच्छा है; हम अपना खुद का जटिल प्रकार रोल कर सकते हैं (इसी तरह हम अपने आधे प्रकार को कैसे रोल करते हैं), या आप जीत के लिए अपना रास्ता फिर से व्याख्या कर सकते हैं, क्योंकि std::complex<> को एक विशिष्ट बाइनरी लेआउट के लिए परिभाषित किया गया है। यह आप पर निर्भर है, लेकिन अभी के लिए प्रकारों के बीच कास्टिंग की पुनर्व्याख्या करना आसान लगता है।
2. हमारे पास THCNumerics.cuh में गणित का अधिभार है, क्या यह आपके प्रश्न का उत्तर देता है?

@iotamudelta ने #29547 . में C++11 अनुपालन के साथ एक मुद्दा उठाया है

std::real केवल C++14 से constexpr है

अगर मैं सही ढंग से समझता हूं कि std::real() को constexpr होना चाहिए ताकि एचसीसी कंपाइलर __device__ के लिए निर्देश संकलित कर सके।

संभव समाधान:

1. complex<double> को double में बदलने के लिए कोई अन्य विधि या फ़ंक्शन खोजें:
   
   
   
   • abs या तो काम नहीं करता: टेम्पलेटटी एब्स (कॉन्स्ट कॉम्प्लेक्स)& एक्स) ;
   
   

1. फ़ंक्शन को लपेटने का एक तरीका खोजें:

   • std::real पर अधिकांश कॉल aten/src/ATen/native/cpu/zmath.h में की जाती हैं। उदाहरण: inline w/ constexpr बदलें:

     inline VALUE_TYPE real_impl (SCALAR_TYPE z) ->
     constexpr VALUE_TYPE real_impl (SCALAR_TYPE z)

     inline std::complex<float> real_impl <std::complex<float>> (std::complex<float> z) -> constexpr std::complex<float> real_impl <std::complex<float>> (std::complex<float> z)

     inline std::complex<float> real_impl <std::complex<double>> (std::complex<float> z) -> constexpr std::complex<float> real_impl <std::complex<double>> (std::complex<float> z)

यह संकलित नहीं होगा क्योंकि अभी भी std::real() पर एक नेस्टेड कॉल है जो constexpr नहीं है।

3. अगर मैं std::complex . का उपयोग करता हूं::वास्तविक() के बजाय std::real() यह C++11 अनुरूप प्रतीत होता है।

1. मुझे लगता है कि आप कह रहे हैं कि कोई फर्क नहीं पड़ता कि मैं यह कोड क्या करता हूं, सी ++ 14 तक यूबी है। क्या std::complex<double> को double में बदलने का कोई और तरीका है जो आपकी आवश्यकता को पूरा करेगा?

@iotamudelta , @bddppq , @ezyang ,

मैंने CUDA थ्रस्ट :: कॉम्प्लेक्स एपीआई पर जटिल UnaryOps और BinaryOps के लिए समर्थन जोड़ा है, लेकिन मुझे इसे सबमिट करने से पहले कुछ प्रश्न पूछने की आवश्यकता है।

मैंने एक टेम्पलेट फ़ंक्शन परिभाषित किया है जो आपको जटिल संख्याओं से निपटने के दौरान जोर :: जटिल डेटा प्रकारों का उपयोग करने की अनुमति देता है।
aten/src/ATen/native/cuda/zmath.cuh

#pragma once

#include <complex>
#include <thrust/complex.h>

namespace at { namespace native {
namespace {

template <typename TYPE>
struct ztype_cuda {
  using value_t = TYPE; // Complex template type
  using thrust_t = TYPE; // Equivalent thrust type
};

template <>
struct ztype_cuda<std::complex<float>> {
  using value_t = float;
  using thrust_t = thrust::complex<float>;
};

template <>
struct ztype_cuda<std::complex<double>> {
  using value_t = double;
  using thrust_t = thrust::complex<double>;
};

} // end namespace
}} //end at::native

फिर aten/src/ATen/native/cuda/BinaryOpsKernel.cu में
बदलने के:

void add_kernel_cuda(TensorIterator& iter, Scalar alpha_scalar) {
  AT_DISPATCH_ALL_TYPES_AND2(kHalf, kBool, iter.common_dtype(), "add_cuda/sub_cuda", [&]() {
    auto alpha = alpha_scalar.to<scalar_t>();
    gpu_kernel_with_scalars(iter, [alpha]GPU_LAMBDA(scalar_t a, scalar_t b) -> scalar_t {
      return a + alpha * b;
    });
  });
}

साथ:

void add_kernel_cuda(TensorIterator& iter, Scalar alpha_scalar) {
  AT_DISPATCH_ALL_TYPES_AND_COMPLEX_AND2(kHalf, kBool, iter.dtype(), "add_cuda/sub_cuda", [&]() {
    using thrust_t = typename ztype_cuda<scalar_t>::thrust_t;
    auto alpha = thrust_t(alpha_scalar.to<scalar_t>());
    gpu_kernel_with_scalars(iter, [alpha]GPU_LAMBDA(thrust_t a, thrust_t b) -> thrust_t {
      return a + alpha * b;
    });
  });
}

प्रशन

1. @ezyang : गैर-जटिल संख्याओं के लिए, scalar_t और जोर_टी एक ही प्रकार के हैं। हो सकता है कि मैं परिवर्तनीय नाम thrust_t को गैर-जटिल संख्याओं के अनुकूल कुछ और के साथ बदल सकता हूं, जैसे scalar_t_c ?
2. जोर पुस्तकालय कोड में व्यापक रूप से संदर्भित प्रतीत होता है:
   a) @bddppq : क्या कोई कारण है कि मुझे $#$ thrust::complex $#$ के बजाय cuComplex का उपयोग करना चाहिए?
   b) @iotamudelta : ROCm2.7 में हिप-थ्रस्ट को हटा दिया गया है। क्या मुझे इसके बजाय hip_complex का उपयोग करना चाहिए?
   जोर :: जटिल cuComplex से अधिक कार्यक्षमता का समर्थन करता प्रतीत होता है।

मुझे बताओ कि तुम क्या सोचते हो।

@iotamudelta

मैंने std::real() के बारे में चर्चा को अद्यतन किया है। क्या आप पुष्टि कर सकते हैं कि std::complex:: असली() समस्या को ठीक करेगा।

हाय @dylanbespalko ,

मुझे लगता है कि @iotamudelta शिकायत कर रहा है कि जटिल प्रकारों के लिए cast_and_store में C10_HOST_DEVICE गुम है, यह एक यूबी होगा यदि उस कोड पथ को कभी भी GPU पर निष्पादित किया जाता है।

वर्तमान में, यह गतिशील कास्टिंग उपयोगिता केवल GPU TensorIterator में उपयोग की जाती है, और इसका उपयोग केवल तब किया जाता है जब टाइप प्रमोशन होता है। इस कारण से कि कॉम्प्लेक्स वर्तमान में GPU पर समर्थित नहीं था, जटिल प्रकारों के लिए cast_and_store में अभी C10_HOST_DEVICE क्वालिफायर नहीं है और std::real का उपयोग करता है जो एक होस्ट के लिए पूरी तरह से ठीक है- केवल समारोह। यहां कोई यूबी नहीं है क्योंकि इसका उपयोग नहीं किया जाता है और आपको चिंता करने की कोई जरूरत नहीं है।

लेकिन चूंकि आप GPU में कॉम्प्लेक्स का समर्थन जोड़ना चाहते हैं, और कॉम्प्लेक्स टाइप प्रमोशन द्वारा समर्थित है जैसा कि हम https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h#L398 में देख सकते हैं - L420, आपको इस कोड पथ पर बहुत सावधान रहने की आवश्यकता है और इसे काम करने के लिए आपको कुछ संशोधन करने पड़ सकते हैं:

बेशक, आपको C10_HOST_DEVICE जोड़ने की जरूरत है जैसा कि @iotamudelta https://github.com/pytorch/pytorch/pull/29547 में कर रहा है, लेकिन यह पर्याप्त नहीं है, क्योंकि केवल C10_HOST_DEVICE जोड़ना अन्य परिवर्तनों के बिना अभी भी सी ++ 11 पर यूबी है जैसा कि @iotamudelta द्वारा उल्लेख किया गया है, एक अच्छा समाधान वह हो सकता है जिसका आपने उल्लेख किया है: std::complex::real() को बदलने के लिए std::real का उपयोग करें।

लेकिन इसके अलावा, यदि आप https://github.com/pytorch/pytorch/blob/master/c10/util/TypeCast.h फ़ाइल को देखते हैं, तो आप fetch_and_cast के अंदर देखेंगे, कुछ ऐसा है:

#ifndef C10_HOST_DEVICE
    AT_FORALL_COMPLEX_TYPES(FETCH_AND_CAST_COMPLEX_CASE)
#endif

यह कोड पथ GPU पर अक्षम है। आपको इसे सक्षम करने और इसे काम करने की आवश्यकता है।

साथ ही, मुझे complex<float> और complex<double> के बीच fetch_and_cast और cast_and_store के बीच कोई रूपांतरण नहीं दिखाई दिया। आपको उसके लिए रूपांतरण जोड़ने की भी आवश्यकता हो सकती है। सुनिश्चित करें कि आप सभी प्रकार के इन कार्यों के कवरेज पर पूरी तरह से परीक्षण करते हैं।

सीसी: @ezyang और @bddppq

इसके अलावा @dylanbespalko , अगर आप अपने पीआर में TypeCast.h में कोई बदलाव कर रहे हैं तो कृपया मुझे सीसी करें।

ठीक है, मेरे पास एआरएम पर torch.real() और torch.imag() के साथ ठीक करने के लिए कुछ छोटी चीजें हैं, इसलिए जब मैं इसमें हूं तो मैं TypeCast.h और कुछ अन्य को ठीक कर दूंगा। मैं आप लोगों को पीआर पर सीसी करूंगा।

टिप्पणी द्वारा ड्राइव करें: @smessmer हमें C++14 पर ले जा रहा है, जिस बिंदु पर यह UB नहीं होगा। चूंकि यह जल्द ही आ रहा है, अगर यूबी वास्तविक समस्याएं पैदा नहीं कर रहा है तो मुझे इसके बारे में ज्यादा चिंता नहीं होगी।

@ezyang : जानकर अच्छा लगा। Eigen जैसी अधिकांश तृतीय पक्ष सामग्री अभी भी std::real() बहुत उदारतापूर्वक कॉल करती है।

गैर-जटिल संख्याओं के लिए, स्केलर_टी और थ्रस्ट_टी एक ही प्रकार हैं। हो सकता है कि मैं गैर-जटिल संख्याओं जैसे scalar_t_c के लिए अधिक अनुकूल कुछ के साथ चर नाम थ्रस्ट_टी को बदल सकता हूं?

मुझे बहुत यकीन नहीं है, लेकिन scalar_t_c thrust_t से थोड़ा कम स्पष्ट लगता है ( c का वैसे भी क्या मतलब है?) यहां प्रश्न के प्रकार काफी विशिष्ट प्रतीत होते हैं, इसलिए ऐसे नाम का उपयोग करना बेहतर लगता है जो सीधे इरादे के बारे में बात करता हो।

ठीक है, मैं साथ रहूंगा thrust_t । अगर कोई ztype_cuda<>() में गोता लगाता है तो उन्हें तुरंत पता चल जाना चाहिए कि scalar_t गैर-जटिल प्रकारों के लिए thrust_t है।

कृपया देखें https://github.com/pytorch/pytorch/pull/29612

हेलो सब लोग! ऐसा लगता है कि pytorch को जटिल समर्थन जोड़ने की दिशा में अच्छी प्रगति हो रही है! धन्यवाद @dylanbespalko इस पर पहल करने और साथ ही CUDA समर्थन जोड़ने के लिए! उच्च स्तर से, मुझे यह जानने में दिलचस्पी है कि जटिल समर्थन में वर्तमान प्रगति क्या है? जटिल टेंसर (बाइनरी ऑप्स) को जोड़ने और गुणा करने के लिए CUDA समर्थन रखने के लिए मुझे ज्यादातर किसी न किसी समयरेखा में दिलचस्पी है। शुक्रिया!

हाय @sunilkpai ,

मेरे पास एक खुला पीआर है जो CUDA: #30295 पर बाइनरी और यूनरी ऑप्स का समर्थन करना चाहिए।

एक और मुद्दा पिछड़े प्रचार के साथ है। मुझे लगता है कि जटिल abs() के व्युत्पन्न को वास्तविक संख्याओं से अलग तरीके से परिभाषित किया गया है। सुनिश्चित नहीं है कि इसके बारे में क्या करना है, लेकिन डेरिवेटिव को tools/autograd/derivatives.yaml . में परिभाषित किया गया है

मुझे लगता है कि जटिल संख्याओं के लिए /dz abs(z) = z/abs(z) । इसका उपयोग वास्तविक संख्याओं के लिए भी किया जा सकता है, लेकिन संभावना sgn(z) . से धीमी होगी

@dylanbespalko शायद मेरी रिपोर्ट https://arxiv.org/pdf/1701.00392.pdf में टेबल 4.1, 4.2 और 4.3 डेरिवेटिव को परिभाषित करने में आपकी मदद कर सकते हैं।

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

• व्युत्पन्न wrt z के लिए z = x + jy : dJ/dz = dJ/dx -j dJ/dy
• व्युत्पन्न wrt z.conj के लिए z = x + jy : dJ/dz.conj = dJ/dx + j dJ/dy

आपकी टिप्पणी से, मेरी धारणा यह है कि आप इस समय व्युत्पन्न wrt z की गणना करते हैं।
इस मामले में व्युत्पन्न d abs(z) / d z = z.conj / abs(z) है। जब आप दूसरी परिभाषा लेते हैं तो आप @Randl सुझाव का पालन कर सकते हैं।

मुझे बताएं कि क्या मुझे और समझाना चाहिए। मेरे पास जटिल डेरिवेटिव के लिए कुछ सुस्पष्ट कार्यान्वयन भी हैं।

एक अन्य ऑपरेशन जो उपयोगी होगा (विशेष रूप से भौतिकी अंतरिक्ष में परियोजनाओं के लिए जटिल संख्या समर्थन की आवश्यकता होती है) exp() ऑपरेटर के लिए एक हैंडलर है। टेंसरफ़्लो में, हमारे पास tf.exp(x + iy) = tf.exp(x) * (tf.cos(y) + 1j * tf.sin(y)) है। क्या यह pytorch में भी लागू करने के लिए सीधा है?

@sunilkpai , @boeddeker , @Randl ,

जटिल डेरिवेटिव पर रिपोर्ट के लिए धन्यवाद। मैं इसका पालन करने की कोशिश करूंगा और मैं अगले सप्ताह इस पर वापस आऊंगा। मैंने सोचा कि मैं यहां कुछ लिंक जोड़ूंगा और परियोजना की स्थिति का वर्णन करूंगा।

जटिल संख्याओं की स्थिति अनौपचारिक रूप से समर्थित है और इसे PyTorch एक्सटेंशन के माध्यम से जोड़ा जाना चाहिए:

• पाइटोरच-सीपीयू-स्ट्राइड-कॉम्प्लेक्स
• पाइटोरच-क्यूडा-स्ट्राइडेड-कॉम्प्लेक्स

प्रत्येक एक्सटेंशन में दो चीजें होती हैं:

• एक .cpp जिसमें कोई भी आवश्यक गणित कर्नेल पंजीकरण शामिल है।
• एक test/ फ़ोल्डर जिसमें pytorch परीक्षण स्क्रिप्ट के बहुत सरलीकृत संस्करण हैं।
  परीक्षण स्क्रिप्ट में देखें कि कौन से कर्नेल समर्थित हैं (और अन्य क्यों नहीं हैं)।

मैं कंसोल पर एक जटिल टेंसर को प्रिंट क्यों नहीं कर सकता?

• टेंसर पायथन ऑब्जेक्ट में कुछ सुंदर-प्रिंट स्वरूपण है जो कुछ फ़ंक्शन को कॉल करता है जो असमर्थित हैं।
  
  
  
  • प्रिंट स्वरूपण को बायपास करने के लिए आप tensor.py की सामग्री को संशोधित कर सकते हैं।
  
  
  • या, आप बस Pytorch टेंसर को Numpy सरणियों में बदल सकते हैं और फिर प्रिंट कर सकते हैं।
  
  

वर्तमान परियोजना स्थिति:

• सीपीयू कवरेज बहुत अच्छा है।
  
  
  
  • कर्नेल को PyTorch के अंदर 'aten/src/ATen/native/cpu/ </li> <li>Complex number specific code is under 'aten/src/ATen/native/cpu/zmath.h के तहत कार्यान्वित किया जाता है
  
  
  • Intel AVX256 त्वरण 'aten/src/ATen/cpu/vec256/` के अंतर्गत है
    
    
    
    
    
    • @sunilkpai : मैं क्स्प के अनुकूलन को नहीं जानता था। यह वह फ़ोल्डर है जहाँ आप उसे जोड़ते हैं।
    
    
    
    • मुझे बताएं कि क्या आप बदलाव करने में सहज हैं।
    
    
    
  
  
• GPU कवरेज बाइनरी और यूनरी ऑप्स तक सीमित है:
  
  
  
  • कर्नेल को PyTorch के अंदर 'aten/src/ATen/native/cuda/* </li> <li>Complex number specific code is under 'aten/src/ATen/native/cuda/zmath.cuh के तहत कार्यान्वित किया जाता है
  
  
  • thrust::complex<T> डेटा प्रकारों का उपयोग किया जाता है और उनमें अनुकूलित कर्नेल शामिल होते हैं।
  
  

वर्तमान विकास:

• C-आधारित TH कर्नेल को C++ ATen फ़ोल्डर में पोर्ट किए जाने की प्रतीक्षा की जा रही है।
  
  
  
  • परीक्षण मामलों को पाइटोरच के आंतरिक परीक्षणों में पोर्ट करने के लिए रैंड () फ़ंक्शन की आवश्यकता होती है।
  
  
  • कुछ अनुक्रमण संचालन वर्तमान में पोर्ट नहीं किए गए हैं।
  
  
  • वर्तमान में 168/1300 गणित कर्नेल (अक्टूबर में 230 से नीचे) हैं जिन्हें TH से ATen में पोर्ट करने की आवश्यकता है।
  
  
• मैं कॉम्प्लेक्स नंबर सपोर्ट जोड़ने की कोशिश करूंगा क्योंकि ये कर्नेल एटेन में उपलब्ध हो जाते हैं।

--

एफवाईआई। जटिल व्युत्पत्तियों के संबंध में, हमने जूलिया में एक लंबी चर्चा की और इसका कार्यान्वयन अब चैनरूल्स में है (यह भी देखें: http://www.juliadiff.org/ChainRules.jl/dev/api.html#ChainRulesCore.Wirtinger ) और अब Zygote . आम तौर पर, लोगों को केवल जरूरत होती है
\partial L/\partial adjoint(z) ढाल के रूप में (परिभाषा के अनुसार यह सबसे तेज़ कमी की दिशा है), लेकिन व्युत्पन्न \partial L/\partial z के रूप में अलग है, एक अतिरिक्त इंटरफ़ेस जोड़ा जाना चाहिए, अगर हम जटिल संख्या एडी के लिए पूर्ण समर्थन चाहते हैं . विस्तृत नियमों के लिए, आप जांच सकते हैं कि ChainRules या Zygote/lib में क्या लागू किया गया है (चूंकि केवल सामान्य नियम हैं, अधिकांश ऑपरेटरों के लिए जटिल संख्याओं के लिए कोई अलग नियम नहीं है, चीजों के लिए पिछड़ा पास जैसे matmul सामान्य परिभाषा में लिखे गए हैं जैसे adjoint(A) * B )

मैं कंसोल पर एक जटिल टेंसर को प्रिंट क्यों नहीं कर सकता?
टेंसर पायथन ऑब्जेक्ट में कुछ सुंदर-प्रिंट स्वरूपण है जो कुछ फ़ंक्शन को कॉल करता है जो असमर्थित हैं।
प्रिंट स्वरूपण को बायपास करने के लिए आप tensor.py की सामग्री को संशोधित कर सकते हैं।
या, आप बस Pytorch टेंसर को Numpy सरणियों में बदल सकते हैं और फिर प्रिंट कर सकते हैं।

मुझे लगता है कि मैंने डिबगिंग आदि के लिए https://github.com/Roger-luo/pytorch-complex में प्रिंटिंग का कम से कम हिस्सा तय किया है, यह सुनिश्चित नहीं है कि इससे मदद मिलेगी क्योंकि मास्टर ने अतीत में बहुत कुछ बदल दिया है वर्ष। आप इसे ले सकते हैं अगर यह मददगार है, मैं अब इस पर काम नहीं करने जा रहा हूं।

@dylanbespalko मैं पाइटोरच इंटर्नल के साथ अपेक्षाकृत अनुभवहीन हूं, हालांकि मैंने सीखना शुरू कर दिया है! मैं इस परिवर्तन का प्रयास कर सकता था, हालांकि मैं aten/src/ATen/cpu/vec256/* में जो देखता हूं उसके आधार पर, मुझे यकीन नहीं है कि यह आवश्यक है कि std::exp(std::complex) का डिफ़ॉल्ट व्यवहार वही है जो मैंने उल्लेख किया है मेरी पिछली टिप्पणी में: https://en.cppreference.com/w/cpp/numeric/complex/exp के नोट्स देखें। मुझे यह भी यकीन नहीं है कि यह इन ऑप्स को CUDA में लागू करने के लिए कैसे अनुवाद करता है (जो वर्तमान में वास्तविक, कल्पना, conj और कोण तक सीमित लगता है?)

@sunilkpai ,

मैंने प्रदान किए गए समीकरण का उपयोग करके exp() के लिए AVX समर्थन जोड़ा है।

मैंने यह भी देखा कि PyTorch में हाल के कुछ बदलावों के कारण कुछ चीजें टूट गई थीं। मैंने इन्हें #30871 में ठीक कर दिया है।

@dylanbespalko

क्या TH से Aten में पोर्ट करने की कोई समय-सीमा है?
क्या कोई तरीका है जिससे मैं योगदान कर सकता हूं, इस तथ्य को देखते हुए कि मैं पाइटोरच के आंतरिक कामकाज से अच्छी तरह वाकिफ नहीं हूं?

मुझे arxiv पर जटिल svd के बैकप्रोपेगेशन के लिए एक सूत्र मिला और इसे लागू कर सकता है, यदि आप मुझे दिखाते हैं कि कहाँ है

आपके काम के लिए धन्यवाद!

@ जैकब-अनफ्रीड

https://github.com/pytorch/pytorch/wiki/TH-to-ATen-porting-guide

TH कर्नेल C में लागू किए गए हैं और सभी अंतर्निहित संदर्भ गणना मुद्दों के कारण वहां जटिल समर्थन जोड़ने में बहुत कम रुचि है। आप aten/src/ATen/native/native_functions.yaml में प्रगति को ट्रैक कर सकते हैं जहां प्रत्येक कर्नेल पंजीकृत है:

legacy::cpu::_th खोजें और पुराने TH कर्नेल की संख्या के लिए उस संख्या को 3 से विभाजित करें।
legacy::cpu::_thnn खोजें और पुराने TH तंत्रिका नेटवर्क कर्नेल की संख्या के लिए उस संख्या को 3 से विभाजित करें।

प्रत्येक कर्नेल आमतौर पर 3 अलग-अलग तरीकों से पंजीकृत होता है:
1. नियमित कर्नेल y = जोड़ें (ए, बी)
2. इन-प्लेस कर्नेल a = add_(a, b)
3. आउटपुट कर्नेल add_out(a, b, out=y)
वास्तविक कार्यान्वयन हमेशा आउटपुट कर्नेल में होता है और अन्य 2 उस फ़ंक्शन को कॉल करते हैं।

एनएन कर्नेल पोर्ट करना आसान होता है क्योंकि उनके पास कम निर्भर कर्नेल होते हैं। इसलिए, यदि आप गुठली को उल्टे क्रम में पोर्ट कर सकते हैं कि उन्हें कैसे लागू किया गया था, तो आप कम समग्र कार्य करेंगे।

पोर्टिंग ट्रैकिंग समस्या की जाँच करना https://github.com/pytorch/pytorch/issues/24507 , साथ ही cc @VitalyFedyunin

यहां #32437 में अनुरोध के अनुसार जटिल संख्या समर्थन पर एक स्थिति अद्यतन है। मैं आज सीपीयू से संबंधित समर्थन पर काम कर रहा हूं।

ऑटोग्रैड सपोर्ट

• मेरे पास इसके लिए ज्यादा समय नहीं है।
• angle() , real() , imag() , conj() सभी लागू किए गए।
• abs() को जटिल संख्याओं के लिए एक अलग कार्यान्वयन की आवश्यकता होगी। (ऊपर @boeddeker और @Randl से नोट्स देखें)

हार्डवेयर समर्थन

जटिल संख्या समर्थन वर्तमान में आउट-ऑफ-ट्री लागू किया गया है। यहाँ इसका क्या अर्थ है:

इन-ट्री कोड

• गणित ऑप्स वास्तव में इन-ट्री (PyTorch स्रोत कोड के अंदर) लागू किए जाते हैं।
• इन-ट्री पाइटोरच परीक्षणों में से कोई भी जटिल संख्या समर्थन को मान्य नहीं करता है (इसलिए चीजें टूट जाती हैं)।
• PyTorch TH से ATen (#24507) की ओर पलायन कर रहा है।
  - TH में लागू किए गए मैथ कर्नेल सम्मिश्र संख्याओं का समर्थन नहीं करते हैं।
  - केवल ATen में कार्यान्वित गुठली ही सम्मिश्र संख्याओं का समर्थन कर सकती है।
• जटिल प्रकार को सक्षम करने के लिए आपको एक PyTorch एक्सटेंशन स्थापित करने की आवश्यकता है।

आउट-ऑफ-ट्री कोड

• कई PyTorch एक्सटेंशन लागू किए गए हैं और भविष्य में इन्हें आसानी से आंतरिक किया जा सकता है:
• प्रत्येक एक्सटेंशन में महत्व की चार फाइलें होती हैं:
  
  
  
  • setup.py: pytorch एक्सटेंशन बनाएं और इंस्टॉल करें।
  
  
  • [CPU/CUDA/FPGA]ComplexType.cpp: CPUType.cpp या CUDAType.cpp के समान गणित कर्नेल पंजीकरण
  
  
  • test/test_torch.py: बहुत बदसूरत परीक्षण मामले जो इंगित करते हैं कि कौन से कर्नेल काम कर रहे हैं, एटेन समर्थन द्वारा सीमित।
  
  
  • test/test_autograd.py: ऑटोग्रैड कार्यक्षमता का परीक्षण करना।
  
  

आउट-ऑफ-ट्री PyTorch एक्सटेंशन

1. cpu_strided_complex
   - [एक्स] कॉपी कर्नेल
   - [] TensorFactories (th_random, th_uniform, th_normal)
   - [एक्स] रेंज फैक्ट्रीज
   - [x] बाइनरीऑपकर्नल्स
   - [x] UnaryOpKernels
   - [x] ओपकर्नल्स की तुलना करें
   - [एक्स] पावर कर्नेल
   - [x] ReduceOpKernels (th_min, th_max, कुछ मानदंड जटिल संयुग्म की गणना नहीं करते हैं)
   - [ ] IndexOpKernels (th_masked_select_bool, th_set, th_gather, th_cat)
   - [x] प्वाइंटवाइज ऑप्स
   - [एक्स] लेर्प ऑप्स
   - [ ] BlasOps (th_mv, th_mm, th_fmod, th_eig)
   - [] लिनपैकऑप्स (ब्लास का उपयोग करता है)
   - [] स्पेक्ट्रलऑप्स (समर्थित, लेकिन काम की जरूरत है)
   
   
   
   1. cuda_strided_complex
      
      
      
      
      
      • [x] कॉपी कर्नेल
      
      
      
      • [ ] TensorFactories (सीपीयू समस्याएं देखें)
      
      
      
      • [x] बाइनरीऑपकर्नल्स
      
      
      
      • [x] UnaryOpKernels (टूडू: ऐड एंगल, रियल, इमेज, कॉन्ज)
      
      
      
      • [ ] ओपकर्नल्स की तुलना करें (टोडो)
      
      
      
      • [ ] रिड्यूसऑपकर्नल्स (WARP_SIZE से संबंधित त्रुटि संदेश)
      
      
      
      • बिंदु-वार गणना से परे GPU कठिन हो जाता है, हालांकि अतिरिक्त कार्यों का समर्थन किया जा सकता है
      
      
      
   
   
2. vitis_strided_complex
   
   
   
   • Xilinx Vitis एक FPGA उच्च-स्तरीय संश्लेषण मंच है जो सर्वर और एम्बेडेड उपकरणों का समर्थन करता है।
   
   
   • अक्टूबर 2019 में जारी (उपकरणों के लिए संभावित सीमित समर्थन)।
   
   
   • VIvado HLS (एम्बेडेड) के साथ SDAccel (सर्वर) को जोड़ती है।
   
   
   • [ ] BinaryOpKernals (जनवरी का अंत)
   
   
   • [ ] UnaryOpKernels (जनवरी के अंत)
   
   
   • [ ] रिड्यूसऑपकर्नल्स (फरवरी का अंत)।
   
   
   • FPGA ने हाल ही में जोड़े गए वेक्टरकृत ऑब्जेक्ट Vec256 PyTorch टेम्पलेट वर्ग के समान समर्थन करते हैं
   
   
   • Vec256 यह था कि सीपीयू में कितना जटिल समर्थन जोड़ा गया था और यह $C$ या $R^N$ टेंसर स्पेस को लागू करने का अधिक प्राकृतिक तरीका लगता है
   
   

इस मुद्दे पर आने के लिए और अपडेट: https://github.com/pytorch/pytorch/issues/33152

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

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

हाय @redwrasse प्रतिक्रिया के लिए धन्यवाद! वर्तमान में हमारे पास जटिल संख्याओं के लिए एक नोट है जो मास्टर पर जटिल टेंसर के लिए समर्थित कुछ मशाल बुनियादी बातों और जटिल कार्यों के बारे में बात करता है
(जिनमें से अधिकांश 1.6 रिलीज में शामिल हैं) https://pytorch.org/docs/master/complex_numbers.html?highlight=complex। क्या आप साझा कर सकते हैं कि आप किन अन्य कार्यों में रुचि रखते हैं? हमारे वर्तमान समर्थन और आगामी रिलीज़ के लिए क्या योजना है, इस बारे में अधिक बात करने में प्रसन्नता हो रही है।

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

हाय @redwrasse प्रतिक्रिया के लिए धन्यवाद! वर्तमान में हमारे पास जटिल संख्याओं के लिए एक नोट है जो मास्टर पर जटिल टेंसर के लिए समर्थित कुछ मशाल बुनियादी बातों और जटिल कार्यों के बारे में बात करता है
(जिनमें से अधिकांश 1.6 रिलीज में शामिल हैं) https://pytorch.org/docs/master/complex_numbers.html?highlight=complex। क्या आप साझा कर सकते हैं कि आप किन अन्य कार्यों में रुचि रखते हैं? हमारे वर्तमान समर्थन और आगामी रिलीज़ के लिए क्या योजना है, इस बारे में अधिक बात करने में प्रसन्नता हो रही है।

धन्यवाद @ anjali411 , इस दस्तावेज़ को देखकर बहुत अच्छा लगा, मुझे पहले इसकी जानकारी नहीं थी। मुझे लगता है कि जो आवश्यक है वह सामने है और कुछ पंक्तियों को 'जटिल तंत्रिका नेटवर्क के लिए समर्थन की वर्तमान स्थिति' के केंद्र में है, लेकिन मुझे इसके माध्यम से जाने दो ...

जो लोग जटिल ऑटोग्रैड में रुचि रखते हैं, उनमें आपकी रुचि हो सकती है https://github.com/pytorch/pytorch/issues/41857 जो इस बात को छूता है कि PyTorch किस सम्मेलन का पालन करेगा (JAX या TF)।