कन्वेंशन लेयर: मैट्रिक्स गुणन अनुकूलन तकनीक

परिचय

यह लेख अंतर्निहित एल्गोरिदम का वर्णन करने वाले लेखों की एक श्रृंखला का एक निरंतरता है।
सीनेट सीपीयू पर पूर्व-प्रशिक्षित तंत्रिका नेटवर्क को लॉन्च करने के लिए एक रूपरेखा है।

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

कन्वर्सेशन लेयर ऑप्शन

मैं उन मापदंडों के विवरण के साथ विवरण को शुरू करना चाहूंगा जो कि विभेदी परत में हैं। विशेषज्ञ इस अनुभाग को सुरक्षित रूप से छोड़ सकते हैं।

इनपुट और आउटपुट छवि आकार

सबसे पहले, एक दृढ़ परत एक इनपुट और एक आउटपुट छवि की विशेषता है, जो निम्नलिखित मापदंडों की विशेषता है:

• srcC / dstC - इनपुट और आउटपुट इमेज में चैनलों की संख्या। वैकल्पिक संकेतन: C / D
• srcH / dstH - इनपुट और आउटपुट छवि की ऊंचाई। वैकल्पिक पदनाम: एच।
• srcW / dstW - इनपुट और आउटपुट इमेज की चौड़ाई। वैकल्पिक पदनाम: डब्ल्यू।
• बैच - इनपुट (आउटपुट) छवियों की संख्या - परत एक बार में छवियों के पूरे बैच को संसाधित कर सकती है। वैकल्पिक पदनाम: एन।

कनवल्शन कोर साइज़

कनवल्शन ऑपरेशन स्वाभाविक रूप से छवि में दिए गए बिंदु के एक निश्चित पड़ोस का एक भारित योग है। कनवल्शन कर्नेल का आकार - इस पड़ोस के आकार को दर्शाता है और दो मापदंडों द्वारा वर्णित है:

• कर्नेल की लंबाई कनवल्शन कर्नेल की है। वैकल्पिक पदनाम: Y.
• कर्नेलएक्स कन्वेक्शन की कर्नेल की चौड़ाई है। वैकल्पिक पदनाम: X.

1x1 और 3x3 के कर्नेल आकार के साथ सबसे आम दृढ़ संकल्प। आकार 5x5 और 7x7 बहुत कम आम हैं। बड़े कनवल्शन साइज़, साथ ही स्क्वायर के अलावा कर्नेल के साथ कनवल्शन भी कभी-कभी पाए जाते हैं, लेकिन यह अधिक विदेशी है।

बातचीत का कदम

एक अन्य महत्वपूर्ण पैरामीटर कनवल्शन स्टेप है:

• strideY वर्टिकल कनवल्शनशन स्टेप है।
• strideX - क्षैतिज दृढ़ संकल्प कदम।

यदि चरण 1x1 से भिन्न है, उदाहरण के लिए - 2x2 , तो आउटपुट छवि आधी हो जाएगी (कन्वेंशन की गणना केवल समान बिंदुओं के पड़ोस में की जाएगी)।

स्ट्रेचिंग कन्वेंशन

निम्न मापदंडों का उपयोग करते हुए कन्वेक्शन कर्नेल को बढ़ाया जा सकता है (प्रभावी विंडो का आकार बढ़ाएँ, संचालन की संख्या बनाए रखें):

• dilationY - अनुलंब खिंचाव के ऊर्ध्वाधर।
• dilationX - आक्षेप का क्षैतिज फैलाव ।

यह ध्यान देने योग्य है कि 1x1 के अलावा अन्य मामलों के मामले काफी दुर्लभ हैं (मैंने अपने करियर में कभी भी इस तरह का सामना नहीं किया है)।

पैडिंग इनपुट छवि

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

• पैडी / पैडएक्स - सामने ऊर्ध्वाधर और क्षैतिज पैडिंग।
• पैडएच / पैडडब्ल्यू - रियर ऊर्ध्वाधर और क्षैतिज पैडिंग।

चैनल समूह

आमतौर पर, प्रत्येक आउटपुट चैनल सभी इनपुट चैनलों में संकल्पों का योग होता है। हालांकि, यह हमेशा मामला नहीं होता है। इनपुट और आउटपुट चैनलों को समूहों में विभाजित करना संभव है, यह सम्‍मेलन केवल समूहों में किया जाता है:

• समूह - समूहों की संख्या।

व्यवहार में, समूह = 1 और समूह = srcC = dstC , तथाकथित डेप्थवाइज़ कनवल्शन के साथ, स्थितियों का सामना अक्सर किया जाता है।

विस्थापन और सक्रियण कार्य

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

एल्गोरिथ्म का मूल कार्यान्वयन

