Assignment01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment 01: Multi-class Classification \n",
    "In this Assignment, you will train a deep model on the CIFAR10 from the scratch using PyTorch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import os.path as osp\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "import torchvision\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random seed\n",
    "SEED = 1 \n",
    "NUM_CLASS = 10\n",
    "\n",
    "# Training\n",
    "BATCH_SIZE = 128\n",
    "NUM_EPOCHS = 30\n",
    "EVAL_INTERVAL=1\n",
    "SAVE_DIR = './log'\n",
    "\n",
    "# Optimizer\n",
    "LEARNING_RATE = 1e-1\n",
    "MOMENTUM = 0.9\n",
    "STEP=5\n",
    "GAMMA=0.5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# cifar10 transform\n",
    "transform_cifar10_train = transforms.Compose([\n",
    "    transforms.RandomCrop(32, padding=4),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
    "])\n",
    "\n",
    "transform_cifar10_test = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
    "])\n",
    "\n",
    "train_set = torchvision.datasets.CIFAR10(root='../data', train=True,\n",
    "                                        download=True, transform=transform_cifar10_train)\n",
    "train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=BATCH_SIZE,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "test_set = torchvision.datasets.CIFAR10(root='../data', train=False,\n",
    "                                       download=True, transform=transform_cifar10_test)\n",
    "test_dataloader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvNet, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 4, 3)  \n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(4, 8, 3)  \n",
    "        self.fc1 = nn.Linear(8 * 6 * 6, 32)\n",
    "        self.fc2 = nn.Linear(32, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(torch.relu(self.conv1(x)))\n",
    "        x = self.pool(torch.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 8 * 6 * 6)\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvNet(\n",
       "  (conv1): Conv2d(3, 4, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (conv2): Conv2d(4, 8, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (fc1): Linear(in_features=288, out_features=32, bias=True)\n",
       "  (fc2): Linear(in_features=32, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = ConvNet()\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)\n",
    "\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=STEP, gamma=GAMMA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1: per batch training/testing\n",
    "---\n",
    "\n",
    "Please denfine two function named ``train_batch`` and ``test_batch``. These functions are essential for training and evaluating machine learning models using batched data from dataloaders.\n",
    "\n",
    "**To do**: \n",
    "1. Define the loss function i.e [nn.CrossEntropyLoss()](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html).\n",
    "2. Take the image as the input and generate the output using the pre-defined SimpleNet.\n",
    "3. Calculate the loss between the output and the corresponding label using the loss function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 \n",
    "**We first try L1Loss () as a loss function：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################### Write your answer here ##################\n",
    "# Define the loss function\n",
    "criterion = nn.L1Loss()\n",
    "###############################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_batch(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one training batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to train.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated by the defined loss function loss_fn().\n",
    "    \"\"\"\n",
    "    \n",
    "    ##################### Write your answer here ##################\n",
    "    output = model(image)\n",
    "    num_classes = 10\n",
    "    targets = torch.nn.functional.one_hot(target, num_classes)\n",
    "    targets = targets.float()\n",
    "    loss = criterion(output,targets)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_batch(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one testing batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to evaluate.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated for the batch.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################### Write your answer here ##################\n",
    "    output = model(image)\n",
    "    num_classes = 10\n",
    "    targets = torch.nn.functional.one_hot(target, num_classes)\n",
    "    targets = targets.float()\n",
    "    loss = criterion(output,targets)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While running the code, I find that the corresponding input is a tensor of Size(torch.Size([128, 10])), but the corresponding target is a tensor of Size(torch.Size([128])). And the following error message appears:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red;\">*/usr/local/lib/python3.10/dist-packages/torch/nn/modules/loss.py:101: UserWarning: Using a target size (torch.Size([128])) that is different to the input size (torch.Size([128, 10])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
    "  return F.l1_loss(input, target, reduction=self.reduction)*</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It reminds us that the size of the input tensor and the size of the target tensor need to be modified to be the same. At first I tried to use the following methods (these changes are very crude and illogical)："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1**：\n",
    "\n",
    "target = target.view(batch_size, 10)\n",
    "This method forced the expansion of the target tensor, but was rejected because it did not have a sufficient number of elements and was very illogical.\n",
    "\n",
    "**2**：\n",
    "\n",
    "target = target.repeat(10, 1)\n",
    "target = target.transport(0,1)\n",
    "This method forcibly expands the target tensor, but the generated tensor just blindly copies the elements of the original target tensor 10 times, which is completely meaningless\n",
    "\n",
    "So after I called print () and looked at the contents of the input tensor and the target tensor, I came up with one hot encoding mentioned in class.\n",
    "But since the input tensor is in floating-point form, and the result of one hot encoding is in integer form, I converted it so that they can match, and finally entered the model training, you can see the following result:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/30 Train Loss: 0.0009 Acc: 0.1008\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.1000\n",
      "Epoch: 2/30 Train Loss: 0.0009 Acc: 0.1003\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.1000\n",
      "Epoch: 3/30 Train Loss: 0.0009 Acc: 0.0999\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 4/30 Train Loss: 0.0009 Acc: 0.1004\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.1000\n",
      "Epoch: 5/30 Train Loss: 0.0009 Acc: 0.1002\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.1000\n",
      "Epoch: 6/30 Train Loss: 0.0008 Acc: 0.0986\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.1000\n",
      "Epoch: 7/30 Train Loss: 0.0008 Acc: 0.1002\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 8/30 Train Loss: 0.0008 Acc: 0.0988\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 9/30 Train Loss: 0.0008 Acc: 0.0999\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 10/30 Train Loss: 0.0008 Acc: 0.1023\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 11/30 Train Loss: 0.0008 Acc: 0.0995\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 12/30 Train Loss: 0.0008 Acc: 0.1004\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 13/30 Train Loss: 0.0008 Acc: 0.1023\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1001\n",
      "Epoch: 14/30 Train Loss: 0.0008 Acc: 0.0984\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 15/30 Train Loss: 0.0008 Acc: 0.1006\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 16/30 Train Loss: 0.0008 Acc: 0.0990\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 17/30 Train Loss: 0.0008 Acc: 0.1000\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 18/30 Train Loss: 0.0008 Acc: 0.1004\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 19/30 Train Loss: 0.0008 Acc: 0.0998\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 20/30 Train Loss: 0.0008 Acc: 0.1010\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1001\n",
      "Epoch: 21/30 Train Loss: 0.0008 Acc: 0.0989\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1002\n",
      "Epoch: 22/30 Train Loss: 0.0008 Acc: 0.0982\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 23/30 Train Loss: 0.0008 Acc: 0.0989\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 24/30 Train Loss: 0.0008 Acc: 0.1017\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 25/30 Train Loss: 0.0008 Acc: 0.0977\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 26/30 Train Loss: 0.0008 Acc: 0.0989\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1001\n",
      "Epoch: 27/30 Train Loss: 0.0008 Acc: 0.0985\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1002\n",
      "Epoch: 28/30 Train Loss: 0.0008 Acc: 0.0980\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 29/30 Train Loss: 0.0008 Acc: 0.1006\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1000\n",
      "Epoch: 30/30 Train Loss: 0.0008 Acc: 0.0999\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.1001\n"
     ]
    }
   ],
   "source": [
    "training_loss = []\n",
    "training_acc = []\n",
    "testing_loss = []\n",
    "testing_acc = []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    model.train()\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "    ##########################\n",
    "    ### Training\n",
    "    ##########################\n",
    "\n",
    "    running_cls_loss = 0.0\n",
    "    running_cls_corrects = 0\n",
    "\n",
    "    for batch_idx, (image, target) in enumerate(train_dataloader):\n",
    "\n",
    "        image = image.to(device)\n",
    "        target = target.to(device)\n",
    "              \n",
    "        # train model\n",
    "        outputs, loss = train_batch(model, image, target)\n",
    "        _, preds = torch.max(outputs, 1)\n",
    "\n",
    "        \n",
    "        loss_data = loss.data.item()\n",
    "        if np.isnan(loss_data):\n",
    "            raise ValueError('loss is nan while training')\n",
    "        running_cls_loss += loss.item()\n",
    "        running_cls_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "    epoch_loss = running_cls_loss / len(train_set)\n",
    "    epoch_acc = running_cls_corrects.double() / len(train_set)\n",
    "\n",
    "    print(f'Epoch: {epoch+1}/{NUM_EPOCHS} Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')\n",
    "\n",
    "    training_loss.append(epoch_loss)\n",
    "    training_acc.append(epoch_acc.cpu().detach().numpy())\n",
    "\n",
    "    # change learning rate\n",
    "    scheduler.step()\n",
    "\n",
    "\n",
    "    ##########################\n",
    "    ### Testing\n",
    "    ##########################\n",
    "    # # eval model during training or in the last epoch\n",
    "    if (epoch + 1) % EVAL_INTERVAL == 0 or (epoch +1) == NUM_EPOCHS:\n",
    "        print('Begin test......')\n",
    "        model.eval()\n",
    "    \n",
    "        val_loss = 0.0\n",
    "        val_corrects = 0\n",
    "\n",
    "        for batch_idx, (image, target) in enumerate(test_dataloader):\n",
    "\n",
    "            image = image.to(device)\n",
    "            target = target.to(device)\n",
    "\n",
    "            # test model\n",
    "            outputs, loss = test_batch(model, image, target)\n",
    "            _, preds = torch.max(outputs, 1)\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "            val_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        val_loss = val_loss / len(test_set)\n",
    "        val_acc = val_corrects.double() / len(test_set)\n",
    "        print(f'Test Loss: {val_loss:.4f} Acc: {val_acc:.4f}')\n",
    "        testing_loss.append(val_loss)\n",
    "        testing_acc.append(val_acc.cpu().detach().numpy())\n",
    "\n",
    "        # save the model in last epoch\n",
    "        if (epoch +1) == NUM_EPOCHS:\n",
    "            \n",
    "            state = {\n",
    "            'state_dict': model.state_dict(),\n",
    "            'acc': epoch_acc,\n",
    "            'epoch': (epoch+1),\n",
    "            }\n",
    "\n",
    "            # check the dir\n",
    "            if not os.path.exists(SAVE_DIR):\n",
    "                os.makedirs(SAVE_DIR)\n",
    "\n",
    "            # save the state\n",
    "            torch.save(state, osp.join(SAVE_DIR, 'checkpoint_%s.pth' % (str(epoch+1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, when we use L1Loss () as a loss function, the loss value on both the training set and the test set is relatively small, but the accuracy of the test is generally around 10%, which is not very ideal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the information by constructing a line chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(training_loss, training_acc)\n",
    "plt.title('Training set representation')\n",
    "plt.xlabel('training_loss')\n",
    "plt.ylabel('training_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(testing_loss, testing_acc)\n",
    "plt.title('Testing set representation')\n",
    "plt.xlabel('testing_loss')\n",
    "plt.ylabel('testing_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can note that the image is very cluttered and the L1loss is not very effective, which will be discussed later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2\n",
    "**Next we use CrossEntropyLoss() as the loss function:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion2 = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_batch2(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one training batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to train.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated by the defined loss function loss_fn().\n",
    "    \"\"\"\n",
    "    \n",
    "    ##################### Write your answer here ##################\n",
    "    output = model(image)\n",
    "    loss = criterion2(output,target)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_batch2(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one testing batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to evaluate.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated for the batch.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################### Write your answer here ##################\n",
    "    output = model(image)\n",
    "    loss = criterion2(output,target)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/30 Train Loss: 0.0155 Acc: 0.2574\n",
      "Begin test......\n",
      "Test Loss: 0.0150 Acc: 0.2960\n",
      "Epoch: 2/30 Train Loss: 0.0144 Acc: 0.3165\n",
      "Begin test......\n",
      "Test Loss: 0.0137 Acc: 0.3536\n",
      "Epoch: 3/30 Train Loss: 0.0139 Acc: 0.3399\n",
      "Begin test......\n",
      "Test Loss: 0.0133 Acc: 0.3691\n",
      "Epoch: 4/30 Train Loss: 0.0137 Acc: 0.3500\n",
      "Begin test......\n",
      "Test Loss: 0.0134 Acc: 0.3640\n",
      "Epoch: 5/30 Train Loss: 0.0137 Acc: 0.3509\n",
      "Begin test......\n",
      "Test Loss: 0.0129 Acc: 0.3848\n",
      "Epoch: 6/30 Train Loss: 0.0128 Acc: 0.3938\n",
      "Begin test......\n",
      "Test Loss: 0.0121 Acc: 0.4357\n",
      "Epoch: 7/30 Train Loss: 0.0126 Acc: 0.4064\n",
      "Begin test......\n",
      "Test Loss: 0.0121 Acc: 0.4447\n",
      "Epoch: 8/30 Train Loss: 0.0125 Acc: 0.4126\n",
      "Begin test......\n",
      "Test Loss: 0.0119 Acc: 0.4403\n",
      "Epoch: 9/30 Train Loss: 0.0124 Acc: 0.4168\n",
      "Begin test......\n",
      "Test Loss: 0.0118 Acc: 0.4513\n",
      "Epoch: 10/30 Train Loss: 0.0123 Acc: 0.4198\n",
      "Begin test......\n",
      "Test Loss: 0.0119 Acc: 0.4475\n",
      "Epoch: 11/30 Train Loss: 0.0117 Acc: 0.4482\n",
      "Begin test......\n",
      "Test Loss: 0.0110 Acc: 0.4871\n",
      "Epoch: 12/30 Train Loss: 0.0116 Acc: 0.4576\n",
      "Begin test......\n",
      "Test Loss: 0.0110 Acc: 0.4924\n",
      "Epoch: 13/30 Train Loss: 0.0115 Acc: 0.4643\n",
      "Begin test......\n",
      "Test Loss: 0.0113 Acc: 0.4771\n",
      "Epoch: 14/30 Train Loss: 0.0116 Acc: 0.4584\n",
      "Begin test......\n",
      "Test Loss: 0.0110 Acc: 0.4967\n",
      "Epoch: 15/30 Train Loss: 0.0115 Acc: 0.4646\n",
      "Begin test......\n",
      "Test Loss: 0.0109 Acc: 0.4926\n",
      "Epoch: 16/30 Train Loss: 0.0111 Acc: 0.4795\n",
      "Begin test......\n",
      "Test Loss: 0.0105 Acc: 0.5174\n",
      "Epoch: 17/30 Train Loss: 0.0111 Acc: 0.4833\n",
      "Begin test......\n",
      "Test Loss: 0.0104 Acc: 0.5185\n",
      "Epoch: 18/30 Train Loss: 0.0109 Acc: 0.4899\n",
      "Begin test......\n",
      "Test Loss: 0.0104 Acc: 0.5263\n",
      "Epoch: 19/30 Train Loss: 0.0109 Acc: 0.4922\n",
      "Begin test......\n",
      "Test Loss: 0.0103 Acc: 0.5187\n",
      "Epoch: 20/30 Train Loss: 0.0109 Acc: 0.4927\n",
      "Begin test......\n",
      "Test Loss: 0.0103 Acc: 0.5233\n",
      "Epoch: 21/30 Train Loss: 0.0107 Acc: 0.5014\n",
      "Begin test......\n",
      "Test Loss: 0.0102 Acc: 0.5364\n",
      "Epoch: 22/30 Train Loss: 0.0107 Acc: 0.5032\n",
      "Begin test......\n",
      "Test Loss: 0.0101 Acc: 0.5379\n",
      "Epoch: 23/30 Train Loss: 0.0106 Acc: 0.5071\n",
      "Begin test......\n",
      "Test Loss: 0.0101 Acc: 0.5365\n",
      "Epoch: 24/30 Train Loss: 0.0106 Acc: 0.5100\n",
      "Begin test......\n",
      "Test Loss: 0.0100 Acc: 0.5420\n",
      "Epoch: 25/30 Train Loss: 0.0106 Acc: 0.5083\n",
      "Begin test......\n",
      "Test Loss: 0.0100 Acc: 0.5413\n",
      "Epoch: 26/30 Train Loss: 0.0104 Acc: 0.5129\n",
      "Begin test......\n",
      "Test Loss: 0.0099 Acc: 0.5463\n",
      "Epoch: 27/30 Train Loss: 0.0104 Acc: 0.5192\n",
      "Begin test......\n",
      "Test Loss: 0.0099 Acc: 0.5469\n",
      "Epoch: 28/30 Train Loss: 0.0104 Acc: 0.5168\n",
      "Begin test......\n",
      "Test Loss: 0.0099 Acc: 0.5494\n",
      "Epoch: 29/30 Train Loss: 0.0104 Acc: 0.5206\n",
      "Begin test......\n",
      "Test Loss: 0.0099 Acc: 0.5494\n",
      "Epoch: 30/30 Train Loss: 0.0104 Acc: 0.5187\n",
      "Begin test......\n",
      "Test Loss: 0.0098 Acc: 0.5505\n"
     ]
    }
   ],
   "source": [
    "model = ConvNet()\n",
    "model.to(device)\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)\n",
    "\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=STEP, gamma=GAMMA)\n",
    "\n",
    "training_loss = []\n",
    "training_acc = []\n",
    "testing_loss = []\n",
    "testing_acc = []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    model.train()\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "    ##########################\n",
    "    ### Training\n",
    "    ##########################\n",
    "\n",
    "    running_cls_loss = 0.0\n",
    "    running_cls_corrects = 0\n",
    "\n",
    "    for batch_idx, (image, target) in enumerate(train_dataloader):\n",
    "\n",
    "        image = image.to(device)\n",
    "        target = target.to(device)\n",
    "\n",
    "        # train model\n",
    "        outputs, loss = train_batch2(model, image, target)\n",
    "        _, preds = torch.max(outputs, 1)\n",
    "\n",
    "        \n",
    "        loss_data = loss.data.item()\n",
    "        if np.isnan(loss_data):\n",
    "            raise ValueError('loss is nan while training')\n",
    "        running_cls_loss += loss.item()\n",
    "        running_cls_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "    epoch_loss = running_cls_loss / len(train_set)\n",
    "    epoch_acc = running_cls_corrects.double() / len(train_set)\n",
    "\n",
    "    print(f'Epoch: {epoch+1}/{NUM_EPOCHS} Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')\n",
    "\n",
    "    training_loss.append(epoch_loss)\n",
    "    training_acc.append(epoch_acc.cpu().detach().numpy())\n",
    "\n",
    "    # change learning rate\n",
    "    scheduler.step()\n",
    "\n",
    "\n",
    "    ##########################\n",
    "    ### Testing\n",
    "    ##########################\n",
    "    # # eval model during training or in the last epoch\n",
    "    if (epoch + 1) % EVAL_INTERVAL == 0 or (epoch +1) == NUM_EPOCHS:\n",
    "        print('Begin test......')\n",
    "        model.eval()\n",
    "    \n",
    "        val_loss = 0.0\n",
    "        val_corrects = 0\n",
    "\n",
    "        for batch_idx, (image, target) in enumerate(test_dataloader):\n",
    "\n",
    "            image = image.to(device)\n",
    "            target = target.to(device)\n",
    "\n",
    "            # test model\n",
    "            outputs, loss = test_batch2(model, image, target)\n",
    "            _, preds = torch.max(outputs, 1)\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "            val_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        val_loss = val_loss / len(test_set)\n",
    "        val_acc = val_corrects.double() / len(test_set)\n",
    "        print(f'Test Loss: {val_loss:.4f} Acc: {val_acc:.4f}')\n",
    "        testing_loss.append(val_loss)\n",
    "        testing_acc.append(val_acc.cpu().detach().numpy())\n",
    "\n",
    "        # save the model in last epoch\n",
    "        if (epoch +1) == NUM_EPOCHS:\n",
    "            \n",
    "            state = {\n",
    "            'state_dict': model.state_dict(),\n",
    "            'acc': epoch_acc,\n",
    "            'epoch': (epoch+1),\n",
    "            }\n",
    "\n",
    "            # check the dir\n",
    "            if not os.path.exists(SAVE_DIR):\n",
    "                os.makedirs(SAVE_DIR)\n",
    "\n",
    "            # save the state\n",
    "            torch.save(state, osp.join(SAVE_DIR, 'checkpoint_%s.pth' % (str(epoch+1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we do not want to continue training the model on the original model, but instead replace the loss functions to see the difference in their training results, we need to re-initialize the model and create a new optimizer here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Cross-Entropy Loss function is commonly used in classification tasks, where the output of the model is a probability distribution for different classes, and the goal is the actual class label. Although the output of the model is a probability distribution, the cross-entropy loss does not require the input and the target to be the same size. This is because the cross entropy loss function is calculated in a way that allows for the adaptation of different numbers of classes. And in the library also has the corresponding automatic adjustment mode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Through the observation of the above results, we can find that when the cross entropy is used as the loss function, its accuracy is greatly improved, generally about 30% to 60%. Its loss is generally around 0.01."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the information by constructing a line chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(training_loss, training_acc)\n",
    "plt.title('Training set representation')\n",
    "plt.xlabel('training_loss')\n",
    "plt.ylabel('training_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(testing_loss, testing_acc)\n",
    "plt.title('Testing set representation')\n",
    "plt.xlabel('testing_loss')\n",
    "plt.ylabel('testing_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3\n",
    "**Now let's try using focal loss as a loss function and set gamma to 0.5:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we rewrite the method using the formula definition of focal loss under multi-classification problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_batch3(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one training batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to train.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated by the defined loss function loss_fn().\n",
    "    \"\"\"\n",
    "    \n",
    "    ##################### Write your answer here ##################\n",
    "    import torch\n",
    "    import torch.nn as nn\n",
    "\n",
    "    class FocalLoss(nn.Module):\n",
    "        def __init__(self, num_classes, gamma=0.5):\n",
    "            super(FocalLoss, self).__init__()\n",
    "            self.gamma = gamma\n",
    "            self.num_classes = num_classes\n",
    "\n",
    "        def forward(self, inputdata, target):\n",
    "            probs = torch.softmax(inputdata, dim=1)\n",
    "            targets = torch.nn.functional.one_hot(target, num_classes)\n",
    "            targets = targets.float()\n",
    "            focal_loss = -((1 - probs) ** self.gamma) * targets * torch.log(probs)\n",
    "            return focal_loss.mean()\n",
    "    \n",
    "    num_classes = 10    \n",
    "    output = model(image)\n",
    "    focal_loss = FocalLoss(num_classes, gamma=0.5)\n",
    "    loss = focal_loss(output, target)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_batch3(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one testing batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to evaluate.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated for the batch.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################### Write your answer here ##################\n",
    "    import torch\n",
    "    import torch.nn as nn\n",
    "\n",
    "    class FocalLoss(nn.Module):\n",
    "        def __init__(self, num_classes, gamma=0.5):\n",
    "            super(FocalLoss, self).__init__()\n",
    "            self.gamma = gamma\n",
    "            self.num_classes = num_classes\n",
    "\n",
    "        def forward(self, inputdata, target):\n",
    "            probs = torch.softmax(inputdata, dim=1)\n",
    "            targets = torch.nn.functional.one_hot(target, num_classes)\n",
    "            targets = targets.float()\n",
    "            focal_loss = -((1 - probs) ** self.gamma) * targets * torch.log(probs)\n",
    "            return focal_loss.mean()\n",
    "    \n",
    "    num_classes = 10    \n",
    "    output = model(image)\n",
    "    focal_loss = FocalLoss(num_classes, gamma=0.5)\n",
    "    loss = focal_loss(output, target)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/30 Train Loss: 0.0014 Acc: 0.2976\n",
      "Begin test......\n",
      "Test Loss: 0.0012 Acc: 0.4022\n",
      "Epoch: 2/30 Train Loss: 0.0012 Acc: 0.4032\n",
      "Begin test......\n",
      "Test Loss: 0.0010 Acc: 0.4674\n",
      "Epoch: 3/30 Train Loss: 0.0011 Acc: 0.4292\n",
      "Begin test......\n",
      "Test Loss: 0.0010 Acc: 0.4805\n",
      "Epoch: 4/30 Train Loss: 0.0010 Acc: 0.4544\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5157\n",
      "Epoch: 5/30 Train Loss: 0.0010 Acc: 0.4671\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5235\n",
      "Epoch: 6/30 Train Loss: 0.0010 Acc: 0.4929\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5486\n",
      "Epoch: 7/30 Train Loss: 0.0010 Acc: 0.4956\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5466\n",
      "Epoch: 8/30 Train Loss: 0.0010 Acc: 0.4996\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5467\n",
      "Epoch: 9/30 Train Loss: 0.0010 Acc: 0.5043\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5588\n",
      "Epoch: 10/30 Train Loss: 0.0009 Acc: 0.5171\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.5642\n",
      "Epoch: 11/30 Train Loss: 0.0009 Acc: 0.5261\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5655\n",
      "Epoch: 12/30 Train Loss: 0.0009 Acc: 0.5314\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5760\n",
      "Epoch: 13/30 Train Loss: 0.0009 Acc: 0.5316\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5770\n",
      "Epoch: 14/30 Train Loss: 0.0009 Acc: 0.5323\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5769\n",
      "Epoch: 15/30 Train Loss: 0.0009 Acc: 0.5349\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5748\n",
      "Epoch: 16/30 Train Loss: 0.0009 Acc: 0.5380\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5824\n",
      "Epoch: 17/30 Train Loss: 0.0009 Acc: 0.5397\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5846\n",
      "Epoch: 18/30 Train Loss: 0.0009 Acc: 0.5391\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5861\n",
      "Epoch: 19/30 Train Loss: 0.0009 Acc: 0.5402\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5871\n",
      "Epoch: 20/30 Train Loss: 0.0009 Acc: 0.5422\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5856\n",
      "Epoch: 21/30 Train Loss: 0.0009 Acc: 0.5462\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5859\n",
      "Epoch: 22/30 Train Loss: 0.0009 Acc: 0.5469\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5885\n",
      "Epoch: 23/30 Train Loss: 0.0009 Acc: 0.5518\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5914\n",
      "Epoch: 24/30 Train Loss: 0.0009 Acc: 0.5499\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5915\n",
      "Epoch: 25/30 Train Loss: 0.0009 Acc: 0.5500\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5919\n",
      "Epoch: 26/30 Train Loss: 0.0009 Acc: 0.5513\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5934\n",
      "Epoch: 27/30 Train Loss: 0.0009 Acc: 0.5488\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5943\n",
      "Epoch: 28/30 Train Loss: 0.0009 Acc: 0.5530\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5949\n",
      "Epoch: 29/30 Train Loss: 0.0009 Acc: 0.5518\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5913\n",
      "Epoch: 30/30 Train Loss: 0.0009 Acc: 0.5499\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.5936\n"
     ]
    }
   ],
   "source": [
    "model = ConvNet()\n",
    "model.to(device)\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)\n",
    "\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=STEP, gamma=GAMMA)\n",
    "\n",
    "training_loss = []\n",
    "training_acc = []\n",
    "testing_loss = []\n",
    "testing_acc = []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    model.train()\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "    ##########################\n",
    "    ### Training\n",
    "    ##########################\n",
    "\n",
    "    running_cls_loss = 0.0\n",
    "    running_cls_corrects = 0\n",
    "\n",
    "    for batch_idx, (image, target) in enumerate(train_dataloader):\n",
    "\n",
    "        image = image.to(device)\n",
    "        target = target.to(device)\n",
    "\n",
    "        # train model\n",
    "        outputs, loss = train_batch3(model, image, target)\n",
    "        _, preds = torch.max(outputs, 1)\n",
    "\n",
    "        \n",
    "        loss_data = loss.data.item()\n",
    "        if np.isnan(loss_data):\n",
    "            raise ValueError('loss is nan while training')\n",
    "        running_cls_loss += loss.item()\n",
    "        running_cls_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "    epoch_loss = running_cls_loss / len(train_set)\n",
    "    epoch_acc = running_cls_corrects.double() / len(train_set)\n",
    "\n",
    "    print(f'Epoch: {epoch+1}/{NUM_EPOCHS} Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')\n",
    "\n",
    "    training_loss.append(epoch_loss)\n",
    "    training_acc.append(epoch_acc.cpu().detach().numpy())\n",
    "\n",
    "    # change learning rate\n",
    "    scheduler.step()\n",
    "\n",
    "\n",
    "    ##########################\n",
    "    ### Testing\n",
    "    ##########################\n",
    "    # # eval model during training or in the last epoch\n",
    "    if (epoch + 1) % EVAL_INTERVAL == 0 or (epoch +1) == NUM_EPOCHS:\n",
    "        print('Begin test......')\n",
    "        model.eval()\n",
    "    \n",
    "        val_loss = 0.0\n",
    "        val_corrects = 0\n",
    "\n",
    "        for batch_idx, (image, target) in enumerate(test_dataloader):\n",
    "\n",
    "            image = image.to(device)\n",
    "            target = target.to(device)\n",
    "\n",
    "            # test model\n",
    "            outputs, loss = test_batch3(model, image, target)\n",
    "            _, preds = torch.max(outputs, 1)\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "            val_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        val_loss = val_loss / len(test_set)\n",
    "        val_acc = val_corrects.double() / len(test_set)\n",
    "        print(f'Test Loss: {val_loss:.4f} Acc: {val_acc:.4f}')\n",
    "        testing_loss.append(val_loss)\n",
    "        testing_acc.append(val_acc.cpu().detach().numpy())\n",
    "\n",
    "        # save the model in last epoch\n",
    "        if (epoch +1) == NUM_EPOCHS:\n",
    "            \n",
    "            state = {\n",
    "            'state_dict': model.state_dict(),\n",
    "            'acc': epoch_acc,\n",
    "            'epoch': (epoch+1),\n",
    "            }\n",
    "\n",
    "            # check the dir\n",
    "            if not os.path.exists(SAVE_DIR):\n",
    "                os.makedirs(SAVE_DIR)\n",
    "\n",
    "            # save the state\n",
    "            torch.save(state, osp.join(SAVE_DIR, 'checkpoint_%s.pth' % (str(epoch+1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the information by constructing a line chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlQAAAHHCAYAAAB5gsZZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAABls0lEQVR4nO3deXhMZ/8G8PvMJDOTnYhshIQglhCCiCWqUgkpQdXS2lJFUaqxtFqlaF/Vxb5Wa21rK0XtBEVErCElCElEyCIhK7LMnN8f/Zk2TVLZz0xyf65rrvedc57zzPecKXM7y/MIoiiKICIiIqJSk0ldABEREZG+Y6AiIiIiKiMGKiIiIqIyYqAiIiIiKiMGKiIiIqIyYqAiIiIiKiMGKiIiIqIyYqAiIiIiKiMGKiIiIqIyYqAi0mEjR46Eo6Njqbb9/PPPIQhC+RZE9BInT56EIAg4efKk1KUQVSoGKqJSEAShWC/+qJTdL7/8gsWLF0tdRpVy9uxZfP7550hNTS11HytXrsSGDRvKrSYifSdwLj+ikvvpp5/yvd+0aROOHj2KzZs351v+2muvwcbGptSfk5ubC41GA6VSWeJt8/LykJeXB5VKVerP1wWvv/46/vzzT8TExEhdSpXx7bffYtq0aYiOji71GdAWLVrAysqqwD8aNBoNcnJyoFAoIJPx3+xUfRhIXQCRPho6dGi+9+fOncPRo0cLLP+3p0+fwtjYuNifY2hoWKr6AMDAwAAGBvwj/uIHvrKCZUm/46pGJpPpfYgnKg3+84Gogrzyyito0aIFLl26BC8vLxgbG+OTTz4BAOzZswd+fn6wt7eHUqlEw4YNMW/ePKjV6nx9/PseqpiYGAiCgG+//Rbff/89GjZsCKVSiXbt2uHChQv5ti3sHipBEPD+++9j9+7daNGiBZRKJZo3b45Dhw4VqP/kyZNo27YtVCoVGjZsiDVr1hT7vqzIyEi88cYbsLW1hUqlQt26dTF48GCkpaXla/fTTz/B3d0dRkZGsLS0xODBg3H//v18x3D//v24d++e9jLqy86ovNjHn3/+Gc2bN4dSqdTu34MHD/DOO+/AxsZGu+/r1q0rsN+CIGDbtm345JNPYGtrCxMTE/Tp0ydfbS/qK+o7zs7OxuzZs+Hs7AylUgkHBwdMnz4d2dnZ+fo4evQoOnfujBo1asDU1BRNmjTR9vFCcfsqzvf7+eefY9q0aQAAJycn7XF9cQZw/fr1ePXVV2FtbQ2lUolmzZph1apV+T7H0dER169fxx9//KHd/pVXXsl3/P595mrHjh3a79rKygpDhw7FgwcP8rUZOXIkTE1N8eDBA/Tt2xempqaoXbs2pk6dWuDPBpGu4T9fiSpQSkoKevbsicGDB2Po0KHay38bNmyAqakpAgMDYWpqiuPHj2PWrFlIT0/HN99889J+f/nlF2RkZGDs2LEQBAFff/01+vfvj6ioqJee1Tpz5gx27dqF8ePHw8zMDEuXLsUbb7yB2NhY1KpVCwBw5coV+Pr6ws7ODnPmzIFarcbcuXNRu3btl9aWk5MDHx8fZGdnY+LEibC1tcWDBw+wb98+pKamwsLCAgDw5Zdf4rPPPsPAgQPx7rvv4tGjR1i2bBm8vLxw5coV1KhRA59++inS0tIQFxeHRYsWAQBMTU1fWsPx48exfft2vP/++7CysoKjoyMSExPRoUMHbeioXbs2Dh48iFGjRiE9PR2TJ0/O18eXX34JQRDw0UcfISkpCYsXL4a3tzfCwsJgZGSkbVfYd6zRaNCnTx+cOXMGY8aMQdOmTREeHo5Fixbh9u3b2L17NwDg+vXreP3119GyZUvMnTsXSqUSd+7cQXBwsLb/4vZV3O+3f//+uH37NrZs2YJFixbBysoKALTf7apVq9C8eXP06dMHBgYG+P333zF+/HhoNBpMmDABALB48WJMnDgRpqam+PTTTwHgPy9tb9iwAQEBAWjXrh3mz5+PxMRELFmyBMHBwdrv+gW1Wg0fHx94eHjg22+/xbFjx/Ddd9+hYcOGGDdu3Eu/eyLJiERUZhMmTBD//cepa9euIgBx9erVBdo/ffq0wLKxY8eKxsbG4vPnz7XLRowYIdavX1/7Pjo6WgQg1qpVS3z8+LF2+Z49e0QA4u+//65dNnv27AI1ARAVCoV4584d7bKrV6+KAMRly5Zpl/Xu3Vs0NjYWHzx4oF0WGRkpGhgYFOjz365cuSICEHfs2FFkm5iYGFEul4tffvllvuXh4eGigYFBvuV+fn75jsHLABBlMpl4/fr1fMtHjRol2tnZicnJyfmWDx48WLSwsNB+JydOnBABiHXq1BHT09O17bZv3y4CEJcsWaJdVtR3vHnzZlEmk4mnT5/Ot3z16tUiADE4OFgURVFctGiRCEB89OhRkftT3L5e7Htxvt9vvvlGBCBGR0cX+LzC/tv08fERGzRokG9Z8+bNxa5duxZo++L4nThxQhRFUczJyRGtra3FFi1aiM+ePdO227dvnwhAnDVrlnbZiBEjRADi3Llz8/XZunVr0d3dvcBnEekSXvIjqkBKpRIBAQEFlv/zDEdGRgaSk5PRpUsXPH36FDdv3nxpv4MGDULNmjW177t06QIAiIqKeum23t7eaNiwofZ9y5YtYW5urt1WrVbj2LFj6Nu3L+zt7bXtnJ2d0bNnz5f2/+IM1OHDh/H06dNC2+zatQsajQYDBw5EcnKy9mVra4tGjRrhxIkTL/2c/9K1a1c0a9ZM+14URezcuRO9e/eGKIr5PtPHxwdpaWm4fPlyvj6GDx8OMzMz7fsBAwbAzs4OBw4cyNeusO94x44daNq0KVxcXPJ91quvvgoA2v17cWZmz5490Gg0he5Lcft64WXf78v887/NtLQ0JCcno2vXroiKiipwybY4Ll68iKSkJIwfPz7fvVV+fn5wcXHB/v37C2zz3nvv5XvfpUuXYtdPJBVe8iOqQHXq1IFCoSiw/Pr165g5cyaOHz+O9PT0fOuK86NVr169fO9fhKsnT56UeNsX27/YNikpCc+ePYOzs3OBdoUt+zcnJycEBgZi4cKF+Pnnn9GlSxf06dMHQ4cO1YatyMhIiKKIRo0aFdpHWW7Gf1HDPz169Aipqan4/vvv8f333xe6TVJSUr73/65NEAQ4OzsXeNqwsO84MjISERERRV4iffFZgwYNwg8//IB3330XH3/8Mbp3747+/ftjwIAB2ifkitvXCy/7fl8mODgYs2fPRkhISIFAnJaWpv0Oi+vevXsAgCZNmhRY5+LigjNnzuRbplKpCuxrSeonkgoDFVEF+ue/9l9ITU1F165dYW5ujrlz56Jhw4ZQqVS4fPkyPvrooyLPVPyTXC4vdLlYjFFQyrJtcX333XcYOXIk9uzZgyNHjmDSpEmYP38+zp07h7p160Kj0UAQBBw8eLDQeopzn9R/+fdxf3FMhw4dihEjRhS6TcuWLcvls158nqurKxYuXFjoNg4ODtptT506hRMnTmD//v04dOgQtm3bhldffRVHjhyBXC4vdl8vlOX7vXv3Lrp37w4XFxcsXLgQDg4OUCgUOHDgABYtWlSs/zbLqqj6iXQdAxVRJTt58iRSUlKwa9cueHl5aZdHR0dLWNXfrK2toVKpcOfOnQLrCltWFFdXV7i6umLmzJk4e/YsOnXqhNWrV+OLL75Aw4YNIYoinJyc0Lhx4//spzxGe69duzbMzMygVqvh7e1drG0iIyPzvRdFEXfu3ClW8GrYsCGuXr2K7t27v7R+mUyG7t27o3v37li4cCH+97//4dNPP8WJEye0l++K21dxFdXP77//juzsbOzduzffma7CLsEWt5b69esDAG7duqW9TPnCrVu3tOuJ9B3voSKqZC/+Bf7PMwY5OTlYuXKlVCXlI5fL4e3tjd27d+Phw4fa5Xfu3MHBgwdfun16ejry8vLyLXN1dYVMJtM+5t+/f3/I5XLMmTOnwJkTURSRkpKifW9iYlKqe3f+SS6X44033sDOnTvx559/Flj/6NGjAss2bdqEjIwM7ftff/0V8fHxxbqPbODAgXjw4AHWrl1bYN2zZ8+QlZUFAHj8+HGB9W5ubgCgPVbF7askTExMAKDASOmF/beZlpaG9evXF9pHcUZab9u2LaytrbF69ep8wzwcPHgQERER8PPzK3H9RLqIZ6iIKlnHjh1Rs2ZNjBgxApMmTYIgCNi8eXO5XnIrq88//xxHjhxBp06dMG7cOKjVaixfvhwtWrRAWFjYf257/PhxvP/++3jzzTfRuHFj5OXlYfPmzdpQA/x1BueLL77AjBkzEBMTg759+8LMzAzR0dH47bffMGbMGEydOhUA4O7ujm3btiEwMBDt2rWDqakpevfuXeJ9+uqrr3DixAl4eHhg9OjRaNasGR4/fozLly/j2LFjBcKNpaUlOnfujICAACQmJmLx4sVwdnbG6NGjX/pZw4YNw/bt2/Hee+/hxIkT6NSpE9RqNW7evInt27fj8OHDaNu2LebOnYtTp07Bz88P9evXR1JSElauXIm6deuic+fOJeqrJNzd3QEAn376KQYPHgxDQ0P07t0bPXr0gEKhQO/evTF27FhkZmZi7dq1sLa2Rnx8fIE+Vq1ahS+++ALOzs6wtrYucAYK+Ot+uAULFiAgIABdu3bFkCFDtMMmODo64sMPPyxR7UQ6S5JnC4mqmKKGTWjevHmh7YODg8UOHTqIRkZGor29vTh9+nTx8OHD+R43F8Wih0345ptvCvQJQJw9e7b2fVHDJkyYMKHAtvXr1xdHjBiRb1lQUJDYunVrUaFQiA0bNhR/+OEHccqUKaJKpSriKPwlKipKfOedd8SGDRuKKpVKtLS0FLt16yYeO3asQNudO3eKnTt3Fk1MTEQTExPRxcVFnDBhgnjr1i1tm8zMTPGtt94Sa9SoIQJ46RAKRe2jKIpiYmKiOGHCBNHBwUE0NDQUbW1txe7du4vff/+9ts2Lx/63bNkizpgxQ7S2thaNjIxEPz8/8d69e/n6+6/vOCcnR1ywYIHYvHlzUalUijVr1hTd3d3FOXPmiGlpaaIo/nWM/f39RXt7e1GhUIj29vbikCFDxNu3b5e4r//a98K+33nz5ol16tQRZTJZviEU9u7dK7Zs2VJUqVSio6OjuGDBAnHdunUFhllISEgQ/fz8RDMzMxGAdgiFfw+b8MK2bdvE1q1bi0qlUrS0tBTffvttMS4uLl+bESNGiCYmJgXqL+y/ZSJdw7n8iKjY+vbti+vXrxe4v6gqOXnyJLp164YdO3ZgwIABUpdDRHqC91ARUaGePXuW731kZCQOHDignWKEiIj+xnuoiKhQDRo0wMiRI9GgQQPcu3cPq1atgkKhwPTp06UujYhI5zBQEVGhfH19sWXLFiQkJECpVMLT0xP/+9//ihyMk4ioOuM9VERERERlxHuoiIiIiMqIgYqIiIiojHgPVSE0Gg0ePnwIMzOzcpvqgYiIiCqWKIrIyMiAvb29doLxysJAVYiHDx8WmHCUiIiI9MP9+/dRt27dSv1MBqpCmJmZAfjrCzE3N5e4GiIiIiqO9PR0ODg4aH/HKxMDVSFeXOYzNzdnoCIiItIzUtyuw5vSiYiIiMqIgYqIiIiojBioiIiIiMqIgYqIiIiojBioiIiIiMqIgYqIiIiojBioiIiIiMqIgYqIiIiojBioiIiIiMqIgYqIiIiojBioiIiIiMqIgYqIiIiojBioJPAw9Rme56qlLoOIiIjKCQNVJYt78hQdvzqOVnOOQK0RpS6HiIiIyoFOBKoVK1bA0dERKpUKHh4eOH/+fJFtN2zYAEEQ8r1UKlW+NiNHjizQxtfXt6J3o1ieZOUCALLzNFh49JbE1RAREVF5kDxQbdu2DYGBgZg9ezYuX76MVq1awcfHB0lJSUVuY25ujvj4eO3r3r17Bdr4+vrma7Nly5aK3I1iCY9LQ+/lZ7TvV5y4i8T05xJWREREROVB8kC1cOFCjB49GgEBAWjWrBlWr14NY2NjrFu3rshtBEGAra2t9mVjY1OgjVKpzNemZs2aFbkbxZKn0RRY5vG/IHT66jjORaVIUBERERGVB0kDVU5ODi5dugRvb2/tMplMBm9vb4SEhBS5XWZmJurXrw8HBwf4+/vj+vXrBdqcPHkS1tbWaNKkCcaNG4eUlKIDS3Z2NtLT0/O9KkLrejWxZLBbgeUPUp9hyNpzeJSRXSGfS0RERBVL0kCVnJwMtVpd4AyTjY0NEhISCt2mSZMmWLduHfbs2YOffvoJGo0GHTt2RFxcnLaNr68vNm3ahKCgICxYsAB//PEHevbsCbW68Cfr5s+fDwsLC+3LwcGh/HbyX/zd6mD7WM8Cy4d1qI8axoYV9rlERERUcQRRFCV71Ozhw4eoU6cOzp49C0/Pv0PG9OnT8ccffyA0NPSlfeTm5qJp06YYMmQI5s2bV2ibqKgoNGzYEMeOHUP37t0LrM/OzkZ29t9nh9LT0+Hg4IC0tDSYm5uXYs9eLu1pLlrNPaJ9H/OVX4V8DhERUXWRnp4OCwuLCv39LoqkZ6isrKwgl8uRmJiYb3liYiJsbW2L1YehoSFat26NO3fuFNmmQYMGsLKyKrKNUqmEubl5vldFszA2xDudnAAATlYmeJKVU+GfSURERBVD0kClUCjg7u6OoKAg7TKNRoOgoKB8Z6z+i1qtRnh4OOzs7IpsExcXh5SUlP9sI4WRHR0hCEB0chZazzsK93lHMWhNCGbuDsfGszF8ApCIiEhPSP6UX2BgINauXYuNGzciIiIC48aNQ1ZWFgICAgAAw4cPx4wZM7Tt586diyNHjiAqKgqXL1/G0KFDce/ePbz77rsA/rphfdq0aTh37hxiYmIQFBQEf39/ODs7w8fHR5J9LEq9WsaY8lpjOFgaAQBSsnIQGv0YP52Lxey91+G7+BTORz+WuEoiIiJ6GQOpCxg0aBAePXqEWbNmISEhAW5ubjh06JD2RvXY2FjIZH/nvidPnmD06NFISEhAzZo14e7ujrNnz6JZs2YAALlcjmvXrmHjxo1ITU2Fvb09evTogXnz5kGpVEqyj//l/Vcb4f1XG+FpTh6iHmUhMikDkYmZCIpIwq3EDLz9wznM798SA9zrSl0qERERFUHSm9J1lZQ3tb3wLEeNKTvCcCD8r6cdx73SENN6NIFMJkhSDxERka6rtjelU9GMFHIsH9IG73dzBgCsOnkX43++jKc5eRJXRkRERP/GQKXDZDIBU32aYOHAVlDIZTh0PQED14QgIY03qxMREekSBio90L9NXfwy2gOWJgr8+SAdw34MBa/UEhER6Q4GKj3R1tESeyZ0gspQhsikTEQmZUpdEhEREf0/Bio94mBpjHaOlgCAU7cfSVwNERERvcBApWc6NrQCAHyxPwKOH+/HrstxL9mCiIiIKhoDlZ4Z7lkfjrWMte8Dt1/Fb1cYqoiIiKTEQKVnTJQGODmtG5rZ/T2+xrQd13A7MUPCqoiIiKo3DuxZCF0Y2LM4dl6Kw7Rfr0Lz/9+gs7Upernawc/VDo1tTCEIHASUiIiqDyl/vxmoCqEvgQoAgu8kY92ZaJyOTEaOWqNd3qC2Cfxc7dDL1Q4utmYMV0REVOUxUOkYfQpUL6Q/z0VQRCL2X0vAqduP8oUrJysT9HK1RS9XOzSzM2e4IiKiKomBSsfoY6D6p4znuTh+Mwn7r8Xj5O1HyMn7O1w51jKGX0s7jHvFGaZKyefGJiIiKjcMVDpG3wPVP2Vm5+H4zSQcuBaPE7eSkP3/4apnC1usGuoucXVERETlR8rfb56iqOJMlQbo08oefVrZIys7D4evJ2Dar9dw8M8EnI58hC6NaktdIhERkd7jsAnViInSAP3b1MVwz/oAgNl7riM7Ty1xVURERPqPgaoa+vC1xrAyVSIqOQs/nI7mRMtERERlxEBVDZmrDDGsw19nqb45fAuNZx6E39LTiHrECZeJiIhKg4GqmvJpYYNaJgoAQK5axPWH6Xjvp0vIys6TuDIiIiL9w6f8ClGVnvL7L6Io4lmuGg+ePMPbP4QiKSMbr7e0w7IhrTlWFRER6R0pf795hqoaEwQBxgoDNLIxw8q328BAJmDftXisC46RujQiIiK9wkBFAIC2jpaY6dcUAPC/AxEIjUqRuCIiIiL9wUBFWiM6OsLfzR5qjYgJv1xBYvpzqUsiIiLSCwxUpCUIAub3d4WLrRmSM7Mx/ufL+aatISIiosIxUFE+xgoDrB7qDjOVAS7de4LA7WFIf54rdVlEREQ6jYGKCnC0MsHiQW6QCcC+a/HwXXQKpyMfSV0WERGRzmKgokJ1b2qDrWM8Ub+WMR6mPcewH8/jk9/CkclxqoiIiApgoKIitXeyxMEPumDE/8/990toLHwXn8LZu8kSV0ZERKRbGKjoPxkrDDDHvwV+Ge2BujWNEPfkGd5aG4rZe/7E0xyerSIiIgIYqKiYOja0wqHJXnjbox4AYGPIPfguPo3z0Y8lroyIiEh6DFRUbKZKA3zZzxWbR7WHvYUKsY+fYtD3IZj7+w08y1FLXR4REZFkGKioxLo0qo1DH3phUFsHiCKwLjgavZaexqV7PFtFRETVEwMVlYq5yhALBrTE+oB2sDFXIjo5C2+uDsH8AxF4nsuzVUREVL0wUFGZdGtijSOTu+KNNnWhEYE1p6Lgt/Q0wu6nSl0aERFRpWGgojKzMDbEdwNb4YfhbVHbTIm7j7LQf2Uwvj50E9l5PFtFRERVHwMVlRvvZjY4+qEX/N3soRGBlSfvos+yYITHpUldGhERUYVioKJyVcNYgSWDW2P10DaoZaLArcQM9F0ZjIPh8VKXRkREVGEYqKhC+Laww5EPveDT3AZqjYjJ28JwlfdVERFRFcVARRWmlqkSK992R7cmtZGdp8G7my7iQeozqcsiIiIqdwxUVKHkMgHL3moDF1szPMrIxqgNFzjBMhERVTkMVFThTJUG+HFkO1iZKnEzIQOTtlyBWiNKXRYREVG5YaCiSlGnhhF+GNEWSgMZjt9Mwpf7I6QuiYiIqNwwUFGlcXOogYUD3QD8NV3NT+fuSVsQERFROWGgokrl19IOU3s0BgDM3nsdp24/krgiIiKismOgoko3oZsz+repA7VGxISfLyMyMUPqkoiIiMqEgYoqnSAImN/fFe0dLZGRnYd3Nl5ASma21GURERGVGgMVSUJpIMfqYe6oX8sY9x8/w5jNl/A8l/P+ERGRfmKgIslYmijw44h2MFcZ4NK9J/ho5zWIIodTICIi/cNARZJytjbFqqHuMJAJ2BP2EEuD7khdEhERUYkxUJHkOjlbYV7fFgCARcduY+/VhxJXREREVDIMVKQThrSvh9FdnAAAU3dcxaV7TySuiIiIqPgYqEhnfNyzKbyb2iAnT4Mxmy7i/uOnUpdERERULAxUpDPkMgFLBruhmZ05UrJyMGrjBWQ8z5W6LCIiopdioCKdYqI0wI8j28LGXInbiZkYvu48nmTlSF0WERHRf2KgIp1jZ2GEH0e0g4WRIa7EpuKN1WcR94SX/4iISHfpRKBasWIFHB0doVKp4OHhgfPnzxfZdsOGDRAEId9LpVLlayOKImbNmgU7OzsYGRnB29sbkZGRFb0bVI5a1LHAznGesLdQIepRFvqvPIuI+HSpyyIiIiqU5IFq27ZtCAwMxOzZs3H58mW0atUKPj4+SEpKKnIbc3NzxMfHa1/37t3Lt/7rr7/G0qVLsXr1aoSGhsLExAQ+Pj54/vx5Re8OlSNnazPsGt8JTWzMkJSRjYGrQxByN0XqsoiIiAqQPFAtXLgQo0ePRkBAAJo1a4bVq1fD2NgY69atK3IbQRBga2urfdnY2GjXiaKIxYsXY+bMmfD390fLli2xadMmPHz4ELt3766EPaLyZGuhwvb3PNHe6a95/0asO4/91+KlLouIiCgfSQNVTk4OLl26BG9vb+0ymUwGb29vhISEFLldZmYm6tevDwcHB/j7++P69evaddHR0UhISMjXp4WFBTw8PIrsMzs7G+np6flepDssjAyx6Z326NnCFjlqDd7fchkbgqOlLouIiEhL0kCVnJwMtVqd7wwTANjY2CAhIaHQbZo0aYJ169Zhz549+Omnn6DRaNCxY0fExcUBgHa7kvQ5f/58WFhYaF8ODg5l3TUqZypDOZa/1QbDOtSHKAKf/34DozddxM0Ehl8iIpKe5Jf8SsrT0xPDhw+Hm5sbunbtil27dqF27dpYs2ZNqfucMWMG0tLStK/79++XY8VUXuQyAXP9m2OaTxPIBODojUT0XHIak7deQUxyltTlERFRNSZpoLKysoJcLkdiYmK+5YmJibC1tS1WH4aGhmjdujXu3PlrUt0X25WkT6VSCXNz83wv0k2CIGBCN2cc+dALfq52EEVgd9hDdF/4B2bsCkd82jOpSyQiompI0kClUCjg7u6OoKAg7TKNRoOgoCB4enoWqw+1Wo3w8HDY2dkBAJycnGBra5uvz/T0dISGhha7T9J9ztZmWPF2G+yb2BmvNKkNtUbElvOx6PrNSczbdwMpmdlSl0hERNWI5Jf8AgMDsXbtWmzcuBEREREYN24csrKyEBAQAAAYPnw4ZsyYoW0/d+5cHDlyBFFRUbh8+TKGDh2Ke/fu4d133wXw1xmMyZMn44svvsDevXsRHh6O4cOHw97eHn379pViF6kCtahjgQ0B7bHjPU+0d7RETp4GP56JhtfXJ/DdkVtIe8apa4iIqOIZSF3AoEGD8OjRI8yaNQsJCQlwc3PDoUOHtDeVx8bGQib7O/c9efIEo0ePRkJCAmrWrAl3d3ecPXsWzZo107aZPn06srKyMGbMGKSmpqJz5844dOhQgQFAqepo52iJbWM74FRkMr49fAvhD9Kw7PgdbAq5h3GvNMQIT0cYKeRSl0lERFWUIIqiKHURuiY9PR0WFhZIS0vj/VR6SBRFHL6egO+O3EZkUiYAwNpMiQ+8G2FgWwcYyiU/MUtERBVAyt9vBqpCMFBVDWqNiN+uPMCio7fxIPWvm9UdaxkjsEcTvO5qB5lMkLhCIiIqTwxUOoaBqmrJzlNjS2gslh2/g5SsHABAMztzTPdtgleaWEtcHRERlRcGKh3DQFU1ZWbnYd2ZaHx/KgqZ2XkAgHc7O2FGr6aQ82wVEZHek/L3mzeTULVhqjTApO6NcGp6NwR0cgQA/HAmGmM3X0TW/wcsIiKi0mCgomrH0kSB2b2bY+mQ1lAYyHAsIgkDVofgYSoHBSUiotJhoKJqq08re2wd0wFWpgpExKej74pgXItLlbosIiLSQwxUVK21qVcTv43vhCY2ZkjKyMbANSE4GB4vdVlERKRnGKio2nOwNMav4zzRtXFtPM/VYNzPl7HixB3weQ0iIiouBioiAGYqQ/w4oi1GeNYHAHxz+Bam/XoNOXkaiSsjIiJ9wEBF9P8M5DLM8W+BOX2aQyYAv16Kw9AfQ/Hk/8euIiIiKgoDFdG/jOjoiHUj28FUaYDz0Y/Rb2Uw7j7KlLosIiLSYQxURIV4pYk1do7riDo1jBCT8hT9VgTj7N1kqcsiIiIdxUBFVIQmtmbYPaETWtergfTneRj+43lsuxArdVlERKSDGKiI/kNtMyW2jO6A3q3skacR8dHOcMw/EAG1hk8AEhHR3xioiF5CZSjH0sFu+KB7IwDAmlNReO+nS3iaw+lqiIjoLwxURMUgCAI+fK0xlgx2g0Iuw9EbiXhzdQgS0p5LXRoREekABiqiEvB3q4MtYzxQy0SB6w/T4b/iDP58kCZ1WUREJDEGKqIScq9vid0TOqGRtSkS07Px5uoQHL6eIHVZREQkIQYqolJwsDTGzvEd0aWRFZ7lqvHeT5ew+o+7nK6GiKiaYqAiKiVzlSHWj2yHYR3qQxSBrw7exEc7OV0NEVF1xEBFVAYGchnm+jfH572bQSYA2y/GYcS680h9yulqiIiqEwYqojISBAEjOznhxxHtYKKQIyQqBf1XnkV0cpbUpRERUSVhoCIqJ91crLFz/F/T1UQlZ6HvimCE3E2RuiwiIqoEDFRE5cjF1hy/TegIN4caSHuWi+HrQrH94n2pyyIiogrGQEVUzqzNVNg6pgP8WtohVy1i+q/X8NXBm9BwuhoioiqLgYqoAqgM5Vg2uDUmvuoMAFj9x12M//kyp6shIqqiGKiIKohMJmBKjyZYOLAVFHIZDl1PwKA155CYzulqiIiqGgYqogrWv01d/DzaA5YmCoQ/SIP/8mBOV0NEVMUwUBFVgnaOltg9vhMa1jZBQvpzDFwTgqM3EqUui4iIygkDFVElqVfLGLvGd0JnZys8zVFjzOaLWHsqitPVEBFVAQxURJXIwsgQ6wPa4S2PehBF4MsDEfjkt3DkqjldDRGRPmOgIqpkhnIZvuzbAp+93gyCAGw5fx8j159H2tNcqUsjIqJSYqAikoAgCBjV2Qk/DG8LY4UcwXdS0G9VMGI4XQ0RkV5ioCKSUPemNvj1vY6ws1Ah6lEW+q4MRmgUp6shItI3DFREEmtmb449EzqhVV0LpD7NxdAfQ7HzUpzUZRERUQkwUBHpAGtzFbaO8UQvV1vkqkVM2XEV3xzmdDVERPqCgYpIRxgp5Fg+pA0mdGsIAFhx4i7e++kSMrM5XQ0Rka5joCLSITKZgGk+Lvjuzb+mqzlyIxH9VwbjXgpvVici0mUMVEQ66A33utg6tgOszZS4nZiJPsuDcSYyWeqyiIioCAxURDqqTb2a+H1iZ7RyqIG0Z7kYvi4UP56J5sjqREQ6iIGKSIfZmKuwbUwHvNGmLjQiMG/fDUz79Rqe56qlLo2IiP6BgYpIx6kM5fj2zZb47PVmkAnAr5fiMPj7c0hMfy51aURE9P8YqIj0wIuR1Te+0x4WRoYIu5+K3svO4ErsE6lLIyIiMFAR6ZUujWpjz4ROaGRtiqSMbAz6/hwHASUi0gEMVER6xtHKBL9N6ITXmtkgJ0+DKTuuYt6+G8hTa6QujYio2mKgItJDpkoDrBnqjkmvOgMAfjwTjZHrLyD1aY7ElRERVU8MVER6SiYTENijCVa+3QZGhnKcuZMM/xXBuJ2YIXVpRETVDgMVkZ7r5WqHXeM7om5NI9xLeYp+K4Jx5HqC1GUREVUrDFREVUBTO3Psfb8zOjSwRFaOGmM2X8LSoEhOrkxEVEkYqIiqCEsTBTaP8sAIz/oAgIVHb2PCL5eRxcmViYgqHAMVURViKJdhjn8LfNXfFYZyAQf/TMAbq87i/uOnUpdGRFSlMVARVUGD29fD1jEdYGWqxM2EDPRZfgZn73JyZSKiisJARVRFude3xN73O8G1jgWePM3FsB/PY+PZGE6uTERUAUoVqN544w0sWLCgwPKvv/4ab775ZpmLIqLyYV/DCDve80RfN3uoNSJm772OT34LR04eBwElIipPpQpUp06dQq9evQos79mzJ06dOlXmooio/KgM5Vg0yA0zerpAEIAt5+9j6A+hSMnMlro0IqIqo1SBKjMzEwqFosByQ0NDpKenl7i/FStWwNHRESqVCh4eHjh//nyxttu6dSsEQUDfvn3zLR85ciQEQcj38vX1LXFdRFWFIAgY27Uh1o1oBzOlAc7HPEaf5cG48bDkf16JiKigUgUqV1dXbNu2rcDyrVu3olmzZiXqa9u2bQgMDMTs2bNx+fJltGrVCj4+PkhKSvrP7WJiYjB16lR06dKl0PW+vr6Ij4/XvrZs2VKiuoiqom4u1vhtQkc41jLGg9RneGPVWRwMj5e6LCIivSeIpbhD9ffff0f//v3x1ltv4dVXXwUABAUFYcuWLdixY0eBM0b/xcPDA+3atcPy5csBABqNBg4ODpg4cSI+/vjjQrdRq9Xw8vLCO++8g9OnTyM1NRW7d+/Wrh85cmSBZSWRnp4OCwsLpKWlwdzcvFR9EOmytKe5mPDLZZy589eTf5O9G2HSq40gkwkSV0ZEVHpS/n6X6gxV7969sXv3bty5cwfjx4/HlClTEBcXh2PHjpUoTOXk5ODSpUvw9vb+uyCZDN7e3ggJCSlyu7lz58La2hqjRo0qss3JkydhbW2NJk2aYNy4cUhJSSmybXZ2NtLT0/O9iKoyC2NDbAhoh4BOjgCAxcci8f6Wy3iaw0FAiYhKw6C0G/r5+cHPz69MH56cnAy1Wg0bG5t8y21sbHDz5s1Ctzlz5gx+/PFHhIWFFdmvr68v+vfvDycnJ9y9exeffPIJevbsiZCQEMjl8gLt58+fjzlz5pRpX4j0jYFchtm9m8PF1gwzd/+JA+EJiE5+irXD3VG3prHU5RER6ZVSnaG6cOECQkNDCywPDQ3FxYsXy1xUUTIyMjBs2DCsXbsWVlZWRbYbPHgw+vTpA1dXV/Tt2xf79u3DhQsXcPLkyULbz5gxA2lpadrX/fv3K2gPiHTPoHb1sGV0B1iZKhARnw7/5cG4EPNY6rKIiPRKqQLVhAkTCg0dDx48wIQJE4rdj5WVFeRyORITE/MtT0xMhK2tbYH2d+/eRUxMDHr37g0DAwMYGBhg06ZN2Lt3LwwMDHD37t1CP6dBgwawsrLCnTt3Cl2vVCphbm6e70VUnbR1tMSe9zujmZ05UrJy8Nbac9h2IVbqsoiI9EapAtWNGzfQpk2bAstbt26NGzduFLsfhUIBd3d3BAUFaZdpNBoEBQXB09OzQHsXFxeEh4cjLCxM++rTpw+6deuGsLAwODg4FPo5cXFxSElJgZ2dXbFrI6pu6tQwwq/jPNHL1Ra5ahEf7QzH53uvI0/NQUCJiF6mVIFKqVQWOKsEAPHx8TAwKNltWYGBgVi7di02btyIiIgIjBs3DllZWQgICAAADB8+HDNmzAAAqFQqtGjRIt+rRo0aMDMzQ4sWLaBQKJCZmYlp06bh3LlziImJQVBQEPz9/eHs7AwfH5/S7C5RtWGsMMCKt9og8LXGAIANZ2Mwcv0FpD7NkbgyIiLdVqpA1aNHD+19Ry+kpqbik08+wWuvvVaivgYNGoRvv/0Ws2bNgpubG8LCwnDo0CHtjeqxsbGIjy/+ODlyuRzXrl1Dnz590LhxY4waNQru7u44ffo0lEpliWojqo4EQcCk7o2weqg7jBVynLmTjL4rgnEnKUPq0oiIdFapxqF68OABvLy8kJKSgtatWwMAwsLCYGNjg6NHjxZ56U1fcBwqor9ExKfj3Y0X8SD1GUyVBlg6xA2vuti8fEMiIglI+ftdqkAFAFlZWfj5559x9epVGBkZoWXLlhgyZAgMDQ3Lu8ZKx0BF9LeUzGyM+/kyzkc/hiAAH/m6YKxXAwgCBwElIt2il4GqKmOgIsovJ0+D2XuvY8v5v5786+tmj6/eaAmVYcFx3YiIpCLl73epB/YE/nraLzY2Fjk5+W9Y7dOnT5mKIiLdojCQ4X/9WqCZnRk+//0Gdoc9RHRyFr4f3hY25iqpyyMiklypzlBFRUWhX79+CA8PhyAIeNHFi0sAarW6fKusZDxDRVS0s3eSMf6Xy0h9mgtrMyW+H94Wbg41pC6LiEj/5vL74IMP4OTkhKSkJBgbG+P69es4deoU2rZtW+Ro5ERUNXR0tsKeCZ3QyNoUSRnZGLgmBL9diZO6LCIiSZUqUIWEhGDu3LmwsrKCTCaDTCZD586dMX/+fEyaNKm8ayQiHVO/lgl2je8I76bWyMnT4MNtVzH/YATUGt6SSUTVU6kClVqthpmZGYC/po95+PAhAKB+/fq4detW+VVHRDrLTGWI74e1xfhXGgIA1vwRhdGbLiLjea7ElRERVb5SBaoWLVrg6tWrAAAPDw98/fXXCA4Oxty5c9GgQYNyLZCIdJdMJmC6rwuWDHaD0kCG4zeT0G/lWcQkZ0ldGhFRpSpVoJo5cyY0mr/m95o7dy6io6PRpUsXHDhwAEuXLi3XAolI9/m71cGO9zxha67CnaRM+K8IxpnIZKnLIiKqNOU2DtXjx49Rs2bNfIP9xcXFwd7eHjJZqXKbZPiUH1HpJKU/x5jNlxB2PxVymYCZfk0xsqMjBwElokqhd0/5FcbS0rLAX5rNmjVDTExMeX0EEek4a3MVto7pgP5t6kCtETHn9xv4eGc4cvI0UpdGRFShKvTUEQdhJ6p+VIZyfPdmK3zaqylkArDt4n28/cM5JGdmS10aEVGF0a9rcUSkFwRBwGivBvhxZDuYKQ1wIeYJ/JcH4/rDNKlLIyKqEAxURFRhujWxxm8TOsHJygQPUp9hwKoQHAyPl7osIqJyx0BFRBXK2doUu8d3QpdGVniWq8a4ny9j0dHb0HAQUCKqQio0UPHJHiICAAtjQ6wf2Q6jOjsBAJYERWL8z5eRlZ0ncWVEROWDN6UTUaUwkMvw2evN8PWAllDIZTh0PQFvrDqL+4+fSl0aEVGZVWigunHjBurXr1+RH0FEemZgWwdsGeMBK1MlbiZkwH9FMM5HP5a6LCKiMinVwJ79+vUr9HKeIAhQqVRwdnbGW2+9hSZNmpRLkZWNA3sSVbyHqc8wetNFXH+YDkO5gLn+LTCkfT2pyyIiPaZ3A3taWFjg+PHjuHz5MgRBgCAIuHLlCo4fP468vDxs27YNrVq1QnBwcHnXS0RVhH0NI/z6Xkf4tbRDrlrEjF3hmL3nT+SqOQgoEemfUgUqW1tbvPXWW4iKisLOnTuxc+dO3L17F0OHDkXDhg0RERGBESNG4KOPPirveomoCjFSyLF8SGtM7dEYALAx5B76rQxGZGKGxJUREZVMqS751a5dG8HBwWjcuHG+5bdv30bHjh2RnJyM8PBwdOnSBampqeVVa6XhJT+iynfkegKm77yG1Ke5UBjIMN2nCd7p5ASZjE8LE1Hx6N0lv7y8PNy8ebPA8ps3b0KtVgMAVCoVh00gomLr0dwWhyd74ZUmtZGTp8EX+yPw1g/nEPeETwESke4rVaAaNmwYRo0ahUWLFuHMmTM4c+YMFi1ahFGjRmH48OEAgD/++APNmzcv12KJqGqzMVdh/ch2+LJfCxgZynEu6jF8F5/Gjov3OQwLEem0Ul3yU6vV+Oqrr7B8+XIkJiYCAGxsbDBx4kR89NFHkMvliI2NhUwmQ926dcu96IrGS35E0otJzsKUHVdx6d4TAECPZjb4X39XWJkqJa6MiHSVlL/fpQpU/5Seng4AVSp4MFAR6Qa1RsSaU3ex6Oht5KpF1DJRYH5/V/Robit1aUSkg/TuHqp/Mjc3Z+ggogohlwkY/4oz9kzoDBdbM6Rk5WDM5kuYuuMqMp7nSl0eEZFWqQJVYmIihg0bBnt7exgYGEAul+d7ERGVp2b25tjzfieM7doAggD8eikOvotPI+RuitSlEREBKOUlv549eyI2Nhbvv/8+7OzsCjzN5+/vX24FSoGX/Ih01/nox5iyIwz3Hz8DAIzq7IRpPk2gMuQ/5oiqO727h8rMzAynT5+Gm5tbBZQkPQYqIt2WmZ2HL/ffwJbz9wEAjaxNsWiQG1rUsZC4MiKSkt7dQ+Xg4MBHmIlIMqZKA8zv3xLrRraFlakSkUmZ6LsiGMuCIpHHqWuISAKlClSLFy/Gxx9/jJiYmHIuh4io+F51scGRD73Qs4Ut8jQivjt6G2+sDkHUo0ypSyOiaqZUl/xq1qyJp0+fIi8vD8bGxjA0NMy3/vHjx+VWoBR4yY9Iv4iiiD1hD/HZnj+R8TwPKkMZPunVFEM96nPqGqJqRMrfb4PSbLR48eJyLoOIqPQEQUDf1nXQ3skS0369iuA7KZi15zqO3kjE1wNaws7CSOoSiaiKK/PAnlURz1AR6S+NRsTmc/cw/2AEnudqYKYywDz/FvB3s+f8okRVnF485Zeenq4t7sXo6EXR9xDCQEWk/+4+ykTgtjBcjUsDAPi52uGLvi1Q00QhcWVEVFH0IlDJ5XLEx8fD2toaMpms0H/piaIIQRCgVqvLvdDKxEBFVDXkqTVYceIulh2PRJ5GRG0zJb5+oyW6uVhLXRoRVQC9uIfq+PHjsLS0BACcOHGiwgoiIiovBnIZPvBuhG4utRG4/SruJGUiYMMFDGlfDzP9msJEWarbSImICuA9VIXgGSqiqud5rhpfH7qFdcHRAIB6lsZYOLAV2jpaSlwZEZUXvbjk92+pqak4f/48kpKSoNHkH0hv+PDh5VKcVBioiKqus3eTMW3HNTxIfQZBAMZ6NcSHrzWC0oBT1xDpO70LVL///jvefvttZGZmwtzcPN/9VIIgcBwqItJp6c9zMff3G/j1UhwAwMXWDIsGuaGpHf+8E+kzvQtUjRs3Rq9evfC///0PxsbGFVGXpBioiKqHQ38m4JPfwvE4KweGcgGBrzXBGK8GkHMwUCK9pHeBysTEBOHh4WjQoEFF1CQ5Biqi6uNRRjZm7ArHsYhEAEDb+jXx3cBWqF/LROLKiKik9G5yZB8fH1y8eLG8ayEiqnS1zZRYO9wdXw9oCVOlAS7ee4KeS07jl9BYTgJPRMVWqmeG/fz8MG3aNNy4cQOurq4F5vLr06dPuRRHRFQZBEHAwLYO8GxQC1N3XEVo9GN88ls4jt5IwII3WsLaXCV1iUSk40p1yU8mK/rEFgf2JCJ9ptGIWBccja8P30JOngY1jA3xZV9X+LW0k7o0InoJvbvkp9Foinzpe5gioupNJhPwbpcG2DexM5rbmyP1aS4m/HIZk7deQdrTXKnLIyIdVapARURU1TW2McNv4zth4qvOkAnA7rCH8Fl8CqcjH0ldGhHpoGJf8lu6dCnGjBkDlUqFpUuX/mfbSZMmlUtxUuElPyL6p8uxTzBl+1VEJ2cBAEZ41sfHPZvCSMHBQIl0iV4Mm+Dk5ISLFy+iVq1acHJyKrpDQUBUVFS5FSgFBioi+renOXn46uBNbAq5BwBoYGWC7wa2Qut6NSWujIhe0ItAVZ0wUBFRUU7dfoTpv15DQvpzyGUCJrzSEBO7N4KhnHdQEElN725KJyKqrrwa18bhyV7wd7OHWiNi6fE76LcyGJGJGVKXRkQSKvUZqri4OOzduxexsbHIycnJt27hwoXlUpxUeIaKiIpj37WHmLn7T6Q+zYXCQIbpPk3wTicnyDh1DZEkpPz9LtXAnkFBQejTpw8aNGiAmzdvokWLFoiJiYEoimjTpk1510hEpJNeb2mPdo6W+GjnNZy89Qhf7I/AsYhEfDOgFRwsq948p0RUtFJd8psxYwamTp2K8PBwqFQq7Ny5E/fv30fXrl3x5ptvlneNREQ6y8ZchfUj2+HLfi1gZCjHuajH6LnkNHZcvM+pa4iqkVIFqoiICAwfPhwAYGBggGfPnsHU1BRz587FggULStzfihUr4OjoCJVKBQ8PD5w/f75Y223duhWCIKBv3775louiiFmzZsHOzg5GRkbw9vZGZGRkiesiIioOQRDwtkd9HPygC9zr10Rmdh6m/XoNYzdfQnJmttTlEVElKFWgMjEx0d43ZWdnh7t372rXJScnl6ivbdu2ITAwELNnz8bly5fRqlUr+Pj4ICkp6T+3i4mJwdSpU9GlS5cC677++mssXboUq1evRmhoKExMTODj44Pnz5+XqDYiopJwtDLB9rGemO7bBIZyAUduJMJ38SkcuZ4gdWlEVMFKFag6dOiAM2fOAAB69eqFKVOm4Msvv8Q777yDDh06lKivhQsXYvTo0QgICECzZs2wevVqGBsbY926dUVuo1ar8fbbb2POnDlo0KBBvnWiKGLx4sWYOXMm/P390bJlS2zatAkPHz7E7t27S7yvREQlIZcJGP+KM3ZP6IQmNmZIzszBmM2XMG3HVWQ859Q1RFVVqQLVwoUL4eHhAQCYM2cOunfvjm3btsHR0RE//vhjsfvJycnBpUuX4O3t/XdBMhm8vb0REhJS5HZz586FtbU1Ro0aVWBddHQ0EhIS8vVpYWEBDw+PIvvMzs5Genp6vhcRUVk0t7fA3omdMLZrAwgCsONSHHwXn8a5qBSpSyOiClDip/zUajXi4uLQsmVLAH9d/lu9enWpPjw5ORlqtRo2Njb5ltvY2ODmzZuFbnPmzBn8+OOPCAsLK3R9QkKCto9/9/li3b/Nnz8fc+bMKWH1RET/TWkgx4yeTdHdxQZTdoTh/uNnGLL2HN7t7IQpPZpAZcipa4iqihKfoZLL5ejRoweePHlSEfX8p4yMDAwbNgxr166FlZVVufU7Y8YMpKWlaV/3798vt76JiNo7WeLgB14Y3M4BogisPR2N3svO4M8HaVKXRkTlpFTjULVo0QJRUVH/OadfcVhZWUEulyMxMTHf8sTERNja2hZof/fuXcTExKB3797aZRqNBsBfTxveunVLu11iYiLs7Ozy9enm5lZoHUqlEkqlskz7QkT0X0yVBvjqjZZ4rZkNPtoZjsikTPRdEYzJ3o3wXteGMODUNUR6rVR/gr/44gtMnToV+/btQ3x8fKnvP1IoFHB3d0dQUJB2mUajQVBQEDw9PQu0d3FxQXh4OMLCwrSvPn36oFu3bggLC4ODgwOcnJxga2ubr8/09HSEhoYW2icRUWXq3tQGhyd3gW9zW+RpRHx75DbeXBOC6OQsqUsjojIo1dQzMtnfOUwQ/p5iQRRFCIIAtVpd7L62bduGESNGYM2aNWjfvj0WL16M7du34+bNm7CxscHw4cNRp04dzJ8/v9DtR44cidTU1HxP8C1YsABfffUVNm7cCCcnJ3z22We4du0abty4AZVK9dKaOPUMEVU0URTx25UHmL3nOjKy82BkKMcnvVwwtEP9fH+vElHx6d3UM+vXr4eDgwPk8vw3VGo0GsTGxpaor0GDBuHRo0eYNWsWEhIS4ObmhkOHDmlvKo+Njc0X4Ipj+vTpyMrKwpgxY5CamorOnTvj0KFDxQpTRESVQRAE9G9TFx4NamHajqs4ezcFn+25jqMRSfj6jZawteDfV0T6pFRnqORyOeLj42FtbZ1veUpKCqytrUt0hkoX8QwVEVUmjUbExpAYfHXwJrLzNLAwMsS8vi3Qp5W91KUR6RUpf79LdQ/Vi0t7/5aZmcmzQEREJSSTCQjo5IT9kzrDtY4F0p7lYtKWK5i45QpSn+ZIXR4RFUOJLvkFBgYC+OtU9WeffQZj479nU1er1QgNDS3ySToiIvpvztZm2DW+I5Yfv4PlJ+7g96sPERqVgq8HtMQrTaxf3gERSaZEgerKlSsA/jpDFR4eDoVCoV2nUCjQqlUrTJ06tXwrJCKqRgzlMnz4WmO86mKND7eHIepRFkauv4ChHerhk15NYawo1a2vRFTBSnUPVUBAAJYsWVJl7y/iPVREpAue5aix4NBNbDgbAwBwrGWM7wa6wb1+TWkLI9JRUv5+lypQVXUMVESkS85EJmPar1cRn/YcMgEY90pDfNC9MRQGHAyU6J/07qZ0IiKqPJ0bWeHQZC/0a10HGhFYceIu+q0Mxu3EDKlLI6L/x0BFRKQHLIwMsWiQG1a+3QY1jQ1x/WE6Xl92BmtPRUGt4YUGIqkxUBER6ZFernY4PNkL3ZrURk6eBl8eiMCQtedw//FTqUsjqtYYqIiI9Iy1uQrrRrbD/P6uMFbIcT76MXouOY3tF++Dt8USSYOBiohIDwmCgCHt6+HQB15oW78mMrPzMP3Xaxi96RIeZWRLXR5RtcNARUSkx+rVMsa2sZ74yNcFhnIBxyIS4bv4FA5fT5C6NKJqhYGKiEjPyWUCxr3SEHvf7wwXWzOkZOVg7OZLmLL9KtKf50pdHlG1wEBFRFRFNLUzx573O+G9rg0hCMDOy3Houfg0Qu6mSF0aUZXHQEVEVIUoDeT4uKcLto/1RD1LYzxIfYYha89h3r4beJ6rlro8oiqLgYqIqApq52iJAx90wZD29QAAP56JRu9lZ/DngzSJKyOqmhioiIiqKFOlAeb3d8W6kW1hZapEZFIm+q4IxrKgSOSpNVKXR1SlMFAREVVxr7rY4MiHXujlaos8jYjvjt7GgNUhiHqUKXVpRFUGAxURUTVgaaLAirfaYNGgVjBTGSDsfip6LT2NTSExHAyUqBwwUBERVROCIKBf67o4PNkLnZxr4XmuBrP2XMfwdeeRkPZc6vKI9BoDFRFRNWNfwwib3/HA572bQWkgw+nIZPRY9Af2hD3g2SqiUmKgIiKqhmQyASM7OWH/pC5oVdcC6c/z8MHWMLy/5QqeZOVIXR6R3mGgIiKqxpytTfHruI740Lsx5DIB+6/Fw2fxKZy4lSR1aUR6hYGKiKiaM5TL8IF3I/w2viMa1jZBUkY2AtZfwKe/hSMrO0/q8oj0AgMVEREBAFrWrYH9k7ogoJMjAODn0Fj0Wnoal+49lrYwIj3AQEVERFoqQzlm926OX971gL2FCvdSnuLN1SH4+tBN5ORxMFCiojBQERFRAR2drXBwshf6t6kDjQisPHkX/iuCcSshQ+rSiHQSAxURERXKwsgQCwe6YdXbbVDT2BAR8enovewMvj91F2oNh1cg+icGKiIi+k89Xe1w+EMvdHexRo5ag/8duIkh35/D/cdPpS6NSGcwUBER0UtZm6nww4i2WPCGK0wUcpyPeQzfxaew7UIsBwMlAgMVEREVkyAIGNSuHg5+4IV2jjWRlaPGRzvDMXrTRTzKyJa6PCJJMVAREVGJ1KtljK1jPDGjpwsUchmORSTBZ/EpHPozXurSiCTDQEVERCUmlwkY27Uh9k7shKZ25niclYP3frqMwO1hSH+eK3V5RJWOgYqIiErNxdYcuyd0xPhXGkImALsuP4DvolM4eydZ6tKIKhUDFRERlYnSQI7pvi7YPtYT9SyN8TDtOd76IRRzfr+O57lqqcsjqhQMVEREVC7aOlri4Add8JZHPQDA+uAYvL7sDMLj0iSujKjiMVAREVG5MVEa4H/9XLE+oB1qmylxJykT/VYGY8mxSOSpOXUNVV0MVEREVO66NbHGkcle8HO1Q55GxKJjt/HG6hDcfZQpdWlEFYKBioiIKkRNEwWWv9UaSwa7wVxlgKv3U+G39DQ2no2BhlPXUBXDQEVERBVGEAT4u9XB4Q+90KWRFZ7najB773UMX3ce8WnPpC6PqNwwUBERUYWzszDCxoD2mOvfHCpDGc7cSUaPRaew+8oDTl1DVQIDFRERVQqZTMBwT0fsn9QFrRxqION5HiZvC8OEXy7jSVaO1OURlQkDFRERVaqGtU2x8z1PBL7WGAYyAQfCE9Bj8SmcuJkkdWlEpcZARURElc5ALsOk7o3w2/hOcLY2xaOMbARsuIAZu8KRlZ0ndXlEJcZARUREknGta4F9EztjVGcnAMCW87HoueQ0LsY8lrgyopJhoCIiIkmpDOX47PVm+GW0B+rUMELs46cYuCYECw7dRHYep64h/cBARUREOqFjQyscnNwFb7SpC40IrDp5F/7Lg3EzIV3q0oheioGKiIh0hrnKEN8NbIXVQ91haaLAzYQM9FkWjNV/3IWag4GSDmOgIiIinePbwhaHJ3vBu6k1ctQafHXwJgZ/H4LYlKdSl0ZUKAYqIiLSSbXNlFg7vC2+fqMlTBRyXIh5gp5LTmHr+VgOBko6h4GKiIh0liAIGNjOAYcme6G9kyWyctT4eFc43t14EUkZz6Uuj0iLgYqIiHSeg6UxtozugE97NYVCLkPQzST4LDqFg+HxUpdGBICBioiI9IRcJmC0VwP8PrEzmtmZ48nTXIz7+TICt4Uh7Vmu1OVRNcdARUREeqWJrRl2T+iECd0aQiYAu648QM/FpxB8J1nq0qgaY6AiIiK9ozCQYZqPC3a81xGOtYzxMO053v4hFJ/vvY7nuRwMlCofAxUREekt9/o1ceCDLhjaoR4AYMPZGPgtPY2r91OlLYyqHZ0IVCtWrICjoyNUKhU8PDxw/vz5Itvu2rULbdu2RY0aNWBiYgI3Nzds3rw5X5uRI0dCEIR8L19f34reDSIikoCxwgBf9HXFhoB2sDZT4u6jLPRfdRaLj91GrlojdXlUTUgeqLZt24bAwEDMnj0bly9fRqtWreDj44OkpKRC21taWuLTTz9FSEgIrl27hoCAAAQEBODw4cP52vn6+iI+Pl772rJlS2XsDhERSeSVJtY48qEXXm9pB7VGxOJjkRiw6izuJGVKXRpVA4Io8ehoHh4eaNeuHZYvXw4A0Gg0cHBwwMSJE/Hxxx8Xq482bdrAz88P8+bNA/DXGarU1FTs3r27VDWlp6fDwsICaWlpMDc3L1UfREQknb1XH2Lmb+FIf54HpYEMH/d0wQhPR8hkgtSlUQWS8vdb0jNUOTk5uHTpEry9vbXLZDIZvL29ERIS8tLtRVFEUFAQbt26BS8vr3zrTp48CWtrazRp0gTjxo1DSkpKkf1kZ2cjPT0934uIiPRXn1b2OPJhV3RpZIXsPA3m/H4Dw9aF4mHqM6lLoypK0kCVnJwMtVoNGxubfMttbGyQkJBQ5HZpaWkwNTWFQqGAn58fli1bhtdee0273tfXF5s2bUJQUBAWLFiAP/74Az179oRaXfiTH/Pnz4eFhYX25eDgUD47SEREkrG1UGHTO+0xz785VIYyBN9Jgc/iU/jtShynrqFyZyB1AaVhZmaGsLAwZGZmIigoCIGBgWjQoAFeeeUVAMDgwYO1bV1dXdGyZUs0bNgQJ0+eRPfu3Qv0N2PGDAQGBmrfp6enM1QREVUBgiBgmKcjOjlbIXD7VYTdT8WH267iyPVEfNnPFZYmCqlLpCpC0jNUVlZWkMvlSExMzLc8MTERtra2RW4nk8ng7OwMNzc3TJkyBQMGDMD8+fOLbN+gQQNYWVnhzp07ha5XKpUwNzfP9yIioqqjQW1T/PqeJ6b2aAwDmYCDfyagx6JTOH4z8eUbExWDpIFKoVDA3d0dQUFB2mUajQZBQUHw9PQsdj8ajQbZ2dlFro+Li0NKSgrs7OzKVC8REekvA7kM77/aCLsndEIja1MkZ2bjnQ0XMWPXNWRm50ldHuk5yYdNCAwMxNq1a7Fx40ZERERg3LhxyMrKQkBAAABg+PDhmDFjhrb9/PnzcfToUURFRSEiIgLfffcdNm/ejKFDhwIAMjMzMW3aNJw7dw4xMTEICgqCv78/nJ2d4ePjI8k+EhGR7mhRxwK/T+yMdzs7QRCALefvo+eSU7gQ81jq0kiPSX4P1aBBg/Do0SPMmjULCQkJcHNzw6FDh7Q3qsfGxkIm+zv3ZWVlYfz48YiLi4ORkRFcXFzw008/YdCgQQAAuVyOa9euYePGjUhNTYW9vT169OiBefPmQalUSrKPRESkW1SGcsx8vRm6N7XB1B1Xcf/xMwxcE4IxXg0Q+FpjKA3kUpdIekbycah0EcehIiKqPjKe52LO7zfw66U4AICLrRkWDnRDM3v+/a9vqu04VERERFIzUxni2zdbYc0wd9QyUeBmQgb8V5zBypN3oNbwnAMVDwMVERERAJ/mtjj8oRdea2aDXLWIrw/dwqA1IbiXkiV1aaQHGKiIiIj+n5WpEt8Pc8c3A1rCVGmAi/eeoOeS0/glNJaDgdJ/YqAiIiL6B0EQ8GZbBxz8oAs8nCzxNEeNT34LxzsbLiAp/bnU5ZGOYqAiIiIqhIOlMbaM7oCZfk2hMJDhxK1H8Fl8CgfC46UujXQQAxUREVERZDIB73ZpgH0TO6O5vTmePM3F+J8vY/LWK0h7lit1eaRDGKiIiIheorGNGX4b3wkTX3WGTAB2hz2E7+JTOBOZLHVppCMYqIiIiIpBYSDDlB5N8Ou4jnCyMkF82nMM/TEUn++9jmc5aqnLI4kxUBEREZVAm3o1sX9SZwzrUB8AsOFsDPyWncbV+6nSFkaSYqAiIiIqIWOFAeb1bYGN77SHjbkSUY+y0H/VWSw8ehu5ao3U5ZEEGKiIiIhKqWvj2jg82Qt9WtlDrRGxNCgS/VeexZ2kDKlLo0rGQEVERFQGNYwVWDqkNZYNaQ0LI0OEP0iD39IzWHcmGhpOXVNtMFARERGVg96t7HHkQy94Na6N7DwN5u67gaE/huJB6jOpS6NKwEBFRERUTmzMVdgY0A5f9G0BI0M5zt5Nge+iU9h1OY5T11RxDFRERETlSBAEDO1QHwc+6ILW9WogIzsPgduvYtxPl5GSmS11eVRBGKiIiIgqgJOVCXaM9cQ0nyYwkAk4dD0BPotPIygiUerSqAIwUBEREVUQA7kME7o5Y/eETmhsY4rkzGyM2ngRH++8hszsPKnLo3LEQEVERFTBWtSxwN73O2OMVwMIArD1wn34Lj6F89GPpS6NygkDFRERUSVQGcrxSa+m2DK6A+rUMELck2cY9H0I5h+IQHYep67RdwxURERElahDg1o4NLkLBrV1gCgCa05Foc+yYFx/mCZ1aVQGDFRERESVzExliAUDWmLt8LawMlXgVmIG+q4IxooTd6DmYKB6iYGKiIhIIq81s8HhyV7o0cwGuWoR3xy+hYFrQhCTnCV1aVRCDFREREQSqmWqxJph7vj2zVYwVRrg0r0n6LX0NH4OvcfBQPUIAxUREZHEBEHAAPe6ODS5Czwb1MLTHDU+/e1PBGy4gKT051KXR8XAQEVERKQj6tY0xs/veuCz15tBYSDDyVuP0GPxKey79lDq0uglGKiIiIh0iEwmYFRnJ+yf2Bkt6pgj9Wku3v/lCj7YegVpT3OlLo+KwEBFRESkgxrZmOG38Z0w6VVnyGUC9oQ9hM/iUzgd+Ujq0qgQDFREREQ6ylAuQ2CPJvj1PU80sDJBQvpzDPvxPGbt+RPPcjgYqC5hoCIiItJxrevVxP5JXTDCsz4AYFPIPfgtPY0rsU8kroxeYKAiIiLSA0YKOeb4t8Cmd9rD1lyFqOQsDFgdgoVHbiFXrZG6vGqPgYqIiEiPeDWujcOTveDvZg+1RsTS43fQb2UwIhMzpC6tWmOgIiIi0jMWxoZYMrg1lr/VGjWMDfHng3T4LTuDH05HQcOpayTBQEVERKSnXm9pj8OTvfBKk9rIydPgi/0ReOuHc4h78lTq0qodBioiIiI9ZmOuwvqR7fBlvxYwMpTjXNRj9Fx8Gr9eiuPUNZWIgYqIiEjPCYKAtz3q4+AHXeBevyYysvMwdcdVvPfTJaRkZktdXrXAQEVERFRFOFqZYPtYT0z3bQJDuYDD1xPhs/gUjt5IlLq0Ko+BioiIqAqRywSMf8UZuyd0QhMbMyRn5mD0pouY/utVZDzn1DUVhYGKiIioCmpub4G9EzthrFcDCAKw/WIcei45jdCoFKlLq5IYqIiIiKoopYEcM3o1xbYxnqhb0whxT55h8Npz+HL/DTzP5dQ15YmBioiIqIpr72SJQ5O9MLidA0QRWHs6Gn2Wn8GfD9KkLq3KYKAiIiKqBkyVBvjqjZb4YXhbWJkqcDsxE/1WBmPFiTvI49Q1ZcZARUREVI14N7PB4cle8G1ui1y1iG8O38LANSGISc6SujS9xkBFRERUzdQyVWLV0DZYOLAVzJQGuBybip5LTuOnc/c4GGgpMVARERFVQ4IgoH+bujj0oRc6NqyFZ7lqzNz9J0asv4DE9OdSl6d3GKiIiIiqsTo1jPDTKA/Mer0ZlAYynLr9CD0WncLvVx9KXZpeYaAiIiKq5mQyAe90dsL+SZ3hWscCac9yMXHLFUzacgWpT3OkLk8vMFARERERAMDZ2gy7xnfEB90bQS4TsPfqQ/gsPoVTtx9JXZrOY6AiIiIiLUO5DB++1hg7x3VEAysTJKZnY/i68/hs9594mpMndXk6i4GKiIiICnBzqIH9k7pgZEdHAMDmc/fgt/QMLsc+kbYwHcVARURERIUyUsjxeZ/m+GmUB+wsVIhOzsKAVWfx3ZFbyMnjYKD/xEBFRERE/6lzIyscmuyFfq3rQCMCy47fQb+VwbidmCF1aTqDgYqIiIheysLIEIsGuWHl221Q09gQ1x+m4/VlZ/DD6ShoNBwMlIGKiIiIiq2Xqx0OT/ZCtya1kZOnwRf7IzBk7Tncf/xU6tIkxUBFREREJWJtrsK6ke0wv78rjBVyhEY/Rs8lp7H94v1qO3WNTgSqFStWwNHRESqVCh4eHjh//nyRbXft2oW2bduiRo0aMDExgZubGzZv3pyvjSiKmDVrFuzs7GBkZARvb29ERkZW9G4QERFVG4IgYEj7ejj4QRe0rV8Tmdl5mP7rNYzZfAnJmdlSl1fpJA9U27ZtQ2BgIGbPno3Lly+jVatW8PHxQVJSUqHtLS0t8emnnyIkJATXrl1DQEAAAgICcPjwYW2br7/+GkuXLsXq1asRGhoKExMT+Pj44Plzzk1ERERUnurXMsG2sZ74yNcFhnIBR28kwmfRKRy5niB1aZVKECU+N+fh4YF27dph+fLlAACNRgMHBwdMnDgRH3/8cbH6aNOmDfz8/DBv3jyIogh7e3tMmTIFU6dOBQCkpaXBxsYGGzZswODBg1/aX3p6OiwsLJCWlgZzc/PS7xwREVE1EhGfjg+3heFmwl9P/w1wr4vZvZvBTGVYKZ8v5e+3pGeocnJycOnSJXh7e2uXyWQyeHt7IyQk5KXbi6KIoKAg3Lp1C15eXgCA6OhoJCQk5OvTwsICHh4exeqTiIiISqepnTn2vN8J73VtCEEAfr0UB9/FpxFyN0Xq0iqcpIEqOTkZarUaNjY2+Zbb2NggIaHoU4VpaWkwNTWFQqGAn58fli1bhtdeew0AtNuVpM/s7Gykp6fnexEREVHJKQ3k+LinC7aP9YSDpREepD7DWz+cwxf7buB5rlrq8iqM5PdQlYaZmRnCwsJw4cIFfPnllwgMDMTJkydL3d/8+fNhYWGhfTk4OJRfsURERNVQO0dLHPzAC0PaO0AUgR/ORKP3sjP480Ga1KVVCEkDlZWVFeRyORITE/MtT0xMhK2tbZHbyWQyODs7w83NDVOmTMGAAQMwf/58ANBuV5I+Z8yYgbS0NO3r/v37ZdktIiIiAmCqNMD8/i2xbmRbWJkqEZmUib4rgrEsKBJ56qo1dY2kgUqhUMDd3R1BQUHaZRqNBkFBQfD09Cx2PxqNBtnZfz2i6eTkBFtb23x9pqenIzQ0tMg+lUolzM3N872IiIiofLzqYoMjH3qhZwtb5GlEfHf0NiZuuSJ1WeXKQOoCAgMDMWLECLRt2xbt27fH4sWLkZWVhYCAAADA8OHDUadOHe0ZqPnz56Nt27Zo2LAhsrOzceDAAWzevBmrVq0C8Ne4GJMnT8YXX3yBRo0awcnJCZ999hns7e3Rt29fqXaTiIioWrM0UWDl222wO+wBZu+5jrc86kldUrmSPFANGjQIjx49wqxZs5CQkAA3NzccOnRIe1N5bGwsZLK/T6RlZWVh/PjxiIuLg5GREVxcXPDTTz9h0KBB2jbTp09HVlYWxowZg9TUVHTu3BmHDh2CSqWq9P0jIiKivwiCgH6t66J7UxuYV9JQCpVF8nGodBHHoSIiItI/1XYcKiIiIqKqgIGKiIiIqIwYqIiIiIjKiIGKiIiIqIwYqIiIiIjKiIGKiIiIqIwYqIiIiIjKiIGKiIiIqIwYqIiIiIjKiIGKiIiIqIwYqIiIiIjKiIGKiIiIqIwYqIiIiIjKyEDqAnSRKIoA/pq1moiIiPTDi9/tF7/jlYmBqhAZGRkAAAcHB4krISIiopLKyMiAhYVFpX6mIEoR43ScRqPBw4cPYWZmBkEQpC6nVNLT0+Hg4ID79+/D3Nxc6nKqJB7jisXjW/F4jCsej3HF++cxNjMzQ0ZGBuzt7SGTVe5dTTxDVQiZTIa6detKXUa5MDc35x/iCsZjXLF4fCsej3HF4zGueC+OcWWfmXqBN6UTERERlREDFREREVEZMVBVUUqlErNnz4ZSqZS6lCqLx7hi8fhWPB7jisdjXPF05RjzpnQiIiKiMuIZKiIiIqIyYqAiIiIiKiMGKiIiIqIyYqAiIiIiKiMGKh2xYsUKODo6QqVSwcPDA+fPn//P9jt27ICLiwtUKhVcXV1x4MCBfOtFUcSsWbNgZ2cHIyMjeHt7IzIyMl+bx48f4+2334a5uTlq1KiBUaNGITMzM1+b7du3w83NDcbGxqhfvz6++eab8tlhCUhxjL/88kt07NgRxsbGqFGjRqGfExsbCz8/PxgbG8Pa2hrTpk1DXl5emfZVCrp6fCdNmgR3d3colUq4ubmVZRclp4vH+OrVqxgyZAgcHBxgZGSEpk2bYsmSJWXeV6no4jFOSUmBr68v7O3toVQq4eDggPfff18v55vVxeP7TykpKahbty4EQUBqamrJdk4kyW3dulVUKBTiunXrxOvXr4ujR48Wa9SoISYmJhbaPjg4WJTL5eLXX38t3rhxQ5w5c6ZoaGgohoeHa9t89dVXooWFhbh7927x6tWrYp8+fUQnJyfx2bNn2ja+vr5iq1atxHPnzomnT58WnZ2dxSFDhmjXHzhwQDQwMBBXrVol3r17V9y3b59oZ2cnLlu2rOIORgWR6hjPmjVLXLhwoRgYGChaWFgU+Jy8vDyxRYsWore3t3jlyhXxwIEDopWVlThjxoxyPwYVSVePryiK4sSJE8Xly5eLw4YNE1u1alWeu12pdPUY//jjj+KkSZPEkydPinfv3hU3b94sGhkZ8e+J/1cex/jx48fiypUrxQsXLogxMTHisWPHxCZNmuT7+1of6Orx/Sd/f3+xZ8+eIgDxyZMnJdo/Biod0L59e3HChAna92q1WrS3txfnz59faPuBAweKfn5++ZZ5eHiIY8eOFUVRFDUajWhrayt+88032vWpqamiUqkUt2zZIoqiKN64cUMEIF64cEHb5uDBg6IgCOKDBw9EURTFIUOGiAMGDMj3OUuXLhXr1q0rajSaMuxx5ZPiGP/T+vXrC/2DfODAAVEmk4kJCQnaZatWrRLNzc3F7OzsEu2jlHT1+P7T7Nmz9TpQ6cMxfmH8+PFit27ditVWl+jTMV6yZIlYt27dYrXVFbp+fFeuXCl27dpVDAoKKlWg4iU/ieXk5ODSpUvw9vbWLpPJZPD29kZISEih24SEhORrDwA+Pj7a9tHR0UhISMjXxsLCAh4eHto2ISEhqFGjBtq2batt4+3tDZlMhtDQUABAdnY2VCpVvs8xMjJCXFwc7t27V4a9rlxSHePiCAkJgaurK2xsbPJ9Tnp6Oq5fv17sfqSky8e3qtC3Y5yWlgZLS8sy9VHZ9OkYP3z4ELt27ULXrl1L3Udl0/Xje+PGDcydOxebNm0q9aTKDFQSS05OhlqtzveDCgA2NjZISEgodJuEhIT/bP/if1/WxtraOt96AwMDWFpaatv4+Phg165dCAoKgkajwe3bt/Hdd98BAOLj40uzu5KQ6hgXR1Gf88/P0HW6fHyrCn06xmfPnsW2bdswZsyYUvchBX04xkOGDIGxsTHq1KkDc3Nz/PDDDyXuQyq6fHyzs7MxZMgQfPPNN6hXr16xt/s3Bioq0ujRo/H+++/j9ddfh0KhQIcOHTB48GAAKHWCJ6Kq688//4S/vz9mz56NHj16SF1OlbNo0SJcvnwZe/bswd27dxEYGCh1SVXCjBkz0LRpUwwdOrRM/fBXUWJWVlaQy+VITEzMtzwxMRG2traFbmNra/uf7V/878vaJCUl5Vufl5eHx48fa9sIgoAFCxYgMzMT9+7dQ0JCAtq3bw8AaNCgQWl2VxJSHePiKOpz/vkZuk6Xj29VoQ/H+MaNG+jevTvGjBmDmTNnlnh7qenDMba1tYWLiwv69OmDNWvWYNWqVXpztUCXj+/x48exY8cOGBgYwMDAAN27d9fWPHv27GL3w0AlMYVCAXd3dwQFBWmXaTQaBAUFwdPTs9BtPD0987UHgKNHj2rbOzk5wdbWNl+b9PR0hIaGatt4enoiNTUVly5d0rY5fvw4NBoNPDw88vUtl8tRp04dKBQKbNmyBZ6enqhdu3bZdrwSSXWMi8PT0xPh4eH5wu3Ro0dhbm6OZs2aFbsfKeny8a0qdP0YX79+Hd26dcOIESPw5ZdflmhbXaHrx/jfNBoNgL8uV+kDXT6+O3fuxNWrVxEWFoawsDDtpdTTp09jwoQJxe6HT/npgK1bt4pKpVLcsGGDeOPGDXHMmDFijRo1tE9+DRs2TPz444+17YODg0UDAwPx22+/FSMiIsTZs2cX+ihpjRo1xD179ojXrl0T/f39Cx02oXXr1mJoaKh45swZsVGjRvkew3306JG4atUqMSIiQrxy5Yo4adIkUaVSiaGhoZVwVMqXVMf43r174pUrV8Q5c+aIpqam4pUrV8QrV66IGRkZoij+PWxCjx49xLCwMPHQoUNi7dq19XLYBF08vqIoipGRkeKVK1fEsWPHio0bN9a20aenKEVRd49xeHi4WLt2bXHo0KFifHy89pWUlFRJR6b86Oox3r9/v7hu3ToxPDxcjI6OFvft2yc2bdpU7NSpUyUdmfKhq8f3306cOMFhE/TZsmXLxHr16okKhUJs3769eO7cOe26rl27iiNGjMjXfvv27WLjxo1FhUIhNm/eXNy/f3++9RqNRvzss89EGxsbUalUit27dxdv3bqVr01KSoo4ZMgQ0dTUVDQ3NxcDAgLy/Qf26NEjsUOHDqKJiYlobGwsdu/ePV9d+kaKYzxixAgRQIHXiRMntG1iYmLEnj17ikZGRqKVlZU4ZcoUMTc3t9z3v6Lp6vHt2rVroW2io6PL+xBUOF08xrNnzy50ff369SviEFQ4XTzGx48fFz09PUULCwtRpVKJjRo1Ej/66KMS/+DrAl08vv9W2kAliKIoFv98FhERERH9G++hIiIiIiojBioiIiKiMmKgIiIiIiojBioiIiKiMmKgIiIiIiojBioiIiKiMmKgIiIiIiojBioi0kmOjo5YvHhxsdufPHkSgiAgNTW1wmr6t1deeQWTJ0+utM8jIt1lIHUBRFR1vPLKK3BzcytRECrKhQsXYGJiUuz2HTt2RHx8PCwsLMr82UREJcVARUSVRhRFqNVqGBi8/K+ekk7ArVAoSjTDPBFReeIlPyIqFyNHjsQff/yBJUuWQBAECIKADRs2QBAEHDx4EO7u7lAqlThz5gzu3r0Lf39/2NjYwNTUFO3atcOxY8fy9ffvS36CIOCHH35Av379YGxsjEaNGmHv3r3a9f++5LdhwwbUqFEDhw8fRtOmTWFqagpfX1/Ex8drt8nLy8OkSZNQo0YN1KpVCx999BFGjBiBvn37luoYPHnyBMOHD0fNmjVhbGyMnj17IjIyUrv+3r176N27N2rWrAkTExM0b94cBw4c0G779ttvo3bt2jAyMkKjRo2wfv36UtVBRJWPgYqIysWSJUvg6emJ0aNHIz4+HvHx8XBwcAAAfPzxx/jqq68QERGBli1bIjMzE7169UJQUBCuXLkCX19f9O7dG7Gxsf/5GXPmzMHAgQNx7do19OrVC2+//TYeP35cZPunT5/i22+/xebNm3Hq1CnExsZi6tSp2vULFizAzz//jPXr1yM4OBjp6enYvXt3qY/ByJEjcfHiRezduxchISEQRRG9evVCbm4uAGDChAnIzs7GqVOnEB4ejgULFsDU1BQA8Nlnn+HGjRs4ePAgIiIisGrVKlhZWZW6FiKqZCWaSpmI6D907dpV/OCDD7TvX8zavnv37pdu27x5c3HZsmXa9/Xr1xcXLVqkfQ9AnDlzpvZ9ZmamCEA8ePBgvs96MUP8+vXrRQDinTt3tNusWLFCtLGx0b63sbERv/nmG+37vLw8sV69eqK/v3+J9/f27dsiADE4OFi7Pjk5WTQyMhK3b98uiqIourq6ip9//nmhffXu3VsMCAgo1ucSke7hGSoiqnBt27bN9z4zMxNTp05F06ZNUaNGDZiamiIiIuKlZ6hatmyp/f8mJiYwNzdHUlJSke2NjY3RsGFD7Xs7Oztt+7S0NCQmJqJ9+/ba9XK5HO7u7iXatxciIiJgYGAADw8P7bJatWqhSZMmiIiIAABMmjQJX3zxBTp16oTZs2fj2rVr2rbjxo3D1q1b4ebmhunTp+Ps2bOlqoOIpMFARUQV7t9P602dOhW//fYb/ve//+H06dMICwuDq6srcnJy/rMfQ0PDfO8FQYBGoylRe1EUS1h9+Xn33XcRFRWFYcOGITw8HG3btsWyZcsAAD179sS9e/fw4Ycf4uHDh+jevXu+y5NEpNsYqIio3CgUCqjV6pe2Cw4OxsiRI9GvXz+4urrC1tYWMTExFV/gP1hYWMDGxgYXLlzQLlOr1bh8+XKp+mvatCny8vIQGhqqXZaSkoJbt26hWbNm2mUODg547733sGvXLkyZMgVr167VrqtduzZGjBiBn376CYsXL8b3339fqlqIqPJx2AQiKjeOjo4IDQ1FTEwMTE1Nizx71KhRI+zatQu9e/eGIAj47LPP/vNMU0WZOHEi5s+fD2dnZ7i4uGDZsmV48uQJBEEocV+NGjWCv78/Ro8ejTVr1sDMzAwff/wx6tSpA39/fwDA5MmT0bNnTzRu3BhPnjzBiRMn0LRpUwDArFmz4O7ujubNmyM7Oxv79u3TriMi3cczVERUbqZOnQq5XI5mzZqhdu3aRd4TtXDhQtSsWRMdO3ZE79694ePjgzZt2lRytcBHH32EIUOGYPjw4fD09ISpqSl8fHygUqlK1d/69evh7u6O119/HZ6enhBFEQcOHNBeelSr1ZgwYQKaNm0KX19fNG7cGCtXrgTw19m9GTNmoGXLlvDy8oJcLsfWrVvLbV+JqGIJopQ3FBAR6RCNRoOmTZti4MCBmDdvntTlEJEe4SU/Iqq27t27hyNHjqBr167Izs7G8uXLER0djbfeekvq0ohIz/CSHxFVWzKZDBs2bEC7du3QqVMnhIeH49ixY2jatCliY2Nhampa5OtlQzwQUfXCS35ERIXIy8v7zycPHR0dizUnIRFVDwxURERERGXES35EREREZcRARURERFRGDFREREREZcRARURERFRGDFREREREZcRARURERFRGDFREREREZcRARURERFRG/wcygegutkD2qgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(training_loss, training_acc)\n",
    "plt.title('Training set representation')\n",
    "plt.xlabel('training_loss')\n",
    "plt.ylabel('training_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(testing_loss, testing_acc)\n",
    "plt.title('Testing set representation')\n",
    "plt.xlabel('testing_loss')\n",
    "plt.ylabel('testing_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that focal loss performance is also very impressive when gamma is set at 0.5: loss is generally around 0.009, and accuracy ranges from 30% to 60%, with most remaining around 50%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4\n",
    "**Now let's try using focal loss as a loss function and set gamma to 2:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_batch4(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one training batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to train.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated by the defined loss function loss_fn().\n",
    "    \"\"\"\n",
    "    \n",
    "    ##################### Write your answer here ##################\n",
    "    import torch\n",
    "    import torch.nn as nn\n",
    "\n",
    "    class FocalLoss(nn.Module):\n",
    "        def __init__(self, num_classes, gamma=2):\n",
    "            super(FocalLoss, self).__init__()\n",
    "            self.gamma = gamma\n",
    "            self.num_classes = num_classes\n",
    "\n",
    "        def forward(self, inputdata, target):\n",
    "            probs = torch.softmax(inputdata, dim=1)\n",
    "            targets = torch.nn.functional.one_hot(target, num_classes)\n",
    "            targets = targets.float()\n",
    "            focal_loss = -((1 - probs) ** self.gamma) * targets * torch.log(probs)\n",
    "            return focal_loss.mean()\n",
    "    \n",
    "    num_classes = 10    \n",
    "    output = model(image)\n",
    "    focal_loss = FocalLoss(num_classes, gamma=2)\n",
    "    loss = focal_loss(output, target)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_batch4(model, image, target):\n",
    "    \"\"\"\n",
    "    Perform one testing batch iteration.\n",
    "\n",
    "    Args:\n",
    "        model (torch.nn.Module): The machine learning model to evaluate.\n",
    "        image (torch.Tensor): Batch of input data (images).\n",
    "        target (torch.Tensor): Batch of target labels.\n",
    "\n",
    "    Returns:\n",
    "        torch.Tensor: Model output (predictions) for the batch.\n",
    "        torch.Tensor: Loss value calculated for the batch.\n",
    "    \"\"\"\n",
    "\n",
    "    ##################### Write your answer here ##################\n",
    "    import torch\n",
    "    import torch.nn as nn\n",
    "\n",
    "    class FocalLoss(nn.Module):\n",
    "        def __init__(self, num_classes, gamma=2):\n",
    "            super(FocalLoss, self).__init__()\n",
    "            self.gamma = gamma\n",
    "            self.num_classes = num_classes\n",
    "\n",
    "        def forward(self, inputdata, target):\n",
    "            probs = torch.softmax(inputdata, dim=1)\n",
    "            targets = torch.nn.functional.one_hot(target, num_classes)\n",
    "            targets = targets.float()\n",
    "            focal_loss = -((1 - probs) ** self.gamma) * targets * torch.log(probs)\n",
    "            return focal_loss.mean()\n",
    "    \n",
    "    num_classes = 10    \n",
    "    output = model(image)\n",
    "    focal_loss = FocalLoss(num_classes, gamma=2)\n",
    "    loss = focal_loss(output, target)\n",
    "    ###############################################################\n",
    "\n",
    "    return output, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/30 Train Loss: 0.0011 Acc: 0.3031\n",
      "Begin test......\n",
      "Test Loss: 0.0009 Acc: 0.3954\n",
      "Epoch: 2/30 Train Loss: 0.0009 Acc: 0.4040\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.4620\n",
      "Epoch: 3/30 Train Loss: 0.0008 Acc: 0.4350\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.4575\n",
      "Epoch: 4/30 Train Loss: 0.0008 Acc: 0.4567\n",
      "Begin test......\n",
      "Test Loss: 0.0008 Acc: 0.4686\n",
      "Epoch: 5/30 Train Loss: 0.0008 Acc: 0.4698\n",
      "Begin test......\n",
      "Test Loss: 0.0007 Acc: 0.5139\n",
      "Epoch: 6/30 Train Loss: 0.0007 Acc: 0.4957\n",
      "Begin test......\n",
      "Test Loss: 0.0007 Acc: 0.5265\n",
      "Epoch: 7/30 Train Loss: 0.0007 Acc: 0.5018\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5456\n",
      "Epoch: 8/30 Train Loss: 0.0007 Acc: 0.5043\n",
      "Begin test......\n",
      "Test Loss: 0.0007 Acc: 0.5393\n",
      "Epoch: 9/30 Train Loss: 0.0007 Acc: 0.5078\n",
      "Begin test......\n",
      "Test Loss: 0.0007 Acc: 0.5418\n",
      "Epoch: 10/30 Train Loss: 0.0007 Acc: 0.5133\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5557\n",
      "Epoch: 11/30 Train Loss: 0.0007 Acc: 0.5270\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5611\n",
      "Epoch: 12/30 Train Loss: 0.0007 Acc: 0.5265\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5642\n",
      "Epoch: 13/30 Train Loss: 0.0007 Acc: 0.5280\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5637\n",
      "Epoch: 14/30 Train Loss: 0.0007 Acc: 0.5313\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5690\n",
      "Epoch: 15/30 Train Loss: 0.0007 Acc: 0.5320\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5730\n",
      "Epoch: 16/30 Train Loss: 0.0006 Acc: 0.5407\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5715\n",
      "Epoch: 17/30 Train Loss: 0.0006 Acc: 0.5402\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5739\n",
      "Epoch: 18/30 Train Loss: 0.0006 Acc: 0.5396\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5760\n",
      "Epoch: 19/30 Train Loss: 0.0006 Acc: 0.5426\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5728\n",
      "Epoch: 20/30 Train Loss: 0.0006 Acc: 0.5386\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5741\n",
      "Epoch: 21/30 Train Loss: 0.0006 Acc: 0.5480\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5727\n",
      "Epoch: 22/30 Train Loss: 0.0006 Acc: 0.5483\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5783\n",
      "Epoch: 23/30 Train Loss: 0.0006 Acc: 0.5480\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5785\n",
      "Epoch: 24/30 Train Loss: 0.0006 Acc: 0.5469\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5779\n",
      "Epoch: 25/30 Train Loss: 0.0006 Acc: 0.5474\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5764\n",
      "Epoch: 26/30 Train Loss: 0.0006 Acc: 0.5501\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5774\n",
      "Epoch: 27/30 Train Loss: 0.0006 Acc: 0.5497\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5797\n",
      "Epoch: 28/30 Train Loss: 0.0006 Acc: 0.5504\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5796\n",
      "Epoch: 29/30 Train Loss: 0.0006 Acc: 0.5531\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5828\n",
      "Epoch: 30/30 Train Loss: 0.0006 Acc: 0.5490\n",
      "Begin test......\n",
      "Test Loss: 0.0006 Acc: 0.5808\n"
     ]
    }
   ],
   "source": [
    "model = ConvNet()\n",
    "model.to(device)\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)\n",
    "\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=STEP, gamma=GAMMA)\n",
    "\n",
    "training_loss = []\n",
    "training_acc = []\n",
    "testing_loss = []\n",
    "testing_acc = []\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    model.train()\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "    ##########################\n",
    "    ### Training\n",
    "    ##########################\n",
    "\n",
    "    running_cls_loss = 0.0\n",
    "    running_cls_corrects = 0\n",
    "\n",
    "    for batch_idx, (image, target) in enumerate(train_dataloader):\n",
    "\n",
    "        image = image.to(device)\n",
    "        target = target.to(device)\n",
    "\n",
    "        # train model\n",
    "        outputs, loss = train_batch4(model, image, target)\n",
    "        _, preds = torch.max(outputs, 1)\n",
    "\n",
    "        \n",
    "        loss_data = loss.data.item()\n",
    "        if np.isnan(loss_data):\n",
    "            raise ValueError('loss is nan while training')\n",
    "        running_cls_loss += loss.item()\n",
    "        running_cls_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "    epoch_loss = running_cls_loss / len(train_set)\n",
    "    epoch_acc = running_cls_corrects.double() / len(train_set)\n",
    "\n",
    "    print(f'Epoch: {epoch+1}/{NUM_EPOCHS} Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')\n",
    "\n",
    "    training_loss.append(epoch_loss)\n",
    "    training_acc.append(epoch_acc.cpu().detach().numpy())\n",
    "\n",
    "    # change learning rate\n",
    "    scheduler.step()\n",
    "\n",
    "\n",
    "    ##########################\n",
    "    ### Testing\n",
    "    ##########################\n",
    "    # # eval model during training or in the last epoch\n",
    "    if (epoch + 1) % EVAL_INTERVAL == 0 or (epoch +1) == NUM_EPOCHS:\n",
    "        print('Begin test......')\n",
    "        model.eval()\n",
    "    \n",
    "        val_loss = 0.0\n",
    "        val_corrects = 0\n",
    "\n",
    "        for batch_idx, (image, target) in enumerate(test_dataloader):\n",
    "\n",
    "            image = image.to(device)\n",
    "            target = target.to(device)\n",
    "\n",
    "            # test model\n",
    "            outputs, loss = test_batch4(model, image, target)\n",
    "            _, preds = torch.max(outputs, 1)\n",
    "            \n",
    "            val_loss += loss.item()\n",
    "            val_corrects += torch.sum(preds == target.data)\n",
    "\n",
    "        val_loss = val_loss / len(test_set)\n",
    "        val_acc = val_corrects.double() / len(test_set)\n",
    "        print(f'Test Loss: {val_loss:.4f} Acc: {val_acc:.4f}')\n",
    "        testing_loss.append(val_loss)\n",
    "        testing_acc.append(val_acc.cpu().detach().numpy())\n",
    "\n",
    "        # save the model in last epoch\n",
    "        if (epoch +1) == NUM_EPOCHS:\n",
    "            \n",
    "            state = {\n",
    "            'state_dict': model.state_dict(),\n",
    "            'acc': epoch_acc,\n",
    "            'epoch': (epoch+1),\n",
    "            }\n",
    "\n",
    "            # check the dir\n",
    "            if not os.path.exists(SAVE_DIR):\n",
    "                os.makedirs(SAVE_DIR)\n",
    "\n",
    "            # save the state\n",
    "            torch.save(state, osp.join(SAVE_DIR, 'checkpoint_%s.pth' % (str(epoch+1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the information by constructing a line chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(training_loss, training_acc)\n",
    "plt.title('Training set representation')\n",
    "plt.xlabel('training_loss')\n",
    "plt.ylabel('training_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(testing_loss, testing_acc)\n",
    "plt.title('Testing set representation')\n",
    "plt.xlabel('testing_loss')\n",
    "plt.ylabel('testing_acc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that focal loss seems to perform better when gamma is 2: loss is generally around 0.0007, while accuracy ranges from 30% to 60% and mostly stays around 55%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results comparison and analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Results comparison**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all, we can clearly see that L1loss is inferior to cross-entropy and focal loss.\n",
    "As we can see, when we use L1Loss () as a loss function, the loss value on both the training set and the test set is relatively small, but the accuracy of the test is generally around 10%, which is not very ideal.\n",
    "Secondly, cross-entropy does not perform as well as focal loss.\n",
    "Through the observation of the above results of CE, we can find that when the cross entropy is used as the loss function, its accuracy is greatly improved, generally about 30% to 60%. Its loss is generally around 0.01.\n",
    "We can see that focal loss performance is also very impressive: when gamma = 0.5, loss is generally around 0.009, and accuracy ranges from 30% to 60%, with most remaining around 50%. When gamma = 2, we can see that focal loss seems to perform better: loss is generally around 0.0007, while accuracy ranges from 30% to 60% and mostly stays around 55%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**analysis**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question1:Why did L1loss perform so poorly?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:**\n",
    "L1 Loss is a commonly used loss function in regression problems, which is used to measure the absolute difference between the predicted value and the actual value of the model. It does not apply to the classification problem in this assignment, so it performs poorly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question2:Why does cross entropy not perform as well as focal loss?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:**\n",
    "First, the cross-entropy loss may be affected in the class imbalance problem because it imposes the same penalty for misclassification of all classes. In the case of unbalanced categories, the model may be more inclined to predict categories that are in the majority, resulting in poor classification performance for a few categories. Focal Loss introduces an adjustable parameter (γ), which can reduce the weight of easy to classify samples and increase the weight of difficult to classify samples, so as to better deal with class imbalances.\n",
    "Second, traditional cross-entropy Loss penalizes samples that are easy to classify (those with high confidence) less, whereas Focal Loss penalizes these samples relatively more. This means that the model may perform better on easily classified samples, while paying more attention to hard-to-classify samples, which helps improve overall performance. Focal Loss is designed so that the model is more focused on difficult samples, which helps the model better locate and learn important features in the data.\n",
    "There may be a class imbalance in the data for this job, because when you call the print () method to look at the target tensor, you can see that it actually has only 7 different elements, but the size is 10 classes. So the performance of focal loss is better than that of normal cross entropy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question3：Why is the accuracy slightly higher for test sets than for training sets?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, the accuracy of the training set should be higher than that of the test set, because the model is trained on the training set, and it will try to fit the patterns and features in the training data, so it will perform better on the training set.\n",
    "\n",
    "Ideally, the model should behave similarly on the test set as it does on the training set, but because the test set contains data that the model has not seen, the accuracy of the test set will usually be slightly lower than the accuracy of the training set.\n",
    "\n",
    "However, under all the above loss functions, the accuracy of the test set is slightly higher than that of the training set. In addition, we can observe that no matter what kind of loss function is replaced, the highest accuracy of the model is only about 60%. This may be due to the fact that the size of the training set exceeds the model fitting ability, leading to problems such as model underfitting."
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}