टेंसरों का सबसे बड़ा लाभ कुशल गणितीय संचालन करने की उनकी क्षमता है। टेंसर अंकगणितीय परिचालनों की एक विस्तृत श्रृंखला का समर्थन करते हैं जिनमें जोड़, घटाव, गुणा और भाग जैसे तत्व-वार संचालन और मैट्रिक्स गुणन और ट्रांसपोज़ जैसे मैट्रिक्स संचालन शामिल हैं।
PyTorch टेंसर में हेरफेर करने के लिए कार्यों और विधियों का एक व्यापक सेट प्रदान करता है। इनमें टेंसरों को दोबारा आकार देने, विशिष्ट तत्वों या उप-टेंसरों को निकालने और निर्दिष्ट आयामों के साथ टेंसरों को जोड़ने या विभाजित करने के संचालन शामिल हैं। इसके अतिरिक्त, PyTorch टेंसर को अनुक्रमित करने, स्लाइस करने और प्रसारित करने के लिए कार्यक्षमता प्रदान करता है जिससे विभिन्न आकार और आकार के टेंसर के साथ काम करना आसान हो जाता है।
इस लेख में, हम PyTorch में टेंसर के साथ बुनियादी संचालन सीखेंगे, पता लगाएंगे कि टेंसर कैसे बनाएं, बुनियादी संचालन कैसे करें, उनके आकार में हेरफेर करें और उन्हें सीपीयू और जीपीयू के बीच स्थानांतरित करें।
टेंसर बनाना
PyTorch में टेंसर कई तरीकों से बनाए जा सकते हैं। आइए कुछ सामान्य तरीकों का पता लगाएं।
टेंसर बनाने के लिए, हम 'टॉर्च.टेन्सर' क्लास या 'टॉर्च.टेन्सर' फ़ंक्शन का उपयोग कर सकते हैं। आइए कुछ उदाहरण देखें:
आयात मशाल
# एक बनाने के 1 - पायथन सूची से आयामी टेंसर
टेंसर_1डी = मशाल. टेन्सर ( [ 1 , 2 , 3 , 4 , 5 ] )
छपाई ( टेंसर_1डी )
# एक बनाने के 2 - नेस्टेड पायथन सूची से आयामी टेंसर
टेंसर_2डी = मशाल. टेन्सर ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
छपाई ( टेंसर_2डी )
# एक विशिष्ट आकार के साथ शून्य का एक टेंसर बनाएं
शून्य_टेंसर = मशाल. शून्य ( 3 , 2 )
छपाई ( शून्य_टेंसर )
# एक विशिष्ट आकार वाले टेंसर बनाएं
one_tensor = मशाल. लोगों ( 2 , 3 )
छपाई ( one_tensor )
# एक समान वितरण से यादृच्छिक मानों के साथ एक टेंसर बनाएं
यादृच्छिक_टेंसर = मशाल. हाशिया ( 2 , 2 )
छपाई ( यादृच्छिक_टेंसर )
दिए गए उदाहरणों में, हम विभिन्न आकृतियों के टेंसर बनाते हैं और उन्हें विशिष्ट संख्याओं, शून्य, एक या यादृच्छिक मानों जैसे विभिन्न मानों के साथ प्रारंभ करते हैं। जब आप पिछला कोड स्निपेट चलाते हैं तो आपको एक समान आउटपुट देखना चाहिए:
टेंसर संचालन
एक बार जब हमारे पास टेंसर हो जाते हैं, तो हम उन पर विभिन्न ऑपरेशन कर सकते हैं जैसे कि तत्व-वार अंकगणितीय ऑपरेशन, मैट्रिक्स ऑपरेशन और बहुत कुछ।
तत्व-वार अंकगणितीय संक्रियाएँ
तत्व-वार अंकगणितीय ऑपरेशन हमें तत्व-दर-तत्व के आधार पर टेंसरों के बीच गणना करने की अनुमति देते हैं। ऑपरेशन में शामिल टेंसर का आकार समान होना चाहिए।
यहां कुछ उदाहरण दिए गए हैं:
आयात मशाल# टेंसर बनाएं
टेंसर1 = मशाल. टेन्सर ( [ 1 , 2 , 3 ] )
टेंसर2 = मशाल. टेन्सर ( [ 4 , 5 , 6 ] )
# जोड़ना
जोड़ना = टेंसर1 + टेंसर2
छपाई ( 'जोड़ना:' , जोड़ना )
# घटाव
घटाव = टेंसर1 - टेंसर2
छपाई ( 'घटाव:' , घटाव )
# गुणन
गुणा = टेंसर1 * टेंसर2
छपाई ( 'गुणा:' , गुणा )
# विभाजन
विभाजन = टेंसर1 / टेंसर2
छपाई ( 'विभाजन:' , विभाजन )
दिए गए कोड में, हम दो टेंसरों के बीच जोड़, घटाव, गुणा और भाग संचालन करते हैं जिसके परिणामस्वरूप गणना किए गए मानों के साथ एक नया टेंसर बनता है। कोड स्निपेट का परिणाम इस प्रकार दिखाया गया है:
मैट्रिक्स संचालन
PyTorch मैट्रिक्स गुणन और ट्रांसपोज़ जैसे टेंसरों के लिए कुशल मैट्रिक्स संचालन प्रदान करता है। ये ऑपरेशन रैखिक बीजगणित और तंत्रिका नेटवर्क गणना जैसे कार्यों के लिए विशेष रूप से उपयोगी हैं।
आयात मशाल# टेंसर बनाएं
टेंसर1 = मशाल. टेन्सर ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
टेंसर2 = मशाल. टेन्सर ( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
# मैट्रिक्स गुणन
मैट्रिक्स_उत्पाद = मशाल. चटाई ( टेंसर1 , टेंसर2 )
छपाई ( 'मैट्रिक्स उत्पाद:' , मैट्रिक्स_उत्पाद )
# मैट्रिक्स ट्रांसपोज़
मैट्रिक्स_ट्रांसपोज़ = टेंसर1. टी
छपाई ( 'मैट्रिक्स ट्रांसपोज़:' , मैट्रिक्स_ट्रांसपोज़ )
दिए गए उदाहरण में, हम 'torch.matmul' फ़ंक्शन का उपयोग करके मैट्रिक्स गुणन करते हैं और '.T' विशेषता का उपयोग करके मैट्रिक्स का स्थानांतरण प्राप्त करते हैं।
टेंसर आकार हेरफेर
टेंसरों पर संचालन करने के अलावा, हमें अक्सर विशिष्ट आवश्यकताओं को पूरा करने के लिए उनके आकार में हेरफेर करने की आवश्यकता होती है। PyTorch टेंसर को नया आकार देने के लिए कई फ़ंक्शन प्रदान करता है। आइए इनमें से कुछ कार्यों का पता लगाएं:
आयात मशाल# एक टेंसर बनाएं
टेन्सर = मशाल. टेन्सर ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
# टेंसर को दोबारा आकार दें
पुनः आकार_टेंसर = टेंसर. आकृति बदलें ( 3 , 2 )
छपाई ( 'पुनर्आकारित टेंसर:' , पुनः आकार_टेंसर )
# एक टेंसर का आकार प्राप्त करें
आकार = टेंसर. आकार ( )
छपाई ( 'टेंसर का आकार:' , आकार )
# तत्वों की संख्या प्राप्त करें में एक टेंसर
num_Elements = टेंसर. नाम देना ( )
छपाई ( 'तत्वों की संख्या:' , num_Elements )
दिए गए कोड में, हम रीशेप फ़ंक्शन का उपयोग करके एक टेंसर को नया आकार देते हैं, आकार विधि का उपयोग करके टेंसर के आकार को पुनः प्राप्त करते हैं, और अंक विधि का उपयोग करके टेंसर में तत्वों की कुल संख्या प्राप्त करते हैं।
सीपीयू और जीपीयू के बीच टेंसरों को स्थानांतरित करना
PyTorch GPU त्वरण के लिए समर्थन प्रदान करता है जो हमें ग्राफिक्स कार्ड पर गणना करने की अनुमति देता है जो प्रशिक्षण समय को कम करके गहन शिक्षण कार्यों को काफी तेज कर सकता है। हम 'टू' विधि का उपयोग करके सीपीयू और जीपीयू के बीच टेंसर को स्थानांतरित कर सकते हैं।
टिप्पणी : यह केवल तभी किया जा सकता है जब आपकी मशीन पर CUDA के साथ NVIDIA GPU हो।
आयात मशाल# सीपीयू पर एक टेंसर बनाएं
टेंसर_सीपीयू = मशाल. टेन्सर ( [ 1 , 2 , 3 ] )
# जाँच करना अगर जीपीयू उपलब्ध है
अगर मशाल. अलग . उपलब्ध है ( ) :
# टेंसर को GPU पर ले जाएं
टेंसर_जीपीयू = टेंसर_सीपीयू. को ( 'अलग' )
छपाई ( 'जीपीयू पर टेंसर:' , टेंसर_जीपीयू )
अन्य :
छपाई ( 'जीपीयू उपलब्ध नहीं है।' )
दिए गए कोड में, हम torch.cuda.is_available() का उपयोग करके जाँचते हैं कि GPU उपलब्ध है या नहीं। यदि कोई जीपीयू उपलब्ध है, तो हम 'क्यूडा' तर्क के साथ 'टू' विधि का उपयोग करके टेंसर को सीपीयू से जीपीयू में ले जाते हैं।
निष्कर्ष
PyTorch के साथ काम करने और गहन शिक्षण मॉडल बनाने के लिए मूलभूत टेंसर संचालन को समझना महत्वपूर्ण है। इस लेख में, हमने पता लगाया कि टेंसर कैसे बनाएं, बुनियादी संचालन कैसे करें, उनके आकार में हेरफेर करें और उन्हें सीपीयू और जीपीयू के बीच कैसे स्थानांतरित करें। इस ज्ञान से लैस, अब आप PyTorch में टेंसर के साथ काम करना शुरू कर सकते हैं, गणना कर सकते हैं और परिष्कृत डीप-लर्निंग मॉडल बना सकते हैं। टेंसर PyTorch में डेटा प्रतिनिधित्व और हेरफेर के लिए आधार के रूप में काम करते हैं जो आपको इस बहुमुखी मशीन-लर्निंग ढांचे की पूरी शक्ति का उपयोग करने में सक्षम बनाता है।