समानांतर में FFT कंप्यूटिंग के लिए एल्गोरिदम

12

मैं टेराबाइट-आकार की सिग्नल फ़ाइलों पर एक एफएफटी की गणना को समानांतर करने की कोशिश कर रहा हूं। अभी इस तरह के एफएफटी एक ओपन-सोर्स लाइब्रेरी का उपयोग करते हुए कई घंटे लगते हैं, यहां तक कि सबसे तेज जीपीयू मेरे पास CUDA के माध्यम से चल रहा है। मैं इस प्रक्रिया के अनुरूप ढलने की कोशिश कर रहा हूं। बहुत ही बुनियादी शब्दों में, Hadoop निम्नलिखित तरीके से किसी भी सर्वर नोड पर एक समस्या वितरित करता है:

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

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

मैं आपको प्रोग्रामिंग मम्बो जंबो के साथ परेशान नहीं करूंगा, क्योंकि यह एक डीएसपी क्यू एंड ए है। हालाँकि, मैं समानांतर में FFTs की गणना के लिए क्या एल्गोरिदम मौजूद है पर उलझन में हूँ; मानचित्र और कार्य कम करें (तकनीकी रूप से) एक दूसरे से बात नहीं कर सकते हैं, इसलिए एफएफटी को स्वतंत्र समस्याओं में विभाजित किया जाना चाहिए, जहां से परिणाम किसी भी तरह अंत में पुनर्संयोजित किया जा सकता है।

मैंने Cooley-Tukey Radix 2 DIT के एक साधारण कार्यान्वयन को क्रमबद्ध किया है जो छोटे उदाहरणों पर काम करता है, लेकिन एक अरब बाइट्स के लिए विषम / समान इंडेक्स DFTs की पुनरावर्ती गणना के लिए इसका उपयोग करने से काम नहीं चलेगा। मैंने कई पत्रों को पढ़ने में कुछ सप्ताह बिताए हैं, जिसमें एक मैपरेड्यूस एफएफटी एल्गोरिथ्म पर लिखा गया है (एसएसए गुणन पर उनके पेपर के हिस्से के रूप में त्सज़-वो सेज़ द्वारा लिखा गया है, मैं 2 से अधिक हाइपरलिंक लिंक नहीं कर सकता) और "चार-चरण एफएफटी" ( इधर और उधर), जो एक दूसरे के समान लगते हैं और जो मैं पूरा करने की कोशिश कर रहा हूं। हालाँकि, मैं गणित में बुरी तरह से बुरा हूँ, और किसी भी तरीके को हाथ से लागू करके {1,2, 3, 4, 5, 6, 7, 8} जैसे कुछ का एक सरल सेट (सभी काल्पनिक घटकों के साथ 0) देता है। मुझे बेतहाशा गलत परिणाम मिले। क्या कोई मुझे अंग्रेजी में एक कुशल समानांतर एफएफटी एल्गोरिदम समझा सकता है (एक जिसे मैंने लिंक किया है या कोई अन्य) ताकि मैं कोशिश करूं और इसे कार्यक्रम कर सकूं?

संपादित करें: जिम क्ले और कोई भी जो मेरे स्पष्टीकरण से भ्रमित हो सकता है, मैं टेराबाइट फ़ाइल का एक एकल एफएफटी करने की कोशिश कर रहा हूं। लेकिन मैं इस प्रक्रिया को गति देने के लिए कई सर्वरों पर समवर्ती रूप से करने में सक्षम होना चाहता हूं।

fft

— फिलिप
स्रोत

1

वास्तव में आप क्या हासिल करने की कोशिश कर रहे हैं? क्या आप टेराबाइट सिग्नल फ़ाइल का एक एफएफटी, या प्रत्येक फ़ाइल के कई छोटे एफएफटी करना चाहते हैं?

— जिम क्ले

13

