016_PyTorch神经网络基础.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 层和块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① nn.Sequential 定义了一种特殊的Module。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0564,  0.1933,  0.0509, -0.0680,  0.0838,  0.2006,  0.0469, -0.1139,\n",
       "          0.0783,  0.0375],\n",
       "        [-0.0768,  0.1437,  0.0791,  0.0175, -0.0232,  0.2282, -0.0082, -0.0042,\n",
       "          0.0856,  0.0253]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 回顾一下多层感知机\n",
    "import torch\n",
    "from torch import nn  #多层感知机用的\n",
    "from torch.nn import functional as F  #新引入的\n",
    "net = nn.Sequential(nn.Linear(20,256),nn.ReLU(),nn.Linear(256,10)) \n",
    "X = torch.rand(2,20)\n",
    "net(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 自定义块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 任何的层或者神经网络都可以认为是Module的子类\n",
    "* 自定义块的两个关键函数：__init__ 和 forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0333, -0.0948,  0.2563, -0.1596,  0.0060, -0.0274, -0.0398, -0.1366,\n",
       "          0.0437, -0.0589],\n",
       "        [ 0.0217, -0.0773,  0.1643, -0.0892,  0.0680,  0.0901, -0.0526, -0.1759,\n",
       "         -0.0367,  0.0286]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn  #多层感知机用的\n",
    "from torch.nn import functional as F  #新引入的\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self): #__init__用于定义所需要的类和参数\n",
    "        super().__init__()  # 调用父类的__init__函数\n",
    "        self.hidden = nn.Linear(20,256) # 全连接层1：隐藏层\n",
    "        self.out = nn.Linear(256,10) # 全连接层2：输出层\n",
    "        \n",
    "    # 定义前向函数，self指向自己，类似this指针\n",
    "    # 解决给定输入怎么做输出的问题\n",
    "    def forward(self, X):\n",
    "        return self.out(F.relu(self.hidden(X)))\n",
    "    \n",
    "# 实例化多层感知机的层，然后在每次调用正向传播函数调用这些层\n",
    "net = MLP()\n",
    "X = torch.rand(2,20)\n",
    "net(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 顺序块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(in_features=20, out_features=256, bias=True)\n",
      "ReLU()\n",
      "Linear(in_features=256, out_features=10, bias=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0839, -0.0649,  0.0872,  0.1242,  0.1059,  0.0641,  0.0942, -0.0150,\n",
       "          0.0728,  0.1937],\n",
       "        [-0.1131, -0.1980,  0.2062,  0.3204,  0.0752,  0.0940,  0.0154,  0.2404,\n",
       "         -0.0119,  0.2041]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MySequential(nn.Module):\n",
    "    def __init__(self, *args):\n",
    "        # 接收了一个list of input arguments，用于存储liner的信息\n",
    "        super().__init__()\n",
    "        for block in args:\n",
    "            self._modules[block] = block # block 本身作为它的key，存在_modules里面的为层，以字典的形式 \n",
    "            \n",
    "    def forward(self, X):\n",
    "        for block in self._modules.values():\n",
    "            print(block)\n",
    "            X = block(X)\n",
    "        return X\n",
    "    \n",
    "net = MySequential(nn.Linear(20,256),nn.ReLU(),nn.Linear(256,10))\n",
    "X = torch.rand(2,20)\n",
    "net(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 正向传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.0037, grad_fn=<SumBackward0>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 通过继承 nn.Module ，更加灵活的定义网络与前向计算\n",
    "# 不使用Sequential，自定义一个类，可以进行大量的自定义的计算\n",
    "# 在正向传播函数中执行代码\n",
    "class FixedHiddenMLP(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.rand_weight = torch.rand((20,20),requires_grad=False) # 随机生成权重，但是不计算梯度，不参与计算\n",
    "        self.linear = nn.Linear(20,20)\n",
    "    \n",
    "    def forward(self, X):\n",
    "        X = self.linear(X)\n",
    "        X = F.relu(torch.mm(X, self.rand_weight + 1))  # 矩阵乘法加1\n",
    "        X = self.linear(X)\n",
    "        while X.abs().sum() > 1:\n",
    "            X /= 2\n",
    "        return X.sum()  # 返回一个标量\n",
    "    \n",
    "net = FixedHiddenMLP()\n",
    "X = torch.rand(2,20)\n",
    "net(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 混合组合块（套娃）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(-0.1488, grad_fn=<SumBackward0>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 理解：嵌套使用，因为现有的层和网络都是nn.Module的子类\n",
    "# 混合代培各种组合块的方法\n",
    "class NestMLP(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.net = nn.Sequential(nn.Linear(20,64),nn.ReLU(),\n",
    "                                nn.Linear(64,32),nn.ReLU())\n",
    "        self.linear = nn.Linear(32,16)\n",
    "        \n",
    "    def forward(self, X):\n",
    "        return self.linear(self.net(X))\n",
    "    \n",
    "chimear = nn.Sequential(NestMLP(),nn.Linear(16,20),FixedHiddenMLP())\n",
    "X = torch.rand(2,20)\n",
    "chimear(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. 参数管理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.1048],\n",
      "        [-0.0973]], grad_fn=<AddmmBackward0>)\n",
      "OrderedDict([('weight', tensor([[ 0.3125,  0.2318, -0.2194,  0.2756, -0.2195, -0.2564, -0.0820,  0.1823]])), ('bias', tensor([-0.3087]))])\n",
      "<class 'torch.nn.parameter.Parameter'>\n",
      "Parameter containing:\n",
      "tensor([-0.3087], requires_grad=True)\n",
      "tensor([-0.3087])\n",
      "True\n",
      "('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))\n",
      "('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))\n",
      "tensor([-0.3087])\n"
     ]
    }
   ],
   "source": [
    "# 首先关注具有单隐藏层的多层感知机\n",
    "import torch\n",
    "from torch import nn\n",
    " \n",
    "net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))  # Sequential可以理解成一个list\n",
    "X = torch.rand(size=(2,4))\n",
    "print(net(X))\n",
    "print(net[2].state_dict()) # 访问参数，net[2]就是最后一个输出层，线性层的state就是权重和偏移\n",
    "print(type(net[2].bias)) # 目标参数\n",
    "print(net[2].bias)\n",
    "print(net[2].bias.data)\n",
    "print(net[2].weight.grad == None) # 还没进行反向计算，所以grad为None\n",
    "print(*[(name, param.shape) for name, param in net[0].named_parameters()])  # 一次性访问所有参数         \n",
    "print(*[(name, param.shape) for name, param in net.named_parameters()])  # 0是第一层名字，1是ReLU，它没有参数\n",
    "print(net.state_dict()['2.bias'].data) # 通过名字获取参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. 嵌套块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.1750],\n",
      "        [-0.1750]], grad_fn=<AddmmBackward0>)\n",
      "Sequential(\n",
      "  (0): Sequential(\n",
      "    (block0): Sequential(\n",
      "      (0): Linear(in_features=4, out_features=8, bias=True)\n",
      "      (1): ReLU()\n",
      "      (2): Linear(in_features=8, out_features=4, bias=True)\n",
      "      (3): ReLU()\n",
      "    )\n",
      "    (block1): Sequential(\n",
      "      (0): Linear(in_features=4, out_features=8, bias=True)\n",
      "      (1): ReLU()\n",
      "      (2): Linear(in_features=8, out_features=4, bias=True)\n",
      "      (3): ReLU()\n",
      "    )\n",
      "    (block2): Sequential(\n",
      "      (0): Linear(in_features=4, out_features=8, bias=True)\n",
      "      (1): ReLU()\n",
      "      (2): Linear(in_features=8, out_features=4, bias=True)\n",
      "      (3): ReLU()\n",
      "    )\n",
      "    (block3): Sequential(\n",
      "      (0): Linear(in_features=4, out_features=8, bias=True)\n",
      "      (1): ReLU()\n",
      "      (2): Linear(in_features=8, out_features=4, bias=True)\n",
      "      (3): ReLU()\n",
      "    )\n",
      "  )\n",
      "  (1): Linear(in_features=4, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# 从嵌套块收集参数\n",
    "def block1():\n",
    "    return nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,4),nn.ReLU())\n",
    "\n",
    "def block2():\n",
    "    net = nn.Sequential()\n",
    "    for i in range(4):\n",
    "        net.add_module(f'block{i}',block1()) # f'block{i}' 可以传一个字符串名字过来，block2可以嵌套四个block1                                      \n",
    "    return net\n",
    "\n",
    "rgnet = nn.Sequential(block2(), nn.Linear(4,1))\n",
    "print(rgnet(X))\n",
    "print(rgnet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8 内置初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.0113,  0.0138,  0.0002, -0.0009])\n",
      "tensor(0.)\n"
     ]
    }
   ],
   "source": [
    "net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))\n",
    "\n",
    "def init_normal(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        nn.init.normal_(m.weight, mean=0, std=0.01) # 下划线表示把m.weight的值替换掉   \n",
    "        nn.init.zeros_(m.bias)\n",
    "        \n",
    "net.apply(init_normal) # 会递归调用 直到net里的所有层都初始化\n",
    "print(net[0].weight.data[0])\n",
    "print(net[0].bias.data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 1., 1., 1.])\n",
      "tensor(0.)\n"
     ]
    }
   ],
   "source": [
    "net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))\n",
    "\n",
    "def init_constant(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        nn.init.constant_(m.weight,1)\n",
    "        nn.init.zeros_(m.bias)\n",
    "        \n",
    "net.apply(init_constant)\n",
    "print(net[0].weight.data[0]) \n",
    "print(net[0].bias.data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.3779, -0.3074, -0.2969, -0.5504],\n",
      "        [ 0.0260, -0.1049, -0.6233, -0.2050],\n",
      "        [-0.0937, -0.2387, -0.4923,  0.4747],\n",
      "        [ 0.0792,  0.5286,  0.2346,  0.0479],\n",
      "        [-0.0352,  0.1823, -0.1764, -0.4183],\n",
      "        [-0.2254,  0.2669,  0.6601, -0.0258],\n",
      "        [-0.2206,  0.3543,  0.6917,  0.5300],\n",
      "        [-0.6918,  0.3496,  0.4863, -0.2998]])\n",
      "tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])\n"
     ]
    }
   ],
   "source": [
    "# 对某些块应用不同的初始化\n",
    "def xavier(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        nn.init.xavier_uniform_(m.weight)\n",
    "        \n",
    "def init_42(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        nn.init.constant_(m.weight, 42) # 宇宙的答案\n",
    "        \n",
    "net[0].apply(xavier)\n",
    "net[2].apply(init_42)\n",
    "print(net[0].weight.data)\n",
    "print(net[2].weight.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. 参数替换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Init weight torch.Size([8, 4])\n",
      "Init weight torch.Size([1, 8])\n",
      "tensor([[-5.3670, -0.0000,  6.3498, -6.8195],\n",
      "        [ 0.0000, -5.5124, -7.0872, -5.8630]], grad_fn=<SliceBackward0>)\n",
      "tensor([42.0000,  1.0000,  7.3498, -5.8195])\n"
     ]
    }
   ],
   "source": [
    "# 自定义初始化\n",
    "def my_init(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        print(\"Init\",*[(name, param.shape) for name, param in m.named_parameters()][0])  # 打印名字是啥，形状是啥       \n",
    "        nn.init.uniform_(m.weight, -10, 10) # 均匀初始化\n",
    "        m.weight.data *= m.weight.data.abs() >=  5 # 这里*=的代码相当于先计算一个布尔矩阵(先判断>=)，然后再用布尔矩阵的对应元素去乘以原始矩阵的每个元素。保留绝对值大于5的权重，不是的话就设为0\n",
    "\n",
    "net.apply(my_init)\n",
    "print(net[0].weight[:2])\n",
    "net[0].weight.data[:] += 1 # 参数替换\n",
    "net[0].weight.data[0,0] = 42\n",
    "print(net[0].weight.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. 参数绑定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([True, True, True, True, True, True, True, True])\n",
      "tensor([[ 1.0000e+02,  3.1971e-01, -1.0494e-01, -1.1566e-01, -2.6466e-01,\n",
      "         -1.8208e-01,  1.4149e-01, -3.4933e-01],\n",
      "        [ 1.4787e-01, -1.1238e-01, -2.1118e-01, -2.1453e-01,  2.2779e-01,\n",
      "          2.9798e-02,  2.7491e-01,  1.7850e-02],\n",
      "        [-2.6862e-01,  2.5214e-01,  2.5834e-01, -6.3154e-02, -6.3644e-02,\n",
      "         -1.2992e-01, -3.0072e-01, -2.7816e-01],\n",
      "        [-3.2799e-01, -1.2887e-01, -2.5755e-01, -2.4677e-01,  1.5814e-01,\n",
      "          2.5854e-01,  1.3341e-01, -3.5038e-01],\n",
      "        [ 2.9017e-01, -1.4982e-01, -6.1505e-02, -2.4450e-02, -1.8523e-01,\n",
      "         -2.3352e-02,  2.6686e-01, -2.9543e-01],\n",
      "        [ 2.9985e-01,  3.1190e-01,  6.2135e-02,  2.2126e-01,  2.4378e-01,\n",
      "          1.7160e-02, -2.3796e-01,  1.6013e-01],\n",
      "        [-9.0081e-02,  4.4785e-02,  1.7597e-01, -1.2041e-01, -5.5048e-02,\n",
      "          3.4668e-01, -2.7371e-01,  2.2327e-01],\n",
      "        [-1.3605e-01, -1.9636e-01, -2.9743e-01,  1.9270e-01, -1.5947e-01,\n",
      "          7.2071e-02,  3.2328e-01,  7.3537e-03]])\n",
      "tensor([True, True, True, True, True, True, True, True])\n"
     ]
    }
   ],
   "source": [
    "# 在一些层之前共享权重\n",
    "# 参数绑定\n",
    "shared = nn.Linear(8,8) # 1.先构造要共享的层\n",
    "net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),shared,nn.ReLU(),shared,nn.ReLU(),nn.Linear(8,1))  # 第2个隐藏层和第3个隐藏层是share权重的，第一个和第四个是自己的  \n",
    "net(X)\n",
    "print(net[2].weight.data[0] == net[4].weight.data[0])\n",
    "net[2].weight.data[0,0] = 100\n",
    "print(net[2].weight.data )\n",
    "print(net[2].weight.data[0] == net[4].weight.data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. 自定义层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-2., -1.,  0.,  1.,  2.])\n",
      "tensor(7.4506e-09, grad_fn=<MeanBackward0>)\n",
      "Parameter containing:\n",
      "tensor([[-0.5568,  1.3441,  0.1659],\n",
      "        [ 0.5718,  0.1446,  0.6569],\n",
      "        [-0.5675,  0.7232, -0.4598],\n",
      "        [-1.2581,  0.9977, -1.6795],\n",
      "        [ 2.0943,  0.4172, -0.6235]], requires_grad=True)\n",
      "tensor([[0.0199, 2.7975, 0.0000],\n",
      "        [0.0000, 1.7644, 0.0000]])\n",
      "tensor([[3.4710],\n",
      "        [2.4605]])\n"
     ]
    }
   ],
   "source": [
    "# 与自定义网络本质相同，同样是nn.Module的子类\n",
    "# 构造一个没有任何参数的自定义层\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch import nn\n",
    "\n",
    "class CenteredLayer(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "    def forward(self, X):\n",
    "        return X - X.mean()   # 输入减均值，使得均值变成0\n",
    "    \n",
    "layer = CenteredLayer()\n",
    "print(layer(torch.FloatTensor([1,2,3,4,5])))\n",
    "\n",
    "# 将层作为组件合并到构建更复杂的模型中\n",
    "net = nn.Sequential(nn.Linear(8,128),CenteredLayer())\n",
    "Y = net(torch.rand(4,8))\n",
    "print(Y.mean())\n",
    "\n",
    "# 带参数的层\n",
    "class MyLinear(nn.Module):\n",
    "    def __init__(self, in_units, units):\n",
    "        super().__init__()\n",
    "        self.weight = nn.Parameter(torch.randn(in_units,units)) # nn.Parameter使得这些参数加上了梯度  输入大小乘以输出大小\n",
    "        self.bias = nn.Parameter(torch.randn(units,))\n",
    "\n",
    "    def forward(self, X):\n",
    "        linear = torch.matmul(X, self.weight.data) + self.bias.data\n",
    "        return F.relu(linear)\n",
    "    \n",
    "dense = MyLinear(5,3)\n",
    "print(dense.weight)\n",
    "\n",
    "# 使用自定义层直接执行正向传播计算\n",
    "print(dense(torch.rand(2,5)))\n",
    "# 使用自定义层构建模型\n",
    "net = nn.Sequential(MyLinear(64,8),MyLinear(8,1))\n",
    "print(net(torch.rand(2,64)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. 读写文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3, 4])\n",
      "tensor([0, 1, 2, 3, 4])\n",
      "tensor([0., 0., 0., 0.])\n",
      "{'x': tensor([0, 1, 2, 3, 4]), 'y': tensor([0., 0., 0., 0.])}\n"
     ]
    }
   ],
   "source": [
    "# 加载和保存张量（怎么存一个矩阵）\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "\n",
    "x = torch.arange(5)\n",
    "torch.save(x, 'x-file1') # 将工程中的张量保存到文件中\n",
    "x2 = torch.load('x-file1') # 将文件中的张量加载到工程中\n",
    "print(x2)\n",
    "\n",
    "#存储一个张量列表，然后把它们读回内存\n",
    "y = torch.zeros(4)\n",
    "torch.save([x,y],'x-files')\n",
    "x2, y2 = torch.load('x-files')\n",
    "print(x2)\n",
    "print(y2)\n",
    "\n",
    "# 写入或读取从字符串映射到张量的字典\n",
    "mydict = {'x':x,'y':y}\n",
    "torch.save(mydict,'mydict')\n",
    "mydict2 = torch.load('mydict')\n",
    "print(mydict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLP(\n",
      "  (hidden): Linear(in_features=20, out_features=256, bias=True)\n",
      "  (output): Linear(in_features=256, out_features=10, bias=True)\n",
      ")\n",
      "tensor([[True, True, True, True, True, True, True, True, True, True],\n",
      "        [True, True, True, True, True, True, True, True, True, True]])\n"
     ]
    }
   ],
   "source": [
    "# 加载和保存模型参数\n",
    "# 网络中有什么可以存的参数 - 权重\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.hidden = nn.Linear(20,256)\n",
    "        self.output = nn.Linear(256,10)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return self.output(F.relu(self.hidden(x)))\n",
    "    \n",
    "net = MLP()\n",
    "X = torch.randn(size=(2,20))\n",
    "Y = net(X)\n",
    "\n",
    "# 将模型的参数存储为一个叫做\"mlp.params\"的文件\n",
    "torch.save(net.state_dict(),'mlp.params')\n",
    "\n",
    "# 实例化了原始多层感知机模型的一个备份。直接读取文件中存储的参数\n",
    "clone = MLP() # 必须要先声明一下，才能导入参数\n",
    "clone.load_state_dict(torch.load(\"mlp.params\"))\n",
    "print(clone.eval()) # eval()是进入测试模式\n",
    "\n",
    "Y_clone = clone(X)\n",
    "print(Y_clone == Y)"
   ]
  }
 ],
 "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.8.19"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "2041.23px",
    "left": "45.9792px",
    "top": "56px",
    "width": "301.875px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}