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

18

मैंने सिर्फ अपने डेस्कटॉप पर एक एनवीडिया जीटी 660 ग्राफिक कार्ड स्थापित किया है और कुछ संघर्ष के बाद, मैं इसे आर के साथ इंटरफेस करने का प्रबंधन करता हूं।

मैं कई आर पैकेजों के साथ खेल रहा हूं जो GPU का उपयोग करते हैं, विशेष रूप से gputools, और मैं कुछ बुनियादी ऑपरेशन करने के लिए अपने GPU और CPU द्वारा लिए गए समय की तुलना कर रहा था:

इनवरटिंग मैट्रिसेस (सीपीयू तेज)
qr अपघटन (तेजी से सीपीयू)
बड़ा सहसंबंध matrices (सीपीयू तेजी से)
मैट्रिक्स गुणा (GPU बहुत तेजी से!)

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

व्यापक रूप से मेरा सवाल है: कुछ नियमित सांख्यिकीय संचालन जो सीपीयू के बजाय एक GPU पर निष्पादित करने के लायक हो सकते हैं?

r gpu

— Jugurtha
स्रोत

1

मैट्रिक्स गुणन में बहुत सारी चीजें शामिल हैं? :) तंत्रिका जाल समुदाय में जीपीयू काफी लोकप्रिय हैं।

आपको इसमें शामिल मेट्रिसेस का आकार प्रदान करने की आवश्यकता है। उदाहरण के लिए, अंतिम बार मैंने जाँच की (लगभग 2 साल पहले) उलटा और अपघटन केवल बड़े मेट्रिसेस (2 ^ 9 गुणा 2 ^ 9 और ऊपर) से शुरू होने वाले GPU पर तेज़ थे

— user189035

1

मैंने उलटा, qr और मैट्रिक्स गुणन के लिए लगभग का उपयोग किया, जबकि सहसंबंधों के लिए मैंने आकार 100 के वैक्टर के लगभग 10 ^ 4 का उपयोग किया है। मैट्रिक्स व्युत्क्रम के लिए GPU बहुत धीमा था, जबकि qr के लिए अपघटन यह धीमा था लेकिन सीपीयू के बराबर था।

10^{3} \times 10^{3}

$10^3 \times 10^3$

— जुगरात २३'१३ को

2

यह एक बहुत अच्छा सवाल है, लेकिन मुझे लगता है कि

— स्टैकओवरफ्लो में

2

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

— usεr11852

6

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

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

यदि आप वास्तव में उस गति को बढ़ाना चाहते हैं जिस पर आपके कार्य GPU पर चलते हैं, तो मैं C ++ और CUDA के संयोजन में आपके स्वयं के कार्यों को लागू करने पर विचार करूंगा। CUBLAS पुस्तकालय का उपयोग रेखीय बीजगणित से संबंधित भारी उठाने के लिए किया जा सकता है। हालांकि, ध्यान रखें कि इस तरह के कोड को लिखने में काफी समय लग सकता है (विशेषकर यदि यह आपका पहली बार ऐसा कर रहा है), और इसलिए यह दृष्टिकोण केवल उन संगणनाओं के लिए आरक्षित होना चाहिए जिन्हें चलाने के लिए एक बहुत लंबा समय (महीने) और / या कि आप सैकड़ों बार दोहरा रहे हैं।

— टेलीफोन
स्रोत

6

व्यापक रूप से, GPU पर तेजी से चलने वाले एल्गोरिदम वे हैं जहां आप कई अलग-अलग डेटा बिंदुओं पर एक ही प्रकार के निर्देश कर रहे हैं।

इसका उदाहरण देने के लिए एक आसान उदाहरण मैट्रिक्स गुणा के साथ है।

मान लीजिए हम मैट्रिक्स की गणना कर रहे हैं

$A \times B = C$

एक साधारण सीपीयू एल्गोरिथ्म कुछ इस तरह दिख सकता है

// सी = 0 से शुरू

for (int i = 0; i < C_Width; i++)
{
    for (int j = 0; j < C_Height; j++)
    {
        for (int k = 0; k < A_Width; k++)
        {
            for (int l = 0; l < B_Height; l++)
            {
                C[j, i] += A[j, k] * B[l, i];
            }
        }
    }
}

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

इसका एक चित्र देखें

ध्यान दें कि C के प्रत्येक तत्व की गणना किसी अन्य तत्व पर निर्भर नहीं करती है। इसलिए यह मायने नहीं रखता कि गणना किस क्रम में की जाती है।

