10.2 Mátrixszorzás és lineáris transzformáció

10.2.1 Cél és konkrét helyzet

A helyzet: három rendelést választottunk ki a Northstar-példából. Minden rendeléshez két, a rendelés pillanatában ismert jellemző tartozik: a szállítási távolság kilométerben (distance_km) és a kosárérték eurócentben (basket_minor). Egy kolléga adott nekünk egy kézi, még nem tanított lineáris modellt a várható kézbesítési napokra:

$$\hat y_i \;=\; 2.0 \;+\; 0.3 \cdot \text{distance\_km}_i \;+\; 0.0002 \cdot \text{basket\_minor}_i .$$

A három megfigyelési egység egy-egy rendelés:

Cél: ezt a három predikciót egyszerre, mátrixműveletként kiszámítani, és elkülöníteni a mátrixszorzást a koordinátánkénti szorzástól. A fejezetben nem becslünk súlyokat; a súlyokat adottnak vesszük. A súlyok becslése a következő alfejezet (Vetítés és legkisebb négyzetek) feladata lesz.

Előzetes becslés a téma előtt: számold ki kézzel az első rendelés predikcióját: $2.0 + 0.3 \cdot 10 + 0.0002 \cdot 2500$. Ha $5.5$ nap jött ki, jó úton jársz; a mátrixszorzás pontosan ezt a műveletet végzi el egyszerre minden sorra.

10.2.2 Fogalmi magyarázat: a mátrixszorzás mint sor-skaláris szorzat

10.2.2.1 Kétismeretlenes egyenletből mátrixszorzáshoz

Induljunk ki egy közismert lineáris egyenletrendszerből:

$$\begin{cases} 2a + 3b = 13, \\ 4a + \; b = 11. \end{cases}$$

Ezt úgy írhatjuk tömören, hogy az együtthatókat egy $2 \times 2$-es mátrixba gyűjtjük, az ismeretleneket pedig oszlopvektorba:

$$\mathbf A = \begin{pmatrix} 2 & 3 \\ 4 & 1 \end{pmatrix}, \qquad \mathbf z = \begin{pmatrix} a \\ b \end{pmatrix}, \qquad \mathbf A \mathbf z = \begin{pmatrix} 2a + 3b \\ 4a + b \end{pmatrix} = \begin{pmatrix} 13 \\ 11 \end{pmatrix}.$$

A mátrixszorzás (matrix product) szabálya tehát: a kimenet $i$-edik eleme az $\mathbf A$ $i$-edik sora és a $\mathbf z$ oszlopa skaláris szorzata. A skaláris szorzatot az előző alfejezetben, Vektor, skalárszorzat, norma és távolság alfejezetben definiáltuk: koordinátaszorzatok összege. A példa megoldása $a=2$, $b=3$, mert $2\cdot 2+3\cdot 3=13$ és $4\cdot 2+1\cdot 3=11$.

10.2.2.2 A design mátrix és az $Xw$ predikció

A predikciós feladatban az $\mathbf A$ szerepét a design mátrix (design matrix) veszi át, jele $\mathbf X$. Egy $\mathbf X$ mátrix $n \times p$ alakú, ha $n$ megfigyelés és $p$ oszlop van. Minden sor egy megfigyelés, minden oszlop egy jellemző. A fenti három rendelésnél $n=3$; ha a tengelymetszethez (intercept) tartozó, csupa $1$-es oszlopot is hozzáadjuk, akkor $p=3$:

$$\mathbf X = \begin{pmatrix} 1 & 10 & 2500 \\ 1 & 25 & 5000 \\ 1 & 5 & 1000 \end{pmatrix}, \qquad \mathbf w = \begin{pmatrix} w_0 \\ w_1 \\ w_2 \end{pmatrix} = \begin{pmatrix} 2.0 \\ 0.3 \\ 0.0002 \end{pmatrix}.$$

A lineáris predikció:

$$\hat{\mathbf y} = \mathbf X \mathbf w .$$

Ebben a példában:

