పైథాన్ lstsq() యొక్క పద్ధతుల్లో ఒకటి తెలిసిన సరళ సమీకరణం ax=b యొక్క రిగ్రెషన్ లైన్‌ను కనుగొనడానికి ఉపయోగించబడుతుంది, ఇది ఈ సమీకరణంతో బాగా సరిపోతుంది. దీనర్థం మీరు x మరియు y పాయింట్ల మధ్య సంబంధాన్ని సరిగ్గా చూపే పంక్తిని గుర్తించాలని మీ డేటా సూచించినట్లయితే. ఈ సమీకరణం ద్వారా అతి తక్కువ చతురస్రాన్ని కనుగొనడానికి ఉపయోగించినప్పుడు రెండు బిందువుల మధ్య రేఖను రిగ్రెషన్ లైన్ అంటారు, ax=b.
సింటాక్స్:
linalg.lstsq() ఫంక్షన్ యొక్క అమలు శైలిని నేర్చుకోవడం ప్రారంభిద్దాం. మొదట, పైథాన్‌లో మనం ఉపయోగించే లైబ్రరీ పేరును వ్రాస్తాము, అది “numpy”. అప్పుడు, మేము 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 అనేది: ' , బి )
X = ఉదా లిన్సీడ్ . lstsq ( ఉదా vstack ( [ ఎ , ఉదా వాటిని ( మాత్రమే ( ఎ ) ) ] ) . టి , బి , rcond = ఏదీ లేదు ) [ 0 ]
ముద్రణ ( ' \n తక్కువ చతురస్రం: ' , X )
A మరియు B రెండు పాయింట్లను సృష్టించిన తర్వాత, మేము lstsq() ఫంక్షన్‌ను అమలు చేస్తాము. కానీ ముందుగా, మేము 'A' మూలకాలను వరుస క్రమంలో పేర్చడానికి vstack() ఫంక్షన్‌ని ఉపయోగిస్తాము. అప్పుడు, మేము శ్రేణి 'A' యొక్క బదిలీని తీసుకుంటాము. అప్పుడు, మనము vstack() ఫంక్షన్‌ని lstsq() ఫంక్షన్ యొక్క మొదటి ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము. రెండవ ఆర్గ్యుమెంట్ “B” శ్రేణి మరియు మూడవ ఆర్గ్యుమెంట్ “rcond” దీనిలో మనం rcond విలువను “ఏదీ కాదు”గా సెట్ చేస్తాము. అప్పుడు, మేము మొత్తం ఫంక్షన్‌ను “x” అనే పేరు గల మరొక శ్రేణిలో నిల్వ చేస్తాము, ఇది తెలిసిన వేరియబుల్ లీనియర్ ఈక్వేషన్, ax=b అని చూపిస్తుంది. దీని తర్వాత, మేము ఫలితాలను ప్రదర్శిస్తాము కాబట్టి మేము దీని కోసం ప్రింట్() స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము మరియు దానిలో “x” శ్రేణిని పాస్ చేస్తాము.
ఉదాహరణ 2:
ఇప్పుడు, NumPy మినిస్ట్ స్క్వేర్‌ల యొక్క మరొక ఉదాహరణను అమలు చేయడం ప్రారంభిద్దాం. మేము ఎల్లప్పుడూ NumPy ప్రోగ్రామ్‌లో ఉపయోగించే లైబ్రరీని మొదట దిగుమతి చేస్తాము. ముందుగా, ప్రోగ్రామ్‌లో ప్యాకేజీని పొందడానికి మేము 'దిగుమతి' అనే కీవర్డ్‌ని వ్రాస్తాము. మేము ప్యాకేజీ పేరును 'numpy' అని వ్రాసి, ఆపై అతని మారుపేరు 'np' అని కూడా వ్రాస్తాము. అప్పుడు, మేము ప్రింట్() పద్ధతిని పిలుస్తాము, తద్వారా వినియోగదారుని బాగా అర్థం చేసుకోవడానికి మేము తక్కువ స్క్వేర్‌ల రీటేబుల్ సందేశాన్ని ప్రదర్శిస్తాము.
అప్పుడు, మేము శ్రేణి పేరు 'x_axis'ని సృష్టించి, arange() ఫంక్షన్‌ని ఉపయోగించి శ్రేణిని నిల్వ చేస్తాము. అప్పుడు, మేము దానిని ప్రింట్ () పద్ధతిని ఉపయోగించి ప్రింట్ చేస్తాము. అప్పుడు, మేము మరొక శ్రేణి పేరు “y_axis”ని సృష్టిస్తాము మరియు క్రింది దృష్టాంతంలో మేము సృష్టించిన శ్రేణిని దానిలో నిల్వ చేస్తాము.
రెండు శ్రేణులను సృష్టించిన తర్వాత, మేము x_axis శ్రేణిలో ones() పద్ధతిని అమలు చేస్తాము మరియు దానిని “array_a” పేరుతో మరొక శ్రేణిలో నిల్వ చేస్తాము. ఆపై, మేము కూడా ఈ శ్రేణిని ప్రింట్ చేస్తాము. మేము “arg_reg_line” పేరుతో మరొక శ్రేణిని సృష్టించి, దానిపై linalg.lstsq() ఫంక్షన్‌ని అమలు చేస్తాము. అప్పుడు, మేము ఈ ఫంక్షన్‌కు పారామితులను పాస్ చేస్తాము, తద్వారా మేము రెండు శ్రేణులు లేదా పాయింట్ల మధ్య కనీసం చతురస్రాలను పొందగలము. మొదటి పరామితి ఏమిటంటే మనం array_a యొక్క ట్రాన్స్‌పోజ్‌ని తీసుకుంటాము. రెండవ పరామితి రెండవ పాయింట్, ఇది y_axis. అప్పుడు, మనకు “rcond” ఉంది, ఇందులో “ఏదీ లేదు” విలువ ఉంటుంది. మేము ప్రింట్ () పద్ధతిని ఉపయోగించి శ్రేణిని ప్రదర్శిస్తాము.
దిగుమతి మొద్దుబారిన వంటి ఉదాముద్రణ ( 'linalg.lstsq() ఫంక్షన్ అమలు: ' )
x_axis = ఉదా ఏర్పాటు ( 0 , 10 )
ముద్రణ ( ' \n x అక్షం యొక్క విలువ: ' , x_axis )
y_axis = [ 10.3 , 10.5 , పదకొండు , 11.5 , 13.2 , 13.9 , 14 , 15.5 , 16.6 , 17 ]
ముద్రణ ( ' \n y అక్షం యొక్క విలువ: ' , y_axis )
శ్రేణి_a = ఉదా అమరిక ( [ x_axis , ఉదా వాటిని ( 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_axis , reg_line , 'r-' )
plt. ప్లాట్లు ( x_axis , y_axis , 'ఓ' )
plt. శీర్షిక ( 'లీనియర్ రిగ్రెషన్ లైన్' )
plt. xlabel ( 'X-యాక్సిస్' )
plt. ylabel ( 'Y-యాక్సిస్' )
plt. చూపించు ( )
గతంలో అమలు చేసిన ఉదాహరణ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:
మేము NumPy యొక్క మరొక ప్యాకేజీని దిగుమతి చేస్తాము, ఇది గ్రాఫ్‌ను ప్లాట్ చేయడానికి ఉపయోగించే “matplotlib” ప్యాకేజీ. అప్పుడు, మేము x_axis విలువలు మరియు y_axis_valuesని ప్లాట్ చేస్తాము. తరువాత, మేము గ్రాఫ్ యొక్క శీర్షిక మరియు లేబుల్లను సెట్ చేస్తాము. చివరగా, మేము show() పద్ధతిని ఉపయోగించి గ్రాఫ్‌ని ప్రదర్శిస్తాము.
ఇవ్వబడిన ఉదాహరణ యొక్క కావలసిన గ్రాఫ్ ఇక్కడ ఉంది:
ముగింపు
ఈ కథనంలో, మేము లీనియర్ సమీకరణం ax=bని ఉపయోగించి తెలియని వేరియబుల్ x యొక్క linalg.lstsq()ని అతి తక్కువ చతురస్రం ఏది మరియు ఎలా పొందాలో తెలుసుకున్నాము. మేము తక్కువ స్క్వేర్‌లను కనుగొనడానికి NumPy యొక్క బహుళ ఫంక్షన్‌లను ఉపయోగించాము మరియు వినియోగదారుని బాగా అర్థం చేసుకోవడం కోసం వివరణాత్మక వివరణలతో కొన్ని ఉదాహరణలను అమలు చేసాము.