def export_load_infer(args, model=None):
    """
    Export the ONNX model from PaddlePaddle, infer it by TRT.
    It checks the accuracy and tests the infer time.

    Args:
        args (dict): The input args.
        model (nn.Layer, optional): The paddle model to be exported and tested.
            If model is None, it creates a model with config file in args.
    """

    # 1. prepare
    if model is None:
        cfg = Config(args.config)
        builder = SegBuilder(cfg)
        model = builder.model
    if args.model_path is not None:
        utils.load_entire_model(model, args.model_path)
        logger.info('Loaded trained params of model successfully')

    model.eval()
    if args.print_model:
        print(model)

    input_shape = [1, 3, args.height, args.width]
    print("input shape:", input_shape)
    input_data = np.random.random(input_shape).astype('float32')
    model_name = os.path.basename(args.config).split(".")[0]

    # 2. run paddle
    paddle_out = run_paddle(model, input_data)
    print("out shape:", paddle_out.shape)
    print("The paddle model has been predicted by PaddlePaddle.\n")

    # 3. export onnx
    input_spec = paddle.static.InputSpec(input_shape, 'float32', 'x')
    onnx_model_path = os.path.join(args.save_dir, model_name + "_model")
    paddle.onnx.export(
        model, onnx_model_path, input_spec=[input_spec], opset_version=11)
    print("Completed export onnx model.\n")

    # 4. run and check onnx
    onnx_model_path = onnx_model_path + ".onnx"
    onnx_out = check_and_run_onnx(onnx_model_path, input_data)
    assert onnx_out.shape == paddle_out.shape
    np.testing.assert_allclose(onnx_out, paddle_out, rtol=0, atol=1e-03)
    print("The paddle and onnx models have the same outputs.\n")

    # 5. run and check trt
    assert args.trt_version in (5, 7), "trt_version should be 5 or 7"
    if args.trt_version == 5:
        trt_out, latency = TRTPredictorV2().trt5_run(args, onnx_model_path,
                                                     input_data)
    elif args.trt_version == 7:
        trt_out, latency = TRTPredictorV2().trt7_run(args, onnx_model_path,
                                                     input_data)
    print("trt avg latency: {:.3f} ms".format(latency))

    assert trt_out.size == paddle_out.size
    trt_out = trt_out.reshape(paddle_out.shape)
    np.testing.assert_allclose(trt_out, paddle_out, rtol=0, atol=1e-03)
    print("The paddle and trt models have the same outputs.\n")

    return latency

    Export the ONNX model from PaddlePaddle, infer it by TRT.
    It checks the accuracy and tests the infer time.

    Args:
        args (dict): The input args.
        model (nn.Layer, optional): The paddle model to be exported and tested.
            If model is None, it creates a model with config file in args.
    
deploy/python/infer_onnx_trt.py