వెక్టర్స్, మాత్రికలు మరియు శ్రేణుల వంటి మెషిన్ లెర్నింగ్ మరియు డేటా సైన్స్‌లో తరచుగా ఉపయోగించే డేటా స్ట్రక్చర్‌లపై చేయవలసిన వివిధ కార్యకలాపాలను నిర్వహించడానికి NumPy లైబ్రరీ మాకు అనుమతిస్తుంది. మేము చాలా మెషిన్ లెర్నింగ్ పైప్‌లైన్‌లలో ఉపయోగించే NumPy తో అత్యంత సాధారణ కార్యకలాపాలను మాత్రమే చూపుతాము. చివరగా, దయచేసి NumPy అనేది కార్యకలాపాలను నిర్వహించడానికి ఒక మార్గం అని దయచేసి గమనించండి, కాబట్టి, మేము చూపించే గణిత కార్యకలాపాలు ఈ పాఠం యొక్క ప్రధాన దృష్టి మరియు NumPy ప్యాకేజీనే కాదు. ప్రారంభిద్దాం.
వెక్టర్ అంటే ఏమిటి?
గూగుల్ ప్రకారం, వెక్టర్ అనేది దిశ మరియు పరిమాణాన్ని కలిగి ఉండే పరిమాణం, ప్రత్యేకించి మరొక ప్రదేశానికి సంబంధించి స్థలంలో ఒక బిందువు స్థానాన్ని నిర్ణయించడం.
మెషిన్ లెర్నింగ్‌లో వెక్టర్‌లు చాలా ముఖ్యమైనవి ఎందుకంటే అవి పరిమాణాన్ని మాత్రమే కాకుండా ఫీచర్‌ల దిశను కూడా వర్ణిస్తాయి. కింది కోడ్ స్నిప్పెట్‌తో మేము NumPy లో వెక్టర్‌ను సృష్టించవచ్చు:
నంపి దిగుమతిగాఉదా
row_vector = np.array([1,2,3])
ముద్రణ(వరుస_వేక్టర్)
పై కోడ్ స్నిప్పెట్‌లో, మేము వరుస వెక్టర్‌ను సృష్టించాము. మేము కాలమ్ వెక్టర్‌ని కూడా సృష్టించవచ్చు:
నంపి దిగుమతిగాఉదాcol_vector = np.array([[1],[2],[3]])
ముద్రణ(col_vector)
మాతృకను తయారు చేయడం
మాతృకను కేవలం రెండు డైమెన్షనల్ శ్రేణిగా అర్థం చేసుకోవచ్చు. బహుళ-పరిమాణ శ్రేణిని తయారు చేయడం ద్వారా మేము NumPy తో మాతృకను తయారు చేయవచ్చు:
మాతృక = np.array([[1,2,3],[4,5,6],[7,8,9]])
ముద్రణ(మాతృక)
మాతృక బహుళ డైమెన్షనల్ శ్రేణికి సమానంగా ఉన్నప్పటికీ, మాతృక డేటా నిర్మాణం సిఫార్సు చేయబడలేదు రెండు కారణాల వల్ల:
- NumPy ప్యాకేజీ విషయానికి వస్తే శ్రేణి ప్రమాణం
- NumPy తో చాలా కార్యకలాపాలు శ్రేణులను అందిస్తుంది మరియు మాతృక కాదు
అరుదైన మాతృకను ఉపయోగించడం
గుర్తుకు తెచ్చుకోవడానికి, చాలా అంశాలు సున్నాగా ఉండేవి ఒక చిన్న మాతృక. ఇప్పుడు, డేటా ప్రాసెసింగ్ మరియు మెషిన్ లెర్నింగ్‌లో ఒక సాధారణ దృష్టాంతంలో మ్యాట్రిక్స్ ప్రాసెస్ చేయబడుతోంది, ఇందులో చాలా అంశాలు సున్నా. ఉదాహరణకు, యూట్యూబ్‌లోని ప్రతి వీడియోను వరుసలు వివరించే మాతృకను పరిగణించండి మరియు నిలువు వరుసలు ప్రతి నమోదిత వినియోగదారుని సూచిస్తాయి. ప్రతి విలువ యూజర్ వీడియోను చూశారా లేదా అని సూచిస్తుంది. వాస్తవానికి, ఈ మాతృకలోని మెజారిటీ విలువలు సున్నాగా ఉంటాయి. ది అరుదైన మాతృకతో ప్రయోజనం అది సున్నా అయిన విలువలను నిల్వ చేయదు. ఇది భారీ గణన ప్రయోజనం మరియు నిల్వ ఆప్టిమైజేషన్‌కు దారితీస్తుంది.
ఇక్కడ స్పార్క్ మాతృకను సృష్టిద్దాం:
scipy దిగుమతి తక్కువ నుండిఅసలు_మాట్రిక్స్ = np.array([[1,0,3],[0,0,6],[7,0,0]])
sparse_matrix = తక్కువ. csr_matrix(ఒరిజినల్_మాట్రిక్స్)
ముద్రణ(అరుదైన_మాట్రిక్స్)
కోడ్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి, మేము ఇక్కడ అవుట్‌పుట్‌ను చూస్తాము:
పై కోడ్‌లో, a ని సృష్టించడానికి మేము NumPy ఫంక్షన్‌ను ఉపయోగించాము సంపీడన అరుదైన వరుస సున్నా-ఆధారిత సూచికలను ఉపయోగించి సున్నా కాని మూలకాలు సూచించబడే మాతృక. వివిధ రకాల అరుదైన మాతృకలు ఉన్నాయి, అవి:
- సంపీడన అరుదైన కాలమ్
- జాబితాల జాబితా
- కీల నిఘంటువు
మేము ఇక్కడ ఇతర అరుదైన మాత్రికల్లోకి ప్రవేశించలేము కానీ వాటి యొక్క ప్రతి ఉపయోగం నిర్దిష్టమని తెలుసు మరియు ఎవరూ 'ఉత్తమమైనది' అని పిలవబడరు.
అన్ని వెక్టర్ ఎలిమెంట్‌లకు ఆపరేషన్‌లను వర్తింపజేయడం
బహుళ వెక్టర్ ఎలిమెంట్‌లకు మేము ఒక సాధారణ ఆపరేషన్‌ను వర్తింపజేయాల్సిన అవసరం వచ్చినప్పుడు ఇది సాధారణ దృష్టాంతం. లాంబ్డాను నిర్వచించి, ఆపై దానిని వెక్టరైజ్ చేయడం ద్వారా దీనిని చేయవచ్చు. దీని కోసం కొన్ని కోడ్ స్నిప్పెట్‌ను చూద్దాం:
మాతృక = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
mul_5 = లాంబ్డా x: x* 5
vectorized_mul_5 = np.vectorize(mul_5)
vectorized_mul_5(మాతృక)
కోడ్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి, మేము ఇక్కడ అవుట్‌పుట్‌ను చూస్తాము:
పై కోడ్ స్నిప్పెట్‌లో, వెక్టర్‌లోని ప్రతి మూలకాన్ని ప్రాసెస్ చేయగల సాధారణ లాంబ్డా నిర్వచనాన్ని ఫంక్షన్‌గా మార్చడానికి మేము NumPy లైబ్రరీలో భాగమైన వెక్టరైజ్ ఫంక్షన్‌ను ఉపయోగించాము. వెక్టరైజ్ అని గమనించడం ముఖ్యం అంశాలపై కేవలం లూప్ మరియు అది ప్రోగ్రామ్ పనితీరుపై ఎలాంటి ప్రభావం చూపదు. NumPy కూడా అనుమతిస్తుంది ప్రసారం , అంటే పై కాంప్లెక్స్ కోడ్‌కు బదులుగా, మనం కేవలం ఇలా చేసి ఉండవచ్చు:
మాతృక* 5మరియు ఫలితం సరిగ్గా అదే విధంగా ఉండేది. నేను ముందుగా క్లిష్టమైన భాగాన్ని చూపించాలనుకున్నాను, లేకుంటే మీరు విభాగాన్ని దాటవేసేవారు!
సగటు, వైవిధ్యం మరియు ప్రామాణిక విచలనం
NumPy తో, వెక్టర్స్‌పై వివరణాత్మక గణాంకాలకు సంబంధించిన కార్యకలాపాలను నిర్వహించడం సులభం. వెక్టర్ సగటును ఇలా లెక్కించవచ్చు:
np. అర్థం(మాతృక)వెక్టర్ యొక్క వైవిధ్యాన్ని ఇలా లెక్కించవచ్చు:
np.var(మాతృక)వెక్టర్ యొక్క ప్రామాణిక విచలనాన్ని ఇలా లెక్కించవచ్చు:
ఉదా. std(మాతృక)ఇచ్చిన మాతృకపై పై ఆదేశాల అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
మాతృకను బదిలీ చేయడం
ట్రాన్స్‌పోజింగ్ అనేది చాలా సాధారణమైన ఆపరేషన్, మీరు మాతృకలతో చుట్టుముట్టినప్పుడు మీరు వినే ఉంటారు. ట్రాన్స్‌పోజింగ్ అనేది మ్యాట్రిక్స్ యొక్క నిలువు వరుసలు మరియు నిలువు వరుసలను మార్చుకోవడానికి ఒక మార్గం. దయచేసి గమనించండి a వెక్టర్ ట్రాన్స్‌పోజ్ చేయబడదు వెక్టర్ అనేది విలువలు వరుసలు మరియు నిలువు వరుసలుగా వర్గీకరించబడకుండా కేవలం విలువల సమాహారం. వరుస వెక్టర్‌ను కాలమ్ వెక్టర్‌గా మార్చడం దయచేసి గమనించండి (లీనియర్ ఆల్జీబ్రా నిర్వచనాల ఆధారంగా, ఈ పాఠం పరిధికి వెలుపల).
ప్రస్తుతానికి, మాతృకను బదిలీ చేయడం ద్వారా మేము శాంతిని కనుగొంటాము. NumPy తో మాతృక యొక్క ట్రాన్స్‌పోస్‌ను యాక్సెస్ చేయడం చాలా సులభం:
మాతృక. టిఇచ్చిన మాతృకపై పై ఆదేశం యొక్క అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
కాలమ్ వెక్టర్‌గా మార్చడానికి వరుస వెక్టర్‌లో అదే ఆపరేషన్ చేయవచ్చు.
మ్యాట్రిక్స్‌ను చదును చేయడం
మేము మ్యాట్రిక్స్‌ని ఒక లీనియర్ పద్ధతిలో ప్రాసెస్ చేయాలనుకుంటే ఒక డైమెన్షనల్ అర్రేగా మార్చగలము. కింది కోడ్ స్నిప్పెట్‌తో దీన్ని చేయవచ్చు:
matrix.flatten()ఇచ్చిన మాతృకపై పై ఆదేశం యొక్క అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
ఫ్లాటెన్ మ్యాట్రిక్స్ ఒక డైమెన్షనల్ అర్రే అని గమనించండి, ఫ్యాషన్‌లో సరళంగా ఉంటుంది.
ఈజెన్‌వాల్యూస్ మరియు ఈజెన్‌వేక్టర్‌లను లెక్కిస్తోంది
మెషిన్ లెర్నింగ్ ప్యాకేజీలలో ఐజెన్‌వెక్టర్లు చాలా సాధారణంగా ఉపయోగించబడతాయి. కాబట్టి, ఒక లీనియర్ ట్రాన్స్‌ఫర్మేషన్ ఫంక్షన్‌ను మాతృకగా ప్రదర్శించినప్పుడు, X, Eigenvectors అనేది వెక్టర్ స్కేల్‌లో మాత్రమే మారే వెక్టర్స్ కానీ దాని దిశ కాదు. మేము ఇలా చెప్పగలం:
Xv = .vఇక్కడ, X అనేది చతురస్ర మాతృక మరియు γ లో ఈజెన్‌వాల్యూలు ఉంటాయి. అలాగే, v లో ఈజెన్‌వేక్టర్స్ ఉన్నాయి. NumPy తో, Eigenvalues మరియు Eigenvectors లెక్కించడం సులభం. మేము అదే విధంగా ప్రదర్శించే కోడ్ స్నిప్పెట్ ఇక్కడ ఉంది:
ఎవల్యూస్, ఎవెక్టర్స్ = np.linalg.eig(మాతృక)ఇచ్చిన మాతృకపై పై ఆదేశం యొక్క అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
వెక్టర్స్ యొక్క డాట్ ఉత్పత్తులు
వెక్టర్స్ యొక్క డాట్ ప్రొడక్ట్స్ అనేది 2 వెక్టర్స్‌ని గుణించడం. ఇది మీకు చెబుతుంది ఒకే దిశలో ఎంత వెక్టర్స్ ఉన్నాయి , క్రాస్ ప్రొడక్ట్‌కు విరుద్ధంగా, ఇది మీకు విరుద్ధంగా చెబుతుంది, వెక్టర్స్ ఒకే దిశలో ఎంత తక్కువగా ఉంటాయి (ఆర్తోగోనల్ అని పిలుస్తారు). కోడ్ స్నిప్పెట్‌లో ఇచ్చిన విధంగా మేము రెండు వెక్టర్‌ల డాట్ ఉత్పత్తిని ఇక్కడ లెక్కించవచ్చు:
a = np.array([3,5,6])b = np.array([2. 3,పదిహేను,1])
np.dot(a, b)
ఇచ్చిన శ్రేణులపై పై ఆదేశం యొక్క అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
మాత్రికలను జోడించడం, తీసివేయడం మరియు గుణించడం
బహుళ మాత్రికలను జోడించడం మరియు తీసివేయడం మాత్రికలలో చాలా సరళమైన ఆపరేషన్. దీన్ని చేయడానికి రెండు మార్గాలు ఉన్నాయి. ఈ కార్యకలాపాలను నిర్వహించడానికి కోడ్ స్నిప్పెట్‌ను చూద్దాం. దీన్ని సరళంగా ఉంచడం కోసం, మేము ఒకే మాతృకను రెండుసార్లు ఉపయోగిస్తాము:
np.add(మాతృక, మాతృక)తరువాత, రెండు మాత్రికలను ఇలా తీసివేయవచ్చు:
np. సబ్‌ట్రాక్ట్(మాతృక, మాతృక)ఇచ్చిన మాతృకపై పై ఆదేశం యొక్క అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
ఊహించినట్లుగా, మాతృకలోని ప్రతి మూలకం సంబంధిత మూలకంతో జోడించబడుతుంది/తీసివేయబడుతుంది. మాతృకను గుణించడం మనం ఇంతకు ముందు చేసినట్లుగా డాట్ ఉత్పత్తిని కనుగొనడం లాంటిది:
np.dot(మాతృక, మాతృక)పై కోడ్ రెండు మాత్రికల యొక్క నిజమైన గుణకార విలువను కనుగొంటుంది:
ఇచ్చిన మాతృకపై పై ఆదేశం యొక్క అవుట్‌పుట్ ఇక్కడ ఇవ్వబడింది:
ముగింపు
ఈ పాఠంలో, మేము సాధారణంగా ఉపయోగించే డేటా ప్రాసెసింగ్, వివరణాత్మక గణాంకాలు మరియు డేటా సైన్స్‌ని ఉపయోగించే వెక్టర్స్, మ్యాట్రిసెస్ మరియు అర్రేలకు సంబంధించిన చాలా గణిత కార్యకలాపాల ద్వారా వెళ్ళాము. ఇది విస్తృతమైన భావనల యొక్క అత్యంత సాధారణ మరియు అత్యంత ముఖ్యమైన విభాగాలను మాత్రమే కవర్ చేసే శీఘ్ర పాఠం, అయితే ఈ డేటా స్ట్రక్చర్‌లతో వ్యవహరించేటప్పుడు అన్ని కార్యకలాపాలు ఏమి చేయగలవనే దాని గురించి ఈ ఆపరేషన్‌లు చాలా మంచి ఆలోచనను అందించాలి.
దయచేసి ట్విట్టర్‌లో పాఠం గురించి మీ అభిప్రాయాన్ని ఉచితంగా పంచుకోండి @linuxhint మరియు @sbmaggarwal (అది నేను!).