$$\hat{\mathbf y} = \begin{pmatrix} 1 \cdot 2.0 + 10 \cdot 0.3 + 2500 \cdot 0.0002 \\ 1 \cdot 2.0 + 25 \cdot 0.3 + 5000 \cdot 0.0002 \\ 1 \cdot 2.0 + 5 \cdot 0.3 + 1000 \cdot 0.0002 \end{pmatrix} = \begin{pmatrix} 5.5 \\ 10.5 \\ 3.7 \end{pmatrix}.$$

10.2.2.3 Alakok és mértékegységek

A mátrixszorzás alakszabálya: ha $\mathbf X$ alakja $(n, p)$ és $\mathbf w$ alakja $(p, 1)$, akkor $\hat{\mathbf y}$ alakja $(n, 1)$. A két belső dimenzió, $p$, megegyezik, és a szorzás során eltűnik. Szavakkal: annyi kimenet lesz, ahány sor, és minden kimenet annyi tagot összegez, ahány oszlop.

A súlyok mértékegysége a predikciót teszi dimenzionálisan helyessé. Ha a cél a kézbesítési napok száma, akkor:

• $w_0$ mértékegysége nap;
• $w_1$ mértékegysége nap/km, mert $w_1 \cdot \text{distance\_km}$ eredménye nap;
• $w_2$ mértékegysége nap/eurocent, mert $w_2 \cdot \text{basket\_minor}$ eredménye nap.

A súlyok tehát nem puszta számok: átváltják a jellemző mértékegységét a cél mértékegységére. A szorzatok azért összeadhatók, mert mindegyik tag már nap egységben van.

10.2.2.4 Transzponálás és a sor-oszlop átrendezés

A transzponált (transpose) mátrix sorait és oszlopait felcseréli:

$$\big(\mathbf X^T\big)_{ij} = \mathbf X_{ji}.$$

Ha $\mathbf X$ alakja $(n, p)$, akkor $\mathbf X^T$ alakja $(p, n)$. A fenti példában:

$$\mathbf X^T = \begin{pmatrix} 1 & 1 & 1 \\ 10 & 25 & 5 \\ 2500 & 5000 & 1000 \end{pmatrix}.$$

A transzponálás a becslés későbbi lépésében, az $\mathbf X^T \mathbf X$ mátrixban tér majd vissza; egyelőre elég annyi, hogy a sorok és oszlopok megcserélésével a „minta” és a „jellemző” irány felcserélhető.

10.2.2.5 Bázis és tengelymetszet

A design mátrix oszlopai tekinthetők bázisfüggvény-vektoroknak (basis vectors). A predikció az oszlopok lineáris kombinációja:

$$\hat{\mathbf y} = w_0 \underbrace{\begin{pmatrix}1\\1\\1\end{pmatrix}}_{\text{intercept oszlop}} + w_1 \underbrace{\begin{pmatrix}10\\25\\5\end{pmatrix}}_{\text{távolság oszlop}} + w_2 \underbrace{\begin{pmatrix}2500\\5000\\1000\end{pmatrix}}_{\text{kosárérték oszlop}}.$$

A csupa $1$-es oszlop az intercept oszlop; a hozzá tartozó $w_0$ a tengelymetszet, vagyis az a predikció, amikor minden numerikus jellemző nulla. A „bázis” itt annyit jelent: a modell által elérhető predikciók az oszlopvektorok összes lehetséges lineáris kombinációja. Ez a kép lesz fontos a legkisebb négyzeteknél (Vetítés és legkisebb négyzetek) és a főkomponens-elemzésnél (PCA: skála, vetítés és megőrzött variancia).

10.2.2.6 Miért nem koordinátánkénti szorzás?

A NumPy-ban és sok más eszközben két művelet hasonlít egymásra:

• Elemenkénti szorzás (* operátor, angolul Hadamard product): azonos alakú tömbök azonos pozíciójú elemeit szorozza össze.
• Mátrixszorzás (@ operátor): sorok és oszlopok skaláris szorzatát számolja, az előbb leírt szabállyal.

A predikció nem elemenkénti szorzás, mert $\mathbf X$ alakja $(3,3)$, a súlyok alakja pedig $(3,)$, tehát nincs sor-sor pár. A helyes művelet a mátrixszorzás: minden sor a teljes súlyvektorral kombinálódik. A koordinátánkénti szorzás csak közbülső lépés lehet, de önmagában nem adja a predikciót.

