3,819 रीडिंग

2022 में छवि वर्गीकरण

द्वारा Joshini Lobo13m2022/08/10

बहुत लंबा; पढ़ने के लिए

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

Companies Mentioned

ट्रांसफॉर्मर-आधारित विजन मॉडल धीरे-धीरे विकसित हो रहे हैं और वर्गीकरण, सेगमेंटेशन और एक्शन रिकग्निशन कार्यों पर कन्वेन्शनल मॉडल के रूप में अच्छे होने की सूचना दी गई है। हमारे पास विज़न कार्यों के लिए कन्वेन्शनल मॉडल की एक पूरी श्रृंखला है और यह ट्रांसफॉर्मर-आधारित मॉडल की तुलना में अधिक लोकप्रिय हैं। यह ब्लॉग SWin Transformer Vision मॉडल पर चर्चा करता है जिसे Microsoft अनुसंधान दल द्वारा इंटरनेशनल कॉन्फ़्रेंस फ़ॉर कंप्यूटर विजन (ICCV) 2021 में प्रस्तुत किया गया था। यह डॉग ब्रीड इमेज क्लासिफिकेशन टास्क पर कई SOTA कनवल्शन-आधारित मॉडलों के खिलाफ अपने प्रदर्शन को बेंचमार्क करता है।

चुना गया डेटा और उसका समस्या विवरण:

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

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

अन्वेषणात्मक डेटा विश्लेषण

एक नस्ल के लिए, प्रशिक्षण डेटा में अधिकतम 120+ चित्र और न्यूनतम 66 चित्र होते हैं। प्रत्येक वर्ग में औसतन 85 छवियों की अपेक्षा की जाती है। बार प्लॉट को देखते हुए, यह निष्कर्ष निकाला जाता है कि कोई वर्ग असंतुलन नहीं है।

हालांकि कोई वर्ग असंतुलन नहीं है, तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए डेटा अपर्याप्त हो सकता है। यादृच्छिक छवि गड़बड़ी और पूर्व-प्रशिक्षित मॉडल का उपयोग करके छवि वृद्धि इस समस्या को दूर करने में सक्षम होगी।
सबसे अधिक छवियों वाली शीर्ष 5 नस्लें scottish_deerhound, maltese_dog, afghan_hound, entlebucher और bernese_mountain_dog हैं। सबसे कम छवियों वाली निचली 5 नस्लें गोल्डन_रेट्रिवर, ब्रेबनकॉन_ग्रिफ़ॉन, कोमोंडोर, एस्किमो_डॉग और ब्रियार्ड हैं।
छवि ऊंचाई, चौड़ाई और उनके पहलू अनुपात के वितरण को समझने के लिए प्रशिक्षण छवियों के स्थानिक आयामों पर एक त्वरित विश्लेषण किया जाता है।

बहुत कम (<0.5) और बहुत अधिक (>2.3) पक्षानुपात वाली छवियों को विसंगतिपूर्ण छवियां माना जाता है। 1.5 को एक अच्छा पहलू अनुपात माना जाता है।
विभिन्न कुत्तों की नस्लों के विश्लेषण में, नस्लों के नीचे जोड़े आमतौर पर एक जैसे दिखते थे।
- 'बोस्टन_बुल', 'फ्रेंच_बुलडॉग'
- 'बीगल', 'english_foxhound'
- 'बर्नीज़_माउंटेन_डॉग', 'ग्रेटर_स्विस_माउंटेन_डॉग'
- 'मैलाम्यूट', 'साइबेरियन_हस्की'
- 'बेसेंजी', 'इबिजान_हाउंड'
- 'विज़स्ला', 'रोड्सियन_रिजबैक'
- 'ल्हासा', 'शिह-त्ज़ु'
- 'व्हिपेट', 'इतालवी_ग्रेहाउंड'
- 'ब्रिटनी_स्पैनियल', 'वेल्श_स्प्रिंगर_स्पैनियल', 'ब्लेनहेम_स्पैनियल'
- 'मैलिनोइस', 'जर्मन_शेफर्ड'
- 'बॉर्डर_कोली', 'कोली'
- 'नॉरफ़ॉक_टेरियर', 'नॉर्विच_टेरियर'

मूल्यांकन मेट्रिक्स

