From e4553deb77503cb747b38046569bedd802929d3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 19 Nov 2022 06:28:06 +0800
Subject: [PATCH 01/14] Create GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -0,0 +1 @@
+

From a4ebe54cfb38b598c8ef3e85f4d981a92cdae14f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 19 Nov 2022 06:28:25 +0800
Subject: [PATCH 02/14] Add files via upload

---
 .../gan/GAN_with_MINIST/main (2).ipynb        | 668 ++++++++++++++++++
 1 file changed, 668 insertions(+)
 create mode 100644 docs/practices/gan/GAN_with_MINIST/main (2).ipynb

diff --git a/docs/practices/gan/GAN_with_MINIST/main (2).ipynb b/docs/practices/gan/GAN_with_MINIST/main (2).ipynb
new file mode 100644
index 00000000000..30fbfcd93a2
--- /dev/null
+++ b/docs/practices/gan/GAN_with_MINIST/main (2).ipynb	
@@ -0,0 +1,668 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "tags": []
+   },
+   "source": [
+    "# MNIST数据集下用Paddle框架的动态图模式玩耍经典对抗生成网络（GAN）\n",
+    "\n",
+    "作者信息：[Liyulingyue](https://github.com/Liyulingyue)\n",
+    "\n",
+    "更新日期：2022 年 11 月 18 日\n",
+    "\n",
+    "## 1. 简要介绍\n",
+    "### 关于GAN\n",
+    "简单来说，可以将GAN看作是一种框架，这个框架提供了一种不需要标签即可进行训练的方法。稍微具体一点来说，有一个生成任务，需要生成一组和训练集相同分布的数据，可以按照以下步骤和逻辑训练生成模型：\n",
+    "1. 定义生成模型G，input是一组随机数，output是生成的数据\n",
+    "2. 定义鉴别模型D，input是一组数据，output是这组数据是否是被生成的\n",
+    "3. 将已有数据作为正样本，将生成的数据作为负样本，训练二分类D\n",
+    "4. 将生成数据输入D，将D的输出和正标签求loss，以此loss更新G\n",
+    "5. 重复3和4直至收敛\n",
+    "\n",
+    "### 关于MINIST\n",
+    "一个手写数字数据集，Paddle已经集成了这个数据集。\n",
+    "\n",
+    "### 关于Paddle的梯度反馈\n",
+    "- 目前Paddle的梯度反馈是自动累加模式，所以可以多个batch，或者多个模块的loss单独进行backword\n",
+    "- 通过[Tensor].detach()的方式可以截断梯度传播\n",
+    "\n",
+    "### 致谢\n",
+    "本文参考以下项目\n",
+    "- [一文搞懂生成对抗网络之经典GAN（动态图、VisualDL2.0）](https://aistudio.baidu.com/aistudio/projectdetail/551962)\n",
+    "- [生成对抗网络七日打卡营](https://aistudio.baidu.com/aistudio/course/introduce/16651)\n",
+    "\n",
+    "**什么？上面没看懂？不重要！往下看就行了！锐利的loss！锐利的更新！永远的两步走！**\n",
+    "\n",
+    "## 2. 环境设置\n",
+    "导入包，主要包括paddle和一些画图辅助，如plt\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:56:15.275443Z",
+     "iopub.status.busy": "2022-11-18T14:56:15.274825Z",
+     "iopub.status.idle": "2022-11-18T14:56:18.239494Z",
+     "shell.execute_reply": "2022-11-18T14:56:18.238232Z",
+     "shell.execute_reply.started": "2022-11-18T14:56:15.275404Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/__init__.py:107: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\r\n",
+      "  from collections import MutableMapping\r\n",
+      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/rcsetup.py:20: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\r\n",
+      "  from collections import Iterable, Mapping\r\n",
+      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/colors.py:53: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\r\n",
+      "  from collections import Sized\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import paddle \n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.animation as animation\n",
+    "import cv2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. 数据集\n",
+    "Paddle已经集成MNIST数据集了，直接调用即可。本项目通过`paddle.vision.datasets.MNIST`导入数据集，并且用paddle.io.DataLoader封装为读取器。\n",
+    "\n",
+    "如果想要换成其他数据集，可以自行参考如何使用`paddle.io.Dataset`和`paddle.io.DataLoader`，封装后即可轻松复用本项目代码进行训练。\n",
+    "\n",
+    "首先，加载数据集。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset = paddle.vision.datasets.MNIST(mode='train', \n",
+    "                                        transform=paddle.vision.transforms.Compose([\n",
+    "                                            paddle.vision.transforms.Resize((32,32)),\n",
+    "                                            paddle.vision.transforms.Normalize([0], [255])\n",
+    "                                        ]))\n",
+    "\n",
+    "dataloader = paddle.io.DataLoader(dataset, batch_size=32,shuffle=True, num_workers=4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "查看数据的形状，可以看到从dataloader返回的数据格式中，每张图大小为32*32，每张图片带有一个标签。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:56:26.398712Z",
+     "iopub.status.busy": "2022-11-18T14:56:26.398464Z",
+     "iopub.status.idle": "2022-11-18T14:56:28.588250Z",
+     "shell.execute_reply": "2022-11-18T14:56:28.586489Z",
+     "shell.execute_reply.started": "2022-11-18T14:56:26.398689Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 [32, 1, 32, 32] [32, 1]\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "for step, data in enumerate(dataloader):\n",
+    "    data, label = data\n",
+    "    print(step, data.shape, label.shape)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "查看一张图片。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:56:33.127447Z",
+     "iopub.status.busy": "2022-11-18T14:56:33.126723Z",
+     "iopub.status.idle": "2022-11-18T14:56:33.300217Z",
+     "shell.execute_reply": "2022-11-18T14:56:33.299356Z",
+     "shell.execute_reply.started": "2022-11-18T14:56:33.127406Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f58c027bb50>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(data[0].numpy()[0])\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "通过下述代码可以快捷查看十张图片。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T15:44:02.287336Z",
+     "iopub.status.busy": "2022-11-18T15:44:02.285886Z",
+     "iopub.status.idle": "2022-11-18T15:44:02.507338Z",
+     "shell.execute_reply": "2022-11-18T15:44:02.506391Z",
+     "shell.execute_reply.started": "2022-11-18T15:44:02.287293Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in range(10):\n",
+    "    image = data[i].numpy()[0]\n",
+    "    plt.subplot(1, 10, i + 1)\n",
+    "\n",
+    "    plt.imshow(image, vmin=-1, vmax=1)\n",
+    "    plt.axis('off')\n",
+    "    plt.xticks([])\n",
+    "    plt.yticks([])\n",
+    "    plt.subplots_adjust(wspace=0.1, hspace=0.1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. 模型组网\n",
+    "由于GAN只是一种框架，因此我们可以使用任何网络，这里简单使用了全连接层。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:57:02.380985Z",
+     "iopub.status.busy": "2022-11-18T14:57:02.380290Z",
+     "iopub.status.idle": "2022-11-18T14:57:02.844687Z",
+     "shell.execute_reply": "2022-11-18T14:57:02.843654Z",
+     "shell.execute_reply.started": "2022-11-18T14:57:02.380931Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generator(\r\n",
+      "  (gen): Sequential(\r\n",
+      "    (0): Linear(in_features=100, out_features=256, dtype=float32)\r\n",
+      "    (1): ReLU(name=True)\r\n",
+      "    (2): Linear(in_features=256, out_features=512, dtype=float32)\r\n",
+      "    (3): ReLU(name=True)\r\n",
+      "    (4): Linear(in_features=512, out_features=1024, dtype=float32)\r\n",
+      "    (5): Tanh()\r\n",
+      "  )\r\n",
+      ")\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      " Layer (type)       Input Shape          Output Shape         Param #    \r\n",
+      "===========================================================================\r\n",
+      "   Linear-2          [[8, 100]]            [8, 256]           25,856     \r\n",
+      "    ReLU-1           [[8, 256]]            [8, 256]              0       \r\n",
+      "   Linear-3          [[8, 256]]            [8, 512]           131,584    \r\n",
+      "    ReLU-2           [[8, 512]]            [8, 512]              0       \r\n",
+      "   Linear-4          [[8, 512]]           [8, 1024]           525,312    \r\n",
+      "    Tanh-1          [[8, 1024]]           [8, 1024]              0       \r\n",
+      "===========================================================================\r\n",
+      "Total params: 682,752\r\n",
+      "Trainable params: 682,752\r\n",
+      "Non-trainable params: 0\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "Input size (MB): 0.00\r\n",
+      "Forward/backward pass size (MB): 0.22\r\n",
+      "Params size (MB): 2.60\r\n",
+      "Estimated Total Size (MB): 2.83\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "\r\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'total_params': 682752, 'trainable_params': 682752}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Generator Code\n",
+    "class Generator(paddle.nn.Layer):\n",
+    "    def __init__(self, ):\n",
+    "        super(Generator, self).__init__()\n",
+    "        self.gen = paddle.nn.Sequential(\n",
+    "            paddle.nn.Linear(in_features=100, out_features=256),\n",
+    "            paddle.nn.ReLU(True),\n",
+    "            paddle.nn.Linear(in_features=256, out_features=512),\n",
+    "            paddle.nn.ReLU(True),\n",
+    "            paddle.nn.Linear(in_features=512, out_features=1024),\n",
+    "            paddle.nn.Tanh(),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.gen(x)\n",
+    "        out = paddle.reshape(x,[-1,1,32,32])\n",
+    "        return out\n",
+    "\n",
+    "# 创建模型\n",
+    "netG = Generator()\n",
+    "print(netG)\n",
+    "\n",
+    "# 通过paddle.summary可以查看一个指定形状的数据在网络中各个模块中的传递\n",
+    "paddle.summary(netG, (8, 100))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:57:11.520623Z",
+     "iopub.status.busy": "2022-11-18T14:57:11.520016Z",
+     "iopub.status.idle": "2022-11-18T14:57:11.537228Z",
+     "shell.execute_reply": "2022-11-18T14:57:11.536325Z",
+     "shell.execute_reply.started": "2022-11-18T14:57:11.520583Z"
+    },
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Discriminator(\r\n",
+      "  (dis): Sequential(\r\n",
+      "    (0): Linear(in_features=1024, out_features=512, dtype=float32)\r\n",
+      "    (1): LeakyReLU(negative_slope=0.2)\r\n",
+      "    (2): Linear(in_features=512, out_features=256, dtype=float32)\r\n",
+      "    (3): LeakyReLU(negative_slope=0.2)\r\n",
+      "    (4): Linear(in_features=256, out_features=1, dtype=float32)\r\n",
+      "    (5): Sigmoid()\r\n",
+      "  )\r\n",
+      ")\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      " Layer (type)       Input Shape          Output Shape         Param #    \r\n",
+      "===========================================================================\r\n",
+      "   Linear-5         [[8, 1024]]            [8, 512]           524,800    \r\n",
+      "  LeakyReLU-1        [[8, 512]]            [8, 512]              0       \r\n",
+      "   Linear-6          [[8, 512]]            [8, 256]           131,328    \r\n",
+      "  LeakyReLU-2        [[8, 256]]            [8, 256]              0       \r\n",
+      "   Linear-7          [[8, 256]]             [8, 1]              257      \r\n",
+      "   Sigmoid-1          [[8, 1]]              [8, 1]               0       \r\n",
+      "===========================================================================\r\n",
+      "Total params: 656,385\r\n",
+      "Trainable params: 656,385\r\n",
+      "Non-trainable params: 0\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "Input size (MB): 0.03\r\n",
+      "Forward/backward pass size (MB): 0.09\r\n",
+      "Params size (MB): 2.50\r\n",
+      "Estimated Total Size (MB): 2.63\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "\r\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'total_params': 656385, 'trainable_params': 656385}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Discriminator Code\n",
+    "class Discriminator(paddle.nn.Layer):\n",
+    "    def __init__(self, ):\n",
+    "        super(Discriminator, self).__init__()\n",
+    "        self.dis = paddle.nn.Sequential(\n",
+    "            paddle.nn.Linear(in_features=1024, out_features=512),\n",
+    "            paddle.nn.LeakyReLU(0.2),\n",
+    "            paddle.nn.Linear(in_features=512, out_features=256),\n",
+    "            paddle.nn.LeakyReLU(0.2),\n",
+    "            paddle.nn.Linear(in_features=256, out_features=1),\n",
+    "            paddle.nn.Sigmoid()\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = paddle.reshape(x, [-1, 1024])\n",
+    "        out = self.dis(x)\n",
+    "        return out\n",
+    "\n",
+    "netD = Discriminator()\n",
+    "print(netD)\n",
+    "\n",
+    "# 通过paddle.summary可以查看一个指定形状的数据在网络中各个模块中的传递\n",
+    "paddle.summary(netD, (8, 1, 32, 32))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. 模型训练"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T16:16:22.907384Z",
+     "iopub.status.busy": "2022-11-18T16:16:22.906610Z",
+     "iopub.status.idle": "2022-11-18T16:16:25.184043Z",
+     "shell.execute_reply": "2022-11-18T16:16:25.182665Z",
+     "shell.execute_reply.started": "2022-11-18T16:16:22.907342Z"
+    },
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch ID=0 Batch ID=100 \r\n",
+      "\r\n",
+      " D-Loss=0.3066627085208893 G-Loss=0.5891025066375732\r\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1500x1500 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# create Net\n",
+    "netG = Generator()\n",
+    "netD = Discriminator()\n",
+    "\n",
+    "# 如果想要接着之前训练的模型训练，将if 0修改为if 1即可\n",
+    "if 1:\n",
+    "    try:\n",
+    "        mydict = paddle.load('generator.params')\n",
+    "        netG.set_dict(mydict)\n",
+    "        mydict = paddle.load('discriminator.params')\n",
+    "        netD.set_dict(mydict)\n",
+    "    except:\n",
+    "        print('fail to load model')\n",
+    "\n",
+    "optimizerD = paddle.optimizer.Adam(parameters=netD.parameters(), learning_rate=0.0002, beta1=0.5, beta2=0.999)\n",
+    "optimizerG = paddle.optimizer.Adam(parameters=netG.parameters(), learning_rate=0.0002, beta1=0.5, beta2=0.999)\n",
+    "\n",
+    "# 最大迭代epoch\n",
+    "max_epoch = 10\n",
+    "\n",
+    "now_step = 0\n",
+    "for epoch in range(max_epoch):\n",
+    "    for step, (data, label) in enumerate(dataloader):\n",
+    "        ############################\n",
+    "        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
+    "        ###########################\n",
+    "\n",
+    "        # 清除D的梯度\n",
+    "        optimizerD.clear_grad()\n",
+    "\n",
+    "        # 传入正样本，并更新梯度\n",
+    "        pos_img = data\n",
+    "        label = paddle.full([pos_img.shape[0], 1], 1, dtype='float32')\n",
+    "        pre = netD(pos_img)\n",
+    "        loss_D_1 = paddle.nn.functional.mse_loss(pre, label)\n",
+    "        loss_D_1.backward()\n",
+    "\n",
+    "        # 通过randn构造随机数，制造负样本，并传入D，更新梯度\n",
+    "        noise = paddle.randn([pos_img.shape[0], 100], 'float32')\n",
+    "        neg_img = netG(noise)\n",
+    "        label = paddle.full([pos_img.shape[0], 1], 0, dtype='float32')\n",
+    "        pre = netD(neg_img.detach()) # 通过detach截断网络梯度，不影响G的梯度计算\n",
+    "        loss_D_2 = paddle.nn.functional.mse_loss(pre,label)\n",
+    "        loss_D_2.backward()\n",
+    "\n",
+    "        # 更新D网络参数\n",
+    "        optimizerD.step()\n",
+    "        optimizerD.clear_grad()\n",
+    "\n",
+    "        loss_D = loss_D_1 + loss_D_2\n",
+    "\n",
+    "        ############################\n",
+    "        # (2) Update G network: maximize log(D(G(z)))\n",
+    "        ###########################\n",
+    "\n",
+    "        # 清除D的梯度\n",
+    "        optimizerG.clear_grad()\n",
+    "\n",
+    "        noise = paddle.randn([pos_img.shape[0], 100],'float32')\n",
+    "        fake = netG(noise)\n",
+    "        label = paddle.full((pos_img.shape[0], 1), 1, dtype=np.float32,)\n",
+    "        output = netD(fake)\n",
+    "        loss_G = paddle.nn.functional.mse_loss(output,label)\n",
+    "        loss_G.backward()\n",
+    "\n",
+    "        # 更新G网络参数\n",
+    "        optimizerG.step()\n",
+    "        optimizerG.clear_grad()\n",
+    "\n",
+    "        now_step += 1\n",
+    "\n",
+    "        ###########################\n",
+    "        # 可视化\n",
+    "        ###########################\n",
+    "        if now_step % 100 == 0:\n",
+    "            generated_image = netG(noise).numpy()\n",
+    "            imgs = []\n",
+    "            plt.figure(figsize=(15,15))\n",
+    "            try:\n",
+    "                for i in range(10):\n",
+    "                    # image = generated_image[i].transpose()\n",
+    "                    image = generated_image[i]\n",
+    "                    image = np.where(image > 0, image, 0)\n",
+    "                    image = image.transpose((1,2,0))\n",
+    "                    plt.subplot(10, 10, i + 1)\n",
+    "                    \n",
+    "                    plt.imshow(image[...,0], vmin=-1, vmax=1)\n",
+    "                    plt.axis('off')\n",
+    "                    plt.xticks([])\n",
+    "                    plt.yticks([])\n",
+    "                    plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
+    "                msg = 'Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(epoch, now_step, loss_D.numpy()[0], errG.numpy()[0])\n",
+    "                print(msg)\n",
+    "                plt.suptitle(msg,fontsize=20)\n",
+    "                plt.draw()\n",
+    "                # 保存在work文件夹下\n",
+    "                plt.savefig('{}/{:04d}_{:04d}.png'.format('work', epoch, now_step), bbox_inches='tight')\n",
+    "                plt.pause(0.01)\n",
+    "            except IOError:\n",
+    "                print(IOError)\n",
+    "paddle.save(netG.state_dict(), \"generator.params\")\n",
+    "paddle.save(netD.state_dict(), \"discriminator.params\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. 模型预测\n",
+    "通过下述代码即可调用刚刚训练好的生成器啦~"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T16:20:27.124813Z",
+     "iopub.status.busy": "2022-11-18T16:20:27.124035Z",
+     "iopub.status.idle": "2022-11-18T16:20:27.311705Z",
+     "shell.execute_reply": "2022-11-18T16:20:27.310847Z",
+     "shell.execute_reply.started": "2022-11-18T16:20:27.124762Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f58c0125810>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "netG = Generator()\n",
+    "mydict = paddle.load('generator.params')\n",
+    "netG.set_dict(mydict)\n",
+    "\n",
+    "noise = paddle.randn([1, 100],'float32')\n",
+    "img = netG(noise)\n",
+    "img = img.numpy()[0][0]\n",
+    "img[img<0] = 0\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. 结语\n",
+    "本文简单的用全连接网络跑通了GAN的流程，如果对网络有更高的性能需求可以参考文首处的两个参考链接，内容类似，但是会更为详实。\n",
+    "\n",
+    "当然，在本文的基础上，如果删除了激活层，代码也是可以运行的，但是没有激活层的情况下，模型学习到的效果较差，因此，在GAN的时候，还是需要较为慎重的选择对应的生成模型。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "请点击[此处](https://ai.baidu.com/docs#/AIStudio_Project_Notebook/a38e5576)查看本环境基本用法.  <br>\n",
+    "Please click [here ](https://ai.baidu.com/docs#/AIStudio_Project_Notebook/a38e5576) for more detailed instructions. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "py35-paddle1.2.0"
+  },
+  "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From dfbd7f9f5f6b35a6a6874eb437626ea8e12ab9af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 19 Nov 2022 06:29:03 +0800
Subject: [PATCH 03/14] Delete GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
deleted file mode 100644
index 8b137891791..00000000000
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-

