add DB code

.gitignore

@@ -1,3 +1,4 @@
+__pycache__/
 icdar2015_aliocr/
 icdar2015_aliocr_char/
 poly.jpg

DB/.gitignore

@@ -0,0 +1,121 @@
+# Byte-compiled / optimized / DLL files
+*/__pycache__/*
+workspace
+*.py[cod]
+*$py.class
+*.swp
+*.swo
+*.lock
+
+# C extensions
+*.so
+*.nfs*
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+.idea
+log.txt # From the naive evaluating of ICDAR15
+
+# specific directory
+# datasets
+evaluation
+experiments/backup
+lib
+outputs
+results
+*.zip
+*.pyx
+struture/representers/setup.py
+demo_results

DB/README.md

@@ -0,0 +1,195 @@
+## News
+* The ASF module in DBNet++([TPAMI](https://ieeexplore.ieee.org/abstract/document/9726868/), [arxiv](https://arxiv.org/abs/2202.10304)) is released.
+* DB is included in [WeChat OCR engine](https://mp.weixin.qq.com/s/6IGXof3KWVnN8z1i2YOqJA)
+* DB is included in [OpenCV](https://github.com/opencv/opencv/blob/master/doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown)
+* DB is included in [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)
+
+# Introduction
+This is a PyToch implementation of DBNet([arxiv](https://arxiv.org/abs/1911.08947)) and DBNet++([TPAMI](https://ieeexplore.ieee.org/abstract/document/9726868/), [arxiv](https://arxiv.org/abs/2202.10304)).  It presents a real-time arbitrary-shape scene text detector, achieving the state-of-the-art performance on standard benchmarks.
+
+Part of the code is inherited from [MegReader](https://github.com/Megvii-CSG/MegReader).
+
+## ToDo List
+
+- [x] Release code
+- [x] Document for Installation
+- [x] Trained models
+- [x] Document for testing and training
+- [x] Evaluation
+- [x] Demo script
+- [x] Release DBNet++ code
+- [x] Release DBNet++ models
+
+
+
+## Installation
+
+### Requirements:
+- Python3
+- PyTorch == 1.2 
+- GCC >= 4.9 (This is important for PyTorch)
+- CUDA >= 9.0 (10.1 is recommended)
+
+
+```bash
+  # first, make sure that your conda is setup properly with the right environment
+  # for that, check that `which conda`, `which pip` and `which python` points to the
+  # right path. From a clean conda env, this is what you need to do
+
+  conda create --name DB -y
+  conda activate DB
+
+  # this installs the right pip and dependencies for the fresh python
+  conda install ipython pip
+
+  # python dependencies
+  pip install -r requirement.txt
+
+  # install PyTorch with cuda-10.1
+  conda install pytorch torchvision cudatoolkit=10.1 -c pytorch
+
+  # clone repo
+  git clone https://github.com/MhLiao/DB.git
+  cd DB/
+
+  # build deformable convolution opertor
+  # make sure your cuda path of $CUDA_HOME is the same version as your cuda in PyTorch
+  # make sure GCC >= 4.9
+  # you need to delete the build directory before you re-build it.
+  echo $CUDA_HOME
+  cd assets/ops/dcn/
+  python setup.py build_ext --inplace
+
+```
+
+## Models
+New: DBNet++ trained models [Google Drive](https://drive.google.com/drive/folders/1buwe_b6ysoZFCJgHMHIr-yHd-hEivQRK?usp=sharing).
+
+Download Trained models [Baidu Drive](https://pan.baidu.com/s/1vxcdpOswTK6MxJyPIJlBkA) (download code: p6u3), [Google Drive](https://drive.google.com/open?id=1T9n0HTP3X3Y_nJ0D1ekMhCQRHntORLJG).
+```
+  pre-trained-model-synthtext   -- used to finetune models, not for evaluation
+  td500_resnet18
+  td500_resnet50
+  totaltext_resnet18
+  totaltext_resnet50
+```
+
+## Datasets
+The root of the dataset directory can be ```DB/datasets/```.
+
+Download the converted ground-truth and data list [Baidu Drive](https://pan.baidu.com/s/1BPYxcZnLXN87rQKmz9PFYA) (download code: mz0a), [Google Drive](https://drive.google.com/open?id=12ozVTiBIqK8rUFWLUrlquNfoQxL2kAl7). The images of each dataset can be obtained from their official website.
+
+## Testing
+### Prepar dataset
+An example of the path of test images: 
+```
+  datasets/total_text/train_images
+  datasets/total_text/train_gts
+  datasets/total_text/train_list.txt
+  datasets/total_text/test_images
+  datasets/total_text/test_gts
+  datasets/total_text/test_list.txt
+```
+The data root directory and the data list file can be defined in ```base_totaltext.yaml```
+
+### Config file
+**The YAML files with the name of ```base*.yaml``` should not be used as the training or testing config file directly.**
+
+### Demo
+Run the model inference with a single image. Here is an example:
+
+```CUDA_VISIBLE_DEVICES=0 python demo.py experiments/seg_detector/totaltext_resnet18_deform_thre.yaml --image_path datasets/total_text/test_images/img10.jpg --resume path-to-model-directory/totaltext_resnet18 --polygon --box_thresh 0.7 --visualize```
+
+The results can be find in `demo_results`.
+
+### Evaluate the performance
+Note that we do not provide all the protocols for all benchmarks for simplification. The embedded evaluation protocol in the code is modified from the protocol of ICDAR 2015 dataset while support arbitrary-shape polygons. It almost produces the same results as the pascal evaluation protocol in Total-Text dataset. 
+
+The `img651.jpg` in the test set of Total-Text contains exif info for a 90° rotation thus the gt does not match the image. You should read and re-write this image to get normal results. The converted image is also provided in the dataset links. 
+
+The following command can re-implement the results in the paper:
+
+```
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/totaltext_resnet18_deform_thre.yaml --resume path-to-model-directory/totaltext_resnet18 --polygon --box_thresh 0.7
+
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/totaltext_resnet50_deform_thre.yaml --resume path-to-model-directory/totaltext_resnet50 --polygon --box_thresh 0.6
+
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/td500_resnet18_deform_thre.yaml --resume path-to-model-directory/td500_resnet18 --box_thresh 0.5
+
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/td500_resnet50_deform_thre.yaml --resume path-to-model-directory/td500_resnet50 --box_thresh 0.5
+
+# short side 736, which can be changed in base_ic15.yaml
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/ic15_resnet18_deform_thre.yaml --resume path-to-model-directory/ic15_resnet18 --box_thresh 0.55
+
+# short side 736, which can be changed in base_ic15.yaml
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/ic15_resnet50_deform_thre.yaml --resume path-to-model-directory/ic15_resnet50 --box_thresh 0.6
+
+# short side 1152, which can be changed in base_ic15.yaml
+CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/ic15_resnet50_deform_thre.yaml --resume path-to-model-directory/ic15_resnet50 --box_thresh 0.6
+```
+
+The results should be as follows:
+
+|        Model       	| precision 	| recall 	| F-measure 	| precision (paper) 	| recall (paper) 	| F-measure (paper) 	|
+|:------------------:	|:---------:	|:------:	|:---------:	|:-----------------:	|:--------------:	|:-----------------:	|
+| totaltext-resnet18 	|    88.9   	|  77.6  	|    82.9   	|        88.3       	|      77.9      	|        82.8       	|
+| totaltext-resnet50 	|    88.0   	|  81.5  	|    84.6   	|        87.1       	|      82.5      	|        84.7       	|
+|   td500-resnet18   	|    86.5   	|  79.4  	|    82.8   	|        90.4       	|      76.3      	|        82.8       	|
+|   td500-resnet50   	|    91.1   	|  80.8  	|    85.6   	|        91.5       	|      79.2      	|        84.9       	|
+| ic15-resnet18 (736) |    87.7   	|  77.5  	|    82.3   	|        86.8       	|      78.4     	|        82.3       	|
+| ic15-resnet50 (736) |    91.3   	|  80.3  	|    85.4   	|        88.2       	|      82.7      	|        85.4       	|
+| ic15-resnet50 (1152)|    90.7   	|  84.0  	|    87.2   	|        91.8      	  |      83.2      	|        87.3       	|
+
+
+```box_thresh``` can be used to balance the precision and recall, which may be different for different datasets to get a good F-measure. ```polygon``` is only used for arbitrary-shape text dataset. The size of the input images are defined in ```validate_data->processes->AugmentDetectionData``` in ```base_*.yaml```.
+
+### Evaluate the speed 
+Set ```adaptive``` to ```False``` in the yaml file to speedup the inference without decreasing the performance. The speed is evaluated by performing a testing image for 50 times to exclude extra IO time.
+
+```CUDA_VISIBLE_DEVICES=0 python eval.py experiments/seg_detector/totaltext_resnet18_deform_thre.yaml --resume path-to-model-directory/totaltext_resnet18 --polygon --box_thresh 0.7 --speed```
+
+Note that the speed is related to both to the GPU and the CPU since the model runs with the GPU and the post-processing algorithm runs with the CPU.
+
+## Training
+Check the paths of data_dir and data_list in the base_*.yaml file. For better performance, you can first per-train the model with SynthText and then fine-tune it with the specific real-world dataset.
+
+```CUDA_VISIBLE_DEVICES=0,1,2,3 python train.py path-to-yaml-file --num_gpus 4```
+
+You can also try distributed training (**Note that the distributed mode is not fully tested. I am not sure whether it can achieves the same performance as non-distributed training.**)
+
+```CUDA_VISIBLE_DEVICES=0,1,2,3 python -m torch.distributed.launch --nproc_per_node=4 train.py path-to-yaml-file --num_gpus 4```
+
+## Improvements
+Note that the current implementation is written by pure Python code except for the deformable convolution operator. Thus, the code can be further optimized by some optimization skills, such as [TensorRT](https://github.com/NVIDIA/TensorRT) for the model forward and efficient C++ code for the [post-processing function](https://github.com/MhLiao/DB/blob/d0d855df1c66b002297885a089a18d50a265fa30/structure/representers/seg_detector_representer.py#L26).
+
+Another option to increase speed is to run the model forward and the post-processing algorithm in parallel through a producer-consumer strategy.
+
+Contributions or pull requests are welcome.
+
+## Third-party implementations
+* Keras implementation: [xuannianz/DifferentiableBinarization](https://github.com/xuannianz/DifferentiableBinarization)
+* DB is included in [OpenCV](https://github.com/opencv/opencv/blob/master/doc/tutorials/dnn/dnn_text_spotting/dnn_text_spotting.markdown)
+* DB is included in [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)
+
+## Citing the related works
+
+Please cite the related works in your publications if it helps your research:
+
+     @inproceedings{liao2020real,
+      author={Liao, Minghui and Wan, Zhaoyi and Yao, Cong and Chen, Kai and Bai, Xiang},
+      title={Real-time Scene Text Detection with Differentiable Binarization},
+      booktitle={Proc. AAAI},
+      year={2020}
+    }
+
+    @article{liao2022real,
+      title={Real-Time Scene Text Detection with Differentiable Binarization and Adaptive Scale Fusion},
+      author={Liao, Minghui and Zou, Zhisheng and Wan, Zhaoyi and Yao, Cong and Bai, Xiang},
+      journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
+      year={2022},
+      publisher={IEEE}
+    }
+
+
+    
+

DB/assets/ic15_eval/rrc_evaluation_funcs.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python2
+#encoding: UTF-8
+import json
+import sys;sys.path.append('./')
+import zipfile
+import re
+import sys
+import os
+import codecs
+import importlib
+from StringIO import StringIO
+
+def print_help():
+    sys.stdout.write('Usage: python %s.py -g=<gtFile> -s=<submFile> [-o=<outputFolder> -p=<jsonParams>]' %sys.argv[0])
+    sys.exit(2)
+    
+
+def load_zip_file_keys(file,fileNameRegExp=''):
+    """
+    Returns an array with the entries of the ZIP file that match with the regular expression.
+    The key's are the names or the file or the capturing group definied in the fileNameRegExp
+    """
+    try:
+        archive=zipfile.ZipFile(file, mode='r', allowZip64=True)
+    except :
+        raise Exception('Error loading the ZIP archive.')
+
+    pairs = []
+    
+    for name in archive.namelist():
+        addFile = True
+        keyName = name
+        if fileNameRegExp!="":
+            m = re.match(fileNameRegExp,name)
+            if m == None:
+                addFile = False
+            else:
+                if len(m.groups())>0:
+                    keyName = m.group(1)
+                    
+        if addFile:
+            pairs.append( keyName )
+                
+    return pairs
+    
+
+def load_zip_file(file,fileNameRegExp='',allEntries=False):
+    """
+    Returns an array with the contents (filtered by fileNameRegExp) of a ZIP file.
+    The key's are the names or the file or the capturing group definied in the fileNameRegExp
+    allEntries validates that all entries in the ZIP file pass the fileNameRegExp
+    """
+    try:
+        archive=zipfile.ZipFile(file, mode='r', allowZip64=True)
+    except :
+        raise Exception('Error loading the ZIP archive')    
+
+    pairs = []
+    for name in archive.namelist():
+        addFile = True
+        keyName = name
+        if fileNameRegExp!="":
+            m = re.match(fileNameRegExp,name)
+            if m == None:
+                addFile = False
+            else:
+                if len(m.groups())>0:
+                    keyName = m.group(1)
+        
+        if addFile:
+            pairs.append( [ keyName , archive.read(name)] )
+        else:
+            if allEntries:
+                raise Exception('ZIP entry not valid: %s' %name)             
+
+    return dict(pairs)
+	
+def decode_utf8(raw):
+    """
+    Returns a Unicode object on success, or None on failure
+    """
+    try:
+        raw = codecs.decode(raw,'utf-8', 'replace')
+        #extracts BOM if exists
+        raw = raw.encode('utf8')
+        if raw.startswith(codecs.BOM_UTF8):
+            raw = raw.replace(codecs.BOM_UTF8, '', 1)
+        return raw.decode('utf-8')
+    except:
+       return None
+   
+def validate_lines_in_file(fileName,file_contents,CRLF=True,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0):
+    """
+    This function validates that all lines of the file calling the Line validation function for each line
+    """
+    utf8File = decode_utf8(file_contents)
+    if (utf8File is None) :
+        raise Exception("The file %s is not UTF-8" %fileName)
+
+    lines = utf8File.split( "\r\n" if CRLF else "\n" )
+    for line in lines:
+        line = line.replace("\r","").replace("\n","")
+        if(line != ""):
+            try:
+                validate_tl_line(line,LTRB,withTranscription,withConfidence,imWidth,imHeight)
+            except Exception as e:
+                raise Exception(("Line in sample not valid. Sample: %s Line: %s Error: %s" %(fileName,line,str(e))).encode('utf-8', 'replace'))
+    
+   
+   
+def validate_tl_line(line,LTRB=True,withTranscription=True,withConfidence=True,imWidth=0,imHeight=0):
+    """
+    Validate the format of the line. If the line is not valid an exception will be raised.
+    If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+    Posible values are:
+    LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription] 
+    LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription] 
+    """
+    get_tl_line_values(line,LTRB,withTranscription,withConfidence,imWidth,imHeight)
+    
+   
+def get_tl_line_values(line,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0):
+    """
+    Validate the format of the line. If the line is not valid an exception will be raised.
+    If maxWidth and maxHeight are specified, all points must be inside the imgage bounds.
+    Posible values are:
+    LTRB=True: xmin,ymin,xmax,ymax[,confidence][,transcription] 
+    LTRB=False: x1,y1,x2,y2,x3,y3,x4,y4[,confidence][,transcription] 
+    Returns values from a textline. Points , [Confidences], [Transcriptions]
+    """
+    confidence = 0.0
+    transcription = "";
+    points = []
+    
+    numPoints = 4;
+    
+    if LTRB:
+    
+        numPoints = 4;
+        
+        if withTranscription and withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+            if m == None :
+                m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence,transcription")
+        elif withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-1].?[0-9]*)\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,confidence")
+        elif withTranscription:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,(.*)$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax,transcription")
+        else:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,?\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: xmin,ymin,xmax,ymax")
+            
+        xmin = int(m.group(1))
+        ymin = int(m.group(2))
+        xmax = int(m.group(3))
+        ymax = int(m.group(4))
+        if(xmax<xmin):
+                raise Exception("Xmax value (%s) not valid (Xmax < Xmin)." %(xmax))
+        if(ymax<ymin):
+                raise Exception("Ymax value (%s)  not valid (Ymax < Ymin)." %(ymax))  
+
+        points = [ float(m.group(i)) for i in range(1, (numPoints+1) ) ]
+        
+        if (imWidth>0 and imHeight>0):
+            validate_point_inside_bounds(xmin,ymin,imWidth,imHeight);
+            validate_point_inside_bounds(xmax,ymax,imWidth,imHeight);
+
+    else:
+        
+        numPoints = 8;
+        
+        if withTranscription and withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-1].?[0-9]*)\s*,(.*)$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence,transcription")
+        elif withConfidence:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*([0-1].?[0-9]*)\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,confidence")
+        elif withTranscription:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,(.*)$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4,transcription")
+        else:
+            m = re.match(r'^\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*$',line)
+            if m == None :
+                raise Exception("Format incorrect. Should be: x1,y1,x2,y2,x3,y3,x4,y4")
+            
+        points = [ float(m.group(i)) for i in range(1, (numPoints+1) ) ]
+        
+        validate_clockwise_points(points)
+        
+        if (imWidth>0 and imHeight>0):
+            validate_point_inside_bounds(points[0],points[1],imWidth,imHeight);
+            validate_point_inside_bounds(points[2],points[3],imWidth,imHeight);
+            validate_point_inside_bounds(points[4],points[5],imWidth,imHeight);
+            validate_point_inside_bounds(points[6],points[7],imWidth,imHeight);
+            
+    
+    if withConfidence:
+        try:
+            confidence = float(m.group(numPoints+1))
+        except ValueError:
+            raise Exception("Confidence value must be a float")       
+            
+    if withTranscription:
+        posTranscription = numPoints + (2 if withConfidence else 1)
+        transcription = m.group(posTranscription)
+        m2 = re.match(r'^\s*\"(.*)\"\s*$',transcription)
+        if m2 != None : #Transcription with double quotes, we extract the value and replace escaped characters
+            transcription = m2.group(1).replace("\\\\", "\\").replace("\\\"", "\"")
+    
+    return points,confidence,transcription
+    
+            
+def validate_point_inside_bounds(x,y,imWidth,imHeight):
+    if(x<0 or x>imWidth):
+            raise Exception("X value (%s) not valid. Image dimensions: (%s,%s)" %(xmin,imWidth,imHeight))
+    if(y<0 or y>imHeight):
+            raise Exception("Y value (%s)  not valid. Image dimensions: (%s,%s) Sample: %s Line:%s" %(ymin,imWidth,imHeight))
+
+def validate_clockwise_points(points):
+    """
+    Validates that the points that the 4 points that dlimite a polygon are in clockwise order.
+    """
+    
+    if len(points) != 8:
+        raise Exception("Points list not valid." + str(len(points)))
+    
+    point = [
+                [int(points[0]) , int(points[1])],
+                [int(points[2]) , int(points[3])],
+                [int(points[4]) , int(points[5])],
+                [int(points[6]) , int(points[7])]
+            ]
+    edge = [
+                ( point[1][0] - point[0][0])*( point[1][1] + point[0][1]),
+                ( point[2][0] - point[1][0])*( point[2][1] + point[1][1]),
+                ( point[3][0] - point[2][0])*( point[3][1] + point[2][1]),
+                ( point[0][0] - point[3][0])*( point[0][1] + point[3][1])
+    ]
+    
+    summatory = edge[0] + edge[1] + edge[2] + edge[3];
+    if summatory>0:
+        raise Exception("Points are not clockwise. The coordinates of bounding quadrilaterals have to be given in clockwise order. Regarding the correct interpretation of 'clockwise' remember that the image coordinate system used is the standard one, with the image origin at the upper left, the X axis extending to the right and Y axis extending downwards.")
+
+def get_tl_line_values_from_file_contents(content,CRLF=True,LTRB=True,withTranscription=False,withConfidence=False,imWidth=0,imHeight=0,sort_by_confidences=True):
+    """
+    Returns all points, confindences and transcriptions of a file in lists. Valid line formats:
+    xmin,ymin,xmax,ymax,[confidence],[transcription]
+    x1,y1,x2,y2,x3,y3,x4,y4,[confidence],[transcription]
+    """
+    pointsList = []
+    transcriptionsList = []
+    confidencesList = []
+    
+    lines = content.split( "\r\n" if CRLF else "\n" )
+    for line in lines:
+        line = line.replace("\r","").replace("\n","")
+        if(line != "") :
+            points, confidence, transcription = get_tl_line_values(line,LTRB,withTranscription,withConfidence,imWidth,imHeight);
+            pointsList.append(points)
+            transcriptionsList.append(transcription)
+            confidencesList.append(confidence)
+
+    if withConfidence and len(confidencesList)>0 and sort_by_confidences:
+        import numpy as np
+        sorted_ind = np.argsort(-np.array(confidencesList))
+        confidencesList = [confidencesList[i] for i in sorted_ind]
+        pointsList = [pointsList[i] for i in sorted_ind]
+        transcriptionsList = [transcriptionsList[i] for i in sorted_ind]        
+        
+    return pointsList,confidencesList,transcriptionsList
+
+def main_evaluation(p,default_evaluation_params_fn,validate_data_fn,evaluate_method_fn,show_result=True,per_sample=True):
+    """
+    This process validates a method, evaluates it and if it succed generates a ZIP file with a JSON entry for each sample.
+    Params:
+    p: Dictionary of parmeters with the GT/submission locations. If None is passed, the parameters send by the system are used.
+    default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation
+    validate_data_fn: points to a method that validates the corrct format of the submission
+    evaluate_method_fn: points to a function that evaluated the submission and return a Dictionary with the results
+    """
+    
+    if (p == None):
+        p = dict([s[1:].split('=') for s in sys.argv[2:]])
+        model_name=sys.argv[1].split('=')[-1]
+        if(len(sys.argv)<4):
+            print_help()
+
+    evalParams = default_evaluation_params_fn()
+    if 'p' in p.keys():
+        evalParams.update( p['p'] if isinstance(p['p'], dict) else json.loads(p['p'][1:-1]) )
+
+    resDict={'calculated':True,'Message':'','method':'{}','per_sample':'{}'}    
+    try:
+        validate_data_fn(p['g'], p['s'], evalParams)  
+        evalData = evaluate_method_fn(p['g'], p['s'], evalParams)
+        resDict.update(evalData)
+        
+    except Exception, e:
+        resDict['Message']= str(e)
+        resDict['calculated']=False
+
+    if 'o' in p:
+        if not os.path.exists(p['o']):
+            os.makedirs(p['o'])
+
+        resultsOutputname = p['o'] + '/results.zip'
+        outZip = zipfile.ZipFile(resultsOutputname, mode='w', allowZip64=True)
+
+        del resDict['per_sample']
+        if 'output_items' in resDict.keys():
+            del resDict['output_items']
+
+        outZip.writestr('method.json',json.dumps(resDict))
+        
+    if not resDict['calculated']:
+        if show_result:
+            sys.stderr.write('Error!\n'+ resDict['Message']+'\n\n')
+        if 'o' in p:
+            outZip.close()
+        return resDict
+    
+    if 'o' in p:
+        if per_sample == True:
+            for k,v in evalData['per_sample'].iteritems():
+                outZip.writestr( k + '.json',json.dumps(v)) 
+
+            if 'output_items' in evalData.keys():
+                for k, v in evalData['output_items'].iteritems():
+                    outZip.writestr( k,v) 
+
+        outZip.close()
+
+    if show_result:
+        sys.stdout.write("Calculated!")
+        sys.stdout.write(json.dumps(resDict['method']))
+    
+    return resDict,model_name
+
+
+def main_validation(default_evaluation_params_fn,validate_data_fn):
+    """
+    This process validates a method
+    Params:
+    default_evaluation_params_fn: points to a function that returns a dictionary with the default parameters used for the evaluation
+    validate_data_fn: points to a method that validates the corrct format of the submission
+    """    
+    try:
+        p = dict([s[1:].split('=') for s in sys.argv[1:]])
+        evalParams = default_evaluation_params_fn()
+        if 'p' in p.keys():
+            evalParams.update( p['p'] if isinstance(p['p'], dict) else json.loads(p['p'][1:-1]) )
+
+        validate_data_fn(p['g'], p['s'], evalParams)              
+        print 'SUCCESS'
+        sys.exit(0)
+    except Exception as e:
+        print str(e)
+        sys.exit(101)

DB/assets/ic15_eval/script.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from collections import namedtuple
+import rrc_evaluation_funcs
+import importlib
+import json
+def evaluation_imports():
+    """
+    evaluation_imports: Dictionary ( key = module name , value = alias  )  with python modules used in the evaluation. 
+    """    
+    return {
+            'Polygon':'plg',
+            'numpy':'np'
+            }
+
+def default_evaluation_params():
+    """
+    default_evaluation_params: Default parameters to use for the validation and evaluation.
+    """
+    return {
+                'IOU_CONSTRAINT' :0.5,
+                'AREA_PRECISION_CONSTRAINT' :0.5,
+                'GT_SAMPLE_NAME_2_ID':'gt_img_([0-9]+).txt',
+                'DET_SAMPLE_NAME_2_ID':'res_img_([0-9]+).txt',
+                'LTRB':False, #LTRB:2points(left,top,right,bottom) or 4 points(x1,y1,x2,y2,x3,y3,x4,y4)
+                'CRLF':False, # Lines are delimited by Windows CRLF format
+                'CONFIDENCES':False, #Detections must include confidence value. AP will be calculated
+                'PER_SAMPLE_RESULTS':True #Generate per sample results and produce data for visualization
+            }
+
+def validate_data(gtFilePath, submFilePath,evaluationParams):
+    """
+    Method validate_data: validates that all files in the results folder are correct (have the correct name contents).
+                            Validates also that there are no missing files in the folder.
+                            If some error detected, the method raises the error
+    """
+    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath,evaluationParams['GT_SAMPLE_NAME_2_ID'])
+
+    subm = rrc_evaluation_funcs.load_zip_file(submFilePath,evaluationParams['DET_SAMPLE_NAME_2_ID'],True)
+    
+    #Validate format of GroundTruth
+    for k in gt:
+        rrc_evaluation_funcs.validate_lines_in_file(k,gt[k],evaluationParams['CRLF'],evaluationParams['LTRB'],True)
+
+    #Validate format of results
+    for k in subm:
+        if (k in gt) == False :
+            raise Exception("The sample %s not present in GT" %k)
+        
+        rrc_evaluation_funcs.validate_lines_in_file(k,subm[k],evaluationParams['CRLF'],evaluationParams['LTRB'],False,evaluationParams['CONFIDENCES'])
+
+    
+def evaluate_method(gtFilePath, submFilePath, evaluationParams):
+    """
+    Method evaluate_method: evaluate method and returns the results
+        Results. Dictionary with the following values:
+        - method (required)  Global method metrics. Ex: { 'Precision':0.8,'Recall':0.9 }
+        - samples (optional) Per sample metrics. Ex: {'sample1' : { 'Precision':0.8,'Recall':0.9 } , 'sample2' : { 'Precision':0.8,'Recall':0.9 }
+    """    
+    
+    for module,alias in evaluation_imports().iteritems():
+        globals()[alias] = importlib.import_module(module)    
+    
+    def polygon_from_points(points):
+        """
+        Returns a Polygon object to use with the Polygon2 class from a list of 8 points: x1,y1,x2,y2,x3,y3,x4,y4
+        """        
+        resBoxes=np.empty([1,8],dtype='int32')
+        resBoxes[0,0]=int(points[0])
+        resBoxes[0,4]=int(points[1])
+        resBoxes[0,1]=int(points[2])
+        resBoxes[0,5]=int(points[3])
+        resBoxes[0,2]=int(points[4])
+        resBoxes[0,6]=int(points[5])
+        resBoxes[0,3]=int(points[6])
+        resBoxes[0,7]=int(points[7])
+        pointMat = resBoxes[0].reshape([2,4]).T
+        return plg.Polygon( pointMat)    
+    
+    def rectangle_to_polygon(rect):
+        resBoxes=np.empty([1,8],dtype='int32')
+        resBoxes[0,0]=int(rect.xmin)
+        resBoxes[0,4]=int(rect.ymax)
+        resBoxes[0,1]=int(rect.xmin)
+        resBoxes[0,5]=int(rect.ymin)
+        resBoxes[0,2]=int(rect.xmax)
+        resBoxes[0,6]=int(rect.ymin)
+        resBoxes[0,3]=int(rect.xmax)
+        resBoxes[0,7]=int(rect.ymax)
+
+        pointMat = resBoxes[0].reshape([2,4]).T
+        
+        return plg.Polygon( pointMat)
+    
+    def rectangle_to_points(rect):
+        points = [int(rect.xmin), int(rect.ymax), int(rect.xmax), int(rect.ymax), int(rect.xmax), int(rect.ymin), int(rect.xmin), int(rect.ymin)]
+        return points
+        
+    def get_union(pD,pG):
+        areaA = pD.area();
+        areaB = pG.area();
+        return areaA + areaB - get_intersection(pD, pG);
+        
+    def get_intersection_over_union(pD,pG):
+        try:
+            return get_intersection(pD, pG) / get_union(pD, pG);
+        except:
+            return 0
+        
+    def get_intersection(pD,pG):
+        pInt = pD & pG
+        if len(pInt) == 0:
+            return 0
+        return pInt.area()
+    
+    def compute_ap(confList, matchList,numGtCare):
+        correct = 0
+        AP = 0
+        if len(confList)>0:
+            confList = np.array(confList)
+            matchList = np.array(matchList)
+            sorted_ind = np.argsort(-confList)
+            confList = confList[sorted_ind]
+            matchList = matchList[sorted_ind]
+            for n in range(len(confList)):
+                match = matchList[n]
+                if match:
+                    correct += 1
+                    AP += float(correct)/(n + 1)
+
+            if numGtCare>0:
+                AP /= numGtCare
+            
+        return AP
+    
+    perSampleMetrics = {}
+    
+    matchedSum = 0
+    
+    Rectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')
+    
+    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath,evaluationParams['GT_SAMPLE_NAME_2_ID'])
+    subm = rrc_evaluation_funcs.load_zip_file(submFilePath,evaluationParams['DET_SAMPLE_NAME_2_ID'],True)
+   
+    numGlobalCareGt = 0;
+    numGlobalCareDet = 0;
+    
+    arrGlobalConfidences = [];
+    arrGlobalMatches = [];
+
+    for resFile in gt:
+        
+        gtFile = rrc_evaluation_funcs.decode_utf8(gt[resFile])
+        recall = 0
+        precision = 0
+        hmean = 0    
+        
+        detMatched = 0
+        
+        iouMat = np.empty([1,1])
+        
+        gtPols = []
+        detPols = []
+        
+        gtPolPoints = []
+        detPolPoints = []  
+        
+        #Array of Ground Truth Polygons' keys marked as don't Care
+        gtDontCarePolsNum = []
+        #Array of Detected Polygons' matched with a don't Care GT
+        detDontCarePolsNum = []   
+        
+        pairs = [] 
+        detMatchedNums = []
+        
+        arrSampleConfidences = [];
+        arrSampleMatch = [];
+        sampleAP = 0;
+
+        evaluationLog = ""
+        
+        pointsList,_,transcriptionsList = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(gtFile,evaluationParams['CRLF'],evaluationParams['LTRB'],True,False)
+        for n in range(len(pointsList)):
+            points = pointsList[n]
+            transcription = transcriptionsList[n]
+            dontCare = transcription == "###"
+            if evaluationParams['LTRB']:
+                gtRect = Rectangle(*points)
+                gtPol = rectangle_to_polygon(gtRect)
+            else:
+                gtPol = polygon_from_points(points)
+            gtPols.append(gtPol)
+            gtPolPoints.append(points)
+            if dontCare:
+                gtDontCarePolsNum.append( len(gtPols)-1 )
+                
+        evaluationLog += "GT polygons: " + str(len(gtPols)) + (" (" + str(len(gtDontCarePolsNum)) + " don't care)\n" if len(gtDontCarePolsNum)>0 else "\n")
+        
+        if resFile in subm:
+            
+            detFile = rrc_evaluation_funcs.decode_utf8(subm[resFile]) 
+            
+            pointsList,confidencesList,_ = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(detFile,evaluationParams['CRLF'],evaluationParams['LTRB'],False,evaluationParams['CONFIDENCES'])
+            for n in range(len(pointsList)):
+                points = pointsList[n]
+                
+                if evaluationParams['LTRB']:
+                    detRect = Rectangle(*points)
+                    detPol = rectangle_to_polygon(detRect)
+                else:
+                    detPol = polygon_from_points(points)                    
+                detPols.append(detPol)
+                detPolPoints.append(points)
+                if len(gtDontCarePolsNum)>0 :
+                    for dontCarePol in gtDontCarePolsNum:
+                        dontCarePol = gtPols[dontCarePol]
+                        intersected_area = get_intersection(dontCarePol,detPol)
+                        pdDimensions = detPol.area()
+                        precision = 0 if pdDimensions == 0 else intersected_area / pdDimensions
+                        if (precision > evaluationParams['AREA_PRECISION_CONSTRAINT'] ):
+                            detDontCarePolsNum.append( len(detPols)-1 )
+                            break
+                                
+            evaluationLog += "DET polygons: " + str(len(detPols)) + (" (" + str(len(detDontCarePolsNum)) + " don't care)\n" if len(detDontCarePolsNum)>0 else "\n")
+            
+            if len(gtPols)>0 and len(detPols)>0:
+                #Calculate IoU and precision matrixs
+                outputShape=[len(gtPols),len(detPols)]
+                iouMat = np.empty(outputShape)
+                gtRectMat = np.zeros(len(gtPols),np.int8)
+                detRectMat = np.zeros(len(detPols),np.int8)
+                for gtNum in range(len(gtPols)):
+                    for detNum in range(len(detPols)):
+                        pG = gtPols[gtNum]
+                        pD = detPols[detNum]
+                        iouMat[gtNum,detNum] = get_intersection_over_union(pD,pG)
+
+                for gtNum in range(len(gtPols)):
+                    for detNum in range(len(detPols)):
+                        if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCarePolsNum and detNum not in detDontCarePolsNum :
+                            if iouMat[gtNum,detNum]>evaluationParams['IOU_CONSTRAINT']:
+                                gtRectMat[gtNum] = 1
+                                detRectMat[detNum] = 1
+                                detMatched += 1
+                                pairs.append({'gt':gtNum,'det':detNum})
+                                detMatchedNums.append(detNum)
+                                evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + "\n"
+
+            if evaluationParams['CONFIDENCES']:
+                for detNum in range(len(detPols)):
+                    if detNum not in detDontCarePolsNum :
+                        #we exclude the don't care detections
+                        match = detNum in detMatchedNums
+
+                        arrSampleConfidences.append(confidencesList[detNum])
+                        arrSampleMatch.append(match)
+
+                        arrGlobalConfidences.append(confidencesList[detNum]);
+                        arrGlobalMatches.append(match);
+                            
+        numGtCare = (len(gtPols) - len(gtDontCarePolsNum))
+        numDetCare = (len(detPols) - len(detDontCarePolsNum))
+        if numGtCare == 0:
+            recall = float(1)
+            precision = float(0) if numDetCare >0 else float(1)
+            sampleAP = precision
+        else:
+            recall = float(detMatched) / numGtCare
+            precision = 0 if numDetCare==0 else float(detMatched) / numDetCare
+            if evaluationParams['CONFIDENCES'] and evaluationParams['PER_SAMPLE_RESULTS']:
+                sampleAP = compute_ap(arrSampleConfidences, arrSampleMatch, numGtCare )                    
+
+        hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)                
+
+        matchedSum += detMatched
+        numGlobalCareGt += numGtCare
+        numGlobalCareDet += numDetCare
+        
+        if evaluationParams['PER_SAMPLE_RESULTS']:
+            perSampleMetrics[resFile] = {
+                                            'precision':precision,
+                                            'recall':recall,
+                                            'hmean':hmean,
+                                            'pairs':pairs,
+                                            'AP':sampleAP,
+                                            'iouMat':[] if len(detPols)>100 else iouMat.tolist(),
+                                            'gtPolPoints':gtPolPoints,
+                                            'detPolPoints':detPolPoints,
+                                            'gtDontCare':gtDontCarePolsNum,
+                                            'detDontCare':detDontCarePolsNum,
+                                            'evaluationParams': evaluationParams,
+                                            'evaluationLog': evaluationLog                                        
+                                        }
+                                    
+    # Compute MAP and MAR
+    AP = 0
+    if evaluationParams['CONFIDENCES']:
+        AP = compute_ap(arrGlobalConfidences, arrGlobalMatches, numGlobalCareGt)
+
+    methodRecall = 0 if numGlobalCareGt == 0 else float(matchedSum)/numGlobalCareGt
+    methodPrecision = 0 if numGlobalCareDet == 0 else float(matchedSum)/numGlobalCareDet
+    methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
+    
+    methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean, 'AP': AP  }
+
+    resDict = {'calculated':True,'Message':'','method': methodMetrics,'per_sample': perSampleMetrics}
+    
+    
+    return resDict;
+
+
+
+if __name__=='__main__':
+    res_dict,model_name=rrc_evaluation_funcs.main_evaluation(None,default_evaluation_params,validate_data,evaluate_method)
+    with open('./log.txt','a') as f:
+        f.write(model_name+':'+json.dumps(res_dict['method'])+'\n')

DB/assets/ops/dcn/__init__.py

@@ -0,0 +1,13 @@
+from .functions.deform_conv import deform_conv, modulated_deform_conv
+from .functions.deform_pool import deform_roi_pooling
+from .modules.deform_conv import (DeformConv, ModulatedDeformConv,
+                                  DeformConvPack, ModulatedDeformConvPack)
+from .modules.deform_pool import (DeformRoIPooling, DeformRoIPoolingPack,
+                                  ModulatedDeformRoIPoolingPack)
+
+__all__ = [
+    'DeformConv', 'DeformConvPack', 'ModulatedDeformConv',
+    'ModulatedDeformConvPack', 'DeformRoIPooling', 'DeformRoIPoolingPack',
+    'ModulatedDeformRoIPoolingPack', 'deform_conv', 'modulated_deform_conv',
+    'deform_roi_pooling'
+]

DB/assets/ops/dcn/functions/deform_conv.py

@@ -0,0 +1,181 @@
+import torch
+from torch.autograd import Function
+from torch.nn.modules.utils import _pair
+
+from .. import deform_conv_cuda
+
+
+class DeformConvFunction(Function):
+
+    @staticmethod
+    def forward(ctx,
+                input,
+                offset,
+                weight,
+                stride=1,
+                padding=0,
+                dilation=1,
+                groups=1,
+                deformable_groups=1,
+                im2col_step=64):
+        if input is not None and input.dim() != 4:
+            raise ValueError(
+                "Expected 4D tensor as input, got {}D tensor instead.".format(
+                    input.dim()))
+        ctx.stride = _pair(stride)
+        ctx.padding = _pair(padding)
+        ctx.dilation = _pair(dilation)
+        ctx.groups = groups
+        ctx.deformable_groups = deformable_groups
+        ctx.im2col_step = im2col_step
+
+        ctx.save_for_backward(input, offset, weight)
+
+        output = input.new_empty(
+            DeformConvFunction._output_size(input, weight, ctx.padding,
+                                            ctx.dilation, ctx.stride))
+
+        ctx.bufs_ = [input.new_empty(0), input.new_empty(0)]  # columns, ones
+
+        if not input.is_cuda:
+            raise NotImplementedError
+        else:
+            cur_im2col_step = min(ctx.im2col_step, input.shape[0])
+            assert (input.shape[0] %
+                    cur_im2col_step) == 0, 'im2col step must divide batchsize'
+            deform_conv_cuda.deform_conv_forward_cuda(
+                input, weight, offset, output, ctx.bufs_[0], ctx.bufs_[1],
+                weight.size(3), weight.size(2), ctx.stride[1], ctx.stride[0],
+                ctx.padding[1], ctx.padding[0], ctx.dilation[1],
+                ctx.dilation[0], ctx.groups, ctx.deformable_groups,
+                cur_im2col_step)
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        input, offset, weight = ctx.saved_tensors
+
+        grad_input = grad_offset = grad_weight = None
+
+        if not grad_output.is_cuda:
+            raise NotImplementedError
+        else:
+            cur_im2col_step = min(ctx.im2col_step, input.shape[0])
+            assert (input.shape[0] %
+                    cur_im2col_step) == 0, 'im2col step must divide batchsize'
+
+            if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]:
+                grad_input = torch.zeros_like(input)
+                grad_offset = torch.zeros_like(offset)
+                deform_conv_cuda.deform_conv_backward_input_cuda(
+                    input, offset, grad_output, grad_input,
+                    grad_offset, weight, ctx.bufs_[0], weight.size(3),
+                    weight.size(2), ctx.stride[1], ctx.stride[0],
+                    ctx.padding[1], ctx.padding[0], ctx.dilation[1],
+                    ctx.dilation[0], ctx.groups, ctx.deformable_groups,
+                    cur_im2col_step)
+
+            if ctx.needs_input_grad[2]:
+                grad_weight = torch.zeros_like(weight)
+                deform_conv_cuda.deform_conv_backward_parameters_cuda(
+                    input, offset, grad_output,
+                    grad_weight, ctx.bufs_[0], ctx.bufs_[1], weight.size(3),
+                    weight.size(2), ctx.stride[1], ctx.stride[0],
+                    ctx.padding[1], ctx.padding[0], ctx.dilation[1],
+                    ctx.dilation[0], ctx.groups, ctx.deformable_groups, 1,
+                    cur_im2col_step)
+
+        return (grad_input, grad_offset, grad_weight, None, None, None, None,
+                None)
+
+    @staticmethod
+    def _output_size(input, weight, padding, dilation, stride):
+        channels = weight.size(0)
+        output_size = (input.size(0), channels)
+        for d in range(input.dim() - 2):
+            in_size = input.size(d + 2)
+            pad = padding[d]
+            kernel = dilation[d] * (weight.size(d + 2) - 1) + 1
+            stride_ = stride[d]
+            output_size += ((in_size + (2 * pad) - kernel) // stride_ + 1, )
+        if not all(map(lambda s: s > 0, output_size)):
+            raise ValueError(
+                "convolution input is too small (output would be {})".format(
+                    'x'.join(map(str, output_size))))
+        return output_size
+
+
+class ModulatedDeformConvFunction(Function):
+
+    @staticmethod
+    def forward(ctx,
+                input,
+                offset,
+                mask,
+                weight,
+                bias=None,
+                stride=1,
+                padding=0,
+                dilation=1,
+                groups=1,
+                deformable_groups=1):
+        ctx.stride = stride
+        ctx.padding = padding
+        ctx.dilation = dilation
+        ctx.groups = groups
+        ctx.deformable_groups = deformable_groups
+        ctx.with_bias = bias is not None
+        if not ctx.with_bias:
+            bias = input.new_empty(1)  # fake tensor
+        if not input.is_cuda:
+            raise NotImplementedError
+        if weight.requires_grad or mask.requires_grad or offset.requires_grad \
+                or input.requires_grad:
+            ctx.save_for_backward(input, offset, mask, weight, bias)
+        output = input.new_empty(
+            ModulatedDeformConvFunction._infer_shape(ctx, input, weight))
+        ctx._bufs = [input.new_empty(0), input.new_empty(0)]
+        deform_conv_cuda.modulated_deform_conv_cuda_forward(
+            input, weight, bias, ctx._bufs[0], offset, mask, output,
+            ctx._bufs[1], weight.shape[2], weight.shape[3], ctx.stride,
+            ctx.stride, ctx.padding, ctx.padding, ctx.dilation, ctx.dilation,
+            ctx.groups, ctx.deformable_groups, ctx.with_bias)
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        if not grad_output.is_cuda:
+            raise NotImplementedError
+        input, offset, mask, weight, bias = ctx.saved_tensors
+        grad_input = torch.zeros_like(input)
+        grad_offset = torch.zeros_like(offset)
+        grad_mask = torch.zeros_like(mask)
+        grad_weight = torch.zeros_like(weight)
+        grad_bias = torch.zeros_like(bias)
+        deform_conv_cuda.modulated_deform_conv_cuda_backward(
+            input, weight, bias, ctx._bufs[0], offset, mask, ctx._bufs[1],
+            grad_input, grad_weight, grad_bias, grad_offset, grad_mask,
+            grad_output, weight.shape[2], weight.shape[3], ctx.stride,
+            ctx.stride, ctx.padding, ctx.padding, ctx.dilation, ctx.dilation,
+            ctx.groups, ctx.deformable_groups, ctx.with_bias)
+        if not ctx.with_bias:
+            grad_bias = None
+
+        return (grad_input, grad_offset, grad_mask, grad_weight, grad_bias,
+                None, None, None, None, None)
+
+    @staticmethod
+    def _infer_shape(ctx, input, weight):
+        n = input.size(0)
+        channels_out = weight.size(0)
+        height, width = input.shape[2:4]
+        kernel_h, kernel_w = weight.shape[2:4]
+        height_out = (height + 2 * ctx.padding -
+                      (ctx.dilation * (kernel_h - 1) + 1)) // ctx.stride + 1
+        width_out = (width + 2 * ctx.padding -
+                     (ctx.dilation * (kernel_w - 1) + 1)) // ctx.stride + 1
+        return n, channels_out, height_out, width_out
+
+
+deform_conv = DeformConvFunction.apply
+modulated_deform_conv = ModulatedDeformConvFunction.apply

DB/assets/ops/dcn/functions/deform_pool.py

@@ -0,0 +1,69 @@
+import torch
+from torch.autograd import Function
+
+from .. import deform_pool_cuda
+
+
+class DeformRoIPoolingFunction(Function):
+
+    @staticmethod
+    def forward(ctx,
+                data,
+                rois,
+                offset,
+                spatial_scale,
+                out_size,
+                out_channels,
+                no_trans,
+                group_size=1,
+                part_size=None,
+                sample_per_part=4,
+                trans_std=.0):
+        ctx.spatial_scale = spatial_scale
+        ctx.out_size = out_size
+        ctx.out_channels = out_channels
+        ctx.no_trans = no_trans
+        ctx.group_size = group_size
+        ctx.part_size = out_size if part_size is None else part_size
+        ctx.sample_per_part = sample_per_part
+        ctx.trans_std = trans_std
+
+        assert 0.0 <= ctx.trans_std <= 1.0
+        if not data.is_cuda:
+            raise NotImplementedError
+
+        n = rois.shape[0]
+        output = data.new_empty(n, out_channels, out_size, out_size)
+        output_count = data.new_empty(n, out_channels, out_size, out_size)
+        deform_pool_cuda.deform_psroi_pooling_cuda_forward(
+            data, rois, offset, output, output_count, ctx.no_trans,
+            ctx.spatial_scale, ctx.out_channels, ctx.group_size, ctx.out_size,
+            ctx.part_size, ctx.sample_per_part, ctx.trans_std)
+
+        if data.requires_grad or rois.requires_grad or offset.requires_grad:
+            ctx.save_for_backward(data, rois, offset)
+        ctx.output_count = output_count
+
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        if not grad_output.is_cuda:
+            raise NotImplementedError
+
+        data, rois, offset = ctx.saved_tensors
+        output_count = ctx.output_count
+        grad_input = torch.zeros_like(data)
+        grad_rois = None
+        grad_offset = torch.zeros_like(offset)
+
+        deform_pool_cuda.deform_psroi_pooling_cuda_backward(
+            grad_output, data, rois, offset, output_count, grad_input,
+            grad_offset, ctx.no_trans, ctx.spatial_scale, ctx.out_channels,
+            ctx.group_size, ctx.out_size, ctx.part_size, ctx.sample_per_part,
+            ctx.trans_std)
+        return (grad_input, grad_rois, grad_offset, None, None, None, None,
+                None, None, None, None)
+
+
+deform_roi_pooling = DeformRoIPoolingFunction.apply

DB/assets/ops/dcn/modules/deform_conv.py

@@ -0,0 +1,157 @@
+import math
+
+import torch
+import torch.nn as nn
+from torch.nn.modules.utils import _pair
+
+from ..functions.deform_conv import deform_conv, modulated_deform_conv
+
+
+class DeformConv(nn.Module):
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size,
+                 stride=1,
+                 padding=0,
+                 dilation=1,
+                 groups=1,
+                 deformable_groups=1,
+                 bias=False):
+        super(DeformConv, self).__init__()
+
+        assert not bias
+        assert in_channels % groups == 0, \
+            'in_channels {} cannot be divisible by groups {}'.format(
+                in_channels, groups)
+        assert out_channels % groups == 0, \
+            'out_channels {} cannot be divisible by groups {}'.format(
+                out_channels, groups)
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = _pair(kernel_size)
+        self.stride = _pair(stride)
+        self.padding = _pair(padding)
+        self.dilation = _pair(dilation)
+        self.groups = groups
+        self.deformable_groups = deformable_groups
+
+        self.weight = nn.Parameter(
+            torch.Tensor(out_channels, in_channels // self.groups,
+                         *self.kernel_size))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        n = self.in_channels
+        for k in self.kernel_size:
+            n *= k
+        stdv = 1. / math.sqrt(n)
+        self.weight.data.uniform_(-stdv, stdv)
+
+    def forward(self, x, offset):
+        return deform_conv(x, offset, self.weight, self.stride, self.padding,
+                           self.dilation, self.groups, self.deformable_groups)
+
+
+class DeformConvPack(DeformConv):
+
+    def __init__(self, *args, **kwargs):
+        super(DeformConvPack, self).__init__(*args, **kwargs)
+
+        self.conv_offset = nn.Conv2d(
+            self.in_channels,
+            self.deformable_groups * 2 * self.kernel_size[0] *
+            self.kernel_size[1],
+            kernel_size=self.kernel_size,
+            stride=_pair(self.stride),
+            padding=_pair(self.padding),
+            bias=True)
+        self.init_offset()
+
+    def init_offset(self):
+        self.conv_offset.weight.data.zero_()
+        self.conv_offset.bias.data.zero_()
+
+    def forward(self, x):
+        offset = self.conv_offset(x)
+        return deform_conv(x, offset, self.weight, self.stride, self.padding,
+                           self.dilation, self.groups, self.deformable_groups)
+
+
+class ModulatedDeformConv(nn.Module):
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size,
+                 stride=1,
+                 padding=0,
+                 dilation=1,
+                 groups=1,
+                 deformable_groups=1,
+                 bias=True):
+        super(ModulatedDeformConv, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = _pair(kernel_size)
+        self.stride = stride
+        self.padding = padding
+        self.dilation = dilation
+        self.groups = groups
+        self.deformable_groups = deformable_groups
+        self.with_bias = bias
+
+        self.weight = nn.Parameter(
+            torch.Tensor(out_channels, in_channels // groups,
+                         *self.kernel_size))
+        if bias:
+            self.bias = nn.Parameter(torch.Tensor(out_channels))
+        else:
+            self.register_parameter('bias', None)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        n = self.in_channels
+        for k in self.kernel_size:
+            n *= k
+        stdv = 1. / math.sqrt(n)
+        self.weight.data.uniform_(-stdv, stdv)
+        if self.bias is not None:
+            self.bias.data.zero_()
+
+    def forward(self, x, offset, mask):
+        return modulated_deform_conv(x, offset, mask, self.weight, self.bias,
+                                     self.stride, self.padding, self.dilation,
+                                     self.groups, self.deformable_groups)
+
+
+class ModulatedDeformConvPack(ModulatedDeformConv):
+
+    def __init__(self, *args, **kwargs):
+        super(ModulatedDeformConvPack, self).__init__(*args, **kwargs)
+
+        self.conv_offset_mask = nn.Conv2d(
+            self.in_channels,
+            self.deformable_groups * 3 * self.kernel_size[0] *
+            self.kernel_size[1],
+            kernel_size=self.kernel_size,
+            stride=_pair(self.stride),
+            padding=_pair(self.padding),
+            bias=True)
+        self.init_offset()
+
+    def init_offset(self):
+        self.conv_offset_mask.weight.data.zero_()
+        self.conv_offset_mask.bias.data.zero_()
+
+    def forward(self, x):
+        out = self.conv_offset_mask(x)
+        o1, o2, mask = torch.chunk(out, 3, dim=1)
+        offset = torch.cat((o1, o2), dim=1)
+        mask = torch.sigmoid(mask)
+        return modulated_deform_conv(x, offset, mask, self.weight, self.bias,
+                                     self.stride, self.padding, self.dilation,
+                                     self.groups, self.deformable_groups)

DB/assets/ops/dcn/modules/deform_pool.py

@@ -0,0 +1,172 @@
+from torch import nn
+
+from ..functions.deform_pool import deform_roi_pooling
+
+
+class DeformRoIPooling(nn.Module):
+
+    def __init__(self,
+                 spatial_scale,
+                 out_size,
+                 out_channels,
+                 no_trans,
+                 group_size=1,
+                 part_size=None,
+                 sample_per_part=4,
+                 trans_std=.0):
+        super(DeformRoIPooling, self).__init__()
+        self.spatial_scale = spatial_scale
+        self.out_size = out_size
+        self.out_channels = out_channels
+        self.no_trans = no_trans
+        self.group_size = group_size
+        self.part_size = out_size if part_size is None else part_size
+        self.sample_per_part = sample_per_part
+        self.trans_std = trans_std
+
+    def forward(self, data, rois, offset):
+        if self.no_trans:
+            offset = data.new_empty(0)
+        return deform_roi_pooling(
+            data, rois, offset, self.spatial_scale, self.out_size,
+            self.out_channels, self.no_trans, self.group_size, self.part_size,
+            self.sample_per_part, self.trans_std)
+
+
+class DeformRoIPoolingPack(DeformRoIPooling):
+
+    def __init__(self,
+                 spatial_scale,
+                 out_size,
+                 out_channels,
+                 no_trans,
+                 group_size=1,
+                 part_size=None,
+                 sample_per_part=4,
+                 trans_std=.0,
+                 num_offset_fcs=3,
+                 deform_fc_channels=1024):
+        super(DeformRoIPoolingPack,
+              self).__init__(spatial_scale, out_size, out_channels, no_trans,
+                             group_size, part_size, sample_per_part, trans_std)
+
+        self.num_offset_fcs = num_offset_fcs
+        self.deform_fc_channels = deform_fc_channels
+
+        if not no_trans:
+            seq = []
+            ic = self.out_size * self.out_size * self.out_channels
+            for i in range(self.num_offset_fcs):
+                if i < self.num_offset_fcs - 1:
+                    oc = self.deform_fc_channels
+                else:
+                    oc = self.out_size * self.out_size * 2
+                seq.append(nn.Linear(ic, oc))
+                ic = oc
+                if i < self.num_offset_fcs - 1:
+                    seq.append(nn.ReLU(inplace=True))
+            self.offset_fc = nn.Sequential(*seq)
+            self.offset_fc[-1].weight.data.zero_()
+            self.offset_fc[-1].bias.data.zero_()
+
+    def forward(self, data, rois):
+        assert data.size(1) == self.out_channels
+        if self.no_trans:
+            offset = data.new_empty(0)
+            return deform_roi_pooling(
+                data, rois, offset, self.spatial_scale, self.out_size,
+                self.out_channels, self.no_trans, self.group_size,
+                self.part_size, self.sample_per_part, self.trans_std)
+        else:
+            n = rois.shape[0]
+            offset = data.new_empty(0)
+            x = deform_roi_pooling(data, rois, offset, self.spatial_scale,
+                                   self.out_size, self.out_channels, True,
+                                   self.group_size, self.part_size,
+                                   self.sample_per_part, self.trans_std)
+            offset = self.offset_fc(x.view(n, -1))
+            offset = offset.view(n, 2, self.out_size, self.out_size)
+            return deform_roi_pooling(
+                data, rois, offset, self.spatial_scale, self.out_size,
+                self.out_channels, self.no_trans, self.group_size,
+                self.part_size, self.sample_per_part, self.trans_std)
+
+
+class ModulatedDeformRoIPoolingPack(DeformRoIPooling):
+
+    def __init__(self,
+                 spatial_scale,
+                 out_size,
+                 out_channels,
+                 no_trans,
+                 group_size=1,
+                 part_size=None,
+                 sample_per_part=4,
+                 trans_std=.0,
+                 num_offset_fcs=3,
+                 num_mask_fcs=2,
+                 deform_fc_channels=1024):
+        super(ModulatedDeformRoIPoolingPack, self).__init__(
+            spatial_scale, out_size, out_channels, no_trans, group_size,
+            part_size, sample_per_part, trans_std)
+
+        self.num_offset_fcs = num_offset_fcs
+        self.num_mask_fcs = num_mask_fcs
+        self.deform_fc_channels = deform_fc_channels
+
+        if not no_trans:
+            offset_fc_seq = []
+            ic = self.out_size * self.out_size * self.out_channels
+            for i in range(self.num_offset_fcs):
+                if i < self.num_offset_fcs - 1:
+                    oc = self.deform_fc_channels
+                else:
+                    oc = self.out_size * self.out_size * 2
+                offset_fc_seq.append(nn.Linear(ic, oc))
+                ic = oc
+                if i < self.num_offset_fcs - 1:
+                    offset_fc_seq.append(nn.ReLU(inplace=True))
+            self.offset_fc = nn.Sequential(*offset_fc_seq)
+            self.offset_fc[-1].weight.data.zero_()
+            self.offset_fc[-1].bias.data.zero_()
+
+            mask_fc_seq = []
+            ic = self.out_size * self.out_size * self.out_channels
+            for i in range(self.num_mask_fcs):
+                if i < self.num_mask_fcs - 1:
+                    oc = self.deform_fc_channels
+                else:
+                    oc = self.out_size * self.out_size
+                mask_fc_seq.append(nn.Linear(ic, oc))
+                ic = oc
+                if i < self.num_mask_fcs - 1:
+                    mask_fc_seq.append(nn.ReLU(inplace=True))
+                else:
+                    mask_fc_seq.append(nn.Sigmoid())
+            self.mask_fc = nn.Sequential(*mask_fc_seq)
+            self.mask_fc[-2].weight.data.zero_()
+            self.mask_fc[-2].bias.data.zero_()
+
+    def forward(self, data, rois):
+        assert data.size(1) == self.out_channels
+        if self.no_trans:
+            offset = data.new_empty(0)
+            return deform_roi_pooling(
+                data, rois, offset, self.spatial_scale, self.out_size,
+                self.out_channels, self.no_trans, self.group_size,
+                self.part_size, self.sample_per_part, self.trans_std)
+        else:
+            n = rois.shape[0]
+            offset = data.new_empty(0)
+            x = deform_roi_pooling(data, rois, offset, self.spatial_scale,
+                                   self.out_size, self.out_channels, True,
+                                   self.group_size, self.part_size,
+                                   self.sample_per_part, self.trans_std)
+            offset = self.offset_fc(x.view(n, -1))
+            offset = offset.view(n, 2, self.out_size, self.out_size)
+            mask = self.mask_fc(x.view(n, -1))
+            mask = mask.view(n, 1, self.out_size, self.out_size)
+            return deform_roi_pooling(
+                data, rois, offset, self.spatial_scale, self.out_size,
+                self.out_channels, self.no_trans, self.group_size,
+                self.part_size, self.sample_per_part, self.trans_std) * mask

DB/assets/ops/dcn/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup
+from torch.utils.cpp_extension import BuildExtension, CUDAExtension
+
+setup(
+    name='deform_conv',
+    ext_modules=[
+        CUDAExtension('deform_conv_cuda', [
+            'src/deform_conv_cuda.cpp',
+            'src/deform_conv_cuda_kernel.cu',
+        ]),
+        CUDAExtension('deform_pool_cuda', [
+            'src/deform_pool_cuda.cpp', 'src/deform_pool_cuda_kernel.cu'
+        ]),
+    ],
+    cmdclass={'build_ext': BuildExtension})

DB/assets/ops/dcn/src/deform_conv_cuda.cpp

@@ -0,0 +1,695 @@
+// modify from
+// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/deform_conv_cuda.c
+
+#include <torch/extension.h>
+
+#include <cmath>
+#include <vector>
+
+void deformable_im2col(const at::Tensor data_im, const at::Tensor data_offset,
+                       const int channels, const int height, const int width,
+                       const int ksize_h, const int ksize_w, const int pad_h,
+                       const int pad_w, const int stride_h, const int stride_w,
+                       const int dilation_h, const int dilation_w,
+                       const int parallel_imgs, const int deformable_group,
+                       at::Tensor data_col);
+
+void deformable_col2im(const at::Tensor data_col, const at::Tensor data_offset,
+                       const int channels, const int height, const int width,
+                       const int ksize_h, const int ksize_w, const int pad_h,
+                       const int pad_w, const int stride_h, const int stride_w,
+                       const int dilation_h, const int dilation_w,
+                       const int parallel_imgs, const int deformable_group,
+                       at::Tensor grad_im);
+
+void deformable_col2im_coord(
+    const at::Tensor data_col, const at::Tensor data_im,
+    const at::Tensor data_offset, const int channels, const int height,
+    const int width, const int ksize_h, const int ksize_w, const int pad_h,
+    const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w, const int parallel_imgs,
+    const int deformable_group, at::Tensor grad_offset);
+
+void modulated_deformable_im2col_cuda(
+    const at::Tensor data_im, const at::Tensor data_offset,
+    const at::Tensor data_mask, const int batch_size, const int channels,
+    const int height_im, const int width_im, const int height_col,
+    const int width_col, const int kernel_h, const int kenerl_w,
+    const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w, const int deformable_group,
+    at::Tensor data_col);
+
+void modulated_deformable_col2im_cuda(
+    const at::Tensor data_col, const at::Tensor data_offset,
+    const at::Tensor data_mask, const int batch_size, const int channels,
+    const int height_im, const int width_im, const int height_col,
+    const int width_col, const int kernel_h, const int kenerl_w,
+    const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w, const int deformable_group,
+    at::Tensor grad_im);
+
+void modulated_deformable_col2im_coord_cuda(
+    const at::Tensor data_col, const at::Tensor data_im,
+    const at::Tensor data_offset, const at::Tensor data_mask,
+    const int batch_size, const int channels, const int height_im,
+    const int width_im, const int height_col, const int width_col,
+    const int kernel_h, const int kenerl_w, const int pad_h, const int pad_w,
+    const int stride_h, const int stride_w, const int dilation_h,
+    const int dilation_w, const int deformable_group, at::Tensor grad_offset,
+    at::Tensor grad_mask);
+
+void shape_check(at::Tensor input, at::Tensor offset, at::Tensor *gradOutput,
+                 at::Tensor weight, int kH, int kW, int dH, int dW, int padH,
+                 int padW, int dilationH, int dilationW, int group,
+                 int deformable_group) {
+  TORCH_CHECK(weight.ndimension() == 4,
+           "4D weight tensor (nOutputPlane,nInputPlane,kH,kW) expected, "
+           "but got: %s",
+           weight.ndimension());
+
+  TORCH_CHECK(weight.is_contiguous(), "weight tensor has to be contiguous");
+
+  TORCH_CHECK(kW > 0 && kH > 0,
+           "kernel size should be greater than zero, but got kH: %d kW: %d", kH,
+           kW);
+
+  TORCH_CHECK((weight.size(2) == kH && weight.size(3) == kW),
+           "kernel size should be consistent with weight, ",
+           "but got kH: %d kW: %d weight.size(2): %d, weight.size(3): %d", kH,
+           kW, weight.size(2), weight.size(3));
+
+  TORCH_CHECK(dW > 0 && dH > 0,
+           "stride should be greater than zero, but got dH: %d dW: %d", dH, dW);
+
+  TORCH_CHECK(
+      dilationW > 0 && dilationH > 0,
+      "dilation should be greater than 0, but got dilationH: %d dilationW: %d",
+      dilationH, dilationW);
+
+  int ndim = input.ndimension();
+  int dimf = 0;
+  int dimh = 1;
+  int dimw = 2;
+
+  if (ndim == 4) {
+    dimf++;
+    dimh++;
+    dimw++;
+  }
+
+  TORCH_CHECK(ndim == 3 || ndim == 4, "3D or 4D input tensor expected but got: %s",
+           ndim);
+
+  long nInputPlane = weight.size(1) * group;
+  long inputHeight = input.size(dimh);
+  long inputWidth = input.size(dimw);
+  long nOutputPlane = weight.size(0);
+  long outputHeight =
+      (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1;
+  long outputWidth =
+      (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1;
+
+  TORCH_CHECK(nInputPlane % deformable_group == 0,
+           "input channels must divide deformable group size");
+
+  if (outputWidth < 1 || outputHeight < 1)
+    AT_ERROR(
+        "Given input size: (%ld x %ld x %ld). "
+        "Calculated output size: (%ld x %ld x %ld). Output size is too small",
+        nInputPlane, inputHeight, inputWidth, nOutputPlane, outputHeight,
+        outputWidth);
+
+  TORCH_CHECK(input.size(1) == nInputPlane,
+           "invalid number of input planes, expected: %d, but got: %d",
+           nInputPlane, input.size(1));
+
+  TORCH_CHECK((inputHeight >= kH && inputWidth >= kW),
+           "input image is smaller than kernel");
+
+  TORCH_CHECK((offset.size(2) == outputHeight && offset.size(3) == outputWidth),
+           "invalid spatial size of offset, expected height: %d width: %d, but "
+           "got height: %d width: %d",
+           outputHeight, outputWidth, offset.size(2), offset.size(3));
+
+  TORCH_CHECK((offset.size(1) == deformable_group * 2 * kH * kW),
+           "invalid number of channels of offset");
+
+  if (gradOutput != NULL) {
+    TORCH_CHECK(gradOutput->size(dimf) == nOutputPlane,
+             "invalid number of gradOutput planes, expected: %d, but got: %d",
+             nOutputPlane, gradOutput->size(dimf));
+
+    TORCH_CHECK((gradOutput->size(dimh) == outputHeight &&
+              gradOutput->size(dimw) == outputWidth),
+             "invalid size of gradOutput, expected height: %d width: %d , but "
+             "got height: %d width: %d",
+             outputHeight, outputWidth, gradOutput->size(dimh),
+             gradOutput->size(dimw));
+  }
+}
+
+int deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
+                             at::Tensor offset, at::Tensor output,
+                             at::Tensor columns, at::Tensor ones, int kW,
+                             int kH, int dW, int dH, int padW, int padH,
+                             int dilationW, int dilationH, int group,
+                             int deformable_group, int im2col_step) {
+  // todo: resize columns to include im2col: done
+  // todo: add im2col_step as input
+  // todo: add new output buffer and transpose it to output (or directly
+  // transpose output) todo: possibly change data indexing because of
+  // parallel_imgs
+
+  shape_check(input, offset, NULL, weight, kH, kW, dH, dW, padH, padW,
+              dilationH, dilationW, group, deformable_group);
+
+  input = input.contiguous();
+  offset = offset.contiguous();
+  weight = weight.contiguous();
+
+  int batch = 1;
+  if (input.ndimension() == 3) {
+    // Force batch
+    batch = 0;
+    input.unsqueeze_(0);
+    offset.unsqueeze_(0);
+  }
+
+  // todo: assert batchsize dividable by im2col_step
+
+  long batchSize = input.size(0);
+  long nInputPlane = input.size(1);
+  long inputHeight = input.size(2);
+  long inputWidth = input.size(3);
+
+  long nOutputPlane = weight.size(0);
+
+  long outputWidth =
+      (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1;
+  long outputHeight =
+      (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1;
+
+  TORCH_CHECK((offset.size(0) == batchSize), "invalid batch size of offset");
+
+  output = output.view({batchSize / im2col_step, im2col_step, nOutputPlane,
+                        outputHeight, outputWidth});
+  columns = at::zeros(
+      {nInputPlane * kW * kH, im2col_step * outputHeight * outputWidth},
+      input.options());
+
+  if (ones.ndimension() != 2 ||
+      ones.size(0) * ones.size(1) < outputHeight * outputWidth) {
+    ones = at::ones({outputHeight, outputWidth}, input.options());
+  }
+
+  input = input.view({batchSize / im2col_step, im2col_step, nInputPlane,
+                      inputHeight, inputWidth});
+  offset =
+      offset.view({batchSize / im2col_step, im2col_step,
+                   deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+
+  at::Tensor output_buffer =
+      at::zeros({batchSize / im2col_step, nOutputPlane,
+                 im2col_step * outputHeight, outputWidth},
+                output.options());
+
+  output_buffer = output_buffer.view(
+      {output_buffer.size(0), group, output_buffer.size(1) / group,
+       output_buffer.size(2), output_buffer.size(3)});
+
+  for (int elt = 0; elt < batchSize / im2col_step; elt++) {
+    deformable_im2col(input[elt], offset[elt], nInputPlane, inputHeight,
+                      inputWidth, kH, kW, padH, padW, dH, dW, dilationH,
+                      dilationW, im2col_step, deformable_group, columns);
+
+    columns = columns.view({group, columns.size(0) / group, columns.size(1)});
+    weight = weight.view({group, weight.size(0) / group, weight.size(1),
+                          weight.size(2), weight.size(3)});
+
+    for (int g = 0; g < group; g++) {
+      output_buffer[elt][g] = output_buffer[elt][g]
+                                  .flatten(1)
+                                  .addmm_(weight[g].flatten(1), columns[g])
+                                  .view_as(output_buffer[elt][g]);
+    }
+  }
+
+  output_buffer = output_buffer.view(
+      {output_buffer.size(0), output_buffer.size(1) * output_buffer.size(2),
+       output_buffer.size(3), output_buffer.size(4)});
+
+  output_buffer = output_buffer.view({batchSize / im2col_step, nOutputPlane,
+                                      im2col_step, outputHeight, outputWidth});
+  output_buffer.transpose_(1, 2);
+  output.copy_(output_buffer);
+  output = output.view({batchSize, nOutputPlane, outputHeight, outputWidth});
+
+  input = input.view({batchSize, nInputPlane, inputHeight, inputWidth});
+  offset = offset.view(
+      {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+
+  if (batch == 0) {
+    output = output.view({nOutputPlane, outputHeight, outputWidth});
+    input = input.view({nInputPlane, inputHeight, inputWidth});
+    offset = offset.view({offset.size(1), offset.size(2), offset.size(3)});
+  }
+
+  return 1;
+}
+
+int deform_conv_backward_input_cuda(at::Tensor input, at::Tensor offset,
+                                    at::Tensor gradOutput, at::Tensor gradInput,
+                                    at::Tensor gradOffset, at::Tensor weight,
+                                    at::Tensor columns, int kW, int kH, int dW,
+                                    int dH, int padW, int padH, int dilationW,
+                                    int dilationH, int group,
+                                    int deformable_group, int im2col_step) {
+  shape_check(input, offset, &gradOutput, weight, kH, kW, dH, dW, padH, padW,
+              dilationH, dilationW, group, deformable_group);
+
+  input = input.contiguous();
+  offset = offset.contiguous();
+  gradOutput = gradOutput.contiguous();
+  weight = weight.contiguous();
+
+  int batch = 1;
+
+  if (input.ndimension() == 3) {
+    // Force batch
+    batch = 0;
+    input = input.view({1, input.size(0), input.size(1), input.size(2)});
+    offset = offset.view({1, offset.size(0), offset.size(1), offset.size(2)});
+    gradOutput = gradOutput.view(
+        {1, gradOutput.size(0), gradOutput.size(1), gradOutput.size(2)});
+  }
+
+  long batchSize = input.size(0);
+  long nInputPlane = input.size(1);
+  long inputHeight = input.size(2);
+  long inputWidth = input.size(3);
+
+  long nOutputPlane = weight.size(0);
+
+  long outputWidth =
+      (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1;
+  long outputHeight =
+      (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1;
+
+  TORCH_CHECK((offset.size(0) == batchSize), 3, "invalid batch size of offset");
+  gradInput = gradInput.view({batchSize, nInputPlane, inputHeight, inputWidth});
+  columns = at::zeros(
+      {nInputPlane * kW * kH, im2col_step * outputHeight * outputWidth},
+      input.options());
+
+  // change order of grad output
+  gradOutput = gradOutput.view({batchSize / im2col_step, im2col_step,
+                                nOutputPlane, outputHeight, outputWidth});
+  gradOutput.transpose_(1, 2);
+
+  gradInput = gradInput.view({batchSize / im2col_step, im2col_step, nInputPlane,
+                              inputHeight, inputWidth});
+  input = input.view({batchSize / im2col_step, im2col_step, nInputPlane,
+                      inputHeight, inputWidth});
+  gradOffset = gradOffset.view({batchSize / im2col_step, im2col_step,
+                                deformable_group * 2 * kH * kW, outputHeight,
+                                outputWidth});
+  offset =
+      offset.view({batchSize / im2col_step, im2col_step,
+                   deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+
+  for (int elt = 0; elt < batchSize / im2col_step; elt++) {
+    // divide into groups
+    columns = columns.view({group, columns.size(0) / group, columns.size(1)});
+    weight = weight.view({group, weight.size(0) / group, weight.size(1),
+                          weight.size(2), weight.size(3)});
+    gradOutput = gradOutput.view(
+        {gradOutput.size(0), group, gradOutput.size(1) / group,
+         gradOutput.size(2), gradOutput.size(3), gradOutput.size(4)});
+
+    for (int g = 0; g < group; g++) {
+      columns[g] = columns[g].addmm_(weight[g].flatten(1).transpose(0, 1),
+                                     gradOutput[elt][g].flatten(1), 0.0f, 1.0f);
+    }
+
+    columns =
+        columns.view({columns.size(0) * columns.size(1), columns.size(2)});
+    gradOutput = gradOutput.view(
+        {gradOutput.size(0), gradOutput.size(1) * gradOutput.size(2),
+         gradOutput.size(3), gradOutput.size(4), gradOutput.size(5)});
+
+    deformable_col2im_coord(columns, input[elt], offset[elt], nInputPlane,
+                            inputHeight, inputWidth, kH, kW, padH, padW, dH, dW,
+                            dilationH, dilationW, im2col_step, deformable_group,
+                            gradOffset[elt]);
+
+    deformable_col2im(columns, offset[elt], nInputPlane, inputHeight,
+                      inputWidth, kH, kW, padH, padW, dH, dW, dilationH,
+                      dilationW, im2col_step, deformable_group, gradInput[elt]);
+  }
+
+  gradOutput.transpose_(1, 2);
+  gradOutput =
+      gradOutput.view({batchSize, nOutputPlane, outputHeight, outputWidth});
+
+  gradInput = gradInput.view({batchSize, nInputPlane, inputHeight, inputWidth});
+  input = input.view({batchSize, nInputPlane, inputHeight, inputWidth});
+  gradOffset = gradOffset.view(
+      {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+  offset = offset.view(
+      {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+
+  if (batch == 0) {
+    gradOutput = gradOutput.view({nOutputPlane, outputHeight, outputWidth});
+    input = input.view({nInputPlane, inputHeight, inputWidth});
+    gradInput = gradInput.view({nInputPlane, inputHeight, inputWidth});
+    offset = offset.view({offset.size(1), offset.size(2), offset.size(3)});
+    gradOffset =
+        gradOffset.view({offset.size(1), offset.size(2), offset.size(3)});
+  }
+
+  return 1;
+}
+
+int deform_conv_backward_parameters_cuda(
+    at::Tensor input, at::Tensor offset, at::Tensor gradOutput,
+    at::Tensor gradWeight,  // at::Tensor gradBias,
+    at::Tensor columns, at::Tensor ones, int kW, int kH, int dW, int dH,
+    int padW, int padH, int dilationW, int dilationH, int group,
+    int deformable_group, float scale, int im2col_step) {
+  // todo: transpose and reshape outGrad
+  // todo: reshape columns
+  // todo: add im2col_step as input
+
+  shape_check(input, offset, &gradOutput, gradWeight, kH, kW, dH, dW, padH,
+              padW, dilationH, dilationW, group, deformable_group);
+
+  input = input.contiguous();
+  offset = offset.contiguous();
+  gradOutput = gradOutput.contiguous();
+
+  int batch = 1;
+
+  if (input.ndimension() == 3) {
+    // Force batch
+    batch = 0;
+    input = input.view(
+        at::IntList({1, input.size(0), input.size(1), input.size(2)}));
+    gradOutput = gradOutput.view(
+        {1, gradOutput.size(0), gradOutput.size(1), gradOutput.size(2)});
+  }
+
+  long batchSize = input.size(0);
+  long nInputPlane = input.size(1);
+  long inputHeight = input.size(2);
+  long inputWidth = input.size(3);
+
+  long nOutputPlane = gradWeight.size(0);
+
+  long outputWidth =
+      (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1;
+  long outputHeight =
+      (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1;
+
+  TORCH_CHECK((offset.size(0) == batchSize), "invalid batch size of offset");
+
+  columns = at::zeros(
+      {nInputPlane * kW * kH, im2col_step * outputHeight * outputWidth},
+      input.options());
+
+  gradOutput = gradOutput.view({batchSize / im2col_step, im2col_step,
+                                nOutputPlane, outputHeight, outputWidth});
+  gradOutput.transpose_(1, 2);
+
+  at::Tensor gradOutputBuffer = at::zeros_like(gradOutput);
+  gradOutputBuffer =
+      gradOutputBuffer.view({batchSize / im2col_step, nOutputPlane, im2col_step,
+                             outputHeight, outputWidth});
+  gradOutputBuffer.copy_(gradOutput);
+  gradOutputBuffer =
+      gradOutputBuffer.view({batchSize / im2col_step, nOutputPlane,
+                             im2col_step * outputHeight, outputWidth});
+
+  gradOutput.transpose_(1, 2);
+  gradOutput =
+      gradOutput.view({batchSize, nOutputPlane, outputHeight, outputWidth});
+
+  input = input.view({batchSize / im2col_step, im2col_step, nInputPlane,
+                      inputHeight, inputWidth});
+  offset =
+      offset.view({batchSize / im2col_step, im2col_step,
+                   deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+
+  for (int elt = 0; elt < batchSize / im2col_step; elt++) {
+    deformable_im2col(input[elt], offset[elt], nInputPlane, inputHeight,
+                      inputWidth, kH, kW, padH, padW, dH, dW, dilationH,
+                      dilationW, im2col_step, deformable_group, columns);
+
+    // divide into group
+    gradOutputBuffer = gradOutputBuffer.view(
+        {gradOutputBuffer.size(0), group, gradOutputBuffer.size(1) / group,
+         gradOutputBuffer.size(2), gradOutputBuffer.size(3)});
+    columns = columns.view({group, columns.size(0) / group, columns.size(1)});
+    gradWeight =
+        gradWeight.view({group, gradWeight.size(0) / group, gradWeight.size(1),
+                         gradWeight.size(2), gradWeight.size(3)});
+
+    for (int g = 0; g < group; g++) {
+      gradWeight[g] = gradWeight[g]
+                          .flatten(1)
+                          .addmm_(gradOutputBuffer[elt][g].flatten(1),
+                                  columns[g].transpose(1, 0), 1.0, scale)
+                          .view_as(gradWeight[g]);
+    }
+    gradOutputBuffer = gradOutputBuffer.view(
+        {gradOutputBuffer.size(0),
+         gradOutputBuffer.size(1) * gradOutputBuffer.size(2),
+         gradOutputBuffer.size(3), gradOutputBuffer.size(4)});
+    columns =
+        columns.view({columns.size(0) * columns.size(1), columns.size(2)});
+    gradWeight = gradWeight.view({gradWeight.size(0) * gradWeight.size(1),
+                                  gradWeight.size(2), gradWeight.size(3),
+                                  gradWeight.size(4)});
+  }
+
+  input = input.view({batchSize, nInputPlane, inputHeight, inputWidth});
+  offset = offset.view(
+      {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth});
+
+  if (batch == 0) {
+    gradOutput = gradOutput.view({nOutputPlane, outputHeight, outputWidth});
+    input = input.view({nInputPlane, inputHeight, inputWidth});
+  }
+
+  return 1;
+}
+
+void modulated_deform_conv_cuda_forward(
+    at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones,
+    at::Tensor offset, at::Tensor mask, at::Tensor output, at::Tensor columns,
+    int kernel_h, int kernel_w, const int stride_h, const int stride_w,
+    const int pad_h, const int pad_w, const int dilation_h,
+    const int dilation_w, const int group, const int deformable_group,
+    const bool with_bias) {
+  TORCH_CHECK(input.is_contiguous(), "input tensor has to be contiguous");
+  TORCH_CHECK(weight.is_contiguous(), "weight tensor has to be contiguous");
+
+  const int batch = input.size(0);
+  const int channels = input.size(1);
+  const int height = input.size(2);
+  const int width = input.size(3);
+
+  const int channels_out = weight.size(0);
+  const int channels_kernel = weight.size(1);
+  const int kernel_h_ = weight.size(2);
+  const int kernel_w_ = weight.size(3);
+
+  if (kernel_h_ != kernel_h || kernel_w_ != kernel_w)
+    AT_ERROR("Input shape and kernel shape wont match: (%d x %d vs %d x %d).",
+             kernel_h_, kernel_w, kernel_h_, kernel_w_);
+  if (channels != channels_kernel * group)
+    AT_ERROR("Input shape and kernel channels wont match: (%d vs %d).",
+             channels, channels_kernel * group);
+
+  const int height_out =
+      (height + 2 * pad_h - (dilation_h * (kernel_h - 1) + 1)) / stride_h + 1;
+  const int width_out =
+      (width + 2 * pad_w - (dilation_w * (kernel_w - 1) + 1)) / stride_w + 1;
+
+  if (ones.ndimension() != 2 ||
+      ones.size(0) * ones.size(1) < height_out * width_out) {
+    // Resize plane and fill with ones...
+    ones = at::ones({height_out, width_out}, input.options());
+  }
+
+  // resize output
+  output = output.view({batch, channels_out, height_out, width_out}).zero_();
+  // resize temporary columns
+  columns =
+      at::zeros({channels * kernel_h * kernel_w, 1 * height_out * width_out},
+                input.options());
+
+  output = output.view({output.size(0), group, output.size(1) / group,
+                        output.size(2), output.size(3)});
+
+  for (int b = 0; b < batch; b++) {
+    modulated_deformable_im2col_cuda(
+        input[b], offset[b], mask[b], 1, channels, height, width, height_out,
+        width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w,
+        dilation_h, dilation_w, deformable_group, columns);
+
+    // divide into group
+    weight = weight.view({group, weight.size(0) / group, weight.size(1),
+                          weight.size(2), weight.size(3)});
+    columns = columns.view({group, columns.size(0) / group, columns.size(1)});
+
+    for (int g = 0; g < group; g++) {
+      output[b][g] = output[b][g]
+                         .flatten(1)
+                         .addmm_(weight[g].flatten(1), columns[g])
+                         .view_as(output[b][g]);
+    }
+
+    weight = weight.view({weight.size(0) * weight.size(1), weight.size(2),
+                          weight.size(3), weight.size(4)});
+    columns =
+        columns.view({columns.size(0) * columns.size(1), columns.size(2)});
+  }
+
+  output = output.view({output.size(0), output.size(1) * output.size(2),
+                        output.size(3), output.size(4)});
+
+  if (with_bias) {
+    output += bias.view({1, bias.size(0), 1, 1});
+  }
+}
+
+void modulated_deform_conv_cuda_backward(
+    at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones,
+    at::Tensor offset, at::Tensor mask, at::Tensor columns,
+    at::Tensor grad_input, at::Tensor grad_weight, at::Tensor grad_bias,
+    at::Tensor grad_offset, at::Tensor grad_mask, at::Tensor grad_output,
+    int kernel_h, int kernel_w, int stride_h, int stride_w, int pad_h,
+    int pad_w, int dilation_h, int dilation_w, int group, int deformable_group,
+    const bool with_bias) {
+  TORCH_CHECK(input.is_contiguous(), "input tensor has to be contiguous");
+  TORCH_CHECK(weight.is_contiguous(), "weight tensor has to be contiguous");
+
+  const int batch = input.size(0);
+  const int channels = input.size(1);
+  const int height = input.size(2);
+  const int width = input.size(3);
+
+  const int channels_kernel = weight.size(1);
+  const int kernel_h_ = weight.size(2);
+  const int kernel_w_ = weight.size(3);
+  if (kernel_h_ != kernel_h || kernel_w_ != kernel_w)
+    AT_ERROR("Input shape and kernel shape wont match: (%d x %d vs %d x %d).",
+             kernel_h_, kernel_w, kernel_h_, kernel_w_);
+  if (channels != channels_kernel * group)
+    AT_ERROR("Input shape and kernel channels wont match: (%d vs %d).",
+             channels, channels_kernel * group);
+
+  const int height_out =
+      (height + 2 * pad_h - (dilation_h * (kernel_h - 1) + 1)) / stride_h + 1;
+  const int width_out =
+      (width + 2 * pad_w - (dilation_w * (kernel_w - 1) + 1)) / stride_w + 1;
+
+  if (ones.ndimension() != 2 ||
+      ones.size(0) * ones.size(1) < height_out * width_out) {
+    // Resize plane and fill with ones...
+    ones = at::ones({height_out, width_out}, input.options());
+  }
+
+  grad_input = grad_input.view({batch, channels, height, width});
+  columns = at::zeros({channels * kernel_h * kernel_w, height_out * width_out},
+                      input.options());
+
+  grad_output =
+      grad_output.view({grad_output.size(0), group, grad_output.size(1) / group,
+                        grad_output.size(2), grad_output.size(3)});
+
+  for (int b = 0; b < batch; b++) {
+    // divide int group
+    columns = columns.view({group, columns.size(0) / group, columns.size(1)});
+    weight = weight.view({group, weight.size(0) / group, weight.size(1),
+                          weight.size(2), weight.size(3)});
+
+    for (int g = 0; g < group; g++) {
+      columns[g].addmm_(weight[g].flatten(1).transpose(0, 1),
+                        grad_output[b][g].flatten(1), 0.0f, 1.0f);
+    }
+
+    columns =
+        columns.view({columns.size(0) * columns.size(1), columns.size(2)});
+    weight = weight.view({weight.size(0) * weight.size(1), weight.size(2),
+                          weight.size(3), weight.size(4)});
+
+    // gradient w.r.t. input coordinate data
+    modulated_deformable_col2im_coord_cuda(
+        columns, input[b], offset[b], mask[b], 1, channels, height, width,
+        height_out, width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h,
+        stride_w, dilation_h, dilation_w, deformable_group, grad_offset[b],
+        grad_mask[b]);
+    // gradient w.r.t. input data
+    modulated_deformable_col2im_cuda(
+        columns, offset[b], mask[b], 1, channels, height, width, height_out,
+        width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w,
+        dilation_h, dilation_w, deformable_group, grad_input[b]);
+
+    // gradient w.r.t. weight, dWeight should accumulate across the batch and
+    // group
+    modulated_deformable_im2col_cuda(
+        input[b], offset[b], mask[b], 1, channels, height, width, height_out,
+        width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w,
+        dilation_h, dilation_w, deformable_group, columns);
+
+    columns = columns.view({group, columns.size(0) / group, columns.size(1)});
+    grad_weight = grad_weight.view({group, grad_weight.size(0) / group,
+                                    grad_weight.size(1), grad_weight.size(2),
+                                    grad_weight.size(3)});
+    if (with_bias)
+      grad_bias = grad_bias.view({group, grad_bias.size(0) / group});
+
+    for (int g = 0; g < group; g++) {
+      grad_weight[g] =
+          grad_weight[g]
+              .flatten(1)
+              .addmm_(grad_output[b][g].flatten(1), columns[g].transpose(0, 1))
+              .view_as(grad_weight[g]);
+      if (with_bias) {
+        grad_bias[g] =
+            grad_bias[g]
+                .view({-1, 1})
+                .addmm_(grad_output[b][g].flatten(1), ones.view({-1, 1}))
+                .view(-1);
+      }
+    }
+
+    columns =
+        columns.view({columns.size(0) * columns.size(1), columns.size(2)});
+    grad_weight = grad_weight.view({grad_weight.size(0) * grad_weight.size(1),
+                                    grad_weight.size(2), grad_weight.size(3),
+                                    grad_weight.size(4)});
+    if (with_bias)
+      grad_bias = grad_bias.view({grad_bias.size(0) * grad_bias.size(1)});
+  }
+  grad_output = grad_output.view({grad_output.size(0) * grad_output.size(1),
+                                  grad_output.size(2), grad_output.size(3),
+                                  grad_output.size(4)});
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("deform_conv_forward_cuda", &deform_conv_forward_cuda,
+        "deform forward (CUDA)");
+  m.def("deform_conv_backward_input_cuda", &deform_conv_backward_input_cuda,
+        "deform_conv_backward_input (CUDA)");
+  m.def("deform_conv_backward_parameters_cuda",
+        &deform_conv_backward_parameters_cuda,
+        "deform_conv_backward_parameters (CUDA)");
+  m.def("modulated_deform_conv_cuda_forward",
+        &modulated_deform_conv_cuda_forward,
+        "modulated deform conv forward (CUDA)");
+  m.def("modulated_deform_conv_cuda_backward",
+        &modulated_deform_conv_cuda_backward,
+        "modulated deform conv backward (CUDA)");
+}

DB/assets/ops/dcn/src/deform_conv_cuda_kernel.cu

@@ -0,0 +1,866 @@
+/*!
+ ******************* BEGIN Caffe Copyright Notice and Disclaimer ****************
+ *
+ * COPYRIGHT
+ *
+ * All contributions by the University of California:
+ * Copyright (c) 2014-2017 The Regents of the University of California (Regents)
+ * All rights reserved.
+ *
+ * All other contributions:
+ * Copyright (c) 2014-2017, the respective contributors
+ * All rights reserved.
+ *
+ * Caffe uses a shared copyright model: each contributor holds copyright over
+ * their contributions to Caffe. The project versioning records all such
+ * contribution and copyright details. If a contributor wants to further mark
+ * their specific copyright on a particular contribution, they should indicate
+ * their copyright solely in the commit message of the change when it is
+ * committed.
+ *
+ * LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * CONTRIBUTION AGREEMENT
+ *
+ * By contributing to the BVLC/caffe repository through pull-request, comment,
+ * or otherwise, the contributor releases their content to the
+ * license and copyright terms herein.
+ *
+ ***************** END Caffe Copyright Notice and Disclaimer ********************
+ *
+ * Copyright (c) 2018 Microsoft
+ * Licensed under The MIT License [see LICENSE for details]
+ * \file modulated_deformable_im2col.cuh
+ * \brief Function definitions of converting an image to
+ * column matrix based on kernel, padding, dilation, and offset.
+ * These functions are mainly used in deformable convolution operators.
+ * \ref: https://arxiv.org/abs/1703.06211
+ * \author Yuwen Xiong, Haozhi Qi, Jifeng Dai, Xizhou Zhu, Han Hu, Dazhi Cheng
+ */
+
+// modify from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu
+
+#include <ATen/ATen.h>
+#include <THC/THCAtomics.cuh>
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+
+using namespace at;
+
+#define CUDA_KERNEL_LOOP(i, n)                                 \
+  for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < (n); \
+       i += blockDim.x * gridDim.x)
+
+const int CUDA_NUM_THREADS = 1024;
+const int kMaxGridNum = 65535;
+
+inline int GET_BLOCKS(const int N)
+{
+  return std::min(kMaxGridNum, (N + CUDA_NUM_THREADS - 1) / CUDA_NUM_THREADS);
+}
+
+template <typename scalar_t>
+__device__ scalar_t deformable_im2col_bilinear(const scalar_t *bottom_data, const int data_width,
+                                               const int height, const int width, scalar_t h, scalar_t w)
+{
+
+  int h_low = floor(h);
+  int w_low = floor(w);
+  int h_high = h_low + 1;
+  int w_high = w_low + 1;
+
+  scalar_t lh = h - h_low;
+  scalar_t lw = w - w_low;
+  scalar_t hh = 1 - lh, hw = 1 - lw;
+
+  scalar_t v1 = 0;
+  if (h_low >= 0 && w_low >= 0)
+    v1 = bottom_data[h_low * data_width + w_low];
+  scalar_t v2 = 0;
+  if (h_low >= 0 && w_high <= width - 1)
+    v2 = bottom_data[h_low * data_width + w_high];
+  scalar_t v3 = 0;
+  if (h_high <= height - 1 && w_low >= 0)
+    v3 = bottom_data[h_high * data_width + w_low];
+  scalar_t v4 = 0;
+  if (h_high <= height - 1 && w_high <= width - 1)
+    v4 = bottom_data[h_high * data_width + w_high];
+
+  scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw;
+
+  scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4);
+  return val;
+}
+
+template <typename scalar_t>
+__device__ scalar_t get_gradient_weight(scalar_t argmax_h, scalar_t argmax_w,
+                                        const int h, const int w, const int height, const int width)
+{
+
+  if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width)
+  {
+    //empty
+    return 0;
+  }
+
+  int argmax_h_low = floor(argmax_h);
+  int argmax_w_low = floor(argmax_w);
+  int argmax_h_high = argmax_h_low + 1;
+  int argmax_w_high = argmax_w_low + 1;
+
+  scalar_t weight = 0;
+  if (h == argmax_h_low && w == argmax_w_low)
+    weight = (h + 1 - argmax_h) * (w + 1 - argmax_w);
+  if (h == argmax_h_low && w == argmax_w_high)
+    weight = (h + 1 - argmax_h) * (argmax_w + 1 - w);
+  if (h == argmax_h_high && w == argmax_w_low)
+    weight = (argmax_h + 1 - h) * (w + 1 - argmax_w);
+  if (h == argmax_h_high && w == argmax_w_high)
+    weight = (argmax_h + 1 - h) * (argmax_w + 1 - w);
+  return weight;
+}
+
+template <typename scalar_t>
+__device__ scalar_t get_coordinate_weight(scalar_t argmax_h, scalar_t argmax_w,
+                                          const int height, const int width, const scalar_t *im_data,
+                                          const int data_width, const int bp_dir)
+{
+
+  if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width)
+  {
+    //empty
+    return 0;
+  }
+
+  int argmax_h_low = floor(argmax_h);
+  int argmax_w_low = floor(argmax_w);
+  int argmax_h_high = argmax_h_low + 1;
+  int argmax_w_high = argmax_w_low + 1;
+
+  scalar_t weight = 0;
+
+  if (bp_dir == 0)
+  {
+    if (argmax_h_low >= 0 && argmax_w_low >= 0)
+      weight += -1 * (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_low * data_width + argmax_w_low];
+    if (argmax_h_low >= 0 && argmax_w_high <= width - 1)
+      weight += -1 * (argmax_w - argmax_w_low) * im_data[argmax_h_low * data_width + argmax_w_high];
+    if (argmax_h_high <= height - 1 && argmax_w_low >= 0)
+      weight += (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_high * data_width + argmax_w_low];
+    if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1)
+      weight += (argmax_w - argmax_w_low) * im_data[argmax_h_high * data_width + argmax_w_high];
+  }
+  else if (bp_dir == 1)
+  {
+    if (argmax_h_low >= 0 && argmax_w_low >= 0)
+      weight += -1 * (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_low];
+    if (argmax_h_low >= 0 && argmax_w_high <= width - 1)
+      weight += (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_high];
+    if (argmax_h_high <= height - 1 && argmax_w_low >= 0)
+      weight += -1 * (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_low];
+    if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1)
+      weight += (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_high];
+  }
+
+  return weight;
+}
+
+template <typename scalar_t>
+__global__ void deformable_im2col_gpu_kernel(const int n, const scalar_t *data_im, const scalar_t *data_offset,
+                                             const int height, const int width, const int kernel_h, const int kernel_w,
+                                             const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+                                             const int dilation_h, const int dilation_w, const int channel_per_deformable_group,
+                                             const int batch_size, const int num_channels, const int deformable_group,
+                                             const int height_col, const int width_col,
+                                             scalar_t *data_col)
+{
+  CUDA_KERNEL_LOOP(index, n)
+  {
+    // index index of output matrix
+    const int w_col = index % width_col;
+    const int h_col = (index / width_col) % height_col;
+    const int b_col = (index / width_col / height_col) % batch_size;
+    const int c_im = (index / width_col / height_col) / batch_size;
+    const int c_col = c_im * kernel_h * kernel_w;
+
+    // compute deformable group index
+    const int deformable_group_index = c_im / channel_per_deformable_group;
+
+    const int h_in = h_col * stride_h - pad_h;
+    const int w_in = w_col * stride_w - pad_w;
+    scalar_t *data_col_ptr = data_col + ((c_col * batch_size + b_col) * height_col + h_col) * width_col + w_col;
+    //const scalar_t* data_im_ptr = data_im + ((b_col * num_channels + c_im) * height + h_in) * width + w_in;
+    const scalar_t *data_im_ptr = data_im + (b_col * num_channels + c_im) * height * width;
+    const scalar_t *data_offset_ptr = data_offset + (b_col * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col;
+
+    for (int i = 0; i < kernel_h; ++i)
+    {
+      for (int j = 0; j < kernel_w; ++j)
+      {
+        const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_col) * width_col + w_col;
+        const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_col) * width_col + w_col;
+        const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr];
+        const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr];
+        scalar_t val = static_cast<scalar_t>(0);
+        const scalar_t h_im = h_in + i * dilation_h + offset_h;
+        const scalar_t w_im = w_in + j * dilation_w + offset_w;
+        if (h_im > -1 && w_im > -1 && h_im < height && w_im < width)
+        {
+          //const scalar_t map_h = i * dilation_h + offset_h;
+          //const scalar_t map_w = j * dilation_w + offset_w;
+          //const int cur_height = height - h_in;
+          //const int cur_width = width - w_in;
+          //val = deformable_im2col_bilinear(data_im_ptr, width, cur_height, cur_width, map_h, map_w);
+          val = deformable_im2col_bilinear(data_im_ptr, width, height, width, h_im, w_im);
+        }
+        *data_col_ptr = val;
+        data_col_ptr += batch_size * height_col * width_col;
+      }
+    }
+  }
+}
+
+void deformable_im2col(
+    const at::Tensor data_im, const at::Tensor data_offset, const int channels,
+    const int height, const int width, const int ksize_h, const int ksize_w,
+    const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w, const int parallel_imgs,
+    const int deformable_group, at::Tensor data_col)
+{
+  // num_axes should be smaller than block size
+  // todo: check parallel_imgs is correctly passed in
+  int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1;
+  int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1;
+  int num_kernels = channels * height_col * width_col * parallel_imgs;
+  int channel_per_deformable_group = channels / deformable_group;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data_im.type(), "deformable_im2col_gpu", ([&] {
+        const scalar_t *data_im_ = data_im.data<scalar_t>();
+        const scalar_t *data_offset_ = data_offset.data<scalar_t>();
+        scalar_t *data_col_ = data_col.data<scalar_t>();
+
+        deformable_im2col_gpu_kernel<<<GET_BLOCKS(num_kernels), CUDA_NUM_THREADS>>>(
+            num_kernels, data_im_, data_offset_, height, width, ksize_h, ksize_w,
+            pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w,
+            channel_per_deformable_group, parallel_imgs, channels, deformable_group,
+            height_col, width_col, data_col_);
+      }));
+
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    printf("error in deformable_im2col: %s\n", cudaGetErrorString(err));
+  }
+}
+
+template <typename scalar_t>
+__global__ void deformable_col2im_gpu_kernel(
+    const int n, const scalar_t *data_col, const scalar_t *data_offset,
+    const int channels, const int height, const int width,
+    const int kernel_h, const int kernel_w,
+    const int pad_h, const int pad_w,
+    const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w,
+    const int channel_per_deformable_group,
+    const int batch_size, const int deformable_group,
+    const int height_col, const int width_col,
+    scalar_t *grad_im)
+{
+  CUDA_KERNEL_LOOP(index, n)
+  {
+    const int j = (index / width_col / height_col / batch_size) % kernel_w;
+    const int i = (index / width_col / height_col / batch_size / kernel_w) % kernel_h;
+    const int c = index / width_col / height_col / batch_size / kernel_w / kernel_h;
+    // compute the start and end of the output
+
+    const int deformable_group_index = c / channel_per_deformable_group;
+
+    int w_out = index % width_col;
+    int h_out = (index / width_col) % height_col;
+    int b = (index / width_col / height_col) % batch_size;
+    int w_in = w_out * stride_w - pad_w;
+    int h_in = h_out * stride_h - pad_h;
+
+    const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) *
+                                                        2 * kernel_h * kernel_w * height_col * width_col;
+    const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out;
+    const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out;
+    const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr];
+    const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr];
+    const scalar_t cur_inv_h_data = h_in + i * dilation_h + offset_h;
+    const scalar_t cur_inv_w_data = w_in + j * dilation_w + offset_w;
+
+    const scalar_t cur_top_grad = data_col[index];
+    const int cur_h = (int)cur_inv_h_data;
+    const int cur_w = (int)cur_inv_w_data;
+    for (int dy = -2; dy <= 2; dy++)
+    {
+      for (int dx = -2; dx <= 2; dx++)
+      {
+        if (cur_h + dy >= 0 && cur_h + dy < height &&
+            cur_w + dx >= 0 && cur_w + dx < width &&
+            abs(cur_inv_h_data - (cur_h + dy)) < 1 &&
+            abs(cur_inv_w_data - (cur_w + dx)) < 1)
+        {
+          int cur_bottom_grad_pos = ((b * channels + c) * height + cur_h + dy) * width + cur_w + dx;
+          scalar_t weight = get_gradient_weight(cur_inv_h_data, cur_inv_w_data, cur_h + dy, cur_w + dx, height, width);
+          atomicAdd(grad_im + cur_bottom_grad_pos, weight * cur_top_grad);
+        }
+      }
+    }
+  }
+}
+
+void deformable_col2im(
+    const at::Tensor data_col, const at::Tensor data_offset, const int channels,
+    const int height, const int width, const int ksize_h,
+    const int ksize_w, const int pad_h, const int pad_w,
+    const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w,
+    const int parallel_imgs, const int deformable_group,
+    at::Tensor grad_im)
+{
+
+  // todo: make sure parallel_imgs is passed in correctly
+  int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1;
+  int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1;
+  int num_kernels = channels * ksize_h * ksize_w * height_col * width_col * parallel_imgs;
+  int channel_per_deformable_group = channels / deformable_group;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data_col.type(), "deformable_col2im_gpu", ([&] {
+        const scalar_t *data_col_ = data_col.data<scalar_t>();
+        const scalar_t *data_offset_ = data_offset.data<scalar_t>();
+        scalar_t *grad_im_ = grad_im.data<scalar_t>();
+
+        deformable_col2im_gpu_kernel<<<GET_BLOCKS(num_kernels), CUDA_NUM_THREADS>>>(
+            num_kernels, data_col_, data_offset_, channels, height, width, ksize_h,
+            ksize_w, pad_h, pad_w, stride_h, stride_w,
+            dilation_h, dilation_w, channel_per_deformable_group,
+            parallel_imgs, deformable_group, height_col, width_col, grad_im_);
+      }));
+
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    printf("error in deformable_col2im: %s\n", cudaGetErrorString(err));
+  }
+}
+
+template <typename scalar_t>
+__global__ void deformable_col2im_coord_gpu_kernel(const int n, const scalar_t *data_col,
+                                                   const scalar_t *data_im, const scalar_t *data_offset,
+                                                   const int channels, const int height, const int width,
+                                                   const int kernel_h, const int kernel_w,
+                                                   const int pad_h, const int pad_w,
+                                                   const int stride_h, const int stride_w,
+                                                   const int dilation_h, const int dilation_w,
+                                                   const int channel_per_deformable_group,
+                                                   const int batch_size, const int offset_channels, const int deformable_group,
+                                                   const int height_col, const int width_col, scalar_t *grad_offset)
+{
+  CUDA_KERNEL_LOOP(index, n)
+  {
+    scalar_t val = 0;
+    int w = index % width_col;
+    int h = (index / width_col) % height_col;
+    int c = (index / width_col / height_col) % offset_channels;
+    int b = (index / width_col / height_col) / offset_channels;
+    // compute the start and end of the output
+
+    const int deformable_group_index = c / (2 * kernel_h * kernel_w);
+    const int col_step = kernel_h * kernel_w;
+    int cnt = 0;
+    const scalar_t *data_col_ptr = data_col + deformable_group_index * channel_per_deformable_group *
+                                                  batch_size * width_col * height_col;
+    const scalar_t *data_im_ptr = data_im + (b * deformable_group + deformable_group_index) *
+                                                channel_per_deformable_group / kernel_h / kernel_w * height * width;
+    const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * 2 *
+                                                        kernel_h * kernel_w * height_col * width_col;
+
+    const int offset_c = c - deformable_group_index * 2 * kernel_h * kernel_w;
+
+    for (int col_c = (offset_c / 2); col_c < channel_per_deformable_group; col_c += col_step)
+    {
+      const int col_pos = (((col_c * batch_size + b) * height_col) + h) * width_col + w;
+      const int bp_dir = offset_c % 2;
+
+      int j = (col_pos / width_col / height_col / batch_size) % kernel_w;
+      int i = (col_pos / width_col / height_col / batch_size / kernel_w) % kernel_h;
+      int w_out = col_pos % width_col;
+      int h_out = (col_pos / width_col) % height_col;
+      int w_in = w_out * stride_w - pad_w;
+      int h_in = h_out * stride_h - pad_h;
+      const int data_offset_h_ptr = (((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out);
+      const int data_offset_w_ptr = (((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out);
+      const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr];
+      const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr];
+      scalar_t inv_h = h_in + i * dilation_h + offset_h;
+      scalar_t inv_w = w_in + j * dilation_w + offset_w;
+      if (inv_h <= -1 || inv_w <= -1 || inv_h >= height || inv_w >= width)
+      {
+        inv_h = inv_w = -2;
+      }
+      const scalar_t weight = get_coordinate_weight(
+          inv_h, inv_w,
+          height, width, data_im_ptr + cnt * height * width, width, bp_dir);
+      val += weight * data_col_ptr[col_pos];
+      cnt += 1;
+    }
+
+    grad_offset[index] = val;
+  }
+}
+
+void deformable_col2im_coord(
+    const at::Tensor data_col, const at::Tensor data_im, const at::Tensor data_offset,
+    const int channels, const int height, const int width, const int ksize_h,
+    const int ksize_w, const int pad_h, const int pad_w, const int stride_h,
+    const int stride_w, const int dilation_h, const int dilation_w,
+    const int parallel_imgs, const int deformable_group, at::Tensor grad_offset)
+{
+
+  int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1;
+  int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1;
+  int num_kernels = height_col * width_col * 2 * ksize_h * ksize_w * deformable_group * parallel_imgs;
+  int channel_per_deformable_group = channels * ksize_h * ksize_w / deformable_group;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data_col.type(), "deformable_col2im_coord_gpu", ([&] {
+        const scalar_t *data_col_ = data_col.data<scalar_t>();
+        const scalar_t *data_im_ = data_im.data<scalar_t>();
+        const scalar_t *data_offset_ = data_offset.data<scalar_t>();
+        scalar_t *grad_offset_ = grad_offset.data<scalar_t>();
+
+        deformable_col2im_coord_gpu_kernel<<<GET_BLOCKS(num_kernels), CUDA_NUM_THREADS>>>(
+            num_kernels, data_col_, data_im_, data_offset_, channels, height, width,
+            ksize_h, ksize_w, pad_h, pad_w, stride_h, stride_w,
+            dilation_h, dilation_w, channel_per_deformable_group,
+            parallel_imgs, 2 * ksize_h * ksize_w * deformable_group, deformable_group,
+            height_col, width_col, grad_offset_);
+      }));
+}
+
+template <typename scalar_t>
+__device__ scalar_t dmcn_im2col_bilinear(const scalar_t *bottom_data, const int data_width,
+                                         const int height, const int width, scalar_t h, scalar_t w)
+{
+  int h_low = floor(h);
+  int w_low = floor(w);
+  int h_high = h_low + 1;
+  int w_high = w_low + 1;
+
+  scalar_t lh = h - h_low;
+  scalar_t lw = w - w_low;
+  scalar_t hh = 1 - lh, hw = 1 - lw;
+
+  scalar_t v1 = 0;
+  if (h_low >= 0 && w_low >= 0)
+    v1 = bottom_data[h_low * data_width + w_low];
+  scalar_t v2 = 0;
+  if (h_low >= 0 && w_high <= width - 1)
+    v2 = bottom_data[h_low * data_width + w_high];
+  scalar_t v3 = 0;
+  if (h_high <= height - 1 && w_low >= 0)
+    v3 = bottom_data[h_high * data_width + w_low];
+  scalar_t v4 = 0;
+  if (h_high <= height - 1 && w_high <= width - 1)
+    v4 = bottom_data[h_high * data_width + w_high];
+
+  scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw;
+
+  scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4);
+  return val;
+}
+
+template <typename scalar_t>
+__device__ scalar_t dmcn_get_gradient_weight(scalar_t argmax_h, scalar_t argmax_w,
+                                             const int h, const int w, const int height, const int width)
+{
+  if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width)
+  {
+    //empty
+    return 0;
+  }
+
+  int argmax_h_low = floor(argmax_h);
+  int argmax_w_low = floor(argmax_w);
+  int argmax_h_high = argmax_h_low + 1;
+  int argmax_w_high = argmax_w_low + 1;
+
+  scalar_t weight = 0;
+  if (h == argmax_h_low && w == argmax_w_low)
+    weight = (h + 1 - argmax_h) * (w + 1 - argmax_w);
+  if (h == argmax_h_low && w == argmax_w_high)
+    weight = (h + 1 - argmax_h) * (argmax_w + 1 - w);
+  if (h == argmax_h_high && w == argmax_w_low)
+    weight = (argmax_h + 1 - h) * (w + 1 - argmax_w);
+  if (h == argmax_h_high && w == argmax_w_high)
+    weight = (argmax_h + 1 - h) * (argmax_w + 1 - w);
+  return weight;
+}
+
+template <typename scalar_t>
+__device__ scalar_t dmcn_get_coordinate_weight(scalar_t argmax_h, scalar_t argmax_w,
+                                               const int height, const int width, const scalar_t *im_data,
+                                               const int data_width, const int bp_dir)
+{
+  if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width)
+  {
+    //empty
+    return 0;
+  }
+
+  int argmax_h_low = floor(argmax_h);
+  int argmax_w_low = floor(argmax_w);
+  int argmax_h_high = argmax_h_low + 1;
+  int argmax_w_high = argmax_w_low + 1;
+
+  scalar_t weight = 0;
+
+  if (bp_dir == 0)
+  {
+    if (argmax_h_low >= 0 && argmax_w_low >= 0)
+      weight += -1 * (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_low * data_width + argmax_w_low];
+    if (argmax_h_low >= 0 && argmax_w_high <= width - 1)
+      weight += -1 * (argmax_w - argmax_w_low) * im_data[argmax_h_low * data_width + argmax_w_high];
+    if (argmax_h_high <= height - 1 && argmax_w_low >= 0)
+      weight += (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_high * data_width + argmax_w_low];
+    if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1)
+      weight += (argmax_w - argmax_w_low) * im_data[argmax_h_high * data_width + argmax_w_high];
+  }
+  else if (bp_dir == 1)
+  {
+    if (argmax_h_low >= 0 && argmax_w_low >= 0)
+      weight += -1 * (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_low];
+    if (argmax_h_low >= 0 && argmax_w_high <= width - 1)
+      weight += (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_high];
+    if (argmax_h_high <= height - 1 && argmax_w_low >= 0)
+      weight += -1 * (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_low];
+    if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1)
+      weight += (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_high];
+  }
+
+  return weight;
+}
+
+template <typename scalar_t>
+__global__ void modulated_deformable_im2col_gpu_kernel(const int n,
+                                                       const scalar_t *data_im, const scalar_t *data_offset, const scalar_t *data_mask,
+                                                       const int height, const int width, const int kernel_h, const int kernel_w,
+                                                       const int pad_h, const int pad_w,
+                                                       const int stride_h, const int stride_w,
+                                                       const int dilation_h, const int dilation_w,
+                                                       const int channel_per_deformable_group,
+                                                       const int batch_size, const int num_channels, const int deformable_group,
+                                                       const int height_col, const int width_col,
+                                                       scalar_t *data_col)
+{
+  CUDA_KERNEL_LOOP(index, n)
+  {
+    // index index of output matrix
+    const int w_col = index % width_col;
+    const int h_col = (index / width_col) % height_col;
+    const int b_col = (index / width_col / height_col) % batch_size;
+    const int c_im = (index / width_col / height_col) / batch_size;
+    const int c_col = c_im * kernel_h * kernel_w;
+
+    // compute deformable group index
+    const int deformable_group_index = c_im / channel_per_deformable_group;
+
+    const int h_in = h_col * stride_h - pad_h;
+    const int w_in = w_col * stride_w - pad_w;
+
+    scalar_t *data_col_ptr = data_col + ((c_col * batch_size + b_col) * height_col + h_col) * width_col + w_col;
+    //const float* data_im_ptr = data_im + ((b_col * num_channels + c_im) * height + h_in) * width + w_in;
+    const scalar_t *data_im_ptr = data_im + (b_col * num_channels + c_im) * height * width;
+    const scalar_t *data_offset_ptr = data_offset + (b_col * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col;
+
+    const scalar_t *data_mask_ptr = data_mask + (b_col * deformable_group + deformable_group_index) * kernel_h * kernel_w * height_col * width_col;
+
+    for (int i = 0; i < kernel_h; ++i)
+    {
+      for (int j = 0; j < kernel_w; ++j)
+      {
+        const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_col) * width_col + w_col;
+        const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_col) * width_col + w_col;
+        const int data_mask_hw_ptr = ((i * kernel_w + j) * height_col + h_col) * width_col + w_col;
+        const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr];
+        const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr];
+        const scalar_t mask = data_mask_ptr[data_mask_hw_ptr];
+        scalar_t val = static_cast<scalar_t>(0);
+        const scalar_t h_im = h_in + i * dilation_h + offset_h;
+        const scalar_t w_im = w_in + j * dilation_w + offset_w;
+        //if (h_im >= 0 && w_im >= 0 && h_im < height && w_im < width) {
+        if (h_im > -1 && w_im > -1 && h_im < height && w_im < width)
+        {
+          //const float map_h = i * dilation_h + offset_h;
+          //const float map_w = j * dilation_w + offset_w;
+          //const int cur_height = height - h_in;
+          //const int cur_width = width - w_in;
+          //val = dmcn_im2col_bilinear(data_im_ptr, width, cur_height, cur_width, map_h, map_w);
+          val = dmcn_im2col_bilinear(data_im_ptr, width, height, width, h_im, w_im);
+        }
+        *data_col_ptr = val * mask;
+        data_col_ptr += batch_size * height_col * width_col;
+        //data_col_ptr += height_col * width_col;
+      }
+    }
+  }
+}
+
+template <typename scalar_t>
+__global__ void modulated_deformable_col2im_gpu_kernel(const int n,
+                                                       const scalar_t *data_col, const scalar_t *data_offset, const scalar_t *data_mask,
+                                                       const int channels, const int height, const int width,
+                                                       const int kernel_h, const int kernel_w,
+                                                       const int pad_h, const int pad_w,
+                                                       const int stride_h, const int stride_w,
+                                                       const int dilation_h, const int dilation_w,
+                                                       const int channel_per_deformable_group,
+                                                       const int batch_size, const int deformable_group,
+                                                       const int height_col, const int width_col,
+                                                       scalar_t *grad_im)
+{
+  CUDA_KERNEL_LOOP(index, n)
+  {
+    const int j = (index / width_col / height_col / batch_size) % kernel_w;
+    const int i = (index / width_col / height_col / batch_size / kernel_w) % kernel_h;
+    const int c = index / width_col / height_col / batch_size / kernel_w / kernel_h;
+    // compute the start and end of the output
+
+    const int deformable_group_index = c / channel_per_deformable_group;
+
+    int w_out = index % width_col;
+    int h_out = (index / width_col) % height_col;
+    int b = (index / width_col / height_col) % batch_size;
+    int w_in = w_out * stride_w - pad_w;
+    int h_in = h_out * stride_h - pad_h;
+
+    const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col;
+    const scalar_t *data_mask_ptr = data_mask + (b * deformable_group + deformable_group_index) * kernel_h * kernel_w * height_col * width_col;
+    const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out;
+    const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out;
+    const int data_mask_hw_ptr = ((i * kernel_w + j) * height_col + h_out) * width_col + w_out;
+    const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr];
+    const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr];
+    const scalar_t mask = data_mask_ptr[data_mask_hw_ptr];
+    const scalar_t cur_inv_h_data = h_in + i * dilation_h + offset_h;
+    const scalar_t cur_inv_w_data = w_in + j * dilation_w + offset_w;
+
+    const scalar_t cur_top_grad = data_col[index] * mask;
+    const int cur_h = (int)cur_inv_h_data;
+    const int cur_w = (int)cur_inv_w_data;
+    for (int dy = -2; dy <= 2; dy++)
+    {
+      for (int dx = -2; dx <= 2; dx++)
+      {
+        if (cur_h + dy >= 0 && cur_h + dy < height &&
+            cur_w + dx >= 0 && cur_w + dx < width &&
+            abs(cur_inv_h_data - (cur_h + dy)) < 1 &&
+            abs(cur_inv_w_data - (cur_w + dx)) < 1)
+        {
+          int cur_bottom_grad_pos = ((b * channels + c) * height + cur_h + dy) * width + cur_w + dx;
+          scalar_t weight = dmcn_get_gradient_weight(cur_inv_h_data, cur_inv_w_data, cur_h + dy, cur_w + dx, height, width);
+          atomicAdd(grad_im + cur_bottom_grad_pos, weight * cur_top_grad);
+        }
+      }
+    }
+  }
+}
+
+template <typename scalar_t>
+__global__ void modulated_deformable_col2im_coord_gpu_kernel(const int n,
+                                                             const scalar_t *data_col, const scalar_t *data_im,
+                                                             const scalar_t *data_offset, const scalar_t *data_mask,
+                                                             const int channels, const int height, const int width,
+                                                             const int kernel_h, const int kernel_w,
+                                                             const int pad_h, const int pad_w,
+                                                             const int stride_h, const int stride_w,
+                                                             const int dilation_h, const int dilation_w,
+                                                             const int channel_per_deformable_group,
+                                                             const int batch_size, const int offset_channels, const int deformable_group,
+                                                             const int height_col, const int width_col,
+                                                             scalar_t *grad_offset, scalar_t *grad_mask)
+{
+  CUDA_KERNEL_LOOP(index, n)
+  {
+    scalar_t val = 0, mval = 0;
+    int w = index % width_col;
+    int h = (index / width_col) % height_col;
+    int c = (index / width_col / height_col) % offset_channels;
+    int b = (index / width_col / height_col) / offset_channels;
+    // compute the start and end of the output
+
+    const int deformable_group_index = c / (2 * kernel_h * kernel_w);
+    const int col_step = kernel_h * kernel_w;
+    int cnt = 0;
+    const scalar_t *data_col_ptr = data_col + deformable_group_index * channel_per_deformable_group * batch_size * width_col * height_col;
+    const scalar_t *data_im_ptr = data_im + (b * deformable_group + deformable_group_index) * channel_per_deformable_group / kernel_h / kernel_w * height * width;
+    const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col;
+    const scalar_t *data_mask_ptr = data_mask + (b * deformable_group + deformable_group_index) * kernel_h * kernel_w * height_col * width_col;
+
+    const int offset_c = c - deformable_group_index * 2 * kernel_h * kernel_w;
+
+    for (int col_c = (offset_c / 2); col_c < channel_per_deformable_group; col_c += col_step)
+    {
+      const int col_pos = (((col_c * batch_size + b) * height_col) + h) * width_col + w;
+      const int bp_dir = offset_c % 2;
+
+      int j = (col_pos / width_col / height_col / batch_size) % kernel_w;
+      int i = (col_pos / width_col / height_col / batch_size / kernel_w) % kernel_h;
+      int w_out = col_pos % width_col;
+      int h_out = (col_pos / width_col) % height_col;
+      int w_in = w_out * stride_w - pad_w;
+      int h_in = h_out * stride_h - pad_h;
+      const int data_offset_h_ptr = (((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out);
+      const int data_offset_w_ptr = (((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out);
+      const int data_mask_hw_ptr = (((i * kernel_w + j) * height_col + h_out) * width_col + w_out);
+      const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr];
+      const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr];
+      const scalar_t mask = data_mask_ptr[data_mask_hw_ptr];
+      scalar_t inv_h = h_in + i * dilation_h + offset_h;
+      scalar_t inv_w = w_in + j * dilation_w + offset_w;
+      if (inv_h <= -1 || inv_w <= -1 || inv_h >= height || inv_w >= width)
+      {
+        inv_h = inv_w = -2;
+      }
+      else
+      {
+        mval += data_col_ptr[col_pos] * dmcn_im2col_bilinear(data_im_ptr + cnt * height * width, width, height, width, inv_h, inv_w);
+      }
+      const scalar_t weight = dmcn_get_coordinate_weight(
+          inv_h, inv_w,
+          height, width, data_im_ptr + cnt * height * width, width, bp_dir);
+      val += weight * data_col_ptr[col_pos] * mask;
+      cnt += 1;
+    }
+    // KERNEL_ASSIGN(grad_offset[index], offset_req, val);
+    grad_offset[index] = val;
+    if (offset_c % 2 == 0)
+      // KERNEL_ASSIGN(grad_mask[(((b * deformable_group + deformable_group_index) * kernel_h * kernel_w + offset_c / 2) * height_col + h) * width_col + w], mask_req, mval);
+      grad_mask[(((b * deformable_group + deformable_group_index) * kernel_h * kernel_w + offset_c / 2) * height_col + h) * width_col + w] = mval;
+  }
+}
+
+void modulated_deformable_im2col_cuda(
+    const at::Tensor data_im, const at::Tensor data_offset, const at::Tensor data_mask,
+    const int batch_size, const int channels, const int height_im, const int width_im,
+    const int height_col, const int width_col, const int kernel_h, const int kenerl_w,
+    const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w,
+    const int deformable_group, at::Tensor data_col)
+{
+  // num_axes should be smaller than block size
+  const int channel_per_deformable_group = channels / deformable_group;
+  const int num_kernels = channels * batch_size * height_col * width_col;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data_im.type(), "modulated_deformable_im2col_gpu", ([&] {
+        const scalar_t *data_im_ = data_im.data<scalar_t>();
+        const scalar_t *data_offset_ = data_offset.data<scalar_t>();
+        const scalar_t *data_mask_ = data_mask.data<scalar_t>();
+        scalar_t *data_col_ = data_col.data<scalar_t>();
+
+        modulated_deformable_im2col_gpu_kernel<<<GET_BLOCKS(num_kernels), CUDA_NUM_THREADS>>>(
+            num_kernels, data_im_, data_offset_, data_mask_, height_im, width_im, kernel_h, kenerl_w,
+            pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w, channel_per_deformable_group,
+            batch_size, channels, deformable_group, height_col, width_col, data_col_);
+      }));
+
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    // printf("error in modulated_deformable_im2col_cuda: %s\n", cudaGetErrorString(err));
+  }
+}
+
+void modulated_deformable_col2im_cuda(
+    const at::Tensor data_col, const at::Tensor data_offset, const at::Tensor data_mask,
+    const int batch_size, const int channels, const int height_im, const int width_im,
+    const int height_col, const int width_col, const int kernel_h, const int kernel_w,
+    const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w,
+    const int deformable_group, at::Tensor grad_im)
+{
+
+  const int channel_per_deformable_group = channels / deformable_group;
+  const int num_kernels = channels * kernel_h * kernel_w * batch_size * height_col * width_col;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data_col.type(), "modulated_deformable_col2im_gpu", ([&] {
+        const scalar_t *data_col_ = data_col.data<scalar_t>();
+        const scalar_t *data_offset_ = data_offset.data<scalar_t>();
+        const scalar_t *data_mask_ = data_mask.data<scalar_t>();
+        scalar_t *grad_im_ = grad_im.data<scalar_t>();
+
+        modulated_deformable_col2im_gpu_kernel<<<GET_BLOCKS(num_kernels), CUDA_NUM_THREADS>>>(
+            num_kernels, data_col_, data_offset_, data_mask_, channels, height_im, width_im,
+            kernel_h, kernel_w, pad_h, pad_h, stride_h, stride_w,
+            dilation_h, dilation_w, channel_per_deformable_group,
+            batch_size, deformable_group, height_col, width_col, grad_im_);
+      }));
+
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    printf("error in modulated_deformable_col2im_cuda: %s\n", cudaGetErrorString(err));
+  }
+}
+
+void modulated_deformable_col2im_coord_cuda(
+    const at::Tensor data_col, const at::Tensor data_im, const at::Tensor data_offset, const at::Tensor data_mask,
+    const int batch_size, const int channels, const int height_im, const int width_im,
+    const int height_col, const int width_col, const int kernel_h, const int kernel_w,
+    const int pad_h, const int pad_w, const int stride_h, const int stride_w,
+    const int dilation_h, const int dilation_w,
+    const int deformable_group,
+    at::Tensor grad_offset, at::Tensor grad_mask)
+{
+  const int num_kernels = batch_size * height_col * width_col * 2 * kernel_h * kernel_w * deformable_group;
+  const int channel_per_deformable_group = channels * kernel_h * kernel_w / deformable_group;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data_col.type(), "modulated_deformable_col2im_coord_gpu", ([&] {
+        const scalar_t *data_col_ = data_col.data<scalar_t>();
+        const scalar_t *data_im_ = data_im.data<scalar_t>();
+        const scalar_t *data_offset_ = data_offset.data<scalar_t>();
+        const scalar_t *data_mask_ = data_mask.data<scalar_t>();
+        scalar_t *grad_offset_ = grad_offset.data<scalar_t>();
+        scalar_t *grad_mask_ = grad_mask.data<scalar_t>();
+
+        modulated_deformable_col2im_coord_gpu_kernel<<<GET_BLOCKS(num_kernels), CUDA_NUM_THREADS>>>(
+            num_kernels, data_col_, data_im_, data_offset_, data_mask_, channels, height_im, width_im,
+            kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w,
+            dilation_h, dilation_w, channel_per_deformable_group,
+            batch_size, 2 * kernel_h * kernel_w * deformable_group, deformable_group, height_col, width_col,
+            grad_offset_, grad_mask_);
+      }));
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    printf("error in modulated_deformable_col2im_coord_cuda: %s\n", cudaGetErrorString(err));
+  }
+}

