Lab_Guide_04.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lab Guide 04.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/thalisreboucas/Python-codes-ML/blob/main/Lab_Guide_04.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsLqqUd8escA"
      },
      "source": [
        "# Lab Guide 04 - TensorFlow 2.x\n",
        "Nesse experimento, iremos trabalhar com os conceitos básicos da API Python do TensorFlow 2.x (ou seja, 2.0 ou superior) com Python 3, a qual já vem convenientemente instalada de antemão pelo ambiente do Google Colab.\n",
        "\n",
        "Essa é uma atividade extensa, portanto recomendamos usar o índice à esquerda do Colab para navegação devido à quantidade de saídas geradas nas diversas células de código. Além disso, esteja ciente de que talvez seja preciso reiniciar o Ambiente de Execução deste notebook durante a **Atividade 4**.\n",
        "\n",
        "Ao completar essas tarefas, você:\n",
        "* entenderá a operação da API;\n",
        "* estará familiarizado com o uso de tensores e sua aritmética; e\n",
        "* terá experimentado as novidades introduzidas com a versão 2.0 do TensorFlow.\n",
        "\n",
        "**NOTA:** esse *Lab Guide* é baseado no material da Huawei, sendo disponibilizado para uso exclusivo pelos alunos do curso e não deve ser divulgado sem autorização prévia e expressa.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nL-GiiYwmzef"
      },
      "source": [
        "## [Atividade 1] Tensores\n",
        "\n",
        "Cada tensor possui uma série de propriedades, destacando-se:\n",
        " - **dtype**, o tipo de dados armazenado internamente. Geralmente são usados números de ponto-flutuante, porém há diversos outros tipos suportados;\n",
        " - **rank**, também conhecido como *ordem* ou *grau* do tensor, diz quantas dimensões o tensor possui. Isso equivale ao número de índices necessário para  acessar cada elemento armazenado em um tensor;\n",
        " - **shape**, o formato interno, ou seja, as dimensões desse tensor como arranjo multidimensional; e\n",
        " - **device**, o nome do dispositivo no qual esse tensor será produzido. \n",
        " \n",
        "\n",
        "Analogamente às linguagens de programação, há dois tipos de tensores no TensorFlow:\n",
        " - **constantes**. possuem dimensões fixas e os valores armazenados também são fixos desde a sua criação. Geralmente são usados para hiperparâmetros e dados estruturados que devam ser protegidos contra alteração;\n",
        " - **variáveis**. também possuem dimensões fixas, porém os valores armazenados podem ser alterados. Usados para armazenar peso e outros dados que mudam com o decorrer de um treinamento ou ativação.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VQaow90HXna2"
      },
      "source": [
        "### 1.1 *Criando Tensores Constantes*\n",
        "Há diversas formas de criar um tensor constante em TensorFlow, das quais se destacam as seguintes funções:\n",
        " - **tf.constant()**, cria um tensor a partir de um arranjo multidimensional;\n",
        " - **tf.zeros()** **tf.zeros_like()**, as quais criam vetores povoados apenas com *0*;\n",
        " - **tf.ones()** e **tf.ones_like()**, as quais criam vetores povoados apenas com *1*;\n",
        " - **tf.fill()**, que cria um tensor com valores definidos pelo usuário;\n",
        " - **tf.random**, pacote com funções para criar tensores a partir de uma distriuição conhecida; e\n",
        " - **tf.convert_to_tensor()**, que converte vários tipos de objetos Python em tensores, geralmente subclasses de [tf.Tensor](https://www.tensorflow.org/api_docs/python/tf/Tensor)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y858QJ5baIrY"
      },
      "source": [
        "#### 1.1.1 **tf.constant()**\n",
        "Essa função recebe como entrada:\n",
        " - *value*, geralmente uma lista Python;\n",
        " - *dtype* (opcional), informa o tipo de dado armazenado no tensor, fazendo com que os valores sejam convertidos para o tipo desejado. Se não for informado, esse tipo é inferido a partir de value; \n",
        " - *shape* (opcional), define a forma do tensor, de modo que a entrada é reformulada para corresponder a essa propriedade; e\n",
        " - *name* (opcional) o *nome* da constante. Útil para depuração e visualização do grafo.\n",
        "\n",
        "Veja a [documentação da função tf.constant()](https://www.tensorflow.org/api_docs/python/tf/constant) para maiores detalhes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "co7Z2IFweqXo"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "# cria uma matriz 2x2 a partir de uma lista com 4 elementos\n",
        "const_a = tf.constant([[1, 2], [3, 4]], shape=[2,2], dtype=tf.float32)\n",
        "print( \"const_a:\\n\", const_a)\n",
        "\n",
        "# note-se que a dimensão da lista é indiferente, desde que esta contenha a\n",
        "# quantidade correta de elementos armazenados\n",
        "const_b = tf.constant([[1, 2, 3, 4]],shape=[2,2], dtype=tf.float32)\n",
        "const_c = tf.constant([ 1, 2, 3, 4] ,shape=[2,2], dtype=tf.float32)\n",
        "const_d = tf.constant([[1], [2], [3], [4]],shape=[2,2], dtype=tf.float32)\n",
        "\n",
        "# assim, todas as constantes são equivalentes\n",
        "print(\"\\nequivalentes:\");\n",
        "print(const_b)\n",
        "print(const_c)\n",
        "print(const_d)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CkavD6LrdfU1"
      },
      "source": [
        "Agora vamos visualizar as propriedades do nosso tensor:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V326-G-tdnb9"
      },
      "source": [
        "# o método numpy() é bastante útil\n",
        "print(\"valor do tensor: \", const_a.numpy())\n",
        "print(\"\\ttipo de dado armazenado:\", const_a.dtype)\n",
        "# há duas formas de acessar o rank: via tf.rank() ou pelo tamanho do shape\n",
        "print(\"\\trank:\", tf.rank(const_a).numpy())\n",
        "print(\"\\trank:\", len(const_a.shape))\n",
        "print(\"\\tshape:\", const_a.shape)\n",
        "# dispositivo associado, o qual pode ser None\n",
        "print(\"\\tdispositivo associado:\", const_a.device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kCe3lB4SmqIL"
      },
      "source": [
        "#### 1.1.2 **tf.zeros()** e **tf.ones()**\n",
        "\n",
        "As funções [tf.zeros()](https://www.tensorflow.org/api_docs/python/tf/zeros) e [tf.ones()](https://www.tensorflow.org/api_docs/python/tf/ones) são semelhantes, recebendo como argumentos:\n",
        " - *shape*, o formato do tensor. Uma lista ou tupla de inteiros, ou um tensor 1D do tipo int32;\n",
        " - *dtype* (opcional), define o tipo armazenado pelo tensor resultante. O tipo de dados padrão é *tf.float32*; e\n",
        " - *name* (opcional), o nome do tensor.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nebkemVEekur"
      },
      "source": [
        "# cria uma matriz 2x2 preenchida com zeros\n",
        "zeros_a = tf.zeros( shape=[2,2], dtype=tf.int32, name='zeros_a' )\n",
        "print(zeros_a)\n",
        "\n",
        "# cria uma matriz 2x4 preenchida com uns\n",
        "ones_a = tf.ones( shape=[2,4], dtype=tf.float32, name='zeros_a' )\n",
        "print(ones_a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4i_1PKA9dwaf"
      },
      "source": [
        "#### 1.1.3 **tf.zeros_like()** e **tf.ones_like()**\n",
        "\n",
        "As funções [tf.zeros_like()](https://www.tensorflow.org/api_docs/python/tf/zeros_like) e [tf.ones_like()](https://www.tensorflow.org/api_docs/python/tf/ones_like) são semelhantes às funções *tf.zeros()* e *tf.ones()*. Essas funções criam um tensor de zeros e uns, respectivamente, com *shape* e *dtype* idênticos aos de outro tensor.\n",
        "\n",
        "Assim, essas funções recebem como argumentos:\n",
        " - *input*, um tensor;\n",
        " - *dtype* (opcional), define o tipo armazenado pelo tensor resultante. O tipo de dados padrão é igual ao de *input*; e\n",
        " - *name* (opcional), o nome do tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xAFbpBLXnQ6o"
      },
      "source": [
        "zero_a2 = tf.zeros_like(const_a)\n",
        "print(zero_a2)\n",
        "\n",
        "zero_a3 = tf.zeros_like(const_a,dtype=tf.int16,name='zero3')\n",
        "print(zero_a3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vJn3cBCeCHBj"
      },
      "source": [
        "#### 1.1.4 **tf.fill()**\n",
        "Cria um vetor preenchido com um determinado valor. Assim, recebe os seguintes parâmetros:\n",
        " - *dims*, o mesmo que o parâmetro *shape* das funções anteriores. Suporta os tipos *int32* e *int64*;\n",
        " - *value*, o valor que preenche o tensor criado. Note-se que o tipo de dados é deduzido a partir deste valor; e \n",
        " - *name* (opcional), o nome do tensor.\n",
        "\n",
        "**IMPORTANTE:** [tf.fill()](https://www.tensorflow.org/api_docs/python/tf/fill) avalia o grafo em tempo de execução, suportando *shape dinâmico* com base em outros tensores.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KCoyeogyCMUM"
      },
      "source": [
        "filled_ei  = tf.fill( [3,2], 6)\n",
        "filled_ef = tf.fill( [3,2], 6.0)\n",
        "print(filled_ei)\n",
        "print(filled_ef)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9HhqqmfgCTip"
      },
      "source": [
        "1.1.5 módulo **tf.random**\n",
        "\n",
        "É possível fazer um embaralhamento ao longo da primeira dimensão usando a função [tf.random.shuffle()](https://www.tensorflow.org/api_docs/python/tf/random/shuffle). Essa operação é útil em diversos cenários, como divisão de datasets, por exemplo. Essa função recebe os seguintes argumentos:\n",
        " - *value*, o tensor a ser embaralhado;\n",
        " - *seed* (opcional), valor inteiro Python, usado para permitir a reprodução de uma sequência pseudoaleatória. Vide [tf.random.set_seed(()](https://www.tensorflow.org/api_docs/python/tf/random/set_seed) para maiores detalhes; e\n",
        " - *name* (opcional), nome do tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nuY5fAhICWi0"
      },
      "source": [
        "crows = tf.constant( [[1,2],[3,4],[5,6]] )\n",
        "\n",
        "# necessário para um resultado previsível\n",
        "tf.random.set_seed(5)\n",
        "shuff = tf.random.shuffle(crows, seed=66 )\n",
        "print('original:\\n', crows)\n",
        "print('\\nembaralhado:\\n', shuff)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "86ouzCvGECZo"
      },
      "source": [
        "As funções [tf.random.uniform()](https://www.tensorflow.org/api_docs/python/tf/random/uniform) e [tf.random.normal()](https://www.tensorflow.org/api_docs/python/tf/random/normal)geram valores aleatórios obedecendo às distribuições uniforme e normal (Gaussiana), respectivamente.\n",
        "\n",
        "A função *tf.random.normal()*, ilustrada no exemplo a seguir, recebe os seguintes argumentos:\n",
        " - *shape*, shape do tensor a ser produzido;\n",
        " - *mean* (opcional), média da distribuição normal. O valor padrão é *0.0*;\n",
        " - *stddev* (opcional), desvio padrão da distribuição normal. O valor padrão é *1.0*;\n",
        " - *dtype* (opcional), o tipo de dados do tensor. Seu valor padrão é *tf.dtypes.float32*;\n",
        " - *seed* (opcional), semente aleatória, útil para reprodutibilidade de resultados. Seu valor padrão é *None*, indicando que não será usado; e\n",
        " - *name* (opcional), o nome do tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ap6xTzw2D_QL"
      },
      "source": [
        "tf.random.set_seed(1);\n",
        "random_e = tf.random.normal([5,5],mean=0,stddev=1.0, seed = 1)\n",
        "#View the created data.\n",
        "random_e.numpy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XWW6jAsx5yyC"
      },
      "source": [
        "#### 1.1.5 *tf.convert_to_tensor()*\n",
        "A sua principal função é converter listas de objetos *Python* e arrays *numpy* em tensores. Além disso, essa função também suporta o tipo *Tensor* e escalares Python.\n",
        "\n",
        "A função [tf.convert_to_tensor()](https://www.tensorflow.org/api_docs/python/tf/convert_to_tensor) recebe os seguintes argumentos:\n",
        " - *value*, um objeto convertível em tensor;\n",
        " - *dtype* (opcional), o tipo de elemento armazenado no tensor criado. O valor padrão é *None*, indicando que o tipo deve ser inferido a partir do tipo de *value*;\n",
        " - *dtype_hint* (opcional), usado quando dtype é None; e\n",
        " - *name* (opcional).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VB7IPhh466Az"
      },
      "source": [
        "# uma lista \n",
        "list_f = [1,2,3,4,5,6]\n",
        "type(list_f)\n",
        "\n",
        "# conversão\n",
        "tensor_f = tf.convert_to_tensor(list_f, dtype=tf.float32)\n",
        "tensor_f"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xnCJ8ziOGvLL"
      },
      "source": [
        "### 1.2 Criando Tensores Variáveis\n",
        "Variáveis são operadas usando a classe [tf.Variable](https://www.tensorflow.org/api_docs/python/tf/Variable), que representa tensores. Necessariamente, o valor inicial de uma variável deve ser especificado.\n",
        "\n",
        "O valor de suas instâncias pode ser modificado ao executar uma operação aritmética. Além disso, os valores das variáveis podem tanto ser lidos quanto modificados.\n",
        "\n",
        "Vejamos um exemplo simples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4qCBwgCfGzDL"
      },
      "source": [
        "# o valor inicial precisa ser especificado \n",
        "v = tf.Variable(1.) \n",
        "print(v)\n",
        "\n",
        "# o valor pode ser substituído usando o método assign()\n",
        "v.assign(3.1415)\n",
        "print(v)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X-SvrnX--1Dv"
      },
      "source": [
        "Vejamos como criar uma variável a partir de uma constante:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "embdrYL2IbCH"
      },
      "source": [
        "var_1 = tf.Variable(tf.ones([2,3]))\n",
        "var_1\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H_2QyfCTBzv1"
      },
      "source": [
        "Ler seu valor é bem simples, basta usar o método *read_value()*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WnxPsUDT2Az2"
      },
      "source": [
        "# leitura\n",
        "print(\"var_1 = \",var_1.read_value())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9WXssK4m2KO3"
      },
      "source": [
        "Alterar seu valor também é simples, podem é preciso ter cuidado. Usar o operador de atribuição **=** sobrescreve o tipo em Python, sendo mais seguro usar o método *assign()*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YkZ__6XBJbJu"
      },
      "source": [
        "var_1.assign( [ [1.,2,3], [4.,5,6] ] )\n",
        "var_1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NTpYC8NA26IT"
      },
      "source": [
        "Por fim, é possível utilizar operações diretamente no tensor. Por exemplo, usaremos o método *assign_add()* para acumular valores adiconados ao tensor. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t_TSqctd3HJ1"
      },
      "source": [
        "# adiciona um tensor de mesma dimensão\n",
        "var_1.assign_add( tf.ones([2,3]) )\n",
        "print('var_1 = ', var_1.read_value())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ln1gu7jF5Nnx"
      },
      "source": [
        "## [Atividade 2] Recorte e Indexação de Tensores\n",
        "Os elementos de um tensor podem ser acessados convenientemente de diversas formas via Python. Nessa seção veremos como utilizar os operadores de recorte e indexação para esse propósito. \n",
        "\n",
        "Primeiro criemos um tensor relativamente simples, inicializado de forma aleatória para fins de testarmos esses operadores:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8k2oDV836ULU"
      },
      "source": [
        "\"\"\" Criemos um tensor que possui 4 dimensões:\n",
        "     - a dimensão mais externa é 5, indicando que temos 5 tensores de rank menor.\n",
        "       Isso equivale a uma coleção com 5 imagens;\n",
        "     - após isso, temos duas dimensões internas de 32 x 32. Assim, cada uma das\n",
        "       5 imagens possui 32 pixels de largura por 32 de altura; e\n",
        "     - por fim, cada pixel é armazenado em RGB com 3 componentes.    \n",
        "\"\"\"\n",
        "tensor_h = tf.random.normal([5,32,32,3])\n",
        "print( tensor_h )\n",
        "print( tensor_h.shape )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KKcVI5me5-vq"
      },
      "source": [
        "### 2.1 Recorte de Tensores\n",
        "Os principais métodos de recorte recorrem aos operadores que o Python já provê para acessar listas multidimensionais:\n",
        " 1. É possível usar valores específicos como `tensor[i]` ou intervalos como ```tensor[inicio:fim]``` para criar recortes;\n",
        " 2. É possível usar o índice **:** para selecionar todos os elementos em uma dimensão;\n",
        " 3. Opcionalmente, é possível definir passos para extrair uma sub-amostragem a partir de intervalos\n",
        "  - `tensor[inicio:fim:passo]` faz com que o recorte seja formado no intervalo, porém salteando *passo* elementos. \n",
        "  - `tensor[::passo]` faz o mesmo, porém considerando todo o intervalo.\n",
        "  - consequentemente `tensor[::-1]` extrair recorte a partir do último elemento.\n",
        " 4. Por fim, `tensor[...]` indica um recorte de qualquer tamanho."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WM6k5bPC9-tt"
      },
      "source": [
        "O exemplo a seguir extrai um recorte que contém a primeira imagem do tensor:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DBsoi55V5Mr0"
      },
      "source": [
        "# o operador acessa todo os intervalos da imagem (altura, largura, canal)\n",
        "print( tensor_h[0, :, :, :] )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n4InKkae-LNx"
      },
      "source": [
        "Assim, o exemplo a seguir extrai um recorte intervalando de 2 em 2 imagens:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CbPBgi3D-SI_"
      },
      "source": [
        "# o operador ... omite os índices no restante do tensor\n",
        "print( tensor_h[::2,...] )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ay5KRkk-_DQT"
      },
      "source": [
        "Por fim, o exemplo a seguir extrai o canal R das imagens 0 e 3:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CX95ESUw-3Xj"
      },
      "source": [
        "# o operador ... omite os índices no restante do tensor\n",
        "print( tensor_h[::3, ..., 0 ] )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tztK6xge_R7H"
      },
      "source": [
        "### 2.2 Indexação de Tensores\n",
        "O acesso a um elemento específico do tensor é feito utiliza tantos índices quanto o *rank* de um tensor, o que equivalente à quantidade de elementos no seu *shape*.\n",
        "\n",
        "Como no exemplo anterior, temos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EXW76UAG_xvm"
      },
      "source": [
        "# há 4 dimensões nesse tensor, portanto devemos usar 4 índices\n",
        "print( tensor_h.shape )\n",
        "\n",
        "# obtemos o pixel [3,32] no 2º canal da 1ª imagem \n",
        "print( tensor_h[0][2][31][1] )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JB842nKFAtP-"
      },
      "source": [
        "#### 2.2.1 **tf.gather()**\n",
        "A função [tf.gather()](https://www.tensorflow.org/api_docs/python/tf/gather) é útil para extrair índices que não são consecutivos a partir de um eixo, agrupando índices quaisquer naquele eixo. Essa função recebe os seguintes argumentos:\n",
        " - *params*, tensor de entrada;\n",
        " - *indices*, identifica quais índices dos dados de entrada devem ser extraídos;\n",
        " - *axis*, dimensão no tensor de entrada que será extraída; e\n",
        " - *batch_dims*, o número de dimensões no lote. Deve ser menor ou igual a **rank(indices)**; e\n",
        " - *name* (opcional).\n",
        "\n",
        "No exemplo a seguir, são agrupadas a 1ª, a 4ª e a 2ª imagens do tensor com shape (5,32,32,3):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HK7cl5H5Bvf6"
      },
      "source": [
        "# agrupa a 1ª, 4ª e 2ª imagens do tensor com shape (5,32,32,3)\n",
        "print(tf.gather(tensor_h,axis=0,indices=[0,3,1],batch_dims=1))\n",
        "print(tensor_h.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DbDoy17eAwXG"
      },
      "source": [
        "#### 2.2.2 **tf.gather_nd()**\n",
        "Semelhante a *tf.gather()*, porém [tf.gather_nd()](https://www.tensorflow.org/api_docs/python/tf/gather_nd) agrupa recortes de um tensor com shape especificado por indices, onde:\n",
        " - *params* é o tensor de entrada;\n",
        " - *indices* é um tensor k-1 de índices em *params*, de modo que cada elemento define um recorte de *params*;\n",
        " - *batch_dims*, opcional. Igual a 0 por padrão"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2sVc5U5lEUfo"
      },
      "source": [
        "# tensor contém 2 matrizes\n",
        "tensor_g = tf.constant( [ \n",
        "                         [[1., 2.], [3., 4.]],\n",
        "                         [[5., 6.], [7., 8.]]\n",
        "                        ] )\n",
        "\n",
        "# 1) agrupa a 2ª linha da 1ª matriz com a 1ª linha da 2ª matriz\n",
        "output = tf.gather_nd( tensor_g, indices = [[1], [0]],batch_dims=1 )\n",
        "print(output)\n",
        "\n",
        "# 2) agrupa a 2ª matriz com a 1ª\n",
        "output2 = tf.gather_nd( tensor_g, indices = [[[1], [0]]] )\n",
        "print()\n",
        "print(output2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0kyFNcR1HmHS"
      },
      "source": [
        "## [Atividade 3] Redimensionando Tensores\n",
        "A função [tf.shape()](https://www.tensorflow.org/api_docs/python/tf/shape) retorna um objeto [tf.Tensor](https://www.tensorflow.org/api_docs/python/tf/Tensor).\n",
        "\n",
        "Por sua vez, o atributo *shape* e o método [get_shape()](https://www.tensorflow.org/api_docs/python/tf/Tensor#get_shape) de um tensor são equivalentes. Ambos retornam instâncias de [TensorShape](https://www.tensorflow.org/api_docs/python/tf/TensorShape).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Hicxw5-IpdC"
      },
      "source": [
        "# muito embora esse shape seja conhecido, em algoritmos do mundo real\n",
        "# utilizam shapes arbitrários que podem variar de acordo com aplicação\n",
        "# e com as limitações do hardware (batch size, canais, etc). Assim, é\n",
        "# importante saber acessar o formato do tensor\n",
        "const_d_1 = tf.constant([[1, 2, 3, 4]],shape=[2,2], dtype=tf.float32)\n",
        "\n",
        "# shape do tensor criado acima\n",
        "print(const_d_1.shape)\n",
        "print(const_d_1.get_shape())\n",
        "# a saída é um tensor, pouco útil para acesso direto\n",
        "print(tf.shape(const_d_1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuLR1mpKJJ19"
      },
      "source": [
        "### 3.1 **tf.reshape()**\n",
        "A função [tf.reshape()](https://www.tensorflow.org/api_docs/python/tf/reshape) é responsável por reordenar os elementos do tensor para que estes formem outra estrutura lógica, a qual afeta a indexação e o recorte. Essa função recebe os seguintes argumentos:\n",
        " - *tensor*, o tensor de entrada;\n",
        " - *shape*, o layout desejado;\n",
        " - *name* (opcional);\n",
        "\n",
        "Assim, essa operação retorna um novo tensor com os valores do tensor oferecido como entrada, porém com um shape diferente. Essa é uma operação eficiente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OAmHAaajKJZl"
      },
      "source": [
        "# cria uma matriz 2 x 3\n",
        "it = tf.constant([[1,2,3],[4,5,6]])\n",
        "print(it)\n",
        "\n",
        "# que contém tantos elementos quanto uma matriz 3 x 2,\n",
        "# portanto o redimensionamento é permitido\n",
        "print('\\n', tf.reshape(it, (3,2)))\n",
        "\n",
        "# da mesma forma, o redimensionamento pode resultar em um\n",
        "# vetor de 6 elementos\n",
        "print('\\n', tf.reshape(it, (6)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tg3GQYNpNQiY"
      },
      "source": [
        "### 3.2 Adicionando Dimensões\n",
        "A função [tf.expand_dims()](https://www.tensorflow.org/api_docs/python/tf/expand_dims) insere um novo eixo em tensores. Na prática, retorna um novo tensor com uma nova dimensão de tamanho 1, antes de um eixo desejado. Essa função tem como entrada:\n",
        " - *input*, tensor de entrada;\n",
        " - *axis*, eixo no qual será criada a nova dimensão. Caso seja negativo, a dimensão será criada após o eixo identificado, seguindo a lógica do Python. Assim, dado um tensor de *rank* D, esse argumento deve estar entre `-(D+1)` e `D`;\n",
        " - *name* (opcional)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2pEcqQG-NkXY"
      },
      "source": [
        "# cria um tensor 100 x 100 x 3, o que seria uma imagem RGB\n",
        "img = tf.random.normal([100,100,3], seed=1)\n",
        "print(\"shape original: \",img.shape)\n",
        "\n",
        "print( \"shape estendido (axis = 0):\",\n",
        "       tf.expand_dims(img, axis=0).shape)\n",
        "print( \"shape estendido (axis = 1):\",\n",
        "       tf.expand_dims(img, axis=1).shape)\n",
        "print( \"shape estendido (axis = 2):\",\n",
        "       tf.expand_dims(img, axis=2).shape)\n",
        "print( \"shape estendido (axis = 3):\",\n",
        "       tf.expand_dims(img, axis=3).shape)\n",
        "print()\n",
        "\n",
        "# agora eixos negativos\n",
        "print( \"shape estendido (axis = -1):\",\n",
        "       tf.expand_dims(img, axis=-1).shape)\n",
        "print( \"shape estendido (axis = -2):\",\n",
        "       tf.expand_dims(img, axis=-2).shape)\n",
        "print( \"shape estendido (axis = -3):\",\n",
        "       tf.expand_dims(img, axis=-3).shape)\n",
        "print( \"shape estendido (axis = -4):\",\n",
        "       tf.expand_dims(img, axis=-4).shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1rovXB4iQRfX"
      },
      "source": [
        "### 3.3 Removendo Dimensões\n",
        "A função [tf.squeeze()](https://www.tensorflow.org/api_docs/python/tf/squeeze) remove dimensões de tamanho 1, recebendo os seguintes argumentos:\n",
        " - *input*, tensor de entrada;\n",
        " - *axis*, eixo no qual será criada a nova dimensão. Caso seja negativo, a dimensão será criada após o eixo identificado, seguindo a lógica do Python. Assim, dado um tensor de *rank* D, esse argumento deve estar entre `-(D+1)` e `D`;\n",
        " - *name* (opcional)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nuxyzj9WRcfs"
      },
      "source": [
        "# cria um tensor 1 x 100 x 100 x 3, o que seria um batch com \n",
        "# uma única imagem RGB\n",
        "img = tf.random.normal([1, 100,100,3], seed=1)\n",
        "print( \"shape original: \",img.shape)\n",
        "print( \"shape reduzido:\", tf.squeeze(img).shape)\n",
        "\n",
        "# agora um tensor com uma propriedade extra por pixel\n",
        "img2 = tf.random.normal([1,100,100,3,1], seed=1)\n",
        "print()\n",
        "print( \"shape original 2: \",img2.shape)\n",
        "# essa chamada remove todas as dimensões de valor 1\n",
        "print( \"shape reduzido:\", tf.squeeze(img2).shape)\n",
        "# é possível remover apenas a dimensão desejada\n",
        "print( \"shape reduzido no eixo 4:\", tf.squeeze(img2, [4]).shape)\n",
        "# é possível remover apenas a dimensão desejada\n",
        "print( \"shape reduzido no eixo 0:\", tf.squeeze(img2, [0]).shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ac9MjaVyUx_L"
      },
      "source": [
        "### 3.4 Transposição de Tensores\n",
        "A função [tf.transpose()](https://www.tensorflow.org/api_docs/python/tf/transpose) é capaz de computar o transposto e conjugado de um tensor. Essa função recebe os seguintes parâmetros:\n",
        " - *a*, um tensor;\n",
        " - *perm* (opcional), uma permutação das dimensões de *a*;\n",
        " - *conjugate* (opcional), booleano, se definido como *`True`*, a função retorna o tensor conjugado do transposto. Útil para lidar com tensores contendo números complexos; e\n",
        " - *name* (opcional)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aHiLm_NWVq-X"
      },
      "source": [
        "t = tf.constant([1,2,3,4,5,6],shape=[2,3])\n",
        "\n",
        "print(\"tensor original:\\n\", t.numpy())\n",
        "print(\"shape original: \", t.shape)\n",
        "tt = tf.transpose(t)\n",
        "\n",
        "print(\"tensor transposto:\\n\", tt.numpy())\n",
        "print(\"shape do transposto:\", tt.shape)\n",
        "\n",
        "ctt = tf.transpose(t,conjugate=True)\n",
        "print(\"tensor transposto conjugado:\\n\", ctt.numpy())\n",
        "print(\"shape do transposto conjugado:\", ctt.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ze1ayfd8WfKC"
      },
      "source": [
        "Caso o usuário necessite, é possível permutar a entrada, prodizindo resultado mais interessante e útil para lidar com tensores de alta dimensionalidade. Isso permite transposições em dimensões internas, por exemplo, o que é útil para compatibilizar dados que usam diferentes convenções de alinhamento."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lSpOePQeWpla"
      },
      "source": [
        "# tensor 4 x 100 x 200 x 3, representa 4 imagens RGB de 100 x 200\n",
        "batch = tf.random.normal([4,100,200,3])\n",
        "print(\"shape original:\", batch.shape)\n",
        "\n",
        "# transpõe as imagens do batch, ou seja, troca altura e largura.\n",
        "# a permutação original [0,1,2,3] é alterada para [0,2,1,3], o\n",
        "# que afeta as dimensões internas do tensor e preserva valores\n",
        "tbatch = tf.transpose(batch,[0,2,1,3])\n",
        "print(\"shape transposto:\", tbatch.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g2sKLOJgZN_t"
      },
      "source": [
        "### 3.5 **Broadcast** (Difusão)\n",
        "Também é possível difundir dados de um tensor de baixa dimensionalidade para formar um *shape* de dimensão maior. Para tanto, usemos a função [tf.broadcast_to()](https://www.tensorflow.org/api_docs/python/tf/broadcast_to):\n",
        " - *input*, o tensor de entrada com baixa dimensionalidade;\n",
        " - *shape*, o shape de destino, que deve ser compatível com o shape do tensor *input*; e\n",
        " - *name* (opcional)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JE6qXbyZilQw"
      },
      "source": [
        "low = tf.constant( [1,2,3,4,5,6] )\n",
        "print(\"dados originais:\\n\", low.numpy())\n",
        "\n",
        "high = tf.broadcast_to(low,shape=[4,6])\n",
        "print(\"dados após difusão:\\n\", high.numpy())\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZxOXHo-0jNru"
      },
      "source": [
        "Também é importante salientar que, durante a operação entre dois tensores, o TensorFlow automaticamente dispara o mecanismo de broadcast da mesma maneira que NumPy:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1W01hmI7je84"
      },
      "source": [
        "# uma matriz\n",
        "a = tf.constant( [[ 0, 0, 0],\n",
        "                  [10,10,10],\n",
        "                  [20,20,20],\n",
        "                  [30,30,30]] )\n",
        "\n",
        "# um vetor-linha é compatível. Note-se que um vetor-coluna \n",
        "# não \"casa\" com o formato interno ao tensor a\n",
        "b = tf.constant([1,2,3])\n",
        "print(a + b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DzOZgvHdjfkZ"
      },
      "source": [
        "### 3.6 **Operações Aritméticas**\n",
        "\n",
        "Há diversas operações aritméticas simples suportadas pelo TensorFlow na forma de funções:\n",
        " - **tf.add()**;\n",
        " - **tf.subtract()**;\n",
        " - **tf.multiply()**;\n",
        " - **tf.divide()**;\n",
        " - **tf.math.log()**;\n",
        " - **tf.log()**;\n",
        " - e [muitas outras](https://www.tensorflow.org/api_docs/python/tf/math/)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DphkXXSPlQm9"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "a = tf.constant([[3, 5], [4, 8]])\n",
        "b = tf.constant([[1, 6], [2, 9]])\n",
        "print(\"a + b = \", tf.add(a, b))\n",
        "print(\"a - b = \", tf.subtract(a, b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pD8hAFhnld0J"
      },
      "source": [
        "#### 3.6.1 **Multiplicação Matricial**\n",
        "Basta usar a função [tf.matmul()](https://www.tensorflow.org/api_docs/python/tf/linalg/matmul), como visto no Lab Guide anterior:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nNSNfHuIlyH_"
      },
      "source": [
        "# multiplicação\n",
        "tf.matmul(a,b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tOmbJuUTmVA1"
      },
      "source": [
        "#### 3.6.2 **Coletando Estatísticas de Tensores**\n",
        "\n",
        "Há diversas funções para o cálculo de estatísticas a partir de tensores:\n",
        " - **tf.reduce_min()**, **tf.reduce_max()** e **tf.reduce_mean()** calculam os valores mínimo, máximo e médio em um tensor, respectivamente;\n",
        " - **tf.argmax()** e **tf.argmin()** calculam as posições onde ocorrem os valores máximo e mínimo de um tensor, respectivamente;"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l8OHWwbUmd4Z"
      },
      "source": [
        "ten = tf.constant([[1,3,2],[2,5,8],[7,5,9]])\n",
        "\n",
        "print(\"input tensor:\\n\", ten.numpy())\n",
        "print(\"minimum:\", tf.reduce_min(ten).numpy())\n",
        "print(\"maximum:\", tf.reduce_max(ten).numpy())\n",
        "print(\"mean:\", tf.reduce_mean(ten).numpy())\n",
        "\n",
        "max1 = tf.argmax( ten, axis=0)\n",
        "max2  = tf.argmax( ten, axis=1)\n",
        "print(\"index of the maximum value, by column:\", max1.numpy())\n",
        "print(\"index of the maximum value, by row:\", max2.numpy())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "85HHlS0jpUWN"
      },
      "source": [
        " - **tf.equal()** e o operador de comparação **===** verificam se dois tensores são iguais, elemento por elemento;\n",
        " - **tf.unique()** remove elementos duplicados em um tensor 1D;"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXjCWGgHpc-M"
      },
      "source": [
        "a = tf.constant( [[1,3,1], [3,1,3], [1,3,1]] )\n",
        "b = tf.transpose(a)\n",
        "\n",
        "print( \"a == b? \", tf.equal(a, b) )\n",
        "print( a == b )\n",
        "\n",
        "# converte a para um vetor 1D\n",
        "va = tf.reshape(a, [9])\n",
        "print( \"\\nva:\", va.numpy() )\n",
        "\n",
        "# computa os valores únicos e suas ocorrências em va, estas como índices\n",
        "u, ids =  tf.unique( va )\n",
        "print( \"valores únicos:\", u.numpy() )\n",
        "print( \"índices desses valores em va:\", ids.numpy() )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SB4MoLaPrfEX"
      },
      "source": [
        " - [tf.math.in_top_k()](https://www.tensorflow.org/api_docs/python/tf/math/in_top_k) calcula se o valor previsto (*prediction*) é igual a um alvo (*target*), retornando um tensor booleano."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dokoMFTrvf1E"
      },
      "source": [
        "#### 3.6.3 **Operações Aritméticas Baseadas na Dimensão**\n",
        "\n",
        "Há uma série de operações que reduzem as dimensões de um tensor, as quais são identificadas pelo prefixo **tf.reduce_** e que podem ser realizadas em elementos multidimensionais de um tensor, tais como:\n",
        " - [tf.math.reduce_min()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_min), [tf.math.reduce_max()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_max) e [tf.math.reduce_mean()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_mean), já vistas;\n",
        " - [tf.math.reduce_sum()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_sum), adição;\n",
        " - [tf.math.reduce_prod()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_prod), multiplicação;\n",
        " - [tf.math.reduce_all()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_all), conjunção lógica (AND);\n",
        " - [tf.math.reduce_any()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_any), disjunção lógica (OR); e\n",
        " - [tf.math.reduce_logsumexp()](https://www.tensorflow.org/api_docs/python/tf/math/reduce_logsumexp ), disjunção lógica (OR).\n",
        "\n",
        "Todas essas operações são bastante semelhantes e possuem *aliases* (\"apelidos\") no módulo raiz **tf**, portanto analisemos os argumentos da função **tf.math.reduce_sum()**, equivalente a **tf.reduce_sum()**:\n",
        " - *input_tensor*, tensor numérico a ser \"reduzido\";\n",
        " - *axis*, dimensões a serem reduzidas. Caso não seja fornecido, todas as dimensões são reduzidas;\n",
        " - *keepdims*, se True, mantém dimensões reduzidas de tamanho 1; e\n",
        " - *name* (opcional).\n",
        "\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "62unyLC8xa4b"
      },
      "source": [
        "# soma todos os valores em um tensor\n",
        "print(tf.reduce_sum(a))\n",
        "# produz um tensor de rank 2, mas de dimensões unitárias\n",
        "print(tf.reduce_sum(a,keepdims=True))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6X1NDp_gy5FC"
      },
      "source": [
        "Vejamos um exemplo mais complexo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jB6ZCAFqy7Nn"
      },
      "source": [
        "rs1 = tf.constant([1,2,3,4,5,6],shape=[2,3])\n",
        "print(\"dados originais:\\n\", rs1.numpy())\n",
        "print(\"soma de todos os elementos (axis = None):\",tf.reduce_sum(rs1,axis=None).numpy())\n",
        "print(\"soma por coluna (axis = 0):\\n\",tf.reduce_sum(rs1,axis=0).numpy())\n",
        "print(\"soma por linha (axis = 1):\\n\",tf.reduce_sum(rs1,axis=1).numpy())\n",
        "print(\"soma por linha (axis = 1), mantendo as dimensões reduzidas:\\n\"\n",
        "      , tf.reduce_sum(rs1,axis=1,keepdims=True).numpy())\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BnxA-FPDz978"
      },
      "source": [
        "### 3.7 **Concatenação e Particionamento de Tensores**\n",
        "\n",
        "Dentre as operações com tensores, note-se que também é possível juntar tensores de modo a formar um tensor de maior dimensões. Além disso, o caminho inverso também é possível, ou seja, particionar um tensor em outros.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UUmsxPR803N6"
      },
      "source": [
        "#### 3.7.1 **Concatenando Tensores**\n",
        "\n",
        "Tanto **tf.concat()** quanto **tf.stack()** concatenam tensores. A função [tf.concat()](https://www.tensorflow.org/api_docs/python/tf/concat) concatena dois vetores ao longo de um dimensão, recebendo como argumentos:\n",
        " - *values*, uma lista de tensores ou um único tensor;\n",
        " - *axis*, eixo ao longo do qual concatenar os tensores; e\n",
        " - *name* (opcional)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HvRpaTDb1D_o"
      },
      "source": [
        "# 1) matrizes\n",
        "t1 = [[1, 2, 3], [4, 5, 6]]\n",
        "t2 = [[7, 8, 9], [10, 11, 12]]\n",
        "print( 't1 =', t1 )\n",
        "print( 't2 =', t2 )\n",
        "\n",
        "# concatena as linhas\n",
        "print(\"concatenated data (rows):\")\n",
        "print( tf.concat([t1, t2], 0).numpy() )\n",
        "\n",
        "# concatena as colunas\n",
        "print(\"concatenated data (columns):\")\n",
        "print( tf.concat([t1, t2], 1).numpy() )\n",
        "\n",
        "\n",
        "# 2) 'lotes' de imagens (batches)\n",
        "b1 = tf.random.normal([ 4,100,100,3])\n",
        "b2 = tf.random.normal([40,100,100,3])\n",
        "\n",
        "# concatena os dois lotes em um só\n",
        "bc = tf.concat([b1,b2],axis=0)\n",
        "print(\"size of the concatenated data:\",bc.shape)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DBbDVL_bk_Yq"
      },
      "source": [
        "A função [tf.stack()](https://www.tensorflow.org/api_docs/python/tf/stack) faz algo semelhante, porém empacota os tensores, produzindo tensor de rank maior. Para tanto, recebe os seguintes argumentos:\n",
        " - *values*, uma lista de tensores de mesmo shape e tipo de dados;\n",
        " - *axis*, eixo ao longo do qual empilhar os tensores. Também aceita valores negativos; e\n",
        " - name (opcional).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZysIx4hWlVux"
      },
      "source": [
        "x = tf.constant([1, 4])\n",
        "y = tf.constant([2, 5])\n",
        "z = tf.constant([3, 6])\n",
        "# combina os tensores, produzindo uma matriz\n",
        "print( tf.stack([x, y, z]).numpy())\n",
        "\n",
        "# produz a matriz transposta, empilhando coluna por coluna\n",
        "tf.stack([x, y, z], axis=1).numpy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p-KGMofx1EiJ"
      },
      "source": [
        "#### 3.7.2 **Particionando Tensores**\n",
        "\n",
        "Analogamente à concatenação e empilhamento, um tensor também pode ser subdividido em partições menores usando as funções **tf.split()** e **tf.unstack()**.\n",
        "\n",
        "A função [tf.split()](https://www.tensorflow.org/api_docs/python/tf/split) particiona um tensor em uma lista de sub-tensores. Essa função recebe os seguintes argumentos:\n",
        " - *value*, tensor a ser subdividido;\n",
        " - *num_or_size_splits*, pode ser tanto um inteiro indicando o número de subdivisões ao longo do eixo *axis*, quanto um Tensor ou lista Python de 1D dimensão contendo os tamanhos de cada vetor ao o longo do eixo;\n",
        " - *axis*, dimensão  ao longo a qual subvididir;\n",
        " - *num* (opcional), especifica o número de saídas quando não pode ser inferido a partir do *shape* de size_splits; e\n",
        " - *name* (opcional)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RPijMZdVn22q"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "ori = tf.random.normal([10,100,100,3])\n",
        "print(\"shape original:\",ori.shape)\n",
        "s1 = tf.split(ori, num_or_size_splits=5,axis=0)\n",
        "print(\"shape da subdivisão com m_or_size_splits=5:\", s1[0].shape)\n",
        "\n",
        "# divide o batch em 3 partes, que somam 10\n",
        "s2 = tf.split(ori, num_or_size_splits=[3,5,2],axis=0)\n",
        "print(\"dados resultantes da subdivisão para num_or_size_splits=[3,5,2]:\\n\",\n",
        "s2[0].shape,\n",
        "s2[1].shape,\n",
        "s2[2].shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZagOLgwqn3YL"
      },
      "source": [
        "A função [tf.unstack()](https://www.tensorflow.org/api_docs/python/tf/unstack) subdivide um tensor com base em uma dimensão específica. Essa função recebe os seguintes argumentos:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FoVEV3Opr0YR"
      },
      "source": [
        "# cria uma pilha de tensores\n",
        "s1 = tf.constant([1,2,3])\n",
        "s2 = tf.constant([4,5,6])\n",
        "s3 = tf.constant([7,8,9])\n",
        "ss = tf.stack([s1, s2, s3],axis=0)\n",
        "print(\"dimensão dos tensores empilhados = \", ss.shape)\n",
        "print(\"pilha resultante:\\n\", ss.numpy())\n",
        "\n",
        "# desfaz a pilha de tensores, produzindo uma lista\n",
        "l = tf.unstack( ss,axis=0)\n",
        "print(\"\\ndimensões dos tensores desempilhados de ss:\")\n",
        "for x in l:\n",
        "  print( \"shape:\", x.shape, 'valor:', x.numpy())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FhOTsGQt14YW"
      },
      "source": [
        "### 3.8 **Ordenando Tensores**\n",
        "A seleção de valores com base na ordem e ordenação em geral são ferramentas fundamentais para resolver diversos problemas. Assim, as principais funções de ordenação do TensorFlow são:\n",
        " - [tf.sort()](https://www.tensorflow.org/api_docs/python/tf/sort), que ordena um tensor ao longo de um eixo e retorna o tensor ordenado;\n",
        " - [tf.argsort()](https://www.tensorflow.org/api_docs/python/tf/argsort), semelhante a *tf.sort()*, porém retorna os índices que produzem um tensor ordenado ao longo de um eixo; e\n",
        " - [tf.math.top_k()](https://www.tensorflow.org/api_docs/python/tf/math/top_k), que retorna os valores e os respectivos índices para os *k* maiores elementos para a última dimensão do tensor.\n",
        "\n",
        "Os argumentos mais comuns dessas funções são:\n",
        " - *values*, o tensor de entrada;\n",
        " - *axis* (opcional), eixo a ser ordenado. Caso não seja fornecido, assume valor -1, que corresponde ao último eixo;\n",
        " - *direction*, o sentido da ordenação *'ASCENDING'* ou *'DESCENDING '*. O valor padrão é *'ASCENDING'*;\n",
        " - *stable*, um booleano, quando *True* indica que um algoritmo de ordenação estável deve ser usado. Isso garante que elementos iguais no tensor de entrada não serão permutados pela ordenação, o que pode gerar ruído no sentido lógico em algoritmos. Algoritmos não estáveis geralmente são mais eficientes e provavelmente serão implementados pela API do TensorFlow, portanto *stable=True* é uma escolha mais adequada para compatibilidade futura;\n",
        " - *name* (opcional).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XoEujt7W14Di"
      },
      "source": [
        "# a) lida com a ordenação de uma matriz\n",
        "mat = tf.constant( [[3,4], [1,2],[2,1]] )\n",
        "print(\"matriz inicial:\", mat.numpy())\n",
        "print(\"matriz ordenada:\", tf.sort(mat,axis=0).numpy())\n",
        "\n",
        "# cria um tensor como permutação de 10 inteiros\n",
        "tin = tf.random.shuffle(tf.range(10))\n",
        "print(\"\\ntensor inicial:\", tin.numpy())\n",
        "\n",
        "# ordenação\n",
        "ordered1 = tf.sort(tin, direction=\"ASCENDING\")\n",
        "print(\"\\ntensor ordenado em ordem ascendente:\", ordered1.numpy())\n",
        "ordered2 = tf.argsort(tin,direction=\"ASCENDING\")\n",
        "print(\"indices dos elementos em ordem ascendente:\",ordered2.numpy())\n",
        "\n",
        "# valores e índices\n",
        "vk, idxk = tf.math.top_k( tin, k=3 )\n",
        "print( \"\\nos 3 maiores valores: \", vk.numpy())\n",
        "print( \"que estão nas posições:\",idxk.numpy())\n",
        "\n",
        "vk2, idxk2 = tf.math.top_k( tin, k=3, sorted=False )\n",
        "print( \"\\nos 3 maiores valores, em ordem crescente: \", vk2.numpy())\n",
        "print( \"que estão nas posições:\",idxk2.numpy())\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j6C7cE3u2Nod"
      },
      "source": [
        "## [Atividade 4] Eager Execution no TensorFlow 2.x\n",
        "Há dois modos principais de execução no framework TensorFlow desde a versão 2.0, que introduziu um modo interativo (\"ansioso\"), o qual parece ser mais favorável aos novatos nessa intrincada API.\n",
        "\n",
        "O modo **Eager Execution** é um tipo de programação *imperativa* e que funciona de maneira similar ao Python ou C++. Nesse modelo de programação, o sistema informa imediatamente sobre o resultado de uma operação tão logo esta seja concluída. Esse é o modo padrão do TensorFlow 2.0 e que temos usado até agora neste notebook do Colab.\n",
        "\n",
        "O **Graph Mode**, por sua vez, é o modo disponível desde a versão 1.0 do TensorFlow e que assume uma perspectiva mais formal, de programação *declarativa*. Nesse modo, um *grafo computacional* é construído antes que uma *sessão* seja criada e habilitada para executá-lo, para que só então os dados sejam alimentados nesse processo \"burocrático\" para produzir um resultado.\n",
        "\n",
        "Esses dois modos serão comparados a seguir usando uma simples multiplicação.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JPkw9_0KJx23"
      },
      "source": [
        "### 4.1 **Eager Execution**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mbp-ZbGxJ86k"
      },
      "source": [
        "# cada tensor é associado imediatamente ao seu valor\n",
        "x = tf.ones((2, 2), dtype=tf.dtypes.float32)\n",
        "y = tf.constant([[1, 2],\n",
        "                 [3, 4]], dtype=tf.dtypes.float32)\n",
        "\n",
        "# o resultado de operações está sempre disponível.\n",
        "# Além disso, o programador sequer habilita uma sessão.\n",
        "z = tf.matmul(x, y)\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m7MQE2rTJ9eQ"
      },
      "source": [
        "### 4.2 **Graph Mode**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7X8YFxmwKAIn"
      },
      "source": [
        "# usemos a sintaxe\n",
        "import tensorflow as tf\n",
        "import tensorflow.compat.v1 as tf1\n",
        "from tensorflow.python.framework.ops import disable_eager_execution\n",
        "\n",
        "# desabilitemos o modo padrão\n",
        "disable_eager_execution()\n",
        "\n",
        "# criemos o grafo\n",
        "a = tf.ones((2, 2), dtype=tf.dtypes.float32)\n",
        "b = tf.constant([[1, 2],\n",
        "                 [3, 4]], dtype=tf.dtypes.float32)\n",
        "c = tf.matmul(a, b)\n",
        "\n",
        "# sem uma sessão, o valor de c não pode ser calculado\n",
        "print( 'sem a sessão, c = ', c);\n",
        "\n",
        "# habilitando uma sessão, executamos o grafo que produz c\n",
        "with tf1.Session() as sess:\n",
        "    print(sess.run(c))\n",
        "    sess.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "52mdnKfrMmXK"
      },
      "source": [
        "A vantagem do eager execution está na facilidade de visualizar o resultado, assim como na disponibilidade de funções nativas em Python.\n",
        "\n",
        "Por exemplo, é possível usar condicionais mais facilmente com o *eager mode*, permitindo que fluxos de controle dinâmicos gerem valores NumPy acessíveis por um tensor, o que dispensa o uso de operadores como **tf.cond** e **tf.while**, os quais são providos em *graph mode*.\n",
        "\n",
        "**NOTA:** de agora em diante, vá no menu do Colab e reinicie o ambiente de execução. Caso isso não seja feito, é provável que os próximos códigos continuem sendo executados em *graph mode*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XK-WjT81MrXl"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "try:\n",
        "  if (not tf.executing_eagerly()):\n",
        "    print('Por favor, reinicie o ambiente de execução deste notebook.')\n",
        "    print('1) Vá no menu \\\"Ambiente de execução\\\"')\n",
        "    print('2) Clique em \\\"Reiniciar ambiente de execução\\\"')\n",
        "    exit(-1)\n",
        "except Exception as ex:\n",
        "  print(ex);\n",
        "\n",
        "\n",
        "# executa normalmente, de forma imperativa\n",
        "thre_1 = tf.random.uniform([], 0, 1)\n",
        "x = tf.reshape(tf.range(0, 4), [2, 2])\n",
        "print(thre_1)\n",
        "if thre_1.numpy() > 0.5:\n",
        "    y = tf.matmul(x, x)\n",
        "else:\n",
        "    y = tf.add(x, x)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVIBsI502ZPU"
      },
      "source": [
        "## [Atividade 5] AutoGraph no TensorFlow 2.x\n",
        "Uma das novidades do TensorFlow 2.x é o uso de um decorador para comentar funções: [@tf.function](https://www.tensorflow.org/api_docs/python/tf/function), o qual pode ser usado como qualquer outro decorador. No caso, **@tf.function** fará com que a função decorada seja compilada na forma de um grafo otimizável, de modo que possa executar mais eficientemente por aceleração em uma GPU ou TPU.\n",
        "\n",
        "Com efeito, a função decorada se torna uma operação do TensorFlow e que pode ser executada diretamente para retornar um único valor. Todavia, note-se que a execução subjacente previne que valores intermediários de variáveis sejam acessados diretamente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPf8TC6h2sfx"
      },
      "source": [
        "@tf.function\n",
        "def simple_nn_layer(w,x,b):\n",
        "    # esse valor é desconhecido internamente\n",
        "    print(b)\n",
        "    return tf.nn.relu(tf.matmul(w, x)+b)\n",
        "\n",
        "# instancia as entradas da camada\n",
        "w = tf.random.uniform((3, 3))\n",
        "x = tf.random.uniform((3, 3))\n",
        "b = tf.constant(0.5, dtype='float32')\n",
        "\n",
        "# captura o resultado, já que o valor de 'b' é \"ofuscado\"\n",
        "c = simple_nn_layer(w,x,b)\n",
        "print( '\\nc = ', c.numpy() )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kX7d73hQ2v9e"
      },
      "source": [
        "A próxima célula de código Python efetua uma comparação do desempenho: (a) eager execution *versus* (b) graph mode com AutoGraph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K5IjxblR3Dyp"
      },
      "source": [
        "import timeit\n",
        "\n",
        "# camada convolucional: eager execution\n",
        "CNN_cell = tf.keras.layers.Conv2D(filters=100,kernel_size=2,strides=(1,1))\n",
        "\n",
        "# conversão automática em grafo nessa função\n",
        "@tf.function\n",
        "def CNN_fn(image):\n",
        "    return CNN_cell(image)\n",
        "\n",
        "# a imagem de entrada não importa: usaremos zeros\n",
        "image = tf.zeros([100, 200, 200, 3])\n",
        "\n",
        "# executa uma primeira vez\n",
        "CNN_cell(image)\n",
        "CNN_fn(image)\n",
        "\n",
        "# benchmark usando 30 execuções\n",
        "runs = 30\n",
        "print(\"tempo da camada CNN, em eager execution:\\n\", timeit.timeit(lambda: CNN_cell(image), number=runs))\n",
        "print(\"tempo da camada CNN, em graph mode:\\n\", timeit.timeit(lambda: CNN_fn(image), number=runs))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JOLou7b-4ngf"
      },
      "source": [
        "Os valores podem variar de plataforma para plataforma, mas os testes no Colab mostraram que o *graph mode* é executado *1,37* vezes mais rápido. \n",
        "\n",
        "Dependendo do ambiente hospedeiro e da complexidade do grafo, é provável que a execução em *graph mode* seja muito mais eficiente. Assim, o simples uso do decorador **@tf.function** em funções é um mecanismo conveniente de otimização.\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o13Ic5rcZYAr"
      },
      "source": [
        "#[Atividade 5] Conhecendo os Principais Módulos da API TensorFlow 2.x\n",
        "Agora que você está familiarizado com a manipulação de tensores e as principais operações disponíveis para esse tipo de dados, iremos introduzir os principais módulos presents na API do TensorFlow 2:\n",
        " - **tf.data**, para lidar com datasets, incluindo leitura a partir de diversas fontes (memória, arquivos CSV e arquivos TFRecord) e *data augmentation*;\n",
        " - **tf.image**, para processamento de imagens, incluindo redimensionamento, rotação, detecção de arestas, bem como transformações sobre luma e chroma;\n",
        " - **tf.gfile**, lida com arquivos e diretórios, permitindo leitura, escrita e renomeação;\n",
        " - **tf.keras**, uma API de alto nível para construir e treinar modelos de *deep learning*. *NOTA:* essa API não é necessariamente idêntica ao módulo Keras. Além disso, a compatibilidade entre diferentes versões do TensorFlow e versões específicas do Keras é um assunto que requer cuidado;\n",
        " - e muitas outras, como **tf.distribute**, usada para executar computação em múltiplos dispositivos.\n",
        "\n",
        "Os experimentos realizados nessa atividade possuem como foco o módulo [tf.keras](https://www.tensorflow.org/api_docs/python/tf/keras), pois visa fixar o conhecimento sobre modelos de deep learning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_so7bfu-bvbz"
      },
      "source": [
        "### 5.1 - Modelos Sequenciais\n",
        "A forma mais comum de construir um modelo consiste em empilhar camadas a partir de um modelo [tf.keras.Sequential](https://www.tensorflow.org/api_docs/python/tf/keras/Sequential), como no exemplo a seguir."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aPx3NFRGcI2z"
      },
      "source": [
        "import tensorflow as tf\n",
        "import tensorflow.keras.layers as layers\n",
        "2,442\n",
        "# cria um modelo como sequência de camadas\n",
        "model = tf.keras.Sequential()\n",
        "\n",
        "# empilha camadas no modelo\n",
        "model.add(layers.Dense(32, activation='relu'))\n",
        "model.add(layers.Dense(32, activation='relu'))\n",
        "model.add(layers.Dense(10, activation='relu'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YDhIUm_Hc5wF"
      },
      "source": [
        "Contudo, esse um modelo sequencial não é adequado para lidar com as seguintes situações:\n",
        " - múltiplas entradas;\n",
        " - múltiplas saídas;\n",
        " - compartilhamento de camadas;\n",
        " - lidar com topologias/fluxos não lineares ou sequenciais, tais como uma ramificação múltipla ou uma conexão residual (como na arquitetura ResNet). "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uat8Ahz1klZ0"
      },
      "source": [
        "#### 5.1.1 - Visualizando um Modelo\n",
        "Há várias formas de visualizar a estrutura de um modelo no TensorFlow, porém as mais comuns são via um resumo textual, que é mais simples, e a plotagem de um gráfico mais sofisticado."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Newby56Hkouy"
      },
      "source": [
        "# é preciso construir o modelo antes de acessar o sumário\n",
        "# para tanto, o método build, passando o shape do batch. \n",
        "# usaremos (None, 32) com um coringa\n",
        "model.build((None, 32))\n",
        "\n",
        "# imprime o sumário do modelo\n",
        "print( model.summary() )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "47X9AVw4lshw"
      },
      "source": [
        "Já a plotagem para uma imagem pode ser feita de forma conveniente usando a função utilitária\n",
        "[keras.utils.vis_utils.plot_model()](https://keras.io/api/utils/model_plotting_utils/#plotmodel-function)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0lsgTHcokqfb"
      },
      "source": [
        "\n",
        "from keras.utils.vis_utils import plot_model\n",
        "\n",
        "plot_model(model, to_file='sequential.png', show_shapes=True, show_layer_names=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9iflZdEums6l"
      },
      "source": [
        "### 5.2 Modelos Funcionais\n",
        "Modelos funcionais são construídos de forma mais complexa e declarativa do que modelos criados via **tf.keras.Sequential**. Isso é feito com base nas classes **tf.keras.Input** and **tf.keras.Model**, porém isso tem um efeito positivo, pois podem contornar as limitações de um modelo sequencial.\n",
        "\n",
        "Por exemplo, em modelos funcionais, é possível usar as variáveis como entradas ao mesmo tempo ou em diferentes fases do processamento do grafo. Além disso, os dados podem ser gerados como saída em diversas fases do processamento. Assim, é preferível utilizar modelos funcionais caso mais de uma saída seja necessária."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sBRQZO3AmzJZ"
      },
      "source": [
        "# usa a saída \n",
        "x = tf.keras.Input(shape=(32,))\n",
        "h1 = layers.Dense(32, activation='relu')(x)\n",
        "h2 = layers.Dense(32, activation='relu')(h1)\n",
        "y = layers.Dense(10, activation='softmax')(h2)\n",
        "\n",
        "# cria o modelo funcional, de 'x' para 'y'\n",
        "funcModel = tf.keras.models.Model(x, y)\n",
        "\n",
        "# exibe o sumário\n",
        "funcModel.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KES6dePLoLd6"
      },
      "source": [
        "### 5.3 Construindo Camadas de uma Rede Profunda\n",
        "O módulo **tf.keras.layers** contém funcionalidades que facilitam a configuraçã de camadas de uma rede neural. As classes mais comumente usadas são:\n",
        " - [tf.keras.layers.Dense](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense), uma camada totalmente conectada (fully connected);\n",
        " - [tf.keras.layers.Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D) e [tf.keras.layers.Conv3D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv3D), que constrem convoluções sobre imagens 2D e 3D, respectivamente;\n",
        " - [tf.keras.layers.MaxPool2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D) e [tf.keras.layers.AveragePooling2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D), para camadas de pooling usadas em CNNs;\n",
        " - [tf.keras.layers.RNN](https://www.tensorflow.org/api_docs/python/tf/keras/layers/RNN), para camada de uma rede neural recorrente;\n",
        " - [tf.keras.layers.LSTM](https://www.tensorflow.org/api_docs/python/tf/keras/layers/LSTM) e [tf.keras.layers.LSTMCell](https://www.tensorflow.org/api_docs/python/tf/keras/layers/LSTMCell), as quais constroem uma camada de uma rede LSTM e uma unidade LSTM, respectivamente;\n",
        " - similarmente, as classes [tf.keras.layers.GRU](https://www.tensorflow.org/api_docs/python/tf/keras/layers/GRU) e [tf.keras.layers.GRUCell](https://www.tensorflow.org/api_docs/python/tf/keras/layers/GRUCell) constroem uma camada de uma rede GRU e uma unidade GRU, respectivamente;\n",
        " - [tf.keras.layers.Embedding](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Embedding), a qual transforma índice, i.e., inteiros positivos, em um vetor de tamanho fixo. Contudo, um *embedding* só pode ser usado como a primeira camada de um modelo; e\n",
        " - [tf.keras.layers.Dropout](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dropout), o qual constrói uma camada de *dropout* que desativa aleatoriamente de entrada em tempo de treinamento para ajudar a prevenir *overfitting*.\n",
        "\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4w-6kV--uCB"
      },
      "source": [
        "Os principais parâmetros de configuração nas camadas disponíveis no pacote **f.keras.layers** são:\n",
        " - **activation**, define a função de ativação daquela camada. Por padrão, o sistema não aplica uma função;\n",
        " - **kernel_initializer** e **bias_initializer**, ambos opcionais, que definem como os pesos iniciais dos *kernels* e dos *biases* são computados. O método padrão é o inicializador uniforme Glorot;\n",
        " - **kernel_regularizer** e **bias_regularizer**, ambos opcionais, que definem os esquemas de regularização aplicados aos pesos (kernel e bias) da camada, tais como a regularização L1 ou L2. O sistema não aplica uma regularização por padrão."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hbzi6x-SvWbI"
      },
      "source": [
        "#### 5.3.1 **tf.keras.layers.Dense**\n",
        "Os principais parâmetros de configuração desse tipo de camada são:\n",
        " - *units*, número de neurônios;\n",
        " - *activation*, função de ativação;\n",
        " - *use_bias*, indica se usa ou não um bias, que são ativados por padrão;\n",
        " - *kernel_initializer*, inicializador de pesos do kernel;\n",
        " - *bias_initializer*, inicializador de pesos para do *bias*;\n",
        " - *kernel_regularizer* e *bias_regularizer*, esquema de regularização aplicável ao kernel e ao bias, respectivamente;\n",
        " - *activity_regularizer*, função de regularização aplicada à saída desta camada, i.e., à sua ativação;\n",
        " - *kernel_constraint* e *bias_constraint*, restrições aplicadas aos pesos do kernel e ao bias, respectivamente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNC_6zjK_nvv"
      },
      "source": [
        "\"\"\" Cria uma camada com 32 neurônios com ativação sigmóide.\n",
        "    Note-se que a ativação tanto pode ser uma string como a\n",
        "    própria função Python.\n",
        "\"\"\"\n",
        "layers.Dense(32, activation='sigmoid')\n",
        "layers.Dense(32, activation=tf.sigmoid)\n",
        "\n",
        "# definindo um inicializador de kernel \n",
        "layers.Dense(32, kernel_initializer=tf.keras.initializers.he_normal)\n",
        "# habilitando regularização L2 com fator 0.05\n",
        "layers.Dense(32, kernel_regularizer=tf.keras.regularizers.L2(0.05))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ngyEnG2RvlOl"
      },
      "source": [
        "#### 5.3.2 **tf.keras.layers.Conv2D**\n",
        "Os principais parâmetros de configuração de uma convolução 2D são:\n",
        " - *filters*, o número de kernels de convolução. Quanto maior, mais neurônios e conexões são criados para as dimensões de saída da camada;\n",
        " - *kernel_size*, largura e altura do kernel. Geralmente quanto maior, menor a saída;\n",
        " - *strides*, o deslocamento entre as convoluções ao longo da altura e largura;\n",
        " - *padding*, política de preenchimento das bordas. Quando o *padding* é definido como **'valid'**, apenas convoluções no domínio válido são efetuadas, ou seja, a borda externa não é processada por falta de informação. Caso o padding seja definido como **'same'**, a convolução preserva a borda e geralmente resulta em uma saída de mesma dimensão da entrada;\n",
        " - *activation* (opcional), função de ativação desta camada. Há diversas opções padrões no módulo [tf.keras.activations](https://www.tensorflow.org/api_docs/python/tf/keras/activations);\n",
        " - *data_format*, define o formato das dimensões nas entradas qual formato usar.\n",
        "  **channels_first**, valor padrão, dita o shape organizado como *(batch_size, channels,height, width)*. Já **channels_last** corresponde ao shape *(batch_size, height, width, channels)*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9E79kwMjhfS5"
      },
      "source": [
        "layers.Conv2D(64,[1,1],2,padding='same',activation=\"relu\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0EOk-9_Wvint"
      },
      "source": [
        "#### 5.3.3 **tf.keras.layers.MaxPool2D** e **tf.keras.layers.AveragePooling2D**\n",
        "Os principais argumentos que configuram esses operadores de pooling autoexplicativos são:\n",
        " - *pool_size=(2,2)*, dimensões do kernel a ser agrupado. Quanto maior, menor a saída produzida. Por exemplo, uma matriz 2 x 2 produz uma saída com metade do tamanho da entrada em ambas as dimensões. Caso um valor inteiro seja especificado, é usado em todas as dimensões; e\n",
        " - *strides=None*, deslocamento entre ativações consecutivas. Usado para aumentar a distância entre os elementos da entrada 2D.\n",
        "\n",
        "O exemplo a seguir constrói um operador que causa deslocamentos de 2 pixels em uma dimensão e 1 pixel na outra. Com efeito, a largura da saída é a metade da original, enquanto a altura da saída é menor do que a entrada por apenas 1 pixel. Confira mais exemplos e detalhes na documentação para [tf.keras.layers.MaxPool2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D) e [tf.keras.layers.AveragePooling2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4q81NrPBedU2"
      },
      "source": [
        "layers.MaxPooling2D(pool_size=(2,2),strides=(2,1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3LKnNdXAvmYu"
      },
      "source": [
        "#### 5.3.4 **tf.keras.layers.LSTM** e **tf.keras.layers.LSTMCell**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s3lOLcXdWqQ2"
      },
      "source": [
        "import numpy as np\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "# cria uma rede com uma camada LSTM\n",
        "inputs = tf.keras.Input(shape=(3, 1))\n",
        "lstm = layers.LSTM(1, return_sequences=True)(inputs)\n",
        "model_lstm_1 = tf.keras.models.Model(inputs=inputs, outputs=lstm)\n",
        "\n",
        "# cria uma segunda rede para comparar com a primeira\n",
        "inputs = tf.keras.Input(shape=(3, 1))\n",
        "lstm = layers.LSTM(1, return_sequences=False)(inputs)\n",
        "model_lstm_2 = tf.keras.models.Model(inputs=inputs, outputs=lstm)\n",
        "\n",
        "# cria uma sequência de entrada t1, t2, and t3\n",
        "# as LSTMs serão alimentadas com essa sequência\n",
        "data = [ [[0.1], [0.2], [0.3]] ]\n",
        "print(data)\n",
        "\n",
        "# a sequência de saída completa\n",
        "print(\"saída quando return_sequences=True :\", model_lstm_1.predict(data))\n",
        "# a última célula da sequência de saída\n",
        "print(\"saída quando return_sequences=False:\", model_lstm_2.predict(data))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wM2AEOYxWrWe"
      },
      "source": [
        "Já a classe LSTMCell é a implementação de uma unidade da camada LSTM."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_5ylggNVWlI4"
      },
      "source": [
        "# cria uma LSTM\n",
        "tf.keras.layers.LSTM(4, return_sequences=True)\n",
        "\n",
        "# cria uma unidade LSTMCell em uma RNN\n",
        "x = tf.keras.Input(shape=(3, 1))\n",
        "y = layers.RNN(layers.LSTMCell(4))(x)\n",
        "rnn = tf.keras.Model(x, y)\n",
        "\n",
        "# teste com dados aleatórios anteriores\n",
        "print(\"saída da RNN:\", rnn.predict(data))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VobCZ-f3wDps"
      },
      "source": [
        "### 5.4 Treinando e Avaliando o Modelo\n",
        "Veremos a seguir uma visão geral das várias etapas envolvidas no ciclo de vida de um modelo já criado, que compreende as seguintes etapas: *compilação*, *treinamento*, *avaliação do desempenho* e *inferência*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xZkonF9Jwh8u"
      },
      "source": [
        "#### 5.4.1 Compilando o Modelo\n",
        "Após construir um modelo, é necessário compilá-lo para configurar o seu processo de aprendizagem. Isso é encapsulado pelo método [compile()](https://www.tensorflow.org/api_docs/python/tf/keras/Model#compile) da classe **tf.keras.Model**, cujos principais argumentos são:\n",
        " - *optimizer='rmsprop'*, string identificando o otimizador;\n",
        " - *loss=None*, a função de perda usada para guiar o processo de otimização;\n",
        " - *metrics=None*, lista de critérios de avaliação do modelo durante treino e teste. Geralmente se usa *metrics=['accuracy']*. Várias conversões internas são feitas automaticamente para que o método de computação da acurácia seja adequado à rede do seu modelo; e\n",
        " - *loss_weights=None*, argumento muito conveniente para modelos que lidam com múltiplas tarefas e que devem produzir múltiplas saídas. Assim, *loss_weights* define um peso para cada uma dessas saídas quando o treinamento estiver otimizando o *loss* global composto."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QjMIGdTCDGJq"
      },
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "# cria um modelo muito simples\n",
        "model = tf.keras.Sequential()\n",
        "model.add( tf.keras.layers.Dense(10, activation='softmax'))\n",
        "\n",
        "\"\"\"\n",
        "Configura a aprendizagem do modelo:\n",
        " - Adam como otimizador;\n",
        " - categorical_crossentropy como função de perda;\n",
        " - categorical_accuracy como método de avaliação de desempenho.\n",
        "\"\"\"\n",
        "model.compile(optimizer=tf.keras.optimizers.Adam(0.001),\n",
        "             loss=tf.keras.losses.categorical_crossentropy,\n",
        "             metrics=[tf.keras.metrics.categorical_accuracy])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0-r8iSMwlMn"
      },
      "source": [
        "#### 5.4.2 Treinando um Modelo\n",
        "O processo de treinamento do modelo é disparado pelo método [fit()](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit) da classe **tf.keras.Model**. Esses são os principais argumentos do método **fit()**:\n",
        " - *x=None*, dados de entrada;\n",
        " - *y=None*, dados-alvo da saída desse modelo;\n",
        " - *batch_size=None*, tamanho do lote;\n",
        " - *epochs=1*, épocas, i.e., número de vezes que o modelo percorre um dataset por treinamento;\n",
        " - *verbose=1*, modo de verbosidade, que influencia as mensagens impressas durante o treinamento.  0 = silencioso, 1 = barra de progresso, 2 = uma linha por época;\n",
        " - *callbacks=None*, lista opcional de callbacks, úteis para customizar o treinamento;\n",
        " - *validation_split=0.0*, número entre 0 e 1 usado para informar qual fração dos dados de treinamento será usada para validação;\n",
        " - *validation_data=None*, dataset de validação. Quando informado, *validation_split* é ignorado;\n",
        " - *shuffle=True*, indica se os dados devem ser embaralhados antes de cada iteração. Inválido se *steps_per_epoch* não for None;\n",
        " - *initial_epoch=0*, diz em qual época o treinamento inicia. Útil para continuar o processo de treino;\n",
        " - *steps_per_epoch=None*, número total de passos (batches de amostras) entes de considerar que uma época do treinamento foi finalizada. Seu valor depende do tamanho do dataset e do tamanho do batch (*batch_size*); e\n",
        " - *validation_steps*, número total de passos (batches de amostras) de validação validar antes de acabar uma época. Válido apenas quando *steps_per_epoch* é fornecido."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "azUwqG73C0FO"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# produz um dataset aleatório\n",
        "train_x = np.random.random((1000, 36))\n",
        "train_y = np.random.random((1000, 10))\n",
        "val_x = np.random.random((200, 36))\n",
        "val_y = np.random.random((200, 10))\n",
        "\n",
        "# invoca o método de treinamento\n",
        "model.fit(train_x, train_y, epochs=10, batch_size=100,\n",
        "          validation_data=(val_x, val_y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Hbp_YJDC4-_"
      },
      "source": [
        "Treinamento com datasets de grande escala requer uma pipeline adequada. Por exemplo, pode ser necessário repetir um *dataset*, para que seja revisto várias vezes durante o treinamento: isso pode ser feito usando o método [repeat()](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#repeat) da classe **Dataset**. Por outro lado, também é possível um controle sobre como os datasets de treinamento e de validação são usados a cada época. Isso é ilustrado no exemplo a seguir."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nPV9B6FeC88s"
      },
      "source": [
        "# dataset de treinamento\n",
        "dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y))\n",
        "dataset = dataset.batch(32)\n",
        "dataset = dataset.repeat() # repete indefinidamente\n",
        "\n",
        "# dataset de validação\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((val_x, val_y))\n",
        "val_dataset = val_dataset.batch(32)\n",
        "val_dataset = val_dataset.repeat() # repete indefinidamente\n",
        "\n",
        "\"\"\"\n",
        "O processo de treinamento procede assim:\n",
        " - são 10 épocas sobre todo o dataset;\n",
        " - a cada época, 30 passos são usasos para treino e 3 para teste.\n",
        "\"\"\"\n",
        "model.fit(dataset, epochs=10, steps_per_epoch=30,\n",
        "          validation_data=val_dataset, validation_steps=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-UfMU4k4wu1v"
      },
      "source": [
        "#### 5.4.3 Tratando Eventos de Treinamento: Funções Callback\n",
        "O processo de treinamento é longo, de modo que ocorrerão diversos eventos que podem (e devem) ser tratados para que o programador consiga customizar o processo desejado. Exemplo de eventos incluem: salvamento de uma cópia de segurança (*checkpoint*), alteração do *learning rate*, parada prematura e exportação de dados de progresso para o TensorBoard.\n",
        "\n",
        "Desse modo, o programador pode especificar diferentes funções para tratar esses eventos. Essas funções são chamadas de *callbacks* e permitem estender o comportamento do modelo durante a fase de treinamento. Por conveniência, a API do TensorFlow oferece diversas funções pré-prontas no módulo [tf.keras.callbacks](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks), porém o programador também tem a liberdade de definir suas próprias funções.\n",
        "\n",
        "Os principais *callbacks* no módulo **tf.keras.callbacks** são:\n",
        " - **ModelCheckpoint**, que periodicamente salva modelos;\n",
        " - **LearningRateScheduler**, que altera o *learning rate* dinamicamente durante o treinamento, permitindo que o usuário defina o controle fino dessa política no otimizador;\n",
        " - **EarlyStopping**, que faz com que o treinamento seja abortado;\n",
        " - **TensorBoard**, para exportação e visualização de informações sobre o progresso e os resultados do treinamento por meio da ferramenta [TensorBoard](https://www.tensorflow.org/tensorboard/get_started).\n",
        "\n",
        "O exemplo a seguir definirá funções callback customizadas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ix_1_3OA_yrx"
      },
      "source": [
        "# hiperparâmetros do treinamento\n",
        "Epochs = 10\n",
        "\n",
        "# escalonador de learning rate customizado por época\n",
        "def lr_Scheduler(epoch):\n",
        "    if epoch > 0.9 * Epochs:\n",
        "        lr = 0.0001\n",
        "    elif epoch > 0.5 * Epochs:\n",
        "        lr = 0.001\n",
        "    elif epoch > 0.25 * Epochs:\n",
        "        lr = 0.01\n",
        "    else:\n",
        "        lr = 0.1\n",
        "        \n",
        "    print(lr)\n",
        "    return lr\n",
        "            \n",
        "\n",
        "callbacks = [\n",
        "    # condições para abortar o treinamento\n",
        "    tf.keras.callbacks.EarlyStopping(\n",
        "        # métrica usada para checar se o modelo estagnou o desempenho\n",
        "        monitor='val_loss',\n",
        "        # limiar para determinar se o desempenho melhorou\n",
        "        min_delta=1e-2,\n",
        "        # número de épocas para aguardar enquanto o modelo não melhora o desempenho\n",
        "        patience=2),\n",
        "    \n",
        "    # criação de checkpoints\n",
        "     tf.keras.callbacks.ModelCheckpoint(\n",
        "        # onde salvar: path usa a época\n",
        "        filepath='testmodel_{epoch}.h5',\n",
        "        # manter todos os modelos ou salvar apenas o melhor?\n",
        "        save_best_only=True,\n",
        "        # qual a métrica monitorada\n",
        "        monitor='val_loss'),\n",
        "    \n",
        "    # instala a política de alteração learning rate.\n",
        "    tf.keras.callbacks.LearningRateScheduler(lr_Scheduler),\n",
        "    \n",
        "    # configura o uso de TensorBoard\n",
        "    tf.keras.callbacks.TensorBoard(log_dir='./logs')\n",
        "]\n",
        "\n",
        "# inicia o treinamento\n",
        "model.fit(train_x, train_y, batch_size=16, epochs=Epochs,\n",
        "         callbacks=callbacks, validation_data=(val_x, val_y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vDMacrLFw7Iv"
      },
      "source": [
        "#### 5.4.4 Avaliando o Modelo\n",
        "A avaliação do modelo pode ser feita usando o método [evaluate()](https://www.tensorflow.org/api_docs/python/tf/keras/Model#evaluate). Note-se que o processamento é realizado por lotes, de acordo com o parâmetro **batch_size**, como no exemplo a seguir.\n",
        "Como resultado, teremos métricas como *loss* e acurácia."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0MKKU7yS_BDL"
      },
      "source": [
        "# cria amostras de entrada\n",
        "test_x = np.random.random((1000, 36))\n",
        "test_y = np.random.random((1000, 10))\n",
        "\n",
        "# o tipo dos objetos em y é consistente com aqueles em x\n",
        "model.evaluate(test_x, test_y, batch_size=32)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VPOECyT__bGS"
      },
      "source": [
        "**NOTA:** o exemplo acima é apenas ilustrativo,sendo propositalmente aleatório, portanto não espere que o modelo consiga aprender um padrão consistente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A99WbA-jxD_O"
      },
      "source": [
        "#### 5.4.5 Usando o Modelo para Inferência\n",
        "Basta invocar o médoto [predict()](https://www.tensorflow.org/api_docs/python/tf/keras/Model#predict) do modelo com um tensor de entrada representando uma amostra ou um lote de amostras."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8vgjmjKOxIyH"
      },
      "source": [
        "# entrada aleatória\n",
        "pre_x = np.random.random((10, 36))\n",
        "\n",
        "# inferência simples\n",
        "result = model.predict(test_x,)\n",
        "\n",
        "# visualização do resultado\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ekGXVmuuxUCR"
      },
      "source": [
        "### 5.5 Salvando e Carregando Modelos\n",
        "O treinamento de um modelo de *deep learning* é uma tarefa delicada e computacionalmente complexa que pode demorar horas, dias ou mesmo semanas. Isso posto, é importante saber como manter seus modelos à disposição no disco e como carregá-los depois."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C-iLaiSexcRm"
      },
      "source": [
        "#### 5.5.1 Salvando e Carregando o Modelo Completo\n",
        "Salvar o modelo é relativamente simples. Todavia, esse processo perpetua todos os pesos ao longo da rede e também a estrutura do grafo computacional, *i.e.*, a descrição das camadas e conexões que compõem a rede.\n",
        "\n",
        "Além disso, o arquivo também conterá outras informações que permitirão continuar o treinamento do modelo, caso necessário."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvi8tkQA04Kj"
      },
      "source": [
        "import numpy as np\n",
        "from os import path, mkdir\n",
        "\n",
        "if not path.exists('./model'):\n",
        "  mkdir('./model')\n",
        "\n",
        "# salva o modelo completo\n",
        "model.save('./model/the_best_model.h5')\n",
        "\n",
        "# -----------------------------------------------------------------\n",
        "# o carregamento do modelo é simples: uma chamada\n",
        "new_model = tf.keras.models.load_model('./model/the_best_model.h5')\n",
        "new_prediction = new_model.predict(test_x)\n",
        "\n",
        "\n",
        "# teste de similaridade entre os objetos considerando uma margem\n",
        "np.testing.assert_allclose(result, new_prediction, atol=1e-6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7urb9j7zxilH"
      },
      "source": [
        "#### 5.5.2 Salvando e Carregando apenas os Pesos da Rede\n",
        "Caso o nome do arquivo de pesos possua o sufixo **.h5** ou **.keras**, o modelo será salvo para o formato HDF5 (*Hierarchical Data Format*) binário e eficiente. Caso contrário, pode-se salvar o modelo como um checkpoint do TensorFlow."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ddx0eS5yFTv"
      },
      "source": [
        "# salvamento do modelo em duas opções\n",
        "model.save_weights('./model/model_weights') #checkpoint\n",
        "model.save_weights('./model/model_weights.h5')\n",
        "\n",
        "# carregamento dos pesos em duas opções\n",
        "model.load_weights('./model/model_weights') # checkpoint\n",
        "model.load_weights('./model/model_weights.h5')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}