Lidsky řečeno
Lineární algebra zní hrozivě, ale z velké části je to účtování v obchodě. Košík je řada čísel: kolik čeho kupuješ. Ceník je taky řada čísel. Účtenka vznikne tak, že je spáruješ, vynásobíš a sečteš. Když máš víc obchodů a víc košíků, máš tabulky, a počítá se pořád totéž. Neuronová síť dělá v jádru právě tohle, jen s miliony čísel.
Vektor: čísla, která patří k sobě
Vektor je uspořádaná řada čísel. V NumPy je to obyčejné jednorozměrné pole. Každá pozice něco znamená: tady počet rohlíků, kusů mléka a jablek.
Dva vektory můžeš sečíst po složkách a můžeš je vynásobit jedním číslem. Tomu se odborně říká skalár, jde prostě o obyčejné číslo.
Vektor si lze představit i jako šipku z počátku souřadnic. Vektor [3, 4] vede o 3 doprava a o 4 nahoru. Její délku spočítá Pythagorova věta a v NumPy se jmenuje norma.
import numpy as np
pondeli = np.array([4, 1, 3])
utery = np.array([0, 2, 5])
print(pondeli + utery) # nákup za oba dny
print(2 * pondeli) # dvojnásobný nákup
sipka = np.array([3, 4])
print(np.linalg.norm(sipka))
print(np.sqrt(np.sum(sipka ** 2)))
[4 3 8] [8 2 6] 5.0 5.0
Skalární součin
Skalární součin (dot product) vezme dva stejně dlouhé vektory, vynásobí čísla na stejných pozicích a všechno sečte. Výsledek je jedno číslo. V Pythonu se píše operátorem @.
košík 4 1 3
ceny 5 20 8
---------------
20 + 20 + 24 = 64Skalární součin má i druhý, geometrický význam. Prozradí, jak moc dva vektory míří stejným směrem. Když ho vydělíš délkami obou, dostaneš kosinovou podobnost: 1 znamená stejný směr, 0 kolmo, tedy „nic společného“, a -1 opačný směr. Takhle systémy porovnávají vkus lidí i význam textů.
import numpy as np
kosik = np.array([4, 1, 3])
ceny = np.array([5, 20, 8])
print(kosik @ ceny)
def podobnost(a, b):
return (a @ b) / (np.linalg.norm(a) * np.linalg.norm(b))
# hodnocení žánrů: akce, komedie, drama, sci-fi
anna = np.array([5, 1, 0, 4])
ben = np.array([4, 0, 1, 5])
cyril = np.array([0, 5, 4, 0])
print(round(float(podobnost(anna, ben)), 3))
print(round(float(podobnost(anna, cyril)), 3))
64 0.952 0.12
Anna a Ben mají podobný vkus, Anna a Cyril skoro žádný společný.
Kosinová podobnost
Napiš funkci kosinova(a, b), která vrátí kosinovou podobnost dvou vektorů.
import numpy as np
def kosinova(a, b):
# doplň
pass
Matice: tabulka, která násobí
Matice je tabulka čísel, v NumPy dvourozměrné pole. Vezmi tři obchody a v každém řádku jejich ceník. Vynásobení matice vektorem znamená: udělej skalární součin každého řádku s vektorem. Dostaneš cenu košíku v každém obchodě.
Když máš košíků víc, napíšeš je jako sloupce druhé matice a počítá se každý řádek s každým sloupcem. Košíky máš ale obvykle po řádcích, takže je napřed transponuješ, tedy překlopíš řádky na sloupce přes .T.
ceny @ košíky.T = výsledek
3 x 3 3 x 2 3 x 2Vnitřní čísla tvarů (tady 3 a 3) se musí rovnat, vnější (3 a 2) udávají tvar výsledku.
import numpy as np
# řádky = obchody, sloupce = rohlík, mléko, jablko
ceny = np.array([
[5, 20, 8],
[4, 24, 9],
[6, 18, 7],
])
kosik = np.array([4, 1, 3])
print(ceny @ kosik)
# řádky = zákazníci
kosiky = np.array([
[4, 1, 3],
[0, 2, 5],
])
print(kosiky.T.shape)
print(ceny @ kosiky.T) # řádek = obchod, sloupec = zákazník
[64 67 63] (3, 2) [[64 80] [67 93] [63 71]]
Nejlevnější obchod pro prvního zákazníka je ten s nejmenším číslem v prvním sloupci.
Matice A má tvar (4, 2) a B tvar (2, 3). Jaký tvar má A @ B?
Vnitřní čísla jsou 2 a 2, takže násobení jde. Výsledek má vnější čísla, 4 a 3. Naopak B @ A by nešlo, tam by se potkaly 3 a 4.
Účet ve všech obchodech
ceny má v řádcích obchody a ve sloupcích zboží. kosiky má v řádcích zákazníky a ve stejných sloupcích zboží. Napiš funkci ucty(ceny, kosiky), která vrátí matici, kde řádek je obchod a sloupec zákazník.
import numpy as np
def ucty(ceny, kosiky):
# doplň
pass
Matice jako pohyb
Matici lze číst ještě jinak: jako transformaci, předpis, který body někam přesune. Matice 2 × 2 umí otáčet, natahovat a zkosovat. Tak se počítá grafika ve hrách i úprava dat v neuronové síti.
Body napíšeme jako sloupce. Matice [[0, -1], [1, 0]] otáčí o 90° proti směru hodinových ručiček a [[2, 0], [0, 3]] natahuje dvakrát do šířky a třikrát do výšky. Spojení dvou kroků je jejich součin a čte se zprava: to, co stojí nejblíž bodům, se provede první.
import numpy as np
# rohy čtverce, každý bod je jeden sloupec
ctverec = np.array([
[0, 1, 1, 0],
[0, 0, 1, 1],
])
otoceni = np.array([[0, -1], [1, 0]])
natazeni = np.array([[2, 0], [0, 3]])
print((otoceni @ ctverec).T)
print((natazeni @ ctverec).T)
print((natazeni @ otoceni @ ctverec).T) # nejdřív otoč, pak natáhni
print((otoceni @ natazeni @ ctverec).T) # nejdřív natáhni, pak otoč
[[ 0 0] [ 0 1] [-1 1] [-1 0]] [[0 0] [2 0] [2 3] [0 3]] [[ 0 0] [ 0 3] [-2 3] [-2 0]] [[ 0 0] [ 0 2] [-3 2] [-3 0]]
.T na konci je jen kvůli čitelnosti, aby byl každý bod na vlastním řádku. Poslední dva výsledky se liší, což je pořadí násobení v praxi.
Co udělá B @ A @ v s vektorem v?
Matice nejblíž vektoru působí první. Je to stejné jako u funkcí, kde se v f(g(x)) nejdřív spočítá g.
Soustavy rovnic a proložení přímky
Anna koupila 2 rohlíky a 1 mléko za 30 Kč. Ben 1 rohlík a 3 mléka za 65 Kč. Kolik stojí co? To je soustava rovnic a dá se zapsat jako A @ x = b, kde A jsou nákupy, b účty a x neznámé ceny.
Inverzní matice je matice, která vrátí účinek původní zpátky. Vynásobením vznikne jednotková matice (jedničky na diagonále), která nic nemění. K výpočtu x se ale používá np.linalg.solve, je přesnější a rychlejší.
import numpy as np
A = np.array([[2.0, 1.0], [1.0, 3.0]])
b = np.array([30.0, 65.0])
x = np.linalg.solve(A, b)
print(np.round(x, 6) + 0.0)
print(np.round(A @ x, 6) + 0.0) # zkouška
print(np.round(np.linalg.inv(A) @ A, 6) + 0.0) # jednotková matice
[ 5. 20.] [30. 65.] [[1. 0.] [0. 1.]]
Rohlík stojí 5 Kč a mléko 20 Kč.
V reálných datech bývá rovnic víc než neznámých a přesně nesedí žádné řešení. Měření jsou zatížená šumem. Hledá se proto takové x, u kterého je součet čtverců chyb nejmenší. Říká se tomu metoda nejmenších čtverců a je to základ lineární regrese, ke které se v modulu o strojovém učení vrátíš.
Chceme přímku y = a * x + b. Do matice dáme sloupec s x a sloupec jedniček pro posun b.
import numpy as np
x = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
y = np.array([1.1, 2.9, 5.2, 6.8, 9.0])
X = np.column_stack([x, np.ones_like(x)])
print(X.shape)
koeficienty, *_ = np.linalg.lstsq(X, y, rcond=None)
print(np.round(koeficienty, 3))
predpoved = X @ koeficienty
print(np.round(predpoved, 2))
(5, 2) [1.97 1.06] [1.06 3.03 5. 6.97 8.94]
Pět měření se tak shrnulo do dvou čísel: sklon je přibližně 2 a přímka začíná přibližně na 1.
Proložení přímky
Napiš funkci primka(x, y), která metodou nejmenších čtverců najde přímku y = a * x + b a vrátí dvojici (a, b).
import numpy as np
def primka(x, y):
# doplň
pass
Pod kapotou · numerika: co se v učebnicích nedočteš
inv(A) @ b nepiš. solve provede LU rozklad s částečnou pivotací (LAPACK gesv), je levnější a numericky stabilnější. Inverzi skutečně potřebuješ zřídka. Na opakované řešení se stejnou maticí si rozklad ulož přes scipy.linalg.lu_factor, u symetrických pozitivně definitních matic použij Choleskyho rozklad.
Determinant není dobrý test singularity, protože závisí na měřítku. Rozhoduje číslo podmíněnosti: říká, kolikrát se může zesílit relativní chyba vstupu. Tady změna pravé strany v páté platné cifře převrátí celý výsledek.
import numpy as np
A = np.array([[1.0, 1.0], [1.0, 1.0001]])
print(np.round(np.linalg.solve(A, np.array([2.0, 2.0001])), 3) + 0.0)
print(np.round(np.linalg.solve(A, np.array([2.0, 2.0002])), 3) + 0.0)
print(round(float(np.linalg.cond(A)), -3))
[1. 1.] [0. 2.] 40000.0
Proto se regrese nepočítá přes normální rovnice inv(X.T @ X) @ X.T @ y: X.T @ X má podmíněnost na druhou. lstsq používá SVD (LAPACK gelsd), a zvládne tedy i sloupce, které jsou na sobě závislé. Vrací také singulární hodnoty a hodnost, které prozradí multikolinearitu. Stejný rozklad stojí za matrix_rank, pinv i PCA.
U symetrických matic volej eigh, ne eig: vrací reálná vlastní čísla seřazená vzestupně a je přesnější. Znaménka vlastních a singulárních vektorů nejsou určena jednoznačně a mezi verzemi LAPACK se mohou lišit, takže je netestuj přímým porovnáním.
@ u vícerozměrných polí násobí po dávkách (poslední dvě osy jsou matice, zbytek se broadcastuje), np.dot se tam chová jinak. Násobení jde přes BLAS, který si sám spouští vlákna. Když k tomu přidáš multiprocessing, vznikne přetížení jader a výkon spadne. Řeší to proměnné OPENBLAS_NUM_THREADS a OMP_NUM_THREADS nebo knihovna threadpoolctl.
Vyzkoušej si: Vektory na dosah
Přetahuj dva vektory a sleduj součet, násobek, skalární součin a úhel.
Vyzkoušej si: Matice jako přetvoření
Posuvníky mění prvky matice 2×2. Sleduj, jak se zkroutí mřížka, kam se posunou jednotkové vektory a kolik je determinant.