{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN+CTC图像文本识别\n",
    "\n",
    "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/tutorials/application/zh_cn/cv/mindspore_cnnctc.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/tutorials/application/zh_cn/cv/mindspore_cnnctc.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/master/tutorials/application/source_zh_cn/cv/cnnctc.ipynb)\n",
    "\n",
    "> 本案例当前仅支持在GPU/CPU设备上以动态图模式运行，其他设备和运行模式将在后续的版本中支持。\n",
    "\n",
    "## 模型简介\n",
    "\n",
    "### 文本识别流程介绍\n",
    "\n",
    "文本识别指从图像中识别出文本，将图像中的文字区域转化为字符信息，通常采用CNN网络从图像中提取丰富的特征信息，然后根据提取的特征信息进行识别。这里采用ResNet作为特征提取网络，采用CTC(Connectionist Temporal Classification)方法进行识别。由于每张样本的字符数量不同，字符样式不同，字体大小也不同，导致每列的输出并不一定能与每个字符一一对应，CTC提出一种不需要对齐的Loss计算方法，用于训练网络。\n",
    "\n",
    "模型实现的步骤如下：\n",
    "\n",
    "1. 通过CNN（ResNet）提取文本图片中的Feature Map；\n",
    "2. 对每张图片中的Feature Map 划分为不同的特征序列；\n",
    "3. 对每个序列进行字符分类；\n",
    "4. 使用CTC损失函数计算损失，CTC能够根据固定长度的特征序列预测非固定长度的标签。\n",
    "\n",
    "整体流程图如下：\n",
    "\n",
    "![算法流程图](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/tutorials/application/source_zh_cn/cv/images/cnnctc.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CTC方法介绍\n",
    "\n",
    "对于固定长度的输出和可变长度的标签数据，CTC提供了一种计算Loss的方法，用于训练网络参数。CTC的关键方法是预测每列的字符并通过删除重复和空白的字符将整个字符序列修改为非固定长度的字符流。步骤如下：\n",
    "\n",
    "1. 获得定长的字符序列\n",
    "\n",
    "    根据模型得到的序列在每个位置上的概率分布获得定长的字符序列。模型输出的序列$H = h_1$, . . . , $h_T$，其中$T$为序列长度，这个序列长度是固定的，$\\pi$为根据序列的概率分布得到的字符序列，其概率定义为：\n",
    "\n",
    "    $$\n",
    "    p(\\pi|H)=\\prod_{t=1}^{T}{y^t_{\\pi_t}}\n",
    "    $$\n",
    "\n",
    "    其中$y^t_{\\pi_t}$为在每个时间步$t$生成字符$\\pi_t$的概率。\n",
    "\n",
    "2. 定长的字符序列变为非固定长度序列\n",
    "\n",
    "    映射函数$M$，通过删除重复字符和空白，将$\\pi$映射到$Y$。例如，对于‘aaa-dd-d-c-d---d’，映射函数$M$将其映射为‘addcdd’，其中‘-’表示空白。\n",
    "\n",
    "3. 条件概率定义\n",
    "\n",
    "    条件概率则定义为所有能够通过映射函数$M$映射到标签字符序列$Y$上的定长字符序列$\\pi$的概率之和：\n",
    "\n",
    "    $$\n",
    "    p(Y|H)= \\displaystyle \\sum^{ }_{\\pi:M(\\pi)=Y}{P(\\pi|H)}\n",
    "    $$\n",
    "\n",
    "4. 目标函数\n",
    "\n",
    "    训练的目标是使得这个条件概率取得最大值，而且计算条件概率的过程只有加和乘操作，一定是可导的，故可以得到一个梯度来进行网络模型参数的更新，公式如下：\n",
    "\n",
    "    $$\n",
    "    p(Y|H)=- \\displaystyle \\sum^{ }_{X_i,Y_i\\in TD}{logP(Y_i|X_i)}\n",
    "    $$\n",
    "\n",
    "    $TD$表示训练数据集。\n",
    "\n",
    "5. 测试\n",
    "\n",
    "    在进行测试的时候，在每个时间步，取具有最大概率的字符，来作为预测的标签序列，公式如下：\n",
    "\n",
    "    $$\n",
    "    Y^*\\approx M(arg  max  P(\\pi|H))\n",
    "    $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ResNet网络介绍\n",
    "\n",
    "残差神经网络(ResNet)是由微软研究院的何恺明、张祥雨、任少卿、孙剑等人提出的，并在2015 年的ILSVRC（ImageNet Large Scale Visual Recognition Challenge）比赛中取得了冠军。残差神经网络的主要贡献是提出了了 “快捷连接（Shortcut Connection）”，极大的改善网络的“退化现象（Degradation）”，有效的缓解了较深的神经网络在训练过程中的梯度消失问题，从而实现更深的网络结构设计，提高了模型的精度。\n",
    "\n",
    "1. 残差网络结构\n",
    "\n",
    "    残差网络结构由两个分支构成：一个主分支，一个Shortcuts。主分支通过堆叠一系列卷积操作得到，Shortcuts从输入直接到输出，主分支得到的输出加上Shortcuts得到的输出，通过ReLU激活函数后即为残差网络最后的输出。\n",
    "\n",
    "    这里使用的残差网络结构，主分支有两层卷积网络结构：\n",
    "\n",
    "    - 第一层网络，Kernel_size为3的卷积层 + BatchNorm + ReLU；\n",
    "    - 第二层网络，Kernel_size为3的卷积层 + BatchNorm。\n",
    "\n",
    "    最后将主分支输出的特征矩阵与Shortcuts输出的特征矩阵相加，通过ReLU激活函数即为残差网络结构的最终输出。\n",
    "\n",
    "2. ResNet网络结构\n",
    "\n",
    "    这里的ResNet由5层网络结构组成：\n",
    "\n",
    "    - 第一层，Kernel_size为3的卷积层 + BatchNorm + Kernel_size为3的卷积层 + BatchNorm + Relu；\n",
    "    - 第二层，最大池化 + 残差网络 + Kernel_size为3的卷积层 + BatchNorm；\n",
    "    - 第三层，最大池化 + 残差网络 + Kernel_size为3的卷积层 + BatchNorm；\n",
    "    - 第四层，最大池化 + 残差网络 + Kernel_size为3的卷积层 + BatchNorm；\n",
    "    - 第五层， 残差网络 + Kernel_size为2的卷积层 + BatchNorm + Kernel_size为2的卷积层 + BatchNorm。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-12-16T07:35:54.280578Z",
     "start_time": "2022-12-16T07:35:54.256640Z"
    }
   },
   "source": [
    "## 数据集\n",
    "\n",
    "### 数据集介绍\n",
    "\n",
    "为了使得训练的结果更具有说明性，采用了多个数据集进行训练，在训练之前需要将多个数据集合并为一个数据集；同时数据集中每条数据的标签长度不一，为了达到更好的训练效果，希望每次训练的数据的标签长度都一致，在提取数据的时候需要按照一定的索引进行提取。\n",
    "\n",
    "本案例使用[MJSynth](https://www.robots.ox.ac.uk/~vgg/data/text/)和[SynthText](https://github.com/ankush-me/SynthText)数据集用于模型训练，[The IIIT 5K-word dataset](https://cvit.iiit.ac.in/research/projects/cvit-projects/the-iiit-5k-word-dataset)数据集用于测试。\n",
    "\n",
    "- MJSynth（MJ）\n",
    "\n",
    "    MJ是一个为STR设计的合成数据集，包含8.9M个单词框图像。单词框生成过程如下：\n",
    "\n",
    "    1. 字体渲染；\n",
    "    2. 边框和阴影渲染；\n",
    "    3. 背景着色；\n",
    "    4. 字体、边框和背景的合成；\n",
    "    5. 应用投影失真；\n",
    "    6. 与真实图像混合；\n",
    "    7. 添加噪声。\n",
    "\n",
    "- SynthText（ST）\n",
    "\n",
    "    ST是另一个合成产生的数据集，最初设计用于场景文本检测。尽管ST是为场景文本检测任务设计的，但它也可以通过裁剪单词框用于场景文字识别(Scene Text Recognition, STR)。通过对数据集的单词框进行裁剪获得了5.5 M个单词文本图像。\n",
    "\n",
    "- IIIT5K Words（IIIT）\n",
    "\n",
    "    IIIT是从Google图像搜索中抓取的数据集，其中包含可能返回文本图像的查询词，例如“广告牌”、“招牌”、“门牌号”、“门牌号”和“电影海报”。IIIT包括2000张用于训练的图像和3000张用于评估的图像。\n",
    "\n",
    "### 数据集合并及索引生成\n",
    "\n",
    "- 数据集合并\n",
    "\n",
    "    依次打开数据集的lmdb文件，读取图片和标签，并写入同一个新的lmdb文件中。\n",
    "\n",
    "- 分析新数据集中的标签的长度分布以及组合\n",
    "\n",
    "    在一个Batch中所有数据的Label总长度固定的情况下，得到Batch中组成数据的Label的长度的可能组合。首先得到每条数据中标签的长度，获取数据集中各种标签长度的分布情况，以及数据集中所有标签的总长度，然后根据数据计算出每个Batch中的标签的平均长度，最后根据Batch中的平均长度以及各种标签长度的分布情况，获得可能的组合，使得每个Batch的平均长度相同。\n",
    "\n",
    "- 根据标签组合得到一个索引表\n",
    "\n",
    "    根据获取的可能组合，形成训练时采集数据的索引列表。这里有超参数可以控制实际训练数据集的大小，在采样过程中，根据标签长度组合随机选择，故超参可设置稍大一些，目的是尽可能将数据集中所有数据都采集到。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据集下载\n",
    "\n",
    "使用download模块对数据集进行下载和解压。数据下载之前需要使用```pip install download```安装download包。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:08:06.790978Z",
     "start_time": "2023-01-18T05:59:15.602888Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cnnctc_dataset.tar.gz (545.4 MB)\n",
      "\n",
      "file_sizes: 100%|████████████████████████████| 572M/572M [08:38<00:00, 1.10MB/s]\n",
      "Extracting tar.gz file...\n",
      "Successfully downloaded / unzipped to .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'.'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from download import download\n",
    "\n",
    "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cnnctc_dataset.tar.gz\"\n",
    "\n",
    "download(url, \".\", kind=\"tar.gz\", replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型构建\n",
    "\n",
    "这边模型构建分三个部分，具体如下：\n",
    "\n",
    "1. 采用ResNet网络从图片中提取特征；\n",
    "2. 将每张图片提取的Feature Map划分为不同的序列Feature；\n",
    "3. 对每个序列Feature进行预测，得到该序列属于不同字符的概率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:09:02.592683Z",
     "start_time": "2023-01-18T06:08:53.619420Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from mindspore import nn\n",
    "from mindspore.common.initializer import TruncatedNormal\n",
    "\n",
    "\n",
    "class CNNCTC(nn.Cell):\n",
    "    def __init__(self, num_class, hidden_size, final_feature_width):\n",
    "        super(CNNCTC, self).__init__()\n",
    "\n",
    "        self.num_class = num_class\n",
    "        self.hidden_size = hidden_size\n",
    "        self.final_feature_width = final_feature_width\n",
    "\n",
    "        self.feature_extraction = ResNet(3, 512, BasicBlock, [1, 2, 5, 3])\n",
    "        self.prediction = nn.Dense(self.hidden_size, self.num_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.feature_extraction(x)\n",
    "        # 进行维度转换，方便划分图片时按列划分\n",
    "        x = ops.transpose(x, (0, 3, 1, 2))  # [b, c, h, w] -> [b, w, c, h]\n",
    "        x = ops.reshape(x, (-1, self.hidden_size))\n",
    "        x = self.prediction(x)\n",
    "        x = ops.reshape(x, (-1, self.final_feature_width, self.num_class))\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "class ResNet(nn.Cell):\n",
    "    def __init__(self, input_channel, output_channel, block, layers):\n",
    "        super(ResNet, self).__init__()\n",
    "\n",
    "        self.output_channel_block = [int(output_channel / 4), int(output_channel / 2), output_channel, output_channel]\n",
    "        self.inplanes = int(output_channel / 8)\n",
    "\n",
    "        self.conv0_1 = nn.Conv2d(input_channel, int(output_channel / 16), kernel_size=3, stride=1, padding=1,\n",
    "                                 pad_mode='pad', weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn0_1 = nn.BatchNorm2d(int(output_channel / 16), momentum=0.1)\n",
    "        self.conv0_2 = nn.Conv2d(int(output_channel / 16), self.inplanes, kernel_size=3, stride=1, padding=1,\n",
    "                                 pad_mode='pad', weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn0_2 = nn.BatchNorm2d(self.inplanes, momentum=0.1)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "        self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='valid')\n",
    "        self.layer1 = self._make_layer(block, self.output_channel_block[0], layers[0])\n",
    "        self.conv1 = nn.Conv2d(self.output_channel_block[0], self.output_channel_block[0], kernel_size=3, stride=1,\n",
    "                               padding=1, pad_mode='pad', weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(self.output_channel_block[0], momentum=0.1)\n",
    "\n",
    "        self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='valid')\n",
    "        self.layer2 = self._make_layer(block, self.output_channel_block[1], layers[1])\n",
    "        self.conv2 = nn.Conv2d(self.output_channel_block[1], self.output_channel_block[1], kernel_size=3, stride=1,\n",
    "                               padding=1, pad_mode='pad', weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn2 = nn.BatchNorm2d(self.output_channel_block[1], momentum=0.1)\n",
    "        self.pad = nn.Pad(((0, 0), (0, 0), (0, 0), (2, 2)))\n",
    "\n",
    "        self.maxpool3 = nn.MaxPool2d(kernel_size=2, stride=(2, 1), pad_mode='valid')\n",
    "        self.layer3 = self._make_layer(block, self.output_channel_block[2], layers[2])\n",
    "        self.conv3 = nn.Conv2d(self.output_channel_block[2], self.output_channel_block[2], kernel_size=3, stride=1,\n",
    "                               padding=1, pad_mode='pad', weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn3 = nn.BatchNorm2d(self.output_channel_block[2], momentum=0.1)\n",
    "\n",
    "        self.layer4 = self._make_layer(block, self.output_channel_block[3], layers[3])\n",
    "        self.conv4_1 = nn.Conv2d(self.output_channel_block[3], self.output_channel_block[3], kernel_size=2,\n",
    "                                 stride=(2, 1), padding=0, pad_mode='valid', weight_init=TruncatedNormal(0.02),\n",
    "                                 has_bias=False)\n",
    "        self.bn4_1 = nn.BatchNorm2d(self.output_channel_block[3], momentum=0.1)\n",
    "        self.conv4_2 = nn.Conv2d(self.output_channel_block[3], self.output_channel_block[3], kernel_size=2, stride=1,\n",
    "                                 padding=0, pad_mode='valid', weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn4_2 = nn.BatchNorm2d(self.output_channel_block[3], momentum=0.1)\n",
    "\n",
    "    def _make_layer(self, block, planes, blocks, stride=1):\n",
    "        downsample = None\n",
    "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
    "            downsample = nn.SequentialCell(\n",
    "                [nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, padding=0,\n",
    "                           pad_mode='same', weight_init=TruncatedNormal(0.02), has_bias=False),\n",
    "                 nn.BatchNorm2d(planes * block.expansion, momentum=0.1)]\n",
    "            )\n",
    "\n",
    "        layers = [block(self.inplanes, planes, stride, downsample)]\n",
    "        self.inplanes = planes * block.expansion\n",
    "        for _ in range(1, blocks):\n",
    "            layers.append(block(self.inplanes, planes))\n",
    "\n",
    "        return nn.SequentialCell(layers)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv0_1(x)\n",
    "        x = self.bn0_1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv0_2(x)\n",
    "        x = self.bn0_2(x)\n",
    "        x = self.relu(x)\n",
    "\n",
    "        x = self.maxpool1(x)\n",
    "        x = self.layer1(x)\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "\n",
    "        x = self.maxpool2(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.bn2(x)\n",
    "        x = self.relu(x)\n",
    "\n",
    "        x = self.maxpool3(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.bn3(x)\n",
    "        x = self.relu(x)\n",
    "\n",
    "        x = self.layer4(x)\n",
    "        x = self.pad(x)\n",
    "        x = self.conv4_1(x)\n",
    "        x = self.bn4_1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv4_2(x)\n",
    "        x = self.bn4_2(x)\n",
    "        x = self.relu(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "class BasicBlock(nn.Cell):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, inplanes, planes, stride=1, downsample=None):\n",
    "        super(BasicBlock, self).__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride, padding=1, pad_mode='pad',\n",
    "                               weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(planes, momentum=0.1)\n",
    "        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, pad_mode='pad',\n",
    "                               weight_init=TruncatedNormal(0.02), has_bias=False)\n",
    "        self.bn2 = nn.BatchNorm2d(planes, momentum=0.1)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.downsample = downsample\n",
    "\n",
    "    def construct(self, x):\n",
    "        residual = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            residual = self.downsample(x)\n",
    "        out = ops.add(out, residual)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 动态学习率\n",
    "\n",
    "根据训练的步数，设置学习率，在warmup_steps以内的，学习率线性改变；在warmup_steps之后的，学习率改变符合余弦分布。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:09:08.450880Z",
     "start_time": "2023-01-18T06:09:08.444868Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 实现动态学习率\n",
    "import math\n",
    "\n",
    "def dynamic_lr(steps_per_epoch, base_lr, warmup_ratio, warmup_step, epochs):\n",
    "    total_steps = steps_per_epoch * epochs\n",
    "    warmup_steps = int(warmup_step)\n",
    "    decay_steps = total_steps - warmup_steps\n",
    "    lr = []\n",
    "    for i in range(total_steps):\n",
    "        if i < warmup_steps:\n",
    "            lr_inc = (float(base_lr) - float(base_lr * warmup_ratio)) / float(warmup_steps)\n",
    "            learning_rate = float(base_lr * warmup_ratio) + lr_inc * i\n",
    "            lr.append(learning_rate)\n",
    "        else:\n",
    "            base = float(i - warmup_steps) / float(decay_steps)\n",
    "            learning_rate = (1 + math.cos(base * math.pi)) / 2 * base_lr\n",
    "            lr.append(learning_rate)\n",
    "    return lr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型训练\n",
    "\n",
    "接下来建训练过程。\n",
    "\n",
    "使用函数式自动微分，需先定义前向过程函数forward_fn，使用mindspore.value_and_grad获得微分函数grad_fn。然后，我们将微分函数和优化器的执行封装为train_step函数，接下来循环迭代数据集进行训练。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:10:07.170887Z",
     "start_time": "2023-01-18T06:09:19.420969Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset_size: 57600\n",
      "batch_size: 64\n",
      "Epoch:[  1/  5], step:[   0/ 900], loss:77.652679 , time:8.120287s, lr:0.000000\n",
      "Epoch:[  1/  5], step:[   1/ 900], loss:76.893089 , time:8.016563s, lr:0.000000\n",
      "Epoch:[  1/  5], step:[   2/ 900], loss:76.870682 , time:7.142902s, lr:0.000000\n",
      "Epoch:[  1/  5], step:[   3/ 900], loss:77.617393 , time:7.100014s, lr:0.000000\n",
      "...\n",
      "Epoch:[  2/  5], step:[ 694/ 900], loss:16.674129 , time:7.087050s, lr:0.000089\n",
      "Epoch:[  2/  5], step:[ 695/ 900], loss:17.313869 , time:7.034190s, lr:0.000090\n",
      "Epoch:[  2/  5], step:[ 696/ 900], loss:16.146877 , time:6.950437s, lr:0.000090\n",
      "Epoch:[  2/  5], step:[ 697/ 900], loss:15.746553 , time:7.120959s, lr:0.000090\n",
      "...\n",
      "Epoch:[  5/  5], step:[ 896/ 900], loss:1.363952 , time:7.270558s, lr:0.000143\n",
      "Epoch:[  5/  5], step:[ 897/ 900], loss:1.594411 , time:7.133924s, lr:0.000143\n",
      "Epoch:[  5/  5], step:[ 898/ 900], loss:1.676782 , time:7.165838s, lr:0.000143\n",
      "Epoch:[  5/  5], step:[ 899/ 900], loss:2.227234 , time:7.168831s, lr:0.000144\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import mindspore as ms\n",
    "from mindspore import ops, ParameterTuple, Tensor\n",
    "from mindspore.common import dtype\n",
    "from mindspore.train.serialization import load_checkpoint, load_param_into_net\n",
    "from mindspore.dataset import MindDataset\n",
    "\n",
    "device_target = 'CPU'\n",
    "train_dataset_path = './cnnctc_dataset/STMJ_train_dataset.mindrecord'\n",
    "batch_size = 64\n",
    "epochs = 5\n",
    "pred_trained = ''\n",
    "final_feature_width = 26\n",
    "num_class = 37\n",
    "hidden_size = 512\n",
    "\n",
    "ms.set_context(device_target=device_target, mode=ms.PYNATIVE_MODE)\n",
    "\n",
    "# 数据集加载\n",
    "data = MindDataset(dataset_files=train_dataset_path)\n",
    "dataset_size = data.get_dataset_size()\n",
    "print('dataset_size:', dataset_size)\n",
    "print('batch_size:', batch_size)\n",
    "\n",
    "# 模型初始化\n",
    "net = CNNCTC(num_class, hidden_size, final_feature_width)\n",
    "\n",
    "# 加载预训练权重\n",
    "if pred_trained:\n",
    "    param_dict = load_checkpoint(pred_trained)\n",
    "    load_param_into_net(net, param_dict)\n",
    "    print('Pred_trained parameters loaded!')\n",
    "\n",
    "# 损失函数\n",
    "loss_fn = nn.CTCLoss(blank=0, reduction='mean', zero_infinity=False)\n",
    "\n",
    "# 学习率\n",
    "lr = Tensor(dynamic_lr(dataset_size // batch_size, 0.0005, 0.0625, 2000, epochs), dtype.float32)\n",
    "lr = lr[::-1]\n",
    "\n",
    "# 优化器\n",
    "opt = nn.RMSProp(params=net.trainable_params(),\n",
    "                 centered=True,\n",
    "                 learning_rate=lr,\n",
    "                 momentum=0.8)\n",
    "\n",
    "# 前向过程\n",
    "def forward_fn(data):\n",
    "    logits = net(data['img'])\n",
    "    logits = ops.log_softmax(logits)\n",
    "    logits = ops.transpose(logits, (1, 0, 2))\n",
    "    loss = loss_fn(logits, data['text'], data['sequence_length'], data['target_lengths'])\n",
    "    return loss, logits\n",
    "\n",
    "# 计算梯度\n",
    "grad_fn = ms.value_and_grad(forward_fn, None, ParameterTuple(net.trainable_params()), has_aux=True)\n",
    "\n",
    "# 梯度更新\n",
    "def train_step(data):\n",
    "    (loss, _), grads = grad_fn(data)\n",
    "    opt(grads)\n",
    "    return loss\n",
    "\n",
    "# 全部数据训练\n",
    "def train_loop(data_1):\n",
    "    # 将数据组织batch_size\n",
    "    batch_list = np.arange(0, dataset_size, batch_size)\n",
    "    sequence_length = np.array([final_feature_width] * batch_size, dtype=np.int32)\n",
    "    sequence_length = Tensor.from_numpy(sequence_length)\n",
    "    data_input = {}\n",
    "    for step, data in enumerate(data_1.create_dict_iterator()):\n",
    "        if step in batch_list:\n",
    "            step_b = step\n",
    "            data_img = data['img']\n",
    "            text = data['text']\n",
    "            target_lengths = data['target_lengths']\n",
    "            continue\n",
    "        if step <= step_b + batch_size - 1:\n",
    "            data_img = ops.concat((data_img, data['img']), axis=0)\n",
    "            text = ops.concat((text, data['text']), axis=0)\n",
    "            target_lengths = ops.concat((target_lengths, data['target_lengths']), axis=0)\n",
    "        if step == step_b + batch_size - 1:\n",
    "            data_input['img'] = data_img\n",
    "            data_input['text'] = text\n",
    "            data_input['target_lengths'] = target_lengths\n",
    "            data_input['sequence_length'] = sequence_length\n",
    "\n",
    "            begin_time = time.time()\n",
    "            loss = train_step(data_input)\n",
    "            end_time = time.time()\n",
    "            times = end_time - begin_time\n",
    "            if step % 1 == 0:\n",
    "                loss = loss.asnumpy()\n",
    "                print(f\"Epoch:[{int(epoch + 1):>3d}/{int(epochs):>3d}], \"\n",
    "                      f\"step:[{int(step // batch_size):>4d}/{int(dataset_size / batch_size):>4d}], \"\n",
    "                      f\"loss:{loss:>4f} , \"\n",
    "                      f\"time:{times:>3f}s, \"\n",
    "                      f\"lr:{lr[int(step // batch_size)].asnumpy():>6f}\")\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    train_loop(data)\n",
    "    ms.save_checkpoint(net, f\"./cnnctc_{epoch+1}_{dataset_size // batch_size}.ckpt\")\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 因为在训练的过程中输出结果较长，这里只提供了部分过程，下文中使用已训练好的权重文件进行模型评估和推理效果的展示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型验证\n",
    "\n",
    "模型验证时，选择模型训练时保存的参数文件，验证数据集采用IIIT数据集。使用CNNCTC方法定义模型，并加载权重文件，运行模型前向运算，将模型输出结果进过后处理方法，即对于每条数据的输出选取概率最高的字符组成字符串，并进行解码获得最后预测结果，与标签数据进行对比，如果相同就算正确，最后输出验证结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:13:52.337135Z",
     "start_time": "2023-01-18T06:10:54.178938Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cnnctc.ckpt (169.0 MB)\n",
      "\n",
      "file_sizes: 100%|████████████████████████████| 177M/177M [02:56<00:00, 1.01MB/s]\n",
      "Successfully downloaded file to cnnctc.ckpt\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'cnnctc.ckpt'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 权重下载\n",
    "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cnnctc.ckpt\"\n",
    "download(url, \"cnnctc.ckpt\", replace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:14:08.715717Z",
     "start_time": "2023-01-18T06:14:08.708699Z"
    }
   },
   "outputs": [],
   "source": [
    "# 文本与数据编码\n",
    "class CTCLabelConverter():\n",
    "    def __init__(self, character):\n",
    "        dict_character = list(character)\n",
    "        self.dict = {}\n",
    "        for i, char in enumerate(dict_character):\n",
    "            self.dict[char] = i + 1\n",
    "        self.character = ['[blank]'] + dict_character\n",
    "        self.dict['[blank]'] = 0\n",
    "\n",
    "    def encode(self, text):\n",
    "        # 将文本转换为数字编码\n",
    "        length = [len(s) for s in text]\n",
    "        text = ''.join(text)\n",
    "        text = [self.dict[char] for char in text]\n",
    "\n",
    "        return np.array(text), np.array(length)\n",
    "\n",
    "    def decode(self, text_index, length):\n",
    "        # 将数字编码转换为文本\n",
    "        texts = []\n",
    "        index = 0\n",
    "        for l in length:\n",
    "            t = text_index[index:index + l]\n",
    "            char_list = []\n",
    "            for i in range(l):\n",
    "                if t[i] != self.dict['[blank]'] and (\n",
    "                        not (i > 0 and t[i - 1] == t[i])):\n",
    "                    char_list.append(self.character[t[i]])\n",
    "            text = ''.join(char_list)\n",
    "            texts.append(text)\n",
    "            index += l\n",
    "        return texts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:15:53.544237Z",
     "start_time": "2023-01-18T06:14:27.974015Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters loaded! from:  ./cnnctc.ckpt\n",
      "accuracy: 0.5214\n",
      " time:84.27s\n"
     ]
    }
   ],
   "source": [
    "# 验证过程\n",
    "# 参数设置\n",
    "checkpoint_path = './cnnctc.ckpt'\n",
    "test_batch_size = 64\n",
    "character = '0123456789abcdefghijklmnopqrstuvwxyz'\n",
    "num_class = 37\n",
    "hidden_size = 512\n",
    "final_feature_width = 26\n",
    "\n",
    "# 加载测试数据集\n",
    "test_dataset_path = './cnnctc_dataset/IIIT_eval_dataset.mindrecord'\n",
    "dataset_eval = MindDataset(dataset_files=test_dataset_path)\n",
    "\n",
    "# 初始化模型\n",
    "net = CNNCTC(num_class, hidden_size, final_feature_width)\n",
    "net.set_train(False)\n",
    "\n",
    "# 加载权重文件\n",
    "param_dict = load_checkpoint(checkpoint_path)\n",
    "load_param_into_net(net, param_dict)\n",
    "print('Parameters loaded! from: ', checkpoint_path)\n",
    "\n",
    "# 初始化文本编码函数\n",
    "converter = CTCLabelConverter(character)\n",
    "\n",
    "count = 0\n",
    "correct_count = 0\n",
    "begin_time = time.time()\n",
    "num_b = 0\n",
    "\n",
    "for data in dataset_eval.create_tuple_iterator():\n",
    "    if num_b == 0 or num_b % test_batch_size == 0:\n",
    "        img, length, text = data\n",
    "        num_b = num_b + 1\n",
    "        continue\n",
    "    else:\n",
    "        img_1, length_1, text_1 = data\n",
    "        img = ops.concat((img, img_1), axis=0)\n",
    "        text = ops.concat((text, text_1), axis=0)\n",
    "        length = ops.concat((length, length_1), axis=0)\n",
    "        if num_b != 0 and (num_b + 1) % test_batch_size == 0:\n",
    "            img_tensor = Tensor(img, dtype.float32)\n",
    "            model_predict = net(img_tensor)\n",
    "\n",
    "            model_predict_1 = np.squeeze(model_predict.asnumpy())\n",
    "            preds_size = np.array([model_predict_1.shape[1]] * test_batch_size)\n",
    "            preds_index = np.argmax(model_predict_1, 2)\n",
    "            preds_index = np.reshape(preds_index, [-1])\n",
    "            preds_str = converter.decode(preds_index, preds_size)\n",
    "            label_str = converter.decode(text.asnumpy(), length.asnumpy())\n",
    "            for pred, label in zip(preds_str, label_str):\n",
    "                if pred == label:\n",
    "                    correct_count += 1\n",
    "                count += 1\n",
    "        num_b = num_b + 1\n",
    "\n",
    "times = time.time() - begin_time\n",
    "print(f'accuracy: {correct_count/count:.4f}\\n',\n",
    "      f\"time:{times:.2f}s\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型推理\n",
    "\n",
    "先配置输入图片的地址，读取图片，经过预处理转为Tensor格式，将图片的Tensor数据输入模型进行前向计算。将预测的结果后处理获得预测的标签。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-18T06:16:03.806098Z",
     "start_time": "2023-01-18T06:16:03.215646Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predict:  ['parking']\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from PIL import Image\n",
    "\n",
    " # 推理过程\n",
    "infer_file_path = './cnnctc_dataset/predict.png'\n",
    "\n",
    "img_PIL = Image.open(infer_file_path).convert('RGB')\n",
    "img = img_PIL.resize((100, 32), resample=3)\n",
    "img = np.array(img, dtype=np.float32)\n",
    "img = np.expand_dims(img, axis=0)  # (1,32,100,3)\n",
    "img = np.transpose(img, [0, 3, 1, 2])  # (1,3,32,100)\n",
    "img_tensor = Tensor.from_numpy(img)\n",
    "\n",
    "model_predict = net(img_tensor)\n",
    "preds_size = np.array([model_predict.shape[1]])\n",
    "preds_index = np.argmax(model_predict, 2)\n",
    "preds_index = np.reshape(preds_index, [-1])\n",
    "preds_str = converter.decode(preds_index, preds_size)\n",
    "print('Predict: ', preds_str)\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(img_PIL)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MindSpore",
   "language": "python",
   "name": "mindspore"
  },
  "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.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "304.475px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}