DB/assets/ops/dcn/src/deform_pool_cuda.cpp

@@ -0,0 +1,87 @@
+// modify from
+// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/modulated_dcn_cuda.c
+
+// based on
+// author: Charles Shang
+// https://github.com/torch/cunn/blob/master/lib/THCUNN/generic/SpatialConvolutionMM.cu
+
+#include <torch/extension.h>
+
+#include <cmath>
+#include <vector>
+
+void DeformablePSROIPoolForward(
+    const at::Tensor data, const at::Tensor bbox, const at::Tensor trans,
+    at::Tensor out, at::Tensor top_count, const int batch, const int channels,
+    const int height, const int width, const int num_bbox,
+    const int channels_trans, const int no_trans, const float spatial_scale,
+    const int output_dim, const int group_size, const int pooled_size,
+    const int part_size, const int sample_per_part, const float trans_std);
+
+void DeformablePSROIPoolBackwardAcc(
+    const at::Tensor out_grad, const at::Tensor data, const at::Tensor bbox,
+    const at::Tensor trans, const at::Tensor top_count, at::Tensor in_grad,
+    at::Tensor trans_grad, const int batch, const int channels,
+    const int height, const int width, const int num_bbox,
+    const int channels_trans, const int no_trans, const float spatial_scale,
+    const int output_dim, const int group_size, const int pooled_size,
+    const int part_size, const int sample_per_part, const float trans_std);
+
+void deform_psroi_pooling_cuda_forward(
+    at::Tensor input, at::Tensor bbox, at::Tensor trans, at::Tensor out,
+    at::Tensor top_count, const int no_trans, const float spatial_scale,
+    const int output_dim, const int group_size, const int pooled_size,
+    const int part_size, const int sample_per_part, const float trans_std) {
+  TORCH_CHECK(input.is_contiguous(), "input tensor has to be contiguous");
+
+  const int batch = input.size(0);
+  const int channels = input.size(1);
+  const int height = input.size(2);
+  const int width = input.size(3);
+  const int channels_trans = no_trans ? 2 : trans.size(1);
+
+  const int num_bbox = bbox.size(0);
+  if (num_bbox != out.size(0))
+    AT_ERROR("Output shape and bbox number wont match: (%d vs %d).",
+             out.size(0), num_bbox);
+
+  DeformablePSROIPoolForward(
+      input, bbox, trans, out, top_count, batch, channels, height, width,
+      num_bbox, channels_trans, no_trans, spatial_scale, output_dim, group_size,
+      pooled_size, part_size, sample_per_part, trans_std);
+}
+
+void deform_psroi_pooling_cuda_backward(
+    at::Tensor out_grad, at::Tensor input, at::Tensor bbox, at::Tensor trans,
+    at::Tensor top_count, at::Tensor input_grad, at::Tensor trans_grad,
+    const int no_trans, const float spatial_scale, const int output_dim,
+    const int group_size, const int pooled_size, const int part_size,
+    const int sample_per_part, const float trans_std) {
+  TORCH_CHECK(out_grad.is_contiguous(), "out_grad tensor has to be contiguous");
+  TORCH_CHECK(input.is_contiguous(), "input tensor has to be contiguous");
+
+  const int batch = input.size(0);
+  const int channels = input.size(1);
+  const int height = input.size(2);
+  const int width = input.size(3);
+  const int channels_trans = no_trans ? 2 : trans.size(1);
+
+  const int num_bbox = bbox.size(0);
+  if (num_bbox != out_grad.size(0))
+    AT_ERROR("Output shape and bbox number wont match: (%d vs %d).",
+             out_grad.size(0), num_bbox);
+
+  DeformablePSROIPoolBackwardAcc(
+      out_grad, input, bbox, trans, top_count, input_grad, trans_grad, batch,
+      channels, height, width, num_bbox, channels_trans, no_trans,
+      spatial_scale, output_dim, group_size, pooled_size, part_size,
+      sample_per_part, trans_std);
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("deform_psroi_pooling_cuda_forward", &deform_psroi_pooling_cuda_forward,
+        "deform psroi pooling forward(CUDA)");
+  m.def("deform_psroi_pooling_cuda_backward",
+        &deform_psroi_pooling_cuda_backward,
+        "deform psroi pooling backward(CUDA)");
+}

