1780 lines
384 KiB
Plaintext
1780 lines
384 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"<p style=\"text-align: center;\"><img alt=\"school-logo\" src=\"../images/school_logo.png\" style=\"zoom: 50%;\" /></p>\n",
|
||
"\n",
|
||
"<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;\">深度学习</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;\">21281280</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;\">物联网2101班</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;\">2023年10月24日</span></div>\n",
|
||
"</div>"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"实验环境：\n",
|
||
"- OS：WSL2 Ubuntu-22.04 (Kernel: 5.15.90.1-microsoft-standard-WSL2)\n",
|
||
"- CPU：12th Gen Intel(R) Core(TM) i7-12700H\n",
|
||
"- GPU：NVIDIA GeForce RTX 3070 Ti Laptop\n",
|
||
"- cuda: 12.3\n",
|
||
"- conda: miniconda 23.9.0\n",
|
||
"- python：3.10.13\n",
|
||
"- pytorch：2.1.0"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 1,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import time\n",
|
||
"import numpy as np\n",
|
||
"import torch\n",
|
||
"from torch.nn.functional import *\n",
|
||
"from torch.utils.data import Dataset, DataLoader\n",
|
||
"from torch import nn\n",
|
||
"from torchvision import datasets, transforms\n",
|
||
"import matplotlib.pyplot as plt"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"引用相关库。"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 任务一\n",
|
||
"**手动实现前馈神经网络解决上述回归、二分类、多分类任务。**\n",
|
||
"- 从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先生成数据集。\n",
|
||
"\n",
|
||
"一共有3个数据集：\n",
|
||
"\n",
|
||
"1. 回归任务数据集。\n",
|
||
" - 生成单个数据集。\n",
|
||
" - 数据集的大小为$10000$且训练集大小为$7000$，测试集大小为$3000$。\n",
|
||
" - 数据集的样本特征维度$p$为$500$，且服从如下的高维线性函数：$y = 0.028 + \\sum_{p}^{i=1}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$到$1$。为每个图像都被平展并转换为$784$（$28 \\times 28$）个特征的一维numpy数组。 "
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"实现回归任务数据集。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 2,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"训练数据集大小：7000，测试数据集大小：3000\n",
|
||
"训练数据集的第1对数据：\n",
|
||
"x[0]第1个特征维度数据x[0][0] = 0.002744067460298538\n",
|
||
"y[0] = tensor([0.0210])\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"class My_Regression_Dataset(Dataset):\n",
|
||
" def __init__(self, train=True):\n",
|
||
" data_size = 7000 if train else 3000\n",
|
||
" np.random.seed(0)\n",
|
||
" x = np.random.rand(data_size, 500) * 0.005\n",
|
||
" noise = np.random.randn(data_size) * 1e-7\n",
|
||
" y = 0.028 - 0.0056 * x.sum(axis=1) + noise\n",
|
||
" y = y.reshape(-1, 1)\n",
|
||
" self.data = [[x[i], y[i]] for i in range(x.shape[0])]\n",
|
||
"\n",
|
||
" def __len__(self):\n",
|
||
" return len(self.data)\n",
|
||
"\n",
|
||
" def __getitem__(self, index):\n",
|
||
" x, y = self.data[index]\n",
|
||
" x = torch.FloatTensor(x)\n",
|
||
" y = torch.FloatTensor(y)\n",
|
||
" return x, y\n",
|
||
"\n",
|
||
" \n",
|
||
"# 测试，并后面的训练创建变量\n",
|
||
"train_regression_dataset = My_Regression_Dataset(train=True)\n",
|
||
"test_regression_dataset = My_Regression_Dataset(train=False)\n",
|
||
"\n",
|
||
"train_regression_dataset_size = len(train_regression_dataset)\n",
|
||
"test_regression_dataset_size = len(test_regression_dataset)\n",
|
||
"print(f\"训练数据集大小：{train_regression_dataset_size}，测试数据集大小：{test_regression_dataset_size}\")\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": 3,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"训练数据集大小：14000，测试数据集大小：6000\n",
|
||
"训练数据集的第1对数据：\n",
|
||
"x[0]第1个特征维度数据x[0][0] = -0.519691526889801\n",
|
||
"y[0] = tensor([0])\n",
|
||
"训练数据集的第7001对数据：\n",
|
||
"x[7000]第1个特征维度数据x[7000][0] = 0.3035626709461212\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",
|
||
" \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",
|
||
" \n",
|
||
" labels_1 = np.zeros((num_samples, 1))\n",
|
||
" labels_2 = np.ones((num_samples, 1))\n",
|
||
" \n",
|
||
" x = np.concatenate((x_1, x_2), axis=0)\n",
|
||
" labels = np.concatenate((labels_1, labels_2), axis=0)\n",
|
||
" self.data = [[x[i], labels[i]] for i in range(2 * num_samples)]\n",
|
||
"\n",
|
||
" def __len__(self):\n",
|
||
" return len(self.data)\n",
|
||
"\n",
|
||
" def __getitem__(self, index):\n",
|
||
" x, y = self.data[index]\n",
|
||
" x = torch.FloatTensor(x)\n",
|
||
" y = torch.LongTensor(y)\n",
|
||
" return x, y\n",
|
||
"\n",
|
||
"\n",
|
||
"# 测试，并后面的训练创建变量\n",
|
||
"train_binarycls_dataset = My_BinaryCLS_Dataset(train=True)\n",
|
||
"test_binarycls_dataset = My_BinaryCLS_Dataset(train=False)\n",
|
||
"\n",
|
||
"train_binarycls_dataset_size = len(train_binarycls_dataset)\n",
|
||
"test_binarycls_dataset_size = len(test_binarycls_dataset)\n",
|
||
"print(f\"训练数据集大小：{train_binarycls_dataset_size}，测试数据集大小：{test_binarycls_dataset_size}\")\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": [
|
||
"首先造一个展示图片的函数。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 4,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"def imshow(img):\n",
|
||
" img = img.squeeze().numpy()\n",
|
||
" plt.figure(figsize=(1.5, 1.5))\n",
|
||
" plt.imshow(img)\n",
|
||
" plt.axis('off')\n",
|
||
" plt.show()"
|
||
]
|
||
},
|
||
{
|
||
"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",
|
||
"训练数据集的第1对数据：\n",
|
||
"x[0]第1个特征维度数据x[0]的大小 = torch.Size([1, 28, 28])\n",
|
||
"y[0] = 5\n",
|
||
"x[0]的图像：\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAIcAAACHCAYAAAA850oKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAFI0lEQVR4nO3df2jUdRzH8W53pplLXaYp2Fw621BzlZSmuCA0/+iPItYQ/1r0R5qKtcCSoB9YWESwzPxDsClkmVLkH/0gIkRILTMMi1zoRuhstR3OUmvz7vq31333ujv3ndvd7vn473V8v7vv5OVnb773/X4vkkqlUtcAfSgZ6gNA/qIcsCgHLMoBi3LAohywKAcsygGLcsCK5brhkpK6q3kcGGRfJvdk3YaVAxblgEU5YFEOWJQDFuWARTlgUQ5YlAMW5YBFOWBRDliUAxblgEU5YFEOWJQDFuWARTlg5XwN6XARiemvHL1pwhXtf+KZaZITo5OBbcqn/yF59KqI5N/fvFby0Xm7JXcmLki+Z0+j5BlPH8rpWMNi5YBFOWBRDlgFNXNEqyslp0aOkNxeOy6wz6X5+ve7bKzmA3P17/1A+OxiqeTX3l4m+fCcXZJbey9J3tSxRPKUA0Pz8CVWDliUAxblgBXJ9WmCQ3GvbOK+OyU3NW+RPHOEni8YCr2pROC1e19fJzl2IfM/cemZy5JHduoMkjpyvH8HlwH3yiIUygGLcsDK6/McI0+0S/7+n6mSZ47oGPD3bDw7X/Kpv/Wzl+bpeyV3J4PzxKS3vgl1DPnySGlWDliUAxblgJXX5znSxRsWSD6/TD8nif44JrDPsVWbM/7MjZ23S/6uVmeMxLluyakFcyW3rQ3+zIrlxzK+Zz7gPAdCoRywKAesgpo50kUn3Cg50RUPbNO6S2eKnxZvl3z3q2skT9wS7hxFoWDmQCiUAxblgEU5YOX1B2/ZJDq7sm7Tez7zBUGzVvws+c+tUd0gGbyYp1iwcsCiHLAoB6yCnjlyUb2+RXLDnPslv1v+leTauicll+4enJuW8xErByzKAYtywBr2M0f6xTpdK6sl/7ZPbyB6duNOyc89+rDk1A9jJU995WDwTXP7LDPvsXLAohywKAesgr7YZyDEH9OLlt974Q3JFbFRGfeftXN14LXKbWclXz7V1r+Du4q42AehUA5YlANW0c8c6VILayTfsOm05Pdv/SLrz6j6+nHJt72k51oSv57q38ENIGYOhEI5YFEOWMwcWUQnTZTcXj9D8uH1TYF9StL+z61oXSq5e1H2a1+vNmYOhEI5YFEOWMwcIX14Ong9x+iI3itzMdUj+cE163T7jw8P+HFlw8yBUCgHLMoBi3LAGvYXGF+p5KIaySfr9GKf2TVtktOHz75sjt+h+3xypF/HNthYOWBRDliUA1bRzRyRebMlt6zVmWHbwh2SF4/SE1i5+DfVK/lQvEI3SOoFyPmKlQMW5YBFOWANq5kjVlEeeO1kwxTJL9Z/IPmRMZ2h3nNDx7zAa/ub9Nuexu/o42brAsDKAYtywKIcsApq5ohNu0Vy912TJde//HlgnyfGfRTqPdO/LfLgOzpjlDV/G9hnfLIwZ4x0rBywKAcsygErr2aO2OSbJce3Xy95ZcV+yctLw38j9eoziyQf3VojecLe45LL/hoe80QuWDlgUQ5YlAPWoM4cPQ/oOYKep/TbHDfM+FTy0uv0G6f7oyOhD6FdvK9RctXzv0guO6czRTL0ERQuVg5YlAMW5YA1qDNH20PaxZY52W/m/b8t56ZLbtqvD0WJJCKBfao2tkqu7NCblov36/2yY+WARTlgUQ5YlAMWT/YpUjzZB6FQDliUAxblgEU5YFEOWJQDFuWARTlgUQ5YlANWzp+toPiwcsCiHLAoByzKAYtywKIcsCgHLMoBi3LA+g+uFCia61xwLAAAAABJRU5ErkJggg==",
|
||
"text/plain": [
|
||
"<Figure size 150x150 with 1 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"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",
|
||
"\n",
|
||
"train_mnist_dataset_size = len(train_mnist_dataset)\n",
|
||
"test_mnist_dataset_size = len(test_mnist_dataset)\n",
|
||
"print(f\"训练数据集大小：{train_mnist_dataset_size}，测试数据集大小：{test_mnist_dataset_size}\")\n",
|
||
"\n",
|
||
"x0, y0 = train_mnist_dataset[0]\n",
|
||
"print(f\"训练数据集的第1对数据：\")\n",
|
||
"print(f\"x[0]第1个特征维度数据x[0]的大小 = {x0.shape}\")\n",
|
||
"print(f\"y[0] = {y0}\")\n",
|
||
"print(f\"x[0]的图像：\")\n",
|
||
"imshow(x0)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"接下来手动实现前馈神经网络并训练。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先手动实现一些工具和基本模型层。这些工具都在前一个实验中实现并测试过，在此就不再分析其原理和具体实现步骤，也不在此重新测试。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 6,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"# 手动实现torch.nn.functional.one_hot\n",
|
||
"def my_one_hot(indices: torch.Tensor, num_classes: int):\n",
|
||
" one_hot_tensor = torch.zeros(len(indices), num_classes, dtype=torch.long).to(indices.device)\n",
|
||
" one_hot_tensor.scatter_(1, indices.view(-1, 1), 1)\n",
|
||
" return one_hot_tensor\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.functional.softmax\n",
|
||
"def my_softmax(predictions: torch.Tensor, dim: int):\n",
|
||
" max_values = torch.max(predictions, dim=dim, keepdim=True).values\n",
|
||
" exp_values = torch.exp(predictions - max_values)\n",
|
||
" softmax_output = exp_values / torch.sum(exp_values, dim=dim, keepdim=True)\n",
|
||
" return softmax_output\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.Linear\n",
|
||
"class My_Linear:\n",
|
||
" def __init__(self, in_features: int, out_features: int):\n",
|
||
" self.weight = torch.normal(mean=0.001, std=0.5, size=(out_features, in_features), requires_grad=True, dtype=torch.float32)\n",
|
||
" self.bias = torch.normal(mean=0.001, std=0.5, size=(1,), requires_grad=True, dtype=torch.float32)\n",
|
||
" self.params = [self.weight, self.bias]\n",
|
||
"\n",
|
||
" def __call__(self, x):\n",
|
||
" return self.forward(x)\n",
|
||
"\n",
|
||
" def forward(self, x):\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",
|
||
" x = torch.max(x, torch.tensor(0.0, device=x.device))\n",
|
||
" return x\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.Sigmoid\n",
|
||
"class My_Sigmoid():\n",
|
||
" def __call__(self, x: torch.Tensor):\n",
|
||
" x = 1. / (1. + torch.exp(-x))\n",
|
||
" return x\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.BCELoss\n",
|
||
"class My_BCELoss:\n",
|
||
" def __call__(self, prediction: torch.Tensor, target: torch.Tensor):\n",
|
||
" loss = -torch.mean(target * torch.log(prediction) + (1 - target) * torch.log(1 - prediction))\n",
|
||
" return loss\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.nn.CrossEntropyLoss\n",
|
||
"class My_CrossEntropyLoss:\n",
|
||
" def __call__(self, predictions: torch.Tensor, targets: torch.Tensor):\n",
|
||
" max_values = torch.max(predictions, dim=1, keepdim=True).values\n",
|
||
" exp_values = torch.exp(predictions - max_values)\n",
|
||
" softmax_output = exp_values / torch.sum(exp_values, dim=1, keepdim=True)\n",
|
||
"\n",
|
||
" log_probs = torch.log(softmax_output)\n",
|
||
" nll_loss = -torch.sum(targets * log_probs, dim=1)\n",
|
||
" average_loss = torch.mean(nll_loss)\n",
|
||
" return average_loss\n",
|
||
"\n",
|
||
"\n",
|
||
"# 手动实现torch.optim.SGD\n",
|
||
"class My_optimizer:\n",
|
||
" def __init__(self, params: list[torch.Tensor], lr: float):\n",
|
||
" self.params = params\n",
|
||
" self.lr = lr\n",
|
||
"\n",
|
||
" def step(self):\n",
|
||
" with torch.no_grad():\n",
|
||
" for param in self.params:\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 = torch.zeros_like(param.grad.data)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先造一个显示训练损失和测试正确率的函数。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 7,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"def draw_loss_and_acc(train_loss:list[float], test_acc:list[float]):\n",
|
||
" # train loss\n",
|
||
" plt.figure(figsize=(7, 3.5))\n",
|
||
" plt.subplot(1, 2, 1)\n",
|
||
" plt.plot(range(1, num_epochs + 1), train_loss, label='Train Loss', color='blue')\n",
|
||
" plt.xlabel('Epoch')\n",
|
||
" plt.ylabel('Train Loss')\n",
|
||
" plt.legend()\n",
|
||
" \n",
|
||
" # test acc\n",
|
||
" plt.subplot(1, 2, 2)\n",
|
||
" plt.plot(range(1, num_epochs + 1), test_acc, label='Test Accuracy', color='green')\n",
|
||
" plt.xlabel('Epoch')\n",
|
||
" plt.ylabel('Test Accuracy')\n",
|
||
" plt.legend()\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):\n",
|
||
" self.linear = My_Linear(in_features=500, out_features=1)\n",
|
||
" self.sigmoid = My_Sigmoid()\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",
|
||
" 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": [
|
||
"训练并测试上述回归模型。\n",
|
||
"\n",
|
||
"本次实验不再逐epoch输出损失、正确率和时间，而是每5个epoch输出1次，每个模型训练21个epoch。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 9,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/21], Train Loss: 1.1030388400, Used Time: 1353.186ms, Test Acc: 35.957%, Used Time: 266.134ms\n",
|
||
"Epoch [6/21], Train Loss: 0.7133886367, Used Time: 260.719ms, Test Acc: 98.385%, Used Time: 276.593ms\n",
|
||
"Epoch [11/21], Train Loss: 0.7133838981, Used Time: 262.404ms, Test Acc: 98.545%, Used Time: 246.299ms\n",
|
||
"Epoch [16/21], Train Loss: 0.7133851796, Used Time: 269.623ms, Test Acc: 98.545%, Used Time: 253.705ms\n",
|
||
"Epoch [21/21], Train Loss: 0.7133822516, Used Time: 263.288ms, Test Acc: 98.545%, Used Time: 250.530ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 700x350 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 5\n",
|
||
"num_epochs = 21\n",
|
||
"batch_size = 1024\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_1_1().to(device)\n",
|
||
"criterion = My_BCELoss()\n",
|
||
"optimizer = My_optimizer(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
" \n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" \n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" total_epoch_acc += (1 - torch.abs(y_pred - targets) / torch.abs(targets)).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_regression_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"手动构建二分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 10,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_1_2:\n",
|
||
" def __init__(self):\n",
|
||
" self.fc = My_Linear(in_features=200, 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": 11,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/21], Train Loss: 32.8091183305, Used Time: 697.000ms, Test Acc: 52.767%, Used Time: 258.649ms\n",
|
||
"Epoch [6/21], Train Loss: 0.8007395566, Used Time: 290.056ms, Test Acc: 99.600%, Used Time: 257.690ms\n",
|
||
"Epoch [11/21], Train Loss: 0.3398014214, Used Time: 282.811ms, Test Acc: 99.983%, Used Time: 249.543ms\n",
|
||
"Epoch [16/21], Train Loss: 0.2110017957, Used Time: 280.831ms, Test Acc: 99.983%, Used Time: 261.706ms\n",
|
||
"Epoch [21/21], Train Loss: 0.1522123339, Used Time: 290.631ms, Test Acc: 100.000%, Used Time: 251.535ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 700x350 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 8e-3\n",
|
||
"num_epochs = 21\n",
|
||
"batch_size = 1024\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_1_2().to(device)\n",
|
||
"criterion = My_BCELoss()\n",
|
||
"optimizer = My_optimizer(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
" \n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device).to(dtype=torch.float)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" output = model(x)\n",
|
||
" pred = (output > 0.5).to(dtype=torch.long)\n",
|
||
" total_epoch_acc += (pred == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
"\n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_binarycls_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"手动构建MNIST多分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 12,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_1_3:\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" self.flatten = My_Flatten()\n",
|
||
" self.linear = My_Linear(in_features=28 * 28, 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": 13,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/21], Train Loss: 193.7902541161, Used Time: 917.054ms, Test Acc: 48.590%, Used Time: 425.420ms\n",
|
||
"Epoch [6/21], Train Loss: 37.7431737185, Used Time: 983.078ms, Test Acc: 77.800%, Used Time: 443.390ms\n",
|
||
"Epoch [11/21], Train Loss: 27.9078875780, Used Time: 983.323ms, Test Acc: 82.270%, Used Time: 426.247ms\n",
|
||
"Epoch [16/21], Train Loss: 23.6815550327, Used Time: 982.686ms, Test Acc: 84.340%, Used Time: 410.447ms\n",
|
||
"Epoch [21/21], Train Loss: 21.1408505440, Used Time: 946.963ms, Test Acc: 85.450%, Used Time: 385.761ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 700x350 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 1e-1\n",
|
||
"num_epochs = 21\n",
|
||
"batch_size = 2048\n",
|
||
"num_classes = 10\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_loader = DataLoader(dataset=train_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_loader = DataLoader(dataset=test_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_1_3(num_classes).to(device)\n",
|
||
"criterion = My_CrossEntropyLoss()\n",
|
||
"optimizer = My_optimizer(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (images, targets) in enumerate(train_loader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" images = images.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" one_hot_targets = my_one_hot(targets, num_classes=num_classes).to(dtype=torch.float)\n",
|
||
"\n",
|
||
" outputs = model(images)\n",
|
||
" loss = criterion(outputs, one_hot_targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (image, targets) in enumerate(test_loader):\n",
|
||
" image = image.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" outputs = model(image)\n",
|
||
" pred = my_softmax(outputs, dim=1)\n",
|
||
" total_epoch_acc += (pred.argmax(1) == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 任务二\n",
|
||
"**利用torch.nn实现前馈神经网络解决上述回归、二分类、多分类任务。**\n",
|
||
"- 从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用`torch.nn`构建回归任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 14,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_2_1(nn.Module):\n",
|
||
" def __init__(self):\n",
|
||
" super().__init__()\n",
|
||
" self.linear = nn.Linear(in_features=500, 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": 15,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/21], Train Loss: 1.4070934802, Used Time: 286.710ms, Test Acc: 40.067%, Used Time: 255.361ms\n",
|
||
"Epoch [6/21], Train Loss: 0.7133745328, Used Time: 262.477ms, Test Acc: 99.014%, Used Time: 257.300ms\n",
|
||
"Epoch [11/21], Train Loss: 0.7133530825, Used Time: 272.271ms, Test Acc: 99.332%, Used Time: 260.335ms\n",
|
||
"Epoch [16/21], Train Loss: 0.7133620456, Used Time: 272.843ms, Test Acc: 99.332%, Used Time: 258.615ms\n",
|
||
"Epoch [21/21], Train Loss: 0.7133617774, Used Time: 267.960ms, Test Acc: 99.332%, Used Time: 260.866ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 700x350 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 5\n",
|
||
"num_epochs = 21\n",
|
||
"batch_size = 1024\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_regression_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_2_1().to(device)\n",
|
||
"criterion = nn.BCELoss()\n",
|
||
"optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
" \n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" \n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" total_epoch_acc += (1 - torch.abs(y_pred - targets) / torch.abs(targets)).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_regression_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用`torch.nn`构建二分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 16,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_2_2(nn.Module):\n",
|
||
" def __init__(self):\n",
|
||
" super().__init__()\n",
|
||
" self.fc = nn.Linear(in_features=200, 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": 17,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/21], Train Loss: 8.2741773129, Used Time: 289.847ms, Test Acc: 97.267%, Used Time: 259.124ms\n",
|
||
"Epoch [6/21], Train Loss: 7.3801211119, Used Time: 291.994ms, Test Acc: 99.900%, Used Time: 252.881ms\n",
|
||
"Epoch [11/21], Train Loss: 6.6250074506, Used Time: 297.947ms, Test Acc: 100.000%, Used Time: 264.765ms\n",
|
||
"Epoch [16/21], Train Loss: 5.9835222065, Used Time: 297.365ms, Test Acc: 100.000%, Used Time: 265.306ms\n",
|
||
"Epoch [21/21], Train Loss: 5.4366103113, Used Time: 291.419ms, Test Acc: 100.000%, Used Time: 261.692ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 700x350 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 1e-4\n",
|
||
"num_epochs = 21\n",
|
||
"batch_size = 1024\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_dataloader = DataLoader(dataset=train_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"test_dataloader = DataLoader(dataset=test_binarycls_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_2_2().to(device)\n",
|
||
"criterion = nn.BCELoss()\n",
|
||
"optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(train_dataloader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device).to(dtype=torch.float32)\n",
|
||
" \n",
|
||
" y_pred = model(x)\n",
|
||
" loss = criterion(y_pred, targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (x, targets) in enumerate(test_dataloader):\n",
|
||
" x = x.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" output = model(x)\n",
|
||
" pred = (output > 0.5).to(dtype=torch.long)\n",
|
||
" total_epoch_acc += (pred == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
"\n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_binarycls_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"使用`torch.nn`构建MNIST多分类任务的模型。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 18,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"class Model_2_3(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.linear = nn.Linear(in_features=28 * 28, 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": 19,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Epoch [1/21], Train Loss: 39.7126239538, Used Time: 1002.760ms, Test Acc: 77.470%, Used Time: 413.127ms\n",
|
||
"Epoch [6/21], Train Loss: 12.7497836053, Used Time: 988.396ms, Test Acc: 89.530%, Used Time: 415.606ms\n",
|
||
"Epoch [11/21], Train Loss: 11.1715984643, Used Time: 1025.708ms, Test Acc: 90.290%, Used Time: 439.041ms\n",
|
||
"Epoch [16/21], Train Loss: 10.4914320111, Used Time: 970.570ms, Test Acc: 90.670%, Used Time: 460.806ms\n",
|
||
"Epoch [21/21], Train Loss: 10.0342348516, Used Time: 984.248ms, Test Acc: 91.010%, Used Time: 418.183ms\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"image/png": "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",
|
||
"text/plain": [
|
||
"<Figure size 700x350 with 2 Axes>"
|
||
]
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data"
|
||
}
|
||
],
|
||
"source": [
|
||
"learning_rate = 5e-2\n",
|
||
"num_epochs = 21\n",
|
||
"batch_size = 2048\n",
|
||
"num_classes = 10\n",
|
||
"device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
"\n",
|
||
"train_loader = DataLoader(dataset=train_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True,)\n",
|
||
"test_loader = DataLoader(dataset=test_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14,pin_memory=True)\n",
|
||
"\n",
|
||
"model = Model_2_3(num_classes).to(device)\n",
|
||
"criterion = nn.CrossEntropyLoss()\n",
|
||
"optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
"\n",
|
||
"train_loss = list()\n",
|
||
"test_acc = list()\n",
|
||
"for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (images, targets) in enumerate(train_loader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" images = images.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" one_hot_targets = one_hot(targets, num_classes=num_classes).to(dtype=torch.float)\n",
|
||
"\n",
|
||
" outputs = model(images)\n",
|
||
" loss = criterion(outputs, one_hot_targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (image, targets) in enumerate(test_loader):\n",
|
||
" image = image.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" outputs = model(image)\n",
|
||
" pred = softmax(outputs, dim=1)\n",
|
||
" total_epoch_acc += (pred.argmax(1) == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" \n",
|
||
"draw_loss_and_acc(train_loss, test_acc)"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 任务三\n",
|
||
"**在多分类任务中使用至少三种不同的激活函数。**\n",
|
||
"- 使用不同的激活函数，进行对比实验并分析实验结果\n"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"首先定义一个训练函数。\n",
|
||
"\n",
|
||
"我们将在接下来的测试中复用同一个训练过程，因此将训练过程封装成一个函数。每次使用时将模型传入训练函数，返回训练的损失变化和测试的正确率变化列表以画出其曲线即可。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 20,
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"def train_MNIST_CLS(Model:nn.Module):\n",
|
||
" learning_rate = 8e-2\n",
|
||
" num_epochs = 21\n",
|
||
" batch_size = 2048\n",
|
||
" num_classes = 10\n",
|
||
" device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
|
||
" \n",
|
||
" train_loader = DataLoader(dataset=train_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
" test_loader = DataLoader(dataset=test_mnist_dataset, batch_size=batch_size, shuffle=True, num_workers=14, pin_memory=True)\n",
|
||
"\n",
|
||
" model = Model(num_classes).to(device)\n",
|
||
" criterion = nn.CrossEntropyLoss()\n",
|
||
" optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
|
||
" \n",
|
||
" train_loss = list()\n",
|
||
" test_acc = list()\n",
|
||
" for epoch in range(num_epochs):\n",
|
||
" model.train()\n",
|
||
" total_epoch_loss = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (images, targets) in enumerate(train_loader):\n",
|
||
" optimizer.zero_grad()\n",
|
||
"\n",
|
||
" images = images.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" one_hot_targets = one_hot(targets, num_classes=num_classes).to(dtype=torch.float)\n",
|
||
"\n",
|
||
" outputs = model(images)\n",
|
||
" loss = criterion(outputs, one_hot_targets)\n",
|
||
" total_epoch_loss += loss.item()\n",
|
||
"\n",
|
||
" loss.backward()\n",
|
||
" optimizer.step()\n",
|
||
"\n",
|
||
" end_time = time.time()\n",
|
||
" train_time = end_time - start_time\n",
|
||
"\n",
|
||
" model.eval()\n",
|
||
" with torch.no_grad():\n",
|
||
" total_epoch_acc = 0\n",
|
||
" start_time = time.time()\n",
|
||
" for index, (image, targets) in enumerate(test_loader):\n",
|
||
" image = image.to(device)\n",
|
||
" targets = targets.to(device)\n",
|
||
" \n",
|
||
" outputs = model(image)\n",
|
||
" pred = softmax(outputs, dim=1)\n",
|
||
" total_epoch_acc += (pred.argmax(1) == targets).sum().item()\n",
|
||
" \n",
|
||
" end_time = time.time()\n",
|
||
" test_time = end_time - start_time\n",
|
||
" \n",
|
||
" avg_epoch_acc = total_epoch_acc / len(test_mnist_dataset)\n",
|
||
" if epoch % 5 == 0:\n",
|
||
" print(\n",
|
||
" f\"Epoch [{epoch + 1}/{num_epochs}],\",\n",
|
||
" f\"Train Loss: {total_epoch_loss:.10f},\",\n",
|
||
" f\"Used Time: {train_time * 1000:.3f}ms,\",\n",
|
||
" f\"Test Acc: {avg_epoch_acc * 100:.3f}%,\",\n",
|
||
" f\"Used Time: {test_time * 1000:.3f}ms\",\n",
|
||
" )\n",
|
||
" train_loss.append(total_epoch_loss)\n",
|
||
" test_acc.append(avg_epoch_acc * 100)\n",
|
||
" return train_loss, test_acc"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"接下来定义4个模型，分别使用`nn.functional.relu()`、`nn.functional.sigmoid()`、`nn.functional.tanh()`和`nn.functional.leaky_relu()`作为激活函数。\n",
|
||
"\n",
|
||
"分别训练和测试。并将损失曲线和正确率曲线分别画在一个图内以进行比较4种激活函数的效果。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 21,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"模型1开始训练，激活函数为relu：\n",
|
||
"Epoch [1/21], Train Loss: 61.8182386160, Used Time: 978.523ms, Test Acc: 49.980%, Used Time: 423.773ms\n",
|
||
"Epoch [6/21], Train Loss: 25.5127722025, Used Time: 982.802ms, Test Acc: 73.470%, Used Time: 436.265ms\n",
|
||
"Epoch [11/21], Train Loss: 15.8406201303, Used Time: 1054.201ms, Test Acc: 83.110%, Used Time: 439.752ms\n",
|
||
"Epoch [16/21], Train Loss: 14.4223749340, Used Time: 1017.818ms, Test Acc: 84.240%, Used Time: 447.467ms\n",
|
||
"Epoch [21/21], Train Loss: 13.3417748809, Used Time: 1017.753ms, Test Acc: 84.740%, Used Time: 414.742ms\n",
|
||
"模型2开始训练，激活函数为sigmoid：\n",
|
||
"Epoch [1/21], Train Loss: 69.0693337917, Used Time: 992.551ms, Test Acc: 11.350%, Used Time: 459.880ms\n",
|
||
"Epoch [6/21], Train Loss: 68.9371833801, Used Time: 1079.764ms, Test Acc: 11.350%, Used Time: 452.875ms\n",
|
||
"Epoch [11/21], Train Loss: 68.8318073750, Used Time: 1042.284ms, Test Acc: 11.350%, Used Time: 433.641ms\n",
|
||
"Epoch [16/21], Train Loss: 68.6989393234, Used Time: 1051.316ms, Test Acc: 11.350%, Used Time: 425.384ms\n",
|
||
"Epoch [21/21], Train Loss: 68.5154776573, Used Time: 1010.672ms, Test Acc: 11.860%, Used Time: 478.529ms\n",
|
||
"模型3开始训练，激活函数为tanh：\n",
|
||
"Epoch [1/21], Train Loss: 53.1757580042, Used Time: 1077.345ms, Test Acc: 82.820%, Used Time: 417.360ms\n",
|
||
"Epoch [6/21], Train Loss: 33.2101881504, Used Time: 1019.480ms, Test Acc: 89.520%, Used Time: 425.635ms\n",
|
||
"Epoch [11/21], Train Loss: 31.1644053459, Used Time: 1017.508ms, Test Acc: 90.440%, Used Time: 460.416ms\n",
|
||
"Epoch [16/21], Train Loss: 30.2417434454, Used Time: 1063.097ms, Test Acc: 91.030%, Used Time: 443.540ms\n",
|
||
"Epoch [21/21], Train Loss: 29.6629508138, Used Time: 1108.540ms, Test Acc: 91.440%, Used Time: 422.681ms\n",
|
||
"模型4开始训练，激活函数为leaky_relu：\n",
|
||
"Epoch [1/21], Train Loss: 59.1613249779, Used Time: 1004.892ms, Test Acc: 57.020%, Used Time: 429.153ms\n",
|
||
"Epoch [6/21], Train Loss: 12.9856970310, Used Time: 1100.574ms, Test Acc: 88.430%, Used Time: 425.293ms\n",
|
||
"Epoch [11/21], Train Loss: 9.0050866008, Used Time: 1120.788ms, Test Acc: 90.730%, Used Time: 431.718ms\n",
|
||
"Epoch [16/21], Train Loss: 7.4811368883, Used Time: 1574.020ms, Test Acc: 92.100%, Used Time: 687.461ms\n",
|
||
"Epoch [21/21], Train Loss: 6.7170338333, Used Time: 1530.672ms, Test Acc: 93.410%, Used Time: 626.056ms\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_1(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, 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",
|
||
" self.activate_fn = relu\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",
|
||
"\n",
|
||
"class Model_3_2(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, 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",
|
||
" self.activate_fn = sigmoid\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",
|
||
"\n",
|
||
"class Model_3_3(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, 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",
|
||
" self.activate_fn = tanh\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",
|
||
"class Model_3_4(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, 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",
|
||
" self.activate_fn = leaky_relu\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",
|
||
"\n",
|
||
"# 训练、测试并画图\n",
|
||
"print(\"模型1开始训练，激活函数为relu：\")\n",
|
||
"train_loss_3_1, test_acc_3_1 = train_MNIST_CLS(Model=Model_3_1) # 激活函数为relu\n",
|
||
"print(\"模型2开始训练，激活函数为sigmoid：\")\n",
|
||
"train_loss_3_2, test_acc_3_2 = train_MNIST_CLS(Model=Model_3_2) # 激活函数为sigmoid\n",
|
||
"print(\"模型3开始训练，激活函数为tanh：\")\n",
|
||
"train_loss_3_3, test_acc_3_3 = train_MNIST_CLS(Model=Model_3_3) # 激活函数为tanh\n",
|
||
"print(\"模型4开始训练，激活函数为leaky_relu：\")\n",
|
||
"train_loss_3_4, test_acc_3_4 = train_MNIST_CLS(Model=Model_3_4) # 激活函数为leaky_relu\n",
|
||
"\n",
|
||
"# train loss\n",
|
||
"plt.figure(figsize=(7, 3.5))\n",
|
||
"plt.subplot(1, 2, 1)\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_3_1, label='Relu Model', color='blue')\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_3_2, label='Sigmoid Model', color='green')\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_3_3, label='Tanh Model', color='orange')\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_3_4, label='Leaky Relu Model', color='purple')\n",
|
||
"plt.xlabel('Epoch')\n",
|
||
"plt.ylabel('Train Loss')\n",
|
||
"plt.legend()\n",
|
||
"\n",
|
||
"# test acc\n",
|
||
"plt.subplot(1, 2, 2)\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_3_1, label='Relu Model', color='blue')\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_3_2, label='Sigmoid Model', color='green')\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_3_3, label='Tanh Model', color='orange')\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_3_4, label='Leaky Relu Model', color='purple')\n",
|
||
"plt.xlabel('Epoch')\n",
|
||
"plt.ylabel('Test Accuracy')\n",
|
||
"plt.legend()\n",
|
||
"\n",
|
||
"plt.tight_layout()\n",
|
||
"plt.show()"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"在性能表现上，激活函数为`sigmoid`的模型训练过程中损失下降速度非常慢，可见发生了梯度消失，这验证了`sigmoid`非常容易出现梯度消失的问题。\n",
|
||
"\n",
|
||
"激活函数为`relu`的模型比较不稳定，有时会出现神经元死亡过多（值为$0$）的情况。\n",
|
||
"\n",
|
||
"`tanh`以及`leaky relu`的表现相对优秀。\n",
|
||
"\n",
|
||
"在用时上，`relu`训练的用时相较其他激活函数的用时平均少约$50\\rm ms$，猜测是因为`relu`的计算量少。"
|
||
]
|
||
},
|
||
{
|
||
"attachments": {},
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 任务四\n",
|
||
"**对多分类任务中的模型评估隐藏层层数和隐藏单元个数对实验结果的影响。**\n",
|
||
"- 使用不同的隐藏层层数和隐藏单元个数，进行对比实验并分析实验结果\n"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"接下来定义4个模型，隐藏层层数和隐藏单元个数分别如下：\n",
|
||
"\n",
|
||
"- `Model_4_1`：hidden_size=512, hidden_layer=1\n",
|
||
"- `Model_4_2`：hidden_size=1024, hidden_layer=1\n",
|
||
"- `Model_4_3`：hidden_size=512, hidden_layer=2\n",
|
||
"- `Model_4_4`：hidden_size=1024, hidden_layer=2\n",
|
||
"\n",
|
||
"分别训练和测试。并将损失曲线和正确率曲线分别画在一个图内以进行比较4个模型的效果。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 22,
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"模型1开始训练，hidden_size=512，hidden_layer=1 ：\n",
|
||
"Epoch [1/21], Train Loss: 46.8096676469, Used Time: 2256.211ms, Test Acc: 69.590%, Used Time: 586.215ms\n",
|
||
"Epoch [6/21], Train Loss: 11.3356736004, Used Time: 1152.953ms, Test Acc: 89.530%, Used Time: 520.603ms\n",
|
||
"Epoch [11/21], Train Loss: 9.1393958330, Used Time: 1139.308ms, Test Acc: 92.030%, Used Time: 746.556ms\n",
|
||
"Epoch [16/21], Train Loss: 8.0443021357, Used Time: 1113.647ms, Test Acc: 92.620%, Used Time: 474.136ms\n",
|
||
"Epoch [21/21], Train Loss: 7.1652033627, Used Time: 1088.146ms, Test Acc: 93.250%, Used Time: 449.901ms\n",
|
||
"模型2开始训练，hidden_size=1024，hidden_layer=1 ：\n",
|
||
"Epoch [1/21], Train Loss: 46.0817536116, Used Time: 1064.347ms, Test Acc: 74.630%, Used Time: 450.943ms\n",
|
||
"Epoch [6/21], Train Loss: 10.7080544233, Used Time: 1324.216ms, Test Acc: 90.230%, Used Time: 475.444ms\n",
|
||
"Epoch [11/21], Train Loss: 8.8931061625, Used Time: 1338.181ms, Test Acc: 91.680%, Used Time: 495.663ms\n",
|
||
"Epoch [16/21], Train Loss: 7.7604069710, Used Time: 1053.048ms, Test Acc: 93.020%, Used Time: 438.297ms\n",
|
||
"Epoch [21/21], Train Loss: 6.9309708327, Used Time: 1153.692ms, Test Acc: 93.380%, Used Time: 450.776ms\n",
|
||
"模型3开始训练，hidden_size=512，hidden_layer=2 ：\n",
|
||
"Epoch [1/21], Train Loss: 61.6364710331, Used Time: 1106.529ms, Test Acc: 46.510%, Used Time: 427.871ms\n",
|
||
"Epoch [6/21], Train Loss: 13.6856049299, Used Time: 985.926ms, Test Acc: 87.340%, Used Time: 425.533ms\n",
|
||
"Epoch [11/21], Train Loss: 9.1959046721, Used Time: 1228.561ms, Test Acc: 91.240%, Used Time: 752.901ms\n",
|
||
"Epoch [16/21], Train Loss: 7.7999121249, Used Time: 1338.665ms, Test Acc: 92.300%, Used Time: 497.456ms\n",
|
||
"Epoch [21/21], Train Loss: 6.8975805193, Used Time: 1224.102ms, Test Acc: 92.770%, Used Time: 847.491ms\n",
|
||
"模型4开始训练，hidden_size=1024，hidden_layer=2 ：\n",
|
||
"Epoch [1/21], Train Loss: 57.2625247240, Used Time: 1338.882ms, Test Acc: 68.750%, Used Time: 630.328ms\n",
|
||
"Epoch [6/21], Train Loss: 11.1512524188, Used Time: 1090.787ms, Test Acc: 90.220%, Used Time: 482.404ms\n",
|
||
"Epoch [11/21], Train Loss: 8.5673914552, Used Time: 1168.953ms, Test Acc: 89.830%, Used Time: 466.643ms\n",
|
||
"Epoch [16/21], Train Loss: 7.1884415299, Used Time: 1108.380ms, Test Acc: 93.400%, Used Time: 460.032ms\n",
|
||
"Epoch [21/21], Train Loss: 6.2258996069, Used Time: 1081.092ms, Test Acc: 93.920%, Used Time: 488.327ms\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_1(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, out_features=512)\n",
|
||
" self.fc2 = nn.Linear(in_features=512, out_features=num_classes)\n",
|
||
" self.activate_fn = leaky_relu\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",
|
||
" return x\n",
|
||
" \n",
|
||
"\n",
|
||
"class Model_4_2(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, out_features=1024)\n",
|
||
" self.fc2 = nn.Linear(in_features=1024, out_features=num_classes)\n",
|
||
" self.activate_fn = leaky_relu\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",
|
||
" return x\n",
|
||
" \n",
|
||
"\n",
|
||
"class Model_4_3(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, out_features=512)\n",
|
||
" self.fc2 = nn.Linear(in_features=512, out_features=512)\n",
|
||
" self.fc3 = nn.Linear(in_features=512, out_features=num_classes)\n",
|
||
" self.activate_fn = leaky_relu\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",
|
||
"\n",
|
||
"class Model_4_4(nn.Module):\n",
|
||
" def __init__(self, num_classes):\n",
|
||
" super().__init__()\n",
|
||
" self.flatten = nn.Flatten()\n",
|
||
" self.fc1 = nn.Linear(in_features=28 * 28, out_features=1024)\n",
|
||
" self.fc2 = nn.Linear(in_features=1024, out_features=1024)\n",
|
||
" self.fc3 = nn.Linear(in_features=1024, out_features=num_classes)\n",
|
||
" self.activate_fn = leaky_relu\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",
|
||
"\n",
|
||
"print(\"模型1开始训练，hidden_size=512，hidden_layer=1 ：\")\n",
|
||
"train_loss_4_1, test_acc_4_1 = train_MNIST_CLS(Model=Model_4_1) # hidden_size=512, hidden_layer=1\n",
|
||
"print(\"模型2开始训练，hidden_size=1024，hidden_layer=1 ：\")\n",
|
||
"train_loss_4_2, test_acc_4_2 = train_MNIST_CLS(Model=Model_4_2) # hidden_size=1024, hidden_layer=1\n",
|
||
"print(\"模型3开始训练，hidden_size=512，hidden_layer=2 ：\")\n",
|
||
"train_loss_4_3, test_acc_4_3 = train_MNIST_CLS(Model=Model_4_3) # hidden_size=512, hidden_layer=2\n",
|
||
"print(\"模型4开始训练，hidden_size=1024，hidden_layer=2 ：\")\n",
|
||
"train_loss_4_4, test_acc_4_4 = train_MNIST_CLS(Model=Model_4_4) # hidden_size=1024, hidden_layer=2\n",
|
||
"\n",
|
||
"# train loss\n",
|
||
"plt.figure(figsize=(7, 3.5))\n",
|
||
"plt.subplot(1, 2, 1)\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_4_1, label='S=512, L=1', color='blue')\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_4_2, label='S=1024, L=1', color='green')\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_4_3, label='S=512, L=2', color='orange')\n",
|
||
"plt.plot(range(1, num_epochs + 1), train_loss_4_4, label='S=1024, L=2', color='purple')\n",
|
||
"plt.xlabel('Epoch')\n",
|
||
"plt.ylabel('Train Loss')\n",
|
||
"plt.legend()\n",
|
||
"\n",
|
||
"# test acc\n",
|
||
"plt.subplot(1, 2, 2)\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_4_1, label='S=512, L=1', color='blue')\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_4_2, label='S=1024, L=1', color='green')\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_4_3, label='S=512, L=2', color='orange')\n",
|
||
"plt.plot(range(1, num_epochs + 1), test_acc_4_4, label='S=1024, L=2', color='purple')\n",
|
||
"plt.xlabel('Epoch')\n",
|
||
"plt.ylabel('Test Accuracy')\n",
|
||
"plt.legend()\n",
|
||
"\n",
|
||
"plt.tight_layout()\n",
|
||
"plt.show()"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"在性能表现上，4种隐藏层数量和隐藏单元个数的模型相差无几，正确率都能达到$93\\%$左右。\n",
|
||
"\n",
|
||
"在用时上，由于模型较小，数据集也较小，用时基本没有差别。"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"metadata": {},
|
||
"source": [
|
||
"# 心得体会\r\n",
|
||
"\r\n",
|
||
"在本次实验中，我手动实现了基础的神经网络模块，包括全连接层、激活函数、损失函数等。这加深了我对神经网络内部工作原理的理解。通过手动实现的过程，让我更清楚神经网络的各个组成部分是如何协同工作的。\r\n",
|
||
"\r\n",
|
||
"我比较不同激活函数和网络结构对模型性能的影响。通过实验发现`sigmoid`函数容易导致梯度消失，而`ReLU`和`Leaky ReLU`等激活函数表现较好。隐藏层的层数和神经元个数也会影响最终的准确率。这让我明白了选择合适的激活函数和网络结构对获得良好性能至关重要。\r\n",
|
||
"\r\n",
|
||
"通过系统地调参、训练不同的模型，记录并对比它们的损失曲线和准确率曲线，我也更深入地理解了不同模型设置的优劣。当然本次实验使用的模型还是非常基础的模型，我非常期待在后面的实验中使用复杂的模型，提升我对深度学习的认识。"
|
||
]
|
||
}
|
||
],
|
||
"metadata": {
|
||
"kernelspec": {
|
||
"display_name": "Python 3 (ipykernel)",
|
||
"language": "python",
|
||
"name": "python3"
|
||
},
|
||
"language_info": {
|
||
"codemirror_mode": {
|
||
"name": "ipython",
|
||
"version": 3
|
||
},
|
||
"file_extension": ".py",
|
||
"mimetype": "text/x-python",
|
||
"name": "python",
|
||
"nbconvert_exporter": "python",
|
||
"pygments_lexer": "ipython3",
|
||
"version": "3.10.13"
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 4
|
||
}
|