{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center/>使用PyNative进行神经网络的训练调试体验"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概述"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在神经网络训练过程中，数据是否按照自己设计的神经网络运行，是使用者非常关心的事情，如何去查看数据是怎样经过神经网络，并产生变化的呢？这时候需要AI框架提供一个功能，方便使用者将计算图中的每一步变化拆开成单个算子或者深层网络拆分成多个单层来调试观察，了解分析数据在经过算子或者计算层后的变化情况，MindSpore在设计之初就提供了这样的功能模式--`PyNative_MODE`，与此对应的是`GRAPH_MODE`，他们的特点分别如下：\n",
    "- PyNative模式：也称动态图模式，将神经网络中的各个算子逐一下发执行，方便用户编写和调试神经网络模型。\n",
    "- Graph模式：也称静态图模式或者图模式，将神经网络模型编译成一整张图，然后下发执行。该模式利用图优化等技术提高运行性能，同时有助于规模部署和跨平台运行。\n",
    "\n",
    "默认情况下，MindSpore处于PyNative模式，可以通过`context.set_context(mode=context.GRAPH_MODE)`切换为Graph模式；同样地，MindSpore处于Graph模式时，可以通过`context.set_context(mode=context.PYNATIVE_MODE)`切换为PyNative模式。\n",
    "\n",
    "<br/>本次体验我们将使用一张手写数字图片跑完单次训练，在PyNative模式下，将数据在训练中经过每层神经网络的变化情况打印出来，并计算对应的loss值以及梯度值`grads`，整体流程如下：\n",
    "\n",
    "1. 数据集准备，并取用单张图片数据。\n",
    "\n",
    "2. 构建神经网络并设置每层断点打印数据。\n",
    "\n",
    "3. 构建梯度计算函数。\n",
    "\n",
    "4. 执行神经网络训练，查看网络各参数梯度。\n",
    "\n",
    "> 你可以在这里找到完整可运行的样例代码：<https://gitee.com/mindspore/docs/blob/r0.6/tutorials/tutorial_code/lenet.py>。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据集的下载"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里我们需要将MNIST数据集中随机取出一张图片，并增强成适合LeNet网络的数据格式（如何处理请参考[quick_start.ipynb](https://gitee.com/mindspore/docs/blob/r0.6/tutorials/notebook/quick_start.ipynb)），训练数据集下载地址：{\"<http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz>\", \"<http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz>\"} 。\n",
    "<br/>数据集放在----Jupyter工作目录+\\MNIST_Data\\train\\，如下图结构："
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "MNIST\n",
    "├── test\n",
    "│   ├── t10k-images-idx3-ubyte\n",
    "│   └── t10k-labels-idx1-ubyte\n",
    "└── train\n",
    "    ├── train-images-idx3-ubyte\n",
    "    └── train-labels-idx1-ubyte\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据集的增强操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下载下来后的数据集，需要通过`mindspore.dataset`处理成适用于MindSpore框架的数据，再使用一系列框架中提供的工具进行数据增强操作来适应LeNet网络的数据处理需求。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.dataset.transforms.vision.c_transforms as CV\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "from mindspore.dataset.transforms.vision import Inter\n",
    "from mindspore.common import dtype as mstype\n",
    "import mindspore.dataset as ds\n",
    "import numpy as np\n",
    "\n",
    "def create_dataset(data_path, batch_size=32, repeat_size=1,\n",
    "                   num_parallel_workers=1):\n",
    "    \"\"\" create dataset for train or test\n",
    "    Args:\n",
    "        data_path (str): Data path\n",
    "        batch_size (int): The number of data records in each group\n",
    "        repeat_size (int): The number of replicated data records\n",
    "        num_parallel_workers (int): The number of parallel workers\n",
    "    \"\"\"\n",
    "    # define dataset\n",
    "    mnist_ds = ds.MnistDataset(data_path)\n",
    "\n",
    "    # define some parameters needed for data enhancement and rough justification\n",
    "    resize_height, resize_width = 32, 32\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "    rescale_nml = 1 / 0.3081\n",
    "    shift_nml = -1 * 0.1307 / 0.3081\n",
    "\n",
    "    # according to the parameters, generate the corresponding data enhancement method\n",
    "    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n",
    "    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml) \n",
    "    rescale_op = CV.Rescale(rescale, shift) \n",
    "    hwc2chw_op = CV.HWC2CHW()  \n",
    "    type_cast_op = C.TypeCast(mstype.int32)\n",
    "\n",
    "    # using map method to apply operations to a dataset\n",
    "    mnist_ds = mnist_ds.map(input_columns=\"label\", operations=type_cast_op, num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(input_columns=\"image\", operations=resize_op, num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(input_columns=\"image\", operations=rescale_op, num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(input_columns=\"image\", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(input_columns=\"image\", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)\n",
    "   \n",
    "    # process the generated dataset\n",
    "    buffer_size = 10000\n",
    "    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n",
    "    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n",
    "    mnist_ds = mnist_ds.repeat(repeat_size)\n",
    "\n",
    "    return mnist_ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据图片的提取"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本次体验我们只需要一张图片进行训练体验，所以随机选取`batch`中的第一张图片`image`和下标`label`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 1, 32, 32)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mindspore import Tensor\n",
    "import matplotlib.pyplot as plt\n",
    "train_data_path = \"./MNIST_Data/train/\" \n",
    "datas = create_dataset(train_data_path)\n",
    "data1 = datas.create_dict_iterator()\n",
    "data= data1.get_next()\n",
    "images = data[\"image\"]\n",
    "labels = data[\"label\"]\n",
    "print(images.shape)\n",
    "count = 1\n",
    "for i in images:\n",
    "    plt.subplot(4, 8, count) \n",
    "    plt.imshow(np.squeeze(i))\n",
    "    plt.title('num:%s'%labels[count-1])\n",
    "    plt.xticks([])\n",
    "    count += 1\n",
    "    plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当前batch的image数据如上图，后面的体验将提取第一张图片进行训练操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义图像显示函数\n",
    "\n",
    "定义一个图像显示函数`image_show`，插入LeNet5的前面4层神经网络中抽取图像数据并显示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def image_show(x):\n",
    "    count = 1\n",
    "    x = x.asnumpy()\n",
    "    number = x.shape[1]\n",
    "    sqrt_number = int(np.sqrt(number))\n",
    "    for i in x[0]:\n",
    "        plt.subplot(sqrt_number,int(number/sqrt_number),count)\n",
    "        plt.imshow(i)\n",
    "        count += 1\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建神经网络LeNet5\n",
    "在`construct`中使用`image_show`，查看每层网络后的图片变化。\n",
    "> 这里只抽取了图片显示，想要查看具体的数值，可以按照自己的需要进行`print(x)`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import mindspore.nn as nn\n",
    "import mindspore.ops.operations as P\n",
    "from mindspore.ops import composite as C\n",
    "from mindspore.common import dtype as mstype\n",
    "from mindspore.common.initializer import TruncatedNormal\n",
    "from mindspore.nn import Dense\n",
    "\n",
    "def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):\n",
    "    \"\"\"weight initial for conv layer\"\"\"\n",
    "    weight = weight_variable()\n",
    "    return nn.Conv2d(in_channels, out_channels,\n",
    "                     kernel_size=kernel_size, stride=stride, padding=padding,\n",
    "                     weight_init=weight, has_bias=False, pad_mode=\"valid\")\n",
    "\n",
    "def fc_with_initialize(input_channels, out_channels):\n",
    "    \"\"\"weight initial for fc layer\"\"\"\n",
    "    weight = weight_variable()\n",
    "    bias = weight_variable()\n",
    "    return nn.Dense(input_channels, out_channels, weight, bias)\n",
    "    \n",
    "def weight_variable():\n",
    "    \"\"\"weight initial\"\"\"\n",
    "    return TruncatedNormal(0.02)\n",
    "\n",
    "\n",
    "class LeNet5(nn.Cell):\n",
    "    def __init__(self, num_class=10):\n",
    "        super(LeNet5, self).__init__()\n",
    "        self.num_class = num_class\n",
    "        self.batch_size = 1\n",
    "        self.conv1 = conv(1, 6, 5)\n",
    "        self.conv2 = conv(6, 16, 5)\n",
    "        self.fc1 = fc_with_initialize(16 * 5 * 5, 120)\n",
    "        self.fc2 = fc_with_initialize(120, 84)\n",
    "        self.fc3 = fc_with_initialize(84, self.num_class)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.reshape = P.Reshape()\n",
    "        self.switch = 1\n",
    "        \n",
    "    def construct(self, x):\n",
    "        \n",
    "        x = self.conv1(x)\n",
    "        if self.switch > 0:\n",
    "            print(\"The first layer: convolution layer\")\n",
    "            image_show(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        if self.switch > 0:\n",
    "            print(\"The second layer: pool layer\")\n",
    "            image_show(x)\n",
    "        x = self.conv2(x)\n",
    "        if self.switch > 0:\n",
    "            print(\"The third layer: convolution layer\")\n",
    "            image_show(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        if self.switch > 0:\n",
    "            print(\"The fourth layer: pool layer\")\n",
    "            image_show(x)\n",
    "        x = self.reshape(x, (self.batch_size, -1))\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        self.switch -= 1\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LeNet5<\n",
      "  (conv1): Conv2d<input_channels=1, output_channels=6, kernel_size=(5, 5),stride=(1, 1),  pad_mode=valid, padding=0, dilation=(1, 1), group=1, has_bias=False,weight_init=Parameter (name=conv1.weight), bias_init=None>\n",
      "  (conv2): Conv2d<input_channels=6, output_channels=16, kernel_size=(5, 5),stride=(1, 1),  pad_mode=valid, padding=0, dilation=(1, 1), group=1, has_bias=False,weight_init=Parameter (name=conv2.weight), bias_init=None>\n",
      "  (fc1): Dense<in_channels=400, out_channels=120, weight=Parameter (name=fc1.weight), has_bias=True, bias=Parameter (name=fc1.bias)>\n",
      "  (fc2): Dense<in_channels=120, out_channels=84, weight=Parameter (name=fc2.weight), has_bias=True, bias=Parameter (name=fc2.bias)>\n",
      "  (fc3): Dense<in_channels=84, out_channels=10, weight=Parameter (name=fc3.weight), has_bias=True, bias=Parameter (name=fc3.bias)>\n",
      "  (relu): ReLU<>\n",
      "  (max_pool2d): MaxPool2d<kernel_size=2, stride=2, pad_mode=VALID>\n",
      "  >\n"
     ]
    }
   ],
   "source": [
    "print(LeNet5())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建计算梯度函数GradWrap\n",
    "构建梯度下降求值函数，该函数可计算网络中所有权重的梯度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindspore import context, Tensor, ParameterTuple\n",
    "context.set_context(mode=context.PYNATIVE_MODE, device_target = \"GPU\")\n",
    "\n",
    "class GradWrap(nn.Cell):\n",
    "    \"\"\" GradWrap definition \"\"\"\n",
    "    def __init__(self, network):\n",
    "        super(GradWrap, self).__init__(auto_prefix=False)\n",
    "        self.network = network\n",
    "        self.weights = ParameterTuple(filter(lambda x: x.requires_grad, network.get_parameters()))\n",
    "\n",
    "    def construct(self, x, label):\n",
    "        weights = self.weights\n",
    "        return C.GradOperation('get_by_list', get_by_list=True)(self.network, weights)(x, label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 执行训练函数\n",
    "\n",
    "执行前需要使用`context.set_context`将模式设置成`PYNATIVE_MODE`。然后可以从网络中查看当前`batch`中第一张图片`image`的数据在神经网络中的变化，经过神经网络后，计算出其loss值，再根据loss值求参数的偏导即神经网络的梯度值，最后将梯度和loss进行优化。\n",
    "- image：为当前batch的第一张图片。\n",
    "- output：表示图片数据经过当前网络训练后生成的值，其张量为（1,10）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first layer: convolution layer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The second layer: pool layer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The third layer: convolution layer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The fourth layer: pool layer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mindspore.nn import WithLossCell, SoftmaxCrossEntropyWithLogits, Momentum\n",
    "\n",
    "net = LeNet5()\n",
    "optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.1, 0.9)\n",
    "criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)\n",
    "net_with_criterion = WithLossCell(net, criterion)\n",
    "train_network = GradWrap(net_with_criterion)\n",
    "train_network.set_train()\n",
    "\n",
    "image = images[0][0]\n",
    "image = image.reshape((1,1,32,32))\n",
    "plt.imshow(np.squeeze(image))\n",
    "plt.show()\n",
    "input_data = Tensor(np.array(image).astype(np.float32))\n",
    "label = Tensor(np.array([labels[0]]).astype(np.int32))\n",
    "output = net(Tensor(input_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将第一层卷积层、第二层池化层、第三层卷积层和第四层池化层的图像特征打印出来后，直观地看到随着深度的增加，图像特征几乎无法用肉眼识别，但是机器可以用这些特征进行学习和识别，后续的全连接层为二维数组，无法图像显示，但可以打印出数据查看，由于数据量过大此处就不打印了，用户可以根据需求选择打印。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 求loss值和梯度值，并进行优化\n",
    "\n",
    "先求得loss值，后再根据loss值求梯度（偏导函数值），使用优化器`optimizer`进行优化。\n",
    "- `loss_output`：即为loss值。\n",
    "- `grads`：即网络中每层权重的梯度。\n",
    "- `net_params`：即网络中每层权重的名称，用户可执行`print(net_params)`自行打印。\n",
    "- `success`：优化参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "already has forward run before grad by user\n",
      "conv1.weight: (6, 1, 5, 5)\n",
      "conv2.weight: (16, 6, 5, 5)\n",
      "fc1.weight: (120, 400)\n",
      "fc1.bias: (120,)\n",
      "fc2.weight: (84, 120)\n",
      "fc2.bias: (84,)\n",
      "fc3.weight: (10, 84)\n",
      "fc3.bias: (10,)\n",
      "Loss_value: 2.2908278\n"
     ]
    }
   ],
   "source": [
    "loss_output = criterion(output, label)\n",
    "grads = train_network(input_data, label)\n",
    "net_params = net.trainable_params()\n",
    "for i in range(len(grads)):\n",
    "    print(\"{}:\".format(net_params[i].name),grads[i].shape)\n",
    "success = optimizer(grads)\n",
    "loss = loss_output.asnumpy()\n",
    "print(\"Loss_value:\",loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "具体每层权重的参数有多少，从打印出来的梯度张量能够看到，对应的梯度值用户可以自行选择打印。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本次体验我们将MindSpore的数据增强后，使用了`create_dict_iterator`转化成字典，再单独取出来；使用PyNative模式将神经网络分层单独调试，提取并观察数据；用`WithLossCell`在PyNative模式下计算loss值；构造梯度函数`GradWrap`将神经网络中各个权重的梯度计算出来，以上就是本次的全部体验内容。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}