Ebből az oktatóanyagból megtudhatja, hogyan szorozhat meg két mátrixot Pythonban.
Kezdje azzal, hogy megtanulja az érvényes mátrixszorzás feltételét, és írjon egy egyéni Python-függvényt a mátrixok szorzásához. Ezután látni fogja, hogyan érheti el ugyanazt az eredményt a beágyazott listaértelmezések használatával.
Végül a NumPy és a beépített funkciói használatával hatékonyabban hajthatja végre a mátrixszorzást.
Tartalomjegyzék
Hogyan ellenőrizhető, hogy a mátrixszorzás érvényes-e
Mielőtt Python-kódot írna a mátrixszorzáshoz, tekintsük át újra a mátrixszorzás alapjait.
Mátrix A két A és B mátrix közötti szorzás csak akkor érvényes, ha az A mátrix oszlopainak száma megegyezik a B mátrix sorainak számával.
Valószínűleg már korábban is találkozott ezzel a feltétellel a mátrixszorzáshoz. Azonban elgondolkozott már azon, hogy miért van ez így?
Nos, ez a mátrixszorzás működése miatt van. Vessen egy pillantást az alábbi képre.
Általános példánkban az A mátrixnak m sora és n oszlopa van. És a B mátrixnak n sora és p oszlopa van.
Milyen a termékmátrix alakja?
A C eredő mátrixban az (i, j) indexű elem az A mátrix i sorának és a B mátrix j oszlopának pontszorzata.
Tehát ahhoz, hogy a kapott C mátrixban egy adott indexen lévő elemet kapjunk, ki kell számítanunk a megfelelő sor és oszlop pontszorzatát az A és B mátrixban.
A fenti folyamatot megismételve megkapja az mxp alakú C szorzatmátrixot – m sorral és p oszloppal, az alábbiak szerint.
A pontszorzatot vagy két a és b vektor közötti belső szorzatot pedig a következő egyenlet adja meg.
Most összegezzük:
- Nyilvánvaló, hogy a pontszorzat csak egyenlő hosszúságú vektorok között van definiálva.
- Tehát ahhoz, hogy egy sor és egy oszlop közötti pontszorzat érvényes legyen – amikor két mátrixot szorozunk –, mindkettőnek ugyanannyi eleműnek kell lennie.
- A fenti általános példában az A mátrix minden sora n elemet tartalmaz. És a B mátrix minden oszlopának n eleme is van.
Ha jobban megnézzük, n az A mátrix oszlopainak száma, és egyben a B mátrix sorainak száma is. És pontosan ez az oka annak, hogy az A mátrixban lévő oszlopok számának egyenlőnek kell lennie a számmal. sorok közül a B mátrixban.
Remélem, megérti a mátrixszorzás érvényességének feltételét, és a szorzatmátrix egyes elemeinek beszerzését.
Írjunk egy Python-kódot két mátrix szorzásához.
Írjon egyéni Python-függvényt a mátrixok szorzásához
Első lépésként írjunk egy egyedi függvényt a mátrixok szorzására.
Ennek a funkciónak a következőket kell tennie:
- Fogadjunk el két mátrixot, A-t és B-t bemenetként.
- Ellenőrizze, hogy érvényes-e az A és B közötti mátrixszorzás.
- Ha érvényes, szorozza meg a két A és B mátrixot, és adja vissza a C szorzatmátrixot.
- Ellenkező esetben hibaüzenetet ad vissza, hogy az A és B mátrixok nem szorozhatók.
1. lépés: Hozzon létre két egész számmátrixot a NumPy random.randint() függvényével. A mátrixokat beágyazott Python-listákként is deklarálhatja.
import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:n {A}n")
print(f"Matrix B:n {B}n")
# Output
Matrix A:
[[4 9 9]
[9 1 6]
[9 2 3]]
Matrix B:
[[2 2]
[5 7]
[4 4]]
2. lépés: Folytassa és határozza meg a szorzómátrix(A,B) függvényt. Ez a függvény két A és B mátrixot vesz be bemenetként, és a C szorzatmátrixot adja vissza, ha a mátrixszorzás érvényes.
def multiply_matrix(A,B):
global C
if A.shape[1] == B.shape[0]:
C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
for row in range(rows):
for col in range(cols):
for elt in range(len(B)):
C[row, col] += A[row, elt] * B[elt, col]
return C
else:
return "Sorry, cannot multiply A and B."
A függvénydefiníció elemzése
Folytassuk a függvénydefiníció elemzésével.
A C deklarálása globális változóként: Alapértelmezés szerint a Python-függvényen belüli összes változó helyi hatókörrel rendelkezik. És nem érheti el őket a funkción kívülről. Ahhoz, hogy a C szorzatmátrixot kívülről is elérhetővé tegyük, globális változóként kell deklarálnunk. Csak adja hozzá a globális minősítőt a változó neve elé.
Ellenőrizze, hogy a mátrixszorzás érvényes-e: A shape attribútum segítségével ellenőrizze, hogy A és B szorozható-e. Bármely tömb esetén arr, arr.shape[0] és arr.alak[1] adja meg a sorok, illetve az oszlopok számát. Tehát ha A.alak[1] == B.alak[0] ellenőrzi, hogy a mátrixszorzás érvényes-e. A szorzatmátrix csak akkor kerül kiszámításra, ha ez a feltétel igaz. Ellenkező esetben a függvény hibaüzenetet ad vissza.
Használjon beágyazott ciklusokat az értékek kiszámításához: Az eredő mátrix elemeinek kiszámításához az A mátrix sorain kell átmenni, és ezt a külső for ciklus teszi meg. A belső for ciklus segít áthurkolni a B mátrix oszlopát. A legbelső for ciklus pedig segít elérni a kiválasztott oszlop minden elemét.
▶️ Most, hogy megtanultuk, hogyan működik a Python függvény a mátrixok szorzására, hívjuk meg a függvényt a korábban generált A és B mátrixokkal.
multiply_matrix(A,B)
# Output
array([[ 89, 107],
[ 47, 49],
[ 40, 44]])
Mivel A és B mátrixszorzása érvényes, a multiply_matrix() függvény a C szorzatmátrixot adja vissza.
Használja a Python beágyazott lista megértését a mátrixok szorzásához
Az előző részben egy Python-függvényt írt a mátrixok szorzására. Most látni fogja, hogyan használhatja a beágyazott listaértelmezéseket ugyanerre.
Itt van a beágyazott lista megértése a mátrixok szorzásához.
Elsőre ez bonyolultnak tűnhet. De a beágyazott lista megértését lépésről lépésre elemezzük.
Koncentráljunk egy-egy lista megértésére, és határozzuk meg, mit csinál.
A lista megértéséhez a következő általános sablont fogjuk használni:
[<do-this> for <item> in <iterable>] where, <do-this>: what you'd like to do—expression or operation <item>: each item you'd like to perform the operation on <iterable>: the iterable (list, tuple, etc.) that you're looping through
▶️ Tekintse meg a Python nyelvű lista megértése című útmutatónkat – példákkal a mélyreható megértés érdekében.
Mielőtt továbbmenne, vegye figyelembe, hogy az eredő C mátrixot soronként szeretnénk felépíteni.
Beágyazott lista értelmezése magyarázata
1. lépés: Számítson ki egyetlen értéket a C mátrixban
Adott az A mátrix i sora és a B mátrix j oszlopa, az alábbi kifejezés a C mátrix (i, j) indexének bejegyzését adja.
sum(a*b for a,b in zip(A_row, B_col) # zip(A_row, B_col) returns an iterator of tuples # If A_row = [a1, a2, a3] & B_col = [b1, b2, b3] # zip(A_row, B_col) returns (a1, b1), (a2, b2), and so on
Ha i = j = 1, akkor a kifejezés a C mátrix c_11 bejegyzését adja vissza. Így egy sorban egy elemet kaphat így.
2. lépés: Építsen egy sort a C mátrixban
A következő célunk egy teljes sor felépítése.
Az A mátrix 1. sorához végig kell görgetnie a B mátrix összes oszlopát, hogy egy teljes sort kapjon a C mátrixban.
Térjen vissza a listaértelmezési sablonhoz.
- Cserélje ki a
kifejezést az 1. lépésből származó kifejezésre, mert ezt szeretné tenni. - Ezután cserélje ki az
- elemet B_col-ra – a B mátrix minden oszlopában.
- Végül cserélje ki az
elemet a zip(*B)-re – ez a lista a B mátrix összes oszlopát tartalmazza.
És itt az első listaértés.
[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] # zip(*B): * is the unzipping operator # zip(*B) returns a list of columns in matrix B
3. lépés: Építsen fel minden sort, és szerezze be a C mátrixot
Ezután fel kell töltenie a C szorzatmátrixot a többi sor kiszámításával.
Ehhez pedig végig kell görgetnie az A mátrix összes sorát.
Térjen vissza még egyszer a lista megértéséhez, és tegye a következőket.
- Cserélje ki a
elemet a 2. lépésből származó listaértelmezésre. Emlékezzünk vissza, hogy az előző lépésben egy teljes sort számoltunk ki. - Most cserélje ki az
elemet A_sorra – az A mátrix minden sorában. - Az
pedig maga az A mátrix, miközben a sorait hurkolod.
És itt a végső beágyazott listaértésünk.🎊
[[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)]
for A_row in A]
Ideje ellenőrizni az eredményt! ✔
# cast into <a href="https://etoppc.com.com/numpy-reshape-arrays-in-python/">NumPy array</a> using np.array()
C = np.array([[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)]
for A_row in A])
# Output:
[[ 89 107]
[ 47 49]
[ 40 44]]
Ha jobban megnézzük, ez megegyezik a korábban használt egymásba ágyazott for ciklusokkal – csak annyi, hogy tömörebb.
Ezt egyes beépített funkciók segítségével még hatékonyabban is megteheti. Tanuljunk meg róluk a következő részben.
Használja a NumPy matmul()-t a mátrixok szorzásához Pythonban
Az np.matmul() két mátrixot vesz be bemenetként, és visszaadja a szorzatot, ha a bemeneti mátrixok közötti mátrixszorzás érvényes.
C = np.matmul(A,B) print(C) # Output: [[ 89 107] [ 47 49] [ 40 44]]
Figyelje meg, hogy ez a módszer egyszerűbb, mint a korábban megismert két módszer. Valójában az np.matmul() helyett használhatunk egy ekvivalens @ operátort, és ezt mindjárt látni fogjuk.
A @ operátor használata Pythonban a mátrixok szorzásához
A Pythonban a @ egy mátrixszorzáshoz használt bináris operátor.
Két mátrixon, és általában N-dimenziós NumPy tömbön működik, és a szorzatmátrixot adja vissza.
Megjegyzés: A @ operátor használatához Python 3.5 vagy újabb verzióra van szükség.
Így használhatja.
C = [email protected]
print(C)
# Output
array([[ 89, 107],
[ 47, 49],
[ 40, 44]])
Figyeljük meg, hogy a C szorzatmátrix ugyanaz, mint amit korábban kaptunk.
Használható az np.dot() mátrixok szorzásához?
Ha valaha is találkozott olyan kóddal, amely az np.dot() függvényt használja két mátrix szorzására, akkor ez a következőképpen működik.
C = np.dot(A,B) print(C) # Output: [[ 89 107] [ 47 49] [ 40 44]]
Látni fogja, hogy az np.dot(A, B) szintén a várt termékmátrixot adja vissza.
Azonban a szerint NumPy dokumentumokaz np.dot() függvényt csak két egydimenziós vektor pontszorzatának kiszámításához kell használni, mátrixszorzáshoz nem.
Emlékezzünk vissza az előző részből, a C szorzatmátrix (i, j) indexű eleme az A mátrix i sorának és a B mátrix j oszlopának pontszorzata.
Mivel a NumPy implicit módon sugározza ezt a pontszorzati műveletet az összes sorba és oszlopba, megkapja az eredményül kapott szorzatmátrixot. De annak érdekében, hogy a kód olvasható maradjon és elkerülje a kétértelműséget, használja helyette az np.matmul()-t vagy a @ operátort.
Következtetés
🎯 Ebből az oktatóanyagból a következőket tanulta meg.
- A mátrixszorzás érvényességének feltétele: oszlopok száma az A mátrixban = sorok száma a B mátrixban.
- Egyéni Python-függvény írása, amely ellenőrzi, hogy a mátrixszorzás érvényes-e, és visszaadja a szorzatmátrixot. A függvény törzse a beágyazott ciklusokat használja.
- Ezután megtanulta, hogyan használhatja a beágyazott listaértelmezéseket a mátrixok szorzásához. Ezek tömörebbek, mint a hurkok esetében, de hajlamosak az olvashatósági problémákra.
- Végül megtanulta a NumPy beépített np.matmul() függvényét a mátrixok szorzására, és azt, hogy ez a sebesség szempontjából a leghatékonyabb.
- Megtanulta a @ operátort is, amellyel két mátrixot szorozhat meg Pythonban.
És ezzel lezárjuk a Python mátrixszorzásról szóló vitánkat. Következő lépésként tanulja meg, hogyan ellenőrizheti, hogy egy szám prímszámú-e a Pythonban. Vagy oldjon meg érdekes problémákat Python karakterláncokon.
Jó tanulást!🎉