DB/assets/ops/dcn/src/deform_pool_cuda_kernel.cu

@@ -0,0 +1,364 @@
+/*!
+ * Copyright (c) 2017 Microsoft
+ * Licensed under The MIT License [see LICENSE for details]
+ * \file deformable_psroi_pooling.cu
+ * \brief
+ * \author Yi Li, Guodong Zhang, Jifeng Dai
+*/
+/***************** Adapted by Charles Shang *********************/
+// modify from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/cuda/deform_psroi_pooling_cuda.cu
+
+#include <ATen/ATen.h>
+#include <THC/THCAtomics.cuh>
+#include <stdio.h>
+#include <math.h>
+#include <algorithm>
+
+using namespace at;
+
+#define CUDA_KERNEL_LOOP(i, n)                        \
+  for (int i = blockIdx.x * blockDim.x + threadIdx.x; \
+       i < (n);                                       \
+       i += blockDim.x * gridDim.x)
+
+const int CUDA_NUM_THREADS = 1024;
+inline int GET_BLOCKS(const int N)
+{
+  return (N + CUDA_NUM_THREADS - 1) / CUDA_NUM_THREADS;
+}
+
+template <typename scalar_t>
+__device__ scalar_t bilinear_interp(
+    const scalar_t *data,
+    const scalar_t x,
+    const scalar_t y,
+    const int width,
+    const int height)
+{
+  int x1 = floor(x);
+  int x2 = ceil(x);
+  int y1 = floor(y);
+  int y2 = ceil(y);
+  scalar_t dist_x = (scalar_t)(x - x1);
+  scalar_t dist_y = (scalar_t)(y - y1);
+  scalar_t value11 = data[y1 * width + x1];
+  scalar_t value12 = data[y2 * width + x1];
+  scalar_t value21 = data[y1 * width + x2];
+  scalar_t value22 = data[y2 * width + x2];
+  scalar_t value = (1 - dist_x) * (1 - dist_y) * value11 + (1 - dist_x) * dist_y * value12 + dist_x * (1 - dist_y) * value21 + dist_x * dist_y * value22;
+  return value;
+}
+
+template <typename scalar_t>
+__global__ void DeformablePSROIPoolForwardKernel(
+    const int count,
+    const scalar_t *bottom_data,
+    const scalar_t spatial_scale,
+    const int channels,
+    const int height, const int width,
+    const int pooled_height, const int pooled_width,
+    const scalar_t *bottom_rois, const scalar_t *bottom_trans,
+    const int no_trans,
+    const scalar_t trans_std,
+    const int sample_per_part,
+    const int output_dim,
+    const int group_size,
+    const int part_size,
+    const int num_classes,
+    const int channels_each_class,
+    scalar_t *top_data,
+    scalar_t *top_count)
+{
+  CUDA_KERNEL_LOOP(index, count)
+  {
+    // The output is in order (n, ctop, ph, pw)
+    int pw = index % pooled_width;
+    int ph = (index / pooled_width) % pooled_height;
+    int ctop = (index / pooled_width / pooled_height) % output_dim;
+    int n = index / pooled_width / pooled_height / output_dim;
+
+    // [start, end) interval for spatial sampling
+    const scalar_t *offset_bottom_rois = bottom_rois + n * 5;
+    int roi_batch_ind = offset_bottom_rois[0];
+    scalar_t roi_start_w = (scalar_t)(round(offset_bottom_rois[1])) * spatial_scale - 0.5;
+    scalar_t roi_start_h = (scalar_t)(round(offset_bottom_rois[2])) * spatial_scale - 0.5;
+    scalar_t roi_end_w = (scalar_t)(round(offset_bottom_rois[3]) + 1.) * spatial_scale - 0.5;
+    scalar_t roi_end_h = (scalar_t)(round(offset_bottom_rois[4]) + 1.) * spatial_scale - 0.5;
+
+    // Force too small ROIs to be 1x1
+    scalar_t roi_width = max(roi_end_w - roi_start_w, 0.1); //avoid 0
+    scalar_t roi_height = max(roi_end_h - roi_start_h, 0.1);
+
+    // Compute w and h at bottom
+    scalar_t bin_size_h = roi_height / (scalar_t)(pooled_height);
+    scalar_t bin_size_w = roi_width / (scalar_t)(pooled_width);
+
+    scalar_t sub_bin_size_h = bin_size_h / (scalar_t)(sample_per_part);
+    scalar_t sub_bin_size_w = bin_size_w / (scalar_t)(sample_per_part);
+
+    int part_h = floor((scalar_t)(ph) / pooled_height * part_size);
+    int part_w = floor((scalar_t)(pw) / pooled_width * part_size);
+    int class_id = ctop / channels_each_class;
+    scalar_t trans_x = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std;
+    scalar_t trans_y = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2 + 1) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std;
+
+    scalar_t wstart = (scalar_t)(pw)*bin_size_w + roi_start_w;
+    wstart += trans_x * roi_width;
+    scalar_t hstart = (scalar_t)(ph)*bin_size_h + roi_start_h;
+    hstart += trans_y * roi_height;
+
+    scalar_t sum = 0;
+    int count = 0;
+    int gw = floor((scalar_t)(pw)*group_size / pooled_width);
+    int gh = floor((scalar_t)(ph)*group_size / pooled_height);
+    gw = min(max(gw, 0), group_size - 1);
+    gh = min(max(gh, 0), group_size - 1);
+
+    const scalar_t *offset_bottom_data = bottom_data + (roi_batch_ind * channels) * height * width;
+    for (int ih = 0; ih < sample_per_part; ih++)
+    {
+      for (int iw = 0; iw < sample_per_part; iw++)
+      {
+        scalar_t w = wstart + iw * sub_bin_size_w;
+        scalar_t h = hstart + ih * sub_bin_size_h;
+        // bilinear interpolation
+        if (w < -0.5 || w > width - 0.5 || h < -0.5 || h > height - 0.5)
+        {
+          continue;
+        }
+        w = min(max(w, 0.), width - 1.);
+        h = min(max(h, 0.), height - 1.);
+        int c = (ctop * group_size + gh) * group_size + gw;
+        scalar_t val = bilinear_interp(offset_bottom_data + c * height * width, w, h, width, height);
+        sum += val;
+        count++;
+      }
+    }
+    top_data[index] = count == 0 ? (scalar_t)(0) : sum / count;
+    top_count[index] = count;
+  }
+}
+
+template <typename scalar_t>
+__global__ void DeformablePSROIPoolBackwardAccKernel(
+    const int count,
+    const scalar_t *top_diff,
+    const scalar_t *top_count,
+    const int num_rois,
+    const scalar_t spatial_scale,
+    const int channels,
+    const int height, const int width,
+    const int pooled_height, const int pooled_width,
+    const int output_dim,
+    scalar_t *bottom_data_diff, scalar_t *bottom_trans_diff,
+    const scalar_t *bottom_data,
+    const scalar_t *bottom_rois,
+    const scalar_t *bottom_trans,
+    const int no_trans,
+    const scalar_t trans_std,
+    const int sample_per_part,
+    const int group_size,
+    const int part_size,
+    const int num_classes,
+    const int channels_each_class)
+{
+  CUDA_KERNEL_LOOP(index, count)
+  {
+    // The output is in order (n, ctop, ph, pw)
+    int pw = index % pooled_width;
+    int ph = (index / pooled_width) % pooled_height;
+    int ctop = (index / pooled_width / pooled_height) % output_dim;
+    int n = index / pooled_width / pooled_height / output_dim;
+
+    // [start, end) interval for spatial sampling
+    const scalar_t *offset_bottom_rois = bottom_rois + n * 5;
+    int roi_batch_ind = offset_bottom_rois[0];
+    scalar_t roi_start_w = (scalar_t)(round(offset_bottom_rois[1])) * spatial_scale - 0.5;
+    scalar_t roi_start_h = (scalar_t)(round(offset_bottom_rois[2])) * spatial_scale - 0.5;
+    scalar_t roi_end_w = (scalar_t)(round(offset_bottom_rois[3]) + 1.) * spatial_scale - 0.5;
+    scalar_t roi_end_h = (scalar_t)(round(offset_bottom_rois[4]) + 1.) * spatial_scale - 0.5;
+
+    // Force too small ROIs to be 1x1
+    scalar_t roi_width = max(roi_end_w - roi_start_w, 0.1); //avoid 0
+    scalar_t roi_height = max(roi_end_h - roi_start_h, 0.1);
+
+    // Compute w and h at bottom
+    scalar_t bin_size_h = roi_height / (scalar_t)(pooled_height);
+    scalar_t bin_size_w = roi_width / (scalar_t)(pooled_width);
+
+    scalar_t sub_bin_size_h = bin_size_h / (scalar_t)(sample_per_part);
+    scalar_t sub_bin_size_w = bin_size_w / (scalar_t)(sample_per_part);
+
+    int part_h = floor((scalar_t)(ph) / pooled_height * part_size);
+    int part_w = floor((scalar_t)(pw) / pooled_width * part_size);
+    int class_id = ctop / channels_each_class;
+    scalar_t trans_x = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std;
+    scalar_t trans_y = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2 + 1) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std;
+
+    scalar_t wstart = (scalar_t)(pw)*bin_size_w + roi_start_w;
+    wstart += trans_x * roi_width;
+    scalar_t hstart = (scalar_t)(ph)*bin_size_h + roi_start_h;
+    hstart += trans_y * roi_height;
+
+    if (top_count[index] <= 0)
+    {
+      continue;
+    }
+    scalar_t diff_val = top_diff[index] / top_count[index];
+    const scalar_t *offset_bottom_data = bottom_data + roi_batch_ind * channels * height * width;
+    scalar_t *offset_bottom_data_diff = bottom_data_diff + roi_batch_ind * channels * height * width;
+    int gw = floor((scalar_t)(pw)*group_size / pooled_width);
+    int gh = floor((scalar_t)(ph)*group_size / pooled_height);
+    gw = min(max(gw, 0), group_size - 1);
+    gh = min(max(gh, 0), group_size - 1);
+
+    for (int ih = 0; ih < sample_per_part; ih++)
+    {
+      for (int iw = 0; iw < sample_per_part; iw++)
+      {
+        scalar_t w = wstart + iw * sub_bin_size_w;
+        scalar_t h = hstart + ih * sub_bin_size_h;
+        // bilinear interpolation
+        if (w < -0.5 || w > width - 0.5 || h < -0.5 || h > height - 0.5)
+        {
+          continue;
+        }
+        w = min(max(w, 0.), width - 1.);
+        h = min(max(h, 0.), height - 1.);
+        int c = (ctop * group_size + gh) * group_size + gw;
+        // backward on feature
+        int x0 = floor(w);
+        int x1 = ceil(w);
+        int y0 = floor(h);
+        int y1 = ceil(h);
+        scalar_t dist_x = w - x0, dist_y = h - y0;
+        scalar_t q00 = (1 - dist_x) * (1 - dist_y);
+        scalar_t q01 = (1 - dist_x) * dist_y;
+        scalar_t q10 = dist_x * (1 - dist_y);
+        scalar_t q11 = dist_x * dist_y;
+        int bottom_index_base = c * height * width;
+        atomicAdd(offset_bottom_data_diff + bottom_index_base + y0 * width + x0, q00 * diff_val);
+        atomicAdd(offset_bottom_data_diff + bottom_index_base + y1 * width + x0, q01 * diff_val);
+        atomicAdd(offset_bottom_data_diff + bottom_index_base + y0 * width + x1, q10 * diff_val);
+        atomicAdd(offset_bottom_data_diff + bottom_index_base + y1 * width + x1, q11 * diff_val);
+
+        if (no_trans)
+        {
+          continue;
+        }
+        scalar_t U00 = offset_bottom_data[bottom_index_base + y0 * width + x0];
+        scalar_t U01 = offset_bottom_data[bottom_index_base + y1 * width + x0];
+        scalar_t U10 = offset_bottom_data[bottom_index_base + y0 * width + x1];
+        scalar_t U11 = offset_bottom_data[bottom_index_base + y1 * width + x1];
+        scalar_t diff_x = (U11 * dist_y + U10 * (1 - dist_y) - U01 * dist_y - U00 * (1 - dist_y)) * trans_std * diff_val;
+        diff_x *= roi_width;
+        scalar_t diff_y = (U11 * dist_x + U01 * (1 - dist_x) - U10 * dist_x - U00 * (1 - dist_x)) * trans_std * diff_val;
+        diff_y *= roi_height;
+
+        atomicAdd(bottom_trans_diff + (((n * num_classes + class_id) * 2) * part_size + part_h) * part_size + part_w, diff_x);
+        atomicAdd(bottom_trans_diff + (((n * num_classes + class_id) * 2 + 1) * part_size + part_h) * part_size + part_w, diff_y);
+      }
+    }
+  }
+}
+
+void DeformablePSROIPoolForward(const at::Tensor data,
+                                const at::Tensor bbox,
+                                const at::Tensor trans,
+                                at::Tensor out,
+                                at::Tensor top_count,
+                                const int batch,
+                                const int channels,
+                                const int height,
+                                const int width,
+                                const int num_bbox,
+                                const int channels_trans,
+                                const int no_trans,
+                                const float spatial_scale,
+                                const int output_dim,
+                                const int group_size,
+                                const int pooled_size,
+                                const int part_size,
+                                const int sample_per_part,
+                                const float trans_std)
+{
+  const int pooled_height = pooled_size;
+  const int pooled_width = pooled_size;
+  const int count = num_bbox * output_dim * pooled_height * pooled_width;
+  const int num_classes = no_trans ? 1 : channels_trans / 2;
+  const int channels_each_class = no_trans ? output_dim : output_dim / num_classes;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      data.type(), "deformable_psroi_pool_forward", ([&] {
+        const scalar_t *bottom_data = data.data<scalar_t>();
+        const scalar_t *bottom_rois = bbox.data<scalar_t>();
+        const scalar_t *bottom_trans = no_trans ? NULL : trans.data<scalar_t>();
+        scalar_t *top_data = out.data<scalar_t>();
+        scalar_t *top_count_data = top_count.data<scalar_t>();
+
+        DeformablePSROIPoolForwardKernel<<<GET_BLOCKS(count), CUDA_NUM_THREADS>>>(
+            count, bottom_data, (scalar_t)spatial_scale, channels, height, width, pooled_height, pooled_width,
+            bottom_rois, bottom_trans, no_trans, (scalar_t)trans_std, sample_per_part, output_dim,
+            group_size, part_size, num_classes, channels_each_class, top_data, top_count_data);
+      }));
+
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    printf("error in DeformablePSROIPoolForward: %s\n", cudaGetErrorString(err));
+  }
+}
+
+void DeformablePSROIPoolBackwardAcc(const at::Tensor out_grad,
+                                    const at::Tensor data,
+                                    const at::Tensor bbox,
+                                    const at::Tensor trans,
+                                    const at::Tensor top_count,
+                                    at::Tensor in_grad,
+                                    at::Tensor trans_grad,
+                                    const int batch,
+                                    const int channels,
+                                    const int height,
+                                    const int width,
+                                    const int num_bbox,
+                                    const int channels_trans,
+                                    const int no_trans,
+                                    const float spatial_scale,
+                                    const int output_dim,
+                                    const int group_size,
+                                    const int pooled_size,
+                                    const int part_size,
+                                    const int sample_per_part,
+                                    const float trans_std)
+{
+  // LOG(INFO) << "DeformablePSROIPoolBackward";
+  const int num_rois = num_bbox;
+  const int pooled_height = pooled_size;
+  const int pooled_width = pooled_size;
+  const int count = num_bbox * output_dim * pooled_height * pooled_width;
+  const int num_classes = no_trans ? 1 : channels_trans / 2;
+  const int channels_each_class = no_trans ? output_dim : output_dim / num_classes;
+
+  AT_DISPATCH_FLOATING_TYPES_AND_HALF(
+      out_grad.type(), "deformable_psroi_pool_backward_acc", ([&] {
+        const scalar_t *top_diff = out_grad.data<scalar_t>();
+        const scalar_t *bottom_data = data.data<scalar_t>();
+        const scalar_t *bottom_rois = bbox.data<scalar_t>();
+        const scalar_t *bottom_trans = no_trans ? NULL : trans.data<scalar_t>();
+        scalar_t *bottom_data_diff = in_grad.data<scalar_t>();
+        scalar_t *bottom_trans_diff = no_trans ? NULL : trans_grad.data<scalar_t>();
+        const scalar_t *top_count_data = top_count.data<scalar_t>();
+
+        DeformablePSROIPoolBackwardAccKernel<<<GET_BLOCKS(count), CUDA_NUM_THREADS>>>(
+            count, top_diff, top_count_data, num_rois, (scalar_t)spatial_scale, channels, height, width,
+            pooled_height, pooled_width, output_dim, bottom_data_diff, bottom_trans_diff,
+            bottom_data, bottom_rois, bottom_trans, no_trans, (scalar_t)trans_std, sample_per_part,
+            group_size, part_size, num_classes, channels_each_class);
+      }));
+
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess)
+  {
+    printf("error in DeformablePSROIPoolForward: %s\n", cudaGetErrorString(err));
+  }
+}

