simple_neural_network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create a model class that inherits nn.Module\n",
    "#dizer qual o tipo de flor iris\n",
    "class Model(nn.Module):\n",
    "    #Input layer (4 features of the flower) \n",
    "    #--> Hidden Layer1\n",
    "    #--> .. \n",
    "    #--> Hidden LayerN \n",
    "    #--> Output\n",
    "    def __init__(self,in_features=4, h1=8, h2=9, out_features=3):\n",
    "        super().__init__() #vai instanciar a classe\n",
    "        #vai da entrada pra h1\n",
    "        self.fc1 = nn.Linear(in_features, h1)\n",
    "        #vai de h1 pra h2\n",
    "        self.fc2 = nn.Linear(h1, h2)\n",
    "        #vai de h2 pra output\n",
    "        self.out = nn.Linear(h2, out_features)\n",
    "\n",
    "    def forward(self, x):\n",
    "        #vai empurrando pra frente\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.out(x)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Model(\n",
       "  (fc1): Linear(in_features=4, out_features=8, bias=True)\n",
       "  (fc2): Linear(in_features=8, out_features=9, bias=True)\n",
       "  (out): Linear(in_features=9, out_features=3, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sementezinha azar\n",
    "torch.manual_seed(41)\n",
    "\n",
    "model = Model()\n",
    "\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\arthu\\AppData\\Local\\Temp\\ipykernel_636\\2225940201.py:1: DeprecationWarning: \n",
      "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n",
      "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n",
      "but was not found to be installed on your system.\n",
      "If this would cause problems for you,\n",
      "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n",
      "        \n",
      "  import pandas as pd\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://gist.githubusercontent.com/curran/a08a1080b88344b0c8a7/raw/0e7a9b0a5d22642a06d3d5b9bcbad9890c8ee534/iris.csv'\n",
    "myDf = pd.read_csv(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\arthu\\AppData\\Local\\Temp\\ipykernel_636\\2851050775.py:4: FutureWarning: Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n",
      "  myDf['species'] = myDf['species'].replace('virginica',2.0)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal_length  sepal_width  petal_length  petal_width  species\n",
       "0             5.1          3.5           1.4          0.2      0.0\n",
       "1             4.9          3.0           1.4          0.2      0.0\n",
       "2             4.7          3.2           1.3          0.2      0.0\n",
       "3             4.6          3.1           1.5          0.2      0.0\n",
       "4             5.0          3.6           1.4          0.2      0.0\n",
       "..            ...          ...           ...          ...      ...\n",
       "145           6.7          3.0           5.2          2.3      2.0\n",
       "146           6.3          2.5           5.0          1.9      2.0\n",
       "147           6.5          3.0           5.2          2.0      2.0\n",
       "148           6.2          3.4           5.4          2.3      2.0\n",
       "149           5.9          3.0           5.1          1.8      2.0\n",
       "\n",
       "[150 rows x 5 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#de strings pra inteiros\n",
    "myDf['species'] = myDf['species'].replace('setosa',0.0)\n",
    "myDf['species'] = myDf['species'].replace('versicolor',1.0)\n",
    "myDf['species'] = myDf['species'].replace('virginica',2.0)\n",
    "myDf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training\n",
    "#pegando os parâmetros\n",
    "x = myDf.drop('species',axis=1)\n",
    "#pegando os resultados\n",
    "y = myDf['species']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#convertendo pra np arrays\n",
    "x = x.values\n",
    "y = y.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train test split\n",
    "#20% do dataset pra teste, 80% pra treino\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,y, test_size=0.2, random_state=41)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#convertendo pra tensores\n",
    "x_train = torch.FloatTensor(x_train)\n",
    "x_test = torch.FloatTensor(x_test)\n",
    "y_train = torch.LongTensor(y_train)\n",
    "y_test = torch.LongTensor(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#definir o quanto a saida ta diferente da entrada\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "#escolher um otimizador (?) e uma taxa de aprendizado (até a taxa de erro ficar abaixo disso)\n",
    "optimizer = torch.optim.Adam(model.parameters(),lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:0 com perda 1.1251550912857056\n",
      "Epoch:10 com perda 1.0096259117126465\n",
      "Epoch:20 com perda 0.8157405853271484\n",
      "Epoch:30 com perda 0.585706353187561\n",
      "Epoch:40 com perda 0.3999636471271515\n",
      "Epoch:50 com perda 0.26768797636032104\n",
      "Epoch:60 com perda 0.17942361533641815\n",
      "Epoch:70 com perda 0.1215168908238411\n",
      "Epoch:80 com perda 0.0860118418931961\n",
      "Epoch:90 com perda 0.06520850211381912\n"
     ]
    }
   ],
   "source": [
    "#treinar!\n",
    "#epoch? (um rodada até o final da nossa rede)\n",
    "epoch = 100\n",
    "losses = []\n",
    "for i in range(epoch):\n",
    "    #frente!\n",
    "    y_pred = model.forward(x_train) #pega a primeira passagem\n",
    "\n",
    "    #calcular a quantiade de discrepancia que a gente achou\n",
    "    loss = criterion(y_pred, y_train)\n",
    "\n",
    "    #continuar tendo em vista oq a gente ta melhorando\n",
    "    losses.append(loss.detach().numpy())\n",
    "\n",
    "    #printar pra ver como tamo indo\n",
    "    if (i % 10 == 0):\n",
    "        print(f'Epoch:{i} com perda {loss}')\n",
    "    \n",
    "    #backpropagation (eu vou voltando pra acertar minha rede neural)\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'epoch')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#graficamente!!!!!!!!!\n",
    "plt.plot(range(epoch),losses)\n",
    "plt.ylabel(\"loss/error\")\n",
    "plt.ylabel(\"epoch\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#começo do teste\n",
    "with torch.no_grad(): #não volta mais pro backpropagation\n",
    "    y_eval = model.forward(x_test) #y_eval são classificações\n",
    "    loss = criterion(y_eval,y_test) #ver a discrepância\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.1315)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.) tensor([-5.8760,  4.4628,  6.5124]) \t 2 \t 2\n",
      "2.) tensor([-7.5436,  4.1670,  9.7255]) \t 2 \t 2\n",
      "3.) tensor([-8.4504,  5.1271, 10.1987]) \t 2 \t 2\n",
      "4.) tensor([-4.3398,  5.6267,  2.5608]) \t 1 \t 1\n",
      "5.) tensor([-7.1825,  4.8754,  8.2992]) \t 2 \t 2\n",
      "6.) tensor([-3.3974,  5.3463,  1.2803]) \t 1 \t 1\n",
      "7.) tensor([-5.9231,  4.9822,  5.9997]) \t 2 \t 2\n",
      "8.) tensor([-4.2881,  5.7003,  2.3889]) \t 1 \t 1\n",
      "9.) tensor([-6.5356,  4.9257,  7.1260]) \t 2 \t 2\n",
      "10.) tensor([-8.0509,  4.4129, 10.3286]) \t 2 \t 2\n",
      "11.) tensor([-5.6762,  4.9500,  5.6215]) \t 2 \t 2\n",
      "12.) tensor([ 4.5662, -2.2476, -2.8911]) \t 0 \t 0\n",
      "13.) tensor([ 4.2571, -1.9967, -2.7330]) \t 0 \t 0\n",
      "14.) tensor([-2.1108,  4.0515,  0.5799]) \t 1 \t 1\n",
      "15.) tensor([ 3.4575, -1.2098, -2.3514]) \t 0 \t 0\n",
      "16.) tensor([-5.4724,  5.1165,  5.0934]) \t 2 \t 1\n",
      "17.) tensor([ 4.0557, -1.7949, -2.6492]) \t 0 \t 0\n",
      "18.) tensor([-5.8075,  4.6053,  6.2458]) \t 1 \t 2\n",
      "19.) tensor([ 4.4343, -2.1392, -2.8242]) \t 0 \t 0\n",
      "20.) tensor([ 3.4528, -1.2514, -2.3660]) \t 0 \t 0\n",
      "21.) tensor([-2.6189,  4.5619,  0.8574]) \t 1 \t 1\n",
      "22.) tensor([-7.7412,  4.7377,  9.4199]) \t 2 \t 2\n",
      "23.) tensor([ 3.5743, -1.3221, -2.4135]) \t 0 \t 0\n",
      "24.) tensor([ 4.5365, -2.2383, -2.8684]) \t 0 \t 0\n",
      "25.) tensor([-2.6579,  4.6177,  0.8823]) \t 1 \t 1\n",
      "26.) tensor([-3.2865,  5.2229,  1.2164]) \t 1 \t 1\n",
      "27.) tensor([-4.6514,  5.7776,  2.9273]) \t 1 \t 1\n",
      "28.) tensor([-2.9464,  4.8892,  1.0379]) \t 1 \t 1\n",
      "29.) tensor([ 4.5847, -2.2687, -2.8974]) \t 0 \t 0\n",
      "30.) tensor([-4.5784,  5.4554,  3.1660]) \t 1 \t 1\n",
      "corretos: 28\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "with torch.no_grad():\n",
    "    for i, data in enumerate(x_test):\n",
    "        y_eval = model.forward(data)\n",
    "        #printando o tipo de flor\n",
    "        print(f'{i+1}.) {str(y_eval)} \\t {y_test[i]} \\t {y_eval.argmax().item()}')\n",
    "\n",
    "        #correto?\n",
    "        if y_eval.argmax().item() == y_test[i]:\n",
    "            correct += 1\n",
    "\n",
    "print(f'corretos: {correct}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-5.9944,  4.5077,  6.6792])\n"
     ]
    }
   ],
   "source": [
    "#inserindo novos dados\n",
    "new_iris = torch.tensor([5.9,3.0,5.1,1.8])\n",
    "with torch.no_grad():\n",
    "    print(model(new_iris))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#salvar e carregar o modelo de NN\n",
    "torch.save(model.state_dict(), \"modelinho.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-5.9944,  4.5077,  6.6792])\n"
     ]
    }
   ],
   "source": [
    "new_model = Model()\n",
    "new_model.load_state_dict(torch.load(\"modelinho.pt\"))\n",
    "with torch.no_grad():\n",
    "    print(new_model(new_iris))"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}