Python Jiří Znamenáček NumPy – výřezy polí, optimalizace 2017-04-24

Výřezy (vícerozměrných) polí (tedy objektů typu ndarray) patří – po jejich zavedení – ke zcela základním a zdaleka nejdůležitějším operacím nad poli v NumPy. V podstatě se dá skoro bez nadsázky říci, že bez správných výběrů prvků pole nemáte šanci pomocí Numpy napsat optimální kód.

Všechno navíc komplikuje, že je třeba si u každé metody uvědomit, zda vrací pouze jiný pohled na originální pole (takže každá změna v tomto pohledu se projeví i v originálu), nebo zda vrátí kopii příslušné části dat. Bohužel konkrétní chování se může lišit i v rámci jedné jediné metody v závislosti na vstupních datech (typicky jejich velikosti a tvaru) a pomoci s rozhodováním vám může pouze detailní znalost interní reprezentace dat a metod nad nimi operujících.

Nicméně pár užitečných pravidel se vysledovat a naučit dá. Pak už zbývá na ně „jen“ ve vlastním kódu pamatovat…

PS: V příkladech budu používat modul numpy naimportovaný podle zvyku jako: import numpy as np

Nepřekvapivě se z polí dají vybírat podpole především velmi podobným způsobem jako u pythoního seznamu. Pouze máme k dispozici více os, ve kterých můžeme operovat, což situaci poněkud komplikuje. Ale zároveň činí zábavnější ^_~

Celé je to umožněné rozšířenou výřezovou notací, která je v Python'u víceméně jen a právě kvůli NumPy.

Tyto „klasické“ výřezy se zvláště pro 1D a 2D pole chápou snadno. Nejdůležitější věcí k zapamatování jest:

Klasické výřezy vyrábějí pouze jiné pohledy na data.

Tedy přiřadíte-li něco nového výřezu, projeví se to i v původním poli (a naopak)!

PS: Jiným způsobem by se klasické výřezy daly charakterizovat jako ty výřezy, k jejichž provedení stačí použití kroků (tedy strides).

1D je úplně stejné jako v klasickém Python'u, ve 2D pak představuje první index řádku a druhý sloupec:

>>> a = np.arange(1, 21).reshape(5, 4) >>> a array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12], [13, 14, 15, 16], [17, 18, 19, 20]]) >>> a[1] array([5, 6, 7, 8]) >>> a[1, 2:] array([7, 8]) >>> a[1, 2] 7

Přiřazení do výřezu pak funguje také tak, jak by člověk intuituvně očekával:

>>> a = np.zeros((3, 4), dtype=int) >>> a array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]) >>> a[1] = 1 >>> a array([[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]]) >>> a[2, 2:] = 2 >>> a array([[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 2, 2]]) >>> a[0, 1] = 3 >>> a array([[0, 3, 0, 0], [1, 1, 1, 1], [0, 0, 2, 2]])

Python (opět právě kvůli Numpy) podporuje mimo jiné i tzv. výpustkovou notaci, tedy použití ... na místě indexů do pole. V Numpy se takto označují sekvence os, které není třeba blíže určovat:

>>> a = np.full((3, 4), 7) >>> a array([[7, 7, 7, 7], [7, 7, 7, 7], [7, 7, 7, 7]]) >>> a[...] = 3 >>> a array([[3, 3, 3, 3], [3, 3, 3, 3], [3, 3, 3, 3]])

Výřezy tedy představují jiné pohledy na stejná data, pouze podle zavedení buď a nebo s:

První dvě situace si můžete snadno ověřit pomocí adresy počátku dat, která ovšem bude pro třetí trochu posunutá. Vhodnější je tak rovnou použít řetězec základních polí pomocí atributu base:

>>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> a array([[1, 2, 3], [4, 5, 6]]) >>> a.__array_interface__['data'][0] 13087104 >>> a.base None >>> a.shape (2, 3) >>> a.strides (24, 8) >>> b = a.T >>> b array([[1, 4], [2, 5], [3, 6]]) >>> b.__array_interface__['data'][0] 13087104 >>> b.base is a True >>> b.shape (3, 2) >>> b.strides (8, 24) >>> c = a[..., 1:] >>> c array([[2, 3], [5, 6]]) >>> c.__array_interface__['data'][0] 13087112 >>> c.base is a True >>> c.shape (2, 2) >>> c.strides (24, 8)

Na první pohled možná trochu překvapivě umožňuje Numpy indexovat prvky polí dokonce i pomocí jiných numpyovských polí! (Čemuž se většinou říká právě fancy indexing.) Nicméně přitom narozdíl od výřezů dochází ke kopírování dat:

>>> a = np.array([2, 4, 3, 5, 6, 7]) # A) výřez (jiný pohled na data) >>> b = a[::2] >>> b array([2, 3, 6]) >>> b.base is a True # B1) seznam indexů (kopie dat) >>> c = a[np.arange(0, 6, 2)] >>> c array([2, 3, 6]) >>> c.base is a False # PS: >>> np.arange(0, 6, 2) array([0, 2, 4]) # B2) seznam indexů jinak (kopie dat) >>> d = a[a % 2] >>> d array([2, 2, 4, 4, 2, 4]) >>> d.base is a False # PS: >>> a % 2 array([0, 0, 1, 1, 0, 1]) # C) pravdivostní maska (kopie dat) >>> e = a[a % 2 == 1] >>> e array([3, 5, 7]) >>> e.base is a False # PS: >>> a % 2 == 1 array([False, False, True, True, False, True], dtype=bool)

Tento přístup je sice velmi mocný (spousta operací nad poli se pomocí něj dá zapsat velmi kompaktním a pochopitelným způsobem), nicméně je také velmi pomalý (především právě kvůli tomu kopírování dat). Proto, je-li to možné, vyplatí se místo něj použít dedikované metody (ovšem typicky pouze pro výběr nad jednou osou).

Metoda take() je – pro výběr v jedné ose – rychlejší variantou k indexování pomocí pole indexů do pole:

>>> a = np.array([2, 3, 4, 5, 6, 7]) # výběrové pole >>> idx = np.arange(0, 6, 2) >>> idx array([0, 2, 4]) # „fancy indexing“ >>> b1 = a[idx] >>> b1 array([2, 4, 6]) # dedikovaná metoda >>> b2 = a.take(idx, axis=0) >>> b2 array([2, 4, 6])

Metoda compress() je – pro výběr v jedné ose – rychlejší variantou k indexování pomocí pravdivostního pole:

>>> a = np.array([2, 3, 4, 5, 6, 7]) # výběrové pole >>> idx = (a % 2 == 1) >>> idx array([False, True, False, True, False, True], dtype=bool) # „fancy indexing“ >>> b1 = a[idx] >>> b1 array([3, 5, 7]) # dedikovaná metoda >>> b2 = a.compress(idx, axis=0) >>> b2 array([3, 5, 7])

Abyste mohli výběry prvků z pole efektivně používat, musíte samozřejmě vědět, jak ono pole vypadá. A pole v Numpy dokáže být docela proměnlivá mrška.

A opět – stejně jako u výřezů je důležité vědět, kdy změna tvaru pole vyrobí jenom jiný pohled na data a kdy je naopak zkopíruje úplně někam jinam.

Zdroj: Scipy Lectures – Array shape manipulation

Pomineme-li iterátor přes vektorový pohled flat a vždy-kopírující metodu flatten(), používá se pro převod vícerozměrných polí na pole jednorozměrná především metoda ravel():

>>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> a array([[1, 2, 3], [4, 5, 6]]) >>> a.ravel() array([1, 2, 3, 4, 5, 6]) >>> a.T array([[1, 4], [2, 5], [3, 6]]) >>> a.T.ravel() array([1, 4, 2, 5, 3, 6])

Její hlavní výhodou je, že – je-li to možné – neprovádí kopie dat, takže je výrazně rychlejší než ostatní způsoby:

>>> a.ravel().base is a True >>> a.T.ravel().base is a False

Metoda reshape() umí měnit tvary polí, pokud jsou navzájem „kompatibilní“ (neboli dá-li se z jednoho přes celkový počet prvků a rozměry dopočítat na druhý):

>>> a = np.arange(1, 13) >>> a array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) >>> a.reshape(3, 4) array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) >>> a.reshape(3, 4).reshape(2, 6) array([[ 1, 2, 3, 4, 5, 6], [ 7, 8, 9, 10, 11, 12]])

Přitom dokud nenabouráte (typicky transpozicí) možnost pouhé změny pohledu na prvky, nedostanete kopii:

>>> a.reshape(3, 4).reshape(2, 6).base is a True >>> a.reshape(3, 4).T.reshape(2, 6).base array([[ 1, 5, 9], [ 2, 6, 10], [ 3, 7, 11], [ 4, 8, 12]]) >>> a.reshape(3, 4).T.reshape(2, 6).base is a False

Na místě indexů je možno použít i speciální numpyovský operátor numpy.newaxis, který automagicky přidá ke vstupnímu poli další dimenzi na uvedeném místě:

# originál >>> a = np.array([1, 2, 3]) >>> a array([1, 2, 3]) >>> a.shape (3,) # přidaná dimenze >>> b = a[np.newaxis, :] >>> b array([[1, 2, 3]]) >>> b.shape (1, 3) # totéž s pomocí výpustky >>> c = a[np.newaxis, ...] >>> c array([[1, 2, 3]]) >>> c.shape (1, 3)

Tohle si zaslouží i složitější příklad:

# originál >>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> a array([[1, 2, 3], [4, 5, 6]]) >>> a.shape (2, 3) # přidání „uprostřed“ >>> d = a[:, np.newaxis, :] >>> d array([[[1, 2, 3]], [[4, 5, 6]]]) >>> d.shape (2, 1, 3)

Asi nejčastější použití nalezne tento operátor v případech, kdy potřebujeme zbroadcastingovat pole nekompatibilního tvaru:

>>> a = np.array([0, 10, 20, 30]) >>> b = np.array([0, 1, 2]) >>> a + b Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: operands could not be broadcast together with shapes (4,) (3,) >>> am = a[:,np.newaxis] >>> am.shape (4, 1) >>> am array([[ 0], [10], [20], [30]]) >>> am + b array([[ 0, 1, 2], [10, 11, 12], [20, 21, 22], [30, 31, 32]])

V jednodušších případech vrací metoda transpose() a atribut T stejný výsledek, a to nový (transponovaný) pohled na originální pole:

>>> a = np.arange(1, 7) >>> a array([1, 2, 3, 4, 5, 6]) >>> a.transpose() array([1, 2, 3, 4, 5, 6]) >>> a.T array([1, 2, 3, 4, 5, 6]) >>> a.transpose() == a.T array([ True, True, True, True, True, True], dtype=bool) >>> a.transpose() is a.T False >>> a.transpose().base is a.T.base is a True

PS: Nutno připomenout, že pro cokoliv složitějšího než 1D už s největší pravděpodobností nepůjde o jiný pohled na táž data, nýbrž o jejich kopii do nového paměťového umístění!

Metoda transpose() je ovšem univerzálnější, protože ve vícedimenzionálních případech si můžete vybrat, podle kterých os k transpozici dojde (musíte ji pak ale volat na globální úrovni*):

# originál >>> a = np.arange(1, 13).reshape(2, 3, 2) >>> a array([[[ 1, 2], [ 3, 4], [ 5, 6]], [[ 7, 8], [ 9, 10], [11, 12]]]) >>> a.shape (2, 3, 2) # atribut „T“ >>> a.T array([[[ 1, 7], [ 3, 9], [ 5, 11]], [[ 2, 8], [ 4, 10], [ 6, 12]]]) >>> a.T.shape (2, 3, 2) # komplexnější použití metody „transpose()“ >>> np.transpose(a, axes=[2, 0, 1]) array([[[ 1, 3, 5], [ 7, 9, 11]], [[ 2, 4, 6], [ 8, 10, 12]]]) >>> np.transpose(a, axes=[2, 0, 1]).shape (2, 2, 3) * Ano – v duchu „dobré“ tradice Numpy nemají transpose() na poli a ve jmenném prostoru balíčku numpy stejné parametry…

Tyto dvě doplňkové metody k univerzální transpose() operují nad zadanou podmnožinou os, takže ve vícedimenzionálních případech by mohly najít své uplatnění.

Metoda swapaxes() prohodí dvě zadané osy:

>>> a = np.arange(1, 13).reshape(2, 3, 2) >>> a.shape (2, 3, 2) >>> a.swapaxes(0, 1) array([[[ 1, 2], [ 7, 8]], [[ 3, 4], [ 9, 10]], [[ 5, 6], [11, 12]]]) >>> a.swapaxes(0, 1).shape (3, 2, 2)

Metoda moveaxes() dělá v podstatě totéž, ale kromě dvou os dokáže na vstupu přebírat i dva seznamy os:

>>> a = np.arange(1, 13).reshape(2, 3, 2) >>> a.shape (2, 3, 2) >>> np.moveaxis(a, 0, 1) array([[[ 1, 2], [ 7, 8]], [[ 3, 4], [ 9, 10]], [[ 5, 6], [11, 12]]]) >>> np.moveaxis(a, 0, 1).shape (3, 2, 2) >>> np.moveaxis(a, [2, 0], [0, 1]) array([[[ 1, 3, 5], [ 7, 9, 11]], [[ 2, 4, 6], [ 8, 10, 12]]]) >>> np.moveaxis(a, [2, 0], [0, 1]).shape (2, 2, 3)

Další schizofrenní metoda, která se (někdy) chová jinak na poli a jinak v numpyovském jmenném prostoru – resize(). Jejím hlavním úkolem je změnit tvar a počet prvků pole. Ať už směrem k vyšším nebo menším číslům.

Jako metoda pole se resize() pokusí změnit jeho velikost v místě, to znamená bez kopírování dat (pokud to půjde), přičemž při zvětšování doplní do nových míst nuly:

>>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> a.resize((2, 4)) >>> a array([[1, 2, 3, 4], [5, 6, 0, 0]])

Nicméně jakýkoliv odkaz na toto pole – především pak jakýkoliv jiný pohled na něj (pod svým vlastním jménem) – tomu zabrání, pokud uvedené chování nevypnete nastavením parametru refcheck=False.

A bohužel odkazy na vaše pole se často vyrábí na pozadí i bez vašeho zásahu, takže třeba příklad zeshora – ač vyloženě dokumentační – mi bez tohoto parametru nefungoval ani na čistě puštěném interpretru…

Narozdíl od předchozí metody resize() v numpyovském jmenném prostoru data téměř vždy kopíruje, ale především při zvětšování doplňuje kopii původních dat:

>>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> np.resize(a, (2, 4)) array([[1, 2, 3, 4], [5, 6, 1, 2]]) Mimochodem zrovna v tomhle případě ke kopii nedošlo – zvětšené pole trůní na stejné adrese jako originální.