10.2.3 Teljes minimális munkapélda

A labor konkrét célja: három mintára, két valódi jellemzővel számítsuk ki a lineáris predikciót először kézzel, majd a NumPy @ operátorával. A kézi számítást már elvégeztük fent; az eredmény $[5.5, 10.5, 3.7]$.

import numpy as np

# Minden sor egy rendelés.
# Az első oszlop az intercept, a második a distance_km,
# a harmadik a basket_minor.
X = np.array([
    [1.0, 10.0, 2500.0],
    [1.0, 25.0, 5000.0],
    [1.0,  5.0, 1000.0],
])

# Súlyok: w0 = 2 nap, w1 = 0.3 nap/km, w2 = 0.0002 nap/eurocent.
w = np.array([2.0, 0.3, 0.0002])

# Mátrixszorzás: (3, 3) @ (3,) -> (3,)
y_hat = X @ w

# Kézi ellenőrzés oszloponkénti súlyozott összeggel.
manual = X[:, 0] * w[0] + X[:, 1] * w[1] + X[:, 2] * w[2]

print("X.shape:", X.shape)        # (3, 3)
print("w.shape:", w.shape)        # (3,)
print("y_hat.shape:", y_hat.shape)  # (3,)
print("y_hat:", y_hat)            # várhatóan [5.5 10.5 3.7]
print("allclose:", np.allclose(y_hat, manual, rtol=1e-12, atol=1e-12))

Szemléltető kimenet, nem mért futtatás; a kézi kontroll alapján várható:

X.shape: (3, 3)
w.shape: (3,)
y_hat.shape: (3,)
y_hat: [ 5.5 10.5  3.7]
allclose: True

A manual sor azt mutatja, hogy a mátrixszorzás belül oszloponkénti elemenkénti szorzások összege, de maga az X * w kifejezés nem a predikció. Ezt a megkülönböztetést a gyakori tévedéseknél részletezzük.

10.2.4 Az eredmény értelmezése

A három predikció: $5.5$, $10.5$, $3.7$ nap. Az első rendelésre a kézi számítás pontosan ezt adta, tehát a kód alakja és iránya jó. A kimenet shape=(3,), dtype=float64, mert a bemenetek float64 mátrixok. A np.allclose azért hasznos, mert a 0.3 és 0.0002 bináris ábrázolása nem mindig egzakt; rtol=1e-12, atol=1e-12 toleranciával a gépi és kézi eredmény megegyezik.

Értelmezési korlát: ez a lineáris modell additív és globálisan lineáris. Ha a távolság $0$ és a kosárérték $0$, a predikció $2$ nap; ha a távolság nagyon nagy, a predikció tetszőlegesen nagy lehet. A valós kézbesítés nem lehet negatív és nem nőhet minden határon túl; a későbbi modellezésnél nemlineáris vagy korlátos modellt választunk. A log-skálát Exponenciális és logaritmikus skála alfejezetben láttuk: ha a cél $\log y$ lenne, a súlyok multiplikatív hatást jelentenének a nyers skálán. Itt azonban nyers skálán dolgozunk, ezért a hozzájárulások összeadódnak.

Rövid pandas-visszautalás (Kiválasztás és módosítás Copy-on-Write mellett): ha a mátrixot egy DataFrame-ből készítjük a .to_numpy() hívással, a mátrix elveszíti a sorindexet. A predikció visszaírásánál ezért mindig a DataFrame eredeti indexét használjuk, ne a NumPy pozícióját. A példában a sorrend és az index azonos, de nagyobb táblánál ez a leggyakoribb csendes hiba.

10.2.5 Feladatok

1. Értelmezés. Adott egy másik kézi súlyvektor: $w_0=1.0$ nap, $w_1=0.2$ nap/km, $w_2=0.0005$ nap/eurocent. Számold ki kézzel a predikciót arra a két új rendelésre, ahol (distance_km, basket_minor) rendre $(20, 4000)$ és $(8, 1200)$. Mi a mértékegysége $w_1$ és $w_2$ fontos szerepének?