From fca1c1b671f7cdf09147ec234f0abec46fa0752d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 19 Nov 2022 06:29:46 +0800
Subject: [PATCH 04/14] Rename main (2).ipynb to GAN_with_MINIST.ipynb

---
 .../gan/GAN_with_MINIST/{main (2).ipynb => GAN_with_MINIST.ipynb} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/practices/gan/GAN_with_MINIST/{main (2).ipynb => GAN_with_MINIST.ipynb} (100%)

diff --git a/docs/practices/gan/GAN_with_MINIST/main (2).ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
similarity index 100%
rename from docs/practices/gan/GAN_with_MINIST/main (2).ipynb
rename to docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb

From d23ddee5b4c302a3efdd784a4577541b1baf928c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Mon, 21 Nov 2022 19:41:59 +0800
Subject: [PATCH 05/14] Update GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index 30fbfcd93a2..c6f9534d42d 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -557,7 +557,7 @@
     "                    plt.xticks([])\n",
     "                    plt.yticks([])\n",
     "                    plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
-    "                msg = 'Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(epoch, now_step, loss_D.numpy()[0], errG.numpy()[0])\n",
+    "                msg = 'Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(epoch, now_step, loss_D.numpy()[0], loss_G.numpy()[0])\n",
     "                print(msg)\n",
     "                plt.suptitle(msg,fontsize=20)\n",
     "                plt.draw()\n",

