CRNN笔记

已于 2022-08-17 18:25:07 修改
阅读量439 收藏
点赞数
文章标签： 人工智能 前端 深度学习
于 2022-08-17 15:43:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44137397/article/details/126383214
版权

参考链接：

一文读懂CRNN+CTC文字识别 - 知乎

CTC loss - 知乎

1、背景

文字识别主流的两种算法

 1.1 基于CRNN+CTC

1.2 基于CNN+Seq2Seq+Attention

2、CRNN+CTC原理解析

CRNN+CTC结构图

 以下是根据paddleocr中以mobilenetv3为backbone的网络结构图

model                                           输入：256*3*32*100
BaseModel(
  (backbone): MobileNetV3(
    (conv1): ConvBNLayer(
      (conv): Conv2D(3, 8, kernel_size=[3, 3], stride=[2, 2], padding=1, data_format=NCHW)
      (bn): BatchNorm()
    )
    (blocks): Sequential(
      (0): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(8, 8, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(8, 8, kernel_size=[3, 3], padding=1, groups=8, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(8, 8, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (1): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(8, 32, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(32, 32, kernel_size=[3, 3], stride=[2, 1], padding=1, groups=32, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(32, 16, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (2): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(16, 40, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(40, 40, kernel_size=[3, 3], padding=1, groups=40, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(40, 16, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (3): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(16, 40, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(40, 40, kernel_size=[5, 5], stride=[2, 1], padding=2, groups=40, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(40, 10, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(10, 40, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(40, 24, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (4): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(24, 64, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(64, 64, kernel_size=[5, 5], padding=2, groups=64, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(64, 16, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(16, 64, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(64, 24, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (5): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(24, 64, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(64, 64, kernel_size=[5, 5], padding=2, groups=64, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(64, 16, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(16, 64, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(64, 24, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (6): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(24, 120, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(120, 120, kernel_size=[3, 3], padding=1, groups=120, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(120, 40, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (7): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(40, 104, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(104, 104, kernel_size=[3, 3], padding=1, groups=104, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(104, 40, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (8): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(40, 96, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(96, 96, kernel_size=[3, 3], padding=1, groups=96, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(96, 40, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (9): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(40, 96, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(96, 96, kernel_size=[3, 3], padding=1, groups=96, data_format=NCHW)
          (bn): BatchNorm()
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(96, 40, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (10): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(40, 240, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(240, 240, kernel_size=[3, 3], padding=1, groups=240, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(240, 60, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(60, 240, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(240, 56, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (11): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(56, 336, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(336, 336, kernel_size=[3, 3], padding=1, groups=336, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(336, 84, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(84, 336, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(336, 56, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (12): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(56, 336, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(336, 336, kernel_size=[5, 5], stride=[2, 1], padding=2, groups=336, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(336, 84, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(84, 336, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(336, 80, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (13): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(80, 480, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(480, 480, kernel_size=[5, 5], padding=2, groups=480, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(480, 120, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(120, 480, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(480, 80, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
      (14): ResidualUnit(
        (expand_conv): ConvBNLayer(
          (conv): Conv2D(80, 480, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
        (bottleneck_conv): ConvBNLayer(
          (conv): Conv2D(480, 480, kernel_size=[5, 5], padding=2, groups=480, data_format=NCHW)
          (bn): BatchNorm()
        )
        (mid_se): SEModule(
          (avg_pool): AdaptiveAvgPool2D(output_size=1)
          (conv1): Conv2D(480, 120, kernel_size=[1, 1], data_format=NCHW)
          (conv2): Conv2D(120, 480, kernel_size=[1, 1], data_format=NCHW)
        )
        (linear_conv): ConvBNLayer(
          (conv): Conv2D(480, 80, kernel_size=[1, 1], data_format=NCHW)
          (bn): BatchNorm()
        )
      )
    )
    (conv2): ConvBNLayer(
      (conv): Conv2D(80, 480, kernel_size=[1, 1], data_format=NCHW)       # 输出256 * 480 *1 *25，就是将图片编码为480*25的序列。
      (bn): BatchNorm()
    )
    (pool): MaxPool2D(kernel_size=2, stride=2, padding=0)
  )
  (neck): SequenceEncoder(                         # 输入neck的是256*480*1*25
    (encoder_reshape): Im2Seq()                    # 经过Im2Seq后，将图片输出为256*25*480的向量序列，25个时间序列，每个序列的维度为480
    (encoder): EncoderWithRNN(
      (lstm): LSTM(480, 96, num_layers=2
        (0): BiRNN(
          (cell_fw): LSTMCell(480, 96)
          (cell_bw): LSTMCell(480, 96)
        )
        (1): BiRNN(
          (cell_fw): LSTMCell(192, 96)
          (cell_bw): LSTMCell(192, 96)               #经过BILSTM后输出256*25*192
        )
      )
    )
  )
  (head): CTCHead(                                          #输入256*25*192，输出256*25*96，25是最大字符长度，96是字典的个数加上了sos，bos两个起始符
    (fc): Linear(in_features=192, out_features=96, dtype=float32)
  )
)
CTCLOSS：最后一步ctcloss就是动态路径规划，设定一些规则，去掉重复的和空白的字符。
forward计算得到loss=每一条可以正确到达lable的路径的概率之和
每一条可以正确到达lable的路径的概率=这条路径的每个字符的概率乘积。
backward计算更新梯度，就是为了更新LSTM中的参数。反向算法：计算在t时刻，以第s个label 开始的后缀到正确结束点的概率和。

Jack Su
关注
pytorch crnn笔记（一）
juluwangriyue的博客
09-26 1079
最近在看ocr识别，就尝试了一下pytorch的crnn。 https://github.com/meijieru/crnn.pytorch 有一个lmdb库原来没有安装，网上参考的安装办法大多都是： conda install -c conda-forge python-lmdb 我尝试用这种方法安装，还是安装失败，主要可能是找不到这个库，或者下载不下来。 我的解决办法是下载下来本地安装。 从https://conda.anaconda.org/conda-forge/win-64/下载p.
pytorch crnn 笔记（二）
juluwangriyue的博客
10-12 1078
crnn的论文、原理，训练等。 CRNN论文地址：http://arxiv.org/abs/1507.05717（作者是华中科技大学的老师） 代码：https://github.com/Sierkinhane/crnn_chinese_characters_rec 论文阅读： 摘要： 基于图像的序列识别一直是计算机视觉领域的一个长期研究课题。本文研究了场景文本识别问题，这是在基于图像的序列识别中最重要和最具挑战性的任务之一。提出了一种新的神经网络结构，将特征提取、序列建模和转录集成到一个统一的框架
【OCR】【专题系列】四、基于RCNN-CTC的不定长文本识别
小博客大智慧
08-08 1609
本文实现基于crnn-ctc的不定长文本识别，采用pytorch框架可直接运行跑通，并基于开源数据集进行实验验证。
关于crnn中的ctc
AWhiteDongDong的博客
07-16 405
图文可以参考 crnn就是卷积加lstm加ctc，cnn用于提取特征，lstm用于提取序列特征，ctc用来解决训练时标签对齐问题，假如没有ctc，经过lstm输出的维度为w×n×c，其中w为输入进lstm的特征图宽度，n为batch size，c为类别数，如果直接以softmax输出，我们需要为每一个时刻的序列都标注一个标签，而每一个序列在原图上会对应一个区域，这样我们会为一个图片标注w个标签，我们在标注标签的时候还需要计算每一个序列在原图对应的区域，是相当麻烦的，ctc提出了一种计算方法，引入blank，
【论文解读】图像序列识别：CRNN技术在场景文本识别中的应用与突破（附论文地址）
最新发布
牧子川的博客
09-10 971
。文章主要研究了基于图像的序列识别问题，特别是场景文本识别，这是基于图像的序列识别中最重要和最具挑战性的任务之一。
软件工程应用与实践（十一）：CRNN-CTC模型再介绍
pinkray_c的博客
12-11 2895
2021SC@SDUSC 目录 一、前情回顾和背景介绍 1.1　PP-OCR文字识别策略回顾 1.2　CRNN-CTC模型概述 二、CRNN-CTC模型策略详解 2.1 模型流程 代码结构 数据 数据示例 数据准备 模型训练 测试 三、CTC model VS　attention model 预测 预训练模型 总结 一、前情回顾和背景介绍 1.1　PP-OCR文字识别策略回顾 策略的选用主要是用来增强模型能力和减少模型大小。下面是PP-OCR文字识...
CRNN
cengjing12的博客
11-13 7428
CRNN详解：https://blog.csdn.net/bestrivern/article/details/91050960 https://www.cnblogs.com/skyfsm/p/10335717.html 1 概述 传统的OCR识别过程分为两步：单字切割和分类任务。现在更流行的是基于深度学习的端到端的文字识别，即我们不需要显式加入文字切割这个环节，而是将文字识别转化为序列学习问题，虽然输入的图像尺度不同，文本长度不同，但是经过DCNN和RNN后，在输出阶段经过一定的翻译后，就可以对整个文本
CRNN文本识别模型
zhenming的博客
06-28 4246
CRNN文本识别模型描述模型结构CNNRNNCTC 描述 CRNN是一种简单高效的文本识别模型。相比与Attention类型的文本识别模型，其具有如下优缺点。 优点： 容易训练，模型容易收敛，且鲁棒性较高。 易于部署，模型结构简单，inference速度快且支持变长输入，适合文本长度变化较大的生产环境。 缺点： 识别准确率相对较低，在包含大量中文字符集情况下，会比RARE类型的Attention模型低不少，英文字符集的情况下会低更多。 对于艺术字等有较大形变的短文本，或自然场景下的变化较大的文本，CR
OCR论文笔记系列（一）: CRNN文字识别
热门推荐
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
12-08 2万+
本文主要介绍OCR领域经典深度学习方法CRNN+CTC,CRNN是一种卷积循环神经网络结构，用于解决基于图像的序列识别问题，特别是场景文字识别问题。CRNN网络结构包含三部分，从下到上依次为：1. 卷积层。作用是从输入图像中提取特征序列。2. 循环层。......
CRNN论文笔记
prague6695的博客
07-11 592
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
CRNN代码笔记
prague6695的博客
06-17 1133
CRNN代码笔记 主要由五个模块组成： 数据集的加载与切分 CRNN代码复现 训练过程 预测过程 训练过程中对的评估 文章目录CRNN代码笔记数据集的加载与切分RCNN模型构建训练部分训练辅助函数注意超参数设置判断cuda是否可用，是则基于GPU训练，否则用cpu训练设置训练数据加载器、验证数据加载器，常规操作collate_fn用法实例化CRNN模型，加载模型参数，并运行至可用设备（CPU or GPU）定义优化方法、损失函数开始训练预测部分超参数设置判断cuda是否可用，否则用cpu预测设置预测数据
CRNN：文本序列识别
Twilight737的博客
08-02 2937
CRNN：文字序列识别 文字序列识别是图像领域的一个常见问题。一般来说，从自然场景图片中识别文字需要两步，首先定位图像中的文字位置，然后对文字序列进行识别。 文字检测：解决的问题是哪里有文字，文字的范围有多长。 文字识别：对定位好的文字区域进行识别，主要解决的问题是每个文字是什么，将图像中的文字区域进转化为字符信息。 文章目录CRNN：文字序列识别一、相关背景介绍二、CRNN模型结构三、实验结果四、深入思考五、源码总结 一、相关背景介绍 常用的文字识别算法主要有两种框架，本文主要介绍第一种框架： 1、CN
PaddleOCR 文字识别 c++ win10 安装使用教程
qq_38836770的博客
11-07 1万+
开头先夸一句，百度真棒 这里写目录标题引言安装流程前置条件注意：提前预警，本文中并不涉及安装GPU版本1. 拉取PaddleOCR整体目录2. 安装 paddle 预测库 fluid_inference我下载的是cpu_avx_mkl版的（就是红圈里这个）文件解压后的目录3. 开始cmake（贴官方图）3.1 打开Visual Studio 2019 Community，点击继续但无需代码3.2 文件->打开->CMake3.3 点击：项目->cpp_inference_demo的CM.
OCR 模型记录
华灯初上博客
09-18 2811
文章目录OCR算法检测类1. DBNet特征融合模型输出处理2. SAST3. PGNet算法原理 OCR算法 检测类 1. DBNet 属于分割类文本检测算法。其基于对模型预测出的特征图进行复制筛选的朴素思想，创新提出使用模型预测其阈值特征图，利用两者获得二值图，从而获取文本位置信息。其流程如下图： 可以发现其能够处理不规则的文本，那么具体是怎么实现的呢？ 上图是整体网络流程，其基本架构为Backbone + FPN + DB Head,并不复杂，可能会造成疑惑的的有以下几点： 特征融合的细节处理
CTC原理介绍
minjialong的博客
10-27 1677
https://github.com/parlance/ctcdecode
字符识别（CRNN，Opencv，Pytorch）
Czqqwer的博客
04-13 1765
本文从零实现字符识别，使用自制数据集进行训练，使用的网络是CRNN，使用的深度学习框架为Pytorch，此外还用到了Opencv。
文本识别CRNN模型介绍以及pytorch代码实现
weixin_44599230的博客
06-25 9542
文本识别CRNN pytorch
一文读懂CRNN（基于图像序列识别的端到端可训练网络）
Pleadge的博客
08-19 1973
CRNN网络介绍
文字识别-CRNN
人工智能曾小健
10-19 3715
CRNN的主要特点是： （1）可以进行端到端的训练； （2）不需要对样本数据进行字符分割，可识别任意长度的文本序列 （3）模型速度快、性能好，并且模型很小（参数少） 下面将展开对这三个层进行介绍： （1）卷积层 ① 预处理 CRNN对输入图像先做了缩放处理，把所有输入图像缩放到相同高度，默认是32，宽度可任意长。 ② 卷积运算 由标准的CNN模型中的卷积层和最大池化层组成，结构类似于VGG，如下图： 从上图可以看出，卷积层是由一系列的卷积、最大池化、批量归一化等操作组..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值