लॉगलॉस, जो सभी 120 वर्गों के लिए मॉडल भविष्यवाणियों के विश्वास का मूल्यांकन जमीनी सच्चाई की संभावना से भविष्यवाणी की संभावना की तुलना करके करता है, प्रमुख मीट्रिक है।
एन * एन भ्रम मैट्रिक्स का उपयोग भविष्यवाणियों के परिणाम का अध्ययन करने के लिए किया जाता है ताकि विश्लेषण किया जा सके कि मॉडल द्वारा भ्रमित वर्गों की कोई जोड़ी है और गलत भविष्यवाणी की गई है।

SWIN - ट्रांसफार्मर आधारित मॉडल

यह आर्किटेक्चर माइक्रोसॉफ्ट रिसर्च टीम द्वारा विकसित "स्वाइन ट्रांसफॉर्मर: हायरार्किकल विजन ट्रांसफॉर्मर यूजिंग शिफ्टेड विंडोज" पर आधारित है। यह पेपर एक बेहतर वीआईटी आर्किटेक्चर पर चर्चा करता है जो फीचर मैप्स का एक पदानुक्रमित प्रतिनिधित्व उत्पन्न करता है जो स्व-ध्यान तंत्र की गणना जटिलता को द्विघात से रैखिक तक कम करता है। यह इमेजनेट वर्गीकरण समस्या पर EfficientNet जैसे SOTA कनवल्शन नेटवर्क के समान परिणाम देने के लिए सिद्ध होता है।

इस वास्तुकला के निर्माण खंडों को नीचे दिए गए नोटों में समझाया गया है:

छवि पैचिंग:

एनएलपी में, टोकन जो एक मॉडल के प्रसंस्करण तत्व हैं, एक वाक्य में शब्द हैं जहां 1 टोकन का आकार 1 (सिर्फ 1 शब्द) है। वीआईटी ( विशन टी रैंसफॉर्मर्स) "इमेज पैच" को टोकन के रूप में मानते हैं जहां प्रत्येक पैच पड़ोसी पिक्सल के समूह से युक्त एक छवि का विभाजन होता है। प्रत्येक छवि पैच एक टोकन है। किसी भी वीआईटी में 1 टोकन का आकार पैच_हाइट * पैच_विड्थ * चैनलों की संख्या है। पैच आयामों के आधार पर, हमें एक छवि के लिए कई पैच या टोकन मिलते हैं। यदि छवि का आकार (H*W*3) 224 * 224 * 3 पिक्सेल है और पैच का आकार 4 * 4 है, तो हमें छवि से 224/4 * 224/4 = 56 * 56 पैच या 3136 टोकन मिलते हैं। प्रत्येक टोकन या पैच आकार 4*4*3 = 48 आयाम या 48 पिक्सेल डेटा का होगा। तो इस छवि के लिए आर्किटेक्चर के इनपुट में 3136 टोकन होते हैं जिनमें से प्रत्येक का आकार 48 आयाम होता है।

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

आर्किटेक्चर के हर चरण में, हम टोकन की संख्या में कमी देख सकते हैं जबकि टोकन का आकार बढ़ रहा है।

SWIN-T आर्किटेक्चर, " पैच पार्टिशनर" के अलावा, 3 अन्य बिल्डिंग ब्लॉक्स से भी बना है - लीनियर एंबेडिंग, स्वाइन ट्रांसफॉर्मर ब्लॉक, पैच मर्जिंग। इन बिल्डिंग ब्लॉक्स को दोहराया जाता है और यह फीचर मैप्स को एक पदानुक्रमित तरीके से प्रोसेस करता है।

रैखिक एम्बेडिंग:

"पैच पार्टिशनर" से 48 आयामों में से प्रत्येक के 3136 टोकन को 'सी' आकार के फीचर वेक्टर में 48 फीचर वेक्टर के टोकन को एम्बेड करने के लिए फीड फॉरवर्ड लेयर में खिलाया जाता है। यहां 'सी' ट्रांसफॉर्मर की क्षमता के रूप में कार्य करता है और इसके आधार पर SWIN आर्किटेक्चर के 4 प्रकार हैं।

टिनी (स्वाइन-टी) - सी '96' है
छोटा (स्वाइन-एस) - सी '96' है
बेस (स्वाइन-बी) - सी '128' है
बड़ा (स्वाइन-एल) - सी '192' है

इमेज पैचिंग और लीनियर एम्बेडिंग को संयुक्त रूप से एकल कनवल्शन में कार्यान्वित किया जाता है जिसका कर्नेल-आकार और स्ट्राइड-लेंथ पैच-साइज़ के समान होता है। कन्वेन्शनल में चैनलों की संख्या 'सी' होगी।

स्विन ट्रांसफार्मर ब्लॉक:

