diff --git a/._.DS_Store b/._.DS_Store
deleted file mode 100755
index 9ad849c..0000000
Binary files a/._.DS_Store and /dev/null differ
diff --git a/.gitignore b/.gitignore
index ea1ac33..7393194 100755
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
.vscode/
checkpoints/
+.idea/
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 1b0bbe6..4e17f0d 100755
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -11,63 +11,51 @@
+
+
+
+
+
+
+
+
+
+
-
+
-
-
+
+
-
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
@@ -75,17 +63,39 @@
+
+
+
+
+
+ 蹬
+
+
-
+
@@ -95,10 +105,11 @@
true
DEFINITION_ORDER
-
-
-
-
+
+
+
+
+
@@ -116,6 +127,7 @@
+
@@ -123,11 +135,20 @@
-
+
+
+
+
+
+
+看到这么密密麻麻的文字相信连人类都.... 开始头疼了，这些复杂的文字能够通过一个神经网络来识别出来？？答案是肯定的.... 不有得感叹一下神经网络的强大。。上面的部分文字识别出来的结果是这样的：
+
+
+
+
-其对应的label为：
-```
-['!', '"', '#', '$', '%', '&', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '、', '。', '々', '…', '‘', '’', '“', '”']
-```
关于数据的处理部分，从服务器下载到的原始数据是 `trn_gnt.zip` 解压之后是 `gnt.alz`， 需要再次解压得到一个包含 gnt文件的文件夹。里面每一个gnt文件都包含了若干个汉字及其标注。直接处理比较麻烦，也不方便抽取出图片再进行操作，**虽然转为图片存入文件夹比较直观，但是不适合批量读取和训练**, 后面我们统一转为tfrecord进行训练。
@@ -33,8 +59,282 @@
- `cd dataset && python3 convert_to_tfrecord.py`, 请注意我们使用的是tf2.0；
- 你需要修改对应的路径，等待生成完成，大概有89万个example，如果1.0和1.1都用，那估计得double。
-
-## Model
-关于我们采用的OCR模型的构建，我们大致采用的是比较先进的MobileNetV3架构，同时设计了一个修改的过的MobileNetV3Big的更深网络。主要考虑模型的轻量型和表达能力。最终训练结果表明，我们的模型可以在中文手写字上达到约99.8%的准确率。
\ No newline at end of file
+
+## 模型构建
+
+关于我们采用的OCR模型的构建，我们构建了3个模型分别做测试，三个模型的复杂度逐渐的复杂，网络层数逐渐深入。但是到最后发现，最复杂的那个模型竟然不收敛。这个其中一个稍微简单模型的训练过程：
+
+
+
+
+
+大家可以看到，准确率可以在短时间内达到87%非常不错，测试集的准确率大概在40%，由于测试集中的样本在训练集中完全没有出现，相对训练集的准确率来讲偏低。可能原因无外乎两个，一个事模型泛化性能不强，另外一个原因是训练还不够。
+
+不过好在这个简单的模型也能达到训练集90%的准确率，it's a good start. 让我们来看一下如何快速的构建一个OCR网络模型：
+
+
+
+```python
+def build_net_003(input_shape, n_classes):
+ model = tf.keras.Sequential([
+ layers.Conv2D(input_shape=input_shape, filters=32, kernel_size=(3, 3), strides=(1, 1),
+ padding='same', activation='relu'),
+ layers.MaxPool2D(pool_size=(2, 2), padding='same'),
+ layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same'),
+ layers.MaxPool2D(pool_size=(2, 2), padding='same'),
+
+ layers.Flatten(),
+ layers.Dense(n_classes, activation='softmax')
+ ])
+ return model
+```
+
+这是我们使用keras API构建的一个模型，它足够简单，仅仅包含两个卷积层以及两个maxpool层。下面我们让大家知道，即便是再简单的模型，有时候也能发挥出巨大的用处，对于某些特定的问题可能比更深的网络更有用途。关于这部分模型构建大家只要知道这么几点：
+
+- 如果你只是构建序列模型，没有太fancy的跳跃链接，你可以直接用`keras.Sequential` 来构建你的模型；
+- Conv2D中最好指定每个参数的名字，不要省略，否则别人不知道你的写的事输入的通道数还是filters。
+
+
+
+最后，在你看完本篇博客后，并准备自己动手复现这个教程的时候， 可以思考一下为什么下面这个模型就发散了呢？（仅仅稍微复杂一点）：
+
+
+
+```python
+
+def build_net_002(input_shape, n_classes):
+ model = tf.keras.Sequential([
+ layers.Conv2D(input_shape=input_shape, filters=64, kernel_size=(3, 3), strides=(1, 1),
+ padding='same', activation='relu'),
+ layers.MaxPool2D(pool_size=(2, 2), padding='same'),
+ layers.Conv2D(filters=128, kernel_size=(3, 3), padding='same'),
+ layers.MaxPool2D(pool_size=(2, 2), padding='same'),
+ layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same'),
+ layers.MaxPool2D(pool_size=(2, 2), padding='same'),
+
+ layers.Flatten(),
+ layers.Dense(1024, activation='relu'),
+ layers.Dense(n_classes, activation='softmax')
+ ])
+ return model
+```
+
+
+
+## 数据输入
+
+其实最复杂的还是数据准备过程啊。这里着重说一下，我们的数据存入tfrecords中的事image和label，也就是这么一个example：
+
+
+
+```
+ example = tf.train.Example(features=tf.train.Features(
+ feature={
+ "label": tf.train.Feature(int64_list=tf.train.Int64List(value=[index])),
+ 'image': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img.tobytes()])),
+ 'width': tf.train.Feature(int64_list=tf.train.Int64List(value=[w])),
+ 'height': tf.train.Feature(int64_list=tf.train.Int64List(value=[h])),
+ }))
+```
+
+然后读取的时候相应的读取即可，这里告诉大家几点坑爹的地方：
+
+- 将numpyarray的bytes存入tfrecord跟将文件的bytes直接存入tfrecord解码的方式事不同的，由于我们的图片数据不是来自于本地文件，所以我们使用了一个tobytes()方法存入的事numpy array的bytes格式，它实际上并不包含维度信息，所以这就是坑爹的地方之一，如果你不同时存储width和height，你后面读取的时候便无法知道维度，**存储tfrecord顺便存储图片长宽事一个好的习惯**.
+- 关于不同的存储方式解码的方法有坑爹的地方，比如这里我们存储numpy array的bytes，通常情况下，你很难知道如何解码。。（不看本教程应该很多人不知道）
+
+最后load tfrecord也就比较直观了：
+
+
+
+```python
+def parse_example(record):
+ features = tf.io.parse_single_example(record,
+ features={
+ 'label':
+ tf.io.FixedLenFeature([], tf.int64),
+ 'image':
+ tf.io.FixedLenFeature([], tf.string),
+ })
+ img = tf.io.decode_raw(features['image'], out_type=tf.uint8)
+ img = tf.cast(tf.reshape(img, (64, 64)), dtype=tf.float32)
+ label = tf.cast(features['label'], tf.int64)
+ return {'image': img, 'label': label}
+
+
+def parse_example_v2(record):
+ """
+ latest version format
+ :param record:
+ :return:
+ """
+ features = tf.io.parse_single_example(record,
+ features={
+ 'width':
+ tf.io.FixedLenFeature([], tf.int64),
+ 'height':
+ tf.io.FixedLenFeature([], tf.int64),
+ 'label':
+ tf.io.FixedLenFeature([], tf.int64),
+ 'image':
+ tf.io.FixedLenFeature([], tf.string),
+ })
+ img = tf.io.decode_raw(features['image'], out_type=tf.uint8)
+ # we can not reshape since it stores with original size
+ w = features['width']
+ h = features['height']
+ img = tf.cast(tf.reshape(img, (w, h)), dtype=tf.float32)
+ label = tf.cast(features['label'], tf.int64)
+ return {'image': img, 'label': label}
+
+
+def load_ds():
+ input_files = ['dataset/HWDB1.1trn_gnt.tfrecord']
+ ds = tf.data.TFRecordDataset(input_files)
+ ds = ds.map(parse_example)
+ return ds
+```
+
+
+
+这个v2的版本就是兼容了新的存入长宽的方式，因为我第一次生成的时候就没有保存。。。最后入坑了。注意这行代码：
+
+```
+ img = tf.io.decode_raw(features['image'], out_type=tf.uint8)
+```
+
+它是对raw bytes进行解码，这个解码跟从文件读取bytes存入tfrecord的有着本质的不同。**同时注意type的变化，这里以unit8的方式解码，因为我们存储进去的就是uint8**.
+
+
+
+## 训练过程
+
+不瞒你说，我一开始写了一个很复杂的模型，训练了大概一个晚上结果准确率0.00012， 发散了。后面改成了更简单的模型才收敛。整个过程的训练pipleline：
+
+
+
+```python
+def train():
+ all_characters = load_characters()
+ num_classes = len(all_characters)
+ logging.info('all characters: {}'.format(num_classes))
+ train_dataset = load_ds()
+ train_dataset = train_dataset.shuffle(100).map(preprocess).batch(32).repeat()
+
+ val_ds = load_val_ds()
+ val_ds = val_ds.shuffle(100).map(preprocess).batch(32).repeat()
+
+ for data in train_dataset.take(2):
+ print(data)
+
+ # init model
+ model = build_net_003((64, 64, 1), num_classes)
+ model.summary()
+ logging.info('model loaded.')
+
+ start_epoch = 0
+ latest_ckpt = tf.train.latest_checkpoint(os.path.dirname(ckpt_path))
+ if latest_ckpt:
+ start_epoch = int(latest_ckpt.split('-')[1].split('.')[0])
+ model.load_weights(latest_ckpt)
+ logging.info('model resumed from: {}, start at epoch: {}'.format(latest_ckpt, start_epoch))
+ else:
+ logging.info('passing resume since weights not there. training from scratch')
+
+ if use_keras_fit:
+ model.compile(
+ optimizer=tf.keras.optimizers.Adam(),
+ loss=tf.keras.losses.SparseCategoricalCrossentropy(),
+ metrics=['accuracy'])
+ callbacks = [
+ tf.keras.callbacks.ModelCheckpoint(ckpt_path,
+ save_weights_only=True,
+ verbose=1,
+ period=500)
+ ]
+ try:
+ model.fit(
+ train_dataset,
+ validation_data=val_ds,
+ validation_steps=1000,
+ epochs=15000,
+ steps_per_epoch=1024,
+ callbacks=callbacks)
+ except KeyboardInterrupt:
+ model.save_weights(ckpt_path.format(epoch=0))
+ logging.info('keras model saved.')
+ model.save_weights(ckpt_path.format(epoch=0))
+ model.save(os.path.join(os.path.dirname(ckpt_path), 'cn_ocr.h5'))
+```
+
+
+
+在本系列教程开篇之际，我们就立下了几条准则，其中一条就是**handle everything**, 从这里就能看出，它事一个很稳健的训练代码，同事也很自动化：
+
+- 自动寻找之前保存的最新模型；
+- 自动保存模型；
+- 捕捉ctrl + c事件保存模型。
+- 支持断点续训练
+
+大家在以后编写训练代码的时候其实可以保持这个好的习惯。
+
+OK，整个模型训练起来之后，可以在短时间内达到95%的准确率：
+
+
+
+
+
+效果还是很不错的！
+
+
+
+## 模型测试
+
+
+
+最后模型训练完了，时候测试一下模型效果到底咋样。我们使用了一些简单的文字来测试：
+
+
+
+
+
+这个字写的还真的。。。。具有鬼神之势。相信普通人类大部分字都能认出来，不过有些字还真的。。。。不好认。看看神经网络的表现怎么样！
+
+
+
+
+
+这是大概2000次训练的结果， 基本上能识别出来了！神经网络的认字能力还不错的! 收工！
+
+
+
+## 总结
+
+通过本教程，我们完成了使用tensorflow 2.0全新的API搭建一个中文汉字手写识别系统。模型基本能够实现我们想要的功能。要知道，这个模型可是在搜索空间多大3755的类别当中准确的找到最相似的类别！！通过本实验，我们有几点心得：
+
+- 神经网络不仅仅是在学习，它具有一定的想象力！！比如它的一些看着很像的字：拜-佯， 扮-捞，笨-苯.... 这些字如果手写出来，连人都比较难以辨认！！但是大家要知道这些字在类别上并不是相领的！也就是说，模型具有一定的联想能力！
+- 不管问题多复杂，要敢于动手、善于动手。
+
+最后希望大家对本文点个赞，编写教程不容易。希望大家多多支持。笨教程将支持为大家输出全新的tensorflow2.0教程！欢迎关注！！
+
+本文所有代码开源在：
+
+https://github.com/jinfagang/ocrcn_tf2.git
+
+
+
+记得随手star哦！！
+
+我们的AI社区：
+
+
+
+http://talk.strangeai.pro
+
+
+
+全球最大的开源AI代码平台：
+
+http://manaai.cn
+
diff --git a/sample.png b/sample.png
deleted file mode 100755
index 24184e1..0000000
Binary files a/sample.png and /dev/null differ
diff --git a/train.py b/train_simple.py
similarity index 75%
rename from train.py
rename to train_simple.py
index f589719..32cb83a 100755
--- a/train.py
+++ b/train_simple.py
@@ -1,11 +1,11 @@
-'''
-training HWDB Chinese charactors classification
-on MobileNetV2
-'''
+"""
+
+training a simple net on Chinese Characters classification dataset
+we got about 90% accuracy by simply applying a simple CNN net
+
+"""
from alfred.dl.tf.common import mute_tf
-
mute_tf()
-
import os
import sys
import numpy as np
@@ -13,8 +13,8 @@ import tensorflow as tf
from alfred.utils.log import logger as logging
import tensorflow_datasets as tfds
-from dataset.casia_hwdb import load_ds, load_characters
-from models.cnn_net import CNNNet, build_net_002
+from dataset.casia_hwdb import load_ds, load_characters, load_val_ds
+from models.cnn_net import CNNNet, build_net_002, build_net_003
@@ -29,10 +29,10 @@ def preprocess(x):
"""
minus mean pixel or normalize?
"""
+ # original is 64x64, add a channel dim
x['image'] = tf.expand_dims(x['image'], axis=-1)
x['image'] = tf.image.resize(x['image'], (target_size, target_size))
- x['image'] /= 255.
- x['image'] = 2 * x['image'] - 1
+ x['image'] = (x['image'] - 128.) / 128.
return x['image'], x['label']
@@ -41,10 +41,16 @@ def train():
num_classes = len(all_characters)
logging.info('all characters: {}'.format(num_classes))
train_dataset = load_ds()
- train_dataset = train_dataset.shuffle(100).map(preprocess).batch(4).repeat()
+ train_dataset = train_dataset.shuffle(100).map(preprocess).batch(32).repeat()
+
+ val_ds = load_val_ds()
+ val_ds = val_ds.shuffle(100).map(preprocess).batch(32).repeat()
+
+ for data in train_dataset.take(2):
+ print(data)
# init model
- model = build_net_002((64, 64, 1), num_classes)
+ model = build_net_003((64, 64, 1), num_classes)
model.summary()
logging.info('model loaded.')
@@ -62,10 +68,20 @@ def train():
optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
+ callbacks = [
+ tf.keras.callbacks.ModelCheckpoint(ckpt_path,
+ save_weights_only=True,
+ verbose=1,
+ period=500)
+ ]
try:
model.fit(
- train_dataset, epochs=50,
- steps_per_epoch=700, )
+ train_dataset,
+ validation_data=val_ds,
+ validation_steps=1000,
+ epochs=15000,
+ steps_per_epoch=1024,
+ callbacks=callbacks)
except KeyboardInterrupt:
model.save_weights(ckpt_path.format(epoch=0))
logging.info('keras model saved.')