டென்சர்களின் மிகப்பெரிய நன்மைகளில் ஒன்று திறமையான கணித செயல்பாடுகளைச் செய்யும் திறன் ஆகும். கூட்டல், கழித்தல், பெருக்கல் மற்றும் வகுத்தல் போன்ற உறுப்பு வாரியான செயல்பாடுகள் மற்றும் மேட்ரிக்ஸ் பெருக்கல் மற்றும் இடமாற்றம் போன்ற மேட்ரிக்ஸ் செயல்பாடுகள் உட்பட பலவிதமான எண்கணித செயல்பாடுகளை டென்சர்கள் ஆதரிக்கின்றன.
PyTorch டென்சர்களைக் கையாள்வதற்கான விரிவான செயல்பாடுகள் மற்றும் முறைகளை வழங்குகிறது. டென்சர்களை மறுவடிவமைத்தல், குறிப்பிட்ட உறுப்புகள் அல்லது துணை-டென்சர்களைப் பிரித்தெடுத்தல் மற்றும் குறிப்பிட்ட பரிமாணங்களில் டென்சர்களை ஒருங்கிணைத்தல் அல்லது பிரித்தல் போன்ற செயல்பாடுகள் இதில் அடங்கும். கூடுதலாக, PyTorch பல்வேறு வடிவங்கள் மற்றும் அளவுகள் கொண்ட டென்சர்களுடன் வேலை செய்வதை எளிதாக்கும் டென்சர்களை அட்டவணைப்படுத்துதல், வெட்டுதல் மற்றும் ஒளிபரப்புவதற்கான செயல்பாடுகளை வழங்குகிறது.
இந்தக் கட்டுரையில், PyTorchல் உள்ள டென்சர்களுடன் அடிப்படைச் செயல்பாடுகளைக் கற்றுக்கொள்வோம், எப்படி டென்சர்களை உருவாக்குவது, அடிப்படை செயல்பாடுகளைச் செய்வது, அவற்றின் வடிவத்தைக் கையாள்வது மற்றும் CPU மற்றும் GPU இடையே அவற்றை நகர்த்துவது எப்படி என்பதை ஆராய்வோம்.
டென்சர்களை உருவாக்குதல்
PyTorchல் உள்ள டென்சர்களை பல வழிகளில் உருவாக்கலாம். சில பொதுவான முறைகளை ஆராய்வோம்.
ஒரு டென்சரை உருவாக்க, நாம் 'torch.Tensor' வகுப்பு அல்லது 'torch.tensor' செயல்பாட்டைப் பயன்படுத்தலாம். சில உதாரணங்களைப் பார்ப்போம்:
இறக்குமதி ஜோதி
# உருவாக்கு 1 - பைதான் பட்டியலில் இருந்து பரிமாண டென்சர்
tensor_1d = ஜோதி. பதற்றம் ( [ 1 , 2 , 3 , 4 , 5 ] )
அச்சு ( tensor_1d )
# உருவாக்கு 2 - உள்ளமைக்கப்பட்ட பைதான் பட்டியலில் இருந்து பரிமாண டென்சர்
tensor_2d = ஜோதி. பதற்றம் ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
அச்சு ( tensor_2d )
# ஒரு குறிப்பிட்ட வடிவத்துடன் பூஜ்ஜியங்களின் டென்சரை உருவாக்கவும்
பூஜ்ஜியம்_டென்சர் = ஜோதி. பூஜ்ஜியங்கள் ( 3 , 2 )
அச்சு ( பூஜ்ஜியம்_டென்சர் )
# ஒரு குறிப்பிட்ட வடிவத்துடன் ஒரு டென்சரை உருவாக்கவும்
ஒன்று_டென்சர் = ஜோதி. ஒன்றை ( 2 , 3 )
அச்சு ( ஒன்று_டென்சர் )
# சீரான விநியோகத்திலிருந்து சீரற்ற மதிப்புகளைக் கொண்ட டென்சரை உருவாக்கவும்
சீரற்ற_டென்சர் = ஜோதி. ராண்ட் ( 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 )
அச்சு ( 'மறுவடிவ டென்சர்:' , மறுவடிவமான_டென்சர் )
# ஒரு டென்சரின் அளவைப் பெறுங்கள்
அளவு = பதற்றம் அளவு ( )
அச்சு ( 'டென்சரின் அளவு:' , அளவு )
# உறுப்புகளின் எண்ணிக்கையைப் பெறுங்கள் உள்ளே ஒரு டென்சர்
எண்_உறுப்புகள் = பதற்றம் பெயர் கொடு ( )
அச்சு ( 'உறுப்புகளின் எண்ணிக்கை:' , எண்_உறுப்புகள் )
வழங்கப்பட்ட குறியீட்டில், ரீஷேப் செயல்பாட்டைப் பயன்படுத்தி ஒரு டென்சரை மறுவடிவமைப்போம், அளவு முறையைப் பயன்படுத்தி ஒரு டென்சரின் அளவை மீட்டெடுக்கிறோம் மற்றும் எண் முறையைப் பயன்படுத்தி ஒரு டென்சரில் உள்ள மொத்த உறுப்புகளின் எண்ணிக்கையைப் பெறுகிறோம்.
CPU மற்றும் GPU இடையே டென்சர்களை நகர்த்துதல்
PyTorch GPU முடுக்கத்திற்கான ஆதரவை வழங்குகிறது, இது கிராபிக்ஸ் கார்டுகளில் கணக்கீடுகளைச் செய்ய அனுமதிக்கிறது, இது பயிற்சி நேரத்தைக் குறைப்பதன் மூலம் ஆழமான கற்றல் பணிகளை கணிசமாக துரிதப்படுத்தும். 'to' முறையைப் பயன்படுத்தி CPU மற்றும் GPU க்கு இடையில் டென்சர்களை நகர்த்தலாம்.
குறிப்பு : உங்கள் கணினியில் CUDA உடன் NVIDIA GPU இருந்தால் மட்டுமே இதைச் செய்ய முடியும்.
இறக்குமதி ஜோதி# CPU இல் டென்சரை உருவாக்கவும்
tensor_cpu = ஜோதி. பதற்றம் ( [ 1 , 2 , 3 ] )
# காசோலை என்றால் GPU உள்ளது
என்றால் ஜோதி. வெவ்வேறு . கிடைக்கும் ( ) :
# டென்சரை GPU க்கு நகர்த்தவும்
tensor_gpu = tensor_cpu. செய்ய ( 'வெவ்வேறு' )
அச்சு ( 'GPU இல் டென்சர்:' , tensor_gpu )
வேறு :
அச்சு ( 'GPU கிடைக்கவில்லை.' )
வழங்கப்பட்ட குறியீட்டில், torch.cuda.is_available() ஐப் பயன்படுத்தி GPU உள்ளதா என்பதைச் சரிபார்க்கிறோம். ஒரு GPU இருந்தால், டென்சரை CPU இலிருந்து GPU க்கு 'குடா' வாதத்துடன் 'to' முறையைப் பயன்படுத்தி நகர்த்துவோம்.
முடிவுரை
PyTorch உடன் பணிபுரிவதற்கும் ஆழமான கற்றல் மாதிரிகளை உருவாக்குவதற்கும் அடிப்படை டென்சர் செயல்பாடுகளைப் புரிந்துகொள்வது முக்கியமானது. இந்தக் கட்டுரையில், டென்சர்களை உருவாக்குவது, அடிப்படை செயல்பாடுகளைச் செய்வது, அவற்றின் வடிவத்தைக் கையாளுவது மற்றும் CPU மற்றும் GPU இடையே அவற்றை நகர்த்துவது எப்படி என்பதை ஆராய்ந்தோம். இந்த அறிவைக் கொண்டு, நீங்கள் இப்போது PyTorch இல் டென்சர்களுடன் வேலை செய்யத் தொடங்கலாம், கணக்கீடுகளைச் செய்யலாம் மற்றும் அதிநவீன ஆழ்ந்த கற்றல் மாதிரிகளை உருவாக்கலாம். PyTorch இல் தரவுப் பிரதிநிதித்துவம் மற்றும் கையாளுதலுக்கான அடித்தளமாக டென்சர்கள் செயல்படுகின்றன, இது இந்த பல்துறை இயந்திர கற்றல் கட்டமைப்பின் முழு ஆற்றலையும் வெளிக்கொணர உதவுகிறது.