mindspore/model_zoo/official/cv/warpctc

• Contents
• • WarpCTC Description
  • Model Architecture
  • Dataset
  • Environment Requirements
  • Quick Start
  • Script Description
  • • Script and Sample Code
    • Script Parameters
    • • Training Script Parameters
      • Parameters Configuration
  • Dataset Preparation
  • • Training Process
    • • Training
      • • Distributed Training
    • Evaluation Process
    • • Evaluation
  • Model Description
  • • Performance
    • • Training Performance
      • Evaluation Performance
  • Description of Random Situation
  • ModelZoo Homepage

Contents

• WarpCTC Description
• Model Architecture
• Dataset
• Environment Requirements
• Quick Start
• Script Description
  • Script and Sample Code
  • Script Parameters
    • Training Script Parameters
    • Parameters Configuration
  • Dataset Preparation
  • Training Process
    • Training
    • Distributed Training
  • Evaluation Process
    • Evaluation
• Model Description
  • Performance
    • Training Performance
    • Evaluation Performance
• Description of Random Situation
• ModelZoo Homepage

WarpCTC Description

This is an example of training WarpCTC with self-generated captcha image dataset in MindSpore.

Model Architecture

WarpCTC is a two-layer stacked LSTM appending with one-layer FC neural network. See src/warpctc.py for details.

Dataset

The dataset is self-generated using a third-party library called captcha, which can randomly generate digits from 0 to 9 in image. In this network, we set the length of digits varying from 1 to 4.

Environment Requirements

• Hardware（Ascend/GPU）
  • Prepare hardware environment with Ascend or GPU processor.
• Framework
  • MindSpore
• For more information, please check the resources below：
  • MindSpore Tutorials
  • MindSpore Python API

Quick Start

• Generate dataset.

  Run the script scripts/run_process_data.sh to generate a dataset. By default, the shell script will generate 10000 test images and 50000 train images separately.

   $ cd scripts
   $ sh run_process_data.sh
  
   # after execution, you will find the dataset like the follows:
   .  
   └─warpctc
     └─data
       ├─ train  # train dataset
       └─ test   # evaluate dataset
  

• After the dataset is prepared, you may start running the training or the evaluation scripts as follows:

  • Running on Ascend

  # distribute training example in Ascend
  $ bash run_distribute_train.sh rank_table.json ../data/train
  
  # evaluation example in Ascend
  $ bash run_eval.sh ../data/test warpctc-30-97.ckpt Ascend
  
  # standalone training example in Ascend
  $ bash run_standalone_train.sh ../data/train Ascend
  
  

  For distributed training, a hccl configuration file with JSON format needs to be created in advance.

  Please follow the instructions in the link below:

  https://gitee.com/mindspore/mindspore/tree/master/model_zoo/utils/hccl_tools.

  • Running on GPU

  # distribute training example in GPU
  $ bash run_distribute_train_for_gpu.sh 8 ../data/train
  
  # standalone training example in GPU
  $ bash run_standalone_train.sh ../data/train GPU
  
  # evaluation example in GPU
  $ bash run_eval.sh ../data/test warpctc-30-97.ckpt GPU
  

Script Description

Script and Sample Code

.
└──warpctc
  ├── README.md
  ├── script
    ├── run_distribute_train.sh         # launch distributed training in Ascend(8 pcs)
    ├── run_distribute_train_for_gpu.sh # launch distributed training in GPU
    ├── run_eval.sh                     # launch evaluation
    ├── run_process_data.sh             # launch dataset generation
    └── run_standalone_train.sh         # launch standalone training(1 pcs)
  ├── src
    ├── config.py                       # parameter configuration
    ├── dataset.py                      # data preprocessing
    ├── loss.py                         # ctcloss definition
    ├── lr_generator.py                 # generate learning rate for each step
    ├── metric.py                       # accuracy metric for warpctc network
    ├── warpctc.py                      # warpctc network definition
    └── warpctc_for_train.py            # warpctc network with grad, loss and gradient clip
  ├── mindspore_hub_conf.py             # mindspore hub interface
  ├── eval.py                           # eval net
  ├── process_data.py                   # dataset generation script
  └── train.py                          # train net

