{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 认识 Jupyter Notebook\n",
    "\n",
    "把python程序放在 Notebook 中分段运行。它像一本可以执行代码的实验记录本：说明、公式、代码和结果可以放在一起。\n",
    "\n",
    "| 普通脚本 `.py` | Notebook `.ipynb` |\n",
    "| --- | --- |\n",
    "| 通常用 `python 文件名.py` 启动，按程序流程执行 | 可以逐个执行单元格，也可以全部运行 |\n",
    "| 每次用上述命令启动，通常是一个新进程 | 同一个内核会保留之前创建的变量 |\n",
    "| 主要保存代码和注释 | 可以一起保存代码、说明、公式和输出 |\n",
    "\n",
    "### 公式也可以放进 Notebook\n",
    "\n",
    "**Markdown 单元格**具有接近latex的公式表达能力，你可以在这里编辑大多数的latex公式\n",
    "\n",
    "$$\n",
    "y=f(x) \\cdot \\frac{x^2}{5}.\n",
    "$$\n",
    "\n",
    "**先选对内核。** 内核（Kernel）是实际执行代码的程序。今天做神经网络演示时，选择装有 PyTorch 的 `pubpy` 环境。点击单元格旁的运行按钮，或按 `Shift+Enter`，即可执行代码。\n",
    "\n",
    "下面先看：当前究竟是哪一个 Python 在运行？\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 542,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "当前运行代码的 Python：\n",
      "/opt/miniconda/envs/pubpy/bin/python\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(\"当前运行代码的 Python：\")\n",
    "print(sys.executable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "设置 x = 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "print(\"设置 x =\", x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " x = 2\n"
     ]
    }
   ],
   "source": [
    "x = x + 1\n",
    "print(\" x =\", x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 其他运行注意事项\n",
    "\n",
    "- **中断运行**：停止当前计算，通常保留已经创建的变量；不会撤销之前的操作。\n",
    "- **重启内核**：清空内存中的变量，需要重新运行代码。调试结束后，试一次“重启内核并运行全部”，检查程序是否能按顺序运行。\n",
    "- **关闭内核**：结束后台运行。在vscode中关闭标签页就会关闭内核。\n",
    "- **保存文件**：Notebook 可以保存代码和输出，但不会保存内存中所有变量。训练好的模型参数仍需单独保存。\n",
    "\n",
    "参考：[Jupyter 官方说明](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 神经网络部分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 545,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import os\n",
    "import time\n",
    "\n",
    "# torch.manual_seed(seed=42) \n",
    "# 如果想要能够复现完全一样的训练结果的话，可以用这个命令固定每一次的torch包的随机种子，不过仅仅是固定torch包的随机种子，其他包的随机种子还是不固定的\n",
    "# 但设备、版本和部分运算仍可能影响结果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 546,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mynetwork(nn.Module):                                        # class 定义一个神经网络类，继承自nn.Module的基础模板，可以使用nn.Module的各种方法和属性\n",
    "    def __init__(self,input_num=1 , out_num=1,hidden_num=32):      # 创建网络时进行的初始化操作，input_num是输入层的默认神经元数量，hidden_num是隐藏层的默认神经元数量\n",
    "        super().__init__()                                         # 这个是固定写法，表示调用父类的初始化方法，确保父类的初始化逻辑被执行，对于我们来说，记住这个必写就可以了。\n",
    "        self.MLP=nn.Sequential(                                    # 这里定义了一个我们自定义的属性“MLP”，使用nn.Sequential将多个层按顺序组合起来\n",
    "            nn.Linear(input_num, hidden_num),                      # nn.Sequential是一个容器，可以将多个层组合成一个整体，按顺序执行\n",
    "            nn.ELU(),                                              # 这种写法相比于我们第三次作业中的网络分层定义，更加简洁，避免了去定义每一层的变量名，不过灵活性会稍微差一些\n",
    "            nn.Linear(hidden_num,hidden_num),                      # nn.Linear是一个全连接层，nn.ELU()是一个激活函数层，ELU是指数线性单元（Exponential Linear Unit）\n",
    "            nn.ELU(),\n",
    "            nn.Linear(hidden_num,hidden_num),                      # 关于网络参数的选择，目前这样的一个网络算是一种较小的test型网络。\n",
    "            nn.ELU(),                                              # 在实际应用中，选择网络参数需要根据具体问题进行调试和优化，可能需要尝试不同的网络结构、层数、神经元数量等，以找到最适合的配置。\n",
    "            nn.Linear(hidden_num,out_num),                         # 在探索参数选择的过程中，首先最重要的是要先通过小步扩展来判断自己的问题中，网络规模扩张（深、宽、数据类型）带来的计算内存开销、时间消耗的增长。                                                           \n",
    "        )                                                          # 由此来先确定自己的计算资源和时间所能承受的范围，然后再在这个范围内去按计划尝试不同的网络参数选择，最终找到一个最优的网络结构。\n",
    "    def forward(self,x):\n",
    "        return self.MLP(x)                                         # 由于我们用nn.Sequential定义了一个整体的网络，所以在前向传播时，直接调用self.MLP(x)就可以了\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 547,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n    def __init__(self):\\n        super().__init__()\\n        self.fc1 = nn.Linear(2*N*10, layer_num)\\n        self.fc2 = nn.Linear(layer_num, layer_num)\\n        self.fc3 = nn.Linear(layer_num, (N+1) * 10)  # 输出 N+1 个位置，每个位置 10 个类别\\n\\n    def forward(self, x: torch.Tensor):\\n        x = x.view(-1, 2*N*10)\\n        x = torch.relu(self.fc1(x))\\n        x = torch.relu(self.fc2(x))\\n        x = self.fc3(x)\\n        x = x.view(-1,( N+1)* 10)\\n        x = torch.log_softmax(x, dim=1)  # 输出概率分布的对数值。用 log_softmax 代替 softmax，以防止数值不稳定\\n        return x\\n'"
      ]
     },
     "execution_count": 547,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(2*N*10, layer_num)\n",
    "        self.fc2 = nn.Linear(layer_num, layer_num)\n",
    "        self.fc3 = nn.Linear(layer_num, (N+1) * 10)  # 输出 N+1 个位置，每个位置 10 个类别\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = x.view(-1, 2*N*10)\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        x = x.view(-1,( N+1)* 10)\n",
    "        x = torch.log_softmax(x, dim=1)  # 输出概率分布的对数值。用 log_softmax 代替 softmax，以防止数值不稳定\n",
    "        return x\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 548,
   "metadata": {},
   "outputs": [],
   "source": [
    "def potential(x):                                  # 这个是我们要拟合的目标函数\n",
    "    y=x*torch.sin(torch.pi*x*2/3)+x**2*2+10\n",
    "    return y\n",
    "\n",
    "# 因为这里我们的目标函数已经清晰，如何生成训练数据非常容易，所以我们不需要使用例如DataLoader这样的工具来管理、操作。不过这个工具的使用也不难，大家可以自行参考相关文档"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 549,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtype=torch.float32                    # 数据类型，datatype，请根据具体情况选择所需的数据精度，足够表示，不影响训练就可以了\n",
    "device=torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\") \n",
    "# 计算设备选择，cuda就是用显卡设备来训练，cuda:0就是指定第一块显卡，cpu就是用电脑的CPU来训练。如果不写device去指定，那么会默认直接用CPU。\n",
    "# 如果你训练的时候，发现第一块显卡被其他同学占用了，你可以自己指定换成cuda:1,就是第二块显卡，cuda:2就是第三块显卡，依次类推\n",
    "# 判断显卡是否繁忙主要看 Memory-Usage 和 GPU-Util，前者是显存占用率，后者是计算占用率\n",
    "# 可以用watch -n 1 nvidia-smi命令来实时查看GPU的使用情况（-n 1表示每1秒更新一次），或者使用nvitop指令，界面更清楚\n",
    "# 而通常查看CPU的使用情况可以用htop指令，或者top，前者界面更清楚，后者是最基本的指令。\n",
    "\n",
    "La=-12    # 左边界a\n",
    "Lb =12    # 右边界b\n",
    "N = 800   # 格点数量,这里的格点数量，就类似于我们通常情况下的“batch size”了，也就是一次梯度下降时使用的累计样本数量\n",
    "\n",
    "grid=torch.linspace(La,Lb,N,dtype=dtype,device=device,requires_grad=False) # 用torch定义的格点，指定了数据类型和设备，并且指定该类数据不需要计算梯度。这里我们做演示，就采用固定格点来训练，训练会方便一些，更快。\n",
    "grid=grid.unsqueeze(-1)                                                    # 这里我们用unsqueeze把grid的形状从(N,)变成了(N,1)，因为我们定义的网络输入层是1个，所以这里需要把grid变成(N,1)的形状。\n",
    "\n",
    "# 你可以尝试注释掉unsqueeze这一行，看看会有什么报错\n",
    "\n",
    "epoch=12000  # 训练轮数\n",
    "lr=0.01      # 起始学习率\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 550,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:0,train_loss:18411.001953125,time:0.004842519760131836,lr:0.01\n",
      "epoch:100,train_loss:110.85800170898438,time:0.23454523086547852,lr:0.01\n",
      "epoch:200,train_loss:17.58053207397461,time:0.4712390899658203,lr:0.01\n",
      "epoch:300,train_loss:15.190961837768555,time:0.7012531757354736,lr:0.01\n",
      "epoch:400,train_loss:14.829568862915039,time:0.9337944984436035,lr:0.01\n",
      "epoch:500,train_loss:14.628449440002441,time:1.165781021118164,lr:0.01\n",
      "epoch:600,train_loss:14.47785758972168,time:1.3979310989379883,lr:0.01\n",
      "epoch:700,train_loss:14.348600387573242,time:1.6317288875579834,lr:0.01\n",
      "epoch:800,train_loss:15.208807945251465,time:1.8647007942199707,lr:0.01\n",
      "epoch:900,train_loss:14.202492713928223,time:2.090874671936035,lr:0.001\n",
      "epoch:1000,train_loss:14.187517166137695,time:2.3278872966766357,lr:0.001\n",
      "epoch:1100,train_loss:14.172142028808594,time:2.555849313735962,lr:0.001\n",
      "epoch:1200,train_loss:14.156261444091797,time:2.7881226539611816,lr:0.001\n",
      "epoch:1300,train_loss:14.139301300048828,time:3.0212368965148926,lr:0.001\n",
      "epoch:1400,train_loss:14.121016502380371,time:3.2503957748413086,lr:0.001\n",
      "epoch:1500,train_loss:14.101296424865723,time:3.4732964038848877,lr:0.001\n",
      "epoch:1600,train_loss:14.080242156982422,time:3.6979751586914062,lr:0.001\n",
      "epoch:1700,train_loss:14.057917594909668,time:3.9207370281219482,lr:0.001\n",
      "epoch:1800,train_loss:14.034164428710938,time:4.145089387893677,lr:0.001\n",
      "epoch:1900,train_loss:14.008684158325195,time:4.368898153305054,lr:0.001\n",
      "epoch:2000,train_loss:13.981154441833496,time:4.591480255126953,lr:0.001\n",
      "epoch:2100,train_loss:13.951220512390137,time:4.834418058395386,lr:0.001\n",
      "epoch:2200,train_loss:13.918449401855469,time:5.06925630569458,lr:0.001\n",
      "epoch:2300,train_loss:13.88231372833252,time:5.305926561355591,lr:0.001\n",
      "epoch:2400,train_loss:13.842138290405273,time:5.546279430389404,lr:0.001\n",
      "epoch:2500,train_loss:13.797123908996582,time:5.781099319458008,lr:0.001\n",
      "epoch:2600,train_loss:13.746193885803223,time:6.017056703567505,lr:0.001\n",
      "epoch:2700,train_loss:13.687910079956055,time:6.2496631145477295,lr:0.001\n",
      "epoch:2800,train_loss:13.620468139648438,time:6.475085258483887,lr:0.001\n",
      "epoch:2900,train_loss:13.541438102722168,time:6.700105905532837,lr:0.001\n",
      "epoch:3000,train_loss:13.447772979736328,time:6.924379110336304,lr:0.001\n",
      "epoch:3100,train_loss:13.335728645324707,time:7.148844003677368,lr:0.001\n",
      "epoch:3200,train_loss:13.200871467590332,time:7.373458385467529,lr:0.001\n",
      "epoch:3300,train_loss:13.038372039794922,time:7.600604772567749,lr:0.001\n",
      "epoch:3400,train_loss:12.843524932861328,time:7.835951328277588,lr:0.001\n",
      "epoch:3500,train_loss:12.608110427856445,time:8.069189548492432,lr:0.001\n",
      "epoch:3600,train_loss:12.31723403930664,time:8.29159140586853,lr:0.001\n",
      "epoch:3700,train_loss:11.981742858886719,time:8.511895895004272,lr:0.001\n",
      "epoch:3800,train_loss:11.599078178405762,time:8.732720375061035,lr:0.001\n",
      "epoch:3900,train_loss:11.164289474487305,time:8.952880144119263,lr:0.001\n",
      "epoch:4000,train_loss:10.660248756408691,time:9.173529386520386,lr:0.001\n",
      "epoch:4100,train_loss:10.089672088623047,time:9.39467167854309,lr:0.001\n",
      "epoch:4200,train_loss:9.480738639831543,time:9.615317344665527,lr:0.001\n",
      "epoch:4300,train_loss:8.835295677185059,time:9.84409785270691,lr:0.001\n",
      "epoch:4400,train_loss:8.163290977478027,time:10.070646047592163,lr:0.001\n",
      "epoch:4500,train_loss:7.365195274353027,time:10.29808259010315,lr:0.001\n",
      "epoch:4600,train_loss:6.560342788696289,time:10.522731065750122,lr:0.001\n",
      "epoch:4700,train_loss:5.824617862701416,time:10.747547626495361,lr:0.001\n",
      "epoch:4800,train_loss:5.19984769821167,time:10.974195718765259,lr:0.001\n",
      "epoch:4900,train_loss:4.68257999420166,time:11.197509765625,lr:0.001\n",
      "epoch:5000,train_loss:4.271015644073486,time:11.42589807510376,lr:0.001\n",
      "epoch:5100,train_loss:3.9565606117248535,time:11.652895212173462,lr:0.001\n",
      "epoch:5200,train_loss:3.716932535171509,time:11.878429889678955,lr:0.001\n",
      "epoch:5300,train_loss:3.5310423374176025,time:12.103486061096191,lr:0.001\n",
      "epoch:5400,train_loss:3.380643844604492,time:12.328575611114502,lr:0.001\n",
      "epoch:5500,train_loss:3.2417407035827637,time:12.555377006530762,lr:0.001\n",
      "epoch:5600,train_loss:3.1195671558380127,time:12.781010627746582,lr:0.001\n",
      "epoch:5700,train_loss:3.0073578357696533,time:13.006986141204834,lr:0.001\n",
      "epoch:5800,train_loss:2.8860433101654053,time:13.232312440872192,lr:0.001\n",
      "epoch:5900,train_loss:2.7645251750946045,time:13.460218667984009,lr:0.001\n",
      "epoch:6000,train_loss:2.6438393592834473,time:13.685314655303955,lr:0.001\n",
      "epoch:6100,train_loss:2.513310432434082,time:13.910719871520996,lr:0.001\n",
      "epoch:6200,train_loss:2.3798069953918457,time:14.137380838394165,lr:0.001\n",
      "epoch:6300,train_loss:2.247786521911621,time:14.360487937927246,lr:0.001\n",
      "epoch:6400,train_loss:2.1211860179901123,time:14.5814528465271,lr:0.001\n",
      "epoch:6500,train_loss:2.007619857788086,time:14.80326533317566,lr:0.001\n",
      "epoch:6600,train_loss:1.8843337297439575,time:15.025578260421753,lr:0.001\n",
      "epoch:6700,train_loss:1.7731612920761108,time:15.26265025138855,lr:0.001\n",
      "epoch:6800,train_loss:1.6490423679351807,time:15.493676900863647,lr:0.001\n",
      "epoch:6900,train_loss:1.5401643514633179,time:15.727216958999634,lr:0.001\n",
      "epoch:7000,train_loss:1.4401562213897705,time:15.954206228256226,lr:0.001\n",
      "epoch:7100,train_loss:1.3816648721694946,time:16.180573225021362,lr:0.001\n",
      "epoch:7200,train_loss:1.4329551458358765,time:16.414371252059937,lr:0.001\n",
      "epoch:7300,train_loss:1.1923564672470093,time:16.639400005340576,lr:0.001\n",
      "epoch:7400,train_loss:1.1163232326507568,time:16.86646318435669,lr:0.001\n",
      "epoch:7500,train_loss:1.048782467842102,time:17.090769290924072,lr:0.0001\n",
      "epoch:7600,train_loss:1.0404011011123657,time:17.315361976623535,lr:0.0001\n",
      "epoch:7700,train_loss:1.031854271888733,time:17.54466986656189,lr:0.0001\n",
      "epoch:7800,train_loss:1.022757649421692,time:17.776652097702026,lr:0.0001\n",
      "epoch:7900,train_loss:1.0129600763320923,time:18.002079248428345,lr:0.0001\n",
      "epoch:8000,train_loss:1.002095103263855,time:18.231680870056152,lr:0.0001\n",
      "epoch:8100,train_loss:0.989155650138855,time:18.45863127708435,lr:0.0001\n",
      "epoch:8200,train_loss:0.9705618023872375,time:18.687884092330933,lr:0.0001\n",
      "epoch:8300,train_loss:0.9422773718833923,time:18.91660165786743,lr:0.0001\n",
      "epoch:8400,train_loss:0.9226653575897217,time:19.142988681793213,lr:0.0001\n",
      "epoch:8500,train_loss:0.9083887338638306,time:19.37563681602478,lr:0.0001\n",
      "epoch:8600,train_loss:0.8944027423858643,time:19.60071635246277,lr:0.0001\n",
      "epoch:8700,train_loss:0.8803054690361023,time:19.83296251296997,lr:0.0001\n",
      "epoch:8800,train_loss:0.8659948706626892,time:20.06264615058899,lr:0.0001\n",
      "epoch:8900,train_loss:0.8513931035995483,time:20.293076038360596,lr:0.0001\n",
      "epoch:9000,train_loss:0.836454451084137,time:20.524984121322632,lr:0.0001\n",
      "epoch:9100,train_loss:0.8211544752120972,time:20.754987955093384,lr:0.0001\n",
      "epoch:9200,train_loss:0.8054617047309875,time:20.992491960525513,lr:0.0001\n",
      "epoch:9300,train_loss:0.7893514633178711,time:21.22255301475525,lr:0.0001\n",
      "epoch:9400,train_loss:0.7728306651115417,time:21.451836109161377,lr:0.0001\n",
      "epoch:9500,train_loss:0.7558884024620056,time:21.683242559432983,lr:0.0001\n",
      "epoch:9600,train_loss:0.7384935021400452,time:21.91243267059326,lr:0.0001\n",
      "epoch:9700,train_loss:0.7205883860588074,time:22.14257264137268,lr:0.0001\n",
      "epoch:9800,train_loss:0.7021007537841797,time:22.37173628807068,lr:0.0001\n",
      "epoch:9900,train_loss:0.6830517649650574,time:22.601688385009766,lr:0.0001\n",
      "epoch:10000,train_loss:0.6636183261871338,time:22.837986946105957,lr:0.0001\n",
      "epoch:10100,train_loss:0.644112229347229,time:23.071028232574463,lr:0.0001\n",
      "epoch:10200,train_loss:0.6245487332344055,time:23.30179452896118,lr:0.0001\n",
      "epoch:10300,train_loss:0.6047046780586243,time:23.531216382980347,lr:0.0001\n",
      "epoch:10400,train_loss:0.584556519985199,time:23.76363730430603,lr:0.0001\n",
      "epoch:10500,train_loss:0.5645787715911865,time:23.998741626739502,lr:0.0001\n",
      "epoch:10600,train_loss:0.5446854829788208,time:24.23323345184326,lr:0.0001\n",
      "epoch:10700,train_loss:0.524888813495636,time:24.458651304244995,lr:0.0001\n",
      "epoch:10800,train_loss:0.5055217146873474,time:24.682341814041138,lr:0.0001\n",
      "epoch:10900,train_loss:0.4864844083786011,time:24.907315015792847,lr:0.0001\n",
      "epoch:11000,train_loss:0.46710440516471863,time:25.13211154937744,lr:0.0001\n",
      "epoch:11100,train_loss:0.4438101053237915,time:25.366856575012207,lr:0.0001\n",
      "epoch:11200,train_loss:0.4258485734462738,time:25.600341320037842,lr:0.0001\n",
      "epoch:11300,train_loss:0.40807655453681946,time:25.839513540267944,lr:0.0001\n",
      "epoch:11400,train_loss:0.3897169530391693,time:26.08141541481018,lr:0.0001\n",
      "epoch:11500,train_loss:0.37077629566192627,time:26.31732964515686,lr:0.0001\n",
      "epoch:11600,train_loss:0.35199397802352905,time:26.54985737800598,lr:0.0001\n",
      "epoch:11700,train_loss:0.3345426619052887,time:26.77903461456299,lr:0.0001\n",
      "epoch:11800,train_loss:0.3184145390987396,time:27.014850616455078,lr:0.0001\n",
      "epoch:11900,train_loss:0.30289316177368164,time:27.250335693359375,lr:0.0001\n",
      "terminal epoch:  12000\n"
     ]
    }
   ],
   "source": [
    "model=Mynetwork(hidden_num=64).to(device=device,dtype=dtype) # 这里我们主动指定了参数hidden_num=64\n",
    "optimizer=torch.optim.Adam(model.parameters(),lr=lr)         # model.parameters()是获取模型的所有参数，注意到这个参数我们并没有主动定义，实际上就是继承自nn.Module，返回的是一个迭代器，里面包含了所有模型参数\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,patience=30,threshold=1e-4) \n",
    "# Plateau 是“高原；稳定期”的意思，threshold是阈值，patience是耐心值，意思是如果连续30次训练loss没有下降超过1e-4，那么就降低学习率\n",
    "loss_fn=nn.MSELoss()  # 损失函数，MSELoss是均方误差损失函数，常用于回归问题，也可以尝试其他各种各样的损失函数\n",
    "\n",
    "loss_list=[]          # 列表用于记录训练过程中的loss变化情况\n",
    "init_time=time.time() # 标记训练开始时间\n",
    "\n",
    "for i in range(epoch):\n",
    "    optimizer.zero_grad()        # 清零梯度，避免梯度累加\n",
    "    \n",
    "    # grid = La + (Lb - La) * torch.rand(N, 1, dtype=dtype, device=device) # 可以去掉注释，尝试用随机点试试看训练效果如何\n",
    "    f_Value=model(grid)\n",
    "    f_Value_real=potential(grid)\n",
    "    \n",
    "    \n",
    "    train_loss=loss_fn(f_Value,f_Value_real)   # 用前面定义的损失函数来计算当次训练的loss\n",
    "    train_loss.backward()                      # 反向传播，计算梯度\n",
    "    optimizer.step()                           # 按优化器方案更新参数\n",
    "    \n",
    "    loss_list.append(train_loss.item())        # 记录训练过程中的loss变化情况，train_loss.item()是把tensor类型的loss转换成python的float类型，方便可视化   \n",
    "    \n",
    "    if i%100==0:\n",
    "        print(f'epoch:{i},train_loss:{train_loss},time:{time.time()-init_time},lr:{optimizer.param_groups[0][\"lr\"]}')  # 定时反馈训练情况\n",
    "    \n",
    "    scheduler.step(train_loss)\n",
    "    if optimizer.param_groups[0][\"lr\"] <= 1.1e-7:\n",
    "        print(f'epoch:{i},train_loss:{train_loss},time:{time.time()-init_time},lr:{optimizer.param_groups[0][\"lr\"]}')  # 如果学习率已经小于1.1e-7了，就及时阻断，因为后续的训练收效甚微，浪费时间\n",
    "        break\n",
    "print('terminal epoch: ',i+1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch 的张量与自动求导\n",
    "\n",
    "PyTorch 用 `Tensor`（张量）保存数据。除了保存数值，它还可以记录数据经过了哪些计算，并据此自动计算导数。这些运算之间的联系称为**计算图**。\n",
    "\n",
    "`requires_grad` 表示是否需要跟踪求导。它为 `True`，并不意味着梯度已经算出来了。\n",
    "\n",
    "### 对照上面的训练程序\n",
    "\n",
    "| 对象 | 是否需要梯度 | 作用 |\n",
    "| --- | --- | --- |\n",
    "| `grid` | 否 | 输入坐标，是已知数据 |\n",
    "| `f_Value_real` | 否 | 由目标函数计算的正确答案 |\n",
    "| 网络的权重和偏置 | 是，默认开启 | 训练中需要调整的参数 |\n",
    "| `f_Value` | 是 | 预测依赖网络参数，因此会记录计算过程 |\n",
    "| `train_loss` | 是 | 损失依赖预测，可以沿计算图求导 |\n",
    "\n",
    "**输入不需要梯度，也不妨碍训练网络。** 本例要计算的是“损失对网络参数的导数”，用来判断参数应该怎样调整。\n",
    "\n",
    "### 一次训练更新做了什么？\n",
    "\n",
    "1. `optimizer.zero_grad()`：清除上一次留下的参数梯度。\n",
    "2. `f_Value = model(grid)`：计算预测，并记录计算过程。\n",
    "3. `train_loss = loss_fn(f_Value, f_Value_real)`：计算预测与答案的差距。\n",
    "4. `train_loss.backward()`：沿计算图反向求导，将梯度累积到网络参数的 `.grad` 中。\n",
    "5. `optimizer.step()`：利用这些梯度更新参数。\n",
    "\n",
    "注意：**`backward()` 计算梯度，`step()` 才更新参数。** PyTorch 默认会累积梯度，所以普通训练通常每次更新前都要清除旧梯度。\n",
    "\n",
    "### 为什么记录损失时使用 `.item()`？\n",
    "\n",
    "`train_loss` 是一个参与自动求导的标量张量；`train_loss.item()` 则取出它的数值，变成普通 Python 数字，方便打印和保存。\n",
    "\n",
    "因此，记录损失可以写：\n",
    "\n",
    "`loss_list.append(train_loss.item())`\n",
    "\n",
    "但计算用于训练的损失时，不能提前用 `.item()` 把预测转成普通数字，否则会断开求导链路。\n",
    "\n",
    "类似地，`detach()` 会得到脱离当前计算图的张量；`torch.no_grad()` 可以临时停止记录计算图。它们适合绘图和预测检查，不应包住需要反向传播的训练计算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-17.,  -7.,   3.,  13.,  23.], device='cuda:0')\n",
      "None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1992701/1633435708.py:7: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at /pytorch/build/aten/src/ATen/core/TensorBody.h:489.)\n",
      "  print(b.grad)\n"
     ]
    }
   ],
   "source": [
    "# 一个带梯度的数据，其梯度是可以查看的\n",
    "a=torch.linspace(-10,10,5,dtype=dtype,device=device,requires_grad=True) \n",
    "b=a**2+3*a+5\n",
    "c=b.sum()\n",
    "c.backward()\n",
    "print(a.grad)\n",
    "print(b.grad)  \n",
    "\n",
    "# 可以看看b的梯度，应该是None，因为b不是叶子节点，叶子节点才会有梯度，b是由a计算出来的，所以b的梯度不会被保留，除非我们在定义b的时候加上retain_grad()，例如b.retain_grad()，这样就可以保留b的梯度了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 558,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt   # 导入matplotlib.pyplot模块，用于绘制图形，这个不详细介绍了，大家可以自己参考pyplot的官方文档\n",
    "\n",
    "plt.plot(loss_list)\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 559,
   "metadata": {},
   "outputs": [],
   "source": [
    "#保存模型参数\n",
    "os.makedirs(f'./model_para', exist_ok=True)  # 前面加f是可以让后面路径中，{}里面的变量被识别，例如可以加上你的时间戳\n",
    "model_path=f'./model_para/model_class.pth'\n",
    "torch.save(model.state_dict(), model_path)   # model.state_dict()是获取模型的所有参数，保存为一个字典，torch.save()是保存这个字典到指定路径\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Mynetwork(\n",
       "  (MLP): Sequential(\n",
       "    (0): Linear(in_features=1, out_features=64, bias=True)\n",
       "    (1): ELU(alpha=1.0)\n",
       "    (2): Linear(in_features=64, out_features=64, bias=True)\n",
       "    (3): ELU(alpha=1.0)\n",
       "    (4): Linear(in_features=64, out_features=64, bias=True)\n",
       "    (5): ELU(alpha=1.0)\n",
       "    (6): Linear(in_features=64, out_features=1, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 560,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读取模型参数\n",
    "model_path=f'./model_para/model_class.pth'\n",
    "model = Mynetwork(hidden_num=64).to(device=device,dtype=dtype)  # 读取模型参数时，需要重新创建一个模型实例，并且要确保模型的结构和参数数量与保存时一致，否则会报错\n",
    "model.load_state_dict(torch.load(model_path))                   # 导入模型参数\n",
    "model.eval()                                                    # 这个是把模型设置为评估模式，主要是为了关闭dropout和batch normalization等训练时特有的操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "grid=torch.linspace(La,Lb,N,dtype=dtype,device=device)\n",
    "grid=grid.unsqueeze(-1)\n",
    "\n",
    "f_network=model(grid)\n",
    "f_network=f_network.cpu().detach().numpy()  # 这里的.cpu()是把数据从GPU上转移到CPU上，detach()是得到脱离当前计算图的张量，numpy()是把tensor类型的数据转换成numpy数组类型，这样就可以用matplotlib来绘图了\n",
    "\n",
    "f_real=potential(grid)\n",
    "f_real=f_real.cpu().detach().numpy()\n",
    "\n",
    "plt.plot(grid.cpu().detach().numpy(),f_real,label='real')\n",
    "plt.plot(grid.cpu().detach().numpy(),f_network,label='NN')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f_network=model(grid)\n",
    "V_model=f_network.flatten().detach().cpu().numpy()\n",
    "\n",
    "f_real=potential(grid)\n",
    "V_real=f_real.flatten().detach().cpu().numpy()\n",
    "\n",
    "plt.plot(np.abs((V_real-V_model)/V_real))\n",
    "# plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pubpy",
   "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.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}