मुझे लगता है कि आपकी मुख्य समस्या यह नहीं है कि एल्गोरिथ्म को कैसे समानांतर किया जाए (जो वास्तव में किया जा सकता है) लेकिन यह संख्यात्मक परिशुद्धता है। एक आकार के एफएफटी जो बड़े संख्यात्मक रूप से काफी पेचीदा होते हैं। FFT गुणांक प्रपत्र और यदि N बहुत बड़ा है तो गुणांक गणना में शोर हो जाता है। कहते हैं कि आपके पास और आप 64 बिट डबल प्रिसिजन अंकगणित का उपयोग करते हैं। पहले 1000 गुणांक में एक वास्तविक हिस्सा होता है जो वास्तव में एकता है (हालांकि यह उस तरह से नहीं होना चाहिए) इसलिए आपको उच्च परिशुद्धता गणित की आवश्यकता होगी, जो उपयोग करने के लिए बहुत अक्षम और बोझिल है। $e^{-j\cdot 2\cdot \pi \cdot \frac{k }{N}}$ $N = 2^{40}$

आप बहुत सारी राउंडिंग और ट्रंकेशन त्रुटियों को भी मिटा देंगे क्योंकि एक ही आउटपुट नंबर में जाने वाले ऑपरेशन की सरासर संख्या बहुत बड़ी है। एफएफटी की "हर आउटपुट हर इनपुट पर निर्भर करता है" प्रकृति के कारण, त्रुटि प्रसार प्रचंड है।

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

— Hilmar
स्रोत

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

— फिलिप

मुझे पता है कि मुझे वास्तव में देर हो चुकी है, लेकिन क्या आप किसी भी मौके से, यह कैसे किया जा सकता है, इसका एक स्रोत है, क्योंकि आपने उल्लेख किया है कि यह किया जा सकता है?

— क्लाउडियो ब्रेसर

4

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

इन छोटी लंबाई के FFT को एक-दूसरे के साथ संवाद करने की आवश्यकता नहीं है और पूरी योजना मानचित्र-कम किए गए चरणों से मेल खाती है।

सामान्य तौर पर, आप जो करने का लक्ष्य रखेंगे, वह यह है कि आपका सिग्नल X छोटे-छोटे खंडों में विभाजित हो जाए, जो अतिव्यापी भी हो सकते हैं (उदाहरण के लिए X [0:10], X [5:15], X [10:20] ... ।)। इन छोटे खंडों पर एफएफटी का प्रदर्शन करें और अंतिम एक का उत्पादन करने के लिए अंत में उन्हें पुनर्संयोजित करें। यह मैप-कम ऑपरेटरों के साथ बहुत अच्छी तरह से फिट बैठता है।

"मानचित्र" के दौरान आप "कुंजी" के साथ प्रत्येक सेगमेंट की कुछ अनुक्रमिक आईडी (0,1,2,3,4,5, ....) और "मूल्य" होने के साथ (कुंजी, मूल्य) जोड़े उत्पन्न कर सकते हैं। आपके संकेत की फ़ाइल में किसी खंड के पहले मूल्य का INDEX (या फ़ाइल स्थिति)। इसलिए, उदाहरण के लिए, यदि आपकी फ़ाइल INT32s से भरी है तो दूसरे खंड (ऊपर) का सूचकांक 5 * आकार (INT32) पर है। (या यदि यह किसी अन्य प्रारूप में है तो आपके लिए इसके लिए एक शुल्क हो सकता है)

अब, प्रत्येक कार्यकर्ता एक कुंजी (कुंजी, मूल्य) प्राप्त करता है, एक फ़ाइल खोलता है, सही बिंदु की तलाश करता है, इसमें से एम नमूने पढ़ता है (जहां एम 10 से ऊपर है), एफएफटी करता है और इसे किसी नाम से फ़ाइल में सहेजता है, उदाहरण के लिए " RES_ [INKEY] .dat "और (कुंजी, मान) जोड़ी लौटाता है। इस स्थिति में, "कुंजी" INDEX होगी (आने वाली (मूल्य, मूल्य) टपल) का "मूल्य" और "मान" उस फ़ाइल का नाम होगा जिसमें एफएफटी परिणाम शामिल हैं। (हम इसे वापस ले लेंगे)

