Deep_Learning_M502019B/Lab2/.ipynb_checkpoints/前馈神经网络实验-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">研究生《深度学习》课程<br>实验报告</h1>\n",
    "<div style=\"text-align: center;\">\n",
    "    <div><span style=\"display: inline-block; width: 65px; text-align: center;\">课程名称</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">深度学习 M502019B</span></div>\n",
    "    <div><span style=\"display: inline-block; width: 65px; text-align: center;\">实验题目</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">Pytorch基本操作实验</span></div>\n",
    "    <div><span style=\"display: inline-block; width: 65px; text-align: center;\">学号</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">25120323</span></div>\n",
    "    <div><span style=\"display: inline-block; width: 65px; text-align: center;\">姓名</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">柯劲帆</span></div>\n",
    "    <div><span style=\"display: inline-block; width: 65px; text-align: center;\">授课老师</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">原继东</span></div>\n",
    "    <div><span style=\"display: inline-block; width: 65px; text-align: center;\">报告日期</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">2025年8月4日</span></div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pytorch version: 2.7.1+cu118\n",
      "CUDA version: 11.8\n",
      "CUDA device count: 1\n",
      "CUDA device name: NVIDIA TITAN Xp\n",
      "CUDA device capability: (6, 1)\n",
      "CUDA device memory: 11.90 GB\n",
      "CPU count: 4\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import Dataset, DataLoader, Subset, random_split\n",
    "from torch import nn\n",
    "from torchvision import datasets, transforms\n",
    "from multiprocessing import cpu_count\n",
    "from sklearn.model_selection import KFold\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm.notebook import tqdm\n",
    "import pandas as pd\n",
    "from typing import Literal, Union, Optional\n",
    "\n",
    "print('Pytorch version:',torch.__version__)\n",
    "if not torch.cuda.is_available():\n",
    "    print('CUDA is_available:', torch.cuda.is_available())\n",
    "else:\n",
    "    print('CUDA version:', torch.version.cuda)\n",
    "    print('CUDA device count:', torch.cuda.device_count())\n",
    "    print('CUDA device name:', torch.cuda.get_device_name())\n",
    "    print('CUDA device capability:', torch.cuda.get_device_capability())\n",
    "    print('CUDA device memory:', f'{torch.cuda.get_device_properties(0).total_memory/1024/1024/1024:.2f}', 'GB')\n",
    "print('CPU count:', cpu_count())\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "seed = 42\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed(seed)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务一\n",
    "**手动实现前馈神经网络解决上述回归、二分类、多分类任务。**\n",
    "- 从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先生成数据集。\n",
    "\n",
    "一共有3个数据集：\n",
    "\n",
    "1. 回归任务数据集。\n",
    "   - 生成单个数据集。\n",
    "   - 数据集的大小为$10000$且训练集大小为$7000$，测试集大小为$3000$。\n",
    "   - 数据集的样本特征维度$p$为$500$，且服从如下的高维线性函数：$y = 0.028 + \\sum_{i=1}^{p}0.0056 x_i + \\epsilon $。\n",
    "2. 二分类任务数据集。\n",
    "   - 共生成两个数据集。\n",
    "   - 两个数据集的大小均为$10000$且训练集大小为$7000$，测试集大小为$3000$。\n",
    "   - 两个数据集的样本特征$x$的维度均为$200$，且分别服从均值互为相反数且方差相同的正态分布。\n",
    "   - 两个数据集的样本标签分别为$0$和$1$。\n",
    "3. MNIST手写体数据集。\n",
    "   - 该数据集包含$60,000$个用于训练的图像样本和$10,000$个用于测试的图像样本。\n",
    "   - 图像是固定大小（$28\\times 28$像素），其标签为$0$到$10$。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实现回归任务数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练数据集大小：7000，测试数据集大小：3000\n",
      "训练数据集的第1对数据：\n",
      "输入x[0]第1个特征维度数据x[0][0]：-0.25091975927352905\n",
      "标签y[0]：tensor([-1.0123])\n"
     ]
    }
   ],
   "source": [
    "class My_Regression_Dataset(Dataset):\n",
    "    def __init__(self, train=True, num_features=500):\n",
    "        data_size = (7000 if train else 3000)\n",
    "        x = np.random.uniform(low=-1, high=1, size=(data_size, num_features))\n",
    "        noise = np.random.normal(loc=0, scale=1, size=(data_size, 1))\n",
    "        y = 0.028 - 0.0056 * x.sum(axis=1, keepdims=True) + noise\n",
    "        self.inputs = torch.tensor(x, dtype=torch.float32)\n",
    "        self.labels = torch.tensor(y, dtype=torch.float32)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.inputs.shape[0]\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.inputs[index], self.labels[index]\n",
    "\n",
    "        \n",
    "# 测试，并后面的训练创建变量\n",
    "train_regression_dataset = My_Regression_Dataset(train=True)\n",
    "test_regression_dataset = My_Regression_Dataset(train=False)\n",
    "print(\n",
    "    f\"训练数据集大小：{len(train_regression_dataset)}，\"\n",
    "    f\"测试数据集大小：{len(test_regression_dataset)}\"\n",
    ")\n",
    "x0, y0 = train_regression_dataset[0]\n",
    "print(f\"训练数据集的第1对数据：\")\n",
    "print(f\"输入x[0]第1个特征维度数据x[0][0]：{x0[0]}\")\n",
    "print(f\"标签y[0]：{y0}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实现二分类任务数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练数据集大小：14000，测试数据集大小：6000\n",
      "训练数据集的第1对数据：\n",
      "x[0]第1个特征维度数据x[0][0] = -0.4228987991809845\n",
      "y[0] = tensor([0.])\n",
      "训练数据集的第7001对数据：\n",
      "x[7000]第1个特征维度数据x[7000][0] = 0.4295016825199127\n",
      "y[7000] = tensor([1.])\n"
     ]
    }
   ],
   "source": [
    "class My_BinaryCLS_Dataset(Dataset):\n",
    "    def __init__(self, train=True, num_features=200):\n",
    "        num_samples = (7000 if train else 3000)\n",
    "        x_1 = np.random.normal(loc=-0.5, scale=0.2, size=(num_samples, num_features))\n",
    "        x_2 = np.random.normal(loc=0.5, scale=0.2, size=(num_samples, num_features))\n",
    "        labels_1, labels_2 = np.zeros((num_samples, 1)), np.ones((num_samples, 1))\n",
    "        self.inputs = torch.tensor(np.concatenate((x_1, x_2), axis=0), dtype=torch.float32)\n",
    "        self.labels = torch.tensor(np.concatenate((labels_1, labels_2), axis=0), dtype=torch.float32)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.inputs.shape[0]\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.inputs[index], self.labels[index]\n",
    "\n",
    "\n",
    "# 测试，并后面的训练创建变量\n",
    "train_binarycls_dataset = My_BinaryCLS_Dataset(train=True)\n",
    "test_binarycls_dataset = My_BinaryCLS_Dataset(train=False)\n",
    "\n",
    "print(\n",
    "    f\"训练数据集大小：{len(train_binarycls_dataset)}，\"\n",
    "    f\"测试数据集大小：{len(test_binarycls_dataset)}\"\n",
    ")\n",
    "x0, y0 = train_binarycls_dataset[0]\n",
    "print(f\"训练数据集的第1对数据：\")\n",
    "print(f\"x[0]第1个特征维度数据x[0][0] = {x0[0]}\")\n",
    "print(f\"y[0] = {y0}\")\n",
    "\n",
    "x7000, y7000 = train_binarycls_dataset[7000]\n",
    "print(f\"训练数据集的第7001对数据：\")\n",
    "print(f\"x[7000]第1个特征维度数据x[7000][0] = {x7000[0]}\")\n",
    "print(f\"y[7000] = {y7000}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用MNIST数据集。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用`torchvision.datasets.MNIST()`，获取数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练数据集大小：60000，测试数据集大小：10000\n",
      "A Train Sample:\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 150x150 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Image Type': <class 'torch.Tensor'>, 'Image Shape': torch.Size([1, 28, 28]), 'Label Type': <class 'int'>, 'Label Value': 5}\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.Compose(\n",
    "    [\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize((0.5,), (0.5,)),\n",
    "    ]\n",
    ")\n",
    "\n",
    "train_mnist_dataset = datasets.MNIST(root=\"dataset\", train=True, transform=transform, download=True)\n",
    "test_mnist_dataset = datasets.MNIST(root=\"dataset\", train=False, transform=transform, download=True)\n",
    "print(\n",
    "    f\"训练数据集大小：{len(train_mnist_dataset)}，\"\n",
    "    f\"测试数据集大小：{len(test_mnist_dataset)}\"\n",
    ")\n",
    "\n",
    "image, label = train_mnist_dataset[0]\n",
    "sample = {\n",
    "    'Image Type': type(image),\n",
    "    'Image Shape': image.shape,\n",
    "    'Label Type': type(label),\n",
    "    'Label Value': label\n",
    "}\n",
    "print('A Train Sample:\\n')\n",
    "plt.figure(figsize=(1.5, 1.5))\n",
    "plt.imshow(image.squeeze(0), cmap='gray')\n",
    "plt.title(f\"Label: {label}\")\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "print(sample)\n",
    "\n",
    "image_width, image_height = 28, 28\n",
    "num_classes = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来手动实现前馈神经网络并训练。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先手动实现一些工具和基本模型层。这些工具都在前一个实验中实现并测试过，在此就不再分析其原理和具体实现步骤，也不在此重新测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 手动实现torch.nn.functional.softmax\n",
    "def my_softmax(x: torch.Tensor, dim: int):\n",
    "    max_x = torch.max(x, dim=dim, keepdim=True).values\n",
    "    exp_x = torch.exp(x - max_x)\n",
    "    return exp_x / torch.sum(exp_x, dim=dim, keepdim=True)\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.Linear\n",
    "class My_Linear:\n",
    "    def __init__(self, in_features: int, out_features: int):\n",
    "        self.weight = torch.randn((out_features, in_features), requires_grad=True, dtype=torch.float32)\n",
    "        self.bias = torch.zeros(1, requires_grad=True, dtype=torch.float32)\n",
    "        self.params = [self.weight, self.bias]\n",
    "\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        return self.forward(x)\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = torch.matmul(x, self.weight.T) + self.bias\n",
    "        return x\n",
    "\n",
    "    def to(self, device: str):\n",
    "        for param in self.params:\n",
    "            param.data = param.data.to(device=device)\n",
    "        return self\n",
    "\n",
    "    def parameters(self):\n",
    "        return self.params\n",
    "\n",
    "        \n",
    "# 手动实现torch.nn.Flatten\n",
    "class My_Flatten:\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        x = x.view(x.shape[0], -1)\n",
    "        return x\n",
    "\n",
    "        \n",
    "# 手动实现torch.nn.ReLU\n",
    "class My_ReLU():\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        return torch.where(x > 0, x, torch.zeros_like(x))\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.LeakyReLU\n",
    "class My_LeakyReLU():\n",
    "    def __init__(self, negative_slope=0.01):\n",
    "        self.negative_slope = negative_slope\n",
    "    \n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        return torch.where(x > 0, x, x * self.negative_slope)\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.Sigmoid\n",
    "class My_Sigmoid():\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        z = torch.exp(-x.abs())\n",
    "        return torch.where(x >= 0, 1 / (1 + z), z / (1 + z))\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.Softmax\n",
    "class My_Softmax:\n",
    "    def __init__(self, dim: int):\n",
    "        self.dim = dim\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        max_x = torch.max(x, dim=self.dim, keepdim=True).values\n",
    "        exp_x = torch.exp(x - max_x)\n",
    "        return exp_x / torch.sum(exp_x, dim=self.dim, keepdim=True)\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.MSELoss\n",
    "class My_MSELoss:  \n",
    "    def __call__(self, prediction: torch.Tensor, target: torch.Tensor):\n",
    "        loss = torch.mean(torch.square(prediction - target))\n",
    "        return loss\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.BCELoss\n",
    "class My_BCELoss:\n",
    "    def __call__(self, prediction: torch.Tensor, target: torch.Tensor):\n",
    "        eps = 1e-9\n",
    "        loss = -torch.mean(target * torch.log(prediction + eps) + (1 - target) * torch.log(1 - prediction + eps))\n",
    "        return loss\n",
    "\n",
    "\n",
    "# 手动实现torch.nn.CrossEntropyLoss\n",
    "class My_CrossEntropyLoss:\n",
    "    def __call__(\n",
    "        self, \n",
    "        x: torch.Tensor, \n",
    "        targets: torch.Tensor, \n",
    "        reduction: Literal[\"mean\", \"sum\"] = \"mean\"\n",
    "    ):\n",
    "        max_x = torch.max(x, dim=1, keepdim=True).values\n",
    "        exp_x = torch.exp(x - max_x)\n",
    "        log_probs = x - max_x - torch.log(torch.sum(exp_x, dim=1, keepdim=True))\n",
    "        \n",
    "        if len(x.shape) == len(targets.shape) + 1:\n",
    "            nll_loss = -log_probs.gather(1, targets.unsqueeze(-1)).squeeze()\n",
    "        else:\n",
    "            nll_loss = -torch.sum(targets * log_probs, dim=1)\n",
    "            \n",
    "        if reduction == \"mean\": \n",
    "            return torch.mean(nll_loss)\n",
    "        else: \n",
    "            return torch.sum(nll_loss)\n",
    "\n",
    "\n",
    "# 手动实现torch.optim.SGD\n",
    "class My_Optimizer:\n",
    "    def __init__(self, params: list[torch.Tensor], lr: float):\n",
    "        self.params = list(params)\n",
    "        self.lr = lr\n",
    "\n",
    "    def step(self):\n",
    "        for param in self.params:\n",
    "            if param.grad is not None:\n",
    "                param.data = param.data - self.lr * param.grad.data\n",
    "\n",
    "    def zero_grad(self):\n",
    "        for param in self.params:\n",
    "            if param.grad is not None:\n",
    "                param.grad.data.zero_()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来实现Regression回归的Trainer，包括训练流程、测试和画图。\n",
    "\n",
    "训练Regression回归模型，进行如下步骤：\n",
    "1. 定义模型、数据集、损失函数、优化器和其他超参数\n",
    "2. 训练\n",
    "    1. 从训练dataloader中获取批量数据\n",
    "    2. 传入模型\n",
    "    3. 使用损失函数计算与ground_truth的损失\n",
    "    4. 使用优化器进行反向传播\n",
    "    5. 循环以上步骤\n",
    "3. 验证及测试\n",
    "    1. 从验证或测试dataloader中获取批量数据\n",
    "    2. 传入模型，验证时需要将模型输出与ground_truth进行比较得计算loss\n",
    "    3. 将预测值与ground_truth进行比较，得出正确率\n",
    "    4. 对整个训练集统计正确率，从而分析训练效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RegressionTrainer():\n",
    "    def __init__(\n",
    "        self,\n",
    "        model,\n",
    "        train_dataset: Union[Dataset, DataLoader],\n",
    "        eval_dataset: Union[Dataset, DataLoader],\n",
    "        optimizer: Literal['torch', 'manual'],\n",
    "        criterion: Literal['torch', 'manual'],\n",
    "        learning_rate: float,\n",
    "        num_epochs: int,\n",
    "        batch_size: int,\n",
    "        test_dataset: Union[Dataset, DataLoader] = None,\n",
    "        plot: bool = True, \n",
    "        print_test_result = True,\n",
    "        return_curves: bool = False,\n",
    "        log_epoch: int = 1\n",
    "    ):\n",
    "        self.model = model\n",
    "        self.learning_rate = learning_rate\n",
    "        self.num_epochs = num_epochs\n",
    "        self.batch_size = batch_size\n",
    "        self.plot = plot\n",
    "        self.print_test_result = print_test_result\n",
    "        self.return_curves = return_curves\n",
    "        self.log_epoch = log_epoch\n",
    "\n",
    "        if isinstance(train_dataset, Dataset):\n",
    "            self.train_dataloader = DataLoader(\n",
    "                dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.train_dataloader = train_dataset\n",
    "        if isinstance(eval_dataset, Dataset):\n",
    "            self.eval_dataloader = DataLoader(\n",
    "                dataset=eval_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.eval_dataloader = eval_dataset\n",
    "        if isinstance(test_dataset, Dataset):\n",
    "            self.test_dataloader = DataLoader(\n",
    "                dataset=test_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.test_dataloader = test_dataset\n",
    "\n",
    "        if optimizer == 'torch':\n",
    "            self.optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
    "        else:\n",
    "            self.optimizer = My_Optimizer(model.parameters(), lr=learning_rate)\n",
    "\n",
    "        if criterion == 'torch':\n",
    "            self.criterion = nn.MSELoss()\n",
    "        else:\n",
    "            self.criterion = My_MSELoss()\n",
    "\n",
    "    def train(self):\n",
    "        train_loss_curve = []\n",
    "        eval_loss_curve = []\n",
    "        eval_error_curve = []\n",
    "        step = 0\n",
    "        total_train_steps = self.num_epochs * len(self.train_dataloader)\n",
    "        with tqdm(total=total_train_steps) as pbar:\n",
    "            for epoch in range(self.num_epochs):\n",
    "                total_train_loss = 0\n",
    "                for x, targets in self.train_dataloader:\n",
    "                    x = x.to(device=device, dtype=torch.float32)\n",
    "                    targets = targets.to(device=device, dtype=torch.float32)\n",
    "\n",
    "                    self.optimizer.zero_grad()\n",
    "                    output = self.model(x)\n",
    "                    loss = self.criterion(output, targets)\n",
    "                    total_train_loss += loss.item()\n",
    "                    train_loss_curve.append(loss.item())\n",
    "            \n",
    "                    loss.backward()\n",
    "                    self.optimizer.step()\n",
    "                    step += 1\n",
    "                    pbar.update(1)\n",
    "\n",
    "                avg_eval_loss, avg_eval_error = self.eval()\n",
    "                eval_loss_curve.append(avg_eval_loss)\n",
    "                eval_error_curve.append(avg_eval_error)\n",
    "                if self.log_epoch > 0 and (epoch + 1) % self.log_epoch == 0:\n",
    "                    log_info = {\n",
    "                        'Epoch': f'{epoch + 1}/{self.num_epochs}',\n",
    "                        'Total Train Loss': f'{total_train_loss:.2f}',\n",
    "                        'Scaled Total Valid Loss': f'{avg_eval_loss * len(self.train_dataloader):.2f}',\n",
    "                        'Avg Valid Error': f'{avg_eval_error:.2f}'\n",
    "                    }\n",
    "                    print(log_info)\n",
    "\n",
    "        return_info = {}\n",
    "        if self.test_dataloader:\n",
    "            test_error = self.test()\n",
    "            if self.print_test_result:\n",
    "                print('Avg Test Error:', f'{test_error:.2f}')\n",
    "            return_info['test_error'] = test_error\n",
    "        if self.plot:\n",
    "            self.plot_results(train_loss_curve, eval_loss_curve, eval_error_curve)\n",
    "        if self.return_curves:\n",
    "            curves = {\n",
    "                'train_loss_curve': train_loss_curve,\n",
    "                'eval_loss_curve': eval_loss_curve,\n",
    "                'eval_error_curve': eval_error_curve\n",
    "            }\n",
    "            return_info['curves'] = curves\n",
    "        return return_info\n",
    "\n",
    "    def eval(self):\n",
    "        total_eval_loss = 0\n",
    "        total_eval_error = 0\n",
    "        total_eval_samples = 0\n",
    "        with torch.inference_mode():\n",
    "            for x, targets in self.eval_dataloader:\n",
    "                x = x.to(device=device, dtype=torch.float32)\n",
    "                targets = targets.to(device=device, dtype=torch.float32)\n",
    "                output = self.model(x)\n",
    "                loss = self.criterion(output, targets)\n",
    "                total_eval_loss += loss.item()\n",
    "                total_eval_error += torch.square(output - targets).sum().item()\n",
    "                total_eval_samples += targets.numel()\n",
    "        avg_eval_loss = total_eval_loss / len(self.eval_dataloader)\n",
    "        avg_eval_error = total_eval_error / total_eval_samples\n",
    "        return avg_eval_loss, avg_eval_error\n",
    "\n",
    "    def test(self):\n",
    "        total_test_error = 0\n",
    "        total_test_samples = 0\n",
    "        with torch.inference_mode():\n",
    "            for x, targets in self.test_dataloader:\n",
    "                x = x.to(device=device, dtype=torch.float32)\n",
    "                targets = targets.to(device=device, dtype=torch.float32)\n",
    "                output = self.model(x)\n",
    "                total_test_error += torch.square(output - targets).sum().item()\n",
    "                total_test_samples += targets.numel()\n",
    "        avg_test_error = total_test_error / total_test_samples\n",
    "        return avg_test_error\n",
    "        \n",
    "    def plot_results(self, train_loss_curve, eval_loss_curve, eval_error_curve):\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
    "        \n",
    "        axes[0].plot(train_loss_curve, label='Training Loss', color='blue')\n",
    "        axes[0].plot(\n",
    "            np.linspace(len(self.train_dataloader), len(train_loss_curve), len(eval_loss_curve), endpoint=True),\n",
    "            eval_loss_curve, label='Validation Loss', color='orange'\n",
    "        )\n",
    "        axes[0].set_xlabel('Step')\n",
    "        axes[0].set_ylabel('Loss')\n",
    "        axes[0].set_title('Loss Curve')\n",
    "        axes[0].legend()\n",
    "        axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "    \n",
    "        axes[1].plot(eval_error_curve, label='Validation Error', color='red', marker='o')\n",
    "        axes[1].set_xlabel('Epoch')\n",
    "        axes[1].set_ylabel('Error')\n",
    "        axes[1].set_title('Validation Error Curve')\n",
    "        axes[1].legend()\n",
    "        axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "    \n",
    "        plt.tight_layout()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "手动构建回归任务的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_1_1:\n",
    "    def __init__(self, input_features=500, output_features=1):\n",
    "        self.linear = My_Linear(in_features=input_features, out_features=output_features)\n",
    "        self.params = self.linear.params\n",
    "\n",
    "    def __call__(self, x):\n",
    "        return self.forward(x)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.linear(x)\n",
    "        return x\n",
    "\n",
    "    def to(self, device: str):\n",
    "        for param in self.params:\n",
    "            param.data = param.data.to(device=device)\n",
    "        return self\n",
    "\n",
    "    def parameters(self):\n",
    "        return self.params\n",
    "    \n",
    "    def train(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = True\n",
    "    \n",
    "    def eval(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "开始训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d341fbe13fc4c4bbb254738ed3a3210",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '769.69', 'Scaled Total Valid Loss': '464.15', 'Avg Valid Error': '66.30'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '291.14', 'Scaled Total Valid Loss': '197.26', 'Avg Valid Error': '28.15'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '120.49', 'Scaled Total Valid Loss': '90.02', 'Avg Valid Error': '12.87'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '54.79', 'Scaled Total Valid Loss': '44.94', 'Avg Valid Error': '6.43'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '28.08', 'Scaled Total Valid Loss': '25.07', 'Avg Valid Error': '3.58'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '16.56', 'Scaled Total Valid Loss': '15.95', 'Avg Valid Error': '2.28'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '11.41', 'Scaled Total Valid Loss': '11.62', 'Avg Valid Error': '1.66'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '9.01', 'Scaled Total Valid Loss': '9.55', 'Avg Valid Error': '1.37'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '7.85', 'Scaled Total Valid Loss': '8.55', 'Avg Valid Error': '1.22'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '7.30', 'Scaled Total Valid Loss': '8.04', 'Avg Valid Error': '1.15'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 1.0e-1,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_1_1().to(device)\n",
    "\n",
    "trainer = RegressionTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_regression_dataset, eval_dataset=test_regression_dataset,\n",
    "    optimizer='manual', criterion='manual', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来实现二分类任务的Trainer，包括训练流程、测试和画图。\n",
    "\n",
    "训练二分类任务模型，进行如下步骤：\n",
    "1. 定义模型、数据集、损失函数、优化器和其他超参数\n",
    "2. 训练\n",
    "    1. 从训练dataloader中获取批量数据\n",
    "    2. 传入模型\n",
    "    3. 使用损失函数计算与ground_truth的损失\n",
    "    4. 使用优化器进行反向传播\n",
    "    5. 循环以上步骤\n",
    "3. 验证及测试\n",
    "    1. 从验证或测试dataloader中获取批量数据\n",
    "    2. 传入模型，验证时需要将模型输出与ground_truth进行比较得计算loss\n",
    "    3. 将预测值与ground_truth进行比较，得出正确率\n",
    "    4. 对整个训练集统计正确率，从而分析训练效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BinaryCLSTrainer():\n",
    "    def __init__(\n",
    "        self,\n",
    "        model,\n",
    "        train_dataset: Union[Dataset, DataLoader],\n",
    "        eval_dataset: Union[Dataset, DataLoader],\n",
    "        optimizer: Literal['torch', 'manual'],\n",
    "        criterion: Literal['torch', 'manual'],\n",
    "        learning_rate: float,\n",
    "        num_epochs: int,\n",
    "        batch_size: int,\n",
    "        test_dataset: Union[Dataset, DataLoader] = None,\n",
    "        plot: bool = True, \n",
    "        print_test_result: bool = True,\n",
    "        return_curves: bool = False,\n",
    "        log_epoch: int = 1\n",
    "    ):\n",
    "        self.model = model\n",
    "        self.learning_rate = learning_rate\n",
    "        self.num_epochs = num_epochs\n",
    "        self.batch_size = batch_size\n",
    "        self.plot = plot\n",
    "        self.print_test_result = print_test_result\n",
    "        self.return_curves = return_curves\n",
    "        self.log_epoch = log_epoch\n",
    "\n",
    "        if isinstance(train_dataset, Dataset):\n",
    "            self.train_dataloader = DataLoader(\n",
    "                dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.train_dataloader = train_dataset\n",
    "        if isinstance(eval_dataset, Dataset):\n",
    "            self.eval_dataloader = DataLoader(\n",
    "                dataset=eval_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.eval_dataloader = eval_dataset\n",
    "        if isinstance(test_dataset, Dataset):\n",
    "            self.test_dataloader = DataLoader(\n",
    "                dataset=test_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.test_dataloader = test_dataset\n",
    "\n",
    "        if optimizer == 'torch':\n",
    "            self.optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
    "        else:\n",
    "            self.optimizer = My_Optimizer(model.parameters(), lr=learning_rate)\n",
    "\n",
    "        if criterion == 'torch':\n",
    "            self.criterion = nn.BCELoss()\n",
    "        else:\n",
    "            self.criterion = My_BCELoss()\n",
    "\n",
    "    def train(self):\n",
    "        train_loss_curve = []\n",
    "        eval_loss_curve = []\n",
    "        eval_acc_curve = []\n",
    "        step = 0\n",
    "        total_train_steps = self.num_epochs * len(self.train_dataloader)\n",
    "        with tqdm(total=total_train_steps) as pbar:\n",
    "            for epoch in range(self.num_epochs):\n",
    "                total_train_loss = 0\n",
    "                for x, targets in self.train_dataloader:\n",
    "                    x = x.to(device=device, dtype=torch.float32)\n",
    "                    targets = targets.to(device=device, dtype=torch.float32)\n",
    "\n",
    "                    self.optimizer.zero_grad()\n",
    "                    output = self.model(x)\n",
    "                    loss = self.criterion(output, targets)\n",
    "                    total_train_loss += loss.item()\n",
    "                    train_loss_curve.append(loss.item())\n",
    "            \n",
    "                    loss.backward()\n",
    "                    self.optimizer.step()\n",
    "\n",
    "                    step += 1\n",
    "                    pbar.update(1)\n",
    "\n",
    "                avg_eval_loss, avg_eval_acc = self.eval()\n",
    "                eval_loss_curve.append(avg_eval_loss)\n",
    "                eval_acc_curve.append(avg_eval_acc)\n",
    "                if self.log_epoch > 0 and (epoch + 1) % self.log_epoch == 0:\n",
    "                    log_info = {\n",
    "                        'Epoch': f'{epoch + 1}/{self.num_epochs}',\n",
    "                        'Total Train Loss': f'{total_train_loss:.2f}',\n",
    "                        'Scaled Total Valid Loss': f'{avg_eval_loss * len(self.train_dataloader):.2f}',\n",
    "                        'Avg Valid Acc': f'{avg_eval_acc:.2%}'\n",
    "                    }\n",
    "                    print(log_info)\n",
    "\n",
    "        return_info = {}\n",
    "        if self.test_dataloader:\n",
    "            test_acc = self.test()\n",
    "            if self.print_test_result:\n",
    "                print('Avg Test Acc:', f'{test_acc:.2%}')\n",
    "            return_info['test_acc'] = test_acc\n",
    "        if self.plot:\n",
    "            self.plot_results(train_loss_curve, eval_loss_curve, eval_acc_curve)\n",
    "        if self.return_curves:\n",
    "            curves = {\n",
    "                'train_loss_curve': train_loss_curve,\n",
    "                'eval_loss_curve': eval_loss_curve,\n",
    "                'eval_acc_curve': eval_acc_curve\n",
    "            }\n",
    "            return_info['curves'] = curves\n",
    "        return return_info\n",
    "\n",
    "    def eval(self):\n",
    "        total_eval_loss = 0\n",
    "        total_eval_acc = 0\n",
    "        total_eval_samples = 0\n",
    "        with torch.inference_mode():\n",
    "            for x, targets in self.eval_dataloader:\n",
    "                x = x.to(device=device, dtype=torch.float32)\n",
    "                targets = targets.to(device=device, dtype=torch.float32)\n",
    "                output = self.model(x)\n",
    "                loss = self.criterion(output, targets)\n",
    "                total_eval_loss += loss.item()\n",
    "                preds = (output >= 0.5).float()\n",
    "                total_eval_acc += (preds == targets.to(dtype=torch.long)).float().sum().item()\n",
    "                total_eval_samples += targets.numel()\n",
    "        avg_eval_loss = total_eval_loss / len(self.eval_dataloader)\n",
    "        avg_eval_acc = total_eval_acc / total_eval_samples\n",
    "        return avg_eval_loss, avg_eval_acc\n",
    "\n",
    "    def test(self):\n",
    "        total_test_acc = 0\n",
    "        total_test_samples = 0\n",
    "        with torch.inference_mode():\n",
    "            for x, targets in self.test_dataloader:\n",
    "                x = x.to(device=device, dtype=torch.float32)\n",
    "                targets = targets.to(device=device, dtype=torch.long)\n",
    "                output = self.model(x)\n",
    "                preds = (output >= 0.5).float()\n",
    "                total_test_acc += (preds == targets).float().sum().item()\n",
    "                total_test_samples += targets.numel()\n",
    "        avg_test_acc = total_test_acc / total_test_samples\n",
    "        return avg_test_acc\n",
    "        \n",
    "    def plot_results(self, train_loss_curve, eval_loss_curve, eval_acc_curve):\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
    "        \n",
    "        axes[0].plot(train_loss_curve, label='Training Loss', color='blue')\n",
    "        axes[0].plot(\n",
    "            np.linspace(len(self.train_dataloader), len(train_loss_curve), len(eval_loss_curve), endpoint=True),\n",
    "            eval_loss_curve, label='Validation Loss', color='orange'\n",
    "        )\n",
    "        axes[0].set_xlabel('Step')\n",
    "        axes[0].set_ylabel('Loss')\n",
    "        axes[0].set_title('Loss Curve')\n",
    "        axes[0].legend()\n",
    "        axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "    \n",
    "        axes[1].plot(eval_acc_curve, label='Validation Accuracy', color='green', marker='o')\n",
    "        axes[1].set_xlabel('Epoch')\n",
    "        axes[1].set_ylabel('Accuracy')\n",
    "        axes[1].set_title('Validation Accuracy Curve')\n",
    "        axes[1].legend()\n",
    "        axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "    \n",
    "        plt.tight_layout()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "手动构建二分类任务的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_1_2:\n",
    "    def __init__(self, input_features=200):\n",
    "        self.fc = My_Linear(in_features=input_features, out_features=1)\n",
    "        self.sigmoid = My_Sigmoid()\n",
    "        self.params = self.fc.parameters()\n",
    "\n",
    "    def __call__(self, x):\n",
    "        return self.forward(x)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc(x)\n",
    "        x = self.sigmoid(x)\n",
    "        return x\n",
    "\n",
    "    def to(self, device: str):\n",
    "        for param in self.params:\n",
    "            param.data = param.data.to(device=device)\n",
    "        return self\n",
    "\n",
    "    def parameters(self):\n",
    "        return self.params\n",
    "    \n",
    "    def train(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = True\n",
    "    \n",
    "    def eval(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练并测试上述二分类模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ddf036c37e040188f27cb5bab5ea3aa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/140 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '2.40', 'Scaled Total Valid Loss': '0.76', 'Avg Valid Acc': '97.95%'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '0.60', 'Scaled Total Valid Loss': '0.34', 'Avg Valid Acc': '99.38%'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '0.33', 'Scaled Total Valid Loss': '0.21', 'Avg Valid Acc': '99.65%'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '0.22', 'Scaled Total Valid Loss': '0.15', 'Avg Valid Acc': '99.83%'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '0.17', 'Scaled Total Valid Loss': '0.11', 'Avg Valid Acc': '99.92%'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '0.13', 'Scaled Total Valid Loss': '0.09', 'Avg Valid Acc': '99.92%'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '0.11', 'Scaled Total Valid Loss': '0.07', 'Avg Valid Acc': '99.95%'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '0.09', 'Scaled Total Valid Loss': '0.06', 'Avg Valid Acc': '99.97%'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '0.08', 'Scaled Total Valid Loss': '0.05', 'Avg Valid Acc': '99.97%'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '0.07', 'Scaled Total Valid Loss': '0.05', 'Avg Valid Acc': '99.98%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 5.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_1_2().to(device)\n",
    "\n",
    "trainer = BinaryCLSTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_binarycls_dataset, eval_dataset=test_binarycls_dataset,\n",
    "    optimizer='manual', criterion='manual', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来实现多分类任务的Trainer，包括训练流程、测试和画图。\n",
    "\n",
    "训练多分类任务模型，与二分类任务大部分一致，仅修改损失函数，以及对数据类型做适配。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiCLSTrainer():\n",
    "    def __init__(\n",
    "        self,\n",
    "        model,\n",
    "        train_dataset: Union[Dataset, DataLoader],\n",
    "        eval_dataset: Union[Dataset, DataLoader],\n",
    "        optimizer,\n",
    "        criterion: Literal['torch', 'manual'],\n",
    "        learning_rate: float,\n",
    "        num_epochs: int,\n",
    "        batch_size: int,\n",
    "        weight_decay: float = 0.0,\n",
    "        test_dataset: Union[Dataset, DataLoader] = None,\n",
    "        plot: bool = True, \n",
    "        print_test_result: bool = True,\n",
    "        return_curves: bool = False,\n",
    "        log_epoch: int = 1\n",
    "    ):\n",
    "        self.model = model\n",
    "        self.learning_rate = learning_rate\n",
    "        self.num_epochs = num_epochs\n",
    "        self.batch_size = batch_size\n",
    "        self.plot = plot\n",
    "        self.print_test_result = print_test_result\n",
    "        self.return_curves = return_curves\n",
    "        self.log_epoch = log_epoch\n",
    "\n",
    "        if isinstance(train_dataset, Dataset):\n",
    "            self.train_dataloader = DataLoader(\n",
    "                dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.train_dataloader = train_dataset\n",
    "        if isinstance(eval_dataset, Dataset):\n",
    "            self.eval_dataloader = DataLoader(\n",
    "                dataset=eval_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.eval_dataloader = eval_dataset\n",
    "        if isinstance(test_dataset, Dataset):\n",
    "            self.test_dataloader = DataLoader(\n",
    "                dataset=test_dataset, batch_size=batch_size, shuffle=True, num_workers=cpu_count()\n",
    "            )\n",
    "        else:\n",
    "            self.test_dataloader = test_dataset\n",
    "\n",
    "        if isinstance(optimizer, str):\n",
    "            if optimizer == 'torch':\n",
    "                self.optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n",
    "            else:\n",
    "                self.optimizer = My_Optimizer(model.parameters(), lr=learning_rate)\n",
    "        else:\n",
    "            self.optimizer = optimizer(model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n",
    "\n",
    "        if criterion == 'torch':\n",
    "            self.criterion = nn.CrossEntropyLoss()\n",
    "            self.softmax = nn.Softmax(dim=1)\n",
    "        else:\n",
    "            self.criterion = My_CrossEntropyLoss()\n",
    "            self.softmax = My_Softmax(dim=1)\n",
    "\n",
    "    def train(self):\n",
    "        train_loss_curve = []\n",
    "        eval_loss_curve = []\n",
    "        eval_acc_curve = []\n",
    "        step = 0\n",
    "        total_train_steps = self.num_epochs * len(self.train_dataloader)\n",
    "        with tqdm(total=total_train_steps) as pbar:\n",
    "            for epoch in range(self.num_epochs):\n",
    "                total_train_loss = 0\n",
    "                for x, targets in self.train_dataloader:\n",
    "                    x = x.to(device=device, dtype=torch.float32)\n",
    "                    targets = targets.to(device=device, dtype=torch.long)\n",
    "\n",
    "                    self.optimizer.zero_grad()\n",
    "                    output = self.model(x)\n",
    "                    loss = self.criterion(output, targets)\n",
    "                    total_train_loss += loss.item()\n",
    "                    train_loss_curve.append(loss.item())\n",
    "            \n",
    "                    loss.backward()\n",
    "                    self.optimizer.step()\n",
    "                    step += 1\n",
    "                    pbar.update(1)\n",
    "\n",
    "                avg_eval_loss, avg_eval_acc = self.eval()\n",
    "                eval_loss_curve.append(avg_eval_loss)\n",
    "                eval_acc_curve.append(avg_eval_acc)\n",
    "                if self.log_epoch > 0 and (epoch + 1) % self.log_epoch == 0:\n",
    "                    log_info = {\n",
    "                        'Epoch': f'{epoch + 1}/{self.num_epochs}',\n",
    "                        'Total Train Loss': f'{total_train_loss:.2f}',\n",
    "                        'Scaled Total Valid Loss': f'{avg_eval_loss * len(self.train_dataloader):.2f}',\n",
    "                        'Avg Valid Acc': f'{avg_eval_acc:.2%}'\n",
    "                    }\n",
    "                    print(log_info)\n",
    "\n",
    "        return_info = {}\n",
    "        if self.test_dataloader:\n",
    "            test_acc = self.test()\n",
    "            if self.print_test_result:\n",
    "                print('Avg Test Acc:', f'{test_acc:.2%}')\n",
    "            return_info['test_acc'] = test_acc\n",
    "        if self.plot:\n",
    "            self.plot_results(train_loss_curve, eval_loss_curve, eval_acc_curve)\n",
    "        if self.return_curves:\n",
    "            curves = {\n",
    "                'train_loss_curve': train_loss_curve,\n",
    "                'eval_loss_curve': eval_loss_curve,\n",
    "                'eval_acc_curve': eval_acc_curve\n",
    "            }\n",
    "            return_info['curves'] = curves\n",
    "        return return_info\n",
    "\n",
    "    def eval(self):\n",
    "        total_eval_loss = 0\n",
    "        total_eval_acc = 0\n",
    "        total_eval_samples = 0\n",
    "        with torch.inference_mode():\n",
    "            for x, targets in self.eval_dataloader:\n",
    "                x = x.to(device=device, dtype=torch.float32)\n",
    "                targets = targets.to(device=device, dtype=torch.long)\n",
    "                output = self.model(x)\n",
    "                loss = self.criterion(output, targets)\n",
    "                total_eval_loss += loss.item()\n",
    "                preds = self.softmax(output).argmax(dim=1)\n",
    "                total_eval_acc += (preds == targets).float().sum().item()\n",
    "                total_eval_samples += targets.numel()\n",
    "        avg_eval_loss = total_eval_loss / len(self.eval_dataloader)\n",
    "        avg_eval_acc = total_eval_acc / total_eval_samples\n",
    "        return avg_eval_loss, avg_eval_acc\n",
    "\n",
    "    def test(self):\n",
    "        total_test_acc = 0\n",
    "        total_test_samples = 0\n",
    "        with torch.inference_mode():\n",
    "            for x, targets in self.test_dataloader:\n",
    "                x = x.to(device=device, dtype=torch.float32)\n",
    "                targets = targets.to(device=device, dtype=torch.long)\n",
    "                output = self.model(x)\n",
    "                preds = self.softmax(output).argmax(dim=1)\n",
    "                total_test_acc += (preds == targets).float().sum().item()\n",
    "                total_test_samples += targets.numel()\n",
    "        avg_test_acc = total_test_acc / total_test_samples\n",
    "        return avg_test_acc\n",
    "        \n",
    "    def plot_results(self, train_loss_curve, eval_loss_curve, eval_acc_curve):\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
    "        \n",
    "        axes[0].plot(train_loss_curve, label='Training Loss', color='blue')\n",
    "        axes[0].plot(\n",
    "            np.linspace(len(self.train_dataloader), len(train_loss_curve), len(eval_loss_curve), endpoint=True),\n",
    "            eval_loss_curve, label='Validation Loss', color='orange'\n",
    "        )\n",
    "        axes[0].set_xlabel('Step')\n",
    "        axes[0].set_ylabel('Loss')\n",
    "        axes[0].set_title('Loss Curve')\n",
    "        axes[0].legend()\n",
    "        axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "    \n",
    "        axes[1].plot(eval_acc_curve, label='Validation Accuracy', color='green', marker='o')\n",
    "        axes[1].set_xlabel('Epoch')\n",
    "        axes[1].set_ylabel('Accuracy')\n",
    "        axes[1].set_title('Validation Accuracy Curve')\n",
    "        axes[1].legend()\n",
    "        axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "    \n",
    "        plt.tight_layout()\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "手动构建MNIST多分类任务的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_1_3:\n",
    "    def __init__(self, input_features=784, num_classes=10):\n",
    "        self.flatten = My_Flatten()\n",
    "        self.linear = My_Linear(in_features=input_features, out_features=num_classes)\n",
    "        self.params = self.linear.params\n",
    "\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "        return self.forward(x)\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = self.flatten(x)\n",
    "        x = self.linear(x)\n",
    "        return x\n",
    "\n",
    "    def to(self, device: str):\n",
    "        for param in self.params:\n",
    "            param.data = param.data.to(device=device)\n",
    "        return self\n",
    "\n",
    "    def parameters(self):\n",
    "        return self.params\n",
    "    \n",
    "    def train(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = True\n",
    "    \n",
    "    def eval(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练并测试上述MNIST多分类模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45fbb247fc7a45bb9acfdab217c6a235",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '838.57', 'Scaled Total Valid Loss': '503.22', 'Avg Valid Acc': '35.28%'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '382.18', 'Scaled Total Valid Loss': '300.46', 'Avg Valid Acc': '52.85%'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '260.97', 'Scaled Total Valid Loss': '224.79', 'Avg Valid Acc': '61.54%'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '207.34', 'Scaled Total Valid Loss': '185.67', 'Avg Valid Acc': '66.55%'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '177.52', 'Scaled Total Valid Loss': '161.63', 'Avg Valid Acc': '69.71%'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '158.18', 'Scaled Total Valid Loss': '145.88', 'Avg Valid Acc': '72.55%'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '144.46', 'Scaled Total Valid Loss': '134.26', 'Avg Valid Acc': '74.28%'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '134.35', 'Scaled Total Valid Loss': '125.45', 'Avg Valid Acc': '75.68%'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '126.49', 'Scaled Total Valid Loss': '118.48', 'Avg Valid Acc': '76.99%'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '120.29', 'Scaled Total Valid Loss': '112.85', 'Avg Valid Acc': '77.80%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_1_3(\n",
    "    input_features=image_width * image_height, \n",
    "    num_classes=num_classes\n",
    ").to(device)\n",
    "\n",
    "trainer = MultiCLSTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "    optimizer='manual', criterion='manual', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务二\n",
    "**利用torch.nn实现前馈神经网络解决上述回归、二分类、多分类任务。**\n",
    "- 从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用`torch.nn`构建回归任务的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_2_1(nn.Module):\n",
    "    def __init__(self, input_features=500):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(in_features=input_features, out_features=1)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.linear(x)\n",
    "        x = self.sigmoid(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练并测试上述回归模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "891aac516c0a425192093fab78c3e7d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '8.49', 'Scaled Total Valid Loss': '8.37', 'Avg Valid Error': '1.20'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '8.27', 'Scaled Total Valid Loss': '8.17', 'Avg Valid Error': '1.17'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '8.05', 'Scaled Total Valid Loss': '8.02', 'Avg Valid Error': '1.15'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '7.89', 'Scaled Total Valid Loss': '7.89', 'Avg Valid Error': '1.13'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '7.76', 'Scaled Total Valid Loss': '7.78', 'Avg Valid Error': '1.11'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '7.64', 'Scaled Total Valid Loss': '7.70', 'Avg Valid Error': '1.10'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '7.54', 'Scaled Total Valid Loss': '7.63', 'Avg Valid Error': '1.09'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '7.45', 'Scaled Total Valid Loss': '7.57', 'Avg Valid Error': '1.08'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '7.38', 'Scaled Total Valid Loss': '7.52', 'Avg Valid Error': '1.07'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '7.33', 'Scaled Total Valid Loss': '7.48', 'Avg Valid Error': '1.07'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 1.0e-1,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_2_1().to(device)\n",
    "\n",
    "trainer = RegressionTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_regression_dataset, eval_dataset=test_regression_dataset,\n",
    "    optimizer='torch', criterion='torch', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用`torch.nn`构建二分类任务的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_2_2(nn.Module):\n",
    "    def __init__(self, input_features=200):\n",
    "        super().__init__()\n",
    "        self.fc = nn.Linear(in_features=input_features, out_features=1)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc(x)\n",
    "        x = self.sigmoid(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练并测试上述二分类模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "35b427ce904541dfb6156882068e21ce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/140 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '8.87', 'Scaled Total Valid Loss': '8.30', 'Avg Valid Acc': '95.65%'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '7.88', 'Scaled Total Valid Loss': '7.41', 'Avg Valid Acc': '99.80%'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '7.05', 'Scaled Total Valid Loss': '6.65', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '6.34', 'Scaled Total Valid Loss': '6.00', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '5.74', 'Scaled Total Valid Loss': '5.45', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '5.23', 'Scaled Total Valid Loss': '4.98', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '4.79', 'Scaled Total Valid Loss': '4.57', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '4.40', 'Scaled Total Valid Loss': '4.21', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '4.07', 'Scaled Total Valid Loss': '3.91', 'Avg Valid Acc': '100.00%'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '3.78', 'Scaled Total Valid Loss': '3.63', 'Avg Valid Acc': '100.00%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 5.0e-4,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_2_2().to(device)\n",
    "\n",
    "trainer = BinaryCLSTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_binarycls_dataset, eval_dataset=test_binarycls_dataset,\n",
    "    optimizer='torch', criterion='torch', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用`torch.nn`构建MNIST多分类任务的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_2_3(nn.Module):\n",
    "    def __init__(self, input_features=784, num_classes=10):\n",
    "        super().__init__()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear = nn.Linear(in_features=input_features, out_features=num_classes)\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = self.flatten(x)\n",
    "        x = self.linear(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练并测试上述MNIST多分类模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f5758a4202d0422bad77b31145b7f80b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '62.60', 'Scaled Total Valid Loss': '30.53', 'Avg Valid Acc': '86.13%'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '28.31', 'Scaled Total Valid Loss': '25.16', 'Avg Valid Acc': '88.45%'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '25.01', 'Scaled Total Valid Loss': '22.58', 'Avg Valid Acc': '89.70%'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '23.17', 'Scaled Total Valid Loss': '21.44', 'Avg Valid Acc': '89.96%'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '22.04', 'Scaled Total Valid Loss': '20.87', 'Avg Valid Acc': '90.06%'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '21.33', 'Scaled Total Valid Loss': '20.09', 'Avg Valid Acc': '90.57%'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '20.75', 'Scaled Total Valid Loss': '19.36', 'Avg Valid Acc': '90.74%'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '20.22', 'Scaled Total Valid Loss': '19.18', 'Avg Valid Acc': '90.80%'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '19.89', 'Scaled Total Valid Loss': '18.82', 'Avg Valid Acc': '91.12%'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '19.57', 'Scaled Total Valid Loss': '18.81', 'Avg Valid Acc': '90.98%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_2_3(\n",
    "    input_features=image_width * image_height, \n",
    "    num_classes=num_classes\n",
    ").to(device)\n",
    "\n",
    "trainer = MultiCLSTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "    optimizer='torch', criterion='torch', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务三\n",
    "**在多分类任务中使用至少三种不同的激活函数。**\n",
    "- 使用不同的激活函数，进行对比实验并分析实验结果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义4个模型，分别使用`nn.ReLU()`、`nn.Sigmoid()`、`nn.Tanh()`和`nn.LeakyReLU()`的实例作为激活函数。\n",
    "\n",
    "分别训练和测试。并将损失曲线和正确率曲线分别画在一个图内以进行比较4种激活函数的效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "以ReLU为激活函数的模型开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "efd5837ab4d34678acf767b988a8fd3a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '15.90', 'Scaled Total Valid Loss': '16.60', 'Avg Valid Acc': '91.41%'}\n",
      "以Sigmoid为激活函数的模型开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f1b883a3794a4b639c8ee26530fc78d2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '135.16', 'Scaled Total Valid Loss': '135.09', 'Avg Valid Acc': '11.35%'}\n",
      "以Tanh为激活函数的模型开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b9cc05c821e145a782ddd5a9b4742d3e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '59.84', 'Scaled Total Valid Loss': '59.09', 'Avg Valid Acc': '91.16%'}\n",
      "以LeakyReLU为激活函数的模型开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c16376b5cd064a9a9f6e5cd0cb9cb935",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '16.09', 'Scaled Total Valid Loss': '14.88', 'Avg Valid Acc': '92.73%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_3(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        activate_fn: Literal['ReLU', 'Sigmoid', 'Tanh', 'LeakyReLU'],\n",
    "        input_features: int = 784, \n",
    "        num_classes: int = 10\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Linear(in_features=input_features, out_features=1024)\n",
    "        self.fc2 = nn.Linear(in_features=1024, out_features=256)\n",
    "        self.fc3 = nn.Linear(in_features=256, out_features=num_classes)\n",
    "        if activate_fn == 'ReLU':\n",
    "            self.activate_fn = nn.ReLU()\n",
    "        elif activate_fn == 'Sigmoid':\n",
    "            self.activate_fn = nn.Sigmoid()\n",
    "        elif activate_fn == 'Tanh':\n",
    "            self.activate_fn = nn.Tanh()\n",
    "        elif activate_fn == 'LeakyReLU':\n",
    "            self.activate_fn = nn.LeakyReLU()\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.activate_fn(x)\n",
    "\n",
    "        x = self.fc2(x)\n",
    "        x = self.activate_fn(x)\n",
    "\n",
    "        x = self.fc3(x)\n",
    "        x = self.activate_fn(x)\n",
    "        return x\n",
    "    \n",
    "models = {\n",
    "    fn: Model_3(fn, input_features=image_width * image_height, num_classes=num_classes).to(device) \n",
    "    for fn in ['ReLU', 'Sigmoid', 'Tanh', 'LeakyReLU']\n",
    "}\n",
    "plot_colors = {'ReLU': 'blue', 'Sigmoid': 'green', 'Tanh': 'orange', 'LeakyReLU': 'purple'}\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
    "\n",
    "axes[0].set_xlabel('Epoch')\n",
    "axes[0].set_ylabel('Loss')\n",
    "axes[0].set_title('Validation Loss Curve')\n",
    "axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "axes[1].set_xlabel('Epoch')\n",
    "axes[1].set_ylabel('Accuracy')\n",
    "axes[1].set_title('Validation Accuracy Curve')\n",
    "axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "for fn_name, model in models.items():\n",
    "    print(f\"以{fn_name}为激活函数的模型开始训练：\")\n",
    "    trainer = MultiCLSTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "        optimizer='torch', criterion='torch', **hyper_params, \n",
    "        plot=False, return_curves=True, log_epoch=10\n",
    "    )\n",
    "    curves = trainer.train()['curves']\n",
    "\n",
    "    axes[0].plot(\n",
    "        range(1, len(curves['eval_loss_curve']) + 1), curves['eval_loss_curve'], \n",
    "        label=fn_name, color=plot_colors[fn_name]\n",
    "    )\n",
    "    axes[1].plot(\n",
    "        range(1, len(curves['eval_acc_curve']) + 1), curves['eval_acc_curve'], \n",
    "        label=fn_name, color=plot_colors[fn_name]\n",
    "    )\n",
    "\n",
    "axes[0].legend()\n",
    "axes[1].legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在性能表现上，激活函数为`Sigmoid`的模型训练过程中损失下降速度非常慢，可见发生了梯度消失，这验证了`Sigmoid`非常容易出现梯度消失的问题。\n",
    "\n",
    "激活函数为`ReLU`的模型比较不稳定，有时会出现神经元死亡过多（值为$0$或接近$0$）的情况。\n",
    "\n",
    "`Tanh`以及`LeakyReLU`的表现相对优秀。\n",
    "\n",
    "在用时上，各激活函数的模型训练用时相近。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务四\n",
    "**对多分类任务中的模型评估隐藏层层数和隐藏单元个数对实验结果的影响。**\n",
    "- 使用不同的隐藏层层数和隐藏单元个数，进行对比实验并分析实验结果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义6个模型，隐藏层层数和隐藏单元个数分别如下：\n",
    "\n",
    "| 模型编号 | hidden_layer (层数) | hidden_size (隐藏单元个数) |\n",
    "|:--------:|:-------------------:|:--------------------------:|\n",
    "| 1        | 2                   | 64                         |\n",
    "| 2        | 2                   | 1024                       |\n",
    "| 3        | 4                   | 64                         |\n",
    "| 4        | 4                   | 1024                       |\n",
    "| 5        | 8                   | 64                         |\n",
    "| 6        | 8                   | 1024                       |\n",
    "\n",
    "\n",
    "\n",
    "分别训练和测试。并将损失曲线和正确率曲线分别画在一个图内以进行比较6个模型的效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型1（隐藏层层数为2，隐藏单元个数为64）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "137bb123d4664678b57c3a4c2e7ea977",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '16.74', 'Scaled Total Valid Loss': '15.85', 'Avg Valid Acc': '92.05%'}\n",
      "模型2（隐藏层层数为2，隐藏单元个数为1024）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b220f4d96280427e9979a5422705d132",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '15.05', 'Scaled Total Valid Loss': '14.35', 'Avg Valid Acc': '93.08%'}\n",
      "模型3（隐藏层层数为4，隐藏单元个数为64）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fee9f6e3489447049f6cec7d41c90c94",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '22.21', 'Scaled Total Valid Loss': '20.44', 'Avg Valid Acc': '89.60%'}\n",
      "模型4（隐藏层层数为4，隐藏单元个数为1024）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2599a2e7954a4077995339e9803f2b20",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '15.20', 'Scaled Total Valid Loss': '14.95', 'Avg Valid Acc': '92.11%'}\n",
      "模型5（隐藏层层数为8，隐藏单元个数为64）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c26ac95647ae4684be9048e0dc544eb0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '135.77', 'Scaled Total Valid Loss': '135.76', 'Avg Valid Acc': '11.35%'}\n",
      "模型6（隐藏层层数为8，隐藏单元个数为1024）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "69747d8b5b884e468a13270ea8f66d53",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '135.72', 'Scaled Total Valid Loss': '135.70', 'Avg Valid Acc': '11.35%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_4(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        hidden_size: int,\n",
    "        num_hidden_layer: int,\n",
    "        input_features: int = 784, \n",
    "        num_classes: int = 10\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=input_features, out_features=hidden_size),\n",
    "            nn.LeakyReLU()\n",
    "        )\n",
    "        for i in range(num_hidden_layer - 1):\n",
    "            self.net.append(nn.Linear(in_features=hidden_size, out_features=hidden_size))\n",
    "            self.net.append(nn.LeakyReLU())\n",
    "        self.net.append(nn.Linear(in_features=hidden_size, out_features=num_classes))\n",
    "        \n",
    "    def forward(self, x: torch.Tensor):\n",
    "        return self.net(x)\n",
    "        \n",
    "model_arch_params = [\n",
    "    {'num_hidden_layer': 2, 'hidden_size': 64},\n",
    "    {'num_hidden_layer': 2, 'hidden_size': 1024},\n",
    "    {'num_hidden_layer': 4, 'hidden_size': 64},\n",
    "    {'num_hidden_layer': 4, 'hidden_size': 1024},\n",
    "    {'num_hidden_layer': 8, 'hidden_size': 64},\n",
    "    {'num_hidden_layer': 8, 'hidden_size': 1024},\n",
    "]\n",
    "plot_colors = ['blue', 'blue', 'green', 'green', 'orange', 'orange']\n",
    "plot_linestyles = ['solid', 'dashed', 'solid', 'dashed', 'solid', 'dashed']\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
    "\n",
    "axes[0].set_xlabel('Epoch')\n",
    "axes[0].set_ylabel('Loss')\n",
    "axes[0].set_title('Validation Loss Curve')\n",
    "axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "axes[1].set_xlabel('Epoch')\n",
    "axes[1].set_ylabel('Accuracy')\n",
    "axes[1].set_title('Validation Accuracy Curve')\n",
    "axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "for index, arch_param in enumerate(model_arch_params):\n",
    "    num_hidden_layer, hidden_size = arch_param['num_hidden_layer'], arch_param['hidden_size']\n",
    "    model = Model_4(**arch_param, input_features=image_width * image_height, num_classes=num_classes).to(device)\n",
    "    \n",
    "    print(f\"模型{index + 1}（隐藏层层数为{num_hidden_layer}，隐藏单元个数为{hidden_size}）开始训练：\")\n",
    "    trainer = MultiCLSTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "        optimizer='torch', criterion='torch', **hyper_params, \n",
    "        plot=False, return_curves=True, log_epoch=10\n",
    "    )\n",
    "    curves = trainer.train()['curves']\n",
    "\n",
    "    axes[0].plot(\n",
    "        range(1, len(curves['eval_loss_curve']) + 1), curves['eval_loss_curve'], color=plot_colors[index],\n",
    "        label=f\"({num_hidden_layer}, {hidden_size})\", linestyle=plot_linestyles[index]\n",
    "    )\n",
    "    axes[1].plot(\n",
    "        range(1, len(curves['eval_acc_curve']) + 1), curves['eval_acc_curve'], color=plot_colors[index], \n",
    "        label=f\"({num_hidden_layer}, {hidden_size})\", linestyle=plot_linestyles[index]\n",
    "    )\n",
    "\n",
    "axes[0].legend()\n",
    "axes[1].legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在最终性能表现上，前4个模型相差无几，正确率都能达到$89\\%$左右。在训练过程中，深层网络的收敛速度慢。当模型层数增加到4以上时，模型无法正常收敛。\n",
    "\n",
    "以上两个现象可分析得知：深层网络容易出现梯度消失的问题。需要采用残差网络等结构优化。\n",
    "\n",
    "在用时上，由于模型较小，数据集也较小，GPU算力较高，用时基本没有差别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务五\n",
    "\n",
    "**在多分类任务实验中分别手动实现和用torch.nn实现dropout**\n",
    "\n",
    "- 探究不同丢弃率对实验结果的影响（可用loss曲线进行展示）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "手动实现Dropout。\n",
    "\n",
    "由于需要判断此时传入的张量是否是训练状态，需要继承`nn.Module`来获取`self.training`，否则需要手动传入training参数。这里采取前者。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入：\n",
      "tensor([[ 1.,  2.,  3.,  4.,  5.],\n",
      "        [ 6.,  7.,  8.,  9., 10.]])\n",
      "My_Dropout输出：\n",
      "tensor([[ 2.,  0.,  0.,  0.,  0.],\n",
      "        [ 0., 14.,  0.,  0.,  0.]])\n",
      "nn.Dropout输出：\n",
      "tensor([[ 0.,  4.,  6.,  8.,  0.],\n",
      "        [12., 14.,  0., 18.,  0.]])\n"
     ]
    }
   ],
   "source": [
    "class My_Dropout(nn.Module):\n",
    "    def __init__(self, p=0.5):\n",
    "        super().__init__()\n",
    "        self.p = p\n",
    "        self.mask = None\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        if self.training:\n",
    "            mask = (torch.rand(x.shape, device=x.device) > self.p).to(x.dtype)\n",
    "            return x * mask / (1 - self.p)\n",
    "        else:\n",
    "            return x\n",
    "            \n",
    "\n",
    "# 测试\n",
    "my_dropout = My_Dropout(p=0.5)\n",
    "nn_dropout = nn.Dropout(p=0.5)\n",
    "x = torch.tensor([[1.0, 2.0, 3.0, 4.0, 5.0],\n",
    "                  [6.0, 7.0, 8.0, 9.0, 10.0]])\n",
    "print(f\"输入：\\n{x}\")\n",
    "output_my_dropout = my_dropout(x)\n",
    "output_nn_dropout = nn_dropout(x)\n",
    "print(f\"My_Dropout输出：\\n{output_my_dropout}\")\n",
    "print(f\"nn.Dropout输出：\\n{output_nn_dropout}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用手动实现的Dropout进行多分类任务训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9dbe15ae148c48f1b3b63f5fc56aaa98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '9559.07', 'Scaled Total Valid Loss': '1025.22', 'Avg Valid Acc': '61.21%'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '891.85', 'Scaled Total Valid Loss': '729.12', 'Avg Valid Acc': '65.64%'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '691.14', 'Scaled Total Valid Loss': '601.95', 'Avg Valid Acc': '67.76%'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '592.68', 'Scaled Total Valid Loss': '530.28', 'Avg Valid Acc': '68.37%'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '538.68', 'Scaled Total Valid Loss': '479.18', 'Avg Valid Acc': '69.71%'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '494.34', 'Scaled Total Valid Loss': '462.81', 'Avg Valid Acc': '70.04%'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '468.10', 'Scaled Total Valid Loss': '449.81', 'Avg Valid Acc': '70.69%'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '439.43', 'Scaled Total Valid Loss': '412.36', 'Avg Valid Acc': '71.97%'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '422.94', 'Scaled Total Valid Loss': '407.92', 'Avg Valid Acc': '72.54%'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '401.58', 'Scaled Total Valid Loss': '408.63', 'Avg Valid Acc': '73.58%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_5_1():\n",
    "    def __init__(\n",
    "        self, \n",
    "        dropout_p: float = 0.5,\n",
    "        input_features: int = 784, \n",
    "        num_classes: int = 10\n",
    "    ):\n",
    "        self.flatten = My_Flatten()\n",
    "        self.fc1 = My_Linear(in_features=input_features, out_features=1024)\n",
    "        self.leakyrelu = My_LeakyReLU()\n",
    "        self.dropout = My_Dropout(p=dropout_p)\n",
    "        self.fc2 = My_Linear(in_features=1024, out_features=num_classes)\n",
    "        self.params = self.fc1.params + self.fc2.params\n",
    "\n",
    "    def __call__(self, x: torch.Tensor):\n",
    "            return self.forward(x)\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = self.flatten(x)\n",
    "        x = self.dropout(self.leakyrelu(self.fc1(x)))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "    def to(self, device: str):\n",
    "        for param in self.params:\n",
    "            param.data = param.data.to(device=device)\n",
    "        return self\n",
    "\n",
    "    def parameters(self):\n",
    "        return self.params\n",
    "    \n",
    "    def train(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = True\n",
    "    \n",
    "    def eval(self):\n",
    "        for param in self.params:\n",
    "            param.requires_grad = False\n",
    "\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "model = Model_5_1(\n",
    "    input_features=image_width * image_height, \n",
    "    num_classes=num_classes\n",
    ").to(device)\n",
    "\n",
    "trainer = MultiCLSTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "    optimizer='manual', criterion='manual', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "探究不同丢弃率对实验结果的影响。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型1（丢弃率为0.0）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "00396f5e8fd24b02ac36d992f605f531",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '12.82', 'Scaled Total Valid Loss': '13.02', 'Avg Valid Acc': '93.18%'}\n",
      "模型2（丢弃率为0.2）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e028a3f0518b4d68b77b14c4c0c4b57d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '14.17', 'Scaled Total Valid Loss': '13.75', 'Avg Valid Acc': '93.04%'}\n",
      "模型3（丢弃率为0.5）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9da2c9753e554db4b60eb7e664eaf1aa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '16.85', 'Scaled Total Valid Loss': '15.49', 'Avg Valid Acc': '92.30%'}\n",
      "模型4（丢弃率为0.9）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da2f65ed7845400a9e4123e3cf1195db",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '102.58', 'Scaled Total Valid Loss': '102.01', 'Avg Valid Acc': '29.78%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_5_2(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        dropout_p: float = None,\n",
    "        input_features: int = 784, \n",
    "        num_classes: int = 10\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(in_features=input_features, out_features=4096),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Dropout(p=dropout_p),\n",
    "            nn.Linear(in_features=4096, out_features=4096),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Dropout(p=dropout_p),\n",
    "            nn.Linear(in_features=4096, out_features=4096),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Dropout(p=dropout_p),\n",
    "            nn.Linear(in_features=4096, out_features=4096),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Dropout(p=dropout_p),\n",
    "            nn.Linear(in_features=4096, out_features=num_classes)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        return self.net(x)\n",
    "        \n",
    "dropout_ratios = [0.0, 0.2, 0.5, 0.9]\n",
    "plot_colors = ['blue', 'green', 'orange', 'purple']\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
    "\n",
    "axes[0].set_xlabel('Epoch')\n",
    "axes[0].set_ylabel('Loss')\n",
    "axes[0].set_title('Validation Loss Curve')\n",
    "axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "axes[1].set_xlabel('Epoch')\n",
    "axes[1].set_ylabel('Accuracy')\n",
    "axes[1].set_title('Validation Accuracy Curve')\n",
    "axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "for index, dropout_ratio in enumerate(dropout_ratios):\n",
    "    model = Model_5_2(dropout_p=dropout_ratio, input_features=image_width * image_height, num_classes=num_classes).to(device)\n",
    "    \n",
    "    print(f\"模型{index + 1}（丢弃率为{dropout_ratio}）开始训练：\")\n",
    "    trainer = MultiCLSTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "        optimizer='torch', criterion='torch', **hyper_params, \n",
    "        plot=False, return_curves=True, log_epoch=10\n",
    "    )\n",
    "    curves = trainer.train()['curves']\n",
    "\n",
    "    axes[0].plot(\n",
    "        range(1, len(curves['eval_loss_curve']) + 1), curves['eval_loss_curve'],\n",
    "        label=f\"dropout={dropout_ratio}\", color=plot_colors[index]\n",
    "    )\n",
    "    axes[1].plot(\n",
    "        range(1, len(curves['eval_acc_curve']) + 1), curves['eval_acc_curve'], \n",
    "        label=f\"dropout={dropout_ratio}\", color=plot_colors[index]\n",
    "    )\n",
    "\n",
    "axes[0].legend()\n",
    "axes[1].legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务六\n",
    "\n",
    "**在多分类任务实验中分别手动实现和用torch.nn实现$L_2$正则化**\n",
    "\n",
    "- 探究惩罚项的权重对实验结果的影响（可用loss曲线进行展示）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$L_2$正则化，又称权重衰减，pytorch的的实现是将$L_2$正则化的系数作为优化器的`weight_decay`参数传入，在`step()`的过程中计算完成。具体原理如下：\n",
    "\n",
    "$L_2$正则化的公式是\n",
    "\n",
    "$$\n",
    "L = L_0 + \\frac{\\lambda }{2n} \\sum_{w}^{}w^2\n",
    "$$\n",
    "\n",
    "其中$L$是进行$L_2$正则化后的损失，$L_0$是损失函数计算出来的原损失，$\\lambda$是$L_2$正则化系数/惩罚项权重（即optimizer的`weight_decay`参数），$n$是样本大小。\n",
    "\n",
    "反向传播：\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\frac{\\partial L}{\\partial w} & = \\frac{\\partial L_0}{\\partial w} + \\sum_{w}^{} \\frac{\\lambda }{n} w \\\\\n",
    "\\frac{\\partial L}{\\partial b} & = \\frac{\\partial L_0}{\\partial b}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "所以，参数更新为：\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "w: & = w - \\frac{\\eta}{n}\\frac{\\partial L_0}{\\partial w} - \\frac{\\eta \\lambda }{n}\\sum_{w}^{}w \\\\\n",
    "b: & = b - \\frac{\\eta}{n}\\frac{\\partial L_0}{\\partial b}\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "其中$\\eta$是学习率。\n",
    "\n",
    "所以，手动在优化器中实现$L_2$正则化如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "params1的梯度为：\n",
      " tensor([[2., 2.]])\n",
      "params2的梯度为：\n",
      " tensor([[2., 2.]])\n",
      "经过L_2正则化后的My_SGD反向传播结果：\n",
      " tensor([[-0.0500,  0.9000]])\n",
      "经过L_2正则化后的torch.optim.SGD反向传播结果：\n",
      " tensor([[-0.0500,  0.9000]])\n"
     ]
    }
   ],
   "source": [
    "class My_SGD:\n",
    "    def __init__(self, params: list[torch.Tensor], lr: float, weight_decay=0.0):\n",
    "        self.params = params\n",
    "        self.lr = lr\n",
    "        self.weight_decay = weight_decay\n",
    "\n",
    "    def step(self):\n",
    "        with torch.no_grad():\n",
    "            for param in self.params:\n",
    "                if param.grad is not None:\n",
    "                    if len(param.data.shape) > 1:\n",
    "                        param.data = param.data - self.lr * (param.grad + self.weight_decay * param.data)\n",
    "                    else:\n",
    "                        param.data = param.data - self.lr * param.grad\n",
    "\n",
    "    def zero_grad(self):\n",
    "        for param in self.params:\n",
    "            if param.grad is not None:\n",
    "                param.grad.data = torch.zeros_like(param.grad.data)\n",
    "\n",
    "\n",
    "# 测试\n",
    "params1 = torch.tensor([[1., 2, ]], requires_grad=True)\n",
    "params2 = torch.tensor([[1., 2, ]], requires_grad=True)\n",
    "\n",
    "my_sgd = My_SGD(params=[params1], lr=0.5, weight_decay=0.1)\n",
    "optim_sgd = torch.optim.SGD(params=[params2], lr=0.5, weight_decay=0.1)\n",
    "my_sgd.zero_grad()\n",
    "optim_sgd.zero_grad()\n",
    "\n",
    "loss1 = 2 * params1.sum()\n",
    "loss2 = 2 * params2.sum()\n",
    " # 偏导为2\n",
    "loss1.backward()\n",
    "loss2.backward()\n",
    "print(\"params1的梯度为：\\n\", params1.grad.data)\n",
    "print(\"params2的梯度为：\\n\", params2.grad.data)\n",
    "\n",
    "my_sgd.step()\n",
    "optim_sgd.step()\n",
    "# 结果为：w - lr * grad - lr * weight_decay_rate * w\n",
    "# w[0] = 1 - 0.5 * 2 - 0.5 * 0.1 * 1 = -0.0500\n",
    "# w[1] = 2 - 0.5 * 2 - 0.5 * 0.1 * 2 = 0.9000\n",
    "print(\"经过L_2正则化后的My_SGD反向传播结果：\\n\", params1.data)\n",
    "print(\"经过L_2正则化后的torch.optim.SGD反向传播结果：\\n\", params2.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用手动实现的带$L_2$正则项的优化器进行多分类任务训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e2d7d0e1bee4e9198ddbac0c330bfdf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '1/10', 'Total Train Loss': '13266.24', 'Scaled Total Valid Loss': '225.38', 'Avg Valid Acc': '67.70%'}\n",
      "{'Epoch': '2/10', 'Total Train Loss': '149.26', 'Scaled Total Valid Loss': '130.71', 'Avg Valid Acc': '52.37%'}\n",
      "{'Epoch': '3/10', 'Total Train Loss': '100.84', 'Scaled Total Valid Loss': '76.51', 'Avg Valid Acc': '60.38%'}\n",
      "{'Epoch': '4/10', 'Total Train Loss': '74.90', 'Scaled Total Valid Loss': '66.35', 'Avg Valid Acc': '65.02%'}\n",
      "{'Epoch': '5/10', 'Total Train Loss': '62.80', 'Scaled Total Valid Loss': '62.20', 'Avg Valid Acc': '68.23%'}\n",
      "{'Epoch': '6/10', 'Total Train Loss': '58.05', 'Scaled Total Valid Loss': '53.42', 'Avg Valid Acc': '75.31%'}\n",
      "{'Epoch': '7/10', 'Total Train Loss': '51.98', 'Scaled Total Valid Loss': '46.64', 'Avg Valid Acc': '79.61%'}\n",
      "{'Epoch': '8/10', 'Total Train Loss': '46.84', 'Scaled Total Valid Loss': '44.85', 'Avg Valid Acc': '79.73%'}\n",
      "{'Epoch': '9/10', 'Total Train Loss': '45.81', 'Scaled Total Valid Loss': '42.45', 'Avg Valid Acc': '82.64%'}\n",
      "{'Epoch': '10/10', 'Total Train Loss': '43.65', 'Scaled Total Valid Loss': '41.54', 'Avg Valid Acc': '83.07%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "    'weight_decay': 0.1\n",
    "}\n",
    "\n",
    "model = Model_5_1(\n",
    "    dropout_p=0.0,\n",
    "    input_features=image_width * image_height, \n",
    "    num_classes=num_classes\n",
    ").to(device)\n",
    "\n",
    "trainer = MultiCLSTrainer(\n",
    "    model=model, \n",
    "    train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "    optimizer=My_SGD, criterion='manual', **hyper_params\n",
    ")\n",
    "_ = trainer.train()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "探究惩罚项的权重对实验结果的影响。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型1（训练正则项系数为0.0）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6b3d5ec1bdba4ed7ba4cc88234ed38d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '110.98', 'Scaled Total Valid Loss': '114.33', 'Avg Valid Acc': '81.89%'}\n",
      "模型2（训练正则项系数为0.1）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ec92266cba764671830a3e4988fbfd55",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '29.31', 'Scaled Total Valid Loss': '29.37', 'Avg Valid Acc': '88.45%'}\n",
      "模型3（训练正则项系数为0.5）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3df5ca2ff3c24baeb7eedb51026b2ed3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '88.02', 'Scaled Total Valid Loss': '87.13', 'Avg Valid Acc': '62.48%'}\n",
      "模型4（训练正则项系数为0.9）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b64214174eb64ea9b8204f3eff1a63ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/590 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '10/10', 'Total Train Loss': '126.15', 'Scaled Total Valid Loss': '125.85', 'Avg Valid Acc': '29.15%'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weight_decays = [0.0, 0.1, 0.5, 0.9]\n",
    "plot_colors = ['blue', 'green', 'orange', 'purple']\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
    "\n",
    "axes[0].set_xlabel('Epoch')\n",
    "axes[0].set_ylabel('Loss')\n",
    "axes[0].set_title('Validation Loss Curve')\n",
    "axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "axes[1].set_xlabel('Epoch')\n",
    "axes[1].set_ylabel('Accuracy')\n",
    "axes[1].set_title('Validation Accuracy Curve')\n",
    "axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "hyper_params_list = [\n",
    "    {\n",
    "        'learning_rate': 6.0e-2, 'num_epochs': 10, 'batch_size': 1024,\n",
    "        'weight_decay': weight_decay\n",
    "    } \n",
    "    for weight_decay in weight_decays\n",
    "]\n",
    "\n",
    "for index, hyper_params in enumerate(hyper_params_list):\n",
    "    model = Model_5_1(dropout_p=0.0, input_features=image_width * image_height, num_classes=num_classes).to(device)\n",
    "    \n",
    "    print(f\"模型{index + 1}（训练正则项系数为{hyper_params['weight_decay']}）开始训练：\")\n",
    "    trainer = MultiCLSTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_mnist_dataset, eval_dataset=test_mnist_dataset, \n",
    "        optimizer='torch', criterion='torch', **hyper_params, \n",
    "        plot=False, return_curves=True, log_epoch=10\n",
    "    )\n",
    "    curves = trainer.train()['curves']\n",
    "\n",
    "    axes[0].plot(\n",
    "        range(1, len(curves['eval_loss_curve']) + 1), curves['eval_loss_curve'],\n",
    "        label=f\"weight_decay={hyper_params['weight_decay']}\", color=plot_colors[index]\n",
    "    )\n",
    "    axes[1].plot(\n",
    "        range(1, len(curves['eval_acc_curve']) + 1), curves['eval_acc_curve'], \n",
    "        label=f\"weight_decay={hyper_params['weight_decay']}\", color=plot_colors[index]\n",
    "    )\n",
    "\n",
    "axes[0].legend()\n",
    "axes[1].legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 任务七\n",
    "\n",
    "**对回归、二分类、多分类任务分别选择上述实验中效果最好的模型，采用10折交叉验证评估实验结果**\n",
    "\n",
    "- 要求除了最终结果外还需以表格的形式展示每折的实验结果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "制造$k$折数据集，将原先的训练集和测试集混合，然后按照$k-1:1$的比例，按照顺序拆分出$k$对训练集和测试集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KFoldDatasetSplitter:\n",
    "    def __init__(self, dataset, k_folds: int=10, shuffle=True):\n",
    "        self.dataset = dataset\n",
    "        self.k_folds = k_folds\n",
    "        self.shuffle = shuffle\n",
    "\n",
    "        self.kfold = KFold(n_splits=k_folds, shuffle=shuffle, random_state=seed)\n",
    "        self.indices = list(range(len(dataset)))\n",
    "        self.splits = list(self.kfold.split(self.indices))\n",
    "\n",
    "    def get_fold(self, fold_idx: int):\n",
    "        assert 0 <= fold_idx and fold_idx < self.k_folds, \"fold_idx out of range\"\n",
    "\n",
    "        train_idx, val_idx = self.splits[fold_idx]\n",
    "        train_subset = Subset(self.dataset, train_idx)\n",
    "        val_subset = Subset(self.dataset, val_idx)\n",
    "\n",
    "        return train_subset, val_subset\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.k_folds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "回归任务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第1组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0641e17cd94442ccbd2c7afdac1e8a07",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第2组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d65f57bd9cc14a6c92f60b928f99216f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第3组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8226c7daceea4e31b45e8bae315d2da9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第4组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5927294759164291ac72e21cb3d8c749",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第5组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5701394f8af84d18a401983cf6bd987b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第6组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9a5f5c8452ad4ca4a74af47a48be1874",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第7组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9f7b16a4ddaa4ca99d6df3320c58ef40",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第8组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "027149f395c04b98bb92833db10a39f2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第9组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56e6c82ea2e04cc78a07be823ff737c8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第10组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d49f7a2f18ef4f0d81344a3fe5050998",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/70 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k_fold_splitter = KFoldDatasetSplitter(train_regression_dataset, k_folds=10, shuffle=True)\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 1.0e-1,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "eval_errors = []\n",
    "test_errors = []\n",
    "\n",
    "for index in range(len(k_fold_splitter)):\n",
    "    model = Model_2_1().to(device)\n",
    "    train_dataset, eval_dataset = k_fold_splitter.get_fold(fold_idx=index)\n",
    "    print(f\"模型使用第{index + 1}组数据开始训练：\")\n",
    "    trainer = RegressionTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_dataset, eval_dataset=eval_dataset, test_dataset=test_regression_dataset,\n",
    "        optimizer='torch', criterion='torch', **hyper_params,\n",
    "        plot=False, print_test_result=False, return_curves=True, log_epoch=0\n",
    "    )\n",
    "    train_result = trainer.train()\n",
    "    eval_errors.append(train_result['curves']['eval_error_curve'][-1])\n",
    "    test_errors.append(train_result['test_error'])\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 3.5))\n",
    "\n",
    "fold_indices = list(range(1, len(k_fold_splitter) + 1))\n",
    "bar_width = 0.35\n",
    "x = np.arange(len(fold_indices))\n",
    "\n",
    "val_bars = ax.bar(x - bar_width / 2, eval_errors, width=bar_width, label='Validation Error', color='blue')\n",
    "test_bars = ax.bar(x + bar_width / 2, test_errors, width=bar_width, label='Test Error', color='green')\n",
    "\n",
    "ax.set_xlabel('Fold Index')\n",
    "ax.set_ylabel('Error')\n",
    "ax.set_title('Validation vs Test Error per Fold')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(fold_indices)\n",
    "ax.legend()\n",
    "ax.grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "for bar in val_bars:\n",
    "    height = bar.get_height()\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2, height + 0.01, f'{height:.2f}', ha='center', va='bottom', fontsize=6)\n",
    "for bar in test_bars:\n",
    "    height = bar.get_height()\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2, height + 0.01, f'{height:.2f}', ha='center', va='bottom', fontsize=6)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二分类任务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第1组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c57b0a4859784e3280f53bf5f4164c33",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第2组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "079afdc2f16c4b0b869f2a01ea8b840f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第3组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "679d20dbe5c44bc8a217c9386315ddcb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第4组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9006f8c98bc94b018c827de176d3af50",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第5组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c4504d6d1b0a42f9b4ffdc6f55363937",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第6组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2482e7d3bb7c495e8edd076be4b1a6f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第7组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dadb3037e4fc4871b0276b28be78ea66",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第8组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e406d666bba14671836e39896290ad7f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第9组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c7d2ccc316d424d89947ad9c1723507",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第10组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2dce934fdd67423a93b63077d639b3b0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/130 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k_fold_splitter = KFoldDatasetSplitter(train_binarycls_dataset, k_folds=10, shuffle=True)\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 5.0e-4,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "eval_accs = []\n",
    "test_accs = []\n",
    "\n",
    "for index in range(len(k_fold_splitter)):\n",
    "    model = Model_2_2().to(device)\n",
    "    train_dataset, eval_dataset = k_fold_splitter.get_fold(fold_idx=index)\n",
    "    print(f\"模型使用第{index + 1}组数据开始训练：\")\n",
    "    trainer = BinaryCLSTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_dataset, eval_dataset=eval_dataset, test_dataset=test_binarycls_dataset,\n",
    "        optimizer='torch', criterion='torch', **hyper_params,\n",
    "        plot=False, print_test_result=False, return_curves=True, log_epoch=0\n",
    "    )\n",
    "    train_result = trainer.train()\n",
    "    eval_accs.append(train_result['curves']['eval_acc_curve'][-1])\n",
    "    test_accs.append(train_result['test_acc'])\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 3.5))\n",
    "\n",
    "fold_indices = list(range(1, len(k_fold_splitter) + 1))\n",
    "bar_width = 0.35\n",
    "x = np.arange(len(fold_indices))\n",
    "\n",
    "val_bars = ax.bar(x - bar_width / 2, eval_accs, width=bar_width, label='Validation Accuracy', color='blue')\n",
    "test_bars = ax.bar(x + bar_width / 2, test_accs, width=bar_width, label='Test Accuracy', color='green')\n",
    "\n",
    "ax.set_xlabel('Fold Index')\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_title('Validation vs Test Accuracy per Fold')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(fold_indices)\n",
    "ax.legend()\n",
    "ax.grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "for bar in val_bars:\n",
    "    height = bar.get_height()\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2, height + 0.01, f'{height:.1%}', ha='center', va='bottom', fontsize=6)\n",
    "for bar in test_bars:\n",
    "    height = bar.get_height()\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2, height + 0.01, f'{height:.1%}', ha='center', va='bottom', fontsize=6)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多分类任务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第1组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f652aaa3f4b4473d9bbbf665dc40f192",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第2组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "901264600ad748ffaa5ab2686f00fc32",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第3组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "48c504bc95ee416fa9d8944055316252",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第4组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e55b6fd11c2543219431f5e1a4e36035",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第5组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "84894cc1acd341d3acb382086ca5385c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第6组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "12dbe3dcad12468db8a45469a5414061",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第7组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "442979584cfb496c9f25a2202cce1b01",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第8组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "80c1a91a078e4661b00032fa61d84599",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第9组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "109925cad5f2476d83633fd833874143",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型使用第10组数据开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e894ae192ec4251b07f55c5cf594a4a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/530 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k_fold_splitter = KFoldDatasetSplitter(train_mnist_dataset, k_folds=10, shuffle=True)\n",
    "\n",
    "hyper_params = {\n",
    "    'learning_rate': 6.0e-2,\n",
    "    'num_epochs': 10,\n",
    "    'batch_size': 1024,\n",
    "}\n",
    "\n",
    "eval_accs = []\n",
    "test_accs = []\n",
    "\n",
    "for index in range(len(k_fold_splitter)):\n",
    "    model = Model_4(\n",
    "        num_hidden_layer=4, hidden_size=1024, \n",
    "        input_features=image_width * image_height, num_classes=num_classes\n",
    "    ).to(device)\n",
    "    train_dataset, eval_dataset = k_fold_splitter.get_fold(fold_idx=index)\n",
    "    print(f\"模型使用第{index + 1}组数据开始训练：\")\n",
    "    trainer = MultiCLSTrainer(\n",
    "        model=model, \n",
    "        train_dataset=train_dataset, eval_dataset=eval_dataset, test_dataset=test_mnist_dataset,\n",
    "        optimizer='torch', criterion='torch', **hyper_params,\n",
    "        plot=False, print_test_result=False, return_curves=True, log_epoch=0\n",
    "    )\n",
    "    train_result = trainer.train()\n",
    "    eval_accs.append(train_result['curves']['eval_acc_curve'][-1])\n",
    "    test_accs.append(train_result['test_acc'])\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 3.5))\n",
    "\n",
    "fold_indices = list(range(1, len(k_fold_splitter) + 1))\n",
    "bar_width = 0.35\n",
    "x = np.arange(len(fold_indices))\n",
    "\n",
    "val_bars = ax.bar(x - bar_width / 2, eval_accs, width=bar_width, label='Validation Accuracy', color='blue')\n",
    "test_bars = ax.bar(x + bar_width / 2, test_accs, width=bar_width, label='Test Accuracy', color='green')\n",
    "\n",
    "ax.set_xlabel('Fold Index')\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_title('Validation vs Test Accuracy per Fold')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(fold_indices)\n",
    "ax.legend()\n",
    "ax.grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "for bar in val_bars:\n",
    "    height = bar.get_height()\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2, height + 0.01, f'{height:.1%}', ha='center', va='bottom', fontsize=5.5)\n",
    "for bar in test_bars:\n",
    "    height = bar.get_height()\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2, height + 0.01, f'{height:.1%}', ha='center', va='bottom', fontsize=5.5)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}