{
"cells": [
{
"cell_type": "markdown",
"id": "e59a56ee",
"metadata": {},
"source": [
"**实验四：神经网络中的前向传播与后向传播**"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "62f100c9",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"id": "eebaf0fe",
"metadata": {},
"source": [
"**第一部分:PyTorch介绍**"
]
},
{
"cell_type": "markdown",
"id": "2a394db6",
"metadata": {},
"source": [
"这里介绍一小部分PyTorch常用的库和函数，更多需求可参阅[PyTorch官方教程](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)以及[PyTorch官方文档](https://pytorch.org/docs/stable/index.html)。"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "6fae149b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.4.1+cu121\n"
]
}
],
"source": [
"import torch # 导入的是 torch 而不是 pytorch\n",
"print(torch.__version__) # 输出当前pytorch的版本"
]
},
{
"cell_type": "markdown",
"id": "392780bb",
"metadata": {},
"source": [
"1.Tensor"
]
},
{
"cell_type": "markdown",
"id": "904623e4",
"metadata": {},
"source": [
"Tensor与NumPy中的ndarray很相似，但Tensor可以利用GPU来加速计算（虽然本门课不用）。"
]
},
{
"cell_type": "markdown",
"id": "23642996",
"metadata": {},
"source": [
"1.1. Tensor的创建"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "38cdf3ad",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[-9.5667e+36, 4.5586e-41, 9.0599e-01],\n",
" [ 0.0000e+00, 9.0599e-01, 0.0000e+00]])\n",
"tensor([[1, 2, 3],\n",
" [4, 5, 6]])\n",
"tensor([[0.0424, 0.2776, 0.6579, 0.9163],\n",
" [0.7382, 0.8476, 0.4629, 0.7418],\n",
" [0.5258, 0.5010, 0.0436, 0.4098]])\n",
"tensor([[0., 0., 0.],\n",
" [0., 0., 0.]])\n",
"tensor([[1., 1., 1.],\n",
" [1., 1., 1.]])\n"
]
}
],
"source": [
"# 创建一个未初始化的Tensor\n",
"x = torch.empty(2, 3)\n",
"print(x)\n",
"\n",
"# 从一个列表创建Tensor\n",
"x = torch.tensor([[1,2,3],[4,5,6]])\n",
"print(x)\n",
"\n",
"# 创建一个随机Tensor\n",
"x = torch.rand([3, 4])\n",
"print(x)\n",
"\n",
"# 创建一个全零Tensor\n",
"x = torch.zeros([2, 3])\n",
"print(x)\n",
"\n",
"# 创建一个全一Tensor\n",
"x = torch.ones([2, 3])\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"id": "9f354fd4",
"metadata": {},
"source": [
"1.2. Tensor的运算"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "8070a903",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[7, 7, 7],\n",
" [7, 7, 7]])\n",
"tensor([[-5, -3, -1],\n",
" [ 1, 3, 5]])\n",
"tensor([[ 6, 10, 12],\n",
" [12, 10, 6]])\n",
"tensor([[ 6, 10, 12],\n",
" [12, 10, 6]])\n",
"tensor([[28, 10],\n",
" [73, 28]])\n",
"tensor([[28, 10],\n",
" [73, 28]])\n",
"tensor([[1, 2],\n",
" [3, 4],\n",
" [5, 6]])\n",
"tensor([[1, 2, 3],\n",
" [4, 5, 6],\n",
" [6, 5, 4],\n",
" [3, 2, 1]])\n",
"tensor([[1, 2, 3, 6, 5, 4],\n",
" [4, 5, 6, 3, 2, 1]])\n"
]
}
],
"source": [
"# 加减法\n",
"x = torch.tensor([[1,2,3],[4,5,6]])\n",
"y = torch.tensor([[6,5,4],[3,2,1]])\n",
"print(x + y)\n",
"print(x - y)\n",
"\n",
"# 对应位置相乘\n",
"print(x * y)\n",
"print(x.mul(y))\n",
"\n",
"# 矩阵乘法\n",
"print(x.matmul(y.T))\n",
"print(x @ y.T)\n",
"\n",
"# reshape\n",
"print(x.reshape(3, 2))\n",
"\n",
"# 拼接\n",
"print(torch.cat([x,y], dim=0)) # 纵向拼接\n",
"print(torch.cat([x,y], dim=1)) # 横向拼接"
]
},