From ab320ee35645d9a36d1daeecc55c88f443551e16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Wed, 23 Nov 2022 22:52:34 +0800
Subject: [PATCH 06/14] Update GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index c6f9534d42d..0e67b407ae2 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -428,6 +428,7 @@
    "metadata": {},
    "source": [
     "## 5. 模型训练"
+    "大约需要半个小时~"
    ]
   },
   {

From 8c9e690b3478c37f74f9c3029265c955dc414be9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Mon, 28 Nov 2022 12:36:03 +0800
Subject: [PATCH 07/14] Update GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index 0e67b407ae2..d44dab0bc0f 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -427,7 +427,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 5. 模型训练"
+    "## 5. 模型训练\n",
     "大约需要半个小时~"
    ]
   },

From f2e317317eb1745d85605e1a79cbfccd351a0bd7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Thu, 8 Dec 2022 19:13:41 +0800
Subject: [PATCH 08/14] Update GAN_with_MINIST.ipynb

---
 .../gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 70 +++++++++----------
 1 file changed, 33 insertions(+), 37 deletions(-)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index d44dab0bc0f..ab05e39e5ab 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -17,26 +17,31 @@
     "\n",
     "## 1. 简要介绍\n",
     "### 关于GAN\n",
-    "简单来说，可以将GAN看作是一种框架，这个框架提供了一种不需要标签即可进行训练的方法。稍微具体一点来说，有一个生成任务，需要生成一组和训练集相同分布的数据，可以按照以下步骤和逻辑训练生成模型：\n",
-    "1. 定义生成模型G，input是一组随机数，output是生成的数据\n",
-    "2. 定义鉴别模型D，input是一组数据，output是这组数据是否是被生成的\n",
-    "3. 将已有数据作为正样本，将生成的数据作为负样本，训练二分类D\n",
-    "4. 将生成数据输入D，将D的输出和正标签求loss，以此loss更新G\n",
-    "5. 重复3和4直至收敛\n",
+    "[GAN](https://arxiv.org/abs/1406.2661)（Generative Adversarial Networks, 对抗生成网络）是Ian J. Goodfellow等在2014年提出的一种建立生成模型的框架。在这个框架中，用于刻画目标数据的生成模型（Generative model, 下文简称G）和用于鉴别数据是否真实的鉴别模型（Discriminative model, 下文简称D）被交替训练，最终使得G能够完美刻画目标数据的分布，而D的误判率趋近于1/2。\n",
+    "\n",
+    "GAN的训练框架可以描述如下：\n",
+    "\n",
+    "\n",
+    "```\n",
+    "1. 抽取一组真实数据\n",
+    "2. 根据随机数，通过G生成假数据\n",
+    "3. 训练鉴别器D\n",
+    "4. 将生成数据输入D，将D的输出和正标签求loss\n",
+    "5. 根据第四步的loss更新G\n",
+    "5. 重复第一到第五步直到收敛\n",
+    "```\n",
     "\n",
     "### 关于MINIST\n",
-    "一个手写数字数据集，Paddle已经集成了这个数据集。\n",
+    "[MINIST](http://yann.lecun.com/exdb/mnist/)是一个手写数字数据集，Paddle已经集成了这个数据集，可以通过封装好的API直接获取这个数据集中的内容。\n",
     "\n",
     "### 关于Paddle的梯度反馈\n",
-    "- 目前Paddle的梯度反馈是自动累加模式，所以可以多个batch，或者多个模块的loss单独进行backword\n",
-    "- 通过[Tensor].detach()的方式可以截断梯度传播\n",
+    "Paddle动态图模式梯度反馈是自动累加模式。因此，在运行GAN（对抗生成网络）的时候，可以多个batch/多个模块的loss单独进行backward，但也需要需要注意清除梯度和截断梯度。\n",
     "\n",
-    "### 致谢\n",
-    "本文参考以下项目\n",
-    "- [一文搞懂生成对抗网络之经典GAN（动态图、VisualDL2.0）](https://aistudio.baidu.com/aistudio/projectdetail/551962)\n",
-    "- [生成对抗网络七日打卡营](https://aistudio.baidu.com/aistudio/course/introduce/16651)\n",
+    "关于梯度累加和梯度截断的介绍如下：\n",
+    "\n",
+    "1. 梯度累加：梯度累加是指在模型训练过程中，训练一个 batch 的数据得到梯度后，不立即用该梯度更新模型参数，而是继续下一个 batch 数据的训练，得到梯度后继续循环，多次循环后梯度不断累加，直至达到一定次数后，用累加的梯度更新参数，这样可以起到变相扩大 batch_size 的作用。受限于显存大小，可能无法开到更大的 batch_size，使用梯度累加可以实现增大 batch_size 的作用。动态图模式天然支持梯度累加，即只要不调用梯度清零 clear_grad 方法，动态图的梯度会一直累积。\n",
+    "2. 梯度截断：在一些任务中，只希望拿到正向预测的值，但是不希望更新参数，或者在反向的时候剪枝，减少计算量，阻断反向的传播，即可使用`paddle.Tensor.detach()`产生一个新的、和当前计算图分离的，但是拥有当前变量内容的临时变量。\n",
     "\n",
-    "**什么？上面没看懂？不重要！往下看就行了！锐利的loss！锐利的更新！永远的两步走！**\n",
     "\n",
     "## 2. 环境设置\n",
     "导入包，主要包括paddle和一些画图辅助，如plt\n",
@@ -47,31 +52,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T14:56:15.275443Z",
-     "iopub.status.busy": "2022-11-18T14:56:15.274825Z",
-     "iopub.status.idle": "2022-11-18T14:56:18.239494Z",
-     "shell.execute_reply": "2022-11-18T14:56:18.238232Z",
-     "shell.execute_reply.started": "2022-11-18T14:56:15.275404Z"
-    },
-    "scrolled": true
+    "scrolled": true,
+    "tags": []
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/__init__.py:107: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\r\n",
-      "  from collections import MutableMapping\r\n",
-      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/rcsetup.py:20: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\r\n",
-      "  from collections import Iterable, Mapping\r\n",
-      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/colors.py:53: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\r\n",
-      "  from collections import Sized\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import random\n",
@@ -636,6 +622,16 @@
     "当然，在本文的基础上，如果删除了激活层，代码也是可以运行的，但是没有激活层的情况下，模型学习到的效果较差，因此，在GAN的时候，还是需要较为慎重的选择对应的生成模型。"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. 致谢\n",
+    "本文参考以下项目\n",
+    "- [一文搞懂生成对抗网络之经典GAN（动态图、VisualDL2.0）](https://aistudio.baidu.com/aistudio/projectdetail/551962)\n",
+    "- [生成对抗网络七日打卡营](https://aistudio.baidu.com/aistudio/course/introduce/16651)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

From 70b6b60e4fe66ceba24d44bb080eac839e09f25d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 24 Dec 2022 12:05:18 +0800
Subject: [PATCH 09/14] Add files via upload

---
 .../gan/GAN_with_MINIST/main (8).ipynb        | 693 ++++++++++++++++++
 1 file changed, 693 insertions(+)
 create mode 100644 docs/practices/gan/GAN_with_MINIST/main (8).ipynb

