{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# data prepare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据集路径（这是我电脑上的，使用时也需要修改）\n",
    "path = r'/hy-tmp/Enderfga/plant_dataset/val' \n",
    "# 读取csv中的label\n",
    "import pandas as pd\n",
    "df = pd.read_csv(path+'/val'+'_label.csv')\n",
    "label = df['labels'].unique()\n",
    "# 给每一种label创建文件夹，若已存在则跳过\n",
    "import os\n",
    "for i in df['labels'].unique():\n",
    "    if not os.path.exists(path+'/'+i):\n",
    "        os.makedirs(path+'/'+i)\n",
    "# 将图片移动到对应的文件夹中\n",
    "import shutil\n",
    "for i in range(len(df)):\n",
    "    shutil.copy(path+'/images/'+df['images'][i],path+'/'+df['labels'][i]+'/'+df['images'][i])\n",
    "# 注意 这里用的是copy不是move，原来的图片还都保存在images文件夹中，训练前需要移走"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把scab，scab frog_eye_leaf_spot，scab frog_eye_leaf_spot complex归为scab类\n",
    "# 把rust，rust complex，rust frog_eye_leaf_spot归为rust类\n",
    "# 把powdery_mildew，powdery_mildew complex归为powdery_mildew类\n",
    "# 把frog_eye_leaf_spot，frog_eye_leaf_spot complex归为frog_eye_leaf_spot类\n",
    "path = r'/hy-tmp/Enderfga/plant_dataset/val' \n",
    "import os\n",
    "import shutil\n",
    "for i in ['scab frog_eye_leaf_spot','scab frog_eye_leaf_spot complex']:\n",
    "    if not os.path.exists(path+'/'+i):\n",
    "        continue\n",
    "    for j in os.listdir(path+'/'+i):\n",
    "        shutil.move(path+'/'+i+'/'+j,path+'/scab/'+j)\n",
    "    os.removedirs(path+'/'+i)\n",
    "for i in ['rust complex','rust frog_eye_leaf_spot']:\n",
    "    if not os.path.exists(path+'/'+i):\n",
    "        continue\n",
    "    for j in os.listdir(path+'/'+i):\n",
    "        shutil.move(path+'/'+i+'/'+j,path+'/rust/'+j)\n",
    "    os.removedirs(path+'/'+i)\n",
    "for i in ['powdery_mildew complex']:\n",
    "    if not os.path.exists(path+'/'+i):\n",
    "        continue\n",
    "    for j in os.listdir(path+'/'+i):\n",
    "        shutil.move(path+'/'+i+'/'+j,path+'/powdery_mildew/'+j)\n",
    "    os.removedirs(path+'/'+i)\n",
    "for i in ['frog_eye_leaf_spot complex']:\n",
    "    if not os.path.exists(path+'/'+i):\n",
    "        continue\n",
    "    for j in os.listdir(path+'/'+i):\n",
    "        shutil.move(path+'/'+i+'/'+j,path+'/frog_eye_leaf_spot/'+j)\n",
    "    os.removedirs(path+'/'+i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mindspore提供的train函数不使用验证集\n",
    "# 所以需要将验证集中的图片移动到训练集中\n",
    "import os\n",
    "import shutil\n",
    "val_path = r'/hy-tmp/Enderfga/plant_dataset/val'\n",
    "train_path = r'/hy-tmp/Enderfga/plant_dataset/train'\n",
    "for i in os.listdir(val_path):\n",
    "    for j in os.listdir(val_path+'/'+i):\n",
    "        shutil.move(val_path+'/'+i+'/'+j,train_path+'/'+i+'/'+j)\n",
    "    os.removedirs(val_path+'/'+i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Create dataset.\"\"\"\n",
    "import os\n",
    "import mindspore.common.dtype as mstype\n",
    "import mindspore.dataset.engine as de\n",
    "import mindspore.dataset.vision as C\n",
    "import mindspore.dataset.transforms as C2\n",
    "import mindspore.dataset as das\n",
    "\n",
    "device_id = 0\n",
    "device_num = 1\n",
    "\n",
    "\n",
    "def create_dataset(dataset_path, spilt, repeat_num=1, batch_size=32,num_classes=12):\n",
    "\n",
    "    \"\"\"\n",
    "    Create a train or eval dataset.\n",
    "\n",
    "    Args:\n",
    "        dataset_path (str): The path of dataset.\n",
    "        spilt (str): Whether dataset is used for train or eval.\n",
    "        repeat_num (int): The repeat times of dataset. Default: 1.\n",
    "        batch_size (int): The batch size of dataset. Default: 32.\n",
    "\n",
    "    Returns:\n",
    "        Dataset.\n",
    "    \"\"\"\n",
    "    if spilt == 'train':\n",
    "        dataset_path = os.path.join(dataset_path, 'train')\n",
    "        do_shuffle = True\n",
    "    elif spilt == 'val':\n",
    "        dataset_path = os.path.join(dataset_path, 'val')\n",
    "        do_shuffle = False\n",
    "    else:\n",
    "        dataset_path = os.path.join(dataset_path, 'test')\n",
    "        do_shuffle = False\n",
    "\n",
    "    if device_num == 1 :\n",
    "        ds = das.ImageFolderDataset(dataset_path,num_parallel_workers=8, shuffle=do_shuffle,decode=True)\n",
    "    else:\n",
    "       ds = das.ImageFolderDataset(dataset_path,num_parallel_workers=8, shuffle=do_shuffle, num_shards=device_num, shard_id=device_id,decode=True)\n",
    "\n",
    "    resize_height = 224\n",
    "    resize_width = 224\n",
    "    buffer_size = 100\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "\n",
    "    # define map operations\n",
    "    #random_crop_op = C.RandomCrop((32, 32), (4, 4, 4, 4))\n",
    "    random_horizontal_flip_op = C.RandomHorizontalFlip(device_id / (device_id + 1))\n",
    "\n",
    "    resize_op = C.Resize((resize_height, resize_width))\n",
    "    rescale_op = C.Rescale(rescale, shift)\n",
    "    normalize_op = C.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])\n",
    "\n",
    "    change_swap_op = C.HWC2CHW()\n",
    "\n",
    "    trans = []\n",
    "    if spilt == 'train':\n",
    "        trans += [ random_horizontal_flip_op]\n",
    "    type_op = C2.TypeCast(mstype.float32)\n",
    "    trans += [resize_op, rescale_op, normalize_op, change_swap_op,type_op]\n",
    "\n",
    "\n",
    "    Onehot_op = C2.OneHot(num_classes) #SoftmaxCrossEntropyWithLogits不能用onehot编码\n",
    "    type_cast_op = C2.TypeCast(mstype.int32)\n",
    "    \n",
    "    \n",
    "\n",
    "    ds = ds.map(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=8)\n",
    "    ds = ds.map(operations=trans, input_columns=\"image\", num_parallel_workers=8)\n",
    "\n",
    "    # apply batch operations\n",
    "    ds = ds.batch(batch_size, drop_remainder=True)\n",
    "\n",
    "    # apply dataset repeat operation\n",
    "    ds = ds.repeat(repeat_num)\n",
    "    return ds\n",
    "\n",
    "batch_size = 32                     # 每批次大小\n",
    "eval_per_epoch = 2                  # 检查精度的轮次间隔\n",
    "epoch_size = 50                     # 轮次数量\n",
    "dataset_path = r'/hy-tmp/Enderfga/plant_dataset'\n",
    "ds_train = create_dataset(dataset_path, 'train', batch_size=batch_size)\n",
    "ds_test = create_dataset(dataset_path, 'test', batch_size=batch_size)\n",
    "Training_size = ds_train.get_dataset_size()*batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Pipeline.\"\"\"\n",
    "import mindspore as ms\n",
    "from mindspore import nn\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor\n",
    "from mindspore.train.callback import Callback\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "class EvalCallBack(Callback):\n",
    "    def __init__(self, model, eval_dataset, eval_per_epoch, epoch_per_eval):\n",
    "        self.model = model\n",
    "        self.eval_dataset = eval_dataset\n",
    "        self.eval_per_epoch = eval_per_epoch\n",
    "        self.epoch_per_eval = epoch_per_eval\n",
    " \n",
    " \n",
    "    def on_train_epoch_end(self, run_context):\n",
    "        cb_param = run_context.original_args()\n",
    "        cur_epoch = cb_param.cur_epoch_num\n",
    "        if cur_epoch % self.eval_per_epoch == 0:\n",
    "            acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)\n",
    "            self.epoch_per_eval[\"epoch\"].append(cur_epoch)\n",
    "            self.epoch_per_eval[\"acc\"].append(acc[\"Accuracy\"])\n",
    "            print(acc)\n",
    "def eval_show(epoch_per_eval,net_name):\n",
    "    plt.xlabel(\"epoch number\")\n",
    "    plt.ylabel(\"Model accuracy\")\n",
    "    plt.title(\"Model accuracy variation chart\")\n",
    "    plt.plot(epoch_per_eval[\"epoch\"], epoch_per_eval[\"acc\"], \"red\")\n",
    "    plt.savefig(net_name+'acc.png')\n",
    "    plt.show()\n",
    "def process(network,net_name, ds_train, ds_test, epoch):\n",
    "\n",
    "    \n",
    "    status = \"train\"\n",
    "    print(\"=============== 来到训练过程 ==============\")\n",
    "    # 返回当前设备\n",
    "    device_target = ms.context.get_context('device_target')\n",
    "    print(\"当前设备为: {}\".format(device_target))\n",
    "    # 确定图模型是否下沉到芯片上\n",
    "    dataset_sink_mode = True if device_target in ['Ascend', 'GPU'] else False\n",
    "\n",
    "    # 设置模型的设备与图的模式\n",
    "    ms.context.set_context(mode=ms.context.GRAPH_MODE, device_target=device_target)\n",
    "    # 使用交叉熵函数作为损失函数\n",
    "    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "    # 优化器\n",
    "    net_opt = nn.Momentum(filter(lambda x: x.requires_grad, network.get_parameters()), learning_rate=0.001, momentum=0.9)\n",
    "\n",
    "    # 建立可训练模型\n",
    "    model = ms.Model(network=network, loss_fn=net_loss, optimizer=net_opt, metrics={\"Accuracy\": nn.Accuracy()})\n",
    "\n",
    "    # 设置CheckpointConfig，callback函数。save_checkpoint_steps=训练总数/batch_size\n",
    "    ckp_config = CheckpointConfig(save_checkpoint_steps=int(Training_size / batch_size) * eval_per_epoch, keep_checkpoint_max=10)\n",
    "    ckp_cb = ModelCheckpoint(prefix=\"checkpoint_{}_verified\".format(net_name), directory='results/'+net_name, config=ckp_config)\n",
    "    # 监控每个epoch训练的时间\n",
    "    time_cb = TimeMonitor(int(Training_size / batch_size))\n",
    "    # 监控每次打印时的loss值\n",
    "    loss_cb = LossMonitor(int(Training_size / batch_size))\n",
    "    # 监控每个epoch的验证集准确率\n",
    "    epoch_per_eval = {\"epoch\": [], \"acc\": []}  # 方便最后打印精度曲线\n",
    "    eval_cb = EvalCallBack(model, ds_train, eval_per_epoch, epoch_per_eval)\n",
    "    \n",
    "\n",
    "    print(\"============== 开始训练 ==============\")\n",
    "    model.train(epoch, ds_train, callbacks=[ckp_cb, loss_cb, time_cb,eval_cb], dataset_sink_mode=dataset_sink_mode)\n",
    "    print(\"============== 训练结束 ==============\")\n",
    "# -----------------------------------------------------------------------------------------------------------------------\n",
    "    \n",
    "    status = \"test\"\n",
    "    print(\"============== 开始测试 ==============\")\n",
    "    res = model.eval(ds_test, dataset_sink_mode=dataset_sink_mode)\n",
    "    \n",
    "    # 评估测试集\n",
    "    print('测试结果:', res)\n",
    "    eval_show(epoch_per_eval,net_name)\n",
    "    print(\"============== 测试结束 ==============\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LeNet5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== 来到训练过程 ==============\n",
      "当前设备为: GPU\n",
      "============== 开始训练 ==============\n",
      "epoch: 1 step: 112, loss is 2.3923087120056152\n",
      "Train epoch time: 182194.443 ms, per step time: 1626.736 ms\n",
      "epoch: 2 step: 112, loss is 2.2964911460876465\n",
      "Train epoch time: 148214.466 ms, per step time: 1323.343 ms\n",
      "{'Accuracy': 0.25474330357142855}\n",
      "epoch: 3 step: 112, loss is 2.256774663925171\n",
      "Train epoch time: 28953.101 ms, per step time: 258.510 ms\n",
      "epoch: 4 step: 112, loss is 2.2147865295410156\n",
      "Train epoch time: 145790.588 ms, per step time: 1301.702 ms\n",
      "{'Accuracy': 0.25474330357142855}\n",
      "epoch: 5 step: 112, loss is 2.0852854251861572\n",
      "Train epoch time: 30397.486 ms, per step time: 271.406 ms\n",
      "epoch: 6 step: 112, loss is 2.0441372394561768\n",
      "Train epoch time: 152315.356 ms, per step time: 1359.959 ms\n",
      "{'Accuracy': 0.25558035714285715}\n",
      "epoch: 7 step: 112, loss is 1.9879432916641235\n",
      "Train epoch time: 27582.388 ms, per step time: 246.271 ms\n",
      "epoch: 8 step: 112, loss is 2.0498454570770264\n",
      "Train epoch time: 145395.372 ms, per step time: 1298.173 ms\n",
      "{'Accuracy': 0.2553013392857143}\n",
      "epoch: 9 step: 112, loss is 2.074831962585449\n",
      "Train epoch time: 26086.590 ms, per step time: 232.916 ms\n",
      "epoch: 10 step: 112, loss is 1.9922101497650146\n",
      "Train epoch time: 145197.942 ms, per step time: 1296.410 ms\n",
      "{'Accuracy': 0.25558035714285715}\n",
      "epoch: 11 step: 112, loss is 2.0222363471984863\n",
      "Train epoch time: 28118.570 ms, per step time: 251.059 ms\n",
      "epoch: 12 step: 112, loss is 2.1611921787261963\n",
      "Train epoch time: 143891.471 ms, per step time: 1284.745 ms\n",
      "{'Accuracy': 0.255859375}\n",
      "epoch: 13 step: 112, loss is 1.9237799644470215\n",
      "Train epoch time: 28091.744 ms, per step time: 250.819 ms\n",
      "epoch: 14 step: 112, loss is 1.8097776174545288\n",
      "Train epoch time: 142901.677 ms, per step time: 1275.908 ms\n",
      "{'Accuracy': 0.2544642857142857}\n",
      "epoch: 15 step: 112, loss is 1.9593663215637207\n",
      "Train epoch time: 27326.008 ms, per step time: 243.982 ms\n",
      "epoch: 16 step: 112, loss is 1.9631072282791138\n",
      "Train epoch time: 141105.665 ms, per step time: 1259.872 ms\n",
      "{'Accuracy': 0.2544642857142857}\n",
      "epoch: 17 step: 112, loss is 1.8579509258270264\n",
      "Train epoch time: 26126.683 ms, per step time: 233.274 ms\n",
      "epoch: 18 step: 112, loss is 1.895508050918579\n",
      "Train epoch time: 151991.754 ms, per step time: 1357.069 ms\n",
      "{'Accuracy': 0.25502232142857145}\n",
      "epoch: 19 step: 112, loss is 2.0610527992248535\n",
      "Train epoch time: 28396.431 ms, per step time: 253.540 ms\n",
      "epoch: 20 step: 112, loss is 1.996309757232666\n",
      "Train epoch time: 144504.890 ms, per step time: 1290.222 ms\n",
      "{'Accuracy': 0.2553013392857143}\n",
      "epoch: 21 step: 112, loss is 1.8752323389053345\n",
      "Train epoch time: 26726.589 ms, per step time: 238.630 ms\n",
      "epoch: 22 step: 112, loss is 1.955612301826477\n",
      "Train epoch time: 143594.190 ms, per step time: 1282.091 ms\n",
      "{'Accuracy': 0.25418526785714285}\n",
      "epoch: 23 step: 112, loss is 2.0152273178100586\n",
      "Train epoch time: 27723.617 ms, per step time: 247.532 ms\n",
      "epoch: 24 step: 112, loss is 2.015843152999878\n",
      "Train epoch time: 141709.362 ms, per step time: 1265.262 ms\n",
      "{'Accuracy': 0.2544642857142857}\n",
      "epoch: 25 step: 112, loss is 2.081289291381836\n",
      "Train epoch time: 27900.819 ms, per step time: 249.114 ms\n",
      "epoch: 26 step: 112, loss is 1.870562195777893\n",
      "Train epoch time: 142583.823 ms, per step time: 1273.070 ms\n",
      "{'Accuracy': 0.25502232142857145}\n",
      "epoch: 27 step: 112, loss is 1.779657006263733\n",
      "Train epoch time: 25572.999 ms, per step time: 228.330 ms\n",
      "epoch: 28 step: 112, loss is 2.0299739837646484\n",
      "Train epoch time: 140914.667 ms, per step time: 1258.167 ms\n",
      "{'Accuracy': 0.2544642857142857}\n",
      "epoch: 29 step: 112, loss is 2.0083084106445312\n",
      "Train epoch time: 27742.028 ms, per step time: 247.697 ms\n",
      "epoch: 30 step: 112, loss is 1.9279289245605469\n",
      "Train epoch time: 149241.799 ms, per step time: 1332.516 ms\n",
      "{'Accuracy': 0.25502232142857145}\n",
      "============== 训练结束 ==============\n",
      "============== 开始测试 ==============\n",
      "测试结果: {'Accuracy': 0.010416666666666666}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== 测试结束 ==============\n"
     ]
    }
   ],
   "source": [
    "import mindspore.nn as nn\n",
    "class LeNet5(nn.Cell):\n",
    "    \"\"\"\n",
    "    LeNet-5网络结构\n",
    "    \"\"\"\n",
    "    def __init__(self, num_class=12, num_channel=3):\n",
    "        super(LeNet5, self).__init__()\n",
    "        # 卷积层，输入的通道数为num_channel，输出的通道数为6，卷积核大小为5*5\n",
    "        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n",
    "        # 卷积层，输入的通道数为6，输出的通道数为16，卷积核大小为5*5\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n",
    "        # 全连接层，输入个数为16*5*5，输出个数为120\n",
    "        self.fc1 = nn.Dense(16 * 5 * 5, 120)\n",
    "        # 全连接层，输入个数为120，输出个数为84\n",
    "        self.fc2 = nn.Dense(120, 84)\n",
    "        # 全连接层，输入个数为84，分类的个数为num_class\n",
    "        self.fc3 = nn.Dense(84, num_class)\n",
    "        # ReLU激活函数\n",
    "        self.relu = nn.ReLU()\n",
    "        # 池化层\n",
    "        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        # 多维数组展平为一维数组\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "    def construct(self, x):\n",
    "        # 使用定义好的运算构建前向网络\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "# 图片resize为32*32\n",
    "network = LeNet5(num_class=12)\n",
    "process(network,'lenet5', ds_train, ds_test, epoch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vgg16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== 来到训练过程 ==============\n",
      "当前设备为: GPU\n",
      "============== 开始训练 ==============\n",
      "epoch: 1 step: 112, loss is 2.5148966312408447\n",
      "Train epoch time: 167241.798 ms, per step time: 1493.230 ms\n",
      "epoch: 2 step: 112, loss is 2.0780904293060303\n",
      "Train epoch time: 158824.783 ms, per step time: 1418.078 ms\n",
      "{'Accuracy': 0.29073660714285715}\n",
      "epoch: 3 step: 112, loss is 2.173339605331421\n",
      "Train epoch time: 32213.806 ms, per step time: 287.623 ms\n",
      "epoch: 4 step: 112, loss is 1.9137698411941528\n",
      "Train epoch time: 155298.556 ms, per step time: 1386.594 ms\n",
      "{'Accuracy': 0.302734375}\n",
      "epoch: 5 step: 112, loss is 2.365485191345215\n",
      "Train epoch time: 31993.538 ms, per step time: 285.657 ms\n",
      "epoch: 6 step: 112, loss is 2.0239381790161133\n",
      "Train epoch time: 156794.618 ms, per step time: 1399.952 ms\n",
      "{'Accuracy': 0.2935267857142857}\n",
      "epoch: 7 step: 112, loss is 1.9226138591766357\n",
      "Train epoch time: 30756.538 ms, per step time: 274.612 ms\n",
      "epoch: 8 step: 112, loss is 2.0665833950042725\n",
      "Train epoch time: 154979.074 ms, per step time: 1383.742 ms\n",
      "{'Accuracy': 0.30831473214285715}\n",
      "epoch: 9 step: 112, loss is 1.8531365394592285\n",
      "Train epoch time: 30899.231 ms, per step time: 275.886 ms\n",
      "epoch: 10 step: 112, loss is 1.9292842149734497\n",
      "Train epoch time: 153812.822 ms, per step time: 1373.329 ms\n",
      "{'Accuracy': 0.31863839285714285}\n",
      "epoch: 11 step: 112, loss is 1.9502143859863281\n",
      "Train epoch time: 32763.409 ms, per step time: 292.530 ms\n",
      "epoch: 12 step: 112, loss is 1.9230560064315796\n",
      "Train epoch time: 152498.579 ms, per step time: 1361.594 ms\n",
      "{'Accuracy': 0.3158482142857143}\n",
      "epoch: 13 step: 112, loss is 1.8686610460281372\n",
      "Train epoch time: 31112.193 ms, per step time: 277.787 ms\n",
      "epoch: 14 step: 112, loss is 1.944849967956543\n",
      "Train epoch time: 157414.340 ms, per step time: 1405.485 ms\n",
      "{'Accuracy': 0.32003348214285715}\n",
      "epoch: 15 step: 112, loss is 1.8614004850387573\n",
      "Train epoch time: 30500.947 ms, per step time: 272.330 ms\n",
      "epoch: 16 step: 112, loss is 1.7658277750015259\n",
      "Train epoch time: 153615.556 ms, per step time: 1371.567 ms\n",
      "{'Accuracy': 0.3091517857142857}\n",
      "epoch: 17 step: 112, loss is 1.6396090984344482\n",
      "Train epoch time: 32069.498 ms, per step time: 286.335 ms\n",
      "epoch: 18 step: 112, loss is 1.8042677640914917\n",
      "Train epoch time: 157409.459 ms, per step time: 1405.442 ms\n",
      "{'Accuracy': 0.32505580357142855}\n",
      "epoch: 19 step: 112, loss is 2.1337735652923584\n",
      "Train epoch time: 30735.614 ms, per step time: 274.425 ms\n",
      "epoch: 20 step: 112, loss is 1.981469988822937\n",
      "Train epoch time: 157619.973 ms, per step time: 1407.321 ms\n",
      "{'Accuracy': 0.32728794642857145}\n",
      "epoch: 21 step: 112, loss is 2.065399646759033\n",
      "Train epoch time: 30832.916 ms, per step time: 275.294 ms\n",
      "epoch: 22 step: 112, loss is 1.9327666759490967\n",
      "Train epoch time: 152402.770 ms, per step time: 1360.739 ms\n",
      "{'Accuracy': 0.3325892857142857}\n",
      "epoch: 23 step: 112, loss is 1.950724720954895\n",
      "Train epoch time: 29999.344 ms, per step time: 267.851 ms\n",
      "epoch: 24 step: 112, loss is 1.9081926345825195\n",
      "Train epoch time: 159534.206 ms, per step time: 1424.413 ms\n",
      "{'Accuracy': 0.326171875}\n",
      "epoch: 25 step: 112, loss is 1.9981718063354492\n",
      "Train epoch time: 31291.907 ms, per step time: 279.392 ms\n",
      "epoch: 26 step: 112, loss is 1.9115060567855835\n",
      "Train epoch time: 155912.349 ms, per step time: 1392.075 ms\n",
      "{'Accuracy': 0.32840401785714285}\n",
      "epoch: 27 step: 112, loss is 1.7553311586380005\n",
      "Train epoch time: 30715.328 ms, per step time: 274.244 ms\n",
      "epoch: 28 step: 112, loss is 1.9103162288665771\n",
      "Train epoch time: 160238.079 ms, per step time: 1430.697 ms\n",
      "{'Accuracy': 0.33621651785714285}\n",
      "epoch: 29 step: 112, loss is 1.6885271072387695\n",
      "Train epoch time: 30673.425 ms, per step time: 273.870 ms\n",
      "epoch: 30 step: 112, loss is 1.5539753437042236\n",
      "Train epoch time: 151859.171 ms, per step time: 1355.885 ms\n",
      "{'Accuracy': 0.33370535714285715}\n",
      "============== 训练结束 ==============\n",
      "============== 开始测试 ==============\n",
      "测试结果: {'Accuracy': 0.08854166666666667}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== 测试结束 ==============\n"
     ]
    }
   ],
   "source": [
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import initializer\n",
    "import mindspore.common.dtype as mstype\n",
    "import mindspore\n",
    "\n",
    "\n",
    "def _make_layer(base, batch_norm):\n",
    "    \"\"\"Make stage network of VGG.\"\"\"\n",
    "    layers = []\n",
    "    in_channels = 3\n",
    "    for v in base:\n",
    "        if v == 'M':\n",
    "            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n",
    "        else:\n",
    "            weight = 'ones'\n",
    "            # if args.initialize_mode == \"XavierUniform\":\n",
    "            # weight_shape = (v, in_channels, 3, 3)\n",
    "            # weight = initializer('XavierUniform', shape=weight_shape, dtype=mindspore.float32)\n",
    "\n",
    "            conv2d = nn.Conv2d(in_channels=in_channels,\n",
    "                               out_channels=v,\n",
    "                               kernel_size=3,\n",
    "                               padding=1,\n",
    "                               pad_mode='pad',\n",
    "                               has_bias=False,\n",
    "                               weight_init=weight)\n",
    "            if batch_norm:\n",
    "                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU()]\n",
    "            else:\n",
    "                layers += [conv2d, nn.ReLU()]\n",
    "            in_channels = v\n",
    "    return nn.SequentialCell(layers)\n",
    "\n",
    "\n",
    "class Vgg(nn.Cell):\n",
    "    \"\"\"\n",
    "    VGG network definition.\n",
    "    Args:\n",
    "        base (list): Configuration for different layers, mainly the channel number of Conv layer.\n",
    "        num_classes (int): Class numbers. Default: 1000.\n",
    "        batch_norm (bool): Whether to do the batchnorm. Default: False.\n",
    "        batch_size (int): Batch size. Default: 1.\n",
    "        include_top(bool): Whether to include the 3 fully-connected layers at the top of the network. Default: True.\n",
    "    Returns:\n",
    "        Tensor, infer output tensor.\n",
    "    Examples:\n",
    "        >>> Vgg([64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],\n",
    "        >>>     num_classes=1000, batch_norm=False, batch_size=1)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, base, num_classes=1000, batch_norm=True, phase=\"train\", include_top=True):\n",
    "        super(Vgg, self).__init__()\n",
    "        self.layers = _make_layer(base, batch_norm=batch_norm)\n",
    "        self.include_top = include_top\n",
    "        self.flatten = nn.Flatten()\n",
    "        dropout_ratio = 0.5\n",
    "        has_dropout = True\n",
    "        if not has_dropout or phase == \"test\":\n",
    "            dropout_ratio = 1.0\n",
    "        self.classifier = nn.SequentialCell([\n",
    "            nn.Dense(512 * 7 * 7, 4096),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(dropout_ratio),\n",
    "            nn.Dense(4096, 4096),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(dropout_ratio),\n",
    "            nn.Dense(4096, num_classes)])\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.layers(x)\n",
    "        if self.include_top:\n",
    "            x = self.flatten(x)\n",
    "            x = self.classifier(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "cfg = {\n",
    "    '11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n",
    "    '13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n",
    "    '16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],\n",
    "    '19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],\n",
    "}\n",
    "\n",
    "net = Vgg(cfg['16'], num_classes=12, batch_norm=True, phase=\"train\", include_top=True)\n",
    "process(net,'vgg16', ds_train, ds_test, epoch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ResNet50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== 来到训练过程 ==============\n",
      "当前设备为: GPU\n",
      "============== 开始训练 ==============\n",
      "epoch: 1 step: 112, loss is 1.3805581331253052\n",
      "Train epoch time: 161704.724 ms, per step time: 1443.792 ms\n",
      "epoch: 2 step: 112, loss is 1.407403826713562\n",
      "Train epoch time: 146276.430 ms, per step time: 1306.040 ms\n",
      "{'Accuracy': 0.42940848214285715}\n",
      "epoch: 3 step: 112, loss is 1.555513620376587\n",
      "Train epoch time: 30893.225 ms, per step time: 275.832 ms\n",
      "epoch: 4 step: 112, loss is 1.0754059553146362\n",
      "Train epoch time: 144288.920 ms, per step time: 1288.294 ms\n",
      "{'Accuracy': 0.45619419642857145}\n",
      "epoch: 5 step: 112, loss is 1.419057011604309\n",
      "Train epoch time: 30626.357 ms, per step time: 273.450 ms\n",
      "epoch: 6 step: 112, loss is 1.3742318153381348\n",
      "Train epoch time: 146417.694 ms, per step time: 1307.301 ms\n",
      "{'Accuracy': 0.43833705357142855}\n",
      "epoch: 7 step: 112, loss is 1.2259702682495117\n",
      "Train epoch time: 29825.494 ms, per step time: 266.299 ms\n",
      "epoch: 8 step: 112, loss is 1.2132371664047241\n",
      "Train epoch time: 145225.064 ms, per step time: 1296.652 ms\n",
      "{'Accuracy': 0.5309709821428571}\n",
      "epoch: 9 step: 112, loss is 1.419845700263977\n",
      "Train epoch time: 29616.257 ms, per step time: 264.431 ms\n",
      "epoch: 10 step: 112, loss is 1.2148149013519287\n",
      "Train epoch time: 147011.488 ms, per step time: 1312.603 ms\n",
      "{'Accuracy': 0.6261160714285714}\n",
      "epoch: 11 step: 112, loss is 1.286866545677185\n",
      "Train epoch time: 30347.289 ms, per step time: 270.958 ms\n",
      "epoch: 12 step: 112, loss is 1.5387418270111084\n",
      "Train epoch time: 147503.083 ms, per step time: 1316.992 ms\n",
      "{'Accuracy': 0.6618303571428571}\n",
      "epoch: 13 step: 112, loss is 1.7815543413162231\n",
      "Train epoch time: 33465.960 ms, per step time: 298.803 ms\n",
      "epoch: 14 step: 112, loss is 1.4701341390609741\n",
      "Train epoch time: 147518.894 ms, per step time: 1317.133 ms\n",
      "{'Accuracy': 0.5965401785714286}\n",
      "epoch: 15 step: 112, loss is 0.799081563949585\n",
      "Train epoch time: 29815.295 ms, per step time: 266.208 ms\n",
      "epoch: 16 step: 112, loss is 1.2581506967544556\n",
      "Train epoch time: 148621.075 ms, per step time: 1326.974 ms\n",
      "{'Accuracy': 0.7661830357142857}\n",
      "epoch: 17 step: 112, loss is 0.7141536474227905\n",
      "Train epoch time: 29413.316 ms, per step time: 262.619 ms\n",
      "epoch: 18 step: 112, loss is 0.6939231157302856\n",
      "Train epoch time: 145807.322 ms, per step time: 1301.851 ms\n",
      "{'Accuracy': 0.8565848214285714}\n",
      "epoch: 19 step: 112, loss is 0.26584726572036743\n",
      "Train epoch time: 28248.618 ms, per step time: 252.220 ms\n",
      "epoch: 20 step: 112, loss is 0.442241370677948\n",
      "Train epoch time: 146301.189 ms, per step time: 1306.261 ms\n",
      "{'Accuracy': 0.91796875}\n",
      "epoch: 21 step: 112, loss is 0.2749621272087097\n",
      "Train epoch time: 30414.351 ms, per step time: 271.557 ms\n",
      "epoch: 22 step: 112, loss is 0.24993960559368134\n",
      "Train epoch time: 150109.010 ms, per step time: 1340.259 ms\n",
      "{'Accuracy': 0.9324776785714286}\n",
      "epoch: 23 step: 112, loss is 0.12948472797870636\n",
      "Train epoch time: 34088.687 ms, per step time: 304.363 ms\n",
      "epoch: 24 step: 112, loss is 0.11195835471153259\n",
      "Train epoch time: 172009.710 ms, per step time: 1535.801 ms\n",
      "{'Accuracy': 0.9347098214285714}\n",
      "epoch: 25 step: 112, loss is 0.18433399498462677\n",
      "Train epoch time: 28205.726 ms, per step time: 251.837 ms\n",
      "epoch: 26 step: 112, loss is 0.03422930836677551\n",
      "Train epoch time: 150904.179 ms, per step time: 1347.359 ms\n",
      "{'Accuracy': 0.9885602678571429}\n",
      "epoch: 27 step: 112, loss is 0.015233147889375687\n",
      "Train epoch time: 32119.834 ms, per step time: 286.784 ms\n",
      "epoch: 28 step: 112, loss is 0.12897279858589172\n",
      "Train epoch time: 281100.178 ms, per step time: 2509.823 ms\n",
      "{'Accuracy': 0.9983258928571429}\n",
      "epoch: 29 step: 112, loss is 0.025019073858857155\n",
      "Train epoch time: 36158.706 ms, per step time: 322.846 ms\n",
      "epoch: 30 step: 112, loss is 0.00998919177800417\n",
      "Train epoch time: 199523.240 ms, per step time: 1781.458 ms\n",
      "{'Accuracy': 0.9991629464285714}\n",
      "epoch: 31 step: 112, loss is 0.0035294394474476576\n",
      "Train epoch time: 37098.202 ms, per step time: 331.234 ms\n",
      "epoch: 32 step: 112, loss is 0.008417782373726368\n",
      "Train epoch time: 258200.134 ms, per step time: 2305.358 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 33 step: 112, loss is 0.0030750439036637545\n",
      "Train epoch time: 29954.420 ms, per step time: 267.450 ms\n",
      "epoch: 34 step: 112, loss is 0.0033342011738568544\n",
      "Train epoch time: 146088.744 ms, per step time: 1304.364 ms\n",
      "{'Accuracy': 0.9991629464285714}\n",
      "epoch: 35 step: 112, loss is 0.04989391565322876\n",
      "Train epoch time: 28912.660 ms, per step time: 258.149 ms\n",
      "epoch: 36 step: 112, loss is 0.002936761127784848\n",
      "Train epoch time: 152900.732 ms, per step time: 1365.185 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 37 step: 112, loss is 0.00867350772023201\n",
      "Train epoch time: 30514.711 ms, per step time: 272.453 ms\n",
      "epoch: 38 step: 112, loss is 0.013944489881396294\n",
      "Train epoch time: 169287.993 ms, per step time: 1511.500 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 39 step: 112, loss is 0.0013053450966253877\n",
      "Train epoch time: 31936.190 ms, per step time: 285.145 ms\n",
      "epoch: 40 step: 112, loss is 0.011352192610502243\n",
      "Train epoch time: 144799.657 ms, per step time: 1292.854 ms\n",
      "{'Accuracy': 0.998046875}\n",
      "epoch: 41 step: 112, loss is 0.013285499997437\n",
      "Train epoch time: 29841.447 ms, per step time: 266.441 ms\n",
      "epoch: 42 step: 112, loss is 0.0022445570211857557\n",
      "Train epoch time: 151882.290 ms, per step time: 1356.092 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 43 step: 112, loss is 0.0014307014644145966\n",
      "Train epoch time: 31009.284 ms, per step time: 276.869 ms\n",
      "epoch: 44 step: 112, loss is 0.013306794688105583\n",
      "Train epoch time: 146819.707 ms, per step time: 1310.890 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 45 step: 112, loss is 0.003126951167359948\n",
      "Train epoch time: 32617.732 ms, per step time: 291.230 ms\n",
      "epoch: 46 step: 112, loss is 0.0006828579353168607\n",
      "Train epoch time: 146809.759 ms, per step time: 1310.801 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 47 step: 112, loss is 0.16203805804252625\n",
      "Train epoch time: 30745.761 ms, per step time: 274.516 ms\n",
      "epoch: 48 step: 112, loss is 0.0006309582386165857\n",
      "Train epoch time: 144498.285 ms, per step time: 1290.163 ms\n",
      "{'Accuracy': 0.9994419642857143}\n",
      "epoch: 49 step: 112, loss is 0.001286874758079648\n",
      "Train epoch time: 39249.295 ms, per step time: 350.440 ms\n",
      "epoch: 50 step: 112, loss is 0.00961524248123169\n",
      "Train epoch time: 185011.056 ms, per step time: 1651.884 ms\n",
      "{'Accuracy': 0.9991629464285714}\n",
      "============== 训练结束 ==============\n",
      "============== 开始测试 ==============\n",
      "测试结果: {'Accuracy': 0.3350694444444444}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== 测试结束 ==============\n"
     ]
    }
   ],
   "source": [
    "from mindvision.classification.models import resnet50\n",
    "# 图片resize为224*224\n",
    "net = resnet50(num_classes=12)\n",
    "process(net, 'resnet50', ds_train, ds_test, epoch_size)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vision Transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== 来到训练过程 ==============\n",
      "当前设备为: GPU\n",
      "============== 开始训练 ==============\n",
      "epoch: 1 step: 112, loss is 2.364872694015503\n",
      "Train epoch time: 250624.843 ms, per step time: 2237.722 ms\n",
      "epoch: 2 step: 112, loss is 1.7558811902999878\n",
      "Train epoch time: 162311.998 ms, per step time: 1449.214 ms\n",
      "{'Accuracy': 0.2845982142857143}\n",
      "epoch: 3 step: 112, loss is 1.8237632513046265\n",
      "Train epoch time: 34133.316 ms, per step time: 304.762 ms\n",
      "epoch: 4 step: 112, loss is 1.8459337949752808\n",
      "Train epoch time: 159435.267 ms, per step time: 1423.529 ms\n",
      "{'Accuracy': 0.30440848214285715}\n",
      "epoch: 5 step: 112, loss is 1.4525882005691528\n",
      "Train epoch time: 33851.389 ms, per step time: 302.245 ms\n",
      "epoch: 6 step: 112, loss is 1.3554213047027588\n",
      "Train epoch time: 152305.747 ms, per step time: 1359.873 ms\n",
      "{'Accuracy': 0.318359375}\n",
      "epoch: 7 step: 112, loss is 1.804255723953247\n",
      "Train epoch time: 33893.695 ms, per step time: 302.622 ms\n",
      "epoch: 8 step: 112, loss is 1.6409599781036377\n",
      "Train epoch time: 150991.157 ms, per step time: 1348.135 ms\n",
      "{'Accuracy': 0.27232142857142855}\n",
      "epoch: 9 step: 112, loss is 1.6442686319351196\n",
      "Train epoch time: 33956.994 ms, per step time: 303.187 ms\n",
      "epoch: 10 step: 112, loss is 1.63052237033844\n",
      "Train epoch time: 152620.064 ms, per step time: 1362.679 ms\n",
      "{'Accuracy': 0.32254464285714285}\n",
      "epoch: 11 step: 112, loss is 1.6538642644882202\n",
      "Train epoch time: 34002.270 ms, per step time: 303.592 ms\n",
      "epoch: 12 step: 112, loss is 1.8669514656066895\n",
      "Train epoch time: 151407.556 ms, per step time: 1351.853 ms\n",
      "{'Accuracy': 0.36690848214285715}\n",
      "epoch: 13 step: 112, loss is 1.8686379194259644\n",
      "Train epoch time: 34049.203 ms, per step time: 304.011 ms\n",
      "epoch: 14 step: 112, loss is 1.5106415748596191\n",
      "Train epoch time: 152917.727 ms, per step time: 1365.337 ms\n",
      "{'Accuracy': 0.33705357142857145}\n",
      "epoch: 15 step: 112, loss is 1.8452328443527222\n",
      "Train epoch time: 34020.301 ms, per step time: 303.753 ms\n",
      "epoch: 16 step: 112, loss is 1.8550208806991577\n",
      "Train epoch time: 153109.827 ms, per step time: 1367.052 ms\n",
      "{'Accuracy': 0.328125}\n",
      "epoch: 17 step: 112, loss is 1.7063195705413818\n",
      "Train epoch time: 33748.339 ms, per step time: 301.324 ms\n",
      "epoch: 18 step: 112, loss is 1.613258957862854\n",
      "Train epoch time: 154112.516 ms, per step time: 1376.005 ms\n",
      "{'Accuracy': 0.38002232142857145}\n",
      "epoch: 19 step: 112, loss is 1.7041995525360107\n",
      "Train epoch time: 33809.144 ms, per step time: 301.867 ms\n",
      "epoch: 20 step: 112, loss is 1.582168698310852\n",
      "Train epoch time: 158998.973 ms, per step time: 1419.634 ms\n",
      "{'Accuracy': 0.38560267857142855}\n",
      "epoch: 21 step: 112, loss is 1.809660792350769\n",
      "Train epoch time: 33888.836 ms, per step time: 302.579 ms\n",
      "epoch: 22 step: 112, loss is 1.5077245235443115\n",
      "Train epoch time: 153708.009 ms, per step time: 1372.393 ms\n",
      "{'Accuracy': 0.36300223214285715}\n",
      "epoch: 23 step: 112, loss is 1.7090352773666382\n",
      "Train epoch time: 34009.634 ms, per step time: 303.657 ms\n",
      "epoch: 24 step: 112, loss is 1.5475236177444458\n",
      "Train epoch time: 156615.024 ms, per step time: 1398.348 ms\n",
      "{'Accuracy': 0.34347098214285715}\n",
      "epoch: 25 step: 112, loss is 1.7868871688842773\n",
      "Train epoch time: 34021.110 ms, per step time: 303.760 ms\n",
      "epoch: 26 step: 112, loss is 1.7244008779525757\n",
      "Train epoch time: 158624.005 ms, per step time: 1416.286 ms\n",
      "{'Accuracy': 0.3911830357142857}\n",
      "epoch: 27 step: 112, loss is 1.613624095916748\n",
      "Train epoch time: 33812.412 ms, per step time: 301.897 ms\n",
      "epoch: 28 step: 112, loss is 1.5247454643249512\n",
      "Train epoch time: 155412.721 ms, per step time: 1387.614 ms\n",
      "{'Accuracy': 0.36356026785714285}\n",
      "epoch: 29 step: 112, loss is 1.8185023069381714\n",
      "Train epoch time: 34475.398 ms, per step time: 307.816 ms\n",
      "epoch: 30 step: 112, loss is 1.7269868850708008\n",
      "Train epoch time: 155309.789 ms, per step time: 1386.695 ms\n",
      "{'Accuracy': 0.37583705357142855}\n",
      "epoch: 31 step: 112, loss is 1.4232769012451172\n",
      "Train epoch time: 33642.963 ms, per step time: 300.384 ms\n",
      "epoch: 32 step: 112, loss is 1.6332200765609741\n",
      "Train epoch time: 159420.075 ms, per step time: 1423.394 ms\n",
      "{'Accuracy': 0.3950892857142857}\n",
      "epoch: 33 step: 112, loss is 1.7034509181976318\n",
      "Train epoch time: 35662.974 ms, per step time: 318.419 ms\n",
      "epoch: 34 step: 112, loss is 1.927314281463623\n",
      "Train epoch time: 158095.964 ms, per step time: 1411.571 ms\n",
      "{'Accuracy': 0.37862723214285715}\n",
      "epoch: 35 step: 112, loss is 1.6060348749160767\n",
      "Train epoch time: 33998.761 ms, per step time: 303.560 ms\n",
      "epoch: 36 step: 112, loss is 1.8134690523147583\n",
      "Train epoch time: 160016.372 ms, per step time: 1428.718 ms\n",
      "{'Accuracy': 0.40736607142857145}\n",
      "epoch: 37 step: 112, loss is 1.5226751565933228\n",
      "Train epoch time: 33913.281 ms, per step time: 302.797 ms\n",
      "epoch: 38 step: 112, loss is 1.6158429384231567\n",
      "Train epoch time: 153410.882 ms, per step time: 1369.740 ms\n",
      "{'Accuracy': 0.4068080357142857}\n",
      "epoch: 39 step: 112, loss is 1.5749843120574951\n",
      "Train epoch time: 33703.889 ms, per step time: 300.928 ms\n",
      "epoch: 40 step: 112, loss is 1.590851902961731\n",
      "Train epoch time: 155590.755 ms, per step time: 1389.203 ms\n",
      "{'Accuracy': 0.35714285714285715}\n",
      "epoch: 41 step: 112, loss is 1.6421993970870972\n",
      "Train epoch time: 33702.680 ms, per step time: 300.917 ms\n",
      "epoch: 42 step: 112, loss is 1.5972013473510742\n",
      "Train epoch time: 158128.186 ms, per step time: 1411.859 ms\n",
      "{'Accuracy': 0.41517857142857145}\n",
      "epoch: 43 step: 112, loss is 1.633280873298645\n",
      "Train epoch time: 33942.053 ms, per step time: 303.054 ms\n",
      "epoch: 44 step: 112, loss is 1.7092034816741943\n",
      "Train epoch time: 155002.995 ms, per step time: 1383.955 ms\n",
      "{'Accuracy': 0.39732142857142855}\n",
      "epoch: 45 step: 112, loss is 1.70185387134552\n",
      "Train epoch time: 34193.800 ms, per step time: 305.302 ms\n",
      "epoch: 46 step: 112, loss is 1.6865572929382324\n",
      "Train epoch time: 154628.742 ms, per step time: 1380.614 ms\n",
      "{'Accuracy': 0.44112723214285715}\n",
      "epoch: 47 step: 112, loss is 1.4661524295806885\n",
      "Train epoch time: 33629.835 ms, per step time: 300.266 ms\n",
      "epoch: 48 step: 112, loss is 1.8761814832687378\n",
      "Train epoch time: 149027.058 ms, per step time: 1330.599 ms\n",
      "{'Accuracy': 0.4321986607142857}\n",
      "epoch: 49 step: 112, loss is 1.4296462535858154\n",
      "Train epoch time: 33942.684 ms, per step time: 303.060 ms\n",
      "epoch: 50 step: 112, loss is 1.8614946603775024\n",
      "Train epoch time: 139271.116 ms, per step time: 1243.492 ms\n",
      "{'Accuracy': 0.41685267857142855}\n",
      "============== 训练结束 ==============\n",
      "============== 开始测试 ==============\n",
      "测试结果: {'Accuracy': 0.2638888888888889}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== 测试结束 ==============\n"
     ]
    }
   ],
   "source": [
    "from mindvision.classification.models import vit_l_32\n",
    "# 图片resize为224*224\n",
    "net = vit_l_32(num_classes=12)\n",
    "process(net, 'vit_l_32', ds_train, ds_test, epoch_size)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.12 ('torch')",
   "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.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c65094271e18768ba853ee00da8ef0989016e0be5b6a976cebf700525936202a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}