upload PaddleOCR code

ppocr/data/__init__.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

ppocr/data/det/data_augment.py

+# -*- coding:utf-8 -*- 
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import random
+import cv2
+import math
+
+import imgaug
+import imgaug.augmenters as iaa
+
+
+def AugmentData(data):
+    img = data['image']
+    shape = img.shape
+
+    aug = iaa.Sequential(
+        [iaa.Fliplr(0.5), iaa.Affine(rotate=(-10, 10)), iaa.Resize(
+            (0.5, 3))]).to_deterministic()
+
+    def may_augment_annotation(aug, data, shape):
+        if aug is None:
+            return data
+
+        line_polys = []
+        for poly in data['polys']:
+            new_poly = may_augment_poly(aug, shape, poly)
+            line_polys.append(new_poly)
+        data['polys'] = np.array(line_polys)
+        return data
+
+    def may_augment_poly(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
+
+    img_aug = aug.augment_image(img)
+    data['image'] = img_aug
+    data = may_augment_annotation(aug, data, shape)
+    return data

ppocr/data/det/dataset_traversal.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+import os
+import math
+import random
+import functools
+import numpy as np
+import cv2
+import string
+from ppocr.utils.utility import initial_logger
+logger = initial_logger()
+from ppocr.utils.utility import create_module
+import time
+
+
+class TrainReader(object):
+    def __init__(self, params):
+        self.num_workers = params['num_workers']
+        self.label_file_path = params['label_file_path']
+        self.batch_size = params['train_batch_size_per_card']
+        assert 'process_function' in params,\
+            "absence process_function in Reader"
+        self.process = create_module(params['process_function'])(params)
+
+    def __call__(self, process_id):
+        def sample_iter_reader():
+            with open(self.label_file_path, "rb") as fin:
+                label_infor_list = fin.readlines()
+            img_num = len(label_infor_list)
+            img_id_list = list(range(img_num))
+            random.shuffle(img_id_list)
+            for img_id in range(process_id, img_num, self.num_workers):
+                label_infor = label_infor_list[img_id_list[img_id]]
+                outs = self.process(label_infor)
+                if outs is None:
+                    continue
+                yield outs
+
+        def batch_iter_reader():
+            batch_outs = []
+            for outs in sample_iter_reader():
+                batch_outs.append(outs)
+                if len(batch_outs) == self.batch_size:
+                    yield batch_outs
+                    batch_outs = []
+            if len(batch_outs) != 0:
+                yield batch_outs
+
+        return batch_iter_reader
+
+
+class EvalTestReader(object):
+    def __init__(self, params):
+        self.params = params
+        assert 'process_function' in params,\
+            "absence process_function in EvalTestReader"
+
+    def __call__(self, mode):
+        process_function = create_module(self.params['process_function'])(
+            self.params)
+        batch_size = self.params['test_batch_size_per_card']
+
+        flag_test_single_img = False
+        if mode == "test":
+            single_img_path = self.params['single_img_path']
+            if single_img_path is not None:
+                flag_test_single_img = True
+
+        img_list = []
+        if flag_test_single_img:
+            img_list.append([single_img_path, single_img_path])
+        else:
+            img_set_dir = self.params['img_set_dir']
+            img_name_list_path = self.params['label_file_path']
+            with open(img_name_list_path, "rb") as fin:
+                lines = fin.readlines()
+                for line in lines:
+                    img_name = line.decode().strip("\n").split("\t")[0]
+                    img_path = img_set_dir + "/" + img_name
+                    img_list.append([img_path, img_name])
+
+        def batch_iter_reader():
+            batch_outs = []
+            for img_path, img_name in img_list:
+                img = cv2.imread(img_path)
+                if img is None:
+                    logger.info("load image error:" + img_path)
+                    continue
+                outs = process_function(img)
+                outs.append(img_name)
+                batch_outs.append(outs)
+                if len(batch_outs) == batch_size:
+                    yield batch_outs
+                    batch_outs = []
+            if len(batch_outs) != 0:
+                yield batch_outs
+
+        return batch_iter_reader

ppocr/data/det/db_process.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+import math
+import cv2
+import numpy as np
+import json
+import sys
+
+from .data_augment import AugmentData
+from .random_crop_data import RandomCropData
+from .make_shrink_map import MakeShrinkMap
+from .make_border_map import MakeBorderMap
+
+
+class DBProcessTrain(object):
+    def __init__(self, params):
+        self.img_set_dir = params['img_set_dir']
+        self.image_shape = params['image_shape']
+
+    def order_points_clockwise(self, pts):
+        rect = np.zeros((4, 2), dtype="float32")
+        s = pts.sum(axis=1)
+        rect[0] = pts[np.argmin(s)]
+        rect[2] = pts[np.argmax(s)]
+        diff = np.diff(pts, axis=1)
+        rect[1] = pts[np.argmin(diff)]
+        rect[3] = pts[np.argmax(diff)]
+        return rect
+
+    def make_data_dict(self, imgvalue, entry):
+        boxes = []
+        texts = []
+        ignores = []
+        for rect in entry:
+            points = rect['points']
+            transcription = rect['transcription']
+            try:
+                box = self.order_points_clockwise(
+                    np.array(points).reshape(-1, 2))
+                if cv2.contourArea(box) > 0:
+                    boxes.append(box)
+                    texts.append(transcription)
+                    ignores.append(transcription in ['*', '###'])
+            except:
+                print('load label failed!')
+        data = {
+            'image': imgvalue,
+            'shape': [imgvalue.shape[0], imgvalue.shape[1]],
+            'polys': np.array(boxes),
+            'texts': texts,
+            'ignore_tags': ignores,
+        }
+        return data
+
+    def NormalizeImage(self, data):
+        im = data['image']
+        img_mean = [0.485, 0.456, 0.406]
+        img_std = [0.229, 0.224, 0.225]
+        im = im.astype(np.float32, copy=False)
+        im = im / 255
+        im -= img_mean
+        im /= img_std
+        channel_swap = (2, 0, 1)
+        im = im.transpose(channel_swap)
+        data['image'] = im
+        return data
+
+    def FilterKeys(self, data):
+        filter_keys = ['polys', 'texts', 'ignore_tags', 'shape']
+        for key in filter_keys:
+            if key in data:
+                del data[key]
+        return data
+
+    def convert_label_infor(self, label_infor):
+        label_infor = label_infor.decode()
+        label_infor = label_infor.encode('utf-8').decode('utf-8-sig')
+        substr = label_infor.strip("\n").split("\t")
+        img_path = self.img_set_dir + substr[0]
+        label = json.loads(substr[1])
+        return img_path, label
+
+    def __call__(self, label_infor):
+        img_path, gt_label = self.convert_label_infor(label_infor)
+        imgvalue = cv2.imread(img_path)
+        if imgvalue is None:
+            return None
+        data = self.make_data_dict(imgvalue, gt_label)
+        data = AugmentData(data)
+        data = RandomCropData(data, self.image_shape[1:])
+        data = MakeShrinkMap(data)
+        data = MakeBorderMap(data)
+        data = self.NormalizeImage(data)
+        data = self.FilterKeys(data)
+        return data['image'], data['shrink_map'], data['shrink_mask'], data[
+            'threshold_map'], data['threshold_mask']
+
+
+class DBProcessTest(object):
+    def __init__(self, params):
+        super(DBProcessTest, self).__init__()
+        self.resize_type = 0
+        if 'det_image_shape' in params:
+            self.image_shape = params['det_image_shape']
+            # print(self.image_shape)
+            self.resize_type = 1
+        if 'max_side_len' in params:
+            self.max_side_len = params['max_side_len']
+        else:
+            self.max_side_len = 2400
+
+    def resize_image_type0(self, im):
+        """
+        resize image to a size multiple of 32 which is required by the network
+        :param im: the resized image
+        :param max_side_len: limit of max image size to avoid out of memory in gpu
+        :return: the resized image and the resize ratio
+        """
+        max_side_len = self.max_side_len
+        h, w, _ = im.shape
+
+        resize_w = w
+        resize_h = h
+
+        # limit the max side
+        if max(resize_h, resize_w) > max_side_len:
+            if resize_h > resize_w:
+                ratio = float(max_side_len) / resize_h
+            else:
+                ratio = float(max_side_len) / resize_w
+        else:
+            ratio = 1.
+        resize_h = int(resize_h * ratio)
+        resize_w = int(resize_w * ratio)
+        if resize_h % 32 == 0:
+            resize_h = resize_h
+        else:
+            resize_h = (resize_h // 32 + 1) * 32
+        if resize_w % 32 == 0:
+            resize_w = resize_w
+        else:
+            resize_w = (resize_w // 32 + 1) * 32
+        try:
+            if int(resize_w) <= 0 or int(resize_h) <= 0:
+                return None, (None, None)
+            im = cv2.resize(im, (int(resize_w), int(resize_h)))
+        except:
+            print(im.shape, resize_w, resize_h)
+            sys.exit(0)
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+        return im, (ratio_h, ratio_w)
+
+    def resize_image_type1(self, im):
+        resize_h, resize_w = self.image_shape
+        ori_h, ori_w = im.shape[:2]  # (h, w, c)
+        im = cv2.resize(im, (int(resize_w), int(resize_h)))
+        ratio_h = float(resize_h) / ori_h
+        ratio_w = float(resize_w) / ori_w
+        return im, (ratio_h, ratio_w)
+
+    def normalize(self, im):
+        img_mean = [0.485, 0.456, 0.406]
+        img_std = [0.229, 0.224, 0.225]
+        im = im.astype(np.float32, copy=False)
+        im = im / 255
+        im -= img_mean
+        im /= img_std
+        channel_swap = (2, 0, 1)
+        im = im.transpose(channel_swap)
+        return im
+
+    def __call__(self, im):
+        if self.resize_type == 0:
+            im, (ratio_h, ratio_w) = self.resize_image_type0(im)
+        else:
+            im, (ratio_h, ratio_w) = self.resize_image_type1(im)
+        im = self.normalize(im)
+        im = im[np.newaxis, :]
+        return [im, (ratio_h, ratio_w)]

ppocr/data/det/make_border_map.py

+# -*- coding:utf-8 -*- 
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import cv2
+np.seterr(divide='ignore', invalid='ignore')
+import pyclipper
+from shapely.geometry import Polygon
+import sys
+import warnings
+warnings.simplefilter("ignore")
+
+
+def draw_border_map(polygon, canvas, mask, shrink_ratio):
+    polygon = np.array(polygon)
+    assert polygon.ndim == 2
+    assert polygon.shape[1] == 2
+
+    polygon_shape = Polygon(polygon)
+    if polygon_shape.area <= 0:
+        return
+    distance = polygon_shape.area * (
+        1 - np.power(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 = _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(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(point_1, point_2, result, shrink_ratio):
+    ex_point_1 = (
+        int(
+            round(point_1[0] + (point_1[0] - point_2[0]) * (1 + shrink_ratio))),
+        int(
+            round(point_1[1] + (point_1[1] - point_2[1]) * (1 + 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 + shrink_ratio))),
+        int(
+            round(point_2[1] + (point_2[1] - point_1[1]) * (1 + 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
+
+
+def MakeBorderMap(data):
+    shrink_ratio = 0.4
+    thresh_min = 0.3
+    thresh_max = 0.7
+
+    im = data['image']
+    text_polys = data['polys']
+    ignore_tags = data['ignore_tags']
+
+    canvas = np.zeros(im.shape[:2], dtype=np.float32)
+    mask = np.zeros(im.shape[:2], dtype=np.float32)
+
+    for i in range(len(text_polys)):
+        if ignore_tags[i]:
+            continue
+        draw_border_map(
+            text_polys[i], canvas, mask=mask, shrink_ratio=shrink_ratio)
+    canvas = canvas * (thresh_max - thresh_min) + thresh_min
+
+    data['threshold_map'] = canvas
+    data['threshold_mask'] = mask
+    return data

ppocr/data/det/make_shrink_map.py

+# -*- coding:utf-8 -*- 
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import cv2
+from shapely.geometry import Polygon
+import pyclipper
+
+
+def validate_polygons(polygons, ignore_tags, h, w):
+    '''
+    polygons (numpy.array, required): of shape (num_instances, num_points, 2)
+    '''
+    if len(polygons) == 0:
+        return polygons, ignore_tags
+    assert len(polygons) == len(ignore_tags)
+    for polygon in polygons:
+        polygon[:, 0] = np.clip(polygon[:, 0], 0, w - 1)
+        polygon[:, 1] = np.clip(polygon[:, 1], 0, h - 1)
+
+    for i in range(len(polygons)):
+        area = polygon_area(polygons[i])
+        if abs(area) < 1:
+            ignore_tags[i] = True
+        if area > 0:
+            polygons[i] = polygons[i][::-1, :]
+    return polygons, ignore_tags
+
+
+def polygon_area(polygon):
+    edge = 0
+    for i in range(polygon.shape[0]):
+        next_index = (i + 1) % polygon.shape[0]
+        edge += (polygon[next_index, 0] - polygon[i, 0]) * (
+            polygon[next_index, 1] - polygon[i, 1])
+
+    return edge / 2.
+
+
+def MakeShrinkMap(data):
+    min_text_size = 8
+    shrink_ratio = 0.4
+
+    image = data['image']
+    text_polys = data['polys']
+    ignore_tags = data['ignore_tags']
+
+    h, w = image.shape[:2]
+    text_polys, ignore_tags = validate_polygons(text_polys, ignore_tags, h, w)
+    gt = np.zeros((h, w), dtype=np.float32)
+    # gt = np.zeros((1, h, w), dtype=np.float32)
+    mask = np.ones((h, w), dtype=np.float32)
+    for i in range(len(text_polys)):
+        polygon = text_polys[i]
+        height = max(polygon[:, 1]) - min(polygon[:, 1])
+        width = max(polygon[:, 0]) - min(polygon[:, 0])
+        # 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) < 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(shrink_ratio, 2)) / polygon_shape.length
+            subject = [tuple(l) for l in text_polys[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, [shrinked.astype(np.int32)], 1)
+            # cv2.fillPoly(gt[0], [shrinked.astype(np.int32)], 1)
+
+    data['shrink_map'] = gt
+    data['shrink_mask'] = mask
+    return data

ppocr/data/det/random_crop_data.py

+# -*- coding:utf-8 -*- 
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import cv2
+import random
+
+
+def is_poly_in_rect(poly, x, y, w, h):
+    poly = np.array(poly)
+    if poly[:, 0].min() < x or poly[:, 0].max() > x + w:
+        return False
+    if poly[:, 1].min() < y or poly[:, 1].max() > y + h:
+        return False
+    return True
+
+
+def is_poly_outside_rect(poly, x, y, w, h):
+    poly = np.array(poly)
+    if poly[:, 0].max() < x or poly[:, 0].min() > x + w:
+        return True
+    if poly[:, 1].max() < y or poly[:, 1].min() > y + h:
+        return True
+    return False
+
+
+def split_regions(axis):
+    regions = []
+    min_axis = 0
+    for i in range(1, axis.shape[0]):
+        if axis[i] != axis[i - 1] + 1:
+            region = axis[min_axis:i]
+            min_axis = i
+            regions.append(region)
+    return regions
+
+
+def random_select(axis, max_size):
+    xx = np.random.choice(axis, size=2)
+    xmin = np.min(xx)
+    xmax = np.max(xx)
+    xmin = np.clip(xmin, 0, max_size - 1)
+    xmax = np.clip(xmax, 0, max_size - 1)
+    return xmin, xmax
+
+
+def region_wise_random_select(regions, max_size):
+    selected_index = list(np.random.choice(len(regions), 2))
+    selected_values = []
+    for index in selected_index:
+        axis = regions[index]
+        xx = int(np.random.choice(axis, size=1))
+        selected_values.append(xx)
+    xmin = min(selected_values)
+    xmax = max(selected_values)
+    return xmin, xmax
+
+
+def crop_area(im, text_polys, min_crop_side_ratio, max_tries):
+    h, w, _ = im.shape
+    h_array = np.zeros(h, dtype=np.int32)
+    w_array = np.zeros(w, dtype=np.int32)
+    for points in text_polys:
+        points = np.round(points, decimals=0).astype(np.int32)
+        minx = np.min(points[:, 0])
+        maxx = np.max(points[:, 0])
+        w_array[minx:maxx] = 1
+        miny = np.min(points[:, 1])
+        maxy = np.max(points[:, 1])
+        h_array[miny:maxy] = 1
+    # ensure the cropped area not across a text
+    h_axis = np.where(h_array == 0)[0]
+    w_axis = np.where(w_array == 0)[0]
+
+    if len(h_axis) == 0 or len(w_axis) == 0:
+        return 0, 0, w, h
+
+    h_regions = split_regions(h_axis)
+    w_regions = split_regions(w_axis)
+
+    for i in range(max_tries):
+        if len(w_regions) > 1:
+            xmin, xmax = region_wise_random_select(w_regions, w)
+        else:
+            xmin, xmax = random_select(w_axis, w)
+        if len(h_regions) > 1:
+            ymin, ymax = region_wise_random_select(h_regions, h)
+        else:
+            ymin, ymax = random_select(h_axis, h)
+
+        if xmax - xmin < min_crop_side_ratio * w or ymax - ymin < min_crop_side_ratio * h:
+            # area too small
+            continue
+        num_poly_in_rect = 0
+        for poly in text_polys:
+            if not is_poly_outside_rect(poly, xmin, ymin, xmax - xmin,
+                                        ymax - ymin):
+                num_poly_in_rect += 1
+                break
+
+        if num_poly_in_rect > 0:
+            return xmin, ymin, xmax - xmin, ymax - ymin
+
+    return 0, 0, w, h
+
+
+def RandomCropData(data, size):
+    max_tries = 10
+    min_crop_side_ratio = 0.1
+    require_original_image = False
+    keep_ratio = True
+
+    im = data['image']
+    text_polys = data['polys']
+    ignore_tags = data['ignore_tags']
+    texts = data['texts']
+    all_care_polys = [
+        text_polys[i] for i, tag in enumerate(ignore_tags) if not tag
+    ]
+    # 计算crop区域
+    crop_x, crop_y, crop_w, crop_h = crop_area(im, all_care_polys,
+                                               min_crop_side_ratio, max_tries)
+    # crop 图片 保持比例填充
+    scale_w = size[0] / crop_w
+    scale_h = size[1] / crop_h
+    scale = min(scale_w, scale_h)
+    h = int(crop_h * scale)
+    w = int(crop_w * scale)
+    if keep_ratio:
+        padimg = np.zeros((size[1], size[0], im.shape[2]), im.dtype)
+        padimg[:h, :w] = cv2.resize(
+            im[crop_y:crop_y + crop_h, crop_x:crop_x + crop_w], (w, h))
+        img = padimg
+    else:
+        img = cv2.resize(im[crop_y:crop_y + crop_h, crop_x:crop_x + crop_w],
+                         tuple(size))
+    # crop 文本框
+    text_polys_crop = []
+    ignore_tags_crop = []
+    texts_crop = []
+    for poly, text, tag in zip(text_polys, texts, ignore_tags):
+        poly = ((poly - (crop_x, crop_y)) * scale).tolist()
+        if not is_poly_outside_rect(poly, 0, 0, w, h):
+            text_polys_crop.append(poly)
+            ignore_tags_crop.append(tag)
+            texts_crop.append(text)
+    data['image'] = img
+    data['polys'] = np.array(text_polys_crop)
+    data['ignore_tags'] = ignore_tags_crop
+    data['texts'] = texts_crop
+    return data

ppocr/data/reader_main.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+import os
+import random
+import numpy as np
+
+import paddle
+from ppocr.utils.utility import create_module
+from copy import deepcopy
+
+from .rec.img_tools import process_image
+import cv2
+
+import sys
+import signal
+
+
+# handle terminate reader process, do not print stack frame
+def _reader_quit(signum, frame):
+    print("Reader process exit.")
+    sys.exit()
+
+
+def _term_group(sig_num, frame):
+    print('pid {} terminated, terminate group '
+          '{}...'.format(os.getpid(), os.getpgrp()))
+    os.killpg(os.getpgid(os.getpid()), signal.SIGKILL)
+
+
+signal.signal(signal.SIGTERM, _reader_quit)
+signal.signal(signal.SIGINT, _term_group)
+
+
+def reader_main(config=None, mode=None):
+    """Create a reader for trainning
+
+    Args:
+        settings: arguments
+
+    Returns:
+        train reader
+    """
+    assert mode in ["train", "eval", "test"],\
+        "Nonsupport mode:{}".format(mode)
+    global_params = config['Global']
+    if mode == "train":
+        params = deepcopy(config['TrainReader'])
+    elif mode == "eval":
+        params = deepcopy(config['EvalReader'])
+    else:
+        params = deepcopy(config['TestReader'])
+    params['mode'] = mode
+    params.update(global_params)
+    reader_function = params['reader_function']
+    function = create_module(reader_function)(params)
+    if mode == "train":
+        readers = []
+        num_workers = params['num_workers']
+        for process_id in range(num_workers):
+            readers.append(function(process_id))
+        return paddle.reader.multiprocess_reader(readers, False)
+    else:
+        return function(mode)
+
+
+def test_reader(image_shape, img_path):
+    img = cv2.imread(img_path)
+    norm_img = process_image(img, image_shape)
+    return norm_img

ppocr/data/rec/__init__.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

ppocr/data/rec/dataset_traversal.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+import os
+import math
+import random
+import numpy as np
+import cv2
+
+import string
+import lmdb
+
+from ppocr.utils.utility import initial_logger
+logger = initial_logger()
+
+from .img_tools import process_image, get_img_data
+
+
+class LMDBReader(object):
+    def __init__(self, params):
+        if params['mode'] != 'train':
+            self.num_workers = 1
+        else:
+            self.num_workers = params['num_workers']
+        self.lmdb_sets_dir = params['lmdb_sets_dir']
+        self.char_ops = params['char_ops']
+        self.image_shape = params['image_shape']
+        self.loss_type = params['loss_type']
+        self.max_text_length = params['max_text_length']
+        self.mode = params['mode']
+        if params['mode'] == 'train':
+            self.batch_size = params['train_batch_size_per_card']
+        else:
+            self.batch_size = params['test_batch_size_per_card']
+
+    def load_hierarchical_lmdb_dataset(self):
+        lmdb_sets = {}
+        dataset_idx = 0
+        for dirpath, dirnames, filenames in os.walk(self.lmdb_sets_dir + '/'):
+            if not dirnames:
+                env = lmdb.open(
+                    dirpath,
+                    max_readers=32,
+                    readonly=True,
+                    lock=False,
+                    readahead=False,
+                    meminit=False)
+                txn = env.begin(write=False)
+                num_samples = int(txn.get('num-samples'.encode()))
+                lmdb_sets[dataset_idx] = {"dirpath":dirpath, "env":env, \
+                    "txn":txn, "num_samples":num_samples}
+                dataset_idx += 1
+        return lmdb_sets
+
+    def print_lmdb_sets_info(self, lmdb_sets):
+        lmdb_info_strs = []
+        for dataset_idx in range(len(lmdb_sets)):
+            tmp_str = " %s:%d," % (lmdb_sets[dataset_idx]['dirpath'],
+                                   lmdb_sets[dataset_idx]['num_samples'])
+            lmdb_info_strs.append(tmp_str)
+        lmdb_info_strs = ''.join(lmdb_info_strs)
+        logger.info("DataSummary:" + lmdb_info_strs)
+        return
+
+    def close_lmdb_dataset(self, lmdb_sets):
+        for dataset_idx in lmdb_sets:
+            lmdb_sets[dataset_idx]['env'].close()
+        return
+
+    def get_lmdb_sample_info(self, txn, index):
+        label_key = 'label-%09d'.encode() % index
+        label = txn.get(label_key)
+        if label is None:
+            return None
+        label = label.decode('utf-8')
+        img_key = 'image-%09d'.encode() % index
+        imgbuf = txn.get(img_key)
+        img = get_img_data(imgbuf)
+        if img is None:
+            return None
+        return img, label
+
+    def __call__(self, process_id):
+        if self.mode != 'train':
+            process_id = 0
+
+        def sample_iter_reader():
+            lmdb_sets = self.load_hierarchical_lmdb_dataset()
+            if process_id == 0:
+                self.print_lmdb_sets_info(lmdb_sets)
+            cur_index_sets = [1 + process_id] * len(lmdb_sets)
+            while True:
+                finish_read_num = 0
+                for dataset_idx in range(len(lmdb_sets)):
+                    cur_index = cur_index_sets[dataset_idx]
+                    if cur_index > lmdb_sets[dataset_idx]['num_samples']:
+                        finish_read_num += 1
+                    else:
+                        sample_info = self.get_lmdb_sample_info(
+                            lmdb_sets[dataset_idx]['txn'], cur_index)
+                        cur_index_sets[dataset_idx] += self.num_workers
+                        if sample_info is None:
+                            continue
+                        img, label = sample_info
+                        outs = process_image(img, self.image_shape, label,
+                                             self.char_ops, self.loss_type,
+                                             self.max_text_length)
+                        if outs is None:
+                            continue
+                        yield outs
+
+                if finish_read_num == len(lmdb_sets):
+                    break
+            self.close_lmdb_dataset(lmdb_sets)
+
+        def batch_iter_reader():
+            batch_outs = []
+            for outs in sample_iter_reader():
+                batch_outs.append(outs)
+                if len(batch_outs) == self.batch_size:
+                    yield batch_outs
+                    batch_outs = []
+            if len(batch_outs) != 0:
+                yield batch_outs
+
+        return batch_iter_reader
+
+
+class SimpleReader(object):
+    def __init__(self, params):
+        if params['mode'] != 'train':
+            self.num_workers = 1
+        else:
+            self.num_workers = params['num_workers']
+        self.img_set_dir = params['img_set_dir']
+        self.label_file_path = params['label_file_path']
+        self.char_ops = params['char_ops']
+        self.image_shape = params['image_shape']
+        self.loss_type = params['loss_type']
+        self.max_text_length = params['max_text_length']
+        self.mode = params['mode']
+        if params['mode'] == 'train':
+            self.batch_size = params['train_batch_size_per_card']
+        elif params['mode'] == 'eval':
+            self.batch_size = params['test_batch_size_per_card']
+        else:
+            self.batch_size = 1
+            self.infer_img = params['infer_img']
+
+    def __call__(self, process_id):
+        if self.mode != 'train':
+            process_id = 0
+
+        def sample_iter_reader():
+            if self.mode == 'test':
+                print("infer_img:", self.infer_img)
+                img = cv2.imread(self.infer_img)
+                norm_img = process_image(img, self.image_shape)
+                yield norm_img
+            with open(self.label_file_path, "rb") as fin:
+                label_infor_list = fin.readlines()
+            img_num = len(label_infor_list)
+            img_id_list = list(range(img_num))
+            random.shuffle(img_id_list)
+            for img_id in range(process_id, img_num, self.num_workers):
+                label_infor = label_infor_list[img_id_list[img_id]]
+                substr = label_infor.decode('utf-8').strip("\n").split("\t")
+                img_path = self.img_set_dir + "/" + substr[0]
+                img = cv2.imread(img_path)
+                if img is None:
+                    continue
+                label = substr[1]
+                outs = process_image(img, self.image_shape, label,
+                                     self.char_ops, self.loss_type,
+                                     self.max_text_length)
+                if outs is None:
+                    continue
+                yield outs
+
+        def batch_iter_reader():
+            batch_outs = []
+            for outs in sample_iter_reader():
+                batch_outs.append(outs)
+                if len(batch_outs) == self.batch_size:
+                    yield batch_outs
+                    batch_outs = []
+            if len(batch_outs) != 0:
+                yield batch_outs
+
+        return batch_iter_reader

ppocr/data/rec/img_tools.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+import math
+import cv2
+import numpy as np
+
+
+def get_bounding_box_rect(pos):
+    left = min(pos[0])
+    right = max(pos[0])
+    top = min(pos[1])
+    bottom = max(pos[1])
+    return [left, top, right, bottom]
+
+
+def resize_norm_img(img, image_shape):
+    imgC, imgH, imgW = image_shape
+    h = img.shape[0]
+    w = img.shape[1]
+    ratio = w / float(h)
+    if math.ceil(imgH * ratio) > imgW:
+        resized_w = imgW
+    else:
+        resized_w = int(math.ceil(imgH * ratio))
+    resized_image = cv2.resize(img, (resized_w, imgH))
+    resized_image = resized_image.astype('float32')
+    if image_shape[0] == 1:
+        resized_image = resized_image / 255
+        resized_image = resized_image[np.newaxis, :]
+    else:
+        resized_image = resized_image.transpose((2, 0, 1)) / 255
+    resized_image -= 0.5
+    resized_image /= 0.5
+    padding_im = np.zeros((imgC, imgH, imgW), dtype=np.float32)
+    padding_im[:, :, 0:resized_w] = resized_image
+    return padding_im
+
+
+def get_img_data(value):
+    """get_img_data"""
+    if not value:
+        return None
+    imgdata = np.frombuffer(value, dtype='uint8')
+    if imgdata is None:
+        return None
+    imgori = cv2.imdecode(imgdata, 1)
+    if imgori is None:
+        return None
+    return imgori
+
+
+def process_image(img,
+                  image_shape,
+                  label=None,
+                  char_ops=None,
+                  loss_type=None,
+                  max_text_length=None):
+    norm_img = resize_norm_img(img, image_shape)
+    norm_img = norm_img[np.newaxis, :]
+    if label is not None:
+        char_num = char_ops.get_char_num()
+        text = char_ops.encode(label)
+        if len(text) == 0 or len(text) > max_text_length:
+            return None
+        else:
+            if loss_type == "ctc":
+                text = text.reshape(-1, 1)
+                return (norm_img, text)
+            elif loss_type == "attention":
+                beg_flag_idx = char_ops.get_beg_end_flag_idx("beg")
+                end_flag_idx = char_ops.get_beg_end_flag_idx("end")
+                beg_text = np.append(beg_flag_idx, text)
+                end_text = np.append(text, end_flag_idx)
+                beg_text = beg_text.reshape(-1, 1)
+                end_text = end_text.reshape(-1, 1)
+                return (norm_img, beg_text, end_text)
+            else:
+                assert False, "Unsupport loss_type %s in process_image"\
+                    % loss_type
+    return (norm_img)

ppocr/modeling/__init__.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

ppocr/modeling/architectures/det_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from paddle import fluid
+
+from ppocr.utils.utility import create_module
+from ppocr.utils.utility import initial_logger
+logger = initial_logger()
+from copy import deepcopy
+
+
+class DetModel(object):
+    def __init__(self, params):
+        """
+        Detection module for OCR text detection.
+        args:
+            params (dict): the super parameters for detection module.
+        """
+        global_params = params['Global']
+        self.algorithm = global_params['algorithm']
+
+        backbone_params = deepcopy(params["Backbone"])
+        backbone_params.update(global_params)
+        self.backbone = create_module(backbone_params['function'])\
+                (params=backbone_params)
+
+        head_params = deepcopy(params["Head"])
+        head_params.update(global_params)
+        self.head = create_module(head_params['function'])\
+                (params=head_params)
+
+        loss_params = deepcopy(params["Loss"])
+        loss_params.update(global_params)
+        self.loss = create_module(loss_params['function'])\
+                (params=loss_params)
+
+        self.image_shape = global_params['image_shape']
+
+    def create_feed(self, mode):
+        """
+        create Dataloader feeds
+        args:
+            mode (str): 'train' for training  or else for evaluation
+        return: (image, corresponding label, dataloader)
+        """
+        image_shape = deepcopy(self.image_shape)
+        image = fluid.layers.data(
+            name='image', shape=image_shape, dtype='float32')
+        if mode == "train":
+            if self.algorithm == "EAST":
+                score = fluid.layers.data(
+                    name='score', shape=[1, 128, 128], dtype='float32')
+                geo = fluid.layers.data(
+                    name='geo', shape=[9, 128, 128], dtype='float32')
+                mask = fluid.layers.data(
+                    name='mask', shape=[1, 128, 128], dtype='float32')
+                feed_list = [image, score, geo, mask]
+                labels = {'score': score, 'geo': geo, 'mask': mask}
+            elif self.algorithm == "DB":
+                shrink_map = fluid.layers.data(
+                    name='shrink_map', shape=image_shape[1:], dtype='float32')
+                shrink_mask = fluid.layers.data(
+                    name='shrink_mask', shape=image_shape[1:], dtype='float32')
+                threshold_map = fluid.layers.data(
+                    name='threshold_map',
+                    shape=image_shape[1:],
+                    dtype='float32')
+                threshold_mask = fluid.layers.data(
+                    name='threshold_mask',
+                    shape=image_shape[1:],
+                    dtype='float32')
+                feed_list=[image, shrink_map, shrink_mask,\
+                    threshold_map, threshold_mask]
+                labels = {'shrink_map':shrink_map,\
+                    'shrink_mask':shrink_mask,\
+                    'threshold_map':threshold_map,\
+                    'threshold_mask':threshold_mask}
+            loader = fluid.io.DataLoader.from_generator(
+                feed_list=feed_list,
+                capacity=64,
+                use_double_buffer=True,
+                iterable=False)
+        else:
+            labels = None
+            loader = None
+        return image, labels, loader
+
+    def __call__(self, mode):
+        """
+        run forward of defined module
+        args:
+            mode (str): 'train' for training; 'export'  for inference,
+                others for evaluation]
+        """
+        image, labels, loader = self.create_feed(mode)
+        conv_feas = self.backbone(image)
+        predicts = self.head(conv_feas)
+        if mode == "train":
+            losses = self.loss(predicts, labels)
+            return loader, losses
+        elif mode == "export":
+            return [image, predicts]
+        else:
+            return loader, predicts

ppocr/modeling/architectures/rec_model.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from paddle import fluid
+
+from ppocr.utils.utility import create_module
+from ppocr.utils.utility import initial_logger
+logger = initial_logger()
+from copy import deepcopy
+
+
+class RecModel(object):
+    def __init__(self, params):
+        super(RecModel, self).__init__()
+        global_params = params['Global']
+        char_num = global_params['char_ops'].get_char_num()
+        global_params['char_num'] = char_num
+        if "TPS" in params:
+            tps_params = deepcopy(params["TPS"])
+            tps_params.update(global_params)
+            self.tps = create_module(tps_params['function'])\
+                (params=tps_params)
+        else:
+            self.tps = None
+
+        backbone_params = deepcopy(params["Backbone"])
+        backbone_params.update(global_params)
+        self.backbone = create_module(backbone_params['function'])\
+                (params=backbone_params)
+
+        head_params = deepcopy(params["Head"])
+        head_params.update(global_params)
+        self.head = create_module(head_params['function'])\
+                (params=head_params)
+
+        loss_params = deepcopy(params["Loss"])
+        loss_params.update(global_params)
+        self.loss = create_module(loss_params['function'])\
+                (params=loss_params)
+
+        self.loss_type = global_params['loss_type']
+        self.image_shape = global_params['image_shape']
+        self.max_text_length = global_params['max_text_length']
+
+    def create_feed(self, mode):
+        image_shape = deepcopy(self.image_shape)
+        image_shape.insert(0, -1)
+        image = fluid.data(name='image', shape=image_shape, dtype='float32')
+        if mode == "train":
+            if self.loss_type == "attention":
+                label_in = fluid.data(
+                    name='label_in',
+                    shape=[None, 1],
+                    dtype='int32',
+                    lod_level=1)
+                label_out = fluid.data(
+                    name='label_out',
+                    shape=[None, 1],
+                    dtype='int32',
+                    lod_level=1)
+                feed_list = [image, label_in, label_out]
+                labels = {'label_in': label_in, 'label_out': label_out}
+            else:
+                label = fluid.data(
+                    name='label', shape=[None, 1], dtype='int32', lod_level=1)
+                feed_list = [image, label]
+                labels = {'label': label}
+            loader = fluid.io.DataLoader.from_generator(
+                feed_list=feed_list,
+                capacity=64,
+                use_double_buffer=True,
+                iterable=False)
+        else:
+            labels = None
+            loader = None
+        return image, labels, loader
+
+    def __call__(self, mode):
+        image, labels, loader = self.create_feed(mode)
+        if self.tps is None:
+            inputs = image
+        else:
+            inputs = self.tps(image)
+        conv_feas = self.backbone(inputs)
+        predicts = self.head(conv_feas, labels, mode)
+        decoded_out = predicts['decoded_out']
+        if mode == "train":
+            loss = self.loss(predicts, labels)
+            if self.loss_type == "attention":
+                label = labels['label_out']
+            else:
+                label = labels['label']
+            outputs = {'total_loss':loss, 'decoded_out':\
+                decoded_out, 'label':label}
+            return loader, outputs
+        elif mode == "export":
+            return [image, {'decoded_out': decoded_out}]
+        else:
+            return loader, {'decoded_out': decoded_out}

ppocr/modeling/backbones/det_mobilenet_v3.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ['MobileNetV3']
+
+
+class MobileNetV3():
+    def __init__(self, params):
+        """
+        the MobilenetV3 backbone network for detection module.
+        Args:
+            params(dict): the super parameters for build network
+        """
+        self.scale = params['scale']
+        model_name = params['model_name']
+        self.inplanes = 16
+        if model_name == "large":
+            self.cfg = [
+                # k, exp, c,  se,     nl,  s,
+                [3, 16, 16, False, 'relu', 1],
+                [3, 64, 24, False, 'relu', 2],
+                [3, 72, 24, False, 'relu', 1],
+                [5, 72, 40, True, 'relu', 2],
+                [5, 120, 40, True, 'relu', 1],
+                [5, 120, 40, True, 'relu', 1],
+                [3, 240, 80, False, 'hard_swish', 2],
+                [3, 200, 80, False, 'hard_swish', 1],
+                [3, 184, 80, False, 'hard_swish', 1],
+                [3, 184, 80, False, 'hard_swish', 1],
+                [3, 480, 112, True, 'hard_swish', 1],
+                [3, 672, 112, True, 'hard_swish', 1],
+                [5, 672, 160, True, 'hard_swish', 2],
+                [5, 960, 160, True, 'hard_swish', 1],
+                [5, 960, 160, True, 'hard_swish', 1],
+            ]
+            self.cls_ch_squeeze = 960
+            self.cls_ch_expand = 1280
+        elif model_name == "small":
+            self.cfg = [
+                # k, exp, c,  se,     nl,  s,
+                [3, 16, 16, True, 'relu', 2],
+                [3, 72, 24, False, 'relu', 2],
+                [3, 88, 24, False, 'relu', 1],
+                [5, 96, 40, True, 'hard_swish', 2],
+                [5, 240, 40, True, 'hard_swish', 1],
+                [5, 240, 40, True, 'hard_swish', 1],
+                [5, 120, 48, True, 'hard_swish', 1],
+                [5, 144, 48, True, 'hard_swish', 1],
+                [5, 288, 96, True, 'hard_swish', 2],
+                [5, 576, 96, True, 'hard_swish', 1],
+                [5, 576, 96, True, 'hard_swish', 1],
+            ]
+            self.cls_ch_squeeze = 576
+            self.cls_ch_expand = 1280
+        else:
+            raise NotImplementedError("mode[" + model_name +
+                                      "_model] is not implemented!")
+
+        supported_scale = [0.35, 0.5, 0.75, 1.0, 1.25]
+        assert self.scale in supported_scale, \
+            "supported scale are {} but input scale is {}".format(supported_scale, self.scale)
+
+    def __call__(self, input):
+        scale = self.scale
+        inplanes = self.inplanes
+        cfg = self.cfg
+        cls_ch_squeeze = self.cls_ch_squeeze
+        cls_ch_expand = self.cls_ch_expand
+        #conv1
+        conv = self.conv_bn_layer(
+            input,
+            filter_size=3,
+            num_filters=self.make_divisible(inplanes * scale),
+            stride=2,
+            padding=1,
+            num_groups=1,
+            if_act=True,
+            act='hard_swish',
+            name='conv1')
+        i = 0
+        inplanes = self.make_divisible(inplanes * scale)
+        outs = []
+        for layer_cfg in cfg:
+            if layer_cfg[5] == 2 and i > 2:
+                outs.append(conv)
+            conv = self.residual_unit(
+                input=conv,
+                num_in_filter=inplanes,
+                num_mid_filter=self.make_divisible(scale * layer_cfg[1]),
+                num_out_filter=self.make_divisible(scale * layer_cfg[2]),
+                act=layer_cfg[4],
+                stride=layer_cfg[5],
+                filter_size=layer_cfg[0],
+                use_se=layer_cfg[3],
+                name='conv' + str(i + 2))
+            inplanes = self.make_divisible(scale * layer_cfg[2])
+            i += 1
+
+        conv = self.conv_bn_layer(
+            input=conv,
+            filter_size=1,
+            num_filters=self.make_divisible(scale * cls_ch_squeeze),
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=True,
+            act='hard_swish',
+            name='conv_last')
+        outs.append(conv)
+        return outs
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      num_groups=1,
+                      if_act=True,
+                      act=None,
+                      name=None,
+                      use_cudnn=True,
+                      res_last_bn_init=False):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(name=name + '_weights'),
+            bias_attr=False)
+        bn_name = name + '_bn'
+        bn = fluid.layers.batch_norm(
+            input=conv,
+            param_attr=ParamAttr(
+                name=bn_name + "_scale",
+                regularizer=fluid.regularizer.L2DecayRegularizer(
+                    regularization_coeff=0.0)),
+            bias_attr=ParamAttr(
+                name=bn_name + "_offset",
+                regularizer=fluid.regularizer.L2DecayRegularizer(
+                    regularization_coeff=0.0)),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+        if if_act:
+            if act == 'relu':
+                bn = fluid.layers.relu(bn)
+            elif act == 'hard_swish':
+                bn = fluid.layers.hard_swish(bn)
+        return bn
+
+    def make_divisible(self, v, divisor=8, min_value=None):
+        if min_value is None:
+            min_value = divisor
+        new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+        if new_v < 0.9 * v:
+            new_v += divisor
+        return new_v
+
+    def se_block(self, input, num_out_filter, ratio=4, name=None):
+        num_mid_filter = num_out_filter // ratio
+        pool = fluid.layers.pool2d(
+            input=input, pool_type='avg', global_pooling=True, use_cudnn=False)
+        conv1 = fluid.layers.conv2d(
+            input=pool,
+            filter_size=1,
+            num_filters=num_mid_filter,
+            act='relu',
+            param_attr=ParamAttr(name=name + '_1_weights'),
+            bias_attr=ParamAttr(name=name + '_1_offset'))
+        conv2 = fluid.layers.conv2d(
+            input=conv1,
+            filter_size=1,
+            num_filters=num_out_filter,
+            act='hard_sigmoid',
+            param_attr=ParamAttr(name=name + '_2_weights'),
+            bias_attr=ParamAttr(name=name + '_2_offset'))
+        scale = fluid.layers.elementwise_mul(x=input, y=conv2, axis=0)
+        return scale
+
+    def residual_unit(self,
+                      input,
+                      num_in_filter,
+                      num_mid_filter,
+                      num_out_filter,
+                      stride,
+                      filter_size,
+                      act=None,
+                      use_se=False,
+                      name=None):
+
+        conv0 = self.conv_bn_layer(
+            input=input,
+            filter_size=1,
+            num_filters=num_mid_filter,
+            stride=1,
+            padding=0,
+            if_act=True,
+            act=act,
+            name=name + '_expand')
+
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            filter_size=filter_size,
+            num_filters=num_mid_filter,
+            stride=stride,
+            padding=int((filter_size - 1) // 2),
+            if_act=True,
+            act=act,
+            num_groups=num_mid_filter,
+            use_cudnn=False,
+            name=name + '_depthwise')
+        if use_se:
+            conv1 = self.se_block(
+                input=conv1, num_out_filter=num_mid_filter, name=name + '_se')
+
+        conv2 = self.conv_bn_layer(
+            input=conv1,
+            filter_size=1,
+            num_filters=num_out_filter,
+            stride=1,
+            padding=0,
+            if_act=False,
+            name=name + '_linear',
+            res_last_bn_init=True)
+        if num_in_filter != num_out_filter or stride != 1:
+            return conv2
+        else:
+            return fluid.layers.elementwise_add(x=input, y=conv2, act=None)

ppocr/modeling/backbones/det_resnet_vd.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import paddle.fluid as fluid
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = ["ResNet"]
+
+
+class ResNet(object):
+    def __init__(self, params):
+        """
+        the Resnet backbone network for detection module.
+        Args:
+            params(dict): the super parameters for network build
+        """
+        self.layers = params['layers']
+        supported_layers = [18, 34, 50, 101, 152]
+        assert self.layers in supported_layers, \
+            "supported layers are {} but input layer is {}".format(supported_layers, self.layers)
+        self.is_3x3 = True
+
+    def __call__(self, input):
+        layers = self.layers
+        is_3x3 = self.is_3x3
+        if layers == 18:
+            depth = [2, 2, 2, 2]
+        elif layers == 34 or layers == 50:
+            depth = [3, 4, 6, 3]
+        elif layers == 101:
+            depth = [3, 4, 23, 3]
+        elif layers == 152:
+            depth = [3, 8, 36, 3]
+        elif layers == 200:
+            depth = [3, 12, 48, 3]
+        num_filters = [64, 128, 256, 512]
+        outs = []
+
+        if is_3x3 == False:
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=64,
+                filter_size=7,
+                stride=2,
+                act='relu')
+        else:
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=32,
+                filter_size=3,
+                stride=2,
+                act='relu',
+                name='conv1_1')
+            conv = self.conv_bn_layer(
+                input=conv,
+                num_filters=32,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv1_2')
+            conv = self.conv_bn_layer(
+                input=conv,
+                num_filters=64,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv1_3')
+
+        conv = fluid.layers.pool2d(
+            input=conv,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=1,
+            pool_type='max')
+
+        if layers >= 50:
+            for block in range(len(depth)):
+                for i in range(depth[block]):
+                    if layers in [101, 152, 200] and block == 2:
+                        if i == 0:
+                            conv_name = "res" + str(block + 2) + "a"
+                        else:
+                            conv_name = "res" + str(block + 2) + "b" + str(i)
+                    else:
+                        conv_name = "res" + str(block + 2) + chr(97 + i)
+                    conv = self.bottleneck_block(
+                        input=conv,
+                        num_filters=num_filters[block],
+                        stride=2 if i == 0 and block != 0 else 1,
+                        if_first=block == i == 0,
+                        name=conv_name)
+                outs.append(conv)
+        else:
+            for block in range(len(depth)):
+                for i in range(depth[block]):
+                    conv_name = "res" + str(block + 2) + chr(97 + i)
+                    conv = self.basic_block(
+                        input=conv,
+                        num_filters=num_filters[block],
+                        stride=2 if i == 0 and block != 0 else 1,
+                        if_first=block == i == 0,
+                        name=conv_name)
+                outs.append(conv)
+        return outs
+
+    def conv_bn_layer(self,
+                      input,
+                      num_filters,
+                      filter_size,
+                      stride=1,
+                      groups=1,
+                      act=None,
+                      name=None):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=None,
+            param_attr=ParamAttr(name=name + "_weights"),
+            bias_attr=False)
+        if name == "conv1":
+            bn_name = "bn_" + name
+        else:
+            bn_name = "bn" + name[3:]
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=ParamAttr(name=bn_name + '_scale'),
+            bias_attr=ParamAttr(bn_name + '_offset'),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def conv_bn_layer_new(self,
+                          input,
+                          num_filters,
+                          filter_size,
+                          stride=1,
+                          groups=1,
+                          act=None,
+                          name=None):
+        pool = fluid.layers.pool2d(
+            input=input,
+            pool_size=2,
+            pool_stride=2,
+            pool_padding=0,
+            pool_type='avg',
+            ceil_mode=True)
+
+        conv = fluid.layers.conv2d(
+            input=pool,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=1,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=None,
+            param_attr=ParamAttr(name=name + "_weights"),
+            bias_attr=False)
+        if name == "conv1":
+            bn_name = "bn_" + name
+        else:
+            bn_name = "bn" + name[3:]
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=ParamAttr(name=bn_name + '_scale'),
+            bias_attr=ParamAttr(bn_name + '_offset'),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def shortcut(self, input, ch_out, stride, name, if_first=False):
+        ch_in = input.shape[1]
+        if ch_in != ch_out or stride != 1:
+            if if_first:
+                return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
+            else:
+                return self.conv_bn_layer_new(
+                    input, ch_out, 1, stride, name=name)
+        elif if_first:
+            return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
+        else:
+            return input
+
+    def bottleneck_block(self, input, num_filters, stride, name, if_first):
+        conv0 = self.conv_bn_layer(
+            input=input,
+            num_filters=num_filters,
+            filter_size=1,
+            act='relu',
+            name=name + "_branch2a")
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            num_filters=num_filters,
+            filter_size=3,
+            stride=stride,
+            act='relu',
+            name=name + "_branch2b")
+        conv2 = self.conv_bn_layer(
+            input=conv1,
+            num_filters=num_filters * 4,
+            filter_size=1,
+            act=None,
+            name=name + "_branch2c")
+
+        short = self.shortcut(
+            input,
+            num_filters * 4,
+            stride,
+            if_first=if_first,
+            name=name + "_branch1")
+
+        return fluid.layers.elementwise_add(x=short, y=conv2, act='relu')
+
+    def basic_block(self, input, num_filters, stride, name, if_first):
+        conv0 = self.conv_bn_layer(
+            input=input,
+            num_filters=num_filters,
+            filter_size=3,
+            act='relu',
+            stride=stride,
+            name=name + "_branch2a")
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            num_filters=num_filters,
+            filter_size=3,
+            act=None,
+            name=name + "_branch2b")
+        short = self.shortcut(
+            input,
+            num_filters,
+            stride,
+            if_first=if_first,
+            name=name + "_branch1")
+        return fluid.layers.elementwise_add(x=short, y=conv1, act='relu')

ppocr/modeling/backbones/rec_mobilenet_v3.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import paddle.fluid as fluid
+from paddle.fluid.initializer import MSRA
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = [
+    'MobileNetV3', 'MobileNetV3_small_x0_35', 'MobileNetV3_small_x0_5',
+    'MobileNetV3_small_x0_75', 'MobileNetV3_small_x1_0',
+    'MobileNetV3_small_x1_25', 'MobileNetV3_large_x0_35',
+    'MobileNetV3_large_x0_5', 'MobileNetV3_large_x0_75',
+    'MobileNetV3_large_x1_0', 'MobileNetV3_large_x1_25'
+]
+
+
+class MobileNetV3():
+    def __init__(self, params):
+        self.scale = params['scale']
+        model_name = params['model_name']
+        self.inplanes = 16
+        if model_name == "large":
+            self.cfg = [
+                # k, exp, c,  se,     nl,  s,
+                [3, 16, 16, False, 'relu', 1],
+                [3, 64, 24, False, 'relu', (2, 1)],
+                [3, 72, 24, False, 'relu', 1],
+                [5, 72, 40, True, 'relu', (2, 1)],
+                [5, 120, 40, True, 'relu', 1],
+                [5, 120, 40, True, 'relu', 1],
+                [3, 240, 80, False, 'hard_swish', 1],
+                [3, 200, 80, False, 'hard_swish', 1],
+                [3, 184, 80, False, 'hard_swish', 1],
+                [3, 184, 80, False, 'hard_swish', 1],
+                [3, 480, 112, True, 'hard_swish', 1],
+                [3, 672, 112, True, 'hard_swish', 1],
+                [5, 672, 160, True, 'hard_swish', (2, 1)],
+                [5, 960, 160, True, 'hard_swish', 1],
+                [5, 960, 160, True, 'hard_swish', 1],
+            ]
+            self.cls_ch_squeeze = 960
+            self.cls_ch_expand = 1280
+        elif model_name == "small":
+            self.cfg = [
+                # k, exp, c,  se,     nl,  s,
+                [3, 16, 16, True, 'relu', (2, 1)],
+                [3, 72, 24, False, 'relu', (2, 1)],
+                [3, 88, 24, False, 'relu', 1],
+                [5, 96, 40, True, 'hard_swish', (2, 1)],
+                [5, 240, 40, True, 'hard_swish', 1],
+                [5, 240, 40, True, 'hard_swish', 1],
+                [5, 120, 48, True, 'hard_swish', 1],
+                [5, 144, 48, True, 'hard_swish', 1],
+                [5, 288, 96, True, 'hard_swish', (2, 1)],
+                [5, 576, 96, True, 'hard_swish', 1],
+                [5, 576, 96, True, 'hard_swish', 1],
+            ]
+            self.cls_ch_squeeze = 576
+            self.cls_ch_expand = 1280
+        else:
+            raise NotImplementedError("mode[" + model_name +
+                                      "_model] is not implemented!")
+
+        supported_scale = [0.35, 0.5, 0.75, 1.0, 1.25]
+        assert self.scale in supported_scale, \
+            "supported scale are {} but input scale is {}".format(supported_scale, scale)
+
+    def __call__(self, input):
+        scale = self.scale
+        inplanes = self.inplanes
+        cfg = self.cfg
+        cls_ch_squeeze = self.cls_ch_squeeze
+        cls_ch_expand = self.cls_ch_expand
+        #conv1
+        conv = self.conv_bn_layer(
+            input,
+            filter_size=3,
+            num_filters=self.make_divisible(inplanes * scale),
+            stride=2,
+            padding=1,
+            num_groups=1,
+            if_act=True,
+            act='hard_swish',
+            name='conv1')
+        i = 0
+        inplanes = self.make_divisible(inplanes * scale)
+        for layer_cfg in cfg:
+            conv = self.residual_unit(
+                input=conv,
+                num_in_filter=inplanes,
+                num_mid_filter=self.make_divisible(scale * layer_cfg[1]),
+                num_out_filter=self.make_divisible(scale * layer_cfg[2]),
+                act=layer_cfg[4],
+                stride=layer_cfg[5],
+                filter_size=layer_cfg[0],
+                use_se=layer_cfg[3],
+                name='conv' + str(i + 2))
+            inplanes = self.make_divisible(scale * layer_cfg[2])
+            i += 1
+
+        conv = self.conv_bn_layer(
+            input=conv,
+            filter_size=1,
+            num_filters=self.make_divisible(scale * cls_ch_squeeze),
+            stride=1,
+            padding=0,
+            num_groups=1,
+            if_act=True,
+            act='hard_swish',
+            name='conv_last')
+
+        conv = fluid.layers.pool2d(
+            input=conv,
+            pool_size=2,
+            pool_stride=2,
+            pool_padding=0,
+            pool_type='max')
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      filter_size,
+                      num_filters,
+                      stride,
+                      padding,
+                      num_groups=1,
+                      if_act=True,
+                      act=None,
+                      name=None,
+                      use_cudnn=True,
+                      res_last_bn_init=False):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=padding,
+            groups=num_groups,
+            act=None,
+            use_cudnn=use_cudnn,
+            param_attr=ParamAttr(name=name + '_weights'),
+            bias_attr=False)
+        bn_name = name + '_bn'
+        bn = fluid.layers.batch_norm(
+            input=conv,
+            param_attr=ParamAttr(
+                name=bn_name + "_scale",
+                regularizer=fluid.regularizer.L2DecayRegularizer(
+                    regularization_coeff=0.0)),
+            bias_attr=ParamAttr(
+                name=bn_name + "_offset",
+                regularizer=fluid.regularizer.L2DecayRegularizer(
+                    regularization_coeff=0.0)),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+        if if_act:
+            if act == 'relu':
+                bn = fluid.layers.relu(bn)
+            elif act == 'hard_swish':
+                bn = fluid.layers.hard_swish(bn)
+        return bn
+
+    def make_divisible(self, v, divisor=8, min_value=None):
+        if min_value is None:
+            min_value = divisor
+        new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+        if new_v < 0.9 * v:
+            new_v += divisor
+        return new_v
+
+    def se_block(self, input, num_out_filter, ratio=4, name=None):
+        num_mid_filter = num_out_filter // ratio
+        pool = fluid.layers.pool2d(
+            input=input, pool_type='avg', global_pooling=True, use_cudnn=False)
+        conv1 = fluid.layers.conv2d(
+            input=pool,
+            filter_size=1,
+            num_filters=num_mid_filter,
+            act='relu',
+            param_attr=ParamAttr(name=name + '_1_weights'),
+            bias_attr=ParamAttr(name=name + '_1_offset'))
+        conv2 = fluid.layers.conv2d(
+            input=conv1,
+            filter_size=1,
+            num_filters=num_out_filter,
+            act='hard_sigmoid',
+            param_attr=ParamAttr(name=name + '_2_weights'),
+            bias_attr=ParamAttr(name=name + '_2_offset'))
+        scale = fluid.layers.elementwise_mul(x=input, y=conv2, axis=0)
+        return scale
+
+    def residual_unit(self,
+                      input,
+                      num_in_filter,
+                      num_mid_filter,
+                      num_out_filter,
+                      stride,
+                      filter_size,
+                      act=None,
+                      use_se=False,
+                      name=None):
+
+        conv0 = self.conv_bn_layer(
+            input=input,
+            filter_size=1,
+            num_filters=num_mid_filter,
+            stride=1,
+            padding=0,
+            if_act=True,
+            act=act,
+            name=name + '_expand')
+
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            filter_size=filter_size,
+            num_filters=num_mid_filter,
+            stride=stride,
+            padding=int((filter_size - 1) // 2),
+            if_act=True,
+            act=act,
+            num_groups=num_mid_filter,
+            use_cudnn=False,
+            name=name + '_depthwise')
+        if use_se:
+            conv1 = self.se_block(
+                input=conv1, num_out_filter=num_mid_filter, name=name + '_se')
+
+        conv2 = self.conv_bn_layer(
+            input=conv1,
+            filter_size=1,
+            num_filters=num_out_filter,
+            stride=1,
+            padding=0,
+            if_act=False,
+            name=name + '_linear',
+            res_last_bn_init=True)
+        if num_in_filter != num_out_filter or stride != 1:
+            return conv2
+        else:
+            return fluid.layers.elementwise_add(x=input, y=conv2, act=None)

ppocr/modeling/backbones/rec_resnet_vd.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+
+import paddle
+import paddle.fluid as fluid
+from paddle.fluid.param_attr import ParamAttr
+
+__all__ = [
+    "ResNet", "ResNet18_vd", "ResNet34_vd", "ResNet50_vd", "ResNet101_vd",
+    "ResNet152_vd", "ResNet200_vd"
+]
+
+
+class ResNet():
+    def __init__(self, params):
+        self.layers = params['layers']
+        self.is_3x3 = True
+        supported_layers = [18, 34, 50, 101, 152, 200]
+        assert self.layers in supported_layers, \
+            "supported layers are {} but input layer is {}".format(supported_layers, self.layers)
+
+    def __call__(self, input):
+        is_3x3 = self.is_3x3
+        layers = self.layers
+
+        if layers == 18:
+            depth = [2, 2, 2, 2]
+        elif layers == 34 or layers == 50:
+            depth = [3, 4, 6, 3]
+        elif layers == 101:
+            depth = [3, 4, 23, 3]
+        elif layers == 152:
+            depth = [3, 8, 36, 3]
+        elif layers == 200:
+            depth = [3, 12, 48, 3]
+        num_filters = [64, 128, 256, 512]
+        if is_3x3 == False:
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=64,
+                filter_size=7,
+                stride=1,
+                act='relu')
+        else:
+            conv = self.conv_bn_layer(
+                input=input,
+                num_filters=32,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv1_1')
+            conv = self.conv_bn_layer(
+                input=conv,
+                num_filters=32,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv1_2')
+            conv = self.conv_bn_layer(
+                input=conv,
+                num_filters=64,
+                filter_size=3,
+                stride=1,
+                act='relu',
+                name='conv1_3')
+
+        conv = fluid.layers.pool2d(
+            input=conv,
+            pool_size=3,
+            pool_stride=2,
+            pool_padding=1,
+            pool_type='max')
+
+        if layers >= 50:
+            for block in range(len(depth)):
+                for i in range(depth[block]):
+                    if layers in [101, 152, 200] and block == 2:
+                        if i == 0:
+                            conv_name = "res" + str(block + 2) + "a"
+                        else:
+                            conv_name = "res" + str(block + 2) + "b" + str(i)
+                    else:
+                        conv_name = "res" + str(block + 2) + chr(97 + i)
+
+                    if i == 0 and block != 0:
+                        stride = (2, 1)
+                    else:
+                        stride = (1, 1)
+
+                    conv = self.bottleneck_block(
+                        input=conv,
+                        num_filters=num_filters[block],
+                        stride=stride,
+                        if_first=block == i == 0,
+                        name=conv_name)
+        else:
+            for block in range(len(depth)):
+                for i in range(depth[block]):
+                    conv_name = "res" + str(block + 2) + chr(97 + i)
+
+                    if i == 0 and block != 0:
+                        stride = (2, 1)
+                    else:
+                        stride = (1, 1)
+
+                    conv = self.basic_block(
+                        input=conv,
+                        num_filters=num_filters[block],
+                        stride=stride,
+                        if_first=block == i == 0,
+                        name=conv_name)
+
+        conv = fluid.layers.pool2d(
+            input=conv,
+            pool_size=2,
+            pool_stride=2,
+            pool_padding=0,
+            pool_type='max')
+
+        return conv
+
+    def conv_bn_layer(self,
+                      input,
+                      num_filters,
+                      filter_size,
+                      stride=1,
+                      groups=1,
+                      act=None,
+                      name=None):
+        conv = fluid.layers.conv2d(
+            input=input,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=stride,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=None,
+            param_attr=ParamAttr(name=name + "_weights"),
+            bias_attr=False)
+        if name == "conv1":
+            bn_name = "bn_" + name
+        else:
+            bn_name = "bn" + name[3:]
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=ParamAttr(name=bn_name + '_scale'),
+            bias_attr=ParamAttr(bn_name + '_offset'),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def conv_bn_layer_new(self,
+                          input,
+                          num_filters,
+                          filter_size,
+                          stride=1,
+                          groups=1,
+                          act=None,
+                          name=None):
+        pool = fluid.layers.pool2d(
+            input=input,
+            pool_size=stride,
+            pool_stride=stride,
+            pool_padding=0,
+            pool_type='avg',
+            ceil_mode=True)
+
+        conv = fluid.layers.conv2d(
+            input=pool,
+            num_filters=num_filters,
+            filter_size=filter_size,
+            stride=1,
+            padding=(filter_size - 1) // 2,
+            groups=groups,
+            act=None,
+            param_attr=ParamAttr(name=name + "_weights"),
+            bias_attr=False)
+
+        if name == "conv1":
+            bn_name = "bn_" + name
+        else:
+            bn_name = "bn" + name[3:]
+        return fluid.layers.batch_norm(
+            input=conv,
+            act=act,
+            param_attr=ParamAttr(name=bn_name + '_scale'),
+            bias_attr=ParamAttr(bn_name + '_offset'),
+            moving_mean_name=bn_name + '_mean',
+            moving_variance_name=bn_name + '_variance')
+
+    def shortcut(self, input, ch_out, stride, name, if_first=False):
+        ch_in = input.shape[1]
+        if ch_in != ch_out or stride[0] != 1:
+            if if_first:
+                return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
+            else:
+                return self.conv_bn_layer_new(
+                    input, ch_out, 1, stride, name=name)
+        elif if_first:
+            return self.conv_bn_layer(input, ch_out, 1, stride, name=name)
+        else:
+            return input
+
+    def bottleneck_block(self, input, num_filters, stride, name, if_first):
+        conv0 = self.conv_bn_layer(
+            input=input,
+            num_filters=num_filters,
+            filter_size=1,
+            act='relu',
+            name=name + "_branch2a")
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            num_filters=num_filters,
+            filter_size=3,
+            stride=stride,
+            act='relu',
+            name=name + "_branch2b")
+        conv2 = self.conv_bn_layer(
+            input=conv1,
+            num_filters=num_filters * 4,
+            filter_size=1,
+            act=None,
+            name=name + "_branch2c")
+
+        short = self.shortcut(
+            input,
+            num_filters * 4,
+            stride,
+            if_first=if_first,
+            name=name + "_branch1")
+
+        return fluid.layers.elementwise_add(x=short, y=conv2, act='relu')
+
+    def basic_block(self, input, num_filters, stride, name, if_first):
+        conv0 = self.conv_bn_layer(
+            input=input,
+            num_filters=num_filters,
+            filter_size=3,
+            act='relu',
+            stride=stride,
+            name=name + "_branch2a")
+        conv1 = self.conv_bn_layer(
+            input=conv0,
+            num_filters=num_filters,
+            filter_size=3,
+            act=None,
+            name=name + "_branch2b")
+        short = self.shortcut(
+            input,
+            num_filters,
+            stride,
+            if_first=if_first,
+            name=name + "_branch1")
+        return fluid.layers.elementwise_add(x=short, y=conv1, act='relu')

ppocr/modeling/common_functions.py

+#copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License.
+#You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+#Unless required by applicable law or agreed to in writing, software
+#distributed under the License is distributed on an "AS IS" BASIS,
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#See the License for the specific language governing permissions and
+#limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import paddle
+import paddle.fluid as fluid
+from paddle.fluid.param_attr import ParamAttr
+import math
+
+
+def get_para_bias_attr(l2_decay, k, name):
+    regularizer = fluid.regularizer.L2Decay(l2_decay)
+    stdv = 1.0 / math.sqrt(k * 1.0)
+    initializer = fluid.initializer.Uniform(-stdv, stdv)
+    para_attr = fluid.ParamAttr(
+        regularizer=regularizer, initializer=initializer, name=name + "_w_attr")
+    bias_attr = fluid.ParamAttr(
+        regularizer=regularizer, initializer=initializer, name=name + "_b_attr")
+    return [para_attr, bias_attr]
+
+
+def conv_bn_layer(input,
+                  num_filters,
+                  filter_size,
+                  stride=1,
+                  groups=1,
+                  act=None,
+                  name=None):
+    conv = fluid.layers.conv2d(
+        input=input,
+        num_filters=num_filters,
+        filter_size=filter_size,
+        stride=stride,
+        padding=(filter_size - 1) // 2,
+        groups=groups,
+        act=None,
+        param_attr=ParamAttr(name=name + "_weights"),
+        bias_attr=False,
+        name=name + '.conv2d')
+
+    bn_name = "bn_" + name
+    return fluid.layers.batch_norm(
+        input=conv,
+        act=act,
+        name=bn_name + '.output',
+        param_attr=ParamAttr(name=bn_name + '_scale'),
+        bias_attr=ParamAttr(bn_name + '_offset'),
+        moving_mean_name=bn_name + '_mean',
+        moving_variance_name=bn_name + '_variance')
+
+
+def deconv_bn_layer(input,
+                    num_filters,
+                    filter_size=4,
+                    stride=2,
+                    act='relu',
+                    name=None):
+    deconv = fluid.layers.conv2d_transpose(
+        input=input,
+        num_filters=num_filters,
+        filter_size=filter_size,
+        stride=stride,
+        padding=1,
+        act=None,
+        param_attr=ParamAttr(name=name + "_weights"),
+        bias_attr=False,
+        name=name + '.deconv2d')
+    bn_name = "bn_" + name
+    return fluid.layers.batch_norm(
+        input=deconv,
+        act=act,
+        name=bn_name + '.output',
+        param_attr=ParamAttr(name=bn_name + '_scale'),
+        bias_attr=ParamAttr(bn_name + '_offset'),
+        moving_mean_name=bn_name + '_mean',
+        moving_variance_name=bn_name + '_variance')
+
+
+def create_tmp_var(program, name, dtype, shape, lod_level=0):
+    return program.current_block().create_var(
+        name=name, dtype=dtype, shape=shape, lod_level=lod_level)