शुरू करने के लिए, मैं एल्गोरिथ्म का एक बुनियादी कार्यान्वयन देना चाहूंगा:

float relu(float value) { return value > 0 ? return value : 0; } void convolution(const float * src, int batch, int srcC, int srcH, int srcW, int kernelY, int kernelX, int dilationY, int dilationX, int strideY, int strideX, int padY, int padX, int padH, int padW, int group, const float * weight, const float * bias, float * dst, int dstC) { int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1; int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1; for (int b = 0; b < batch; ++b) { for (int g = 0; g < group; ++g) { for (int dc = 0; dc < dstC / group; ++dc) { for (int dy = 0; dy < dstH; ++dy) { for (int dx = 0; dx < dstW; ++dx) { float sum = 0; for (int sc = 0; sc < srcC / group; ++sc) { for (int ky = 0; ky < kernelY; ky++) { for (int kx = 0; kx < kernelX; kx++) { int sy = dy * strideY + ky * dilationY - padY; int sx = dx * strideX + kx * dilationX - padX; if (sy >= 0 && sy < srcH && sx >= 0 && sx < srcW) sum += src[((b * srcC + sc)*srcH + sy)*srcW + sx] * weight[((dc * srcC / group + sc)*kernelY + ky)*kernelX + kx]; } } } dst[((b * dstC + dc)*dstH + dy)*dstW + dx] = relu(sum + bias[dc]); } } } } } } 

इस कार्यान्वयन में, मैंने माना कि इनपुट और आउटपुट छवि NCHW प्रारूप में है:



कनवल्शन वेट को DCYX फॉर्मेट में स्टोर किया जाता है, और हमारा एक्टिवेशन फंक्शन ReLU है । सामान्य मामले में, ऐसा नहीं है, लेकिन बुनियादी कार्यान्वयन के लिए, ऐसी धारणाएं काफी उपयुक्त हैं - आपको कुछ से शुरू करना होगा।

हमारे पास 8 नेस्टेड चक्र और कुल संचालन की संख्या है:

 batch * kernelY * kernelX * srcC * dstH * dstW * dstC / group * 2, 

इनपुट में डेटा की मात्रा:

 batch * srcC * srcH * srcW, 

और आउटपुट छवि:

 batch * dstC * dstH * dstW, 

और वज़न की संख्या:

 kernelY * kernelX * srcC * dstC / group. 

यदि समूह << srcC (समूहों की संख्या चैनलों की संख्या की तुलना में बहुत कम है), साथ ही पर्याप्त बड़े मापदंडों srcC , srcH , srcW और dstC के साथ , हम एक शास्त्रीय कम्प्यूटेशनल समस्या प्राप्त करते हैं जब गणना की संख्या इनपुट और आउटपुट डेटा की मात्रा से काफी अधिक होती है। यानी उचित कार्यान्वयन के साथ दृढ़ संकल्प ऑपरेशन को प्रोसेसर के कंप्यूटिंग संसाधनों पर आराम करना चाहिए, न कि मेमोरी बैंडविड्थ पर। यह केवल इस कार्यान्वयन को खोजने के लिए बनी हुई है।

मैट्रिक्स गुणन में समस्या को कम करना

कनवल्शन में मुख्य ऑपरेशन एक भारित राशि प्राप्त करना है, और आउटपुट इमेज के सभी बिंदुओं के लिए भार समान हैं। यदि आप निम्नानुसार इनपुट छवि को पुनर्व्यवस्थित करते हैं:

 void im2col(const float * src, int srcC, int srcH, int srcW, int kernelY, int kernelX, int dilationY, int dilationX, int strideY, int strideX, int padY, int padX, int padH, int padW, float * buf) { int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1; int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1; for (int sc = 0; sc < srcC; ++sc) { for (int ky = 0; ky < kernelY; ky++) { for (int kx = 0; kx < kernelX; kx++) { for (int dy = 0; dy < dstH; ++dy) { for (int dx = 0; dx < dstW; ++dx) { int sy = dy * strideY + ky * dilationY - padY; int sx = dx * strideX + kx * dilationX - padX; if (sy >= 0 && sy < srcH && sx >= 0 && sx < srcW) *buf++ = src[((b * srcC + sc)*srcH + sy)*srcW + sx]; else *buf++ = 0; } } } } } } 

फिर हम फॉर्मेट srcC - srcH - srcW से स्विच करेंगे। हम srcC - कर्नेल - कर्नेल - dstH - dstW फॉर्मेट में स्विच करेंगे। नीचे दिया गया चित्र दिखाता है कि चित्र 1 और 3x3 कोर के साथ कैसे परिवर्तित किया गया है:



