0 dní v řadě · 0 bodů

Práce s daty · 30 min

Lineární algebra lidsky

Vektory, skalární součin a matice vysvětlené na nákupním košíku. Pak otočíš body, vyřešíš soustavu rovnic a proložíš data přímkou.

Hloubka
Úkoly
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)))
Výstup
[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 @.

text
košík    4      1      3
ceny     5     20      8
         ---------------
        20  +  20  +  24  =  64

Skalá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))
Výstup
64
0.952
0.12

Anna a Ben mají podobný vkus, Anna a Cyril skoro žádný společný.

Úkol

Kosinová podobnost

Napiš funkci kosinova(a, b), která vrátí kosinovou podobnost dvou vektorů.

import numpy as np

def kosinova(a, b):
    # doplň
    pass
Výstup

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.

text
ceny    @   košíky.T   =   výsledek
3 x 3       3 x 2          3 x 2

Vnitř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
Výstup
[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.

Kvíz

Matice A má tvar (4, 2) a B tvar (2, 3). Jaký tvar má A @ B?

Úkol

Úč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
Výstup

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č
Výstup
[[ 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.

Kvíz

Co udělá B @ A @ v s vektorem v?

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
Výstup
[ 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))
Výstup
(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.

Úkol

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
Výstup
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))
Výstup
[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.