DB/backbones/__init__.py

@@ -0,0 +1,2 @@
+from .resnet import resnet18, resnet34, resnet50, resnet101, deformable_resnet50, deformable_resnet18
+from .mobilenetv3 import mobilenet_v3_large, mobilenet_v3_small

DB/backbones/mobilenetv3.py

@@ -0,0 +1,252 @@
+# https://github.com/kuan-wang/pytorch-mobilenet-v3
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+__all__ = ['MobileNetV3', 'mobilenetv3']
+
+
+def conv_bn(inp, oup, stride, conv_layer=nn.Conv2d, norm_layer=nn.BatchNorm2d, nlin_layer=nn.ReLU):
+    return nn.Sequential(
+        conv_layer(inp, oup, 3, stride, 1, bias=False),
+        norm_layer(oup),
+        nlin_layer(inplace=True)
+    )
+
+
+def conv_1x1_bn(inp, oup, conv_layer=nn.Conv2d, norm_layer=nn.BatchNorm2d, nlin_layer=nn.ReLU):
+    return nn.Sequential(
+        conv_layer(inp, oup, 1, 1, 0, bias=False),
+        norm_layer(oup),
+        nlin_layer(inplace=True)
+    )
+
+
+class Hswish(nn.Module):
+    def __init__(self, inplace=True):
+        super(Hswish, self).__init__()
+        self.inplace = inplace
+
+    def forward(self, x):
+        return x * F.relu6(x + 3., inplace=self.inplace) / 6.
+
+
+class Hsigmoid(nn.Module):
+    def __init__(self, inplace=True):
+        super(Hsigmoid, self).__init__()
+        self.inplace = inplace
+
+    def forward(self, x):
+        return F.relu6(x + 3., inplace=self.inplace) / 6.
+
+
+class SEModule(nn.Module):
+    def __init__(self, channel, reduction=4):
+        super(SEModule, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(
+            nn.Linear(channel, channel // reduction, bias=False),
+            nn.ReLU(inplace=True),
+            nn.Linear(channel // reduction, channel, bias=False),
+            Hsigmoid()
+            # nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        b, c, _, _ = x.size()
+        y = self.avg_pool(x).view(b, c)
+        y = self.fc(y).view(b, c, 1, 1)
+        return x * y.expand_as(x)
+
+
+class Identity(nn.Module):
+    def __init__(self, channel):
+        super(Identity, self).__init__()
+
+    def forward(self, x):
+        return x
+
+
+def make_divisible(x, divisible_by=8):
+    import numpy as np
+    return int(np.ceil(x * 1. / divisible_by) * divisible_by)
+
+
+class MobileBottleneck(nn.Module):
+    def __init__(self, inp, oup, kernel, stride, exp, se=False, nl='RE'):
+        super(MobileBottleneck, self).__init__()
+        assert stride in [1, 2]
+        assert kernel in [3, 5]
+        padding = (kernel - 1) // 2
+        self.use_res_connect = stride == 1 and inp == oup
+
+        conv_layer = nn.Conv2d
+        norm_layer = nn.BatchNorm2d
+        if nl == 'RE':
+            nlin_layer = nn.ReLU # or ReLU6
+        elif nl == 'HS':
+            nlin_layer = Hswish
+        else:
+            raise NotImplementedError
+        if se:
+            SELayer = SEModule
+        else:
+            SELayer = Identity
+
+        self.conv = nn.Sequential(
+            # pw
+            conv_layer(inp, exp, 1, 1, 0, bias=False),
+            norm_layer(exp),
+            nlin_layer(inplace=True),
+            # dw
+            conv_layer(exp, exp, kernel, stride, padding, groups=exp, bias=False),
+            norm_layer(exp),
+            SELayer(exp),
+            nlin_layer(inplace=True),
+            # pw-linear
+            conv_layer(exp, oup, 1, 1, 0, bias=False),
+            norm_layer(oup),
+        )
+
+    def forward(self, x):
+        if self.use_res_connect:
+            return x + self.conv(x)
+        else:
+            return self.conv(x)
+
+
+class MobileNetV3(nn.Module):
+    def __init__(self, n_class=1000, input_size=224, dropout=0.8, mode='small', width_mult=1.0):
+        super(MobileNetV3, self).__init__()
+        input_channel = 16
+        last_channel = 1280
+        if mode == 'large':
+            # refer to Table 1 in paper
+            mobile_setting = [
+                # k, exp, c,  se,     nl,  s,
+                [3, 16,  16,  False, 'RE', 1],
+                [3, 64,  24,  False, 'RE', 2],
+                [3, 72,  24,  False, 'RE', 1],  # 3
+                [5, 72,  40,  True,  'RE', 2],
+                [5, 120, 40,  True,  'RE', 1],
+                [5, 120, 40,  True,  'RE', 1],  # 6
+                [3, 240, 80,  False, 'HS', 2],
+                [3, 200, 80,  False, 'HS', 1],
+                [3, 184, 80,  False, 'HS', 1],
+                [3, 184, 80,  False, 'HS', 1],
+                [3, 480, 112, True,  'HS', 1],
+                [3, 672, 112, True,  'HS', 1],  # 12
+                [5, 672, 160, True,  'HS', 2],
+                [5, 960, 160, True,  'HS', 1],
+                [5, 960, 160, True,  'HS', 1],
+            ]
+        elif mode == 'small':
+            # refer to Table 2 in paper
+            mobile_setting = [
+                # k, exp, c,  se,     nl,  s,
+                [3, 16,  16,  True,  'RE', 2],
+                [3, 72,  24,  False, 'RE', 2],
+                [3, 88,  24,  False, 'RE', 1],
+                [5, 96,  40,  True,  'HS', 2],
+                [5, 240, 40,  True,  'HS', 1],
+                [5, 240, 40,  True,  'HS', 1],
+                [5, 120, 48,  True,  'HS', 1],
+                [5, 144, 48,  True,  'HS', 1],
+                [5, 288, 96,  True,  'HS', 2],
+                [5, 576, 96,  True,  'HS', 1],
+                [5, 576, 96,  True,  'HS', 1],
+            ]
+        else:
+            raise NotImplementedError
+
+        # building first layer
+        assert input_size % 32 == 0
+        last_channel = make_divisible(last_channel * width_mult) if width_mult > 1.0 else last_channel
+        self.features = nn.ModuleList([conv_bn(3, input_channel, 2, nlin_layer=Hswish)])   # start_idx = 0: Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same
+        self.classifier = []
+
+        # building mobile blocks
+        for k, exp, c, se, nl, s in mobile_setting:
+            output_channel = make_divisible(c * width_mult)
+            exp_channel = make_divisible(exp * width_mult)
+            self.features.append(MobileBottleneck(input_channel, output_channel, k, s, exp_channel, se, nl))
+            input_channel = output_channel
+
+        # building last several layers
+        if mode == 'large':
+            last_conv = make_divisible(960 * width_mult)
+            self.features.append(conv_1x1_bn(input_channel, last_conv, nlin_layer=Hswish))  # 16
+            self.features.append(nn.AdaptiveAvgPool2d(1))
+            self.features.append(nn.Conv2d(last_conv, last_channel, 1, 1, 0))
+            self.features.append(Hswish(inplace=True))
+        elif mode == 'small':
+            last_conv = make_divisible(576 * width_mult)
+            self.features.append(conv_1x1_bn(input_channel, last_conv, nlin_layer=Hswish))
+            # self.features.append(SEModule(last_conv))  # refer to paper Table2, but I think this is a mistake
+            self.features.append(nn.AdaptiveAvgPool2d(1))
+            self.features.append(nn.Conv2d(last_conv, last_channel, 1, 1, 0))
+            self.features.append(Hswish(inplace=True))
+        else:
+            raise NotImplementedError
+
+        # make it nn.Sequential
+        #self.features = nn.Sequential(*self.features)  del for dbnet
+
+        # building classifier
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=dropout),    # refer to paper section 6
+            nn.Linear(last_channel, n_class),
+        )
+
+        self._initialize_weights()
+
+    def forward(self, x):
+        '''x = self.features(x)
+        x = x.mean(3).mean(2)
+        x = self.classifier(x)
+        return x'''
+        x2, x3, x4, x5 = None, None, None, None
+        for stage in range(17): # https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.1/ppocr/modeling/backbones/det_mobilenet_v3.py
+            x = self.features[stage](x)
+            if stage == 3:  # if s == 2 and start_idx > 3
+                x2 = x
+            elif stage == 6:
+                x3 = x
+            elif stage == 12:
+                x4 = x
+            elif stage == 16:
+                x5 = x
+        return x2, x3, x4, x5
+
+    def _initialize_weights(self):
+        # weight initialization
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out')
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+
+
+def mobilenet_v3_large(pretrained=False, **kwargs):
+    model = MobileNetV3(mode='large', **kwargs)
+    if pretrained:
+        state_dict = torch.load('mobilenetv3_large.pth.tar')
+        model.load_state_dict(state_dict, strict=True)
+        # raise NotImplementedError
+    return model
+
+def mobilenet_v3_small(pretrained=False, **kwargs):
+    model = MobileNetV3(mode='small', **kwargs)
+    if pretrained:
+        state_dict = torch.load('mobilenetv3_small_67.4.pth.tar')
+        model.load_state_dict(state_dict, strict=True)
+        # raise NotImplementedError
+    return model

DB/backbones/resnet.py

@@ -0,0 +1,336 @@
+import torch.nn as nn
+import math
+import torch.utils.model_zoo as model_zoo
+BatchNorm2d = nn.BatchNorm2d
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+
+def constant_init(module, constant, bias=0):
+    nn.init.constant_(module.weight, constant)
+    if hasattr(module, 'bias'):
+        nn.init.constant_(module.bias, bias)
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, dcn=None):
+        super(BasicBlock, self).__init__()
+        self.with_dcn = dcn is not None
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.with_modulated_dcn = False
+        if self.with_dcn:
+            fallback_on_stride = dcn.get('fallback_on_stride', False)
+            self.with_modulated_dcn = dcn.get('modulated', False)
+        # self.conv2 = conv3x3(planes, planes)
+        if not self.with_dcn or fallback_on_stride:
+            self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                                   padding=1, bias=False)
+        else:
+            deformable_groups = dcn.get('deformable_groups', 1)
+            if not self.with_modulated_dcn:
+                from assets.ops.dcn import DeformConv
+                conv_op = DeformConv
+                offset_channels = 18
+            else:
+                from assets.ops.dcn import ModulatedDeformConv
+                conv_op = ModulatedDeformConv
+                offset_channels = 27
+            self.conv2_offset = nn.Conv2d(
+                planes,
+                deformable_groups * offset_channels,
+                kernel_size=3,
+                padding=1)
+            self.conv2 = conv_op(
+                planes,
+                planes,
+                kernel_size=3,
+                padding=1,
+                deformable_groups=deformable_groups,
+                bias=False)
+        self.bn2 = BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        # out = self.conv2(out)
+        if not self.with_dcn:
+            out = self.conv2(out)
+        elif self.with_modulated_dcn:
+            offset_mask = self.conv2_offset(out)
+            offset = offset_mask[:, :18, :, :]
+            mask = offset_mask[:, -9:, :, :].sigmoid()
+            out = self.conv2(out, offset, mask)
+        else:
+            offset = self.conv2_offset(out)
+            out = self.conv2(out, offset)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, dcn=None):
+        super(Bottleneck, self).__init__()
+        self.with_dcn = dcn is not None
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = BatchNorm2d(planes)
+        fallback_on_stride = False
+        self.with_modulated_dcn = False
+        if self.with_dcn:
+            fallback_on_stride = dcn.get('fallback_on_stride', False)
+            self.with_modulated_dcn = dcn.get('modulated', False)
+        if not self.with_dcn or fallback_on_stride:
+            self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                                   stride=stride, padding=1, bias=False)
+        else:
+            deformable_groups = dcn.get('deformable_groups', 1)
+            if not self.with_modulated_dcn:
+                from assets.ops.dcn import DeformConv
+                conv_op = DeformConv
+                offset_channels = 18
+            else:
+                from assets.ops.dcn import ModulatedDeformConv
+                conv_op = ModulatedDeformConv
+                offset_channels = 27
+            self.conv2_offset = nn.Conv2d(
+                planes, deformable_groups * offset_channels,
+                kernel_size=3,
+                padding=1)
+            self.conv2 = conv_op(
+                planes, planes, kernel_size=3, padding=1, stride=stride,
+                deformable_groups=deformable_groups, bias=False)
+        self.bn2 = BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
+        self.bn3 = BatchNorm2d(planes * 4)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self.dcn = dcn
+        self.with_dcn = dcn is not None
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        # out = self.conv2(out)
+        if not self.with_dcn:
+            out = self.conv2(out)
+        elif self.with_modulated_dcn:
+            offset_mask = self.conv2_offset(out)
+            offset = offset_mask[:, :18, :, :]
+            mask = offset_mask[:, -9:, :, :].sigmoid()
+            out = self.conv2(out, offset, mask)
+        else:
+            offset = self.conv2_offset(out)
+            out = self.conv2(out, offset)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+    def __init__(self, block, layers, num_classes=1000, 
+                 dcn=None, stage_with_dcn=(False, False, False, False)):
+        self.dcn = dcn
+        self.stage_with_dcn = stage_with_dcn
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = BatchNorm2d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(
+            block, 128, layers[1], stride=2, dcn=dcn)
+        self.layer3 = self._make_layer(
+            block, 256, layers[2], stride=2, dcn=dcn)
+        self.layer4 = self._make_layer(
+            block, 512, layers[3], stride=2, dcn=dcn)
+        self.avgpool = nn.AvgPool2d(7, stride=1)
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+    
+        self.smooth = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=1)    
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+        if self.dcn is not None:
+            for m in self.modules():
+                if isinstance(m, Bottleneck) or isinstance(m, BasicBlock):
+                    if hasattr(m, 'conv2_offset'):
+                        constant_init(m.conv2_offset, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dcn=None):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes,
+                            stride, downsample, dcn=dcn))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes, dcn=dcn))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x2 = self.layer1(x)
+        x3 = self.layer2(x2)
+        x4 = self.layer3(x3)
+        x5 = self.layer4(x4)
+
+        return x2, x3, x4, x5
+
+
+def resnet18(pretrained=True, **kwargs):
+    """Constructs a ResNet-18 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet18']), strict=False)
+    return model
+
+def deformable_resnet18(pretrained=True, **kwargs):
+    """Constructs a ResNet-18 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2],
+                    dcn=dict(modulated=True,
+                            deformable_groups=1,
+                            fallback_on_stride=False),
+                    stage_with_dcn=[False, True, True, True], **kwargs)
+    #if pretrained:
+    #    model.load_state_dict(model_zoo.load_url(
+    #        model_urls['resnet18']), strict=False)
+    return model
+
+
+def resnet34(pretrained=True, **kwargs):
+    """Constructs a ResNet-34 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet34']), strict=False)
+    return model
+
+
+def resnet50(pretrained=True, **kwargs):
+    """Constructs a ResNet-50 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet50']), strict=False)
+    return model
+
+
+def deformable_resnet50(pretrained=True, **kwargs):
+    """Constructs a ResNet-50 model with deformable conv.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3],
+                   dcn=dict(modulated=True,
+                            deformable_groups=1,
+                            fallback_on_stride=False),
+                   stage_with_dcn=[False, True, True, True],
+                   **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet50']), strict=False)
+    return model
+
+
+def resnet101(pretrained=True, **kwargs):
+    """Constructs a ResNet-101 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet101']), strict=False)
+    return model
+
+
+def resnet152(pretrained=True, **kwargs):
+    """Constructs a ResNet-152 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(
+            model_urls['resnet152']), strict=False)
+    return model

DB/concern/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File              : __init__.py
+# Author            : Zhaoyi Wan <wanzhaoyi@megvii.com>
+# Date              : 21.11.2018
+# Last Modified Date: 08.01.2019
+# Last Modified By  : Zhaoyi Wan <wanzhaoyi@megvii.com>
+
+from .log import Logger
+from .average_meter import AverageMeter
+from .visualizer import Visualize
+from .box2seg import resize_with_coordinates, box2seg
+from .convert import convert

DB/concern/average_meter.py

@@ -0,0 +1,17 @@
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+        return self

DB/concern/box2seg.py

@@ -0,0 +1,69 @@
+import cv2
+import numpy as np
+from scipy import interpolate
+
+def intersection(x, p1, p2):
+    x1, y1 = p1
+    x2, y2 = p2
+    if x2 == x1:
+        return 0
+    k = (x - x1) / (x2 - x1)
+    return k * (y2 - y1) + y1
+
+
+def midpoint(p1, p2, typed=float):
+    return [typed((p1[0] + p2[0]) / 2), typed((p1[1] + p2[1]) / 2)]
+
+
+def resize_with_coordinates(image, width, height, coordinates):
+    original_height, original_width = image.shape[:2]
+    resized_image = cv2.resize(image, (width, height))
+    if coordinates is not None:
+        assert coordinates.ndim == 2
+        assert coordinates.shape[-1] == 2
+
+        rate_x = width / original_width
+        rate_y = height / original_height
+
+        coordinates = coordinates * (rate_x, rate_y)
+    return resized_image, coordinates
+
+
+def box2seg(image, boxes, label):
+    height, width = image.shape[:2]
+    mask = np.zeros((height, width), dtype=np.float32)
+    seg = np.zeros((height, width), dtype=np.float32)
+    points = []
+    for box_index in range(boxes.shape[0]):
+        box = boxes[box_index, :, :] # 4x2
+        left_top = box[0]
+        right_top = box[1]
+        right_bottom = box[2]
+        left_bottom = box[3]
+
+        left = [(left_top[0] + left_bottom[0]) / 2, (left_top[1] + left_bottom[1]) / 2]
+        right = [(right_top[0] + right_bottom[0]) / 2, (right_top[1] + right_bottom[1]) / 2]
+
+        center = midpoint(left, right)
+        points.append(midpoint(left, center))
+        points.append(midpoint(right, center))
+
+        poly = np.array([midpoint(left_top, center),
+            midpoint(right_top, center),
+            midpoint(right_bottom, center),
+            midpoint(left_bottom, center)
+            ])
+        seg = cv2.fillPoly(seg, [poly.reshape(4, 1, 2).astype(np.int32)], int(label[box_index]))
+
+    left_y = intersection(0, points[0], points[1])
+    right_y = intersection(width, points[-1], points[-2])
+    points.insert(0, [0, left_y])
+    points.append([width, right_y])
+    points = np.array(points)
+
+    f = interpolate.interp1d(points[:, 0], points[:, 1], fill_value='extrapolate')
+    xnew = np.arange(0, width, 1)
+    ynew = f(xnew).clip(0, height-1)
+    for x in range(width - 1):
+        mask[int(ynew[x]), x] = 1
+    return ynew.reshape(1, -1).round(), seg

DB/concern/config.py

@@ -0,0 +1,191 @@
+import importlib
+from collections import OrderedDict
+
+import anyconfig
+import munch
+
+
+class Config(object):
+    def __init__(self):
+        pass
+
+    def load(self, conf):
+        conf = anyconfig.load(conf)
+        return munch.munchify(conf)
+
+    def compile(self, conf, return_packages=False):
+        packages = conf.get('package', [])
+        defines = {}
+
+        for path in conf.get('import', []):
+            parent_conf = self.load(path)
+            parent_packages, parent_defines = self.compile(
+                parent_conf, return_packages=True)
+            packages.extend(parent_packages)
+            defines.update(parent_defines)
+
+        modules = []
+        for package in packages:
+            module = importlib.import_module(package)
+            modules.append(module)
+
+        if isinstance(conf['define'], dict):
+            conf['define'] = [conf['define']]
+
+        for define in conf['define']:
+            name = define.copy().pop('name')
+
+            if not isinstance(name, str):
+                raise RuntimeError('name must be str')
+
+            defines[name] = self.compile_conf(define, defines, modules)
+
+        if return_packages:
+            return packages, defines
+        else:
+            return defines
+
+    def compile_conf(self, conf, defines, modules):
+        if isinstance(conf, (int, float)):
+            return conf
+        elif isinstance(conf, str):
+            if conf.startswith('^'):
+                return defines[conf[1:]]
+            if conf.startswith('$'):
+                return {'class': self.find_class_in_modules(conf[1:], modules)}
+            return conf
+        elif isinstance(conf, dict):
+            if 'class' in conf:
+                conf['class'] = self.find_class_in_modules(
+                    conf['class'], modules)
+            if 'base' in conf:
+                base = conf.copy().pop('base')
+
+                if not isinstance(base, str):
+                    raise RuntimeError('base must be str')
+
+                conf = {
+                    **defines[base],
+                    **conf,
+                }
+            return {key: self.compile_conf(value, defines, modules) for key, value in conf.items()}
+        elif isinstance(conf, (list, tuple)):
+            return [self.compile_conf(value, defines, modules) for value in conf]
+        else:
+            return conf
+
+    def find_class_in_modules(self, cls, modules):
+        if not isinstance(cls, str):
+            raise RuntimeError('class name must be str')
+
+        if cls.find('.') != -1:
+            package, cls = cls.rsplit('.', 1)
+            module = importlib.import_module(package)
+            if hasattr(module, cls):
+                return module.__name__ + '.' + cls
+
+        for module in modules:
+            if hasattr(module, cls):
+                return module.__name__ + '.' + cls
+        raise RuntimeError('class not found ' + cls)
+
+
+class State:
+    def __init__(self, autoload=True, default=None):
+        self.autoload = autoload
+        self.default = default
+
+
+class StateMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        current_states = []
+        for key, value in attrs.items():
+            if isinstance(value, State):
+                current_states.append((key, value))
+
+        current_states.sort(key=lambda x: x[0])
+        attrs['states'] = OrderedDict(current_states)
+        new_class = super(StateMeta, mcs).__new__(mcs, name, bases, attrs)
+
+        # Walk through the MRO
+        states = OrderedDict()
+        for base in reversed(new_class.__mro__):
+            if hasattr(base, 'states'):
+                states.update(base.states)
+        new_class.states = states
+
+        for key, value in states.items():
+            setattr(new_class, key, value.default)
+
+        return new_class
+
+
+class Configurable(metaclass=StateMeta):
+    def __init__(self, *args, cmd={}, **kwargs):
+        self.load_all(cmd=cmd, **kwargs)
+
+    @staticmethod
+    def construct_class_from_config(args):
+        cls = Configurable.extract_class_from_args(args)
+        return cls(**args)
+
+    @staticmethod
+    def extract_class_from_args(args):
+        cls = args.copy().pop('class')
+        package, cls = cls.rsplit('.', 1)
+        module = importlib.import_module(package)
+        cls = getattr(module, cls)
+        return cls
+
+    def load_all(self, **kwargs):
+        for name, state in self.states.items():
+            if state.autoload:
+                self.load(name, **kwargs)
+
+    def load(self, state_name, **kwargs):
+        # FIXME: kwargs should be filtered
+        # Args passed from command line
+        cmd = kwargs.pop('cmd', dict())
+        if state_name in kwargs:
+            setattr(self, state_name, self.create_member_from_config(
+                (kwargs[state_name], cmd)))
+        else:
+            setattr(self, state_name, self.states[state_name].default)
+
+    def create_member_from_config(self, conf):
+        args, cmd = conf
+        if args is None or isinstance(args, (int, float, str)):
+            return args
+        elif isinstance(args, (list, tuple)):
+            return [self.create_member_from_config((subargs, cmd)) for subargs in args]
+        elif isinstance(args, dict):
+            if 'class' in args:
+                cls = self.extract_class_from_args(args)
+                return cls(**args, cmd=cmd)
+            return {key: self.create_member_from_config((subargs, cmd)) for key, subargs in args.items()}
+        else:
+            return args
+
+    def dump(self):
+        state = {}
+        state['class'] = self.__class__.__module__ + \
+            '.' + self.__class__.__name__
+        for name, value in self.states.items():
+            obj = getattr(self, name)
+            state[name] = self.dump_obj(obj)
+        return state
+
+    def dump_obj(self, obj):
+        if obj is None:
+            return None
+        elif hasattr(obj, 'dump'):
+            return obj.dump()
+        elif isinstance(obj, (int, float, str)):
+            return obj
+        elif isinstance(obj, (list, tuple)):
+            return [self.dump_obj(value) for value in obj]
+        elif isinstance(obj, dict):
+            return {key: self.dump_obj(value) for key, value in obj.items()}
+        else:
+            return str(obj)
+

DB/concern/convert.py

@@ -0,0 +1,31 @@
+from PIL import Image
+import cv2
+import base64
+import io
+import numpy as np
+
+
+def convert(data):
+    if isinstance(data, dict):
+        ndata = {}
+        for key, value in data.items():
+            nkey = key.decode()
+            if nkey == 'img':
+                img = Image.open(io.BytesIO(value))
+                img = img.convert('RGB')
+                img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+                nvalue = img
+            else:
+                nvalue = convert(value)
+            ndata[nkey] = nvalue
+        return ndata
+    elif isinstance(data, list):
+        return [convert(item) for item in data]
+    elif isinstance(data, bytes):
+        return data.decode()
+    else:
+        return data
+
+
+def to_np(x):
+    return x.cpu().data.numpy()

DB/concern/icdar2015_eval/detection/deteval.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import math
+from collections import namedtuple
+import numpy as np
+from shapely.geometry import Polygon
+
+
+class DetectionDetEvalEvaluator(object):
+    def __init__(
+        self,
+        area_recall_constraint=0.8, area_precision_constraint=0.4,
+        ev_param_ind_center_diff_thr=1,
+        mtype_oo_o=1.0, mtype_om_o=0.8, mtype_om_m=1.0
+    ):
+
+
+        self.area_recall_constraint = area_recall_constraint
+        self.area_precision_constraint = area_precision_constraint
+        self.ev_param_ind_center_diff_thr = ev_param_ind_center_diff_thr
+        self.mtype_oo_o = mtype_oo_o
+        self.mtype_om_o = mtype_om_o
+        self.mtype_om_m = mtype_om_m
+
+    def evaluate_image(self, gt, pred):
+
+        def get_union(pD,pG):
+            return Polygon(pD).union(Polygon(pG)).area
+
+        def get_intersection_over_union(pD,pG):
+            return get_intersection(pD, pG) / get_union(pD, pG)
+
+        def get_intersection(pD,pG):
+            return Polygon(pD).intersection(Polygon(pG)).area
+
+        def one_to_one_match(row, col):
+            cont = 0
+            for j in range(len(recallMat[0])):    
+                if recallMat[row,j] >= self.area_recall_constraint and precisionMat[row,j] >= self.area_precision_constraint:
+                    cont = cont +1
+            if (cont != 1):
+                return False
+            cont = 0
+            for i in range(len(recallMat)):    
+                if recallMat[i,col] >= self.area_recall_constraint and precisionMat[i,col] >= self.area_precision_constraint:
+                    cont = cont +1
+            if (cont != 1):
+                return False
+            
+            if recallMat[row,col] >= self.area_recall_constraint and precisionMat[row,col] >= self.area_precision_constraint:
+                return True
+            return False
+        
+        def num_overlaps_gt(gtNum):
+            cont = 0
+            for detNum in range(len(detRects)):
+                if detNum not in detDontCareRectsNum:
+                    if recallMat[gtNum,detNum] > 0 :
+                        cont = cont +1
+            return cont
+
+        def num_overlaps_det(detNum):
+            cont = 0
+            for gtNum in range(len(recallMat)):    
+                if gtNum not in gtDontCareRectsNum:
+                    if recallMat[gtNum,detNum] > 0 :
+                        cont = cont +1
+            return cont
+        
+        def is_single_overlap(row, col):
+            if num_overlaps_gt(row)==1 and num_overlaps_det(col)==1:
+                return True
+            else:
+                return False
+        
+        def one_to_many_match(gtNum):
+            many_sum = 0
+            detRects = []
+            for detNum in range(len(recallMat[0])):    
+                if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and detNum not in detDontCareRectsNum:
+                    if precisionMat[gtNum,detNum] >= self.area_precision_constraint:
+                        many_sum += recallMat[gtNum,detNum]
+                        detRects.append(detNum)
+            if round(many_sum,4) >= self.area_recall_constraint:
+                return True,detRects
+            else:
+                return False,[]         
+        
+        def many_to_one_match(detNum):
+            many_sum = 0
+            gtRects = []
+            for gtNum in range(len(recallMat)):    
+                if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum:
+                    if recallMat[gtNum,detNum] >= self.area_recall_constraint:
+                        many_sum += precisionMat[gtNum,detNum]
+                        gtRects.append(gtNum)
+            if round(many_sum,4) >= self.area_precision_constraint:
+                return True,gtRects
+            else:
+                return False,[]
+        
+        def center_distance(r1, r2):
+            return ((np.mean(r1, axis=0) - np.mean(r2, axis=0)) ** 2).sum() ** 0.5
+        
+        def diag(r):
+            r = np.array(r)
+            return ((r[:, 0].max() - r[:, 0].min()) ** 2 + (r[:, 1].max() - r[:, 1].min()) ** 2) ** 0.5
+        
+        perSampleMetrics = {}
+        
+        recall = 0
+        precision = 0
+        hmean = 0        
+        recallAccum = 0.
+        precisionAccum = 0.
+        gtRects = []
+        detRects = []
+        gtPolPoints = []
+        detPolPoints = []
+        gtDontCareRectsNum = []#Array of Ground Truth Rectangles' keys marked as don't Care
+        detDontCareRectsNum = []#Array of Detected Rectangles' matched with a don't Care GT
+        pairs = []
+        evaluationLog = ""
+        
+        recallMat = np.empty([1,1])
+        precisionMat = np.empty([1,1])              
+        
+        for n in range(len(gt)):
+            points = gt[n]['points']
+            # transcription = gt[n]['text']
+            dontCare = gt[n]['ignore']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            gtRects.append(points)
+            gtPolPoints.append(points)
+            if dontCare:
+                gtDontCareRectsNum.append( len(gtRects)-1 )                 
+        
+        evaluationLog += "GT rectangles: " + str(len(gtRects)) + (" (" + str(len(gtDontCareRectsNum)) + " don't care)\n" if len(gtDontCareRectsNum)>0 else "\n")
+        
+        for n in range(len(pred)):
+            points = pred[n]['points']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            detRect = points
+            detRects.append(detRect)
+            detPolPoints.append(points)
+            if len(gtDontCareRectsNum)>0 :
+                for dontCareRectNum in gtDontCareRectsNum:
+                    dontCareRect = gtRects[dontCareRectNum]
+                    intersected_area = get_intersection(dontCareRect,detRect)
+                    rdDimensions = Polygon(detRect).area
+                    if (rdDimensions==0) :
+                        precision = 0
+                    else:
+                        precision= intersected_area / rdDimensions
+                    if (precision > self.area_precision_constraint):
+                        detDontCareRectsNum.append( len(detRects)-1 )
+                        break
+
+        evaluationLog += "DET rectangles: " + str(len(detRects)) + (" (" + str(len(detDontCareRectsNum)) + " don't care)\n" if len(detDontCareRectsNum)>0 else "\n")
+
+        if len(gtRects)==0:
+            recall = 1
+            precision = 0 if len(detRects)>0 else 1
+
+        if len(detRects)>0:
+            #Calculate recall and precision matrixs
+            outputShape=[len(gtRects),len(detRects)]
+            recallMat = np.empty(outputShape)
+            precisionMat = np.empty(outputShape)
+            gtRectMat = np.zeros(len(gtRects),np.int8)
+            detRectMat = np.zeros(len(detRects),np.int8)
+            for gtNum in range(len(gtRects)):
+                for detNum in range(len(detRects)):
+                    rG = gtRects[gtNum]
+                    rD = detRects[detNum]
+                    intersected_area = get_intersection(rG,rD)
+                    rgDimensions = Polygon(rG).area
+                    rdDimensions = Polygon(rD).area
+                    recallMat[gtNum,detNum] = 0 if rgDimensions==0 else  intersected_area / rgDimensions
+                    precisionMat[gtNum,detNum] = 0 if rdDimensions==0 else intersected_area / rdDimensions
+
+            # Find one-to-one matches
+            evaluationLog += "Find one-to-one matches\n"
+            for gtNum in range(len(gtRects)):
+                for detNum in range(len(detRects)):
+                    if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum and detNum not in detDontCareRectsNum :
+                        match = one_to_one_match(gtNum, detNum)
+                        if match is True :
+                            #in deteval we have to make other validation before mark as one-to-one
+                            if is_single_overlap(gtNum, detNum) is True :
+                                rG = gtRects[gtNum]
+                                rD = detRects[detNum]
+                                normDist = center_distance(rG, rD);
+                                normDist /= diag(rG) + diag(rD);
+                                normDist *= 2.0;
+                                if normDist < self.ev_param_ind_center_diff_thr:
+                                    gtRectMat[gtNum] = 1
+                                    detRectMat[detNum] = 1
+                                    recallAccum += self.mtype_oo_o
+                                    precisionAccum += self.mtype_oo_o
+                                    pairs.append({'gt':gtNum,'det':detNum,'type':'OO'})
+                                    evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + "\n"
+                                else:
+                                    evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(detNum) + " normDist: " + str(normDist) + " \n"
+                            else:
+                                evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(detNum) + " not single overlap\n"
+            # Find one-to-many matches
+            evaluationLog += "Find one-to-many matches\n"
+            for gtNum in range(len(gtRects)):
+                if gtNum not in gtDontCareRectsNum:
+                    match,matchesDet = one_to_many_match(gtNum)
+                    if match is True :
+                        evaluationLog += "num_overlaps_gt=" + str(num_overlaps_gt(gtNum))
+                        #in deteval we have to make other validation before mark as one-to-one
+                        if num_overlaps_gt(gtNum)>=2 :
+                            gtRectMat[gtNum] = 1
+                            recallAccum += (self.mtype_oo_o if len(matchesDet)==1 else self.mtype_om_o)
+                            precisionAccum += (self.mtype_oo_o if len(matchesDet)==1 else self.mtype_om_o*len(matchesDet))
+                            pairs.append({'gt':gtNum,'det':matchesDet,'type': 'OO' if len(matchesDet)==1 else 'OM'})
+                            for detNum in matchesDet :
+                                detRectMat[detNum] = 1
+                            evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(matchesDet) + "\n"
+                        else:
+                            evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(matchesDet) + " not single overlap\n"    
+
+            # Find many-to-one matches
+            evaluationLog += "Find many-to-one matches\n"
+            for detNum in range(len(detRects)):
+                if detNum not in detDontCareRectsNum:
+                    match,matchesGt = many_to_one_match(detNum)
+                    if match is True :
+                        #in deteval we have to make other validation before mark as one-to-one
+                        if num_overlaps_det(detNum)>=2 :                          
+                            detRectMat[detNum] = 1
+                            recallAccum += (self.mtype_oo_o if len(matchesGt)==1 else self.mtype_om_m*len(matchesGt))
+                            precisionAccum += (self.mtype_oo_o if len(matchesGt)==1 else self.mtype_om_m)
+                            pairs.append({'gt':matchesGt,'det':detNum,'type': 'OO' if len(matchesGt)==1 else 'MO'})
+                            for gtNum in matchesGt :
+                                gtRectMat[gtNum] = 1
+                            evaluationLog += "Match GT #" + str(matchesGt) + " with Det #" + str(detNum) + "\n"
+                        else:
+                            evaluationLog += "Match Discarded GT #" + str(matchesGt) + " with Det #" + str(detNum) + " not single overlap\n"                                    
+
+            numGtCare = (len(gtRects) - len(gtDontCareRectsNum))
+            if numGtCare == 0:
+                recall = float(1)
+                precision = float(0) if len(detRects)>0 else float(1)
+            else:
+                recall = float(recallAccum) / numGtCare
+                precision =  float(0) if (len(detRects) - len(detDontCareRectsNum))==0 else float(precisionAccum) / (len(detRects) - len(detDontCareRectsNum))
+            hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)  
+
+        numGtCare = len(gtRects) - len(gtDontCareRectsNum)
+        numDetCare = len(detRects) - len(detDontCareRectsNum)
+
+        perSampleMetrics = {
+            'precision':precision,
+            'recall':recall,
+            'hmean':hmean,
+            'pairs':pairs,
+            'recallMat':[] if len(detRects)>100 else recallMat.tolist(),
+            'precisionMat':[] if len(detRects)>100 else precisionMat.tolist(),
+            'gtPolPoints':gtPolPoints,
+            'detPolPoints':detPolPoints,
+            'gtCare': numGtCare,
+            'detCare': numDetCare,
+            'gtDontCare':gtDontCareRectsNum,
+            'detDontCare':detDontCareRectsNum,
+            'recallAccum':recallAccum,
+            'precisionAccum':precisionAccum,
+            'evaluationLog': evaluationLog
+        }
+
+        return perSampleMetrics
+
+    def combine_results(self, results):
+        numGt = 0
+        numDet = 0
+        methodRecallSum = 0
+        methodPrecisionSum = 0
+
+        for result in results:
+            numGt += result['gtCare']
+            numDet += result['detCare']
+            methodRecallSum += result['recallAccum']
+            methodPrecisionSum += result['precisionAccum']
+
+        methodRecall = 0 if numGt==0 else methodRecallSum/numGt
+        methodPrecision = 0 if numDet==0 else methodPrecisionSum/numDet
+        methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
+        
+        methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean  }
+
+        return methodMetrics
+
+
+if __name__=='__main__':
+    evaluator = DetectionDetEvalEvaluator()
+    gts = [[{
+        'points': [(0, 0), (1, 0), (1, 1), (0, 1)],
+        'text': 1234,
+        'ignore': False,
+    }, {
+        'points': [(2, 2), (3, 2), (3, 3), (2, 3)],
+        'text': 5678,
+        'ignore': True,
+    }]]
+    preds = [[{
+        'points': [(0.1, 0.1), (1, 0), (1, 1), (0, 1)],
+        'text': 123,
+        'ignore': False,
+    }]]
+    results = []
+    for gt, pred in zip(gts, preds):
+        results.append(evaluator.evaluate_image(gt, pred))
+    metrics = evaluator.combine_results(results)
+    print(metrics)

DB/concern/icdar2015_eval/detection/icdar2013.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import math
+from collections import namedtuple
+import numpy as np
+from shapely.geometry import Polygon
+
+
+class DetectionICDAR2013Evaluator(object):
+    def __init__(
+        self,
+        area_recall_constraint=0.8, area_precision_constraint=0.4,
+        ev_param_ind_center_diff_thr=1,
+        mtype_oo_o=1.0, mtype_om_o=0.8, mtype_om_m=1.0
+    ):
+
+
+        self.area_recall_constraint = area_recall_constraint
+        self.area_precision_constraint = area_precision_constraint
+        self.ev_param_ind_center_diff_thr = ev_param_ind_center_diff_thr
+        self.mtype_oo_o = mtype_oo_o
+        self.mtype_om_o = mtype_om_o
+        self.mtype_om_m = mtype_om_m
+
+    def evaluate_image(self, gt, pred):
+
+        def get_union(pD,pG):
+            return Polygon(pD).union(Polygon(pG)).area
+
+        def get_intersection_over_union(pD,pG):
+            return get_intersection(pD, pG) / get_union(pD, pG)
+
+        def get_intersection(pD,pG):
+            return Polygon(pD).intersection(Polygon(pG)).area
+
+        def one_to_one_match(row, col):
+            cont = 0
+            for j in range(len(recallMat[0])):    
+                if recallMat[row,j] >= self.area_recall_constraint and precisionMat[row,j] >= self.area_precision_constraint:
+                    cont = cont +1
+            if (cont != 1):
+                return False
+            cont = 0
+            for i in range(len(recallMat)):    
+                if recallMat[i,col] >= self.area_recall_constraint and precisionMat[i,col] >= self.area_precision_constraint:
+                    cont = cont +1
+            if (cont != 1):
+                return False
+            
+            if recallMat[row,col] >= self.area_recall_constraint and precisionMat[row,col] >= self.area_precision_constraint:
+                return True
+            return False
+        
+        def one_to_many_match(gtNum):
+            many_sum = 0
+            detRects = []
+            for detNum in range(len(recallMat[0])):    
+                if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and detNum not in detDontCareRectsNum:
+                    if precisionMat[gtNum,detNum] >= self.area_precision_constraint:
+                        many_sum += recallMat[gtNum,detNum]
+                        detRects.append(detNum)
+            if round(many_sum,4) >= self.area_recall_constraint:
+                return True,detRects
+            else:
+                return False,[]         
+        
+        def many_to_one_match(detNum):
+            many_sum = 0
+            gtRects = []
+            for gtNum in range(len(recallMat)):    
+                if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum:
+                    if recallMat[gtNum,detNum] >= self.area_recall_constraint:
+                        many_sum += precisionMat[gtNum,detNum]
+                        gtRects.append(gtNum)
+            if round(many_sum,4) >= self.area_precision_constraint:
+                return True,gtRects
+            else:
+                return False,[]
+        
+        def center_distance(r1, r2):
+            return ((np.mean(r1, axis=0) - np.mean(r2, axis=0)) ** 2).sum() ** 0.5
+        
+        def diag(r):
+            r = np.array(r)
+            return ((r[:, 0].max() - r[:, 0].min()) ** 2 + (r[:, 1].max() - r[:, 1].min()) ** 2) ** 0.5
+        
+        perSampleMetrics = {}
+        
+        recall = 0
+        precision = 0
+        hmean = 0        
+        recallAccum = 0.
+        precisionAccum = 0.
+        gtRects = []
+        detRects = []
+        gtPolPoints = []
+        detPolPoints = []
+        gtDontCareRectsNum = []#Array of Ground Truth Rectangles' keys marked as don't Care
+        detDontCareRectsNum = []#Array of Detected Rectangles' matched with a don't Care GT
+        pairs = []
+        evaluationLog = ""
+        
+        recallMat = np.empty([1,1])
+        precisionMat = np.empty([1,1])              
+        
+        for n in range(len(gt)):
+            points = gt[n]['points']
+            # transcription = gt[n]['text']
+            dontCare = gt[n]['ignore']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            gtRects.append(points)
+            gtPolPoints.append(points)
+            if dontCare:
+                gtDontCareRectsNum.append( len(gtRects)-1 )                 
+        
+        evaluationLog += "GT rectangles: " + str(len(gtRects)) + (" (" + str(len(gtDontCareRectsNum)) + " don't care)\n" if len(gtDontCareRectsNum)>0 else "\n")
+        
+        for n in range(len(pred)):
+            points = pred[n]['points']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            detRect = points
+            detRects.append(detRect)
+            detPolPoints.append(points)
+            if len(gtDontCareRectsNum)>0 :
+                for dontCareRectNum in gtDontCareRectsNum:
+                    dontCareRect = gtRects[dontCareRectNum]
+                    intersected_area = get_intersection(dontCareRect,detRect)
+                    rdDimensions = Polygon(detRect).area
+                    if (rdDimensions==0) :
+                        precision = 0
+                    else:
+                        precision= intersected_area / rdDimensions
+                    if (precision > self.area_precision_constraint):
+                        detDontCareRectsNum.append( len(detRects)-1 )
+                        break
+
+        evaluationLog += "DET rectangles: " + str(len(detRects)) + (" (" + str(len(detDontCareRectsNum)) + " don't care)\n" if len(detDontCareRectsNum)>0 else "\n")
+
+        if len(gtRects)==0:
+            recall = 1
+            precision = 0 if len(detRects)>0 else 1
+
+        if len(detRects)>0:
+            #Calculate recall and precision matrixs
+            outputShape=[len(gtRects),len(detRects)]
+            recallMat = np.empty(outputShape)
+            precisionMat = np.empty(outputShape)
+            gtRectMat = np.zeros(len(gtRects),np.int8)
+            detRectMat = np.zeros(len(detRects),np.int8)
+            for gtNum in range(len(gtRects)):
+                for detNum in range(len(detRects)):
+                    rG = gtRects[gtNum]
+                    rD = detRects[detNum]
+                    intersected_area = get_intersection(rG,rD)
+                    rgDimensions = Polygon(rG).area
+                    rdDimensions = Polygon(rD).area
+                    recallMat[gtNum,detNum] = 0 if rgDimensions==0 else  intersected_area / rgDimensions
+                    precisionMat[gtNum,detNum] = 0 if rdDimensions==0 else intersected_area / rdDimensions
+
+            # Find one-to-one matches
+            evaluationLog += "Find one-to-one matches\n"
+            for gtNum in range(len(gtRects)):
+                for detNum in range(len(detRects)):
+                    if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum and detNum not in detDontCareRectsNum :
+                        match = one_to_one_match(gtNum, detNum)
+                        if match is True :
+                            #in deteval we have to make other validation before mark as one-to-one
+                            rG = gtRects[gtNum]
+                            rD = detRects[detNum]
+                            normDist = center_distance(rG, rD);
+                            normDist /= diag(rG) + diag(rD);
+                            normDist *= 2.0;
+                            if normDist < self.ev_param_ind_center_diff_thr:
+                                gtRectMat[gtNum] = 1
+                                detRectMat[detNum] = 1
+                                recallAccum += self.mtype_oo_o
+                                precisionAccum += self.mtype_oo_o
+                                pairs.append({'gt':gtNum,'det':detNum,'type':'OO'})
+                                evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + "\n"
+                            else:
+                                evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(detNum) + " normDist: " + str(normDist) + " \n"
+            # Find one-to-many matches
+            evaluationLog += "Find one-to-many matches\n"
+            for gtNum in range(len(gtRects)):
+                if gtNum not in gtDontCareRectsNum:
+                    match,matchesDet = one_to_many_match(gtNum)
+                    if match is True :
+                        evaluationLog += "num_overlaps_gt=" + str(num_overlaps_gt(gtNum))
+                        gtRectMat[gtNum] = 1
+                        recallAccum += (self.mtype_oo_o if len(matchesDet)==1 else self.mtype_om_o)
+                        precisionAccum += (self.mtype_oo_o if len(matchesDet)==1 else self.mtype_om_o*len(matchesDet))
+                        pairs.append({'gt':gtNum,'det':matchesDet,'type': 'OO' if len(matchesDet)==1 else 'OM'})
+                        for detNum in matchesDet :
+                            detRectMat[detNum] = 1
+                        evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(matchesDet) + "\n"
+
+            # Find many-to-one matches
+            evaluationLog += "Find many-to-one matches\n"
+            for detNum in range(len(detRects)):
+                if detNum not in detDontCareRectsNum:
+                    match,matchesGt = many_to_one_match(detNum)
+                    if match is True :
+                        detRectMat[detNum] = 1
+                        recallAccum += (self.mtype_oo_o if len(matchesGt)==1 else self.mtype_om_m*len(matchesGt))
+                        precisionAccum += (self.mtype_oo_o if len(matchesGt)==1 else self.mtype_om_m)
+                        pairs.append({'gt':matchesGt,'det':detNum,'type': 'OO' if len(matchesGt)==1 else 'MO'})
+                        for gtNum in matchesGt :
+                            gtRectMat[gtNum] = 1
+                        evaluationLog += "Match GT #" + str(matchesGt) + " with Det #" + str(detNum) + "\n"
+
+            numGtCare = (len(gtRects) - len(gtDontCareRectsNum))
+            if numGtCare == 0:
+                recall = float(1)
+                precision = float(0) if len(detRects)>0 else float(1)
+            else:
+                recall = float(recallAccum) / numGtCare
+                precision =  float(0) if (len(detRects) - len(detDontCareRectsNum))==0 else float(precisionAccum) / (len(detRects) - len(detDontCareRectsNum))
+            hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)  
+
+        numGtCare = len(gtRects) - len(gtDontCareRectsNum)
+        numDetCare = len(detRects) - len(detDontCareRectsNum)
+
+        perSampleMetrics = {
+            'precision':precision,
+            'recall':recall,
+            'hmean':hmean,
+            'pairs':pairs,
+            'recallMat':[] if len(detRects)>100 else recallMat.tolist(),
+            'precisionMat':[] if len(detRects)>100 else precisionMat.tolist(),
+            'gtPolPoints':gtPolPoints,
+            'detPolPoints':detPolPoints,
+            'gtCare': numGtCare,
+            'detCare': numDetCare,
+            'gtDontCare':gtDontCareRectsNum,
+            'detDontCare':detDontCareRectsNum,
+            'recallAccum':recallAccum,
+            'precisionAccum':precisionAccum,
+            'evaluationLog': evaluationLog
+        }
+
+        return perSampleMetrics
+
+    def combine_results(self, results):
+        numGt = 0
+        numDet = 0
+        methodRecallSum = 0
+        methodPrecisionSum = 0
+
+        for result in results:
+            numGt += result['gtCare']
+            numDet += result['detCare']
+            methodRecallSum += result['recallAccum']
+            methodPrecisionSum += result['precisionAccum']
+
+        methodRecall = 0 if numGt==0 else methodRecallSum/numGt
+        methodPrecision = 0 if numDet==0 else methodPrecisionSum/numDet
+        methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
+        
+        methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean  }
+
+        return methodMetrics
+
+
+if __name__=='__main__':
+    evaluator = DetectionICDAR2013Evaluator()
+    gts = [[{
+        'points': [(0, 0), (1, 0), (1, 1), (0, 1)],
+        'text': 1234,
+        'ignore': False,
+    }, {
+        'points': [(2, 2), (3, 2), (3, 3), (2, 3)],
+        'text': 5678,
+        'ignore': True,
+    }]]
+    preds = [[{
+        'points': [(0.1, 0.1), (1, 0), (1, 1), (0, 1)],
+        'text': 123,
+        'ignore': False,
+    }]]
+    results = []
+    for gt, pred in zip(gts, preds):
+        results.append(evaluator.evaluate_image(gt, pred))
+    metrics = evaluator.combine_results(results)
+    print(metrics)

DB/concern/icdar2015_eval/detection/iou.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from collections import namedtuple
+import numpy as np
+from shapely.geometry import Polygon
+
+
+class DetectionIoUEvaluator(object):
+    def __init__(self, iou_constraint=0.5, area_precision_constraint=0.5):
+        self.iou_constraint = iou_constraint
+        self.area_precision_constraint = area_precision_constraint
+
+    def evaluate_image(self, gt, pred):
+
+        def get_union(pD, pG):
+            return Polygon(pD).union(Polygon(pG)).area
+
+        def get_intersection_over_union(pD, pG):
+            return get_intersection(pD, pG) / get_union(pD, pG)
+
+        def get_intersection(pD, pG):
+            return Polygon(pD).intersection(Polygon(pG)).area
+
+        def compute_ap(confList, matchList, numGtCare):
+            correct = 0
+            AP = 0
+            if len(confList) > 0:
+                confList = np.array(confList)
+                matchList = np.array(matchList)
+                sorted_ind = np.argsort(-confList)
+                confList = confList[sorted_ind]
+                matchList = matchList[sorted_ind]
+                for n in range(len(confList)):
+                    match = matchList[n]
+                    if match:
+                        correct += 1
+                        AP += float(correct)/(n + 1)
+
+                if numGtCare > 0:
+                    AP /= numGtCare
+
+            return AP
+
+        perSampleMetrics = {}
+
+        matchedSum = 0
+
+        Rectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')
+
+        numGlobalCareGt = 0
+        numGlobalCareDet = 0
+
+        arrGlobalConfidences = []
+        arrGlobalMatches = []
+
+        recall = 0
+        precision = 0
+        hmean = 0
+
+        detMatched = 0
+
+        iouMat = np.empty([1, 1])
+
+        gtPols = []
+        detPols = []
+
+        gtPolPoints = []
+        detPolPoints = []
+
+        # Array of Ground Truth Polygons' keys marked as don't Care
+        gtDontCarePolsNum = []
+        # Array of Detected Polygons' matched with a don't Care GT
+        detDontCarePolsNum = []
+
+        pairs = []
+        detMatchedNums = []
+
+        arrSampleConfidences = []
+        arrSampleMatch = []
+
+        evaluationLog = ""
+
+        for n in range(len(gt)):
+            points = gt[n]['points']
+            # transcription = gt[n]['text']
+            dontCare = gt[n]['ignore']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            gtPol = points
+            gtPols.append(gtPol)
+            gtPolPoints.append(points)
+            if dontCare:
+                gtDontCarePolsNum.append(len(gtPols)-1)
+
+        evaluationLog += "GT polygons: " + str(len(gtPols)) + (" (" + str(len(
+            gtDontCarePolsNum)) + " don't care)\n" if len(gtDontCarePolsNum) > 0 else "\n")
+
+        for n in range(len(pred)):
+            points = pred[n]['points']
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            detPol = points
+            detPols.append(detPol)
+            detPolPoints.append(points)
+            if len(gtDontCarePolsNum) > 0:
+                for dontCarePol in gtDontCarePolsNum:
+                    dontCarePol = gtPols[dontCarePol]
+                    intersected_area = get_intersection(dontCarePol, detPol)
+                    pdDimensions = Polygon(detPol).area
+                    precision = 0 if pdDimensions == 0 else intersected_area / pdDimensions
+                    if (precision > self.area_precision_constraint):
+                        detDontCarePolsNum.append(len(detPols)-1)
+                        break
+
+        evaluationLog += "DET polygons: " + str(len(detPols)) + (" (" + str(len(
+            detDontCarePolsNum)) + " don't care)\n" if len(detDontCarePolsNum) > 0 else "\n")
+
+        if len(gtPols) > 0 and len(detPols) > 0:
+            # Calculate IoU and precision matrixs
+            outputShape = [len(gtPols), len(detPols)]
+            iouMat = np.empty(outputShape)
+            gtRectMat = np.zeros(len(gtPols), np.int8)
+            detRectMat = np.zeros(len(detPols), np.int8)
+            for gtNum in range(len(gtPols)):
+                for detNum in range(len(detPols)):
+                    pG = gtPols[gtNum]
+                    pD = detPols[detNum]
+                    iouMat[gtNum, detNum] = get_intersection_over_union(pD, pG)
+
+            for gtNum in range(len(gtPols)):
+                for detNum in range(len(detPols)):
+                    if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCarePolsNum and detNum not in detDontCarePolsNum:
+                        if iouMat[gtNum, detNum] > self.iou_constraint:
+                            gtRectMat[gtNum] = 1
+                            detRectMat[detNum] = 1
+                            detMatched += 1
+                            pairs.append({'gt': gtNum, 'det': detNum})
+                            detMatchedNums.append(detNum)
+                            evaluationLog += "Match GT #" + \
+                                str(gtNum) + " with Det #" + str(detNum) + "\n"
+
+        numGtCare = (len(gtPols) - len(gtDontCarePolsNum))
+        numDetCare = (len(detPols) - len(detDontCarePolsNum))
+        if numGtCare == 0:
+            recall = float(1)
+            precision = float(0) if numDetCare > 0 else float(1)
+        else:
+            recall = float(detMatched) / numGtCare
+            precision = 0 if numDetCare == 0 else float(
+                detMatched) / numDetCare
+
+        hmean = 0 if (precision + recall) == 0 else 2.0 * \
+            precision * recall / (precision + recall)
+
+        matchedSum += detMatched
+        numGlobalCareGt += numGtCare
+        numGlobalCareDet += numDetCare
+
+        perSampleMetrics = {
+            'precision': precision,
+            'recall': recall,
+            'hmean': hmean,
+            'pairs': pairs,
+            'iouMat': [] if len(detPols) > 100 else iouMat.tolist(),
+            'gtPolPoints': gtPolPoints,
+            'detPolPoints': detPolPoints,
+            'gtCare': numGtCare,
+            'detCare': numDetCare,
+            'gtDontCare': gtDontCarePolsNum,
+            'detDontCare': detDontCarePolsNum,
+            'detMatched': detMatched,
+            'evaluationLog': evaluationLog
+        }
+
+        return perSampleMetrics
+
+    def combine_results(self, results):
+        numGlobalCareGt = 0
+        numGlobalCareDet = 0
+        matchedSum = 0
+        for result in results:
+            numGlobalCareGt += result['gtCare']
+            numGlobalCareDet += result['detCare']
+            matchedSum += result['detMatched']
+
+        methodRecall = 0 if numGlobalCareGt == 0 else float(
+            matchedSum)/numGlobalCareGt
+        methodPrecision = 0 if numGlobalCareDet == 0 else float(
+            matchedSum)/numGlobalCareDet
+        methodHmean = 0 if methodRecall + methodPrecision == 0 else 2 * \
+            methodRecall * methodPrecision / (methodRecall + methodPrecision)
+
+        methodMetrics = {'precision': methodPrecision,
+                         'recall': methodRecall, 'hmean': methodHmean}
+
+        return methodMetrics
+
+
+if __name__ == '__main__':
+    evaluator = DetectionIoUEvaluator()
+    gts = [[{
+        'points': [(0, 0), (1, 0), (1, 1), (0, 1)],
+        'text': 1234,
+        'ignore': False,
+    }, {
+        'points': [(2, 2), (3, 2), (3, 3), (2, 3)],
+        'text': 5678,
+        'ignore': False,
+    }]]
+    preds = [[{
+        'points': [(0.1, 0.1), (1, 0), (1, 1), (0, 1)],
+        'text': 123,
+        'ignore': False,
+    }]]
+    results = []
+    for gt, pred in zip(gts, preds):
+        results.append(evaluator.evaluate_image(gt, pred))
+    metrics = evaluator.combine_results(results)
+    print(metrics)

DB/concern/icdar2015_eval/detection/mtwi2018.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import math
+from collections import namedtuple
+import numpy as np
+from shapely.geometry import Polygon
+
+
+class DetectionMTWI2018Evaluator(object):
+    def __init__(
+        self,
+        area_recall_constraint=0.7, area_precision_constraint=0.7,
+        ev_param_ind_center_diff_thr=1,
+    ):
+
+
+        self.area_recall_constraint = area_recall_constraint
+        self.area_precision_constraint = area_precision_constraint
+        self.ev_param_ind_center_diff_thr = ev_param_ind_center_diff_thr
+
+    def evaluate_image(self, gt, pred):
+
+        def get_union(pD,pG):
+            return Polygon(pD).union(Polygon(pG)).area
+
+        def get_intersection_over_union(pD,pG):
+            return get_intersection(pD, pG) / get_union(pD, pG)
+
+        def get_intersection(pD,pG):
+            return Polygon(pD).intersection(Polygon(pG)).area
+
+        def one_to_one_match(row, col):
+            cont = 0
+            for j in range(len(recallMat[0])):    
+                if recallMat[row,j] >= self.area_recall_constraint and precisionMat[row,j] >= self.area_precision_constraint:
+                    cont = cont +1
+            if (cont != 1):
+                return False
+            cont = 0
+            for i in range(len(recallMat)):    
+                if recallMat[i,col] >= self.area_recall_constraint and precisionMat[i,col] >= self.area_precision_constraint:
+                    cont = cont +1
+            if (cont != 1):
+                return False
+            
+            if recallMat[row,col] >= self.area_recall_constraint and precisionMat[row,col] >= self.area_precision_constraint:
+                return True
+            return False
+        
+        def one_to_many_match(gtNum):
+            many_sum = 0
+            detRects = []
+            for detNum in range(len(recallMat[0])):    
+                if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and detNum not in detDontCareRectsNum:
+                    if precisionMat[gtNum,detNum] >= self.area_precision_constraint:
+                        many_sum += recallMat[gtNum,detNum]
+                        detRects.append(detNum)
+            if round(many_sum,4) >= self.area_recall_constraint:
+                return True,detRects
+            else:
+                return False,[]         
+        
+        def many_to_one_match(detNum):
+            many_sum = 0
+            gtRects = []
+            for gtNum in range(len(recallMat)):    
+                if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum:
+                    if recallMat[gtNum,detNum] >= self.area_recall_constraint:
+                        many_sum += precisionMat[gtNum,detNum]
+                        gtRects.append(gtNum)
+            if round(many_sum,4) >= self.area_precision_constraint:
+                return True,gtRects
+            else:
+                return False,[]
+        
+        def center_distance(r1, r2):
+            return ((np.mean(r1, axis=0) - np.mean(r2, axis=0)) ** 2).sum() ** 0.5
+        
+        def diag(r):
+            r = np.array(r)
+            return ((r[:, 0].max() - r[:, 0].min()) ** 2 + (r[:, 1].max() - r[:, 1].min()) ** 2) ** 0.5
+        
+        perSampleMetrics = {}
+        
+        recall = 0
+        precision = 0
+        hmean = 0        
+        recallAccum = 0.
+        precisionAccum = 0.
+        gtRects = []
+        detRects = []
+        gtPolPoints = []
+        detPolPoints = []
+        gtDontCareRectsNum = []#Array of Ground Truth Rectangles' keys marked as don't Care
+        detDontCareRectsNum = []#Array of Detected Rectangles' matched with a don't Care GT
+        pairs = []
+        evaluationLog = ""
+        
+        recallMat = np.empty([1,1])
+        precisionMat = np.empty([1,1])              
+        
+        for n in range(len(gt)):
+            points = gt[n]['points']
+            # transcription = gt[n]['text']
+            dontCare = gt[n]['ignore']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            gtRects.append(points)
+            gtPolPoints.append(points)
+            if dontCare:
+                gtDontCareRectsNum.append( len(gtRects)-1 )                 
+        
+        evaluationLog += "GT rectangles: " + str(len(gtRects)) + (" (" + str(len(gtDontCareRectsNum)) + " don't care)\n" if len(gtDontCareRectsNum)>0 else "\n")
+        
+        for n in range(len(pred)):
+            points = pred[n]['points']
+
+            if not Polygon(points).is_valid or not Polygon(points).is_simple:
+                continue
+
+            detRect = points
+            detRects.append(detRect)
+            detPolPoints.append(points)
+            if len(gtDontCareRectsNum)>0 :
+                for dontCareRectNum in gtDontCareRectsNum:
+                    dontCareRect = gtRects[dontCareRectNum]
+                    intersected_area = get_intersection(dontCareRect,detRect)
+                    rdDimensions = Polygon(detRect).area
+                    if (rdDimensions==0) :
+                        precision = 0
+                    else:
+                        precision= intersected_area / rdDimensions
+                    if (precision > 0.5):
+                        detDontCareRectsNum.append( len(detRects)-1 )
+                        break
+
+        evaluationLog += "DET rectangles: " + str(len(detRects)) + (" (" + str(len(detDontCareRectsNum)) + " don't care)\n" if len(detDontCareRectsNum)>0 else "\n")
+
+        if len(gtRects)==0:
+            recall = 1
+            precision = 0 if len(detRects)>0 else 1
+
+        if len(detRects)>0:
+            #Calculate recall and precision matrixs
+            outputShape=[len(gtRects),len(detRects)]
+            recallMat = np.empty(outputShape)
+            precisionMat = np.empty(outputShape)
+            gtRectMat = np.zeros(len(gtRects),np.int8)
+            detRectMat = np.zeros(len(detRects),np.int8)
+            for gtNum in range(len(gtRects)):
+                for detNum in range(len(detRects)):
+                    rG = gtRects[gtNum]
+                    rD = detRects[detNum]
+                    intersected_area = get_intersection(rG,rD)
+                    rgDimensions = Polygon(rG).area
+                    rdDimensions = Polygon(rD).area
+                    recallMat[gtNum,detNum] = 0 if rgDimensions==0 else  intersected_area / rgDimensions
+                    precisionMat[gtNum,detNum] = 0 if rdDimensions==0 else intersected_area / rdDimensions
+
+            # Find one-to-one matches
+            evaluationLog += "Find one-to-one matches\n"
+            for gtNum in range(len(gtRects)):
+                for detNum in range(len(detRects)):
+                    if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum and detNum not in detDontCareRectsNum :
+                        match = one_to_one_match(gtNum, detNum)
+                        if match is True :
+                            #in deteval we have to make other validation before mark as one-to-one
+                            rG = gtRects[gtNum]
+                            rD = detRects[detNum]
+                            normDist = center_distance(rG, rD);
+                            normDist /= diag(rG) + diag(rD);
+                            normDist *= 2.0;
+                            if normDist < self.ev_param_ind_center_diff_thr:
+                                gtRectMat[gtNum] = 1
+                                detRectMat[detNum] = 1
+                                recallAccum += 1.0
+                                precisionAccum += 1.0
+                                pairs.append({'gt':gtNum,'det':detNum,'type':'OO'})
+                                evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + "\n"
+                            else:
+                                evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(detNum) + " normDist: " + str(normDist) + " \n"
+            # Find one-to-many matches
+            evaluationLog += "Find one-to-many matches\n"
+            for gtNum in range(len(gtRects)):
+                if gtNum not in gtDontCareRectsNum:
+                    match,matchesDet = one_to_many_match(gtNum)
+                    if match is True :
+                        gtRectMat[gtNum] = 1
+                        recallAccum += 1.0
+                        precisionAccum += len(matchesDet) / (1 + math.log(len(matchesDet)))
+                        pairs.append({'gt':gtNum,'det':matchesDet,'type': 'OO' if len(matchesDet)==1 else 'OM'})
+                        for detNum in matchesDet :
+                            detRectMat[detNum] = 1
+                        evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(matchesDet) + "\n"
+
+            # Find many-to-one matches
+            evaluationLog += "Find many-to-one matches\n"
+            for detNum in range(len(detRects)):
+                if detNum not in detDontCareRectsNum:
+                    match,matchesGt = many_to_one_match(detNum)
+                    if match is True :
+                        detRectMat[detNum] = 1
+                        recallAccum += len(matchesGt) / (1 + math.log(len(matchesGt)))
+                        precisionAccum += 1.0
+                        pairs.append({'gt':matchesGt,'det':detNum,'type': 'OO' if len(matchesGt)==1 else 'MO'})
+                        for gtNum in matchesGt :
+                            gtRectMat[gtNum] = 1
+                        evaluationLog += "Match GT #" + str(matchesGt) + " with Det #" + str(detNum) + "\n"
+
+            numGtCare = (len(gtRects) - len(gtDontCareRectsNum))
+            if numGtCare == 0:
+                recall = float(1)
+                precision = float(0) if len(detRects)>0 else float(1)
+            else:
+                recall = float(recallAccum) / numGtCare
+                precision =  float(0) if (len(detRects) - len(detDontCareRectsNum))==0 else float(precisionAccum) / (len(detRects) - len(detDontCareRectsNum))
+            hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)  
+
+        numGtCare = len(gtRects) - len(gtDontCareRectsNum)
+        numDetCare = len(detRects) - len(detDontCareRectsNum)
+
+        perSampleMetrics = {
+            'precision':precision,
+            'recall':recall,
+            'hmean':hmean,
+            'pairs':pairs,
+            'recallMat':[] if len(detRects)>100 else recallMat.tolist(),
+            'precisionMat':[] if len(detRects)>100 else precisionMat.tolist(),
+            'gtPolPoints':gtPolPoints,
+            'detPolPoints':detPolPoints,
+            'gtCare': numGtCare,
+            'detCare': numDetCare,
+            'gtDontCare':gtDontCareRectsNum,
+            'detDontCare':detDontCareRectsNum,
+            'recallAccum':recallAccum,
+            'precisionAccum':precisionAccum,
+            'evaluationLog': evaluationLog
+        }
+
+        return perSampleMetrics
+
+    def combine_results(self, results):
+        numGt = 0
+        numDet = 0
+        methodRecallSum = 0
+        methodPrecisionSum = 0
+
+        for result in results:
+            numGt += result['gtCare']
+            numDet += result['detCare']
+            methodRecallSum += result['recallAccum']
+            methodPrecisionSum += result['precisionAccum']
+
+        methodRecall = 0 if numGt==0 else methodRecallSum/numGt
+        methodPrecision = 0 if numDet==0 else methodPrecisionSum/numDet
+        methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
+        
+        methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean  }
+
+        return methodMetrics
+
+
+if __name__=='__main__':
+    evaluator = DetectionICDAR2013Evaluator()
+    gts = [[{
+        'points': [(0, 0), (1, 0), (1, 1), (0, 1)],
+        'text': 1234,
+        'ignore': False,
+    }, {
+        'points': [(2, 2), (3, 2), (3, 3), (2, 3)],
+        'text': 5678,
+        'ignore': True,
+    }]]
+    preds = [[{
+        'points': [(0.1, 0.1), (1, 0), (1, 1), (0, 1)],
+        'text': 123,
+        'ignore': False,
+    }]]
+    results = []
+    for gt, pred in zip(gts, preds):
+        results.append(evaluator.evaluate_image(gt, pred))
+    metrics = evaluator.combine_results(results)
+    print(metrics)

DB/concern/log.py

@@ -0,0 +1,196 @@
+import os
+import logging
+import functools
+import json
+import time
+from datetime import datetime
+
+from tensorboardX import SummaryWriter
+import yaml
+import cv2
+import numpy as np
+
+from concern.config import Configurable, State
+
+
+class Logger(Configurable):
+    SUMMARY_DIR_NAME = 'summaries'
+    VISUALIZE_NAME = 'visualize'
+    LOG_FILE_NAME = 'output.log'
+    ARGS_FILE_NAME = 'args.log'
+    METRICS_FILE_NAME = 'metrics.log'
+
+    database_dir = State(default='./outputs/')
+    log_dir = State(default='workspace')
+    verbose = State(default=False)
+    level = State(default='info')
+    log_interval = State(default=100)
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+
+        self._make_storage()
+
+        cmd = kwargs['cmd']
+        self.name = cmd['name']
+        self.log_dir = os.path.join(self.log_dir, self.name)
+        try:
+            self.verbose = cmd['verbose']
+        except:
+            print('verbose:', self.verbose)
+        if self.verbose:
+            print('Initializing log dir for', self.log_dir)
+
+        if not os.path.exists(self.log_dir):
+            os.makedirs(self.log_dir)
+
+        self.message_logger = self._init_message_logger()
+
+        summary_path = os.path.join(self.log_dir, self.SUMMARY_DIR_NAME)
+        self.tf_board_logger = SummaryWriter(summary_path)
+
+        self.metrics_writer = open(os.path.join(
+            self.log_dir, self.METRICS_FILE_NAME), 'at')
+
+        self.timestamp = time.time()
+        self.logged = -1
+        self.speed = None
+        self.eta_time = None
+
+    def _make_storage(self):
+        application = os.path.basename(os.getcwd())
+        storage_dir = os.path.join(
+            self.database_dir, self.log_dir, application)
+        if not os.path.exists(storage_dir):
+            os.makedirs(storage_dir)
+        if not os.path.exists(self.log_dir):
+            os.symlink(storage_dir, self.log_dir)
+
+    def save_dir(self, dir_name):
+        return os.path.join(self.log_dir, dir_name)
+
+    def _init_message_logger(self):
+        message_logger = logging.getLogger('messages')
+        message_logger.setLevel(
+            logging.DEBUG if self.verbose else logging.INFO)
+        formatter = logging.Formatter(
+            '[%(levelname)s] [%(asctime)s] %(message)s')
+        std_handler = logging.StreamHandler()
+        std_handler.setLevel(message_logger.level)
+        std_handler.setFormatter(formatter)
+
+        file_handler = logging.FileHandler(
+            os.path.join(self.log_dir, self.LOG_FILE_NAME))
+        file_handler.setLevel(message_logger.level)
+        file_handler.setFormatter(formatter)
+
+        message_logger.addHandler(std_handler)
+        message_logger.addHandler(file_handler)
+        return message_logger
+
+    def report_time(self, name: str):
+        if self.verbose:
+            self.info(name + " time :" + str(time.time() - self.timestamp))
+            self.timestamp = time.time()
+
+    def report_eta(self, steps, total, epoch):
+        self.logged = self.logged % total + 1
+        steps = steps % total
+        if self.eta_time is None:
+            self.eta_time = time.time()
+            speed = -1
+        else:
+            eta_time = time.time()
+            speed = eta_time - self.eta_time
+            if self.speed is not None:
+                speed = ((self.logged - 1) * self.speed + speed) / self.logged
+            self.speed = speed
+            self.eta_time = eta_time
+
+        seconds = (total - steps) * speed
+        hours = seconds // 3600
+        minutes = (seconds - (hours * 3600)) // 60
+        seconds = seconds % 60
+
+        print('%d/%d batches processed in epoch %d, ETA: %2d:%2d:%2d' %
+              (steps, total, epoch,
+               hours, minutes, seconds), end='\r')
+
+    def args(self, parameters=None):
+        if parameters is None:
+            with open(os.path.join(self.log_dir, self.ARGS_FILE_NAME), 'rt') as reader:
+                return yaml.load(reader.read())
+        with open(os.path.join(self.log_dir, self.ARGS_FILE_NAME), 'wt') as writer:
+            yaml.dump(parameters.dump(), writer)
+
+    def metrics(self, epoch, steps, metrics_dict):
+        results = {}
+        for name, a in metrics_dict.items():
+            results[name] = {'count': a.count, 'value': float(a.avg)}
+            self.add_scalar('metrics/' + name, a.avg, steps)
+        result_dict = {
+            str(datetime.now()): {
+                'epoch': epoch,
+                'steps': steps,
+                **results
+            }
+        }
+        string_result = yaml.dump(result_dict)
+        self.info(string_result)
+        self.metrics_writer.write(string_result)
+        self.metrics_writer.flush()
+
+    def named_number(self, name, num=None, default=0):
+        if num is None:
+            return int(self.has_signal(name)) or default
+        else:
+            with open(os.path.join(self.log_dir, name), 'w') as writer:
+                writer.write(str(num))
+            return num
+
+    epoch = functools.partialmethod(named_number, 'epoch')
+    iter = functools.partialmethod(named_number, 'iter')
+
+    def message(self, level, content):
+        self.message_logger.__getattribute__(level)(content)
+
+    def images(self, prefix, image_dict, step):
+        for name, image in image_dict.items():
+            self.add_image(prefix + '/' + name, image, step, dataformats='HWC')
+
+    def merge_save_images(self, name, images):
+        for i, image in enumerate(images):
+            if i == 0:
+                result = image
+            else:
+                result = np.concatenate([result, image], 0)
+        cv2.imwrite(os.path.join(self.vis_dir(), name+'.jpg'), result)
+
+    def vis_dir(self):
+        vis_dir = os.path.join(self.log_dir, self.VISUALIZE_NAME)
+        if not os.path.exists(vis_dir):
+            os.mkdir(vis_dir)
+        return vis_dir
+
+    def save_image_dict(self, images, max_size=1024):
+        for file_name, image in images.items():
+            height, width = image.shape[:2]
+            if height > width:
+                actual_height = min(height, max_size)
+                actual_width = int(round(actual_height * width / height))
+            else:
+                actual_width = min(width, max_size)
+                actual_height = int(round(actual_width * height / width))
+                image = cv2.resize(image, (actual_width, actual_height))
+            cv2.imwrite(os.path.join(self.vis_dir(), file_name+'.jpg'), image)
+
+    def __getattr__(self, name):
+        message_levels = set(['debug', 'info', 'warning', 'error', 'critical'])
+        if name == '__setstate__':
+            raise AttributeError('haha')
+        if name in message_levels:
+            return functools.partial(self.message, name)
+        elif hasattr(self.__dict__.get('tf_board_logger'), name):
+            return self.tf_board_logger.__getattribute__(name)
+        else:
+            super()

DB/concern/signal_monitor.py

@@ -0,0 +1,17 @@
+import os
+
+
+class SignalMonitor(object):
+    def __init__(self, file_path):
+        self.file_path = file_path
+
+    def get_signal(self):
+        if self.file_path is None:
+            return None
+        if os.path.exists(self.file_path):
+            with open(self.file_path) as f:
+                data = self.file.read()
+                os.remove(f)
+                return data
+        else:
+            return None

DB/concern/visualizer.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File              : visualizer.py
+# Author            : Zhaoyi Wan <wanzhaoyi@megvii.com>
+# Date              : 08.01.2019
+# Last Modified Date: 02.12.2019
+# Last Modified By  : Minghui Liao 
+import torch
+import numpy as np
+import cv2
+
+class Visualize:
+    @classmethod
+    def visualize(cls, x):
+        dimension = len(x.shape)
+        if dimension == 2:
+            pass
+        elif dimension == 3:
+            pass
+
+    @classmethod
+    def to_np(cls, x):
+        return x.cpu().data.numpy()
+
+    @classmethod
+    def visualize_weights(cls, tensor, format='HW', normalize=True):
+        if isinstance(tensor, torch.Tensor):
+            x = cls.to_np(tensor.permute(format.index('H'), format.index('W')))
+        else:
+            x = tensor.transpose(format.index('H'), format.index('W'))
+        if normalize:
+            x = (x - x.min()) / (x.max() - x.min())
+        # return np.tile(x * 255., (3, 1, 1)).swapaxes(0, 2).swapaxes(1, 0).astype(np.uint8)
+        return cv2.applyColorMap((x * 255).astype(np.uint8), cv2.COLORMAP_JET)
+
+    @classmethod
+    def visualize_points(cls, image, tensor, radius=5, normalized=True):
+        if isinstance(tensor, torch.Tensor):
+            points = cls.to_np(tensor)
+        else:
+            points = tensor
+        if normalized:
+            points = points * image.shape[:2][::-1]
+        for i in range(points.shape[0]):
+            color = np.random.randint(
+                0, 255, (3, ), dtype=np.uint8).astype(np.float)
+            image = cv2.circle(image,
+                               tuple(points[i].astype(np.int32).tolist()),
+                               radius, color, thickness=radius//2)
+        return image
+
+    @classmethod
+    def visualize_heatmap(cls, tensor, format='CHW'):
+        if isinstance(tensor, torch.Tensor):
+            x = cls.to_np(tensor.permute(format.index('H'),
+                                         format.index('W'), format.index('C')))
+        else:
+            x = tensor.transpose(
+                format.index('H'), format.index('W'), format.index('C'))
+        canvas = np.zeros((x.shape[0], x.shape[1], 3), dtype=np.float)
+
+        for c in range(0, x.shape[-1]):
+            color = np.random.randint(
+                0, 255, (3, ), dtype=np.uint8).astype(np.float)
+            canvas += np.tile(x[:, :, c], (3, 1, 1)
+                              ).swapaxes(0, 2).swapaxes(1, 0) * color
+
+        canvas = canvas.astype(np.uint8)
+        return canvas
+
+    @classmethod
+    def visualize_classes(cls, x):
+        canvas = np.zeros((x.shape[0], x.shape[1], 3), dtype=np.uint8)
+        for c in range(int(x.max())):
+            color = np.random.randint(
+                0, 255, (3, ), dtype=np.uint8).astype(np.float)
+            canvas[np.where(x == c)] = color
+        return canvas
+
+    @classmethod
+    def visualize_grid(cls, x, y, stride=16, color=(0, 0, 255), canvas=None):
+        h, w = x.shape
+        if canvas is None:
+            canvas = np.zeros((h, w, 3), dtype=np.uint8)
+        # canvas = np.concatenate([canvas, canvas], axis=1)
+        i, j = 0, 0
+        while i < w:
+            j = 0
+            while j < h:
+                canvas = cv2.circle(canvas, (int(x[i, j] * w + 0.5), int(y[i, j] * h + 0.5)), radius=max(stride//4, 1), color=color, thickness=stride//8)
+                j += stride
+            i += stride
+        return canvas
+
+    @classmethod
+    def visualize_rect(cls, canvas, _rect, color=(0, 0, 255)):
+        rect = (_rect + 0.5).astype(np.int32)
+        return cv2.rectangle(canvas, (rect[0], rect[1]), (rect[2], rect[3]), color)

DB/concern/webcv2/__init__.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env mdl
+class WebCV2:
+    def __init__(self):
+        import cv2
+        self._cv2 = cv2
+        from .manager import global_manager as gm
+        self._gm = gm
+
+    def __getattr__(self, name):
+        if hasattr(self._gm, name):
+            return getattr(self._gm, name)
+        elif hasattr(self._cv2, name):
+            return getattr(self._cv2, name)
+        else:
+            raise AttributeError
+
+import sys
+sys.modules[__name__] = WebCV2()
+

DB/concern/webcv2/manager.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env mdl
+import socket
+import base64
+import cv2
+import numpy as np
+from collections import OrderedDict
+
+from .server import get_server
+
+
+def jpeg_encode(img):
+    return cv2.imencode('.png', img)[1]
+
+
+def get_free_port(rng, low=2000, high=10000):
+    in_use = True
+    while in_use:
+        port = rng.randint(high - low) + low
+        in_use = False
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            s.bind(("0.0.0.0", port))
+        except socket.error as e:
+            if e.errno == 98:  # port already in use
+                in_use = True
+        s.close()
+    return port
+
+
+class Manager:
+    def __init__(self, img_encode_method=jpeg_encode, rng=None):
+        self._queue = OrderedDict()
+        self._server = None
+        self.img_encode_method = img_encode_method
+        if rng is None:
+            rng = np.random.RandomState(self.get_default_seed())
+        self.rng = rng
+
+    def get_default_seed(self):
+        return 0
+
+    def imshow(self, title, img):
+        data = self.img_encode_method(img)
+        data = base64.b64encode(data)
+        data = data.decode('utf8')
+        self._queue[title] = data
+
+    def waitKey(self, delay=0):
+        if self._server is None:
+            self.port = get_free_port(self.rng)
+            self._server, self._conn = get_server(port=self.port)
+        self._conn.send([delay, list(self._queue.items())])
+        # self._queue = OrderedDict()
+        return self._conn.recv()
+
+global_manager = Manager()
+

DB/concern/webcv2/server.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env mdl
+import os
+BASE_DIR = os.path.dirname(os.path.realpath(__file__))
+import time
+import json
+import select
+import traceback
+import socket
+from multiprocessing import Process, Pipe
+
+import gevent
+from gevent.pywsgi import WSGIServer
+from geventwebsocket.handler import WebSocketHandler
+from flask import Flask, request, render_template, abort
+
+
+def log_important_msg(msg, *, padding=3):
+    msg_len = len(msg)
+    width = msg_len + padding * 2 + 2
+    print('#' * width)
+    print('#' + ' ' * (width - 2) + '#')
+    print('#' + ' ' * padding + msg + ' ' * padding + '#')
+    print('#' + ' ' * (width - 2) + '#')
+    print('#' * width)
+
+
+def hint_url(url, port):
+    log_important_msg(
+        'The server is running at: {}'.format(url))
+
+
+def _set_server(conn, name='webcv2', port=7788):
+    package = None
+    package_alive = False
+
+    app = Flask(name)
+    app.root_path = BASE_DIR
+
+    @app.route('/')
+    def index():
+        return render_template('index.html', title=name)
+
+    @app.route('/stream')
+    def stream():
+        def poll_ws(ws, delay):
+            return len(select.select([ws.stream.handler.rfile], [], [], delay / 1000.)[0]) > 0
+
+        if request.environ.get('wsgi.websocket'):
+            ws = request.environ['wsgi.websocket']
+            if ws is None:
+                abort(404)
+            else:
+                should_send = True
+                while not ws.closed:
+                    global package
+                    global package_alive
+                    if conn.poll():
+                        package = conn.recv()
+                        package_alive = True
+                        should_send = True
+                    if not should_send:
+                        continue
+                    should_send = False
+                    if package is None:
+                        ws.send(None)
+                    else:
+                        delay, info_lst = package
+                        ws.send(json.dumps((time.time(), package_alive, delay, info_lst)))
+                        if package_alive:
+                            if delay <= 0 or poll_ws(ws, delay):
+                                message = ws.receive()
+                                if ws.closed or message is None:
+                                    break
+                                try:
+                                    if isinstance(message, bytes):
+                                        message = message.decode('utf8')
+                                    message = int(message)
+                                except:
+                                    traceback.print_exc()
+                                    message = -1
+                            else:
+                                message = -1
+                            conn.send(message)
+                            package_alive = False
+        return ""
+
+    http_server = WSGIServer(('', port), app, handler_class=WebSocketHandler)
+    hint_url('http://{}:{}'.format(socket.getfqdn(), port), port)
+    http_server.serve_forever()
+
+
+def get_server(name='webcv2', port=7788):
+    conn_server, conn_factory = Pipe()
+    p_server = Process(
+        target=_set_server,
+        args=(conn_server,),
+        kwargs=dict(
+            name=name, port=port,
+        ),
+    )
+    p_server.daemon = True
+    p_server.start()
+    return p_server, conn_factory
+

DB/concern/webcv2/templates/index.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0, user-scalable=no"/>
+    <title>{{title}}</title>
+    <link rel="icon" href="//assets.megvii.com/static%2Ffavicon.ico?ver=1498037959257">
+    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
+    <script src="//cdnjs.cloudflare.com/ajax/libs/vue/2.2.6/vue.min.js"></script>
+</head>
+
+<body>
+    <script language="javascript" type="text/javascript">
+        var vm = null;
+        function isCharacterKeyPress(evt) {
+            if (typeof evt.which == "undefined") {
+                // This is IE, which only fires keypress events for printable keys
+                return true;
+            } else if (typeof evt.which == "number" && evt.which > 0) {
+                // In other browsers except old versions of WebKit, evt.which is
+                // only greater than zero if the keypress is a printable key.
+                // We need to filter out backspace and ctrl/alt/meta key combinations
+                return !evt.ctrlKey && !evt.metaKey && !evt.altKey && evt.which != 8;
+            }
+            return false;
+        };
+        $(function() {
+            vm = new Vue({
+                el: '#board',
+                data: {
+                    websocket: null,
+                    // resources
+                    delay: -1,
+                    data_alive: null,
+                    img_lst: null,
+                    // network
+                    package_size: 0,
+                    download_time: 0,
+                    net_speed: 0,
+                    // timer
+                    timer_interval: null,
+                    timer_step: 100,
+                },
+                created: function() {
+                    this.create_connection();
+                    document.addEventListener("keypress", this.send_key, false);
+                },
+                computed: {
+                    connection_alive: function() {
+                        return (this.websocket != null) &&
+                            !(this.websocket.readyState == this.websocket.CLOSING || this.websocket.readyState == this.websocket.CLOSED);
+                    },
+                },
+                methods: {
+                    get_ws_url: function(s) {
+                        var l = window.location;
+                        return ((l.protocol === "https:") ? "wss://" : "ws://") + l.hostname + (((l.port != 80) && (l.port != 443)) ? ":" + l.port : "") + l.pathname + s;
+                    },
+                    create_connection: function() {
+                        this.websocket = new WebSocket(this.get_ws_url("stream"));
+                        this.websocket.binaryType = "arraybuffer";
+                        this.websocket.onopen = function(evt) { console.log("connected"); };
+                        this.websocket.onclose = this.close_connection;
+                        this.websocket.onerror = function(evt) { console.log("error occurred"); console.log(evt); };
+                        this.websocket.onmessage = this.receive_message;
+                    },
+                    close_connection: function() {
+                        console.log("disconnected");
+                        this.websocket = null;
+                    },
+                    receive_message: function(evt) {
+                        var obj = JSON.parse(evt.data);
+                        var send_time = obj[0], recv_time = (new Date()).getTime() / 1000;
+                        this.package_size = evt.data.length * 8;
+                        this.download_time = recv_time - send_time;
+                        this.net_speed = this.package_size / this.download_time;
+                        console.log(obj);
+                        this.data_alive = obj[1];
+                        this.delay = obj[2];
+                        this.img_lst = obj[3];
+                        this.start_timer();
+                    },
+                    send_key: function(evt) {
+                        if (!this.connection_alive || !this.data_alive) return;
+                        if (!isCharacterKeyPress(evt)) return;
+                        this.delay = 0;
+                        this.data_alive = false;
+                        var keycode = evt.keyCode;
+                        console.log("key pressed " + keycode + " " + String.fromCharCode(keycode));
+                        this.websocket.send(keycode);
+                    },
+                    update_timer: function() {
+                        if (this.delay > 0) this.delay -= this.timer_step;
+                        if (this.delay <= 0) {
+                            this.data_alive = false;
+                            if (this.timer_interval != null) {
+                                clearInterval(this.timer_interval);
+                                this.timer_interval = null;
+                            }
+                        }
+                    },
+                    start_timer: function() {
+                        if (this.timer_interval != null) {
+                            clearInterval(this.timer_interval);
+                            this.timer_interval = null;
+                        }
+                        if (this.delay > 0) this.timer_interval = setInterval(this.update_timer, this.timer_step);
+                    },
+                },
+                filters: {
+                    decimal: function(num, fixed_point) {
+                        return num.toFixed(fixed_point);
+                    },
+                },
+            });
+        });
+    </script>
+
+    {% raw %}
+    <!-- Vue template -->
+    <div id="board">
+        <template v-if="connection_alive">
+            <template v-if="data_alive">
+                <p v-if="delay > 0">Press any key in {{delay / 1000 | decimal(1)}} seconds. </p>
+                <p v-else>Press any key to continue. </p>
+            </template>
+            <template v-else>
+                <p>Waiting for response from server. </p>
+            </template>
+        </template>
+        <template v-else>
+            <p>Disconnected from server. </p>
+        </template>
+        <p>Network: {{net_speed / 1000000 | decimal(2)}} MB/s * {{download_time | decimal(2)}} s = {{package_size / 1000000 | decimal(2)}} MB</p>
+        <div style="display:inline-block">
+            <div style="display:inline-block; vertical-align: top;" v-for="obj in img_lst">
+                <p>{{obj[0]}}</p>
+                <img :src="'data:image/png;base64,' + obj[1]" />
+            </div>
+        </div>
+    </div>
+    {% endraw %}
+
+</body>
+</html>

DB/convert_to_onnx.py

@@ -0,0 +1,78 @@
+import argparse
+import os
+import torch
+import numpy as np
+from concern.config import Configurable, Config
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert model to ONNX')
+    parser.add_argument('exp', type=str)
+    parser.add_argument('resume', type=str, help='Resume from checkpoint')
+    parser.add_argument('output', type=str, help='Output ONNX path')
+
+    args = parser.parse_args()
+    args = vars(args)
+    args = {k: v for k, v in args.items() if v is not None}
+
+    conf = Config()
+    experiment_args = conf.compile(conf.load(args['exp']))['Experiment']
+    experiment_args.update(cmd=args)
+    experiment = Configurable.construct_class_from_config(experiment_args)
+
+    Demo(experiment, experiment_args, cmd=args).inference()
+
+
+class Demo:
+    def __init__(self, experiment, args, cmd=dict()):
+        self.RGB_MEAN = np.array([122.67891434, 116.66876762, 104.00698793])
+        self.experiment = experiment
+        experiment.load('evaluation', **args)
+        self.args = cmd
+        self.structure = experiment.structure
+        self.model_path = self.args['resume']
+        self.output_path = self.args['output']
+
+    def init_torch_tensor(self):
+        # Use gpu or not
+        if torch.cuda.is_available():
+            self.device = torch.device('cuda')
+            torch.set_default_tensor_type('torch.cuda.FloatTensor')
+        else:
+            self.device = torch.device('cpu')
+            torch.set_default_tensor_type('torch.FloatTensor')
+
+    def init_model(self):
+        model = self.structure.builder.build(self.device)
+        return model
+
+    def resume(self, model, path):
+        if not os.path.exists(path):
+            print("Checkpoint not found: " + path)
+            return
+        states = torch.load(path, map_location=self.device)
+        model.load_state_dict(states, strict=False)
+        print("Resumed from " + path)
+
+    def inference(self):
+        self.init_torch_tensor()
+        model = self.init_model()
+        self.resume(model, self.model_path)
+        model.eval()
+
+        img = np.random.randint(0, 255, size=(960, 960, 3), dtype=np.uint8)
+        img = img.astype(np.float32)
+        img = (img / 255. - 0.5) / 0.5  # torch style norm
+        img = img.transpose((2, 0, 1))
+        img = torch.from_numpy(img).unsqueeze(0).float()
+        dynamic_axes = {'input': {0: 'batch_size', 2: 'height', 3: 'width'},
+                        'output': {0: 'batch_size', 2: 'height', 3: 'width'}}
+        with torch.no_grad():
+            img = img.to(self.device)
+            torch.onnx.export(model.model.module, img, self.output_path, input_names=['input'],
+                              output_names=['output'], dynamic_axes=dynamic_axes, keep_initializers_as_inputs=False,
+                              verbose=False, opset_version=12)
+
+
+if __name__ == '__main__':
+    main()

DB/data/__init__.py

@@ -0,0 +1,5 @@
+from .make_seg_detector_data import MakeSegDetectorData
+from .transform_data import TransformData
+from .random_crop_aug import RandomCropAug
+from .make_border_map import MakeBorderMap
+from .image_dataset import ImageDataset

DB/data/augmenter.py

@@ -0,0 +1,35 @@
+import imgaug
+import imgaug.augmenters as iaa
+
+from concern.config import Configurable, State
+
+
+class AugmenterBuilder(object):
+    def __init__(self):
+        pass
+
+    def build(self, args, root=True):
+        if args is None:
+            return None
+        elif isinstance(args, (int, float, str)):
+            return args
+        elif isinstance(args, list):
+            if root:
+                sequence = [self.build(value, root=False) for value in args]
+                return iaa.Sequential(sequence)
+            else:
+                return getattr(iaa, args[0])(
+                    *[self.to_tuple_if_list(a) for a in args[1:]])
+        elif isinstance(args, dict):
+            if 'cls' in args:
+                cls = getattr(iaa, args['cls'])
+                return cls(**{k: self.to_tuple_if_list(v) for k, v in args.items() if not k == 'cls'})
+            else:
+                return {key: self.build(value, root=False) for key, value in args.items()}
+        else:
+            raise RuntimeError('unknown augmenter arg: ' + str(args))
+
+    def to_tuple_if_list(self, obj):
+        if isinstance(obj, list):
+            return tuple(obj)
+        return obj

DB/data/data_loader.py

@@ -0,0 +1,250 @@
+import math
+import bisect
+
+import imgaug
+import numpy as np
+
+import torch
+import torch.distributed as dist
+from torch.utils.data import Sampler, ConcatDataset, BatchSampler
+
+from concern.config import Configurable, State
+
+
+def default_worker_init_fn(worker_id):
+    np.random.seed(worker_id)
+    imgaug.seed(worker_id)
+
+
+class DataLoader(Configurable, torch.utils.data.DataLoader):
+    dataset = State()
+    batch_size = State(default=256)
+    num_workers = State(default=10)
+    is_train = State(default=True)
+    collect_fn = State(default=None)
+    drop_last = State(default=True)
+    shuffle = State()
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+        if self.collect_fn is None:
+            self.collect_fn = torch.utils.data.dataloader.default_collate
+        cmd = kwargs.get('cmd', {})
+        self.is_train = cmd['is_train']
+        if 'batch_size' in cmd:
+            self.batch_size = cmd['batch_size']
+        if self.shuffle is None:
+            self.shuffle = self.is_train
+        self.num_workers = cmd.get('num_workers', self.num_workers)
+
+        if cmd.get('distributed'):
+            sampler = DistributedSampler(
+                self.dataset, shuffle=self.shuffle,
+                num_replicas=cmd['num_gpus'])
+            batch_sampler = BatchSampler(
+                sampler, self.batch_size//cmd['num_gpus'], False)
+            torch.utils.data.DataLoader.__init__(
+                self, self.dataset, batch_sampler=batch_sampler,
+                num_workers=self.num_workers, pin_memory=False,
+                drop_last=self.drop_last, collate_fn=self.collect_fn,
+                worker_init_fn=default_worker_init_fn)
+        else:
+            torch.utils.data.DataLoader.__init__(
+                self, self.dataset,
+                batch_size=self.batch_size, num_workers=self.num_workers,
+                drop_last=self.drop_last, shuffle=self.shuffle,
+                pin_memory=True, collate_fn=self.collect_fn,
+                worker_init_fn=default_worker_init_fn)
+        self.collect_fn = str(self.collect_fn)
+
+
+class SuccessiveRandomSampler(Sampler):
+    '''Random Sampler that yields sorted data in successive ranges.
+    Args:
+        dataset: Dataset used for sampling.
+    '''
+    def __init__(self, dataset):
+        self.dataset = dataset
+        self.epoch = 0
+
+    def __iter__(self):
+        if self.shuffle:
+            # deterministically shuffle based on epoch
+            g = torch.Generator()
+            g.manual_seed(self.epoch)
+            indices = torch.randperm(len(self.dataset)).tolist()
+        else:
+            indices = torch.arange(len(self.dataset)).tolist()
+
+        # add extra samples to make it evenly divisible
+        indices += indices[: (self.total_size - len(indices))]
+        assert len(indices) == self.total_size
+
+        # subsample
+        offset = self.num_samples * self.rank
+        indices = indices[offset: offset + self.num_samples]
+        assert len(indices) == self.num_samples
+
+        return iter(indices)
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def set_epoch(self, epoch):
+        self.epoch = epoch
+
+
+class DistributedSampler(Sampler):
+    """Sampler that restricts data loading to a subset of the dataset.
+    It is especially useful in conjunction with
+    :class:`torch.nn.parallel.DistributedDataParallel`. In such case, each
+    process can pass a DistributedSampler instance as a DataLoader sampler,
+    and load a subset of the original dataset that is exclusive to it.
+    .. note::
+        Dataset is assumed to be of constant size.
+    Arguments:
+        dataset: Dataset used for sampling.
+        num_replicas (optional): Number of processes participating in
+            distributed training.
+        rank (optional): Rank of the current process within num_replicas.
+    """
+
+    def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
+        if num_replicas is None:
+            if not dist.is_available():
+                raise RuntimeError(
+                    "Requires distributed package to be available")
+            num_replicas = dist.get_world_size()
+        if rank is None:
+            if not dist.is_available():
+                raise RuntimeError(
+                    "Requires distributed package to be available")
+            rank = dist.get_rank()
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.epoch = 0
+        self.num_samples = int(
+            math.ceil(len(self.dataset) * 1.0 / self.num_replicas))
+        self.total_size = self.num_samples * self.num_replicas
+        self.shuffle = shuffle
+
+    def __iter__(self):
+        if self.shuffle:
+            # deterministically shuffle based on epoch
+            g = torch.Generator()
+            g.manual_seed(self.epoch)
+            indices = torch.randperm(len(self.dataset)).tolist()
+        else:
+            indices = torch.arange(len(self.dataset)).tolist()
+
+        # add extra samples to make it evenly divisible
+        indices += indices[: (self.total_size - len(indices))]
+        assert len(indices) == self.total_size
+
+        # subsample
+        offset = self.num_samples * self.rank
+        indices = indices[offset: offset + self.num_samples]
+        assert len(indices) == self.num_samples
+
+        return iter(indices)
+
+    def __len__(self):
+        return self.num_samples
+
+    def set_epoch(self, epoch):
+        self.epoch = epoch
+
+
+class InfiniteOrderedSampler(Sampler):
+    def __init__(self, data_source, limit_size):
+        self.data_source = data_source
+        self.limit_size = limit_size
+
+    def __iter__(self):
+        n = len(self.data_source)
+
+        def wrapper():
+            cnt = 0
+            while cnt < self.limit_size:
+                if cnt % n == 0:
+                    idx = torch.randperm(n).tolist()
+                yield idx[cnt % n]
+                cnt += 1
+        return wrapper()
+
+    def __len__(self):
+        return self.limit_size
+
+
+class InfiniteDataLoader(Configurable, torch.utils.data.DataLoader):
+    dataset = State()
+    batch_size = State(default=256)
+    num_workers = State(default=10)
+    limit_size = State(default=2 ** 31)
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+
+        cmd = kwargs['cmd']
+        if 'batch_size' in cmd:
+            self.batch_size = cmd['batch_size']
+
+        sampler = InfiniteOrderedSampler(self.dataset, self.limit_size)
+
+        torch.utils.data.DataLoader.__init__(
+            self, self.dataset,
+            batch_size=self.batch_size, num_workers=self.num_workers,
+            sampler=sampler, worker_init_fn=default_worker_init_fn,
+        )
+
+
+class RandomSampleSampler(Sampler):
+    def __init__(self, data_source, weights=None, size=2 ** 31):
+        self.data_source = data_source
+        if weights is None:
+            self.probabilities = np.full(len(data_source), 1 / len(data_source))
+        else:
+            self.probabilities = np.array(weights) / np.sum(weights)
+        self.cum_prob = np.cumsum(self.probabilities)
+        self.size = size
+
+    def __iter__(self):
+        def wrapper():
+            for i in range(self.size):
+                yield bisect.bisect(self.cum_prob, torch.rand(1)[0], hi=len(self.data_source) - 1)
+        return wrapper()
+
+    def __len__(self):
+        return self.size
+
+
+class RandomSampleDataLoader(Configurable, torch.utils.data.DataLoader):
+    datasets = State()
+    weights = State()
+    batch_size = State(default=256)
+    num_workers = State(default=10)
+    size = State(default=2 ** 31)
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+
+        cmd = kwargs['cmd']
+        if 'batch_size' in cmd:
+            self.batch_size = cmd['batch_size']
+
+        probs = []
+        for dataset, weight in zip(self.datasets, self.weights):
+            probs.append(np.full(len(dataset), weight / len(dataset)))
+
+        dataset = ConcatDataset(self.datasets)
+        probs = np.concatenate(probs)
+        assert(len(dataset) == len(probs))
+
+        sampler = RandomSampleSampler(dataset, probs, self.size)
+
+        torch.utils.data.DataLoader.__init__(
+            self, dataset,
+            batch_size=self.batch_size, num_workers=self.num_workers,
+            sampler=sampler, worker_init_fn=default_worker_init_fn,
+        )

DB/data/dataset.py

@@ -0,0 +1,23 @@
+from torch.utils.data import Dataset as TorchDataset
+
+from concern.config import Configurable, State
+
+
+class SliceDataset(TorchDataset, Configurable):
+    dataset = State()
+    start = State()
+    end = State()
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+
+        if self.start is None:
+            self.start = 0
+        if self.end is None:
+            self.end = len(self.dataset)
+
+    def __getitem__(self, idx):
+        return self.dataset[self.start + idx]
+
+    def __len__(self):
+        return self.end - self.start

DB/data/image_dataset.py

@@ -0,0 +1,105 @@
+import functools
+import logging
+import bisect
+
+import torch.utils.data as data
+import cv2
+import numpy as np
+import glob
+from concern.config import Configurable, State
+import math
+
+class ImageDataset(data.Dataset, Configurable):
+    r'''Dataset reading from images.
+    Args:
+        Processes: A series of Callable object, which accept as parameter and return the data dict,
+            typically inherrited the `DataProcess`(data/processes/data_process.py) class.
+    '''
+    data_dir = State()
+    data_list = State()
+    processes = State(default=[])
+
+    def __init__(self, data_dir=None, data_list=None, cmd={}, **kwargs):
+        self.load_all(**kwargs)
+        self.data_dir = data_dir or self.data_dir
+        self.data_list = data_list or self.data_list
+        if 'train' in self.data_list[0]:
+            self.is_training = True
+        else:
+            self.is_training = False
+        self.debug = cmd.get('debug', False)
+        self.image_paths = []
+        self.gt_paths = []
+        self.get_all_samples()
+
+    def get_all_samples(self):
+        for i in range(len(self.data_dir)):
+            with open(self.data_list[i], 'r') as fid:
+                image_list = fid.readlines()
+            if self.is_training:
+                image_path=[self.data_dir[i]+'/train_images/'+timg.strip() for timg in image_list]
+                #gt_path=[self.data_dir[i]+'/train_gts/gt_'+timg.strip()+'.txt' for timg in image_list]
+                gt_path=[self.data_dir[i]+'/train_gts/gt_'+timg.strip().split('.')[0]+'.txt' for timg in image_list]
+            else:
+                image_path=[self.data_dir[i]+'/test_images/'+timg.strip() for timg in image_list]
+                #gt_path=[self.data_dir[i]+'/train_gts/gt_'+timg.strip()+'.txt' for timg in image_list]
+                gt_path=[self.data_dir[i]+'/test_gts/gt_'+timg.strip().split('.')[0]+'.txt' for timg in image_list]
+                # image_path=[self.data_dir[i]+'/test_images/gt_'+timg.strip() for timg in image_list]
+                # print(self.data_dir[i])
+                # if 'TD500' in self.data_list[i] or 'total_text' in self.data_list[i]:
+                #     #gt_path=[self.data_dir[i]+'/test_gts/'+timg.strip()+'.txt' for timg in image_list]
+                #     gt_path=[self.data_dir[i]+'/test_gts/'+timg.strip().split('.')[0]+'.gt' for timg in image_list]
+                # else:
+                #     gt_path=[self.data_dir[i]+'/test_gts/'+timg.strip().split('.')[0]+'.gt' for timg in image_list]
+            self.image_paths += image_path
+            self.gt_paths += gt_path
+        self.num_samples = len(self.image_paths)
+        self.targets = self.load_ann()
+        if self.is_training:
+            assert len(self.image_paths) == len(self.targets)
+
+    def load_ann(self):
+        res = []
+        for gt in self.gt_paths:
+            lines = []
+            reader = open(gt, 'r').readlines()
+            for line in reader:
+                item = {}
+                parts = line.strip().split(',')
+                label = parts[-1]
+                if 'TD' in self.data_dir[0] and label == '1':
+                    label = '###'
+                line = [i.strip('\ufeff').strip('\xef\xbb\xbf') for i in parts]
+                if 'icdar' in self.data_dir[0]:
+                    poly = np.array(list(map(float, line[:8]))).reshape((-1, 2)).tolist()
+                else:
+                    num_points = math.floor((len(line) - 1) / 2) * 2
+                    poly = np.array(list(map(float, line[:num_points]))).reshape((-1, 2)).tolist()
+                item['poly'] = poly
+                item['text'] = label
+                lines.append(item)
+            res.append(lines)
+        return res
+
+    def __getitem__(self, index, retry=0):
+        if index >= self.num_samples:
+            index = index % self.num_samples
+        data = {}
+        image_path = self.image_paths[index]
+        img = cv2.imread(image_path, cv2.IMREAD_COLOR).astype('float32')
+        if self.is_training:
+            data['filename'] = image_path
+            data['data_id'] = image_path
+        else:
+            data['filename'] = image_path.split('/')[-1]
+            data['data_id'] = image_path.split('/')[-1]
+        data['image'] = img
+        target = self.targets[index]
+        data['lines'] = target
+        if self.processes is not None:
+            for data_process in self.processes:
+                data = data_process(data)
+        return data
+
+    def __len__(self):
+        return len(self.image_paths)

DB/data/make_border_map.py

@@ -0,0 +1,121 @@
+import warnings
+import numpy as np
+import cv2
+from shapely.geometry import Polygon
+import pyclipper
+
+from concern.config import Configurable, State
+
+
+class MakeBorderMap(Configurable):
+    shrink_ratio = State(default=0.4)
+    thresh_min = State(default=0.3)
+    thresh_max = State(default=0.7)
+
+    def __init__(self, cmd={}, *args, **kwargs):
+        self.load_all(cmd=cmd, **kwargs)
+        warnings.simplefilter("ignore")
+
+
+    def __call__(self, data, *args, **kwargs):
+        image = data['image']
+        polygons = data['polygons']
+        ignore_tags = data['ignore_tags']
+
+        canvas = np.zeros(image.shape[:2], dtype=np.float32)
+        mask = np.zeros(image.shape[:2], dtype=np.float32)
+
+        for i in range(len(polygons)):
+            if ignore_tags[i]:
+                continue
+            self.draw_border_map(polygons[i], canvas, mask=mask)
+        canvas = canvas * (self.thresh_max - self.thresh_min) + self.thresh_min
+        data['thresh_map'] = canvas
+        data['thresh_mask'] = mask
+        return data
+
+    def draw_border_map(self, polygon, canvas, mask):
+        polygon = np.array(polygon)
+        assert polygon.ndim == 2
+        assert polygon.shape[1] == 2
+
+        polygon_shape = Polygon(polygon)
+        distance = polygon_shape.area * \
+            (1 - np.power(self.shrink_ratio, 2)) / polygon_shape.length
+        subject = [tuple(l) for l in polygon]
+        padding = pyclipper.PyclipperOffset()
+        padding.AddPath(subject, pyclipper.JT_ROUND,
+                        pyclipper.ET_CLOSEDPOLYGON)
+        padded_polygon = np.array(padding.Execute(distance)[0])
+        cv2.fillPoly(mask, [padded_polygon.astype(np.int32)], 1.0)
+
+        xmin = padded_polygon[:, 0].min()
+        xmax = padded_polygon[:, 0].max()
+        ymin = padded_polygon[:, 1].min()
+        ymax = padded_polygon[:, 1].max()
+        width = xmax - xmin + 1
+        height = ymax - ymin + 1
+
+        polygon[:, 0] = polygon[:, 0] - xmin
+        polygon[:, 1] = polygon[:, 1] - ymin
+
+        xs = np.broadcast_to(
+            np.linspace(0, width - 1, num=width).reshape(1, width), (height, width))
+        ys = np.broadcast_to(
+            np.linspace(0, height - 1, num=height).reshape(height, 1), (height, width))
+
+        distance_map = np.zeros(
+            (polygon.shape[0], height, width), dtype=np.float32)
+        for i in range(polygon.shape[0]):
+            j = (i + 1) % polygon.shape[0]
+            absolute_distance = self.distance(xs, ys, polygon[i], polygon[j])
+            distance_map[i] = np.clip(absolute_distance / distance, 0, 1)
+        distance_map = distance_map.min(axis=0)
+
+        xmin_valid = min(max(0, xmin), canvas.shape[1] - 1)
+        xmax_valid = min(max(0, xmax), canvas.shape[1] - 1)
+        ymin_valid = min(max(0, ymin), canvas.shape[0] - 1)
+        ymax_valid = min(max(0, ymax), canvas.shape[0] - 1)
+        canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1] = np.fmax(
+            1 - distance_map[
+                ymin_valid-ymin:ymax_valid-ymax+height,
+                xmin_valid-xmin:xmax_valid-xmax+width],
+            canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1])
+
+    def distance(self, xs, ys, point_1, point_2):
+        '''
+        compute the distance from point to a line
+        ys: coordinates in the first axis
+        xs: coordinates in the second axis
+        point_1, point_2: (x, y), the end of the line
+        '''
+        height, width = xs.shape[:2]
+        square_distance_1 = np.square(
+            xs - point_1[0]) + np.square(ys - point_1[1])
+        square_distance_2 = np.square(
+            xs - point_2[0]) + np.square(ys - point_2[1])
+        square_distance = np.square(
+            point_1[0] - point_2[0]) + np.square(point_1[1] - point_2[1])
+
+        cosin = (square_distance - square_distance_1 - square_distance_2) / \
+            (2 * np.sqrt(square_distance_1 * square_distance_2))
+        square_sin = 1 - np.square(cosin)
+        square_sin = np.nan_to_num(square_sin)
+        result = np.sqrt(square_distance_1 * square_distance_2 *
+                         square_sin / square_distance)
+
+        result[cosin < 0] = np.sqrt(np.fmin(
+            square_distance_1, square_distance_2))[cosin < 0]
+        # self.extend_line(point_1, point_2, result)
+        return result
+
+    def extend_line(self, point_1, point_2, result):
+        ex_point_1 = (int(round(point_1[0] + (point_1[0] - point_2[0]) * (1 + self.shrink_ratio))),
+                      int(round(point_1[1] + (point_1[1] - point_2[1]) * (1 + self.shrink_ratio))))
+        cv2.line(result, tuple(ex_point_1), tuple(point_1),
+                 4096.0, 1, lineType=cv2.LINE_AA, shift=0)
+        ex_point_2 = (int(round(point_2[0] + (point_2[0] - point_1[0]) * (1 + self.shrink_ratio))),
+                      int(round(point_2[1] + (point_2[1] - point_1[1]) * (1 + self.shrink_ratio))))
+        cv2.line(result, tuple(ex_point_2), tuple(point_2),
+                 4096.0, 1, lineType=cv2.LINE_AA, shift=0)
+        return ex_point_1, ex_point_2

DB/data/make_seg_detector_data.py

@@ -0,0 +1,96 @@
+from collections import OrderedDict
+
+import numpy as np
+import cv2
+from shapely.geometry import Polygon
+import pyclipper
+
+from concern.config import Configurable, State
+
+
+class MakeSegDetectorData(Configurable):
+    min_text_size = State(default=8)
+    shrink_ratio = State(default=0.4)
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+
+    def __call__(self, data, *args, **kwargs):
+        '''
+        data: a dict typically returned from `MakeICDARData`,
+            where the following keys are contrains:
+                image*, polygons*, ignore_tags*, shape, filename
+                * means required.
+        '''
+        image = data['image']
+        polygons = data['polygons']
+        ignore_tags = data['ignore_tags']
+        image = data['image']
+        filename = data['filename']
+
+        h, w = image.shape[:2]
+        polygons, ignore_tags = self.validate_polygons(
+            polygons, ignore_tags, h, w)
+        gt = np.zeros((1, h, w), dtype=np.float32)
+        mask = np.ones((h, w), dtype=np.float32)
+        for i in range(polygons.shape[0]):
+            polygon = polygons[i]
+            height = min(np.linalg.norm(polygon[0] - polygon[3]),
+                         np.linalg.norm(polygon[1] - polygon[2]))
+            width = min(np.linalg.norm(polygon[0] - polygon[1]),
+                        np.linalg.norm(polygon[2] - polygon[3]))
+            if ignore_tags[i] or min(height, width) < self.min_text_size:
+                cv2.fillPoly(mask, polygon.astype(
+                    np.int32)[np.newaxis, :, :], 0)
+                ignore_tags[i] = True
+            else:
+                polygon_shape = Polygon(polygon)
+                distance = polygon_shape.area * \
+                    (1 - np.power(self.shrink_ratio, 2)) / polygon_shape.length
+                subject = [tuple(l) for l in polygons[i]]
+                padding = pyclipper.PyclipperOffset()
+                padding.AddPath(subject, pyclipper.JT_ROUND,
+                                pyclipper.ET_CLOSEDPOLYGON)
+                shrinked = padding.Execute(-distance)
+                if shrinked == []:
+                    cv2.fillPoly(mask, polygon.astype(
+                        np.int32)[np.newaxis, :, :], 0)
+                    ignore_tags[i] = True
+                    continue
+                shrinked = np.array(shrinked[0]).reshape(-1, 2)
+                cv2.fillPoly(gt[0], [shrinked.astype(np.int32)], 1)
+
+        if filename is None:
+            filename = ''
+        data.update(image=image,
+                    polygons=polygons,
+                    gt=gt, mask=mask, filename=filename)
+        return data
+
+    def validate_polygons(self, polygons, ignore_tags, h, w):
+        '''
+        polygons (numpy.array, required): of shape (num_instances, num_points, 2)
+        '''
+        if polygons.shape[0] == 0:
+            return polygons, ignore_tags
+        assert polygons.shape[0] == len(ignore_tags)
+
+        polygons[:, :, 0] = np.clip(polygons[:, :, 0], 0, w - 1)
+        polygons[:, :, 1] = np.clip(polygons[:, :, 1], 0, h - 1)
+
+        for i in range(polygons.shape[0]):
+            area = self.polygon_area(polygons[i])
+            if abs(area) < 1:
+                ignore_tags[i] = True
+            if area > 0:
+                polygons[i] = polygons[i][(0, 3, 2, 1), :]
+        return polygons, ignore_tags
+
+    def polygon_area(self, polygon):
+        edge = [
+            (polygon[1][0] - polygon[0][0]) * (polygon[1][1] + polygon[0][1]),
+            (polygon[2][0] - polygon[1][0]) * (polygon[2][1] + polygon[1][1]),
+            (polygon[3][0] - polygon[2][0]) * (polygon[3][1] + polygon[2][1]),
+            (polygon[0][0] - polygon[3][0]) * (polygon[0][1] + polygon[3][1])
+        ]
+        return np.sum(edge) / 2.

DB/data/meta_loader.py

@@ -0,0 +1,92 @@
+import pickle
+import hashlib
+import os
+import io
+import urllib.parse as urlparse
+import warnings
+import numpy as np
+from concern.charset_tool import stringQ2B
+from hanziconv import HanziConv
+from concern.config import Configurable, State
+from data.text_lines import TextLines
+
+class DataIdMetaLoader(MetaLoader):
+    return_dict = State(default=False)
+    scan_meta = False
+
+    def __init__(self, return_dict=None, cmd={}, **kwargs):
+        super().__init__(cmd=cmd, **kwargs)
+        if return_dict is not None:
+            self.return_dict = return_dict
+
+    def parse_meta(self, data_id):
+        return dict(data_id=data_id)
+
+    def post_prosess(self, meta):
+        if self.return_dict:
+            return meta
+        return meta['data_id']
+
+class MetaCache(Configurable):
+    META_FILE = 'meta_cache.pickle'
+    client = State(default='all')
+
+    def __init__(self, **kwargs):
+        self.load_all(**kwargs)
+
+    def cache(self, nori_path, meta=None):
+        if meta is None:
+            return self.read(nori_path)
+        else:
+            return self.save(nori_path, meta)
+
+    def read(self, nori_path):
+        raise NotImplementedError
+
+    def save(self, nori_path, meta):
+        raise NotImplementedError
+
+
+class FileMetaCache(MetaCache):
+    storage_dir = State(default='/data/.meta_cache')
+
+    def __init__(self, storage_dir=None, cmd={}, **kwargs):
+        super(FileMetaCache, self).__init__(cmd=cmd, **kwargs)
+
+        self.storage_dir = cmd.get('storage_dir', self.storage_dir)
+        if storage_dir is not None:
+            self.storage_dir = storage_dir
+        self.debug = cmd.get('debug', False)
+
+    def ensure_dir(self):
+        if not os.path.exists(self.storage_dir):
+            os.makedirs(self.storage_dir)
+
+    def storate_path(self, nori_path):
+        return os.path.join(self.storage_dir, self.hash(nori_path) + '.pickle')
+
+    def hash(self, nori_path: str):
+        return hashlib.md5(nori_path.encode('utf-8')).hexdigest() + '-' + self.client
+
+    def read(self, nori_path):
+        file_path = self.storate_path(nori_path)
+        if not os.path.exists(file_path):
+            warnings.warn(
+                'Meta cache not found: ' + file_path)
+            warnings.warn('Now trying to read meta from nori')
+            return None
+        with open(file_path, 'rb') as reader:
+            try:
+                return pickle.load(reader)
+            except EOFError as e:  # recover from broken file
+                if self.debug:
+                    raise e
+                return None
+
+    def save(self, nori_path, meta):
+        self.ensure_dir()
+
+        with open(self.storate_path(nori_path), 'wb') as writer:
+            pickle.dump(meta, writer)
+        return True
+        

DB/data/processes/__init__.py

@@ -0,0 +1,10 @@
+from .normalize_image import NormalizeImage
+from .make_center_points import MakeCenterPoints
+from .resize_image import ResizeImage, ResizeData
+from .filter_keys import FilterKeys
+from .make_center_map import MakeCenterMap
+from .augment_data import AugmentData, AugmentDetectionData
+from .random_crop_data import RandomCropData
+from .make_icdar_data import MakeICDARData, ICDARCollectFN
+from .make_seg_detection_data import MakeSegDetectionData
+from .make_border_map import MakeBorderMap

DB/data/processes/augment_data.py

@@ -0,0 +1,82 @@
+import imgaug
+import numpy as np
+
+from concern.config import State
+from .data_process import DataProcess
+from data.augmenter import AugmenterBuilder
+import cv2
+import math
+
+
+class AugmentData(DataProcess):
+    augmenter_args = State(autoload=False)
+
+    def __init__(self, **kwargs):
+        self.augmenter_args = kwargs.get('augmenter_args')
+        self.keep_ratio = kwargs.get('keep_ratio')
+        self.only_resize = kwargs.get('only_resize')
+        self.augmenter = AugmenterBuilder().build(self.augmenter_args)
+
+    def may_augment_annotation(self, aug, data):
+        pass
+
+    def resize_image(self, image):
+        origin_height, origin_width, _ = image.shape
+        resize_shape = self.augmenter_args[0][1]
+        height = resize_shape['height']
+        width = resize_shape['width']
+        if self.keep_ratio:
+            width = origin_width * height / origin_height
+            N = math.ceil(width / 32)
+            width = N * 32
+        image = cv2.resize(image, (width, height))
+        return image
+
+    def process(self, data):
+        image = data['image']
+        aug = None
+        shape = image.shape
+
+        if self.augmenter:
+            aug = self.augmenter.to_deterministic()
+            if self.only_resize:
+                data['image'] = self.resize_image(image)
+            else:
+                data['image'] = aug.augment_image(image)
+            self.may_augment_annotation(aug, data, shape)
+
+        filename = data.get('filename', data.get('data_id', ''))
+        data.update(filename=filename, shape=shape[:2])
+        if not self.only_resize:
+            data['is_training'] = True 
+        else:
+            data['is_training'] = False 
+        return data
+
+
+class AugmentDetectionData(AugmentData):
+    def may_augment_annotation(self, aug, data, shape):
+        if aug is None:
+            return data
+
+        line_polys = []
+        for line in data['lines']:
+            if self.only_resize:
+                new_poly = [(p[0], p[1]) for p in line['poly']]
+            else:
+                new_poly = self.may_augment_poly(aug, shape, line['poly'])
+            line_polys.append({
+                'points': new_poly,
+                'ignore': line['text'] == '###',
+                'text': line['text'],
+            })
+        data['polys'] = line_polys
+        return data
+
+    def may_augment_poly(self, aug, img_shape, poly):
+        keypoints = [imgaug.Keypoint(p[0], p[1]) for p in poly]
+        keypoints = aug.augment_keypoints(
+            [imgaug.KeypointsOnImage(keypoints, shape=img_shape)])[0].keypoints
+        poly = [(p.x, p.y) for p in keypoints]
+        return poly
+

DB/data/processes/data_process.py

@@ -0,0 +1,25 @@
+from concern.config import Configurable
+
+
+class DataProcess(Configurable):
+    r'''Processes of data dict.
+    '''
+
+    def __call__(self, data):
+        return self.process(data)
+
+    def process(self, data):
+        raise NotImplementedError
+
+    def render_constant(self, canvas, xmin, xmax, ymin, ymax, value=1, shrink=0):
+        def shrink_rect(xmin, xmax, ratio):
+            center = (xmin + xmax) / 2
+            width = center - xmin
+            return int(center - width * ratio + 0.5), int(center + width * ratio + 0.5)
+
+        if shrink > 0:
+            xmin, xmax = shrink_rect(xmin, xmax, shrink)
+            ymin, ymax = shrink_rect(ymin, ymax, shrink)
+
+        canvas[int(ymin+0.5):int(ymax+0.5)+1, int(xmin+0.5):int(xmax+0.5)+1] = value
+        return canvas