pfld.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# PFLD：实时人脸关键点检测算法\n",
    "\n",
    "人脸关键点检测是一个非常核心的算法业务，其在许多场景中都有应用。比如我们常用的换脸、换妆、人脸识别等2C APP中的功能，都需要先进行人脸关键点的检测，然后再进行其他的算法业务处理；在一些2B的业务场景中，如疲劳驾驶中对人脸姿态的估计，也可以先进行人脸关键点的检测，然后再通过2D到3D的估计，最后算出人脸相对相机的姿态角。\n",
    "\n",
    "如图所示，PFLD算法可以以很小的网络模型，在常见的人脸关键点检测数据集上得出不错的结果（300W数据集中nme为0.0453，在WFLW数据集上nme为0.0693）。\n",
    "\n",
    "![show_images](images/result1.png)\n",
    "\n",
    "## 模型简介\n",
    "\n",
    "在模型设计上，PFLD的骨干网络没有采用VGG16、ResNet等网络模型，而是采用了轻量化的Backbone MobileNet。但是为了增加模型的表达能力，对MobileNet的输出特征进行了结构上的修改，融合了大中小三个尺度上的特征，并使用融合后的特征进行人脸关键点检测，从而实现对不同大小的脸都有较好的检测效果。同时，网络包含主干网络和辅助网络两部分，辅助网络主要用于在训练时预测人脸姿态，从而提高定位精度。\n",
    "\n",
    "论文[1]中将PFLD与主流的人脸关键点检测算法做了对比实验，主要从CED(cumulative error distribution)曲线、检测精度、模型大小、处理速度几个方面着手。下面是人脸关键点检测的几个具体指标：\n",
    "\n",
    "1. CED曲线\n",
    "\n",
    "首先将pfld与常见的人脸关键点检测算法做比较，并画出CED曲线。此曲线右下区域越大越好，从图中紫红色线段可以清楚的看出，pfld在所有人脸关键点检测算法中表现极好。\n",
    "\n",
    "> CED曲线横坐标是平均归一化误差，纵坐标表示小于归一化误差的特征点占所有特征点的比例。\n",
    "\n",
    "![mne](images/experience1.png)\n",
    "\n",
    "2. 检测精度\n",
    "\n",
    "首先将PFLD与多种主流方法在300W数据集上进行比较。不论是IPN（Inter-Pupli Normalization）还是ION（Inter-Ocular Normalization）指标，PFLD的三个版本均比其他算法更好，结果见下图。\n",
    "\n",
    "![accuracy](images/experience2.png)\n",
    "\n",
    "3. 模型大小\n",
    "\n",
    "PFLD的两个版本不止在精度上有优势，在模型大小上也更胜一筹，PFLD 0.25X仅有2.1Mb，而其他主流算法如：SDM需要10.1Mb，LAB需要50.7Mb，SAN约800Mb(包含两个基于VGG的子网270.5Mb+528Mb)。\n",
    "\n",
    "4. 处理速度\n",
    "\n",
    "在i7-6700K CPU和Nvidia GTX 1080Ti GPU上评估每个算法的效率。从比较中可以看出，PFLD 0.25X和PFLD 1X在CPU和GPU时间上都比其他的要快。PFLD 0.25X在CPU和GPU上花费相同的时间(1.2 毫秒)，这是因为大部分时间都来自于I/O操作。尽管如此，PFLD 1X的性能仍然比其他网络要快得多。\n",
    "\n",
    "其中C代表 CPU i7-6700K，G表示GPU GTX 1080Ti ，A表示 Qualcomm ARM 845 处理器。PFLD 0.25X 和 1X 分别表示mobilenet 网络中深度可分离卷积的宽度乘法因子（width Multiplier）。\n",
    "\n",
    "![speed](images/experience3.png)\n",
    "\n",
    "### 网络特点\n",
    "\n",
    "1. 算法对嵌入式设备非常友好，在骁龙845的芯片中效率可达140fps。\n",
    "2. 另外模型大小较小，仅2.1MB。\n",
    "3. ION和IPN等指标在已有算法中名列前茅。\n",
    "\n",
    "综上所述，PFLD算法速度快、精度高、模型小，在实际的应用场景中（如低算力的端侧设备）有很大的应用空间。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据处理\n",
    "\n",
    "开始实验之前，请确保本地已经安装了Python环境并安装了MindSpore Vision套件。\n",
    "\n",
    "### 数据准备\n",
    "\n",
    "本案例使用[300W](https://ibug.doc.ic.ac.uk/resources/300-W/)数据集作为训练集和验证集。请在官网<https://ibug.doc.ic.ac.uk/resources/300-W/>下载afw，helen，ibug，ifpw这四个文件。\n",
    "\n",
    "其中每个图像上包含不止一张人脸，但是对于每张图像只标注一张人脸。由以上4个文件夹组成的训练集共计3148张图像，测试集有689张图像。\n",
    "\n",
    "请将解压后的数据集放到./datasets/300W/300W_images/下，文件目录如下所示：\n",
    "\n",
    "```text\n",
    "\n",
    ".datasets/\n",
    "    └── 300W\n",
    "         ├── 300W_annotations\n",
    "                └── Mirrors68.txt\n",
    "         └── 300W_images\n",
    "                ├── afw\n",
    "                ├── helen\n",
    "                ├── ibug\n",
    "                └── ifpw\n",
    "```\n",
    "\n",
    "### 数据预处理\n",
    "\n",
    "原始数据集中并没有将训练集的图片和关键点进行汇总，而是存储在pts文件中，非常分散，不利于数据集加载。\n",
    "\n",
    "因此，运行以下代码对数据中的关键点和样本路径进行收集汇总以便后续的训练和评估过程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "from src.datasets.get_annotations import get_annotation\n",
    "\n",
    "# 300W数据集的根路径\n",
    "root_dir = os.path.dirname(os.path.abspath('./') + '/datasets/300W/')\n",
    "\n",
    "# 定义训练数据和测试数据的注释文件的存储路径\n",
    "fw_path_train = os.path.join(\n",
    "    root_dir,\n",
    "    '300W_annotations/list_68pt_rect_attr_train.txt')\n",
    "fw_path_test = os.path.join(\n",
    "    root_dir,\n",
    "    '300W_annotations/list_68pt_rect_attr_test.txt')\n",
    "\n",
    "# 将注释信息保存值注释文件中\n",
    "get_annotation(root_dir, fw_path_train, fw_path_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行成功后，将生成list_68pt_rect_attr_train.txt和list_68pt_rect_attr_test.txt两个文件。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 数据增强\n",
    "\n",
    "在300W数据集中，尽管已经重新标注了四个数据集并统一为68个坐标点，但是对于网络而言数据量仍然不大，因此使用旋转、平移等操作将训练数据进行数据增强。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file: 100/3283\n",
      "file: 200/3283\n",
      "file: 300/3283\n",
      "file: 400/3283\n",
      "file: 500/3283\n",
      "file: 600/3283\n",
      "file: 700/3283\n",
      "file: 800/3283\n",
      "file: 900/3283\n",
      "file: 1000/3283\n",
      "file: 1100/3283\n",
      "file: 1200/3283\n",
      "file: 1300/3283\n",
      "file: 1400/3283\n",
      "file: 1500/3283\n",
      "file: 1600/3283\n",
      "file: 1700/3283\n",
      "file: 1800/3283\n",
      "file: 1900/3283\n",
      "file: 2000/3283\n",
      "file: 2100/3283\n",
      "file: 2200/3283\n",
      "file: 2300/3283\n",
      "file: 2400/3283\n",
      "file: 2500/3283\n",
      "file: 2600/3283\n",
      "file: 2700/3283\n",
      "file: 2800/3283\n",
      "file: 2900/3283\n",
      "file: 3000/3283\n",
      "file: 3100/3283\n",
      "file: 3200/3283\n",
      "file: 100/554\n",
      "file: 200/554\n",
      "file: 300/554\n",
      "file: 400/554\n",
      "file: 500/554\n"
     ]
    }
   ],
   "source": [
    "import shutil\n",
    "import os\n",
    "\n",
    "from src.datasets.augmentation import get_dataset_list\n",
    "\n",
    "# 数据集的根路径\n",
    "root_dir = os.path.dirname(os.path.abspath('./') + '/datasets/300W/')\n",
    "\n",
    "# 图片文件的路径\n",
    "image_dirs = 'datasets/300W/300W_images'\n",
    "\n",
    "# 注释文件的路径，包括训练和测试集\n",
    "landmark_dirs = ['datasets/300W/300W_annotations/list_68pt_rect_attr_train.txt',\n",
    "                 'datasets/300W/300W_annotations/list_68pt_rect_attr_test.txt']\n",
    "\n",
    "# 训练集和数据集处理之后的保存路径\n",
    "out_dirs = ['train_data', 'test_data']\n",
    "\n",
    "for landmark_dir, out_dir in zip(landmark_dirs, out_dirs):\n",
    "    # 得到保存路径\n",
    "    out_dir = os.path.join(root_dir, out_dir)\n",
    "\n",
    "    # 如果没有此文件夹，就创建\n",
    "    if os.path.exists(out_dir):\n",
    "        shutil.rmtree(out_dir)\n",
    "    os.mkdir(out_dir)\n",
    "\n",
    "    # 只对训练数据做增强\n",
    "    if 'list_68pt_rect_attr_test.txt' in landmark_dir:\n",
    "        is_train = False\n",
    "    else:\n",
    "        is_train = True\n",
    "\n",
    "    # 保存图像（3*112*112）及注释文件\n",
    "    get_dataset_list(image_dirs, out_dir, landmark_dir, is_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 数据加载\n",
    "\n",
    "通过数据集加载接口加载数据集，并转换为Tensor以备输入模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'datasets/300W/train_data/list.txt'",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mFileNotFoundError\u001B[0m                         Traceback (most recent call last)",
      "\u001B[1;32m~\\AppData\\Local\\Temp\\ipykernel_6980\\2112571938.py\u001B[0m in \u001B[0;36m<module>\u001B[1;34m\u001B[0m\n\u001B[0;32m      9\u001B[0m \u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m     10\u001B[0m \u001B[1;31m# 生成指定batch的数据集\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[1;32m---> 11\u001B[1;33m \u001B[0mdataset_generator\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mDatasets300W\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;34m'datasets/300W/train_data/list.txt'\u001B[0m\u001B[1;33m,\u001B[0m \u001B[0mtransform\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0m\u001B[0;32m     12\u001B[0m \u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m     13\u001B[0m dataset = ds.GeneratorDataset(source=list(dataset_generator),\n",
      "\u001B[1;32mE:\\PI\\Desktop\\922\\course\\application_example\\pfld\\src\\datasets\\data_loader.py\u001B[0m in \u001B[0;36m__init__\u001B[1;34m(self, file_dir, transforms)\u001B[0m\n\u001B[0;32m     36\u001B[0m         \u001B[0mself\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0meuler_angle\u001B[0m \u001B[1;33m=\u001B[0m \u001B[1;32mNone\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m     37\u001B[0m         \u001B[0mself\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mtransforms\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mtransforms\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[1;32m---> 38\u001B[1;33m         \u001B[1;32mwith\u001B[0m \u001B[0mopen\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0mfile_dir\u001B[0m\u001B[1;33m,\u001B[0m \u001B[1;34m'r'\u001B[0m\u001B[1;33m)\u001B[0m \u001B[1;32mas\u001B[0m \u001B[0mf\u001B[0m\u001B[1;33m:\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0m\u001B[0;32m     39\u001B[0m             \u001B[0mself\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mlines\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mf\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mreadlines\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m     40\u001B[0m \u001B[1;33m\u001B[0m\u001B[0m\n",
      "\u001B[1;31mFileNotFoundError\u001B[0m: [Errno 2] No such file or directory: 'datasets/300W/train_data/list.txt'"
     ]
    }
   ],
   "source": [
    "import mindspore.dataset as ds\n",
    "from mindspore.dataset import vision\n",
    "\n",
    "from src.datasets.data_loader import Datasets300W\n",
    "from src.pfld_utils.utils import map_func\n",
    "\n",
    "# 定义数据集图片中的通道转换及归一化操作\n",
    "transform = vision.py_transforms.ToTensor()\n",
    "\n",
    "# 生成指定batch的数据集\n",
    "dataset_generator = Datasets300W('datasets/300W/train_data/list.txt', transform)\n",
    "\n",
    "dataset = ds.GeneratorDataset(source=list(dataset_generator),\n",
    "                              column_names=[\"img\", \"landmark\", \"attributes\", \"angle\"],\n",
    "                              shuffle=True)\n",
    "\n",
    "dataset = dataset.batch(batch_size=256,\n",
    "                        input_columns=[\"attributes\"],\n",
    "                        output_columns=[\"weight_attribute\"],\n",
    "                        per_batch_map=map_func)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 训练集可视化\n",
    "\n",
    "运行以下代码观察数据增强后的图片。可以发现图片经过了旋转处理，并且图片的shape也已经转换为待输入网络的（N，C，H，W）格式，其中N代表样本数量，C代表图片通道，H和W代表图片的高和宽。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: (256, 3, 112, 112)\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 8 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "show_data = next(dataset.create_dict_iterator())\n",
    "\n",
    "show_images = show_data[\"img\"].asnumpy()\n",
    "print(f'Image shape: {show_images.shape}')\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "# 展示图片供参考\n",
    "for i in range(1, 9):\n",
    "    plt.subplot(2, 4, i)\n",
    "\n",
    "    # 将图片转换HWC格式\n",
    "    image_trans = np.transpose(show_images[i - 1], (1, 2, 0))\n",
    "    image_trans = np.clip(image_trans, 0, 1)\n",
    "\n",
    "    plt.imshow(image_trans[:, :, [2, 1, 0]])\n",
    "    plt.axis(\"off\")\n",
    "    plt.subplots_adjust(wspace=0.05, hspace=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 网络结构\n",
    "\n",
    "前文提到过PFLD模型的骨干网络采用了MobileNet网络，其中采用了大量的卷积层用于提取面部特征，由于人脸除了丰富的细节特征，还包含不同器官间之间的结构特征。所以，在主干网络的最后将多个尺度的特征结合起来以增强关键点的检测效果。\n",
    "\n",
    "![pfld_structure](./images/pfld_structure.png)\n",
    "\n",
    "图中黄色框的部分代表了网络的骨干部分，主要由MobileNet构成用于提取特征，在骨干网络的后半部分有明显大小不同的三组特征图，这代表了不同尺度的特征图，通过对不同尺度特征图的组合利用来进行关键点的检测。\n",
    "\n",
    "骨干网络中还有一条分支指向了绿色框代表的辅助网络，辅助网络接受骨干网络其中一层的特征图用于进行偏航角、俯仰角和横滚角的预测，以此来增强模型的泛化能力，提高预测准确率。\n",
    "\n",
    "### 骨干网络\n",
    "\n",
    "主干网络主要用于提取特征和预测关键点。结构如所示，先采用了mobilenet v2 的多个bottleneck 层， 然后采用多尺度，再通过全连接层把多个尺度的特征连接起来。主干网子网的详细配置为：\n",
    "\n",
    "![network](images/network.png)\n",
    "\n",
    "> 说明：在原论文中，作者并没有明确定义骨干网络和检测器。为了更好的适应在不同的数据集上进行训练和迁移，本案例中将最后一层全连接层定义为检测器，之上的网络结构定义为骨干网络。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from mindspore import nn\n",
    "from mindspore import ops\n",
    "\n",
    "from mindvision.classification.models.blocks import ConvNormActivation\n",
    "from mindvision.classification.models.backbones import InvertedResidual\n",
    "\n",
    "\n",
    "class PFLDBackbone(nn.Cell):\n",
    "\n",
    "    def __init__(self,\n",
    "                 channel_num: tuple = (3, 64, 64, 64, 64, 128, 128, 128, 16, 32, 128)):\n",
    "        super(PFLDBackbone, self).__init__()\n",
    "\n",
    "        # Input channel, output channel, stride, expansion rate\n",
    "        self.block1 = ConvNormActivation(channel_num[0], channel_num[1], 3, 2)\n",
    "        self.block2 = ConvNormActivation(channel_num[1], channel_num[2], 3, 1)\n",
    "\n",
    "        self.conv3 = InvertedResidual(channel_num[2], channel_num[3], 2, 2)\n",
    "        self.block3 = self.make_layer(InvertedResidual, 4, channel_num[3], channel_num[4], 1, 2)\n",
    "\n",
    "        self.conv4 = InvertedResidual(channel_num[4], channel_num[5], 2, 2)\n",
    "        self.conv5 = nn.SequentialCell(\n",
    "            ConvNormActivation(channel_num[5], channel_num[5] * 4, 1),\n",
    "            ConvNormActivation(channel_num[5] * 4, channel_num[5] * 4),\n",
    "            ConvNormActivation(channel_num[5] * 4, channel_num[6], 1, activation=None))\n",
    "        self.block5 = self.make_layer(InvertedResidual, 5, channel_num[6], channel_num[7], 1, 4)\n",
    "\n",
    "        self.conv6 = InvertedResidual(channel_num[7], channel_num[8], 1, 2)\n",
    "        self.avg_pool1 = nn.AvgPool2d(14)\n",
    "\n",
    "        self.conv7 = ConvNormActivation(channel_num[8], channel_num[9], 3, 2)\n",
    "        self.avg_pool2 = nn.AvgPool2d(7)\n",
    "\n",
    "        self.conv8 = nn.Conv2d(channel_num[9], channel_num[10], 7, 1, pad_mode=\"pad\")\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "        self.concat_op = ops.Concat(1)\n",
    "\n",
    "    def make_layer(self,\n",
    "                   block: nn.Cell,\n",
    "                   layer_num: int,\n",
    "                   in_channel: int,\n",
    "                   out_channel: int,\n",
    "                   stride: int,\n",
    "                   expand_ratio: int):\n",
    "\n",
    "        layers = []\n",
    "        for _ in range(layer_num):\n",
    "            pfld_aux_blk = block(in_channel, out_channel, stride, expand_ratio)\n",
    "            layers.append(pfld_aux_blk)\n",
    "\n",
    "        return nn.SequentialCell(layers)\n",
    "\n",
    "    def construct(self, x):\n",
    "        \"\"\" build network \"\"\"\n",
    "        x = self.block1(x)\n",
    "        x = self.block2(x)\n",
    "        x = self.conv3(x)\n",
    "        features1 = self.block3(x)\n",
    "\n",
    "        x = self.conv4(features1)\n",
    "        x = self.conv5(x)\n",
    "        x = self.block5(x)\n",
    "        x = self.conv6(x)\n",
    "\n",
    "        x1 = self.avg_pool1(x)\n",
    "        x1 = x1.view((x1.shape[0], -1))\n",
    "\n",
    "        x = self.conv7(x)\n",
    "        x2 = self.avg_pool2(x)\n",
    "        x2 = x2.view((x2.shape[0], -1))\n",
    "\n",
    "        x3 = self.conv8(x)\n",
    "        x3 = self.relu(x3)\n",
    "        x3 = x3.view((x3.shape[0], -1))\n",
    "\n",
    "        multi_scale = self.concat_op((x1, x2, x3))\n",
    "\n",
    "        return features1, multi_scale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 检测器\n",
    "\n",
    "定义检测器的目的是为了更好的适应不同数量坐标点的情况。feature_num默认为176，如果使用0.25X版本需要改为44，具体计算方式可查看论文[1]。landmark_num常见取值为21，68，98，这主要取决于使用的数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class LandmarkHead(nn.Cell):\n",
    "\n",
    "    def __init__(self,\n",
    "                 feature_num: int = 176,\n",
    "                 landmark_num: int = 68):\n",
    "        super(LandmarkHead, self).__init__()\n",
    "        self.fc = nn.Dense(feature_num, landmark_num * 2)\n",
    "\n",
    "    def construct(self, x):\n",
    "        \"\"\" build network \"\"\"\n",
    "        landmark = self.fc(x)\n",
    "        return landmark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 辅助网络\n",
    "\n",
    "辅助网络是PFLD网络中一个非常重要的结构，前文提到人脸的器官结构信息是非常重要的，而该信息在头部发生扭动，俯仰等情况时，关键点会变形。此时，如果加入偏航角，俯仰角等信息会增强模型的预测能力。\n",
    "\n",
    "辅助网络就负责预测头部姿势，包括偏航角、俯仰角和横滚角。\n",
    "\n",
    "关于计算三个角度的方法如下：\n",
    "\n",
    "1. 预定义一张标准人脸（在一堆正面中平均），并在主导人脸平面上固定11个界标作为所有训练人脸的参考。\n",
    "2. 使用每个人脸的相应11个界标和参考界标来估计旋转矩阵。\n",
    "3. 根据旋转矩阵计算欧拉角。\n",
    "\n",
    "这个部分的操作在数据预处理中已经完成，具体可参考源码src/augmentation.py。\n",
    "\n",
    "或许有人会感到奇怪，给定预测的和地面的地标，为什么不直接从它们计算出欧拉角呢？从技术上讲，这是可行的。然而，界标预测可能太不准确，尤其是在训练开始时，因此导致角度的低质量估计。这可能会使训练陷入困境，例如过度惩罚和缓慢收敛。为了使旋转信息的估计与地标定位分离，辅助子网应运而生。辅助网络的结构如图：\n",
    "\n",
    "![AuxiliaryNet](images/auxiliarynet.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class AuxiliaryNet(nn.Cell):\n",
    "\n",
    "    def __init__(self,\n",
    "                 channel_num: tuple = (64, 128, 128, 32, 128, 32)):\n",
    "        super(AuxiliaryNet, self).__init__()\n",
    "        self.conv1 = ConvNormActivation(channel_num[0], channel_num[1], 3, 2)\n",
    "        self.conv2 = ConvNormActivation(channel_num[1], channel_num[2], 3, 1)\n",
    "        self.conv3 = ConvNormActivation(channel_num[2], channel_num[3], 3, 2)\n",
    "        self.conv4 = ConvNormActivation(channel_num[3], channel_num[4], 2, 2)\n",
    "\n",
    "        self.max_pool1 = nn.MaxPool2d(3, 2)\n",
    "        self.fc1 = nn.Dense(channel_num[4], channel_num[5])\n",
    "        self.fc2 = nn.Dense(channel_num[5], 3)\n",
    "\n",
    "    def construct(self, x):\n",
    "        \"\"\" build network \"\"\"\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.max_pool1(x)\n",
    "        x = x.view((x.shape[0], -1))\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 损失函数\n",
    "\n",
    "训练的质量极大程度上取决于损失函数的设计，常用的$L_1$和$L_2$损失对于小规模训练数据不十分友好，给定两点在图像空间中的偏差，将两点的投影从3D真实面孔应用到2D图像，真实面孔的内在距离可能明显不同，因此将几何信息即偏航角、俯仰角和横滚角整合到惩罚中可缓解此问题。\n",
    "\n",
    "另外，对于包含大量正面，而缺少姿势的较大的面孔的数据集，以此训练的模型不能处理大姿势改变的情况，自然地，针对不同姿势的样本设计不同的惩罚可以有效缓解数据不平衡问题。损失函数的一般形式如下：\n",
    "\n",
    "$$\n",
    "\\mathcal{L} := \\frac{1}{M} \\sum_{m=1}^{M}\\sum_{n=1}^{N}\\gamma_n\\lVert d_n^m \\rVert\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "公式1中，$\\lVert  . \\rVert$指定一个度量来测量预测值与真实值的误差，我们使用$L_2$，$N$是每个面孔要检测的预定义坐标数量，$M$表示每个过程中训练图像的数量。权重$\\gamma_n$是结合光照、模糊程度等信息和三个角度的综合考量，具体损失设计如下：\n",
    "\n",
    "$$\n",
    "\\mathcal{L} := \\frac{1}{M} \\sum_{m=1}^{M}\\sum_{n=1}^{N}\\left ( \\sum_{c=1}^{C}\\omega_n^c\\sum_{k=1}^{K}\\left ( 1-cos \\theta_n^k \\right ) \\right )\\lVert d_n^m \\rVert_2^2\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "公式2中，$\\theta_1$，$\\theta_2$，$\\theta_3$表示真角与估计偏航角、俯仰角和横滚角之间的偏离角，随着偏差角增大，惩罚增加。另外，将样本分为多个属性类别，包括侧面、正面、仰头、低头、表情和遮挡等属性，使用加权参数$\\omega_n^c$根据$c$类样本的分数进行调整。当然，如果不使用$\\gamma_n$，我们的损失会退化为$L_2$损失。例如在使用WFLW数据集时，数据集中有各种属性的值，但是300W中就没有，我们使用的方法就是在300W数据集进行训练时将$\\omega_n^c$置为1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class PFLDLoss(nn.Cell):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(PFLDLoss, self).__init__()\n",
    "        self.sum = ops.ReduceSum(keep_dims=False)\n",
    "        self.cos = ops.Cos()\n",
    "        self.mean = ops.ReduceMean(keep_dims=False)\n",
    "\n",
    "    # TODO：代码格式对齐\n",
    "    def construct(\n",
    "            self,\n",
    "            angle,\n",
    "            landmark,\n",
    "            landmark_gt,\n",
    "            weight_attribute,\n",
    "            euler_angle_gt):\n",
    "        \"\"\"Constructing the forward calculation process.\"\"\"\n",
    "        weight_angle = self.sum(1 - self.cos(angle - euler_angle_gt), 1)\n",
    "        l2_distant = self.sum((landmark_gt - landmark) *\n",
    "                              (landmark_gt - landmark), 1)\n",
    "        loss = weight_angle * weight_attribute * l2_distant\n",
    "        return self.mean(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 模型实现\n",
    "\n",
    "在之前的工作中，我们已经将300W数据集进行了训练集和测试集的划分、定义了网络结构，完成了针对不同数据进行不同程度惩罚的损失函数。在midspore中提供了训练的接口，但是直接使用此接口必须满足每条数据只有两列，例如一张图片和对应的类别等，的数据集不能满足此要求，因此在定义训练流程之前，需要自定义封装了损失函数和模型网络的类。\n",
    "\n",
    "具体代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class CustomWithLossCell(nn.Cell):\n",
    "\n",
    "    def __init__(self,\n",
    "                 net: nn.Cell,\n",
    "                 net_auxiliary: nn.Cell,\n",
    "                 loss_fn: nn.Cell):\n",
    "        super(CustomWithLossCell, self).__init__()\n",
    "        self.net = net\n",
    "        self.net_auxiliary = net_auxiliary\n",
    "        self._loss_fn = loss_fn\n",
    "\n",
    "    def construct(self, img, landmark_gt, weight_attribute, euler_angle):\n",
    "        \"\"\" build network \"\"\"\n",
    "        feature1, landmark = self.net(img)\n",
    "        angle = self.net_auxiliary(feature1)\n",
    "        return self._loss_fn(angle,\n",
    "                             landmark,\n",
    "                             landmark_gt,\n",
    "                             weight_attribute,\n",
    "                             euler_angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 模型训练\n",
    "\n",
    "实例化损失函数，优化器，使用Model接口编译网络。本案例训练的是PFLD1X网络，论文中也提到了0.25X网络，其网络的每层参数为1X网络的四分之一。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:[  0/  1], step:[    1/  129], loss:[581.288/581.288], time:44476.852 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    2/  129], loss:[576.937/579.112], time:18116.197 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    3/  129], loss:[552.494/570.240], time:19197.866 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    4/  129], loss:[542.873/563.398], time:16463.019 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    5/  129], loss:[546.425/560.003], time:13915.870 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    6/  129], loss:[517.990/553.001], time:12586.502 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    7/  129], loss:[542.402/551.487], time:12466.777 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    8/  129], loss:[466.898/540.913], time:12537.039 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[    9/  129], loss:[427.811/528.346], time:12699.592 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   10/  129], loss:[425.052/518.017], time:12739.454 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   11/  129], loss:[400.191/507.305], time:11772.568 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   12/  129], loss:[364.690/495.421], time:11716.254 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   13/  129], loss:[339.469/483.425], time:11793.044 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   14/  129], loss:[295.535/470.004], time:11778.119 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   15/  129], loss:[286.748/457.787], time:11944.703 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   16/  129], loss:[259.980/445.424], time:12086.287 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   17/  129], loss:[235.322/433.065], time:12009.361 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   18/  129], loss:[213.349/420.859], time:12494.035 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   19/  129], loss:[178.337/408.094], time:12490.165 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   20/  129], loss:[166.038/395.991], time:11718.032 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   21/  129], loss:[145.740/384.075], time:11962.940 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   22/  129], loss:[131.592/372.598], time:12261.936 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   23/  129], loss:[103.932/360.917], time:12262.350 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   24/  129], loss:[96.707/349.908], time:14083.940 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   25/  129], loss:[81.497/339.172], time:12796.073 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   26/  129], loss:[78.123/329.132], time:11635.688 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   27/  129], loss:[68.266/319.470], time:11702.208 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   28/  129], loss:[63.227/310.318], time:12870.678 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   29/  129], loss:[58.742/301.643], time:11825.486 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   30/  129], loss:[53.469/293.371], time:11632.436 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   31/  129], loss:[48.946/285.486], time:11434.098 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   32/  129], loss:[40.967/277.845], time:12207.756 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   33/  129], loss:[39.766/270.630], time:12428.792 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   34/  129], loss:[35.395/263.712], time:12954.846 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   35/  129], loss:[33.245/257.127], time:12243.325 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   36/  129], loss:[32.075/250.875], time:11998.529 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   37/  129], loss:[32.143/244.964], time:11697.808 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   38/  129], loss:[28.406/239.265], time:12900.228 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   39/  129], loss:[29.180/233.878], time:12475.002 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   40/  129], loss:[27.413/228.716], time:12501.025 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   41/  129], loss:[25.826/223.768], time:11615.274 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   42/  129], loss:[23.803/219.007], time:11835.812 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   43/  129], loss:[25.069/214.497], time:12152.284 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   44/  129], loss:[24.317/210.174], time:12165.624 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   45/  129], loss:[23.333/206.022], time:12718.478 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   46/  129], loss:[21.988/202.022], time:12818.429 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   47/  129], loss:[23.694/198.227], time:12566.947 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   48/  129], loss:[22.186/194.560], time:12403.713 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   49/  129], loss:[21.727/191.033], time:13207.042 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   50/  129], loss:[22.974/187.672], time:11415.272 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   51/  129], loss:[22.195/184.427], time:11920.888 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   52/  129], loss:[21.978/181.303], time:12098.041 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   53/  129], loss:[21.767/178.293], time:14087.443 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   54/  129], loss:[20.980/175.380], time:14318.826 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   55/  129], loss:[21.362/172.579], time:11826.589 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   56/  129], loss:[20.663/169.866], time:11703.038 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   57/  129], loss:[18.593/167.212], time:11570.292 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   58/  129], loss:[22.502/164.717], time:11715.304 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   59/  129], loss:[20.423/162.272], time:11839.044 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   60/  129], loss:[19.140/159.886], time:11872.802 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   61/  129], loss:[19.721/157.589], time:11323.099 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   62/  129], loss:[18.822/155.350], time:11601.373 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   63/  129], loss:[20.609/153.212], time:11446.129 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   64/  129], loss:[20.000/151.130], time:11897.146 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   65/  129], loss:[19.196/149.100], time:11935.644 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   66/  129], loss:[19.418/147.136], time:11925.317 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   67/  129], loss:[19.574/145.232], time:11984.935 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   68/  129], loss:[20.053/143.391], time:12035.405 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   69/  129], loss:[18.302/141.578], time:12849.683 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   70/  129], loss:[18.872/139.825], time:11290.481 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   71/  129], loss:[17.978/138.109], time:11449.435 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   72/  129], loss:[17.910/136.439], time:11704.601 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   73/  129], loss:[18.319/134.821], time:12793.662 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   74/  129], loss:[20.595/133.278], time:13034.542 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   75/  129], loss:[18.367/131.746], time:12155.425 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   76/  129], loss:[18.454/130.255], time:11232.874 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   77/  129], loss:[20.426/128.829], time:11298.011 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   78/  129], loss:[17.807/127.405], time:11330.746 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   79/  129], loss:[19.282/126.037], time:12819.696 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   80/  129], loss:[18.058/124.687], time:11618.170 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   81/  129], loss:[17.761/123.367], time:11928.420 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   82/  129], loss:[18.566/122.089], time:12000.052 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   83/  129], loss:[18.710/120.843], time:12409.901 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   84/  129], loss:[19.784/119.640], time:12651.496 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   85/  129], loss:[19.179/118.458], time:11354.265 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   86/  129], loss:[18.155/117.292], time:11375.352 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   87/  129], loss:[17.788/116.148], time:11560.277 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   88/  129], loss:[16.884/115.020], time:11461.226 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   89/  129], loss:[18.081/113.931], time:11721.600 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   90/  129], loss:[18.492/112.870], time:11649.674 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   91/  129], loss:[19.618/111.846], time:11391.711 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   92/  129], loss:[17.306/110.818], time:11760.335 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   93/  129], loss:[17.441/109.814], time:11611.262 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   94/  129], loss:[18.259/108.840], time:12283.985 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   95/  129], loss:[16.999/107.873], time:11439.200 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   96/  129], loss:[17.607/106.933], time:11639.779 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   97/  129], loss:[17.762/106.014], time:11377.137 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   98/  129], loss:[19.660/105.133], time:11409.182 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[   99/  129], loss:[18.927/104.262], time:13044.309 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  100/  129], loss:[17.998/103.399], time:11428.230 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  101/  129], loss:[17.731/102.551], time:11603.289 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  102/  129], loss:[16.978/101.712], time:11777.459 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  103/  129], loss:[18.777/100.907], time:11799.811 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  104/  129], loss:[16.826/100.098], time:12470.743 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  105/  129], loss:[17.998/99.316], time:11347.458 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  106/  129], loss:[17.231/98.542], time:11923.260 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  107/  129], loss:[15.984/97.770], time:11830.349 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  108/  129], loss:[15.673/97.010], time:11333.899 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  109/  129], loss:[17.912/96.285], time:11779.983 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  110/  129], loss:[16.174/95.556], time:12318.487 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  111/  129], loss:[17.940/94.857], time:11297.961 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  112/  129], loss:[15.499/94.149], time:11193.397 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  113/  129], loss:[16.355/93.460], time:11374.882 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  114/  129], loss:[16.059/92.781], time:11356.546 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  115/  129], loss:[17.428/92.126], time:11255.473 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  116/  129], loss:[16.810/91.477], time:11563.527 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  117/  129], loss:[16.286/90.834], time:11282.822 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  118/  129], loss:[17.099/90.209], time:11308.687 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  119/  129], loss:[16.754/89.592], time:11703.825 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  120/  129], loss:[16.535/88.983], time:11363.945 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  121/  129], loss:[15.576/88.376], time:11286.570 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  122/  129], loss:[16.592/87.788], time:11250.528 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  123/  129], loss:[15.404/87.200], time:11285.125 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  124/  129], loss:[16.833/86.632], time:12538.205 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  125/  129], loss:[16.314/86.070], time:11246.741 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  126/  129], loss:[14.972/85.505], time:11237.152 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  127/  129], loss:[16.021/84.958], time:11219.213 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  128/  129], loss:[14.178/84.405], time:11222.227 ms, lr:0.00010\n",
      "Epoch:[  0/  1], step:[  129/  129], loss:[13.119/83.853], time:15511.670 ms, lr:0.00010\n",
      "Epoch time: 1614258.835 ms, per step time: 12513.634 ms, avg loss: 83.853\n"
     ]
    }
   ],
   "source": [
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig\n",
    "from mindspore import Model\n",
    "from mindvision.engine.callback import LossMonitor\n",
    "\n",
    "from src.model.auxiliarynet import AuxiliaryNet\n",
    "from src.pfld_utils.loss_cell import CustomWithLossCell\n",
    "from src.model.pfld import pfld_1x_68\n",
    "from src.pfld_utils.loss import PFLDLoss\n",
    "\n",
    "\n",
    "# 初始化模型结构\n",
    "net_auxiliary = AuxiliaryNet()\n",
    "net = pfld_1x_68()\n",
    "\n",
    "# 计算学习率\n",
    "lr = nn.inverse_decay_lr(learning_rate=0.0001,\n",
    "                         decay_rate=0.4,\n",
    "                         total_step=12900,\n",
    "                         step_per_epoch=129,\n",
    "                         decay_epoch=1)\n",
    "\n",
    "# 优化器\n",
    "optimizer = nn.Adam(params=net.get_parameters(),\n",
    "                    learning_rate=lr,\n",
    "                    weight_decay=1e-6)\n",
    "\n",
    "# 自定义损失函数\n",
    "loss = PFLDLoss()\n",
    "\n",
    "# 联合损失函数的网络，适用于数据集中有多列的情况\n",
    "net_with_loss = CustomWithLossCell(net, net_auxiliary, loss)\n",
    "\n",
    "# 初始化模型\n",
    "model = Model(network=net_with_loss, optimizer=optimizer)\n",
    "\n",
    "# 设置ckpt文件保存的参数\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=129,\n",
    "                             keep_checkpoint_max=100)\n",
    "ckpoint = ModelCheckpoint(prefix=\"checkpoint_300W\",\n",
    "                          directory='./checkpoint_300w',\n",
    "                          config=config_ck)\n",
    "\n",
    "# 训练\n",
    "model.train(1, dataset, callbacks=[ckpoint, LossMonitor(lr)], dataset_sink_mode=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出结果：\n",
    "\n",
    "```text\n",
    "Epoch:[ 1/40], step:[  0/129], loss:[6.709/6.732], time:418.097ms, lr:1.00010\n",
    "Epoch:[ 1/40], step:[  1/129], loss:[6.739/6.739], time:417.928ms, lr:1.00010\n",
    "Epoch:[ 1/40], step:[  2/129], loss:[6.729/6.734], time:418.322ms, lr:1.00010\n",
    "......\n",
    "Epoch:[40/40], step:[127/129], loss:[0.709/0.732], time:418.097ms, lr:0.00001\n",
    "Epoch:[40/40], step:[128/129], loss:[0.739/0.739], time:417.928ms, lr:0.00001\n",
    "Epoch:[40/40], step:[129/129], loss:[0.729/0.734], time:418.322ms, lr:0.00001\n",
    "```\n",
    "\n",
    "为了方便展示，案例中将epoch设置为1，经测试，在实际训练中，将epoch设置为100是一个不错的选择。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 模型评估\n",
    "\n",
    "在300W数据集的验证集上进行评估。\n",
    "\n",
    "IPN（Inter-pupil Normalization）和ION（Inter-Ocular Normalization），以及NME（Normalization Mean Error）是人脸关键点的常用评价指标。\n",
    "\n",
    "IPN和ION的计算公式一致:\n",
    "\n",
    "$$\n",
    "e_i = \\frac{\\left\\| x_i - x_i^*\\right\\|_2}{d}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "公式3中，$x_i$表示第 i 个关键点的预测坐标，$x_i^*$表示第 i 个关键点的 ground truth。\n",
    "\n",
    "对于ION指标而言，d取值为左右眼角的距离。对于IPN指标而言，d取值为两瞳孔之间的距离（WFLW），如果没有瞳孔点（300W），取双眼区域12个关键点的平均距离。即用这些瞳孔距离的归一化值来表示预测结果与真实结果之间的差值，显然该值表明了预测的准确度，该值越小越好。\n",
    "\n",
    "Normalization Mean Error 的计算公式为：\n",
    "\n",
    "$$\n",
    "e = \\frac{\\sum_{i=1}^{N}\\left\\| x_i - x_i^*\\right\\|_2}{N *d}\n",
    "\\tag{4}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "44699648B [00:07, 6228214.74B/s]                                \n",
      "[WARNING] ME(2184:15380,MainProcess):2022-09-20-16:47:56.935.048 [mindspore\\train\\serialization.py:660] For 'load_param_into_net', remove parameter net.backbone.block1.features.0.weight's prefix name: net., continue to load it to net parameter backbone.block1.features.0.weight.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== PFLD1X ==============\n",
      "nme:0.0511\n",
      "ion:0.5138\n",
      "ipn:0.3030\n",
      "inference_cost_time: 0.018299\n"
     ]
    }
   ],
   "source": [
    "from mindvision.utils.load_pretrained_model import LoadPretrainedModel\n",
    "from src.pfld_utils.metric import validate\n",
    "\n",
    "\n",
    "# 初始化网络并将训练好的模型加载置网络中\n",
    "net = pfld_1x_68()\n",
    "LoadPretrainedModel(net, 'https://download.mindspore.cn/vision/pfld/PFLD1X_300W.ckpt').run()\n",
    "\n",
    "# 加载评估所用的数据集\n",
    "transform = vision.py_transforms.ToTensor()\n",
    "dataset_generator = Datasets300W('./datasets/300W/test_data/list.txt', transform)\n",
    "wlfw_dataset_val = ds.GeneratorDataset(list(dataset_generator),\n",
    "                                       [\"img\", \"landmark\", \"attributes\", \"angle\"])\n",
    "wlfw_dataset_val = wlfw_dataset_val.batch(batch_size=1,\n",
    "                                          input_columns=[\"attributes\"],\n",
    "                                          output_columns=[\"weight_attribute\"],\n",
    "                                          per_batch_map=map_func)\n",
    "\n",
    "# 验证模型效果\n",
    "net.set_train(False)\n",
    "validate(wlfw_dataset_val, net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 模型推理\n",
    "\n",
    "值得注意的是：\n",
    "\n",
    "1. PFLD是人脸关键点检测的网络，重点在关键点检测上，网络的输入需要为人脸区域图像，作者在验证模型效果之前用到了mtcnn检测人脸区域，因此，推理的图片需要直接使用人脸图像。\n",
    "\n",
    "2. 网络的输入为（1，3，112，112）的张量，本案例中的推理选择的是AFLW数据集中的一张处理后图片，若要使用其他大小的图片，请在输入网络前处理成网络可以推理的张量形式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[WARNING] ME(2184:15380,MainProcess):2022-09-20-16:49:56.282.523 [mindspore\\train\\serialization.py:660] For 'load_param_into_net', remove parameter net.backbone.block1.features.0.weight's prefix name: net., continue to load it to net parameter backbone.block1.features.0.weight.\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2\n",
    "from mindspore import Tensor\n",
    "\n",
    "\n",
    "net = pfld_1x_68()\n",
    "LoadPretrainedModel(net, 'https://download.mindspore.cn/vision/pfld/PFLD1X_300W.ckpt').run()\n",
    "\n",
    "transform = vision.py_transforms.ToTensor()\n",
    "\n",
    "# 读取图片\n",
    "origin_img = cv2.imread('images/infer_image.png')\n",
    "origin_h, origin_w, _ = origin_img.shape\n",
    "\n",
    "# 将图片修正为（112，112）的尺寸并归一化\n",
    "img = cv2.resize(origin_img, (112, 112))\n",
    "img = transform(img)\n",
    "\n",
    "# 网络输入为（1，3，112，112），对图片进行转换\n",
    "img = np.expand_dims(img, axis=0)\n",
    "img = Tensor(img)\n",
    "\n",
    "# 得到预测的坐标点\n",
    "_, landmarks = net(img)\n",
    "\n",
    "# 处理坐标点及展示图片\n",
    "landmarks = landmarks.asnumpy()\n",
    "landmarks = landmarks.reshape(landmarks.shape[0], -1, 2)\n",
    "\n",
    "pre_landmark = landmarks[0] * [origin_w, origin_h]\n",
    "\n",
    "img_clone = cv2.imread(\"images/infer_image.png\")\n",
    "for (x, y) in pre_landmark.astype(np.int32):\n",
    "    cv2.circle(img_clone, (x, y), 1, (255, 0, 0), -1)\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(img_clone[:, :, [2, 1, 0]])\n",
    "plt.axis(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 流程与总结\n",
    "\n",
    "![](images/data_flow.png)\n",
    "\n",
    "本案例对PFLD的论文中提出的模型进行了详细的解释，向读者完整地展现了该算法的流程，分析了PFLD作者处理人脸检测问题中存在的挑战的思路等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 引用\n",
    "\n",
    "[1] Guo X, Li S, Yu J, et al. PFLD: A practical facial landmark detector[J]. arXiv preprint arXiv:1902.10859, 2019.\n",
    "\n",
    "[2] C. Sagonas, E. Antonakos, G, Tzimiropoulos, S. Zafeiriou, M. Pantic. 300 faces In-the-wild challenge: Database and results. Image and Vision Computing (IMAVIS), Special Issue on Facial Landmark Localisation \"In-The-Wild\". 2016.\n",
    "\n",
    "[3] C. Sagonas, G. Tzimiropoulos, S. Zafeiriou, M. Pantic. 300 Faces in-the-Wild Challenge: The first facial landmark localization Challenge. Proceedings of IEEE Int’l Conf. on Computer Vision (ICCV-W), 300 Faces in-the-Wild Challenge (300-W). Sydney, Australia, December 2013.\n",
    "\n",
    "[4] C. Sagonas, G. Tzimiropoulos, S. Zafeiriou, M. Pantic. A semi-automatic methodology for facial landmark annotation. Proceedings of IEEE Int’l Conf. Computer Vision and Pattern Recognition (CVPR-W), 5th Workshop on Analysis and Modeling of Faces and Gestures (AMFG 2013). Oregon, USA, June 2013."
   ]
  }
 ],
 "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.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "dc8ea5c3e1e94bda308d7721c92a234a592f7f0e8435030535cc19755bee3e9b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}