
{
"cell_type": "markdown",
"id": "95961cee",
"metadata": {},
"source": [
"1.3. Tensor与ndarray的相互转换"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "d1269212",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[1, 2, 3],\n",
" [4, 5, 6]])\n",
"[[1 2 3]\n",
" [4 5 6]]\n",
"[[0 0 0]\n",
" [0 0 0]]\n",
"tensor([[0, 0, 0],\n",
" [0, 0, 0]])\n"
]
}
],
"source": [
"x = torch.tensor([[1,2,3],[4,5,6]])\n",
"print(x)\n",
"\n",
"# 从Tensor转换到ndarray\n",
"y = x.numpy()\n",
"print(y)\n",
"\n",
"# Tensor与ndarray是共享空间的\n",
"x[:]=0\n",
"print(y)\n",
"\n",
"# 从ndarray到Tensor\n",
"z = torch.from_numpy(y)\n",
"print(z)"
]
},
{
"cell_type": "markdown",
"id": "bb6c36a7",
"metadata": {},
"source": [
"2.自动求梯度"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "3b30fec3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[3., 4.]]) tensor(1.)\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966,\n",
" 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966, 0.1966,\n",
" 0.1966, 0.1966])\n",
"tensor(4.)\n",
"tensor(5.)\n",
"tensor(0.)\n"
]
}
],
"source": [
"a = torch.tensor([[1.,2.]], requires_grad=True) # 把requires_grad设为True, 开始跟踪基于它的所有运算\n",
"b = torch.tensor([[3.],[4.]])\n",
"c = torch.tensor(5., requires_grad=True)\n",
"y = a @ b + c\n",
"y.backward() #自动计算梯度\n",
"print(a.grad, c.grad) #输出叶子节点a和c的梯度\n",
"\n",
"# 可支持多种运算求梯度，如torch.mean(),torch.sum()等\n",
"a = torch.ones(20, requires_grad=True)\n",
"z = torch.sum(torch.sigmoid(a))\n",
"z.backward()\n",
"print(a.grad)\n",
"\n",
"# 多次求梯度时梯度会累加，可使用tensor.grad.zero_()进行手动清零\n",
"x = torch.tensor(2., requires_grad=True)\n",
"y = x ** 2\n",
"y.backward()\n",
"print(x.grad)\n",
"z = x + 3\n",
"z.backward()\n",
"print(x.grad)\n",
"x.grad.zero_()\n",
"print(x.grad)"
]
},