diff --git a/docs/practices/gan/GAN_with_MINIST/main (8).ipynb b/docs/practices/gan/GAN_with_MINIST/main (8).ipynb
new file mode 100644
index 00000000000..e7b58883ebc
--- /dev/null
+++ b/docs/practices/gan/GAN_with_MINIST/main (8).ipynb	
@@ -0,0 +1,693 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "tags": []
+   },
+   "source": [
+    "# MNIST数据集下用Paddle框架的动态图模式玩耍经典对抗生成网络（GAN）\n",
+    "\n",
+    "作者信息：[Liyulingyue](https://github.com/Liyulingyue)\n",
+    "\n",
+    "更新日期：2022 年 11 月 18 日\n",
+    "\n",
+    "## 1. 简要介绍\n",
+    "### 关于GAN\n",
+    "[GAN](https://arxiv.org/abs/1406.2661)（Generative Adversarial Networks, 对抗生成网络）是Ian J. Goodfellow等在2014年提出的一种建立生成模型的框架。在这个框架中，用于刻画目标数据的生成模型（Generative model, 下文简称G）和用于鉴别数据是否真实的鉴别模型（Discriminative model, 下文简称D）被交替训练，最终使得G能够完美刻画目标数据的分布，而D的误判率趋近于1/2。\n",
+    "\n",
+    "GAN的训练框架可以描述如下：\n",
+    "\n",
+    "\n",
+    "```\n",
+    "1. 抽取一组真实数据\n",
+    "2. 根据随机数，通过G生成假数据\n",
+    "3. 训练鉴别器D\n",
+    "4. 将生成数据输入D，将D的输出和正标签求loss\n",
+    "5. 根据第四步的loss更新G\n",
+    "5. 重复第一到第五步直到收敛\n",
+    "```\n",
+    "\n",
+    "### 关于MINIST\n",
+    "[MINIST](http://yann.lecun.com/exdb/mnist/)是一个手写数字数据集，Paddle已经集成了这个数据集，可以通过封装好的API直接获取这个数据集中的内容。\n",
+    "\n",
+    "### 关于Paddle的梯度反馈\n",
+    "Paddle动态图模式梯度反馈是自动累加模式。因此，在运行GAN（对抗生成网络）的时候，可以多个batch/多个模块的loss单独进行backward，但也需要需要注意清除梯度和截断梯度。\n",
+    "\n",
+    "关于梯度累加和梯度截断的介绍如下：\n",
+    "\n",
+    "1. 梯度累加：梯度累加是指在模型训练过程中，训练一个 batch 的数据得到梯度后，不立即用该梯度更新模型参数，而是继续下一个 batch 数据的训练，得到梯度后继续循环，多次循环后梯度不断累加，直至达到一定次数后，用累加的梯度更新参数，这样可以起到变相扩大 batch_size 的作用。受限于显存大小，可能无法开到更大的 batch_size，使用梯度累加可以实现增大 batch_size 的作用。动态图模式天然支持梯度累加，即只要不调用梯度清零 clear_grad 方法，动态图的梯度会一直累积。\n",
+    "2. 梯度截断：在一些任务中，只希望拿到正向预测的值，但是不希望更新参数，或者在反向的时候剪枝，减少计算量，阻断反向的传播，即可使用`paddle.Tensor.detach()`产生一个新的、和当前计算图分离的，但是拥有当前变量内容的临时变量。\n",
+    "\n",
+    "\n",
+    "## 2. 环境设置\n",
+    "导入包，主要包括paddle和一些画图辅助，如plt\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-12-23T13:46:17.513893Z",
+     "iopub.status.busy": "2022-12-23T13:46:17.513484Z",
+     "iopub.status.idle": "2022-12-23T13:46:17.518065Z",
+     "shell.execute_reply": "2022-12-23T13:46:17.517491Z",
+     "shell.execute_reply.started": "2022-12-23T13:46:17.513865Z"
+    },
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.3.2\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import paddle \n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.animation as animation\n",
+    "import cv2\n",
+    "\n",
+    "# 输出使用的paddle版本\n",
+    "print(paddle.__version__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. 数据集\n",
+    "Paddle已经集成MNIST数据集了，直接调用即可。本项目通过`paddle.vision.datasets.MNIST`导入数据集，并且用paddle.io.DataLoader封装为读取器。\n",
+    "\n",
+    "如果想要换成其他数据集，可以自行参考如何使用`paddle.io.Dataset`和`paddle.io.DataLoader`，封装后即可轻松复用本项目代码进行训练。\n",
+    "\n",
+    "首先，加载数据集。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset = paddle.vision.datasets.MNIST(mode='train', \n",
+    "                                        transform=paddle.vision.transforms.Compose([\n",
+    "                                            paddle.vision.transforms.Resize((32,32)),\n",
+    "                                            paddle.vision.transforms.Normalize([0], [255])\n",
+    "                                        ]))\n",
+    "\n",
+    "dataloader = paddle.io.DataLoader(dataset, batch_size=32,shuffle=True, num_workers=4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "查看数据的形状，可以看到从dataloader返回的数据格式中，每张图大小为32*32，每张图片带有一个标签。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:56:26.398712Z",
+     "iopub.status.busy": "2022-11-18T14:56:26.398464Z",
+     "iopub.status.idle": "2022-11-18T14:56:28.588250Z",
+     "shell.execute_reply": "2022-11-18T14:56:28.586489Z",
+     "shell.execute_reply.started": "2022-11-18T14:56:26.398689Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 [32, 1, 32, 32] [32, 1]\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "for step, data in enumerate(dataloader):\n",
+    "    data, label = data\n",
+    "    print(step, data.shape, label.shape)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "查看一张图片。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:56:33.127447Z",
+     "iopub.status.busy": "2022-11-18T14:56:33.126723Z",
+     "iopub.status.idle": "2022-11-18T14:56:33.300217Z",
+     "shell.execute_reply": "2022-11-18T14:56:33.299356Z",
+     "shell.execute_reply.started": "2022-11-18T14:56:33.127406Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f58c027bb50>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(data[0].numpy()[0])\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "通过下述代码可以快捷查看十张图片。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T15:44:02.287336Z",
+     "iopub.status.busy": "2022-11-18T15:44:02.285886Z",
+     "iopub.status.idle": "2022-11-18T15:44:02.507338Z",
+     "shell.execute_reply": "2022-11-18T15:44:02.506391Z",
+     "shell.execute_reply.started": "2022-11-18T15:44:02.287293Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in range(10):\n",
+    "    image = data[i].numpy()[0]\n",
+    "    plt.subplot(1, 10, i + 1)\n",
+    "\n",
+    "    plt.imshow(image, vmin=-1, vmax=1)\n",
+    "    plt.axis('off')\n",
+    "    plt.xticks([])\n",
+    "    plt.yticks([])\n",
+    "    plt.subplots_adjust(wspace=0.1, hspace=0.1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. 模型组网\n",
+    "GAN是一种生成网络框架，因此，可以选用任何网络去训练生成模型，只需要保证G和D的构造是满足需求的即可。\n",
+    "\n",
+    "本项目中，Generator由3个全连接层组建，用于将一个长为100的随机数向量扩充为长和宽均为32的图片。Discriminator同样由3个全连接层组成，用于将一张图片转化为数字，1表明这张图片是真实的，0表示这张图片是由网络生成的。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:57:02.380985Z",
+     "iopub.status.busy": "2022-11-18T14:57:02.380290Z",
+     "iopub.status.idle": "2022-11-18T14:57:02.844687Z",
+     "shell.execute_reply": "2022-11-18T14:57:02.843654Z",
+     "shell.execute_reply.started": "2022-11-18T14:57:02.380931Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generator(\r\n",
+      "  (gen): Sequential(\r\n",
+      "    (0): Linear(in_features=100, out_features=256, dtype=float32)\r\n",
+      "    (1): ReLU(name=True)\r\n",
+      "    (2): Linear(in_features=256, out_features=512, dtype=float32)\r\n",
+      "    (3): ReLU(name=True)\r\n",
+      "    (4): Linear(in_features=512, out_features=1024, dtype=float32)\r\n",
+      "    (5): Tanh()\r\n",
+      "  )\r\n",
+      ")\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      " Layer (type)       Input Shape          Output Shape         Param #    \r\n",
+      "===========================================================================\r\n",
+      "   Linear-2          [[8, 100]]            [8, 256]           25,856     \r\n",
+      "    ReLU-1           [[8, 256]]            [8, 256]              0       \r\n",
+      "   Linear-3          [[8, 256]]            [8, 512]           131,584    \r\n",
+      "    ReLU-2           [[8, 512]]            [8, 512]              0       \r\n",
+      "   Linear-4          [[8, 512]]           [8, 1024]           525,312    \r\n",
+      "    Tanh-1          [[8, 1024]]           [8, 1024]              0       \r\n",
+      "===========================================================================\r\n",
+      "Total params: 682,752\r\n",
+      "Trainable params: 682,752\r\n",
+      "Non-trainable params: 0\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "Input size (MB): 0.00\r\n",
+      "Forward/backward pass size (MB): 0.22\r\n",
+      "Params size (MB): 2.60\r\n",
+      "Estimated Total Size (MB): 2.83\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "\r\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'total_params': 682752, 'trainable_params': 682752}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Generator Code\n",
+    "class Generator(paddle.nn.Layer):\n",
+    "    def __init__(self, ):\n",
+    "        super(Generator, self).__init__()\n",
+    "        self.gen = paddle.nn.Sequential(\n",
+    "            paddle.nn.Linear(in_features=100, out_features=256),\n",
+    "            paddle.nn.ReLU(True),\n",
+    "            paddle.nn.Linear(in_features=256, out_features=512),\n",
+    "            paddle.nn.ReLU(True),\n",
+    "            paddle.nn.Linear(in_features=512, out_features=1024),\n",
+    "            paddle.nn.Tanh(),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.gen(x)\n",
+    "        out = paddle.reshape(x,[-1,1,32,32])\n",
+    "        return out\n",
+    "\n",
+    "# 创建模型\n",
+    "netG = Generator()\n",
+    "print(netG)\n",
+    "\n",
+    "# 通过paddle.summary可以查看一个指定形状的数据在网络中各个模块中的传递\n",
+    "paddle.summary(netG, (8, 100))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T14:57:11.520623Z",
+     "iopub.status.busy": "2022-11-18T14:57:11.520016Z",
+     "iopub.status.idle": "2022-11-18T14:57:11.537228Z",
+     "shell.execute_reply": "2022-11-18T14:57:11.536325Z",
+     "shell.execute_reply.started": "2022-11-18T14:57:11.520583Z"
+    },
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Discriminator(\r\n",
+      "  (dis): Sequential(\r\n",
+      "    (0): Linear(in_features=1024, out_features=512, dtype=float32)\r\n",
+      "    (1): LeakyReLU(negative_slope=0.2)\r\n",
+      "    (2): Linear(in_features=512, out_features=256, dtype=float32)\r\n",
+      "    (3): LeakyReLU(negative_slope=0.2)\r\n",
+      "    (4): Linear(in_features=256, out_features=1, dtype=float32)\r\n",
+      "    (5): Sigmoid()\r\n",
+      "  )\r\n",
+      ")\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      " Layer (type)       Input Shape          Output Shape         Param #    \r\n",
+      "===========================================================================\r\n",
+      "   Linear-5         [[8, 1024]]            [8, 512]           524,800    \r\n",
+      "  LeakyReLU-1        [[8, 512]]            [8, 512]              0       \r\n",
+      "   Linear-6          [[8, 512]]            [8, 256]           131,328    \r\n",
+      "  LeakyReLU-2        [[8, 256]]            [8, 256]              0       \r\n",
+      "   Linear-7          [[8, 256]]             [8, 1]              257      \r\n",
+      "   Sigmoid-1          [[8, 1]]              [8, 1]               0       \r\n",
+      "===========================================================================\r\n",
+      "Total params: 656,385\r\n",
+      "Trainable params: 656,385\r\n",
+      "Non-trainable params: 0\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "Input size (MB): 0.03\r\n",
+      "Forward/backward pass size (MB): 0.09\r\n",
+      "Params size (MB): 2.50\r\n",
+      "Estimated Total Size (MB): 2.63\r\n",
+      "---------------------------------------------------------------------------\r\n",
+      "\r\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'total_params': 656385, 'trainable_params': 656385}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Discriminator Code\n",
+    "class Discriminator(paddle.nn.Layer):\n",
+    "    def __init__(self, ):\n",
+    "        super(Discriminator, self).__init__()\n",
+    "        self.dis = paddle.nn.Sequential(\n",
+    "            paddle.nn.Linear(in_features=1024, out_features=512),\n",
+    "            paddle.nn.LeakyReLU(0.2),\n",
+    "            paddle.nn.Linear(in_features=512, out_features=256),\n",
+    "            paddle.nn.LeakyReLU(0.2),\n",
+    "            paddle.nn.Linear(in_features=256, out_features=1),\n",
+    "            paddle.nn.Sigmoid()\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = paddle.reshape(x, [-1, 1024])\n",
+    "        out = self.dis(x)\n",
+    "        return out\n",
+    "\n",
+    "netD = Discriminator()\n",
+    "print(netD)\n",
+    "\n",
+    "# 通过paddle.summary可以查看一个指定形状的数据在网络中各个模块中的传递\n",
+    "paddle.summary(netD, (8, 1, 32, 32))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. 模型训练\n",
+    "\n",
+    "本项目的训练参数配置如下：\n",
+    "\n",
+    "- 迭代次数：10\n",
+    "- 优化器：Adam优化器，出自[Adam论文](https://arxiv.org/abs/1412.6980)的第二节，能够利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。\n",
+    "- 学习率：0.0002\n",
+    "\n",
+    "下述程序大约需要运行半个小时。\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T16:16:22.907384Z",
+     "iopub.status.busy": "2022-11-18T16:16:22.906610Z",
+     "iopub.status.idle": "2022-11-18T16:16:25.184043Z",
+     "shell.execute_reply": "2022-11-18T16:16:25.182665Z",
+     "shell.execute_reply.started": "2022-11-18T16:16:22.907342Z"
+    },
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch ID=0 Batch ID=100 \r\n",
+      "\r\n",
+      " D-Loss=0.3066627085208893 G-Loss=0.5891025066375732\r\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1500x1500 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# create Net\n",
+    "netG = Generator()\n",
+    "netD = Discriminator()\n",
+    "\n",
+    "# 如果想要接着之前训练的模型训练，将if 0修改为if 1即可\n",
+    "if 1:\n",
+    "    try:\n",
+    "        mydict = paddle.load('generator.params')\n",
+    "        netG.set_dict(mydict)\n",
+    "        mydict = paddle.load('discriminator.params')\n",
+    "        netD.set_dict(mydict)\n",
+    "    except:\n",
+    "        print('fail to load model')\n",
+    "\n",
+    "optimizerD = paddle.optimizer.Adam(parameters=netD.parameters(), learning_rate=0.0002, beta1=0.5, beta2=0.999)\n",
+    "optimizerG = paddle.optimizer.Adam(parameters=netG.parameters(), learning_rate=0.0002, beta1=0.5, beta2=0.999)\n",
+    "\n",
+    "# 最大迭代epoch\n",
+    "max_epoch = 10\n",
+    "\n",
+    "now_step = 0\n",
+    "for epoch in range(max_epoch):\n",
+    "    for step, (data, label) in enumerate(dataloader):\n",
+    "        ############################\n",
+    "        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
+    "        ###########################\n",
+    "\n",
+    "        # 清除D的梯度\n",
+    "        optimizerD.clear_grad()\n",
+    "\n",
+    "        # 传入正样本，并更新梯度\n",
+    "        pos_img = data\n",
+    "        label = paddle.full([pos_img.shape[0], 1], 1, dtype='float32')\n",
+    "        pre = netD(pos_img)\n",
+    "        loss_D_1 = paddle.nn.functional.mse_loss(pre, label)\n",
+    "        loss_D_1.backward()\n",
+    "\n",
+    "        # 通过randn构造随机数，制造负样本，并传入D，更新梯度\n",
+    "        noise = paddle.randn([pos_img.shape[0], 100], 'float32')\n",
+    "        neg_img = netG(noise)\n",
+    "        label = paddle.full([pos_img.shape[0], 1], 0, dtype='float32')\n",
+    "        pre = netD(neg_img.detach()) # 通过detach截断网络梯度，不影响G的梯度计算\n",
+    "        loss_D_2 = paddle.nn.functional.mse_loss(pre,label)\n",
+    "        loss_D_2.backward()\n",
+    "\n",
+    "        # 更新D网络参数\n",
+    "        optimizerD.step()\n",
+    "        optimizerD.clear_grad()\n",
+    "\n",
+    "        loss_D = loss_D_1 + loss_D_2\n",
+    "\n",
+    "        ############################\n",
+    "        # (2) Update G network: maximize log(D(G(z)))\n",
+    "        ###########################\n",
+    "\n",
+    "        # 清除D的梯度\n",
+    "        optimizerG.clear_grad()\n",
+    "\n",
+    "        noise = paddle.randn([pos_img.shape[0], 100],'float32')\n",
+    "        fake = netG(noise)\n",
+    "        label = paddle.full((pos_img.shape[0], 1), 1, dtype=np.float32,)\n",
+    "        output = netD(fake)\n",
+    "        loss_G = paddle.nn.functional.mse_loss(output,label)\n",
+    "        loss_G.backward()\n",
+    "\n",
+    "        # 更新G网络参数\n",
+    "        optimizerG.step()\n",
+    "        optimizerG.clear_grad()\n",
+    "\n",
+    "        now_step += 1\n",
+    "\n",
+    "        ###########################\n",
+    "        # 可视化\n",
+    "        ###########################\n",
+    "        if now_step % 100 == 0:\n",
+    "            generated_image = netG(noise).numpy()\n",
+    "            imgs = []\n",
+    "            plt.figure(figsize=(15,15))\n",
+    "            try:\n",
+    "                for i in range(10):\n",
+    "                    # image = generated_image[i].transpose()\n",
+    "                    image = generated_image[i]\n",
+    "                    image = np.where(image > 0, image, 0)\n",
+    "                    image = image.transpose((1,2,0))\n",
+    "                    plt.subplot(10, 10, i + 1)\n",
+    "                    \n",
+    "                    plt.imshow(image[...,0], vmin=-1, vmax=1)\n",
+    "                    plt.axis('off')\n",
+    "                    plt.xticks([])\n",
+    "                    plt.yticks([])\n",
+    "                    plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
+    "                msg = 'Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(epoch, now_step, loss_D.numpy()[0], loss_G.numpy()[0])\n",
+    "                print(msg)\n",
+    "                plt.suptitle(msg,fontsize=20)\n",
+    "                plt.draw()\n",
+    "                # 保存在work文件夹下\n",
+    "                plt.savefig('{}/{:04d}_{:04d}.png'.format('work', epoch, now_step), bbox_inches='tight')\n",
+    "                plt.pause(0.01)\n",
+    "            except IOError:\n",
+    "                print(IOError)\n",
+    "paddle.save(netG.state_dict(), \"generator.params\")\n",
+    "paddle.save(netD.state_dict(), \"discriminator.params\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. 模型预测\n",
+    "通过下述代码即可调用刚刚训练好的生成器啦~"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-11-18T16:20:27.124813Z",
+     "iopub.status.busy": "2022-11-18T16:20:27.124035Z",
+     "iopub.status.idle": "2022-11-18T16:20:27.311705Z",
+     "shell.execute_reply": "2022-11-18T16:20:27.310847Z",
+     "shell.execute_reply.started": "2022-11-18T16:20:27.124762Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f58c0125810>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "netG = Generator()\n",
+    "mydict = paddle.load('generator.params')\n",
+    "netG.set_dict(mydict)\n",
+    "\n",
+    "noise = paddle.randn([1, 100],'float32')\n",
+    "img = netG(noise)\n",
+    "img = img.numpy()[0][0]\n",
+    "img[img<0] = 0\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. 结语\n",
+    "本文简单的用全连接网络跑通了GAN的流程，如果对网络有更高的性能需求可以参考文末的两个参考链接，内容类似，但是会更为详实。\n",
+    "\n",
+    "在本文的基础上，如果删除了激活层，代码也是可以运行的，但是没有激活层的情况下，模型学习到的效果较差，因此，在构造GAN的时候需要较为慎重的选择对应的生成模型。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. 致谢\n",
+    "本文参考以下项目\n",
+    "- [一文搞懂生成对抗网络之经典GAN（动态图、VisualDL2.0）](https://aistudio.baidu.com/aistudio/projectdetail/551962)\n",
+    "- [生成对抗网络七日打卡营](https://aistudio.baidu.com/aistudio/course/introduce/16651)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "请点击[此处](https://ai.baidu.com/docs#/AIStudio_Project_Notebook/a38e5576)查看本环境基本用法.  <br>\n",
+    "Please click [here ](https://ai.baidu.com/docs#/AIStudio_Project_Notebook/a38e5576) for more detailed instructions. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "py35-paddle1.2.0"
+  },
+  "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 1a90c459a42c4e1527ddc02963f75689f703e294 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 24 Dec 2022 12:05:55 +0800
Subject: [PATCH 10/14] Delete GAN_with_MINIST.ipynb

