ప్రొఫైలింగ్ సాధనాలతో పైథాన్ కోడ్‌ని ఆప్టిమైజ్ చేయడం
ప్రొఫైలింగ్ సాధనాలతో పైథాన్ కోడ్‌ని ఆప్టిమైజ్ చేయడానికి పని చేయడానికి Google Colabని సెటప్ చేయడం, మేము Google Colab వాతావరణాన్ని సెటప్ చేయడం ద్వారా ప్రారంభిస్తాము. మేము Colabకి కొత్తవారైతే, ఇది జూపిటర్ నోట్‌బుక్‌లు మరియు పైథాన్ లైబ్రరీల శ్రేణికి ప్రాప్యతను అందించే ముఖ్యమైన, శక్తివంతమైన క్లౌడ్-ఆధారిత ప్లాట్‌ఫారమ్. మేము (https://colab.research.google.com/)ని సందర్శించడం ద్వారా మరియు కొత్త పైథాన్ నోట్‌బుక్‌ని సృష్టించడం ద్వారా Colabని యాక్సెస్ చేస్తాము.
ప్రొఫైలింగ్ లైబ్రరీలను దిగుమతి చేయండి
మా ఆప్టిమైజేషన్ ప్రొఫైలింగ్ లైబ్రరీల నైపుణ్యం వినియోగంపై ఆధారపడి ఉంటుంది. ఈ సందర్భంలో రెండు ముఖ్యమైన లైబ్రరీలు cProfile మరియు line_profiler.
దిగుమతి cProfile
దిగుమతి లైన్_ప్రొఫైలర్
“cProfile” లైబ్రరీ అనేది ప్రొఫైలింగ్ కోడ్ కోసం అంతర్నిర్మిత పైథాన్ సాధనం, అయితే “line_profiler” అనేది ఒక బాహ్య ప్యాకేజీ, ఇది లైన్ ద్వారా కోడ్‌ను విశ్లేషించడం ద్వారా మరింత లోతుగా వెళ్లడానికి అనుమతిస్తుంది.
ఈ దశలో, రికర్సివ్ ఫంక్షన్‌ని ఉపయోగించి ఫైబొనాక్సీ సీక్వెన్స్‌ను లెక్కించేందుకు మేము నమూనా పైథాన్ స్క్రిప్ట్‌ని సృష్టిస్తాము. ఈ ప్రక్రియను మరింత లోతుగా విశ్లేషిద్దాం. ఫైబొనాక్సీ సీక్వెన్స్ అనేది సంఖ్యల సమితి, దీనిలో ప్రతి వరుస సంఖ్య దాని ముందు ఉన్న రెండు సంఖ్యల మొత్తం. ఇది సాధారణంగా 0 మరియు 1తో మొదలవుతుంది, కాబట్టి క్రమం 0, 1, 1, 2, 3, 5, 8, 13, 21, మొదలైన వాటిలా కనిపిస్తుంది. ఇది గణిత క్రమం, దాని పునరావృత స్వభావం కారణంగా ప్రోగ్రామింగ్‌లో సాధారణంగా ఉదాహరణగా ఉపయోగించబడుతుంది.
మేము రికర్సివ్ ఫైబొనాక్సీ ఫంక్షన్‌లో “ఫైబొనాక్సీ” అనే పైథాన్ ఫంక్షన్‌ని నిర్వచించాము. ఈ ఫంక్షన్ “n” పూర్ణాంకాన్ని దాని వాదనగా తీసుకుంటుంది, ఇది మనం లెక్కించదలిచిన ఫైబొనాక్సీ సీక్వెన్స్‌లోని స్థానాన్ని సూచిస్తుంది. మేము ఫిబొనాక్సీ సీక్వెన్స్‌లో ఐదవ సంఖ్యను గుర్తించాలనుకుంటున్నాము, ఉదాహరణకు, “n” 5కి సమానం అయితే.
డెఫ్ ఫైబొనాక్సీ ( n ) :
తరువాత, మేము బేస్ కేసును ఏర్పాటు చేస్తాము. రికర్షన్‌లో బేస్ కేస్ అనేది కాల్‌లను ముగించే మరియు ముందుగా నిర్ణయించిన విలువను అందించే దృశ్యం. ఫైబొనాక్సీ సీక్వెన్స్‌లో, “n” 0 లేదా 1 అయినప్పుడు, మనకు ఇప్పటికే ఫలితం తెలుసు. 0వ మరియు 1వ ఫైబొనాక్సీ సంఖ్యలు వరుసగా 0 మరియు 1.
ఉంటే n <= 1 :తిరిగి n
ఈ “if” స్టేట్‌మెంట్ “n” 1 కంటే తక్కువగా ఉందో లేదా సమానంగా ఉందో లేదో నిర్ణయిస్తుంది. ఒకవేళ అలా అయితే, తదుపరి పునరావృతం అవసరం లేనందున మేము “n”ని తిరిగి ఇస్తాము.
పునరావృత గణన
“n” 1ని మించి ఉంటే, మేము పునరావృత గణనతో కొనసాగుతాము. ఈ సందర్భంలో, మనం “(n-1)”వ మరియు “(n-2)”వ ఫైబొనాక్సీ సంఖ్యలను సంగ్రహించడం ద్వారా “n”-th ఫైబొనాక్సీ సంఖ్యను కనుగొనాలి. మేము ఫంక్షన్‌లో రెండు పునరావృత కాల్‌లు చేయడం ద్వారా దీనిని సాధిస్తాము.
లేకపోతే :తిరిగి ఫైబొనాక్సీ ( n - 1 ) + ఫైబొనాక్సీ ( n - 2 )
ఇక్కడ, “ఫైబొనాక్సీ(n – 1)” అనేది “(n-1)”వ ఫైబొనాక్సీ సంఖ్యను మరియు “ఫైబొనాక్సీ(n – 2)” అనేది “(n-2)”వ ఫైబొనాక్సీ సంఖ్యను గణిస్తుంది. “n” స్థానం వద్ద కావలసిన ఫైబొనాక్సీ సంఖ్యను పొందడానికి మేము ఈ రెండు విలువలను జోడిస్తాము.
సారాంశంలో, ఈ 'ఫైబొనాక్సీ' ఫంక్షన్ ఫిబొనాక్సీ సంఖ్యలను పునరావృతంగా గణిస్తుంది, సమస్యను చిన్న ఉప-సమస్యలుగా విభజించడం ద్వారా. ఇది బేస్ కేసులను (0 లేదా 1) చేరుకునే వరకు పునరావృత కాల్‌లను చేస్తుంది, తెలిసిన విలువలను అందిస్తుంది. ఏదైనా ఇతర “n” కోసం, ఇది “(n-1)” మరియు “(n-2)” కోసం రెండు పునరావృత కాల్‌ల ఫలితాలను సంగ్రహించడం ద్వారా ఫైబొనాక్సీ సంఖ్యను గణిస్తుంది.
ఫైబొనాక్సీ సంఖ్యలను లెక్కించేందుకు ఈ అమలు సూటిగా ఉన్నప్పటికీ, ఇది అత్యంత ప్రభావవంతమైనది కాదు. తదుపరి దశల్లో, మెరుగైన అమలు సమయాల కోసం దాని పనితీరు పరిమితులను గుర్తించడానికి మరియు ఆప్టిమైజ్ చేయడానికి మేము ప్రొఫైలింగ్ సాధనాలను ఉపయోగిస్తాము.
CPprofileతో కోడ్‌ని ప్రొఫైల్ చేయడం
ఇప్పుడు, మేము 'cProfile'ని ఉపయోగించడం ద్వారా మా 'ఫైబొనాక్సీ' ఫంక్షన్‌ను ప్రొఫైల్ చేస్తాము. ఈ ప్రొఫైలింగ్ వ్యాయామం ప్రతి ఫంక్షన్ కాల్ ద్వారా వినియోగించబడే సమయం గురించి అంతర్దృష్టులను అందిస్తుంది.
cprofiler = cProfile. ప్రొఫైల్ ( )cprofiler. ప్రారంభించు ( )
ఫలితం = ఫైబొనాక్సీ ( 30 )
cprofiler. డిసేబుల్ ( )
cprofiler. ముద్రణ_గణాంకాలు ( క్రమబద్ధీకరించు = 'సంచిత' )
ఈ విభాగంలో, మేము “cProfile” ఆబ్జెక్ట్‌ను ప్రారంభిస్తాము, ప్రొఫైలింగ్‌ను సక్రియం చేస్తాము, “n=30”తో “fibonacci” ఫంక్షన్‌ను అభ్యర్థిస్తాము, ప్రొఫైలింగ్‌ను నిష్క్రియం చేస్తాము మరియు సంచిత సమయం ప్రకారం క్రమబద్ధీకరించబడిన గణాంకాలను ప్రదర్శిస్తాము. ఈ ప్రారంభ ప్రొఫైలింగ్ మాకు అధిక-స్థాయి అవలోకనాన్ని అందిస్తుంది.
! pip install line_profilerదిగుమతి cProfile
దిగుమతి లైన్_ప్రొఫైలర్
డెఫ్ ఫైబొనాక్సీ ( n ) :
ఉంటే n <= 1 :
తిరిగి n
లేకపోతే :
తిరిగి ఫైబొనాక్సీ ( n - 1 ) + ఫైబొనాక్సీ ( n - 2 )
cprofiler = cProfile. ప్రొఫైల్ ( )
cprofiler. ప్రారంభించు ( )
ఫలితం = ఫైబొనాక్సీ ( 30 )
cprofiler. డిసేబుల్ ( )
cprofiler. ముద్రణ_గణాంకాలు ( క్రమబద్ధీకరించు = 'సంచిత' )
మరింత వివరణాత్మక విశ్లేషణ కోసం line_profilerతో లైన్ ద్వారా కోడ్ లైన్‌ను ప్రొఫైల్ చేయడానికి, మేము మా కోడ్ లైన్‌ను లైన్ ద్వారా విభజించడానికి “line_profiler”ని ఉపయోగిస్తాము. “line_profiler”ని ఉపయోగించే ముందు, మేము తప్పనిసరిగా Colab రిపోజిటరీలో ప్యాకేజీని ఇన్‌స్టాల్ చేయాలి.
! pip install line_profilerఇప్పుడు మనకు “line_profiler” సిద్ధంగా ఉంది, మేము దానిని మా “fibonacci” ఫంక్షన్‌కి వర్తింపజేయవచ్చు:
%load_ext line_profilerడెఫ్ ఫైబొనాక్సీ ( n ) :
ఉంటే n <= 1 :
తిరిగి n
లేకపోతే :
తిరిగి ఫైబొనాక్సీ ( n - 1 ) + ఫైబొనాక్సీ ( n - 2 )
%lprun -f ఫైబొనాక్సీ ఫైబొనాక్సీ ( 30 )
ఈ స్నిప్పెట్ “line_profiler” పొడిగింపును లోడ్ చేయడం ద్వారా ప్రారంభమవుతుంది, మా “fibonacci” ఫంక్షన్‌ను నిర్వచిస్తుంది మరియు చివరికి “n=30”తో “fibonacci” ఫంక్షన్‌ను ప్రొఫైల్ చేయడానికి “%lprun”ని ఉపయోగిస్తుంది. ఇది అమలు సమయాల యొక్క లైన్-బై-లైన్ సెగ్మెంటేషన్‌ను అందిస్తుంది, మా కోడ్ దాని వనరులను ఎక్కడ ఖర్చు చేస్తుందో ఖచ్చితంగా క్లియర్ చేస్తుంది.
ఫలితాలను విశ్లేషించడానికి ప్రొఫైలింగ్ సాధనాలను అమలు చేసిన తర్వాత, ఇది మా కోడ్ పనితీరు లక్షణాలను చూపే గణాంకాల శ్రేణితో ప్రదర్శించబడుతుంది. ఈ గణాంకాలు ప్రతి ఫంక్షన్‌లో వెచ్చించిన మొత్తం సమయం మరియు కోడ్ యొక్క ప్రతి లైన్ వ్యవధిని కలిగి ఉంటాయి. ఉదాహరణకు, ఫైబొనాక్సీ ఫంక్షన్ ఒకేలా ఉండే విలువలను అనేకసార్లు తిరిగి లెక్కించడానికి కొంచెం ఎక్కువ సమయాన్ని పెట్టుబడి పెడుతుందని మేము గుర్తించవచ్చు. ఇది పునరావృత గణన మరియు ఇది మెమోయిజేషన్ ద్వారా లేదా పునరావృత అల్గారిథమ్‌లను ఉపయోగించడం ద్వారా ఆప్టిమైజేషన్‌ని వర్తింపజేయగల స్పష్టమైన ప్రాంతం.
ఇప్పుడు, మేము మా ఫైబొనాక్సీ ఫంక్షన్‌లో సంభావ్య ఆప్టిమైజేషన్‌ను గుర్తించిన ఆప్టిమైజేషన్‌లను చేస్తాము. ఫంక్షన్ అదే ఫైబొనాక్సీ సంఖ్యలను అనేకసార్లు తిరిగి గణించడాన్ని మేము గమనించాము, ఫలితంగా అనవసరమైన రిడెండెన్సీ మరియు నెమ్మదిగా అమలు సమయం ఏర్పడుతుంది.
దీన్ని ఆప్టిమైజ్ చేయడానికి, మేము జ్ఞాపకాలను అమలు చేస్తాము. మెమోయైజేషన్ అనేది ఒక ఆప్టిమైజేషన్ టెక్నిక్, ఇది గతంలో లెక్కించిన ఫలితాలను (ఈ సందర్భంలో, ఫైబొనాక్సీ సంఖ్యలు) నిల్వ చేయడం మరియు వాటిని తిరిగి లెక్కించడానికి బదులుగా అవసరమైనప్పుడు వాటిని మళ్లీ ఉపయోగించడం. ఇది అనవసరమైన గణనలను తగ్గిస్తుంది మరియు పనితీరును మెరుగుపరుస్తుంది, ముఖ్యంగా ఫైబొనాక్సీ సీక్వెన్స్ వంటి పునరావృత ఫంక్షన్ల కోసం.
మా ఫైబొనాక్సీ ఫంక్షన్‌లో మెమోయిజేషన్‌ని అమలు చేయడానికి, మేము ఈ క్రింది కోడ్‌ను వ్రాస్తాము:
# కంప్యూటెడ్ ఫైబొనాక్సీ సంఖ్యలను నిల్వ చేయడానికి నిఘంటువుfib_cache = { }
డెఫ్ ఫైబొనాక్సీ ( n ) :
ఉంటే n <= 1 :
తిరిగి n
# ఫలితం ఇప్పటికే కాష్ చేయబడిందో లేదో తనిఖీ చేయండి
ఉంటే n లో fib_cache:
తిరిగి fib_cache [ n ]
లేకపోతే :
# ఫలితాన్ని లెక్కించండి మరియు కాష్ చేయండి
fib_cache [ n ] = ఫైబొనాక్సీ ( n - 1 ) + ఫైబొనాక్సీ ( n - 2 )
తిరిగి fib_cache [ n ] ,
'fibonacci' ఫంక్షన్ యొక్క ఈ సవరించిన సంస్కరణలో, మేము గతంలో గణించబడిన Fibonacci సంఖ్యలను నిల్వ చేయడానికి 'fib_cache' నిఘంటువును పరిచయం చేస్తాము. ఫైబొనాక్సీ సంఖ్యను లెక్కించే ముందు, అది ఇప్పటికే కాష్‌లో ఉందో లేదో తనిఖీ చేస్తాము. అది ఉంటే, మేము కాష్ చేసిన ఫలితాన్ని తిరిగి ఇస్తాము. ఏదైనా ఇతర సందర్భంలో, మేము దానిని గణించి, కాష్‌లో ఉంచి, ఆపై దాన్ని తిరిగి ఇస్తాము.
ప్రొఫైలింగ్ మరియు ఆప్టిమైజేషన్‌ను పునరావృతం చేయడం
ఆప్టిమైజేషన్ (మా విషయంలో జ్ఞాపకం) అమలు చేసిన తర్వాత, మా మార్పుల ప్రభావాన్ని తెలుసుకోవడానికి మరియు మేము కోడ్ పనితీరును మెరుగుపరిచామని నిర్ధారించుకోవడానికి ప్రొఫైలింగ్ ప్రక్రియను పునరావృతం చేయడం చాలా కీలకం.
ఆప్టిమైజేషన్ తర్వాత ప్రొఫైలింగ్
ఆప్టిమైజ్ చేసిన ఫైబొనాక్సీ ఫంక్షన్‌ను ప్రొఫైల్ చేయడానికి మేము అదే ప్రొఫైలింగ్ సాధనాలను ఉపయోగించవచ్చు, “cProfile” మరియు “line_profiler”. కొత్త ప్రొఫైలింగ్ ఫలితాలను మునుపటి వాటితో పోల్చడం ద్వారా, మేము మా ఆప్టిమైజేషన్ ప్రభావాన్ని కొలవగలము.
“cProfile”ని ఉపయోగించి ఆప్టిమైజ్ చేసిన “ఫైబొనాక్సీ” ఫంక్షన్‌ని ఎలా ప్రొఫైల్ చేయవచ్చో ఇక్కడ ఉంది:
cprofiler = cProfile. ప్రొఫైల్ ( )cprofiler. ప్రారంభించు ( )
ఫలితం = ఫైబొనాక్సీ ( 30 )
cprofiler. డిసేబుల్ ( )
cprofiler. ముద్రణ_గణాంకాలు ( క్రమబద్ధీకరించు = 'సంచిత' )
“line_profiler”ని ఉపయోగించి, మేము దానిని లైన్ వారీగా ప్రొఫైల్ చేస్తాము:
%lprun -f ఫైబొనాక్సీ ఫైబొనాక్సీ ( 30 )కోడ్:
# కంప్యూటెడ్ ఫైబొనాక్సీ సంఖ్యలను నిల్వ చేయడానికి నిఘంటువుfib_cache = { }
డెఫ్ ఫైబొనాక్సీ ( n ) :
ఉంటే n <= 1 :
తిరిగి n
# ఫలితం ఇప్పటికే కాష్ చేయబడిందో లేదో తనిఖీ చేయండి
ఉంటే n లో fib_cache:
తిరిగి fib_cache [ n ]
లేకపోతే :
# ఫలితాన్ని లెక్కించండి మరియు కాష్ చేయండి
fib_cache [ n ] = ఫైబొనాక్సీ ( n - 1 ) + ఫైబొనాక్సీ ( n - 2 )
తిరిగి fib_cache [ n ]
cprofiler = cProfile. ప్రొఫైల్ ( )
cprofiler. ప్రారంభించు ( )
ఫలితం = ఫైబొనాక్సీ ( 30 )
cprofiler. డిసేబుల్ ( )
cprofiler. ముద్రణ_గణాంకాలు ( క్రమబద్ధీకరించు = 'సంచిత' )
%lprun -f ఫైబొనాక్సీ ఫైబొనాక్సీ ( 30 )
ఆప్టిమైజేషన్ తర్వాత ప్రొఫైలింగ్ ఫలితాలను విశ్లేషించడానికి, ముఖ్యంగా పెద్ద “n” విలువల కోసం, అమలు సమయాలు గణనీయంగా తగ్గుతాయి. మెమోయైజేషన్ కారణంగా, ఫిబొనాక్సీ సంఖ్యలను తిరిగి లెక్కించడానికి ఫంక్షన్ ఇప్పుడు చాలా తక్కువ సమయాన్ని వెచ్చిస్తున్నట్లు మేము గమనించాము.
ఆప్టిమైజేషన్ ప్రక్రియలో ఈ దశలు అవసరం. ఆప్టిమైజేషన్ అనేది ప్రొఫైలింగ్ నుండి పొందే పరిశీలనల ఆధారంగా మా కోడ్‌లో సమాచారంతో కూడిన మార్పులను చేయడాన్ని కలిగి ఉంటుంది, అదే సమయంలో ప్రొఫైలింగ్ పునరావృతం చేయడం మా ఆప్టిమైజేషన్‌లు ఆశించిన పనితీరు మెరుగుదలలను అందజేస్తాయని నిర్ధారిస్తుంది. పునరావృత ప్రొఫైలింగ్, ఆప్టిమైజ్ చేయడం మరియు ధృవీకరించడం ద్వారా, మెరుగైన పనితీరును అందించడానికి మరియు మా అప్లికేషన్‌ల వినియోగదారు అనుభవాన్ని మెరుగుపరచడానికి మేము మా పైథాన్ కోడ్‌ని చక్కగా ట్యూన్ చేయవచ్చు.
ముగింపు
ఈ కథనంలో, మేము Google Colab వాతావరణంలో ప్రొఫైలింగ్ సాధనాలను ఉపయోగించి పైథాన్ కోడ్‌ను ఆప్టిమైజ్ చేసిన ఉదాహరణ గురించి చర్చించాము. మేము సెటప్‌తో ఉదాహరణను ప్రారంభించాము, అవసరమైన ప్రొఫైలింగ్ లైబ్రరీలను దిగుమతి చేసాము, నమూనా కోడ్‌లను వ్రాసాము, 'cProfile' మరియు 'line_profiler' రెండింటినీ ఉపయోగించి ప్రొఫైల్ చేసాము, ఫలితాలను లెక్కించాము, ఆప్టిమైజేషన్‌లను వర్తింపజేసాము మరియు కోడ్ పనితీరును పునరావృతంగా మెరుగుపరిచాము.