Neural_Networks.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPXphvgdF4FbkPDtOzcfAKS",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SampMark/Machine-Learning/blob/main/Neural_Networks.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Introdução as Redes Neurais**\n",
        "\n",
        "As redes neurais são uma das ferramentas mais poderosas e versáteis no campo do aprendizado de máquina e da inteligência artificial.\n",
        "\n",
        "São inspiradas no funcionamento do cérebro humano, onde neurônios interconectados processam informações. Ou seja, são formadas por \"neurônios artificiais\" que processam entradas, aplicam funções de ativação e produzem saídas.\n",
        "\n",
        "A representação matricial e o uso de algoritmos como o gradiente descendente permitem que as redes neurais sejam treinadas para realizar tarefas complexas.\n",
        "\n",
        "Com o avanço do deep learning, as redes neurais se tornaram uma ferramenta essencial em muitas áreas da ciência e tecnologia, sendo usadas numa variedade de aplicações, como por exemplo:\n",
        "\n",
        "1. **Visão Computacional**: reconhecimento de objetos, detecção de faces, segmentação de imagens.\n",
        "\n",
        "2. **Processamento de Linguagem Natural**: tradução automática, geração de texto, análise de sentimentos.\n",
        "\n",
        "3. **Sistemas de Recomendação**: recomendação de produtos, filmes, música.\n",
        "\n",
        "4. **Jogos**: desenvolvimento de agentes inteligentes para jogos complexos.\n",
        "\n",
        "A seguir iremos explorar os conceitos básicos e aprofundar o nosso entendimento.\n",
        "\n",
        "## **Conceito Básico sobre uma Rede Neural**\n",
        "\n",
        "Uma rede neural é um modelo matemático composto por unidades de processamento chamadas neurônios artificiais (ou nós), que são organizados em camadas. Esses neurônios recebem entradas, processam-nas e produzem uma saída.\n",
        "\n",
        "A rede neural \"aprende\" ajustando os pesos das conexões entre os neurônios, de modo a minimizar o erro entre as previsões e os valores reais.\n",
        "\n",
        "No exemplo mais simples, uma rede neural pode ser representada como:\n",
        "\n",
        "* Entrada 1 (X₁) → Peso (W₁₁) → Saída (Y)\n",
        "* Entrada 2 (X₂) → Peso (W₂₁) → Saída (Y)\n",
        "\n",
        "Onde:\n",
        "* $X_1$ e $X_2$ são as entradas, $W_{11}$ e $W_{21}$ são os pesos associados a cada entrada, e $Y$ é a saída.\n",
        "\n",
        "## **Funcionamento Matemático de um Neurônio**\n",
        "\n",
        "A saída de um neurônio é calculada como uma combinação linear das entradas, seguida por uma função de ativação não linear. Matematicamente, expressamos como:\n",
        "\n",
        "$$ Y = f(W_{11}X_1 + W_{21}X_2) $$\n",
        "\n",
        "Onde:\n",
        "\n",
        "* $f$ é a **função de ativação**, que introduz não linearidade ao modelo.\n",
        "\n",
        "## **Representação Matricial**\n",
        "\n",
        "Para redes neurais com múltiplas entradas e saídas, é conveniente representar as entradas, pesos e saídas como matrizes. Assim, as entradas e pesos são representados como vetores:\n",
        "\n",
        "$$\n",
        "x = \\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix}, \\quad\n",
        "w = \\begin{bmatrix} w_{11} \\\\ w_{21} \\end{bmatrix}\n",
        "$$\n",
        "\n",
        "A saída $Y$ pode ser calculada como o produto escalar entre os vetores de entrada e pesos, seguido pela aplicação da função de ativação:\n",
        "$$\n",
        "Y = f(w^T x) = f(w_{11} x_1 + w_{21} x_2)\n",
        "$$\n",
        "\n",
        "## **Aprendizado da Rede Neural**\n",
        "O aprendizado em redes neurais ocorre através do ajuste dos pesos $W$ de modo a minimizar o erro entre as previsões da rede e os valores reais. Isso é feito usando um algoritmo chamado _backpropagation_ (retropropagação), que calcula o gradiente do erro em relação aos pesos e os atualiza usando um método de otimização, como o gradiente descendente.\n",
        "\n",
        "**Gradiente Descendente**\n",
        "O gradiente descendente é um algoritmo de otimização que ajusta os pesos na direção que reduz o erro. A atualização dos pesos é dada por:\n",
        "\n",
        "$$\n",
        "W_{novo} = W_{antigo} - \\eta \\frac{\\partial E}{\\partial W}\n",
        "$$\n",
        "Onde:\n",
        "\n",
        "* $η$ é a taxa de aprendizado, que controla o tamanho do passo na atualização dos pesos.\n",
        "\n",
        "* $ \\frac{\\partial E}{\\partial W} $ é o gradiente do erro\n",
        "$E$ em relação aos pesos $W$."
      ],
      "metadata": {
        "id": "mEliNAec6tkt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "eYN8f9qsL_lw"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "h3rvYIxI6mqc"
      },
      "outputs": [],
      "source": [
        "# @title Rede Neural com Função de Ativação ReLU (Rectified Linear Unit), $ f(z) = \\max(0, z) $\n",
        "def neural_network(inputs, weights):\n",
        "  \"\"\"\n",
        "  Aplica uma operação de rede neural com 2 entradas e 1 saída.\n",
        "\n",
        "  Args:\n",
        "    inputs: Um array NumPy com 2 elementos representando as entradas.\n",
        "    weights: Um array NumPy com 2 elementos representando os pesos.\n",
        "\n",
        "  Returns:\n",
        "    A saída da rede neural após aplicar uma função de ativação (ReLU).\n",
        "  \"\"\"\n",
        "  # calcula o produto escalar entre entradas e pesos\n",
        "  weighted_sum = np.dot(inputs, weights)\n",
        "  # Aplica a função de ativação ReLU\n",
        "  output = np.maximum(0, weighted_sum)\n",
        "  return output"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "inputs = np.array([1, 2]) # Exemplo de entradas\n",
        "weights = np.array([3, 4]) # Exemplo de pesos\n",
        "\n",
        "output = neural_network(inputs, weights)\n",
        "\n",
        "print(f\"Entradas: {inputs}\")\n",
        "print(f\"Pesos: {weights}\")\n",
        "print(f\"Saída (z): {output}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JXMb6cFH05Kf",
        "outputId": "e9fd998b-0c32-4c77-a5a5-e3d5188c6bfc"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entradas: [1 2]\n",
            "Pesos: [3 4]\n",
            "Saída (Y): 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Dados de entrada\n",
        "inputs = np.array([1, 0]) # Exemplo de entradas\n",
        "weights = np.array([1, -1]) # Exemplo de pesos\n",
        "\n",
        "output = neural_network(inputs, weights)\n",
        "\n",
        "print(f\"Entradas: {inputs}\")\n",
        "print(f\"Pesos: {weights}\")\n",
        "print(f\"Saída (z) = {output}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bFDC0Pi5076m",
        "outputId": "64e3623d-0ee7-447a-83d6-b3ee45b1fc55"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entradas: [1 0]\n",
            "Pesos: [ 1 -1]\n",
            "Saída (z) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Rede Neural com Função de Ativação Tangente Hiperbólica (tanh), $ f(z) = \\tanh(z) $\n",
        "def neural_network(inputs, weights):\n",
        "    \"\"\"\n",
        "    Executa uma operação de rede neural com 2 entradas e 1 saída, usando ativação tanh.\n",
        "\n",
        "    Argumentos:\n",
        "    inputs (np.array): Um array NumPy de forma (2, 1) representando as entradas.\n",
        "    weights (np.array): Um array NumPy de forma (2, 1) representando os pesos.\n",
        "\n",
        "    Retorna:\n",
        "    np.array: Um array NumPy de forma (1, 1) representando a saída da rede neural.\n",
        "    \"\"\"\n",
        "    z = np.dot(weights.T, inputs)\n",
        "    output = np.tanh(z)\n",
        "    return output"
      ],
      "metadata": {
        "id": "JUnmJ2nlHyqh"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "inputs = np.array([1, 2]) # Exemplo de entradas\n",
        "weights = np.array([3, 4]) # Exemplo de pesos\n",
        "\n",
        "output = neural_network(inputs, weights)\n",
        "\n",
        "print(f\"Entradas: {inputs}\")\n",
        "print(f\"Pesos: {weights}\")\n",
        "print(f\"Saída (Y): {output}\")\n",
        "\n",
        "# Visualização\n",
        "plt.figure(figsize=(6,4))\n",
        "plt.bar(['Entrada X1', 'Entrada X2'], inputs, color='skyblue', label='Entradas')\n",
        "plt.bar(['Peso W11', 'Peso W21'], weights, color='coral', label='Pesos')\n",
        "plt.ylabel('Valores')\n",
        "plt.title('Visualização de entradas e pesos')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 443
        },
        "id": "vCi2YdUB1f5b",
        "outputId": "28af1a4d-e735-4f86-a867-81092c1f7540"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entradas: [1 2]\n",
            "Pesos: [3 4]\n",
            "Saída (Y): 0.9999999994421064\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Funções de ativação**\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "A função de ativação é crucial para permitir que a rede neural aprenda padrões complexos. São funções de ativação comuns:\n",
        "\n",
        "* ReLU (Rectified Linear Unit): $ f(x) = \\max(0, x) $\n",
        "\n",
        "* A **tangente hiperbólica** (tanh) é uma escolha comum para funções de ativação em redes neurais devido à sua natureza não linear e ao fato de ser derivável, o que é útil para algoritmos de treinamento como a retropropagação.\n",
        "\n",
        "$$ f(x) = \\tanh(x) $$\n",
        "\n",
        "* Sigmoide: $ f(x) = \\frac{1}{1+e^{-x}} $"
      ],
      "metadata": {
        "id": "IcYh0imaLxZs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def neural_network(inputs, weights, activation='tanh'):\n",
        "    \"\"\"\n",
        "    Executa uma operação de rede neural com múltiplas entradas e uma saída.\n",
        "\n",
        "    Argumentos:\n",
        "    inputs (np.array): Uma matriz NumPy de forma (n, 1) representando as entradas.\n",
        "    weights (np.array): Uma matriz NumPy de forma (n, 1) representando os pesos.\n",
        "    activation (str): A função de ativação a ser usada. Opções: 'tanh', 'relu', 'sigmoid'.\n",
        "    O padrão é 'tanh'.\n",
        "\n",
        "    Retorna:\n",
        "    np.array: Uma matriz NumPy de forma (1, 1) representando a saída da rede neural.\n",
        "\n",
        "    Gera:\n",
        "    ValueError: Se as formas de entradas e pesos não corresponderem.\n",
        "    \"\"\"\n",
        "    # Verifica se as dimensões das entradas e pesos são compatíveis\n",
        "    if inputs.shape != weights.shape:\n",
        "        raise ValueError(\"As dimensões de inputs e weights devem ser iguais.\")\n",
        "\n",
        "    # Calcula a combinação linear das entradas e pesos\n",
        "    z = np.dot(weights.T, inputs)\n",
        "\n",
        "    # Aplica a função de ativação\n",
        "    if activation == 'tanh':\n",
        "        output = np.tanh(z)\n",
        "    elif activation == 'relu':\n",
        "        output = np.maximum(0, z)\n",
        "    elif activation == 'sigmoid':\n",
        "        output = 1 / (1 + np.exp(-z))\n",
        "    else:\n",
        "        raise ValueError(\"Função de ativação não suportada. Use 'tanh', 'relu' ou 'sigmoid'.\")\n",
        "\n",
        "    return output\n",
        "\n",
        "# Exemplo de uso\n",
        "if __name__ == \"__main__\":\n",
        "\n",
        "    inputs = np.array([1, 2]) # Exemplo de entradas\n",
        "    weights = np.array([3, 4]) # Exemplo de pesos\n",
        "    # inputs = np.array([[0.5], [0.3]])  # Exemplo de entradas\n",
        "    # weights = np.array([[0.8], [0.2]])  # Exemplo de pesos\n",
        "\n",
        "    # Aplica a função de ativação padrão (tanh)\n",
        "    output = neural_network(inputs, weights)\n",
        "    print(f\"Saída com ativação tanh: {output}\")\n",
        "\n",
        "    # Usa a função de ativação ReLU\n",
        "    output_relu = neural_network(inputs, weights, activation='relu')\n",
        "    print(f\"Saída com ativação ReLU: {output_relu}\")\n",
        "\n",
        "    # Usa a função de ativação sigmoide\n",
        "    output_sigmoid = neural_network(inputs, weights, activation='sigmoid')\n",
        "    print(f\"Saída com ativação sigmoide: {output_sigmoid}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FSIWM684IVUL",
        "outputId": "33c32b7c-325d-40b2-d8a8-09c2856e40f1"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saída com ativação tanh: 0.9999999994421064\n",
            "Saída com ativação ReLU: 11\n",
            "Saída com ativação sigmoide: 0.999983298578152\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Backpropagation**\n",
        "\n",
        "O Backpropagation (Retropropagação) é um algoritmo fundamental para o treinamento de redes neurais artificiais, permite ajustar os pesos da rede neural minimizando o erro entre a saída prevista e a saída esperada, utilizando a Regra da Cadeia do cálculo diferencial para calcular os gradientes de forma eficiente."
      ],
      "metadata": {
        "id": "EX7wWXXyJK2_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Função de ativação sigmoide e sua derivada\n",
        "def sigmoid(z):\n",
        "    return 1 / (1 + np.exp(-z))\n",
        "\n",
        "def sigmoid_deriv(z):\n",
        "    return sigmoid(z) * (1 - sigmoid(z))\n",
        "\n",
        "# Dados de entrada (X) e saída esperada (y)\n",
        "X = np.array([[0,0], [0,1], [1,0], [1,1]])\n",
        "y = np.array([[0], [1], [1], [0]])  # XOR\n",
        "\n",
        "# Inicialização dos pesos e vieses\n",
        "np.random.seed(42)\n",
        "W1 = np.random.randn(2, 2)\n",
        "b1 = np.zeros((1, 2))\n",
        "W2 = np.random.randn(2, 1)\n",
        "b2 = np.zeros((1, 1))\n",
        "alpha = 0.1  # Taxa de aprendizado\n",
        "\n",
        "# Treinamento da rede neural usando Backpropagation\n",
        "for epoch in range(10000):\n",
        "    # Forward pass\n",
        "    z1 = np.dot(X, W1) + b1\n",
        "    a1 = sigmoid(z1)\n",
        "    z2 = np.dot(a1, W2) + b2\n",
        "    a2 = sigmoid(z2)\n",
        "\n",
        "    # Cálculo do erro\n",
        "    error = a2 - y\n",
        "\n",
        "    # Backpropagation\n",
        "    delta2 = error * sigmoid_deriv(z2)\n",
        "    delta1 = np.dot(delta2, W2.T) * sigmoid_deriv(z1)\n",
        "\n",
        "    # Atualização dos pesos\n",
        "    W2 -= alpha * np.dot(a1.T, delta2)\n",
        "    b2 -= alpha * np.sum(delta2, axis=0, keepdims=True)\n",
        "    W1 -= alpha * np.dot(X.T, delta1)\n",
        "    b1 -= alpha * np.sum(delta1, axis=0, keepdims=True)\n",
        "\n",
        "# Testando a rede treinada\n",
        "print(\"Saída final:\")\n",
        "print(a2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BlHYsIfaJDl8",
        "outputId": "56c4c72b-d61c-44a3-9470-b2ed57b778f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saída final:\n",
            "[[0.05300868]\n",
            " [0.49554213]\n",
            " [0.95091319]\n",
            " [0.50319888]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sigmoid(z):\n",
        "    return 1 / (1 + np.exp(-z))\n",
        "\n",
        "def sigmoid_deriv(z):\n",
        "    return sigmoid(z) * (1 - sigmoid(z))\n",
        "\n",
        "# Generate z values\n",
        "z = np.linspace(-10, 10, 100)\n",
        "\n",
        "# Calculate sigmoid and its derivative\n",
        "sigmoid_values = sigmoid(z)\n",
        "sigmoid_deriv_values = sigmoid_deriv(z)\n",
        "\n",
        "# Plotting\n",
        "plt.figure(figsize=(10, 6))\n",
        "\n",
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(z, sigmoid_values, label='Sigmoid')\n",
        "plt.xlabel('z')\n",
        "plt.ylabel('sigmoid(z)')\n",
        "plt.title('Sigmoid Function')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "\n",
        "plt.subplot(2, 1, 2)\n",
        "plt.plot(z, sigmoid_deriv_values, label='Sigmoid Derivative')\n",
        "plt.xlabel('z')\n",
        "plt.ylabel('sigmoid_deriv(z)')\n",
        "plt.title('Sigmoid Derivative Function')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "OOocXfANJgQy",
        "outputId": "8e579464-db28-41ce-985d-077658441c79"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Referências**\n",
        "\n",
        "- Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press. Disponível em: https://www.deeplearningbook.org/ Acesso em: 05 fev. 2025.\n",
        "\n",
        "- LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444.\n",
        "\n",
        "- Nielsen, M. A. (2015). Neural Networks and Deep Learning. Determination Press.\n",
        "\n",
        "- MASSACHUSETTS INSTITUTE OF TECHNOLOGY. MIT Introduction to Deep Learning 6.S191: Lecture 1New 2025 Edition Foundations of Deep Learning. Lecturer: Alexander Amini. Disponível em: https://introtodeeplearning.com/. Acesso em: 15 fev. 2025."
      ],
      "metadata": {
        "id": "O-OFLWKpBZYf"
      }
    }
  ]
}