Lidsky řečeno
Lepíš tapetu se vzorem. Nemáš jeden obří kus na celou zeď, máš malý dílek a ten se opakuje, dokud zeď nepokryje. Broadcasting dělá totéž s čísly: kratší pole se v duchu zopakuje tak, aby sedělo na větší. Jenže jako u tapety platí, že dílek musí na zeď pasovat.
Tvar se dá změnit
Než začneš pole kombinovat, potřebuješ umět měnit jejich tvar. reshape přeskládá stejná čísla do jiných rozměrů. Počet prvků se změnit nesmí, takže 6 čísel se vejde do 2 × 3, ale ne do 4 × 2. Místo jednoho rozměru můžeš napsat -1 a NumPy si ho dopočítá.
import numpy as np
a = np.arange(1, 7)
print(a.shape)
b = a.reshape(2, 3)
print(b)
print(a.reshape(3, -1))
print(b.ravel()) # zpátky do jedné řady
(6,) [[1 2 3] [4 5 6]] [[1 2] [3 4] [5 6]] [1 2 3 4 5 6]
Pozor na tři tvary, které vypadají skoro stejně a znamenají něco jiného:
(3,) obyčejná řada tří čísel, nemá řádky ani sloupce
(3, 1) tabulka: 3 řádky, 1 sloupec
(1, 3) tabulka: 1 řádek, 3 sloupceNový rozměr o velikosti 1 přidáš přes np.newaxis. Je to jen jiné jméno pro None, takže se často píše rovnou v[:, None].
import numpy as np
v = np.array([10, 20, 30])
sloupec = v[:, np.newaxis]
radek = v[np.newaxis, :]
print(v.shape, sloupec.shape, radek.shape)
print(sloupec)
print(radek)
(3,) (3, 1) (1, 3) [[10] [20] [30]] [[10 20 30]]
Pravidla broadcastingu
Broadcasting je způsob, jakým NumPy sladí dvě pole různého tvaru při výpočtu. Pravidla jsou jen tři:
1. Tvary zarovnej doprava.
2. Kde jednomu poli rozměr chybí, doplň zleva jedničku.
3. V každém sloupci musí být čísla stejná, nebo musí být jedno z nich 1.
Jednička se roztáhne na velikost toho druhého.Takhle to vypadá na příkladech:
tabulka 2 x 3
řada 3 -> 1 x 3 -> výsledek 2 x 3 ok
tabulka 2 x 3
sloupec 2 x 1 -> výsledek 2 x 3 ok
řádek 1 x 4
sloupec 3 x 1 -> výsledek 3 x 4 ok
tabulka 2 x 3
řada 2 -> 1 x 2 -> 3 proti 2 CHYBAČíslo samotné má prázdný tvar, takže pasuje na cokoli. Proto funguje pole * 2.
import numpy as np
m = np.array([
[1, 2, 3],
[4, 5, 6],
])
print(m + 100) # jedno číslo ke všemu
print(m + np.array([10, 20, 30])) # každý řádek dostane stejnou trojici
print(m + np.array([[100], [200]])) # každý sloupec dostane stejnou dvojici
[[101 102 103] [104 105 106]] [[11 22 33] [14 25 36]] [[101 102 103] [204 205 206]]
Když tvary nesedí, NumPy to odmítne. Chyba je tu tvůj přítel, protože ti řekne přesně oba tvary. Tabulka má 2 řádky a ty chceš ke každému přičíst jiné číslo. Řada délky 2 se ale zarovná doprava, tedy na sloupce.
import numpy as np
m = np.array([
[1, 2, 3],
[4, 5, 6],
])
print(m + np.array([100, 200]))
Oprava je přidat rozměr: m + np.array([100, 200])[:, None]. Z tvaru (2,) se stane (2, 1) a všechno sedí.
Jaký tvar má výsledek operace mezi poli tvaru (3, 1) a (1, 5)?
V každém rozměru je jedna ze dvou hodnot jednička, takže se roztáhne. Z 3 a 1 vznikne 3, z 1 a 5 vznikne 5.
Která kombinace tvarů nejde spojit?
Tvary se zarovnávají zprava, takže (4,) se porovnává se sloupci: 3 proti 4. Fungovalo by to až po úpravě na (4, 1).
Užitečné vzory
Největší přínos broadcastingu je, že běžné úpravy dat zvládneš na jednom řádku. Typický krok před strojovým učením je standardizace: od každého sloupce odečteš jeho průměr a vydělíš ho jeho směrodatnou odchylkou, tedy číslem, které říká, jak moc jsou hodnoty rozptýlené. Výška v centimetrech a váha v kilogramech se tak dostanou na stejné měřítko.
Průměr přes axis=0 má tvar (2,) a tabulka (3, 2). Řada se zarovná na sloupce, takže to vyjde samo.
import numpy as np
# řádky = lidé, sloupce = výška, váha
X = np.array([
[170.0, 60.0],
[180.0, 80.0],
[190.0, 100.0],
])
prumer = X.mean(axis=0)
odchylka = X.std(axis=0)
Z = (X - prumer) / odchylka
print(prumer, X.shape, prumer.shape)
print(np.round(Z, 3) + 0.0)
print(np.round(Z.mean(axis=0), 6) + 0.0)
print(np.round(Z.std(axis=0), 6) + 0.0)
[180. 80.] (3, 2) (2,) [[-1.225 -1.225] [ 0. 0. ] [ 1.225 1.225]] [0. 0.] [1. 1.]
(+ 0.0 je tu jen kosmetika, změní případnou zápornou nulu -0. na obyčejnou.)
U řádků zarovnání zprava nepomůže, protože součet přes axis=1 má tvar (2,) a narazil by na sloupce. Řešením je keepdims=True, které zkolabovanou osu nechá s velikostí 1. Tvar (2, 1) už pasuje.
import numpy as np
# řádky = dny, sloupce = tři druhy zboží
prodej = np.array([
[30.0, 50.0, 20.0],
[10.0, 10.0, 20.0],
])
soucty = prodej.sum(axis=1, keepdims=True)
print(soucty.shape)
print(prodej / soucty)
(2, 1) [[0.3 0.5 0.2 ] [0.25 0.25 0.5 ]]
Spojením (n, 1) a (1, m) získáš tabulku všech kombinací. Bez jediného cyklu tak vznikne násobilka.
import numpy as np
a = np.arange(1, 4)
b = np.arange(1, 6)
print(a[:, None] * b[None, :])
[[ 1 2 3 4 5] [ 2 4 6 8 10] [ 3 6 9 12 15]]
Stejný trik spočítá vzdálenost každého bodu od každého, což potřebuje třeba shlukování nebo hledání nejbližších sousedů. Body mají tvar (3, 2). Po přidání rozměrů se odečítá (3, 1, 2) a (1, 3, 2) a vznikne (3, 3, 2): pro každou dvojici bodů rozdíl v obou souřadnicích.
import numpy as np
body = np.array([
[0.0, 0.0],
[3.0, 4.0],
[6.0, 8.0],
])
rozdily = body[:, None, :] - body[None, :, :]
vzdalenosti = np.sqrt((rozdily ** 2).sum(axis=-1))
print(rozdily.shape)
print(vzdalenosti)
(3, 3, 2) [[ 0. 5. 10.] [ 5. 0. 5.] [10. 5. 0.]]
axis=-1 znamená poslední osu. Řádek i, sloupec j výsledku je vzdálenost mezi body i a j.
Podíly v řádcích
Napiš funkci podily(m), která každý řádek tabulky vydělí jeho součtem. Součet každého řádku výsledku tak bude 1 a tvar se nezmění.
import numpy as np
def podily(m):
# doplň
pass
Škálování do intervalu 0 až 1
Napiš funkci min_max(X). V každém sloupci tabulky odečte jeho minimum a vydělí rozdílem maxima a minima toho sloupce. Nejmenší hodnota ve sloupci se tak změní na 0 a největší na 1.
import numpy as np
def min_max(X):
# doplň
pass
Tichá past: (n,) proti (n, 1)
Chyba o tvarech je ten lepší případ. Horší je, když tvary náhodou pasují a výsledek je nesmysl. Klasika ze strojového učení: správné hodnoty mají tvar (3,), předpovědi modelu (3, 1). Předpovědi jsou dokonalé, chyba by měla být nula.
import numpy as np
spravne = np.array([1.0, 2.0, 3.0])
predpoved = np.array([[1.0], [2.0], [3.0]])
rozdil = spravne - predpoved
print(rozdil.shape)
print(rozdil)
print(np.mean(rozdil ** 2))
rozdil = spravne - predpoved.ravel()
print(rozdil.shape)
print(np.mean(rozdil ** 2))
(3, 3) [[ 0. 1. 2.] [-1. 0. 1.] [-2. -1. 0.]] 1.3333333333333333 (3,) 0.0
Místo tří rozdílů vzniklo devět, každý se všemi. Program nespadl a vypsal číslo, které vypadá věrohodně.
Nejbližší střed
Tohle je jádro algoritmu k-means. Napiš funkci nejblizsi_stred(body, stredy). body mají tvar (n, 2), stredy tvar (k, 2). Funkce vrátí pole tvaru (n,), kde je pro každý bod index jeho nejbližšího středu. Obejdi se bez cyklu.
import numpy as np
def nejblizsi_stred(body, stredy):
# doplň
pass
Pod kapotou · broadcasting bez kopírování a jeho cena
Roztažení se fyzicky neděje. Vnitřní smyčka prostě u rozměru velikosti 1 neposouvá ukazatel, takže stejná hodnota se čte znovu. Totéž uvidíš přímo v np.broadcast_to: nulový krok (strides) a pole jen pro čtení, protože zápis do jedné buňky by změnil všechny.
import numpy as np
radek = np.array([1.0, 2.0, 3.0])
velke = np.broadcast_to(radek, (1000, 3))
print(velke.shape)
print(velke.strides)
print(velke.flags.writeable)
print(np.shares_memory(velke, radek))
print(np.broadcast_shapes((3, 1), (1, 5), (5,)))
(1000, 3) (0, 8) False True (3, 5)
Vstupy se tedy nekopírují, ale výsledek se alokuje celý. Matice vzdáleností pro 100 000 bodů se dvěma souřadnicemi má v mezikroku 10^10 × 2 hodnot po 8 bajtech, tedy 160 GB. Elegantní jednořádek pak končí zabitím procesu kvůli paměti. scipy.spatial.distance.cdist ušetří mezikrok, ale samotný výsledek má pořád 80 GB. Pomůže zpracování po dávkách, nebo KD-strom z scipy.spatial, když chceš jen nejbližší sousedy.
Operace na místě neumí levou stranu zvětšit: a += b projde, jen když výsledek má tvar a. Stejně tak hlídá typ, takže pole_int += 0.5 skončí UFuncTypeError, zatímco pole_int = pole_int + 0.5 vytvoří nové pole float64. A reshape obvykle vrací pohled, takže zápis do něj mění původní data.
Vyzkoušej si: Kdy si tvary rozumí
Zvol dva tvary polí. Uvidíš zarovnání rozměrů, zda jsou slučitelné, tvar výsledku a které buňky se opakují.