इस मामले में, कन्वेक्शन ऑपरेशन के लिए आवश्यक छवि पड़ोस के सभी बिंदु परिणामी मैट्रिक्स के कॉलम के साथ संरेखित किए जाते हैं (इसलिए इसका नाम - im उम्र से लेकर कोल पूर्व छात्रों तक)।

इनपुट छवि का नया प्रतिनिधित्व इस बात में दिलचस्प है कि अब हम में संलक्षण संक्रिया मैट्रिक्स गुणन में कम हो गई है:



अब कन्वेंशन कोड इस तरह दिखेगा:

 void gemm_nn(int M, int N, int K, float alpha, const float * A, int lda, float beta, const float * B, int ldb, float * C, int ldc) { for (int i = 0; i < M; ++i) { for (int j = 0; j < N; ++j) { C[i*ldc + j] = beta; for (int k = 0; k < K; ++k) C[i*ldc + j] += alpha * A[i*lda + k] * B[k*ldb + j]; } } } void convolution(const float * src, int batch, int srcC, int srcH, int srcW, int kernelY, int kernelX, int dilationY, int dilationX, int strideY, int strideX, int padY, int padX, int padH, int padW, int group, const float * weight, const float * bias, float * dst, int dstC, float * buf) { int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1; int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1; int M = dstC / group; int N = dstH * dstW; int K = srcC * kernelY * kernelX / group; for (int b = 0; b < batch; ++b) { im2col(src, srcC, srcH, srcW, kernelY, kernelX, dilationY, dilationY, strideY, strideX, padY, padX, padH, padW, buf); for (int g = 0; g < group; ++g) gemm_nn(M, N, K, 1, weight + M * K * g, K, 0, buf + N * K * g, N, dst + M * N * g, N)); for (int i = 0; i < M; ++i) for (int j = 0; j < N; ++j) dst[i*N+ j] = relu(dst[i*N + j] + bias[i]); src += srcC*srcH*srcW; dst += dstC*dstH*dstW; } } 

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

NHWC प्रारूप के लिए मैट्रिक्स गुणा का उपयोग करना

एनसीएचडब्ल्यू प्रारूप के साथ, एनएचडब्ल्यूसी का उपयोग अक्सर मशीन लर्निंग में किया जाता है:



एक उदाहरण के रूप में, ध्यान दें कि NHWC देशी टेन्सरफ्लो प्रारूप है।

यह उल्लेखनीय है कि इस प्रारूप के लिए, कन्वेंशन ऑपरेशन मैट्रिक्स गुणन को भी जन्म दे सकता है। ऐसा करने के लिए, प्रारूप srcH - srcW - srcC से हम मूल छवि का प्रारूप dstH - dstW - k गिनेली - कर्नेल - srcC में im2row फ़ंक्शन का उपयोग करके अनुवाद करते हैं:

 void im2row(const float * src, int srcC, int srcH, int srcW, int kernelY, int kernelX, int dilationY, int dilationX, int strideY, int strideX, int padY, int padX, int padH, int padW, int group, float * buf) { int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1; int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1; for (int g = 0; g < group; ++g) { for (int dy = 0; dy < dstH; ++dy) { for (int dx = 0; dx < dstW; ++dx) { for (int ky = 0; ky < kernelY; ky++) { for (int kx = 0; kx < kernelX; kx++) { int sy = dy * strideY + ky * dilationY - padY; int sx = dx * strideX + kx * dilationX - padX; for (int sc = 0; sc < srcC; ++sc) { if (sy >= 0 && sy < srcH && sx >= 0 && sx < srcW) *buf++ = src[(sy * srcW + sx)*srcC + sc]; else *buf++ = 0; } } } } } src += srcC / group; } } 

इसके अलावा, कन्वेक्शन ऑपरेशन के लिए आवश्यक इमेज पड़ोस के सभी बिंदु परिणामी मैट्रिक्स की पंक्तियों के साथ संरेखित किए जाते हैं (इसलिए इसका नाम - im उम्र से पंक्ति s)। हमें DCYX फॉर्मेट से कन्वर्जन स्केल के स्टोरेज फॉर्मेट को भी YXCD फॉर्मेट में बदलना चाहिए। अब हम मैट्रिक्स गुणा लागू कर सकते हैं:



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

 void convolution(const float * src, int batch, int srcC, int srcH, int srcW, int kernelY, int kernelX, int dilationY, int dilationX, int strideY, int strideX, int padY, int padX, int padH, int padW, int group, const float * weight, const float * bias, float * dst, int dstC, float * buf) { int dstH = (srcH + padY + padH - (dilationY * (kernelY - 1) + 1)) / strideY + 1; int dstW = (srcW + padX + padW - (dilationX * (kernelX - 1) + 1)) / strideX + 1; int M = dstH * dstW; int N = dstC / group; int K = srcC * kernelY * kernelX / group; for (int b = 0; b < batch; ++b) { im2row(src, srcC, srcH, srcW, kernelY, kernelX, dilationY, dilationY, strideY, strideX, padY, padX, padH, padW, group, buf); for (int g = 0; g < group; ++g) gemm_nn(M, N, K, 1, buf + M * K * g, K * group, 0, weight + N * g, dstC, dst + N * g, dstC)); for (int i = 0; i < M; ++i) for (int j = 0; j < N; ++j) dst[i*N+ j] = relu(dst[i*N + j] + bias[i]); src += srcC*srcH*srcW; dst += dstC*dstH*dstW; } } 