2. Megvalósítás. Építsd meg $\mathbf X$-et a fenti három rendelés adatával, de a súlyokat most válaszd $w_0=1.8$, $w_1=0.22$, $w_2=0.00035$ értékűre. Számold ki $\mathbf X \mathbf w$ értékét a @ operátorral, és ellenőrizd az első sorra kézi számítással. Ellenőrizd a shape értékét is.

3. Hibakeresés. Egy kolléga ezt írta ugyanarra az $\mathbf X$-re, $w=(2.0,\,0.3,\,0.0002)$ súlyokkal:

   pred = X * w

   Mi ez pontosan? Miért nem a lineáris predikció? Add meg, mit kap a kolléga az első sorban, és javítsd a kódot két módon: @ operátorral, illetve az elemenkénti szorzat explicit sorösszegzésével.

4. Megváltozott feltétel / továbbvitel. Adj a modellhez egy harmadik jellemzőt: quantity_sum, az adott rendelés összes darabszámát. A három rendelésre legyen $(4, 6, 7)$, az új súly pedig $w_3=0.1$ nap/darab. Írd fel az új $\mathbf X$ mátrixot, add meg az alakját, és számold ki az új predikciókat @ operátorral. Ellenőrizd kézzel az R01 rendelés predikcióját.

5. Értelmezés: mátrixszorzás és nem kommutativitás. Legyen

   $$\mathbf A = \begin{pmatrix} 2 & 3 \\ 4 & 1 \end{pmatrix}, \quad \mathbf B = \begin{pmatrix} 1 & 0 \\ 2 & 1 \end{pmatrix}.$$

   Számold ki kézzel $\mathbf A \mathbf B$-t és $\mathbf B \mathbf A$-t. Milyen alakú a két eredmény? Mit jelent ez a „mátrixosztás” szempontjából?

10.2.6 Megoldások és indoklás

1. megoldás. A predikció:

$$\hat y = 1.0 + 0.2 \cdot \text{distance} + 0.0005 \cdot \text{basket}.$$

• Első rendelés: $1.0 + 0.2 \cdot 20 + 0.0005 \cdot 4000 = 1.0 + 4.0 + 2.0 = 7.0$ nap.
• Második rendelés: $1.0 + 0.2 \cdot 8 + 0.0005 \cdot 1200 = 1.0 + 1.6 + 0.6 = 3.2$ nap.

A $w_1$ mértékegysége nap/km, mert a km-t napra váltja; a $w_2$ mértékegysége nap/eurocent. A mértékegységek nélkül a $4.0$ és $2.0$ tagot nem lehetne egy nap-skálán összeadni.

2. megoldás.

import numpy as np

X = np.array([
    [1.0, 10.0, 2500.0],
    [1.0, 25.0, 5000.0],
    [1.0,  5.0, 1000.0],
])
w = np.array([1.8, 0.22, 0.00035])

y_hat = X @ w
print("shape:", y_hat.shape)
print("y_hat:", y_hat)

Várható kimenet: shape: (3,), y_hat: [4.875 8.05 3.25].

Ellenőrzés az első sorra:

$$1.8 + 0.22 \cdot 10 + 0.00035 \cdot 2500 = 1.8 + 2.2 + 0.875 = 4.875 .$$

3. megoldás. A X * w kifejezés NumPy-ban elemenkénti szorzás broadcastinggal. Mivel $\mathbf X$ alakja $(3,3)$ és $\mathbf w$ alakja $(3,)$, a $\mathbf w$ az utolsó tengelyre illeszkedik, ezért a kolléga eredménye:

$$\mathbf X * \mathbf w = \begin{pmatrix} 1 \cdot 2.0 & 10 \cdot 0.3 & 2500 \cdot 0.0002 \\ 1 \cdot 2.0 & 25 \cdot 0.3 & 5000 \cdot 0.0002 \\ 1 \cdot 2.0 & 5 \cdot 0.3 & 1000 \cdot 0.0002 \end{pmatrix} = \begin{pmatrix} 2.0 & 3.0 & 0.5 \\ 2.0 & 7.5 & 1.0 \\ 2.0 & 1.5 & 0.2 \end{pmatrix}.$$

