Pinapayagan kami ng library ng NumPy na magsagawa ng iba't ibang mga operasyon na kailangang gawin sa mga istruktura ng data na madalas na ginagamit sa Pag-aaral ng Machine at Agham ng Data tulad ng mga vector, matrice at array. Ipapakita lamang namin ang pinakakaraniwang mga pagpapatakbo sa NumPy na ginagamit sa maraming mga pipeline ng Pag-aaral ng Machine. Panghuli, mangyaring tandaan na ang NumPy ay isang paraan lamang upang maisagawa ang mga pagpapatakbo, kaya, ang mga pagpapatakbo na matematika na ipinapakita namin ang pangunahing pokus ng araling ito at hindi ang package na NumPy mismo. Magsimula na tayo.
Ano ang isang Vector?
Ayon sa Google, ang isang Vector ay isang dami ng pagkakaroon ng direksyon pati na rin ang lakas, lalo na sa pagtukoy ng posisyon ng isang punto sa kalawakan na may kaugnayan sa isa pa.
Napakahalaga ng mga vector sa Pag-aaral ng Machine dahil hindi lamang nila inilalarawan ang lakas ngunit pati na rin ang direksyon ng mga tampok. Maaari kaming lumikha ng isang vector sa NumPy na may sumusunod na code snippet:
import numpybilanghal
row_vector = np.array([1,2,3])
mag-print(row_vector)
Sa snippet ng code sa itaas, gumawa kami ng isang hilera na vector. Maaari rin kaming lumikha ng isang vector vector ng haligi bilang:
import numpybilanghalcol_vector = np.array([[1],[2],[3]])
mag-print(col_vector)
Paggawa ng isang Matrix
Ang isang matrix ay maaaring madaling maunawaan bilang isang dalawang-dimensional na array. Maaari kaming gumawa ng isang matrix sa NumPy sa pamamagitan ng paggawa ng isang multi-dimensional na array:
matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])
mag-print(matrix)
Kahit na ang matrix ay eksaktong kapareho ng multi-dimensional array, hindi inirerekumenda ang istraktura ng data ng matrix dahil sa dalawang kadahilanan:
- Ang array ay ang pamantayan pagdating sa NumPy package
- Karamihan sa mga operasyon na may NumPy ay nagbabalik ng mga array at hindi isang matrix
Paggamit ng isang Sparse Matrix
Upang ipaalala, ang isang kalat-kalat na matrix ay ang kung saan ang karamihan sa mga item ay zero. Ngayon, isang pangkaraniwang senaryo sa pagpoproseso ng data at pag-aaral ng makina ay ang pagpoproseso ng mga matrice kung saan ang karamihan sa mga elemento ay zero. Halimbawa, isaalang-alang ang isang matrix na ang mga hilera ay naglalarawan sa bawat video sa Youtube at mga haligi na kumakatawan sa bawat rehistradong gumagamit. Ang bawat halaga ay kumakatawan kung ang gumagamit ay nanood ng isang video o hindi. Siyempre, karamihan sa mga halaga sa matrix na ito ay magiging zero. Ang bentahe sa kalat-kalat na matrix ay hindi nito iniimbak ang mga halagang zero. Nagreresulta ito sa isang malaking kalamangan sa computational at pag-optimize din ng imbakan.
Lumikha tayo ng isang spark matrix dito:
mula sa scipy import kalat-kalatoriginal_matrix = np.array([[1,0,3],[0,0,6],[7,0,0]])
sparse_matrix = sparse.csr_matrix(orihinal_matrix)
mag-print(kalat-kalat_matrix)
Upang maunawaan kung paano gumagana ang code, titingnan namin ang output dito:
Sa code sa itaas, gumamit kami ng pag-andar ng NumPy upang lumikha ng isang Naka-compress na kalat-kalat na hilera matrix kung saan ang mga elemento na hindi zero ay kinakatawan gamit ang mga zero-based index. Mayroong iba't ibang mga kalat-kalat na matrix, tulad ng:
- Naka-compress na kalat-kalat na haligi
- Listahan ng mga listahan
- Diksyonaryo ng mga susi
Hindi kami sasisid sa iba pang kalat-kalat na mga matrice dito ngunit alam na ang bawat isa sa kanila ay paggamit ay tiyak at walang sinumang maaaring masabing ‘pinakamahusay’.
Paglalapat ng Mga Operasyon sa lahat ng mga elemento ng Vector
Ito ay isang pangkaraniwang senaryo kapag kailangan naming mag-apply ng isang karaniwang operasyon sa maraming mga elemento ng vector. Maaari itong magawa sa pamamagitan ng pagtukoy sa isang lambda at pagkatapos ay i-vectorize ang pareho. Tingnan natin ang ilang mga snippet ng code para sa pareho:
matrix = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
mul_5 = lambda x: x* 5
vectorized_mul_5 = np.vectorize(mul_5)
vectorized_mul_5(matrix)
Upang maunawaan kung paano gumagana ang code, titingnan namin ang output dito:
Sa snippet ng code sa itaas, ginamit namin ang pag-andar ng vectorize na bahagi ng library ng NumPy, upang ibahin ang isang simpleng kahulugan ng lambda sa isang pagpapaandar na maaaring maproseso ang bawat elemento ng vector. Mahalagang tandaan na ang vectorize ay isang loop lamang sa mga elemento at wala itong epekto sa pagganap ng programa. Pinapayagan din ng NumPy pagsasahimpapawid , na nangangahulugang sa halip na sa itaas na kumplikadong code, maaari lamang nating gawin ang:
matrix* 5At ang resulta ay magiging eksaktong pareho. Nais kong ipakita muna ang kumplikadong bahagi, kung hindi ay nilaktawan mo ang seksyon!
Ibig sabihin, Pagkakaiba at Pamantayang Paghiwalay
Sa NumPy, madali upang maisagawa ang mga pagpapatakbo na nauugnay sa mapaglarawang istatistika sa mga vector. Ang ibig sabihin ng isang vector ay maaaring kalkulahin bilang:
np.mean(matrix)Maaaring makalkula ang pagkakaiba-iba ng isang vector bilang:
np.var(matrix)Maaaring makalkula ang karaniwang paglihis ng isang vector bilang:
hal std(matrix)Ang output ng mga utos sa itaas sa ibinigay na matrix ay ibinibigay dito:
Paglipat ng isang Matrix
Ang Transposing ay isang pangkaraniwang operasyon na maririnig mo tuwing napapaligiran ka ng mga matris. Ang transposing ay isang paraan lamang upang magpalitan ng haligi ng haligi at hilera ng isang matrix. Mangyaring tandaan na a hindi maaaring ilipat ang vector bilang isang vector ay isang koleksyon lamang ng mga halaga nang hindi ang mga halagang iyon ay ikinategorya sa mga hilera at haligi. Mangyaring tandaan na ang pag-convert ng isang hilera na vector sa isang haligi na vector ay hindi paglilipat (batay sa mga kahulugan ng linear algebra, na nasa labas ng saklaw ng araling ito).
Sa ngayon, makakahanap tayo ng kapayapaan sa pamamagitan lamang ng paglilipat ng isang matrix. Napakadali upang mai-access ang transpose ng isang matrix na may NumPy:
matrix.TAng output ng utos sa itaas sa ibinigay na matrix ay ibinibigay dito:
Ang parehong operasyon ay maaaring isagawa sa isang hilera na vector upang mai-convert ito sa isang haligi na vector.
Flattening isang Matrix
Maaari naming mai-convert ang isang matrix sa isang isang-dimensional na array kung nais naming iproseso ang mga elemento nito sa isang linear fashion. Magagawa ito sa sumusunod na code snippet:
matrix.flatten()Ang output ng utos sa itaas sa ibinigay na matrix ay ibinibigay dito:
Tandaan na ang flatten matrix ay isang isang-dimensional na array, simpleng linear sa fashion.
Kinakalkula ang Eigenvalues at Eigenvector
Ang mga eigenvector ay karaniwang ginagamit sa mga package sa Pag-aaral ng Machine. Kaya, kapag ang isang pagpapaandar na linear na pagbabago ay ipinakita bilang isang matrix, kung gayon ang X, ang mga Eigenvector ay ang mga vector na nagbabago lamang sa sukat ng vector ngunit hindi ang direksyon nito. Maaari nating sabihin na:
Xv = γvDito, ang X ay ang square matrix at ang γ ay naglalaman ng mga Eigenvalues. Gayundin, naglalaman ang v ng mga Eigenvector. Sa NumPy, madaling makalkula ang Eigenvalues at Eigenvector. Narito ang code snippet kung saan ipinapakita namin ang pareho:
sinusuri, evector = np.linalg.eig(matrix)Ang output ng utos sa itaas sa ibinigay na matrix ay ibinibigay dito:
Mga Produkto ng Dot ng Mga Vector
Ang Mga Dot Product ng Vector ay isang paraan ng pagpaparami ng 2 mga vector. Sinasabi nito sa iyo ang tungkol sa kung magkano ang mga vector ay nasa parehong direksyon , taliwas sa cross product na nagsasabi sa iyo ng kabaligtaran, kung gaano kaliit ang mga vector sa parehong direksyon (tinatawag na orthogonal). Maaari nating kalkulahin ang produktong tuldok ng dalawang mga vector tulad ng ibinigay sa code na snippet dito:
a = np.array([3,5,6])b = np.array([2. 3,labinlimang,1])
np.dot(a, b)
Ang output ng utos sa itaas sa mga ibinigay na array ay ibinibigay dito:
Pagdaragdag, Pagbawas at Pagpaparami ng Mga Matrice
Ang pagdaragdag at pagbabawas ng maraming mga matrice ay prangka na operasyon sa mga matris. Mayroong dalawang paraan kung saan magagawa ito. Tingnan natin ang snippet ng code upang maisagawa ang mga pagpapatakbo na ito. Para sa hangaring mapanatili ang simpleng ito, gagamitin namin ang parehong matrix nang dalawang beses:
np.add(matrix, matrix)Susunod, ang dalawang matrices ay maaaring ibawas bilang:
np.subtract(matrix, matrix)Ang output ng utos sa itaas sa ibinigay na matrix ay ibinibigay dito:
Tulad ng inaasahan, ang bawat isa sa mga elemento sa matrix ay idinagdag / binabawas na may kaukulang elemento. Ang pagpaparami ng isang matrix ay katulad ng paghahanap ng produktong tuldok tulad ng ginawa namin kanina:
np.dot(matrix, matrix)Makikita sa code sa itaas ang totoong halaga ng pagpaparami ng dalawang matris, na ibinigay bilang:
Ang output ng utos sa itaas sa ibinigay na matrix ay ibinibigay dito:
Konklusyon
Sa araling ito, dumaan kami sa maraming pagpapatakbo ng matematika na nauugnay sa Vector, Matrices at Arrays na karaniwang ginagamit na Pagproseso ng data, mapaglarawang istatistika at agham ng data. Ito ay isang mabilis na aralin na sumasaklaw lamang sa pinakakaraniwan at pinakamahalagang mga seksyon ng iba't ibang mga konsepto ngunit ang mga pagpapatakbo na ito ay dapat magbigay ng isang napakahusay na ideya tungkol sa kung ano ang maaaring gawin ang lahat ng mga operasyon habang nakikipag-usap sa mga istrukturang ito ng data.
Mangyaring ibahagi ang iyong puna nang malayang tungkol sa aralin sa Twitter @linuxhint at @sbmaggarwal (ako yan!).