Hand-Gesture-Recognition-Lab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8046508a",
   "metadata": {},
   "source": [
    "# MindSpore深度学习之手势识别"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7089e7b8",
   "metadata": {},
   "source": [
    "深度学习技术的发展极大的促进了生产力的提升，智能家务、智能办公等技术景象都在这一轮的技术发展浪潮中成为可能。这其中，手势识别作为一种全新的人机交互模式，在多种场景中都有应用，具有极其重要的作用。本实验探究如何将深度学习技术应用到手势识别之中。本实验的主要内容包含：\n",
    "\n",
    " - [1] 编写**SE-Conv模型**(SENet+CNN)并进行训练与测试，并将SE-Conv各层次提取的特征**可视化**并进行分析。\n",
    " - [2] 使用**ResNet18封装模型**进行训练与测试。\n",
    " - [3] 编写、修改**ViT模型**并进行训练与测试，对比ViT与CNN，**分析**ViT在本任务中效果不佳的原因并提出验证方式。\n",
    " - [4] 使用HUAWEI MATE30设备**采集**手势数据，设计采集数据**预处理**，并使用上述训练得到的模型进行**模型推理预测**。\n",
    " - [5] 针对**模型推理效果、模型终端部署、模型应用前景**展开讨论。\n",
    " - [6] 将模型运用于**另一个手势分类任务**(4-handgesture_mini)，解决模型**不收敛**问题，对比不同**超参数**对模型的影响，对比模型效果。**这部分主要在(附录：实验日志)中展示**。\n",
    "\n",
    "本实验的目录如下：\n",
    " - [一] 数据处理与准备：(1)数据集描述 -> (2)数据预处理 -> (3)处理结果可视化\n",
    " - [二] SE-Conv网络：(1)SENet简介 -> (2)SE-Conv实现 -> (3)SE-Conv训练 -> (4)SE-Conv测试 -> (5)SE-Conv特征可视化\n",
    " - [三] ResNet18网络：(1)ResNet18简介 -> (2)ResNet18实现与训练 -> (3)ResNet18测试\n",
    " - [四] Vision Tramsformer网络：(1)ViT简介 -> (2)ViT实现 -> (3)ViT训练与测试 -> (4)ViT效果分析与解释\n",
    " - [五] 模型推理与应用：(1)数据采集 -> (2)采集数据预处理 -> (3)模型推理\n",
    " - [六] 拓展讨论：(1)模型推理的影响因素 -> (2)模型的终端部署 -> (3)手势识别的应用展望\n",
    " - [七] 附录：(1)本文作者 -> (2)实验日志 -> (3)参考文献\n",
    "\n",
    "开始实验之前，请确保本地已经安装了Python环境并安装了MindSpore Vision套件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "24060beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os,sys\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import cv2\n",
    "import random\n",
    "import shutil\n",
    "import matplotlib.pyplot as plt\n",
    "import requests\n",
    "from mindvision.engine.callback import ValAccMonitor\n",
    "from mindspore.train.callback import TimeMonitor\n",
    "from mindvision.engine.loss import CrossEntropySmooth\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.dataset.vision.c_transforms as transforms\n",
    "import mindspore as ms\n",
    "from mindspore import Model\n",
    "import mindspore.nn as nn\n",
    "import mindspore.ops as ops\n",
    "from mindspore import Tensor\n",
    "from typing import Optional\n",
    "from mindspore.common.initializer import Normal,initializer\n",
    "from mindvision.classification.models import resnet18\n",
    "ms.set_seed(1234)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34379f46",
   "metadata": {},
   "source": [
    "## 一. 数据准备与处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7458714",
   "metadata": {},
   "source": [
    "### (1) 数据集描述"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bf15723",
   "metadata": {},
   "source": [
    "本实验使用Kaggle上的 Hand Gesture Recognition Database 作为数据集(下载地址:https://www.kaggle.com/datasets/gti-upm/leapgestrecog)。 \n",
    "\n",
    "本实验的原数据较大(2GiB)，其中包含十组采样数据，每组中包含十种手势动作的图片。为了实验的方便，我们使用随机采样的方式将数据集适当缩小。具体而言，对于原数据，我们随机采样7%的数据作为训练集，1.5%的数据作为验证集，1.5%的数据作为测试集，并额外加入推理图片，从而构成了本实验使用的handgesture_datasets_mini数据集(180MiB)。在handgesture_datasets_mini数据集中，包含1400张训练数据与300张验证/测试数据，以及5张推理数据。\n",
    "\n",
    "请将本实验文档与handgesture_datasets_mini数据集放置于同一文件夹下。数据集目录如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4de4b93",
   "metadata": {},
   "outputs": [],
   "source": [
    "# handgesture_datasets_mini\n",
    "#     └── train\n",
    "#          ├── 01_palm\n",
    "#          ├── ......\n",
    "#          └── 10_down\n",
    "#                 ├── ......\n",
    "#                 └── xxx.png\n",
    "#     └── val\n",
    "#     └── test\n",
    "#     └── inf\n",
    "#          ├── origin\n",
    "#          ├── nobg\n",
    "#          └── input"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2d790a",
   "metadata": {},
   "source": [
    "数据采样代码如下(请先下载数据集再运行)："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e203e990",
   "metadata": {},
   "outputs": [],
   "source": [
    "typ=['train','val','test']\n",
    "cl=['01_palm','02_l','03_fist','04_fist_moved','05_thumb','06_index','07_ok','08_palm_moved','09_c','10_down']\n",
    "file_base='handgesture_datasets_mini'\n",
    "if not os.path.exists(file_base):\n",
    "    os.makedirs('handgesture_datasets')\n",
    "for t in typ:\n",
    "    filename_1=file_base+'\\\\'+t\n",
    "    if not os.path.exists(filename_1):\n",
    "        os.makedirs(filename_1)\n",
    "    for j in cl:\n",
    "        filename=filename_1+'\\\\'+j\n",
    "        if not os.path.exists(filename):\n",
    "            os.makedirs(filename)\n",
    "ID_train=0\n",
    "ID_dev=0;\n",
    "ID_test=0\n",
    "file_base_org='leapGestRecog'\n",
    "for person_id in range(10):\n",
    "    filename_1=file_base_org+'\\\\0'+str(person_id)\n",
    "    for g in cl:\n",
    "        filename_2=filename_1+'\\\\'+g \n",
    "        list_file=os.listdir(filename_2)\n",
    "        n=len(list_file)\n",
    "        n_train=int(n*0.07)\n",
    "        n_dev=int(n*0.015)\n",
    "        n_test=n_dev\n",
    "        list_train=random.sample(list_file,n_train)\n",
    "        for itm in list_train:\n",
    "            list_file.remove(itm)\n",
    "        list_dev=random.sample(list_file,n_dev)\n",
    "        for itm in list_dev:\n",
    "            list_file.remove(itm)\n",
    "            list_test=list_file\n",
    "        for x in list_train:\n",
    "            file_dir='handgesture_datasets\\\\train\\\\'+g+'\\\\'+str(ID_train)+'.png'\n",
    "            ID_train=ID_train+1\n",
    "            shutil.copy(filename_2+'\\\\'+x,file_dir)\n",
    "        for x in list_dev:\n",
    "            file_dir='handgesture_datasets\\\\dev\\\\'+g+'\\\\'+str(ID_dev)+'.png'\n",
    "            ID_dev=ID_dev+1\n",
    "            shutil.copy(filename_2+'\\\\'+x,file_dir)\n",
    "        for x in list_test:\n",
    "            file_dir='handgesture_datasets\\\\test\\\\'+g+'\\\\'+str(ID_test)+'.png'\n",
    "            ID_test=ID_test+1\n",
    "            shutil.copy(filename_2+'\\\\'+x,file_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "329073e9",
   "metadata": {},
   "source": [
    "### (2) 数据预处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e862549",
   "metadata": {},
   "source": [
    "在将数据图片输入模型之前，本实验首先对其进行预处理。\n",
    "\n",
    "具体而言，对于一张图片，首先根据超参数image_size将图片resize为K×K的大小，K=int(image_size×1.05)，然后中心裁剪成image_size大小。为了处理左右手的情况，本例将图片以50%的概率左右反转。最后，本例将图片的RGB三通道值标准化。\n",
    "\n",
    "上述数据预处理过程使用mindvision中的c_transform模块实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1f561f99",
   "metadata": {},
   "outputs": [],
   "source": [
    "class_index={\"01_palm\": 0, \"02_l\": 1,\"03_fist\":2,\"04_fist_moved\":3,\"05_thumb\":4,\n",
    "            \"06_index\":5,\"07_ok\":6,\"08_palm_moved\":7,\"09_c\":8,\"10_down\":9}\n",
    "def create_dataset(path, batch_size=10, train=True, image_size=224 , class_indexing={}):\n",
    "    dataset = ds.ImageFolderDataset(path, num_parallel_workers=1, class_indexing=class_index)\n",
    "    # 图像增强操作\n",
    "    mean = [0.485 * 255, 0.456 * 255, 0.406 * 255]\n",
    "    std = [0.229 * 255, 0.224 * 255, 0.225 * 255]\n",
    "    if train:\n",
    "        trans = [\n",
    "            transforms.Decode(),\n",
    "            transforms.Resize(int(image_size*1.05)),\n",
    "            transforms.CenterCrop(image_size),\n",
    "            transforms.RandomHorizontalFlip(prob=0.5),\n",
    "            transforms.Normalize(mean=mean, std=std),\n",
    "            transforms.HWC2CHW()\n",
    "        ]\n",
    "    else:\n",
    "        trans = [\n",
    "            transforms.Decode(),\n",
    "            transforms.Resize(int(image_size*1.05)),\n",
    "            transforms.CenterCrop(image_size),\n",
    "            transforms.Normalize(mean=mean, std=std),\n",
    "            transforms.HWC2CHW()\n",
    "        ]\n",
    "\n",
    "    dataset = dataset.map(operations=trans, input_columns=\"image\")\n",
    "    # 设置batch_size的大小，若最后一次抓取的样本数小于batch_size，则丢弃\n",
    "    dataset = dataset.batch(batch_size, drop_remainder=True)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67c32de3",
   "metadata": {},
   "source": [
    "### (3) 数据处理可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "53b25321",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1e2b373de20>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_path = \"handgesture_datasets_mini\\\\train\"\n",
    "dataset_train = create_dataset(train_path,batch_size=16, train=True,image_size=50,class_indexing=class_index)\n",
    "dic=dataset_train.create_dict_iterator(1)\n",
    "pic=next(dic)['image'][0][0]\n",
    "pic=(pic-pic.min())/(pic.max()-pic.min())*255\n",
    "pic=pic.asnumpy()\n",
    "plt.imshow(pic)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f6b3f6a",
   "metadata": {},
   "source": [
    "## 二. SE-Conv网络"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd28ea01",
   "metadata": {},
   "source": [
    "SENet是Squeeze-and-Excitation Networks的简称，拿到了ImageNet2017分类比赛冠军，其效果得到了认可。SE模块思想简单，易于实现，并且很容易可以加载到现有的网络模型框架中。与传统的注意力机制模型相比，SENet主要是学习了channel之间的相关性，筛选出了针对通道的注意力。\n",
    "\n",
    "本实验的第一个模型将SENet加载到一个简单的CNN网络(命名为SE-Conv网络)，并在测试集上取得了96%的准确率。为了进一步理解SENet的学习内容，我们将不同层次的提取特征进行了可视化输出。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78c4ae28",
   "metadata": {},
   "source": [
    "### (1) SENet 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b09526",
   "metadata": {},
   "source": [
    "![](src\\\\pic\\\\senet.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bff56ba5",
   "metadata": {},
   "source": [
    "对于卷积操作，很大一部分工作是提高感受野，即空间上融合更多特征，或者是提取多尺度空间信息，如Inception网络的多分支结构。对于channel维度的特征融合，卷积操作基本上默认对输入特征图的所有channel进行融合。而SENet网络的创新点在于关注channel之间的关系，希望模型可以自动学习到不同channel特征的重要程度。为此，SENet提出了SE模块，如上图所示。\n",
    "\n",
    "具体而言，首先通过n×n的卷积网络进行全局池化，从而将一个channel上整个空间特征编码为一个全局特征。然后，通道特征通过bottleneck结构的两个全连接层，其中第一个FC层起到降维的作用，降维系数为se_ratio是个超参数。本实验中，采用Tanh函数激活。最后的FC层恢复原始的维度。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38e9ac48",
   "metadata": {},
   "source": [
    "### (2) SE-Conv实现"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9ddbf7e",
   "metadata": {},
   "source": [
    "![](src\\\\pic\\\\se-conv.jpg)\n",
    "\n",
    "本实验的第一个模型选择将SENet结构加载到一个简单卷积网络上，从而形成SE-Conv模型。具体而言，Se-Conv包含三个卷积层、一个池化层与两个全连接层，其中SE模块放置在第一、二个卷积层中间，用于使上游16个卷积提取特征通道间进行交互。SE-Conv的具体实现使用MindSpore进行，具体代码如下所示："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9158ce0c",
   "metadata": {},
   "source": [
    "SENet模块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b826383b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# in_channels是输入卷积特征的通道数，in_w是输入特征的宽度(默认shape为正方形)\n",
    "class SENet_Enhence(nn.Cell):\n",
    "    def __init__(self,in_channels,in_w,se_ratio=2):\n",
    "        super(SENet_Enhence,self).__init__()\n",
    "        self.conv_global=nn.Conv2d(in_channels=in_channels,out_channels=in_channels,kernel_size=in_w,pad_mode='valid')\n",
    "        self.drop=nn.Dropout(0.1)\n",
    "        self.se_d1=nn.Dense(in_channels=in_channels,out_channels=in_channels//se_ratio)\n",
    "        self.tanh=nn.Tanh()\n",
    "        self.se_d2=nn.Dense(in_channels=in_channels//se_ratio,out_channels=in_channels)\n",
    "        self.sigmoid=nn.Sigmoid()\n",
    "\n",
    "    def construct(self,x):\n",
    "        w=self.conv_global(x) # (b,c,w,h) --> (b,c,1,1)\n",
    "        w=w.squeeze(-1)\n",
    "        w=w.squeeze(-1)\n",
    "        w=self.drop(w)\n",
    "        w=self.se_d2(self.tanh(self.se_d1(w)))\n",
    "        w=self.sigmoid(w)\n",
    "        w=w.expand_dims(-1)\n",
    "        w=w.expand_dims(-1)\n",
    "        x=x*w\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4141a7df",
   "metadata": {},
   "source": [
    "SE-Conv模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "75d4e68b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# image_size即数据预处理后的图片大小，input_channels为输入通道数，out_n即类别总数\n",
    "class ConvNet(nn.Cell):\n",
    "    def __init__(self,image_size: int = 224,input_channels: int = 3,out_n:int=4) -> None:\n",
    "        super(ConvNet, self).__init__()\n",
    "        # b,c,w,h\n",
    "        self.conv1=nn.Conv2d(in_channels=input_channels,out_channels=16,kernel_size=3,pad_mode='same')\n",
    "        self.se=SENet_Enhence(in_channels=16,in_w=image_size,se_ratio=2)\n",
    "        self.conv2=nn.Conv2d(in_channels=16,out_channels=32,kernel_size=3,pad_mode='same')\n",
    "        self.drop=nn.Dropout(0.1)\n",
    "        self.conv3=nn.Conv2d(in_channels=32,out_channels=16,kernel_size=3,pad_mode='same')\n",
    "        self.pool=nn.MaxPool2d(kernel_size=2,stride=2)\n",
    "        self.dense=nn.Dense(10000,768)\n",
    "        self.relu=nn.Tanh()\n",
    "        self.dense2=nn.Dense(768,out_n)\n",
    "        self.fl=ops.Flatten()\n",
    "        self.sof=ops.Softmax()\n",
    "\n",
    "    def construct(self, x):\n",
    "        x=self.conv1(x)\n",
    "        x=self.se(x)\n",
    "        x=self.conv2(x)\n",
    "        x=self.pool(self.conv3(self.drop(x)))\n",
    "        x=self.fl(x)\n",
    "        x=self.relu(self.dense(x))\n",
    "        x=self.dense2(x)\n",
    "        x=self.sof(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1a83234",
   "metadata": {},
   "source": [
    "### (3) SE-Conv模型的训练"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcca39f5",
   "metadata": {},
   "source": [
    "经过调试后，SE-Net的训练选择Adam优化器，其中学习率设置为0.0002，动量设置为0.05。输入数据方面，image_size设置为50(50×50)，虽然本例的训练数据接近黑白图片，但本例仍保持输入通道为3。最后，在损失函数上，本例选择mindvision模块提供的CrossEntropySmooth，并设置smooth_factor为0.05。\n",
    "\n",
    "具体实现上，本例使用MindSpore提供的Model封装模块进行训练，使用准确率Accuracy作为验证标准，并使用mindvision提供的Monitor模块进行验证与保存。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "604d9613",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SENet-Conv 训练 参数设置\n",
    "train_path = \"handgesture_datasets_mini\\\\train\"\n",
    "dataset_train = create_dataset(train_path,batch_size=16, train=True,image_size=50,class_indexing=class_index)\n",
    "val_path = \"handgesture_datasets_mini\\\\val\"\n",
    "dataset_val = create_dataset(val_path,batch_size=8,train=False,image_size=50,class_indexing=class_index)\n",
    "\n",
    "epoch_size = 120\n",
    "momentum = 0.05\n",
    "step_size = dataset_train.get_dataset_size()\n",
    "num_classes = 10\n",
    "lr=0.0002\n",
    "\n",
    "se_conv=ConvNet(image_size=50,input_channels=3,out_n=num_classes)\n",
    "network_opt=nn.Adam(se_conv.trainable_params(), lr, momentum)\n",
    "network_loss = CrossEntropySmooth(reduction=\"mean\",smooth_factor=0.05,classes_num=num_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8c8deda",
   "metadata": {},
   "source": [
    "运行下面的代码开始SE-Conv训练(共120个Epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "087b8f30",
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics={'Accuracy':nn.Accuracy()}\n",
    "train_model=ms .Model(se_conv, loss_fn=network_loss, optimizer=network_opt, metrics=metrics)\n",
    "#train_model.train(epoch_size,dataset_train,\n",
    "#                  callbacks=[ValAccMonitor(train_model, dataset_val, epoch_size,best_ckpt_name='best_se_conv_hg10.ckpt'), TimeMonitor()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16a3ef82",
   "metadata": {},
   "source": [
    "也可以直接运行下面的代码加载训练结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e7f69794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load pretrain SE-Conv\n"
     ]
    }
   ],
   "source": [
    "param_dict = ms.load_checkpoint(\"model_result\\\\best_se_conv_hg10.ckpt\")\n",
    "ms.load_param_into_net(se_conv, param_dict)\n",
    "print(\"load pretrain SE-Conv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c455f773",
   "metadata": {},
   "source": [
    "### (4) SE-Conv结果测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea2f2d4",
   "metadata": {},
   "source": [
    "将模型运用到测试集上，即可得到测试结果。可以发现，训练得到的模型在测试集上取得了约96%的准确率。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f85ee72",
   "metadata": {},
   "source": [
    "加载测试集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dbab9f2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_path = \"handgesture_datasets_mini\\\\test\"\n",
    "dataset_test = create_dataset(test_path,batch_size=1,train=False,image_size=50,class_indexing=class_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f19b5313",
   "metadata": {},
   "source": [
    "模型测试："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9e16b230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Top_1_Accuracy': 0.9666666666666667}\n"
     ]
    }
   ],
   "source": [
    "eval_metrics = {'Top_1_Accuracy': nn.Top1CategoricalAccuracy()}\n",
    "model = ms.Model(se_conv, network_loss, metrics=eval_metrics)\n",
    "result = model.eval(dataset_test)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27d2293e",
   "metadata": {},
   "source": [
    "可以看到，SE-Conv在测试集上获得了96.6%的正确率。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e7ffad5",
   "metadata": {},
   "source": [
    "### (5) SE-Conv特征可视化"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ce72aa7",
   "metadata": {},
   "source": [
    "为了更好的理解SE-Conv的工作情况，本例将SE-Conv各个层次提取的特征可视化。在卷积神经网络中，不同的channel能够关注到不同的具体特征，因此，输出SE-Conv提取的特征即对网络不同层次提取的特征图进行可视化。\n",
    "\n",
    "为了实现本例后面的各种功能，首先实现三个数据处理函数，具体含义如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "59726303",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入图像(numpy)和超参数image_size，输出进行过数据预处理后的结果\n",
    "def trans_pic(x,image_size):\n",
    "    mean = [0.485 * 255, 0.456 * 255, 0.406 * 255]\n",
    "    std = [0.229 * 255, 0.224 * 255, 0.225 * 255]\n",
    "    tr1=transforms.Resize(int(image_size*1.05))\n",
    "    x=tr1(x)\n",
    "    tr2=transforms.CenterCrop(image_size)\n",
    "    x=tr2(x)\n",
    "    tr3=transforms.Normalize(mean=mean, std=std)\n",
    "    x=tr3(x)\n",
    "    tr4=transforms.HWC2CHW()\n",
    "    x=tr4(x)\n",
    "    return x\n",
    "\n",
    "# 输入图片文件地址filename，输出经过预处理后的结果，并转化可以用plt.imshow显示的格式\n",
    "def get_print_pic(filename,image_size):\n",
    "    img=np.array(Image.open(filename))\n",
    "    if img.ndim==2:\n",
    "        img=img.reshape(img.shape[0],img.shape[1],1)\n",
    "        img=np.concatenate([img,img,img],axis=2)\n",
    "        img_x=trans_pic(img,image_size=image_size)\n",
    "    img_x=img_x.transpose((1,2,0))\n",
    "    return img_x\n",
    "\n",
    "# 输入图片文件地址filename，输出经过预处理后的结果，并转化可以输入训练模型的格式\n",
    "def get_input_pic(filename,image_size):\n",
    "    img=np.array(Image.open(filename))\n",
    "    if img.ndim==2:\n",
    "        img=img.reshape(img.shape[0],img.shape[1],1)\n",
    "        img=np.concatenate([img,img,img],axis=2)\n",
    "    img_x=trans_pic(img,image_size=image_size)\n",
    "    img_x=ms.Tensor(img_x).reshape([1,3,50,50])\n",
    "    return img_x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04982818",
   "metadata": {},
   "source": [
    "随后使用上述函数即可进行特征可视化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f50b9d19",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x1008 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_cls='10_down'\n",
    "plt.figure(figsize=(3,3))\n",
    "filename=test_path+'\\\\'+show_cls+'\\\\'+os.listdir(test_path+'\\\\'+show_cls)[10]\n",
    "img_in=get_print_pic(filename,image_size=50)\n",
    "plt.title(f\"Original Picture\",fontsize=16)\n",
    "plt.imshow(img_in)\n",
    "plt.figure(figsize=(16,14))\n",
    "input=get_input_pic(filename,image_size=50)\n",
    "feature_graph1=se_conv.se(se_conv.conv1(input))\n",
    "feature_graph_se=se_conv.se(se_conv.conv1(input))\n",
    "feature_graph2=se_conv.conv2(se_conv.se(se_conv.conv1(input)))\n",
    "feature_graph3=se_conv.conv3(se_conv.conv2(se_conv.se(se_conv.conv1(input))))\n",
    "feature_graph_pool=se_conv.pool(se_conv.conv3(se_conv.conv2(se_conv.se(se_conv.conv1(input)))))\n",
    "feature_graph_list=[feature_graph1,feature_graph_se,feature_graph2,feature_graph3,feature_graph_pool]\n",
    "feature_name=['Conv1','SE','Conv2','Conv3','Pool']\n",
    "\n",
    "def show_feature_map(i):\n",
    "    for j in range(4):\n",
    "        p_ID=i*4+j\n",
    "        for k in range(5):\n",
    "            plt.subplot(4,5,5*j+k+1)\n",
    "            pic=feature_graph_list[k][0,p_ID,:,:].asnumpy()\n",
    "            pic=(pic-pic.min())/(pic.max()-pic.min())*255\n",
    "            pic=pic.astype(np.int32)\n",
    "            plt.title(f\"{feature_name[k]}-Feature{p_ID}\",fontsize=16)\n",
    "            plt.imshow(pic)\n",
    "\n",
    "show_feature_map(0)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "029be5fc",
   "metadata": {},
   "source": [
    "在上述特征图中，亮部即网络层关注部分。可以发现，不同的channel会关注不同的局部信息。如在Conv1-Feature中，第1个通道关注宏观的手掌，而第二个通道则重点关注大拇指、食指和小拇指，第三个通道关注手的边缘，而第四个通道则重点关注手的轮廓线。同时可以发现，不同通道中越高层次的特征图越趋于相同，这是由于高层次的特征由低层次特征提取出来，更为重要与精炼，因此高层次通道都会优先去关注那些最为重要的特征。例如在上图中，基本上所有通道在Pool阶段时，相比于手心与手掌的部分，都更为关注手的边缘与轮廓线。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df4fc739",
   "metadata": {},
   "source": [
    "## 三. ResNet18网络"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d710c5",
   "metadata": {},
   "source": [
    "\n",
    "### (1) ResNet18简介\n",
    "\n",
    "本例的第二个模型采用图像处理领域中颇负盛名的Resnet系列网络。ResNet的结构可以极快的加速神经网络的训练，并对模型的准确率产生较大的提升。本例采用的是体量最小的Resnet18卷积网络。\n",
    "\n",
    "我们知道深层网络存在着梯度消失或者爆炸的问题，这使得深度学习模型很难训练。而Resnet的最大创新点则是使用Res残差结构，使得深度爆炸问题得到了极大的缓解。\n",
    "\n",
    "![](src\\\\pic\\\\resnet_in.jpg)\n",
    "\n",
    "Resnet18首先经过一个7×7卷积层和3×3 MaxPooling层，然后是四个“Res模块”，每个模块由两个Build Block组成，而每个Build Block又由两个卷积层组成，其中卷积层由残差结构与bottleneck结构构成，具体可见论文《Deep Residual Learning for Image Recognition》。特征最后则是通过average pool、全连接层。由于Pooling层不需要参数学习，故去除Pooling层，整个resnet18网络由18层组成。\n",
    "\n",
    "![](src\\\\pic\\\\resnet_info2.jpg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "673991da",
   "metadata": {},
   "source": [
    "### (2) ResNet18实现与训练\n",
    "\n",
    "MindSpore Vision是一个开源的基于MindSpore框架的计算机视觉研究工具箱，工具所涉及的任务主要包括分类、检测(开发中)、视频(开发中)和3D(开发中)。MindSpore Vision旨在通过提供易用的接口来帮助用户复现现有的经典模型并开发自己的新模型。MindVision工具箱中包含大量预先写好的视觉模型，这其中就包括了ResNet18。因此，本实验选择直接使用MindVision提供的resnet18模型，并在此基础上进行训练。\n",
    "\n",
    "经过调试后，ResNet的训练选择Adam优化器，其中学习率设置为0.0002，不设置动量。输入数据方面，image_size设置为50(50×50)，虽然本例的训练数据接近黑白图片，但本例仍保持输入通道为3。最后，在损失函数上，本例选择mindspore.nn模块提供的SoftmaxCrossEntropyWithLogits损失函数。\n",
    "\n",
    "$ l(x_{i},c)=-log(\\frac{exp(x_{i}[c])}{\\sum_{j}(x_{i}[j])})=-x_{i}[c]+log(\\sum_j exp(x_{i}[j])) $\n",
    "\n",
    "在训练了30个epoch左右，模型在验证集上的准确率达到了99%左右。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1bbb9a3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## ResNet训练参数设置\n",
    "train_path = \"./handgesture_datasets_mini/train\"\n",
    "dataset_train = create_dataset(train_path,batch_size=32, train=True,image_size=50)\n",
    "val_path = \"./handgesture_datasets_mini/val\"\n",
    "dataset_val = create_dataset(val_path,batch_size=32, train=False,image_size=50)\n",
    "\n",
    "resnet18 = resnet18(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "net_opt = nn.Adam(resnet18.trainable_params(), learning_rate=0.0002)\n",
    "metrics = {\"Accuracy\": nn.Accuracy()}\n",
    "model = Model(resnet18, loss_fn=net_loss, optimizer=net_opt, metrics=metrics)\n",
    "num_epochs = 120"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e2b1285",
   "metadata": {},
   "source": [
    "运行下面的代码开始ResNet的训练："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "17eacefe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.train(num_epochs,\n",
    "#             dataset_train,\n",
    "#             callbacks=[ValAccMonitor(resnet18, dataset_val, num_epochs,epoch_size,best_ckpt_name='best_resnet18_imagesize=50.ckpt'), TimeMonitor()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a42c7762",
   "metadata": {},
   "source": [
    "也可以运行下面的代码直接加载预训练好的模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c03c4bc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load pretrain ResNet18\n"
     ]
    }
   ],
   "source": [
    "param_dict = ms.load_checkpoint(\"model_result\\\\best_resnet18_imagesize=50.ckpt\")\n",
    "ms.load_param_into_net(resnet18, param_dict)\n",
    "print(\"load pretrain ResNet18\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02348490",
   "metadata": {},
   "source": [
    "### (3) ResNet18结果测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d423e8e",
   "metadata": {},
   "source": [
    "加载测试数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "04fc9dd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_path = \"handgesture_datasets_mini\\\\test\"\n",
    "dataset_test = create_dataset(test_path,batch_size=1,train=False,image_size=50,class_indexing=class_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e57dc3c8",
   "metadata": {},
   "source": [
    "模型测试："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1422bcd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Top_1_Accuracy': 0.9966666666666667}\n"
     ]
    }
   ],
   "source": [
    "eval_metrics = {'Top_1_Accuracy': nn.Top1CategoricalAccuracy()}\n",
    "model = ms.Model(resnet18, network_loss, metrics=eval_metrics)\n",
    "result = model.eval(dataset_test)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d66b817",
   "metadata": {},
   "source": [
    "可以看到，ResNet18在测试集上获得了99.6%的正确率。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ff109b5",
   "metadata": {},
   "source": [
    "## 四. Vision Transformer网络(ViT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e689763",
   "metadata": {},
   "source": [
    "### (1) ViT简介"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8a55bbf",
   "metadata": {},
   "source": [
    "![](src\\\\pic\\\\vit.png)\n",
    "\n",
    "近些年，随着基于自注意结构（Self-Attention）的模型的发展，特别是Transformer模型的提出，极大地促进了自然语言处理模型的发展。由于Transformers的计算效率和可扩展性，它已经能够训练具有超过100B参数的空前规模的模型。\n",
    "\n",
    "ViT则是自然语言处理和计算机视觉两个领域的融合结晶。在不依赖卷积操作的情况下，依然可以在图像分类任务上达到很好的效果，通过注意力机制提取全局空间结构信息，依旧能在大多数视觉任务上获得不错的结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f989b21",
   "metadata": {},
   "source": [
    "### (2) ViT实现"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9933f556",
   "metadata": {},
   "source": [
    "详细的实现过程可以见MindSpore官网的ViT教程：\n",
    "https://www.mindspore.cn/tutorials/application/zh-CN/master/cv/vit.html\n",
    "\n",
    "本例的ViT代码对官方教程的代码进行了修正。为了适应本实验的任务，本例还在此基础上进行了一定的修改。\n",
    "\n",
    "完整的ViT代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "55547c48",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Attention(nn.Cell):\n",
    "    def __init__(self,dim: int,num_heads: int = 8,keep_prob: float = 1.0,attention_keep_prob: float = 1.0):\n",
    "        super(Attention, self).__init__()\n",
    "        self.num_heads = num_heads\n",
    "        head_dim = dim // num_heads\n",
    "        self.scale = ms.Tensor(head_dim ** -0.5)\n",
    "        self.qkv = nn.Dense(dim, dim * 3)\n",
    "        self.attn_drop = nn.Dropout(attention_keep_prob)\n",
    "        self.out = nn.Dense(dim, dim)\n",
    "        self.out_drop = nn.Dropout(keep_prob)\n",
    "        self.mul = ops.Mul()\n",
    "        self.reshape = ops.Reshape()\n",
    "        self.transpose = ops.Transpose()\n",
    "        self.unstack = ops.Unstack(axis=0)\n",
    "        self.attn_matmul_v = ops.BatchMatMul()\n",
    "        self.q_matmul_k = ops.BatchMatMul(transpose_b=True)\n",
    "        self.softmax = nn.Softmax(axis=-1)\n",
    "\n",
    "    def construct(self, x):\n",
    "        b, n, c = x.shape   \n",
    "        qkv = self.qkv(x)\n",
    "        qkv = self.reshape(qkv, (b, n, 3, self.num_heads, c // self.num_heads))  #(b,n,3,n_head,d_head)\n",
    "        qkv = self.transpose(qkv, (2, 0, 3, 1, 4))        # (3,b,n_head,n,d_head)\n",
    "        q, k, v = self.unstack(qkv)                       # (b,n_head,n,d_head)\n",
    "        attn = self.q_matmul_k(q, k)                      # (b,n_head,n,n)\n",
    "        attn = self.attn_drop(self.softmax(self.mul(attn, self.scale)))\n",
    "        out = self.attn_matmul_v(attn, v)                 # (b,n_head,n,d_head)\n",
    "        out = self.transpose(out, (0, 2, 1, 3))           # (b,n,n_head,d_head)\n",
    "        out = self.out_drop(self.out(self.reshape(out, (b, n, c))))\n",
    "        return out\n",
    "    \n",
    "class FeedForward(nn.Cell):\n",
    "    def __init__(self,in_feature,hidden_feature,activation,keep_prob):\n",
    "        super(FeedForward,self).__init__()\n",
    "        self.feed=nn.Dense(in_feature, hidden_feature)\n",
    "        self.activation=activation()\n",
    "        self.drop=nn.Dropout(keep_prob)\n",
    "        \n",
    "    def construct(self,x):\n",
    "        x=self.feed(x)\n",
    "        x=self.activation(x)\n",
    "        x=self.drop(x)\n",
    "        return x\n",
    "\n",
    "class ResidualCell(nn.Cell):\n",
    "    def __init__(self,net):\n",
    "        super(ResidualCell,self).__init__()\n",
    "        self.net=net\n",
    "    \n",
    "    def construct(self,x):\n",
    "        x=self.net(x)+x\n",
    "        return x\n",
    "    \n",
    "class TransformerEncoder(nn.Cell):\n",
    "    def __init__(self,dim: int,num_layers: int,num_heads: int,mlp_dim: int,keep_prob: float = 1.,\n",
    "                 attention_keep_prob: float = 1.0,drop_path_keep_prob: float = 1.0,activation: nn.Cell = nn.GELU,\n",
    "                 norm: nn.Cell = nn.LayerNorm):\n",
    "        super(TransformerEncoder, self).__init__()\n",
    "        layers = []\n",
    "        for tmp in range(num_layers):\n",
    "            normalization1 = norm((dim,))\n",
    "            normalization2 = norm((dim,))\n",
    "            attention = Attention(dim=dim,num_heads=num_heads,keep_prob=keep_prob,attention_keep_prob=attention_keep_prob)\n",
    "            feedforward = FeedForward(in_feature=dim,\n",
    "                                      hidden_feature=mlp_dim,\n",
    "                                      activation=activation,\n",
    "                                      keep_prob=keep_prob)\n",
    "            layers.append(\n",
    "                nn.SequentialCell([\n",
    "                    ResidualCell(nn.SequentialCell([normalization1,attention])),\n",
    "                    ResidualCell(nn.SequentialCell([normalization2,feedforward]))\n",
    "                ])\n",
    "            )\n",
    "        self.layers = nn.SequentialCell(layers)\n",
    "        \n",
    "    def construct(self, x):\n",
    "        return self.layers(x)\n",
    "\n",
    "\n",
    "class PatchEmbedding(nn.Cell):\n",
    "    def __init__(self,image_size: int = 224,patch_size: int = 16,embed_dim: int = 768,input_channels: int = 3):\n",
    "        super(PatchEmbedding, self).__init__()\n",
    "        self.image_size = image_size\n",
    "        self.patch_size = patch_size\n",
    "        self.num_patches = (image_size // patch_size) ** 2\n",
    "        self.conv = nn.Conv2d(input_channels, embed_dim, kernel_size=patch_size, stride=patch_size, has_bias=True)\n",
    "        self.reshape = ops.Reshape()\n",
    "        self.transpose = ops.Transpose()\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv(x)\n",
    "        b, c, h, w = x.shape\n",
    "        x = self.reshape(x, (b, c, h * w))\n",
    "        x = self.transpose(x, (0, 2, 1))\n",
    "        return x\n",
    "    \n",
    "    \n",
    "class VIT(nn.Cell):\n",
    "    def __init__(self,image_size: int = 224,input_channels: int = 3,patch_size: int = 16,embed_dim: int = 768,\n",
    "                 num_layers: int = 12,num_heads: int = 12,mlp_dim: int = 3072,keep_prob: float = 1.0,\n",
    "                 attention_keep_prob: float = 1.0,drop_path_keep_prob: float = 1.0,activation: nn.Cell = nn.GELU,\n",
    "                 norm: Optional[nn.Cell] = nn.LayerNorm,pool: str = 'cls') -> None:\n",
    "        super(VIT, self).__init__()\n",
    "\n",
    "        self.patch_embedding = PatchEmbedding(image_size=image_size,patch_size=patch_size,\n",
    "                                              embed_dim=embed_dim,input_channels=input_channels)\n",
    "        num_patches = self.patch_embedding.num_patches\n",
    "        self.cls_token=ms.Parameter(Tensor(init=Normal(sigma=1.0),shape=(1, 1, embed_dim),dtype=ms.float32),\n",
    "                                    name='cls_token',requires_grad=True)\n",
    "        self.pos_embedding=ms.Parameter(Tensor(init=Normal(sigma=1.0),shape=(1, num_patches + 1, embed_dim),dtype=ms.float32),\n",
    "                                        name='pos_embedding',requires_grad=True)\n",
    "        self.concat = ops.Concat(axis=1)\n",
    "        self.pool = pool\n",
    "        self.pos_dropout = nn.Dropout(keep_prob)\n",
    "        self.norm = norm((embed_dim,))\n",
    "        self.tile = ops.Tile()\n",
    "        self.transformer = TransformerEncoder(dim=embed_dim,num_layers=num_layers,num_heads=num_heads,mlp_dim=mlp_dim,\n",
    "                                              keep_prob=keep_prob,attention_keep_prob=attention_keep_prob,\n",
    "                                              drop_path_keep_prob=drop_path_keep_prob,\n",
    "                                              activation=activation,norm=norm)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.patch_embedding(x)\n",
    "        cls_tokens = self.tile(self.cls_token, (x.shape[0], 1, 1))  #(b,n,d)\n",
    "        x = self.concat((cls_tokens, x))\n",
    "        x += self.pos_embedding\n",
    "        x=self.pos_dropout(x)\n",
    "        x=self.transformer(x)\n",
    "        x=self.norm(x)\n",
    "        x = x[:, 0]\n",
    "        return x\n",
    "    \n",
    "class VIT_Model(nn.Cell):\n",
    "    def __init__(self,cls_num=10,image_size: int = 224,input_channels: int = 3,patch_size: int = 16,embed_dim: int = 768,\n",
    "                 num_layers: int = 12,num_heads: int = 12,mlp_dim: int = 3072,keep_prob: float = 1.0,\n",
    "                 attention_keep_prob: float = 1.0,drop_path_keep_prob: float = 1.0,activation: nn.Cell = nn.GELU,\n",
    "                 norm: Optional[nn.Cell] = nn.LayerNorm,pool: str = 'cls'):\n",
    "        super(VIT_Model,self).__init__()\n",
    "        self.vit=VIT(image_size=image_size,input_channels=input_channels,patch_size=patch_size,embed_dim=embed_dim,num_layers=num_layers,\n",
    "                    num_heads=num_heads,mlp_dim=mlp_dim,keep_prob=keep_prob,attention_keep_prob=attention_keep_prob,\n",
    "                    drop_path_keep_prob=drop_path_keep_prob)\n",
    "        self.classifier=nn.Dense(mlp_dim, cls_num)\n",
    "    \n",
    "    def construct(self,x):         # (b,n,c,w,h)\n",
    "        x=self.vit(x)\n",
    "        x=self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9faa4133",
   "metadata": {},
   "source": [
    "### (3) ViT模型训练与测试"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "827cf58d",
   "metadata": {},
   "source": [
    "ViT模型训练的可调整内容大致包括：momentum、lr、image_size、embed_dim、smooth_factor、num_layers、num_heads。\n",
    "\n",
    "经过反复调整，ViT模型依旧未能取得较好的效果，一些可能的解释见下文。本实验还将ViT模型应用到了另一个四分类手势识别问题上进行验证(见附件中的实验日志描述)，其效果依旧远不如卷积神经网络。因此，基本可以得出结论：在手势识别问题上，以Transformer为基础的ViT模型不如以CNN为基础的卷积神经网络模型。\n",
    "\n",
    "介于此，下面的代码仅是一个训练示例，不代表绝对的最优训练参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8b13e7f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "## ViT训练参数设置\n",
    "train_path = \"./handgesture_datasets_mini/train\"\n",
    "dataset_train = create_dataset(train_path,batch_size=16, train=True,image_size=50)\n",
    "val_path = \"./handgesture_datasets_mini/val\"\n",
    "dataset_val = create_dataset(val_path,batch_size=8, train=False,image_size=50)\n",
    "\n",
    "epoch_size = 80\n",
    "momentum = 0.05\n",
    "step_size = dataset_train.get_dataset_size()\n",
    "num_classes = 10\n",
    "lr=0.00002\n",
    "\n",
    "vit_net= VIT_Model(cls_num=num_classes,image_size=50,input_channels=3,patch_size=5,embed_dim=512,\n",
    "                   num_layers=6,num_heads=8,mlp_dim=512,keep_prob=0.2,attention_keep_prob=0.2,drop_path_keep_prob=0.2)\n",
    "\n",
    "network_opt=nn.Adam(vit_net.trainable_params(), lr, momentum)\n",
    "network_loss = CrossEntropySmooth(reduction=\"mean\",smooth_factor=0.1,classes_num=num_classes)\n",
    "metrics={'Accuracy':nn.Accuracy()}\n",
    "train_model=ms .Model(vit_net, loss_fn=network_loss, optimizer=network_opt, metrics=metrics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5cd1f504",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load pretrain ViT\n",
      "{'Top_1_Accuracy': 0.16}\n"
     ]
    }
   ],
   "source": [
    "# train_model.train(epoch_size,dataset_train,callbacks=[ValAccMonitor(train_model, dataset_val, \n",
    "#                   epoch_size,best_ckpt_name='best_vit.ckpt'), TimeMonitor()])\n",
    "param_dict = ms.load_checkpoint(\"model_result\\\\best_vit.ckpt\")\n",
    "ms.load_param_into_net(vit_net, param_dict)\n",
    "print(\"load pretrain ViT\")\n",
    "test_path = \"handgesture_datasets_mini\\\\test\"\n",
    "dataset_test = create_dataset(test_path,batch_size=1,train=False,image_size=50,class_indexing=class_index)\n",
    "eval_metrics = {'Top_1_Accuracy': nn.Top1CategoricalAccuracy()}\n",
    "model = ms.Model(vit_net, network_loss, metrics=eval_metrics)\n",
    "result = model.eval(dataset_test)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97580863",
   "metadata": {},
   "source": [
    "### (4) ViT效果分析与解释"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa990af3",
   "metadata": {},
   "source": [
    "从上述结果可以发现，ViT在handgesture-mini数据集上的表现较为糟糕。作者对训练参数和ViT结构进行了多次调整，得到的结果都较为糟糕。因此，基本上可以得出结论，基础的ViT模型并不适合该任务。\n",
    "\n",
    "作者尝试对此结果进行分析。可能的原因如下：\n",
    "\n",
    "第一，训练操作问题，然而作者已经反复调试，因此这种原因的可能性较小。\n",
    "\n",
    "第二，patch的大小太大，导致学习过程中的信息细粒度太低。\n",
    "\n",
    "第三，该任务中的图像隐含模式具有特定性质，其模式信息主要集中在局部的轮廓信息，而非全局的空间结构。而Transformer结构更关注全局空间结构，而传统卷积网络则更能提取出局部轮廓信息。作者认为，此原因的可能性较大，而我们对SE-Conv进行提取特征可视化输出的结果也验证了这一点。对于这一原因，一种可能的验证方式是编写Transformer与CNN结合的产物MobileViT并进行测试。若MobileViT的效果介于ViT和CNN之间，则可以证明该猜想正确。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "135d3000",
   "metadata": {},
   "source": [
    "## 五. 模型推理与应用"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "981ef8b3",
   "metadata": {},
   "source": [
    "在进行这一部分实验前，请先将src文件夹中的infer文件夹拷贝到handgesture_datasets_mini文件夹内。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0508d989",
   "metadata": {},
   "source": [
    "### (1) 数据采集"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e417fc08",
   "metadata": {},
   "source": [
    "最后，本例进行模型推理与应用。本例将训练得到的SE-Conv模型应用到直接采集的数据。\n",
    "\n",
    "我们使用HUAWEI MATE30设备拍摄了5张含背景手势图像：\n",
    "\n",
    "![](src\\\\pic\\\\org-hand.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb1bcfda",
   "metadata": {},
   "source": [
    "### (2) 采集数据预处理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae0385b5",
   "metadata": {},
   "source": [
    "首先将模型训练所用数据显示如下："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e71a3a17",
   "metadata": {},
   "source": [
    "![](src\\\\pic\\\\train-hand.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f9d71db",
   "metadata": {},
   "source": [
    "注意到模型训练所用的数据是高对比度的类黑白图像，其中手部呈现白色，而背景则呈现纯黑色。因此，为了让训练得到的模型可以应用于采集到的数据，必须完成背景去除与黑白转换两个步骤。\n",
    "\n",
    "对于背景去除工作，Removebg是著名的一键式图像分割软件。由于本例重点关注图像识别而非图像分割，因此我们选择直接采用Removebg软件的Python接口，具体的内容读者可以自行查阅。背景去除的效果如下：\n",
    "\n",
    "![](src\\\\pic\\\\nobg-hand.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c33319d",
   "metadata": {},
   "source": [
    "背景去除后，图像仅在被识别为手部的区域有像素值(其它位置像素值接近于0)。因此，本例设置像素值阈值thresh，当像素值大于thresh时，将像素点设置为白色，否则设置为黑色。\n",
    "\n",
    "上述两步的具体执行代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "87bc295f",
   "metadata": {},
   "outputs": [],
   "source": [
    "filename_base='handgesture_datasets_mini\\\\infer'\n",
    "nobg_file_list=[]\n",
    "file_list=os.listdir(filename_base+'\\\\origin')\n",
    "print(file_list)\n",
    "for f in file_list:\n",
    "     filename=filename_base+'\\\\origin\\\\'+f\n",
    "     filename_nobg=filename_base+'\\\\nobg\\\\'+f[:-4]+'_nobg.jpg'\n",
    "     filename_input=filename_base+'\\\\input\\\\'+f[:-4]+'_input.jpg'\n",
    "     response = requests.post(\n",
    "          'https://api.remove.bg/v1.0/removebg',\n",
    "          files={'image_file': open(filename, 'rb')},\n",
    "          data={'size': 'auto'},\n",
    "          headers={'X-Api-Key': 'PBDo7WvQaMNveH9jhimmqTst'},\n",
    "     )\n",
    "     if response.status_code == requests.codes.ok:\n",
    "          with open(filename_nobg, 'wb') as out:\n",
    "               out.write(response.content)\n",
    "     else:\n",
    "          print(\"Error:\", response.status_code, response.text)\n",
    "     img_grey = cv2.imread(filename_nobg, cv2.IMREAD_GRAYSCALE)\n",
    "     thresh =30\n",
    "     img_binary = cv2.threshold(img_grey, thresh, 255, cv2.THRESH_BINARY)[1]\n",
    "     cv2.imwrite(filename_input,img_binary)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dea0eec6",
   "metadata": {},
   "source": [
    "最终的处理效果如下："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4761b48",
   "metadata": {},
   "source": [
    "![](src\\\\pic\\\\input-hand.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b016f714",
   "metadata": {},
   "source": [
    "### (3) 模型推理"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "608dfe1f",
   "metadata": {},
   "source": [
    "使用刚才预训练好的模型进行预测，得到的结果如下。在当前采集的五张图片中，我们的SE-Conv模型成功预测了四张，唯一错误的一张将ok手势预测成了palm_moved。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "31bba3d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred=09_c ; ans=inf_c\n",
      "pred=10_down ; ans=inf_down\n",
      "pred=02_l ; ans=inf_l\n",
      "pred=08_palm_moved ; ans=inf_ok\n",
      "pred=01_palm ; ans=inf_palm\n"
     ]
    }
   ],
   "source": [
    "def infer(filename,model_inf):\n",
    "    img_x=get_input_pic(filename,image_size=50)\n",
    "    out=model_inf(img_x)\n",
    "    pred=out.argmax(-1)\n",
    "    return (pred,list(class_index.keys())[pred])\n",
    "\n",
    "filename_base_inf_input='handgesture_datasets_mini\\\\infer\\\\input'\n",
    "file_list=os.listdir(filename_base_inf_input)\n",
    "for f in file_list:\n",
    "    filename=filename_base_inf_input+'\\\\'+f\n",
    "    pred=infer(filename,se_conv)[1]\n",
    "    print(f\"pred={pred} ; ans={f[:-10]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40fe6221",
   "metadata": {},
   "source": [
    "## (六). 拓展讨论"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32cf7ddc",
   "metadata": {},
   "source": [
    "### (1) 模型推理的影响因素\n",
    "\n",
    "在上述过程中，我们将原采集图片去除背景，并进行黑白处理。但观察原训练数据，不难发现其并非纯黑白图片，而是有一定灰度，并且在手部边缘出出现了明显的颜色渐变。这种差异将导致模型推理能力的下降。一种可能的解决方案是对训练/验证/测试数据也进行黑白预处理，再在此基础上训练新的模型。\n",
    "\n",
    "更重要的影响因素在于采集数据时的角度。观察训练集/验证集可以发现，对于某一个手势，在数据集中只包含特定角度采集的数据。因此，理论上本实验的模型不支持zero-shot，因此只能学习到特定角度采集到的手势中的模式。毫无疑问，数据采集角度将对模型的静态推理产生巨大的影响。解决这个问题的第一个方式是，在采集手势数据时从特定角度采集，但这在实际操作中毫无疑问是困难的。第二个方式或许更为可行，即将静态推理改为动态推理，即模型对采集的手势视频进行实时预测，并取一段时间内置信度最高的手势作为预测结果。当然，为了实现实时预测，则需要将模型部署到终端设备。\n",
    "\n",
    "### (2) 模型的终端部署\n",
    "\n",
    "本例使用的MindSpore架构有配套的MindSpore Lite全生态AI引擎，因此将训练得到的模型(假设其适合部署，这里暂且不讨论模型的量级问题)部署到终端的最大困难主要在于：如何将采集图像的预处理函数部署到终端。这个问题设计更复杂的程序设计问题，以Android系统APP部署为例，通过查看MindSpore仓库可以发现，MindVision APP的数据预处理由Vision仓中的:\n",
    "\n",
    "android/enginelibrary/src/main/cpp/classification/CustomMindSporeNetnative.cpp \n",
    "\n",
    "中的PreProcessImageData函数实现。\n",
    "\n",
    "![](src\\\\pic\\\\ct.png)\n",
    "\n",
    "因此，想要将本例的模型部署到终端，则首先应当用C语言修改上述代码，然后使用MindSpore Lite将模型部署到APP端。\n",
    "\n",
    "### (3) 手势识别的应用展望\n",
    "\n",
    "手势识别的本质是一种全新的人机交互模式，其具有广泛的应用前景，一些例子列举如下。第一，智能家居。手势识别可以使家居物联网的操作互联进一步简化。第二，智能安全。手势识别可以用于对特定安全领域，如当对特定物品(核电站设备、婴幼儿误碰等)进行非法操作时，及时发出警报。第三，智能办公。手势识别将使人机交互效率得到进一步提升，从而提高办公效率。第四，智能教学。手势识别可以广泛运用于手部精细操作的教育与纠正，如幼儿写字、雕刻工艺、乐器弹奏等。第五，智能娱乐。手势识别方式为人机交互提供了全新的视角，必将激发电子娱乐产业的新一波革命......综上所述，手势识别是智能交互领域的风口，具有广阔的应用前景与巨大的商业价值。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "963214bf",
   "metadata": {},
   "source": [
    "## 七. 附录"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51976402",
   "metadata": {},
   "source": [
    "### (1) 本文作者"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b6fc4dd",
   "metadata": {},
   "source": [
    "本实验项目系2022年华中七校华为昇腾AI训练营第16小组成果\n",
    "\n",
    "作者为：武汉大学 啊对对队 ycbqwq ; qaz-del ; donghongyuu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b99922",
   "metadata": {},
   "source": [
    "### (2) 实验日志\n",
    "\n",
    "在实验过程中，作者遇到的问题与对应的解决方法在handgesture_log.md中记录，供读者参考。\n",
    "\n",
    "上述模型的训练参数与详细训练结果也在handgesture_log.md中记录。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14be306d",
   "metadata": {},
   "source": [
    "### (3) 参考文献"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a94d5ce4",
   "metadata": {},
   "source": [
    "<div id=\"refer-anchor-1\"></div>\n",
    "\n",
    " - [1] https://www.kaggle.com/datasets/gti-upm/leapgestrecog \n",
    "\n",
    "<div id=\"refer-anchor-2\"></div>\n",
    "\n",
    " - [2] https://www.remove.bg/tools-api\n",
    "\n",
    "<div id=\"refer-anchor-3\"></div>\n",
    "\n",
    " - [3] Hu J, Shen L, Sun G. Squeeze-and-excitation networks[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2018: 7132-7141.\n",
    " \n",
    "\n",
    "<div id=\"refer-anchor-4\"></div>\n",
    "\n",
    " - [4] He K, Zhang X, Ren S, et al. Deep residual learning for image recognition[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2016: 770-778.\n",
    " \n",
    "<div id=\"refer-anchor-5\"></div>\n",
    "\n",
    " - [5] Dosovitskiy A, Beyer L, Kolesnikov A, et al. An image is worth 16x16 words: Transformers for image recognition at scale[J]. arXiv preprint arXiv:2010.11929, 2020.\n",
    "\n",
    "<div id=\"refer-anchor-6\"></div>\n",
    "\n",
    " - [6] Mehta S, Rastegari M. Mobilevit: light-weight, general-purpose, and mobile-friendly vision transformer[J]. arXiv preprint arXiv:2110.02178, 2021\n",
    " "
   ]
  }
 ],
 "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.8.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "c10870e9c9ec14b72a9a6588c7753433b766e8163e2c78921a3e48ad9361349b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}