Matriisin kertolasku on lineaarisen algebran perusoperaatio.
Käytämme sitä yleensä monissa sovelluksissa, kuten kuvankäsittelyssä, koneoppimisessa ja monissa muissa. NumPy on merkittävä Python-paketti tieteelliseen laskemiseen.
Tässä viestissä tarkastelemme kuitenkin erilaisia menetelmiä matriisin kertomiseen Pythonissa käyttämättä NumPyä.
Me hyödynnämme sisäkkäisiä silmukoita, sisäänrakennettu map()-funktio ja luettelon ymmärtäminen.
Lisäksi tarkastelemme kunkin strategian etuja ja haittoja sekä sitä, milloin kutakin niistä tulee soveltaa. Jos olet uusi lineaarialgebrassa ja haluat oppia lisää matriisikertomisesta; jatka lukemista.
Missä käytämme matriisikertoa?
Matriisin kertolaskua käytetään tietokonegrafiikka muuttaa 2D- ja 3D-visuaalisia ominaisuuksia. Voit esimerkiksi kiertää, skaalata ja kääntää objekteja näytöllä. Matriiseja käytetään kuvankäsittelyssä esittämään kuvia pikseliryhminä. Lisäksi matriiseja voidaan käyttää suorittamaan toimintoja, kuten kuvan suodatusta.
Käytämme myös matriiseja koneoppiminen. Ne voivat auttaa meitä esittämään tietoja ja malliparametreja. Voimme suorittaa lukuisia operaatioita, kuten pistetulojen ja matriisivektoritulojen laskemista.
Varmasti tämä operaatio on erittäin edullinen myös tieteellisessä toiminnassa. Voimme käyttää sitä fysiikassa ja tekniikassa kuvaamaan fysikaalisia suureita. Näin ollen voimme toimia vektoreilla ja tensoreilla.
Miksi emme voi valita NumPyn käyttöä?
Vaikka NumPy on a Python-kirjasto, se ei aina ole ihanteellinen vaihtoehto matriisikertolaskulle. Emme välttämättä halua käyttää NumPyä esimerkiksi koosta ja riippuvuudesta, oppimisesta ja vanhoista järjestelmistä johtuvista syistä.
Pythonin sisäänrakennettujen toimintojen käyttäminen tai mukautetun koodin kehittäminen voi joissain tapauksissa olla tehokkaampaa. On kuitenkin tärkeää huomata, että NumPy on vahva kirjasto. Lisäksi voit käyttää sitä myös matriisin kertomiseen.
Katsotaanpa nyt, kuinka voimme saavuttaa matriisin kertolaskua ilman NumPy:tä.
Sisäkkäiset silmukat -menetelmä
Sisäkkäiset silmukat -tekniikka käyttää sisäkkäisiä silmukoita matriisin kertolaskujen suorittamiseen Pythonissa. Funktio toistuu jokaisen matriisielementin yli. Ja se kertoo ne käyttämällä useita sisäkkäisiä silmukoita. Funktio palauttaa tuloksen, joka tallennetaan uuteen matriisiin.
Tämä lähestymistapa on helppo ymmärtää. Se ei kuitenkaan välttämättä ole yhtä tehokas kuin muut tavat, etenkään suuremmille matriiseille. Silti se on loistava valinta sinulle, jos olet uusi lineaarialgebrassa.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Aseta tulosmatriisi nollia.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
Otetaan esimerkki siitä, kuinka tämä tehdään. Voit vain lisätä nämä koodirivit alle testataksesi tätä esimerkkiä.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
Hyödyt:
- Helppo ymmärtää.
- Erinomainen aloittelijoille tai niille, jotka etsivät syvempää ymmärrystä matriisikertomisesta.
Haitat:
- Ei yhtä tehokas kuin vaihtoehtoiset tekniikat, etenkään isommille matriiseille.
- Se ei ole yhtä luettavaa kuin vaihtoehtoiset lähestymistavat.
map()-funktiomenetelmä
Map()-funktiomenetelmä tarjoaa vaihtoehtoisen lähestymistavan matriisin kertomiseen Pythonissa. Tässä lähestymistavassa käytämme sisäänrakennettua map()-funktiota. Tästä syystä käytämme toiminnallista ohjelmointityökalua, joka käyttää tarjottua funktiota jokaiseen iteroitavaan elementtiin (luettelo, monikko jne.). Lisäksi map()-funktio hyväksyy kaksi parametria, funktion ja iteroitavan. Ja se palauttaa iteraattorin, joka käyttää funktiota jokaiseen iteroitavaan elementtiin.
Tässä lähestymistavassa käymme läpi jokaisen matriisin jäsenen ja teemme kertolasku käyttämällä sisäkkäistä map()-funktiota.
Zip()-funktiota käytetään iteroimaan matriisien jokainen elementti rinnakkain.
Lopuksi summa()-funktiota käytetään tulosten laskemiseen.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
Nyt taas voimme testata koodiamme esimerkillä.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
edut
- Tehokkaampi kuin pinottujen silmukoiden lähestymistapa
- Se käyttää toiminnallista ohjelmointia koodin yksinkertaistamiseksi.
Haitat
- Jotkut ihmiset, jotka eivät tunne toiminnallista ohjelmointia, saattavat pitää sitä vähemmän luettavana.
- Se on vähemmän ymmärrettävää kuin sisäkkäisten silmukoiden tekniikka.
Listan ymmärtämismenetelmä
Listan ymmärtämisen avulla voit luoda uuden luettelon yhdellä koodirivillä. Näin ollen tämä tapahtuu käyttämällä lauseketta olemassa olevan luettelon jokaiseen jäseneen.
Tässä lähestymistavassa kertolasku suoritetaan toistuvasti iteroimalla kunkin matriisin jäsenen läpi. Käytämme kerrosta listan ymmärtämistä.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
Hyödyt
- Map()-funktiomenetelmään verrattuna lyhyempi ja luettavampi.
Haitat
- Se voi olla vähemmän tehokas kuin map()-funktion käyttäminen, etenkin suurille matriiseille.
- Se on vaikeampaa kuin sisäkkäisten silmukoiden lähestymistapa.
Yhteenveto
Tässä viestissä tarkastelimme vaihtoehtoja NumPyn käyttämiselle matriisien kertomisessa Pythonissa. Suoritimme matriisin kertolaskua sisäkkäisissä silmukoissa, sisäänrakennetun map()-funktion ja luettelon ymmärtämisen.
Paras strategia perustuu projektisi erityistarpeisiin.
Jokaisella strategialla on omat hyvät ja huonot puolensa. Varmistaaksesi, että toiminto toimii oikein, on hyvä idea lisätä testitapauksia erilaisilla matriisiulottuvuuksilla ja -arvoilla.
Sinun tulisi myös sisällyttää joitain suorituskykytestejä vertaillaksesi kuinka hyvin nämä menetelmät toimivat.
Jätä vastaus