Script Parameters

Training Script Parameters

# distributed training in Ascend
Usage: bash run_distribute_train.sh [RANK_TABLE_FILE] [DATASET_PATH]

# distributed training in GPU
Usage: bash run_distribute_train_for_gpu.sh [RANK_SIZE] [DATASET_PATH]

# standalone training
Usage: bash run_standalone_train.sh [DATASET_PATH] [PLATFORM]

Parameters Configuration

Parameters for both training and evaluation can be set in config.py.

"max_captcha_digits": 4,                    # max number of digits in each
"captcha_width": 160,                       # width of captcha images
"captcha_height": 64,                       # height of capthca images
"batch_size": 64,                           # batch size of input tensor
"epoch_size": 30,                           # only valid for taining, which is always 1 for inference
"hidden_size": 512,                         # hidden size in LSTM layers
"learning_rate": 0.01,                      # initial learning rate
"momentum": 0.9                             # momentum of SGD optimizer
"save_checkpoint": True,                    # whether save checkpoint or not
"save_checkpoint_steps": 97,                # the step interval between two checkpoints. By default, the last checkpoint will be saved after the last step
"keep_checkpoint_max": 30,                  # only keep the last keep_checkpoint_max checkpoint
"save_checkpoint_path": "./checkpoint",     # path to save checkpoint

Dataset Preparation

• You may refer to "Generate dataset" in Quick Start to automatically generate a dataset, or you may choose to generate a captcha dataset by yourself.

Training Process

• Set options in config.py, including learning rate and other network hyperparameters. Click MindSpore dataset preparation tutorial for more information about dataset.

Training

• Run run_standalone_train.sh for non-distributed training of WarpCTC model, either on Ascend or on GPU.

bash run_standalone_train.sh [DATASET_PATH] [PLATFORM]

Distributed Training

• Run run_distribute_train.sh for distributed training of WarpCTC model on Ascend.

bash run_distribute_train.sh [RANK_TABLE_FILE] [DATASET_PATH]

• Run run_distribute_train_gpu.sh for distributed training of WarpCTC model on GPU.

bash run_distribute_train_gpu.sh [RANK_SIZE] [DATASET_PATH]

Evaluation Process

Evaluation

• Run run_eval.sh for evaluation.

bash run_eval.sh [DATASET_PATH] [CHECKPOINT_PATH] [PLATFORM]

Model Description

Performance

Training Performance

Parameters	Ascend 910	GPU
Model Version	v1.0	v1.0
Resource	Ascend 910; CPU 2.60GHz, 192cores; Memory 755G; OS Euler2.8	GPU(Tesla V100 SXM2)，CPU 2.1GHz 24cores，Memory 128G /
uploaded Date	07/01/2020 (month/day/year)	08/01/2020 (month/day/year)
MindSpore Version	0.5.0-alpha	0.6.0-alpha
Dataset	Captcha	Captcha
Training Parameters	epoch=30, steps per epoch=98, batch_size = 64	epoch=30, steps per epoch=98, batch_size = 64
Optimizer	SGD	SGD
Loss Function	CTCLoss	CTCLoss
outputs	probability	probability
Loss	0.0000157	0.0000246
Speed	980ms/step（8pcs）	150ms/step（8pcs）
Total time	30 mins	5 mins
Parameters (M)	2.75	2.75
Checkpoint for Fine tuning	20.3M (.ckpt file)	20.3M (.ckpt file)
Scripts	Link	Link

Evaluation Performance

Parameters	WarpCTC
Model Version	V1.0
Resource	Ascend 910; OS Euler2.8
Uploaded Date	08/01/2020 (month/day/year)
MindSpore Version	0.6.0-alpha
Dataset	Captcha
batch_size	64
outputs	ACC
Accuracy	99.0%
Model for inference	20.3M (.ckpt file)

Description of Random Situation

In dataset.py, we set the seed inside “create_dataset" function. We also use random seed in train.py for weight initialization.

ModelZoo Homepage

Please check the official homepage.