---
 .../gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 665 ------------------
 1 file changed, 665 deletions(-)
 delete mode 100644 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
deleted file mode 100644
index ab05e39e5ab..00000000000
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ /dev/null
@@ -1,665 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "jupyter": {
-     "outputs_hidden": false
-    },
-    "tags": []
-   },
-   "source": [
-    "# MNIST数据集下用Paddle框架的动态图模式玩耍经典对抗生成网络（GAN）\n",
-    "\n",
-    "作者信息：[Liyulingyue](https://github.com/Liyulingyue)\n",
-    "\n",
-    "更新日期：2022 年 11 月 18 日\n",
-    "\n",
-    "## 1. 简要介绍\n",
-    "### 关于GAN\n",
-    "[GAN](https://arxiv.org/abs/1406.2661)（Generative Adversarial Networks, 对抗生成网络）是Ian J. Goodfellow等在2014年提出的一种建立生成模型的框架。在这个框架中，用于刻画目标数据的生成模型（Generative model, 下文简称G）和用于鉴别数据是否真实的鉴别模型（Discriminative model, 下文简称D）被交替训练，最终使得G能够完美刻画目标数据的分布，而D的误判率趋近于1/2。\n",
-    "\n",
-    "GAN的训练框架可以描述如下：\n",
-    "\n",
-    "\n",
-    "```\n",
-    "1. 抽取一组真实数据\n",
-    "2. 根据随机数，通过G生成假数据\n",
-    "3. 训练鉴别器D\n",
-    "4. 将生成数据输入D，将D的输出和正标签求loss\n",
-    "5. 根据第四步的loss更新G\n",
-    "5. 重复第一到第五步直到收敛\n",
-    "```\n",
-    "\n",
-    "### 关于MINIST\n",
-    "[MINIST](http://yann.lecun.com/exdb/mnist/)是一个手写数字数据集，Paddle已经集成了这个数据集，可以通过封装好的API直接获取这个数据集中的内容。\n",
-    "\n",
-    "### 关于Paddle的梯度反馈\n",
-    "Paddle动态图模式梯度反馈是自动累加模式。因此，在运行GAN（对抗生成网络）的时候，可以多个batch/多个模块的loss单独进行backward，但也需要需要注意清除梯度和截断梯度。\n",
-    "\n",
-    "关于梯度累加和梯度截断的介绍如下：\n",
-    "\n",
-    "1. 梯度累加：梯度累加是指在模型训练过程中，训练一个 batch 的数据得到梯度后，不立即用该梯度更新模型参数，而是继续下一个 batch 数据的训练，得到梯度后继续循环，多次循环后梯度不断累加，直至达到一定次数后，用累加的梯度更新参数，这样可以起到变相扩大 batch_size 的作用。受限于显存大小，可能无法开到更大的 batch_size，使用梯度累加可以实现增大 batch_size 的作用。动态图模式天然支持梯度累加，即只要不调用梯度清零 clear_grad 方法，动态图的梯度会一直累积。\n",
-    "2. 梯度截断：在一些任务中，只希望拿到正向预测的值，但是不希望更新参数，或者在反向的时候剪枝，减少计算量，阻断反向的传播，即可使用`paddle.Tensor.detach()`产生一个新的、和当前计算图分离的，但是拥有当前变量内容的临时变量。\n",
-    "\n",
-    "\n",
-    "## 2. 环境设置\n",
-    "导入包，主要包括paddle和一些画图辅助，如plt\n",
-    "\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import random\n",
-    "import paddle \n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import matplotlib.animation as animation\n",
-    "import cv2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. 数据集\n",
-    "Paddle已经集成MNIST数据集了，直接调用即可。本项目通过`paddle.vision.datasets.MNIST`导入数据集，并且用paddle.io.DataLoader封装为读取器。\n",
-    "\n",
-    "如果想要换成其他数据集，可以自行参考如何使用`paddle.io.Dataset`和`paddle.io.DataLoader`，封装后即可轻松复用本项目代码进行训练。\n",
-    "\n",
-    "首先，加载数据集。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "dataset = paddle.vision.datasets.MNIST(mode='train', \n",
-    "                                        transform=paddle.vision.transforms.Compose([\n",
-    "                                            paddle.vision.transforms.Resize((32,32)),\n",
-    "                                            paddle.vision.transforms.Normalize([0], [255])\n",
-    "                                        ]))\n",
-    "\n",
-    "dataloader = paddle.io.DataLoader(dataset, batch_size=32,shuffle=True, num_workers=4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "查看数据的形状，可以看到从dataloader返回的数据格式中，每张图大小为32*32，每张图片带有一个标签。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T14:56:26.398712Z",
-     "iopub.status.busy": "2022-11-18T14:56:26.398464Z",
-     "iopub.status.idle": "2022-11-18T14:56:28.588250Z",
-     "shell.execute_reply": "2022-11-18T14:56:28.586489Z",
-     "shell.execute_reply.started": "2022-11-18T14:56:26.398689Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0 [32, 1, 32, 32] [32, 1]\r\n"
-     ]
-    }
-   ],
-   "source": [
-    "for step, data in enumerate(dataloader):\n",
-    "    data, label = data\n",
-    "    print(step, data.shape, label.shape)\n",
-    "    break"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "查看一张图片。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T14:56:33.127447Z",
-     "iopub.status.busy": "2022-11-18T14:56:33.126723Z",
-     "iopub.status.idle": "2022-11-18T14:56:33.300217Z",
-     "shell.execute_reply": "2022-11-18T14:56:33.299356Z",
-     "shell.execute_reply.started": "2022-11-18T14:56:33.127406Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f58c027bb50>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.imshow(data[0].numpy()[0])\n",
-    "# plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "通过下述代码可以快捷查看十张图片。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T15:44:02.287336Z",
-     "iopub.status.busy": "2022-11-18T15:44:02.285886Z",
-     "iopub.status.idle": "2022-11-18T15:44:02.507338Z",
-     "shell.execute_reply": "2022-11-18T15:44:02.506391Z",
-     "shell.execute_reply.started": "2022-11-18T15:44:02.287293Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for i in range(10):\n",
-    "    image = data[i].numpy()[0]\n",
-    "    plt.subplot(1, 10, i + 1)\n",
-    "\n",
-    "    plt.imshow(image, vmin=-1, vmax=1)\n",
-    "    plt.axis('off')\n",
-    "    plt.xticks([])\n",
-    "    plt.yticks([])\n",
-    "    plt.subplots_adjust(wspace=0.1, hspace=0.1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. 模型组网\n",
-    "由于GAN只是一种框架，因此我们可以使用任何网络，这里简单使用了全连接层。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T14:57:02.380985Z",
-     "iopub.status.busy": "2022-11-18T14:57:02.380290Z",
-     "iopub.status.idle": "2022-11-18T14:57:02.844687Z",
-     "shell.execute_reply": "2022-11-18T14:57:02.843654Z",
-     "shell.execute_reply.started": "2022-11-18T14:57:02.380931Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Generator(\r\n",
-      "  (gen): Sequential(\r\n",
-      "    (0): Linear(in_features=100, out_features=256, dtype=float32)\r\n",
-      "    (1): ReLU(name=True)\r\n",
-      "    (2): Linear(in_features=256, out_features=512, dtype=float32)\r\n",
-      "    (3): ReLU(name=True)\r\n",
-      "    (4): Linear(in_features=512, out_features=1024, dtype=float32)\r\n",
-      "    (5): Tanh()\r\n",
-      "  )\r\n",
-      ")\r\n",
-      "---------------------------------------------------------------------------\r\n",
-      " Layer (type)       Input Shape          Output Shape         Param #    \r\n",
-      "===========================================================================\r\n",
-      "   Linear-2          [[8, 100]]            [8, 256]           25,856     \r\n",
-      "    ReLU-1           [[8, 256]]            [8, 256]              0       \r\n",
-      "   Linear-3          [[8, 256]]            [8, 512]           131,584    \r\n",
-      "    ReLU-2           [[8, 512]]            [8, 512]              0       \r\n",
-      "   Linear-4          [[8, 512]]           [8, 1024]           525,312    \r\n",
-      "    Tanh-1          [[8, 1024]]           [8, 1024]              0       \r\n",
-      "===========================================================================\r\n",
-      "Total params: 682,752\r\n",
-      "Trainable params: 682,752\r\n",
-      "Non-trainable params: 0\r\n",
-      "---------------------------------------------------------------------------\r\n",
-      "Input size (MB): 0.00\r\n",
-      "Forward/backward pass size (MB): 0.22\r\n",
-      "Params size (MB): 2.60\r\n",
-      "Estimated Total Size (MB): 2.83\r\n",
-      "---------------------------------------------------------------------------\r\n",
-      "\r\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'total_params': 682752, 'trainable_params': 682752}"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Generator Code\n",
-    "class Generator(paddle.nn.Layer):\n",
-    "    def __init__(self, ):\n",
-    "        super(Generator, self).__init__()\n",
-    "        self.gen = paddle.nn.Sequential(\n",
-    "            paddle.nn.Linear(in_features=100, out_features=256),\n",
-    "            paddle.nn.ReLU(True),\n",
-    "            paddle.nn.Linear(in_features=256, out_features=512),\n",
-    "            paddle.nn.ReLU(True),\n",
-    "            paddle.nn.Linear(in_features=512, out_features=1024),\n",
-    "            paddle.nn.Tanh(),\n",
-    "        )\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = self.gen(x)\n",
-    "        out = paddle.reshape(x,[-1,1,32,32])\n",
-    "        return out\n",
-    "\n",
-    "# 创建模型\n",
-    "netG = Generator()\n",
-    "print(netG)\n",
-    "\n",
-    "# 通过paddle.summary可以查看一个指定形状的数据在网络中各个模块中的传递\n",
-    "paddle.summary(netG, (8, 100))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T14:57:11.520623Z",
-     "iopub.status.busy": "2022-11-18T14:57:11.520016Z",
-     "iopub.status.idle": "2022-11-18T14:57:11.537228Z",
-     "shell.execute_reply": "2022-11-18T14:57:11.536325Z",
-     "shell.execute_reply.started": "2022-11-18T14:57:11.520583Z"
-    },
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Discriminator(\r\n",
-      "  (dis): Sequential(\r\n",
-      "    (0): Linear(in_features=1024, out_features=512, dtype=float32)\r\n",
-      "    (1): LeakyReLU(negative_slope=0.2)\r\n",
-      "    (2): Linear(in_features=512, out_features=256, dtype=float32)\r\n",
-      "    (3): LeakyReLU(negative_slope=0.2)\r\n",
-      "    (4): Linear(in_features=256, out_features=1, dtype=float32)\r\n",
-      "    (5): Sigmoid()\r\n",
-      "  )\r\n",
-      ")\r\n",
-      "---------------------------------------------------------------------------\r\n",
-      " Layer (type)       Input Shape          Output Shape         Param #    \r\n",
-      "===========================================================================\r\n",
-      "   Linear-5         [[8, 1024]]            [8, 512]           524,800    \r\n",
-      "  LeakyReLU-1        [[8, 512]]            [8, 512]              0       \r\n",
-      "   Linear-6          [[8, 512]]            [8, 256]           131,328    \r\n",
-      "  LeakyReLU-2        [[8, 256]]            [8, 256]              0       \r\n",
-      "   Linear-7          [[8, 256]]             [8, 1]              257      \r\n",
-      "   Sigmoid-1          [[8, 1]]              [8, 1]               0       \r\n",
-      "===========================================================================\r\n",
-      "Total params: 656,385\r\n",
-      "Trainable params: 656,385\r\n",
-      "Non-trainable params: 0\r\n",
-      "---------------------------------------------------------------------------\r\n",
-      "Input size (MB): 0.03\r\n",
-      "Forward/backward pass size (MB): 0.09\r\n",
-      "Params size (MB): 2.50\r\n",
-      "Estimated Total Size (MB): 2.63\r\n",
-      "---------------------------------------------------------------------------\r\n",
-      "\r\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'total_params': 656385, 'trainable_params': 656385}"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Discriminator Code\n",
-    "class Discriminator(paddle.nn.Layer):\n",
-    "    def __init__(self, ):\n",
-    "        super(Discriminator, self).__init__()\n",
-    "        self.dis = paddle.nn.Sequential(\n",
-    "            paddle.nn.Linear(in_features=1024, out_features=512),\n",
-    "            paddle.nn.LeakyReLU(0.2),\n",
-    "            paddle.nn.Linear(in_features=512, out_features=256),\n",
-    "            paddle.nn.LeakyReLU(0.2),\n",
-    "            paddle.nn.Linear(in_features=256, out_features=1),\n",
-    "            paddle.nn.Sigmoid()\n",
-    "        )\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = paddle.reshape(x, [-1, 1024])\n",
-    "        out = self.dis(x)\n",
-    "        return out\n",
-    "\n",
-    "netD = Discriminator()\n",
-    "print(netD)\n",
-    "\n",
-    "# 通过paddle.summary可以查看一个指定形状的数据在网络中各个模块中的传递\n",
-    "paddle.summary(netD, (8, 1, 32, 32))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. 模型训练\n",
-    "大约需要半个小时~"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T16:16:22.907384Z",
-     "iopub.status.busy": "2022-11-18T16:16:22.906610Z",
-     "iopub.status.idle": "2022-11-18T16:16:25.184043Z",
-     "shell.execute_reply": "2022-11-18T16:16:25.182665Z",
-     "shell.execute_reply.started": "2022-11-18T16:16:22.907342Z"
-    },
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch ID=0 Batch ID=100 \r\n",
-      "\r\n",
-      " D-Loss=0.3066627085208893 G-Loss=0.5891025066375732\r\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1500x1500 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# create Net\n",
-    "netG = Generator()\n",
-    "netD = Discriminator()\n",
-    "\n",
-    "# 如果想要接着之前训练的模型训练，将if 0修改为if 1即可\n",
-    "if 1:\n",
-    "    try:\n",
-    "        mydict = paddle.load('generator.params')\n",
-    "        netG.set_dict(mydict)\n",
-    "        mydict = paddle.load('discriminator.params')\n",
-    "        netD.set_dict(mydict)\n",
-    "    except:\n",
-    "        print('fail to load model')\n",
-    "\n",
-    "optimizerD = paddle.optimizer.Adam(parameters=netD.parameters(), learning_rate=0.0002, beta1=0.5, beta2=0.999)\n",
-    "optimizerG = paddle.optimizer.Adam(parameters=netG.parameters(), learning_rate=0.0002, beta1=0.5, beta2=0.999)\n",
-    "\n",
-    "# 最大迭代epoch\n",
-    "max_epoch = 10\n",
-    "\n",
-    "now_step = 0\n",
-    "for epoch in range(max_epoch):\n",
-    "    for step, (data, label) in enumerate(dataloader):\n",
-    "        ############################\n",
-    "        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
-    "        ###########################\n",
-    "\n",
-    "        # 清除D的梯度\n",
-    "        optimizerD.clear_grad()\n",
-    "\n",
-    "        # 传入正样本，并更新梯度\n",
-    "        pos_img = data\n",
-    "        label = paddle.full([pos_img.shape[0], 1], 1, dtype='float32')\n",
-    "        pre = netD(pos_img)\n",
-    "        loss_D_1 = paddle.nn.functional.mse_loss(pre, label)\n",
-    "        loss_D_1.backward()\n",
-    "\n",
-    "        # 通过randn构造随机数，制造负样本，并传入D，更新梯度\n",
-    "        noise = paddle.randn([pos_img.shape[0], 100], 'float32')\n",
-    "        neg_img = netG(noise)\n",
-    "        label = paddle.full([pos_img.shape[0], 1], 0, dtype='float32')\n",
-    "        pre = netD(neg_img.detach()) # 通过detach截断网络梯度，不影响G的梯度计算\n",
-    "        loss_D_2 = paddle.nn.functional.mse_loss(pre,label)\n",
-    "        loss_D_2.backward()\n",
-    "\n",
-    "        # 更新D网络参数\n",
-    "        optimizerD.step()\n",
-    "        optimizerD.clear_grad()\n",
-    "\n",
-    "        loss_D = loss_D_1 + loss_D_2\n",
-    "\n",
-    "        ############################\n",
-    "        # (2) Update G network: maximize log(D(G(z)))\n",
-    "        ###########################\n",
-    "\n",
-    "        # 清除D的梯度\n",
-    "        optimizerG.clear_grad()\n",
-    "\n",
-    "        noise = paddle.randn([pos_img.shape[0], 100],'float32')\n",
-    "        fake = netG(noise)\n",
-    "        label = paddle.full((pos_img.shape[0], 1), 1, dtype=np.float32,)\n",
-    "        output = netD(fake)\n",
-    "        loss_G = paddle.nn.functional.mse_loss(output,label)\n",
-    "        loss_G.backward()\n",
-    "\n",
-    "        # 更新G网络参数\n",
-    "        optimizerG.step()\n",
-    "        optimizerG.clear_grad()\n",
-    "\n",
-    "        now_step += 1\n",
-    "\n",
-    "        ###########################\n",
-    "        # 可视化\n",
-    "        ###########################\n",
-    "        if now_step % 100 == 0:\n",
-    "            generated_image = netG(noise).numpy()\n",
-    "            imgs = []\n",
-    "            plt.figure(figsize=(15,15))\n",
-    "            try:\n",
-    "                for i in range(10):\n",
-    "                    # image = generated_image[i].transpose()\n",
-    "                    image = generated_image[i]\n",
-    "                    image = np.where(image > 0, image, 0)\n",
-    "                    image = image.transpose((1,2,0))\n",
-    "                    plt.subplot(10, 10, i + 1)\n",
-    "                    \n",
-    "                    plt.imshow(image[...,0], vmin=-1, vmax=1)\n",
-    "                    plt.axis('off')\n",
-    "                    plt.xticks([])\n",
-    "                    plt.yticks([])\n",
-    "                    plt.subplots_adjust(wspace=0.1, hspace=0.1)\n",
-    "                msg = 'Epoch ID={0} Batch ID={1} \\n\\n D-Loss={2} G-Loss={3}'.format(epoch, now_step, loss_D.numpy()[0], loss_G.numpy()[0])\n",
-    "                print(msg)\n",
-    "                plt.suptitle(msg,fontsize=20)\n",
-    "                plt.draw()\n",
-    "                # 保存在work文件夹下\n",
-    "                plt.savefig('{}/{:04d}_{:04d}.png'.format('work', epoch, now_step), bbox_inches='tight')\n",
-    "                plt.pause(0.01)\n",
-    "            except IOError:\n",
-    "                print(IOError)\n",
-    "paddle.save(netG.state_dict(), \"generator.params\")\n",
-    "paddle.save(netD.state_dict(), \"discriminator.params\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. 模型预测\n",
-    "通过下述代码即可调用刚刚训练好的生成器啦~"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2022-11-18T16:20:27.124813Z",
-     "iopub.status.busy": "2022-11-18T16:20:27.124035Z",
-     "iopub.status.idle": "2022-11-18T16:20:27.311705Z",
-     "shell.execute_reply": "2022-11-18T16:20:27.310847Z",
-     "shell.execute_reply.started": "2022-11-18T16:20:27.124762Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f58c0125810>"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "netG = Generator()\n",
-    "mydict = paddle.load('generator.params')\n",
-    "netG.set_dict(mydict)\n",
-    "\n",
-    "noise = paddle.randn([1, 100],'float32')\n",
-    "img = netG(noise)\n",
-    "img = img.numpy()[0][0]\n",
-    "img[img<0] = 0\n",
-    "plt.imshow(img)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. 结语\n",
-    "本文简单的用全连接网络跑通了GAN的流程，如果对网络有更高的性能需求可以参考文首处的两个参考链接，内容类似，但是会更为详实。\n",
-    "\n",
-    "当然，在本文的基础上，如果删除了激活层，代码也是可以运行的，但是没有激活层的情况下，模型学习到的效果较差，因此，在GAN的时候，还是需要较为慎重的选择对应的生成模型。"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. 致谢\n",
-    "本文参考以下项目\n",
-    "- [一文搞懂生成对抗网络之经典GAN（动态图、VisualDL2.0）](https://aistudio.baidu.com/aistudio/projectdetail/551962)\n",
-    "- [生成对抗网络七日打卡营](https://aistudio.baidu.com/aistudio/course/introduce/16651)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "请点击[此处](https://ai.baidu.com/docs#/AIStudio_Project_Notebook/a38e5576)查看本环境基本用法.  <br>\n",
-    "Please click [here ](https://ai.baidu.com/docs#/AIStudio_Project_Notebook/a38e5576) for more detailed instructions. "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "py35-paddle1.2.0"
-  },
-  "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.7.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

