Mae lluosi matrics yn weithrediad sylfaenol mewn algebra llinol.
Yn gyffredinol, rydym yn ei ddefnyddio mewn nifer o gymwysiadau megis prosesu delweddau, dysgu peiriannau, a llawer mwy. Mae NumPy yn becyn Python nodedig ar gyfer cyfrifiadura gwyddonol.
Fodd bynnag, yn y swydd hon, byddwn yn edrych ar wahanol ddulliau ar gyfer lluosi matrics yn Python heb ddefnyddio NumPy.
Byddwn yn defnyddio dolenni nythu, y swyddogaeth map() adeiledig, a deall rhestr.
Yn ogystal, byddwn yn edrych ar fanteision ac anfanteision pob strategaeth, yn ogystal â phryd i gymhwyso pob un ohonynt. Os ydych chi'n newydd i algebra llinol ac eisiau dysgu mwy am luosi matrics; daliwch ati i ddarllen.
Ble Ydym Ni'n Defnyddio Lluosi Matrics?
Defnyddir lluosi matrics yn graffeg gyfrifiadurol i newid delweddau 2D a 3D. Er enghraifft, gallwch chi gylchdroi, graddio a chyfieithu gwrthrychau ar y sgrin. Defnyddir matricsau wrth brosesu delweddau i gynrychioli lluniau fel araeau o bicseli. Yn ogystal, gellir defnyddio matricsau i gynnal gweithrediadau fel hidlo delweddau.
Rydym hefyd yn gwneud defnydd o fatricsau yn dysgu peiriant. Gallant ein helpu i gynrychioli data a pharamedrau model. Gallwn gynnal nifer o weithrediadau, megis cynhyrchion dotiau cyfrifiadurol a chynhyrchion matrics-fector.
Yn sicr, mae'r llawdriniaeth hon hefyd yn fanteisiol iawn mewn gweithrediadau gwyddonol. Gallwn ei ddefnyddio mewn ffiseg a pheirianneg i ddisgrifio meintiau ffisegol. Felly, gallwn weithredu gyda fectorau a tensorau.
Pam na allwn ddewis defnyddio NumPy?
Tra bod NumPy yn a Llyfrgell Python, nid yw bob amser yn opsiwn delfrydol ar gyfer lluosi matrics. Efallai na fyddwn yn dewis defnyddio NumPy am resymau fel maint a dibyniaeth, dysgu, a systemau etifeddiaeth.
Gall defnyddio swyddogaethau adeiledig Python neu ddatblygu cod arfer fod yn fwy effeithlon mewn rhai achosion. Mae'n hollbwysig nodi, fodd bynnag, bod NumPy yn llyfrgell gref. Ar ben hynny, gallwch hefyd ei ddefnyddio ar gyfer lluosi matrics.
Nawr, gadewch i ni edrych ar sut y gallwn gyflawni lluosi matrics heb NumPy.
Dull dolenni nythu
Mae'r dechneg dolenni nythu yn defnyddio dolenni nythu i weithredu lluosi matrics yn Python. Mae'r ffwythiant yn ailadrodd dros bob elfen matrics. Ac, mae'n eu lluosi gan ddefnyddio cyfres o ddolenni nythu. Mae'r swyddogaeth yn dychwelyd y canlyniad, sy'n cael ei storio mewn matrics newydd.
Mae'r dull hwn yn syml i'w ddeall. Fodd bynnag, efallai na fydd mor effeithlon â ffyrdd eraill, yn enwedig ar gyfer matricsau mwy. Eto i gyd, mae'n ddewis gwych i chi os ydych chi'n newydd i algebra llinol.
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])
# Gosodwch y matrics canlyniad i sero.
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
Gadewch i ni gael enghraifft o sut i wneud hyn. Gallwch chi ychwanegu'r llinellau cod hyn isod i brofi'r enghraifft hon.
# 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]]
Budd-daliadau:
- Hawdd i'w ddeall.
- Gwych ar gyfer newbies neu'r rhai sy'n ceisio dealltwriaeth ddyfnach o luosi matrics.
Anfanteision:
- Ddim mor effeithiol â thechnegau amgen, yn enwedig ar gyfer matricsau mwy.
- Nid yw mor ddarllenadwy â dulliau amgen.
map() dull ffwythiant
Mae'r dull ffwythiant map() yn darparu dull arall o luosi matrics yn Python. Yn y dull hwn, rydym yn defnyddio'r swyddogaeth map adeiledig (). Felly, rydym yn defnyddio offeryn rhaglennu swyddogaethol sy'n cymhwyso swyddogaeth a ddarperir i bob elfen ailadroddadwy (rhestr, tuple, ac ati). Hefyd, mae'r ffwythiant map() yn derbyn dau baramedr, swyddogaeth ac ailadroddadwy. Ac, mae'n dychwelyd iterator sy'n cymhwyso'r swyddogaeth i bob elfen ailadroddadwy.
Yn y dull hwn, rydym yn mynd trwy bob aelod o'r matrics ac yn gwneud y lluosi gan ddefnyddio'r ffwythiant map nythu().
Defnyddir y ffwythiant zip() i ailadrodd trwy bob elfen o'r matricsau yn gyfochrog.
Yn olaf, defnyddir y ffwythiant swm() i adio'r canlyniadau.
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
Nawr, unwaith eto, gallwn brofi ein cod gydag enghraifft.
# 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]]
manteision
- Yn fwy effeithiol na'r dull dolenni pentyrru
- Mae'n defnyddio rhaglennu swyddogaethol i wneud y cod yn symlach.
Anfanteision
- Efallai y bydd rhai pobl nad ydynt yn gyfarwydd â rhaglennu swyddogaethol yn ei chael yn llai darllenadwy.
- Mae'n llai dealladwy na'r dechneg dolenni nythu.
Rhestr dull deall
Mae deall rhestr yn eich galluogi i gynhyrchu rhestr newydd mewn un llinell o god. Felly, gwneir hyn trwy gymhwyso mynegiant i bob aelod o restr sy'n bodoli.
Yn y dull hwn, cyflawnir lluosi trwy ailadrodd dro ar ôl tro trwy bob aelod matrics. Rydym yn defnyddio dealltwriaeth rhestr haenog.
# 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]]
Manteision
- O'i gymharu â dull ffwythiant map(), mae'n fyrrach ac yn fwy darllenadwy.
Anfanteision
- Gall fod yn llai effeithiol na defnyddio'r swyddogaeth map(), yn enwedig ar gyfer matricsau mawr.
- Mae'n anoddach na'r dull dolenni nythu.
Casgliad
Yn y swydd hon, buom yn edrych ar ddewisiadau amgen i ddefnyddio NumPy wrth luosi matricsau yn Python. Fe wnaethom berfformio lluosi matrics mewn dolenni nythu, y swyddogaeth map () adeiledig, a deall rhestr.
Bydd y strategaeth orau yn dibynnu ar anghenion penodol eich prosiect.
Mae gan bob un o'r strategaethau ei fanteision a'i anfanteision ei hun. Er mwyn sicrhau bod y swyddogaeth yn gweithredu'n iawn, mae'n syniad da ychwanegu rhai achosion prawf gyda gwahanol ddimensiynau a gwerthoedd matrics.
Dylech hefyd gynnwys rhai profion perfformiad i gymharu pa mor dda y mae'r dulliau hyn yn gweithredu.
Gadael ymateb