विधि के फायदे और नुकसान

शुरुआत से, मैं इस दृष्टिकोण के लाभों को सूचीबद्ध करना चाहूंगा:

• इस पद्धति का बहुत सरल कार्यान्वयन है। कुछ भी नहीं है कि यह मैं जानता हूँ कि लगभग सभी पुस्तकालयों में प्रयोग किया जाता है।
• कई मामलों के लिए विधि की प्रभावशीलता बहुत अधिक है: मूल संस्करण में प्रतिशत की इकाइयों से हम सैद्धांतिक अधिकतम 80% से अधिक तक पहुंचते हैं।
• दृष्टिकोण सार्वभौमिक है - हमारे पास सभी परतों के संभावित मापदंडों के लिए एक कोड है (और उनमें से कई हैं!)। इसलिए, यह विधि अक्सर उन मामलों में काम करती है जहां अधिक प्रभावी (और इसलिए अधिक विशिष्ट) दृष्टिकोणों की सीमाएं हैं।
• दृष्टिकोण छवि टेनर्स के मुख्य स्वरूपों के लिए काम करता है - एनसीएचडब्ल्यू और एनएचडब्ल्यूसी ।

अब नुकसान के बारे में:

• दुर्भाग्य से, मानक मैट्रिक्स गुणा प्रभावी है, बशर्ते कि पैरामीटर M, N, K के मान काफी बड़े हैं और इसके अलावा, वे परिमाण के लगभग समान क्रम हैं (दक्षता इस तथ्य पर आधारित है कि गणना की आवश्यक संख्या ~ O (N ^ 3) है , और आवश्यक थ्रूपुट मेमोरी क्षमता ~ O (N ^ 2) )। इसलिए, यदि कोई पैरामीटर एम, एन, के छोटा है, तो विधि की दक्षता तेजी से गिरती है।
• विधि को इनपुट डेटा के रूपांतरण की आवश्यकता होती है। और यह एक नि: शुल्क ऑपरेशन से दूर है। वह केवल उपेक्षित हो सकता है यदि K काफी बड़ा हो। और अगर हम इस बात को ध्यान में रखते हैं कि मानक मैट्रिक्स गुणन के अंदर अभी भी इनपुट डेटा का एक आंतरिक परिवर्तन है, तो स्थिति और भी दुखी हो जाती है।
• इस तथ्य के आधार पर कि के = srcC * कर्नेल * कर्नेलएक्स / समूह , विधि की दक्षता विशेष रूप से इनपुट कंफ्यूजनल लेयर्स के लिए कम है। और गहराई से दृढ़ संकल्प के लिए, मैट्रिक्स पद्धति आम तौर पर तुच्छ कार्यान्वयन के लिए खो देती है।
• शिफ्ट ऑपरेशन के लिए आउटपुट की अतिरिक्त प्रक्रिया और सक्रियण फ़ंक्शन की गणना के लिए विधि की आवश्यकता होती है।
• दृढ़ संकल्प की गणना के लिए अधिक कुशल गणितीय तरीके हैं, जिनके लिए कम संचालन की आवश्यकता होती है।

निष्कर्ष

मैट्रिक्स गुणन के आधार पर दृढ़ीकरण की गणना की विधि लागू करने के लिए सरल है और उच्च दक्षता है। दुर्भाग्य से, यह सार्वभौमिक नहीं है। कई विशेष मामलों के लिए, तेजी से दृष्टिकोण हैं, जिसका वर्णन मैं इस श्रृंखला के अगले लेखों के लिए स्थगित करना चाहूंगा। पाठकों की प्रतिक्रिया और टिप्पणियों की प्रतीक्षा है। मुझे आशा है कि आप रुचि रखते थे!

PS यह और अन्य दृष्टिकोण सिमड लाइब्रेरी के हिस्से के रूप में कन्वेंशन फ्रेमवर्क में मेरे द्वारा कार्यान्वित किए गए हैं।
यह फ्रेमवर्क Synet को रेखांकित करता है , CPU पर पहले से प्रशिक्षित तंत्रिका नेटवर्क चलाने के लिए एक रूपरेखा।