Ez nem a predikció, hanem egy $(3,3)$-as mátrix. Az első sor helyes predikciója $2.0+3.0+0.5=5.5$, tehát a kolléga csak akkor kapná meg a predikciókat, ha utána soronként összegezné, például:

pred = (X * w).sum(axis=1)

Ez azonban véletlenül működik az egydimenziós $\mathbf w$ esetben; ha $\mathbf w$ oszlopvektor, az elemenkénti szorzás egészen mást ad. A helyes, szándékot tükröző megoldás a mátrixszorzás:

pred = X @ w

A javítási elv: mindig a dimenziókból indulj ki, és a predikciót $\mathbf X\mathbf w$-ként írd le. Az elemenkénti szorzás nem „rossz”, hanem más művelet.

4. megoldás. Az új design mátrix 3 sor és 4 oszlop:

$$\mathbf X_{\text{new}} = \begin{pmatrix} 1 & 10 & 2500 & 4 \\ 1 & 25 & 5000 & 6 \\ 1 & 5 & 1000 & 7 \end{pmatrix}, \qquad \mathbf w_{\text{new}} = \begin{pmatrix} 2.0 \\ 0.3 \\ 0.0002 \\ 0.1 \end{pmatrix}.$$

Kódban:

X_new = np.array([
    [1.0, 10.0, 2500.0, 4.0],
    [1.0, 25.0, 5000.0, 6.0],
    [1.0,  5.0, 1000.0, 7.0],
])
w_new = np.array([2.0, 0.3, 0.0002, 0.1])

y_hat_new = X_new @ w_new
print("X_new.shape:", X_new.shape)  # (3, 4)
print("y_hat_new:", y_hat_new)      # [5.9 11.1  4.4]

Kézi ellenőrzés R01-re: $2.0 + 0.3\cdot 10 + 0.0002\cdot 2500 + 0.1\cdot 4 = 2.0 + 3.0 + 0.5 + 0.4 = 5.9$ nap. A X_new.shape $(3,4)$, mert az intercept és a három jellemző négy oszlopot ad.

5. megoldás. A szorzás:

$$\mathbf A \mathbf B = \begin{pmatrix} 2\cdot 1 + 3\cdot 2 & 2\cdot 0 + 3\cdot 1 \\ 4\cdot 1 + 1\cdot 2 & 4\cdot 0 + 1\cdot 1 \end{pmatrix} = \begin{pmatrix} 8 & 3 \\ 6 & 1 \end{pmatrix}.$$

$$\mathbf B \mathbf A = \begin{pmatrix} 1\cdot 2 + 0\cdot 4 & 1\cdot 3 + 0\cdot 1 \\ 2\cdot 2 + 1\cdot 4 & 2\cdot 3 + 1\cdot 1 \end{pmatrix} = \begin{pmatrix} 2 & 3 \\ 8 & 7 \end{pmatrix}.$$

A két eredmény különböző, tehát a mátrixszorzás nem kommutatív. Ezért nincs értelmes „mátrixosztás” úgy, ahogy a valós számoknál $b/a$ működik. Ha egy $\mathbf A\mathbf z=\mathbf b$ egyenletet akarunk megoldani, külön műveletet használunk: $\mathbf z=\mathbf A^{-1}\mathbf b$ vagy numerikusan jobb $\mathbf z=\text{solve}(\mathbf A,\mathbf b)$. A design mátrix predikciója viszont nem old meg egyenletet: ott $\mathbf w$ adott, és $\hat{\mathbf y}=\mathbf X\mathbf w$ kiszámítása szorzás.

10.2.7 Gyakori tévedés és ellenpélda

Az invertálás, az elemenkénti osztás és a lineáris rendszer megoldása külön művelet.

Tegyük fel, hogy valaki meg akarja oldani a fenti $\mathbf A\mathbf z=\mathbf b$ rendszert $\mathbf A=\begin{pmatrix}2&3\\4&1\end{pmatrix}$ és $\mathbf b=\begin{pmatrix}13\\11\end{pmatrix}$ esetén. Három gyakori, de eltérő jelentésű kifejezés:

1. Elemenkénti osztás: b / A Python/NumPy-ban nem mátrixosztás. Ha egyáltalán lefut, a / elemenként oszt, és az alakokat a broadcasting szabályai szerint illeszti. A fenti $\mathbf b$ alakja $(2,)$, $\mathbf A$ alakja $(2,2)$; ez leggyakrabban ValueError. Ha mégis lefutna, akkor is elemenkénti hányadosokat adna, nem az egyenletrendszer megoldását.

2. Invertálás: np.linalg.inv(A) @ b matematikailag helyes, ha $\mathbf A$ invertálható. Numerikusan azonban rossz szokás, mert az inverz kiszámítása instabil lehet. Az ajánlott megoldás:

   z = np.linalg.solve(A, b)   # z = [2.0, 3.0]

3. Predikció: X @ w. Itt $\mathbf X$ általában nem négyzetes; ha $n \ne p$, nem is beszélhetünk egyértelmű inverzről. A cél pedig nem megoldani egy egyenletet, hanem a súlyokkal kiszámítani a predikciót.

A koordinátánkénti szorzás csendes csapdája. A fenti X * w példa mutatja, hogy a broadcasting miatt a rossz művelet is lefuthat. Ellenőrzésképpen soha ne csak a kódot futtasd, hanem egy sorra kézzel is számold ki a várt eredményt. A mátrixszorzás alakszabálya a belső dimenzió egyezése: $(n,p) @ (p,) \to (n,)$. Ha ezt a dimenziót nem ellenőrizzük, a broadcasting kiszámítható, de értelmetlen eredményt adhat.

10.2.8 Önellenőrzés

1. Adott $\mathbf X$ alakja $(100, 8)$ és $\mathbf w$ alakja $(8,)$. Mi a predikció alakja, és hány tagot összegez minden sor?
   <details><summary>Válasz</summary>A predikció alakja $(100,)$; minden sor 8 tagot (intercept + 7 jellemző, ha az első oszlop intercept) összegez.</details>

2. Miért kell az interceptet külön $1$-es oszlopként felvenni?
   <details><summary>Válasz</summary>Mert a mátrixszorzás minden kimenetet $\sum_j X_{ij}w_j$ alakban állít elő. Az $1$-es bejegyzés révén jelenik meg a $w_0$ tag, amely így nem függ egyetlen jellemzőtől sem.</details>

3. Milyen műveletek a * és a @ NumPy-ban?
   <details><summary>Válasz</summary>A * elemenkénti (Hadamard-) szorzás broadcastinggal; a @ mátrixszorzás, sor-oszlop skaláris szorzatokkal.</details>

4. Mi az alakszabálya $\mathbf X^T \mathbf X$ szorzatnak, ha $\mathbf X$ alakja $(n,p)$?
   <details><summary>Válasz</summary>$\mathbf X^T$ alakja $(p,n)$, így a szorzat $(p,p)$; ez lesz a normálegyenlet mátrixa a következő alfejezetben.</details>

A NumPy * operátora elemenkénti szorzást végez, míg a @ mátrixszorzást. A vektor- és mátrixdimenziókat ellenőrizzük, mert a nem szándékolt broadcasting numerikusan lefuthat úgy is, hogy hibás eredményt ad.

10.2.9 Rövid összefoglaló

A mátrixszorzás a lineáris predikció alapművelete: az $n \times p$ design mátrix minden sorát ugyanazzal a $p$ hosszú súlyvektorral kombinálja skaláris szorzatként, így $\hat{\mathbf y}=\mathbf X\mathbf w$ egyszerre adja meg minden megfigyelés predikcióját. A design mátrix sora egy megfigyelés, oszlopa egy jellemző; az interceptet csupa $1$-es oszlop képviseli. A transzponálás sor és oszlop felcserélése, a bázisok a mátrix oszlopvektorainak lineáris kombinációi. A NumPy @ operátora mátrixszorzás, a * elemenkénti szorzás; a kettő nem felcserélhető. A következő alfejezetben ezt a műveletet használjuk a vetítéshez és a legkisebb négyzetes becsléshez, ahol $\mathbf X^T\mathbf X$ és $\mathbf X^T\mathbf y$ jelenik meg.