{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "[NumPy](http://www.numpy.org) je základní Python knihovna pro práci s numerickými daty, konkrétně s 1- až n-rozměrnými maticemi. Implementace (pro CPython) je z velké části napsána v C a Fortranu a používá BLAS knihovny. Numpy tak umožňuje pracovat s numerickými daty ve stylu Python kontejnerů (existují samozřejmě rozdíly) a zároveň zachovat rychlost kompilovaných jazyků.\n", "\n", "V této lekci se dozvíte a naučíte:\n", "- Proč potřebujeme `numpy` pro efektivní práci s numerickými daty.\n", "- Vytvářet `numpy` pole.\n", "- Vektorové a maticové operace s `numpy.array`.\n", "- Užitečné a pokročilejší `numpy` \"triky\".\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tento notebook byl z části převzat a přeložen z J.R. Johansson: [Lectures on scientific computing with Python](http://github.com/jrjohansson/scientific-python-lectures) - díky." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Importujeme numpy\n", "\n", "Chceme-li použít `numpy`, je samozřejmě nutné modul importovat. Obvykle se použivá zkratka `np`: \n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## IPython pylab\n", "\n", "Můžeme také použít prostředí `pylab`, které oba importy provede. Navíc importuje také grafickou knihovnu `matplotlib`, kterou blíže představíme později." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] } ], "source": [ "%pylab inline --no-import-all" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Vytváříme `numpy` pole (`ndarray`)\n", "Existuje několik základních způsobů, jak vytvořit nové numpy pole.\n", "\n", "* Z nějakého kontejneru typu seznam (`list`) nebo `tuple`.\n", "* Pomocí funkce numpy, která generuje `ndarray`, např. `zeros` nebo `arange`.\n", "* Načtením ze souboru." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ze seznamu\n", "Na seznam použijeme funkci `array`." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 4])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vector = np.array([1, 2, 3, 4])\n", "vector" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vícerozměrné pole (matice) se vytvoří z vnořeného seznamu." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix = np.array([[1, 2], [3, 4]])\n", "matrix" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`vector` a `matrix` jsou oboje typu `ndarray`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(numpy.ndarray, numpy.ndarray)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(vector), type(matrix)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Rozdíl mezi nimi je jejich rozměr, který dostaneme pomocí `shape` property (property proto, že shape lze i měnit)." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(4,)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vector.shape" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(2, 2)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Počet prvků získáme pomocí `size`." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix.size" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vector.size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Počet dimenzí je v `ndim`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix.ndim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Proč NumPy?\n", "\n", "Zatím vypadá `numpy.ndarray` hodně podobně jako (vnořený) seznam. Proč jednoduše tedy jednoduše nepoužívat seznam místo vytváření nového typu?\n", "Existuje několik velmi dobrých důvodů:\n", "\n", "* Python seznamy jsou příliš obecné. Mohou obsahovat jakýkoliv druh objektu. Jsou dynamicky typované. Nepodporují matematické funkce, jako maticové násobení. Implementating takové funkce pro seznamy by nebylo příliš efektivní.\n", "* NumPy pole jsou staticky typovaná a homogenní. Typ prvků je určen při vytvoření pole.\n", "* NumPy pole jsou efektivně uložena v paměti.\n", "* Díky těmto vlastnostem lze implementovat matematické operace, jako je násobení nebo sčítání, v rychlém, kompilovaném jazyce (C/Fortran).\n", "Použití dtype (datový typ) vlastnost ndarray, můžeme vidět, jaký typ dat v poli má:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`dtype` property vrátí typ prvků v numpy poli." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix.dtype" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jiný typ do pole uložit nelze:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "ename": "ValueError", "evalue": "invalid literal for int() with base 10: 'hello'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'" ] } ], "source": [ "matrix[0, 0] = \"hello\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Typ prvků můžeme deklarovat explicitně při vytváření pole." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1.+0.j, 2.+0.j],\n", " [3.+0.j, 4.+0.j]])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix = np.array([[1, 2], [3, 4]], dtype=complex)\n", "matrix" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Běžné (vestavěné) typy pro `dtype` jsou: `int`, `float`, `complex`, `bool`, `object`, atd.\n", "\n", "Můžeme také použít jemnější typování `numpy` typů `int64`, `int16`, `float16`, `float128`, `complex128`, aj." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pomocné generátory polí\n", "Zejména velká pole by bylo nepraktické inicializovat pomocí seznamů. Naštěstí v numpy existují [funkce](http://docs.scipy.org/doc/numpy/reference/routines.array-creation.html), které generují typická pole." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`arange`** vygeneruje posloupnost, syntaxe je stejná jako `range`" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(0, 10, 1) # argumenty: start, stop, step" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([-1. , -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(-1, 0, 0.1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`linspace`** a **`logspace`** vytváří posloupnosti s daným počtem prvků." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 2.5, 5. , 7.5, 10. ])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# první a poslední prvek jsou obsaženy ve výsledku\n", "np.linspace(0, 10, 5)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,\n", " 1.e+08, 1.e+09, 1.e+10])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.logspace(0, 10, 11, base=10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`ones`** a **`zeros`** vytvoří pole ze samých nul nebo jedniček." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1., 1., 1.])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.ones(3)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0., 0., 0.],\n", " [0., 0., 0.]])" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# pokud chceme 2 a více rozměrů, musíme zadat rozměr jako tuple\n", "np.zeros((2, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`mgrid`** tvoří pravidelnou mříž." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = \n", "[[0 0 0]\n", " [1 1 1]]\n", "y = \n", "[[0 1 2]\n", " [0 1 2]]\n" ] } ], "source": [ "# všimněte si syntaxe s hranatými závorkami, mgrid se nevolá jako funkce\n", "x, y = np.mgrid[0:2, 0:3]\n", "print(f\"x = \\n{x}\")\n", "print(f\"y = \\n{y}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Náhodná data vytvoří funkce **`random_sample`** a další z modulu **`random`**." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.24322835, 0.62911947, 0.90406833, 0.4815721 ])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# několik náhodných čísel [0, 1] s rovnoměrným rozdělením\n", "np.random.random_sample(4)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[-1.33032936, -0.17332339, 1.18480304, -0.77883461],\n", " [-0.86913537, 0.92142974, -0.01103739, -1.88087039],\n", " [-1.60771105, 0.12901739, -0.51094771, -1.72278949],\n", " [ 0.62140584, -0.45699894, 0.40971992, 2.09084116]])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# matice s náhodnými čísly z normálním rozdělením\n", "np.random.standard_normal((4, 4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`diagflat`** vytvoří diagonální matici, **`diagonal`** vrátí diagonálu matice." ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 0, 0],\n", " [0, 2, 0],\n", " [0, 0, 3]])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# diagonální matice\n", "diag = np.diagflat([1, 2, 3])\n", "diag" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3])" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# vrátí diagonálu jako vektor\n", "np.diagonal(diag)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Cvičení\n", "\n", "1. Vytvořte pole 3x4 typu `bool` se všemi prvky `True`.\n", "2. Vytvořte matici 5x5 kde jediné nenulová prvky jsou [1, 2, 3, 4] pod hlavní diagonálou (nápověda - podívejte se na nápovědu funkce `diagflat`).\n", "```\n", "0 0 0 0 0\n", "1 0 0 0 0\n", "0 2 0 0 0\n", "0 0 3 0 0 \n", "0 0 0 4 0\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Práce se soubory\n", "\n", "### ASCII soubory\n", "S textovými (ASCII) soubory obsahující data se setkáváme stále často, přestože to z mnoha důvodů není ideální formát. Na čtení ASCII (spadá sem i CSV) máme v Numpy `genfromtxt` a `loadtxt`. V [dokumentaci](http://docs.scipy.org/doc/numpy/reference/routines.io.html) se dozvíte, jak přesně fungují a jaké mají argumenty." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pomocí `%%file` vytvoříme soubor `ascii_data_1.txt`" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting ascii_data_1.txt\n" ] } ], "source": [ "%%file ascii_data_1.txt\n", " 1 -6.1 -6.1 -6.1 1\n", " 2 -15.4 -15.4 -15.4 1\n", " 3 -15.0 -15.0 -15.0 1\n", " 4 -19.3 -19.3 -19.3 1\n", " 5 -16.8 -16.8 -16.8 1\n", " 6 -11.4 -11.4 -11.4 1\n", " 7 -7.6 -7.6 -7.6 1\n", " 8 -7.1 -7.1 -7.1 1\n", " 9 -10.1 -10.1 -10.1 1\n", "10 -9.5 -9.5 -9.5 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nyní se pokusíme soubor načíst pomocí `genfromtxt`." ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 1. -6.1 -6.1 -6.1 1. ]\n", " [ 2. -15.4 -15.4 -15.4 1. ]\n", " [ 3. -15. -15. -15. 1. ]\n", " [ 4. -19.3 -19.3 -19.3 1. ]\n", " [ 5. -16.8 -16.8 -16.8 1. ]\n", " [ 6. -11.4 -11.4 -11.4 1. ]\n", " [ 7. -7.6 -7.6 -7.6 1. ]\n", " [ 8. -7.1 -7.1 -7.1 1. ]\n", " [ 9. -10.1 -10.1 -10.1 1. ]\n", " [ 10. -9.5 -9.5 -9.5 1. ]]\n" ] } ], "source": [ "data = np.genfromtxt('ascii_data_1.txt')\n", "print(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`loadtxt` by mělo fungovat také:" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , -6.1, -6.1, -6.1, 1. ],\n", " [ 2. , -15.4, -15.4, -15.4, 1. ],\n", " [ 3. , -15. , -15. , -15. , 1. ],\n", " [ 4. , -19.3, -19.3, -19.3, 1. ],\n", " [ 5. , -16.8, -16.8, -16.8, 1. ],\n", " [ 6. , -11.4, -11.4, -11.4, 1. ],\n", " [ 7. , -7.6, -7.6, -7.6, 1. ],\n", " [ 8. , -7.1, -7.1, -7.1, 1. ],\n", " [ 9. , -10.1, -10.1, -10.1, 1. ],\n", " [ 10. , -9.5, -9.5, -9.5, 1. ]])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.loadtxt('ascii_data_1.txt')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`savetxt` můžeme použít na uložení." ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "np.savetxt(\"ascii_data_1_new.txt\", data, fmt=\"%6g\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Soubor můžeme vypsat:" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 1 -6.1 -6.1 -6.1 1\n", " 2 -15.4 -15.4 -15.4 1\n", " 3 -15 -15 -15 1\n", " 4 -19.3 -19.3 -19.3 1\n", " 5 -16.8 -16.8 -16.8 1\n", " 6 -11.4 -11.4 -11.4 1\n", " 7 -7.6 -7.6 -7.6 1\n", " 8 -7.1 -7.1 -7.1 1\n", " 9 -10.1 -10.1 -10.1 1\n", " 10 -9.5 -9.5 -9.5 1\n", "\n" ] } ], "source": [ "print(open(\"ascii_data_1_new.txt\", \"r\").read())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Obecně se snažte textovým souborům (včetně csv apod.) pro numerická datavyhýbat. Jejich formát je vždy do značné míry neurčitý a na disku zabírají zbytečně moc místa. Výhodou je pouze jednoduchost zobrazení v textovém editoru nebo příkazové řadce." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Binární formáty\n", "\n", "Pro numerická data se daleko více hodí binární soubory, které jsou dobře definované a úsporné na místo. Pokud použijeme vhodný a rozšířený formát, nemusíme se bát ani přenositelnosti.\n", "\n", "Numpy má vlastní NPY formát. Ten je pochopitelně jednoduchý na používání v NumPy, s přenositelností (pro stále ještě neuživatele Pythonu a obecně další systémy) je to ale už horší. Pomocí `save` a `load` můžete jednoduše ukládat a nahrávat Numpy objekty." ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "np.save(\"ascii_data_1_new.npy\", data)" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , -6.1, -6.1, -6.1, 1. ],\n", " [ 2. , -15.4, -15.4, -15.4, 1. ],\n", " [ 3. , -15. , -15. , -15. , 1. ],\n", " [ 4. , -19.3, -19.3, -19.3, 1. ],\n", " [ 5. , -16.8, -16.8, -16.8, 1. ],\n", " [ 6. , -11.4, -11.4, -11.4, 1. ],\n", " [ 7. , -7.6, -7.6, -7.6, 1. ],\n", " [ 8. , -7.1, -7.1, -7.1, 1. ],\n", " [ 9. , -10.1, -10.1, -10.1, 1. ],\n", " [ 10. , -9.5, -9.5, -9.5, 1. ]])" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.load(\"ascii_data_1_new.npy\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Velice dobrým a rozšířeným standardem je pak [HDF5](https://www.hdfgroup.org/solutions/hdf5/). Pro Python je jednoduché tento foromát používat pomocí knihovny [h5py](https://www.h5py.org/)." ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [], "source": [ "# pokud nemáte h5py nainstalované, můžete jednoduše nainstalovat přímo z notebooku momocí\n", "# %conda install h5py\n", "# nebo pokud používáte pip prostředí\n", "# %pip install h5py" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [], "source": [ "import h5py" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "V HDF5 souborech jsou data ve stromové struktuře (obdoba aresářů a souborů). Soubor se dvěma datasety můžeme vytvořit např. takto:" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [], "source": [ "with h5py.File(\"test_hdf5.h5\", \"w\") as hdf5_file:\n", " hdf5_file.create_dataset(\"data\", data=data)\n", " hdf5_file.create_dataset(\"random\", data=np.random.random_sample((3, 4)))" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [], "source": [ "with h5py.File(\"test_hdf5.h5\", \"r\") as hdf5_file:\n", " # musíme data \"nahrát\" pomocí [:], jinak by byl výsledek jen \"ukazatel\" na data\n", " data_hdf5 = hdf5_file[\"data\"][:]" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , -6.1, -6.1, -6.1, 1. ],\n", " [ 2. , -15.4, -15.4, -15.4, 1. ],\n", " [ 3. , -15. , -15. , -15. , 1. ],\n", " [ 4. , -19.3, -19.3, -19.3, 1. ],\n", " [ 5. , -16.8, -16.8, -16.8, 1. ],\n", " [ 6. , -11.4, -11.4, -11.4, 1. ],\n", " [ 7. , -7.6, -7.6, -7.6, 1. ],\n", " [ 8. , -7.1, -7.1, -7.1, 1. ],\n", " [ 9. , -10.1, -10.1, -10.1, 1. ],\n", " [ 10. , -9.5, -9.5, -9.5, 1. ]])" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data_hdf5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jelikož v HDF5 souboru může být velké množství dat (mnoho datasetů, velká data), je čtení dat z HDF5 \"lazy\": Dokud data opravdu nepotřebujeme v paměti (např. v NumPy poli), data zůstávají jen v souboru a v paměti máme jen jejich popis, jakýsi ukazatel na data.\n", "\n", "To můžete vyzkoušet vymazáním `[:]` z načítání data v předchozí ukázce." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Práce s NumPy poli\n", "\n", "### Indexování a řezání" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. ])" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vector = np.linspace(0, 3, 7)\n", "vector" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy pole můžeme indexovat podobně jako list.\n", "\n", "První prvek vektoru:" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vector[0]" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix = np.array([[1, 2], [3, 4]], dtype=int)\n", "matrix" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pro matice můžeme použít rozšířeného indexování - více argumentů pro řez:" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix[1, 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pokud jeden index vynecháme, vrátí numpy N-1 rozměrný řez." ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([3, 4])" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Toho samého docílíme pomocí `:`" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([3, 4])" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix[1, :]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "První sloupec:" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([2, 4])" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix[:, 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Můžeme také přiřazovat honoty do indexovaných polí." ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[-10 2]\n", " [ 3 4]]\n" ] } ], "source": [ "matrix[0, 0] = -10\n", "print(matrix)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Funguje to i pro více prvků:" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[-10 2]\n", " [ 0 0]]\n" ] } ], "source": [ "matrix[1, :] = 0\n", "print(matrix)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Řezy mají stejnou syntaxi jako pro seznamy (řezy jsou ostatně koncept Pythonu jako takového). Pro připomenutí, tato syntaxe je `[dolní_mez : horní_mez : krok]`." ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array = np.arange(1, 10)\n", "my_array" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jednoduchý řez s krokem 1:" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([2, 3])" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[1:3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Řez s krokem 2" ] }, { "cell_type": "code", "execution_count": 94, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1, 3, 5, 7])" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[:-2:2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Řezy jsou mutable**: pokud do nich něco přiřadíme, projeví se to na původním objektu." ] }, { "cell_type": "code", "execution_count": 95, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1, -2, -3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 95, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[1:3] = [-2, -3]\n", "my_array" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Řezy fungují i pro vícerozměrné matice." ] }, { "cell_type": "code", "execution_count": 96, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n", "my_array" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Část původní matice" ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[31, 32, 33],\n", " [41, 42, 43]])" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[3:, 1:-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Řez s krokem 2" ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 2, 4],\n", " [20, 22, 24],\n", " [40, 42, 44]])" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[::2, ::2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Jetě elegantnější vyřezávání\n", "Pro řezy můžeme použít nejen čísla, ale také přímo pole. Např. pro výběr některých řádků" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24]])" ] }, "execution_count": 99, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_indices = [1, 2]\n", "my_array[row_indices]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Můžeme indexovat i dvěma poli:" ] }, { "cell_type": "code", "execution_count": 106, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([11, 24, 30])" ] }, "execution_count": 106, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[[1, 2, 3], [1, -1, 0]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Můžeme také použít **maskování**. Např. vytvoříme masku dělitelnosti 3mi." ] }, { "cell_type": "code", "execution_count": 107, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ True False False True False]\n", " [False False True False False]\n", " [False True False False True]\n", " [ True False False True False]\n", " [False False True False False]]\n" ] } ], "source": [ "mask3 = my_array % 3 == 0\n", "print(mask3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tuto masku pak můžeme použít pro vytvoření řezu." ] }, { "cell_type": "code", "execution_count": 108, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 3, 12, 21, 24, 30, 33, 42])" ] }, "execution_count": 108, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[mask3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Cvičení\n", "\n", "1. Z pole 8x8 samých nul vyvořte pomocí řezů co nejelegantnějším způsobem 8x8 matici, která vypadá jako šachovnice.\n", "```\n", "0 1 0 1 0 1 0 1\n", "1 0 1 0 1 0 1 0\n", "0 1 0 1 0 1 0 1\n", "1 0 1 0 1 0 1 0\n", "0 1 0 1 0 1 0 1\n", "1 0 1 0 1 0 1 0\n", "0 1 0 1 0 1 0 1\n", "1 0 1 0 1 0 1 0\n", "```\n", "2. Pomocí `np.random.randint` vytvořte vektor dvouciferných kladných celých čísel. Poté pomocí indexu typu masky nahraďte liché hodnoty jejich opačnou hodnotou. Např. [11, 20, 42, 33] -> [-11, 20, 42, -33]." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lineární algebra\n", "Numpy dokáže velice obratně a efektivně pracovat s vektory, maticemi a n-dimenzionálními poli obecně. Toho je potřeba využívat a kdekoli to je možné použít *vektorizovaný kód*, tj. co nejvíce formulovat úlohy pomocí vektorových a maticových operací, jako jsou např. násobení matic." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Operace se skaláry\n", "Jak bychom asi očekávali, skalárem můžeme násobit, dělit, můžeme ho přičítat nebo odečítat." ] }, { "cell_type": "code", "execution_count": 125, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "v1 = np.arange(0, 5)" ] }, { "cell_type": "code", "execution_count": 126, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4, 6, 8])" ] }, "execution_count": 126, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v1 * 2" ] }, { "cell_type": "code", "execution_count": 127, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([2, 3, 4, 5, 6])" ] }, "execution_count": 127, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v1 + 2" ] }, { "cell_type": "code", "execution_count": 128, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.25, 0.25, 0.25],\n", " [0.25, 0.25, 0.25],\n", " [0.25, 0.25, 0.25]])" ] }, "execution_count": 128, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.ones((3, 3)) / 4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Maticové operace po prvcích\n", "Operace jako násobení, sčítání atd. jsou v numpy stardadně *po prvcích*, není to tedy klasická maticová (vektorová) algebra." ] }, { "cell_type": "code", "execution_count": 129, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 129, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1 = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n", "m1" ] }, { "cell_type": "code", "execution_count": 130, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 4, 9, 16],\n", " [ 100, 121, 144, 169, 196],\n", " [ 400, 441, 484, 529, 576],\n", " [ 900, 961, 1024, 1089, 1156],\n", " [1600, 1681, 1764, 1849, 1936]])" ] }, "execution_count": 130, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1 * m1" ] }, { "cell_type": "code", "execution_count": 131, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 4, 9, 16])" ] }, "execution_count": 131, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v1 * v1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pokud se dají pole rozšířit na společný rozměr, numpy to za nás udělá." ] }, { "cell_type": "code", "execution_count": 132, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "((5,), (5, 5))" ] }, "execution_count": 132, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v1.shape, m1.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Výsledek bude mít rozměr `m1.shape`" ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 4, 9, 16],\n", " [ 0, 11, 24, 39, 56],\n", " [ 0, 21, 44, 69, 96],\n", " [ 0, 31, 64, 99, 136],\n", " [ 0, 41, 84, 129, 176]])" ] }, "execution_count": 133, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1 * v1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Maticová algebra\n", "Klasickou maticovou algebru zajišťuje pro pole typu `ndarray` funkce `dot` nebo operátor `@` ([PEP-465](https://www.python.org/dev/peps/pep-0465/)):" ] }, { "cell_type": "code", "execution_count": 134, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 300, 310, 320, 330, 340],\n", " [1300, 1360, 1420, 1480, 1540],\n", " [2300, 2410, 2520, 2630, 2740],\n", " [3300, 3460, 3620, 3780, 3940],\n", " [4300, 4510, 4720, 4930, 5140]])" ] }, "execution_count": 134, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# maticové násobení dvou matic\n", "np.dot(m1, m1)" ] }, { "cell_type": "code", "execution_count": 135, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 300, 310, 320, 330, 340],\n", " [1300, 1360, 1420, 1480, 1540],\n", " [2300, 2410, 2520, 2630, 2740],\n", " [3300, 3460, 3620, 3780, 3940],\n", " [4300, 4510, 4720, 4930, 5140]])" ] }, "execution_count": 135, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1 @ m1" ] }, { "cell_type": "code", "execution_count": 136, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 30, 130, 230, 330, 430])" ] }, "execution_count": 136, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# maticové násobení vektoru a matice\n", "np.dot(m1, v1)" ] }, { "cell_type": "code", "execution_count": 137, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "30" ] }, "execution_count": 137, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# skalární součin\n", "v1 @ v1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Transformace\n", "Už jsme viděli `.T` pro transponování. Existuje také funkce a metoda `transpose`. Dále existuje třeba `conjugate` pro komplexní sdružení." ] }, { "cell_type": "code", "execution_count": 159, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.+1.j, 0.+2.j],\n", " [0.+3.j, 0.+4.j]])" ] }, "execution_count": 159, "metadata": {}, "output_type": "execute_result" } ], "source": [ "C = np.array([[1j, 2j], [3j, 4j]])\n", "C" ] }, { "cell_type": "code", "execution_count": 160, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.-1.j, 0.-2.j],\n", " [0.-3.j, 0.-4.j]])" ] }, "execution_count": 160, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.conjugate(C) # nebo C.conjugate()" ] }, { "cell_type": "code", "execution_count": 162, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.-1.j, 0.-3.j],\n", " [0.-2.j, 0.-4.j]])" ] }, "execution_count": 162, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Hermitovské sdružení\n", "C.conjugate().T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Reálnou a imaginární část dostaneme pomocí `real` a `imag` nebo `.real` a `.imag` properties:" ] }, { "cell_type": "code", "execution_count": 163, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0., 0.],\n", " [0., 0.]])" ] }, "execution_count": 163, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.real(C)" ] }, { "cell_type": "code", "execution_count": 164, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1., 2.],\n", " [3., 4.]])" ] }, "execution_count": 164, "metadata": {}, "output_type": "execute_result" } ], "source": [ "C.imag" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Komplexní číslo rozložíme na absolutní hodnotu a úhel pomocí `abs` a `angle`." ] }, { "cell_type": "code", "execution_count": 165, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.78539816, 1.10714872],\n", " [1.24904577, 1.32581766]])" ] }, "execution_count": 165, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.angle(C+1)" ] }, { "cell_type": "code", "execution_count": 166, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1.41421356, 2.23606798],\n", " [3.16227766, 4.12310563]])" ] }, "execution_count": 166, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.abs(C+1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Cvičení\n", "\n", "1. Ověřte empiricky na náhodné matici, že platí $(AB)^T = B^T A^T$\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Základní funkce lineární algebry" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "V Numpy existuje modul `linalg`. Pokročilejší lineární algebru je ale třeba hledat jinde, např. ve SciPy. \n", "\n", "Invertovat matici můžeme pomocí `linalg.inv`." ] }, { "cell_type": "code", "execution_count": 152, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , 1.5],\n", " [-1. , 2. ]])" ] }, "execution_count": 152, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m2 = np.array([[1., 1.5], [-1, 2]])\n", "m2" ] }, { "cell_type": "code", "execution_count": 169, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0.57142857, -0.42857143],\n", " [ 0.28571429, 0.28571429]])" ] }, "execution_count": 169, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linalg.inv(m2)" ] }, { "cell_type": "code", "execution_count": 172, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1., 0.],\n", " [0., 1.]])" ] }, "execution_count": 172, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# toto by měla být jednotková matice\n", "np.linalg.inv(m2) @ m2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`linalg.det` vypočítá determinant." ] }, { "cell_type": "code", "execution_count": 174, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "3.5" ] }, "execution_count": 174, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linalg.det(m2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Zpracování dat\n", "\n", "Numpy je vhodné pro práci se soubory dat, pro které poskytuje řadu funkcí, např. statistických.\n", "\n", "Zkusme nějakou statistiku na souboru teplot ve Stockholmu. Data si můžete stáhnout z [Gitlabu](https://gitlab.com/coobas/numerical_python_course/-/raw/dda96848bd96e0d1f0e06b2639f48c7f464f8bb1/lecture_notes.cz/data/stockholm_td_adj.dat?inline=false)." ] }, { "cell_type": "code", "execution_count": 185, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(77431, 7)" ] }, "execution_count": 185, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data = np.genfromtxt('data/stockholm_td_adj.dat')\n", "np.shape(data)" ] }, { "cell_type": "code", "execution_count": 183, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1.80e+03, 1.00e+00, 1.00e+00, -6.10e+00, -6.10e+00, -6.10e+00,\n", " 1.00e+00],\n", " [ 1.80e+03, 1.00e+00, 2.00e+00, -1.54e+01, -1.54e+01, -1.54e+01,\n", " 1.00e+00]])" ] }, "execution_count": 183, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data[:2, :]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### mean (aritmetický průměr)" ] }, { "cell_type": "code", "execution_count": 176, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The daily mean temperature in Stockholm over the last 200 year so has been about 6.2 °C.\n" ] } ], "source": [ "# the temperature data is in column 3\n", "print(\n", " \"The daily mean temperature in Stockholm over the last 200 year so has been about {:.1f} °C.\".format(\n", " np.mean(data[:, 3])\n", " )\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### směrodatná odchylka a variance" ] }, { "cell_type": "code", "execution_count": 179, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(8.282271621340573, 68.59602320966341)" ] }, "execution_count": 179, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.std(data[:, 3]), np.var(data[:, 3])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### min a max" ] }, { "cell_type": "code", "execution_count": 180, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "-25.8" ] }, "execution_count": 180, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# nejnižší denní teplota\n", "data[:, 3].min()" ] }, { "cell_type": "code", "execution_count": 181, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "28.3" ] }, "execution_count": 181, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# nejvyšší denní teplota\n", "data[:, 3].max()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### sum, prod, trace" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d = np.arange(1, 11)\n", "d" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "55" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# sečíst všechny prvky\n", "np.sum(d)" ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "3628800" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# násobek všech prvků\n", "np.prod(d)" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1, 3, 6, 10, 15, 21, 28, 36, 45, 55])" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# kumulativní součet\n", "np.cumsum(d)" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1, 2, 6, 24, 120, 720, 5040,\n", " 40320, 362880, 3628800])" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# kumulativní násobení\n", "np.cumprod(d)" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "110" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# stejné jako diag(m1).sum()\n", "np.trace(m1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Výpočty s částmi polí\n", "\n", "Výpočty můžeme také provádět na podmnožinách dat pomocí indexování (jednoduchého či pokročilého) a dalších metod ukázaných níže.\n", "\n", "Vraťme se k údajům o teplotě." ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1.80e+03, 1.00e+00, 2.00e+00, -1.54e+01, -1.54e+01, -1.54e+01,\n", " 1.00e+00])" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Format je: rok, měsíc, den, průměrná teplota, nejnižší teplota, nejvyšší teplota, poloha.\n", "\n", "Pokud chceme spočítat průměrnou teplotu v konkrétním měsíci, např únoru, můžeme použít *maskování*.\n" ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.])" ] }, "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.unique(data[:, 1]) # měsíce mají hodnoty 1 - 12" ] }, { "cell_type": "code", "execution_count": 89, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "# vytvoříme masku\n", "mask_feb = data[:, 1] == 2" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Průměrná únorová teplota je -3.2 °C\n" ] } ], "source": [ "# masku použijeme jako index\n", "print(u\"Průměrná únorová teplota je {:.1f} °C\".format(np.mean(data[mask_feb, 3])))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Získání průměrných teplot pro všechny měsíce je také jednoduché.\n" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "months = np.arange(1,13)\n", "monthly_mean = [np.mean(data[data[:, 1] == month, 3]) for month in months]\n", "\n", "# teď používáme matplotlib, se kterým se naučíme příště :)\n", "fig, ax = plt.subplots()\n", "ax.bar(months, monthly_mean)\n", "ax.set_xlabel(\"Month\")\n", "ax.set_ylabel(\"Monthly avg. temp.\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Výpočty s vícerozměrnými daty\n", "\n", "Pokud je funkce jako `min`, `max` apod. použita na vícerozměrné pole, je někdy účelem ji aplikovat na celé pole, jindy zase po řádcích nebo sloupcích. K tomuto účelu slouží argument `axis`." ] }, { "cell_type": "code", "execution_count": 186, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.01634568, 0.83311498, 0.47349707, 0.47323059],\n", " [0.19986406, 0.09789846, 0.98967341, 0.03272229],\n", " [0.47602455, 0.02792878, 0.61671612, 0.37006065]])" ] }, "execution_count": 186, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m = np.random.rand(3, 4)\n", "m" ] }, { "cell_type": "code", "execution_count": 187, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "0.9896734088817986" ] }, "execution_count": 187, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# globální max\n", "m.max()" ] }, { "cell_type": "code", "execution_count": 188, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.47602455, 0.83311498, 0.98967341, 0.47323059])" ] }, "execution_count": 188, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# max pro každý sloupec\n", "m.max(axis=0)" ] }, { "cell_type": "code", "execution_count": 189, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.83311498, 0.98967341, 0.61671612])" ] }, "execution_count": 189, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# max pro každý řádek\n", "m.max(axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Argument `axis` používá mnoho dalších funkcí z numpy." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Změny rozměrů a spojování polí\n", "\n", "Rozměr Numpy polí může být měněn bez kopírování samotných dat, což výrazně tyto operace zrychluje." ] }, { "cell_type": "code", "execution_count": 190, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 190, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1" ] }, { "cell_type": "code", "execution_count": 191, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "n, m = m1.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Např. takto můžeme vytvořit jednorozměrné pole" ] }, { "cell_type": "code", "execution_count": 192, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n", " 31, 32, 33, 34, 40, 41, 42, 43, 44]])" ] }, "execution_count": 192, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1.reshape((1, n*m))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nebo použít -1 pro automatické dopočítání" ] }, { "cell_type": "code", "execution_count": 193, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n", " 31, 32, 33, 34, 40, 41, 42, 43, 44]])" ] }, "execution_count": 193, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1.reshape((1, -1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ovšem pozor: jelikož data jsou společná, změna v novém poli se projeví i v původním! Numpy to nazývá *views* - pohledy." ] }, { "cell_type": "code", "execution_count": 194, "metadata": {}, "outputs": [], "source": [ "m2 = m1.reshape((1, -1))" ] }, { "cell_type": "code", "execution_count": 195, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n", " 31, 32, 33, 34, 40, 41, 42, 43, 44]])" ] }, "execution_count": 195, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m2[0, 0:5] = 5 # modify the array\n", "m2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Změny se projeví i v původním `m1`" ] }, { "cell_type": "code", "execution_count": 196, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 5, 5, 5, 5],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 196, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Funkce `flatten` vytvoří jednorozměrné pole (vektor), data jsou v tomto případě kopírována." ] }, { "cell_type": "code", "execution_count": 197, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 5, 5, 5, 5, 5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n", " 32, 33, 34, 40, 41, 42, 43, 44])" ] }, "execution_count": 197, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m1.flatten()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Přidávání dimenzí: `newaxis`\n", "\n", "Pomocí `newaxis` můžeme jednoduše pomocí řezů přidávat dimenze. Např. převod 1d vektoru na sloupcovou nebo řádkovou matici." ] }, { "cell_type": "code", "execution_count": 198, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(3,)" ] }, "execution_count": 198, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v = np.array([1, 2, 3])\n", "v.shape" ] }, { "cell_type": "code", "execution_count": 199, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1],\n", " [2],\n", " [3]])" ] }, "execution_count": 199, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# vytvoříme sloupec\n", "vc = v[:, np.newaxis]\n", "vc" ] }, { "cell_type": "code", "execution_count": 200, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(3, 1)" ] }, "execution_count": 200, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vc.shape" ] }, { "cell_type": "code", "execution_count": 201, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(1, 3)" ] }, "execution_count": 201, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# řádek\n", "v[np.newaxis, :].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Spojování a opakování\n", "\n", "Na spojování a opakování máme funkce `repeat`, `tile`, `vstack`, `hstack` a `concatenate`." ] }, { "cell_type": "code", "execution_count": 202, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 202, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.array([[1, 2], [3, 4]])\n", "a" ] }, { "cell_type": "code", "execution_count": 203, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])" ] }, "execution_count": 203, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# opakování po prvcích\n", "np.repeat(a, 3)" ] }, { "cell_type": "code", "execution_count": 204, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 1, 2],\n", " [3, 4, 3, 4],\n", " [1, 2, 1, 2],\n", " [3, 4, 3, 4],\n", " [1, 2, 1, 2],\n", " [3, 4, 3, 4]])" ] }, "execution_count": 204, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# skládání celých polí \n", "np.tile(a, (3, 2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`concatenate` spojí dvě pole" ] }, { "cell_type": "code", "execution_count": 205, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "b = np.array([[5, 6]])" ] }, { "cell_type": "code", "execution_count": 206, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4],\n", " [5, 6]])" ] }, "execution_count": 206, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.concatenate((a, b), axis=0)" ] }, { "cell_type": "code", "execution_count": 207, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 5],\n", " [3, 4, 6]])" ] }, "execution_count": 207, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# musíme použít b.T\n", "np.concatenate((a, b.T), axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`hstack` a `vstack` skládá pole horizontáleně nebo vertikálně" ] }, { "cell_type": "code", "execution_count": 208, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4],\n", " [5, 6]])" ] }, "execution_count": 208, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.vstack((a, b))" ] }, { "cell_type": "code", "execution_count": 209, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 5],\n", " [3, 4, 6]])" ] }, "execution_count": 209, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.hstack((a, b.T))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Cvičení\n", "1. Pro náhodné 1D vektory $u, v$ vypočítejte dyadický součin $uv$ ($uv_{ij} = u_iv_j$) pomocí `newaxis`.\n", "2. Vytvořte šachovnicovou matici pomocí `tile`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Kopírování dat\n", "\n", "Python obecně přiřazuje proměnné pomocí referencí. Numpy objekty nejsou výjimkou." ] }, { "cell_type": "code", "execution_count": 218, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 218, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = np.array([[1, 2], [3, 4]])\n", "A" ] }, { "cell_type": "code", "execution_count": 219, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "# B je teď identický objekt s A\n", "B = A " ] }, { "cell_type": "code", "execution_count": 220, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[10, 2],\n", " [ 3, 4]])" ] }, "execution_count": 220, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# změna v B se projeví v A\n", "B[0, 0] = 10\n", "A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pokud chceme data zkopírovat, tj. pokud bychom chtěli aby `A` bylo nezávislé na `B`, můžeme použít metodu nebo funci `copy`." ] }, { "cell_type": "code", "execution_count": 221, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "B = A.copy()\n", "# nebo B = np.copy(A)" ] }, { "cell_type": "code", "execution_count": 222, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[10, 2],\n", " [ 3, 4]])" ] }, "execution_count": 222, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# změny v B už se neprojeví v A\n", "B[0, 0] = -5\n", "A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Iterace\n", "\n", "Obecně se iteraci vyhýbáme a přednost dáváme vektorovým operacím (viz níže). Někdy je ale iterace nevyhnutelná." ] }, { "cell_type": "code", "execution_count": 223, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "v = np.array([1, 2, 3, 4])\n", "\n", "for element in v:\n", " print(element)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Iteruje se přes první index (po řádcích)." ] }, { "cell_type": "code", "execution_count": 224, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "row: [1 2]\n", "row: [3 4]\n" ] } ], "source": [ "M = np.array([[1, 2], [3, 4]])\n", "\n", "for row in M:\n", " print(\"row: {}\".format(row))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pokud potřebujeme také indexy, použijeme `enumerate`. (Vzpomínáte?)" ] }, { "cell_type": "code", "execution_count": 225, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "row_idx 0 row [1 2]\n", "col_idx 0 element 1\n", "col_idx 1 element 2\n", "row_idx 1 row [3 4]\n", "col_idx 0 element 3\n", "col_idx 1 element 4\n" ] } ], "source": [ "for row_idx, row in enumerate(M):\n", " print(\"row_idx\", row_idx, \"row\", row)\n", " \n", " for col_idx, element in enumerate(row):\n", " print(\"col_idx\", col_idx, \"element\", element)\n", " \n", " # update the matrix M: square each element\n", " M[row_idx, col_idx] = element ** 2" ] }, { "cell_type": "code", "execution_count": 226, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 4],\n", " [ 9, 16]])" ] }, "execution_count": 226, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# each element in M is now squared\n", "M" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Vektorové funkce\n", "\n", "Jak jsme již říkali, vektorové (vektorizované) funkce jsou obecně daleko rychlejší než iterace. Numpy nám naštěstí cestu od skalární po vektorovou funkci usnadňuje." ] }, { "cell_type": "code", "execution_count": 235, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "def Theta(x):\n", " \"\"\"\n", " Scalar implemenation of the Heaviside step function.\n", " \"\"\"\n", " if x >= 0:\n", " return 1\n", " else:\n", " return 0" ] }, { "cell_type": "code", "execution_count": 236, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "ename": "ValueError", "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# toto bychom chtěli, ale asi to nebude fungovat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mTheta\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m\u001b[0m in \u001b[0;36mTheta\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mScalar\u001b[0m \u001b[0mimplemenation\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mHeaviside\u001b[0m \u001b[0mstep\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \"\"\"\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" ] } ], "source": [ "# toto bychom chtěli, ale asi to nebude fungovat\n", "Theta(np.array([-3, -2, -1, 0, 1, 2, 3]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pro vektorizaci naší funkce nám Numpy nabízí `vectorize`." ] }, { "cell_type": "code", "execution_count": 237, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "Theta_vec = np.vectorize(Theta)" ] }, { "cell_type": "code", "execution_count": 238, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 0, 1, 1, 1, 1])" ] }, "execution_count": 238, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Theta_vec(np.array([-3, -2, -1, 0, 1, 2, 3]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To bylo celkem snadné ... Můžeme také (a pokud to jde tak bychom měli) přepsat naší funkci tak, aby fungovala jak pro skaláry tak pro pole." ] }, { "cell_type": "code", "execution_count": 239, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "def Theta_numpy(x):\n", " \"\"\"\n", " Vector-aware implemenation of the Heaviside step function.\n", " \"\"\"\n", " return 1 * (x >= 0)" ] }, { "cell_type": "code", "execution_count": 240, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 0, 1, 1, 1, 1])" ] }, "execution_count": 240, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Theta_numpy(np.array([-3, -2, -1, 0, 1, 2, 3]))" ] }, { "cell_type": "code", "execution_count": 241, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(0, 1)" ] }, "execution_count": 241, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# funguje i pro skalár\n", "Theta_numpy(-1.2), Theta_numpy(2.6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pojďme zkusit porovna rychlost vektorizovaných funkcí. Tipnete si jaká bude rychléjší, případně jak moc rychlejší?" ] }, { "cell_type": "code", "execution_count": 242, "metadata": {}, "outputs": [], "source": [ "randvec = np.random.random_sample((10000)) * 2000 - 1000" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%timeit Theta_vec(randvec)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%timeit Theta_numpy(randvec)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Používání polí v podmínkách\n", "Pokud chceme testovat po prvcí, v podmínkách pak použijeme metody `all` nebo `any`." ] }, { "cell_type": "code", "execution_count": 132, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 4],\n", " [ 9, 16]])" ] }, "execution_count": 132, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M" ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[False, False],\n", " [ True, True]])" ] }, "execution_count": 133, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# výsledkem M > 5 je pole boolovských hodnot\n", "M > 5" ] }, { "cell_type": "code", "execution_count": 134, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "M obsahuje alespoň jeden prvek větší než 5\n" ] } ], "source": [ "if (M > 5).any():\n", " print(\"M obsahuje alespoň jeden prvek větší než 5\")\n", "else:\n", " print(\"M neobsahuje žádný prvek větší než 5\")" ] }, { "cell_type": "code", "execution_count": 135, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "M obsahuje alespoň jeden prvek menší rovno 5\n" ] } ], "source": [ "if (M > 5).all():\n", " print(\"všechny prvky v M jsou větší než 5\")\n", "else:\n", " print(\"M obsahuje alespoň jeden prvek menší rovno 5\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Změna typů\n", "Numpy pole jsou *staticky typované*. Pro změnu typu můžeme použít metodu `astype` (případně `asarray`)." ] }, { "cell_type": "code", "execution_count": 245, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 245, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M.dtype" ] }, { "cell_type": "code", "execution_count": 246, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1., 4.],\n", " [ 9., 16.]])" ] }, "execution_count": 246, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M2 = M.astype(float)\n", "M2" ] }, { "cell_type": "code", "execution_count": 247, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 247, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M2.dtype" ] }, { "cell_type": "code", "execution_count": 248, "metadata": { "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ True, True],\n", " [ True, True]])" ] }, "execution_count": 248, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M3 = M.astype(bool)\n", "M3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Další čtení" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* https://numpy.org/\n", "* https://jakevdp.github.io/PythonDataScienceHandbook/02.00-introduction-to-numpy.html\n", "* http://www.labri.fr/perso/nrougier/teaching/numpy.100/index.html" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 4 }