स्विन ट्रांसफॉर्मर ब्लॉक वीआईटी आर्किटेक्चर में मानक ट्रांसफॉर्मर ब्लॉक से अलग है। स्विन ट्रांसफॉर्मर में, मल्टी-हेड सेल्फ अटेंशन (MSA) परत को या तो बदल दिया जाता है विंडो एमएसए (डब्ल्यू-एमएसए) मॉड्यूल या शिफ्ट विंडो MSA (SW-MSA) मॉड्यूल .

स्टेज 1 में 2 SWIN-T ट्रांसफॉर्मर ब्लॉक (छवि देखें) होते हैं जहां पहले ट्रांसफॉर्मर ब्लॉक में विंडो MSA (W-MSA) होता है और दूसरे ट्रांसफॉर्मर ब्लॉक में विंडो MSA (SW-MSA) मॉड्यूल शिफ्ट होता है। SWin ट्रांसफॉर्मर ब्लॉक में, W-MSA और SW-MSA लेयर्स के इनपुट और आउटपुट को नॉर्मलाइज़ेशन लेयर्स के माध्यम से पास किया जाता है। फिर इसे गॉसियन एरर लीनियर यूनिट्स (GELU) एक्टिवेशन के साथ 2 लेयर्ड फीड फॉरवर्ड नेटवर्क के अधीन किया जाता है। प्रत्येक ब्लॉक के भीतर और इन 2 ब्लॉकों के बीच अवशिष्ट कनेक्शन हैं।

विंडो MSA (W-MSA) और Shifted Window MSA (SW-MSA) मॉड्यूल

वीआईटी में मानक ध्यान परत को विंडो वाली एमएसए परत के साथ क्यों बदल दिया गया है?

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

W-MSA या SW-MSA मॉड्यूल में आत्म-ध्यान तंत्र एक स्थानीय है जो केवल छवि की एक ही विंडो के भीतर पैच के बीच आत्म-ध्यान की गणना करता है, न कि खिड़कियों के बाहर।

विंडोज़ छवि के बड़े विभाजन की तरह हैं जहाँ प्रत्येक विंडो में M*M पैच होते हैं। वैश्विक आत्म-ध्यान को स्थानीय आत्म-ध्यान के साथ बदलकर कम्प्यूटेशनल जटिलता को द्विघात से रैखिक तक कम कर दिया।

स्थानीय आत्म-ध्यान के लिए W-MSA और SW-MSA दोनों क्यों? उनके बीच क्या अंतर है?

W-MSA और SW-MSA ध्यान मॉड्यूल के बीच मुख्य अंतर यह है कि छवि के लिए विंडो कैसे कॉन्फ़िगर की जाती हैं।

W-MSA मॉड्यूल में, एक नियमित विंडो विभाजन रणनीति का पालन किया जाता है। छवि को छवि के ऊपरी-बाएँ पिक्सेल से शुरू होने वाली गैर-अतिव्यापी विंडो में समान रूप से विभाजित किया जाता है, और प्रत्येक विंडो में M*M या M2 पैच होते हैं।

SW-MSA मॉड्यूल में, विंडो कॉन्फ़िगरेशन को W-MSA परत से स्थानांतरित कर दिया जाता है, विंडोज़ को नियमित विभाजन रणनीति से (M/2, M/2) पैच द्वारा विस्थापित करके।

SW-MSA में एक शिफ्ट की गई विंडो विभाजन रणनीति क्यों?

चूंकि W-MSA में एक विंडो के भीतर स्थानीय रूप से ध्यान प्रतिबंधित है, इसलिए शिफ्ट की गई विंडो क्रॉस-विंडो ध्यान को अभी भी वैश्विक ध्यान के लाभ प्राप्त करने में सक्षम बनाती है। यह संभव है क्योंकि W-MSA परत में window1 की सीमाएं SW-MSA परत में windows W2, W4 और W5 के साथ साझा की जाती हैं। इसलिए वैश्विक ध्यान अप्रत्यक्ष रूप से "स्थानांतरित खिड़कियों पर स्थानीय ध्यान" के माध्यम से होता है।

पैच मर्जिंग लेयर

जैसे-जैसे नेटवर्क गहरा और गहरा होता जाता है, पैच मर्जिंग परत टोकन की संख्या को कम करती है। पहली पैच मर्जिंग परत 2×2 पड़ोसी पैच के प्रत्येक समूह की विशेषताओं को जोड़ती है।

कुत्ते की नस्ल के वर्गीकरण पर SWIN ट्रांसफॉर्मर

