NumPy బ్రాడ్కాస్టింగ్ అంటే ఏమిటి?
వివిధ రూపాల శ్రేణులపై అంకగణిత కార్యకలాపాలను నిర్వహిస్తున్నప్పుడు, NumPy దీనిని ప్రసారంగా సూచిస్తుంది. ఈ శ్రేణి కార్యకలాపాలు తరచుగా సంబంధిత మూలకాలపై నిర్వహించబడతాయి. రెండు శ్రేణులు ఒకే ఆకారాన్ని కలిగి ఉంటే, వాటిని సులభంగా చేయవచ్చు. ఈ భావన ఉపయోగకరంగా ఉన్నప్పటికీ, ప్రసారం ఎల్లప్పుడూ సిఫార్సు చేయబడదు ఎందుకంటే ఇది అసమర్థమైన మెమరీ వినియోగానికి దారి తీస్తుంది, ఇది గణనను నెమ్మదిస్తుంది. NumPy కార్యకలాపాలు తరచుగా మూలకం ద్వారా మూలకం విభజించబడిన శ్రేణి జతలలో నిర్వహించబడతాయి.
ప్రసార నియమాలు
ప్రసారం చేసేటప్పుడు నిర్దిష్ట మార్గదర్శకాలను అనుసరించాలి. ఇవి క్రింద వివరించబడ్డాయి:
- రెండు శ్రేణులు ఒకే ర్యాంక్ను కలిగి ఉండకపోతే, శ్రేణుల యొక్క రెండు ఆకారాలు ఒకే పొడవును పంచుకునే వరకు దిగువ ర్యాంక్ శ్రేణి ఆకృతిని 1 సెతో ముందుగా ఉంచడం ముఖ్యం.
- రెండు శ్రేణులు ఒకే పరిమాణంలో ఉన్నట్లయితే లేదా వాటిలో ఒకటి పరిమాణం పరిమాణం 1కి సెట్ చేయబడినట్లయితే అవి అనుకూలమైనవిగా పరిగణించబడతాయి.
- శ్రేణులు వాటి పరిమాణాలు మరియు కొలతలు సరిపోలితే మాత్రమే కలిసి ప్రసారం చేయబడతాయి.
- ప్రసారం పూర్తయిన తర్వాత, ప్రతి శ్రేణి దాని రూపం రెండు ఇన్పుట్ శ్రేణుల ఆకృతులలోని అతిపెద్ద మూలకంతో సరిపోలినట్లుగా పనిచేస్తుంది.
- ఇతర శ్రేణి 1 కంటే ఎక్కువ పరిమాణం మరియు మొదటి శ్రేణి 1 పరిమాణం కలిగి ఉంటే, శ్రేణులలో ఒకటి ఆ పరిమాణంతో ప్రతిరూపం చేసినట్లుగా ప్రవర్తిస్తుంది.
ఇప్పుడు, ప్రసార భావనను అమలు చేయడానికి కొన్ని ఉదాహరణలను చర్చిద్దాం.
ఉదాహరణ 1:
శ్రేణుల జతలలో, NumPy కార్యకలాపాలు సాధారణంగా మూలకం-ద్వారా-మూలకం ద్వారా నిర్వహించబడతాయి. రెండు శ్రేణులు, చాలా సరళమైన దృష్టాంతంలో, దిగువ ఉదాహరణలో వలె ఒకే ఆకారాన్ని కలిగి ఉండాలి:
దిగుమతి మొద్దుబారిన
ఒకటి_అర్ = మొద్దుబారిన. అమరిక ( [ 2.0 , 3.0 , 1.0 ] )
రెండు_అర్ = మొద్దుబారిన. అమరిక ( [ 3.0 , 3.0 , 3.0 ] )
ముద్రణ ( one_arr * two_arr )
మీరు ఎగువ కోడ్ నుండి చూడగలిగినట్లుగా, మాకు రెండు శ్రేణులు ఉన్నాయి: 'one_arr' మరియు 'two_ arr'. వీటిలో ప్రతి ఒక్కటి ప్రత్యేక విలువలను కలిగి ఉంటాయి. 'one_arr'లో విలువలు [2.0,3.0,1.0] మరియు 'రెండు _arr' వి [3.0,3.0,3.0]. మీరు ఈ రెండు శ్రేణుల ఉత్పత్తిని లెక్కించడం వల్ల వచ్చే ఫలితం క్రింది విధంగా ఉందని మీరు చూడవచ్చు:
శ్రేణుల ఫారమ్ల ద్వారా నిర్దిష్ట అవసరాలు తీర్చబడినప్పుడు, NumPy ప్రసార నియమం ఈ పరిమితిని తగ్గిస్తుంది. శ్రేణి మరియు స్కేలార్ విలువ ఒక ఆపరేషన్లో చేరినప్పుడు, ప్రసారం దాని అత్యంత ప్రాథమిక రూపంలో ప్రదర్శించబడుతుంది. మీరు చూడగలిగినట్లుగా, 3 అనేది ‘Two_arr.’ అనే వేరియబుల్లో ఉంది.
దిగుమతి మొద్దుబారినఒకటి_అర్ = మొద్దుబారిన. అమరిక ( [ 2.0 , 3.0 , 1.0 ] )
రెండు_అర్ = 3.0
ముద్రణ ( one_arr * two_arr )
పై కోడ్ క్రింది ఫలితాన్ని ఉత్పత్తి చేస్తుంది.
మునుపటి ఉదాహరణలో, 'two_arr' శ్రేణి అయిన చోట, ఫలితం సమానంగా ఉంటుంది. అంకగణిత ప్రక్రియలో స్కేలార్ 'two_arr'ని 'one _arr' వలె అదే ఆకారాన్ని కలిగి ఉండే శ్రేణిలోకి విస్తరింపజేయడాన్ని మేము చిత్రించవచ్చు. సాగదీయడం పోలిక కేవలం ఊహాత్మకమైనది. ప్రసార కార్యకలాపాలను మెమరీగా మరియు గణనపరంగా పొదుపుగా సాధ్యమయ్యేలా చేయడానికి, NumPy కాపీలను ఉత్పత్తి చేయడం కంటే అసలైన స్కేలార్ విలువను ఉపయోగించడానికి తగినంత తెలివైనది.
ఉదాహరణ 2:
ప్రసారాన్ని నిర్వహించే మరో సాధారణ పైథాన్ ప్రోగ్రామ్ ఇక్కడ ఉంది. మరోసారి, విభిన్న విలువలను కలిగి ఉన్న రెండు శ్రేణులు సృష్టించబడతాయి. బయటి ఉత్పత్తిని లెక్కించడానికి 3×1 ఆకారంతో కాలమ్ వెక్టార్గా 'first_arr'ని రీషేప్ చేయడం అవసరం. దీనిని అనుసరించి, 'first_arr' మరియు 'second_arr' యొక్క బాహ్య ఉత్పత్తిగా పిలువబడే పరిమాణం 3×2 ఫలితాన్ని అందించడానికి 'second_arr'కి వ్యతిరేకంగా ప్రసారం చేయబడుతుంది. 'result_arr' ఆకృతి 2ని కలిగి ఉన్నందున 2×3కి ప్రసారం చేయడం సాధ్యమవుతుంది. × 3 అలాగే ఆకారం (3,).
పైన పేర్కొన్న అన్ని దశలను అనుసరించిన తర్వాత, 'ఫలితం_arr' మరియు 'second_arr' మాత్రికల యొక్క ప్రతి నిలువు వరుసలో వెక్టర్ తప్పనిసరిగా చేర్చబడాలి. ఇవి 2×3 మరియు (2, ) కొలతలు కలిగి ఉంటాయి. ‘ఫలితం_arr’ని ట్రాన్స్పోజ్ చేయడం వల్ల 3×2 ఆకారాన్ని అందజేస్తుంది, ఆ తర్వాత అదే ఫారమ్ను పొందడానికి ‘second_arr’కి వ్యతిరేకంగా ప్రసారం చేయవచ్చు. సాధారణంగా, దీన్ని ట్రాన్స్పోజ్ చేయడం వల్ల 2×3 ఆకారంలో తుది ఉత్పత్తి లభిస్తుంది.
దిగుమతి మొద్దుబారినమొదటి_arr = మొద్దుబారిన. అమరిక ( [ 12 , 24 , 14 ] )
రెండవ_అర్ = మొద్దుబారిన. అమరిక ( [ పదిహేను , 22 ] )
ముద్రణ ( మొద్దుబారిన. పునర్నిర్మించు ( మొదటి_arr , ( 3 , 1 ) ) * second_arr )
ఫలితం_అర్ = మొద్దుబారిన. అమరిక ( [ [ 12 , 22 , 31 ] , [ పదిహేను , 22 , నాలుగు ఐదు ] ] )
ముద్రణ ( result_arr + first_arr )
ముద్రణ ( ( ఫలితం_అర్. టి + second_arr ) . టి )
ముద్రణ ( result_arr + numpy. పునర్నిర్మించు ( రెండవ_అర్ , ( రెండు , 1 ) ) )
ముద్రణ ( ఫలితం_arr * రెండు )
మీరు దిగువ అవుట్పుట్ను చూడవచ్చు.
ఉదాహరణ 3:
కింది పైథాన్ ప్రోగ్రామ్ని ఉపయోగించి త్రిమితీయ శ్రేణిని ప్రసారం చేయవచ్చు. ఈ ఉదాహరణలో, 'first_arr' మరియు 'second_arr' పేరుతో రెండు శ్రేణులు రూపొందించబడ్డాయి. శ్రేణి 'first_arr' [4,13,26,12] విలువలను కలిగి ఉంది మరియు 'second_arr' [32,67,45,17] విలువలను కలిగి ఉంది. ప్రారంభ శ్రేణి యొక్క 2-పరిమాణాలు తేడాను కలిగిస్తాయి. కోడ్ అమలు చేయబడిన తర్వాత మొదటి మరియు రెండవ శ్రేణి మొత్తం క్రింద చూపబడుతుంది. కోడ్లో మనకు మూడు ప్రింట్ స్టేట్మెంట్లు ఉన్నాయని మీరు చూడవచ్చు, వీటిలో ప్రతి ఒక్కటి 'మొదటి శ్రేణి:', 'రెండవ శ్రేణి' మరియు 'మూడవ శ్రేణి:' వచనాన్ని ప్రదర్శిస్తుంది. కొత్తగా రూపొందించబడిన ఈ రెండు శ్రేణుల మొత్తం చూపబడుతుంది.
దిగుమతి మొద్దుబారినమొదటి_arr = మొద్దుబారిన. అమరిక ( [ [ 4 , 13 , 26 , 12 ] , [ 32 , 67 , నాలుగు ఐదు , 17 ] ] )
రెండవ_అర్ = మొద్దుబారిన. అమరిక ( [ 24 , నాలుగు ఐదు , 66 , 87 ] )
ముద్రణ ( ' \n మొదటి శ్రేణి: ' )
ముద్రణ ( మొదటి_arr )
ముద్రణ ( ' \n రెండవ శ్రేణి: ' )
ముద్రణ ( రెండవ_అర్ )
ముద్రణ ( ' \n మొదటి మరియు రెండవ శ్రేణి మొత్తం: ' )
మొత్తం_ఫలితం = first_arr + second_arr ;
ముద్రణ ( మొత్తం_ఫలితం )
ఇచ్చిన కోడ్ యొక్క అవుట్పుట్ స్క్రీన్షాట్ ఇక్కడ ఉంది.
ఉదాహరణ 4:
త్రిమితీయ శ్రేణిని ప్రసారం చేసే చివరి పైథాన్ ప్రోగ్రామ్ ఇక్కడ ఇవ్వబడింది. ఈ ప్రోగ్రామ్లో రెండు శ్రేణులు పేర్కొనబడ్డాయి, వాటిలో మొదటిది మూడు కోణాలను కలిగి ఉంటుంది. కోడ్ అమలు చేయబడిన తర్వాత పైన చూపిన విధంగా మొదటి మరియు రెండవ శ్రేణి మొత్తం చూపబడుతుంది. ఈ శ్రేణులలోని విలువలు మారుతూ ఉన్నప్పటికీ, మిగిలిన కోడ్ పైన ఉన్న ఉదాహరణ ప్రోగ్రామ్లో ఉపయోగించిన విధంగానే ఉంటుంది.
దిగుమతి మొద్దుబారినమొదటి_arr = మొద్దుబారిన. అమరిక ( [ [ 12 , నాలుగు ఐదు , 22 , 13 ] , [ 22 , 54 , 25 , 12 ] , [ యాభై , 40 , 18 , 26 ] ] )
రెండవ_అర్ = మొద్దుబారిన. అమరిక ( [ 12 , 44 , 22 , 12 ] )
ముద్రణ ( ' \n మొదటి శ్రేణి: ' )
ముద్రణ ( మొదటి_arr )
ముద్రణ ( ' \n రెండవ శ్రేణి: ' )
ముద్రణ ( రెండవ_అర్ )
ముద్రణ ( ' \n మొదటి మరియు రెండవ శ్రేణి మొత్తం: ' )
మొత్తం_ఫలితం = first_arr + second_arr ;
ముద్రణ ( మొత్తం_ఫలితం )
మొదటి శ్రేణి నుండి 3-డైమెన్షనల్ శ్రేణి ప్రదర్శించబడిందని మీరు దిగువ చిత్రంలో చూడవచ్చు, దాని తర్వాత రెండవ శ్రేణి నుండి 2-డైమెన్షనల్ శ్రేణి మరియు ఈ రెండింటి ఫలితంగా ప్రసార సూత్రాన్ని అమలు చేస్తారు.
ముగింపు
ఈ కథనం ప్రసారం గురించి చర్చించింది, ఇది కీలకమైన పైథాన్ భావన. NumPyలో, 'ప్రసారం' అనే పదం తరచుగా నిర్వహించబడే అంకగణిత కార్యకలాపాలను నిర్వహిస్తున్నప్పుడు వివిధ ఆకృతుల శ్రేణులను నిర్వహించగల సామర్థ్యాన్ని సూచిస్తుంది. పైన పేర్కొన్న విషయం వివిధ ఉదాహరణలతో పూర్తిగా కవర్ చేయబడింది. ఈ వ్యాసం వరుసగా 1-D, 2-D మరియు 3-D శ్రేణులలో ఎలా ప్రసారం చేయాలో ప్రదర్శించడానికి పేర్కొన్న ఉదాహరణ ప్రోగ్రామ్లను ఉపయోగించింది. మీరు మీ సిస్టమ్లో ఈ ఉదాహరణలను అమలు చేయడానికి ప్రయత్నించవచ్చు మరియు సాధారణంగా ప్రతిదీ ఎలా పనిచేస్తుందో బాగా అర్థం చేసుకోవడానికి ఫలితాలను వీక్షించవచ్చు.