
{
"cell_type": "markdown",
"id": "96d22808",
"metadata": {},
"source": [
"3. 神经网络（官方教程中的例子）"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "207b6433",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Net(\n",
" (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
" (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
" (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
" (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
" (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
")\n"
]
}
],
"source": [
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"\n",
"# 继承自nn.Module\n",
"class Net(nn.Module):\n",
"\n",
" def __init__(self):\n",
" super(Net, self).__init__()\n",
" # 卷积层\n",
" # 1 input image channel, 6 output channels, 5x5 square convolution\n",
" # kernel\n",
" self.conv1 = nn.Conv2d(1, 6, 5)\n",
" self.conv2 = nn.Conv2d(6, 16, 5)\n",
" # an affine operation: y = Wx + b\n",
" # nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)\n",
" # 其中in_features表示有多少个输入，out_features表示该层有多少个神经元\n",
" self.fc1 = nn.Linear(16 * 5 * 5, 120) # 5*5 from image dimension\n",
" self.fc2 = nn.Linear(120, 84)\n",
" self.fc3 = nn.Linear(84, 10)\n",
"\n",
" def forward(self, x):\n",
" # Max pooling over a (2, 2) window\n",
" x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
" # If the size is a square, you can specify with a single number\n",
" x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
" x = torch.flatten(x, 1) # flatten all dimensions except the batch dimension\n",
" x = F.relu(self.fc1(x))\n",
" x = F.relu(self.fc2(x))\n",
" x = self.fc3(x)\n",
" return x\n",
"\n",
"\n",
"net = Net()\n",
"print(net)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "6c2a943f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10\n",
"torch.Size([6, 1, 5, 5])\n"
]
}
],
"source": [
"# 该神经网络中可学习的参数可以通过net.parameters()访问\n",
"params = list(net.parameters())\n",
"print(len(params))\n",
"print(params[0].size()) # conv1's .weight"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "b733263e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[-0.0060, 0.0956, 0.0178, 0.0410, 0.0861, 0.1770, -0.0531, 0.0750,\n",
" -0.0735, -0.0002]], grad_fn=)\n"
]
}
],
"source": [
"# 随机生成一个输入送入net中，除了第0维是样本个数外，其余维度要与forward()参数中x的维度对应上\n",
"input = torch.randn(1, 1, 32, 32) # 1个样本，该样本是有1个通道的32×32的图像\n",
"out = net(input) # 进行一次forward()前向传播\n",
"print(out)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "168659b3",
"metadata": {},
"outputs": [],
"source": [
"net.zero_grad() # 手动清零神经网络中参数的梯度\n",
"out.backward(torch.randn(1, 10)) # 用随机梯度进行一次backward()后向传播来计算梯度"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "af35f14f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor(0.5362, grad_fn=)\n"
]
}
],
"source": [
"output = net(input)\n",
"target = torch.randn(10) # a dummy target, for example\n",
"target = target.view(1, -1) # make it the same shape as output\n",
"# nn模块提供了许多种类的损失函数，如nn.CrossEntropyLoss()、nn.MSELoss()等等\n",
"criterion = nn.MSELoss()\n",
"\n",
"loss = criterion(output, target)\n",
"print(loss)"
]
},
{
"cell_type": "markdown",
"id": "1428f7ce",
"metadata": {},
"source": [
"计算图如下：\n",
"input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d\n",
" -> flatten -> linear -> relu -> linear -> relu -> linear\n",
" -> MSELoss\n",
" -> loss"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "e9ada5be",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"\n"
]
}
],
"source": [
"# 查看计算图中的函数\n",
"print(loss.grad_fn) # MSELoss\n",
"print(loss.grad_fn.next_functions[0][0]) # Linear\n",
"print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "854ee4d1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"conv1.bias.grad before backward\n",
"None\n",
"conv1.bias.grad after backward\n",
"tensor([-0.0351, 0.0220, 0.0229, -0.0064, -0.0042, -0.0091])\n"
]
}
],
"source": [
"net.zero_grad() # zeroes the gradient buffers of all parameters\n",
"\n",
"print('conv1.bias.grad before backward')\n",
"print(net.conv1.bias.grad)\n",
"\n",
"# 进行一次后向传播\n",
"loss.backward()\n",
"\n",
"print('conv1.bias.grad after backward')\n",
"print(net.conv1.bias.grad)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "d7187507",
"metadata": {},
"outputs": [],
"source": [
"# 用梯度下降法(手动)更新net中的参数\n",
"learning_rate = 0.01\n",
"for f in net.parameters():\n",
" f.data.sub_(f.grad.data * learning_rate)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "06d237aa",
"metadata": {},
"outputs": [],
"source": [
"# 用PyTorch的优化器来更新net中的参数\n",
"import torch.optim as optim\n",
"\n",
"# create your optimizer\n",
"optimizer = optim.SGD(net.parameters(), lr=0.01)\n",
"\n",
"# 在每次循环中应该做的事:\n",
"optimizer.zero_grad() # 把梯度清零\n",
"output = net(input) # 进行一次前向传播\n",
"loss = criterion(output, target) # 计算误差\n",
"loss.backward() # 后向传播\n",
"optimizer.step() # 参数更新"
]
},
{
"cell_type": "markdown",
"id": "50be2d1f",
"metadata": {},
"source": [
"**第二部分:实验内容**"
]
},