1.1-TFHelloWorldAula.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TENSORFLOW: Alô Mundo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta aula cobre fundamentos, grafos de tensores, tensores, variáveis, placeholders e _operações_ $\\mathcal{M}_3$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref2\"></a>\n",
    "# Como o TensorFlow funciona?\n",
    "\n",
    "Para executar código em diferentes hardwares desde CPUs a GPUS, o TensorFlow define _computações como grafos_. Estas computações são chamadas operações (_ops_). De forma geral, programar em TensorFlow é definir uma série de ops, criando um grafo geral de computação e, então, executar este grafo em uma sessão.\n",
    "\n",
    "Executar o grafo em um sessão pode ser visto como compilá-lo para o hardware alvo e, então, executá-lo. \n",
    "\n",
    "Por exemplo, abaixo temos a representação de um grafo em TensorFlow. _W_, _x_ e _b_ são tensores representados como arestas no grafo. _MatMul_ é uma operação sobre _W_ e _x_, cujo resultado será parâmetro para _Add_ para que seja somada com _b_. Os vetores resultantes vão sendo propagados até que o vetor _C_ receba a avaliação final do grafo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/mod_ID_23_final.png'>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importando TensorFlow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\Anaconda\\lib\\site-packages\\h5py\\__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref3\"></a>\n",
    "# Criando um Grafo\n",
    "\n",
    "Vamos criar a operação c = a + b.\n",
    "\n",
    "Entre as operações suportadas, é possível usar __source operations__, que não precisam de informação de entrada. Em geral, elas existem para fornecer entradas para outras operações.\n",
    "\n",
    "Vamos criar source ops para definir duas constantes -- tensores [2] e [3]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = tf.constant([2])\n",
    "b = tf.constant([3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para somá-las, podemos usar __tf.add()__ ou simplesmente +. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = tf.add(a,b)\n",
    "#c = a + b        # equivalente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que c não tem o valor de a+b. Para a atribuição ser executada, é necessário criar uma sessão."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "session = tf.Session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora podemos executar a computação c:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5]\n"
     ]
    }
   ],
   "source": [
    "result = session.run(c)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ao fim do uso da sessão, devemos fechá-la:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "session.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para evitar ter que sempre lembrar de fechar sessões, vamos usar o comando de guarda __with__ do Python, que garante a abertura e fechamento da Sessão:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as session:\n",
    "    result = session.run(c)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativamente, __apenas__ no ambiente jupyter, podemos usar sessões interativas, que são válidas para todo notebook até serem fechadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "session = tf.InteractiveSession()\n",
    "\n",
    "session.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Muito complexo? Bom, isso é programar em TensorFlow:\n",
    "\n",
    "1. defina o grafo da computação\n",
    "2. execute-o em uma sessão"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### O que é um Tensor?\n",
    "\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">\n",
    "<font size = 3><strong>Para TensorFlow, é um tipo usado para representar dados em um grafo de computação. Como os valores fluem pelo grafo como tensores, temos TensorFlow</strong></font>\n",
    "<br>\n",
    "<br>\n",
    "O termo __tensor__ vem do Latin e significa algo como \"algo que estica/comprime\". É um objeto matemático criado inicialmente para o estudo da expansão/compressão de materias sobre tensão. Representa uma generalização do conceito de matrizes multi-dimensionais, sem a restrição de associação com linearidade. \n",
    "\n",
    "<p></p>\n",
    "\n",
    "</div>\n",
    "\n",
    "Para entender o conceito de multi-dimensionalidade, é necessário entender o conceito Físico de dimensões:<br>\n",
    "<img src=\"images/Dimension_levels.svg\"/>\n",
    "<div style=\"text-align:center\">[[Image Source]](https://en.wikipedia.org/wiki/Dimension) </div>\n",
    "\n",
    "Dimensão zero se refere ao ponto (escalar), a um objeto isolado ou a um item único.\n",
    "\n",
    "Dimensão 1 é linha (vetor). A dimensão 1 contém infinitas dimensões 0 (ou uma amostra delas, em um vetor ;)).\n",
    "\n",
    "Dimensão 2 é a superfície (vetor 2D ou matriz). Uma série infinita de linhas ao longo de uma linha infinita. \n",
    "\n",
    "Dimensão 3 é o volume ou matriz 3D. Uma série infinita de superfícies ao longo de uma linha infinita.\n",
    "\n",
    "Dimensão 4 é o hiperespaço (ou o espaço-tempo). Um volume variando ao longo do tempo ou uma série infinita de volumes ao longo de uma linha infinita. E assim em diante..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sumarizando:<br><br>\n",
    "<table style=\"width:100%\">\n",
    "  <tr>\n",
    "    <td><b>Dimensão</b></td>\n",
    "    <td><b>Representação</b></td> \n",
    "    <td><b>Matemática</b></td>\n",
    "    <td><b>Programação</b></td>\n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>Zero </td>\n",
    "    <td>Ponto</td> \n",
    "    <td>Escalar</td>\n",
    "    <td>[ 1 ]</td>\n",
    "  </tr>\n",
    "\n",
    "  <tr>\n",
    "    <td>Um</td>\n",
    "    <td>Linha</td> \n",
    "    <td>Vetor (Séries of Números) </td>\n",
    "    <td>[ 1,2,3,4,... ]</td>\n",
    "  </tr>\n",
    "  \n",
    "   <tr>\n",
    "    <td>Dois</td>\n",
    "    <td>Surpefícies</td> \n",
    "    <td>Matriz (Série de Vetores)</td>\n",
    "    <td>[ [1,2,3,4,...], [1,2,3,4,...], [1,2,3,4,...],... ]</td>\n",
    "  </tr>\n",
    "  \n",
    "   <tr>\n",
    "    <td>Três</td>\n",
    "    <td>Volume</td> \n",
    "    <td>Tensor (Série de Matrizes)</td>\n",
    "    <td>[ [[1,2,...], [1,2,...], [1,2,...],...], [[1,2,...], [1,2,...], [1,2,...],...], [[1,2,...], [1,2,...], [1,2,...] ,...]... ]</td>\n",
    "  </tr>\n",
    "  \n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref5\"></a>\n",
    "# Por que usar tensores?\n",
    "\n",
    "Tensores permitem que conjuntos de números sejam arranjados (shape) do modo mais adequado (inclusive para o hardware).\n",
    "\n",
    "É particularmente útil com imagens devido à forma como a informação é codificada em imagens. \n",
    "\n",
    "Como imagens tem altura e largura (2 dimensões), é fácil pensá-las como matrizes de números. Como elas tem cores (terceira dimensão), é mais fácil ainda pensá-las como um tensor de números (um cubo), ou seja um vetor de matrizes de números.\n",
    "\n",
    "A codificação mais comum de cores é a RGB (Red, Blue e Green), em que a cor é reprensentada por 3 cores primárias. A imagem pode ser pensada então como tendo três canais, um para cada cor:\n",
    "\n",
    "<img src='images/IC676790.png'>\n",
    "<div style=\"text-align:center\">[[Image Source]](https://msdn.microsoft.com/en-us/library/windows/desktop/dn424131.aspx)</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref4\"></a>\n",
    "# Definindo tensores\n",
    "Agora vamos definir esses objetos em TensorFlow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escalar (1):\n",
      " [2] \n",
      "\n",
      "Vetor (3 entradas) :\n",
      " [5 6 2] \n",
      "\n",
      "Matriz (3x3 entradas):\n",
      " [[1 2 3]\n",
      " [2 3 4]\n",
      " [3 4 5]] \n",
      "\n",
      "Tensor (3x3x3 entradas) :\n",
      " [[[ 1  2  3]\n",
      "  [ 2  3  4]\n",
      "  [ 3  4  5]]\n",
      "\n",
      " [[ 4  5  6]\n",
      "  [ 5  6  7]\n",
      "  [ 6  7  8]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [ 8  9 10]\n",
      "  [ 9 10 11]]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "Scalar = tf.constant([2])\n",
    "Vector = tf.constant([5,6,2])\n",
    "Matrix = tf.constant([[1,2,3],[2,3,4],[3,4,5]])\n",
    "Tensor = tf.constant( [ [[1,2,3],[2,3,4],[3,4,5]], \n",
    "                       [[4,5,6],[5,6,7],[6,7,8]] , \n",
    "                       [[7,8,9],[8,9,10],[9,10,11]] ] )\n",
    "with tf.Session() as session:\n",
    "    result = session.run(Scalar)\n",
    "    print(\"Escalar (1):\\n %s \\n\" % result)\n",
    "    result = session.run(Vector)\n",
    "    print(\"Vetor (3 entradas) :\\n %s \\n\" % result)\n",
    "    result = session.run(Matrix)\n",
    "    print(\"Matriz (3x3 entradas):\\n %s \\n\" % result)\n",
    "    result = session.run(Tensor)\n",
    "    print(\"Tensor (3x3x3 entradas) :\\n %s \\n\" % result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos praticar com o uso destas estruturas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usando TensorFlow tf.add:\n",
      "[[3 4 5]\n",
      " [4 5 6]\n",
      " [5 6 7]]\n",
      "Usando +:\n",
      "[[3 4 5]\n",
      " [4 5 6]\n",
      " [5 6 7]]\n"
     ]
    }
   ],
   "source": [
    "Matrix_one = tf.constant([[1,2,3],[2,3,4],[3,4,5]])\n",
    "Matrix_two = tf.constant([[2,2,2],[2,2,2],[2,2,2]])\n",
    "\n",
    "first_operation = tf.add(Matrix_one, Matrix_two)\n",
    "second_operation = Matrix_one + Matrix_two\n",
    "\n",
    "with tf.Session() as session:\n",
    "    result = session.run(first_operation)\n",
    "    print(\"Usando TensorFlow tf.add:\")\n",
    "    print(result)\n",
    "    result = session.run(second_operation)\n",
    "    print(\"Usando +:\")\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6]\n",
      " [ 4  6  8]\n",
      " [ 6  8 10]]\n"
     ]
    }
   ],
   "source": [
    "Matrix_one = tf.constant([[1,2,3],[2,3,4],[3,4,5]])\n",
    "Matrix_two = tf.constant([[2,2,2],[2,2,2],[2,2,2]])\n",
    "\n",
    "second_operation = Matrix_one * Matrix_two\n",
    "\n",
    "with tf.Session() as session:\n",
    "    result = session.run(second_operation)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que * corresponde à multiplicação elemento-a-elemento ou produto de Hadamard. <br>\n",
    "\n",
    "Para multiplicação de matrizes, usamos __tf.matmul()__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.matmul :\n",
      "[[13 18 23]\n",
      " [18 25 32]\n",
      " [28 39 50]]\n"
     ]
    }
   ],
   "source": [
    "Matrix_one = tf.constant([[2,3],[3,4],[5,6]])\n",
    "Matrix_two = tf.constant([[2,3,4],[3,4,5]])\n",
    "\n",
    "first_operation = tf.matmul(Matrix_one, Matrix_two)\n",
    "\n",
    "with tf.Session() as session:\n",
    "    result = session.run(first_operation)\n",
    "    print(\"tf.matmul :\")\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que, embora seja trivial definir estas funções, é sempre melhor optar pelas implementações dadas pela biblioteca, se estiverem disponíveis. Em geral, elas foram implementadas de forma a tirar maior proveito de paralelização no hardware."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: Dadas as matrizes $m_1$ e $m_2$, calcule $m_3 = m_1 \\times m_2^T$:\n",
    "\n",
    "$$\n",
    "m1 = \\begin{bmatrix}\n",
    "1 & 2 & 3 \\\\\n",
    "4 & 5 & 6 \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "m2 = \\begin{bmatrix}\n",
    "7 & 8 & 9 \\\\\n",
    "10 & 11 & 12 \\\\\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\">\n",
    "<a href=\"#mult1\" class=\"btn btn-default\" data-toggle=\"collapse\">Solução #1</a>\n",
    "</div>\n",
    "<div id=\"mult1\" class=\"collapse\">\n",
    "```\n",
    "import tensorflow as tf\n",
    "\n",
    "# construcao\n",
    "\n",
    "m1 = tf.constant([[1,2,3], [4,5,6]])\n",
    "m2 = tf.constant([[7,8,9], [10,11,12]])\n",
    "\n",
    "m3 = tf.matmul(m1, tf.transpose(m2))\n",
    "\n",
    "# execução\n",
    "\n",
    "s = tf.Session()\n",
    "res = s.run(m3)\n",
    "print res\n",
    "s.close()\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref6\"></a>\n",
    "# Variáveis\n",
    "\n",
    "Para definir variáveis, usamos o comando __tf.variable()__. Variáveis precisam ser iniciadas antes que o grafo seja avaliado. Isto é feito com __tf.global_variables_initializer()__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Variable:0' shape=() dtype=int32_ref>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = tf.Variable(0)\n",
    "state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar um contador:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "one = tf.constant(1)\n",
    "#new_value = tf.add(state, one)\n",
    "update = tf.assign(state, state + one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também devemos definir a operação de inicialização:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "init_op = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma vez iniciada a sessão, devemos executar o grafo e iniciar suas variáveis. Para observar as mudanças na variável __state__, vamos imprimi-la logo após a inicialização e, então, atualizar seu valor algumas vezes em um laço:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 <- depois de iniciada e antes do loop\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as session:\n",
    "  session.run(init_op)\n",
    "  print(session.run(state), '<- depois de iniciada e antes do loop')\n",
    "  for _ in range(3):\n",
    "    session.run(update)\n",
    "    print(session.run(state))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: dado o código abaixo, escreva um equivalente em tensorflow:\n",
    "\n",
    "```python\n",
    "cont = 1  # iniciar\n",
    "while cont<1024:\n",
    "    print cont # uso \n",
    "    cont = cont * 2 # atualizacoes\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\">\n",
    "<a href=\"#cont\" class=\"btn btn-default\" data-toggle=\"collapse\">Solução #1</a>\n",
    "</div>\n",
    "<div id=\"cont\" class=\"collapse\">\n",
    "```\n",
    "import tensorflow as tf\n",
    "\n",
    "# construcao\n",
    "contador = tf.Variable(1, dtype = tf.int32, name = 'contador')\n",
    "incremente = tf.assign(contador, contador *2)\n",
    "# contador = contador *2\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "\n",
    "# execução\n",
    "\n",
    "with tf.Session() as s:\n",
    "    s.run(init)\n",
    "    res = contador.eval()\n",
    "    while res < 1024:\n",
    "        print(res)\n",
    "        res = s.run(incremente)\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref7\"></a>\n",
    "# Placeholders\n",
    "\n",
    "Agora vamos ver como alimentar um grafo com dados que vem de fora do modelo que estamos criando. Para isso, vamos usar _placeholders_.\n",
    "\n",
    "Placeholders são as portas de entrada do seu modelo. São definidos com <br/> <b>tf.placeholder(_tipo_)</b>, onde <b>_tipo_</b> especifica o tipo de dados (integers, floating points, strings, booleans) junto com sua precisão (8, 16, 32, 64) em bits:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Data type\t|Python type|Description|\n",
    "| --------- | --------- | --------- |\n",
    "|DT_FLOAT\t|tf.float32\t|32 bits floating point.|\n",
    "|DT_DOUBLE\t|tf.float64\t|64 bits floating point.|\n",
    "|DT_INT8\t|tf.int8\t|8 bits signed integer.|\n",
    "|DT_INT16\t|tf.int16\t|16 bits signed integer.|\n",
    "|DT_INT32\t|tf.int32\t|32 bits signed integer.|\n",
    "|DT_INT64\t|tf.int64\t|64 bits signed integer.|\n",
    "|DT_UINT8\t|tf.uint8\t|8 bits unsigned integer.|\n",
    "|DT_STRING\t|tf.string\t|Variable length byte arrays. Each element of a Tensor is a byte array.|\n",
    "|DT_BOOL\t|tf.bool\t|Boolean.|\n",
    "|DT_COMPLEX64\t|tf.complex64\t|Complex number made of two 32 bits floating points: real and imaginary parts.|\n",
    "|DT_COMPLEX128\t|tf.complex128\t|Complex number made of two 64 bits floating points: real and imaginary parts.|\n",
    "|DT_QINT8\t|tf.qint8\t|8 bits signed integer used in quantized Ops.|\n",
    "|DT_QINT32\t|tf.qint32\t|32 bits signed integer used in quantized Ops.|\n",
    "|DT_QUINT8\t|tf.quint8\t|8 bits unsigned integer used in quantized Ops.|\n",
    "\n",
    "<div style=\"text-align:center\">[[Table Source]](https://www.tensorflow.org/versions/r0.9/resources/dims_types.html)</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar um placeholder para um número real de 32 bits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = tf.placeholder(tf.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E definir uma multiplicação com ele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = a*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para usar o placeholder, é necessário definir o valor do argumento feed_dict de run(). Este argumento define um dicionário que indica o nome e o valor que o palceholder vai ter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2*a = 7.0\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    result = sess.run(b, feed_dict={a:3.5})\n",
    "    print('2*a =', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qualquer tipo de tensor pode ser passado para um placeholder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2*a = [[[ 2.  4.  6.]\n",
      "  [ 8. 10. 12.]\n",
      "  [14. 16. 18.]\n",
      "  [20. 22. 24.]]\n",
      "\n",
      " [[26. 28. 30.]\n",
      "  [32. 34. 36.]\n",
      "  [38. 40. 42.]\n",
      "  [44. 46. 48.]]]\n"
     ]
    }
   ],
   "source": [
    "dictionary={a: [ [ [1,2,3],[4,5,6],[7,8,9],[10,11,12] ] , \n",
    "                [ [13,14,15],[16,17,18],[19,20,21],[22,23,24] ] ] }\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    result = sess.run(b, feed_dict = dictionary)\n",
    "    print('2*a =', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No exemplo a seguir, usamos placeholders para definir os valores de uma equação de segundo grau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = tf.placeholder(tf.complex64, name='a')\n",
    "b = tf.placeholder(tf.complex64, name='b')\n",
    "c = tf.placeholder(tf.complex64, name='c')\n",
    "\n",
    "#with tf.name_scope('delta'):\n",
    "delta = b*b - 4*a*c\n",
    "with tf.name_scope('x0'):\n",
    "    x0 = (-b - tf.sqrt(delta))/(2*a)\n",
    "with tf.name_scope('x1'):\n",
    "    x1 = (-b + tf.sqrt(delta))/(2*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-2-1j) (-2+1j)\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as s:\n",
    "    rx0, rx1 = s.run([x0, x1], feed_dict={a:1., b:4., c:5.})\n",
    "    print (rx0, rx1)\n",
    "    tf.summary.FileWriter('logs/tfhelloworld', s.graph).close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dê uma olhada agora no tensorboard para ver o grafo gerado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ref8\"></a>\n",
    "# Operações\n",
    "\n",
    "TensorFlow define uma grande variedade de operações que podem ser realizadas com tensores, tais como _tf.matmul_, _tf.add_ e _tf.nn.sigmoid_.  \n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">Para uma lista de operações, olhe a API python: https://www.tensorflow.org/versions/r1.1/api_docs/python/index.html</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c =: [7]\n",
      "d =: [3]\n"
     ]
    }
   ],
   "source": [
    "a = tf.constant([5])\n",
    "b = tf.constant([2])\n",
    "c = a + b\n",
    "d = a - b\n",
    "\n",
    "with tf.Session() as session:\n",
    "    result = session.run(c)\n",
    "    print('c =: %s' % result)\n",
    "    result = session.run(d)\n",
    "    print('d =: %s' % result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a fase de construção do grafo pode envolver operações complexas. Por exemplo, imagine que queremos definir uma sequência fatorial, ou seja, uma sequência $S$ de números que começa com 1 e cujo valor do $i$-ésimo número é $i S_{i-1}$. Por exemplo, os 5 primeiros valores de $S$ são [1, 1, 2, 6, 24].\n",
    "\n",
    "Podemos definir essa sequencia em TF assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "S = [tf.constant(1)]\n",
    "i = 1\n",
    "while i < 5:\n",
    "    S = S + [i * S[i-1]]\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as s:\n",
    "    res = s.run(S)\n",
    "    print(res)\n",
    "    tf.summary.FileWriter('logs/tfhelloworld', s.graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "S = [tf.constant(1, name=\"S0\")]\n",
    "i = 1\n",
    "while i < 5:\n",
    "    S = S + [tf.multiply(i, S[i-1], name = \"ixS\" + str(i-1))]\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as s:\n",
    "    res = s.run(S)\n",
    "    print(res)\n",
    "    tf.summary.FileWriter('logs/tfhelloworld', s.graph).close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício**: Faça um grafo em tensorflow que gere uma lista com os dez primeiros membros da sequência de Fibonnaci:\n",
    "\n",
    "$$\n",
    "F_0 = 1 \\\\\n",
    "F_1 = 1 \\\\\n",
    "F_n = F_{n-1} + F_{n-2},\\forall n>=2 \n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"left\">\n",
    "<a href=\"#fib\" class=\"btn btn-default\" data-toggle=\"collapse\">Dica</a>\n",
    "</div>\n",
    "<div id=\"fib\" class=\"collapse\">\n",
    "Em python puro, o codigo seria:\n",
    "```python\n",
    "fib = [1,1]\n",
    "i = 2\n",
    "while i < 6:\n",
    "    fib = fib + [fib[i-1] + fib[i-2]]\n",
    "    i += 1\n",
    "print fib\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\">\n",
    "<a href=\"#fib\" class=\"btn btn-default\" data-toggle=\"collapse\">Solução #1</a>\n",
    "</div>\n",
    "<div id=\"fib\" class=\"collapse\">\n",
    "```\n",
    "tf.reset_default_graph()\n",
    "\n",
    "fib = [tf.constant(1,name='fib0'),tf.constant(1,name='fib1')]\n",
    "\n",
    "i = 2\n",
    "while i<6:\n",
    "    fib = fib+ [tf.add(fib[i-1],fib[i-2],name='fib'+str(i))]\n",
    "    i+=1\n",
    "\n",
    "with tf.Session() as s:\n",
    "    print(s.run(fib))\n",
    "    tf.summary.FileWriter('logs/fib', s.graph).close()\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Referências:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.tensorflow.org/versions/r0.9/get_started/index.html<br />\n",
    "http://jrmeyer.github.io/tutorial/2016/02/01/TensorFlow-Tutorial.html<br />\n",
    "https://www.tensorflow.org/versions/r0.9/api_docs/python/index.html<br />\n",
    "https://www.tensorflow.org/versions/r0.9/resources/dims_types.html<br />\n",
    "https://en.wikipedia.org/wiki/Dimension<br />\n",
    "https://book.mql4.com/variables/arrays<br />\n",
    "https://msdn.microsoft.com/en-us/library/windows/desktop/dn424131(v=vs.85).aspx<br />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este curso é baseado em material da [Big Data University](https://bigdatauniversity.com/?utm_source=bducopyrightlink&utm_medium=dswb&utm_campaign=bdu). Assim, segue os termos da [licença do MIT](https://bigdatauniversity.com/mit-license/). Aula modificada por Marco Cristo e André Carvalho a partir de versão de _Rafael Belo da Silva_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}