Aula02/numpy-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy\n",
    "\n",
    "Biblioteca para operações numéricas do Python.\n",
    "\n",
    "- [Array](#array)\n",
    "    - [Gerando arrays](#gerando)\n",
    "    - [Indexando](#indexando)\n",
    "        - [Array 1-D](#1d)\n",
    "        - [Array N-D](#nd)\n",
    "    - [Operações](#operacoes)\n",
    "        - [Com um escalar](#operacoes-escalar)\n",
    "        - [Com um outro array](#operacoes-array)\n",
    "    - [Funções Importantes](#funcoes)\n",
    "        - [Sum](#sum)\n",
    "        - [Reshape](#reshape)\n",
    "        - [Argmax](#argmax)\n",
    "        - [Arange](#arange)\n",
    "- [Teste de velocidade](#velocidade)\n",
    "    - [Multiplicação por constante](#mult)\n",
    "    - [Soma por linha](#sumlines)\n",
    "    - [Argmax](#vargmax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importando a biblioteca\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## <span id='array'>Array</span>\n",
    "Generalização de vetor com qualquer número de dimenções. É um dos conceitos centrais do NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Array](https://www.oreilly.com/library/view/elegant-scipy/9781491922927/assets/elsp_0105.png \"array\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(l)\n",
    "print(l.shape) # Shape é o tamanho da array em cada dimensão\n",
    "l[0] = 23 # Podemos alterar o valor de uma entrada da array\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = np.array([[1, 2, 3], [4, 5, 6]]) # Pode ter duas dimensões\n",
    "\n",
    "print(l)\n",
    "print(l.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos acessar cada elemento do shape\n",
    "l.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**PERGUNTA:** Qual o shape de uma imagem RGB com dimensões 1280x720? E de uma base de dados com 5000 destas imagens?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"gerando\">Gerando arrays</span>\n",
    "Além de arrays com valores específicos temos outras formas de criar esses objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros((2,2)) #Cria um array só com zeros com shape (2,2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = np.ones((2,2)) #Cria um array só com uns com shape (2,2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = np.random.random((3,2)) #Cria um array de shape (3,2) com valores aleatórios\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(20, size=(3,2)) # Cria um array com valores aleatorios inteiros (20 é o valor maxímo)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(5) # Cria um vetor de 0 a 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"indexando\">Indexando arrays</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span id=\"1d\">Array 1D</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(50, size=(10,))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a[2]) # Igual ao python puro\n",
    "print(a[:4]) # Igual ao python puro\n",
    "print(a[3:6]) # Igual ao python puro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = np.array([0,2,3]) # Podemos usar outra array para indexar só algumas posições\n",
    "a[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maior10 = a > 10 # Array de booleanos indicando se é maior que 10\n",
    "maior10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(a[maior10]) # Printa só os valores True do outro array\n",
    "print(a[a > 10]) # Não precisa da variável intermediaria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span id=\"nd\">Array N-D</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = np.random.randint(50, size=(4,6))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(a[1][4]) # [Linha][Coluna] - Igual ao python puro\n",
    "print(a[1,4]) # [Linha, Coluna] - Separando por virgula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a[1:3,2:5]) # Slicing normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a[:,5]) # ':' significa deixar a dimesão inteira (toda o coluna, nesse caso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a[2,:]) # ':' significa deixar a dimesão inteira (toda a linha, nesse caso)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"operacoes\">Operações</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(10, size=(5,))\n",
    "b = np.random.randint(10, size=(5,))\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Soma\n",
    "print(a + b)\n",
    "print(np.add(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + 10 # Soma 10 em cada elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicação element-wise\n",
    "print(a * b)\n",
    "print(np.multiply(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = np.random.randint(10, size=(5,2))\n",
    "b = np.random.randint(10, size=(2,4))\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Soma\n",
    "print(a + b)\n",
    "print(np.add(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![No](https://media.giphy.com/media/ly8G39g1ujpNm/giphy.gif \"no\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(10, size=(10,4))\n",
    "b = np.random.randint(10, size=(4))\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"matematica\">Funções matemática</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(a.T) # Faz a transposta da matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicação de matrizes (Ou produto escalar, se fossem dois vetores)\n",
    "print(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicação de matrizes (com outra notação)\n",
    "print(a @ b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(10, size=(5))\n",
    "b = np.random.randint(10, size=(5))\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(a, b) # produto escalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sistema linear \n",
    "a = np.array([[3,1], [1,2]])\n",
    "b = np.array([9,8])\n",
    "np.linalg.solve(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"funcoes\">Funções importantes</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(10, size=(8,4))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span id=\"sum\"> Sum <span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Soma todos os valores de a\n",
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Soma todos os valores de a em cada um dos eixos\n",
    "print(np.sum(a, axis = 0))\n",
    "print(np.sum(a, axis = 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essas operações sobre eixos são **muito importantes** (Por causa da representação matricial dos dados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span id=\"reshape\"> Reshape </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a.shape)\n",
    "b = a.reshape(16,2) # Importante: Isso retorna o objeto com o novo formato, não é inplace\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "b = a.reshape(-1,16) # Colacando -1 ele deixa do tamanho necessário para fazer sentido\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCÍCIO:** Como criar essa matriz em uma linha no numpy, sem for, usando só as funções passadas até então?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Output desejado\n",
    "print(np.array([[1, 4, 7], [2, 5, 8], [3, 6, 9]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Código aqui"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCÍCIO:** Supondo a base de dados com 5000 imagens RGB de 1280x720, como eu transformo essa base para que cada imagem seja só um vetor de uma dimensão?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SIZE = None # Coloque aqui a tupla com as dimençoes iniciais da base\n",
    "imagens = np.random.randint(255, size=SIZE)\n",
    "# ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span id=\"argmax\"> Argmax </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(50, size=(12,))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.argmax(a)) # Retorna o indice do maior elemento\n",
    "print(a[np.argmax(a)]) # Para pegar o valor do maior elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span id=\"arange\"> Arange </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exemplo = np.arange(0, 1500, 150) # Gera números entre dois valores com um passo determinado\n",
    "print(exemplo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCÍCIO:** Crie uma matriz aleatória e pegue o indice do maior elemento para cada linha e depois para cada coluna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span id=\"velocidade\"> Teste de velocidade </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Speed](https://media1.tenor.com/images/cea1d72266eec94333e2897f8ee86bf1/tenor.gif?itemid=5593970 \"speed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"mult\"> Multiplicação por constante </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [[j for j in range(10000)] for _ in range(1000)]\n",
    "b = np.array(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[0])):\n",
    "        a[i][j] *= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "b *= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"sumlines\"> Soma por linha</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "sums = []\n",
    "for i in range(len(a)):\n",
    "    part_sum = 0\n",
    "    for j in range(len(a[0])):\n",
    "        part_sum += a[i][j]\n",
    "    sums.append(part_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "b.sum(axis=1).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span id=\"vargmax\"> Argmax </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [i for i in range(10000000)]\n",
    "b = np.array(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "idx = 0\n",
    "for i in range(len(a)):\n",
    "    if a[i] > a[idx]:\n",
    "        idx = i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "np.argmax(b);"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}