PyPI में पैकेज tfswin ने SWIN ट्रान्सफ़ॉर्मर्स के TF-Keras वेरिएंट को पूर्व-प्रशिक्षित किया है और इसे आधिकारिक pytorch कार्यान्वयन के आधार पर बनाया गया है। इसका कोड जीथब में उपलब्ध है। tfswin का उपयोग कुत्ते की नस्ल की छवियों को प्रशिक्षित करने के लिए किया जाता है।

 from tfswin import SwinTransformerBase224, preprocess_input def build_model1(swintransformer): tf.keras.backend.clear_session() inputs = Input(shape=(resize_height, resize_width, 3)) outputs = Lambda(preprocess_input)(inputs) outputs = swintransformer(outputs) outputs = Dense(num_classes, activation='softmax')(outputs) swin_model = Model(inputs=inputs, outputs=outputs) return swin_model #build the model swintransformer = SwinTransformerBase224(include_top=False,pooling='avg') swin_model1 = build_model1(swintransformer) #set the layers of the pretrained model as non-trainable for layer in swin_model1.layers[2].layers: layer.trainable = False swin_model1.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),loss='categorical_crossentropy',metrics=['accuracy'])

कनवल्शनल बेस्ड मॉडल्स

शुरू करने के लिए, विभिन्न ResNet वेरिएंट को शीर्ष परतों के लिए अलग-अलग प्रतिस्थापन के साथ प्रशिक्षित किया गया था, और आंशिक रूप से नेटवर्क को पूरी तरह से फ्रीज करने के लिए।

 #Logloss of the test set using various ResNet variants +------------+---------------+-------------------------+----------+ | Model Name | Retrained | Top Layers Replacement | Log_Loss | +------------+---------------+-------------------------+----------+ | ResNet50 | None | ConvBlock_FC_Output | 0.96463 | | ResNet50 | None | GlobalAvgPooling_Output | 0.58147 | | ResNet50 | last 4 layers | ConvBlock_FC_Output | 2.10158 | | ResNet50 | last 4 layers | GlobalAvgPooling_Output | 0.57019 | +------------+---------------+-------------------------+----------+

कम से कम लॉग हानि के साथ ResNet50 मॉडल के अनुरूप कोड

 from tensorflow.keras.layers import Input,Conv2D,Dense,BatchNormalization,Flatten,Concatenate, Dropout,MaxPooling2D from tensorflow.keras.models import Model from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input def build_model(): tf.keras.backend.clear_session() inputs = Input(shape=(resize_height, resize_width, 3)) #added preprocess_input method as a layer to convert input images to those expected by Resnet processed_inputs = preprocess_input(inputs) #use the pretrained ResNet model (Parameter pooling = 'avg' will take care of the Gobal Average Pooling of the ResNet model features) base_model = ResNet50(weights="imagenet", include_top=False,pooling='avg')(processed_inputs) #output layer output = Dense(units=num_classes,activation='softmax',name='Output')(base_model) resnet_model = Model(inputs=inputs, outputs=output) return resnet_model #build the model resnet_model = build_model() #set the layers of the resnet pretrained model as non-trainable except for its last 4 layers which needs to be re-trained for this data for layer in resnet_model.layers[3].layers[:-4]: layer.trainable = False #compile the model resnet_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),loss='categorical_crossentropy',metrics=['accuracy']) print(resnet_model.summary()) history = resnet_model.fit(train_ds, epochs=50, validation_data=val_ds, callbacks=callbacks_list)

अधिक परिष्कृत पूर्व-प्रशिक्षित कनवल्शन मॉडल जैसे एफिशिएंटनेट, NASNet, InceptionResNet, Xception और InceptionV3 को कुत्ते की नस्ल की छवियों का उपयोग स्टैंडअलोन और एक समेकित फैशन दोनों में भी प्रशिक्षित किया गया था। इन मॉडलों से परीक्षण डेटा (10K छवियों से युक्त) पर लॉग हानि किसी भी ResNet वेरिएंट की तुलना में कम थी।

 #Logloss of the standalone model variants +----------------------------+-------------+ | Model Name | Log_Loss | +----------------------------+-------------+ | EfficientNetV2M | 0.28347 | | Inception ResNet | 0.28623 | | NasNetLarge | 0.33285 | | Xception | 0.34187 | | Inception_V3 | 0.54297 | | EfficientNetV2M_GlobalAveg | 0.50423 | | InceptionV3_GlobalAveg | 0.46402 | +----------------------------+-------------+

