sat6-cnn-8bits-gt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://www.kaggle.com/code/vmarkin/advatt\n",
    "# carregar as bibliotecas básicas necessárias\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# gerar os gráficos logo abaixo dos comandos de plot\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_path = 'dataset/X_train_sat6.csv'\n",
    "train_label_path = 'dataset/y_train_sat6.csv'\n",
    "test_data_path = 'dataset/X_test_sat6.csv'\n",
    "test_label_path = 'dataset/y_test_sat6.csv'\n",
    "train_qtdy = 100000\n",
    "test_qtdy = 50000     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_read(data_path, nrows):\n",
    "    data=pd.read_csv(data_path, header=None, nrows=nrows, dtype=np.uint8)\n",
    "    data=data.values ## converting the data into numpy array\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:(100000, 3136)\n",
      "Train data label shape:(100000, 6)\n",
      "Test data shape:(50000, 3136)\n",
      "Test data label shape:(50000, 6)\n"
     ]
    }
   ],
   "source": [
    "train_data=data_read(train_data_path, nrows=train_qtdy)\n",
    "print(\"Train data shape:\" + str(train_data.shape))\n",
    "\n",
    "##Read training data labels\n",
    "train_data_label=data_read(train_label_path,nrows=train_qtdy)\n",
    "print(\"Train data label shape:\" + str(train_data_label.shape))\n",
    "train_dl = np.zeros((train_qtdy, 8),dtype=np.float32)\n",
    "train_dl[:, :6] = train_data_label;\n",
    "\n",
    "##Read test data\n",
    "test_data=data_read(test_data_path, nrows=test_qtdy)\n",
    "print(\"Test data shape:\" + str(test_data.shape))\n",
    "\n",
    "\n",
    "##Read test data labels\n",
    "test_data_label=data_read(test_label_path,nrows=test_qtdy)\n",
    "print(\"Test data label shape:\" + str(test_data_label.shape))\n",
    "test_dl = np.zeros((test_qtdy, 8),dtype=np.float32)\n",
    "test_dl[:, :6] = test_data_label;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3136,)\n",
      "[[[116 119 118]\n",
      "  [108 113 118]\n",
      "  [ 67  60  59]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[122 128 119]\n",
      "  [113 121 114]\n",
      "  [ 64  63  46]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[105 105  93]\n",
      "  [110 117 106]\n",
      "  [ 95 101  90]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]\n",
      "\n",
      " [[  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  ...\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]\n",
      "  [  0   0   0]]]\n",
      "(32, 32, 3)\n"
     ]
    }
   ],
   "source": [
    "example = train_data[0]\n",
    "print(example.shape)\n",
    "reshaped_ex = example.reshape((28,28,4))[:,:,:3] #convert to rgb \n",
    "\n",
    "ex = np.zeros((32, 32, 3),dtype=np.int32)\n",
    "ex[:28, :28, :] = reshaped_ex\n",
    "print(ex)\n",
    "print(ex.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2b62a76a550>"
      ]
     },
     "execution_count": 47,
     "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": [
    "plt.imshow(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 0, 0, 0], dtype=uint8)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex_label = train_data_label[0]\n",
    "ex_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x2b67f866390>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms as T\n",
    "from tqdm import tqdm\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "torch.manual_seed(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SatImgDataset(Dataset):\n",
    "    def __init__(self, X, y):\n",
    "        self.X = X\n",
    "        self.y = y\n",
    "        self.transform = T.ToTensor()\n",
    "    def __len__(self):\n",
    "        return len(self.y)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        x = self.transform(self.X[index])\n",
    "        y = torch.FloatTensor(self.y[index])\n",
    "        return {'x':x, 'y':y}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_reshaped = train_data.reshape(train_qtdy,28,28,4)\n",
    "test_data_reshaped = test_data.reshape(test_qtdy,28,28,4) \n",
    "\n",
    "final_train_data = np.zeros((train_qtdy, 32, 32, 4),dtype=np.float32)\n",
    "final_train_data[:, :28, :28, :] = train_data_reshaped;\n",
    "\n",
    "final_test_data = np.zeros((test_qtdy, 32, 32, 4),dtype=np.float32)\n",
    "final_test_data[:, :28, :28, :] = test_data_reshaped;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_train = SatImgDataset(final_train_data, train_dl)\n",
    "dataset_test = SatImgDataset(final_test_data, test_dl)\n",
    "\n",
    "loader_train = DataLoader(dataset_train, 512, shuffle=True)\n",
    "loader_test = DataLoader(dataset_test, 512, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch\n",
    "# import torch.nn as nn\n",
    "# import torch.nn.functional as F\n",
    "\n",
    "# device = torch.device('cpu')\n",
    "# class SimpleCNN(nn.Module):\n",
    "#     def __init__(self):\n",
    "#         super(SimpleCNN, self).__init__()\n",
    "#         # Camada de convolução 1\n",
    "#         self.conv1 = nn.Conv2d(4, 20, kernel_size=3, stride=2, padding=1)\n",
    "#         # Camada de ativação ReLU 1\n",
    "#         self.relu1 = nn.ReLU()\n",
    "#         # Camada de convolução 2\n",
    "#         self.conv2 = nn.Conv2d(20, 8, kernel_size=1, stride=1)\n",
    "#         # Camada de ativação ReLU 2\n",
    "#         self.relu2 = nn.ReLU()\n",
    "#         # Camada de pooling global média\n",
    "#         self.global_pool = nn.AdaptiveAvgPool2d(1)\n",
    "\n",
    "#     def forward(self, x):\n",
    "#         # Passo através da primeira convolução e ativação\n",
    "#         x = self.conv1(x)\n",
    "#         x = self.relu1(x)\n",
    "#         # Passo através da segunda convolução e ativação\n",
    "#         x = self.conv2(x)\n",
    "#         x = self.relu2(x)\n",
    "#         # Pooling global médio\n",
    "#         x = self.global_pool(x)\n",
    "#         # Achatamento para a saída\n",
    "#         x = x.view(x.size(0), -1)\n",
    "#         return x\n",
    "\n",
    "# # Criar uma instância do modelo\n",
    "# model = SimpleCNN()\n",
    "\n",
    "# # Exibir a arquitetura do modelo\n",
    "# print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QuantizedCNN(\n",
      "  (conv1): QuantConv2d(\n",
      "    4, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (output_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (weight_quant): WeightQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (tensor_quant): RescalingIntQuant(\n",
      "        (int_quant): IntQuant(\n",
      "          (float_to_int_impl): RoundSte()\n",
      "          (tensor_clamp_impl): TensorClampSte()\n",
      "          (delay_wrapper): DelayWrapper(\n",
      "            (delay_impl): _NoDelay()\n",
      "          )\n",
      "        )\n",
      "        (scaling_impl): StatsFromParameterScaling(\n",
      "          (parameter_list_stats): _ParameterListStats(\n",
      "            (first_tracked_param): _ViewParameterWrapper(\n",
      "              (view_shape_impl): OverTensorView()\n",
      "            )\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsMax()\n",
      "            )\n",
      "          )\n",
      "          (stats_scaling_impl): _StatsScaling(\n",
      "            (affine_rescaling): Identity()\n",
      "            (restrict_clamp_scaling): _RestrictClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (restrict_scaling_pre): Identity()\n",
      "          )\n",
      "        )\n",
      "        (int_scaling_impl): IntScaling()\n",
      "        (zero_point_impl): ZeroZeroPoint(\n",
      "          (zero_point): StatelessBuffer()\n",
      "        )\n",
      "        (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "          (bit_width): StatelessBuffer()\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (bias_quant): BiasQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "  )\n",
      "  (relu1): QuantReLU(\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "    (act_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): ReLU()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (conv2): QuantConv2d(\n",
      "    16, 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (output_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (weight_quant): WeightQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (tensor_quant): RescalingIntQuant(\n",
      "        (int_quant): IntQuant(\n",
      "          (float_to_int_impl): RoundSte()\n",
      "          (tensor_clamp_impl): TensorClampSte()\n",
      "          (delay_wrapper): DelayWrapper(\n",
      "            (delay_impl): _NoDelay()\n",
      "          )\n",
      "        )\n",
      "        (scaling_impl): StatsFromParameterScaling(\n",
      "          (parameter_list_stats): _ParameterListStats(\n",
      "            (first_tracked_param): _ViewParameterWrapper(\n",
      "              (view_shape_impl): OverTensorView()\n",
      "            )\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsMax()\n",
      "            )\n",
      "          )\n",
      "          (stats_scaling_impl): _StatsScaling(\n",
      "            (affine_rescaling): Identity()\n",
      "            (restrict_clamp_scaling): _RestrictClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (restrict_scaling_pre): Identity()\n",
      "          )\n",
      "        )\n",
      "        (int_scaling_impl): IntScaling()\n",
      "        (zero_point_impl): ZeroZeroPoint(\n",
      "          (zero_point): StatelessBuffer()\n",
      "        )\n",
      "        (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "          (bit_width): StatelessBuffer()\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (bias_quant): BiasQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "  )\n",
      "  (relu2): QuantReLU(\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "    (act_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): ReLU()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (conv3): QuantConv2d(\n",
      "    8, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (output_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (weight_quant): WeightQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (tensor_quant): RescalingIntQuant(\n",
      "        (int_quant): IntQuant(\n",
      "          (float_to_int_impl): RoundSte()\n",
      "          (tensor_clamp_impl): TensorClampSte()\n",
      "          (delay_wrapper): DelayWrapper(\n",
      "            (delay_impl): _NoDelay()\n",
      "          )\n",
      "        )\n",
      "        (scaling_impl): StatsFromParameterScaling(\n",
      "          (parameter_list_stats): _ParameterListStats(\n",
      "            (first_tracked_param): _ViewParameterWrapper(\n",
      "              (view_shape_impl): OverTensorView()\n",
      "            )\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsMax()\n",
      "            )\n",
      "          )\n",
      "          (stats_scaling_impl): _StatsScaling(\n",
      "            (affine_rescaling): Identity()\n",
      "            (restrict_clamp_scaling): _RestrictClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (restrict_scaling_pre): Identity()\n",
      "          )\n",
      "        )\n",
      "        (int_scaling_impl): IntScaling()\n",
      "        (zero_point_impl): ZeroZeroPoint(\n",
      "          (zero_point): StatelessBuffer()\n",
      "        )\n",
      "        (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "          (bit_width): StatelessBuffer()\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (bias_quant): BiasQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "  )\n",
      "  (relu3): QuantReLU(\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "    (act_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): ReLU()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (conv4): QuantConv2d(\n",
      "    16, 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (output_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): Identity()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (weight_quant): WeightQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (tensor_quant): RescalingIntQuant(\n",
      "        (int_quant): IntQuant(\n",
      "          (float_to_int_impl): RoundSte()\n",
      "          (tensor_clamp_impl): TensorClampSte()\n",
      "          (delay_wrapper): DelayWrapper(\n",
      "            (delay_impl): _NoDelay()\n",
      "          )\n",
      "        )\n",
      "        (scaling_impl): StatsFromParameterScaling(\n",
      "          (parameter_list_stats): _ParameterListStats(\n",
      "            (first_tracked_param): _ViewParameterWrapper(\n",
      "              (view_shape_impl): OverTensorView()\n",
      "            )\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsMax()\n",
      "            )\n",
      "          )\n",
      "          (stats_scaling_impl): _StatsScaling(\n",
      "            (affine_rescaling): Identity()\n",
      "            (restrict_clamp_scaling): _RestrictClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (restrict_scaling_pre): Identity()\n",
      "          )\n",
      "        )\n",
      "        (int_scaling_impl): IntScaling()\n",
      "        (zero_point_impl): ZeroZeroPoint(\n",
      "          (zero_point): StatelessBuffer()\n",
      "        )\n",
      "        (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "          (bit_width): StatelessBuffer()\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (bias_quant): BiasQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "  )\n",
      "  (relu4): QuantReLU(\n",
      "    (input_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "    )\n",
      "    (act_quant): ActQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (fused_activation_quant_proxy): FusedActivationQuantProxy(\n",
      "        (activation_impl): ReLU()\n",
      "        (tensor_quant): RescalingIntQuant(\n",
      "          (int_quant): IntQuant(\n",
      "            (float_to_int_impl): RoundSte()\n",
      "            (tensor_clamp_impl): TensorClamp()\n",
      "            (delay_wrapper): DelayWrapper(\n",
      "              (delay_impl): _NoDelay()\n",
      "            )\n",
      "          )\n",
      "          (scaling_impl): ParameterFromRuntimeStatsScaling(\n",
      "            (stats_input_view_shape_impl): OverTensorView()\n",
      "            (stats): _Stats(\n",
      "              (stats_impl): AbsPercentile()\n",
      "            )\n",
      "            (restrict_scaling): _RestrictValue(\n",
      "              (restrict_value_impl): FloatRestrictValue()\n",
      "            )\n",
      "            (clamp_scaling): _ClampValue(\n",
      "              (clamp_min_ste): ScalarClampMinSte()\n",
      "            )\n",
      "            (restrict_inplace_preprocess): Identity()\n",
      "            (restrict_preprocess): Identity()\n",
      "          )\n",
      "          (int_scaling_impl): IntScaling()\n",
      "          (zero_point_impl): ZeroZeroPoint(\n",
      "            (zero_point): StatelessBuffer()\n",
      "          )\n",
      "          (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "            (bit_width): StatelessBuffer()\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (global_pool): TruncAvgPool2d(\n",
      "    kernel_size=2, stride=2, padding=0\n",
      "    (trunc_quant): TruncQuantProxyFromInjector(\n",
      "      (_zero_hw_sentinel): StatelessBuffer()\n",
      "      (tensor_quant): TruncIntQuant(\n",
      "        (msb_clamp_bit_width_impl): BitWidthConst(\n",
      "          (bit_width): StatelessBuffer()\n",
      "        )\n",
      "        (float_to_int_impl): FloorSte()\n",
      "        (delay_wrapper): DelayWrapper(\n",
      "          (delay_impl): _NoDelay()\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (softmax): Softmax(dim=1)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import brevitas.nn as qnn\n",
    "from brevitas.quant.scaled_int import Int8ActPerTensorFloat\n",
    "from brevitas.quant import TruncTo8bit\n",
    "\n",
    "class QuantizedCNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(QuantizedCNN, self).__init__()\n",
    "        # Camada de convolução 1\n",
    "        self.conv1 = qnn.QuantConv2d(4, 16, kernel_size=3, stride=2, padding=1, weight_bit_width=8, input_quant=Int8ActPerTensorFloat, output_quant=Int8ActPerTensorFloat)\n",
    "        # Camada de ativação ReLU 1\n",
    "        self.relu1 = qnn.QuantReLU(return_quant_tensor=True)\n",
    "        # Camada de convolução 2\n",
    "        self.conv2 = qnn.QuantConv2d(16, 8, kernel_size=3, stride=2, padding=1, weight_bit_width=8, input_quant=Int8ActPerTensorFloat, output_quant=Int8ActPerTensorFloat)\n",
    "        # Camada de ativação ReLU 2\n",
    "        self.relu2 = qnn.QuantReLU(return_quant_tensor=True)\n",
    "        # Camada de convolução 3\n",
    "        self.conv3 = qnn.QuantConv2d(8, 16, kernel_size=3, stride=2, padding=1, weight_bit_width=8, input_quant=Int8ActPerTensorFloat, output_quant=Int8ActPerTensorFloat)\n",
    "        # Camada de ativação ReLU 3\n",
    "        self.relu3 = qnn.QuantReLU(return_quant_tensor=True)\n",
    "        # Camada de convolução 4\n",
    "        self.conv4 = qnn.QuantConv2d(16, 8, kernel_size=3, stride=2, padding=1, weight_bit_width=8, input_quant=Int8ActPerTensorFloat, output_quant=Int8ActPerTensorFloat)\n",
    "        # Camada de ativação ReLU 4\n",
    "        self.relu4 = qnn.QuantReLU(return_quant_tensor=True)\n",
    "        # Camada de pooling global média\n",
    "        self.global_pool = qnn.TruncAvgPool2d(output_size=1, kernel_size=2, trunc_quant=TruncTo8bit)\n",
    "        self.softmax = nn.Softmax(1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Passo através da primeira convolução e ativação\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu1(x)\n",
    "        # Passo através da segunda convolução e ativação\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu2(x)\n",
    "        # Passo através da terceira convolução e ativação\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu3(x)\n",
    "        # Passo através da quarta convolução e ativação\n",
    "        x = self.conv4(x)\n",
    "        x = self.relu4(x)\n",
    "        # Pooling global médio\n",
    "        x = self.global_pool(x)\n",
    "        x = self.softmax(x)\n",
    "        # Achatamento para a saída\n",
    "        x = x.view(x.size(0), -1)\n",
    "        return x\n",
    "\n",
    "# Criar uma instância do modelo\n",
    "model = QuantizedCNN()\n",
    "\n",
    "# Exibir a arquitetura do modelo\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 196/196 [01:06<00:00,  2.95it/s]\n",
      "100%|██████████| 196/196 [01:02<00:00,  3.12it/s]\n",
      "100%|██████████| 196/196 [00:55<00:00,  3.55it/s]\n",
      "100%|██████████| 196/196 [00:39<00:00,  4.97it/s]\n",
      "100%|██████████| 196/196 [00:37<00:00,  5.27it/s]\n",
      "100%|██████████| 196/196 [00:54<00:00,  3.57it/s]\n",
      "100%|██████████| 196/196 [00:49<00:00,  3.99it/s]\n",
      "100%|██████████| 196/196 [00:46<00:00,  4.21it/s]\n",
      "100%|██████████| 196/196 [00:57<00:00,  3.39it/s]\n",
      "100%|██████████| 196/196 [00:36<00:00,  5.35it/s]\n",
      "100%|██████████| 196/196 [00:56<00:00,  3.48it/s]\n",
      "100%|██████████| 196/196 [00:44<00:00,  4.40it/s]\n",
      "100%|██████████| 196/196 [00:41<00:00,  4.74it/s]\n",
      "100%|██████████| 196/196 [00:52<00:00,  3.74it/s]\n",
      "100%|██████████| 196/196 [00:37<00:00,  5.21it/s]\n",
      "100%|██████████| 196/196 [00:51<00:00,  3.77it/s]\n",
      "100%|██████████| 196/196 [00:49<00:00,  3.94it/s]\n",
      "100%|██████████| 196/196 [00:42<00:00,  4.65it/s]\n",
      "100%|██████████| 196/196 [00:57<00:00,  3.39it/s]\n",
      "100%|██████████| 196/196 [00:38<00:00,  5.12it/s]\n",
      "100%|██████████| 196/196 [00:50<00:00,  3.90it/s]\n",
      "100%|██████████| 196/196 [00:53<00:00,  3.68it/s]\n",
      "100%|██████████| 196/196 [00:48<00:00,  4.05it/s]\n",
      "100%|██████████| 196/196 [01:02<00:00,  3.13it/s]\n",
      "100%|██████████| 196/196 [00:45<00:00,  4.34it/s]\n",
      "100%|██████████| 196/196 [01:04<00:00,  3.06it/s]\n",
      "100%|██████████| 196/196 [00:48<00:00,  4.08it/s]\n",
      "100%|██████████| 196/196 [01:03<00:00,  3.08it/s]\n",
      "100%|██████████| 196/196 [00:47<00:00,  4.17it/s]\n",
      "100%|██████████| 196/196 [00:58<00:00,  3.36it/s]\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cpu')\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
    "epochs = 30\n",
    "criterion = nn.BCELoss()\n",
    "model.train()\n",
    "for e in range(epochs):\n",
    "    for batch in tqdm(loader_train):\n",
    "        pred = model(batch['x'].to(device))\n",
    "        loss = criterion( pred, batch['y'].to(device))\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fast_gradient_sign_method(model, imgs, labels, attack_params):\n",
    "    # Determine prediction of the model\n",
    "    inp_imgs = imgs.clone().requires_grad_()\n",
    "    preds = model(inp_imgs.to(device))\n",
    "    pred_logprob = torch.log(preds)\n",
    "    #print(labels.dtype)\n",
    "    # Calculate loss by NLL\n",
    "    loss = nn.CrossEntropyLoss()(preds, labels.to(device))\n",
    "    loss.backward()\n",
    "    # Update image to adversarial example as written above\n",
    "    noise_grad = torch.sign(inp_imgs.grad.to(imgs.device))\n",
    "    fake_imgs = imgs + attack_params['epsilon'] * noise_grad\n",
    "    fake_imgs.detach_()\n",
    "    return fake_imgs, noise_grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_model(model, dataloader, fake_generator=None, attack_params=None):\n",
    "    y_pred = []\n",
    "    y_true = []\n",
    "    \n",
    "    for i, batch in enumerate(dataloader):\n",
    "        if fake_generator is not None:\n",
    "            fake_imgs, _ = fake_generator(model, batch['x'],batch['y'], attack_params)\n",
    "            with torch.no_grad():\n",
    "                pred = model(fake_imgs.to(device))\n",
    "        else:\n",
    "            with torch.no_grad():\n",
    "                pred = model(batch['x'].to(device))\n",
    "        y_pred.append(pred.argmax(dim=1).cpu().numpy())\n",
    "        y_true.append(batch['y'].argmax(dim=1).numpy())\n",
    "    y_pred = np.concatenate(y_pred)\n",
    "    y_true = np.concatenate(y_true)\n",
    "    return accuracy_score(y_true, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps = np.logspace(-2, 0, 10)\n",
    "acc_attack = [eval_model(model, loader_test, fast_gradient_sign_method, {'epsilon': e}) for e in eps]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAG1CAYAAAARLUsBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQ80lEQVR4nO3dd3RUZeLG8e9Mep0AgYQUegdJIAmRuqJRVASxALoKGNFVUSxRd2Et7Oq6UXdZXYG1oBSxgChgXRAiWBCBBEINoZOEkISahEDazPz+QMfNj2L6TTLP55w5x7y5985zkXEe33nvHZPdbrcjIiIi4kTMRgcQERERqW8qQCIiIuJ0VIBERETE6agAiYiIiNNRARIRERGnowIkIiIiTkcFSERERJyOCpCIiIg4HVejAzRENpuN7Oxs/Pz8MJlMRscRERGRSrDb7RQWFhISEoLZfOk5HhWgC8jOziY8PNzoGCIiIlINmZmZhIWFXXIbFaAL8PPzA879Afr7+xucRkRERCqjoKCA8PBwx/v4pagAXcAvH3v5+/urAImIiDQylVm+0iAWQc+aNYt27drh6elJbGwsGzZsqNR+CxcuxGQyMWrUqArjf/nLX+jWrRs+Pj40a9aMuLg41q9fXwfJRUREpDEyvAAtWrSIhIQEpk2bxqZNm4iIiGDYsGHk5eVdcr+DBw/yxBNPMHjw4PN+16VLF2bOnMm2bdv44YcfaNeuHddccw1Hjx6tq9MQERGRRsRkt9vtRgaIjY0lJiaGmTNnAueuwAoPD2fy5MlMmTLlgvtYrVaGDBnC3Xffzffff8+pU6dYtmzZRZ+joKAAi8XCqlWruOqqq34z0y/b5+fn6yMwERGRRqIq79+GzgCVlpaSkpJCXFycY8xsNhMXF8e6desuut9zzz1Hq1atmDhxYqWe46233sJisRAREXHBbUpKSigoKKjwEBERkabL0AJ07NgxrFYrQUFBFcaDgoLIycm54D4//PAD77zzDrNnz77ksb/44gt8fX3x9PTklVdeYeXKlQQGBl5w28TERCwWi+OhS+BFRESaNsPXAFVFYWEh48aNY/bs2RctM78YOnQoqamp/Pjjj1x77bWMGTPmouuKpk6dSn5+vuORmZlZF/FFRESkgTD0MvjAwEBcXFzIzc2tMJ6bm0twcPB52+/bt4+DBw8yYsQIx5jNZgPA1dWV9PR0OnbsCICPjw+dOnWiU6dOXH755XTu3Jl33nmHqVOnnndcDw8PPDw8avPUREREpAEzdAbI3d2dqKgokpKSHGM2m42kpCT69+9/3vbdunVj27ZtpKamOh4jR450zPZc6qMrm81GSUlJnZyHiIiINC6G3wgxISGBCRMmEB0dTb9+/Xj11VcpKioiPj4egPHjxxMaGkpiYiKenp706tWrwv4BAQEAjvGioiJeeOEFRo4cSevWrTl27BizZs3i8OHDjB49ul7PTURERBomwwvQ2LFjOXr0KM8++yw5OTlERkayfPlyx8LojIyM3/xCs//l4uLCrl27mD9/PseOHaNFixbExMTw/fff07Nnz7o6DREREWlEDL8PUEOk+wCJiIg0Po3mPkAiIiIiRjD8IzBn8vmWbBanZBkdo1aYTRDdthm3RIXR2uJldBwREZEqUQGqR5knz/Dd7qbzfWRr0o/yr5W7Gdy5JWNjwrmqeys8XF2MjiUiIvKbVIDq0VXdggj29zQ6Rq04XVLOF1uPsOHACb7dfZRvdx+lmbcbo/qEMiY6nO6ttXZKREQaLi2CvgAtgq68A8eK+Dglk49Tssgt+PU+S5eFWhgTHcbIiFAs3m4GJhQREWdRlfdvFaALUAGqOqvNznd7jrI4OZOVO3Mps577a+XuaubansGMiQ5nQMcWmM0mg5OKiEhTpQJUQypANXOiqJRlmw/zUXImu3IKHeOhAV6Mjg7j1qgwwpp5G5hQRESaIhWgGlIBqh12u51th/P5KDmTT1OzKSwuB8BkgoEdAxkdHcawnsF4umnhtIiI1JwKUA2pANW+4jIrK3bk8FFyJmv3HneM+3u6cmPkuYXTvUL9MZn0EZmIiFSPClANqQDVrcwTZ/g4JYuPU7I4fOqsY7xbsB9josO5qU8ozXzcDUwoIiKNkQpQDakA1Q+bzc7afcf4KDmLFTtyKC23AeDuYubqHkGMjg5jcOeWuGjhtIiIVIIKUA2pANW/U2dK+WxLNh8lZ7L9cIFjvLXFk1v6hjE6Ooy2LXwMTCgiIg2dClANqQAZa0d2PouTs1iWephTZ8oc45d3aM6Y6HCu69UaL3ctnBYRkYpUgGpIBahhKCm3smpnHouSM/l+z1F++Zvq6+HKiIgQxkSHERkeoIXTIiICqADVmApQw5N96iyfpGSxOCWLjBNnHOOdW/meWzjdN5RAXw8DE4qIiNFUgGpIBajhstnsrD9wgsXJmXy1/QjFZecWTruaTVzZrRVjY8L5XZeWuLqYDU4qIiL1TQWohlSAGoeC4jK+2HKEj5IzSc085Rhv6efhWDjdsaWvcQFFRKReqQDVkApQ47M7t5CPNmaydPNhjheVOsaj2zZjTHQ41/duja+Hq4EJRUSkrqkA1ZAKUONVWm7jm115LE7OZHV6Hraf/3Z7u7sw/LLWjIkJJ7ptMy2cFhFpglSAakgFqGnILShmyabDLE7OZP+xIsd4h0AfRkeHc0vfUFr5exqYUEREapMKUA2pADUtdrudlEMn+Sg5ky+2HuFMqRUAF7OJK7q05IErOhLdrrnBKUVEpKZUgGpIBajpOl1Szldbzy2cTj50EgCzCZ4Y1pX7h3TErK/dEBFptFSAakgFyDnsO3qaGUl7WJaaDcBV3VrxrzGRWLzdDE4mIiLVUZX3b90sRZxWx5a+vDI2khdvvgx3VzNJu/IYPuN7tmadMjqaiIjUMRUgcWomk4nb+rVhyQMDaNPcm6yTZ7n19XW8v/4QmhwVEWm6VIBEgF6hFj6fPIirewRRarXx1NLtJHy0hTOl5UZHExGROqACJPIzi5cbb42LYup13XAxm1i6+TCjZq1lb95po6OJiEgtUwES+R8mk4n7fteRD+6JpaWfB7tzT3PjzB/4fEu20dFERKQWqQCJXEBshxZ8+fAgLu/QnKJSK5M/3MxfPttBabnN6GgiIlILVIBELqKVnyfvTYxl0hUdAZj340HGvLmOw6fOGpxMRERqSgVI5BJcXcz88dpuvDMhGn9PV1IzTzH8te9Zk55ndDQREakBFSCRSriqexBfPjyYy0ItnDpTRvy8jfxr5W6sNl0qLyLSGKkAiVRSeHNvFt/fnzti22C3w2tJe5gwZwPHT5cYHU1ERKpIBUikCjzdXHjhpst4ZWwEXm4u/LD3GMNf+4GUQyeMjiYiIlWgAiRSDTf1CePThwbSoaUPOQXFjH3zJ97+fr/uHi0i0kioAIlUU5cgPz57aBA39G5Nuc3O375MY9L7mygsLjM6moiI/AYVIJEa8PVwZcbtffjryJ64uZj47/YcRs5cS9qRAqOjiYjIJTSIAjRr1izatWuHp6cnsbGxbNiwoVL7LVy4EJPJxKhRoxxjZWVl/OlPf+Kyyy7Dx8eHkJAQxo8fT3a27uQrdcNkMjFhQDs+uq8/IRZPDhwrYtSstSxOzjQ6moiIXIThBWjRokUkJCQwbdo0Nm3aREREBMOGDSMv79L3WTl48CBPPPEEgwcPrjB+5swZNm3axDPPPMOmTZtYsmQJ6enpjBw5si5PQ4Q+bZrx5cOD+V2XlpSU23jy461M+WQrxWVWo6OJiMj/Y7IbvGozNjaWmJgYZs6cCYDNZiM8PJzJkyczZcqUC+5jtVoZMmQId999N99//z2nTp1i2bJlF32OjRs30q9fPw4dOkSbNm1+M1NBQQEWi4X8/Hz8/f2rdV7ivGw2OzNX7+WVVbux26FHa39ev7MvbVv4GB1NRKRJq8r7t6EzQKWlpaSkpBAXF+cYM5vNxMXFsW7duovu99xzz9GqVSsmTpxYqefJz8/HZDIREBBwwd+XlJRQUFBQ4SFSXWaziYev6syCu2Np7uPOziMF3DDjB1bsyDE6moiI/MzQAnTs2DGsVitBQUEVxoOCgsjJufCbxQ8//MA777zD7NmzK/UcxcXF/OlPf+L222+/aBtMTEzEYrE4HuHh4VU7EZELGNQ5kC8fHkRU22YUFpdz34IU/v5VGmVWfaGqiIjRDF8DVBWFhYWMGzeO2bNnExgY+Jvbl5WVMWbMGOx2O6+//vpFt5s6dSr5+fmOR2amFq9K7Wht8WLhHy7nnkHtAXjru/3cMXs9uQXFBicTEXFurkY+eWBgIC4uLuTm5lYYz83NJTg4+Lzt9+3bx8GDBxkxYoRjzGY793/Trq6upKen07HjuW/u/qX8HDp0iG+++eaSnwV6eHjg4eFRG6ckch43FzNP39CDqLbNePLjrWw4eILhr33Pa7f3YUDH3y7yIiJS+wydAXJ3dycqKoqkpCTHmM1mIykpif79+5+3fbdu3di2bRupqamOx8iRIxk6dCipqamOj65+KT979uxh1apVtGjRot7OSeRirrusNZ9PHkS3YD+OnS7lzrfXM2v1Xmz6QlURkXpn6AwQQEJCAhMmTCA6Opp+/frx6quvUlRURHx8PADjx48nNDSUxMREPD096dWrV4X9f1nY/Mt4WVkZt956K5s2beKLL77AarU61hM1b94cd3f3+js5kf+nfaAPSycN5JlPt/NxShb/WJFOyqGT/GtMBAHe+rspIlJfDC9AY8eO5ejRozz77LPk5OQQGRnJ8uXLHQujMzIyMJsrP1F1+PBhPvvsMwAiIyMr/G716tVcccUVtRVdpFq83F345+gI+rVrzjOfbuebXXkMf+0HXr+zL73DAoyOJyLiFAy/D1BDpPsASX3ZkZ3PpPc3cej4GdxdzDwzogd3xrbBZDIZHU1EpNFpNPcBEnF2PUMsfPbQIK7pEUSp1cYzy7bz2KJUikrKjY4mItKkaQboAjQDJPXNbrfz9vcHeHH5Lqw2O51b+fL6nX3p1MrP6Gh17mRRKTuyC9iRnU/akQL8vdy4qU8okeEBmgkTkSqpyvu3CtAFqACJUTYcOMFDH2wir7AEb3cXXrylNyMjQoyOVSvsdjvZ+cXsOJz/c+EpYGd2Ptn5F74nUpcgX8ZEhzOqTyiBvrpNhYj8NhWgGlIBEiMdLSzh4Q83s27/cQDG92/LU8O74+HqYnCyyrPa7Bw4dtpRdHZk57Mzu4CTZ8ouuH3bFt70DPGnR2t/9h0t4qttRygp//keX2YTV3VvxZjocH7XpSWuLvrkXkQuTAWohlSAxGhWm51XVu5m5uq9AESEBzDr930Ia+ZtcLLzlZRb2Z1zmh3Z52Z2tmfns+tIIWfLrOdt62o20amVLz1DLPQM8adniD/dQ/zx93SrsF3+2TK+2JrNRxsz2ZKV7xhv6efBLX3DGB0dRseWvnV+biLSuKgA1ZAKkDQU3+zK5bFFW8g/W0aAtxuvjI1kaNdWhuUpLC5jp2NW59zMzt6805Rf4GaOXm4udG/t9z9lx0LnIF883ao2k7Urp4DFyVks3XyYE0WljvHots0YEx3O8N6t8fEw/I4eItIAqADVkAqQNCSZJ87w4Aeb2PrzTMjkKzvxaFwXXMx1u0A4r7D453U6BY7ZnUPHz1xw22bebo6i0+PnstM+0KdWM5aW2/hmVy4fJWexJj2PXzqXt7sLN/RuzZjocKLaNtPCaREnpgJUQypA0tCUlFv52xdpLPjpEAADO7Xg37f1qZXFwXa7nYwTZxwzOr/M7hwtLLng9iEWT3r8z0dYvUIttLZ41mvxyC0o5pNNWSxOzuLAsSLHeIdAH0ZHh3NL31Ba+XvWWx4RaRhUgGpIBUgaqk9TDzPlk22cLbMS5O/BrN/3Jbpd80rvX2a1se/oaXYc/p/FyUcKKCw+/75DJtO5QvG/H2H1DPGnmU/D+coOu91O8qGTLNqYyZdbjzjWHbmYTQzt2pLR0eFc2a0Vblo4LeIUVIBqSAVIGrI9uYXc/14K+44W4WI2MfW6bkwc1P68GZizpVbScn693HxHdgG7cgop/fnqqv/l7mKma7CfY1anR4iF7q398HZvPGtrTpeU8+XWbD5KziLl0EnHeKCvOzf1CWVMdDidg5r+fZVEnJkKUA2pAElDV1RSzpQl2/h8SzYAw3oGceflbUk78usC5f1HT3OhL5r39XClR2t/eob+OqvTqZVvk5ol2Zt3msUpmXyScphjp3/9KC8yPIAx0eHcENH6vCvPRKTxUwGqIRUgaQzsdjvv/XSI577YSZn1wi/jQF8Px6zOL2WnTXNvzHW8gLqhKLPa+Db9KB8lZ/LNrjzH1Wqebmau79WaMTHhxLZvroXTIk2EClANqQBJY5KaeYpnlm0n/2zZeWVHC4F/dbSwhKWbs/goOYu9eacd421beDM6KoxbosJobfEyMKGI1JQKUA2pAIk0XXa7nc2Zp1icnMnnW45w+ucvnjWbYHDnloyJDieuR6tGdedtETlHBaiGVIBEnMOZ0nL+uy2Hj5IzWX/ghGO8mbcbo35eON29tf4bINJYqADVkAqQiPM5eKyIxSmZfJySRW7BrwunLwu1MCY6jJERoVi8tXBapCFTAaohFSAR52W12fluz1EWJ2eycmeuY4G5u6uZa3sGMyY6nAEdWzjNQnKRxkQFqIZUgEQE4ERRKcs2H+aj5Ex25RQ6xkMDvBgdHcatUWEN8gtqRZyVClANqQCJyP+y2+1sP1zAR8mZLEs97LhztskEAzsGMjo6jGE9g6v8Ra8iUrtUgGpIBUhELqa4zMqKHecWTq/de9wx7u/pyo2R5xZO9wr1172FRAygAlRDKkAiUhmZJ87wcUoWH6dkcfjUWcd4t2A/7h7UnjHR4QamE3E+KkA1pAIkIlVhs9n5cd9xPkrOZPmOHMf3rT1zQw8mDmpvcDoR51GV9+/G802HIiINlNlsYlDnQAZ1DiT/TBmvf7uPN77dx9++3ElogCfX9mptdEQR+X+azrcfiog0ABZvN/50bVfuvLwNdjs8sjCVzRknf3tHEalXKkAiIrXMZDLxlxE9ubJbK0rKbdwzP5lDx4uMjiUi/0MFSESkDri6mJlxex96hfpzvKiU+LkbOVlUanQsEfmZCpCISB3x8XBlzoQYQiye7D9WxB8WJFNcZjU6loigAiQiUqda+XsyN74ffh6ubDx4kic/3orNpotvRYymAiQiUse6BvvxxrgoXM0mPt+SzT++Tjc6kojTUwESEakHAzsF8uItvQF4fc0+PlifYXAiEeemAiQiUk9ujQrjkas6A/DMp9tZnZ5ncCIR56UCJCJSjx6N68wtfcOw2uw89P4mdmTnGx1JxCmpAImI1COTyUTizZcxoGMLikqt3D1vI9n/8z1iIlI/VIBEROqZu6uZ1++MokuQL7kFJdw9byMFxWVGxxJxKipAIiIGsHi5MeeuGFr6ebArp5AH399EmdVmdCwRp6ECJCJikLBm3sy9KwZvdxe+33OMp5Zuw27XPYJE6oMKkIiIgXqFWpj5+z6YTfBRchYzv9lrdCQRp2B4AZo1axbt2rXD09OT2NhYNmzYUKn9Fi5ciMlkYtSoURXGlyxZwjXXXEOLFi0wmUykpqbWfmgRkVp0Zbcg/npjLwCmr9zN0s1ZBicSafoMLUCLFi0iISGBadOmsWnTJiIiIhg2bBh5eZe+N8bBgwd54oknGDx48Hm/KyoqYtCgQbz00kt1FVtEpNaNu7wt9w3pAMAfP97Kun3HDU4k0rSZ7AZ+4BwbG0tMTAwzZ84EwGazER4ezuTJk5kyZcoF97FarQwZMoS7776b77//nlOnTrFs2bLztjt48CDt27dn8+bNREZGVilXQUEBFouF/Px8/P39q3paIiLVYrPZmfzhZr7cdgR/T1eWTBpAp1Z+RscSaTSq8v5t2AxQaWkpKSkpxMXF/RrGbCYuLo5169ZddL/nnnuOVq1aMXHixFrLUlJSQkFBQYWHiEh9M5tNTB8TQVTbZhQUlzNhzkbyCouNjiXSJBlWgI4dO4bVaiUoKKjCeFBQEDk5ORfc54cffuCdd95h9uzZtZolMTERi8XieISHh9fq8UVEKsvTzYXZ46NpH+jD4VNnmTgvmTOl5UbHEmlyDF8EXVmFhYWMGzeO2bNnExgYWKvHnjp1Kvn5+Y5HZmZmrR5fRKQqmvu4M/euGJp5u7HtcD4Pf7gZq02Xx4vUJlejnjgwMBAXFxdyc3MrjOfm5hIcHHze9vv27ePgwYOMGDHCMWaznbtpmKurK+np6XTs2LFaWTw8PPDw8KjWviIidaFdoA9vT4jm9tnrWZWWx3Of7+AvI3tiMpmMjibSJBg2A+Tu7k5UVBRJSUmOMZvNRlJSEv379z9v+27durFt2zZSU1Mdj5EjRzJ06FBSU1P1sZWINDlRbZvz6thITCaYv+4Q7/xwwOhIIk2GYTNAAAkJCUyYMIHo6Gj69evHq6++SlFREfHx8QCMHz+e0NBQEhMT8fT0pFevXhX2DwgIAKgwfuLECTIyMsjOzgYgPT0dgODg4AvOLImINGTXX9aaP1/XnRe+SuOFr9IIDfDiustaGx1LpNEztACNHTuWo0eP8uyzz5KTk0NkZCTLly93LIzOyMjAbK7aJNVnn33mKFAAt912GwDTpk3jL3/5S61lFxGpL/cMbk/GiTMs+OkQjy5KpZW/J1FtmxkdS6RRM/Q+QA2V7gMkIg1NudXGfQtSSNqVR3Mfd5Y8MIB2gT5GxxJpUBrFfYBERKTyXF3MzPh9Hy4LtXCiqJT4eRs5WVRqdCyRRksFSESkkfB2d+Wdu6IJDfDiwLEi7n03meIyq9GxRBolFSARkUaklZ8nc+Nj8PN0JfnQSR5fvAWb7hEkUmUqQCIijUyXID/eHBeFm4uJL7ce4eUV6UZHEml0VIBERBqhAR0DeemW3gC88e0+3l9/yOBEIo2LCpCISCN1c98wHovrAsAzy7azeleewYlEGg8VIBGRRuzhqzpxa1QYNjs8+MEmth/ONzqSSKOgAiQi0oiZTCYSb76MQZ0COVNq5e55Gzl86qzRsUQaPBUgEZFGzs3FzH/u7EvXID/yCku4e+5GCorLjI4l0qCpAImINAH+nm7MjY+hlZ8H6bmFPPBeCqXlNqNjiTRYKkAiIk1ESIAXc+6KwdvdhbV7j/PnpdvQtx2JXJgKkIhIE9Ir1MKs3/fFxWzi45QsXkvaa3QkkQZJBUhEpIkZ2q0Vz93YE4BXVu3mk5QsgxOJNDwqQCIiTdAdsW25/3cdAZiyZCs/7j1mcCKRhkUFSESkifrjsK7c0Ls1ZVY7972Xwu7cQqMjiTQYKkAiIk2U2Wzin6MjiGnXjMLicuLnbiSvoNjoWCINggqQiEgT5unmwlvjoukQ6MPhU2e5e/5GikrKjY4lYjgVIBGRJq6Zjztz42No7uPO9sMFPPzhZsqtukeQODcVIBERJ9C2hQ9vT4jGw9VM0q48/vr5Tt0jSJyaCpCIiJPo26YZ/74tEpMJFvx0iLe/P2B0JBHDqACJiDiRa3u15qnruwPwwldpfLXtiMGJRIyhAiQi4mQmDmrPhP5tAXh0USoph04YnEik/qkAiYg4GZPJxLMjehLXPYjSchv3zE/m4LEio2OJ1CsVIBERJ+RiNvHa7ZH0DrNw8kwZd83dwImiUqNjidQbFSARESfl7e7K2xOiCQ3w4uDxM9z7bjLFZVajY4nUCxUgEREn1srPk/l3x+Dv6UrKoZM8/tEWbDZdHi9NnwqQiIiT69TKj7fGR+PmYuLLbUd4afkuoyOJ1DkVIBER4fIOLfjHrREAvPndfhb8dMjgRCJ1SwVIREQAGNUnlMev7gLAtE+3882uXIMTidQdFSAREXF46MpOjI0Ox2aHhz7YzLasfKMjidQJFSAREXEwmUz87aZeDO4cyJlSK3fP30jWyTNGxxKpdSpAIiJSgZuLmf/c0ZduwX4cLSzh7nkbyT9bZnQskVqlAiQiIufx83RjbnwMQf4e7M49zQPvpVBabjM6lkitUQESEZELam3xYs5dMfi4u/DjvuNMWbIVu133CJKmQQVIREQuqmeIhVl39MXFbGLJpsP8O2mP0ZFEaoUKkIiIXNIVXVvxt1G9AHh11R4+TskyOJFIzakAiYjIb7q9XxsmXdERgCmfbGXt3mMGJxKpmQZRgGbNmkW7du3w9PQkNjaWDRs2VGq/hQsXYjKZGDVqVIVxu93Os88+S+vWrfHy8iIuLo49ezRtKyJSE09c05URESGU2+zcvyCF9JxCoyOJVJvhBWjRokUkJCQwbdo0Nm3aREREBMOGDSMvL++S+x08eJAnnniCwYMHn/e7l19+mddee4033niD9evX4+Pjw7BhwyguLq6r0xARafLMZhP/HN2bfu2aU1hSzt3zNpJXoP+uSuNkeAH617/+xb333kt8fDw9evTgjTfewNvbmzlz5lx0H6vVyh133MFf//pXOnToUOF3drudV199laeffpobb7yR3r178+6775Kdnc2yZcvq+GxERJo2D1cX3hofRYeWPhw+dZa752+kqKTc6FgiVWZoASotLSUlJYW4uDjHmNlsJi4ujnXr1l10v+eee45WrVoxceLE83534MABcnJyKhzTYrEQGxt70WOWlJRQUFBQ4SEiIhcW4O3OvLv60cLHne2HC5j84WbKrbpHkDQuhhagY8eOYbVaCQoKqjAeFBRETk7OBff54YcfeOedd5g9e/YFf//LflU5ZmJiIhaLxfEIDw+v6qmIiDiVNi28eXtCNJ5uZr7ZlcdfPt+hewRJo2L4R2BVUVhYyLhx45g9ezaBgYG1dtypU6eSn5/veGRmZtbasUVEmqo+bZrx6tg+mEzw3k8ZvPXdfqMjiVSaq5FPHhgYiIuLC7m5uRXGc3NzCQ4OPm/7ffv2cfDgQUaMGOEYs9nOTbu6urqSnp7u2C83N5fWrVtXOGZkZOQFc3h4eODh4VHT0xERcTrX9grm6eE9eP6LnST+dxdhzbwZ3rv1b+8oYjBDZ4Dc3d2JiooiKSnJMWaz2UhKSqJ///7nbd+tWze2bdtGamqq4zFy5EiGDh1Kamoq4eHhtG/fnuDg4ArHLCgoYP369Rc8poiI1MzEQe25a0A7AB77KJXkgyeMDSRSCdWaAVq9ejVDhw6tlQAJCQlMmDCB6Oho+vXrx6uvvkpRURHx8fEAjB8/ntDQUBITE/H09KRXr14V9g8ICACoMP7oo4/yt7/9jc6dO9O+fXueeeYZQkJCzrtfkIiI1I5nbujB4VNnWbkzl3vfTWbJpIG0D/QxOpbIRVWrAF177bWEhYURHx/PhAkTarRoeOzYsRw9epRnn32WnJwcIiMjWb58uWMRc0ZGBmZz1Saq/vjHP1JUVMQf/vAHTp06xaBBg1i+fDmenp7VzikiIhfnYjbx2m19uO2tdWzJyueuuRtY8sAAWvhqeYE0TCZ7NZbtHzt2jAULFjB//nx27NjBlVdeycSJExk1ahTu7u51kbNeFRQUYLFYyM/Px9/f3+g4IiKNxtHCEm5+fS2ZJ87St00AH9x7OZ5uLkbHEidRlffvaq0BCgwM5LHHHiM1NZX169fTpUsXJk2aREhICA8//DBbtmypVnAREWncWvp5MPeufvh7urIp4xSPLUrFZtPl8dLw1HgRdN++fZk6dSoPPfQQp0+fZs6cOURFRTF48GB27NhRGxlFRKQR6dTKl7fGR+PuYua/23N4cfkuoyOJnKfaBaisrIyPP/6Y66+/nrZt27JixQpmzpxJbm4ue/fupW3btowePbo2s4qISCNxeYcW/GN0bwDe+m4/C9YdNDaQyP9TrTVAkydP5sMPP8RutzNu3Djuueee867OysnJISQkxHGfnsZEa4BERGrHrNV7+ceKdMwmeGtcNHE9gn57J5FqqvM1QDt37mTGjBlkZ2fz6quvnld+4Nw6odWrV1fn8CIi0kRMuqIjt8WEY7PD5A83sy0r3+hIIkA1Z4CaOs0AiYjUnjKrjYnzk/lu91Fa+nmwdNIAwpp5Gx1LmqA6nwFKTExkzpw5543PmTOHl156qTqHFBGRJsrNxcys3/ehW7AfRwtLiJ+7kfyzZUbHEidXrQL05ptv0q1bt/PGe/bsyRtvvFHjUCIi0rT4eboxNz6GYH9P9uSd5v4FKZSWN741otJ0VKsA5eTkVPii0V+0bNmSI0eO1DiUiIg0Pa0tXsy5KwZfD1fW7T/OlE+2olUYYpRqFaDw8HDWrl173vjatWsJCQmpcSgREWmaeoT4M+uOvriYTSzZfJhXVu0xOpI4qWoVoHvvvZdHH32UuXPncujQIQ4dOsScOXN47LHHuPfee2s7o4iINCG/69KSF0adu3r4taQ9LE7ONDiROKNqfRnqk08+yfHjx5k0aRKlpaUAeHp68qc//YmpU6fWakAREWl6buvXhsyTZ5i1eh9Tl2yjtcWLQZ0DjY4lTqRGl8GfPn2atLQ0vLy86Ny5Mx4eTeNbf3UZvIhI3bPb7Ty6KJVPU7Px83Bl8QP96Ras/+ZK9dX5ZfC/8PX1JSYmhl69ejWZ8iMiIvXDZDLx8q296de+OYUl5dw9dyO5BcVGxxInUe0ZoOTkZD766CMyMjIcH4P9YsmSJbUSziiaARIRqT+nzpRy8+s/sv9oET1D/Pnovv74eFRrhYY4uTqfAVq4cCEDBgwgLS2NpUuXUlZWxo4dO/jmm2+wWCzVCi0iIs4pwNud+fH9CPR1Z0d2AQ99sIlyq+4RJHWrWgXo73//O6+88gqff/457u7u/Pvf/2bXrl2MGTOGNm3a1HZGERFp4sKbe/P2hBg83cysTj/KtM926B5BUqeqVYD27dvH8OHDAXB3d6eoqAiTycRjjz3GW2+9VasBRUTEOUSGB/DabX0wmeD99Rm8+d1+oyNJE1atAtSsWTMKCwsBCA0NZfv27QCcOnWKM2fO1F46ERFxKtf0DObZG3oA8OJ/d/H5lmyDE0lTVa0CNGTIEFauXAnA6NGjeeSRR7j33nu5/fbbueqqq2o1oIiIOJf4ge2JH9gOgMcXb2HjwRPGBpImqVpXgZ04cYLi4mJCQkKw2Wy8/PLL/Pjjj3Tu3Jmnn36aZs2a1UXWeqOrwEREjGW12Zn0fgorduQS4O3GkgcG0KGlr9GxpIGryvt3lQtQeXk5H3zwAcOGDSMoKKhGQRsqFSAREeOdLbVy2+yf2JJ5ijbNvVk6aQAtfHXPObm4Or0M3tXVlfvvv5/iYt2sSkRE6o6XuwvvTIgmvLkXGSfOcM+7yRSXWY2OJU1EtdYA9evXj9TU1FqOIiIiUlGgrwfz4vth8XJjc8YpHluUis2my+Ol5qp1q81JkyaRkJBAZmYmUVFR+Pj4VPh97969ayWciIhIx5a+vDUuinHvbOC/23P4+1dpPP3zlWIi1VWtRdBm8/kTRyaTCbvdjslkwmpt3FOUWgMkItLwfJp6mEcWpgLw15E9mTCgnaF5pOGpyvt3tWaADhw4UK1gIiIi1XVjZChZJ8/yjxXp/PXzHYQGeBHXo2lejCN1r1oFqG3btrWdQ0RE5DdNuqIjWSfP8OGGTCZ/uJlF911O77AAo2NJI1StAvTuu+9e8vfjx4+vVhgREZFLMZlMPHdjLw6fKua73Ue5e14ySycNILy5t9HRpJGp1hqg/3+jw7KyMs6cOYO7uzve3t6cONG479qpNUAiIg3b6ZJyRr+xjrQjBXRq5csn9w/A4u1mdCwxWJ3eBwjg5MmTFR6nT58mPT2dQYMG8eGHH1YrtIiISGX5ergy964Ygv092Zt3mvveS6akvHFfgCP1q1oF6EI6d+7Miy++yCOPPFJbhxQREbmoYIsnc+Nj8PVw5af9J5jyyTaq8aGGOKlaK0Bw7i7R2dn65l4REakf3Vv78587+uJiNrF082FeWbnb6EjSSFRrEfRnn31W4We73c6RI0eYOXMmAwcOrJVgIiIilTGkS0v+flMv/vTJNl77Zi9hzbwZExNudCxp4KpVgEaNGlXhZ5PJRMuWLbnyyiuZPn16beQSERGptLExbcg8cZaZq/fy56XbaB3gyeDOLY2OJQ1YtQqQzWar7RwiIiI18vg1Xcg6eYZlqdlMem8Tix/oT7dgXckrF1ara4BERESMYjKZeOnW3sS2b05hSTnxczeSk19sdCxpoKpVgG655RZeeuml88ZffvllRo8eXaVjzZo1i3bt2uHp6UlsbCwbNmy46LZLliwhOjqagIAAfHx8iIyMZMGCBRW2yc3N5a677iIkJARvb2+uvfZa9uzZU6VMIiLSOHm4uvDWuGg6tvThSH4xd8/byOmScqNjSQNUrQL03Xffcf311583ft111/Hdd99V+jiLFi0iISGBadOmsWnTJiIiIhg2bBh5eXkX3L558+Y89dRTrFu3jq1btxIfH098fDwrVqwAzi3GHjVqFPv37+fTTz9l8+bNtG3blri4OIqKiqpzqiIi0shYvN2YF9+PQF93dh4p4MH3N1Fu1dINqahad4L28vIiNTWVrl27VhjftWsXffr04ezZs5U6TmxsLDExMcycORM4t7YoPDycyZMnM2XKlEodo2/fvgwfPpznn3+e3bt307VrV7Zv307Pnj0dxwwODubvf/8799xzT6WOqTtBi4g0flsyTzH2rXUUl9m4vV8b/n5TL0wmk9GxpA7V+Z2gL7vsMhYtWnTe+MKFC+nRo0eljlFaWkpKSgpxcXG/hjGbiYuLY926db+5v91uJykpifT0dIYMGQJASUkJAJ6enhWO6eHhwQ8//HDRY5WUlFBQUFDhISIijVtEeACv3dYHkwk+3JDB69/uMzqSNCDVugrsmWee4eabb2bfvn1ceeWVACQlJfHhhx+yePHiSh3j2LFjWK1WgoKCKowHBQWxa9eui+6Xn59PaGgoJSUluLi48J///Ierr74agG7dutGmTRumTp3Km2++iY+PD6+88gpZWVkcOXLkosdMTEzkr3/9a6Vyi4hI43FNz2Cm3dCDv3y+k5eXpxPWzJuRESFGx5IGoFozQCNGjGDZsmXs3buXSZMm8fjjj5OVlcWqVavOu0dQbfPz8yM1NZWNGzfywgsvkJCQwJo1awBwc3NjyZIl7N69m+bNm+Pt7c3q1au57rrrMJsvfqpTp04lPz/f8cjMzKzTcxARkfpz18D2TBzUHoAnPtrChgON+wu7pXZUawYIYPjw4QwfPrzaTxwYGIiLiwu5ubkVxnNzcwkODr7ofmazmU6dOgEQGRlJWloaiYmJXHHFFQBERUWRmppKfn4+paWltGzZktjYWKKjoy96TA8PDzw8PKp9LiIi0rD9+fruZJ08w4odudz7bjJLJg2gY0tfo2OJgao1A7Rx40bWr19/3vj69etJTk6u1DHc3d2JiooiKSnJMWaz2UhKSqJ///6VzmKz2Rxrf/6XxWKhZcuW7Nmzh+TkZG688cZKH1NERJoWF7OJV8f2ITI8gPyzZcTP3cix0+e/d4jzqFYBevDBBy/4MdHhw4d58MEHK32chIQEZs+ezfz580lLS+OBBx6gqKiI+Ph4AMaPH8/UqVMd2ycmJrJy5Ur2799PWloa06dPZ8GCBdx5552ObRYvXsyaNWscl8JfffXVjBo1imuuuaY6pyoiIk2El7sLb0+Ipk1zbzJOnOGe+cmcLbUaHUsMUq2PwHbu3Enfvn3PG+/Tpw87d+6s9HHGjh3L0aNHefbZZ8nJySEyMpLly5c7FkZnZGRUWLtTVFTEpEmTyMrKwsvLi27duvHee+8xduxYxzZHjhwhISGB3NxcWrduzfjx43nmmWeqc5oiItLEBPp6MDc+hlte/5HUzFM8umgz/7kjChezLo93NtW6D1CLFi344osvzvuo6scff2T48OGcPHmy1gIaQfcBEhFp2jYcOMGdb6+n1Gpj4qD2PHND5W7hIg1bnd8H6JprrnFcOfWLU6dO8ec//9lxSbqIiEhD1a99c/45JgKAd344wLy1BwxOJPWtWh+B/fOf/2TIkCG0bduWPn36AJCamkpQUNB5380lIiLSEI2MCCHr5BleXp7OX7/YSUiAF9f0vPhVyNK0VOsjMDi3Huf9999ny5YteHl50bt3b26//Xbc3NxqO2O900dgIiLOwW638+el2/lwQwaebmYW/aE/EeEBRseSaqrK+3e1CxCcWwydkZFBaWlphfGRI0dW95ANggqQiIjzKLfamDg/mW93HyXQ152lkwYS3tzb6FhSDXVegPbv389NN93Etm3bMJlM2O32Cl8wZ7U27ssKVYBERJzL6ZJyxryxjp1HCujY0oclDwzE4t34P9FwNnW+CPqRRx6hffv25OXl4e3tzfbt2/n222+Jjo52fC2FiIhIY+Hr4crc+BhaWzzZd7SIPyxIpqS8cf/PvFxatQrQunXreO655wgMDMRsNuPi4sKgQYNITEzk4Ycfru2MIiIidS7I35O58TH4eriy/sAJ/vTxVmqwSkQauGoVIKvVip+fH3DuO72ys7MBaNu2Lenp6bWXTkREpB51C/bn9Tv74mo2sSw1m+lf7zY6ktSRahWgXr16sWXLFgBiY2N5+eWXWbt2Lc899xwdOnSo1YAiIiL1aXDnlvz95ssAmLl6L4s2ZhicSOpCtQrQ008/jc1mA+C5557jwIEDDB48mK+++orXXnutVgOKiIjUtzHR4Tx8ZScA/rx0O9/tPmpwIqltNboM/n+dOHGCZs2aVbgarLHSVWAiImK320n4aAtLNx/G18OVj+7rT48QvSc0ZHV+FdiFNG/evEmUHxEREQCTycRLt/Tm8g7NOV1Szt3zNpKTX2x0LKkltVaAREREmhp3VzNv3hlNp1a+5BQUEz9vI4XFZUbHklqgAiQiInIJFm835t4VQ6CvB2lHCnjwg82UWW1Gx5IaUgESERH5DeHNvZlzVzRebi58t/sozyzbrnsENXIqQCIiIpXQOyyAGbf3wWyChRsz+c+afUZHkhpQARIREamkuB5BTBvRE4B/rEjn09TDBieS6lIBEhERqYIJA9pxz6D2ADy5eCvr9x83OJFUhwqQiIhIFf35+u5c1yuYUquNPyxIYW/eaaMjSRWpAImIiFSR2WzilbGR9GkTQP7ZMuLnbeBoYYnRsaQKVIBERESqwdPNhbfHR9O2hTeZJ85yz7vJnC21Gh1LKkkFSEREpJpa+How964YArzd2JJ5ikcWbsZq0+XxjYEKkIiISA10aOnL7PHRuLua+XpnLn/7cqfRkaQSVIBERERqKKZdc6aPjgBg7tqDzPnhgMGJ5LeoAImIiNSCEREhTLmuGwDPf7mTFTtyDE4kl6ICJCIiUkvuG9KB38e2wW6HRxZuJjXzlNGR5CJUgERERGqJyWTiuZE9Gdq1JcVlNibO20jG8TNGx5ILUAESERGpRa4uZmb+vi89Q/w5XlTKXfM2cOpMqdGx5P9RARIREallPh6uzLkrhhCLJ/uPFvGHBSmUlOseQQ2JCpCIiEgdCPL3ZG58P/w8XNlw4ARPLt6KTfcIajBUgEREROpI12A/Xr8zClezic+2ZDN9ZbrRkeRnKkAiIiJ1aFDnQBJvvgyAWav38eGGDIMTCagAiYiI1LnR0eE8fFVnAJ5etp016XkGJxIVIBERkXrwWFxnbu4TitVm58H3N7Ezu8DoSE5NBUhERKQemEwmXrylN/07tKCo1Mrd8zZyJP+s0bGclgqQiIhIPXF3NfPGuCg6t/Ilp6CY+LkbKSwuMzqWU1IBEhERqUcWLzfmxsfQ0s+DXTmFTHp/E2VWm9GxnI7hBWjWrFm0a9cOT09PYmNj2bBhw0W3XbJkCdHR0QQEBODj40NkZCQLFiyosM3p06d56KGHCAsLw8vLix49evDGG2/U9WmIiIhUWlgzb96ZEI2Xmwvf7znG00u3Y7frHkH1ydACtGjRIhISEpg2bRqbNm0iIiKCYcOGkZd34dXxzZs356mnnmLdunVs3bqV+Ph44uPjWbFihWObhIQEli9fznvvvUdaWhqPPvooDz30EJ999ll9nZaIiMhv6h0WwMzf98FsgkXJmcxavdfoSE7FZDewcsbGxhITE8PMmTMBsNlshIeHM3nyZKZMmVKpY/Tt25fhw4fz/PPPA9CrVy/Gjh3LM88849gmKiqK6667jr/97W+VOmZBQQEWi4X8/Hz8/f2reFYiIiKVt2DdQZ75dAcAr46NZFSfUIMTNV5Vef82bAaotLSUlJQU4uLifg1jNhMXF8e6det+c3+73U5SUhLp6ekMGTLEMT5gwAA+++wzDh8+jN1uZ/Xq1ezevZtrrrnmoscqKSmhoKCgwkNERKQ+jOvfjnsHtwfgyY+38NP+4wYncg6GFaBjx45htVoJCgqqMB4UFEROTs5F98vPz8fX1xd3d3eGDx/OjBkzuPrqqx2/nzFjBj169CAsLAx3d3euvfZaZs2aVaEk/X+JiYlYLBbHIzw8vOYnKCIiUklTr+vO9ZcFU2a184d3k9mbV2h0pCbP8EXQVeXn50dqaiobN27khRdeICEhgTVr1jh+P2PGDH766Sc+++wzUlJSmD59Og8++CCrVq266DGnTp1Kfn6+45GZmVkPZyIiInKO2WziX2Mi6dsmgILicu6au5GjhSVGx2rSDFsDVFpaire3Nx9//DGjRo1yjE+YMIFTp07x6aefVuo499xzD5mZmaxYsYKzZ89isVhYunQpw4cPr7BNVlYWy5cvr9QxtQZIRESMcPx0CTe//iOHjp+hd5iFhX+4HG93V6NjNRqNYg2Qu7s7UVFRJCUlOcZsNhtJSUn079+/0sex2WyUlJxryWVlZZSVlWE2VzwtFxcXbDbdY0FERBq2Fr4ezIvvRzNvN7Zm5fPwh6lYbbo8vi4Y+hFYQkICs2fPZv78+aSlpfHAAw9QVFREfHw8AOPHj2fq1KmO7RMTE1m5ciX79+8nLS2N6dOns2DBAu68804A/P39+d3vfseTTz7JmjVrOHDgAPPmzePdd9/lpptuMuQcRUREqqJ9oA+zx0fj7mpmVVouz3+xU/cIqgOGzquNHTuWo0eP8uyzz5KTk0NkZCTLly93LIzOyMioMJtTVFTEpEmTyMrKwsvLi27duvHee+8xduxYxzYLFy5k6tSp3HHHHZw4cYK2bdvywgsvcP/999f7+YmIiFRHdLvmvDImkgc/2MS8Hw8S3tybiYPaGx2rSTH0PkANldYAiYhIQ/Dmt/tI/O8uTCZ4/Y6+XNurtdGRGrRGsQZIRERELu0PQzpw5+VtsNvhkYWpbMo4aXSkJkMFSEREpIEymUz8ZURPruzWipJyG/fMTybr5BmjYzUJKkAiIiINmKuLmRm396FXqD8nikp5eXm60ZGaBBUgERGRBs7Hw5WXbukNwOdbs0k7oq9sqikVIBERkUagZ4iF4b1bY7fD9K93Gx2n0VMBEhERaSQSru6C2QSr0nK1ILqGVIBEREQaiY4tfbmlbxgA07/WWqCaUAESERFpRB6J64ybi4m1e4/z495jRsdptFSAREREGpGwZt7cEdsWgH98na6vyagmFSAREZFGZtLQjni6mdmccYqktDyj4zRKKkAiIiKNTCs/T+IHnvtusH9+nY5N3xhfZSpAIiIijdB9Qzrg5+HKrpxCvth2xOg4jY4KkIiISCMU4O3OH4Z0AOCVlbspt9oMTtS4qACJiIg0UvGD2tPCx50Dx4r4ZFOW0XEaFRUgERGRRsrXw5UHrugIwL9X7aG4zGpwosZDBUhERKQRu/PytrS2eJKdX8wH6zOMjtNoqACJiIg0Yp5uLky+sjMA/1mzl6KScoMTNQ4qQCIiIo3c6Ogw2rbw5tjpUub9eNDoOI2CCpCIiEgj5+ZiJuHqLgC8+e0+8s+UGZyo4VMBEhERaQJG9A6ha5AfBcXlvPX9PqPjNHgqQCIiIk2A2Wzi8WvOzQLN+eEgRwtLDE7UsKkAiYiINBFX9wgiIjyAs2VW/rNmr9FxGjQVIBERkSbCZDLx5DVdAXj/pwwOnzprcKKGSwVIRESkCRnYqQX9O7Sg1GpjRtIeo+M0WCpAIiIiTYjJZOKJYedmgRanZLH/6GmDEzVMKkAiIiJNTFTbZlzVrRVWm51XVmkW6EJUgERERJqghJ+vCPt8SzY7swsMTtPwqACJiIg0QT1DLNzQuzUA/1qZbnCahkcFSEREpIlKuLoLLmYTq9Ly2JRx0ug4DYoKkIiISBPVoaUvt/QNBeCfKzQL9L9UgERERJqwh6/qjLuLmR/3HWft3mNGx2kwVIBERESasLBm3vw+tg0A/1iRjt1uNzhRw6ACJCIi0sRNGtoRLzcXUjNPsSotz+g4DYIKkIiISBPXys+T+IHtAJj+dTo2m2aBVIBEREScwH1DOuLn6cqunEI+35ptdBzDqQCJiIg4AYu3G/cN6QDAKyt3U2a1GZzIWCpAIiIiTiJ+YHta+Lhz8PgZPknJMjqOoRpEAZo1axbt2rXD09OT2NhYNmzYcNFtlyxZQnR0NAEBAfj4+BAZGcmCBQsqbGMymS74+Mc//lHXpyIiItJg+Xi4MmloJwD+nbSH4jKrwYmMY3gBWrRoEQkJCUybNo1NmzYRERHBsGHDyMu78Cr15s2b89RTT7Fu3Tq2bt1KfHw88fHxrFixwrHNkSNHKjzmzJmDyWTilltuqa/TEhERaZDuiG1Da4snR/KL+WB9htFxDGOyG3xDgNjYWGJiYpg5cyYANpuN8PBwJk+ezJQpUyp1jL59+zJ8+HCef/75C/5+1KhRFBYWkpSUVKnjFRQUYLFYyM/Px9/fv3InIiIi0kh8uCGDqUu20cLHne/+OBQfD1ejI9WKqrx/GzoDVFpaSkpKCnFxcY4xs9lMXFwc69at+8397XY7SUlJpKenM2TIkAtuk5uby5dffsnEiRMvepySkhIKCgoqPERERJqqW6PCaNfCm+NFpcxde8DoOIYwtAAdO3YMq9VKUFBQhfGgoCBycnIuul9+fj6+vr64u7szfPhwZsyYwdVXX33BbefPn4+fnx8333zzRY+XmJiIxWJxPMLDw6t3QiIiIo2Am4uZx67uAsCb3+0n/0yZwYnqn+FrgKrDz8+P1NRUNm7cyAsvvEBCQgJr1qy54LZz5szhjjvuwNPT86LHmzp1Kvn5+Y5HZmZmHSUXERFpGEb0DqFbsB+FxeW8+d0+o+PUO0M/9AsMDMTFxYXc3NwK47m5uQQHB190P7PZTKdO51axR0ZGkpaWRmJiIldccUWF7b7//nvS09NZtGjRJXN4eHjg4eFRvZMQERFphMxmE49f05V7301m7tqDxA9sT0s/53kvNHQGyN3dnaioqAqLk202G0lJSfTv37/Sx7HZbJSUlJw3/s477xAVFUVERESt5BUREWlK4rq3IiI8gLNlVmat3mt0nHpl+EdgCQkJzJ49m/nz55OWlsYDDzxAUVER8fHxAIwfP56pU6c6tk9MTGTlypXs37+ftLQ0pk+fzoIFC7jzzjsrHLegoIDFixdzzz331Ov5iIiINBYmk4k/DusKwAfrMzh86qzBieqP4de9jR07lqNHj/Lss8+Sk5NDZGQky5cvdyyMzsjIwGz+tacVFRUxadIksrKy8PLyolu3brz33nuMHTu2wnEXLlyI3W7n9ttvr9fzERERaUwGdgqkf4cWrNt/nNdW7eGlW3sbHaleGH4foIZI9wESERFnknLoJLe8/iMuZhMrHxtCh5a+RkeqlkZzHyARERExXlTbZsR1b4XVZueVVXuMjlMvVIBERESEhKvPrQX6fEs2O7Ob/g2BVYBERESEHiH+jIgIAWD61+kGp6l7KkAiIiICwGNxnXExm0jalUfKoZNGx6lTKkAiIiICQIeWvtzaNwyAf65o2rNAKkAiIiLi8HBcZ9xdzKzbf5y1e48ZHafOqACJiIiIQ2iAF7+PbQPAyyvSaap3y1EBEhERkQoeHNoJLzcXtmSeYuXO3N/eoRFSARIREZEKWvp5ED+wHQDTv96Nzdb0ZoFUgEREROQ89w3piJ+nK+m5hXy+NdvoOLVOBUhERETOY/F2474hHQB4ZeVuyqw2gxPVLhUgERERuaD4ge1p4ePOweNn+Dgly+g4tUoFSERERC7Ix8OVB4d2AuC1pD0Ul1kNTlR7VIBERETkon4f24bWFk+O5Bfz/voMo+PUGhUgERERuShPNxceuaozAP9ZvZeiknKDE9UOFSARERG5pFuiwmjXwpvjRaXMXXvA6Di1QgVIRERELsnNxcxjV3cB4M3v9nPqTKnBiWpOBUhERER+04jeIXQL9qOwuJw3v9tvdJwaUwESERGR32Q2m3j8mq4AzFt7kLzCYoMT1YwKkIiIiFRKXPdWRIYHcLbMyn9W7zM6To2oAImIiEilmEwmnhx2bhbog/UZZJ08Y3Ci6lMBEhERkUob2CmQAR1bUGq18VrSHqPjVJsKkIiIiFTJEz/PAn2y6TD7jp42OE31qACJiIhIlfRt04y47q2w2uy8snK30XGqRQVIREREquyXK8K+2HqEHdn5BqepOhUgERERqbLurf0ZERECwL++bnyzQCpAIiIiUi2PxXXGxWwiaVceKYdOGh2nSlSAREREpFo6tPRldFQYAP9YsQu73W5wospTARIREZFqm3xVZ9xdzPy0/wRr9x43Ok6lqQCJiIhItYUGeHHH5W2AxjULpAIkIiIiNTLpik54ubmwJSuflTtzjY5TKSpAIiIiUiMt/Ty4e1A7AKZ/vRurreHPAqkAiYiISI39YXBH/D1dSc8t5Iut2UbH+U0qQCIiIlJjFm837vtdRwD+tXI3ZVabwYkuTQVIREREasVdA9oR6OvOoeNnWJycZXScS1IBEhERkVrh4+HKpCs6AfBa0h6Ky6wGJ7o4FSARERGpNb+PbUOIxZOcgmLe++mQ0XEuyvACNGvWLNq1a4enpyexsbFs2LDhotsuWbKE6OhoAgIC8PHxITIykgULFpy3XVpaGiNHjsRiseDj40NMTAwZGRl1eRoiIiICeLq58EhcZwBeX7OP0yXlBie6MEML0KJFi0hISGDatGls2rSJiIgIhg0bRl5e3gW3b968OU899RTr1q1j69atxMfHEx8fz4oVKxzb7Nu3j0GDBtGtWzfWrFnD1q1beeaZZ/D09Kyv0xIREXFqt/QNo32gD8eLSpn7wwGj41yQyW7gLRtjY2OJiYlh5syZANhsNsLDw5k8eTJTpkyp1DH69u3L8OHDef755wG47bbbcHNzu+DMUGUVFBRgsVjIz8/H39+/2scRERFxVp9tyebhDzfj5+HK938aSoC3e50/Z1Xevw2bASotLSUlJYW4uLhfw5jNxMXFsW7dut/c3263k5SURHp6OkOGDAHOFagvv/ySLl26MGzYMFq1akVsbCzLli275LFKSkooKCio8BAREZHqu+Gy1nQL9qOwpJw3v9tvdJzzGFaAjh07htVqJSgoqMJ4UFAQOTk5F90vPz8fX19f3N3dGT58ODNmzODqq68GIC8vj9OnT/Piiy9y7bXX8vXXX3PTTTdx88038+233170mImJiVgsFscjPDy8dk5SRETESZnNJp64pisAc9ceIK+w2OBEFRm+CLqq/Pz8SE1NZePGjbzwwgskJCSwZs0a4NwMEMCNN97IY489RmRkJFOmTOGGG27gjTfeuOgxp06dSn5+vuORmZlZH6ciIiLSpF3VvRV92gRQXGbjP6v3GR2nAsMKUGBgIC4uLuTmVvzStNzcXIKDgy+6n9lsplOnTkRGRvL4449z6623kpiY6Dimq6srPXr0qLBP9+7dL3kVmIeHB/7+/hUeIiIiUjMmk4knf54Fen/9IbJOnjE40a8MK0Du7u5ERUWRlJTkGLPZbCQlJdG/f/9KH8dms1FSUuI4ZkxMDOnp6RW22b17N23btq2d4CIiIlJpAzoFMrBTC8qsdv69ao/RcRxcjXzyhIQEJkyYQHR0NP369ePVV1+lqKiI+Ph4AMaPH09oaKhjhicxMZHo6Gg6duxISUkJX331FQsWLOD11193HPPJJ59k7NixDBkyhKFDh7J8+XI+//xzx8dkIiIiUr+euKYra/f+yCebsrj/io50bOlrdCRjC9DYsWM5evQozz77LDk5OURGRrJ8+XLHwuiMjAzM5l8nqYqKipg0aRJZWVl4eXnRrVs33nvvPcaOHevY5qabbuKNN94gMTGRhx9+mK5du/LJJ58waNCgej8/ERERgT5tmhHXPYhVabn8a+VuZv2+r9GRjL0PUEOl+wCJiIjUrrQjBVz/2vfY7fDlw4PoGWKp9edoFPcBEhEREefRvbU/I3qHADD9690Gp1EBEhERkXry2NVdcDGb+GZXHimHThiaRQVIRERE6kX7QB9GR4UB8JbBd4c2dBG0iIiIOJeHr+pMaIAX8YPaG5pDBUhERETqTUiAF5Ov6mx0DH0EJiIiIs5HBUhEREScjgqQiIiIOB0VIBEREXE6KkAiIiLidFSARERExOmoAImIiIjTUQESERERp6MCJCIiIk5HBUhEREScjgqQiIiIOB0VIBEREXE6KkAiIiLidPRt8Bdgt9sBKCgoMDiJiIiIVNYv79u/vI9figrQBRQWFgIQHh5ucBIRERGpqsLCQiwWyyW3MdkrU5OcjM1mIzs7myuvvJLk5ORK7RMTE8PGjRt/c7uCggLCw8PJzMzE39+/plEbvcr+uRmlvvPV1fPV1nFrcpzq7FvVfSqzvV6D59PrsH6erzaOW9Nj1PXr0OjXoN1up7CwkJCQEMzmS6/y0QzQBZjNZsLCwnB1da30vxwXF5cq/Yv09/fXf3yp+p9bfavvfHX1fLV13Jocpzr7VnWfqmyv1+Cv9Dqsn+erjePW9Bh1/TpsCK/B35r5+YUWQV/Cgw8+WCfbyq8a+p9bfeerq+errePW5DjV2beq+zT0v08NVUP/c9PrsPaOUdevw4b+d+l/6SOwelZQUIDFYiE/P79B/x+XSFOl16CIsRrKa1AzQPXMw8ODadOm4eHhYXQUEaek16CIsRrKa1AzQCIiIuJ0NAMkIiIiTkcFSERERJyOCpCIiIg4HRUgERERcToqQCIiIuJ0VIAaqMzMTK644gp69OhB7969Wbx4sdGRRJzOTTfdRLNmzbj11luNjiLiNL744gu6du1K586defvtt+vseXQZfAN15MgRcnNziYyMJCcnh6ioKHbv3o2Pj4/R0UScxpo1aygsLGT+/Pl8/PHHRscRafLKy8vp0aMHq1evxmKxEBUVxY8//kiLFi1q/bk0A9RAtW7dmsjISACCg4MJDAzkxIkTxoYScTJXXHEFfn5+RscQcRobNmygZ8+ehIaG4uvry3XXXcfXX39dJ8+lAlRN3333HSNGjCAkJASTycSyZcvO22bWrFm0a9cOT09PYmNj2bBhQ7WeKyUlBavVSnh4eA1TizQd9fkaFJHKqenrMjs7m9DQUMfPoaGhHD58uE6yqgBVU1FREREREcyaNeuCv1+0aBEJCQlMmzaNTZs2ERERwbBhw8jLy3NsExkZSa9evc57ZGdnO7Y5ceIE48eP56233qrzcxJpTOrrNSgilVcbr8t6Y5caA+xLly6tMNavXz/7gw8+6PjZarXaQ0JC7ImJiZU+bnFxsX3w4MH2d999t7aiijRJdfUatNvt9tWrV9tvueWW2ogp4lSq87pcu3atfdSoUY7fP/LII/b333+/TvJpBqgOlJaWkpKSQlxcnGPMbDYTFxfHunXrKnUMu93OXXfdxZVXXsm4cePqKqpIk1Qbr0ERqV2VeV3269eP7du3c/jwYU6fPs1///tfhg0bVid5VIDqwLFjx7BarQQFBVUYDwoKIicnp1LHWLt2LYsWLWLZsmVERkYSGRnJtm3b6iKuSJNTG69BgLi4OEaPHs1XX31FWFiYypNIDVTmdenq6sr06dMZOnQokZGRPP7443VyBRiAa50cVWps0KBB2Gw2o2OIOLVVq1YZHUHE6YwcOZKRI0fW+fNoBqgOBAYG4uLiQm5uboXx3NxcgoODDUol4jz0GhRpeBra61IFqA64u7sTFRVFUlKSY8xms5GUlET//v0NTCbiHPQaFGl4GtrrUh+BVdPp06fZu3ev4+cDBw6QmppK8+bNadOmDQkJCUyYMIHo6Gj69evHq6++SlFREfHx8QamFmk69BoUaXga1euyTq4tcwKrV6+2A+c9JkyY4NhmxowZ9jZt2tjd3d3t/fr1s//000/GBRZpYvQaFGl4GtPrUt8FJiIiIk5Ha4BERETE6agAiYiIiNNRARIRERGnowIkIiIiTkcFSERERJyOCpCIiIg4HRUgERERcToqQCIiIuJ0VIBExOmsWbMGk8nEqVOnAJg3bx4BAQGGZhKR+qUCJCJOZ8CAARw5cgSLxWJ0FBExiL4MVUScjru7O8HBwUbHEBEDaQZIRBokm81GYmIi7du3x8vLi4iICD7++GPg14+wvvzyS3r37o2npyeXX34527dvd+x/6NAhRowYQbNmzfDx8aFnz5589dVXFfb/5SOwC3n99dfp2LEj7u7udO3alQULFlT4vclk4u233+amm27C29ubzp0789lnn9X+H4SI1AkVIBFpkBITE3n33Xd544032LFjB4899hh33nkn3377rWObJ598kunTp7Nx40ZatmzJiBEjKCsrA+DBBx+kpKSE7777jm3btvHSSy/h6+tbqedeunQpjzzyCI8//jjbt2/nvvvuIz4+ntWrV1fY7q9//Stjxoxh69atXH/99dxxxx2cOHGi9v4QRKTuGPId9CIil1BcXGz39va2//jjjxXGJ06caL/99tvtq1evtgP2hQsXOn53/Phxu5eXl33RokV2u91uv+yyy+x/+ctfLnj8X/Y/efKk3W632+fOnWu3WCyO3w8YMMB+7733Vthn9OjR9uuvv97xM2B/+umnHT+fPn3aDtj/+9//VuucRaR+aQZIRBqcvXv3cubMGa6++mp8fX0dj3fffZd9+/Y5tuvfv7/jn5s3b07Xrl1JS0sD4OGHH+Zvf/sbAwcOZNq0aWzdurXSz5+WlsbAgQMrjA0cONBx7F/07t3b8c8+Pj74+/uTl5dXpXMVEWOoAIlIg3P69GkAvvzyS1JTUx2PnTt3OtYB/ZZ77rmH/fv3M27cOLZt20Z0dDQzZsyo1Zxubm4VfjaZTNhstlp9DhGpGypAItLg9OjRAw8PDzIyMujUqVOFR3h4uGO7n376yfHPJ0+eZPfu3XTv3t0xFh4ezv3338+SJUt4/PHHmT17dqWev3v37qxdu7bC2Nq1a+nRo0cNz0xEGgpdBi8iDY6fnx9PPPEEjz32GDabjUGDBpGfn8/atWvx9/enbdu2ADz33HO0aNGCoKAgnnrqKQIDAxk1ahQAjz76KNdddx1dunTh5MmTrF69ukI5upQnn3ySMWPG0KdPH+Li4vj8889ZsmQJq1atqqtTFpF6pgIkIg3S888/T8uWLUlMTGT//v0EBATQt29f/vznPzs+ZnrxxRd55JFH2LNnD5GRkXz++ee4u7sDYLVaefDBB8nKysLf359rr72WV155pVLPPWrUKP7973/zz3/+k0ceeYT27dszd+5crrjiiro6XRGpZya73W43OoSISFWsWbOGoUOHcvLkSX2FhYhUi9YAiYiIiNNRARIRERGno4/ARERExOloBkhEREScjgqQiIiIOB0VIBEREXE6KkAiIiLidFSARERExOmoAImIiIjTUQESERERp6MCJCIiIk5HBUhERESczv8BjOrXSI7f8agAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(eps, acc_attack)\n",
    "plt.xscale('log')\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.xlabel('epsilon')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_one_image(model, img_data, y):\n",
    "    with torch.no_grad():\n",
    "        pred = model(T.ToTensor()(img_data).unsqueeze(0).to(device))\n",
    "    true_label = y.argmax()\n",
    "    pred_label = pred[0].argmax()\n",
    "    print(pred)\n",
    "    plt.imshow(img_data.astype(int))\n",
    "    print(\"True class: {}, predicted class: {}\".format(true_label, pred_label))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.1012, 0.1595, 0.1608, 0.1286, 0.0972, 0.1473, 0.0849, 0.1206]])\n",
      "True class: 2, predicted class: 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "attack_params = {'epsilon':0.02}\n",
    "\n",
    "image_index = 300\n",
    "\n",
    "img_data = test_data[image_index].reshape((28,28,4))\n",
    "\n",
    "ex_img = np.zeros((32, 32, 4),dtype=np.float32)\n",
    "ex_img[:28, :28, :] = img_data\n",
    "\n",
    "labels = torch.FloatTensor(test_data_label[image_index]).unsqueeze(0)\n",
    "predict_one_image(model, ex_img, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([5, 1, 5, 1, 5, 3, 5, 5, 5, 5, 5, 1, 3, 5, 5, 1, 1, 5, 5, 5, 1, 1, 5, 5,\n",
      "        5, 5, 5, 5, 1, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 1, 5, 5, 1, 1, 3, 5, 5, 5,\n",
      "        5, 1, 2, 3, 1, 1, 5, 3, 1, 1, 5, 5, 3, 5, 1, 5, 5, 1, 5, 5, 5, 5, 5, 1,\n",
      "        5, 5, 1, 1, 5, 5, 1, 5, 5, 3, 5, 1, 1, 5, 5, 5, 1, 1, 3, 3, 1, 5, 5, 7,\n",
      "        5, 5, 5, 1, 5, 5, 5, 5, 5, 5, 5, 3, 5, 1, 5, 3, 5, 5, 1, 3, 5, 3, 3, 5,\n",
      "        3, 5, 1, 7, 5, 5, 1, 5, 1, 5, 1, 3, 5, 1, 5, 5, 5, 5, 5, 3, 1, 5, 1, 1,\n",
      "        5, 1, 1, 1, 5, 5, 3, 5, 5, 5, 5, 1, 1, 3, 1, 5, 5, 3, 5, 5, 1, 5, 5, 1,\n",
      "        5, 1, 5, 5, 5, 3, 5, 5, 5, 3, 5, 3, 5, 5, 1, 5, 1, 5, 1, 5, 5, 5, 5, 1,\n",
      "        5, 1, 5, 5, 1, 5, 3, 5, 1, 1, 5, 1, 5, 1, 5, 1, 1, 5, 5, 1, 3, 3, 1, 1,\n",
      "        5, 5, 5, 5, 1, 5, 1, 1, 5, 1, 5, 5, 1, 5, 5, 1, 3, 1, 3, 5, 5, 1, 1, 1,\n",
      "        5, 5, 5, 3, 5, 5, 5, 5, 1, 5, 5, 5, 5, 3, 1, 5, 5, 5, 5, 5, 5, 1, 5, 5,\n",
      "        5, 5, 1, 1, 5, 1, 3, 5, 5, 5, 3, 5, 1, 5, 1, 3, 3, 5, 5, 1, 1, 5, 5, 5,\n",
      "        5, 1, 3, 1, 3, 5, 1, 5, 3, 5, 5, 5, 1, 1, 3, 5, 5, 3, 5, 1, 5, 1, 5, 5,\n",
      "        5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 3, 3, 5, 5, 5, 1, 5, 1, 5, 5, 5, 5, 5, 1,\n",
      "        3, 5, 5, 5, 3, 1, 5, 5, 5, 5, 1, 5, 5, 5, 5, 1, 5, 5, 5, 5, 3, 5, 5, 5,\n",
      "        5, 5, 5, 5, 5, 5, 1, 5, 5, 3, 5, 5, 5, 5, 5, 1, 5, 5, 1, 5, 3, 5, 2, 5,\n",
      "        5, 5, 3, 5, 1, 5, 5, 5, 1, 5, 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 1, 5, 5, 5,\n",
      "        5, 5, 5, 5, 5, 1, 1, 5, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 5,\n",
      "        3, 5, 5, 5, 5, 1, 5, 5, 5, 3, 5, 5, 5, 5, 5, 5, 1, 5, 5, 1, 3, 5, 1, 5,\n",
      "        5, 5, 5, 1, 1, 1, 1, 5, 5, 5, 3, 5, 5, 3, 5, 3, 5, 1, 5, 5, 1, 3, 5, 5,\n",
      "        1, 5, 5, 5, 5, 3, 5, 5, 1, 5, 3, 5, 1, 1, 1, 5, 3, 5, 5, 5])\n",
      "tensor([2, 2, 5, 1, 5, 2, 5, 1, 5, 5, 5, 2, 2, 5, 2, 3, 1, 5, 0, 0, 3, 3, 1, 5,\n",
      "        1, 0, 5, 1, 3, 1, 5, 5, 5, 5, 0, 1, 5, 1, 3, 2, 2, 5, 2, 3, 2, 5, 4, 2,\n",
      "        5, 1, 2, 1, 2, 3, 2, 2, 2, 3, 5, 5, 1, 5, 3, 5, 4, 2, 1, 1, 5, 5, 2, 3,\n",
      "        5, 5, 1, 1, 5, 5, 3, 5, 5, 2, 5, 1, 1, 3, 2, 5, 3, 2, 2, 1, 1, 2, 2, 2,\n",
      "        1, 1, 4, 3, 5, 5, 0, 5, 1, 3, 0, 1, 5, 3, 5, 1, 1, 5, 3, 1, 5, 1, 1, 2,\n",
      "        3, 5, 3, 1, 5, 5, 2, 1, 2, 5, 2, 3, 5, 2, 3, 1, 2, 5, 5, 2, 3, 1, 1, 2,\n",
      "        5, 2, 2, 2, 2, 1, 1, 5, 4, 1, 1, 1, 2, 1, 2, 5, 5, 1, 5, 5, 3, 5, 1, 2,\n",
      "        5, 3, 5, 0, 2, 2, 1, 5, 5, 1, 5, 1, 5, 1, 1, 5, 2, 1, 3, 0, 5, 5, 5, 2,\n",
      "        5, 3, 2, 2, 3, 1, 1, 5, 3, 3, 1, 2, 1, 1, 5, 3, 1, 5, 5, 1, 1, 1, 1, 3,\n",
      "        3, 5, 5, 1, 3, 2, 2, 1, 2, 3, 1, 1, 3, 2, 5, 2, 1, 3, 2, 5, 1, 3, 3, 3,\n",
      "        5, 0, 5, 1, 5, 1, 5, 2, 1, 1, 5, 5, 5, 2, 2, 1, 5, 5, 5, 5, 5, 3, 5, 5,\n",
      "        5, 5, 3, 3, 2, 2, 2, 5, 5, 2, 1, 5, 2, 5, 1, 1, 2, 5, 5, 1, 2, 3, 4, 5,\n",
      "        3, 3, 3, 3, 1, 5, 1, 5, 1, 0, 5, 5, 2, 1, 1, 5, 5, 2, 5, 1, 3, 2, 5, 5,\n",
      "        1, 5, 3, 4, 5, 1, 1, 5, 2, 3, 3, 1, 2, 4, 5, 2, 5, 2, 4, 4, 5, 1, 5, 3,\n",
      "        1, 5, 5, 3, 1, 1, 0, 1, 4, 5, 3, 5, 5, 2, 5, 2, 5, 5, 5, 5, 2, 2, 2, 3,\n",
      "        3, 1, 1, 2, 2, 0, 2, 5, 5, 1, 5, 5, 5, 2, 5, 2, 5, 1, 2, 5, 3, 1, 2, 5,\n",
      "        5, 5, 1, 0, 1, 5, 5, 5, 2, 5, 3, 3, 5, 1, 5, 5, 0, 1, 4, 0, 3, 5, 5, 5,\n",
      "        1, 5, 5, 5, 5, 3, 2, 1, 1, 1, 5, 3, 5, 5, 5, 5, 1, 1, 5, 5, 5, 0, 3, 5,\n",
      "        3, 5, 5, 5, 5, 2, 5, 5, 5, 3, 1, 5, 5, 5, 5, 2, 2, 2, 5, 3, 2, 5, 3, 0,\n",
      "        1, 5, 5, 1, 2, 3, 1, 2, 5, 2, 1, 2, 5, 1, 4, 3, 5, 2, 0, 5, 2, 3, 5, 1,\n",
      "        3, 5, 1, 2, 5, 1, 0, 4, 1, 5, 1, 2, 3, 2, 2, 1, 3, 1, 5, 2])\n",
      "certos: 220!!!\n",
      "precisão: 44.0%!!!\n"
     ]
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    correct = 0\n",
    "    i=0\n",
    "    for batch in loader_test:\n",
    "        pred = model(batch['x'].to(device))\n",
    "        predicted = torch.max(pred, 1)[1]\n",
    "        real_class = torch.max(batch['y'].to(device), 1)[1]\n",
    "        correct += (predicted == real_class).sum()\n",
    "        if (i % 100 == 0):\n",
    "            print(predicted)\n",
    "            print(real_class)\n",
    "        i += 1\n",
    "\n",
    "print(f\"certos: {correct.item()}!!!\")\n",
    "print(f\"precisão: {correct.item()/len(dataset_test)*100}%!!!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#salvar e carregar o modelo de NN\n",
    "torch.save(model.state_dict(), \"cnn-sat6-w8.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.0973, 0.1578, 0.1700, 0.1310, 0.0973, 0.1411, 0.0838, 0.1216]])\n",
      "True class: 2, predicted class: 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "new_model = QuantizedCNN()\n",
    "new_model.load_state_dict(torch.load(\"cnn-sat6-w8.pt\"))\n",
    "predict_one_image(new_model, ex_img, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 4
}