NumPy குறைந்த சதுரங்கள்

Numpy Kurainta Caturankal



இன்று, லீனியர் சமன்பாடுகளில் உள்ள குறைந்தபட்ச சதுரங்கள் மற்றும் வழங்கப்பட்ட தரவுத்தொகுப்புகளில் பின்னடைவுக் கோட்டிற்கான சிறந்த பொருத்தத்திற்கான குறைந்தபட்ச சதுர முறையை எவ்வாறு செயல்படுத்துவது என்பதைப் பற்றி அறியப் போகிறோம். ஆனால் அதற்கு முன், NumPy பற்றிய அடிப்படை அறிவைப் பெறுவோம். Python இன் சிறந்த கணித தொகுப்புகளில் NumPy ஒன்றாகும்

பைதான் lstsq() இன் முறைகளில் ஒன்று, அறியப்பட்ட நேரியல் சமன்பாட்டின் ax=b இன் பின்னடைவுக் கோட்டைக் கண்டறியப் பயன்படுகிறது, இது இந்தச் சமன்பாட்டுடன் மிகவும் பொருந்துகிறது. அதாவது x மற்றும் y புள்ளிகளுக்கு இடையே உள்ள தொடர்பை உங்கள் தரவு குறிப்பிடும் பட்சத்தில், அந்த வரியை சரியாகக் காட்டும் வரியை நீங்கள் தீர்மானிக்க வேண்டும். இந்த சமன்பாட்டின் மூலம் குறைந்த சதுரத்தை கண்டுபிடிக்க பயன்படுத்தப்படும் போது இரண்டு புள்ளிகளுக்கும் இடையே உள்ள கோடு பின்னடைவு கோடு என அழைக்கப்படுகிறது, ax=b.

தொடரியல்:

linalg.lstsq() செயல்பாட்டின் செயல்படுத்தும் பாணியைக் கற்றுக்கொள்ள ஆரம்பிக்கலாம். முதலில், பைத்தானில் நாம் பயன்படுத்தும் நூலகப் பெயரை “நம்பி” என்று எழுதுகிறோம். பின்னர், நாம் linalg() செயல்பாட்டை இணைக்கிறோம் மற்றும் lstsq() செயல்பாட்டை இணைக்கிறோம். linalg() செயல்பாட்டின் பொருள் நேரியல் இயற்கணிதம். இது எப்போதும் lstsq() செயல்பாட்டுடன் பயன்படுத்தப்படுகிறது, ஏனெனில் இது ஒரு நேரியல் இயற்கணித வெளிப்பாடாகும். இதற்குப் பிறகு, செயல்பாடு அடைப்புக்குறிக்குள் வாதங்களை அனுப்புகிறோம்.









அளவுருக்கள்:

linalg.lstsq() செயல்பாட்டின் அளவுருக்களைப் புரிந்து கொள்வோம்:



புள்ளி 1: இது குணகம் மேட்ரிக்ஸ்.





புள்ளி2: இந்த அணி அல்லது அணியானது சார்பு மாறிகளைக் கொண்டுள்ளது.

rcond: அதன் தரவு வகை மிதவை. rcond விகிதம் புள்ளி_1 இன் சிறிய ஒற்றை மதிப்புகளுக்கான கட்-ஆஃப் ஆகும். புள்ளி_1 இன் மிகப்பெரிய ஒற்றை உறுப்பின் rcond மடங்குகளைக் காட்டிலும் ஒரு ஒற்றை மதிப்பு குறைவாக இருந்தால், தரவரிசையை நிர்ணயிக்கும் போது அது பூஜ்ஜியமாகக் கருதப்படுகிறது.



வருவாய் மதிப்பு:

பதிலுக்கு, ax=b சமன்பாட்டில் அறியப்பட்ட மாறி x இன் குறைந்தபட்ச சதுரத்தைப் பெறுகிறோம்.

எடுத்துக்காட்டு 1:

பைதான் நூலகத்தின் குறைந்தபட்ச சதுர முறையான NumPy இன் முதல் உதாரணத்தை செயல்படுத்தத் தொடங்குவோம். முதலில், நமக்கு ஒரு பைதான் கம்பைலர் தேவை, அதில் நாம் குறியீடு செய்யலாம். கம்பைலரைத் திறக்கவும். நீங்கள் NumPy நூலகத்தையும் நிறுவ வேண்டும், ஏனெனில் நாங்கள் NumPy இன் செயல்பாடுகளில் ஒன்றைப் பயன்படுத்துகிறோம், இது lstsq() செயல்பாடாகும். பின்னர், நீங்கள் அதில் உள்ள NumPy தொகுப்பை இறக்குமதி செய்ய வேண்டும். முதலில், 'இறக்குமதி' என்ற முக்கிய சொல்லை எழுதவும், இது தொகுப்பாளரிடம் தொகுப்பை இறக்குமதி செய்யப் போகிறோம் என்று கூறுகிறது. பின்னர், 'numpy' செயல்பாட்டில் நாம் பயன்படுத்தும் தொகுப்பு பெயரை எழுத வேண்டும். பின்னர், பல புரோகிராமர்கள் இந்த அணுகுமுறையைப் பயன்படுத்துவதால், NumPy 'np' இன் மாற்றுப் பெயரையும் எழுதுகிறோம். இது ஒரு நல்ல நிரலாக்க அணுகுமுறையாகும், மேலும் இது நேரத்தை மிச்சப்படுத்துகிறது.