स्टैंडअलोन मॉडल के लिए, पूर्व-प्रशिक्षित मॉडल की परतें जमी हुई थीं और उनकी शीर्ष परतों को या तो बदल दिया गया था
- कनवल्शनल लेयर और उसके बाद मैक्सपूलिंग लेयर
- वैश्विक औसत पूलिंग परत

EfficientNet आर्किटेक्चर सभी 3 आयामों - गहराई, चौड़ाई और रिज़ॉल्यूशन में एक सही ढंग से स्केल किया गया मॉडल है।
NASNet-Large विभिन्न हाइपरपैरामीटर खोज एल्गोरिदम, अनुकूलन एल्गोरिदम और सुदृढीकरण सीखने वाले एल्गोरिदम का उपयोग करके किए गए मॉडल आर्किटेक्चर खोज का परिणाम है।
इंसेप्शनV3 ने बड़े कनवल्शन को छोटे एसिंक्रोनस कनवल्शन में फैक्टराइज़ किया और मॉडल कन्वर्जेंस को बेहतर बनाने के लिए सहायक क्लासिफायर भी शामिल किया।
इंसेप्शन आर्किटेक्चर इंसेप्शन आर्किटेक्चर में इंसेप्शन मॉड्यूल के बजाय गहराई से वियोज्य कनवल्शन करता है।
सबसे अच्छा प्रदर्शन करने वाले स्टैंडअलोन मॉडल की तुलना में पहनावा मॉडल से लॉग हानि> 0.1 कम हो गई।

 +--------------------------------------------------------------------------+-----------+ | Model Name | Log_Loss | +--------------------------------------------------------------------------+-----------+ | Ensemble1 - EfficientNEt,InceptionResNet,NasNet,Xception) | 0.17363 | | Ensemble2 - EfficientNEt,InceptionResNet,NasNet,Xception and InceptionV3 | 0.16914 | | Ensemble3 - Ensemble2 with 50% dropout. | 0.16678 | | Ensemble4 - Ensemble of various EfficientNet Architecture | 0.16519 | +--------------------------------------------------------------------------+-----------+

Each of these models accepts varied input formats and in Keras they have their own preprocessing functions.

बेंचमार्किंग परिणाम

 +----------------------------------+------------+----------------------+----------+ | Model Name | Parameters | Train time (seconds) | Log_Loss | +----------------------------------+------------+----------------------+----------+ | EfficientNet_ConvBlock_Output | 54.7M | ~260s | 0.28347 | | InceptionResNet_ConvBlock_Output | 56.1M | ~260s | 0.28623 | | NASNetLarge_ConvBlock_Output | 89.6M | ~330s | 0.33285 | | XCeption_ConvBlock_Output | 23.3M | ~240s | 0.34187 | | InceptionV3_ConvBlock_Output | 24.2M | ~225s | 0.54297 | | EfficientNet_GlobalAvg | 53.3M | ~260s | 0.50423 | | InceptionV3_GlobalAvg | 22M | ~215s | 0.46402 | | swin_base224 | 86.8M | ~550s | 0.47289 | | swin_base384 | 87M | ~600s | 0.41902 | | swin_large384 | 195M | ~1000s | 0.42207 | +----------------------------------+------------+----------------------+----------+

SWIN ट्रान्सफ़ॉर्मर्स ने सभी ResNet50 वेरिएंट्स और InceptionV3 मॉडल से बेहतर प्रदर्शन किया है।
इस डेटा पर SWIN ट्रांसफॉर्मर का लॉग-लॉस InceptionResNet, EfficientNet, Xception और NasNet बड़े मॉडल की तुलना में थोड़ा अधिक है, जब उनके आउटपुट को बाद में कनवल्शनल लेयर द्वारा संसाधित किया जाता है और उसके बाद Maxpooling।
हालांकि SWIN प्रदर्शन उतना ही अच्छा है जितना कि EfficientNet मॉडल जब उनके औसत आउटपुट को सीधे आउटपुट लेयर द्वारा संसाधित किया जाता है।
SWIN मॉडल किसी भी कन्वेन्शनल मॉडल की तुलना में बड़े होते हैं और इसलिए सिस्टम थ्रूपुट और लेटेंसी को प्रभावित करेंगे।

यह अध्ययन कंप्यूटर दृष्टि के लिए ट्रांसफॉर्मर आधारित मॉडलों के अनुप्रयोग को समझने में उपयोगी साबित हुआ।

आप मेरे गीथूब पर नोटबुक के लिए कोड पा सकते हैं और इस उपयोग के मामले के लिए जीयूआई यहां ।