Ascend NPU

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

"""
    Examples::
        >>> import layoutparser as lp
        >>> model = lp.models.PaddleDetectionLayoutModel('lp://PubLayNet/ppyolov2_r50vd_dcn_365e/config')
        >>> model.detect(image)
"""


import layoutparser as lp
from layoutparser.models import PaddleDetectionLayoutModel

class MdqPaddleDetectionLayoutModel(PaddleDetectionLayoutModel):
    def load_predictor(
        self,
        model_dir,
        device=None,
        enable_mkldnn=False,
        thread_num=10,
    ):
        """set AnalysisConfig, generate AnalysisPredictor
        Args:
            model_dir (str): root path of __model__ and __params__
            device (str): cuda, npu or cpu
        Returns:
            predictor (PaddlePredictor): AnalysisPredictor
        Raises:
            ValueError: predict by TensorRT need enforce_cpu == False.
        """

        config = paddle.inference.Config(
            os.path.join(
                model_dir, "inference.pdmodel"
            ),  # TODO: Move them to some constants
            os.path.join(model_dir, "inference.pdiparams"),
        )


        if device.startswith('cuda')
            # initial GPU memory(M), device ID
            # 2000 is an appropriate value for PaddleDetection model
            config.enable_use_gpu(2000, 0)
            # optimize graph and fuse op
            config.switch_ir_optim(True)
        elif device.startswith('npu'):
            # enable ascend npu device, device_id, 启用华为NPU
            device_id = int(device[4:])
            config.enable_use_npu(2000, device_id)
        else:
            config.disable_gpu()
            config.set_cpu_math_library_num_threads(thread_num)
            if enable_mkldnn:
                config.enable_mkldnn()
                try:
                    # cache 10 different shapes for mkldnn to avoid memory leak
                    config.set_mkldnn_cache_capacity(10)
                    config.enable_mkldnn()
                except Exception as e:
                    print(
                        "The current environment does not support `mkldnn`, so disable mkldnn."
                    )

        # disable print log when predict
        config.disable_glog_info()
        # enable shared memory
        config.enable_memory_optim()
        # disable feed, fetch OP, needed by zero_copy_run
        config.switch_use_feed_fetch_ops(False)
        predictor = paddle.inference.create_predictor(config)
        return predictor


if __name__ == '__main__':
    lp.models.PaddleDetectionLayoutModel('lp://PubLayNet/ppyolov2_r50vd_dcn_365e/config')
    img = '/work/demo.jpg'
    model.detect(img)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

import fastdeploy as fd
from fastdeploy.serving.server import SimpleServer
import os
import logging
from pathlib import Path
import paddleocr

logging.getLogger().setLevel(logging.INFO)

# Configurations
lang = 'ch'
if lang == 'ch'
    # det_model_dir = f"det/ch/ch_PP-OCRv3_det_infer"
    # cls_model_dir = "cls/ch/ch_ppocr_mobile_v2.0_cls_infer"
    # rec_model_dir = "rec/ch/ch_PP-OCRv3_rec_infer"
    # rec_label_file = "ppocr_keys_v1.txt"
    det_model_dir = f"det/ch/ch_PP-OCRv4_det_infer"
    cls_model_dir = "cls/ch/ch_ppocr_mobile_v2.0_cls_infer"
    rec_model_dir = "rec/ch/ch_PP-OCRv4_rec_infer__server"
    rec_label_file = Path(paddleocr.__file__).parent.joinpath("/ppocr/utils/ppocr_keys_v1.txt")
elif lang == 'en':
    det_model_dir = f"det/ch/ch_PP-OCRv3_det_infer"
    cls_model_dir = "cls/ch/ch_ppocr_mobile_v2.0_cls_infer"
    rec_model_dir = "rec/ch/ch_PP-OCRv3_rec_infer"
    rec_label_file = "ppocr_keys_v1.txt"

device = "npu:0"
# backend: ['paddle', 'trt'], you can also use other backends, but need to modify
# the runtime option below
backend = "paddle"

# Prepare models
# Detection model
model_save_prefix = "~/.paddleocr/whl/"
det_model_file = os.path.join(model_save_prefix, det_model_dir, "inference.pdmodel")
det_params_file = os.path.join(model_save_prefix, det_model_dir, "inference.pdiparams")
# Classification model
cls_model_file = os.path.join(model_save_prefix, cls_model_dir, "inference.pdmodel")
cls_params_file = os.path.join(model_save_prefix, cls_model_dir, "inference.pdiparams")
# Recognition model
rec_model_file = os.path.join(model_save_prefix, rec_model_dir, "inference.pdmodel")
rec_params_file = os.path.join(model_save_prefix, rec_model_dir, "inference.pdiparams")

# Setup runtime option to select hardware, backend, etc.
option = fd.RuntimeOption()

if device.lower() == "gpu":
    option.use_gpu()
if backend == "trt":
    option.use_trt_backend()
elif device.lower().startswith('npu'):
    option.use_ascend()
else:
    option.use_paddle_infer_backend()

det_option = option
# det_option.set_trt_input_shape("x", [1, 3, 64, 64], [1, 3, 640, 640], [1, 3, 960, 960])

# det_option.set_trt_cache_file("det_trt_cache.trt")
print(det_model_file, det_params_file)
det_model = fd.vision.ocr.DBDetector(
    det_model_file, det_params_file, runtime_option=det_option
)

cls_batch_size = 1
rec_batch_size = 6

cls_option = option
cls_option.set_trt_input_shape(
    "x", [1, 3, 48, 10], [cls_batch_size, 3, 48, 320], [cls_batch_size, 3, 48, 1024]
)

# cls_option.set_trt_cache_file("cls_trt_cache.trt")
cls_model = fd.vision.ocr.Classifier(
    cls_model_file, cls_params_file, runtime_option=cls_option
)

rec_option = option
rec_option.set_trt_input_shape(
    "x", [1, 3, 48, 10], [rec_batch_size, 3, 48, 320], [rec_batch_size, 3, 48, 2304]
)

# rec_option.set_trt_cache_file("rec_trt_cache.trt")
rec_model = fd.vision.ocr.Recognizer(
    rec_model_file, rec_params_file, rec_label_file, runtime_option=rec_option
)

# Create PPOCRv3 pipeline
ppocr_v3 = fd.vision.ocr.PPOCRv3(
    det_model=det_model, cls_model=cls_model, rec_model=rec_model
)

ppocr_v3.cls_batch_size = cls_batch_size
ppocr_v3.rec_batch_size = rec_batch_size

# Create server, setup REST API
app = SimpleServer()
app.register(
    task_name="fd/ppocrv3",
    model_handler=fd.serving.handler.VisionModelHandler,
    predictor=ppocr_v3,
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

from paddlex import create_pipeline

pipeline = create_pipeline(pipeline="./OCR.yaml")

output = pipeline.predict(
    input="./scripts/demo.jpg",
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_textline_orientation=False,
    device='npu:2'
)
for res in output:
    res.print()
    res.save_to_img("./output/")
    res.save_to_json("./output/")



from paddlex import create_pipeline

pipeline = create_pipeline(pipeline="./OCR.yaml", device="npu:2") # 将设备名修改为 npu、mlu、xpu、dcu 或 gcu

output = pipeline.predict("./scripts/demo.jpg")
for res in output:
    res.print()
    res.save_to_img("./output/")