From 5b50a1102832ce905f8862b6a25b27cc19a8e952 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Sat, 24 Dec 2022 12:06:12 +0800
Subject: [PATCH 11/14] Rename main (8).ipynb to GAN_with_MINIST.ipynb

---
 .../gan/GAN_with_MINIST/{main (8).ipynb => GAN_with_MINIST.ipynb} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/practices/gan/GAN_with_MINIST/{main (8).ipynb => GAN_with_MINIST.ipynb} (100%)

diff --git a/docs/practices/gan/GAN_with_MINIST/main (8).ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
similarity index 100%
rename from docs/practices/gan/GAN_with_MINIST/main (8).ipynb
rename to docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb

From 25203838e983b0731beb22a8daeebde78a6244f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Wed, 11 Jan 2023 18:26:23 +0800
Subject: [PATCH 12/14] Update GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index e7b58883ebc..bb21f20f0d6 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -28,7 +28,7 @@
     "3. 训练鉴别器D\n",
     "4. 将生成数据输入D，将D的输出和正标签求loss\n",
     "5. 根据第四步的loss更新G\n",
-    "5. 重复第一到第五步直到收敛\n",
+    "6. 重复第一到第五步直到收敛\n",
     "```\n",
     "\n",
     "### 关于MINIST\n",
