Códigos/mnist_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Exercício 5"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from torchvision.datasets import MNIST\n",
    "from torch.utils.data import DataLoader\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesse notebook, será construído uma rede neural com o Pytorch que consegue reconhecer as imagens dos números do conjunto de dados [MNIST](https://en.wikipedia.org/wiki/MNIST_database)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definições de parâmetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_SIZE = 784        # Número de pixeis na imagem (28 x 28)\n",
    "OUTPUT_SIZE = 10        # Número de classes (0, 1, 2, ...9) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualizando a vetorização da entrada\n",
    "![SegmentLocal](Imagens/mnist_pytorch_3b1b_28x28.gif \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Definições de Hiperpârametros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "LEARNING_RATE = 0.005   # Taxa de aprendizado da rede\n",
    "EPOCHS = 10             # Quantos vezes a rede passa pelo conjunto de dados\n",
    "BATCH_SIZE = 64         # Número de imagens passados para rede de uma só vez\n",
    "HIDDEN_SIZE = 64        # Número de neurônios nas camadas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Definindo a classe da rede neural"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):   # Definindo as camadas da rede\n",
    "        super().__init__()                                      \n",
    "        self.linear1 = nn.Linear(input_size, hidden_size)       # Primeira camada linear\n",
    "        self.relu1 = nn.ReLU()                                  # Função de ativação da primeira camada\n",
    "        self.linear2 = nn.Linear(hidden_size, hidden_size)      # Segunda camada linear                     \n",
    "        self.relu2 = nn.ReLU()                                  # Função de ativação da segunda camada\n",
    "        self.linear3 = nn.Linear(hidden_size, output_size)      # Camada de saída\n",
    "\n",
    "    def forward(self, x):                                       # Definindo o foward propagation\n",
    "        x = torch.flatten(x, start_dim=1)                       # Tranformando a matriz de 28x28 para uma array de 784 elementos\n",
    "        x = self.linear1(x)                                     # Passando pela primeira camada\n",
    "        x = self.relu1(x)                                       # Função de ativação da primeira camada\n",
    "        x = self.linear2(x)                                     # Passando pela segunda camada\n",
    "        x = self.relu2(x)                                       # Função de ativação da segunda camada\n",
    "        x = self.linear3(x)                                     # Passando pela última camada\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualizando a rede neural\n",
    "![SegmentLocal](Imagens/mnist_pytorch_3b1b.gif \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist_train = MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())      # Imagens de treino (60000)\n",
    "mnist_test = MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())      # Imagens de teste  (10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instanciando objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = NeuralNetwork(INPUT_SIZE, HIDDEN_SIZE, OUTPUT_SIZE)     # Instanciando a rede\n",
    "criterion = nn.CrossEntropyLoss()                               # Instanciando a função custo \n",
    "optimizer = optim.Adam(model.parameters(), LEARNING_RATE)       # Instanciando a função de otimização"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop de treino"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:59<00:00,  5.93s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mnist_dataloader = DataLoader(mnist_train, batch_size=BATCH_SIZE, drop_last=True)\n",
    "\n",
    "losses = []\n",
    "for epoch in tqdm(range(EPOCHS)):                                   # Iterando o numero de épocas\n",
    "    total_loss = 0                                                  # Inicializando a variavel do custo\n",
    "    for image, labels in mnist_dataloader:                          # Iterando cada imagen do dataset de treino\n",
    "        prediction = model(image)                                   # Forward propagation\n",
    "        loss = criterion(prediction, labels)                        # Calculando a loss\n",
    "        total_loss += loss.item()                                   # Atualizando a loss total\n",
    "        optimizer.zero_grad()                                       # Zerando os gradientes\n",
    "        loss.backward()                                             # Backpropagation\n",
    "        optimizer.step()                                            # Atualizando os pessos\n",
    "    losses.append(total_loss / (len(mnist_train) / BATCH_SIZE))     # Inserindo elentos na lista \n",
    "plt.plot(losses)                                                    # Plotando o loss de cada época\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loop de testes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percentage of correct answers: 95.70%\n"
     ]
    }
   ],
   "source": [
    "mnist_dataloader = DataLoader(mnist_test, batch_size=1, drop_last=True)\n",
    "\n",
    "with torch.no_grad():\n",
    "    total_correct = 0                                              # Inicializando a variavel dos acertos\n",
    "    for image, label in mnist_dataloader:                          # Iterando cada imagen do dataset de teste\n",
    "        prediction = model(image)                                  # Forward propagation\n",
    "        index = torch.argmax(prediction)                           # Recebe o numero previsto\n",
    "        if index == label.item():                                  # Verifica se o numero está certo\n",
    "            total_correct += 1\n",
    "    print(f\"Percentage of correct answers: {((total_correct*100)/len(mnist_test)):.2f}%\")\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "3763ad9f89648d847e6f5401e1219410b4a0054c5a073f5da0c68452446768ec"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}