NumPy என்பது பைத்தான் நிரலாக்க மொழியில் எண்கணித அமைப்புகளை உருவாக்கவும், கையாளவும் பயன்படும் ஒரு நூலகம்(library) ஆகும். நிரலாக்க மொழியில் நூலகம் என்பதை ஏற்கனவே எழுதி இயக்கப்பட்ட பல தொகுப்புகளின் சேகரிப்பு(Collection of Modules) என்று புரிந்துகொள்ளலாம். NumPy பல-பரிமாண அணிகள், மெட்ரிக்ஸ்கள் போன்றவற்றை உருவாக்கவும் கையாளவும் பயன்படுகிறது. NumPy நூலகம் பைத்தான் மொழியின் அடிப்படை அங்கமாகவே செயல்படுகிறது, மேலும் இது பல அறிவியல் கணக்கீட்டு நூலகங்களால் பயன்படுத்தப்படுகிறது.
NumPy நூலகத்தின் சில முக்கிய அம்சங்கள்:
1) பல-பரிமாண அணிகளை உருவாக்கவும் கையாளவும் வழிவகை செய்கிறது
2) அணிகளில் கணித செயல்பாடுகளை மேற்கொள்ள உதவுகிறது
3) அணிகளைக் கோப்புகளில் எழுதவும், அதைத்திரும்பப் பெறவும் வழிகளை உருவாக்குகிறது
4) அணிகளைக் காட்சிப்படுத்துகிறது
NumPy நூலகம் பல அறிவியல் கணக்கீட்டுத் துறைகளில் பயன்படுத்தப்படுகிறது, அவற்றில் சில:
– எண்ணியல் கணக்கீடு
– தரவு பகுப்பாய்வு
– இயந்திர கற்றல்
– உருவகப்படுத்துதல்
– அறிவியல் கணிப்பொறியை உருவாக்குதல்
NumPy நூலகத்தைப் பயன்படுத்த, நீங்கள் அதை முதலில் உங்கள் கணினியில் நிறுவ வேண்டும். இதை pip கட்டளைப் பயன்பாட்டைப் பயன்படுத்திச் செய்யலாம்:
pip install numpy
ஒரே வரியில் NumPy குறித்துச் சொல்லவேண்டுமென்றால், அணிகளுக்கான பிரத்தியேக நூலகம் எனலாம்.
நிரல் 1: பல பரிமாண அணிகளை உருவாக்குதல்
நிரலின் முதல் வரியில் NumPy நூலகத்தை இறக்குமதி செய்திருக்கிறோம், கூடவே அதைச் சுட்டிக்காட்டுவதற்காக np என்ற அடையாளங்காட்டியும் உருவாக்கியிருக்கிறோம். முதலில் ஒற்றைப் பரிமாண அணியை உருவாக்குவதற்காக array() என்ற மு.வ.செயல்பாடு பயன்படுத்தப்பட்டு இருக்கிறது. அதன் அளவுருவாக எண்களைக் கொண்ட ஒரு பட்டியல் அனுப்பப்படுகிறது, அவ்வளவுதான். ஒற்றைப் பரிமாண அணி தயார்.
பல பரிமாண அணியை உருவாக்குவது எப்படி? ஒரு பட்டியலுக்குள் இன்னொன்றை உருவாக்கினால், பல பரிமாண அணி ரெடி. நிரலின் இரண்டாவது பகுதியைக் கவனியுங்கள், அதில் முறையே மூன்று உறுப்புகளைக் கொண்ட இரண்டு பட்டியல்களை array()விறகு அளவுருவாக அனுப்பியிருக்கிறோம். எனில், நாம் உண்டாக்கியிருப்பது 2 x 3 அணிகள்.
இதேபோன்று நம் தேவைக்கு ஏற்ப, array() செயல்பாட்டைக் கொண்டு பல பரிமாண அணிகளை எளிதில் உருவாக்கிவிடலாம்.
நிரல் 2: அணிகளின் வடிவத்தையும், அளவையும் கண்டறிதல்
வடிவம் வேறு, அளவு வேறா என்றால் அணிகளைப் பொறுத்தவரையில் அப்படித்தான் என்கிறது பைத்தான். வடிவம், ஒற்றையா அல்லது அதற்கும் மேலா என்கிற அதன் பரிமாணத்தைக் குறிக்கிறது. அளவைப் பொருத்தமட்டில் எப்போதும் போலக் குறிப்பிட்ட அந்த அணியில் எத்தனை உறுப்புகள் உள்ளன என்ற எண்ணிக்கையைத் தருகிறது.
நிரல் 3: அணிகளின் கூட்டல் பெருக்கல் செயல்பாடுகள்
போன அத்தியாயத்தில் அணிகளைக் கூட்டவும் பெருக்கவும் for loop எல்லாம் பயன்படுத்திப் பாடுபட்டது நினைவிருக்கலாம். NumPyயில் அதற்கான தேவை எதுவும் கிடையாது, நேரடியாகவே அணிகளுக்கே இடையே எண்கணித இயக்கிகளைப் பயன்படுத்த முடியும். அப்படிப் பயன்படுத்துகையில், அவை அணியில் உள்ள ஒவ்வொரு உறுப்பிற்கும் பொருந்தும் என்பதை நிரல் புரிந்துகொள்ளும்.
நிரலில் இரண்டு அணிகள் உருவாக்கி, அவற்றின் மீது கூட்டல் பெருக்கல் செயல்பாடுகளை மேற்கொண்டு இருக்கிறோம், வடிவம் எப்படியிருந்தாலும் கவலையில்லை. + மற்றும் * ஆகிய இயக்கிகள் வேலையை ஒரே வரியில் முடித்துத் தந்துவிடும்.
நிரல் 4: கணித, திரிகோண கணித, அடுக்குக்குச்சார்பு செயல்பாடுகளை மேற்கொள்ளுதல்
மூன்று உறுப்புகளைக்கொண்ட ஒற்றைப்பரிமாண அணியொன்று உருவாக்கப்படுகிறது. அதிலிருந்து ஒவ்வொரு உறுப்பாக எடுத்து அதன் சைன் மதிப்புகள் கண்டறியப்பட்டு, இரண்டாம் அணி உருவாகிறது.
இதே பாணியில் மூன்றாவது அணி அடுக்குக்குச்சார்பு மதிப்புகளை(முதல் அணியின்) கொண்டிருக்கிறது.
இந்த நிரலின் நோக்கம், கணித செயல்பாடுகளுக்கான அத்தனை வாய்ப்புகளையும் ஒற்றை வரியில் மேற்கொள்ளும் வாய்ப்புகளை NumPy வழங்குகிறது என்பதைத் தெரிந்துகொள்வதுதான்.
நிரல் 5: அணியின் வடிவத்தை மாற்றுதல்
for loopல் range() செயல்பாடு குறித்து விரிவாகப் பார்த்திருந்தது வாசகர்களுக்கு நினைவிருக்கலாம். கிட்டத்தட்ட அதே பணியை அணிக்காகச் செய்து தருகிறது arange() செயல்பாடு. நீங்கள் np.arange(12) என்று எழுதினால் 0லிருந்துத் தொடங்கி 11 வரை உள்ள எண்களைக்கொண்டு ஒரு அணியை உருவாக்கித்தரும்.
அப்படி உருவாக்கப்பட்ட அணியின் வடிவத்தை உங்கள் விருப்பத்திற்கு ஏற்ப மாற்றிக்கொள்ள முடியும். அதற்கு reshape() எனும் செயல்பாடு பயன்படுகிறது. மொத்தம் 12 உறுப்புகள் இல்லையா? ஒற்றைப் பரிமாண அணியாக இருக்கிறது. அதன் வடிவத்தை 3 x 4 என்று மாற்றி அச்சிட்டு இருக்கிறோம்.
நிரல் 6: இரண்டு அணிகளை இணைத்தல்
அணிகள் என்ற பதத்தைப் பயன்படுத்தினாலும் கூட அடிப்படையில் பட்டியல் தரவு வகையைக்கொண்டு தான் அவற்றை(அணிகள்) உருவாக்குகிறோம் இல்லையா? எனில் பட்டியலால் சாதிக்க முடிந்த அனைத்தையும் அணிகளில் முயன்று பார்க்கலாம் என்றுதானே அர்த்தம்.
இரண்டு பட்டியலை இணைக்க முடிவது சாத்தியம் என்றால் இரண்டு அணிகளும் இணையும் தானே? அதை முயன்று பார்ப்பதற்காகத் தான் இந்த நிரல். concatenate() என்கிற செயல்பாடு இரண்டு அணிகளை இணைத்துத் தருகிறது. மேலும் axis=0 என்று பிரத்தியேகமாகக் குறிப்பிடுவதற்குக் காரணம் அணிகள் நெட்டுக்குத்தலாக இணைய வேண்டும் என்று நிரலுக்கு அறிவுறுத்துகிறோம். axis=1 என்றிருந்தால் கிடைமட்டமாக என்று அறிக.
நிரல் 7: தற்போக்கு எண்களைக்கொண்ட(random Numbers) அணியை உருவாக்குதல்
ஒரு அணி முழுவதும் நம் கட்டுப்பாட்டில் இல்லாத தற்போக்கு எண்களை மட்டும் இட்டு நிரப்ப முடியுமா? முடியும் என்கிறது இந்த நிரல், 3 x 3 வடிவத்திலுள்ள ஒரு அணி முழுவதும், rand() என்கிற மு.வ.செயல்பாட்டைக்கொண்டு தற்போக்கு எண்களைக்கொண்டு உருவாக்கியிருக்கிறோம்.
நிரல் 8: அணியின் பெரிய சிறிய எண்களைக் கண்டறிதல்
ஒரு 2 x 3 அணியை உருவாக்கி, அதன் பெரிய சிறிய எண்களைக் கண்டறிவது தான் இந்த நிரலின் நோக்கம். ஒட்டுமொத்த அணிக்கும் பெரிய சிறிய எண்களைக் கண்டுபிடிக்கலாம். அதேபோல வரிக்கு வரி மற்றும் செங்குத்தாகவும் பெரிய சிறிய எண்களைக் கண்டறிய முடியும்.
நிரலின் முதல் பகுதியில் ஒட்டுமொத்த அணிக்குமான சிறிய எண்ணைக் கண்டுபிடித்து அச்சிட்டு இருக்கிறோம். இரண்டாம் பகுதியில் வரிக்கு வரி, அதாவது முதல் மற்றும் இரண்டாம் வரியில் உள்ள பெரிய எண்களைக் கண்டுபிடித்து அச்சிட்டு இருக்கிறோம். axis=1 என்பது வரியையே (row) குறிக்கிறது.
(தொடரும்)
