PAVIC_ML_04_Backpropagation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wallisonferreira/machine-learning-pavic/blob/main/PAVIC_ML_04_Backpropagation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "xSaoX9nyOAUq"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "id9SLPA__hOq"
      },
      "source": [
        "A melhor maneira de pensar em redes neurais é como circuitos de valores reais. Mas, ao invés de valores booleanos, valores reais e, ao invés de portas lógicas como **and** ou **or**, portas binárias (dois operandos) como $*$ (multiplicação), + (adição), max, exp, etc. Além disso, também teremos **gradientes** fluindo pelo circuito, mas na direção oposta."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "Y0f-wxW8_FMQ"
      },
      "outputs": [],
      "source": [
        "#Slide 43-46\n",
        "#multiply gate\n",
        "def forwardMultiplyGate(a, b):\n",
        "    return a * b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4XcXrk9o_l9C"
      },
      "source": [
        "De forma matemática, a gente pode considerar que essa porta implementa a seguinte função:\n",
        "\n",
        "$$f(x,y)=x*y$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6wgw17iG_rO9"
      },
      "source": [
        "## O Objetivo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qcK3YjMG_std"
      },
      "source": [
        "Vamos imaginar que temos o seguinte problema:\n",
        "1. Nós vamos providenciar a um circuito valores específicos como entrada (x=1, y=-3)\n",
        "2. O circuito vai calcular o valor de saída (-3)\n",
        "3. A questão é: *Quanto mudar a entrada para levemente **aumentar** a saída?*\n",
        "\n",
        "No nosso caso, em que direção devemos mudar x,y para conseguir um número maior que -3? Note que, pro nosso exemplo, se x = 0.99 e y = -2.99, x$*$y = -2.96 que é maior que -3. **-2.96 é melhor (maior) que -3**, e obtivemos uma melhora de 0.04."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RM1sM-VTALO5"
      },
      "source": [
        "## Estratégia 1: Busca Aleatória"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRvXHkJOAMBW"
      },
      "source": [
        "Ok. Isso não é trivial? A gente pode simplesmente gerar valores aleatórios, calcular a saída e guardar o melhor resultado."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pPTRi7k3_sMO",
        "outputId": "85e2ef45-d8f8-4c99-c684-ad44f5bd6538"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-4.782059636908393 -4.271322669764254 20.425719735291437\n"
          ]
        }
      ],
      "source": [
        "x, y = 1, -3\n",
        "\n",
        "# calcula a multriplicação das entradas\n",
        "melhor_saida = forwardMultiplyGate(x,y)\n",
        "\n",
        "# tigela para receber a melhor saída para x e y\n",
        "melhor_x, melhor_y = 0, 0\n",
        "\n",
        "\n",
        "for k in range(0,100):\n",
        "    x_try = 5*np.random.random() - 5\n",
        "    y_try = 5*np.random.random() - 5\n",
        "    out = forwardMultiplyGate(x_try, y_try)\n",
        "\n",
        "    if out > melhor_saida:\n",
        "        melhor_saida = out\n",
        "        melhor_x, melhor_y = x_try, y_try\n",
        "\n",
        "print(melhor_x, melhor_y, forwardMultiplyGate(melhor_x, melhor_y))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "diiwswcmAW4d"
      },
      "source": [
        "Ok, foi bem melhor. Mas, e se tivermos milhões de entradas? É claro que essa estratégia não funcionará. Vamos tentar algo mais aprimorado."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1nP7MgznAemH"
      },
      "source": [
        "## Estratégia 2: Busca Aleatória Local"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zy5QhY0nAfIw"
      },
      "source": [
        "Um passo aleatorio em qualquer direçao, torcer para tomar a decisao correta\n",
        "agora temos um passo pra evitar um pulo muito longo\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wqIqVaLK_Zn1",
        "outputId": "9ab4a220-edd0-4c16-b999-2a7ffe8cc8d8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9904412804385638 -2.9907058954651253 -2.9621185765196403\n"
          ]
        }
      ],
      "source": [
        "x, y = 1, -3\n",
        "passo = 0.01\n",
        "melhor_saida = forwardMultiplyGate(x,y)\n",
        "melhor_x, melhor_y = 0, 0\n",
        "\n",
        "for k in range(0,100):\n",
        "    x_try = x + passo * (2*np.random.random() - 1)\n",
        "    y_try = y + passo * (2*np.random.random() - 1)\n",
        "    out = forwardMultiplyGate(x_try, y_try)\n",
        "\n",
        "    if out > melhor_saida:\n",
        "        melhor_saida = out\n",
        "        melhor_x, melhor_y = x_try, y_try\n",
        "\n",
        "print(melhor_x, melhor_y, forwardMultiplyGate(melhor_x, melhor_y))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9MbM8KF0BN6T"
      },
      "source": [
        "Otimoooo! Demos um passinho mais controlado -2.96 é menor que -3.... mas precisamos de algo melhor, uma estratégia mais inteligente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6gGRcmPiBZOC"
      },
      "source": [
        "## Estratégia 3: Gradiente Numérico"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_i9gKYaxBZ14"
      },
      "source": [
        "Imagine agora que a gente pega as entradas de um circuito e puxa-as para uma direção positiva. Essa força puxando $x$ e $y$ vai nos dizer como $x$ e $y$ devem mudar para aumentar a saída. Não entendeu? Vamos explicar:\n",
        "\n",
        "Se olharmos para as entradas, a gente pode intuitivamente ver que a força em $y$ deveria sempre ser positiva, porque tornando $y$ um pouquinho maior de $y=1$ para $y=-1$ aumenta a saída do circuito para $-1$, o que é bem maior que $-3$. Por outro lado, se a força em $x$ for negativa, tornando-o menor, como de $x=1$ para $x=0.5$, também aumenta a saída: $-0.5\\times-3 = -1.5$, de novo maior que $-3$.\n",
        "\n",
        "E como calcular essa força? Usando **derivadas**.\n",
        "\n",
        "> *A derivada pode ser pensada como a força que a gente aplica em cada entrada para aumentar a saída*\n",
        "\n",
        "\n",
        "E como exatamente a gente vai fazer isso? Em vez de olhar para o valor de saída, como fizemos anteriormente, nós vamos iterar sobre as cada entrada individualmente, aumentando-as bem devagar e vendo o que acontece com a saída. **A quantidade que a saída muda é a resposta da derivada**.\n",
        "\n",
        "Vamos para definição matemática. A derivada em relação a $x$ pode ser definida como:\n",
        "\n",
        "$$\\frac{\\partial f(x,y)}{\\partial x} = \\frac{f(x+h,y) - f(x,y)}{h}$$\n",
        "\n",
        "Onde $h$ é pequeno. Nós vamos, então, calcular a saída inicial $f(x,y)$ e aumentar $x$ por um valor pequeno $h$ e calcular a nova saída $f(x+h,y)$. Então, nós subtraimos esse valores para ver a diferença e dividimos por $f(x+h,y)$ para normalizar essa mudança pelo valor (arbitrário) que nós usamos.\n",
        "\n",
        "Em termos de código, teremos:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e1IBXIQ1BM4V",
        "outputId": "69c9d435-7b3b-4e6a-c353-cebab3f6c289"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-3.000000000000025, 0.9999999999999787)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "#Slide 49-52\n",
        "x, y = 1, -3\n",
        "out = forwardMultiplyGate(x,y) # f(x,y)\n",
        "h=0.01 #h -> 0\n",
        "\n",
        "# derivada em relação a x\n",
        "out2 = forwardMultiplyGate(x+h, y) # f(x+h, y)\n",
        "\n",
        "derivada_x = (out2 - out) / h\n",
        "\n",
        "# derivada em relação a y\n",
        "out3 = forwardMultiplyGate(x, y+h)\n",
        "\n",
        "derivada_y = (out3 - out ) / h\n",
        "\n",
        "# resultados\n",
        "derivada_x, derivada_y # vetor de gradiente"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SVHuVGboa2dO"
      },
      "source": [
        "Essas saídas representam a foça da atualização naquele ponto\n",
        "o *3* indica que a força da derivada de $x$ é maior que a força da derivada de $y$\n",
        "O sinal indica somente se a função cresce ou decresce\n",
        "\n",
        "> *A derivada em relação a alguma entrada pode ser calculada ajustando levemente aquela entrada e observando a mudança no valor da saída*\n",
        "\n",
        "A derivada é calculada sobre cada entrada, enquanto o **gradiente** representa todas as derivadas sobre as entradas concatenadas em um vetor.\n",
        "> Derivada é so um valor e o gradiente eh o vertor desses valores"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dZAQUVl4ZaSE",
        "outputId": "54c429b2-49ab-4c85-d645-362ca7731240"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-3 0.995006\n"
          ]
        }
      ],
      "source": [
        "#Slide 49-52\n",
        "x, y = 1, -3\n",
        "passo = 0.001\n",
        "out = forwardMultiplyGate(x, y) # f(x , y)\n",
        "\n",
        "x = x + passo * derivada_x\n",
        "y = x + passo * derivada_y\n",
        "\n",
        "out_new = forwardMultiplyGate(x, y)\n",
        "\n",
        "print(out, out_new)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jieswZFNcVgG"
      },
      "source": [
        "Dessa forma conseguimos reduzir nossa função em poucas iterações (rodar mais 2x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qO_-mHJQciad"
      },
      "source": [
        "**Passo maior nem sempre é melhor**: É importante destacar que qualquer valor de passo maior que 0.01 ia sempre funcionar melhor (por exemplo, passo = 1 gera a saída = 1). No entanto, à medida que os circuitos vão ficando mais complexos (como em redes neurais completas), a função vai ser tornando mais caótica e complexa. O gradiente garante que se você tem um passo muito pequeno (o ideal seria infinitesimal), então você definitivamente aumenta a saída seguindo aquela direção. O passo que estamos utilizando (0.01) ainda é muito grande, mas como nosso circuito é simples, podemos esperar pelo melhor resultado. Lembre-se da analogia do **escalador cego**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tRgGJWgJcmYN"
      },
      "source": [
        "## Estratégia 4: Gradiente Analítico"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8P9_J5iPco9F"
      },
      "source": [
        "A estratégia que utilizamos até agora de ajustar levemente a entrada e ver o que acontece com a saída pode não ser muito cômoda na prática quando temos milhares de entradas para ajustar. Então, a gente precisa de algo melhor.\n",
        "\n",
        "Felizmente, existe uma estratégia mais fácil e muito mais rápida para calcular o gradiente: podemos usar cálculo para derivar diretamente a nossa função. Chamamos isso de **gradiente analítico** e dessa forma não precisamos ajustar levemente nada.\n",
        "\n",
        "> *O gradiente analítico evita o leve ajustamento das entradas. O circuito pode ser derivado usando cálculo.*\n",
        "\n",
        "É muito fácil calcular derivadas parciais para funções simples como $x*y$. Se você não lembra da definição, aqui está o cálculo da derivada parcial em relação a $x$ da nossa função $f(x,y)$:\n",
        "\n",
        "$$\\frac{\\partial f(x,y)}{\\partial x} = \\frac{f(x+h,y) - f(x,y)}{h}\n",
        "= \\frac{(x+h)y - xy}{h}\n",
        "= \\frac{xy + hy - xy}{h}\n",
        "= \\frac{hy}{h}\n",
        "= y$$\n",
        "\n",
        "A derivada parcial em relação em $x$ da nossa $f(x,y)$ é igual $y$. Você reparou na coincidência de $\\partial x = 3.0$, que é exatamente o valor de $y$? E que o mesmo aconteceu para $x$? **Então, a gente não precisa ajustar nada!** E nosso código fica assim:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2ZpPemgWc311",
        "outputId": "c0a09b30-6080-4a4c-a6fb-1866815d4ff2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-3 -2.990003\n"
          ]
        }
      ],
      "source": [
        "#Slide 49-52\n",
        "x, y = 1, -3\n",
        "out = forwardMultiplyGate(x,y)\n",
        "\n",
        "derivada_x = y\n",
        "derivada_y = x\n",
        "\n",
        "passo = 0.001\n",
        "\n",
        "x = x + passo * derivada_x\n",
        "y = y + passo * derivada_y\n",
        "\n",
        "out_new = forwardMultiplyGate(x,y)\n",
        "print(out, out_new)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jClYQKl_c_LW"
      },
      "source": [
        "É importante destacar que a Estratégia #3 reduziu a #2 para uma única vez. Porém, a #3 nos dá somente uma aproximação do gradiente, enquanto a Estratégia #4 nos dá o valor exato. Sem aproximações. O único lado negativo é que temos de saber derivar a nossa funcão.\n",
        "\n",
        "Recapitulando o que vimos até aqui:\n",
        "- __Estratégia 1__: definimos valores aleatórios em todas as iterações. Não funciona para muitas entradas.\n",
        "- __Estratégia 2__: pequenos ajustes aleatórios nas entradas e vemos qual funciona melhor. Tão ruim quando a #1.\n",
        "- __Estratégia 3__: muito melhor através do cálculo do gradiente. Independentemente de quão complicado é o circuito, o **gradiente numérico** é muito simples de se calcular (mas um pouco caro).\n",
        "- __Estratégia 4__: no final, vimos que a forma melhor, mais inteligente e mais rápida é calcular o **gradiente analítico**. O resultado é idêntico ao gradiente numérico, porém mais rápido e não precisa de ajustes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W6RTodD9fNZ-"
      },
      "source": [
        "## Caso Recursivo: Múltiplas Portas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r33na5H5fRK-"
      },
      "source": [
        "Como vamos calcular agora a nossa derivada? Primeiramente, vamos esquecer da porta de soma e fingir que temos apenas duas entradas no nosso circuito: **q** e **z**. Como já vimos, as nossas derivadas parciais podem ser definidas da seguinte maneira:\n",
        "\n",
        "$$f(q,z) = q z \\hspace{0.5in} \\implies \\hspace{0.5in} \\frac{\\partial f(q,z)}{\\partial q} = z, \\hspace{1in} \\frac{\\partial f(q,z)}{\\partial z} = q$$\n",
        "\n",
        "Ok, mas e em relação a $x$ e $y$? Como $q$ é calculado em função de $x$ e $y$ (pela adição em nosso exemplo), nós também podemos calcular suas derivadas parciais:\n",
        "\n",
        "$$q(x,y) = x + y \\hspace{0.5in} \\implies \\hspace{0.5in} \\frac{\\partial q(x,y)}{\\partial x} = 1, \\hspace{1in} \\frac{\\partial q(x,y)}{\\partial y} = 1$$\n",
        "\n",
        "Correto! As derivadas parciais são 1, independentemente dos valores de $x$ e $y$. Isso faz sentido se pensarmos que para aumentar A saída de uma porta de adição, a gente espera uma força positiva tanto em $x$ quanto em $y$, independente dos seus valores.\n",
        "\n",
        "Com as fórmulas acima, nós sabemos calcular o gradiente da saída em relação a $q$ e $z$, e o gradiente de $q$ em relação a $x$ e $y$. Para calcular o gradiente do nosso circuito em relação a $x$, $y$ e $z$, nós vamos utilizar a **Regra da Cadeia**, que vai nos dizer como combinar esses gradientes. A derivada final em relação a $x$, será dada por:\n",
        "\n",
        "$$\\frac{\\partial f(q,z)}{\\partial x} = \\frac{\\partial q(x,y)}{\\partial x} \\frac{\\partial f(q,z)}{\\partial q}$$\n",
        "\n",
        "Pode parecer complicado à primeira vista, mas a verdade é que isso vai ser simplificado a somente duas multiplicações:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x9gKhcI5fShU",
        "outputId": "4d7c7a35-d0ed-420b-d8ef-3946d994785e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n"
          ]
        }
      ],
      "source": [
        "#Slide 53-56\n",
        "def forwardAddGate(a, b):\n",
        "    return a + b\n",
        "\n",
        "def forwardCircuit(x, y, z):\n",
        "    q = forwardAddGate(x, y)\n",
        "    f = forwardMultiplyGate(q, z)\n",
        "    return f\n",
        "\n",
        "print(forwardCircuit(-2, 5, 4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oo3gw2l4fvUV",
        "outputId": "060b0c05-c1e9-4871-ace6-76e292aa54a9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-4 -4 3\n"
          ]
        }
      ],
      "source": [
        "#Slide 53-56\n",
        "\n",
        "x, y, z = -2, 5, -4\n",
        "\n",
        "q = forwardAddGate(x, y)\n",
        "f = forwardMultiplyGate(q, z)\n",
        "\n",
        "# derivada da porta de multiplicação\n",
        "der_f_z = q\n",
        "der_f_q = z\n",
        "\n",
        "# derivada da porta de adição\n",
        "der_q_x = 1\n",
        "der_q_y = 1\n",
        "\n",
        "# regra da cadeia (função interna * função externa)\n",
        "der_f_x = der_f_q * der_q_x\n",
        "der_f_y = der_f_q * der_q_y\n",
        "der_f_z = der_f_z\n",
        "\n",
        "print(der_f_x, der_f_y, der_f_z)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Atualizando os pesos\n",
        "passo = 0.001\n",
        "\n",
        "x = x + passo * der_f_x\n",
        "y = y + passo * der_f_y\n",
        "z = z + passo * der_f_z\n",
        "x, y, z"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CS5Hqs_Z5pHq",
        "outputId": "a898381d-46d4-462b-a3cd-f0e463fddd83"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-2.004, 4.996, -3.997)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jpV_BbRsm8nW"
      },
      "source": [
        "O sinal negativo nos indica se devemos crescer ou decrescer aquela entrada\n",
        "e o valor indica com que força"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vetor gradiente\n",
        "grad_f_rel_xyz = [der_f_x, der_f_y, der_f_z]\n",
        "\n",
        "print(forwardCircuit(x, y, z)) # > -12"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qr2djlYp6DHV",
        "outputId": "5dffa423-fe98-4de0-d080-685b9ac54c8c"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-11.959024000000001\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4RFc1X7hmbXk"
      },
      "source": [
        "Agora atualizaremos os nossos pesos com o gradiente"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "hoeJmiHRmEzY"
      },
      "outputs": [],
      "source": [
        "#Slide 53-56"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bSLNnDRwn3am"
      },
      "source": [
        "## Checagem do gradiente numérico"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C6fjb411n41O"
      },
      "source": [
        "Vamos verificar se os gradientes analíticos que calculamos por backpropagation estão corretos. Lembre-se que podemos fazer isso através do gradiente numérico e esperamos que o resultado seja [-4, -4, 4] para $x,y,z$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "56HyHwaon6Ul",
        "outputId": "ce5fc889-c4ef-473c-f431-f562a2eebdbd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-3.9999999999995595 -4.000000000001336 3.0000000000001137\n"
          ]
        }
      ],
      "source": [
        "#Slide 57\n",
        "x, y, z = -2, 5, -4\n",
        "h = 0.001\n",
        "\n",
        "der_x = (forwardCircuit(x + h, y, z) - forwardCircuit(x, y, z)) / h\n",
        "der_y = (forwardCircuit(x, y + h, z) - forwardCircuit(x, y, z)) / h\n",
        "der_z = (forwardCircuit(x, y, z + h) - forwardCircuit(x, y, z)) / h\n",
        "\n",
        "print(der_x, der_y, der_z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l10Jczi5I0VU"
      },
      "source": [
        "## Neurônio Sigmóide"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0WS2wJiIydl"
      },
      "source": [
        "Qualquer função diferenciável pode atuar como uma porta, como também podemos agrupar múltiplas portas para formar uma simples porta, ou decompor um função em múltiplas portas quando for conveniente. Para exemplificar, vamos utilizar a função de ativação *sigmoid* com entradas **x** e pesos **w**:\n",
        "> Neste caso o bias é representado pelo w2\n",
        "\n",
        "$$f(w,x) = \\frac{1}{1+e^{-(w_0x_0 + w_1x_1 + w_2)}}$$\n",
        "\n",
        "Como dito, a função acima nada mais é que a função sigmoid $\\sigma(x)$. Sabendo, então, que a derivada da função sigmoid é:\n",
        "\n",
        "$$\\sigma(x)=\\frac{1}{1+e^{-x}}=(1-\\sigma(x))\\sigma(x)$$\n",
        "\n",
        "Vamos calcular a gradiente em relação as entradas:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oius3x-NA5tH"
      },
      "source": [
        "![This is an image](https://github.com/mafaldasalomao/pavic_treinamento_ml/blob/main/Machine_Learning/figures/sigmoid_example_backprop.png?raw=true)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Portanto, calculamos o neurônio sigmoide, considerando que\n",
        "\n",
        "$$\\sigma(x)=\\frac{1}{1+e^{-x}}=(1-\\sigma(x))\\sigma(x)$$"
      ],
      "metadata": {
        "id": "yCXdCv-xYJBA"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "47pEjlp4B70o",
        "outputId": "a1edb4ac-8334-433f-a5b2-eabd406a8962"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dx0: 0.3932238664829637 - dx1: -0.5898357997244456\n",
            "dw0: -0.19661193324148185 - dw1: -0.3932238664829637 - dw2: 0.19661193324148185\n"
          ]
        }
      ],
      "source": [
        "#forward do sigmoid\n",
        "# vamos tomar o w0 e w1 como entradas\n",
        "# O w2 será considerado como bias\n",
        "#Slide 62\n",
        "#Primeiro vamos calcular a derivada do neuronio sigmoid com as derivadas conhecidas!!  (se soubermos as derivadas) gradiente analítico\n",
        "#Depois calcularemos a derivada do neuronio sigmoid com circuitos... quebradinho (se NAO soubermos as derivadas) gradiente numérico\n",
        "\n",
        "w0, w1, w2 = 2, -3, -3\n",
        "x0, x1 = -1, -2\n",
        "\n",
        "# forward pass\n",
        "dot = (w0 * x0) + (w1 * x1) + w2\n",
        "f = 1.0 / (1.0 + np.exp(-dot))\n",
        "\n",
        "# backward pass\n",
        "df = +1.0\n",
        "ddot = ((1-f) * f) * df # o que está fora (derivada de dot)\n",
        "\n",
        "dx0 = w0 * ddot\n",
        "dw0 = x0 * ddot\n",
        "\n",
        "dx1 = w1 * ddot\n",
        "dw1 = x1 * ddot\n",
        "\n",
        "dw2 = 1.0 * ddot\n",
        "\n",
        "print('dx0: {} - dx1: {}'.format(dx0, dx1))\n",
        "\n",
        "print('dw0: {} - dw1: {} - dw2: {}'.format(dw0, dw1, dw2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6wIKELeMCu9f"
      },
      "outputs": [],
      "source": [
        "#Vamos ver primeiro as questoes do backpropagation antes de continuarmos a implementação do sigmoid\n",
        "#Slide 63-74"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NqHO4fTIJH78",
        "outputId": "dbd8bff4-b0a6-451e-d514-b88432846a97"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-2,\n",
              " 6,\n",
              " 4,\n",
              " 1,\n",
              " -1.0,\n",
              " 0.36787944117144233,\n",
              " 1.3678794411714423,\n",
              " 0.7310585786300049)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "# step by step simoide\n",
        "\n",
        "w0, w1, w2 = 2, -3, -3\n",
        "x0, x1 = -1, -2\n",
        "\n",
        "# Forward pass\n",
        "mult1 = x0 * w0\n",
        "mult2 = x1 * w1\n",
        "\n",
        "add1 = mult1 + mult2\n",
        "add2 = add1 + w2\n",
        "\n",
        "# no passo da função\n",
        "neg = -1.0 * add2\n",
        "exp1 = np.exp(neg)\n",
        "add3 = exp1 + 1.0\n",
        "\n",
        "f = (1.0 / add3)\n",
        "\n",
        "mult1, mult2, add1, add2, neg, exp1, add3, f"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### As derivadas indicam a força de atualização de cada neurônio.\n",
        "\n",
        "#### No backpropagation, vamos fazendo operações de derivadas retornando em cada neurônio, desde a função de custo até a atualização dos pesos (w) e consequentemente a definição de novos valores (x)."
      ],
      "metadata": {
        "id": "EXVgJbOolPND"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Backward pass\n",
        "df = +1.0\n",
        "dadd3 = -1.0 / (add3 * add3) * df # derivada em relação a add3\n",
        "dexp1 = 1.0 * dadd3 # derivada em relação a exp1\n",
        "dneg = np.exp(neg) * dexp1 # derivada em relação a neg\n",
        "dadd2 = -1 * dneg\n",
        "dadd1 = 1.0 * dadd2\n",
        "dw2 = 1.0 * dadd2\n",
        "dmult1 = 1.0 * dadd1\n",
        "dmult2 = 1.0 * dadd2\n",
        "\n",
        "# para x1\n",
        "dx1 = w1 * dmult2\n",
        "dw1 = x1 * dmult2\n",
        "\n",
        "# para x0\n",
        "dx0 = w0 * dmult1\n",
        "dw0 = x0 * dmult1\n",
        "\n",
        "dw0, dx0, dw1, dx1, dmult2, dmult1, dadd1, dw2, dadd2, dneg"
      ],
      "metadata": {
        "id": "aBn8gAUYiKCy",
        "outputId": "428c72af-bc53-4e90-9710-d4aa513ec7c0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-0.19661193324148188,\n",
              " 0.39322386648296376,\n",
              " -0.39322386648296376,\n",
              " -0.5898357997244457,\n",
              " 0.19661193324148188,\n",
              " 0.19661193324148188,\n",
              " 0.19661193324148188,\n",
              " 0.19661193324148188,\n",
              " 0.19661193324148188,\n",
              " -0.19661193324148188)"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Resumo das derivadas -  Atividade Assíncrona\n",
        "w0, x0, w1, x1"
      ],
      "metadata": {
        "id": "dmEfiwQ1nqIe"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}