தொகுப்பை இறக்குமதி செய்த பிறகு, நாம் செய்ய விரும்பும் குறியீட்டின் உண்மையான வரியை எழுதத் தொடங்குகிறோம். நாங்கள் முதலில் செய்திகளை அச்சிடுகிறோம், இதன் மூலம் அச்சு() அறிக்கையைப் பயன்படுத்தி எடுத்துக்காட்டில் நாம் என்ன செய்கிறோம் என்பதை பயனர் எளிதாகப் புரிந்து கொள்ள முடியும். வரிசை() செயல்பாட்டைப் பயன்படுத்தி ஒரு பரிமாண வரிசை 'A' ஐ உருவாக்கி, அதை அச்சு() அறிக்கையை அழைப்பதன் மூலம் அச்சிடுகிறோம். பின்னர், வரிசை() செயல்பாட்டைப் பயன்படுத்தி மற்றொரு ஒரு பரிமாண வரிசை 'B' ஐ உருவாக்கி அதை அச்சு () செயல்பாட்டைப் பயன்படுத்தி அச்சிடுகிறோம்.

இறக்குமதி உணர்ச்சியற்ற என எ.கா.

அச்சு ( 'NumPy இல் குறைந்த சதுர முறையின் செயலாக்கம்:' )

= எ.கா. வரிசை ( [ 1 , இரண்டு , 1 , 1 , 1 , இரண்டு , இரண்டு , 1 , 1 ] )

அச்சு ( ' \n வரிசை A என்பது: ' , )

பி = எ.கா. வரிசை ( [ 4 , 3 , 5 , 4 , இரண்டு , 3 , 6 , 3 , இரண்டு ] )

அச்சு ( ' \n வரிசை B என்பது: ' , பி )

எக்ஸ் = எ.கா. ஆளிவிதை . lstsq ( எ.கா. vstack ( [ , எ.கா. ஒன்றை ( மட்டுமே ( ) ) ] ) . டி , பி , rcond = இல்லை ) [ 0 ]

அச்சு ( ' \n குறைந்த சதுரம்: ' , எக்ஸ் )

A மற்றும் B ஆகிய இரு புள்ளிகளையும் உருவாக்கிய பிறகு, lstsq() செயல்பாட்டைச் செயல்படுத்துகிறோம். ஆனால் முதலில், 'A' இன் உறுப்புகளை வரிசை வாரியாக அடுக்கி வைக்க vstack() செயல்பாட்டைப் பயன்படுத்துகிறோம். பின்னர், 'A' வரிசையை மாற்றுவோம். பின்னர், vstack() செயல்பாட்டை lstsq() செயல்பாட்டின் முதல் வாதமாக அனுப்புகிறோம். இரண்டாவது வாதம் 'B' வரிசை மற்றும் மூன்றாவது வாதம் 'rcond' ஆகும், இதில் rcond இன் மதிப்பை 'இல்லை' என அமைக்கிறோம். பின்னர், முழு செயல்பாட்டையும் “x” என்ற பெயரில் மற்றொரு வரிசையில் சேமிக்கிறோம், இது அறியப்பட்ட மாறி நேரியல் சமன்பாடு, ax=b என்பதைக் காட்டுகிறது. இதற்குப் பிறகு, நாங்கள் முடிவுகளைக் காண்பிப்போம், எனவே இதற்கு அச்சு() அறிக்கையைப் பயன்படுத்துகிறோம் மற்றும் அதில் 'x' வரிசையை அனுப்புகிறோம்.

எடுத்துக்காட்டு 2:

இப்போது, ​​NumPy குறைந்தபட்ச சதுரங்களின் மற்றொரு உதாரணத்தை செயல்படுத்த ஆரம்பிக்கலாம். NumPy நிரலில் நாம் பயன்படுத்தும் நூலகத்தை முதலில் இறக்குமதி செய்கிறோம். முதலில், நிரலில் தொகுப்பைப் பெற 'இறக்குமதி' என்ற முக்கிய சொல்லை எழுதுகிறோம். நாங்கள் தொகுப்பின் பெயரையும் எழுதுகிறோம், அது 'நம்பி' மற்றும் அதன் மாற்றுப்பெயரான 'np'. பின்னர், நாம் அச்சு() முறையை அழைக்கிறோம், இதனால் பயனரை நன்கு புரிந்துகொள்வதற்காக குறைந்தபட்ச சதுரங்களின் மறு அட்டவணை செய்தியை காண்பிக்க முடியும்.