"कम" के भीतर अब आप "मैप" स्टेप से एक कुंजी (कुंजी, मान) को स्वीकार करके ओवरलैप-ऐड या ओवरलैप-सेव को लागू कर सकते हैं, उस फाइल को खोल सकते हैं, एफएफटी परिणाम लोड कर सकते हैं, या तो ओए या ओएस कर सकते हैं और फिर उन्हें सहेज सकते हैं। अपने आउटपुट फ़ाइल में सही INDEX। ( इस (या यह ) में pseudocode देखें , "मैप" स्टेप समानांतर में "yt = ..." को हैंडल करता है और "कम" स्टेप "y (i, k) = ..." भाग को हैंडल करता है। "

नेटवर्क पर ट्रैफ़िक को कम करने के लिए या आपके वास्तविक डेटा फ़ाइल में मौजूद सर्वर के भार को कम करने के लिए कुछ फ़ाइल बाजीगरी की आवश्यकता हो सकती है।

— A_A
स्रोत

1

ओवरलैप-ऐड और ओवरलैप की वैधता के बारे में मुझे यकीन नहीं है कि बड़े आकार के एफएफटी को पुनः प्राप्त करने के लिए छोटे विखंडू को मिलाएं - जहां तक मुझे पता है कि ऐसा करने के लिए आवश्यक एफएफटी का एक दूसरा पास है (आकार एन का एक डीएफटी) = AB को A DFT में आकार B, ट्वीडल फ़ैक्टर अनुप्रयोग में तोड़ा जा सकता है, फिर B D आकार का A)। अगर हम कम रिज़ॉल्यूशन आउटपुट चाहते हैं तो यह काम कर सकता है ...

— pichenettes

हैलो picenettes, इस के लिए धन्यवाद, यह (क्या मैं अपने दिमाग में था engineeringproductivitytools.com/stuff/T0001/PT11.HTM ) जो मैं जवाब में शामिल होंगे।

— AAA

2

हमें मान लें कि आपके डेटा का आकार । शून्य के साथ पैड अन्यथा। आपके मामले में, चूंकि आप "टेराबाइट-स्केल" आकारों का उल्लेख करते हैं, इसलिए हम N = 40 लेंगे। $2^N$

चूँकि एक बड़ी मशीन है - लेकिन FFT आकार के लिए बिल्कुल उचित है, मैं आपको मूलांक सिर्फ एक ही Cooley-Tukey पुनरावृत्ति करने का सुझाव देता हूं , और फिर एक उचित FFT लाइब्रेरी दें (FFTW की तरह) प्रत्येक मशीन पर छोटे आकार । $2^{N / 2}$ $N / 2$ $2 ^{N / 2}$

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

मेरा पहला विचार निम्नलिखित होगा, लेकिन मुझे संदेह है कि यह एक ही एमआर में हो सकता है जो स्मार्ट डेटा प्रतिनिधित्व के साथ हो।

चलो होना अपने इनपुट संकेत, $s$ $R = 2^{N / 2}$

पहला एमआर: इनर एफएफटी

नक्शा: आंतरिक एफएफटी के लिए ब्लॉकों में समूह के नमूने समय में, प्रदर्शन करते हैं

इनपुट: जहां में नमूना सूचकांक है ; द्वारा लिया गया मूल्य $(k, v)$ $k$ $0 .. 2^N - 1$ $v$ $s[k]$

emit: - जहां% modulo और / पूर्णांक विभाजन का प्रतिनिधित्व करता है। $(k \% R, (k / R, v))$

कम करें: आंतरिक FFT की गणना करें

इनपुट: जहां ब्लॉक इंडेक्स है; और जोड़े की एक सूची है $(k, vs)$ $k$ $vs$ $(i, v)$

एक वेक्टर पॉप्युलेट आकार के ऐसी है कि सूची में सभी मूल्यों के लिए। $in$ $R$ $in[i] = v$

एक आकार प्रदर्शन पर FFT एक सदिश पाने के लिए आकार के $R$ $in$ $out$ $R$

के लिए में , फेंकना $i$ $0 .. R - 1$ $(k, (i, out[i]))$

दूसरा एमआर: बाहरी एफएफटी

नक्शा: बाहरी fft के लिए समूह के नमूने और जुड़वाँ कारकों को लागू करें

इनपुट: जहां एक ब्लॉक इंडेक्स है, इस ब्लॉक के आंतरिक एफएफटी का एक नमूना। $(k, (i, v))$ $k$ $(i, v)$

एमिट $(i, (k, v \times \exp \frac{-2 \pi j i k}{2 ^ N}))$

कम करें: बाहरी FFT प्रदर्शन करें

इनपुट: जहां ब्लॉक इंडेक्स है; और जोड़े की एक सूची है $(k, vs)$ $k$ $vs$ $(i, v)$