@@ -438,6 +438,7 @@
     "本项目的训练参数配置如下：\n",
     "\n",
     "- 迭代次数：10\n",
+    "- 损失函数：[均方损失函数（MSELoss）](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/nn/MSELoss_cn.html#mseloss)\n",
     "- 优化器：Adam优化器，出自[Adam论文](https://arxiv.org/abs/1412.6980)的第二节，能够利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。\n",
     "- 学习率：0.0002\n",
     "\n",
@@ -590,7 +591,7 @@
    "metadata": {},
    "source": [
     "## 6. 模型预测\n",
-    "通过下述代码即可调用刚刚训练好的生成器啦~"
+    "通过下述代码即可调用刚刚训练好的生成器。"
    ]
   },
   {

From 9bb3bb3cfee8a613704b13badc2957442093be73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Fri, 13 Jan 2023 06:44:45 +0800
Subject: [PATCH 13/14] Update GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index bb21f20f0d6..9e364a1a470 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -34,13 +34,13 @@
     "### 关于MINIST\n",
     "[MINIST](http://yann.lecun.com/exdb/mnist/)是一个手写数字数据集，Paddle已经集成了这个数据集，可以通过封装好的API直接获取这个数据集中的内容。\n",
     "\n",
-    "### 关于Paddle的梯度反馈\n",
-    "Paddle动态图模式梯度反馈是自动累加模式。因此，在运行GAN（对抗生成网络）的时候，可以多个batch/多个模块的loss单独进行backward，但也需要需要注意清除梯度和截断梯度。\n",
+    "### 关于Paddle的梯度计算\n",
+    "Paddle动态图模式梯度计算是自动累加模式。因此，在运行GAN（对抗生成网络）的时候，可以多个batch/多个模块的loss单独进行backward，但也需要需要注意清除梯度和阻断反向传播。\n",
     "\n",
-    "关于梯度累加和梯度截断的介绍如下：\n",
+    "关于梯度累加和阻断反向传播的介绍如下：\n",
     "\n",
     "1. 梯度累加：梯度累加是指在模型训练过程中，训练一个 batch 的数据得到梯度后，不立即用该梯度更新模型参数，而是继续下一个 batch 数据的训练，得到梯度后继续循环，多次循环后梯度不断累加，直至达到一定次数后，用累加的梯度更新参数，这样可以起到变相扩大 batch_size 的作用。受限于显存大小，可能无法开到更大的 batch_size，使用梯度累加可以实现增大 batch_size 的作用。动态图模式天然支持梯度累加，即只要不调用梯度清零 clear_grad 方法，动态图的梯度会一直累积。\n",
-    "2. 梯度截断：在一些任务中，只希望拿到正向预测的值，但是不希望更新参数，或者在反向的时候剪枝，减少计算量，阻断反向的传播，即可使用`paddle.Tensor.detach()`产生一个新的、和当前计算图分离的，但是拥有当前变量内容的临时变量。\n",
+    "2. 阻断反向传播：在一些任务中，只希望拿到正向预测的值，但是不希望更新参数，或者在反向的时候剪枝，减少计算量，阻断反向的传播，即可使用`paddle.Tensor.detach()`产生一个新的、和当前计算图分离的，但是拥有当前变量内容的临时变量。\n",
     "\n",
     "\n",
     "## 2. 环境设置\n",

From 39301536658b9d40cf87e30b468fc0547f4a5c01 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=98=A5=E4=B9=94?=
 <83450930+Liyulingyue@users.noreply.github.com>
Date: Fri, 13 Jan 2023 07:19:50 +0800
Subject: [PATCH 14/14] Update GAN_with_MINIST.ipynb

---
 docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
index 9e364a1a470..32caf5c9c1e 100644
--- a/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
+++ b/docs/practices/gan/GAN_with_MINIST/GAN_with_MINIST.ipynb
@@ -523,7 +523,7 @@
     "        noise = paddle.randn([pos_img.shape[0], 100], 'float32')\n",
     "        neg_img = netG(noise)\n",
     "        label = paddle.full([pos_img.shape[0], 1], 0, dtype='float32')\n",
-    "        pre = netD(neg_img.detach()) # 通过detach截断网络梯度，不影响G的梯度计算\n",
+    "        pre = netD(neg_img.detach()) # 通过detach阻断网络梯度传播，不影响G的梯度计算\n",
     "        loss_D_2 = paddle.nn.functional.mse_loss(pre,label)\n",
     "        loss_D_2.backward()\n",
     "\n",