பின்னர், 'x_axis' என்ற வரிசைப் பெயரை உருவாக்கி, அதில் arange() செயல்பாட்டைப் பயன்படுத்தி வரிசையை சேமித்து வைக்கிறோம். பின்னர், அச்சு () முறையைப் பயன்படுத்தி அச்சிடுகிறோம். பின்னர், 'y_axis' என்ற மற்றொரு வரிசைப் பெயரை உருவாக்கி, பின்வரும் விளக்கப்படத்தில் நாம் உருவாக்கிய வரிசையை அதில் சேமித்து வைக்கிறோம்.

இரண்டு வரிசைகளையும் உருவாக்கிய பிறகு, நாம் x_axis வரிசையில் one() முறையைச் செயல்படுத்தி, 'array_a' என்ற பெயரில் மற்றொரு வரிசையில் சேமிக்கிறோம். பின்னர், நாம் இந்த வரிசை அச்சிட. “arg_reg_line” என்ற பெயரில் மற்றொரு வரிசையை உருவாக்கி, அதில் linalg.lstsq() செயல்பாட்டைச் செயல்படுத்துகிறோம். பின்னர், இந்த செயல்பாட்டிற்கு அளவுருக்களை அனுப்புகிறோம், இதனால் இரண்டு வரிசைகள் அல்லது புள்ளிகளுக்கு இடையில் குறைந்தபட்ச சதுரங்களைப் பெறலாம். முதல் அளவுரு, நாம் array_a இன் இடமாற்றத்தை எடுத்துக்கொள்கிறோம். இரண்டாவது அளவுரு இரண்டாவது புள்ளியாகும், இது y_axis ஆகும். பின்னர், எங்களிடம் 'rcond' உள்ளது, அதில் 'இல்லை' மதிப்பு உள்ளது. நாம் அச்சு () முறையைப் பயன்படுத்தி வரிசையைக் காண்பிக்கிறோம்.

இறக்குமதி உணர்ச்சியற்ற என எ.கா.

அச்சு ( 'linalg.lstsq() செயல்பாட்டின் செயலாக்கம்: ' )

x_அச்சு = எ.கா. ஏற்பாடு ( 0 , 10 )

அச்சு ( ' \n x அச்சின் மதிப்பு: ' , x_அச்சு )

y_அச்சு = [ 10.3 , 10.5 , பதினொரு , 11.5 , 13.2 , 13.9 , 14 , 15.5 , 16.6 , 17 ]

அச்சு ( ' \n y அச்சின் மதிப்பு: ' , y_அச்சு )

வரிசை_a = எ.கா. வரிசை ( [ x_அச்சு , எ.கா. ஒன்றை ( 10 ) ] )

அச்சு ( ' \n வரிசை என்பது: \n ' , வரிசை_a )

arg_reg_line = எ.கா. ஆளிவிதை . lstsq ( வரிசை_a. டி , y_அச்சு , rcond = இல்லை ) [ 0 ]

அச்சு ( ' \n Regrssion வரியின் அளவுருக்கள்: ' , arg_reg_line )

reg_line = arg_reg_line [ 0 ] * x_axis + arg_reg_line [ 1 ]

இறக்குமதி matplotlib. பைப்லாட் என plt

plt. சதி ( x_அச்சு , reg_line , 'r-' )

plt. சதி ( x_அச்சு , y_அச்சு , 'ஓ' )

plt. தலைப்பு ( 'நேரியல் பின்னடைவு கோடு' )

plt. எக்ஸ்லேபிள் ( 'எக்ஸ்-அச்சு' )

plt. ylabel ( 'ஒய்-அச்சு' )

plt. நிகழ்ச்சி ( )

முன்பு செயல்படுத்தப்பட்ட உதாரணத்தின் வெளியீடு இங்கே:

NumPy இன் மற்றொரு தொகுப்பை நாங்கள் இறக்குமதி செய்கிறோம், இது வரைபடத்தைத் திட்டமிடப் பயன்படும் “matplotlib” தொகுப்பாகும். பின்னர், x_axis மதிப்புகள் மற்றும் y_axis_values ​​ஆகியவற்றைத் திட்டமிடுகிறோம். அடுத்து, வரைபடத்தின் தலைப்பு மற்றும் லேபிள்களை அமைக்கிறோம். கடைசியாக, ஷோ() முறையைப் பயன்படுத்தி வரைபடத்தைக் காண்பிக்கிறோம்.

கொடுக்கப்பட்ட எடுத்துக்காட்டின் விரும்பிய வரைபடம் இங்கே:

முடிவுரை

இந்தக் கட்டுரையில், குறைந்த சதுரம் எது என்பதையும், ax=b என்ற நேரியல் சமன்பாட்டைப் பயன்படுத்தி, தெரியாத மாறி x இன் linalg.lstsq()ஐ எவ்வாறு பெறுவது என்பதையும் கற்றுக்கொண்டோம். குறைந்த சதுரங்களைக் கண்டறிய NumPy இன் பல செயல்பாடுகளைப் பயன்படுத்தினோம், மேலும் பயனரை நன்கு புரிந்துகொள்ள விரிவான விளக்கங்களுடன் சில உதாரணங்களைச் செயல்படுத்தினோம்.