
{
"cell_type": "markdown",
"id": "ba5214e5",
"metadata": {},
"source": [
"[Red Wine Quality](https://www.kaggle.com/datasets/uciml/red-wine-quality-cortez-et-al-2009)是一个关于红酒品质的数据集，总共有1599个样本，每个样本包含11个(都是连续的)特征以及1个标签，每个标签的取值是连续的。本次实验已经按照8：2的比例划分成了训练数据集'wine_train.csv'以及测试数据集'wine_test.csv'，且每个数据集都已经做了归一化处理。"
]
},
{
"cell_type": "markdown",
"id": "d4d9ccac",
"metadata": {},
"source": [
"1) 读入训练数据集'wine_train.csv'与测试数据集'wine_test.csv'。"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "c759660f",
"metadata": {},
"outputs": [],
"source": [
"# -- Your code here --\n",
"file_train = pd.read_csv(\"wine_train.csv\")\n",
"file_test = pd.read_csv(\"wine_test.csv\")\n",
"df_train = pd.DataFrame(file_train)\n",
"df_test = pd.DataFrame(file_test)\n",
"test = torch.tensor(df_test.iloc[:, :-1].to_numpy(), dtype=torch.float32)\n",
"test_y = torch.tensor(df_test.iloc[:, -1].to_numpy(), dtype=torch.float32).view(-1,1)\n",
"train = torch.tensor(df_train.iloc[:, :-1].to_numpy(), dtype=torch.float32)\n",
"train_y = torch.tensor(df_train.iloc[:, -1].to_numpy(), dtype=torch.float32).view(-1,1)"
]
},
{
"cell_type": "markdown",
"id": "d77619fd",
"metadata": {},
"source": [
"2) 利用线性层和激活函数搭建一个神经网络，要求输入和输出维度与数据集维度一致，而神经网络深度、隐藏层大小、激活函数种类等超参数自行调整。"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "26359bae",
"metadata": {},
"outputs": [],
"source": [
"# -- Your code here --\n",
"class NN(torch.nn.Module):\n",
" def __init__(self, in_dim: int, out_dim: int, middle_dim: int = 32):\n",
" super().__init__()\n",
" self.net = nn.Sequential(\n",
" nn.Linear(in_dim, middle_dim),\n",
" nn.ReLU(),\n",
" nn.Linear(middle_dim, out_dim),\n",
" nn.ReLU()\n",
" )\n",
" def forward(self, x: torch.Tensor):\n",
" return self.net(x)\n"
]
},
{
"cell_type": "markdown",
"id": "9b706eea",
"metadata": {},
"source": [
"3) 用梯度下降法进行模型参数更新，记下每轮迭代中的训练损失和测试损失。"
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "cad2f094",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"torch.Size([1279, 11]) torch.Size([1279, 1])\n"
]
}
],
"source": [
"# -- Your code here --\n",
"iter_len = 5000\n",
"lr = 5e-2\n",
"his_J = np.zeros((iter_len, 1))\n",
"test_J = np.zeros_like(his_J)\n",
"model = NN(11, 1)\n",
"optimizer = optim.SGD(model.parameters(), lr=lr)\n",
"lossF = nn.MSELoss()\n",
"print(train.shape, train_y.shape)\n",
"\n",
"\n",
"for _ in range(iter_len):\n",
" optimizer.zero_grad()\n",
" output = model(train)\n",
" output_test = model(test)\n",
" loss = lossF(output, train_y)\n",
" loss_test = lossF(output_test, test_y)\n",
" his_J[_] = loss.item()\n",
" test_J[_] = loss_test.item()\n",
" loss.backward()\n",
" optimizer.step()"
]
},
{
"cell_type": "markdown",
"id": "ff5ff45e",
"metadata": {},
"source": [
"4) 画出训练损失和测试损失关于迭代轮数的折线图。"
]
},
{
"cell_type": "code",
"execution_count": 37,
"id": "3ba3071f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# -- Your code here --\n",
"\n",
"import matplotlib.pyplot as plt\n",
"plt.plot(his_J, label=\"train\")\n",
"plt.plot(test_J, label='test')\n",
"plt.legend()\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "transformer",
"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.8.20"
}
},
"nbformat": 4,
"nbformat_minor": 5
}