इसलिए GPU पर, ये ऑपरेशन समवर्ती रूप से किए जा सकते हैं।

मैट्रिक्स गुणा को शांत करने के लिए एक GPU कर्नेल कुछ इस तरह दिखाई देगा

__kernel void Multiply
(
    __global float * A,
    __global float * B,
    __global float * C
)
{
     const int x = get_global_id(0);
     const int y = get_global_id(1);
     for (int k = 0; k < A_Width; k++)
     {
         for (int l = 0; l < B_Height; l++)
         {
             C[x, y] += A[x, k] * B[l, y];
         }
     }
}

इस कर्नेल में केवल दो आंतरिक छोरों के लिए है। इस काम को GPU पर भेजने वाला एक प्रोग्राम GPU को C. में प्रत्येक डेटा बिंदु के लिए इस कर्नेल को निष्पादित करने के लिए बताएगा। GPU इनमें से प्रत्येक निर्देश को कई थ्रेड्स पर समवर्ती रूप से करेगा। पुरानी कहावत की तरह "सस्ता बाय द दर्जनों" जीपीयू को कई बार एक ही काम तेजी से करने के लिए डिज़ाइन किया गया है।

हालाँकि कुछ एल्गोरिदम हैं जो GPU को धीमा कर देंगे। कुछ GPU के लिए अच्छी तरह से अनुकूल नहीं हैं।

उदाहरण के लिए, डेटा निर्भरताएँ थीं, यानी: पिछले तत्वों पर निर्भर C के प्रत्येक तत्व की गणना। प्रोग्रामर को प्रत्येक पिछले गणना समाप्त होने की प्रतीक्षा करने के लिए कर्नेल में एक बाधा डालनी होगी। यह एक बड़ी धीमी गति होगी।

इसके अलावा, एल्गोरिदम जिसमें बहुत सारे ब्रांचिंग लॉजिक हैं:

__kernel Foo()
{
    if (somecondition)
    {
        do something
    }
    else
    {
        do something completely different
    }
}

GPU पर धीमी गति से चलाने के लिए क्योंकि GPU अब प्रत्येक थ्रेड में एक ही काम नहीं कर रहा है।

यह एक सरलीकृत स्पष्टीकरण है क्योंकि विचार करने के लिए कई अन्य कारक हैं। उदाहरण के लिए, सीपीयू और जीपीयू के बीच डेटा भेजने में भी समय लगता है। कभी-कभी सीपीयू पर तेज होने पर भी यह GPU पर गणना करने के लायक होता है, बस अतिरिक्त भेजने के समय (और इसके विपरीत) से बचने के लिए।

इसके अलावा कई आधुनिक सीपीयू अब हाइपरथ्रेडेड मल्टीकोर प्रोसेसर के साथ ही कंफर्टबिलिटी का समर्थन करते हैं।

GPU भी पुनरावृत्ति के लिए इतना अच्छा नहीं लगता है, यहाँ देखें जो शायद QR एल्गोरिथ्म के साथ कुछ समस्याओं की व्याख्या करता है। मेरा मानना है कि किसी के पास कुछ पुनरावर्ती डेटा निर्भरताएं हैं।

— SAV
स्रोत

2

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

— जी.टी.

एक महत्वपूर्ण विचार यह है कि क्या गणना करने के लिए वास्तव में एक पुस्तकालय है: मेरी जानकारी के लिए, मैट्रिक्स गुणा का कोई विरल एक्स घना जीपीयू कार्यान्वयन नहीं हैं, निश्चित रूप से आर पैकेज के माध्यम से नहीं। यदि आप GPU C कोड लिखने के साथ काम करने के लिए तैयार हैं, तो सौभाग्य है।

— जैक वासी

4

$n = 2^{10}$ $n,m \approx 2^{10}, k \approx 2^{14}$

अधिक मोटे तौर पर, मुझे ज्यादातर सांख्यिकीय परिचालनों पर संदेह है जो अपना अधिकांश समय घने रैखिक बीजगणित (BLAS, लापैक कार्यक्षमता) में कुशलतापूर्वक GPU पर कार्यान्वित कर सकते हैं।

— मैक्स हचिंसन
स्रोत

0

डेटा गुम करने के लिए कई विवादास्पद तरीके? ऐलिस-द्वितीय (आर) में उन लोगों की तरह।

मुझे लगता है कि वे अक्सर शर्मनाक समानांतर होते हैं और इसलिए एक GPU वास्तुकला के लिए उपयुक्त होते हैं। हालांकि खुद इसे कभी आजमाया नहीं।

— curious_cat
स्रोत