एक वेक्टर पॉप्युलेट आकार के ऐसी है कि सूची में सभी मूल्यों के लिए। $in$ $R$ $in[i] = v$

एक आकार प्रदर्शन पर FFT एक सदिश पाने के लिए आकार के $R$ $in$ $out$ $R$

के लिए में , फेंकना $i$ $0 .. R - 1$ $(i \times R + k, out[i]))$

अवधारणा का प्रमाण यहाँ अजगर कोड।

जैसा कि आप देख सकते हैं, मैपर केवल डेटा के क्रम को बदल रहे हैं, इसलिए निम्न मान्यताओं के तहत:

समय में गिरावट (मैपर 1) एक पिछले चरण में किया जा सकता है (उदाहरण के लिए कार्यक्रम जो डेटा को सही इनपुट प्रारूप में परिवर्तित करता है)।
आपका MR फ्रेमवर्क Reducers को उनकी इनपुट कुंजी से अलग लिखने का समर्थन करता है (Google के कार्यान्वयन में reducers उसी डेटा को केवल उसी कुंजी में आउटपुट कर सकते हैं जितना उन्हें प्राप्त हुआ था, मुझे लगता है कि यह SSTable के आउटपुट आउटपुट के रूप में उपयोग किए जाने के कारण है)।

यह सब एक एकल एमआर में किया जा सकता है, मैपर में आंतरिक एफएफटी, रेड्यूसर में बाहरी एफएफटी। यहां अवधारणा का प्रमाण ।

— pichenettes
स्रोत

आपका कार्यान्वयन आशाजनक लगता है और मैं अभी इसके माध्यम से जा रहा हूं, लेकिन आंतरिक एफएफटी रीड्यूसर में, आप "2 आकार आर ^ एफएफटी पर प्रदर्शन करते हैं, जिससे वेक्टर 2 आकार आर से बाहर निकलता है।" यदि R 2 ^ (N / 2) है, तो क्या यह FFT का आकार 2 ^ (2 ^ N / 2) नहीं होगा, और इस प्रकार गलत है? क्या आपका मतलब FFT के साइज़ R से है?

— फिलिप

हां, ऐसा लगता है कि मैंने कुछ स्थानों पर और को मिलाया ... संपादित किया। ध्यान दें कि हिलमार की टिप्पणी मेरे दृष्टिकोण पर लागू होती है - आपको डबल की तुलना में उच्च परिशुद्धता का उपयोग करना होगा अन्यथा, कुछ कारक ( ) का एक वास्तविक हिस्सा होगा 1 जबकि वे नहीं होना चाहिए - संख्यात्मक अशुद्धियों के लिए अग्रणी।

R

$R$

2^{R}

$2^R$

\exp \frac{- 2 π j i k}{2^{N}}

$\exp \frac{-2 \pi j i k}{2^N}$

— विचित्र

0

यदि आपका सिग्नल बहुआयामी है, तो एफएफटी को समानांतर करना काफी आसानी से पूरा किया जा सकता है; एक आयाम को MPI प्रक्रिया में सन्निहित रखें, FFT करें और अगले आयाम पर काम करने के लिए स्थानांतरित करें (altoall)। FFTW यह करता है।

यदि डेटा 1D है, तो समस्या बहुत अधिक कठिन है। उदाहरण के लिए, FFTW ने MPI का उपयोग करके 1D FFT नहीं लिखा। यदि कोई एक मूलांक -2 डिसीमिनेशन इन-फ्रीक्वेंसी एल्गोरिदम का उपयोग करता है, तो पहले कुछ चरणों को एक भोले डीएफटी के रूप में प्रदर्शित किया जा सकता है, जिससे किसी को बिना किसी नुकसान के 2 या 4 नोड्स का उपयोग करने की अनुमति मिलती है (यह इसलिए है क्योंकि एकता की जड़ें पहले चरण -1 या i हैं, जो काम करने के साथ अच्छे हैं)।

संयोग से, एक बार जब आप इसे रूपांतरित करते हैं, तो आप डेटा के साथ क्या कर रहे हैं? यह कुछ हो सकता है अगर कोई जानता है कि आउटपुट का क्या होता है (यानी एक कनवल्शन, लो-पास फ़िल्टर, आदि)।

— मैल्कम
स्रोत